pxt-core 13.2.1 → 13.2.3

package/built/pxtlib.d.ts

@@ -1543,7 +1543,7 @@ declare namespace pxt.github {
     function createReleaseAsync(repopath: string, tag: string, commitid: string): Promise<void>;
     function createPRFromBranchAsync(repopath: string, baseBranch: string, headBranch: string, title: string, msg?: string): Promise<string>;
     function mergeAsync(repopath: string, base: string, head: string, message?: string): Promise<string>;
-    function getRefAsync(repopath: string, branch: string): Promise<any>;
+    function getRefAsync(repopath: string, branch: string): Promise<string | undefined>;
     function getNewBranchNameAsync(repopath: string, pref?: string): Promise<string>;
     function createNewBranchAsync(repopath: string, branchName: string, commitid: string): Promise<string>;
     function forkRepoAsync(repopath: string, commitid: string, pref?: string): Promise<string>;

package/built/pxtlib.js

@@ -10890,8 +10890,29 @@ var pxt;
             }
             async loadConfigAsync(repopath, tag) {
                 if (!tag) {
-                    pxt.debug(`dep: default to master branch`);
-                    tag = "master";
+                    pxt.debug(`dep: no tag specified, try master and main`);
+                    let res;
+                    let error;
+                    try {
+                        res = await this.loadConfigAsync(repopath, "master");
+                    }
+                    catch (e) {
+                        error = e;
+                        pxt.log(`Error loading default master config for ${repopath}: ${e.message}`);
+                    }
+                    if (res)
+                        return res;
+                    try {
+                        res = await this.loadConfigAsync(repopath, "main");
+                    }
+                    catch (e) {
+                        error = e;
+                        pxt.log(`Error loading default main config for ${repopath}: ${e.message}`);
+                    }
+                    if (res)
+                        return res;
+                    else
+                        throw error;
                 }
                 // cache lookup
                 const key = `${repopath}/${tag}`;
@@ -10925,8 +10946,29 @@ var pxt;
             }
             async loadPackageAsync(repopath, tag, fallbackPackageFiles) {
                 if (!tag) {
-                    pxt.debug(`load pkg: default to master branch`);
-                    tag = "master";
+                    pxt.debug(`load pkg: no tag specified, try master and main`);
+                    let res;
+                    let error;
+                    try {
+                        res = await this.loadPackageAsync(repopath, "master", fallbackPackageFiles);
+                    }
+                    catch (e) {
+                        error = e;
+                        pxt.log(`Error loading default master package for ${repopath}: ${e.message}`);
+                    }
+                    if (res)
+                        return res;
+                    try {
+                        res = await this.loadPackageAsync(repopath, "main", fallbackPackageFiles);
+                    }
+                    catch (e) {
+                        error = e;
+                        pxt.log(`Error loading default main package for ${repopath}: ${e.message}`);
+                    }
+                    if (res)
+                        return res;
+                    else
+                        throw error;
                 }
                 // try using github proxy first
                 if (hasProxy()) {
@@ -11212,16 +11254,27 @@ var pxt;
             });
         }
         github.mergeAsync = mergeAsync;
-        function getRefAsync(repopath, branch) {
-            branch = branch || "master";
-            return ghGetJsonAsync("https://api.github.com/repos/" + repopath + "/git/refs/heads/" + branch)
-                .then(resolveRefAsync)
-                .catch(err => {
-                if (err.statusCode == 404)
+        async function getRefAsync(repopath, branch) {
+            if (!branch) {
+                // try master and main
+                let res = await getRefAsync(repopath, "master");
+                if (!res)
+                    res = await getRefAsync(repopath, "main");
+                return res;
+            }
+            try {
+                const ref = await ghGetJsonAsync("https://api.github.com/repos/" + repopath + "/git/refs/heads/" + branch);
+                return resolveRefAsync(ref);
+            }
+            catch (e) {
+                pxt.debug(`Error fetching ref for ${repopath} branch ${branch}: ${e.message}`);
+                if (e.statusCode === 404) {
                     return undefined;
-                else
-                    Promise.reject(err);
-            });
+                }
+                else {
+                    throw e;
+                }
+            }
         }
         github.getRefAsync = getRefAsync;
         function generateNextRefName(res, pref) {
@@ -15807,7 +15860,7 @@ var pxt;
                                         }]
                                 },
                                 {
-                                    name: lf("booming kick"),
+                                    name: lf("boom kick"),
                                     startFrequency: 100,
                                     startVolume: 1024,
                                     steps: [{
@@ -21312,10 +21365,12 @@ var pxt;
          * @param skipIDs string[] a list of string ids (block id, asset id, or file name) to ignore
          **/
         isAssetUsed(asset, files, skipIDs) {
-            var _a, _b, _c;
-            let blockIds = ((_b = (_a = asset.meta) === null || _a === void 0 ? void 0 : _a.blockIDs) === null || _b === void 0 ? void 0 : _b.filter(id => !skipIDs || (skipIDs === null || skipIDs === void 0 ? void 0 : skipIDs.indexOf(id)) < 0)) || [];
-            if (blockIds.length > 0)
-                return true;
+            var _a, _b, _c, _d, _e;
+            if (!((_a = asset.meta) === null || _a === void 0 ? void 0 : _a.displayName) || !files) {
+                let blockIds = ((_c = (_b = asset.meta) === null || _b === void 0 ? void 0 : _b.blockIDs) === null || _c === void 0 ? void 0 : _c.filter(id => !skipIDs || (skipIDs === null || skipIDs === void 0 ? void 0 : skipIDs.indexOf(id)) < 0)) || [];
+                if (blockIds.length > 0)
+                    return true;
+            }
             if (asset.type == "tile" /* pxt.AssetType.Tile */) {
                 for (const tm of this.getAssets("tilemap" /* AssetType.Tilemap */)) {
                     if ((skipIDs === null || skipIDs === void 0 ? void 0 : skipIDs.indexOf(tm.id)) >= 0) {
@@ -21327,84 +21382,83 @@ var pxt;
                 }
             }
             if (files) {
-                const shortId = pxt.Util.escapeForRegex(getShortIDForAsset(asset));
-                const displayName = pxt.Util.escapeForRegex((_c = asset.meta) === null || _c === void 0 ? void 0 : _c.displayName) || "";
-                let assetTsRefs;
-                switch (asset.type) {
-                    case "tile" /* pxt.AssetType.Tile */:
-                        assetTsRefs = `myTiles.${shortId}|assets.tile\`${shortId}\``;
-                        if (displayName)
-                            assetTsRefs += `|assets.tile\`${displayName}\``;
-                        break;
-                    case "tilemap" /* pxt.AssetType.Tilemap */:
-                        assetTsRefs = `tilemap\`${shortId}\``;
-                        break;
-                    case "animation" /* pxt.AssetType.Animation */:
-                        assetTsRefs = `assets.animation\`${shortId}\``;
-                        if (displayName)
-                            assetTsRefs += `|assets.animation\`${displayName}\``;
-                        break;
-                    case "song" /* pxt.AssetType.Song */:
-                        assetTsRefs = `assets.song\`${shortId}\``;
-                        if (displayName)
-                            assetTsRefs += `|assets.song\`${displayName}\``;
-                        break;
-                    case "json" /* pxt.AssetType.Json */:
-                        assetTsRefs = `assets.json\`${shortId}\``;
-                        if (displayName)
-                            assetTsRefs += `|assets.json\`${displayName}\``;
-                        break;
-                    default:
-                        assetTsRefs = `assets.image\`${shortId}\``;
-                        if (displayName)
-                            assetTsRefs += `|assets.image\`${displayName}\``;
-                        break;
+                const config = pxt.U.jsonTryParse((_d = files["pxt.json"]) === null || _d === void 0 ? void 0 : _d.content);
+                const filesToCheck = [];
+                if (config === null || config === void 0 ? void 0 : config.files) {
+                    for (const file of config.files) {
+                        if (file.endsWith(".g.ts"))
+                            continue;
+                        if (skipIDs && (skipIDs.indexOf(file) !== -1))
+                            continue;
+                        if (file.endsWith(".ts") && file !== pxt.MAIN_TS || file.endsWith(".py") && file !== pxt.MAIN_PY) {
+                            filesToCheck.push(file);
+                        }
+                    }
+                }
+                if ((config === null || config === void 0 ? void 0 : config.preferredEditor) === pxt.BLOCKS_PROJECT_NAME) {
+                    filesToCheck.push(pxt.MAIN_BLOCKS);
                 }
-                const assetTsRegex = new RegExp(assetTsRefs, "gm");
-                let assetPyRefs;
+                else if ((config === null || config === void 0 ? void 0 : config.preferredEditor) === pxt.JAVASCRIPT_PROJECT_NAME) {
+                    filesToCheck.push(pxt.MAIN_TS);
+                }
+                else if ((config === null || config === void 0 ? void 0 : config.preferredEditor) === pxt.PYTHON_PROJECT_NAME) {
+                    filesToCheck.push(pxt.MAIN_PY);
+                }
+                const references = [];
+                const shortId = pxt.Util.escapeForRegex(getShortIDForAsset(asset));
+                const displayName = pxt.Util.escapeForRegex((_e = asset.meta) === null || _e === void 0 ? void 0 : _e.displayName) || "";
+                const addNamespaceReference = (namespace, fun, id) => {
+                    references.push(`${namespace}\\s*\\.\\s*${fun}\`\\s*${id}\\s*\``);
+                };
                 switch (asset.type) {
                     case "tile" /* pxt.AssetType.Tile */:
-                        assetPyRefs = `myTiles.${shortId}|assets.tile\("""${shortId}"""\)`;
+                        references.push(`myTiles\\s*\\.\\s*${shortId}\\s*`);
+                        addNamespaceReference("assets", "tile", shortId);
                         if (displayName)
-                            assetPyRefs += `|assets.tile\("""${displayName}"""\)`;
+                            addNamespaceReference("assets", "tile", displayName);
                         break;
                     case "tilemap" /* pxt.AssetType.Tilemap */:
-                        assetPyRefs = `assets.tilemap\("""${shortId}"""\)`;
+                        references.push(`tilemap\`\\s*${shortId}\\s*\``);
+                        addNamespaceReference("assets", "tilemap", shortId);
+                        if (displayName) {
+                            references.push(`tilemap\`\\s*${displayName}\\s*\``);
+                            addNamespaceReference("assets", "tilemap", displayName);
+                        }
                         break;
                     case "animation" /* pxt.AssetType.Animation */:
-                        assetPyRefs = `assets.animation\("""${shortId}"""\)`;
+                        addNamespaceReference("assets", "animation", shortId);
                         if (displayName)
-                            assetPyRefs += `|assets.animation\("""${displayName}"""\)`;
+                            addNamespaceReference("assets", "animation", displayName);
                         break;
                     case "song" /* pxt.AssetType.Song */:
-                        assetPyRefs = `assets.song\("""${shortId}"""\)`;
+                        addNamespaceReference("assets", "song", shortId);
                         if (displayName)
-                            assetPyRefs += `|assets.song\("""${displayName}"""\)`;
+                            addNamespaceReference("assets", "song", displayName);
                         break;
                     case "json" /* pxt.AssetType.Json */:
-                        assetPyRefs = `assets.json\("""${shortId}"""\)`;
+                        addNamespaceReference("assets", "json", shortId);
                         if (displayName)
-                            assetPyRefs += `|assets.json\("""${displayName}"""\)`;
+                            addNamespaceReference("assets", "json", displayName);
                         break;
                     default:
-                        assetPyRefs = `assets.image\("""${shortId}"""\)`;
+                        addNamespaceReference("assets", "image", shortId);
                         if (displayName)
-                            assetPyRefs += `|assets.image\("""${displayName}"""\)`;
+                            addNamespaceReference("assets", "image", displayName);
                         break;
                 }
-                const assetPyRegex = new RegExp(assetPyRefs, "gm");
-                for (let filename of Object.keys(files)) {
-                    if ((skipIDs === null || skipIDs === void 0 ? void 0 : skipIDs.indexOf(filename)) >= 0)
-                        continue;
-                    const f = files[filename];
-                    // Match .ts files that are not generated (.g.ts)
-                    if (filename.match(/((?!\.g).{2}|^.{0,1})\.ts$/i)) {
-                        if (f.content.match(assetTsRegex))
+                const regex = new RegExp(references.map(r => `(?:${r})`).join("|"));
+                const pyRegex = new RegExp(references.map(r => `(?:${r})`).join("|").replace(/`/g, '"""'));
+                for (const file of filesToCheck) {
+                    const content = files[file].content;
+                    if (file.endsWith(".py")) {
+                        if (pyRegex.test(content)) {
                             return true;
+                        }
                     }
-                    else if (filename.endsWith(".py")) {
-                        if (f.content.match(assetPyRegex))
+                    else {
+                        if (regex.test(content)) {
                             return true;
+                        }
                     }
                 }
             }

package/built/react-common/components/controls/DropdownModal.d.ts

@@ -0,0 +1,6 @@
+import { DropdownProps } from "./Dropdown";
+interface DropdownModalProps extends DropdownProps {
+    onClose: () => void;
+}
+export declare const DropdownModal: (props: DropdownModalProps) => JSX.Element;
+export {};

package/built/react-common/components/controls/Input.d.ts

@@ -4,7 +4,7 @@ export interface InputProps extends ControlProps {
     inputClassName?: string;
     groupClassName?: string;
     initialValue?: string;
-    label?: string;
+    label?: string | JSX.Element;
     title?: string;
     placeholder?: string;
     icon?: string;