mphttpx 2.1.2 → 2.1.5-beta.1

package/dist/cjs/file-system/FileReaderP.js

@@ -22,12 +22,8 @@ class FileReaderP extends EventTargetP.EventTargetP {
     get readyState() { return state(this).readyState; }
     get result() { return state(this).result; }
     abort() {
-        switch (state(this).pos) {
-            case 2 /* FRCycle.START */:
-            case 4 /* FRCycle.READING */:
-                execAbort(this);
-                break;
-        }
+        if (state(this).pos === 2 /* FRCycle.LOADING */)
+            execAbort(this);
     }
     readAsArrayBuffer(blob) {
         check(this, "readAsArrayBuffer", arguments.length, blob);
@@ -79,7 +75,7 @@ class FileReaderP extends EventTargetP.EventTargetP {
 /** @internal */
 class FileReaderState {
     constructor(target) {
-        this.pos = 1 /* FRCycle.IDLE */;
+        this.pos = 0 /* FRCycle.EMPTY */;
         this.readyState = 0 /* EMPTY */;
         this.result = null;
         this.error = null;
@@ -112,63 +108,64 @@ function check(reader, kind, actual, blob) {
     if (reader.readyState === 1 /* LOADING */)
         throw new utils.DOMExceptionP(`Failed to execute '${kind}' on 'FileReader': The object is already busy reading Blobs.`, "InvalidStateError");
 }
-function read(reader, size, start) {
-    execStart(reader, size, start);
-}
-function execStart(reader, size, start) {
-    state(reader).pos = 2 /* FRCycle.START */;
-    state(reader).error = null;
-    state(reader).result = null;
-    state(reader).readyState = 1 /* LOADING */;
-    Promise.resolve().then(() => execLoadstart(reader, size, start));
+function read(reader, size, launch) {
+    execLoadstart(reader, size, launch);
 }
-function execLoadstart(reader, size, start) {
-    if (state(reader).pos !== 2 /* FRCycle.START */)
-        return;
-    state(reader).pos = 3 /* FRCycle.LOADSTART */;
-    execReading(reader, size, start);
-    emitProgressEvent.emitProgressEvent(reader, "loadstart", 0, size);
+function execLoadstart(reader, size, launch) {
+    let s = state(reader);
+    s.pos = 1 /* FRCycle.LOADSTART */;
+    s.error = null;
+    s.result = null;
+    const callback = () => { emitProgressEvent.emitProgressEvent(reader, "loadstart", 0, size); return launch(); };
+    return execLoading(reader, size, callback);
 }
-function execReading(reader, size, start) {
-    state(reader).pos = 4 /* FRCycle.READING */;
-    start()
-        .then(r => execLoad(reader, size, r))
-        .catch(err => execError(reader, err));
+function execLoading(reader, size, launch) {
+    let s = state(reader);
+    s.pos = 2 /* FRCycle.LOADING */;
+    s.readyState = 1 /* LOADING */;
+    return Promise.resolve().then(() => {
+        if (s.pos !== 2 /* FRCycle.LOADING */)
+            return;
+        return launch().then(r => execDone(reader, size, r)).catch(err => execError(reader, err));
+    });
 }
-function execLoad(reader, size, result) {
-    if (state(reader).pos !== 4 /* FRCycle.READING */)
+function execDone(reader, size, result) {
+    let s = state(reader);
+    if (s.pos !== 2 /* FRCycle.LOADING */)
         return;
-    state(reader).pos = 5 /* FRCycle.LOAD */;
-    state(reader).result = result;
-    state(reader).readyState = 2 /* DONE */;
+    s.pos = 3 /* FRCycle.DONE */;
+    s.result = result;
+    s.readyState = 2; /* DONE */
+    execLoad(reader, size);
+}
+function execLoad(reader, size) {
+    state(reader).pos = 4 /* FRCycle.LOAD */;
     emitProgressEvent.emitProgressEvent(reader, "load", size, size);
     execLoadend(reader, size);
 }
 function execAbort(reader) {
-    state(reader).pos = 6 /* FRCycle.ABORT */;
-    state(reader).error = new utils.DOMExceptionP("An ongoing operation was aborted, typically with a call to abort().", "AbortError");
-    state(reader).result = null;
-    state(reader).readyState = 2 /* DONE */;
+    let s = state(reader);
+    s.pos = 5 /* FRCycle.ABORT */;
+    s.error = new utils.DOMExceptionP("An ongoing operation was aborted, typically with a call to abort().", "AbortError");
+    s.result = null;
+    s.readyState = 2 /* DONE */;
     emitProgressEvent.emitProgressEvent(reader, "abort");
     execLoadend(reader);
 }
 function execError(reader, err) {
-    if (state(reader).pos !== 4 /* FRCycle.READING */)
+    let s = state(reader);
+    if (s.pos !== 2 /* FRCycle.LOADING */)
         return;
-    state(reader).pos = 7 /* FRCycle.ERROR */;
-    state(reader).error = err;
-    state(reader).result = null;
-    state(reader).readyState = 2 /* DONE */;
+    s.pos = 6 /* FRCycle.ERROR */;
+    s.error = err;
+    s.result = null;
+    s.readyState = 2 /* DONE */;
     emitProgressEvent.emitProgressEvent(reader, "error");
     execLoadend(reader);
 }
 function execLoadend(reader, size = 0) {
-    state(reader).pos = 8 /* FRCycle.LOADEND */;
+    state(reader).pos = 7 /* FRCycle.LOADEND */;
     emitProgressEvent.emitProgressEvent(reader, "loadend", size, size);
-    execEnd(reader);
-}
-function execEnd(reader) {
-    state(reader).pos = 9 /* FRCycle.END */;
 }
 const FileReaderE = (typeof FileReader !== "undefined" && FileReader) || FileReaderP;
 

package/dist/cjs/helpers/handlers.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var EventTargetP = require('../event-system/EventTargetP.js');
+
 /** @internal */
 function attachFn(target, handlers) {
     return function attach(type) {
@@ -7,8 +9,8 @@ function attachFn(target, handlers) {
         const callback = target[fnName];
         const listener = handlers[fnName];
         typeof callback === "function"
-            ? target.addEventListener(type, listener)
-            : target.removeEventListener(type, listener);
+            ? EventTargetP.EventTargetP.prototype.addEventListener.call(target, type, listener)
+            : EventTargetP.EventTargetP.prototype.removeEventListener.call(target, type, listener);
     };
 }
 /** @internal */

package/dist/cjs/mini-program/WebSocketImpl.js

@@ -11,8 +11,8 @@ var EventP = require('../event-system/EventP.js');
 var EventTargetP = require('../event-system/EventTargetP.js');
 var isSequence = require('../helpers/isSequence.js');
 var isArrayBuffer = require('../helpers/isArrayBuffer.js');
-var utils = require('../utils.js');
 var connectSocket = require('./connectSocket.js');
+var utils = require('../utils.js');
 
 const mp = { connectSocket: connectSocket.getConnectSocket() };
 function setConnectSocket(connectSocket) { mp.connectSocket = connectSocket; }
@@ -24,8 +24,9 @@ class WebSocketImpl extends EventTargetP.EventTargetP {
     constructor(url, protocols) {
         utils.checkArgsLength(arguments.length, 1, "WebSocket");
         super();
-        utils.setState(this, "__WebSocket__", new WebSocketState(this, {
-            url: "" + url,
+        const targetURL = "" + url;
+        const socketTask = mp.connectSocket({
+            url: targetURL,
             protocols: protocols !== undefined
                 ? isSequence.isSequence(protocols)
                     ? Array.isArray(protocols) ? protocols : Array.from(protocols)
@@ -33,8 +34,9 @@ class WebSocketImpl extends EventTargetP.EventTargetP {
                 : [],
             multiple: true, // Alipay Mini Program
             fail(err) { console.error(err); },
-        }));
-        let socketTask = state(this).socketTask;
+        });
+        utils.setState(this, "__WebSocket__", new WebSocketState(this, socketTask));
+        state(this).url = targetURL;
         if (socketTask && typeof socketTask === "object") {
             onOpen(this);
             onClose(this);
@@ -54,21 +56,20 @@ class WebSocketImpl extends EventTargetP.EventTargetP {
         state(this).binaryType = value;
     } }
     get bufferedAmount() { return state(this).bufferedAmount; }
-    get extensions() { return state(this).extensions; }
+    get extensions() { return ""; }
     get protocol() { return state(this).protocol; }
     get readyState() { return state(this).readyState; }
     get url() { return state(this).url; }
     close(code, reason) {
+        let s = state(this);
         if (this.readyState === 2 /* CLOSING */ || this.readyState === 3 /* CLOSED */)
             return;
-        state(this).readyState = 2 /* CLOSING */;
-        state(this).socketTask.close({
+        s.readyState = 2 /* CLOSING */;
+        s.socketTask.close({
             code: code,
             reason: reason,
             fail(err) { console.error(err); },
-            complete: (function () {
-                state(this).readyState = 3 /* CLOSED */;
-            }).bind(this),
+            complete: () => { s.readyState = 3 /* CLOSED */; },
         });
     }
     send(data) {
@@ -101,20 +102,18 @@ class WebSocketImpl extends EventTargetP.EventTargetP {
 }
 /** @internal */
 class WebSocketState {
-    constructor(target, opts) {
+    constructor(target, socketTask) {
         this.binaryType = "blob";
         this.bufferedAmount = 0;
-        this.extensions = "";
         this.protocol = "";
         this.readyState = 0;
+        this.url = "";
         this.error = null;
         this.onclose = null;
         this.onerror = null;
         this.onmessage = null;
         this.onopen = null;
-        this.target = target;
-        this.url = opts.url;
-        this.socketTask = mp.connectSocket(opts);
+        this.socketTask = socketTask;
         this.attach = handlers.attachFn(target, getHandlers(target));
     }
 }
@@ -130,20 +129,22 @@ function state(target) {
     return target.__WebSocket__;
 }
 function onOpen(socket) {
-    state(socket).socketTask.onOpen(res => {
+    let s = state(socket);
+    s.socketTask.onOpen(res => {
         if ("header" in res && res.header && typeof res.header === "object") {
             let headers = new HeadersP.HeadersP(res.header);
-            state(socket).protocol = headers.get("Sec-WebSocket-Protocol") || "";
+            s.protocol = headers.get("Sec-WebSocket-Protocol") || "";
         }
-        state(socket).readyState = 1 /* OPEN */;
+        s.readyState = 1 /* OPEN */;
         emitEvent.emitEvent(socket, "open");
     });
 }
 function onClose(socket) {
-    state(socket).socketTask.onClose(res => {
-        state(socket).readyState = 3 /* CLOSED */;
+    let s = state(socket);
+    s.socketTask.onClose(res => {
+        s.readyState = 3 /* CLOSED */;
         let event = new CloseEventP.CloseEventP("close", {
-            wasClean: !state(socket).error,
+            wasClean: !s.error,
             code: res.code,
             reason: res.reason,
         });
@@ -152,10 +153,11 @@ function onClose(socket) {
     });
 }
 function onError(socket) {
-    state(socket).socketTask.onError(res => {
+    let s = state(socket);
+    s.socketTask.onError(res => {
         console.error(res);
-        state(socket).error = res;
-        state(socket).readyState = 3 /* CLOSED */;
+        s.error = res;
+        s.readyState = 3 /* CLOSED */;
         emitEvent.emitEvent(socket, "error");
     });
 }