fetch-xhr-shim 0.0.1-beta

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

@@ -0,0 +1,188 @@
+'use strict';
+
+var HeadersP = require('./HeadersP.js');
+var BodyImpl = require('./BodyImpl.js');
+var AbortControllerP = require('../event-system/AbortControllerP.js');
+var EventTargetP = require('../event-system/EventTargetP.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 = HeadersP.createHeaders(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);
+                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 = HeadersP.createHeaders(_init.headers);
+        }
+        if (_init.method) {
+            s.method = normalizeMethod(_init.method);
+        }
+        if (_init.mode) {
+            s.mode = _init.mode;
+        }
+        if (_init.signal !== null && _init.signal !== undefined) {
+            if (EventTargetP.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.initBody(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.Headers();
+        }
+        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 = (new AbortControllerP.AbortController()).signal;
+        }
+        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._Symbol.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(request) {
+    let payload = Object.create(BodyImpl.Payload.prototype);
+    payload.type = request.headers.get("Content-Type") || "";
+    try {
+        payload.promise = request.arrayBuffer();
+    }
+    catch (e) {
+        try {
+            payload.promise = request.text();
+        }
+        catch (e) {
+            if (payload.type.slice(0, 19).toLowerCase() === "multipart/form-data") {
+                try {
+                    payload.promise = request.formData().then(r => (new BodyImpl.Payload(r, payload.type)).promise);
+                }
+                catch (e) {
+                    // pass
+                }
+            }
+        }
+    }
+    if (!payload.promise) {
+        throw new TypeError("Failed to construct 'Request': Failed to read request body data, underlying data is in an invalid format.");
+    }
+    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();
+    }
+}
+// HTTP methods whose capitalization should be normalized
+const methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
+function normalizeMethod(method) {
+    let upcased = method.toUpperCase();
+    return methods.indexOf(upcased) > -1 ? upcased : method;
+}
+const RequestE = (typeof Request !== "undefined" && Request) || RequestP;
+
+exports.Request = RequestE;
+exports.RequestP = RequestP;
+exports.normalizeMethod = normalizeMethod;

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

@@ -0,0 +1,93 @@
+'use strict';
+
+var BodyImpl = require('./BodyImpl.js');
+var HeadersP = require('./HeadersP.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 = HeadersP.createHeaders(_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.initBody(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.Headers();
+        }
+        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: HeadersP.createHeaders(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._Symbol.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

@@ -0,0 +1,129 @@
+'use strict';
+
+var BodyImpl = require('./BodyImpl.js');
+var RequestP = require('./RequestP.js');
+var ResponseP = require('./ResponseP.js');
+var utils = require('../utils.js');
+var HeadersP = require('./HeadersP.js');
+
+const mp = { XMLHttpRequest: (typeof XMLHttpRequest !== "undefined" && XMLHttpRequest) || undefined };
+function setXMLHttpRequestClass(XHRClass) { mp.XMLHttpRequest = XHRClass; }
+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 XMLHttpRequestClass = mp.XMLHttpRequest || (() => { throw new ReferenceError("XMLHttpRequest is not defined"); })();
+        let xhr = new XMLHttpRequestClass();
+        let aborted = false;
+        let payload = request.__Body__.payload;
+        let response;
+        xhr.onload = () => {
+            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(() => {
+                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") || "");
+                let _payload = response.__Body__.payload;
+                let _contentType = response.headers.get("Content-Type") || "";
+                if (_payload && _contentType) {
+                    _payload.type = _contentType;
+                }
+                if (!aborted)
+                    resolve(response);
+                else
+                    reject(createAbortException());
+            });
+        };
+        xhr.onabort = () => { setTimeout(() => { reject(createAbortException()); }); };
+        xhr.onerror = () => { setTimeout(() => { reject(new TypeError("Failed to fetch")); }); };
+        xhr.ontimeout = () => { setTimeout(() => { reject(new utils.DOMException("The request timed out.", "TimeoutError")); }); };
+        xhr.open(request.method, fixUrl(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 = () => {
+                if (response && !response.bodyUsed) {
+                    let _payload = response.__Body__.payload = new BodyImpl.Payload();
+                    _payload.promise = Promise.reject(createAbortException());
+                }
+                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(createAbortException());
+            })
+                .catch(e => {
+                console.error(e);
+                reject(new TypeError("Failed to fetch"));
+            });
+    });
+}
+function createAbortException() {
+    return new utils.DOMException("The user aborted a request.", "AbortError");
+}
+const locationSupported = typeof location !== "undefined" && !!location;
+const fixUrl = (url) => { if (url === "" && locationSupported && (location === null || location === void 0 ? void 0 : location.href)) {
+    return location.href;
+}
+else {
+    return url;
+} };
+const fetchE = (typeof fetch !== "undefined" && fetch) || fetchP;
+
+exports.fetch = fetchE;
+exports.fetchP = fetchP;
+exports.setXMLHttpRequestClass = setXMLHttpRequestClass;

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

@@ -0,0 +1,171 @@
+'use strict';
+
+var TextEncoderP = require('../encoding/TextEncoderP.js');
+var TextDecoderP = require('../encoding/TextDecoderP.js');
+var utils = require('../utils.js');
+
+const encode = TextEncoderP.TextEncoder.prototype.encode.bind(new TextEncoderP.TextEncoder());
+const decode = TextDecoderP.TextDecoder.prototype.decode.bind(new TextDecoderP.TextDecoder());
+const mp = { ReadableStream: (typeof ReadableStream !== "undefined" && ReadableStream) || undefined };
+function setReadableStreamClass(RSClass) { mp.ReadableStream = RSClass; }
+class BlobP {
+    constructor(blobParts = [], options) {
+        if (!utils.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(chunk)) {
+                size += chunk.size;
+                tasks.push(chunk.arrayBuffer().then(r => new Uint8Array(r)));
+            }
+            else {
+                let bytes = (TextDecoderP.isArrayBuffer(chunk) || ArrayBuffer.isView(chunk))
+                    ? BufferSource_toUint8Array(chunk)
+                    : 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() {
+        let ReadableStreamClass = mp.ReadableStream || (() => { throw new ReferenceError("ReadableStream is not defined"); })();
+        let position = 0;
+        try {
+            return new ReadableStreamClass({
+                type: "bytes",
+                autoAllocateChunkSize: 524288,
+                pull: (function (controller) {
+                    var _a;
+                    let v = (_a = controller.byobRequest) === null || _a === void 0 ? void 0 : _a.view;
+                    let chunk = this.slice(position, (v === null || v === void 0 ? void 0 : v.byteLength) ? (position + v.byteLength) : undefined);
+                    return chunk.arrayBuffer().then((function (buffer) {
+                        var _a;
+                        let uint8array = new Uint8Array(buffer);
+                        let bytesRead = uint8array.byteLength;
+                        position += bytesRead;
+                        v.set(uint8array);
+                        (_a = controller.byobRequest) === null || _a === void 0 ? void 0 : _a.respond(bytesRead);
+                        if (position >= this.size)
+                            controller.close();
+                    }).bind(this));
+                }).bind(this),
+            });
+        }
+        catch (e) {
+            return new ReadableStreamClass({
+                pull: (function (controller) {
+                    let chunk = this.slice(position, position + 524288);
+                    return chunk.arrayBuffer().then((function (buffer) {
+                        position += buffer.byteLength;
+                        let uint8array = new Uint8Array(buffer);
+                        controller.enqueue(uint8array);
+                        if (position == this.size)
+                            controller.close();
+                    }).bind(this));
+                }).bind(this),
+            });
+        }
+    }
+    text() {
+        return state(this).promise.then(r => decode(r));
+    }
+    /** @internal */ toString() { return "[object Blob]"; }
+    /** @internal */ get [utils._Symbol.toStringTag]() { return "Blob"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["Blob"] }; }
+}
+/** @internal */
+class BlobState {
+    constructor(promise) {
+        this.size = 0;
+        this.type = "";
+        this.promise = promise;
+    }
+}
+function state(target) {
+    return target.__Blob__;
+}
+function BufferSource_toUint8Array(buf) {
+    return TextDecoderP.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));
+}
+function isBlob(value, strict = false) {
+    return utils.isPolyfillType("Blob", value, strict) || isExternalBlob(value, strict);
+}
+function isExternalBlob(value, strict = false) {
+    let expects = ["[object Blob]"];
+    if (!strict)
+        expects.push("[object File]");
+    return (expects.indexOf(Object.prototype.toString.call(value)) > -1 || expects.indexOf(String(value)) > -1)
+        && "size" in value
+        && typeof value.size === "number"
+        && "arrayBuffer" in value
+        && typeof value.arrayBuffer === "function";
+}
+const BlobE = (function () { try {
+    return new Blob(['ä']).size === 2;
+}
+catch (e) {
+    return false;
+} })() ? Blob : BlobP;
+
+exports.Blob = BlobE;
+exports.BlobP = BlobP;
+exports.decode = decode;
+exports.encode = encode;
+exports.isBlob = isBlob;
+exports.setReadableStreamClass = setReadableStreamClass;

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

@@ -0,0 +1,53 @@
+'use strict';
+
+var BlobP = require('./BlobP.js');
+var utils = require('../utils.js');
+
+function createFileClass(BlobClass) {
+    class FileClass extends BlobClass {
+        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._Symbol.toStringTag]() { return "File"; }
+    }
+    if (Object.is(BlobClass, BlobP.BlobP)) {
+        Object.defineProperty(FileClass.prototype, "__MPHTTPX__", {
+            configurable: true,
+            get: function () { return { chain: ["File", "Blob"] }; },
+        });
+    }
+    return FileClass;
+}
+/** @internal */
+class FileState {
+    constructor() {
+        this.lastModified = 0;
+        this.name = "";
+    }
+}
+function state(target) {
+    return target.__File__;
+}
+const FilePolyfill = createFileClass(BlobP.BlobP);
+const FileE = (function () { try {
+    new File([], "");
+    return true;
+}
+catch (e) {
+    return false;
+} })()
+    ? File
+    : Object.is(BlobP.Blob, BlobP.BlobP)
+        ? FilePolyfill
+        : createFileClass(BlobP.Blob);
+
+exports.File = FileE;
+exports.FileP = FilePolyfill;