pxt-core 7.5.39 → 7.5.42

package/built/cli.js

@@ -5053,6 +5053,7 @@ function checkFileSize(files) {
     return maxSize;
 }
 function internalCheckDocsAsync(compileSnippets, re, fix, pycheck) {
+    var _a;
     if (!nodeutil.existsDirSync("docs"))
         return Promise.resolve();
     const docsRoot = nodeutil.targetDir;
@@ -5230,6 +5231,13 @@ function internalCheckDocsAsync(compileSnippets, re, fix, pycheck) {
     // test targetconfig
     if (nodeutil.fileExistsSync("targetconfig.json")) {
         const targetConfig = nodeutil.readJson("targetconfig.json");
+        if ((_a = targetConfig === null || targetConfig === void 0 ? void 0 : targetConfig.packages) === null || _a === void 0 ? void 0 : _a.approvedRepoLib) {
+            for (const repoSlug of Object.keys(targetConfig.packages.approvedRepoLib)) {
+                if (repoSlug !== repoSlug.toLocaleLowerCase()) {
+                    U.userError(`targetconfig.json: repo slugs in approvedRepoLib must be lowercased.\n\tError: ${repoSlug}`);
+                }
+            }
+        }
         if (targetConfig && targetConfig.galleries) {
             Object.keys(targetConfig.galleries).forEach(k => {
                 pxt.log(`gallery ${k}`);
@@ -5741,7 +5749,7 @@ function testGithubPackagesAsync(parsed) {
         .then(() => nodeutil.mkdirP(pkgsroot))
         .then(() => pxt.github.searchAsync("", packages))
         .then(ghrepos => ghrepos.filter(ghrepo => ghrepo.status == pxt.github.GitRepoStatus.Approved)
-        .map(ghrepo => ghrepo.fullName).concat(packages.approvedRepos || []))
+        .map(ghrepo => ghrepo.fullName).concat(Object.keys(packages.approvedRepoLib || {})))
         .then(fullnames => {
         // remove dups
         fullnames = U.unique(fullnames, f => f.toLowerCase());

package/built/pxt.js

@@ -108170,13 +108170,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;
         }
@@ -108309,52 +108309,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;
@@ -108684,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;
@@ -108698,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());
@@ -108765,6 +108775,7 @@ var pxt;
                 });
             }
             resetState() {
+                this.initialized = false;
                 this.lock = new pxt.U.PromiseQueue();
                 this.info = null;
                 this.infoRaw = null;
@@ -108787,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}`);
@@ -108995,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 => {
@@ -109030,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();
                 });
             }
         }
@@ -112538,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() {
@@ -162202,6 +162224,7 @@ function checkFileSize(files) {
     return maxSize;
 }
 function internalCheckDocsAsync(compileSnippets, re, fix, pycheck) {
+    var _a;
     if (!nodeutil.existsDirSync("docs"))
         return Promise.resolve();
     const docsRoot = nodeutil.targetDir;
@@ -162379,6 +162402,13 @@ function internalCheckDocsAsync(compileSnippets, re, fix, pycheck) {
     // test targetconfig
     if (nodeutil.fileExistsSync("targetconfig.json")) {
         const targetConfig = nodeutil.readJson("targetconfig.json");
+        if ((_a = targetConfig === null || targetConfig === void 0 ? void 0 : targetConfig.packages) === null || _a === void 0 ? void 0 : _a.approvedRepoLib) {
+            for (const repoSlug of Object.keys(targetConfig.packages.approvedRepoLib)) {
+                if (repoSlug !== repoSlug.toLocaleLowerCase()) {
+                    U.userError(`targetconfig.json: repo slugs in approvedRepoLib must be lowercased.\n\tError: ${repoSlug}`);
+                }
+            }
+        }
         if (targetConfig && targetConfig.galleries) {
             Object.keys(targetConfig.galleries).forEach(k => {
                 pxt.log(`gallery ${k}`);
@@ -162890,7 +162920,7 @@ function testGithubPackagesAsync(parsed) {
         .then(() => nodeutil.mkdirP(pkgsroot))
         .then(() => pxt.github.searchAsync("", packages))
         .then(ghrepos => ghrepos.filter(ghrepo => ghrepo.status == pxt.github.GitRepoStatus.Approved)
-        .map(ghrepo => ghrepo.fullName).concat(packages.approvedRepos || []))
+        .map(ghrepo => ghrepo.fullName).concat(Object.keys(packages.approvedRepoLib || {})))
         .then(fullnames => {
         // remove dups
         fullnames = U.unique(fullnames, f => f.toLowerCase());

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) {
@@ -12037,6 +12038,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 +15880,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 +16991,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 +17051,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 +17072,7 @@ var pxtblockly;
             }
         }
     }
+    pxtblockly.getAllFields = getAllFields;
     function getAllReferencedTiles(workspace, excludeBlockID) {
         var _a;
         let all = {};
@@ -16970,10 +17111,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;