fetch-xhr-shim 0.0.1-beta

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

@@ -0,0 +1,201 @@
+'use strict';
+
+var BlobP = require('./BlobP.js');
+var utils = require('../utils.js');
+var ProgressEventP = require('../event-system/ProgressEventP.js');
+var EventTargetP = require('../event-system/EventTargetP.js');
+
+class FileReaderP extends EventTargetP.EventTargetP {
+    static get EMPTY() { return 0; }
+    static get LOADING() { return 1; }
+    static get DONE() { return 2; }
+    constructor() {
+        super();
+        utils.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 [utils._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 = EventTargetP.attachFn(target, getHandlers(target));
+    }
+}
+function getHandlers(t) {
+    return {
+        onabort: (ev) => { EventTargetP.executeFn(t, t.onabort, ev); },
+        onerror: (ev) => { EventTargetP.executeFn(t, t.onerror, ev); },
+        onload: (ev) => { EventTargetP.executeFn(t, t.onload, ev); },
+        onloadend: (ev) => { EventTargetP.executeFn(t, t.onloadend, ev); },
+        onloadstart: (ev) => { EventTargetP.executeFn(t, t.onloadstart, ev); },
+        onprogress: (ev) => { EventTargetP.executeFn(t, t.onprogress, ev); },
+    };
+}
+function state(target) {
+    return target.__FileReader__;
+}
+function check(reader, kind, actual, blob) {
+    utils.checkArgsLength(actual, 1, "FileReader", kind);
+    if (!BlobP.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 utils.DOMException(`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 = () => { ProgressEventP.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 */;
+    ProgressEventP.emitProgressEvent(reader, "load", size, size);
+    execLoadend(reader, size);
+}
+function execAbort(reader) {
+    let s = state(reader);
+    s.pos = 5 /* FRCycle.ABORT */;
+    s.error = new utils.DOMException("An ongoing operation was aborted, typically with a call to abort().", "AbortError");
+    s.result = null;
+    s.readyState = 2 /* DONE */;
+    ProgressEventP.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 */;
+    ProgressEventP.emitProgressEvent(reader, "error");
+    execLoadend(reader);
+}
+function execLoadend(reader, size = 0) {
+    state(reader).pos = 7 /* FRCycle.LOADEND */;
+    ProgressEventP.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;
+
+exports.FileReader = FileReaderE;
+exports.FileReaderP = FileReaderP;
+exports.Uint8Array_toBase64 = Uint8Array_toBase64;

package/dist/cjs/fixes.js

@@ -0,0 +1,243 @@
+'use strict';
+
+var fetchP = require('./fetch-api/fetchP.js');
+var BodyImpl = require('./fetch-api/BodyImpl.js');
+var FormDataP = require('./network/FormDataP.js');
+var EventTargetP = require('./event-system/EventTargetP.js');
+var utils = require('./utils.js');
+
+function fixFetch(fetchFunc) {
+    const fetchFn = fetchFunc || (typeof fetch !== "undefined" && fetch);
+    if (!fetchFn || fetchFn === fetchP.fetchP)
+        return fetchP.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 (utils.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 (utils.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 (utils.isPolyfillType("Request", input)) {
+            return fetchP.fetchP(input, init);
+        }
+        if (init && init.headers && utils.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 && utils.isPolyfillType("FormData", init.body)) {
+                init.body = FormDataP.FormData_toBlob(init.body);
+            }
+            if (init && init.body && utils.isPolyfillType("Blob", init.body)) {
+                let payload = new BodyImpl.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 && EventTargetP.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 utils.DOMException("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 && utils.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 (utils.isPolyfillType("FormData", body)) {
+            body = FormDataP.FormData_toBlob(body);
+            if (!state(this).hasContentType) {
+                this.setRequestHeader("Content-Type", body.type);
+            }
+        }
+        if (utils.isPolyfillType("Blob", body)) {
+            let payload = new BodyImpl.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 (utils.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 utils.DOMException("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)) {
+            utils.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 (utils.isPolyfillType("Blob", data)) {
+            let payload = new BodyImpl.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;
+}
+
+exports.fixFetch = fixFetch;
+exports.fixWebSocket = fixWebSocket;
+exports.fixXMLHttpRequest = fixXMLHttpRequest;

package/dist/cjs/index.js

@@ -0,0 +1,59 @@
+'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');
+
+
+
+exports.TextEncoder = TextEncoderP.TextEncoder;
+exports.TextEncoderP = TextEncoderP.TextEncoderP;
+exports.TextDecoder = TextDecoderP.TextDecoder;
+exports.TextDecoderP = TextDecoderP.TextDecoderP;
+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.AbortController = AbortControllerP.AbortController;
+exports.AbortControllerP = AbortControllerP.AbortControllerP;
+exports.AbortSignal = AbortSignalP.AbortSignal;
+exports.AbortSignalP = AbortSignalP.AbortSignalP;
+exports.Blob = BlobP.Blob;
+exports.BlobP = BlobP.BlobP;
+exports.setReadableStreamClass = BlobP.setReadableStreamClass;
+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.setXMLHttpRequestClass = fetchP.setXMLHttpRequestClass;
+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.fixFetch = fixes.fixFetch;
+exports.fixWebSocket = fixes.fixWebSocket;
+exports.fixXMLHttpRequest = fixes.fixXMLHttpRequest;