pxt-microbit 4.1.4 → 4.1.8

package/built/common-sim.d.ts

@@ -1075,8 +1075,8 @@ declare namespace pxsim.visuals {
     }
 }
 declare namespace pxsim.settings {
-    function _set(key: string, buf: RefBuffer): 0 | -1;
-    function _remove(key: string): 0 | -1;
+    function _set(key: string, buf: RefBuffer): -1 | 0;
+    function _remove(key: string): -1 | 0;
     function _exists(key: string): boolean;
     function _get(key: string): RefBuffer;
     function _userClean(): void;
@@ -1179,3 +1179,52 @@ declare namespace pxsim.TouchButtonMethods {
 declare namespace pxsim.AnalogInOutPinMethods {
     function touchButton(name: pins.AnalogInOutPin): TouchButton;
 }
+declare namespace pxsim {
+    interface WifiSocketBoard extends CommonBoard {
+        wifiSocketState: WifiSocketState;
+    }
+    class WifiSocket {
+        private fd;
+        ws: WebSocket;
+        _err: number;
+        buffers: Uint8Array[];
+        readers: (() => void)[];
+        bytesAvail: number;
+        reqInit: RequestInit;
+        reqUrl: string;
+        reqSent: boolean;
+        constructor(fd: number);
+        openReq(host: string, port: number): Promise<number>;
+        _queue(data: string | Uint8Array | ArrayBuffer): void;
+        openWS(url: string, proto: string[]): Promise<number>;
+        waitRead(): Promise<void>;
+        read(maxlen: number): number | RefBuffer;
+        private handleFetch;
+        write(buf: RefBuffer): Promise<number>;
+        close(): void;
+    }
+    class WifiSocketState {
+        sockets: WifiSocket[];
+    }
+}
+declare namespace pxsim._wifi {
+    type int32 = number;
+    export function _allowed(): boolean;
+    export function socketAlloc(): int32;
+    export function socketConnectTLS(fd: int32, host: string, port: int32): Promise<int32>;
+    export function socketWrite(fd: int32, data: RefBuffer): Promise<int32>;
+    export function socketRead(fd: int32, size: int32): Promise<number | RefBuffer>;
+    export function socketBytesAvailable(fd: int32): int32;
+    export function socketClose(fd: int32): int32;
+    export function eventID(): int32;
+    export function scanStart(): void;
+    export function scanResults(): RefBuffer;
+    export function connect(ssid: string, pass: string): int32;
+    export function disconnect(): int32;
+    export function isConnected(): boolean;
+    export function _raiseEvent(id: number): void;
+    export {};
+}
+declare namespace pxsim.crypto {
+    function _sha256(bufs: RefCollection): Promise<RefBuffer>;
+}

package/built/common-sim.js

@@ -604,22 +604,20 @@ var pxsim;
         }
         control.profilingEnabled = profilingEnabled;
         function __log(priority, str) {
-            let prefix = "";
             switch (priority) {
                 case 0:
-                    prefix = "d>";
+                    console.debug("d>" + str);
                     break;
                 case 1:
-                    prefix = "l>";
+                    console.log("l>" + str);
                     break;
                 case 2:
-                    prefix = "w>";
+                    console.warn("w>" + str);
                     break;
                 case 3:
-                    prefix = "e>";
+                    console.error("e>" + str);
                     break;
             }
-            console.log(prefix + str);
             pxsim.runtime.board.writeSerial(str);
         }
         control.__log = __log;
@@ -4689,3 +4687,295 @@ var pxsim;
         AnalogInOutPinMethods.touchButton = touchButton;
     })(AnalogInOutPinMethods = pxsim.AnalogInOutPinMethods || (pxsim.AnalogInOutPinMethods = {}));
 })(pxsim || (pxsim = {}));
+var pxsim;
+(function (pxsim) {
+    class WifiSocket {
+        constructor(fd) {
+            this.fd = fd;
+            this.buffers = [];
+            this.readers = [];
+            this.bytesAvail = 0;
+            this.reqInit = {
+                headers: {},
+                credentials: "omit",
+                mode: "cors",
+                cache: "no-cache",
+                redirect: "manual",
+                referrer: "",
+            };
+            this.reqSent = false;
+        }
+        async openReq(host, port) {
+            if (!/^[\w\-\.]+$/.test(host))
+                throw new Error("bad host");
+            this.reqUrl = "https://" + host + ":" + port + "/";
+            return 0;
+        }
+        _queue(data) {
+            let buf;
+            if (data instanceof ArrayBuffer)
+                buf = new Uint8Array(data);
+            else if (data instanceof Uint8Array)
+                buf = data;
+            else
+                buf = pxsim.U.stringToUint8Array(pxsim.U.toUTF8(data));
+            this.buffers.push(buf);
+            if (buf.length && this.bytesAvail == 0)
+                pxsim._wifi._raiseEvent(1000 + this.fd);
+            this.bytesAvail += buf.length;
+            const rr = this.readers;
+            this.readers = [];
+            for (const r of rr)
+                r();
+        }
+        openWS(url, proto) {
+            this.ws = new WebSocket(url, proto);
+            this.ws.binaryType = "arraybuffer";
+            return new Promise((resolve) => {
+                this.ws.onopen = () => {
+                    this.ws.onerror = err => {
+                        console.log("ws error", err);
+                        this._err = -2;
+                    };
+                    resolve(0);
+                };
+                this.ws.onclose = () => {
+                    console.log("ws close");
+                    this._err = -20;
+                };
+                this.ws.onmessage = ev => {
+                    this._queue(ev.data);
+                };
+                this.ws.onerror = () => resolve(-1);
+            });
+        }
+        waitRead() {
+            return new Promise(resolve => {
+                this.readers.push(resolve);
+            });
+        }
+        read(maxlen) {
+            if (this._err)
+                return this._err;
+            let b = this.buffers[0];
+            if (b) {
+                if (b.length <= maxlen) {
+                    this.buffers.shift();
+                }
+                else {
+                    this.buffers[0] = b.slice(maxlen);
+                    b = b.slice(0, maxlen);
+                }
+                this.bytesAvail -= b.length;
+                return new pxsim.RefBuffer(b);
+            }
+            return null;
+        }
+        async handleFetch() {
+            // we ignore post for now
+            this.reqSent = true;
+            const resp = await fetch(this.reqUrl, this.reqInit);
+            this._queue(`HTTP/1.1 ${resp.status} ${resp.statusText}\r\n`);
+            resp.headers.forEach((v, k) => {
+                if (k.toLowerCase() == "content-length")
+                    return;
+                this._queue(`${k}: ${v}\r\n`);
+            });
+            const data = await resp.arrayBuffer();
+            this._queue(`Content-Length: ${data.byteLength}\r\n`);
+            this._queue(`\r\n`);
+            this._queue(data);
+            return 0;
+        }
+        async write(buf) {
+            if (this._err)
+                return this._err;
+            if (this.ws)
+                this.ws.send(buf.data);
+            else {
+                if (this.reqSent)
+                    return -2;
+                let str = pxsim.U.fromUTF8(pxsim.U.uint8ArrayToString(buf.data));
+                if (str == "\r\n") {
+                    const dummy = this.handleFetch();
+                    return 0;
+                }
+                str = str.replace(/\r?\n$/, "");
+                if (!this.reqInit.method) {
+                    const m = /^\s*(\S+)\s+\/(\S+)/.exec(str);
+                    if (m) {
+                        this.reqInit.method = m[1];
+                        this.reqUrl += m[2];
+                    }
+                }
+                else {
+                    const m = /^([^:]+):\s*(.*)/.exec(str);
+                    if (m) {
+                        this.reqInit.headers[m[1]] = m[2];
+                    }
+                }
+            }
+            return 0;
+        }
+        close() {
+            if (this.ws)
+                this.ws.close();
+        }
+    }
+    pxsim.WifiSocket = WifiSocket;
+    class WifiSocketState {
+        constructor() {
+            this.sockets = [null];
+        }
+    }
+    pxsim.WifiSocketState = WifiSocketState;
+})(pxsim || (pxsim = {}));
+(function (pxsim) {
+    var _wifi;
+    (function (_wifi) {
+        const MAX_SOCKET = 16;
+        const WIFI_ID = 1234;
+        function _allowed() {
+            var _a, _b, _c;
+            const bid = (_c = (_b = (_a = pxsim.board()) === null || _a === void 0 ? void 0 : _a.runOptions) === null || _b === void 0 ? void 0 : _b.boardDefinition) === null || _c === void 0 ? void 0 : _c.id;
+            return /esp32|-s2/.test(bid);
+        }
+        _wifi._allowed = _allowed;
+        function getState() {
+            const b = pxsim.board();
+            if (!b.wifiSocketState) {
+                if (!_allowed())
+                    throw new Error("_wifi not enabled");
+                b.wifiSocketState = new pxsim.WifiSocketState();
+            }
+            return b.wifiSocketState;
+        }
+        function getSock(fd) {
+            if (fd < 0 || fd >= MAX_SOCKET)
+                return null;
+            return getState().sockets[fd];
+        }
+        function socketAlloc() {
+            const state = getState();
+            for (let i = 1; i < state.sockets.length; ++i) {
+                if (!state.sockets[i]) {
+                    state.sockets[i] = new pxsim.WifiSocket(i);
+                    return i;
+                }
+            }
+            const idx = state.sockets.length;
+            if (idx > MAX_SOCKET)
+                return -1;
+            state.sockets.push(new pxsim.WifiSocket(idx));
+            return idx;
+        }
+        _wifi.socketAlloc = socketAlloc;
+        function socketConnectTLS(fd, host, port) {
+            const sock = getSock(fd);
+            if (!sock)
+                return Promise.resolve(-11);
+            // TODO loosen this up in future
+            if (port == 8883 && /\.azure-devices.net$/.test(host)) {
+                return sock.openWS("wss://" + host + "/$iothub/websocket?iothub-no-client-cert=true", ["mqtt"]);
+            }
+            else if (port == 443 && host == "microsoft.github.io") {
+                return sock.openReq(host, port);
+            }
+            else {
+                console.log("invalid host: " + host);
+                return Promise.resolve(-1);
+            }
+        }
+        _wifi.socketConnectTLS = socketConnectTLS;
+        async function socketWrite(fd, data) {
+            const sock = getSock(fd);
+            if (!sock)
+                return -11;
+            return sock.write(data);
+        }
+        _wifi.socketWrite = socketWrite;
+        async function socketRead(fd, size) {
+            const sock = getSock(fd);
+            if (!sock)
+                return -11;
+            for (;;) {
+                const buf = sock.read(size);
+                if (buf)
+                    return buf;
+                await sock.waitRead();
+            }
+        }
+        _wifi.socketRead = socketRead;
+        function socketBytesAvailable(fd) {
+            const sock = getSock(fd);
+            if (!sock)
+                return -11;
+            return sock.bytesAvail;
+        }
+        _wifi.socketBytesAvailable = socketBytesAvailable;
+        function socketClose(fd) {
+            const sock = getSock(fd);
+            if (!sock)
+                return -11;
+            sock.close();
+            return 0;
+        }
+        _wifi.socketClose = socketClose;
+        function eventID() {
+            return WIFI_ID;
+        }
+        _wifi.eventID = eventID;
+        function scanStart() {
+            _raiseEvent(1 /* ScanDone */);
+        }
+        _wifi.scanStart = scanStart;
+        function scanResults() {
+            const b = new Uint8Array(7);
+            b[0] = -20; // rssi
+            b[1] = 0; // authmode
+            b.set(pxsim.U.stringToUint8Array("WiFi"), 2);
+            return new pxsim.RefBuffer(b);
+        }
+        _wifi.scanResults = scanResults;
+        function connect(ssid, pass) {
+            _raiseEvent(2 /* GotIP */);
+            return 0;
+        }
+        _wifi.connect = connect;
+        function disconnect() {
+            return 0;
+        }
+        _wifi.disconnect = disconnect;
+        function isConnected() { return true; }
+        _wifi.isConnected = isConnected;
+        function _raiseEvent(id) {
+            pxsim.control.raiseEvent(_wifi.eventID(), id, undefined);
+        }
+        _wifi._raiseEvent = _raiseEvent;
+    })(_wifi = pxsim._wifi || (pxsim._wifi = {}));
+})(pxsim || (pxsim = {}));
+(function (pxsim) {
+    var crypto;
+    (function (crypto) {
+        function _sha256(bufs) {
+            var _a, _b;
+            let len = 0;
+            const buffers = bufs.toArray().filter(e => e instanceof pxsim.RefBuffer).map((b) => {
+                len += b.data.length;
+                return b.data;
+            });
+            const concat = new Uint8Array(len);
+            len = 0;
+            for (const b of buffers) {
+                concat.set(b, len);
+                len += b.length;
+            }
+            const r = (_b = (_a = window === null || window === void 0 ? void 0 : window.crypto) === null || _a === void 0 ? void 0 : _a.subtle) === null || _b === void 0 ? void 0 : _b.digest("SHA-256", concat);
+            if (r)
+                return r.then(buf => new pxsim.RefBuffer(new Uint8Array(buf)));
+            else
+                return Promise.resolve(undefined);
+        }
+        crypto._sha256 = _sha256;
+    })(crypto = pxsim.crypto || (pxsim.crypto = {}));
+})(pxsim || (pxsim = {}));

package/built/hexcache/{6526a3337377701ca7bf1d9940f76fdccac145405380ee3ecc2c96f6049e34ce.hex → 0a7e07c684763d50c302169904fdbb9fc387e1f105f5c8a62f369eab7e443b53.hex}

@@ -8156,14 +8156,14 @@
 :100E9000704700BF43688B4210B400F10804184645
 :100EA000A8BF084632EA220128BF19461B1A9942F8
 :100EB0002044A8BF19465DF8044B00F085BE00BF72
-:100EC000002BBCBF43689B1A002A70B50E4622DB7C
-:100ED00044689918A1421EDC8A421CDCDBB136F062
-:100EE000004118D059428E4213DDB34211DD083063
-:100EF000002E00EB020516DB9C1B2246A919284692
+:100EC000002BBCBF43689B1A002A70B50E4620DB7E
+:100ED00044689918A1421CDC8A421ADCCBB136F076
+:100EE000004116D059428E4214DDB34212DD083063
+:100EF000002E00EB020515DB9C1B2246A919284693
 :100F000021F0BDFA324628190021BDE8704021F0D9
-:100F1000D0BA002C00DA70BD224608300021BDE8AE
-:100F2000704021F0C6BA74429A192946281921F056
-:100F3000A6FA224628460021BDE8704021F0B9BA41
+:100F1000D0BA70BD002211464FF0FF33BDE87040DB
+:100F2000FFF7A0BF74429A192946281921F0A7FAA1
+:100F3000224628460021BDE8704021F0BABA00BF21
 :100F400003460830596800F03DBE00BF70B5044646
 :100F500000206168490000F011FE6668002E11DD76
 :100F6000094D04F1080100EB4606034611F8012B78
@@ -8390,8 +8390,8 @@
 :101D3000012F944203F1010304D1AB42F5D90020F5
 :101D400030BC704704DB012030BC70470020704776
 :101D50004FF0FF30F4E700BF80887047002A16DD9F
-:101D600010B483880029BCBFC91821EAE1715C1A4C
-:101D7000A24202DB002C0CDD22468B4286BF0630DD
+:101D600010B484880029BCBF631823EAE371631AA6
+:101D70009A4202DB002B0CDD1A468C4286BF0630ED
 :101D80004018002011465DF8044BFFF7F7BE0348EA
 :101D9000704702485DF8044B704700BF982F04005D
 :101DA00078B371B32DE9F047858822EAE272AA423E

package/built/hexcache/{8fc8a1499d69a5d8cc851cf49d16112b3021ab801238204dacf84073acf90e7c.hex → 13247a2921d73de268c2d92a591f952d610020f3c1938dde251c0139d1823417.hex}

@@ -8237,14 +8237,14 @@
 :1013A00008041846A8BF084632EA220128BF194699
 :1013B0001B1A99422044A8BF19465DF8044B00F05F
 :1013C00085BE00BF002BBCBF43689B1A002A70B5C6
-:1013D0000E4622DB44689918A1421EDC8A421CDCBE
-:1013E000DBB136F0004118D059428E4213DDB342D2
-:1013F00011DD0830002E00EB020516DB9C1B224697
+:1013D0000E4620DB44689918A1421CDC8A421ADCC4
+:1013E000CBB136F0004116D059428E4214DDB342E3
+:1013F00012DD0830002E00EB020515DB9C1B224697
 :10140000A919284623F099F9324628190021BDE888
-:10141000704023F0ACB9002C00DA70BD22460830D1
-:101420000021BDE8704023F0A2B974429A19294600
-:10143000281923F082F9224628460021BDE8704091
-:1014400023F095B903460830596800F03DBE00BF4F
+:10141000704023F0ACB970BD002211464FF0FF338D
+:10142000BDE87040FFF7A0BF74429A1929462819F9
+:1014300023F083F9224628460021BDE8704023F0BE
+:1014400096B900BF03460830596800F03DBE00BFA2
 :1014500070B5044600206168490000F011FE66681E
 :10146000002E11DD094D04F1080100EB460603468C
 :1014700011F8012B141102F00F022C5DAA5C9C7173
@@ -8470,8 +8470,8 @@
 :10223000014F11F8012F944203F1010304D1AB4285
 :10224000F5D9002030BC704704DB012030BC70475A
 :10225000002070474FF0FF30F4E700BF80887047E0
-:10226000002A16DD10B483880029BCBFC91821EAF2
-:10227000E1715C1AA24202DB002C0CDD22468B428B
+:10226000002A16DD10B484880029BCBF631823EA55
+:10227000E371631A9A4202DB002B0CDD1A468C4292
 :1022800086BF06304018002011465DF8044BFFF76A
 :10229000F7BE0348704702485DF8044B704700BF23
 :1022A0000C53040078B371B32DE9F047858822EA16