pxt-core 7.5.39 → 7.5.42

package/built/pxtblocks.js

@@ -2400,6 +2400,7 @@ var pxt;
             registerFieldEditor('position', pxtblockly.FieldPosition);
             registerFieldEditor('melody', pxtblockly.FieldCustomMelody);
             registerFieldEditor('soundeffect', pxtblockly.FieldSoundEffect);
+            registerFieldEditor('autocomplete', pxtblockly.FieldAutoComplete);
         }
         blocks.initFieldEditors = initFieldEditors;
         function registerFieldEditor(selector, field, validator) {
@@ -8475,6 +8476,156 @@ var pxtblockly;
     }
     pxtblockly.FieldArgumentVariable = FieldArgumentVariable;
 })(pxtblockly || (pxtblockly = {}));
+/// <reference path="../../localtypings/pxtblockly.d.ts" />
+var pxtblockly;
+(function (pxtblockly) {
+    class FieldTextDropdown extends Blockly.FieldTextDropdown {
+        constructor(text, options, opt_validator) {
+            super(text, options.values, opt_validator);
+            this.isFieldCustom_ = true;
+        }
+    }
+    pxtblockly.FieldTextDropdown = FieldTextDropdown;
+})(pxtblockly || (pxtblockly = {}));
+/// <reference path="../../localtypings/pxtblockly.d.ts" />
+/// <reference path="./field_textdropdown.ts" />
+var pxtblockly;
+(function (pxtblockly) {
+    class FieldAutoComplete extends Blockly.FieldTextDropdown {
+        constructor(text, options, opt_validator) {
+            super(text, () => [], opt_validator);
+            this.isFieldCustom_ = true;
+            this.key = options.key;
+            this.isTextValid_ = true;
+        }
+        isOptionListDynamic() {
+            return true;
+        }
+        getDisplayText_() {
+            return this.parsedValue || "";
+        }
+        doValueUpdate_(newValue) {
+            if (newValue === null)
+                return;
+            if (/['"`].*['"`]/.test(newValue)) {
+                this.parsedValue = JSON.parse(newValue);
+            }
+            else {
+                this.parsedValue = newValue;
+            }
+            this.value_ = this.parsedValue;
+        }
+        getValue() {
+            if (this.parsedValue) {
+                return JSON.stringify(this.parsedValue);
+            }
+            else
+                return '""';
+        }
+        getOptions() {
+            var _a;
+            const workspace = (_a = this.sourceBlock_) === null || _a === void 0 ? void 0 : _a.workspace;
+            if (!workspace)
+                return [];
+            const res = [];
+            const fields = pxtblockly.getAllFields(workspace, field => field instanceof FieldAutoComplete && field.getKey() === this.key);
+            const options = fields.map(field => field.ref.getDisplayText_());
+            for (const option of options) {
+                if (!option.trim() || res.some(tuple => tuple[0] === option))
+                    continue;
+                res.push([option, option]);
+            }
+            res.sort((a, b) => a[0].localeCompare(b[0]));
+            return res;
+        }
+        showDropdown_() {
+            const options = this.getOptions();
+            if (options.length)
+                super.showDropdown_();
+        }
+        getKey() {
+            if (this.key)
+                return this.key;
+            if (this.sourceBlock_)
+                return this.sourceBlock_.type;
+            return undefined;
+        }
+        // Copied from field_string in pxt-blockly
+        initView() {
+            // Add quotes around the string
+            // Positioned on updatSize, after text size is calculated.
+            this.quoteSize_ = 16;
+            this.quoteWidth_ = 8;
+            this.quoteLeftX_ = 0;
+            this.quoteRightX_ = 0;
+            this.quoteY_ = 10;
+            if (this.quoteLeft_)
+                this.quoteLeft_.parentNode.removeChild(this.quoteLeft_);
+            this.quoteLeft_ = Blockly.utils.dom.createSvgElement('text', {
+                'font-size': this.quoteSize_ + 'px',
+                'class': 'field-text-quote'
+            }, this.fieldGroup_);
+            super.initView();
+            if (this.quoteRight_)
+                this.quoteRight_.parentNode.removeChild(this.quoteRight_);
+            this.quoteRight_ = Blockly.utils.dom.createSvgElement('text', {
+                'font-size': this.quoteSize_ + 'px',
+                'class': 'field-text-quote'
+            }, this.fieldGroup_);
+            this.quoteLeft_.appendChild(document.createTextNode('"'));
+            this.quoteRight_.appendChild(document.createTextNode('"'));
+        }
+        // Copied from field_string in pxt-blockly
+        updateSize_() {
+            super.updateSize_();
+            const sWidth = Math.max(this.size_.width, 1);
+            const xPadding = 3;
+            let addedWidth = this.positionLeft(sWidth + xPadding);
+            this.textElement_.setAttribute('x', addedWidth.toString());
+            addedWidth += this.positionRight(addedWidth + sWidth + xPadding);
+            this.size_.width = sWidth + addedWidth;
+        }
+        // Copied from field_string in pxt-blockly
+        positionRight(x) {
+            if (!this.quoteRight_) {
+                return 0;
+            }
+            let addedWidth = 0;
+            if (this.sourceBlock_.RTL) {
+                this.quoteRightX_ = Blockly.FieldString.quotePadding;
+                addedWidth = this.quoteWidth_ + Blockly.FieldString.quotePadding;
+            }
+            else {
+                this.quoteRightX_ = x + Blockly.FieldString.quotePadding;
+                addedWidth = this.quoteWidth_ + Blockly.FieldString.quotePadding;
+            }
+            this.quoteRight_.setAttribute('transform', 'translate(' + this.quoteRightX_ + ',' + this.quoteY_ + ')');
+            return addedWidth;
+        }
+        // Copied from field_string in pxt-blockly
+        positionLeft(x) {
+            if (!this.quoteLeft_) {
+                return 0;
+            }
+            let addedWidth = 0;
+            if (this.sourceBlock_.RTL) {
+                this.quoteLeftX_ = x + this.quoteWidth_ + Blockly.FieldString.quotePadding * 2;
+                addedWidth = this.quoteWidth_ + Blockly.FieldString.quotePadding;
+            }
+            else {
+                this.quoteLeftX_ = 0;
+                addedWidth = this.quoteWidth_ + Blockly.FieldString.quotePadding;
+            }
+            this.quoteLeft_.setAttribute('transform', 'translate(' + this.quoteLeftX_ + ',' + this.quoteY_ + ')');
+            return addedWidth;
+        }
+        createSVGArrow_() {
+            // This creates the little arrow for dropdown fields. Intentionally
+            // do nothing
+        }
+    }
+    pxtblockly.FieldAutoComplete = FieldAutoComplete;
+})(pxtblockly || (pxtblockly = {}));
 /// <reference path="../../localtypings/blockly.d.ts" />
 /// <reference path="../../built/pxtsim.d.ts" />
 var pxtblockly;
@@ -12167,17 +12318,6 @@ var pxtblockly;
 })(pxtblockly || (pxtblockly = {}));
 /// <reference path="../../localtypings/pxtblockly.d.ts" />
 var pxtblockly;
-(function (pxtblockly) {
-    class FieldTextDropdown extends Blockly.FieldTextDropdown {
-        constructor(text, options, opt_validator) {
-            super(text, options.values, opt_validator);
-            this.isFieldCustom_ = true;
-        }
-    }
-    pxtblockly.FieldTextDropdown = FieldTextDropdown;
-})(pxtblockly || (pxtblockly = {}));
-/// <reference path="../../localtypings/pxtblockly.d.ts" />
-var pxtblockly;
 (function (pxtblockly) {
     class FieldTextInput extends Blockly.FieldTextInput {
         constructor(value, options, opt_validator) {
@@ -13289,11 +13429,11 @@ var pxtblockly;
         }
     }
     function getAllBlocksWithTilemaps(ws) {
-        return getAllFieldsCore(ws, f => f instanceof pxtblockly.FieldTilemap && !f.isGreyBlock);
+        return getAllFields(ws, f => f instanceof pxtblockly.FieldTilemap && !f.isGreyBlock);
     }
     pxtblockly.getAllBlocksWithTilemaps = getAllBlocksWithTilemaps;
     function getAllBlocksWithTilesets(ws) {
-        return getAllFieldsCore(ws, f => f instanceof pxtblockly.FieldTileset);
+        return getAllFields(ws, f => f instanceof pxtblockly.FieldTileset);
     }
     pxtblockly.getAllBlocksWithTilesets = getAllBlocksWithTilesets;
     function needsTilemapUpgrade(ws) {
@@ -13349,7 +13489,7 @@ var pxtblockly;
         }
     }
     pxtblockly.upgradeTilemapsInWorkspace = upgradeTilemapsInWorkspace;
-    function getAllFieldsCore(ws, predicate) {
+    function getAllFields(ws, predicate) {
         const result = [];
         const top = ws.getTopBlocks(false);
         top.forEach(block => getAllFieldsRecursive(block));
@@ -13370,6 +13510,7 @@ var pxtblockly;
             }
         }
     }
+    pxtblockly.getAllFields = getAllFields;
     function getAllReferencedTiles(workspace, excludeBlockID) {
         var _a;
         let all = {};
@@ -13408,10 +13549,10 @@ var pxtblockly;
     function getTemporaryAssets(workspace, type) {
         switch (type) {
             case "image" /* Image */:
-                return getAllFieldsCore(workspace, field => field instanceof pxtblockly.FieldSpriteEditor && field.isTemporaryAsset())
+                return getAllFields(workspace, field => field instanceof pxtblockly.FieldSpriteEditor && field.isTemporaryAsset())
                     .map(f => f.ref.getAsset());
             case "animation" /* Animation */:
-                return getAllFieldsCore(workspace, field => field instanceof pxtblockly.FieldAnimationEditor && field.isTemporaryAsset())
+                return getAllFields(workspace, field => field instanceof pxtblockly.FieldAnimationEditor && field.isTemporaryAsset())
                     .map(f => f.ref.getAsset());
             default: return [];
         }

package/built/pxtlib.d.ts

@@ -1438,6 +1438,7 @@ declare namespace pxt.HF2 {
     function enableLog(): void;
     class Wrapper implements pxt.packetio.PacketIOWrapper {
         readonly io: pxt.packetio.PacketIO;
+        private initialized;
         private cmdSeq;
         constructor(io: pxt.packetio.PacketIO);
         private lock;
@@ -1458,9 +1459,12 @@ declare namespace pxt.HF2 {
         jacdacAvailable: boolean;
         onSerial: (buf: Uint8Array, isStderr: boolean) => void;
         onCustomEvent: (type: string, payload: Uint8Array) => void;
+        onConnectionChanged: () => void;
         private resetState;
         onEvent(id: number, f: (buf: Uint8Array) => void): void;
         sendCustomEventAsync(type: string, payload: Uint8Array): Promise<void>;
+        isConnected(): boolean;
+        isConnecting(): boolean;
         reconnectAsync(): Promise<void>;
         disconnectAsync(): Promise<void>;
         error(m: string): any;
@@ -1849,6 +1853,8 @@ declare namespace pxt.packetio {
         onSerial: (buf: Uint8Array, isStderr: boolean) => void;
         reconnectAsync(): Promise<void>;
         disconnectAsync(): Promise<void>;
+        isConnected(): boolean;
+        isConnecting(): boolean;
         reflashAsync(resp: pxtc.CompileResult): Promise<void>;
         onCustomEvent: (type: string, payload: Uint8Array) => void;
         sendCustomEventAsync(type: string, payload: Uint8Array): Promise<void>;

package/built/pxtlib.js

@@ -10484,13 +10484,13 @@ var pxt;
             return false;
         }
         function isRepoApproved(repo, config) {
+            var _a;
             if (isOrgApproved(repo, config))
                 return true;
             if (!repo || !config)
                 return false;
             if (repo.fullName
-                && config.approvedRepos
-                && config.approvedRepos.some(fn => fn.toLowerCase() == repo.fullName.toLowerCase()))
+                && ((_a = config.approvedRepoLib) === null || _a === void 0 ? void 0 : _a[repo.fullName.toLowerCase()]))
                 return true;
             return false;
         }
@@ -10623,52 +10623,60 @@ var pxt;
             return parts.filter(p => !!p).join('/');
         }
         github.join = join;
-        function upgradeRule(cfg, id) {
-            if (!cfg || !cfg.upgrades)
+        function upgradeRules(cfg, id) {
+            var _a;
+            if (!cfg)
                 return null;
             const parsed = parseRepoId(id);
             if (!parsed)
                 return null;
-            // lookup base repo for upgrade rules 
+            const repoData = cfg.approvedRepoLib;
+            // lookup base repo for upgrade rules
             // (since nested repoes share the same version number)
-            return pxt.U.lookup(cfg.upgrades, parsed.slug.toLowerCase());
+            return cfg.approvedRepoLib && ((_a = pxt.U.lookup(cfg.approvedRepoLib, parsed.slug.toLowerCase())) === null || _a === void 0 ? void 0 : _a.upgrades);
         }
         function upgradedDisablesVariants(cfg, id) {
-            const upgr = upgradeRule(cfg, id);
-            const m = /^dv:(.*)/.exec(upgr);
-            if (m) {
-                const disabled = m[1].split(/,/);
-                if (disabled.some(d => !/^\w+$/.test(d)))
-                    return null;
-                return disabled;
+            const rules = upgradeRules(cfg, id) || [];
+            if (!rules)
+                return null;
+            for (const upgr of rules) {
+                const m = /^dv:(.*)/.exec(upgr);
+                if (m) {
+                    const disabled = m[1].split(/,/);
+                    if (disabled.some(d => !/^\w+$/.test(d)))
+                        return null;
+                    return disabled;
+                }
             }
             return null;
         }
         function upgradedPackageReference(cfg, id) {
-            const upgr = upgradeRule(cfg, id);
-            if (!upgr)
+            const rules = upgradeRules(cfg, id);
+            if (!rules)
                 return null;
-            const m = /^min:(.*)/.exec(upgr);
-            const minV = m && pxt.semver.tryParse(m[1]);
-            if (minV) {
-                const parsed = parseRepoId(id);
-                const currV = pxt.semver.tryParse(parsed.tag);
-                if (currV && pxt.semver.cmp(currV, minV) < 0) {
-                    parsed.tag = m[1];
-                    pxt.debug(`upgrading ${id} to ${m[1]}`);
-                    return stringifyRepo(parsed);
+            for (const upgr of rules) {
+                const m = /^min:(.*)/.exec(upgr);
+                const minV = m && pxt.semver.tryParse(m[1]);
+                if (minV) {
+                    const parsed = parseRepoId(id);
+                    const currV = pxt.semver.tryParse(parsed.tag);
+                    if (currV && pxt.semver.cmp(currV, minV) < 0) {
+                        parsed.tag = m[1];
+                        pxt.debug(`upgrading ${id} to ${m[1]}`);
+                        return stringifyRepo(parsed);
+                    }
+                    else {
+                        if (!currV)
+                            pxt.log(`not upgrading ${id} - cannot parse version`);
+                        return null;
+                    }
                 }
                 else {
-                    if (!currV)
-                        pxt.log(`not upgrading ${id} - cannot parse version`);
-                    return null;
+                    // check if the rule looks valid at all
+                    if (!upgradedDisablesVariants(cfg, id))
+                        pxt.log(`invalid upgrade rule: ${id} -> ${upgr}`);
                 }
             }
-            else {
-                // check if the rule looks valid at all
-                if (!upgradedDisablesVariants(cfg, id))
-                    pxt.log(`invalid upgrade rule: ${id} -> ${upgr}`);
-            }
             return id;
         }
         github.upgradedPackageReference = upgradedPackageReference;
@@ -10998,6 +11006,7 @@ var pxt;
             constructor(io) {
                 var _a;
                 this.io = io;
+                this.initialized = false;
                 this.cmdSeq = pxt.U.randomUint32();
                 this.lock = new pxt.U.PromiseQueue();
                 this.flashing = false;
@@ -11012,6 +11021,7 @@ var pxt;
                 this.jacdacAvailable = false;
                 this.onSerial = (buf, isStderr) => { };
                 this.onCustomEvent = (type, payload) => { };
+                this.onConnectionChanged = () => { };
                 let frames = [];
                 io.onDeviceConnectionChanged = connect => this.disconnectAsync()
                     .then(() => connect && this.reconnectAsync());
@@ -11079,6 +11089,7 @@ var pxt;
                 });
             }
             resetState() {
+                this.initialized = false;
                 this.lock = new pxt.U.PromiseQueue();
                 this.info = null;
                 this.infoRaw = null;
@@ -11101,6 +11112,12 @@ var pxt;
                         return Promise.resolve(); // ignore
                 return Promise.reject(new Error("invalid custom event type"));
             }
+            isConnected() {
+                return this.io.isConnected() && this.initialized;
+            }
+            isConnecting() {
+                return this.io.isConnecting() || (this.io.isConnected() && !this.initialized);
+            }
             reconnectAsync() {
                 this.resetState();
                 log(`reconnect raw=${this.rawMode}`);
@@ -11309,8 +11326,10 @@ var pxt;
                     .then(() => { });
             }
             initAsync() {
-                if (this.rawMode)
+                if (this.rawMode) {
+                    this.initialized = true;
                     return Promise.resolve();
+                }
                 return Promise.resolve()
                     .then(() => this.talkAsync(HF2.HF2_CMD_BININFO))
                     .then(binfo => {
@@ -11344,13 +11363,16 @@ var pxt;
                         };
                     log(`Board-ID: ${this.info.BoardID} v${this.info.Parsed.Version} f${this.info.Parsed.Features}`);
                 })
-                    .then(() => this.talkAsync(HF2.HF2_CMD_JDS_CONFIG, new Uint8Array([1])).then(() => {
+                    .then(() => this.talkAsync(HF2.HF2_CMD_JDS_CONFIG, new Uint8Array([1]))
+                    .then(() => {
                     this.jacdacAvailable = true;
                 }, _err => {
                     this.jacdacAvailable = false;
                 }))
                     .then(() => {
                     this.reconnectTries = 0;
+                    this.initialized = true;
+                    this.io.onConnectionChanged();
                 });
             }
         }
@@ -14852,11 +14874,11 @@ var pxt;
          * The DAP wrapper is active and the device is connected
          */
         function isConnected() {
-            return !!wrapper && wrapper.io.isConnected();
+            return !!(wrapper === null || wrapper === void 0 ? void 0 : wrapper.isConnected());
         }
         packetio.isConnected = isConnected;
         function isConnecting() {
-            return !!wrapper && wrapper.io.isConnecting();
+            return !!(wrapper === null || wrapper === void 0 ? void 0 : wrapper.isConnecting());
         }
         packetio.isConnecting = isConnecting;
         function icon() {