pxt-core 10.3.2 → 10.3.4

package/built/pxt.js

@@ -120406,50 +120406,51 @@ var pxt;
                 this.handleUSBDisconnected = this.handleUSBDisconnected.bind(this);
             }
             enable() {
+                var _a, _b;
                 if (this.enabled)
                     return;
                 this.enabled = true;
                 this.log("registering webusb events");
-                navigator.usb.addEventListener('disconnect', this.handleUSBDisconnected, false);
-                navigator.usb.addEventListener('connect', this.handleUSBConnected, false);
+                (_a = navigator.usb) === null || _a === void 0 ? void 0 : _a.addEventListener('disconnect', this.handleUSBDisconnected, false);
+                (_b = navigator.usb) === null || _b === void 0 ? void 0 : _b.addEventListener('connect', this.handleUSBConnected, false);
             }
             disable() {
+                var _a, _b;
                 if (!this.enabled)
                     return;
                 this.enabled = false;
                 this.log(`unregistering webusb events`);
-                navigator.usb.removeEventListener('disconnect', this.handleUSBDisconnected);
-                navigator.usb.removeEventListener('connect', this.handleUSBConnected);
+                (_a = navigator.usb) === null || _a === void 0 ? void 0 : _a.removeEventListener('disconnect', this.handleUSBDisconnected);
+                (_b = navigator.usb) === null || _b === void 0 ? void 0 : _b.removeEventListener('connect', this.handleUSBConnected);
             }
-            disposeAsync() {
+            async disposeAsync() {
                 this.disable();
-                return Promise.resolve();
             }
             handleUSBDisconnected(event) {
+                var _a;
                 this.log("device disconnected");
                 if (event.device == this.dev) {
                     this.log("clear device");
                     this.clearDev();
-                    if (this.onDeviceConnectionChanged)
-                        this.onDeviceConnectionChanged(false);
+                    (_a = this.onDeviceConnectionChanged) === null || _a === void 0 ? void 0 : _a.call(this, false);
                 }
             }
             handleUSBConnected(event) {
+                var _a;
                 const newdev = event.device;
                 this.log(`device connected ${newdev.serialNumber}`);
                 if (!this.dev && !this.connecting) {
                     this.log("attach device");
-                    if (this.onDeviceConnectionChanged)
-                        this.onDeviceConnectionChanged(true);
+                    (_a = this.onDeviceConnectionChanged) === null || _a === void 0 ? void 0 : _a.call(this, true);
                 }
             }
             clearDev() {
+                var _a;
                 if (this.dev) {
                     this.dev = null;
                     this.epIn = null;
                     this.epOut = null;
-                    if (this.onConnectionChanged)
-                        this.onConnectionChanged();
+                    (_a = this.onConnectionChanged) === null || _a === void 0 ? void 0 : _a.call(this);
                 }
             }
             error(msg) {
@@ -120458,27 +120459,28 @@ var pxt;
             log(msg) {
                 pxt.debug("webusb: " + msg);
             }
-            disconnectAsync() {
+            async disconnectAsync() {
                 this.ready = false;
                 if (!this.dev)
-                    return Promise.resolve();
+                    return;
                 this.log("close device");
-                return this.dev.close()
-                    .catch(e => {
+                try {
+                    await this.dev.close();
+                }
+                catch (e) {
                     // just ignore errors closing, most likely device just disconnected
-                })
-                    .then(() => {
-                    this.clearDev();
-                    return pxt.U.delay(500);
-                });
+                }
+                this.clearDev();
+                await pxt.U.delay(500);
             }
             async forgetAsync() {
                 var _a;
                 if (!((_a = this.dev) === null || _a === void 0 ? void 0 : _a.forget))
                     return false;
                 try {
+                    const dev = this.dev;
                     await this.disconnectAsync();
-                    await this.dev.forget();
+                    await dev.forget();
                     return true;
                     // connection changed listener will handle disconnecting when access is revoked.
                 }
@@ -120486,19 +120488,23 @@ var pxt;
                     return false;
                 }
             }
-            reconnectAsync() {
+            async reconnectAsync() {
                 this.log("reconnect");
                 this.setConnecting(true);
-                return this.disconnectAsync()
-                    .then(tryGetDevicesAsync)
-                    .then(devs => this.connectAsync(devs))
-                    .finally(() => this.setConnecting(false));
+                try {
+                    await this.disconnectAsync();
+                    const devs = await tryGetDevicesAsync();
+                    await this.connectAsync(devs);
+                }
+                finally {
+                    this.setConnecting(false);
+                }
             }
             setConnecting(v) {
+                var _a;
                 if (v != this.connecting) {
                     this.connecting = v;
-                    if (this.onConnectionChanged)
-                        this.onConnectionChanged();
+                    (_a = this.onConnectionChanged) === null || _a === void 0 ? void 0 : _a.call(this);
                 }
             }
             isConnecting() {
@@ -120558,61 +120564,60 @@ var pxt;
                     this.setConnecting(false);
                 }
             }
-            sendPacketAsync(pkt) {
+            async sendPacketAsync(pkt) {
                 if (!this.dev)
-                    return Promise.reject(new Error("Disconnected"));
+                    throw new Error("Disconnected");
                 pxt.Util.assert(pkt.length <= 64);
                 if (!this.epOut) {
-                    return this.dev.controlTransferOut({
+                    const res = await this.dev.controlTransferOut({
                         requestType: "class",
                         recipient: "interface",
                         request: controlTransferSetReport,
                         value: controlTransferOutReport,
                         index: this.iface.interfaceNumber
-                    }, pkt).then(res => {
-                        if (res.status != "ok")
-                            this.error("USB CTRL OUT transfer failed");
-                    });
+                    }, pkt);
+                    if (res.status != "ok")
+                        this.error("USB CTRL OUT transfer failed");
                 }
-                return this.dev.transferOut(this.epOut.endpointNumber, pkt)
-                    .then(res => {
+                else {
+                    const res = await this.dev.transferOut(this.epOut.endpointNumber, pkt);
                     if (res.status != "ok")
                         this.error("USB OUT transfer failed");
-                });
+                }
             }
-            readLoop() {
+            async readLoop() {
                 if (this.readLoopStarted)
                     return;
                 this.readLoopStarted = true;
                 this.log("start read loop");
-                let loop = () => {
-                    if (!this.ready)
-                        pxt.U.delay(300).then(loop);
-                    else
-                        this.recvPacketAsync()
-                            .then(buf => {
-                            if (buf[0]) {
-                                // we've got data; retry reading immedietly after processing it
-                                this.onData(buf);
-                                loop();
-                            }
-                            else {
-                                // throttle down if no data coming
-                                pxt.U.delay(500).then(loop);
-                            }
-                        }, err => {
-                            if (this.dev)
-                                this.onError(err);
-                            pxt.U.delay(300).then(loop);
-                        });
-                };
-                loop();
+                while (true) {
+                    if (!this.ready) {
+                        await pxt.U.delay(300);
+                        continue;
+                    }
+                    try {
+                        const buf = await this.recvPacketAsync();
+                        if (buf[0]) {
+                            // we've got data; retry reading immedietly after processing it
+                            this.onData(buf);
+                        }
+                        else {
+                            // throttle down if no data coming
+                            await pxt.U.delay(500);
+                        }
+                    }
+                    catch (e) {
+                        if (this.dev)
+                            this.onError(e);
+                        await pxt.U.delay(300);
+                    }
+                }
             }
             async recvPacketAsync(timeoutMs) {
                 const startTime = Date.now();
                 while (!timeoutMs || Date.now() < startTime + timeoutMs) {
                     if (!this.dev) {
-                        return Promise.reject(new Error("Disconnected"));
+                        throw new Error("Disconnected");
                     }
                     const res = await (this.epIn ? this.dev.transferIn(this.epIn.endpointNumber, 64) : this.dev.controlTransferIn({
                         requestType: "class",
@@ -120630,84 +120635,84 @@ var pxt;
                 }
                 this.error("USB IN timed out");
             }
-            initAsync() {
+            async initAsync() {
+                var _a;
                 if (!this.dev)
-                    return Promise.reject(new Error("Disconnected"));
-                let dev = this.dev;
+                    throw new Error("Disconnected");
+                const dev = this.dev;
                 this.log("open device");
-                return dev.open()
-                    // assume one configuration; no one really does more
-                    .then(() => {
-                    this.log("select configuration");
-                    return dev.selectConfiguration(1);
-                })
-                    .then(() => {
-                    let matchesFilters = (iface) => {
-                        let a0 = iface.alternates[0];
-                        for (let f of usb.filters) {
-                            if (f.classCode == null || a0.interfaceClass === f.classCode) {
-                                if (f.subclassCode == null || a0.interfaceSubclass === f.subclassCode) {
-                                    if (f.protocolCode == null || a0.interfaceProtocol === f.protocolCode) {
-                                        if (a0.endpoints.length == 0)
-                                            return true;
-                                        if (a0.endpoints.length == 2 &&
-                                            a0.endpoints.every(e => e.packetSize == 64))
-                                            return true;
-                                    }
+                await dev.open();
+                // assume one configuration; no one really does more
+                this.log("select configuration");
+                await dev.selectConfiguration(1);
+                let matchesFilters = (iface) => {
+                    let a0 = iface.alternates[0];
+                    for (let f of usb.filters) {
+                        if (f.classCode == null || a0.interfaceClass === f.classCode) {
+                            if (f.subclassCode == null || a0.interfaceSubclass === f.subclassCode) {
+                                if (f.protocolCode == null || a0.interfaceProtocol === f.protocolCode) {
+                                    if (a0.endpoints.length == 0)
+                                        return true;
+                                    if (a0.endpoints.length == 2 &&
+                                        a0.endpoints.every(e => e.packetSize == 64))
+                                        return true;
                                 }
                             }
                         }
-                        return false;
-                    };
-                    this.log("got " + dev.configurations[0].interfaces.length + " interfaces");
-                    const matching = dev.configurations[0].interfaces.filter(matchesFilters);
-                    let iface = matching[matching.length - 1];
-                    this.log(`${matching.length} matching interfaces; picking ${iface ? "#" + iface.interfaceNumber : "n/a"}`);
-                    if (!iface)
-                        this.error("cannot find supported USB interface");
-                    this.altIface = iface.alternates[0];
-                    this.iface = iface;
-                    if (this.altIface.endpoints.length) {
-                        this.log("using dedicated endpoints");
-                        this.epIn = this.altIface.endpoints.filter(e => e.direction == "in")[0];
-                        this.epOut = this.altIface.endpoints.filter(e => e.direction == "out")[0];
-                        pxt.Util.assert(this.epIn.packetSize == 64);
-                        pxt.Util.assert(this.epOut.packetSize == 64);
                     }
-                    else {
-                        this.log("using ctrl pipe");
-                    }
-                    this.log("claim interface");
-                    return dev.claimInterface(iface.interfaceNumber);
-                })
-                    .then(() => {
-                    this.log("device ready");
-                    this.lastKnownDeviceSerialNumber = this.dev.serialNumber;
-                    this.ready = true;
-                    if (isHF2)
-                        this.readLoop();
-                    if (this.onConnectionChanged)
-                        this.onConnectionChanged();
-                });
+                    return false;
+                };
+                this.log("got " + dev.configurations[0].interfaces.length + " interfaces");
+                const matching = dev.configurations[0].interfaces.filter(matchesFilters);
+                let iface = matching[matching.length - 1];
+                this.log(`${matching.length} matching interfaces; picking ${iface ? "#" + iface.interfaceNumber : "n/a"}`);
+                if (!iface)
+                    this.error("cannot find supported USB interface");
+                this.altIface = iface.alternates[0];
+                this.iface = iface;
+                if (this.altIface.endpoints.length) {
+                    this.log("using dedicated endpoints");
+                    this.epIn = this.altIface.endpoints.filter(e => e.direction == "in")[0];
+                    this.epOut = this.altIface.endpoints.filter(e => e.direction == "out")[0];
+                    pxt.Util.assert(this.epIn.packetSize == 64);
+                    pxt.Util.assert(this.epOut.packetSize == 64);
+                }
+                else {
+                    this.log("using ctrl pipe");
+                }
+                this.log("claim interface");
+                await dev.claimInterface(iface.interfaceNumber);
+                this.log("device ready");
+                this.lastKnownDeviceSerialNumber = this.dev.serialNumber;
+                this.ready = true;
+                if (isHF2) {
+                    // just starting, not waiting on it.
+                    /* await */ this.readLoop();
+                }
+                (_a = this.onConnectionChanged) === null || _a === void 0 ? void 0 : _a.call(this);
+            }
+        }
+        async function pairAsync() {
+            var _a;
+            try {
+                const dev = await ((_a = navigator.usb) === null || _a === void 0 ? void 0 : _a.requestDevice({
+                    filters: usb.filters
+                }));
+                return !!dev;
             }
-        }
-        function pairAsync() {
-            return navigator.usb.requestDevice({
-                filters: usb.filters
-            })
-                .then(dev => !!dev)
-                .catch(e => {
+            catch (e) {
                 // user cancelled
                 if (e.name == "NotFoundError")
                     return undefined;
                 throw e;
-            });
+            }
         }
         usb.pairAsync = pairAsync;
         async function tryGetDevicesAsync() {
+            var _a;
             pxt.log(`webusb: get devices`);
             try {
-                const devs = await navigator.usb.getDevices();
+                const devs = await ((_a = navigator.usb) === null || _a === void 0 ? void 0 : _a.getDevices());
                 return devs || [];
             }
             catch (e) {

package/built/pxtlib.d.ts

@@ -3308,6 +3308,14 @@ declare namespace pxt.webBluetooth {
     function pairAsync(): Promise<void>;
     function flashAsync(resp: pxtc.CompileResult, d?: pxt.commands.DeployOptions): Promise<void>;
 }
+interface Navigator {
+    readonly usb?: {
+        getDevices(): Promise<pxt.usb.USBDevice[]>;
+        requestDevice(options?: pxt.usb.USBDeviceRequestOptions): Promise<pxt.usb.USBDevice>;
+        addEventListener(type: "connect" | "disconnect", listener: (ev: pxt.usb.USBConnectionEvent) => any, useCapture?: boolean): void;
+        removeEventListener(type: "connect" | "disconnect", callback: (ev: pxt.usb.USBConnectionEvent) => any, useCapture?: boolean): void;
+    };
+}
 declare namespace pxt.usb {
     /**
      * For local testing of WebUSB, be sure to (temporarily)
@@ -3334,6 +3342,13 @@ declare namespace pxt.usb {
         protocolCode?: number;
         serialNumber?: string;
     }
+    interface USBDeviceRequestOptions {
+        filters: USBDeviceFilter[];
+        exclusionFilters?: USBDeviceFilter[] | undefined;
+    }
+    interface USBConnectionEvent extends Event {
+        device: USBDevice;
+    }
     let filters: USBDeviceFilter[];
     function setFilters(f: USBDeviceFilter[]): void;
     type USBEndpointType = "bulk" | "interrupt" | "isochronous";