pxt-core 7.5.40 → 7.5.43

package/built/pxt.js

@@ -108310,6 +108310,7 @@ var pxt;
         }
         github.join = join;
         function upgradeRules(cfg, id) {
+            var _a;
             if (!cfg)
                 return null;
             const parsed = parseRepoId(id);
@@ -108318,7 +108319,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) || [];
@@ -108691,6 +108692,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;
@@ -108705,6 +108707,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());
@@ -108772,6 +108775,7 @@ var pxt;
                 });
             }
             resetState() {
+                this.initialized = false;
                 this.lock = new pxt.U.PromiseQueue();
                 this.info = null;
                 this.infoRaw = null;
@@ -108794,6 +108798,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}`);
@@ -109002,8 +109012,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 => {
@@ -109037,13 +109049,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();
                 });
             }
         }
@@ -112545,11 +112560,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() {
@@ -113435,7 +113450,7 @@ var ts;
             return r;
         }
         pxtc.emptyExtInfo = emptyExtInfo;
-        const numberAttributes = ["weight", "imageLiteral", "topblockWeight"];
+        const numberAttributes = ["weight", "imageLiteral", "topblockWeight", "inlineInputModeLimit"];
         const booleanAttributes = [
             "advanced",
             "handlerStatement",

package/built/pxtblockly.js

@@ -5962,6 +5962,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) {
@@ -10910,7 +10911,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);
@@ -11018,7 +11025,7 @@ var pxt;
                 }
                 updateButtons();
                 if (variableInlineInputs)
-                    b.setInputsInline(visibleOptions < 4);
+                    b.setInputsInline(visibleOptions < inlineInputModeLimit);
                 if (!skipRender)
                     b.render();
             }
@@ -11065,7 +11072,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
@@ -12037,6 +12065,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;
@@ -15729,17 +15907,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) {
@@ -16851,11 +17018,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) {
@@ -16911,7 +17078,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));
@@ -16932,6 +17099,7 @@ var pxtblockly;
             }
         }
     }
+    pxtblockly.getAllFields = getAllFields;
     function getAllReferencedTiles(workspace, excludeBlockID) {
         var _a;
         let all = {};
@@ -16970,10 +17138,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/pxtblocks.d.ts

@@ -515,6 +515,51 @@ declare namespace pxtblockly {
         dropdownCreate(): any;
     }
 }
+declare namespace pxtblockly {
+    interface FieldTextDropdownOptions extends Blockly.FieldCustomOptions {
+        values: any;
+    }
+    class FieldTextDropdown extends Blockly.FieldTextDropdown implements Blockly.FieldCustom {
+        isFieldCustom_: boolean;
+        constructor(text: string, options: FieldTextDropdownOptions, opt_validator?: Function);
+    }
+}
+declare namespace Blockly {
+    interface FieldTextDropdown {
+        showDropdown_(): void;
+        isTextValid_: boolean;
+    }
+}
+declare namespace pxtblockly {
+    interface FieldAutoCompleteOptions extends Blockly.FieldCustomOptions {
+        key: string;
+    }
+    class FieldAutoComplete extends Blockly.FieldTextDropdown implements Blockly.FieldCustom {
+        isFieldCustom_: boolean;
+        protected key: string;
+        protected parsedValue: string;
+        protected quoteSize_: number;
+        protected quoteWidth_: number;
+        protected quoteLeftX_: number;
+        protected quoteRightX_: number;
+        protected quoteY_: number;
+        protected quoteLeft_: SVGTextElement;
+        protected quoteRight_: SVGTextElement;
+        constructor(text: string, options: FieldAutoCompleteOptions, opt_validator?: Function);
+        isOptionListDynamic(): boolean;
+        getDisplayText_(): string;
+        doValueUpdate_(newValue: string): void;
+        getValue(): string;
+        getOptions(): [string, string][];
+        showDropdown_(): void;
+        getKey(): string;
+        initView(): void;
+        updateSize_(): void;
+        positionRight(x: number): number;
+        positionLeft(x: number): number;
+        createSVGArrow_(): void;
+    }
+}
 declare namespace pxtblockly {
     class FieldBreakpoint extends Blockly.FieldNumber implements Blockly.FieldCustom {
         isFieldCustom_: boolean;
@@ -1231,15 +1276,6 @@ declare namespace pxtblockly {
         constructor(value: string, options?: StyleOptions, opt_validator?: Function);
     }
 }
-declare namespace pxtblockly {
-    interface FieldTextDropdownOptions extends Blockly.FieldCustomOptions {
-        values: any;
-    }
-    class FieldTextDropdown extends Blockly.FieldTextDropdown implements Blockly.FieldCustom {
-        isFieldCustom_: boolean;
-        constructor(text: string, options: FieldTextDropdownOptions, opt_validator?: Function);
-    }
-}
 declare namespace pxtblockly {
     class FieldTextInput extends Blockly.FieldTextInput implements Blockly.FieldCustom {
         isFieldCustom_: boolean;
@@ -1469,6 +1505,7 @@ declare namespace pxtblockly {
     function getAllBlocksWithTilesets(ws: Blockly.Workspace): FieldEditorReference<FieldTileset>[];
     function needsTilemapUpgrade(ws: Blockly.Workspace): boolean;
     function upgradeTilemapsInWorkspace(ws: Blockly.Workspace, proj: pxt.TilemapProject): void;
+    function getAllFields<U extends Blockly.Field>(ws: Blockly.Workspace, predicate: (field: Blockly.Field) => boolean): FieldEditorReference<U>[];
     function getAllReferencedTiles(workspace: Blockly.Workspace, excludeBlockID?: string): pxt.Tile[];
     function getTemporaryAssets(workspace: Blockly.Workspace, type: pxt.AssetType): pxt.Asset[];
     function workspaceToScreenCoordinates(ws: Blockly.WorkspaceSvg, wsCoordinates: Blockly.utils.Coordinate): Blockly.utils.Coordinate;