fetch-xhr-shim 0.0.1-beta

package/dist/cjs/network/FormDataP.js

@@ -0,0 +1,308 @@
+'use strict';
+
+var FileP = require('../file-system/FileP.js');
+var BlobP = require('../file-system/BlobP.js');
+var utils = require('../utils.js');
+
+class FormDataP {
+    constructor(form, submitter) {
+        utils.setState(this, "__FormData__", new FormDataState());
+        if (form !== undefined) {
+            try {
+                let elements = form.elements;
+                for (let i = 0; i < elements.length; ++i) {
+                    let elm = elements[i];
+                    if (!elm.name || elm.disabled || elm.type === "submit" || elm.type === "button" || elm.matches("form fieldset[disabled] *"))
+                        return;
+                    if (elm.type === "file") {
+                        let files = elm.files && elm.files.length
+                            ? elm.files
+                            : [new FileP.File([], "", { type: "application/octet-stream" })];
+                        for (let i = 0; i < files.length; ++i) {
+                            this.append(elm.name, files[i]);
+                        }
+                    }
+                    else if (elm.type === "select-multiple" || elm.type === "select-one") {
+                        for (let i = 0; i < elm.options.length; ++i) {
+                            let opt = elm.options[i];
+                            !opt.disabled && opt.selected && this.append(elm.name, opt.value);
+                        }
+                    }
+                    else if (elm.type === "checkbox" || elm.type === "radio") {
+                        if (elm.checked)
+                            this.append(elm.name, elm.value);
+                    }
+                    else {
+                        let value = elm.type === "textarea" ? normalizeLinefeeds(elm.value) : elm.value;
+                        this.append(elm.name, value);
+                    }
+                }
+            }
+            catch (e) {
+                throw new TypeError("Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.");
+            }
+        }
+        if (submitter !== undefined && submitter !== null) {
+            console.warn("Ignoring the 'submitter' of 'FormData' constructor: parameter 2 not implemented.");
+        }
+    }
+    append(name, blobValue, filename) {
+        checkArgsFn(arguments.length, 2, "append");
+        state(this).array.push(normalizeArgs(name, blobValue, filename));
+    }
+    delete(name) {
+        checkArgsFn(arguments.length, 1, "delete");
+        let _name = "" + name;
+        let index = -1;
+        let array = state(this).array;
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                index = i;
+                continue;
+            }
+            result.push(item);
+        }
+        if (index > -1) {
+            state(this).array = result;
+        }
+    }
+    get(name) {
+        checkArgsFn(arguments.length, 1, "get");
+        let _name = "" + name;
+        let array = state(this).array;
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                return item[1];
+            }
+        }
+        return null;
+    }
+    getAll(name) {
+        checkArgsFn(arguments.length, 1, "getAll");
+        let _name = "" + name;
+        let array = state(this).array;
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                result.push(item[1]);
+            }
+        }
+        return result;
+    }
+    has(name) {
+        checkArgsFn(arguments.length, 1, "has");
+        let _name = "" + name;
+        let array = state(this).array;
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                return true;
+            }
+        }
+        return false;
+    }
+    set(name, blobValue, filename) {
+        checkArgsFn(arguments.length, 2, "set");
+        let _name = "" + name;
+        let _args = normalizeArgs(name, blobValue, filename);
+        let index = -1;
+        let array = state(this).array;
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (index === -1) {
+                    index = i;
+                    result.push(_args);
+                }
+                continue;
+            }
+            result.push(item);
+        }
+        if (index === -1) {
+            result.push(_args);
+        }
+        state(this).array = result;
+    }
+    forEach(callbackfn, thisArg) {
+        checkArgsFn(arguments.length, 1, "forEach");
+        if (typeof callbackfn !== "function") {
+            throw new TypeError("Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'.");
+        }
+        let array = state(this).array;
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            callbackfn.call(thisArg, item[1], item[0], thisArg);
+        }
+    }
+    entries() {
+        return state(this).array.map(x => [x[0], x[1]]).values();
+    }
+    keys() {
+        return state(this).array.map(x => x[0]).values();
+    }
+    values() {
+        return state(this).array.map(x => x[1]).values();
+    }
+    // @ts-ignore
+    /** @internal */ [utils._Symbol.iterator]() {
+        return this.entries();
+    }
+    /** @internal */ toString() { return "[object FormData]"; }
+    /** @internal */ get [utils._Symbol.toStringTag]() { return "FormData"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["FormData"] }; }
+}
+/** @internal */
+class FormDataState {
+    constructor() {
+        this.array = [];
+    }
+}
+function state(target) {
+    return target.__FormData__;
+}
+function checkArgsFn(actual, expect, funcName) {
+    return utils.checkArgsLength(actual, expect, "FormData", funcName);
+}
+function normalizeArgs(name, value, filename) {
+    if (BlobP.isBlob(value)) {
+        filename = filename !== undefined
+            ? ("" + filename)
+            : typeof value.name === "string"
+                ? value.name
+                : "blob";
+        if (value.name !== filename || BlobP.isBlob(value, true)) {
+            let FileClass = !utils.isPolyfillType("Blob", value) ? FileP.File : FileP.FileP;
+            value = new FileClass([value], filename);
+        }
+        return ["" + name, value];
+    }
+    return ["" + name, "" + value];
+}
+function isFormData(value) {
+    return utils.isPolyfillType("FormData", value) || isExternalFormData(value);
+}
+function isExternalFormData(value) {
+    let expect = "[object FormData]";
+    return (Object.prototype.toString.call(value) === expect || String(value) === expect)
+        && "forEach" in value
+        && typeof value.forEach === "function";
+}
+function FormData_toBlob(formData, externalBoundary) {
+    const boundary = externalBoundary || ("----formdata-mphttpx-" + Math.random());
+    const p = `--${boundary}\r\nContent-Disposition: form-data; name="`;
+    let chunks = [];
+    let useNativeBlob = true;
+    formData.forEach((value, name) => {
+        if (typeof value === "string") {
+            chunks.push(p + escape(normalizeLinefeeds(name)) + `"\r\n\r\n${normalizeLinefeeds(value)}\r\n`);
+        }
+        else {
+            if (useNativeBlob && utils.isPolyfillType("Blob", value)) {
+                useNativeBlob = false;
+            }
+            chunks.push(p + escape(normalizeLinefeeds(name)) + `"; filename="${escape(value.name)}"\r\nContent-Type: ${value.type || "application/octet-stream"}\r\n\r\n`, value, `\r\n`);
+        }
+    });
+    chunks.push(`--${boundary}--`);
+    let BlobClass = useNativeBlob ? BlobP.Blob : BlobP.BlobP;
+    return new BlobClass(chunks, { type: "multipart/form-data; boundary=" + boundary });
+}
+// normalize line feeds for textarea
+// https://html.spec.whatwg.org/multipage/form-elements.html#textarea-line-break-normalisation-transformation
+function normalizeLinefeeds(value) {
+    return value.replace(/\r?\n|\r/g, "\r\n");
+}
+function escape(str) {
+    return str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22');
+}
+function extractBoundary(contentType) {
+    if (!contentType)
+        return;
+    if (!/multipart\/form-data/i.test(contentType))
+        return;
+    let boundaryMatch = contentType.match(/boundary\s*=\s*([^;]+)/i);
+    if (boundaryMatch && boundaryMatch[1]) {
+        let boundary = boundaryMatch[1].trim();
+        return boundary.replace(/^["']|["']$/g, "");
+    }
+}
+function createFormDataFromBinaryText(text, boundary) {
+    const throwParseError = () => {
+        throw new TypeError("Could not parse content as FormData.");
+    };
+    if (typeof text !== "string" || text.trim() === "") {
+        throwParseError();
+    }
+    let firstLineEnd = text.indexOf("\r\n");
+    if (firstLineEnd === -1) {
+        throwParseError();
+    }
+    let _boundary = text.substring(2, firstLineEnd).trim();
+    if (!_boundary) {
+        throwParseError();
+    }
+    if (boundary !== undefined && boundary !== _boundary) {
+        throwParseError();
+    }
+    let parts = text.split(`--${_boundary}`).filter(part => {
+        let trimmed = part.trim();
+        return trimmed !== "" && trimmed !== "--";
+    });
+    if (parts.length === 0) {
+        throwParseError();
+    }
+    let pairs = [];
+    let hasFile = false;
+    parts.forEach(part => {
+        let separatorIndex = part.indexOf("\r\n\r\n");
+        if (separatorIndex === -1) {
+            throwParseError();
+        }
+        let headerRaw = part.substring(0, separatorIndex).trim();
+        let nameMatch = headerRaw.match(/name="([^"]*)"/);
+        if (!nameMatch || nameMatch.length < 2) {
+            throwParseError();
+        }
+        let fieldName = nameMatch[1];
+        let filenameMatch = headerRaw.match(/filename="([^"]*)"/);
+        let contentRaw = part.substring(separatorIndex + 4);
+        if (!filenameMatch) {
+            pairs.push([fieldName, contentRaw.replace(/^[\r\n]+|[\r\n]+$/g, "")]);
+        }
+        else {
+            let filename = filenameMatch[1] || "";
+            let contentTypeMatch = headerRaw.match(/Content-Type: ([^\r\n]+)/);
+            let mimeType = contentTypeMatch ? (contentTypeMatch[1] || "").trim() : "text/plain";
+            let content = contentRaw.replace(/\r\n/g, "");
+            hasFile = true;
+            pairs.push([fieldName, new FileP.File([content], filename, { type: mimeType })]);
+        }
+    });
+    let useNativeFormData = !hasFile || (() => {
+        try {
+            let fd = new FormDataE();
+            fd.append("file", new FileP.File([], ""));
+            return typeof fd.get("file") !== "string";
+        }
+        catch (e) {
+            return false;
+        }
+    })();
+    let FormDataClass = useNativeFormData ? FormDataE : FormDataP;
+    let formData = new FormDataClass();
+    pairs.forEach(x => { formData.append(x[0], x[1]); });
+    return formData;
+}
+const FormDataE = (typeof FormData !== "undefined" && FormData) || FormDataP;
+
+exports.FormData = FormDataE;
+exports.FormDataP = FormDataP;
+exports.FormData_toBlob = FormData_toBlob;
+exports.createFormDataFromBinaryText = createFormDataFromBinaryText;
+exports.extractBoundary = extractBoundary;
+exports.isFormData = isFormData;

package/dist/cjs/network/URLSearchParamsP.js

@@ -0,0 +1,235 @@
+'use strict';
+
+var utils = require('../utils.js');
+
+class URLSearchParamsP {
+    constructor(init) {
+        utils.setState(this, "__URLSearchParams__", new URLSearchParamsState());
+        if (init !== undefined) {
+            if (isURLSearchParams(init)) {
+                init.forEach((value, name) => { this.append(name, value); }, this);
+            }
+            else if (init && typeof init === "object") {
+                if (utils.isSequence(init)) {
+                    let _init = Array.isArray(init) ? init : Array.from(init);
+                    for (let i = 0; i < _init.length; ++i) {
+                        let item = _init[i];
+                        if (utils.isSequence(item)) {
+                            let pair = Array.isArray(item) ? item : Array.from(item);
+                            if (pair.length === 2) {
+                                this.append(pair[0], pair[1]);
+                            }
+                            else {
+                                throw new TypeError("Failed to construct 'URLSearchParams': Sequence initializer must only contain pair elements");
+                            }
+                        }
+                        else {
+                            throw new TypeError("Failed to construct 'URLSearchParams': The provided value cannot be converted to a sequence.");
+                        }
+                    }
+                }
+                else {
+                    Object.getOwnPropertyNames(init).forEach(name => { this.append(name, init[name]); }, this);
+                }
+            }
+            else {
+                let _init = "" + init;
+                if (_init.indexOf("?") === 0) {
+                    _init = _init.slice(1);
+                }
+                let pairs = _init.split("&");
+                for (let i = 0; i < pairs.length; ++i) {
+                    let pair = pairs[i], separatorIndex = pair.indexOf("=");
+                    if (separatorIndex > -1) {
+                        this.append(decode(pair.slice(0, separatorIndex)), decode(pair.slice(separatorIndex + 1)));
+                    }
+                    else {
+                        if (pair) {
+                            this.append(decode(pair), "");
+                        }
+                    }
+                }
+            }
+        }
+    }
+    get size() { return state(this).array.length; }
+    append(name, value) {
+        checkArgsFn(arguments.length, 2, "append");
+        state(this).array.push(["" + name, normalizeValue(value)]);
+    }
+    delete(name, value) {
+        checkArgsFn(arguments.length, 1, "delete");
+        let _name = "" + name;
+        let index = -1;
+        let array = state(this).array;
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (arguments.length !== 1 && item[1] !== normalizeValue(value)) {
+                    result.push(item);
+                }
+                index = i;
+                continue;
+            }
+            result.push(item);
+        }
+        if (index > -1) {
+            state(this).array = result;
+        }
+    }
+    get(name) {
+        checkArgsFn(arguments.length, 1, "get");
+        let _name = "" + name;
+        let array = state(this).array;
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                return item[1];
+            }
+        }
+        return null;
+    }
+    getAll(name) {
+        checkArgsFn(arguments.length, 1, "getAll");
+        let _name = "" + name;
+        let array = state(this).array;
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                result.push(item[1]);
+            }
+        }
+        return result;
+    }
+    has(name, value) {
+        checkArgsFn(arguments.length, 1, "has");
+        let _name = "" + name;
+        let array = state(this).array;
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (arguments.length === 1) {
+                    return true;
+                }
+                else {
+                    if (item[1] === normalizeValue(value)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    set(name, value) {
+        checkArgsFn(arguments.length, 2, "set");
+        let _name = "" + name;
+        let _value = normalizeValue(value);
+        let index = -1;
+        let array = state(this).array;
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (index === -1) {
+                    index = i;
+                    result.push([_name, _value]);
+                }
+                continue;
+            }
+            result.push(item);
+        }
+        if (index === -1) {
+            result.push([_name, _value]);
+        }
+        state(this).array = result;
+    }
+    sort() {
+        state(this).array.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    }
+    forEach(callbackfn, thisArg) {
+        checkArgsFn(arguments.length, 1, "forEach");
+        if (typeof callbackfn !== "function") {
+            throw new TypeError("Failed to execute 'forEach' on 'URLSearchParams': parameter 1 is not of type 'Function'.");
+        }
+        let array = state(this).array;
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            callbackfn.call(thisArg, item[1], item[0], this);
+        }
+    }
+    entries() {
+        return state(this).array.map(x => [x[0], x[1]]).values();
+    }
+    keys() {
+        return state(this).array.map(x => x[0]).values();
+    }
+    values() {
+        return state(this).array.map(x => x[1]).values();
+    }
+    // @ts-ignore
+    /** @internal */ [utils._Symbol.iterator]() {
+        return this.entries();
+    }
+    toString() {
+        let array = state(this).array;
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            result.push(encode(item[0]) + "=" + encode(item[1]));
+        }
+        return result.join("&");
+    }
+    /** @internal */ get [utils._Symbol.toStringTag]() { return "URLSearchParams"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["URLSearchParams"] }; }
+}
+/** @internal */
+class URLSearchParamsState {
+    constructor() {
+        this.array = [];
+    }
+}
+function state(target) {
+    return target.__URLSearchParams__;
+}
+function checkArgsFn(actual, expect, funcName) {
+    utils.checkArgsLength(actual, expect, "URLSearchParams", funcName);
+}
+function normalizeValue(value) {
+    return typeof value === "string" ? value : (value !== null && value !== undefined && typeof value.toString === "function"
+        ? value.toString()
+        : JSON.stringify(value));
+}
+function encode(str) {
+    const replace = {
+        "!": "%21",
+        "'": "%27",
+        "(": "%28",
+        ")": "%29",
+        "~": "%7E",
+        "%20": "+",
+        "%00": "\x00",
+    };
+    return encodeURIComponent(str).replace(/[!'\(\)~]|%20|%00/g, match => replace[match]);
+}
+function decode(str) {
+    return str
+        .replace(/[ +]/g, "%20")
+        .replace(/(%[a-f0-9]{2})+/ig, match => decodeURIComponent(match));
+}
+function isURLSearchParams(value) {
+    return utils.isPolyfillType("URLSearchParams", value) || isGlobalURLSearchParams(value);
+}
+function isGlobalURLSearchParams(value) {
+    return utils.isObjectType("URLSearchParams", value) || (!!value &&
+        typeof value === "object" &&
+        typeof URLSearchParams !== "undefined" &&
+        URLSearchParams &&
+        URLSearchParams.prototype.isPrototypeOf(value));
+}
+const URLSearchParamsE = (typeof URLSearchParams !== "undefined" && URLSearchParams) || URLSearchParamsP;
+
+exports.URLSearchParams = URLSearchParamsE;
+exports.URLSearchParamsP = URLSearchParamsP;
+exports.isURLSearchParams = isURLSearchParams;

package/dist/cjs/polyfill.js

@@ -0,0 +1,87 @@
+'use strict';
+
+var TextEncoderP = require('./encoding/TextEncoderP.js');
+var TextDecoderP = require('./encoding/TextDecoderP.js');
+var EventTargetP = require('./event-system/EventTargetP.js');
+var EventP = require('./event-system/EventP.js');
+var CustomEventP = require('./event-system/CustomEventP.js');
+var AbortControllerP = require('./event-system/AbortControllerP.js');
+var AbortSignalP = require('./event-system/AbortSignalP.js');
+var BlobP = require('./file-system/BlobP.js');
+var FileP = require('./file-system/FileP.js');
+var FileReaderP = require('./file-system/FileReaderP.js');
+var URLSearchParamsP = require('./network/URLSearchParamsP.js');
+var FormDataP = require('./network/FormDataP.js');
+var fetchP = require('./fetch-api/fetchP.js');
+var HeadersP = require('./fetch-api/HeadersP.js');
+var RequestP = require('./fetch-api/RequestP.js');
+var ResponseP = require('./fetch-api/ResponseP.js');
+var fixes = require('./fixes.js');
+
+/* eslint-disable no-prototype-builtins */
+const g = (typeof globalThis !== "undefined" && globalThis) ||
+    (typeof self !== "undefined" && self) ||
+    // @ts-ignore eslint-disable-next-line no-undef
+    (typeof global !== "undefined" && global) ||
+    {};
+if (typeof XMLHttpRequest !== "undefined" && XMLHttpRequest) {
+    if (!g.Blob || !g.FormData) {
+        fixes.fixXMLHttpRequest();
+    }
+}
+if (typeof WebSocket !== "undefined" && WebSocket) {
+    if (!g.Blob) {
+        fixes.fixWebSocket();
+    }
+}
+if (!g.TextEncoder) {
+    g.TextEncoder = TextEncoderP.TextEncoderP;
+}
+if (!g.TextDecoder) {
+    g.TextDecoder = TextDecoderP.TextDecoderP;
+}
+if (!g.EventTarget) {
+    g.EventTarget = EventTargetP.EventTargetP;
+    if (!g.Event) {
+        g.Event = EventP.EventP;
+    }
+    if (!g.CustomEvent) {
+        g.CustomEvent = CustomEventP.CustomEventP;
+    }
+}
+if (!g.AbortController) {
+    g.AbortController = AbortControllerP.AbortControllerP;
+}
+if (!g.AbortSignal) {
+    g.AbortSignal = AbortSignalP.AbortSignalP;
+}
+if (!g.FileReader) {
+    g.FileReader = FileReaderP.FileReaderP;
+    if (!g.Blob) {
+        g.Blob = BlobP.BlobP;
+    }
+    if (!g.File) {
+        g.File = FileP.FileP;
+    }
+}
+if (!g.URLSearchParams) {
+    g.URLSearchParams = URLSearchParamsP.URLSearchParamsP;
+}
+if (!g.FormData) {
+    g.FormData = FormDataP.FormDataP;
+}
+if (!g.fetch) {
+    g.fetch = fetchP.fetchP;
+    if (!g.Headers) {
+        g.Headers = HeadersP.HeadersP;
+    }
+    if (!g.Request) {
+        g.Request = RequestP.RequestP;
+    }
+    if (!g.Response) {
+        g.Response = ResponseP.ResponseP;
+    }
+}
+else {
+    g.fetch = fixes.fixFetch();
+}

package/dist/cjs/utils.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const _Symbol = {
+    iterator: ((typeof Symbol === "function") && (Symbol.iterator || "Symbol(Symbol.iterator)")),
+    toStringTag: ((typeof Symbol === "function") && (Symbol.toStringTag || "Symbol(Symbol.toStringTag)")),
+};
+class DOMExceptionP extends Error {
+    constructor(message, name) {
+        super(message);
+        if (name !== undefined)
+            this.name = "" + name;
+    }
+    /** @internal */ get [_Symbol.toStringTag]() { return "DOMException"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["DOMException"] }; }
+}
+const DOMExceptionE = (() => { try {
+    new DOMException();
+    return true;
+}
+catch (e) {
+    return false;
+} })() ? DOMException : DOMExceptionP;
+function className(object) {
+    try {
+        return object.__MPHTTPX__.chain[0];
+    }
+    catch (e) {
+        return Object.prototype.toString.call(object).slice(8, -1);
+    }
+}
+function setState(target, name, value) {
+    Object.defineProperty(target, name, { value });
+}
+function isObjectType(name, value) {
+    return Object.prototype.toString.call(value) === `[object ${name}]`;
+}
+function isPolyfillType(name, value, strict = false) {
+    const field = "__MPHTTPX__";
+    return !!value
+        && typeof value === "object"
+        && field in value
+        && !!value[field]
+        && typeof value[field] === "object"
+        && "chain" in value[field]
+        && Array.isArray(value[field].chain)
+        && ((index) => strict ? index === 0 : index > -1)(value[field].chain.indexOf(name));
+}
+function isSequence(value) {
+    return Array.isArray(value) || (!!value
+        && typeof value === "object"
+        && typeof Symbol === "function"
+        && Symbol.iterator
+        && Symbol.iterator in value
+        && typeof value[Symbol.iterator] === "function");
+}
+function checkArgsLength(actual, expect, className, funcName) {
+    if (actual < expect) {
+        throw new TypeError(`Failed to ${funcName ? ("execute '" + funcName + "' on") : "construct"} '${className}': ${expect} argument${expect > 1 ? "s" : ""} required, but only ${actual} present.`);
+    }
+}
+
+exports.DOMException = DOMExceptionE;
+exports.DOMExceptionP = DOMExceptionP;
+exports._Symbol = _Symbol;
+exports.checkArgsLength = checkArgsLength;
+exports.className = className;
+exports.isObjectType = isObjectType;
+exports.isPolyfillType = isPolyfillType;
+exports.isSequence = isSequence;
+exports.setState = setState;