mphttpx 1.2.0-beta.1 → 1.2.0-beta.2

package/dist/cjs/fetchP.js

@@ -0,0 +1,115 @@
+'use strict';
+
+var XMLHttpRequestP = require('./XMLHttpRequestP.js');
+var HeadersP = require('./HeadersP.js');
+var BodyImpl = require('./BodyImpl.js');
+var RequestP = require('./RequestP.js');
+var ResponseP = require('./ResponseP.js');
+var isPolyfill = require('./isPolyfill.js');
+require('./BlobP.js');
+require('./TextEncoderP.js');
+require('./TextDecoderP.js');
+require('./convertor.js');
+require('./FormDataP.js');
+require('./FileP.js');
+require('./EventTargetP.js');
+require('./EventP.js');
+require('./ProgressEventP.js');
+require('./platform.js');
+require('./AbortControllerP.js');
+require('./AbortSignalP.js');
+
+const mp = { XMLHttpRequest: XMLHttpRequestP.XMLHttpRequest };
+const setXMLHttpRequest = (XHR) => { mp.XMLHttpRequest = XHR; };
+function fetchP(...args) {
+    if (new.target === fetchP) {
+        throw new TypeError("fetch is not a constructor");
+    }
+    const [input, init] = args;
+    isPolyfill.checkArgsLength(args, 1, "Window", "fetch");
+    return new Promise((resolve, reject) => {
+        const request = new RequestP.RequestP(input, init);
+        const signal = request[RequestP.requestState].signal;
+        if (signal && signal.aborted) {
+            return reject(signal.reason);
+        }
+        let xhr = new mp.XMLHttpRequest();
+        xhr.onload = function () {
+            let options = {
+                headers: HeadersP.parseHeaders(xhr.getAllResponseHeaders() || ""),
+                status: xhr.status,
+                statusText: xhr.statusText,
+            };
+            // This check if specifically for when a user fetches a file locally from the file system
+            // Only if the status is out of a normal range
+            if (request.url.indexOf("file://") === 0 && (xhr.status < 200 || xhr.status > 599)) {
+                options.status = 200;
+            }
+            setTimeout(() => {
+                let response = new ResponseP.ResponseP("response" in xhr ? xhr.response : xhr.responseText, options);
+                response[ResponseP.responseState].url = "responseURL" in xhr ? xhr.responseURL : (options.headers.get("X-Request-URL") || "");
+                resolve(response);
+            });
+        };
+        xhr.onerror = function () {
+            setTimeout(function () {
+                reject(new TypeError("Failed to fetch"));
+            });
+        };
+        xhr.ontimeout = function () {
+            setTimeout(function () {
+                reject(new isPolyfill.MPException("request:fail timeout", "TimeoutError"));
+            });
+        };
+        xhr.onabort = function () {
+            setTimeout(function () {
+                reject(new isPolyfill.MPException("request:fail abort", "AbortError"));
+            });
+        };
+        xhr.open(request.method, request.url, true);
+        if (request.credentials === "include") {
+            xhr.withCredentials = true;
+        }
+        else if (request.credentials === "omit") {
+            xhr.withCredentials = false;
+        }
+        if ("responseType" in xhr) {
+            xhr.responseType = "arraybuffer";
+        }
+        if (init && typeof init === "object" && typeof init.headers === "object" && !(isPolyfill.isObjectType("Headers", init.headers) || isPolyfill.isPolyfillType("Headers", init.headers))) {
+            let headers = init.headers;
+            let names = [];
+            Object.getOwnPropertyNames(headers).forEach(name => {
+                names.push(HeadersP.normalizeName(name));
+                xhr.setRequestHeader(name, HeadersP.normalizeValue(headers[name]));
+            });
+            request.headers.forEach((value, name) => {
+                if (names.indexOf(name) === -1) {
+                    xhr.setRequestHeader(name, value);
+                }
+            });
+        }
+        else {
+            request.headers.forEach((value, name) => {
+                xhr.setRequestHeader(name, value);
+            });
+        }
+        if (signal) {
+            const abortXHR = () => { xhr.abort(); };
+            signal.addEventListener("abort", abortXHR);
+            xhr.onreadystatechange = function () {
+                // success or failure
+                if (xhr.readyState === 4 /* DONE */) {
+                    signal.removeEventListener("abort", abortXHR);
+                }
+            };
+        }
+        let body = BodyImpl.Body_toPayload(request);
+        xhr.send(body !== "" ? body : void 0);
+    });
+}
+const fetchE = isPolyfill.g["fetch"] || fetchP;
+
+exports.fetch = fetchE;
+exports.fetchP = fetchP;
+exports.setXMLHttpRequest = setXMLHttpRequest;

package/dist/cjs/index.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var TextEncoderP = require('./TextEncoderP.js');
+var TextDecoderP = require('./TextDecoderP.js');
+var BlobP = require('./BlobP.js');
+var FileP = require('./FileP.js');
+var FileReaderP = require('./FileReaderP.js');
+var URLSearchParamsP = require('./URLSearchParamsP.js');
+var FormDataP = require('./FormDataP.js');
+var fetchP = require('./fetchP.js');
+var HeadersP = require('./HeadersP.js');
+var RequestP = require('./RequestP.js');
+var ResponseP = require('./ResponseP.js');
+var AbortControllerP = require('./AbortControllerP.js');
+var AbortSignalP = require('./AbortSignalP.js');
+var EventTargetP = require('./EventTargetP.js');
+var EventP = require('./EventP.js');
+var CustomEventP = require('./CustomEventP.js');
+var XMLHttpRequestP = require('./XMLHttpRequestP.js');
+var WebSocketP = require('./WebSocketP.js');
+var isPolyfill = require('./isPolyfill.js');
+var platform = require('./platform.js');
+var convertor = require('./convertor.js');
+var BodyImpl = require('./BodyImpl.js');
+var ProgressEventP = require('./ProgressEventP.js');
+var CloseEventP = require('./CloseEventP.js');
+var MessageEventP = require('./MessageEventP.js');
+
+
+
+exports.TextEncoder = TextEncoderP.TextEncoder;
+exports.TextEncoderP = TextEncoderP.TextEncoderP;
+exports.TextDecoder = TextDecoderP.TextDecoder;
+exports.TextDecoderP = TextDecoderP.TextDecoderP;
+exports.Blob = BlobP.Blob;
+exports.BlobP = BlobP.BlobP;
+exports.File = FileP.File;
+exports.FileP = FileP.FileP;
+exports.FileReader = FileReaderP.FileReader;
+exports.FileReaderP = FileReaderP.FileReaderP;
+exports.URLSearchParams = URLSearchParamsP.URLSearchParams;
+exports.URLSearchParamsP = URLSearchParamsP.URLSearchParamsP;
+exports.FormData = FormDataP.FormData;
+exports.FormDataP = FormDataP.FormDataP;
+exports.fetch = fetchP.fetch;
+exports.fetchP = fetchP.fetchP;
+exports.setXMLHttpRequest = fetchP.setXMLHttpRequest;
+exports.Headers = HeadersP.Headers;
+exports.HeadersP = HeadersP.HeadersP;
+exports.Request = RequestP.Request;
+exports.RequestP = RequestP.RequestP;
+exports.Response = ResponseP.Response;
+exports.ResponseP = ResponseP.ResponseP;
+exports.AbortController = AbortControllerP.AbortController;
+exports.AbortControllerP = AbortControllerP.AbortControllerP;
+exports.AbortSignal = AbortSignalP.AbortSignal;
+exports.AbortSignalP = AbortSignalP.AbortSignalP;
+exports.EventTarget = EventTargetP.EventTarget;
+exports.EventTargetP = EventTargetP.EventTargetP;
+exports.Event = EventP.Event;
+exports.EventP = EventP.EventP;
+exports.CustomEvent = CustomEventP.CustomEvent;
+exports.CustomEventP = CustomEventP.CustomEventP;
+exports.XMLHttpRequest = XMLHttpRequestP.XMLHttpRequest;
+exports.XMLHttpRequestP = XMLHttpRequestP.XMLHttpRequestImpl;
+exports.setRequest = XMLHttpRequestP.setRequest;
+exports.WebSocket = WebSocketP.WebSocket;
+exports.WebSocketP = WebSocketP.WebSocketImpl;
+exports.setConnectSocket = WebSocketP.setConnectSocket;
+exports.g = isPolyfill.g;
+exports.mp = platform.mp;
+exports.convert = convertor.convert;
+exports.convertBack = convertor.convertBack;
+exports.BodyImpl = BodyImpl.BodyImpl;
+exports.ProgressEvent = ProgressEventP.ProgressEvent;
+exports.ProgressEventP = ProgressEventP.ProgressEventP;
+exports.CloseEvent = CloseEventP.CloseEvent;
+exports.CloseEventP = CloseEventP.CloseEventP;
+exports.MessageEvent = MessageEventP.MessageEvent;
+exports.MessageEventP = MessageEventP.MessageEventP;

package/dist/cjs/isPolyfill.js

@@ -0,0 +1,56 @@
+'use strict';
+
+/* eslint-disable no-prototype-builtins */
+/** @internal */ const g = (typeof globalThis !== "undefined" && globalThis) ||
+    (typeof self !== "undefined" && self) ||
+    // @ts-ignore eslint-disable-next-line no-undef
+    (typeof global !== "undefined" && global) ||
+    {};
+/** @internal */
+const polyfill = "MPHTTPX";
+/** @internal */
+function checkArgsLength(args, required, className, funcName) {
+    if (args.length < required) {
+        throw new TypeError(`Failed to ${funcName ? ("execute '" + funcName + "' on") : "construct"} '${className}': ${required} argument${required > 1 ? "s" : ""} required, but only ${args.length} present.`);
+    }
+}
+/** @internal */
+class MPException extends Error {
+    constructor(message, name) {
+        super(message);
+        this.name = "Error";
+        if (name) {
+            this.name = name;
+        }
+    }
+}
+/** @internal */
+function isObjectType(name, value) {
+    return Object.prototype.toString.call(value) === `[object ${name}]`;
+}
+/** @internal */
+function isPolyfillType(name, value, strict = false) {
+    return !!value
+        && typeof value === "object"
+        && "isPolyfill" in value
+        && !!value.isPolyfill
+        && typeof value.isPolyfill === "object"
+        && "symbol" in value.isPolyfill
+        && value.isPolyfill.symbol === polyfill
+        && "hierarchy" in value.isPolyfill
+        && Array.isArray(value.isPolyfill.hierarchy)
+        && ((index) => strict ? index === 0 : index > -1)(value.isPolyfill.hierarchy.indexOf(name));
+}
+/** @internal */
+function isArrayBuffer(value) {
+    // Mini Program
+    return isObjectType("ArrayBuffer", value) || (!!value && typeof value === "object" && ArrayBuffer.prototype.isPrototypeOf(value));
+}
+
+exports.MPException = MPException;
+exports.checkArgsLength = checkArgsLength;
+exports.g = g;
+exports.isArrayBuffer = isArrayBuffer;
+exports.isObjectType = isObjectType;
+exports.isPolyfillType = isPolyfillType;
+exports.polyfill = polyfill;

package/dist/cjs/platform.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var isPolyfill = require('./isPolyfill.js');
+
+// @ts-nocheck
+function getPlatform() {
+    let u = "undefined", r = "request", f = "function";
+    let mp;
+    mp =
+        (typeof wx !== u && typeof (wx === null || wx === void 0 ? void 0 : wx[r]) === f && wx) || // 微信
+            (typeof my !== u && typeof (my === null || my === void 0 ? void 0 : my[r]) === f && my) || // 支付宝
+            (typeof qq !== u && typeof (qq === null || qq === void 0 ? void 0 : qq[r]) === f && qq) || // QQ
+            (typeof jd !== u && typeof (jd === null || jd === void 0 ? void 0 : jd[r]) === f && jd) || // 京东
+            (typeof swan !== u && typeof (swan === null || swan === void 0 ? void 0 : swan[r]) === f && swan) || // 百度
+            (typeof tt !== u && typeof (tt === null || tt === void 0 ? void 0 : tt[r]) === f && tt) || // 抖音 | 飞书
+            (typeof ks !== u && typeof (ks === null || ks === void 0 ? void 0 : ks[r]) === f && ks) || // 快手
+            (typeof qh !== u && typeof (qh === null || qh === void 0 ? void 0 : qh[r]) === f && qh) || // 360
+            (typeof xhs !== u && typeof (xhs === null || xhs === void 0 ? void 0 : xhs[r]) === f && xhs) || // 小红书
+            undefined;
+    if (typeof isPolyfill.g["XMLHttpRequest"] === f) {
+        return;
+    }
+    if (mp === undefined)
+        mp =
+            (typeof uni !== u && typeof (uni === null || uni === void 0 ? void 0 : uni[r]) === f && uni) || // UniApp
+                (typeof Taro !== u && typeof (Taro === null || Taro === void 0 ? void 0 : Taro[r]) === f && Taro) || // Taro
+                undefined;
+    return mp;
+}
+/** @internal */
+const mp = getPlatform();
+
+exports.mp = mp;

package/dist/esm/AbortControllerP.js

@@ -0,0 +1,28 @@
+import { g, polyfill } from './isPolyfill.js';
+import { AbortSignal_abort, createAbortSignal } from './AbortSignalP.js';
+import './EventP.js';
+import './EventTargetP.js';
+
+/** @internal */
+const state = Symbol( /* "AbortControllerState" */);
+class AbortControllerP {
+    constructor() {
+        this[state] = new AbortControllerState();
+    }
+    get signal() { return this[state].signal; }
+    abort(reason) {
+        AbortSignal_abort(this[state].signal, reason);
+    }
+    /** @internal */ toString() { return "[object AbortController]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "AbortController"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortController"] }; }
+}
+/** @internal */
+class AbortControllerState {
+    constructor() {
+        this.signal = createAbortSignal();
+    }
+}
+const AbortControllerE = g["AbortController"] || AbortControllerP;
+
+export { AbortControllerE as AbortController, AbortControllerP };

package/dist/esm/AbortSignalP.js

@@ -0,0 +1,121 @@
+import { g, checkArgsLength, isPolyfillType, MPException, polyfill } from './isPolyfill.js';
+import { createInnerEvent } from './EventP.js';
+import { EventTargetP, attachFn, EventTargetState, eventTargetState as state$1, EventTarget_fire, executeFn } from './EventTargetP.js';
+
+var _a;
+/** @internal */
+const state = Symbol( /* "AbortSignalState" */);
+class AbortSignalP extends EventTargetP {
+    static abort(reason) {
+        let signal = createAbortSignal();
+        AbortSignal_abort(signal, reason, false);
+        return signal;
+    }
+    static any(...args) {
+        const [signals] = args;
+        checkArgsLength(args, 1, "AbortSignal", "any");
+        if (!(Array.isArray(signals) || (signals && typeof signals === "object" && Symbol.iterator in signals))) {
+            throw new TypeError("Failed to execute 'any' on 'AbortSignal': The provided value cannot be converted to a sequence.");
+        }
+        let _signals = Array.isArray(signals) ? signals : Array.from(signals);
+        _signals.forEach(sig => {
+            if (!isPolyfillType("EventTarget", sig)) {
+                throw new TypeError("Failed to execute 'any' on 'AbortSignal': Failed to convert value to 'AbortSignal'.");
+            }
+        });
+        let signal = createAbortSignal();
+        let abortedSignal = _signals.find(x => x.aborted);
+        if (abortedSignal) {
+            AbortSignal_abort(signal, abortedSignal.reason, false);
+        }
+        else {
+            function abortFn(ev) {
+                for (let i = 0; i < _signals.length; ++i) {
+                    let sig = _signals[i];
+                    sig.removeEventListener("abort", abortFn);
+                }
+                AbortSignal_abort(signal, this.reason, true, ev.isTrusted);
+            }
+            for (let i = 0; i < _signals.length; ++i) {
+                let sig = _signals[i];
+                sig.addEventListener("abort", abortFn);
+            }
+        }
+        return signal;
+    }
+    static timeout(...args) {
+        const [milliseconds] = args;
+        checkArgsLength(args, 1, "AbortSignal", "timeout");
+        if (!(milliseconds >= 0)) {
+            throw new TypeError("Failed to execute 'timeout' on 'AbortSignal': Value is outside the 'unsigned long long' value range.");
+        }
+        let signal = createAbortSignal();
+        setTimeout(() => {
+            AbortSignal_abort(signal, new MPException("signal timed out", "TimeoutError"));
+        }, milliseconds);
+        return signal;
+    }
+    /** @internal */
+    constructor() {
+        if (new.target === AbortSignalP) {
+            throw new TypeError("Failed to construct 'AbortSignal': Illegal constructor");
+        }
+        super();
+        this[state] = new AbortSignalState(this);
+    }
+    get aborted() { return this[state].aborted; }
+    get reason() { return this[state].reason; }
+    throwIfAborted() {
+        if (this.aborted) {
+            throw this.reason;
+        }
+    }
+    get onabort() { return this[state].onabort; }
+    set onabort(value) {
+        this[state].onabort = value;
+        attachFn(this, "abort", value, this[state][_handlers].onabort);
+    }
+    /** @internal */ toString() { return "[object AbortSignal]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "AbortSignal"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortSignal", "EventTarget"] }; }
+}
+/** @internal */
+const _handlers = Symbol();
+/** @internal */
+class AbortSignalState {
+    constructor(target) {
+        this.aborted = false;
+        this.reason = undefined;
+        this[_a] = getHandlers(this);
+        this.onabort = null;
+        this.target = target;
+    }
+}
+_a = _handlers;
+/** @internal */
+function AbortSignal_abort(signal, reason, notify = true, isTrusted = true) {
+    const s = signal[state];
+    if (!s.aborted) {
+        s.aborted = true;
+        s.reason = reason !== null && reason !== void 0 ? reason : (new MPException("signal is aborted without reason", "AbortError"));
+        if (notify) {
+            let evt = createInnerEvent(signal, "abort", undefined, isTrusted);
+            EventTarget_fire(signal, evt);
+        }
+    }
+}
+function getHandlers(s) {
+    return {
+        onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
+    };
+}
+/** @internal */
+function createAbortSignal() {
+    let signal = Object.create(AbortSignalP.prototype);
+    signal[state$1] = new EventTargetState(signal);
+    signal[state] = new AbortSignalState(signal);
+    return signal;
+}
+const AbortSignalE = g["AbortSignal"] || AbortSignalP;
+
+export { AbortSignalE as AbortSignal, AbortSignalP, AbortSignal_abort, createAbortSignal };

package/dist/esm/BlobP.js

@@ -0,0 +1,124 @@
+import { TextEncoderP } from './TextEncoderP.js';
+import { TextDecoderP } from './TextDecoderP.js';
+import { g, isPolyfillType, isArrayBuffer, polyfill } from './isPolyfill.js';
+
+/** @internal */
+const state = Symbol( /* "BlobState" */);
+class BlobP {
+    constructor(blobParts = [], options) {
+        if (!(Array.isArray(blobParts) || (blobParts && typeof blobParts === "object" && Symbol.iterator in blobParts))) {
+            throw new TypeError("Failed to construct 'Blob/File': The provided value cannot be converted to a sequence.");
+        }
+        let _blobParts = Array.isArray(blobParts) ? blobParts : Array.from(blobParts);
+        let chunks = [];
+        for (let i = 0; i < _blobParts.length; ++i) {
+            let chunk = _blobParts[i];
+            if (isPolyfillType("Blob", chunk)) {
+                chunks.push(chunk[state][_buffer]);
+            }
+            else if (isArrayBuffer(chunk) || ArrayBuffer.isView(chunk)) {
+                chunks.push(BufferSource_toUint8Array(chunk));
+            }
+            else {
+                chunks.push(encode("" + chunk));
+            }
+        }
+        this[state] = new BlobState(concat(chunks));
+        const s = this[state];
+        s.size = s[_buffer].length;
+        let rawType = "" + ((options === null || options === void 0 ? void 0 : options.type) || "");
+        s.type = /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
+    }
+    get size() { return this[state].size; }
+    get type() { return this[state].type; }
+    arrayBuffer() {
+        return Promise.resolve(clone(this[state][_buffer].buffer).buffer);
+    }
+    bytes() {
+        return Promise.resolve(clone(this[state][_buffer].buffer));
+    }
+    slice(start, end, contentType) {
+        let sliced = this[state][_buffer].slice(start !== null && start !== void 0 ? start : 0, end !== null && end !== void 0 ? end : this[state][_buffer].length); // × WeChat 2.5.0
+        return new BlobP([sliced], { type: "" + (contentType !== null && contentType !== void 0 ? contentType : "") });
+    }
+    stream() {
+        throw new TypeError("Failed to execute 'stream' on 'Blob': method not implemented.");
+    }
+    text() {
+        return Promise.resolve(decode(this[state][_buffer]));
+    }
+    /** @internal */ toString() { return "[object Blob]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Blob"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Blob"] }; }
+}
+/** @internal */
+const _buffer = Symbol();
+/** @internal */
+class BlobState {
+    constructor(buffer) {
+        this.size = 0;
+        this.type = "";
+        this[_buffer] = buffer;
+    }
+}
+/** @internal */
+function Blob_toUint8Array(blob) {
+    return blob[state][_buffer];
+}
+function BufferSource_toUint8Array(buf) {
+    return isArrayBuffer(buf)
+        ? new Uint8Array(buf)
+        : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function clone(buf) {
+    let sourceArray = BufferSource_toUint8Array(buf);
+    let cloneArray = new Uint8Array(new ArrayBuffer(sourceArray.byteLength));
+    cloneArray.set(sourceArray);
+    return cloneArray;
+}
+function concat(chunks) {
+    let totalByteLength = chunks.reduce((acc, cur) => acc + cur.byteLength, 0);
+    let result = new Uint8Array(totalByteLength);
+    chunks.reduce((offset, chunk) => {
+        result.set(chunk, offset);
+        return offset + chunk.byteLength;
+    }, 0);
+    return result;
+}
+/** @internal */
+function encode(str) {
+    let encoder = new TextEncoderP();
+    return encoder.encode(str);
+}
+/** @internal */
+function decode(buf) {
+    let decoder = new TextDecoderP();
+    return decoder.decode(buf);
+}
+/** @internal */
+function Uint8Array_toBase64(input) {
+    let byteToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+    let output = [];
+    for (var i = 0; i < input.length; i += 3) {
+        let byte1 = input[i];
+        let haveByte2 = i + 1 < input.length;
+        let byte2 = haveByte2 ? input[i + 1] : 0;
+        let haveByte3 = i + 2 < input.length;
+        let byte3 = haveByte3 ? input[i + 2] : 0;
+        let outByte1 = byte1 >> 2;
+        let outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
+        let outByte3 = ((byte2 & 0x0F) << 2) | (byte3 >> 6);
+        let outByte4 = byte3 & 0x3F;
+        if (!haveByte3) {
+            outByte4 = 64;
+            if (!haveByte2) {
+                outByte3 = 64;
+            }
+        }
+        output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
+    }
+    return output.join("");
+}
+const BlobE = g["Blob"] || BlobP;
+
+export { BlobE as Blob, BlobP, Blob_toUint8Array, Uint8Array_toBase64, decode, encode };