pxt-core 7.5.40 → 7.5.43

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) {
@@ -7348,7 +7349,13 @@ var pxt;
             const totalOptions = def.parameters.length;
             const buttonDelta = toggle ? totalOptions : 1;
             const variableInlineInputs = info.blocksById[b.type].attributes.inlineInputMode === "variable";
+            const inlineInputModeLimit = info.blocksById[b.type].attributes.inlineInputModeLimit || 4;
             const compileHiddenArguments = info.blocksById[b.type].attributes.compileHiddenArguments;
+            const breakString = info.blocksById[b.type].attributes.expandableArgumentBreaks;
+            let breaks;
+            if (breakString) {
+                breaks = breakString.split(/[;,]/).map(s => parseInt(s));
+            }
             const state = new MutationState(b);
             state.setEventsEnabled(false);
             state.setValue(numVisibleAttr, 0);
@@ -7456,7 +7463,7 @@ var pxt;
                 }
                 updateButtons();
                 if (variableInlineInputs)
-                    b.setInputsInline(visibleOptions < 4);
+                    b.setInputsInline(visibleOptions < inlineInputModeLimit);
                 if (!skipRender)
                     b.render();
             }
@@ -7503,7 +7510,28 @@ var pxt;
                 updateButtons();
             }
             function addDelta(delta) {
-                return Math.min(Math.max(state.getNumber(numVisibleAttr) + delta, 0), totalOptions);
+                const newValue = Math.min(Math.max(state.getNumber(numVisibleAttr) + delta, 0), totalOptions);
+                if (breaks) {
+                    if (delta >= 0) {
+                        if (newValue === 0)
+                            return 0;
+                        for (const breakpoint of breaks) {
+                            if (breakpoint >= newValue) {
+                                return breakpoint;
+                            }
+                        }
+                        return totalOptions;
+                    }
+                    else {
+                        for (let i = 0; i < breaks.length; i++) {
+                            if (breaks[i] >= newValue) {
+                                return i > 0 ? breaks[i - 1] : 0;
+                            }
+                        }
+                        return breaks[breaks.length - 1];
+                    }
+                }
+                return newValue;
             }
             function setInputVisible(input, visible) {
                 // If the block isn't rendered, Blockly will crash
@@ -8475,6 +8503,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 +12345,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 +13456,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 +13516,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 +13537,7 @@ var pxtblockly;
             }
         }
     }
+    pxtblockly.getAllFields = getAllFields;
     function getAllReferencedTiles(workspace, excludeBlockID) {
         var _a;
         let all = {};
@@ -13408,10 +13576,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

@@ -10624,6 +10624,7 @@ var pxt;
         }
         github.join = join;
         function upgradeRules(cfg, id) {
+            var _a;
             if (!cfg)
                 return null;
             const parsed = parseRepoId(id);
@@ -10632,7 +10633,7 @@ var pxt;
             const repoData = cfg.approvedRepoLib;
             // lookup base repo for upgrade rules
             // (since nested repoes share the same version number)
-            return cfg.approvedRepoLib && pxt.U.lookup(cfg.approvedRepoLib, parsed.slug.toLowerCase()).upgrades;
+            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 rules = upgradeRules(cfg, id) || [];
@@ -11005,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;
@@ -11019,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());
@@ -11086,6 +11089,7 @@ var pxt;
                 });
             }
             resetState() {
+                this.initialized = false;
                 this.lock = new pxt.U.PromiseQueue();
                 this.info = null;
                 this.infoRaw = null;
@@ -11108,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}`);
@@ -11316,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 => {
@@ -11351,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();
                 });
             }
         }
@@ -14859,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() {
@@ -15749,7 +15764,7 @@ var ts;
             return r;
         }
         pxtc.emptyExtInfo = emptyExtInfo;
-        const numberAttributes = ["weight", "imageLiteral", "topblockWeight"];
+        const numberAttributes = ["weight", "imageLiteral", "topblockWeight", "inlineInputModeLimit"];
         const booleanAttributes = [
             "advanced",
             "handlerStatement",