fetch-xhr-shim 0.0.1-beta

package/dist/esm/file-system/FileReaderP.js

@@ -0,0 +1,197 @@
+import { isBlob } from './BlobP.js';
+import { setState, _Symbol, DOMException as DOMExceptionE, checkArgsLength } from '../utils.js';
+import { emitProgressEvent } from '../event-system/ProgressEventP.js';
+import { EventTargetP, attachFn, executeFn } from '../event-system/EventTargetP.js';
+
+class FileReaderP extends EventTargetP {
+    static get EMPTY() { return 0; }
+    static get LOADING() { return 1; }
+    static get DONE() { return 2; }
+    constructor() {
+        super();
+        setState(this, "__FileReader__", new FileReaderState(this));
+    }
+    get EMPTY() { return 0; }
+    get LOADING() { return 1; }
+    get DONE() { return 2; }
+    get error() { return state(this).error; }
+    get readyState() { return state(this).readyState; }
+    get result() { return state(this).result; }
+    abort() {
+        if (state(this).pos === 2 /* FRCycle.LOADING */)
+            execAbort(this);
+    }
+    readAsArrayBuffer(blob) {
+        check(this, "readAsArrayBuffer", arguments.length, blob);
+        read(this, blob.size, () => blob.arrayBuffer());
+    }
+    readAsBinaryString(blob) {
+        check(this, "readAsBinaryString", arguments.length, blob);
+        read(this, blob.size, () => blob.arrayBuffer().then(res => {
+            let str = [];
+            let buf = new Uint8Array(res);
+            for (let i = 0; i < buf.length; ++i) {
+                str.push(String.fromCharCode(buf[i]));
+            }
+            return str.join("");
+        }));
+    }
+    readAsDataURL(blob) {
+        check(this, "readAsDataURL", arguments.length, blob);
+        read(this, blob.size, () => blob.arrayBuffer().then(res => {
+            return "data:" + (blob.type || "application/octet-stream") + ";base64," + Uint8Array_toBase64(new Uint8Array(res));
+        }));
+    }
+    readAsText(blob, encoding) {
+        check(this, "readAsText", arguments.length, blob);
+        if (typeof TextDecoder === "function") {
+            let decoder = new TextDecoder(encoding);
+            read(this, blob.size, () => blob.arrayBuffer().then(r => decoder.decode(r)));
+        }
+        else {
+            if (encoding !== undefined) {
+                let _encoding = "" + encoding;
+                if (["utf-8", "utf8", "unicode-1-1-utf-8"].indexOf(_encoding.toLowerCase()) === -1) {
+                    console.warn(`Ignoring the execution of 'readAsText' on 'FileReader': encoding ('${_encoding}') not implemented.`);
+                }
+            }
+            read(this, blob.size, () => blob.text());
+        }
+    }
+    get onabort() { return state(this).onabort; }
+    set onabort(value) { state(this).onabort = value; state(this).attach("abort"); }
+    get onerror() { return state(this).onerror; }
+    set onerror(value) { state(this).onerror = value; state(this).attach("error"); }
+    get onload() { return state(this).onload; }
+    set onload(value) { state(this).onload = value; state(this).attach("load"); }
+    get onloadend() { return state(this).onloadend; }
+    set onloadend(value) { state(this).onloadend = value; state(this).attach("loadend"); }
+    get onloadstart() { return state(this).onloadstart; }
+    set onloadstart(value) { state(this).onloadstart = value; state(this).attach("loadstart"); }
+    get onprogress() { return state(this).onprogress; }
+    set onprogress(value) { state(this).onprogress = value; state(this).attach("progress"); }
+    /** @internal */ toString() { return "[object FileReader]"; }
+    /** @internal */ get [_Symbol.toStringTag]() { return "FileReader"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["FileReader", "EventTarget"] }; }
+}
+/** @internal */
+class FileReaderState {
+    constructor(target) {
+        this.pos = 0 /* FRCycle.EMPTY */;
+        this.readyState = 0 /* EMPTY */;
+        this.result = null;
+        this.error = null;
+        this.onabort = null;
+        this.onerror = null;
+        this.onload = null;
+        this.onloadend = null;
+        this.onloadstart = null;
+        this.onprogress = null;
+        this.attach = attachFn(target, getHandlers(target));
+    }
+}
+function getHandlers(t) {
+    return {
+        onabort: (ev) => { executeFn(t, t.onabort, ev); },
+        onerror: (ev) => { executeFn(t, t.onerror, ev); },
+        onload: (ev) => { executeFn(t, t.onload, ev); },
+        onloadend: (ev) => { executeFn(t, t.onloadend, ev); },
+        onloadstart: (ev) => { executeFn(t, t.onloadstart, ev); },
+        onprogress: (ev) => { executeFn(t, t.onprogress, ev); },
+    };
+}
+function state(target) {
+    return target.__FileReader__;
+}
+function check(reader, kind, actual, blob) {
+    checkArgsLength(actual, 1, "FileReader", kind);
+    if (!isBlob(blob))
+        throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.");
+    if (reader.readyState === 1 /* LOADING */)
+        throw new DOMExceptionE(`Failed to execute '${kind}' on 'FileReader': The object is already busy reading Blobs.`, "InvalidStateError");
+}
+function read(reader, size, launch) {
+    execLoadstart(reader, size, launch);
+}
+function execLoadstart(reader, size, launch) {
+    let s = state(reader);
+    s.pos = 1 /* FRCycle.LOADSTART */;
+    s.error = null;
+    s.result = null;
+    const callback = () => { emitProgressEvent(reader, "loadstart", 0, size); return launch(); };
+    return execLoading(reader, size, callback);
+}
+function execLoading(reader, size, launch) {
+    let s = state(reader);
+    s.pos = 2 /* FRCycle.LOADING */;
+    s.readyState = 1 /* LOADING */;
+    return Promise.resolve().then(() => {
+        if (s.pos !== 2 /* FRCycle.LOADING */)
+            return;
+        return launch().then(r => execDone(reader, size, r)).catch(err => execError(reader, err));
+    });
+}
+function execDone(reader, size, result) {
+    let s = state(reader);
+    if (s.pos !== 2 /* FRCycle.LOADING */)
+        return;
+    s.pos = 3 /* FRCycle.DONE */;
+    s.result = result;
+    s.readyState = 2; /* DONE */
+    execLoad(reader, size);
+}
+function execLoad(reader, size) {
+    state(reader).pos = 4 /* FRCycle.LOAD */;
+    emitProgressEvent(reader, "load", size, size);
+    execLoadend(reader, size);
+}
+function execAbort(reader) {
+    let s = state(reader);
+    s.pos = 5 /* FRCycle.ABORT */;
+    s.error = new DOMExceptionE("An ongoing operation was aborted, typically with a call to abort().", "AbortError");
+    s.result = null;
+    s.readyState = 2 /* DONE */;
+    emitProgressEvent(reader, "abort");
+    execLoadend(reader);
+}
+function execError(reader, err) {
+    let s = state(reader);
+    if (s.pos !== 2 /* FRCycle.LOADING */)
+        return;
+    s.pos = 6 /* FRCycle.ERROR */;
+    s.error = err;
+    s.result = null;
+    s.readyState = 2 /* DONE */;
+    emitProgressEvent(reader, "error");
+    execLoadend(reader);
+}
+function execLoadend(reader, size = 0) {
+    state(reader).pos = 7 /* FRCycle.LOADEND */;
+    emitProgressEvent(reader, "loadend", size, size);
+}
+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 FileReaderE = (typeof FileReader !== "undefined" && FileReader) || FileReaderP;
+
+export { FileReaderE as FileReader, FileReaderP, Uint8Array_toBase64 };

package/dist/esm/fixes.js

@@ -0,0 +1,239 @@
+import { fetchP } from './fetch-api/fetchP.js';
+import { Payload } from './fetch-api/BodyImpl.js';
+import { FormData_toBlob } from './network/FormDataP.js';
+import { isEventTarget } from './event-system/EventTargetP.js';
+import { isPolyfillType, DOMException as DOMExceptionE, setState, isSequence } from './utils.js';
+
+function fixFetch(fetchFunc) {
+    const fetchFn = fetchFunc || (typeof fetch !== "undefined" && fetch);
+    if (!fetchFn || fetchFn === fetchP)
+        return fetchP;
+    if ("__MPHTTPX__Polyfill__" in fetchFn)
+        return fetchFn;
+    function isHeadersLike(value) {
+        return !!value
+            && typeof value === "object"
+            && "has" in value
+            && typeof value.has === "function"
+            && "set" in value
+            && typeof value.set === "function";
+    }
+    function setContentType(init, contentType) {
+        if (init.headers) {
+            if (isHeadersLike(init.headers)) {
+                if (!init.headers.has("Content-Type")) {
+                    init.headers.set("Content-Type", contentType);
+                }
+            }
+            else if (isSequence(init.headers)) {
+                let hasContentType = false;
+                let _headers = Array.isArray(init.headers) ? init.headers : Array.from(init.headers);
+                for (let i = 0; i < _headers.length; ++i) {
+                    let header = _headers[i];
+                    if (isSequence(header)) {
+                        let pair = Array.isArray(header) ? header : Array.from(header);
+                        if (pair.length >= 2 && String(pair[0]).toLowerCase() === "content-type") {
+                            hasContentType = true;
+                            break;
+                        }
+                    }
+                }
+                if (!hasContentType) {
+                    _headers.push(["Content-Type", contentType]);
+                    init.headers = _headers;
+                }
+            }
+            else {
+                if (typeof init.headers === "object") {
+                    let hasContentType = false;
+                    let names = Object.getOwnPropertyNames(init.headers);
+                    for (let i = 0; i < names.length; ++i) {
+                        let name = names[i];
+                        if (name.toLowerCase() === "content-type") {
+                            hasContentType = true;
+                            break;
+                        }
+                    }
+                    if (!hasContentType) {
+                        init.headers["Content-Type"] = contentType;
+                    }
+                }
+            }
+        }
+        else {
+            init.headers = { "Content-Type": contentType };
+        }
+    }
+    function _fetch(input, init) {
+        if (isPolyfillType("Request", input)) {
+            return fetchP(input, init);
+        }
+        if (init && init.headers && isPolyfillType("Headers", init.headers)) {
+            if (typeof Headers !== "undefined" && Headers && !("__MPHTTPX__" in Headers.prototype)) {
+                let headers = new Headers();
+                init.headers.forEach((value, name) => { headers.append(name, value); });
+                init.headers = headers;
+            }
+            else {
+                let headers = {};
+                init.headers.forEach((value, name) => { headers[name] = value; });
+                init.headers = headers;
+            }
+        }
+        return new Promise((resolve, reject) => {
+            if (init && init.body && isPolyfillType("FormData", init.body)) {
+                init.body = FormData_toBlob(init.body);
+            }
+            if (init && init.body && isPolyfillType("Blob", init.body)) {
+                let payload = new Payload(init.body);
+                if (payload.type) {
+                    setContentType(init, payload.type);
+                }
+                let removeFn = null;
+                let aborted = false;
+                let processing = true;
+                if (input && typeof input === "object" && "signal" in input && isEventTarget(input.signal)) {
+                    let abortFn = () => { if (processing) {
+                        aborted = true;
+                    } removeFn(); };
+                    removeFn = () => { input.signal.removeEventListener("abort", abortFn); };
+                    input.signal.addEventListener("abort", abortFn);
+                }
+                payload.promise.then(r => {
+                    init.body = r !== "" ? r : null;
+                    if (!aborted) {
+                        resolve(fetchFn(input, init));
+                    }
+                    else {
+                        reject(new DOMExceptionE("The user aborted a request.", "AbortError"));
+                    }
+                    processing = false;
+                })
+                    .catch((e) => {
+                    reject(new TypeError("Failed to fetch"));
+                    console.error(e);
+                    processing = false;
+                })
+                    .then(() => { if (removeFn) {
+                    removeFn();
+                } }); // finally
+            }
+            else {
+                if (init && init.body && isPolyfillType("URLSearchParams", init.body)) {
+                    setContentType(init, "application/x-www-form-urlencoded;charset=UTF-8");
+                }
+                resolve(fetchFn(input, init));
+            }
+        });
+    }
+    _fetch["__MPHTTPX__Polyfill__"] = true;
+    return _fetch;
+}
+function fixXMLHttpRequest(XHRClass) {
+    const Klass = XHRClass || (typeof XMLHttpRequest !== "undefined" && XMLHttpRequest);
+    if (!Klass || "__MPHTTPX__Polyfill__" in Klass || "__MPHTTPX__" in Klass.prototype)
+        return;
+    const _abort = Klass.prototype.abort;
+    const _open = Klass.prototype.open;
+    const _send = Klass.prototype.send;
+    const _setRequestHeader = Klass.prototype.setRequestHeader;
+    Klass.prototype.abort = function () {
+        if (state(this).processing) {
+            state(this).aborted = true;
+        }
+        _abort.call(this);
+        state(this).hasContentType = false;
+    };
+    Klass.prototype.open = function (method, url, async = true, username = null, password = null) {
+        if (state(this).processing) {
+            state(this).aborted = true;
+        }
+        _open.call(this, method, url, async, username, password);
+        state(this).hasContentType = false;
+    };
+    Klass.prototype.send = function (body) {
+        if (isPolyfillType("FormData", body)) {
+            body = FormData_toBlob(body);
+            if (!state(this).hasContentType) {
+                this.setRequestHeader("Content-Type", body.type);
+            }
+        }
+        if (isPolyfillType("Blob", body)) {
+            let payload = new Payload(body);
+            if (payload.type && !state(this).hasContentType) {
+                this.setRequestHeader("Content-Type", payload.type);
+            }
+            const withCredentials = this.withCredentials;
+            state(this).processing = true;
+            payload.promise.then((function (r) {
+                if (!state(this).aborted) {
+                    if (withCredentials !== this.withCredentials) {
+                        console.warn("Illegal to set the 'withCredentials' property on 'XMLHttpRequest': The value may only be set if the object's state is UNSENT or OPENED.");
+                        this.withCredentials = withCredentials;
+                    }
+                    _send.call(this, r !== "" ? r : undefined);
+                }
+                state(this).aborted = false;
+                state(this).processing = false;
+            }).bind(this))
+                .catch((function (e) {
+                console.error(e);
+                state(this).aborted = false;
+                state(this).processing = false;
+            }).bind(this));
+        }
+        else {
+            if (isPolyfillType("URLSearchParams", body) && !state(this).hasContentType)
+                this.setRequestHeader("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
+            _send.call(this, body);
+        }
+    };
+    Klass.prototype.setRequestHeader = function (name, value) {
+        if (state(this).processing) {
+            throw new DOMExceptionE("Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.", "InvalidStateError");
+        }
+        _setRequestHeader.call(this, name, value);
+        if (String(name).toLowerCase() === "content-type")
+            state(this).hasContentType = true;
+    };
+    // @ts-ignore
+    Klass["__MPHTTPX__Polyfill__"] = true;
+    class XMLHttpRequestState {
+        constructor() {
+            this.aborted = false;
+            this.processing = false;
+            this.hasContentType = false;
+        }
+    }
+    function state(target) {
+        const prop = "__XMLHttpRequest_Polyfill__";
+        // @ts-ignore
+        if (!(prop in target)) {
+            setState(target, prop, new XMLHttpRequestState());
+        }
+        return target[prop];
+    }
+}
+function fixWebSocket(WSClass) {
+    const Klass = WSClass || (typeof WebSocket !== "undefined" && WebSocket);
+    if (!Klass || "__MPHTTPX__Polyfill__" in Klass || "__MPHTTPX__" in Klass.prototype)
+        return;
+    const _send = Klass.prototype.send;
+    Klass.prototype.send = function (data) {
+        if (isPolyfillType("Blob", data)) {
+            let payload = new Payload(data);
+            payload.promise.then(r => {
+                if (this.readyState !== 1 /* OPEN */)
+                    return;
+                _send.call(this, r);
+            });
+        }
+        else {
+            _send.call(this, data);
+        }
+    };
+    // @ts-ignore
+    Klass["__MPHTTPX__Polyfill__"] = true;
+}
+
+export { fixFetch, fixWebSocket, fixXMLHttpRequest };

package/dist/esm/index.js

@@ -0,0 +1,17 @@
+export { TextEncoder, TextEncoderP } from './encoding/TextEncoderP.js';
+export { TextDecoder, TextDecoderP } from './encoding/TextDecoderP.js';
+export { EventTarget, EventTargetP } from './event-system/EventTargetP.js';
+export { Event, EventP } from './event-system/EventP.js';
+export { CustomEvent, CustomEventP } from './event-system/CustomEventP.js';
+export { AbortController, AbortControllerP } from './event-system/AbortControllerP.js';
+export { AbortSignal, AbortSignalP } from './event-system/AbortSignalP.js';
+export { Blob, BlobP, setReadableStreamClass } from './file-system/BlobP.js';
+export { File, FileP } from './file-system/FileP.js';
+export { FileReader, FileReaderP } from './file-system/FileReaderP.js';
+export { URLSearchParams, URLSearchParamsP } from './network/URLSearchParamsP.js';
+export { FormData, FormDataP } from './network/FormDataP.js';
+export { fetch, fetchP, setXMLHttpRequestClass } from './fetch-api/fetchP.js';
+export { Headers, HeadersP } from './fetch-api/HeadersP.js';
+export { Request, RequestP } from './fetch-api/RequestP.js';
+export { Response, ResponseP } from './fetch-api/ResponseP.js';
+export { fixFetch, fixWebSocket, fixXMLHttpRequest } from './fixes.js';