mphttpx 1.2.0-beta.1 → 1.2.0-beta.2

package/dist/cjs/HeadersP.js

@@ -0,0 +1,176 @@
+'use strict';
+
+var isPolyfill = require('./isPolyfill.js');
+
+var _a, _b;
+/** @internal */ const state = Symbol( /* "HeadersState" */);
+const checkArgsFn = (args, required, funcName) => { isPolyfill.checkArgsLength(args, required, "Headers", funcName); };
+class HeadersP {
+    constructor(init) {
+        this[state] = new HeadersState();
+        if (init !== undefined) {
+            if (isPolyfill.isObjectType("Headers", init) || isPolyfill.isPolyfillType("Headers", init)) {
+                init.forEach((value, name) => { Headers_append(this, name, value); }, this);
+            }
+            else if (Array.isArray(init) || (init && typeof init === "object" && Symbol.iterator in init)) {
+                let _init = Array.isArray(init) ? init : Array.from(init);
+                _init.forEach(item => {
+                    if (Array.isArray(item) || (item && typeof item === "object" && Symbol.iterator in 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 'Headers': Invalid value");
+                        }
+                    }
+                    else {
+                        throw new TypeError("Failed to construct 'Headers': The provided value cannot be converted to a sequence.");
+                    }
+                }, this);
+            }
+            else {
+                if (init && typeof init === "object") {
+                    Object.getOwnPropertyNames(init).forEach(name => { this.append(name, init[name]); }, this);
+                }
+                else {
+                    throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(record<ByteString, ByteString> or sequence<sequence<ByteString>>)'.");
+                }
+            }
+        }
+        this[state][_initialized] = true;
+    }
+    append(...args) {
+        const [name, value] = args;
+        checkArgsFn(args, 2, "append");
+        let _name = normalizeName(name, throwsFn(this[state][_initialized] ? "append" : ""));
+        let _value = normalizeValue(value);
+        Headers_append(this, _name, _value);
+    }
+    delete(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "delete");
+        let _name = normalizeName(name, throwsFn("delete"));
+        delete this[state][_headersDict][_name];
+    }
+    get(...args) {
+        var _c;
+        const [name] = args;
+        checkArgsFn(args, 1, "get");
+        let _name = normalizeName(name, throwsFn("get"));
+        return (_c = this[state][_headersDict][_name]) !== null && _c !== void 0 ? _c : null;
+    }
+    getSetCookie() {
+        let value = this.get("Set-Cookie");
+        return value ? value.split(", ") : [];
+    }
+    has(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "has");
+        let _name = normalizeName(name, throwsFn("has"));
+        return this[state][_headersDict].hasOwnProperty(_name);
+    }
+    set(...args) {
+        const [name, value] = args;
+        checkArgsFn(args, 2, "set");
+        let _name = normalizeName(name, throwsFn("set"));
+        let _value = normalizeValue(value);
+        this[state][_headersDict][_name] = _value;
+    }
+    forEach(...args) {
+        const [callbackfn, thisArg] = args;
+        checkArgsFn(args, 1, "forEach");
+        if (typeof callbackfn !== "function") {
+            throw new TypeError("Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'.");
+        }
+        let names = Object.getOwnPropertyNames(this[state][_headersDict]);
+        for (let i = 0; i < names.length; ++i) {
+            let name = names[i];
+            callbackfn.call(thisArg, this[state][_headersDict][name], name, this);
+        }
+    }
+    entries() {
+        let array = [];
+        this.forEach((value, name) => { array.push([name, value]); });
+        return array.values();
+    }
+    keys() {
+        let array = [];
+        this.forEach((value, name) => { array.push(name); });
+        return array.values();
+    }
+    values() {
+        let array = [];
+        this.forEach((value, name) => { array.push(value); });
+        return array.values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /** @internal */ toString() { return "[object Headers]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Headers"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["Headers"] }; }
+}
+/** @internal */ const _initialized = Symbol();
+/** @internal */ const _headersDict = Symbol();
+/** @internal */
+class HeadersState {
+    constructor() {
+        this[_a] = false;
+        this[_b] = {};
+    }
+}
+_a = _initialized, _b = _headersDict;
+function Headers_append(headers, name, value) {
+    let dict = headers[state][_headersDict];
+    let oldValue = dict[name];
+    dict[name] = oldValue !== undefined ? `${oldValue}, ${value}` : value;
+}
+function throwsFn(kind) {
+    return () => {
+        throw new TypeError(`Failed to ${kind ? ("execute '" + kind + "' on") : "construct"} 'Headers': Invalid name`);
+    };
+}
+/** @internal */
+function normalizeName(name, throwError) {
+    if (typeof name !== "string") {
+        name = "" + name;
+    }
+    if (throwError && (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "")) {
+        throwError();
+    }
+    return name.toLowerCase();
+}
+/** @internal */
+function normalizeValue(value) {
+    return typeof value === "string" ? value : ("" + value);
+}
+/** @internal */
+function parseHeaders(rawHeaders) {
+    let headers = new HeadersP();
+    let preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
+    preProcessedHeaders
+        .split("\r")
+        .map(header => header.indexOf("\n") === 0 ? header.substring(1, header.length) : header)
+        .forEach(line => {
+        let parts = line.split(":");
+        let name = parts.shift().trim();
+        if (name) {
+            let value = parts.join(":").trim();
+            try {
+                headers.append(name, value);
+            }
+            catch (e) {
+                console.warn(`SyntaxError: Response.headers: '${name}' is not a valid HTTP header field name.`);
+            }
+        }
+    });
+    return headers;
+}
+const HeadersE = isPolyfill.g["Headers"] || HeadersP;
+
+exports.Headers = HeadersE;
+exports.HeadersP = HeadersP;
+exports.normalizeName = normalizeName;
+exports.normalizeValue = normalizeValue;
+exports.parseHeaders = parseHeaders;

package/dist/cjs/MessageEventP.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var EventP = require('./EventP.js');
+var isPolyfill = require('./isPolyfill.js');
+
+const dispatched = 1;
+/** @internal */
+const state = Symbol( /* "MessageEventState" */);
+class MessageEventP extends EventP.EventP {
+    constructor(type, eventInitDict) {
+        var _a;
+        super(type, eventInitDict);
+        this[state] = new MessageEventState();
+        const s = this[state];
+        s.data = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.data) !== null && _a !== void 0 ? _a : null;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.origin) !== undefined)
+            s.origin = "" + eventInitDict.origin;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.lastEventId) !== undefined)
+            s.lastEventId = "" + eventInitDict.lastEventId;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.source) !== undefined)
+            s.source = eventInitDict.source;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.ports) !== undefined)
+            s.ports = eventInitDict.ports;
+    }
+    get data() { return this[state].data; }
+    get lastEventId() { return this[state].lastEventId; }
+    get origin() { return this[state].origin; }
+    get ports() { return this[state].ports; }
+    get source() { return this[state].source; }
+    initMessageEvent(...args) {
+        const [type, bubbles, cancelable, data, origin, lastEventId, source, ports] = args;
+        isPolyfill.checkArgsLength(args, 1, "MessageEvent", "initMessageEvent");
+        if (EventP.Event_getEtField(this, dispatched))
+            return;
+        this.initEvent(type, bubbles, cancelable);
+        const s = this[state];
+        s.data = data !== null && data !== void 0 ? data : null;
+        if (origin !== undefined)
+            s.origin = "" + origin;
+        if (lastEventId !== undefined)
+            s.lastEventId = "" + lastEventId;
+        if (source !== undefined)
+            s.source = source;
+        if (ports !== undefined)
+            s.ports = ports;
+    }
+    /** @internal */ toString() { return "[object MessageEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "MessageEvent"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["MessageEvent", "Event"] }; }
+}
+/** @internal */
+class MessageEventState {
+    constructor() {
+        this.data = null;
+        this.lastEventId = "";
+        this.origin = "";
+        this.ports = [];
+        this.source = null;
+    }
+}
+const MessageEventE = isPolyfill.g["EventTarget"] ? isPolyfill.g["MessageEvent"] : MessageEventP;
+
+exports.MessageEvent = MessageEventE;
+exports.MessageEventP = MessageEventP;

package/dist/cjs/ProgressEventP.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var isPolyfill = require('./isPolyfill.js');
+var EventTargetP = require('./EventTargetP.js');
+var EventP = require('./EventP.js');
+
+/** @internal */
+const state = Symbol( /* "ProgressEventState" */);
+class ProgressEventP extends EventP.EventP {
+    constructor(type, eventInitDict) {
+        var _a, _b;
+        super(type, eventInitDict);
+        this[state] = new ProgressEventState();
+        const s = this[state];
+        s.lengthComputable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.lengthComputable);
+        s.loaded = Number((_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.loaded) !== null && _a !== void 0 ? _a : 0);
+        s.total = Number((_b = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.total) !== null && _b !== void 0 ? _b : 0);
+        let errField = "";
+        if (isNaN(s.loaded)) {
+            errField = "loaded";
+        }
+        if (isNaN(s.total)) {
+            errField = "total";
+        }
+        if (errField) {
+            throw new TypeError(`Failed to construct 'ProgressEvent': Failed to read the '${errField}' property from 'ProgressEventInit': The provided double value is non-finite.`);
+        }
+    }
+    get lengthComputable() { return getValue(this[state].lengthComputable); }
+    get loaded() { return getValue(this[state].loaded); }
+    get total() { return getValue(this[state].total); }
+    /** @internal */ toString() { return "[object ProgressEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "ProgressEvent"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["ProgressEvent", "Event"] }; }
+}
+/** @internal */
+class ProgressEventState {
+    constructor() {
+        this.lengthComputable = false;
+        this.loaded = 0;
+        this.total = 0;
+    }
+}
+function getValue(val) {
+    return typeof val === "function" ? val() : val;
+}
+function createInnerProgressEvent(target, type, { lengthComputable = false, loaded = 0, total = 0, } = {}) {
+    let event = new ProgressEventP(type);
+    event[state].lengthComputable = lengthComputable;
+    event[state].loaded = loaded;
+    event[state].total = total;
+    event[EventP.eventState].target = target;
+    EventP.Event_setTrusted(event, true);
+    return event;
+}
+/** @internal */
+function emitProcessEvent(target, type, loaded = 0, total = 0) {
+    let event = createInnerProgressEvent(target, type, {
+        lengthComputable: () => { return getValue(total) > 0; },
+        loaded,
+        total,
+    });
+    EventTargetP.EventTarget_fire(target, event);
+}
+const ProgressEventE = isPolyfill.g["EventTarget"] ? isPolyfill.g["ProgressEvent"] : ProgressEventP;
+
+exports.ProgressEvent = ProgressEventE;
+exports.ProgressEventP = ProgressEventP;
+exports.emitProcessEvent = emitProcessEvent;

package/dist/cjs/RequestP.js

@@ -0,0 +1,158 @@
+'use strict';
+
+var HeadersP = require('./HeadersP.js');
+var AbortControllerP = require('./AbortControllerP.js');
+var isPolyfill = require('./isPolyfill.js');
+var BodyImpl = require('./BodyImpl.js');
+require('./AbortSignalP.js');
+require('./EventP.js');
+require('./EventTargetP.js');
+require('./convertor.js');
+require('./BlobP.js');
+require('./TextEncoderP.js');
+require('./TextDecoderP.js');
+require('./FormDataP.js');
+require('./FileP.js');
+
+/** @internal */ const state = Symbol( /* "RequestState" */);
+class RequestP extends BodyImpl.BodyImpl {
+    constructor(...args) {
+        const [input, init] = args;
+        isPolyfill.checkArgsLength(args, 1, "Request");
+        super();
+        this[BodyImpl.bodyState].name = "Request";
+        this[state] = new RequestState();
+        const s = this[state];
+        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;
+        if (isPolyfill.isPolyfillType("Request", 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) {
+                s.headers = new HeadersP.HeadersP(input.headers);
+            }
+            s.method = input.method;
+            s.mode = input.mode;
+            let inputSignal = input[state].signal;
+            if (inputSignal) {
+                s.signal = inputSignal;
+            }
+            s.url = input.url;
+            let payload = BodyImpl.Body_toPayload(input);
+            if (!body && payload !== "") {
+                body = payload;
+                input[BodyImpl.bodyState].bodyUsed = true;
+            }
+        }
+        else {
+            s.url = "" + input;
+        }
+        if (_init.cache) {
+            s.cache = _init.cache;
+        }
+        if (_init.credentials) {
+            s.credentials = _init.credentials;
+        }
+        if (_init.headers) {
+            s.headers = new HeadersP.HeadersP(_init.headers);
+        }
+        if (_init.method) {
+            s.method = normalizeMethod(_init.method);
+        }
+        if (_init.mode) {
+            s.mode = _init.mode;
+        }
+        if (_init.signal) {
+            s.signal = _init.signal;
+        }
+        if ((this.method === "GET" || this.method === "HEAD") && body) {
+            throw new TypeError("Failed to construct 'Request': Request with GET/HEAD method cannot have body.");
+        }
+        BodyImpl.Body_init(this, body);
+        if (this.method === "GET" || this.method === "HEAD") {
+            if (_init.cache === "no-store" || _init.cache === "no-cache") {
+                // Search for a '_' parameter in the query string
+                let reParamSearch = /([?&])_=[^&]*/;
+                if (reParamSearch.test(this.url)) {
+                    // If it already exists then set the value with the current time
+                    s.url = this.url.replace(reParamSearch, "$1_=" + (new Date()).getTime());
+                }
+                else {
+                    // Otherwise add a new '_' parameter to the end with the current time
+                    let reQueryString = /\?/;
+                    s.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (new Date()).getTime();
+                }
+            }
+        }
+    }
+    get cache() { return this[state].cache; }
+    get credentials() { return this[state].credentials; }
+    get destination() { return this[state].destination; }
+    get headers() {
+        const s = this[state];
+        if (!s.headers) {
+            s.headers = new HeadersP.HeadersP();
+        }
+        return s.headers;
+    }
+    get integrity() { return this[state].integrity; }
+    get keepalive() { return this[state].keepalive; }
+    get method() { return this[state].method; }
+    get mode() { return this[state].mode; }
+    get redirect() { return this[state].redirect; }
+    get referrer() { return this[state].referrer; }
+    get referrerPolicy() { return this[state].referrerPolicy; }
+    get signal() {
+        const s = this[state];
+        if (!s.signal) {
+            s.signal = (new AbortControllerP.AbortControllerP()).signal;
+        }
+        return s.signal;
+    }
+    get url() { return this[state].url; }
+    clone() {
+        var _a;
+        if (this.bodyUsed) {
+            throw new TypeError("Failed to execute 'clone' on 'Request': Request body is already used");
+        }
+        return new RequestP(this, { body: (_a = BodyImpl.Body_toPayload(this)) !== null && _a !== void 0 ? _a : null });
+    }
+    /** @internal */ toString() { return "[object Request]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Request"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["Request"] }; }
+}
+/** @internal */
+class RequestState {
+    constructor() {
+        this.cache = "default";
+        this.credentials = "same-origin";
+        this.destination = "";
+        this.integrity = "";
+        this.keepalive = false;
+        this.method = "GET";
+        this.mode = "cors";
+        this.redirect = "follow";
+        this.referrer = "about:client";
+        this.referrerPolicy = "";
+        this.url = "";
+    }
+}
+// HTTP methods whose capitalization should be normalized
+const methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
+/** @internal */
+function normalizeMethod(method) {
+    let upcased = method.toUpperCase();
+    return methods.indexOf(upcased) > -1 ? upcased : method;
+}
+const RequestE = isPolyfill.g["Request"] || RequestP;
+
+exports.Request = RequestE;
+exports.RequestP = RequestP;
+exports.normalizeMethod = normalizeMethod;
+exports.requestState = state;

package/dist/cjs/ResponseP.js

@@ -0,0 +1,102 @@
+'use strict';
+
+var HeadersP = require('./HeadersP.js');
+var isPolyfill = require('./isPolyfill.js');
+var BodyImpl = require('./BodyImpl.js');
+require('./convertor.js');
+require('./BlobP.js');
+require('./TextEncoderP.js');
+require('./TextDecoderP.js');
+require('./FormDataP.js');
+require('./FileP.js');
+
+/** @internal */ const state = Symbol( /* "ResponseState" */);
+class ResponseP extends BodyImpl.BodyImpl {
+    constructor(body, init) {
+        super();
+        this[BodyImpl.bodyState].name = "Response";
+        this[state] = new ResponseState();
+        const s = this[state];
+        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'.");
+        }
+        let status = _init.status === undefined ? 200 : _init.status;
+        if (status < 200 || status > 500) {
+            throw new RangeError(`Failed to construct 'Response': The status provided (${+status}) is outside the range [200, 599].`);
+        }
+        if (_init.headers) {
+            s.headers = new HeadersP.HeadersP(_init.headers);
+        }
+        s.ok = status >= 200 && status < 300;
+        s.status = status;
+        s.statusText = _init.statusText === undefined ? "" : "" + _init.statusText;
+        BodyImpl.Body_init(this, body);
+    }
+    get headers() {
+        const s = this[state];
+        if (!s.headers) {
+            s.headers = new HeadersP.HeadersP();
+        }
+        return s.headers;
+    }
+    get ok() { return this[state].ok; }
+    get redirected() { return this[state].redirected; }
+    get status() { return this[state].status; }
+    get statusText() { return this[state].statusText; }
+    get type() { return this[state].type; }
+    get url() { return this[state].url; }
+    clone() {
+        if (this.bodyUsed) {
+            throw new TypeError("Failed to execute 'clone' on 'Response': Response body is already used");
+        }
+        let response = new ResponseP(BodyImpl.Body_toPayload(this), {
+            headers: new HeadersP.HeadersP(this.headers),
+            status: this.status,
+            statusText: this.statusText,
+        });
+        response[state].url = this.url;
+        return response;
+    }
+    static json(...args) {
+        const [data, init] = args;
+        isPolyfill.checkArgsLength(args, 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: "" });
+        response[state].ok = false;
+        response[state].status = 0;
+        response[state].type = "error";
+        return response;
+    }
+    static redirect(...args) {
+        const [url, status = 301] = args;
+        isPolyfill.checkArgsLength(args, 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 } });
+    }
+    /** @internal */ toString() { return "[object Response]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Response"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["Response"] }; }
+}
+/** @internal */
+class ResponseState {
+    constructor() {
+        this.ok = true;
+        this.redirected = false;
+        this.status = 200;
+        this.statusText = "";
+        this.type = "default";
+        this.url = "";
+    }
+}
+const ResponseE = isPolyfill.g["Response"] || ResponseP;
+
+exports.Response = ResponseE;
+exports.ResponseP = ResponseP;
+exports.responseState = state;