mphttpx 2.3.0 → 2.3.1

package/dist/cjs/fetch-api/RequestP.js

@@ -1,163 +0,0 @@
-'use strict';
-
-var HeadersP = require('./HeadersP.js');
-var BodyImpl = require('./BodyImpl.js');
-var Payload = require('../helpers/Payload.js');
-var isEventTarget = require('../helpers/isEventTarget.js');
-var normalizeMethod = require('../helpers/normalizeMethod.js');
-var AbortSignalP = require('../event-system/AbortSignalP.js');
-var utils = require('../utils.js');
-
-class RequestP extends BodyImpl.BodyImpl {
-    constructor(input, init) {
-        utils.checkArgsLength(arguments.length, 1, "Request");
-        super();
-        utils.setState(this, "__Request__", new RequestState());
-        const s = state(this);
-        let _init = init !== null && init !== void 0 ? init : {};
-        if (typeof _init !== "object") {
-            throw new TypeError("Failed to construct 'Request': The provided value is not of type 'RequestInit'.");
-        }
-        let body = _init.body;
-        let bodyInited = false;
-        if (isRequest(input)) {
-            if (input.bodyUsed) {
-                throw new TypeError("Failed to construct 'Request': Cannot construct a Request with a Request object that has already been used.");
-            }
-            s.cache = input.cache;
-            s.credentials = input.credentials;
-            if (_init.headers === undefined) {
-                state(this).headers = new HeadersP.HeadersP(input.headers);
-            }
-            s.method = input.method;
-            s.mode = input.mode;
-            s.signal = input.signal;
-            s.url = input.url;
-            if (!body) {
-                this.__Body__.payload = createPhonyPayload(input.arrayBuffer());
-                bodyInited = true;
-            }
-        }
-        else {
-            s.url = "" + input;
-        }
-        if (_init.cache) {
-            s.cache = _init.cache;
-        }
-        if (_init.credentials) {
-            s.credentials = _init.credentials;
-        }
-        if (_init.headers !== undefined) {
-            state(this).headers = new HeadersP.HeadersP(_init.headers);
-        }
-        if (_init.method) {
-            s.method = normalizeMethod.normalizeMethod(_init.method);
-        }
-        if (_init.mode) {
-            s.mode = _init.mode;
-        }
-        if (_init.signal !== null && _init.signal !== undefined) {
-            if (isEventTarget.isEventTarget(_init.signal))
-                s.signal = _init.signal;
-            else
-                throw new TypeError("Failed to construct 'Request': Failed to read the 'signal' property from 'RequestInit': Failed to convert value to 'AbortSignal'.");
-        }
-        if (this.method === "GET" || this.method === "HEAD") {
-            if (body !== null && body !== undefined) {
-                throw new TypeError("Failed to construct 'Request': Request with GET/HEAD method cannot have body.");
-            }
-        }
-        BodyImpl.Body_init(this, bodyInited ? null : body);
-        let payload = this.__Body__.payload;
-        if (!this.headers.has("Content-Type") && payload && payload.type) {
-            this.headers.set("Content-Type", payload.type);
-        }
-        if (this.method === "GET" || this.method === "HEAD") {
-            if (this.cache === "no-cache" || this.cache === "no-store") {
-                clearCache(this);
-            }
-        }
-    }
-    get cache() { return state(this).cache; }
-    get credentials() { return state(this).credentials; }
-    get destination() { return ""; }
-    get headers() {
-        if (!state(this).headers) {
-            state(this).headers = new HeadersP.HeadersP();
-        }
-        return state(this).headers;
-    }
-    get integrity() { return ""; }
-    get keepalive() { return false; }
-    get method() { return state(this).method; }
-    get mode() { return state(this).mode; }
-    get redirect() { return "follow"; }
-    get referrer() { return state(this).referrer; }
-    get referrerPolicy() { return ""; }
-    get signal() {
-        if (!state(this).signal) {
-            state(this).signal = AbortSignalP.createAbortSignal();
-        }
-        return state(this).signal;
-    }
-    get url() { return state(this).url; }
-    clone() {
-        if (!this.bodyUsed) {
-            let req = new RequestP(this);
-            this.__Body__.bodyUsed = false;
-            return req;
-        }
-        else {
-            throw new TypeError("Failed to execute 'clone' on 'Request': Request body is already used");
-        }
-    }
-    /** @internal */ toString() { return "[object Request]"; }
-    /** @internal */ get [utils.SymbolP.toStringTag]() { return "Request"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["Request", "Body"] }; }
-}
-/** @internal */
-class RequestState {
-    constructor() {
-        this.cache = "default";
-        this.credentials = "same-origin";
-        this.method = "GET";
-        this.mode = "cors";
-        this.referrer = "about:client";
-        this.url = "";
-    }
-}
-function state(target) {
-    return target.__Request__;
-}
-function isRequest(value) {
-    return utils.isPolyfillType("Request", value) || isExternalRequest(value);
-}
-function isExternalRequest(value) {
-    let expect = "[object Request]";
-    return (Object.prototype.toString.call(value) === expect || String(value) === expect)
-        && "arrayBuffer" in value
-        && typeof value.arrayBuffer === "function";
-}
-function createPhonyPayload(promise) {
-    let payload = Object.create(Payload.Payload.prototype);
-    payload.promise = promise;
-    payload.type = "";
-    return payload;
-}
-function clearCache(req) {
-    // Search for a '_' parameter in the query string
-    let reParamSearch = /([?&])_=[^&]*/;
-    if (reParamSearch.test(req.url)) {
-        // If it already exists then set the value with the current time
-        state(req).url = req.url.replace(reParamSearch, "$1_=" + (new Date()).getTime());
-    }
-    else {
-        // Otherwise add a new '_' parameter to the end with the current time
-        let reQueryString = /\?/;
-        state(req).url += (reQueryString.test(req.url) ? "&" : "?") + "_=" + (new Date()).getTime();
-    }
-}
-const RequestE = (typeof Request !== "undefined" && Request) || RequestP;
-
-exports.Request = RequestE;
-exports.RequestP = RequestP;

package/dist/cjs/fetch-api/ResponseP.js

@@ -1,93 +0,0 @@
-'use strict';
-
-var HeadersP = require('./HeadersP.js');
-var BodyImpl = require('./BodyImpl.js');
-var utils = require('../utils.js');
-
-class ResponseP extends BodyImpl.BodyImpl {
-    static json(data, init) {
-        utils.checkArgsLength(arguments.length, 1, "Response", "json");
-        let response = new ResponseP(typeof data === "string" ? data : JSON.stringify(data), init);
-        response.headers.set("Content-Type", "application/json");
-        return response;
-    }
-    static error() {
-        let response = new ResponseP(null, { status: 200, statusText: "" });
-        state(response).status = 0;
-        state(response).type = "error";
-        return response;
-    }
-    static redirect(url, status = 302) {
-        utils.checkArgsLength(arguments.length, 1, "Response", "redirect");
-        if ([301, 302, 303, 307, 308].indexOf(status) === -1) {
-            throw new RangeError("Failed to execute 'redirect' on 'Response': Invalid status code");
-        }
-        return new ResponseP(null, { status, headers: { location: "" + url } });
-    }
-    constructor(body, init) {
-        super();
-        utils.setState(this, "__Response__", new ResponseState());
-        const s = state(this);
-        let _init = init !== null && init !== void 0 ? init : {};
-        if (typeof _init !== "object") {
-            throw new TypeError("Failed to construct 'Response': The provided value is not of type 'ResponseInit'.");
-        }
-        if (_init.headers !== undefined) {
-            state(this).headers = new HeadersP.HeadersP(_init.headers);
-        }
-        let status = _init.status === undefined ? 200 : _init.status;
-        if (status < 200 || status > 599)
-            throw new RangeError(`Failed to construct 'Response': The status provided (${+status}) is outside the range [200, 599].`);
-        s.status = status;
-        s.statusText = _init.statusText === undefined ? "" : "" + _init.statusText;
-        BodyImpl.Body_init(this, body);
-        let payload = this.__Body__.payload;
-        if (!this.headers.has("Content-Type") && payload && payload.type) {
-            this.headers.set("Content-Type", payload.type);
-        }
-    }
-    get headers() {
-        if (!state(this).headers) {
-            state(this).headers = new HeadersP.HeadersP();
-        }
-        return state(this).headers;
-    }
-    get ok() { return this.status >= 200 && this.status < 300; }
-    get redirected() { return false; }
-    get status() { return state(this).status; }
-    get statusText() { return state(this).statusText; }
-    get type() { return state(this).type; }
-    get url() { return state(this).url; }
-    clone() {
-        if (this.bodyUsed) {
-            throw new TypeError("Failed to execute 'clone' on 'Response': Response body is already used");
-        }
-        let response = new ResponseP(null, {
-            headers: new HeadersP.HeadersP(this.headers),
-            status: this.status,
-            statusText: this.statusText,
-        });
-        state(response).url = this.url;
-        response.__Body__.payload = this.__Body__.payload;
-        return response;
-    }
-    /** @internal */ toString() { return "[object Response]"; }
-    /** @internal */ get [utils.SymbolP.toStringTag]() { return "Response"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["Response", "Body"] }; }
-}
-/** @internal */
-class ResponseState {
-    constructor() {
-        this.status = 200;
-        this.statusText = "";
-        this.type = "default";
-        this.url = "";
-    }
-}
-function state(target) {
-    return target.__Response__;
-}
-const ResponseE = (typeof Response !== "undefined" && Response) || ResponseP;
-
-exports.Response = ResponseE;
-exports.ResponseP = ResponseP;

package/dist/cjs/fetch-api/fetchP.js

@@ -1,125 +0,0 @@
-'use strict';
-
-var RequestP = require('./RequestP.js');
-var ResponseP = require('./ResponseP.js');
-var utils = require('../utils.js');
-var XMLHttpRequestImpl = require('../mini-program/XMLHttpRequestImpl.js');
-var HeadersP = require('./HeadersP.js');
-
-const mp = { XMLHttpRequest: XMLHttpRequestImpl.XMLHttpRequest };
-function setXMLHttpRequest(XHR) { mp.XMLHttpRequest = XHR; }
-function fetchP(input, init) {
-    utils.checkArgsLength(arguments.length, 1, "Window", "fetch");
-    if (new.target === fetchP) {
-        throw new TypeError("fetch is not a constructor");
-    }
-    return new Promise((resolve, reject) => {
-        const request = new RequestP.RequestP(input, init);
-        const signal = request.__Request__.signal;
-        if (signal && signal.aborted) {
-            return reject(signal.reason);
-        }
-        let xhr = new mp.XMLHttpRequest();
-        let aborted = false;
-        let payload = request.__Body__.payload;
-        xhr.onload = () => {
-            let options = {
-                headers: 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(() => {
-                const response = new ResponseP.ResponseP("response" in xhr ? xhr.response : xhr.responseText, options);
-                response.__Response__.url = "responseURL" in xhr ? xhr.responseURL : (options.headers.get("X-Request-URL") || "");
-                const _payload = response.__Body__.payload;
-                const _contentType = response.headers.get("Content-Type") || "";
-                if (_payload && _contentType) {
-                    _payload.type = _contentType;
-                }
-                resolve(response);
-            });
-        };
-        xhr.onerror = () => { setTimeout(() => { reject(new TypeError("Failed to fetch")); }); };
-        xhr.ontimeout = () => { setTimeout(() => { reject(new utils.DOMExceptionP("request:fail timeout", "TimeoutError")); }); };
-        xhr.onabort = () => { setTimeout(() => { reject(new utils.DOMExceptionP("The user aborted a request.", "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" && init.headers && typeof init.headers === "object" && !HeadersP.isHeaders(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 abortFn = () => { aborted = true; xhr.abort(); removeFn(); };
-            const removeFn = () => { signal.removeEventListener("abort", abortFn); };
-            signal.addEventListener("abort", abortFn);
-            xhr.onreadystatechange = () => { if (xhr.readyState === 4)
-                removeFn(); };
-        }
-        if (!payload)
-            xhr.send();
-        else
-            payload.promise.then(body => {
-                if (!aborted)
-                    xhr.send(body !== "" ? body : undefined);
-                else
-                    reject(new utils.DOMExceptionP("The user aborted a request.", "AbortError"));
-            })
-                .catch(e => {
-                console.error(e);
-                reject(new TypeError("Failed to fetch"));
-            });
-    });
-}
-function parseHeaders(rawHeaders) {
-    let headers = new HeadersP.HeadersP();
-    let preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
-    preProcessedHeaders
-        .split("\r")
-        .map(header => header.indexOf("\n") === 0 ? header.substring(1, header.length) : header)
-        .forEach(line => {
-        let parts = line.split(":");
-        let name = parts.shift().trim();
-        if (name) {
-            let value = parts.join(":").trim();
-            try {
-                headers.append(name, value);
-            }
-            catch (e) {
-                console.warn(`SyntaxError: Response.headers: '${name}' is not a valid HTTP header field name.`);
-            }
-        }
-    });
-    return headers;
-}
-const fetchE = (typeof fetch !== "undefined" && fetch) || fetchP;
-
-exports.fetch = fetchE;
-exports.fetchP = fetchP;
-exports.setXMLHttpRequest = setXMLHttpRequest;

package/dist/cjs/file-system/BlobP.js

@@ -1,111 +0,0 @@
-'use strict';
-
-var encode = require('../helpers/encode.js');
-var decode = require('../helpers/decode.js');
-var utils = require('../utils.js');
-var isBlob = require('../helpers/isBlob.js');
-var isSequence = require('../helpers/isSequence.js');
-var isArrayBuffer = require('../helpers/isArrayBuffer.js');
-
-class BlobP {
-    constructor(blobParts = [], options) {
-        if (!isSequence.isSequence(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 tasks = [];
-        let size = 0;
-        for (let i = 0; i < _blobParts.length; ++i) {
-            let chunk = _blobParts[i];
-            if (isBlob.isBlob(chunk)) {
-                size += chunk.size;
-                tasks.push(chunk.arrayBuffer().then(r => new Uint8Array(r)));
-            }
-            else {
-                let bytes = (isArrayBuffer.isArrayBuffer(chunk) || ArrayBuffer.isView(chunk))
-                    ? BufferSource_toUint8Array(chunk)
-                    : encode.encode(chunk);
-                size += bytes.length;
-                tasks.push(Promise.resolve(bytes));
-            }
-        }
-        utils.setState(this, "__Blob__", new BlobState(Promise.all(tasks).then(chunks => concat(chunks))));
-        state(this).size = size;
-        state(this).type = normalizeType(options === null || options === void 0 ? void 0 : options.type);
-    }
-    get size() { return state(this).size; }
-    get type() { return state(this).type; }
-    arrayBuffer() {
-        return state(this).promise.then(r => clone(r.buffer).buffer);
-    }
-    bytes() {
-        return state(this).promise.then(r => clone(r.buffer));
-    }
-    slice(start, end, contentType) {
-        let _start = start !== null && start !== void 0 ? start : 0, _end = end !== null && end !== void 0 ? end : this.size;
-        let blob = Object.create(BlobP.prototype);
-        utils.setState(blob, "__Blob__", new BlobState(state(this).promise.then(r => clone(r.slice(_start, _end)))));
-        state(blob).size = calcSlicedSize(this.size, _start, _end);
-        state(blob).type = normalizeType(contentType);
-        return blob;
-    }
-    stream() {
-        throw new TypeError(`Failed to execute 'stream' on '${utils.className(this)}': method not implemented.`);
-    }
-    text() {
-        return state(this).promise.then(r => decode.decode(r));
-    }
-    /** @internal */ toString() { return "[object Blob]"; }
-    /** @internal */ get [utils.SymbolP.toStringTag]() { return "Blob"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["Blob"] }; }
-}
-class BlobState {
-    constructor(promise) {
-        this.size = 0;
-        this.type = "";
-        this.promise = promise;
-    }
-}
-function state(target) {
-    return target.__Blob__;
-}
-function BufferSource_toUint8Array(buf) {
-    return isArrayBuffer.isArrayBuffer(buf)
-        ? new Uint8Array(buf)
-        : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-}
-function normalizeType(type) {
-    let rawType = "" + (type !== undefined ? type : "");
-    return /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
-}
-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;
-}
-function calcSlicedSize(size, start, end) {
-    const normalizeNumer = (n) => {
-        let num = Number(n);
-        if (isNaN(num))
-            num = 0;
-        if (num >= 0) {
-            num = Math.min(num, size);
-        }
-        else {
-            num = Math.max(0, num + size);
-        }
-        return num;
-    };
-    return Math.max(0, normalizeNumer(end) - normalizeNumer(start));
-}
-const BlobE = (typeof Blob !== "undefined" && Blob) || BlobP;
-
-exports.Blob = BlobE;
-exports.BlobP = BlobP;

package/dist/cjs/file-system/FileP.js

@@ -1,34 +0,0 @@
-'use strict';
-
-var BlobP = require('./BlobP.js');
-var utils = require('../utils.js');
-
-class FileP extends BlobP.BlobP {
-    constructor(fileBits, fileName, options) {
-        utils.checkArgsLength(arguments.length, 2, "File");
-        super(fileBits, options);
-        utils.setState(this, "__File__", new FileState());
-        state(this).lastModified = +((options === null || options === void 0 ? void 0 : options.lastModified) ? new Date(options.lastModified) : new Date()) || 0;
-        state(this).name = "" + fileName;
-    }
-    get lastModified() { return state(this).lastModified; }
-    get name() { return state(this).name; }
-    get webkitRelativePath() { return ""; }
-    /** @internal */ toString() { return "[object File]"; }
-    /** @internal */ get [utils.SymbolP.toStringTag]() { return "File"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["File", "Blob"] }; }
-}
-/** @internal */
-class FileState {
-    constructor() {
-        this.lastModified = 0;
-        this.name = "";
-    }
-}
-function state(target) {
-    return target.__File__;
-}
-const FileE = (typeof File !== "undefined" && File) || FileP;
-
-exports.File = FileE;
-exports.FileP = FileP;