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

package/dist/esm/BodyImpl.js

@@ -0,0 +1,137 @@
+import { polyfill, isObjectType } from './isPolyfill.js';
+import { convert, convertBack } from './convertor.js';
+import { createFormDataFromBinaryText } from './FormDataP.js';
+import './BlobP.js';
+import './TextEncoderP.js';
+import './TextDecoderP.js';
+import './FileP.js';
+
+var _a;
+/** @internal */ const state = Symbol( /* "BodyState" */);
+class BodyImpl {
+    /** @internal */
+    constructor() {
+        if (new.target === BodyImpl) {
+            throw new TypeError("Failed to construct 'Body': Illegal constructor");
+        }
+        this[state] = new BodyState();
+    }
+    get body() {
+        if (!this[state][_body]) {
+            return null;
+        }
+        throw new TypeError(`Failed to access 'body' on '${this[state].name}': property not implemented.`);
+    }
+    get bodyUsed() { return this[state].bodyUsed; }
+    ;
+    arrayBuffer() {
+        const kind = "arrayBuffer";
+        return consumed(this, kind) || read(this, kind);
+    }
+    blob() {
+        const kind = "blob";
+        return consumed(this, kind) || read(this, kind);
+    }
+    bytes() {
+        const kind = "bytes";
+        return consumed(this, kind) || read(this, kind);
+    }
+    formData() {
+        const kind = "formData";
+        return consumed(this, kind) || read(this, kind);
+    }
+    json() {
+        const kind = "json";
+        return consumed(this, kind) || read(this, kind);
+    }
+    text() {
+        const kind = "text";
+        return consumed(this, kind) || read(this, kind);
+    }
+    /** @internal */ toString() { return "[object Body]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Body"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Body"] }; }
+}
+/** @internal */
+const _body = Symbol();
+/** @internal */
+class BodyState {
+    constructor() {
+        this.name = "Body";
+        this.bodyUsed = false;
+        this[_a] = "";
+    }
+}
+_a = _body;
+/** @internal */
+function Body_init(body, payload) {
+    const b = body;
+    if (isObjectType("ReadableStream", payload)) {
+        throw new TypeError(`Failed to construct '${b[state].name}': ReadableStream not implemented.`);
+    }
+    b[state][_body] = convert(payload, true, type => { if (!b.headers.has("Content-Type")) {
+        b.headers.set("Content-Type", type);
+    } });
+}
+/** @internal */
+function Body_toPayload(body) {
+    return body[state][_body];
+}
+function read(body, kind) {
+    return new Promise((resolve, reject) => {
+        try {
+            resolve(readSync(body, kind));
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+function readSync(body, kind) {
+    const payload = body[state][_body];
+    if (kind === "arrayBuffer") {
+        return convertBack("arraybuffer", payload);
+    }
+    else if (kind === "blob") {
+        return convertBack("blob", payload);
+    }
+    else if (kind === "bytes") {
+        let arrayBuffer = convertBack("arraybuffer", payload);
+        return new Uint8Array(arrayBuffer);
+    }
+    else if (kind === "formData") {
+        const 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, "");
+            }
+        };
+        let text = convertBack("text", payload);
+        let boundary = extractBoundary(body.headers.get("Content-Type")) || "";
+        return createFormDataFromBinaryText(text, boundary);
+    }
+    else if (kind === "json") {
+        return convertBack("json", payload);
+    }
+    else {
+        return convertBack("text", payload);
+    }
+}
+function consumed(body, kind) {
+    const s = body[state];
+    if (!s[_body])
+        return;
+    if (s.bodyUsed) {
+        return Promise.reject(new TypeError(`Failed to execute '${kind}' on '${s.name}': body stream already read`));
+    }
+    s.bodyUsed = true;
+}
+
+export { BodyImpl, Body_init, Body_toPayload, state as bodyState };

package/dist/esm/CloseEventP.js

@@ -0,0 +1,35 @@
+import { EventP } from './EventP.js';
+import { g, polyfill } from './isPolyfill.js';
+
+/** @internal */
+const state = Symbol( /* "CloseEventState" */);
+class CloseEventP extends EventP {
+    constructor(type, eventInitDict) {
+        var _a;
+        super(type, eventInitDict);
+        this[state] = new CloseEventState();
+        const s = this[state];
+        let _code = Number((_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.code) !== null && _a !== void 0 ? _a : 0);
+        s.code = isNaN(_code) ? 0 : _code;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.reason) !== undefined)
+            s.reason = "" + eventInitDict.reason;
+        s.wasClean = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.wasClean);
+    }
+    get code() { return this[state].code; }
+    get reason() { return this[state].reason; }
+    get wasClean() { return this[state].wasClean; }
+    /** @internal */ toString() { return "[object CloseEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "CloseEvent"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["CloseEvent", "Event"] }; }
+}
+/** @internal */
+class CloseEventState {
+    constructor() {
+        this.code = 0;
+        this.reason = "";
+        this.wasClean = false;
+    }
+}
+const CloseEventE = g["EventTarget"] ? g["CloseEvent"] : CloseEventP;
+
+export { CloseEventE as CloseEvent, CloseEventP };

package/dist/esm/CustomEventP.js

@@ -0,0 +1,32 @@
+import { EventP, Event_getEtField } from './EventP.js';
+import { g, checkArgsLength, polyfill } from './isPolyfill.js';
+
+const dispatched = 1;
+/** @internal */
+const state = Symbol( /* "CustomEventState" */);
+class CustomEventP extends EventP {
+    constructor(type, eventInitDict) {
+        var _a;
+        super(type, eventInitDict);
+        this[state] = new CustomEventState();
+        this[state].detail = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.detail) !== null && _a !== void 0 ? _a : null;
+    }
+    get detail() { return this[state].detail; }
+    initCustomEvent(...args) {
+        const [type, bubbles, cancelable, detail] = args;
+        checkArgsLength(args, 1, "CustomEvent", "initCustomEvent");
+        if (Event_getEtField(this, dispatched))
+            return;
+        this.initEvent(type, bubbles, cancelable);
+        this[state].detail = detail !== null && detail !== void 0 ? detail : null;
+    }
+    /** @internal */ toString() { return "[object CustomEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "CustomEvent"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["CustomEvent", "Event"] }; }
+}
+/** @internal */
+class CustomEventState {
+}
+const CustomEventE = g["EventTarget"] ? g["CustomEvent"] : CustomEventP;
+
+export { CustomEventE as CustomEvent, CustomEventP };

package/dist/esm/EventP.js

@@ -0,0 +1,165 @@
+import { g, checkArgsLength, polyfill } from './isPolyfill.js';
+
+var _a, _b, _c, _d, _e;
+/** @internal */ const state = Symbol( /* "EventState" */);
+class EventP {
+    static get NONE() { return 0; }
+    static get CAPTURING_PHASE() { return 1; }
+    static get AT_TARGET() { return 2; }
+    static get BUBBLING_PHASE() { return 3; }
+    constructor(...args) {
+        const [type, eventInitDict] = args;
+        checkArgsLength(args, 1, new.target.name);
+        this[state] = new EventState();
+        const s = this[state];
+        s.type = "" + type;
+        s.bubbles = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.bubbles);
+        s.cancelable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.cancelable);
+        s.composed = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.composed);
+        Object.defineProperty(this, "isTrusted", {
+            enumerable: true,
+            get: (function isTrusted() { return this[state][_isTrusted]; }).bind(this),
+        });
+    }
+    get type() { return this[state].type; }
+    get bubbles() { return this[state].bubbles; }
+    get cancelable() { return this[state].cancelable; }
+    get composed() { return this[state].composed; }
+    get target() { return this[state].target; }
+    get currentTarget() { return this[state].currentTarget; }
+    get eventPhase() { return this[state].eventPhase; }
+    get NONE() { return 0; }
+    get CAPTURING_PHASE() { return 1; }
+    get AT_TARGET() { return 2; }
+    get BUBBLING_PHASE() { return 3; }
+    get srcElement() { return this[state].target; }
+    get cancelBubble() { return this[state].cancelBubble; }
+    set cancelBubble(value) { this[state].cancelBubble = !!value; }
+    get defaultPrevented() { return this[state].defaultPrevented; }
+    get returnValue() { return this[state].returnValue; }
+    set returnValue(value) { if (!value) {
+        this.preventDefault();
+    } }
+    get timeStamp() { return this[state].timeStamp; }
+    composedPath() {
+        let path = !!this.target ? [this.target] : [];
+        if (!!this.currentTarget && this.currentTarget !== this.target)
+            path.push(this.currentTarget);
+        return path;
+    }
+    initEvent(...args) {
+        const [type, bubbles, cancelable] = args;
+        checkArgsLength(args, 1, "Event", "initEvent");
+        const s = this[state];
+        if (s[_dispatched])
+            return;
+        s.type = "" + type;
+        s.bubbles = !!bubbles;
+        s.cancelable = !!cancelable;
+    }
+    preventDefault() {
+        const s = this[state];
+        if (s[_passive]) {
+            console.warn(`Ignoring 'preventDefault()' call on event of type '${this.type}' from a listener registered as 'passive'.`);
+            return;
+        }
+        if (this.cancelable) {
+            s[_preventDefaultCalled] = true;
+            s.defaultPrevented = true;
+            s.returnValue = false;
+        }
+    }
+    stopImmediatePropagation() {
+        this[state][_stopImmediatePropagationCalled] = true;
+        this.cancelBubble = true;
+    }
+    stopPropagation() {
+        this.cancelBubble = true;
+    }
+    /** @internal */ toString() { return "[object Event]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Event"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Event"] }; }
+}
+/** @internal */ const _timeStamp = (new Date()).getTime();
+/** @internal */ const _isTrusted = Symbol();
+/** @internal */ const _passive = Symbol();
+/** @internal */ const _dispatched = Symbol();
+/** @internal */ const _preventDefaultCalled = Symbol();
+/** @internal */ const _stopImmediatePropagationCalled = Symbol();
+/** @internal */
+class EventState {
+    constructor() {
+        this.type = "";
+        this.bubbles = false;
+        this.cancelable = false;
+        this.composed = false;
+        this.target = null;
+        this.currentTarget = null;
+        this.eventPhase = 0 /* NONE */;
+        this.cancelBubble = false;
+        this.defaultPrevented = false;
+        this.returnValue = true;
+        this.timeStamp = (new Date()).getTime() - _timeStamp;
+        this[_a] = false;
+        this[_b] = false;
+        this[_c] = false;
+        this[_d] = false;
+        this[_e] = false;
+    }
+}
+_a = _isTrusted, _b = _passive, _c = _dispatched, _d = _preventDefaultCalled, _e = _stopImmediatePropagationCalled;
+/** @internal */
+function Event_setTrusted(event, isTrusted) {
+    Object.defineProperty(event[state], _isTrusted, {
+        value: isTrusted,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+}
+const passive = 0;
+const dispatched = 1;
+const preventDefaultCalled = 2;
+const stopImmediatePropagationCalled = 3;
+/** @internal */
+function Event_getEtField(event, field) {
+    const s = event[state];
+    switch (field) {
+        case passive:
+            return s[_passive];
+        case dispatched:
+            return s[_dispatched];
+        case preventDefaultCalled:
+            return s[_preventDefaultCalled];
+        case stopImmediatePropagationCalled:
+            return s[_stopImmediatePropagationCalled];
+    }
+}
+/** @internal */
+function Event_setEtField(event, field, value) {
+    const s = event[state];
+    switch (field) {
+        case passive:
+            s[_passive] = value;
+            break;
+        case dispatched:
+            s[_dispatched] = value;
+            break;
+        case preventDefaultCalled:
+            s[_preventDefaultCalled] = value;
+            break;
+        case stopImmediatePropagationCalled:
+            s[_stopImmediatePropagationCalled] = value;
+            break;
+    }
+}
+/** @internal */
+function createInnerEvent(target, type, eventInitDict, isTrusted = true) {
+    let event = new EventP(type, eventInitDict);
+    event[state].target = target;
+    event[state][_isTrusted] = isTrusted;
+    return event;
+}
+const EventE = g["EventTarget"] ? g["Event"] : EventP;
+
+export { EventE as Event, EventP, Event_getEtField, Event_setEtField, Event_setTrusted, createInnerEvent, state as eventState };

package/dist/esm/EventTargetP.js

@@ -0,0 +1,168 @@
+import { EventP, Event_setTrusted, eventState as state$1, Event_setEtField, Event_getEtField } from './EventP.js';
+import { g, checkArgsLength, isPolyfillType, polyfill } from './isPolyfill.js';
+
+var _a;
+const passive = 0;
+const dispatched = 1;
+const preventDefaultCalled = 2;
+const stopImmediatePropagationCalled = 3;
+/** @internal */ const state = Symbol( /* "EventTargetState" */);
+class EventTargetP {
+    constructor() {
+        this[state] = new EventTargetState(this);
+        this[state].name = new.target.name;
+    }
+    addEventListener(...args) {
+        const [type, callback, options] = args;
+        checkArgsLength(args, 2, this[state].name, "addEventListener");
+        if (typeof callback !== "function" && typeof callback !== "object" && typeof callback !== "undefined") {
+            throw new TypeError(`Failed to execute 'addEventListener' on '${this[state].name}': parameter 2 is not of type 'Object'.`);
+        }
+        const s = this[state];
+        const executor = new Executor(type, callback);
+        executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
+        if (!s[_executors].some(x => x.equals(executor))) {
+            if (options && typeof options === "object") {
+                const { once, passive, signal } = options;
+                executor.options.once = !!once;
+                executor.options.passive = !!passive;
+                if (signal && isPolyfillType("EventTarget", signal)) {
+                    executor.options.signal = signal;
+                    reply(this, signal, executor);
+                }
+            }
+            s[_executors].push(executor);
+            const f = (v) => !!v.options.capture ? 0 : 1;
+            s[_executors] = s[_executors].sort((a, b) => f(a) - f(b));
+        }
+    }
+    dispatchEvent(...args) {
+        const [event] = args;
+        checkArgsLength(args, 1, this[state].name, "dispatchEvent");
+        if (!(event instanceof EventP)) {
+            throw new TypeError(`Failed to execute 'dispatchEvent' on '${this[state].name}': parameter 1 is not of type 'Event'.`);
+        }
+        Event_setTrusted(event, false);
+        event[state$1].target = this;
+        return EventTarget_fire(this, event);
+    }
+    removeEventListener(...args) {
+        const [type, callback, options] = args;
+        checkArgsLength(args, 2, this[state].name, "removeEventListener");
+        if (typeof callback !== "function" && typeof callback !== "object" && typeof callback !== "undefined") {
+            throw new TypeError(`Failed to execute 'removeEventListener' on '${this[state].name}': parameter 2 is not of type 'Object'.`);
+        }
+        const s = this[state];
+        const executor = new Executor(type, callback);
+        executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
+        if (s[_executors].some(x => x.equals(executor))) {
+            s[_executors] = s[_executors].filter(x => !x.equals(executor));
+        }
+    }
+    /** @internal */ toString() { return "[object EventTarget]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "EventTarget"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["EventTarget"] }; }
+}
+/** @internal */
+const _executors = Symbol();
+/** @internal */
+class EventTargetState {
+    constructor(target) {
+        this.name = "EventTarget";
+        this[_a] = [];
+        this.target = target;
+    }
+}
+_a = _executors;
+/** @internal */
+function EventTarget_fire(target, event) {
+    const s = target[state];
+    const evs = event[state$1];
+    if (!event.target)
+        evs.target = target;
+    evs.currentTarget = target;
+    evs.eventPhase = 2 /* AT_TARGET */;
+    Event_setEtField(event, dispatched, true);
+    let onceIndexes = [];
+    for (let i = 0; i < s[_executors].length; ++i) {
+        if (Event_getEtField(event, stopImmediatePropagationCalled))
+            break;
+        let executor = s[_executors][i];
+        if (executor.type !== event.type)
+            continue;
+        if (executor.options.once)
+            onceIndexes.push(i);
+        Event_setEtField(event, passive, !!executor.options.passive);
+        try {
+            let cb = executor.callback;
+            if (typeof cb === "function")
+                cb.call(target, event);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        Event_setEtField(event, passive, false);
+    }
+    if (onceIndexes.length > 0) {
+        s[_executors] = s[_executors].reduce((acc, cur, index) => {
+            if (onceIndexes.indexOf(index) === -1)
+                acc.push(cur);
+            return acc;
+        }, []);
+    }
+    evs.currentTarget = null;
+    evs.eventPhase = 0 /* NONE */;
+    Event_setEtField(event, dispatched, false);
+    return !(event.cancelable && Event_getEtField(event, preventDefaultCalled));
+}
+function reply(target, signal, executor) {
+    const s = target[state];
+    const onAbort = () => {
+        s[_executors] = s[_executors].filter(x => !x.equals(executor));
+        signal.removeEventListener("abort", onAbort);
+    };
+    signal.addEventListener("abort", onAbort);
+}
+/** @internal */
+class Executor {
+    constructor(type, callback) {
+        this.options = {};
+        this.type = "" + type;
+        this.callback = extract(callback);
+    }
+    equals(executor) {
+        return Object.is(this.type, executor.type) && Object.is(this.callback, executor.callback)
+            && Object.is(this.options.capture, executor.options.capture);
+    }
+}
+function extract(cb) {
+    if (typeof cb === "function") {
+        return cb;
+    }
+    else if (isEventListenerObject(cb)) {
+        return cb.handleEvent;
+    }
+    else {
+        return cb;
+    }
+}
+function isEventListenerObject(cb) {
+    return !!cb && typeof cb === "object" && "handleEvent" in cb && typeof cb.handleEvent === "function";
+}
+/** @internal */
+function attachFn(target, type, cb, listener) {
+    if (typeof cb === "function") {
+        target.addEventListener(type, listener);
+    }
+    else {
+        target.removeEventListener(type, listener);
+    }
+}
+/** @internal */
+function executeFn(target, cb, ev) {
+    if (typeof cb === "function")
+        cb.call(target, ev);
+}
+const EventTargetE = g["EventTarget"] || EventTargetP;
+
+export { EventTargetE as EventTarget, EventTargetP, EventTargetState, EventTarget_fire, attachFn, state as eventTargetState, executeFn };

package/dist/esm/FileP.js

@@ -0,0 +1,33 @@
+import { BlobP } from './BlobP.js';
+import { g, checkArgsLength, polyfill } from './isPolyfill.js';
+import './TextEncoderP.js';
+import './TextDecoderP.js';
+
+/** @internal */
+const state = Symbol( /* "FileState" */);
+class FileP extends BlobP {
+    constructor(...args) {
+        const [fileBits, fileName, options] = args;
+        checkArgsLength(args, 2, "File");
+        super(fileBits, options);
+        this[state] = new FileState();
+        this[state].lastModified = +((options === null || options === void 0 ? void 0 : options.lastModified) ? new Date(options.lastModified) : new Date()) || 0;
+        this[state].name = "" + fileName;
+    }
+    get lastModified() { return this[state].lastModified; }
+    get name() { return this[state].name; }
+    get webkitRelativePath() { return ""; }
+    /** @internal */ toString() { return "[object File]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "File"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["File", "Blob"] }; }
+}
+/** @internal */
+class FileState {
+    constructor() {
+        this.lastModified = 0;
+        this.name = "";
+    }
+}
+const FileE = g["Blob"] ? g["File"] : FileP;
+
+export { FileE as File, FileP };