mphttpx 1.1.0 → 1.2.0-beta.2

package/dist/cjs/WebSocketP.js

@@ -0,0 +1,238 @@
+'use strict';
+
+var HeadersP = require('./HeadersP.js');
+var BlobP = require('./BlobP.js');
+var CloseEventP = require('./CloseEventP.js');
+var MessageEventP = require('./MessageEventP.js');
+var EventP = require('./EventP.js');
+var EventTargetP = require('./EventTargetP.js');
+var platform = require('./platform.js');
+var isPolyfill = require('./isPolyfill.js');
+require('./TextEncoderP.js');
+require('./TextDecoderP.js');
+
+const connectSocket = platform.mp ? platform.mp.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.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;
+        isPolyfill.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;
+        isPolyfill.checkArgsLength(args, 1, "WebSocket", "send");
+        if (this.readyState === 0 /* CONNECTING */) {
+            throw new isPolyfill.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 (isPolyfill.isArrayBuffer(data)) {
+            _data = data;
+        }
+        else if (ArrayBuffer.isView(data)) {
+            _data = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+        }
+        else if (isPolyfill.isPolyfillType("Blob", data)) {
+            _data = BlobP.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: isPolyfill.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];
+    EventTargetP.attachFn(target, type, cb, listener);
+}
+function getHandlers(s) {
+    return {
+        onclose: (ev) => { EventTargetP.executeFn(s.target, s.onclose, ev); },
+        onerror: (ev) => { EventTargetP.executeFn(s.target, s.onerror, ev); },
+        onmessage: (ev) => { EventTargetP.executeFn(s.target, s.onmessage, ev); },
+        onopen: (ev) => { EventTargetP.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.HeadersP(res.header);
+            socket[state].protocol = headers.get("Sec-WebSocket-Protocol") || "";
+        }
+        socket[state].readyState = 1 /* OPEN */;
+        EventTargetP.EventTarget_fire(socket, EventP.createInnerEvent(socket, "open"));
+    });
+}
+function onClose(ws) {
+    let socket = ws;
+    socket[state][_socketTask].onClose(res => {
+        socket[state].readyState = 3 /* CLOSED */;
+        let event = new CloseEventP.CloseEventP("close", {
+            wasClean: !socket[state][_error],
+            code: res.code,
+            reason: res.reason,
+        });
+        EventP.Event_setTrusted(event, true);
+        EventTargetP.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 */;
+        EventTargetP.EventTarget_fire(socket, EventP.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 (isPolyfill.isArrayBuffer(_data) && socket.binaryType === "blob") {
+            _data = new BlobP.BlobP([_data]);
+        }
+        let event = new MessageEventP.MessageEventP("message", {
+            data: _data,
+            origin: socket.url,
+        });
+        EventP.Event_setTrusted(event, true);
+        EventTargetP.EventTarget_fire(socket, event);
+    });
+}
+const WebSocketE = (typeof WebSocket !== "undefined" && WebSocket) || WebSocketImpl;
+
+exports.WebSocket = WebSocketE;
+exports.WebSocketImpl = WebSocketImpl;
+exports.setConnectSocket = setConnectSocket;