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

package/dist/cjs/EventTargetP.js

@@ -0,0 +1,176 @@
+'use strict';
+
+var EventP = require('./EventP.js');
+var isPolyfill = require('./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;
+        isPolyfill.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 && isPolyfill.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;
+        isPolyfill.checkArgsLength(args, 1, this[state].name, "dispatchEvent");
+        if (!(event instanceof EventP.EventP)) {
+            throw new TypeError(`Failed to execute 'dispatchEvent' on '${this[state].name}': parameter 1 is not of type 'Event'.`);
+        }
+        EventP.Event_setTrusted(event, false);
+        event[EventP.eventState].target = this;
+        return EventTarget_fire(this, event);
+    }
+    removeEventListener(...args) {
+        const [type, callback, options] = args;
+        isPolyfill.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: isPolyfill.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[EventP.eventState];
+    if (!event.target)
+        evs.target = target;
+    evs.currentTarget = target;
+    evs.eventPhase = 2 /* AT_TARGET */;
+    EventP.Event_setEtField(event, dispatched, true);
+    let onceIndexes = [];
+    for (let i = 0; i < s[_executors].length; ++i) {
+        if (EventP.Event_getEtField(event, stopImmediatePropagationCalled))
+            break;
+        let executor = s[_executors][i];
+        if (executor.type !== event.type)
+            continue;
+        if (executor.options.once)
+            onceIndexes.push(i);
+        EventP.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);
+        }
+        EventP.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 */;
+    EventP.Event_setEtField(event, dispatched, false);
+    return !(event.cancelable && EventP.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 = isPolyfill.g["EventTarget"] || EventTargetP;
+
+exports.EventTarget = EventTargetE;
+exports.EventTargetP = EventTargetP;
+exports.EventTargetState = EventTargetState;
+exports.EventTarget_fire = EventTarget_fire;
+exports.attachFn = attachFn;
+exports.eventTargetState = state;
+exports.executeFn = executeFn;

package/dist/cjs/FileP.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var BlobP = require('./BlobP.js');
+var isPolyfill = require('./isPolyfill.js');
+require('./TextEncoderP.js');
+require('./TextDecoderP.js');
+
+/** @internal */
+const state = Symbol( /* "FileState" */);
+class FileP extends BlobP.BlobP {
+    constructor(...args) {
+        const [fileBits, fileName, options] = args;
+        isPolyfill.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: isPolyfill.polyfill, hierarchy: ["File", "Blob"] }; }
+}
+/** @internal */
+class FileState {
+    constructor() {
+        this.lastModified = 0;
+        this.name = "";
+    }
+}
+const FileE = isPolyfill.g["Blob"] ? isPolyfill.g["File"] : FileP;
+
+exports.File = FileE;
+exports.FileP = FileP;

package/dist/cjs/FileReaderP.js

@@ -0,0 +1,151 @@
+'use strict';
+
+var EventTargetP = require('./EventTargetP.js');
+var ProgressEventP = require('./ProgressEventP.js');
+var BlobP = require('./BlobP.js');
+var isPolyfill = require('./isPolyfill.js');
+require('./EventP.js');
+require('./TextEncoderP.js');
+require('./TextDecoderP.js');
+
+var _a;
+/** @internal */
+const state = Symbol( /* "FileReaderState" */);
+class FileReaderP extends EventTargetP.EventTargetP {
+    static get EMPTY() { return 0; }
+    static get LOADING() { return 1; }
+    static get DONE() { return 2; }
+    constructor() {
+        super();
+        this[state] = new FileReaderState(this);
+    }
+    get readyState() { return this[state].readyState; }
+    get result() { return this[state].result; }
+    get EMPTY() { return 0; }
+    get LOADING() { return 1; }
+    get DONE() { return 2; }
+    get error() { return this[state].error; }
+    abort() {
+        if (this.readyState === 1 /* LOADING */) {
+            const s = this[state];
+            s.readyState = 2 /* DONE */;
+            s.result = null;
+            s.error = new isPolyfill.MPException("An ongoing operation was aborted, typically with a call to abort().", "AbortError");
+            ProgressEventP.emitProcessEvent(this, "abort");
+        }
+    }
+    readAsArrayBuffer(...args) {
+        read(this, "readAsArrayBuffer", args, blob => {
+            this[state].result = BlobP.Blob_toUint8Array(blob).buffer.slice(0);
+        });
+    }
+    readAsBinaryString(...args) {
+        read(this, "readAsBinaryString", args, blob => {
+            let str = [];
+            let buf = BlobP.Blob_toUint8Array(blob);
+            for (let i = 0; i < buf.length; ++i) {
+                let char = buf[i];
+                str.push(String.fromCharCode(char));
+            }
+            this[state].result = str.join("");
+        });
+    }
+    readAsDataURL(...args) {
+        read(this, "readAsDataURL", args, blob => {
+            this[state].result = "data:" + (blob.type || "application/octet-stream") + ";base64," + BlobP.Uint8Array_toBase64(BlobP.Blob_toUint8Array(blob));
+        });
+    }
+    readAsText(...args) {
+        const encoding = args.length > 1 ? args[1] : undefined;
+        read(this, "readAsText", args, blob => {
+            if (encoding !== undefined) {
+                let _encoding = "" + encoding;
+                if (["utf-8", "utf8", "unicode-1-1-utf-8"].indexOf(_encoding.toLowerCase()) === -1) {
+                    console.error(`TypeError: Failed to execute 'readAsText' on 'FileReader': encoding ('${_encoding}') not implemented.`);
+                }
+            }
+            this[state].result = BlobP.decode(BlobP.Blob_toUint8Array(blob));
+        });
+    }
+    get onabort() { return this[state].onabort; }
+    set onabort(value) { this[state].onabort = value; attach(this, "abort"); }
+    get onerror() { return this[state].onerror; }
+    set onerror(value) { this[state].onerror = value; attach(this, "error"); }
+    get onload() { return this[state].onload; }
+    set onload(value) { this[state].onload = value; attach(this, "load"); }
+    get onloadend() { return this[state].onloadend; }
+    set onloadend(value) { this[state].onloadend = value; attach(this, "loadend"); }
+    get onloadstart() { return this[state].onloadstart; }
+    set onloadstart(value) { this[state].onloadstart = value; attach(this, "loadstart"); }
+    get onprogress() { return this[state].onprogress; }
+    set onprogress(value) { this[state].onprogress = value; attach(this, "progress"); }
+    /** @internal */ toString() { return "[object FileReader]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "FileReader"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["FileReader", "EventTarget"] }; }
+}
+/** @internal */
+const _handlers = Symbol();
+/** @internal */
+class FileReaderState {
+    constructor(target) {
+        this.readyState = 0 /* EMPTY */;
+        this.result = null;
+        this.error = null;
+        this[_a] = getHandlers(this);
+        this.onabort = null;
+        this.onerror = null;
+        this.onload = null;
+        this.onloadend = null;
+        this.onloadstart = null;
+        this.onprogress = null;
+        this.target = target;
+    }
+}
+_a = _handlers;
+function read(reader, kind, args, setResult) {
+    const [blob] = args;
+    isPolyfill.checkArgsLength(args, 1, "FileReader", kind);
+    if (!isPolyfill.isPolyfillType("Blob", blob)) {
+        throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.");
+    }
+    const s = reader[state];
+    s.error = null;
+    s.readyState = 1 /* LOADING */;
+    ProgressEventP.emitProcessEvent(s.target, "loadstart", 0, blob.size);
+    setTimeout(() => {
+        if (s.readyState === 1 /* LOADING */) {
+            s.readyState = 2 /* DONE */;
+            try {
+                setResult(blob);
+                ProgressEventP.emitProcessEvent(s.target, "load", blob.size, blob.size);
+            }
+            catch (e) {
+                s.result = null;
+                s.error = e;
+                ProgressEventP.emitProcessEvent(s.target, "error", 0, blob.size);
+            }
+        }
+        ProgressEventP.emitProcessEvent(s.target, "loadend", !!s.result ? blob.size : 0, blob.size);
+    });
+}
+function attach(reader, type) {
+    const s = reader[state];
+    const fnName = ("on" + type);
+    const cb = s[fnName];
+    const listener = s[_handlers][fnName];
+    EventTargetP.attachFn(reader, type, cb, listener);
+}
+function getHandlers(s) {
+    return {
+        onabort: (ev) => { EventTargetP.executeFn(s.target, s.onabort, ev); },
+        onerror: (ev) => { EventTargetP.executeFn(s.target, s.onerror, ev); },
+        onload: (ev) => { EventTargetP.executeFn(s.target, s.onload, ev); },
+        onloadend: (ev) => { EventTargetP.executeFn(s.target, s.onloadend, ev); },
+        onloadstart: (ev) => { EventTargetP.executeFn(s.target, s.onloadstart, ev); },
+        onprogress: (ev) => { EventTargetP.executeFn(s.target, s.onprogress, ev); },
+    };
+}
+const FileReaderE = isPolyfill.g["Blob"] ? isPolyfill.g["FileReader"] : FileReaderP;
+
+exports.FileReader = FileReaderE;
+exports.FileReaderP = FileReaderP;

package/dist/cjs/FormDataP.js

@@ -0,0 +1,250 @@
+'use strict';
+
+var BlobP = require('./BlobP.js');
+var FileP = require('./FileP.js');
+var isPolyfill = require('./isPolyfill.js');
+require('./TextEncoderP.js');
+require('./TextDecoderP.js');
+
+var _a;
+/** @internal */ const state = Symbol( /* "FormDataState" */);
+const checkArgsFn = (args, required, funcName) => { isPolyfill.checkArgsLength(args, required, "FormData", funcName); };
+class FormDataP {
+    constructor(form, submitter) {
+        if (submitter === undefined) {
+            if (form !== undefined) {
+                console.error("TypeError: Failed to construct 'FormData': parameter 1 not implemented.");
+            }
+        }
+        else {
+            if (submitter !== null) {
+                console.error("TypeError: Failed to construct 'FormData': parameter 1 and parameter 2 not implemented.");
+            }
+        }
+        this[state] = new FormDataState();
+    }
+    append(...args) {
+        const [name, value, filename] = args;
+        checkArgsFn(args, 2, "append");
+        this[state][_formData].push(normalizeArgs(name, value, filename));
+    }
+    delete(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "delete");
+        let _name = "" + name;
+        let index = -1;
+        let array = this[state][_formData];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                index = i;
+                continue;
+            }
+            result.push(item);
+        }
+        if (index > -1) {
+            this[state][_formData] = result;
+        }
+    }
+    get(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "get");
+        let _name = "" + name;
+        let array = this[state][_formData];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                return item[1];
+            }
+        }
+        return null;
+    }
+    getAll(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "getAll");
+        let _name = "" + name;
+        let array = this[state][_formData];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                result.push(item[1]);
+            }
+        }
+        return result;
+    }
+    has(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "has");
+        let _name = "" + name;
+        let array = this[state][_formData];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                return true;
+            }
+        }
+        return false;
+    }
+    set(...args) {
+        const [name, value, filename] = args;
+        checkArgsFn(args, 2, "set");
+        let _name = "" + name;
+        let _args = normalizeArgs(name, value, filename);
+        let index = -1;
+        let array = this[state][_formData];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (index === -1) {
+                    index = i;
+                    result.push(_args);
+                }
+                continue;
+            }
+            result.push(item);
+        }
+        if (index === -1) {
+            result.push(_args);
+        }
+        this[state][_formData] = result;
+    }
+    forEach(...args) {
+        const [callbackfn, thisArg] = args;
+        checkArgsFn(args, 1, "forEach");
+        if (typeof callbackfn !== "function") {
+            throw new TypeError("Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'.");
+        }
+        let array = this[state][_formData];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            callbackfn.call(thisArg, item[1], item[0], thisArg);
+        }
+    }
+    entries() {
+        return this[state][_formData].map(x => [x[0], x[1]]).values();
+    }
+    keys() {
+        return this[state][_formData].map(x => x[0]).values();
+    }
+    values() {
+        return this[state][_formData].map(x => x[1]).values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /** @internal */ toString() { return "[object FormData]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "FormData"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["FormData"] }; }
+}
+/** @internal */
+const _formData = Symbol();
+/** @internal */
+class FormDataState {
+    constructor() {
+        this[_a] = [];
+    }
+}
+_a = _formData;
+/** @internal */
+function FormData_toBlob(formData) {
+    const boundary = "----formdata-mphttpx-" + Math.random();
+    const p = `--${boundary}\r\nContent-Disposition: form-data; name="`;
+    let chunks = [];
+    for (let i = 0; i < formData[state][_formData].length; ++i) {
+        let pair = formData[state][_formData][i];
+        let name = pair[0];
+        let value = pair[1];
+        if (typeof value === "string") {
+            chunks.push(p + escape(normalizeLinefeeds(name)) + `"\r\n\r\n${normalizeLinefeeds(value)}\r\n`);
+        }
+        else {
+            chunks.push(p + escape(normalizeLinefeeds(name)) + `"; filename="${escape(value.name)}"\r\nContent-Type: ${value.type || "application/octet-stream"}\r\n\r\n`, value, `\r\n`);
+        }
+    }
+    chunks.push(`--${boundary}--`);
+    return new BlobP.BlobP(chunks, { type: "multipart/form-data; boundary=" + boundary });
+}
+function normalizeArgs(name, value, filename) {
+    if (isPolyfill.isPolyfillType("Blob", value)) {
+        filename = filename !== undefined
+            ? ("" + filename)
+            : typeof value.name === "string"
+                ? value.name
+                : "blob";
+        if (value.name !== filename || isPolyfill.isObjectType("Blob", value) || isPolyfill.isPolyfillType("Blob", value, true)) {
+            value = new FileP.FileP([value], filename);
+        }
+        return ["" + name, value];
+    }
+    return ["" + name, "" + value];
+}
+// normalize line feeds for textarea
+// https://html.spec.whatwg.org/multipage/form-elements.html#textarea-line-break-normalisation-transformation
+function normalizeLinefeeds(value) {
+    return value.replace(/\r?\n|\r/g, "\r\n");
+}
+function escape(str) {
+    return str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22');
+}
+/** @internal */
+function createFormDataFromBinaryText(text, boundary) {
+    const throwParseError = () => {
+        throw new TypeError("Could not parse content as FormData.");
+    };
+    if (typeof text !== "string" || text.trim() === "") {
+        throwParseError();
+    }
+    let firstLineEnd = text.indexOf("\r\n");
+    if (firstLineEnd === -1) {
+        throwParseError();
+    }
+    let _boundary = text.substring(2, firstLineEnd).trim();
+    if (!_boundary) {
+        throwParseError();
+    }
+    if (boundary !== undefined && boundary !== _boundary) {
+        throwParseError();
+    }
+    let parts = text.split(`--${_boundary}`).filter(part => {
+        let trimmed = part.trim();
+        return trimmed !== "" && trimmed !== "--";
+    });
+    if (parts.length === 0) {
+        throwParseError();
+    }
+    let formData = new FormDataP();
+    parts.forEach(part => {
+        let separatorIndex = part.indexOf("\r\n\r\n");
+        if (separatorIndex === -1) {
+            throwParseError();
+        }
+        let headerRaw = part.substring(0, separatorIndex).trim();
+        let nameMatch = headerRaw.match(/name="([^"]*)"/);
+        if (!nameMatch || nameMatch.length < 2) {
+            throwParseError();
+        }
+        let fieldName = nameMatch[1];
+        let filenameMatch = headerRaw.match(/filename="([^"]*)"/);
+        let contentRaw = part.substring(separatorIndex + 4);
+        if (!filenameMatch) {
+            formData.append(fieldName, contentRaw.replace(/^[\r\n]+|[\r\n]+$/g, ""));
+        }
+        else {
+            let filename = filenameMatch[1] || "";
+            let contentTypeMatch = headerRaw.match(/Content-Type: ([^\r\n]+)/);
+            let mimeType = contentTypeMatch ? (contentTypeMatch[1] || "").trim() : "text/plain";
+            let content = contentRaw.replace(/\r\n/g, "");
+            formData.append(fieldName, new FileP.FileP([content], filename, { type: mimeType }));
+        }
+    });
+    return formData;
+}
+const FormDataE = isPolyfill.g["FormData"] || FormDataP;
+
+exports.FormData = FormDataE;
+exports.FormDataP = FormDataP;
+exports.FormData_toBlob = FormData_toBlob;
+exports.createFormDataFromBinaryText = createFormDataFromBinaryText;