mphttpx 1.2.0-beta.1 → 1.2.0-beta.3

package/dist/esm/URLSearchParamsP.js

@@ -0,0 +1,227 @@
+import { g, isObjectType, isPolyfillType, polyfill, checkArgsLength } from './isPolyfill.js';
+
+var _a;
+/** @internal */ const state = Symbol( /* "URLSearchParamsState" */);
+const checkArgsFn = (args, required, funcName) => { checkArgsLength(args, required, "URLSearchParams", funcName); };
+class URLSearchParamsP {
+    constructor(init) {
+        this[state] = new URLSearchParamsState();
+        if (init !== undefined) {
+            if (isObjectType("URLSearchParams", init) || isPolyfillType("URLSearchParams", init)) {
+                init.forEach((value, name) => { this.append(name, value); }, this);
+            }
+            else if (init && typeof init === "object") {
+                if (Array.isArray(init) || Symbol.iterator in init) {
+                    let _init = Array.isArray(init) ? init : Array.from(init);
+                    for (let i = 0; i < _init.length; ++i) {
+                        let item = _init[i];
+                        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 'URLSearchParams': Sequence initializer must only contain pair elements");
+                            }
+                        }
+                        else {
+                            throw new TypeError("Failed to construct 'URLSearchParams': The provided value cannot be converted to a sequence.");
+                        }
+                    }
+                }
+                else {
+                    Object.getOwnPropertyNames(init).forEach(name => { this.append(name, init[name]); }, this);
+                }
+            }
+            else {
+                let _init = "" + init;
+                if (_init.indexOf("?") === 0) {
+                    _init = _init.slice(1);
+                }
+                let pairs = _init.split("&");
+                for (let i = 0; i < pairs.length; ++i) {
+                    let pair = pairs[i], separatorIndex = pair.indexOf("=");
+                    if (separatorIndex > -1) {
+                        this.append(decode(pair.slice(0, separatorIndex)), decode(pair.slice(separatorIndex + 1)));
+                    }
+                    else {
+                        if (pair) {
+                            this.append(decode(pair), "");
+                        }
+                    }
+                }
+            }
+        }
+    }
+    get size() { return this[state][_urlspArray].length; }
+    append(...args) {
+        const [name, value] = args;
+        checkArgsFn(args, 2, "append");
+        this[state][_urlspArray].push(["" + name, normalizeValue(value)]);
+    }
+    delete(...args) {
+        const [name, value] = args;
+        checkArgsFn(args, 1, "delete");
+        let _name = "" + name;
+        let index = -1;
+        let array = this[state][_urlspArray];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (args.length !== 1 && item[1] !== normalizeValue(value)) {
+                    result.push(item);
+                }
+                index = i;
+                continue;
+            }
+            result.push(item);
+        }
+        if (index > -1) {
+            this[state][_urlspArray] = result;
+        }
+    }
+    get(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "get");
+        let _name = "" + name;
+        let array = this[state][_urlspArray];
+        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][_urlspArray];
+        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, value] = args;
+        checkArgsFn(args, 1, "has");
+        let _name = "" + name;
+        let array = this[state][_urlspArray];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (args.length === 1) {
+                    return true;
+                }
+                else {
+                    if (item[1] === normalizeValue(value)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    set(...args) {
+        const [name, value] = args;
+        checkArgsFn(args, 2, "set");
+        let _name = "" + name;
+        let _value = normalizeValue(value);
+        let index = -1;
+        let array = this[state][_urlspArray];
+        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([_name, _value]);
+                }
+                continue;
+            }
+            result.push(item);
+        }
+        if (index === -1) {
+            result.push([_name, _value]);
+        }
+        this[state][_urlspArray] = result;
+    }
+    sort() {
+        this[state][_urlspArray].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    }
+    forEach(...args) {
+        const [callbackfn, thisArg] = args;
+        checkArgsFn(args, 1, "forEach");
+        if (typeof callbackfn !== "function") {
+            throw new TypeError("Failed to execute 'forEach' on 'URLSearchParams': parameter 1 is not of type 'Function'.");
+        }
+        let array = this[state][_urlspArray];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            callbackfn.call(thisArg, item[1], item[0], this);
+        }
+    }
+    entries() {
+        return this[state][_urlspArray].map(x => [x[0], x[1]]).values();
+    }
+    keys() {
+        return this[state][_urlspArray].map(x => x[0]).values();
+    }
+    values() {
+        return this[state][_urlspArray].map(x => x[1]).values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    toString() {
+        let array = this[state][_urlspArray];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            result.push(encode(item[0]) + "=" + encode(item[1]));
+        }
+        return result.join("&");
+    }
+    /** @internal */ get [Symbol.toStringTag]() { return "URLSearchParams"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
+}
+/** @internal */
+const _urlspArray = Symbol();
+/** @internal */
+class URLSearchParamsState {
+    constructor() {
+        this[_a] = [];
+    }
+}
+_a = _urlspArray;
+function normalizeValue(value) {
+    return typeof value === "string" ? value : (value !== null && value !== undefined && typeof value.toString === "function"
+        ? value.toString()
+        : JSON.stringify(value));
+}
+function encode(str) {
+    const replace = {
+        "!": "%21",
+        "'": "%27",
+        "(": "%28",
+        ")": "%29",
+        "~": "%7E",
+        "%20": "+",
+        "%00": "\x00",
+    };
+    return encodeURIComponent(str).replace(/[!'\(\)~]|%20|%00/g, match => replace[match]);
+}
+function decode(str) {
+    return str
+        .replace(/[ +]/g, "%20")
+        .replace(/(%[a-f0-9]{2})+/ig, match => decodeURIComponent(match));
+}
+const URLSearchParamsE = g["URLSearchParams"] || URLSearchParamsP;
+
+export { URLSearchParamsE as URLSearchParams, URLSearchParamsP };

package/dist/esm/WebSocketP.js

@@ -0,0 +1,234 @@
+import { HeadersP } from './HeadersP.js';
+import { Blob_toUint8Array, BlobP } from './BlobP.js';
+import { CloseEventP } from './CloseEventP.js';
+import { MessageEventP } from './MessageEventP.js';
+import { createInnerEvent, Event_setTrusted } from './EventP.js';
+import { EventTargetP, EventTarget_fire, attachFn, executeFn } from './EventTargetP.js';
+import { mp as mp$1 } from './platform.js';
+import { checkArgsLength, MPException, isArrayBuffer, isPolyfillType, polyfill } from './isPolyfill.js';
+import './TextEncoderP.js';
+import './TextDecoderP.js';
+
+const connectSocket = mp$1 ? mp$1.connectSocket : function errorConnectSocket(options) {
+    return {
+        send(obj) { },
+        close(obj) { },
+        onOpen(listener) { },
+        onMessage(listener) { },
+        onError(listener) {
+            if (typeof listener === "function") {
+                listener({ errMsg: "NOT_SUPPORTED_ERR" });
+            }
+        },
+        onClose(listener) {
+            if (typeof listener === "function") {
+                setTimeout(() => { listener({ code: 3009, reason: "NOT_SUPPORTED_ERR" }); });
+            }
+        },
+    };
+};
+
+var _a, _b;
+const mp = { connectSocket: connectSocket };
+const setConnectSocket = (connectSocket) => { mp.connectSocket = connectSocket; };
+/** @internal */
+const state = Symbol( /* "WebSocketState" */);
+class WebSocketImpl extends EventTargetP {
+    static get CONNECTING() { return 0; }
+    static get OPEN() { return 1; }
+    static get CLOSING() { return 2; }
+    static get CLOSED() { return 3; }
+    constructor(...args) {
+        const [url, protocols] = args;
+        checkArgsLength(args, 1, "WebSocket");
+        super();
+        this[state] = new WebSocketState(this, {
+            url: "" + url,
+            protocols: protocols !== undefined
+                ? (Array.isArray(protocols) || (protocols && typeof protocols === "object" && Symbol.iterator in protocols))
+                    ? Array.isArray(protocols) ? protocols : Array.from(protocols)
+                    : ["" + protocols]
+                : [],
+            multiple: true, // Alipay Mini Program
+            fail(err) { console.error(err); },
+        });
+        let socketTask = this[state][_socketTask];
+        if (socketTask && typeof socketTask === "object") {
+            onOpen(this);
+            onClose(this);
+            onError(this);
+            onMessage(this);
+        }
+        else {
+            throw new Error(`connectSocket can't establish a connection to the server at ${"" + url}.`);
+        }
+    }
+    get CONNECTING() { return 0; }
+    get OPEN() { return 1; }
+    get CLOSING() { return 2; }
+    get CLOSED() { return 3; }
+    get binaryType() { return this[state].binaryType; }
+    set binaryType(value) { if (value === "blob" || value === "arraybuffer") {
+        this[state].binaryType = value;
+    } }
+    get bufferedAmount() { return this[state].bufferedAmount; }
+    get extensions() { return this[state].extensions; }
+    get protocol() { return this[state].protocol; }
+    get readyState() { return this[state].readyState; }
+    get url() { return this[state].url; }
+    close(code, reason) {
+        if (this.readyState === 2 /* CLOSING */ || this.readyState === 3 /* CLOSED */)
+            return;
+        this[state].readyState = 2 /* CLOSING */;
+        this[state][_socketTask].close({
+            code: code,
+            reason: reason,
+            fail(err) { console.error(err); },
+            complete: (function () {
+                this[state].readyState = 3 /* CLOSED */;
+            }).bind(this),
+        });
+    }
+    send(...args) {
+        const [data] = args;
+        checkArgsLength(args, 1, "WebSocket", "send");
+        if (this.readyState === 0 /* CONNECTING */) {
+            throw new MPException("Failed to execute 'send' on 'WebSocket': Still in CONNECTING state.", "InvalidStateError");
+        }
+        if (this.readyState === 2 /* CLOSING */ || this.readyState === 3 /* CLOSED */) {
+            return console.error("WebSocket is already in CLOSING or CLOSED state.");
+        }
+        let _data;
+        if (isArrayBuffer(data)) {
+            _data = data;
+        }
+        else if (ArrayBuffer.isView(data)) {
+            _data = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+        }
+        else if (isPolyfillType("Blob", data)) {
+            _data = Blob_toUint8Array(data).buffer.slice(0);
+        }
+        else {
+            _data = "" + data;
+        }
+        this[state][_socketTask].send({
+            data: _data,
+            fail(err) { console.error(err); },
+        });
+    }
+    get onclose() { return this[state].onclose; }
+    set onclose(value) { this[state].onclose = value; attach(this, "close"); }
+    get onerror() { return this[state].onerror; }
+    set onerror(value) { this[state].onerror = value; attach(this, "error"); }
+    get onmessage() { return this[state].onmessage; }
+    set onmessage(value) { this[state].onmessage = value; attach(this, "message"); }
+    get onopen() { return this[state].onopen; }
+    set onopen(value) { this[state].onopen = value; attach(this, "open"); }
+    /** @internal */ toString() { return "[object WebSocket]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "WebSocket"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["WebSocket", "EventTarget"] }; }
+}
+/** @internal */ const _socketTask = Symbol();
+/** @internal */ const _error = Symbol();
+/** @internal */ const _handlers = Symbol();
+/** @internal */
+class WebSocketState {
+    constructor(target, opts) {
+        this.binaryType = "blob";
+        this.bufferedAmount = 0;
+        this.extensions = "";
+        this.protocol = "";
+        this.readyState = 0;
+        this[_a] = null;
+        this[_b] = getHandlers(this);
+        this.onclose = null;
+        this.onerror = null;
+        this.onmessage = null;
+        this.onopen = null;
+        this.target = target;
+        this.url = opts.url;
+        this[_socketTask] = mp.connectSocket(opts);
+    }
+}
+_a = _error, _b = _handlers;
+function attach(target, type) {
+    const s = target[state];
+    const fnName = ("on" + type);
+    const cb = s[fnName];
+    const listener = s[_handlers][fnName];
+    attachFn(target, type, cb, listener);
+}
+function getHandlers(s) {
+    return {
+        onclose: (ev) => { executeFn(s.target, s.onclose, ev); },
+        onerror: (ev) => { executeFn(s.target, s.onerror, ev); },
+        onmessage: (ev) => { executeFn(s.target, s.onmessage, ev); },
+        onopen: (ev) => { executeFn(s.target, s.onopen, ev); },
+    };
+}
+function onOpen(ws) {
+    let socket = ws;
+    socket[state][_socketTask].onOpen(res => {
+        if ("header" in res && res.header && typeof res.header === "object") {
+            let headers = new HeadersP(res.header);
+            socket[state].protocol = headers.get("Sec-WebSocket-Protocol") || "";
+        }
+        socket[state].readyState = 1 /* OPEN */;
+        EventTarget_fire(socket, createInnerEvent(socket, "open"));
+    });
+}
+function onClose(ws) {
+    let socket = ws;
+    socket[state][_socketTask].onClose(res => {
+        socket[state].readyState = 3 /* CLOSED */;
+        let event = new CloseEventP("close", {
+            wasClean: !socket[state][_error],
+            code: res.code,
+            reason: res.reason,
+        });
+        Event_setTrusted(event, true);
+        EventTarget_fire(socket, event);
+    });
+}
+function onError(ws) {
+    let socket = ws;
+    socket[state][_socketTask].onError(res => {
+        console.error(res);
+        socket[state][_error] = res;
+        socket[state].readyState = 3 /* CLOSED */;
+        EventTarget_fire(socket, createInnerEvent(socket, "error"));
+    });
+}
+function onMessage(ws) {
+    let socket = ws;
+    socket[state][_socketTask].onMessage(res => {
+        let data = res.data;
+        let _data;
+        // Alipay Mini Program
+        if (data && typeof data === "object" && "data" in data) {
+            _data = data.data;
+            if ("isBuffer" in data && data.isBuffer && typeof _data === "string") {
+                // @ts-ignore
+                try {
+                    _data = my.base64ToArrayBuffer(_data);
+                }
+                catch (e) { }
+            }
+        }
+        else {
+            _data = data;
+        }
+        if (isArrayBuffer(_data) && socket.binaryType === "blob") {
+            _data = new BlobP([_data]);
+        }
+        let event = new MessageEventP("message", {
+            data: _data,
+            origin: socket.url,
+        });
+        Event_setTrusted(event, true);
+        EventTarget_fire(socket, event);
+    });
+}
+const WebSocketE = (typeof WebSocket !== "undefined" && WebSocket) || WebSocketImpl;
+
+export { WebSocketE as WebSocket, WebSocketImpl, setConnectSocket };