Advertisement
Guest User

Untitled

a guest
Jun 14th, 2018
102
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 26.25 KB | None | 0 0
  1. function xhrmook(iframeWindow, iframeDocument ,RequestFunc,context) {
  2. var AFTER,
  3. BEFORE,
  4. COMMON_EVENTS,
  5. EventEmitter,
  6. FETCH,
  7. FIRE,
  8. FormData,
  9. NativeFetch,
  10. NativeFormData,
  11. NativeXMLHttp,
  12. OFF,
  13. ON,
  14. READY_STATE,
  15. UPLOAD_EVENTS,
  16. WINDOW,
  17. XHookFetchRequest,
  18. XHookFormData,
  19. XHookHttpRequest,
  20. XMLHTTP,
  21. convertHeaders,
  22. depricatedProp,
  23. document,
  24. fakeEvent,
  25. mergeObjects,
  26. msie,
  27. nullify,
  28. proxyEvents,
  29. slice,
  30. useragent,
  31. xhook,
  32. _base,
  33. __indexOf =
  34. [].indexOf ||
  35. function(item) {
  36. for (var i = 0, l = this.length; i < l; i++) {
  37. if (i in this && this[i] === item) return i;
  38. }
  39. return -1;
  40. };
  41.  
  42. WINDOW = iframeWindow;
  43.  
  44. document = iframeDocument;
  45.  
  46. BEFORE = "before";
  47.  
  48. AFTER = "after";
  49.  
  50. READY_STATE = "readyState";
  51.  
  52. ON = "addEventListener";
  53.  
  54. OFF = "removeEventListener";
  55.  
  56. FIRE = "dispatchEvent";
  57.  
  58. XMLHTTP = "XMLHttpRequest";
  59.  
  60. FETCH = "fetch";
  61.  
  62. FormData = "FormData";
  63.  
  64. UPLOAD_EVENTS = ["load", "loadend", "loadstart"];
  65.  
  66. COMMON_EVENTS = ["progress", "abort", "error", "timeout"];
  67.  
  68. useragent =
  69. typeof navigator !== "undefined" && navigator["useragent"]
  70. ? navigator.userAgent
  71. : "";
  72.  
  73. msie = parseInt((/msie (\d+)/.exec(useragent.toLowerCase()) || [])[1]);
  74.  
  75. if (isNaN(msie)) {
  76. msie = parseInt(
  77. (/trident\/.*; rv:(\d+)/.exec(useragent.toLowerCase()) || [])[1]
  78. );
  79. }
  80.  
  81. (_base = Array.prototype).indexOf ||
  82. (_base.indexOf = function(item) {
  83. var i, x, _i, _len;
  84. for (i = _i = 0, _len = this.length; _i < _len; i = ++_i) {
  85. x = this[i];
  86. if (x === item) {
  87. return i;
  88. }
  89. }
  90. return -1;
  91. });
  92.  
  93. slice = function(o, n) {
  94. return Array.prototype.slice.call(o, n);
  95. };
  96.  
  97. depricatedProp = function(p) {
  98. return p === "returnValue" || p === "totalSize" || p === "position";
  99. };
  100.  
  101. mergeObjects = function(src, dst) {
  102. var k, v;
  103. for (k in src) {
  104. v = src[k];
  105. if (depricatedProp(k)) {
  106. continue;
  107. }
  108. try {
  109. dst[k] = src[k];
  110. } catch (_error) {}
  111. }
  112. return dst;
  113. };
  114.  
  115. nullify = function(res) {
  116. if (res === void 0) {
  117. return null;
  118. }
  119. return res;
  120. };
  121.  
  122. proxyEvents = function(events, src, dst) {
  123. var event, p, _i, _len;
  124. p = function(event) {
  125. return function(e) {
  126. var clone, k, val;
  127. clone = {};
  128. for (k in e) {
  129. if (depricatedProp(k)) {
  130. continue;
  131. }
  132. val = e[k];
  133. clone[k] = val === src ? dst : val;
  134. }
  135. return dst[FIRE](event, clone);
  136. };
  137. };
  138. for (_i = 0, _len = events.length; _i < _len; _i++) {
  139. event = events[_i];
  140. if (dst._has(event)) {
  141. src["on" + event] = p(event);
  142. }
  143. }
  144. };
  145.  
  146. fakeEvent = function(type) {
  147. var msieEventObject;
  148. if (document && document.createEventObject != null) {
  149. msieEventObject = document.createEventObject();
  150. msieEventObject.type = type;
  151. return msieEventObject;
  152. } else {
  153. try {
  154. return new Event(type);
  155. } catch (_error) {
  156. return {
  157. type: type
  158. };
  159. }
  160. }
  161. };
  162.  
  163. EventEmitter = function(nodeStyle) {
  164. var emitter, events, listeners;
  165. events = {};
  166. listeners = function(event) {
  167. return events[event] || [];
  168. };
  169. emitter = {};
  170. emitter[ON] = function(event, callback, i) {
  171. events[event] = listeners(event);
  172. if (events[event].indexOf(callback) >= 0) {
  173. return;
  174. }
  175. i = i === undefined ? events[event].length : i;
  176. events[event].splice(i, 0, callback);
  177. };
  178. emitter[OFF] = function(event, callback) {
  179. var i;
  180. if (event === undefined) {
  181. events = {};
  182. return;
  183. }
  184. if (callback === undefined) {
  185. events[event] = [];
  186. }
  187. i = listeners(event).indexOf(callback);
  188. if (i === -1) {
  189. return;
  190. }
  191. listeners(event).splice(i, 1);
  192. };
  193. emitter[FIRE] = function() {
  194. var args, event, i, legacylistener, listener, _i, _len, _ref;
  195. args = slice(arguments);
  196. event = args.shift();
  197. if (!nodeStyle) {
  198. args[0] = mergeObjects(args[0], fakeEvent(event));
  199. }
  200. legacylistener = emitter["on" + event];
  201. if (legacylistener) {
  202. legacylistener.apply(emitter, args);
  203. }
  204. _ref = listeners(event).concat(listeners("*"));
  205. for (i = _i = 0, _len = _ref.length; _i < _len; i = ++_i) {
  206. listener = _ref[i];
  207. listener.apply(emitter, args);
  208. }
  209. };
  210. emitter._has = function(event) {
  211. return !!(events[event] || emitter["on" + event]);
  212. };
  213. if (nodeStyle) {
  214. emitter.listeners = function(event) {
  215. return slice(listeners(event));
  216. };
  217. emitter.on = emitter[ON];
  218. emitter.off = emitter[OFF];
  219. emitter.fire = emitter[FIRE];
  220. emitter.once = function(e, fn) {
  221. var fire;
  222. fire = function() {
  223. emitter.off(e, fire);
  224. return fn.apply(null, arguments);
  225. };
  226. return emitter.on(e, fire);
  227. };
  228. emitter.destroy = function() {
  229. return (events = {});
  230. };
  231. }
  232. return emitter;
  233. };
  234.  
  235. xhook = EventEmitter(true);
  236.  
  237. xhook.EventEmitter = EventEmitter;
  238.  
  239. xhook[BEFORE] = function(handler, i) {
  240. if (handler.length < 1 || handler.length > 2) {
  241. throw "invalid hook";
  242. }
  243. return xhook[ON](BEFORE, handler, i);
  244. };
  245.  
  246. xhook[AFTER] = function(handler, i) {
  247. if (handler.length < 2 || handler.length > 3) {
  248. throw "invalid hook";
  249. }
  250. return xhook[ON](AFTER, handler, i);
  251. };
  252.  
  253. xhook.enable = function() {
  254. WINDOW[XMLHTTP] = XHookHttpRequest;
  255. if (typeof XHookFetchRequest === "function") {
  256. WINDOW[FETCH] = XHookFetchRequest;
  257. }
  258. if (NativeFormData) {
  259. WINDOW[FormData] = XHookFormData;
  260. }
  261. };
  262.  
  263. xhook.disable = function() {
  264. WINDOW[XMLHTTP] = xhook[XMLHTTP];
  265. WINDOW[FETCH] = xhook[FETCH];
  266. if (NativeFormData) {
  267. WINDOW[FormData] = NativeFormData;
  268. }
  269. };
  270.  
  271. convertHeaders = xhook.headers = function(h, dest) {
  272. var header, headers, k, name, v, value, _i, _len, _ref;
  273. if (dest == null) {
  274. dest = {};
  275. }
  276. switch (typeof h) {
  277. case "object":
  278. headers = [];
  279. for (k in h) {
  280. v = h[k];
  281. name = k.toLowerCase();
  282. headers.push("" + name + ":\t" + v);
  283. }
  284. return headers.join("\n") + "\n";
  285. case "string":
  286. headers = h.split("\n");
  287. for (_i = 0, _len = headers.length; _i < _len; _i++) {
  288. header = headers[_i];
  289. if (/([^:]+):\s*(.+)/.test(header)) {
  290. name = (_ref = RegExp.$1) != null ? _ref.toLowerCase() : void 0;
  291. value = RegExp.$2;
  292. if (dest[name] == null) {
  293. dest[name] = value;
  294. }
  295. }
  296. }
  297. return dest;
  298. }
  299. };
  300.  
  301. NativeFormData = WINDOW[FormData];
  302.  
  303. XHookFormData = function(form) {
  304. var entries;
  305. this.fd = form ? new NativeFormData(form) : new NativeFormData();
  306. this.form = form;
  307. entries = [];
  308. Object.defineProperty(this, "entries", {
  309. get: function() {
  310. var fentries;
  311. fentries = !form
  312. ? []
  313. : slice(form.querySelectorAll("input,select"))
  314. .filter(function(e) {
  315. var _ref;
  316. return (
  317. ((_ref = e.type) !== "checkbox" && _ref !== "radio") ||
  318. e.checked
  319. );
  320. })
  321. .map(function(e) {
  322. return [e.name, e.type === "file" ? e.files : e.value];
  323. });
  324. return fentries.concat(entries);
  325. }
  326. });
  327. this.append = (function(_this) {
  328. return function() {
  329. var args;
  330. args = slice(arguments);
  331. entries.push(args);
  332. return _this.fd.append.apply(_this.fd, args);
  333. };
  334. })(this);
  335. };
  336.  
  337. if (NativeFormData) {
  338. xhook[FormData] = NativeFormData;
  339. WINDOW[FormData] = XHookFormData;
  340. }
  341.  
  342. NativeXMLHttp = WINDOW[XMLHTTP];
  343.  
  344. xhook[XMLHTTP] = NativeXMLHttp;
  345.  
  346. XHookHttpRequest = WINDOW[XMLHTTP] = function() {
  347. var ABORTED,
  348. currentState,
  349. emitFinal,
  350. emitReadyState,
  351. event,
  352. facade,
  353. hasError,
  354. hasErrorHandler,
  355. readBody,
  356. readHead,
  357. request,
  358. response,
  359. setReadyState,
  360. status,
  361. transiting,
  362. writeBody,
  363. writeHead,
  364. xhr,
  365. _i,
  366. _len,
  367. _ref;
  368. ABORTED = -1;
  369. xhr = new xhook[XMLHTTP]();
  370. request = {};
  371. status = null;
  372. hasError = void 0;
  373. transiting = void 0;
  374. response = void 0;
  375. readHead = function() {
  376. var key, name, val, _ref;
  377. response.status = status || xhr.status;
  378. if (!(status === ABORTED && msie < 10)) {
  379. response.statusText = xhr.statusText;
  380. }
  381. if (status !== ABORTED) {
  382. _ref = convertHeaders(xhr.getAllResponseHeaders());
  383. for (key in _ref) {
  384. val = _ref[key];
  385. if (!response.headers[key]) {
  386. name = key.toLowerCase();
  387. response.headers[name] = val;
  388. }
  389. }
  390. }
  391. };
  392. readBody = function() {
  393. if (!xhr.responseType || xhr.responseType === "text") {
  394. response.text = xhr.responseText;
  395. response.data = xhr.responseText;
  396. response.xml = xhr.responseXML;
  397. } else if (xhr.responseType === "document") {
  398. response.xml = xhr.responseXML;
  399. response.data = xhr.responseXML;
  400. } else {
  401. response.data = xhr.response;
  402. }
  403. if ("responseURL" in xhr) {
  404. response.finalUrl = xhr.responseURL;
  405. }
  406. };
  407. writeHead = function() {
  408. facade.status = response.status;
  409. facade.statusText = response.statusText;
  410. };
  411. writeBody = function() {
  412. if ("text" in response) {
  413. facade.responseText = response.text;
  414. }
  415. if ("xml" in response) {
  416. facade.responseXML = response.xml;
  417. }
  418. if ("data" in response) {
  419. facade.response = response.data;
  420. }
  421. if ("finalUrl" in response) {
  422. facade.responseURL = response.finalUrl;
  423. }
  424. };
  425. emitReadyState = function(n) {
  426. while (n > currentState && currentState < 4) {
  427. facade[READY_STATE] = ++currentState;
  428. if (currentState === 1) {
  429. facade[FIRE]("loadstart", {});
  430. }
  431. if (currentState === 2) {
  432. writeHead();
  433. }
  434. if (currentState === 4) {
  435. writeHead();
  436. writeBody();
  437. }
  438. facade[FIRE]("readystatechange", {});
  439. if (currentState === 4) {
  440. if (request.async === false) {
  441. emitFinal();
  442. } else {
  443. setTimeout(emitFinal, 0);
  444. }
  445. }
  446. }
  447. };
  448. emitFinal = function() {
  449. if (!hasError) {
  450. facade[FIRE]("load", {});
  451. }
  452. facade[FIRE]("loadend", {});
  453. if (hasError) {
  454. facade[READY_STATE] = 0;
  455. }
  456. };
  457. currentState = 0;
  458. setReadyState = function(n) {
  459. var hooks, process;
  460. if (n !== 4) {
  461. emitReadyState(n);
  462. return;
  463. }
  464. hooks = xhook.listeners(AFTER);
  465. process = function() {
  466. var hook;
  467. if (!hooks.length) {
  468. return emitReadyState(4);
  469. }
  470. hook = hooks.shift();
  471. if (hook.length === 2) {
  472. hook(request, response);
  473. return process();
  474. } else if (hook.length === 3 && request.async) {
  475. return hook(request, response, process);
  476. } else {
  477. return process();
  478. }
  479. };
  480. process();
  481. };
  482. facade = request.xhr = EventEmitter();
  483. xhr.onreadystatechange = function(event) {
  484. try {
  485. if (xhr[READY_STATE] === 2) {
  486. readHead();
  487. }
  488. } catch (_error) {}
  489. if (xhr[READY_STATE] === 4) {
  490. transiting = false;
  491. readHead();
  492. readBody();
  493. }
  494. setReadyState(xhr[READY_STATE]);
  495. };
  496. hasErrorHandler = function() {
  497. hasError = true;
  498. };
  499. facade[ON]("error", hasErrorHandler);
  500. facade[ON]("timeout", hasErrorHandler);
  501. facade[ON]("abort", hasErrorHandler);
  502. facade[ON]("progress", function() {
  503. if (currentState < 3) {
  504. setReadyState(3);
  505. } else {
  506. facade[FIRE]("readystatechange", {});
  507. }
  508. });
  509. if ("withCredentials" in xhr || xhook.addWithCredentials) {
  510. facade.withCredentials = false;
  511. }
  512. facade.status = 0;
  513. _ref = COMMON_EVENTS.concat(UPLOAD_EVENTS);
  514. for (_i = 0, _len = _ref.length; _i < _len; _i++) {
  515. event = _ref[_i];
  516. facade["on" + event] = null;
  517. }
  518. facade.open = function(method, url, async, user, pass) {
  519. currentState = 0;
  520. hasError = false;
  521. transiting = false;
  522. request.headers = {};
  523. request.headerNames = {};
  524. request.status = 0;
  525. response = {};
  526. response.headers = {};
  527. request.method = method;
  528. request.url = url;
  529. request.async = async !== false;
  530. request.user = user;
  531. request.pass = pass;
  532. setReadyState(1);
  533. };
  534. facade.send = function(body) {
  535. var hooks, k, modk, process, send, _j, _len1, _ref1;
  536. _ref1 = ["type", "timeout", "withCredentials"];
  537. for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
  538. k = _ref1[_j];
  539. modk = k === "type" ? "responseType" : k;
  540. if (modk in facade) {
  541. request[k] = facade[modk];
  542. }
  543. }
  544. request.body = body;
  545. send = function() {
  546. var header, value, _k, _len2, _ref2, _ref3;
  547. proxyEvents(COMMON_EVENTS, xhr, facade);
  548. if (facade.upload) {
  549. proxyEvents(
  550. COMMON_EVENTS.concat(UPLOAD_EVENTS),
  551. xhr.upload,
  552. facade.upload
  553. );
  554. }
  555. transiting = true;
  556. xhr.open(
  557. request.method,
  558. request.url,
  559. request.async,
  560. request.user,
  561. request.pass
  562. );
  563. _ref2 = ["type", "timeout", "withCredentials"];
  564. for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
  565. k = _ref2[_k];
  566. modk = k === "type" ? "responseType" : k;
  567. if (k in request) {
  568. xhr[modk] = request[k];
  569. }
  570. }
  571. _ref3 = request.headers;
  572. for (header in _ref3) {
  573. value = _ref3[header];
  574. if (header) {
  575. xhr.setRequestHeader(header, value);
  576. }
  577. }
  578. if (request.body instanceof XHookFormData) {
  579. request.body = request.body.fd;
  580. }
  581. xhr.send(request.body);
  582. };
  583. hooks = xhook.listeners(BEFORE);
  584. process = function() {
  585. var done, hook;
  586. if (!hooks.length) {
  587. return send();
  588. }
  589. done = function(userResponse) {
  590. if (
  591. typeof userResponse === "object" &&
  592. (typeof userResponse.status === "number" ||
  593. typeof response.status === "number")
  594. ) {
  595. mergeObjects(userResponse, response);
  596. if (__indexOf.call(userResponse, "data") < 0) {
  597. userResponse.data = userResponse.response || userResponse.text;
  598. }
  599. setReadyState(4);
  600. return;
  601. }
  602. process();
  603. };
  604. done.head = function(userResponse) {
  605. mergeObjects(userResponse, response);
  606. return setReadyState(2);
  607. };
  608. done.progress = function(userResponse) {
  609. mergeObjects(userResponse, response);
  610. return setReadyState(3);
  611. };
  612. hook = hooks.shift();
  613. if (hook.length === 1) {
  614. return done(hook(request));
  615. } else if (hook.length === 2 && request.async) {
  616. return hook(request, done);
  617. } else {
  618. return done();
  619. }
  620. };
  621. process();
  622. };
  623. facade.abort = function() {
  624. status = ABORTED;
  625. if (transiting) {
  626. xhr.abort();
  627. } else {
  628. facade[FIRE]("abort", {});
  629. }
  630. };
  631. facade.setRequestHeader = function(header, value) {
  632. var lName, name;
  633. lName = header != null ? header.toLowerCase() : void 0;
  634. name = request.headerNames[lName] = request.headerNames[lName] || header;
  635. if (request.headers[name]) {
  636. value = request.headers[name] + ", " + value;
  637. }
  638. request.headers[name] = value;
  639. };
  640. facade.getResponseHeader = function(header) {
  641. var name;
  642. name = header != null ? header.toLowerCase() : void 0;
  643. return nullify(response.headers[name]);
  644. };
  645. facade.getAllResponseHeaders = function() {
  646. return nullify(convertHeaders(response.headers));
  647. };
  648. if (xhr.overrideMimeType) {
  649. facade.overrideMimeType = function() {
  650. return xhr.overrideMimeType.apply(xhr, arguments);
  651. };
  652. }
  653. if (xhr.upload) {
  654. facade.upload = request.upload = EventEmitter();
  655. }
  656. facade.UNSENT = 0;
  657. facade.OPENED = 1;
  658. facade.HEADERS_RECEIVED = 2;
  659. facade.LOADING = 3;
  660. facade.DONE = 4;
  661. facade.response = "";
  662. facade.responseText = "";
  663. facade.responseXML = null;
  664. facade.readyState = 0;
  665. facade.statusText = "";
  666. return facade;
  667. };
  668.  
  669. if (typeof WINDOW[FETCH] === "function") {
  670. NativeFetch = WINDOW[FETCH];
  671. xhook[FETCH] = NativeFetch;
  672. XHookFetchRequest = WINDOW[FETCH] = function(url, options) {
  673. var afterHooks, beforeHooks, request;
  674. if (options == null) {
  675. options = {
  676. headers: {}
  677. };
  678. }
  679. options.url = url;
  680. request = null;
  681. beforeHooks = xhook.listeners(BEFORE);
  682. afterHooks = xhook.listeners(AFTER);
  683. return new Promise(function(resolve, reject) {
  684. var done, getRequest, processAfter, processBefore, send;
  685. getRequest = function() {
  686. if (options.body instanceof XHookFormData) {
  687. options.body = options.body.fd;
  688. }
  689. if (options.headers) {
  690. options.headers = new Headers(options.headers);
  691. }
  692. if (!request) {
  693. request = new Request(options.url, options);
  694. }
  695. return mergeObjects(options, request);
  696. };
  697. processAfter = function(response) {
  698. var hook;
  699. if (!afterHooks.length) {
  700. return resolve(response);
  701. }
  702. hook = afterHooks.shift();
  703. if (hook.length === 2) {
  704. hook(getRequest(), response);
  705. return processAfter(response);
  706. } else if (hook.length === 3) {
  707. return hook(getRequest(), response, processAfter);
  708. } else {
  709. return processAfter(response);
  710. }
  711. };
  712. done = function(userResponse) {
  713. var response;
  714. if (userResponse !== void 0) {
  715. response = new Response(
  716. userResponse.body || userResponse.text,
  717. userResponse
  718. );
  719. resolve(response);
  720. processAfter(response);
  721. return;
  722. }
  723. processBefore();
  724. };
  725. processBefore = function() {
  726. var hook;
  727. if (!beforeHooks.length) {
  728. send();
  729. return;
  730. }
  731. hook = beforeHooks.shift();
  732. if (hook.length === 1) {
  733. return done(hook(options));
  734. } else if (hook.length === 2) {
  735. return hook(getRequest(), done);
  736. }
  737. };
  738. send = function() {
  739. return NativeFetch(getRequest())
  740. .then(function(response) {
  741. return processAfter(response);
  742. })
  743. ["catch"](function(err) {
  744. processAfter(err);
  745. return reject(err);
  746. });
  747. };
  748. processBefore();
  749. });
  750. };
  751. }
  752.  
  753. XHookHttpRequest.UNSENT = 0;
  754.  
  755. XHookHttpRequest.OPENED = 1;
  756.  
  757. XHookHttpRequest.HEADERS_RECEIVED = 2;
  758.  
  759. XHookHttpRequest.LOADING = 3;
  760.  
  761. XHookHttpRequest.DONE = 4;
  762.  
  763. if (typeof define === "function" && define.amd) {
  764. define("xhook", [], function() {
  765. return xhook;
  766. });
  767. } else if (typeof module === "object" && module.exports) {
  768. module.exports = {
  769. xhook: xhook
  770. };
  771. } else if (WINDOW) {
  772. WINDOW.xhook = xhook;
  773. }
  774.  
  775. xhook.before(function (request, callback) {
  776.  
  777. if (!request.async) {
  778.  
  779. }
  780.  
  781. let url = Fixurl(request.url, context.origin);
  782.  
  783.  
  784. let has_content_type = false;
  785.  
  786. let headers = [];
  787.  
  788. Object.keys(request.headers).forEach(function (key) {
  789. headers.push(key + ": " + request.headers[key]);
  790. if (request.headers[key].toLowerCase() == "content-type") {
  791. has_content_type = false;
  792. }
  793. });
  794.  
  795. if (has_content_type == false) {
  796. if (typeof(request.body) === "string") {
  797. headers.push("Content-Type: application/text");
  798. }
  799. }
  800. RequestFunc(url,false).then(function (http) {
  801.  
  802. response = {
  803. status: http.status,
  804. statusText: http.statusText,
  805. text: http.responseText,
  806. headers: http.getAllResponseHeaders(),
  807. xml: http.responseXML,
  808. data: http.response,
  809. };
  810.  
  811. callback(response);
  812. }, function (exception) {
  813. callback();
  814. });
  815.  
  816. }, 0);
  817. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement