pxt-core 12.3.20 → 12.3.22

package/built/cli.js

@@ -215,8 +215,8 @@ class FileGithubDb {
     loadConfigAsync(repopath, tag) {
         return this.loadAsync(repopath, tag, "pxt", (r, t) => this.db.loadConfigAsync(r, t));
     }
-    loadPackageAsync(repopath, tag) {
-        return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t));
+    loadPackageAsync(repopath, tag, fallbackPackageFiles) {
+        return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t, fallbackPackageFiles));
     }
     loadTutorialMarkdown(repopath, tag) {
         return this.loadAsync(repopath, tag, "tutorial", (r, t) => this.db.loadTutorialMarkdown(r, t));

package/built/pxt.js

@@ -101957,6 +101957,7 @@ var pxt;
     pxt.TUTORIAL_CODE_STOP = "_onCodeStop.ts";
     pxt.TUTORIAL_INFO_FILE = "tutorial-info-cache.json";
     pxt.TUTORIAL_CUSTOM_TS = "tutorial.custom.ts";
+    pxt.PACKAGED_EXTENSIONS = "_packaged-extensions.json";
     pxt.BREAKPOINT_TABLET = 991; // TODO (shakao) revisit when tutorial stuff is more settled
     pxt.PALETTES_FILE = "_palettes.json";
     pxt.HISTORY_FILE = "_history";
@@ -102003,6 +102004,30 @@ var pxt;
         };
         // Like MATH_FUNCTIONS, but used only for rounding operations
         blocks.ROUNDING_FUNCTIONS = ["round", "ceil", "floor", "trunc"];
+        function parameterDefaultLocalizationKey(qName, actualName) {
+            return qName ? `${qName}|param|${actualName}|defl` : undefined;
+        }
+        blocks.parameterDefaultLocalizationKey = parameterDefaultLocalizationKey;
+        function parameterDefaultToLocalizationString(defaultValue, type) {
+            if (!defaultValue)
+                return undefined;
+            if (type === "string" && defaultValue.charAt(0) !== "\"")
+                return defaultValue;
+            if (defaultValue.charAt(0) !== "\"")
+                return undefined;
+            try {
+                const value = JSON.parse(defaultValue);
+                return typeof value === "string" ? value : undefined;
+            }
+            catch (e) {
+                return undefined;
+            }
+        }
+        blocks.parameterDefaultToLocalizationString = parameterDefaultToLocalizationString;
+        function localizationStringToParameterDefault(value) {
+            return JSON.stringify(value);
+        }
+        blocks.localizationStringToParameterDefault = localizationStringToParameterDefault;
         // Information for blocks that compile to function calls but are defined by vanilla Blockly
         // and not dynamically by BlocklyLoader
         blocks.builtinFunctionInfo = {
@@ -105784,6 +105809,13 @@ int main() {
             });
         }
         hexloader.recordGetAsync = recordGetAsync;
+        function stringifyHexInfoForCache(hexInfo) {
+            if (!(hexInfo === null || hexInfo === void 0 ? void 0 : hexInfo.hex))
+                return undefined;
+            const cachedMeta = Object.assign(Object.assign({}, hexInfo), { hex: compressHex(hexInfo.hex) });
+            return JSON.stringify(cachedMeta);
+        }
+        hexloader.stringifyHexInfoForCache = stringifyHexInfoForCache;
         function getHexInfoAsync(host, extInfo, cloudModule) {
             if (!extInfo.sha)
                 return Promise.resolve(null);
@@ -105812,10 +105844,7 @@ int main() {
                 else {
                     return downloadHexInfoAsync(extInfo)
                         .then(meta => {
-                        let origHex = meta.hex;
-                        meta.hex = compressHex(meta.hex);
-                        let store = JSON.stringify(meta);
-                        meta.hex = origHex;
+                        let store = stringifyHexInfoForCache(meta);
                         return storeWithLimitAsync(host, "hex-keys", key, store)
                             .then(() => meta);
                     }).catch(e => {
@@ -108407,6 +108436,18 @@ var pxt;
         }
         github.shouldUseProxyForRepo = shouldUseProxyForRepo;
         const isPrivateRepoCache = {};
+        function copyCachedPackage(cachedPackage) {
+            return {
+                files: Object.assign({}, cachedPackage.files)
+            };
+        }
+        function cachedPackageFromFallback(fallbackPackageFiles) {
+            if (!fallbackPackageFiles)
+                return undefined;
+            return {
+                files: Object.assign({}, fallbackPackageFiles)
+            };
+        }
         function ghRequestAsync(options) {
             var _a;
             options.method = (_a = options.method) !== null && _a !== void 0 ? _a : "GET";
@@ -108518,7 +108559,7 @@ var pxt;
                 }
                 return resolved;
             }
-            async loadPackageAsync(repopath, tag) {
+            async loadPackageAsync(repopath, tag, fallbackPackageFiles) {
                 if (!tag) {
                     pxt.debug(`load pkg: default to master branch`);
                     tag = "master";
@@ -108526,45 +108567,46 @@ var pxt;
                 // try using github proxy first
                 if (hasProxy()) {
                     try {
-                        return await this.proxyWithCdnLoadPackageAsync(repopath, tag).then(v => pxt.U.clone(v));
+                        return await this.proxyWithCdnLoadPackageAsync(repopath, tag).then(copyCachedPackage);
                     }
                     catch (e) {
                         ghProxyHandleException(e);
                     }
                 }
                 // try using github apis
-                return await this.githubLoadPackageAsync(repopath, tag);
+                return await this.githubLoadPackageAsync(repopath, tag, fallbackPackageFiles);
             }
-            githubLoadPackageAsync(repopath, tag) {
-                return tagToShaAsync(repopath, tag)
-                    .then(sha => {
+            async githubLoadPackageAsync(repopath, tag, fallbackPackageFiles) {
+                try {
+                    const sha = await tagToShaAsync(repopath, tag);
                     // cache lookup
                     const key = `${repopath}/${sha}`;
                     let res = this.packages[key];
                     if (res) {
                         pxt.debug(`github cache ${repopath}/${tag}/text`);
-                        return Promise.resolve(pxt.U.clone(res));
+                        return copyCachedPackage(res);
                     }
                     // load and cache
                     pxt.log(`Downloading ${repopath}/${tag} -> ${sha}`);
-                    return downloadTextAsync(repopath, sha, pxt.CONFIG_NAME)
-                        .then(pkg => {
-                        const current = {
-                            files: {}
-                        };
-                        current.files[pxt.CONFIG_NAME] = pkg;
-                        const cfg = JSON.parse(pkg);
-                        return pxt.U.promiseMapAll(pxt.allPkgFiles(cfg).slice(1), fn => downloadTextAsync(repopath, sha, fn)
-                            .then(text => {
-                            current.files[fn] = text;
-                        }))
-                            .then(() => {
-                            // cache!
-                            this.packages[key] = current;
-                            return pxt.U.clone(current);
-                        });
+                    const pkg = await downloadTextAsync(repopath, sha, pxt.CONFIG_NAME);
+                    const current = {
+                        files: {}
+                    };
+                    current.files[pxt.CONFIG_NAME] = pkg;
+                    const cfg = JSON.parse(pkg);
+                    await pxt.U.promiseMapAll(pxt.allPkgFiles(cfg).slice(1), async (fn) => {
+                        current.files[fn] = await downloadTextAsync(repopath, sha, fn);
                     });
-                });
+                    // cache!
+                    this.packages[key] = current;
+                    return copyCachedPackage(current);
+                }
+                catch (e) {
+                    const fallbackPackage = cachedPackageFromFallback(fallbackPackageFiles);
+                    if (fallbackPackage)
+                        return fallbackPackage;
+                    throw e;
+                }
             }
             async loadTutorialMarkdown(repopath, tag) {
                 repopath = normalizeTutorialPath(repopath);
@@ -108920,7 +108962,7 @@ var pxt;
             return await github.db.loadConfigAsync(repopath, tag);
         }
         github.pkgConfigAsync = pkgConfigAsync;
-        async function downloadPackageAsync(repoWithTag, config) {
+        async function downloadPackageAsync(repoWithTag, config, fallbackPackageFiles) {
             const p = parseRepoId(repoWithTag);
             if (!p) {
                 pxt.log('Unknown GitHub syntax');
@@ -108933,9 +108975,17 @@ var pxt;
             }
             // always try to upgrade unbound versions
             if (!p.tag) {
-                p.tag = await github.db.latestVersionAsync(p.slug, config);
+                try {
+                    p.tag = await github.db.latestVersionAsync(p.slug, config);
+                }
+                catch (e) {
+                    const fallbackPackage = cachedPackageFromFallback(fallbackPackageFiles);
+                    if (fallbackPackage)
+                        return fallbackPackage;
+                    throw e;
+                }
             }
-            const cached = await github.db.loadPackageAsync(p.fullName, p.tag);
+            const cached = await github.db.loadPackageAsync(p.fullName, p.tag, fallbackPackageFiles);
             const dv = upgradedDisablesVariants(config, repoWithTag);
             if (dv) {
                 const cfg = pxt.Package.parseAndValidConfig(cached.files[pxt.CONFIG_NAME]);
@@ -108960,7 +109010,11 @@ var pxt;
             return { version, config };
         }
         github.downloadLatestPackageAsync = downloadLatestPackageAsync;
-        async function cacheProjectDependenciesAsync(cfg) {
+        async function cacheProjectDependenciesAsync(cfg, fallbackPackageFilesById) {
+            await cacheProjectDependenciesCoreAsync(cfg, {}, fallbackPackageFilesById);
+        }
+        github.cacheProjectDependenciesAsync = cacheProjectDependenciesAsync;
+        async function cacheProjectDependenciesCoreAsync(cfg, checked, fallbackPackageFilesById) {
             var _a;
             const ghExtensions = (_a = Object.keys(cfg.dependencies)) === null || _a === void 0 ? void 0 : _a.filter(dep => isGithubId(cfg.dependencies[dep]));
             if (ghExtensions.length) {
@@ -108968,14 +109022,19 @@ var pxt;
                 // Make sure external packages load before installing header.
                 await Promise.all(ghExtensions.map(async (ext) => {
                     const extSrc = cfg.dependencies[ext];
-                    const ghPkg = await downloadPackageAsync(extSrc, pkgConfig);
+                    if (checked[extSrc])
+                        return;
+                    checked[extSrc] = true;
+                    const ghPkg = await downloadPackageAsync(extSrc, pkgConfig, fallbackPackageFilesById === null || fallbackPackageFilesById === void 0 ? void 0 : fallbackPackageFilesById[extSrc]);
                     if (!ghPkg) {
                         throw new Error(lf("Cannot load extension {0} from {1}", ext, extSrc));
                     }
+                    const ghPkgCfg = pxt.Package.parseAndValidConfig(ghPkg.files[pxt.CONFIG_NAME]);
+                    if (ghPkgCfg)
+                        await cacheProjectDependenciesCoreAsync(ghPkgCfg, checked, fallbackPackageFilesById);
                 }));
             }
         }
-        github.cacheProjectDependenciesAsync = cacheProjectDependenciesAsync;
         let GitRepoStatus;
         (function (GitRepoStatus) {
             GitRepoStatus[GitRepoStatus["Unknown"] = 0] = "Unknown";
@@ -115025,7 +115084,7 @@ var pxt;
                 this.config.binaryonly ||
                 !opts.target.isNative;
             if (!noFileEmbed) {
-                const files = await this.filesToBePublishedAsync(true);
+                const files = await this.filesToBePublishedAsync(true, !pxt.appTarget.compile.useUF2);
                 const headerString = JSON.stringify({
                     name: this.config.name,
                     comment: this.config.description,
@@ -115097,25 +115156,61 @@ var pxt;
             cfg.files = cfg.files.filter(fn => fn !== pxt.HISTORY_FILE);
             return cfg;
         }
-        filesToBePublishedAsync(allowPrivate = false) {
+        async filesToBePublishedAsync(allowPrivate = false, packExternalExtensions = false) {
             const files = {};
-            return this.loadAsync()
-                .then(() => {
-                if (!allowPrivate && !this.config.public)
-                    pxt.U.userError('Only packages with "public":true can be published');
-                const cfg = this.prepareConfigToBePublished();
-                files[pxt.CONFIG_NAME] = pxt.Package.stringifyConfig(cfg);
-                for (let f of this.getFiles()) {
-                    // already stored
-                    if (f === pxt.CONFIG_NAME || f === pxt.HISTORY_FILE)
+            await this.loadAsync();
+            if (!allowPrivate && !this.config.public)
+                pxt.U.userError('Only packages with "public":true can be published');
+            const cfg = this.prepareConfigToBePublished();
+            files[pxt.CONFIG_NAME] = pxt.Package.stringifyConfig(cfg);
+            for (let f of this.getFiles()) {
+                // already stored
+                if (f === pxt.CONFIG_NAME || f === pxt.HISTORY_FILE)
+                    continue;
+                let str = this.readFile(f);
+                if (str == null)
+                    pxt.U.userError("referenced file missing: " + f);
+                files[f] = str;
+            }
+            if (packExternalExtensions) {
+                const packagedExtensions = this.packagedExternalExtensions();
+                if (Object.keys(packagedExtensions).length)
+                    files[pxt.PACKAGED_EXTENSIONS] = JSON.stringify(packagedExtensions);
+            }
+            return pxt.U.sortObjectFields(files);
+        }
+        packagedExternalExtensions() {
+            const packaged = {};
+            const seen = {};
+            const packDeps = (pkg) => {
+                for (const dep of pkg.resolvedDependencies()) {
+                    if (!dep)
                         continue;
-                    let str = this.readFile(f);
-                    if (str == null)
-                        pxt.U.userError("referenced file missing: " + f);
-                    files[f] = str;
+                    const seenKey = `${dep.id}:${dep.version()}`;
+                    if (seen[seenKey])
+                        continue;
+                    seen[seenKey] = true;
+                    if (dep.verProtocol() === "github" || dep.verProtocol() === "pub") {
+                        const depFiles = {};
+                        for (const fn of dep.getFiles()) {
+                            if (fn === pxt.CONFIG_NAME || fn === pxt.HISTORY_FILE)
+                                continue;
+                            const content = dep.readFile(fn);
+                            if (content != null)
+                                depFiles[fn] = content;
+                        }
+                        depFiles[pxt.CONFIG_NAME] = pxt.Package.stringifyConfig(dep.config);
+                        packaged[dep._verspec] = depFiles;
+                        if (dep.version() !== dep._verspec)
+                            packaged[dep.version()] = depFiles;
+                        if (dep.verProtocol() === "pub")
+                            packaged[dep.verArgument()] = depFiles;
+                    }
+                    packDeps(dep);
                 }
-                return pxt.U.sortObjectFields(files);
-            });
+            };
+            packDeps(this);
+            return packaged;
         }
         saveToJsonAsync() {
             return this.filesToBePublishedAsync(true)
@@ -116060,18 +116155,25 @@ var ts;
             const langLower = lang.toLowerCase();
             const attrJsLocsKey = langLower + "|jsdoc";
             const attrBlockLocsKey = langLower + "|block";
+            const attrAriaLabelLocsKey = langLower + "|ariaLabel";
             const loc = await mainPkg.localizationStringsAsync(lang);
             if (pxtc.apiLocalizationStrings)
                 pxtc.Util.jsonMergeFrom(loc, pxtc.apiLocalizationStrings);
             const toLocalize = pxtc.Util.values(apis.byQName).filter(fn => fn.attributes._translatedLanguageCode !== lang);
             await pxtc.Util.promiseMapAll(toLocalize, async (fn) => {
-                var _a, _b, _c;
+                var _a, _b, _c, _d;
                 const altLocSrc = fn.attributes.useLoc || fn.attributes.blockAliasFor;
                 const altLocSrcFn = altLocSrc && apis.byQName[altLocSrc];
                 if (fn.attributes._untranslatedJsDoc)
                     fn.attributes.jsDoc = fn.attributes._untranslatedJsDoc;
                 if (fn.attributes._untranslatedBlock)
-                    fn.attributes.jsDoc = fn.attributes._untranslatedBlock;
+                    fn.attributes.block = fn.attributes._untranslatedBlock;
+                if (fn.attributes._untranslatedAriaLabel)
+                    fn.attributes.ariaLabel = fn.attributes._untranslatedAriaLabel;
+                if (fn.attributes._untranslatedParamDefl) {
+                    fn.attributes.paramDefl = pxtc.U.clone(fn.attributes._untranslatedParamDefl);
+                    syncParameterDefaults(fn);
+                }
                 const lookupLoc = (locSuff, attrKey) => {
                     var _a, _b;
                     return loc[fn.qName + locSuff] || ((_a = fn.attributes.locs) === null || _a === void 0 ? void 0 : _a[attrKey])
@@ -116093,6 +116195,7 @@ var ts;
                 });
                 const nsDoc = loc['{id:category}' + pxtc.Util.capitalize(fn.qName)];
                 let locBlock = loc[`${fn.qName}|block`] || ((_b = fn.attributes.locs) === null || _b === void 0 ? void 0 : _b[attrBlockLocsKey]);
+                const locAriaLabel = loc[`${fn.qName}|ariaLabel`] || ((_c = fn.attributes.locs) === null || _c === void 0 ? void 0 : _c[attrAriaLabelLocsKey]);
                 if (fn.attributes.block) {
                     const comp = pxt.blocks.compileInfo(fn);
                     if (comp.handlerArgs) {
@@ -116107,20 +116210,35 @@ var ts;
                     }
                     const paramsWithLabels = comp.thisParameter ? [comp.thisParameter, ...comp.parameters] : comp.parameters;
                     for (const param of paramsWithLabels) {
-                        if (!param.labelLocalizationKey)
-                            continue;
-                        const locSuff = param.labelLocalizationKey.slice(fn.qName.length);
-                        const paramLabel = lookupLoc(locSuff, langLower + locSuff);
-                        if (paramLabel) {
-                            setBlockTranslationCacheKey(param.labelLocalizationKey, paramLabel);
+                        if (param.labelLocalizationKey) {
+                            const locSuff = param.labelLocalizationKey.slice(fn.qName.length);
+                            const paramLabel = lookupLoc(locSuff, langLower + locSuff);
+                            if (paramLabel) {
+                                setBlockTranslationCacheKey(param.labelLocalizationKey, paramLabel);
+                            }
+                            else {
+                                clearBlockTranslationCacheKey(param.labelLocalizationKey);
+                            }
                         }
-                        else {
-                            clearBlockTranslationCacheKey(param.labelLocalizationKey);
+                        const defaultString = pxt.blocks.parameterDefaultToLocalizationString(param.defaultValue, param.type);
+                        const defaultLocalizationKey = pxt.blocks.parameterDefaultLocalizationKey(fn.qName, param.actualName);
+                        if (defaultLocalizationKey && defaultString !== undefined) {
+                            const locSuff = defaultLocalizationKey.slice(fn.qName.length);
+                            const paramDefault = lookupLoc(locSuff, langLower + locSuff);
+                            if (paramDefault !== undefined) {
+                                if (!fn.attributes._untranslatedParamDefl) {
+                                    fn.attributes._untranslatedParamDefl = pxtc.U.clone(fn.attributes.paramDefl || {});
+                                }
+                                if (!fn.attributes.paramDefl)
+                                    fn.attributes.paramDefl = {};
+                                fn.attributes.paramDefl[param.actualName] = pxt.blocks.localizationStringToParameterDefault(paramDefault);
+                                syncParameterDefaults(fn);
+                            }
                         }
                     }
                 }
                 if (!locBlock && altLocSrcFn) {
-                    const otherTranslation = loc[`${altLocSrcFn.qName}|block`] || ((_c = altLocSrcFn.attributes.locs) === null || _c === void 0 ? void 0 : _c[attrBlockLocsKey]);
+                    const otherTranslation = loc[`${altLocSrcFn.qName}|block`] || ((_d = altLocSrcFn.attributes.locs) === null || _d === void 0 ? void 0 : _d[attrBlockLocsKey]);
                     const isSameBlockDef = fn.attributes.block === (altLocSrcFn.attributes._untranslatedBlock || altLocSrcFn.attributes.block);
                     if (isSameBlockDef && !!otherTranslation) {
                         locBlock = otherTranslation;
@@ -116177,11 +116295,24 @@ var ts;
                 else {
                     updateBlockDef(fn.attributes);
                 }
+                if (locAriaLabel) {
+                    if (!fn.attributes._untranslatedAriaLabel) {
+                        fn.attributes._untranslatedAriaLabel = fn.attributes.ariaLabel;
+                    }
+                    fn.attributes.ariaLabel = locAriaLabel;
+                }
                 fn.attributes._translatedLanguageCode = lang;
             });
             return cleanLocalizations(apis);
         }
         pxtc.localizeApisAsync = localizeApisAsync;
+        function syncParameterDefaults(fn) {
+            if (!fn.parameters)
+                return;
+            for (const param of fn.parameters) {
+                param.default = fn.attributes.paramDefl && fn.attributes.paramDefl[param.name];
+            }
+        }
         function cleanLocalizations(apis) {
             pxtc.Util.values(apis.byQName)
                 .filter(fb => fb.attributes.block && /^{[^:]+:[^}]+}/.test(fb.attributes.block))
@@ -116305,6 +116436,11 @@ var ts;
                             res.locs = {};
                         res.locs[n.slice("jsdoc.loc.".length).toLowerCase() + "|jsdoc"] = v;
                     }
+                    else if (pxtc.U.startsWith(n, "ariaLabel.loc.")) {
+                        if (!res.locs)
+                            res.locs = {};
+                        res.locs[n.slice("ariaLabel.loc.".length).toLowerCase() + "|ariaLabel"] = v;
+                    }
                     else if (pxtc.U.contains(n, ".loc.")) {
                         if (!res.locs)
                             res.locs = {};
@@ -124727,8 +124863,8 @@ var pxt;
         loadConfigAsync(repopath, tag) {
             return this.loadAsync(repopath, tag, "pxt", (r, t) => this.db.loadConfigAsync(r, t));
         }
-        loadPackageAsync(repopath, tag) {
-            return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t));
+        loadPackageAsync(repopath, tag, fallbackPackageFiles) {
+            return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t, fallbackPackageFiles));
         }
         loadTutorialMarkdown(repopath, tag) {
             return this.loadAsync(repopath, tag, "tutorial", (r, t) => this.db.loadTutorialMarkdown(r, t));
@@ -133951,7 +134087,7 @@ var ts;
         function inspect(n) {
             pxt.log(stringKind(n));
         }
-        // next free error 9284
+        // next free error 9285
         function userError(code, msg, secondary = false) {
             let e = new Error(msg);
             e.ksEmitterUserError = true;
@@ -137656,9 +137792,35 @@ ${lbl}: .short 0xffff
                 let v = emitExpr(node);
                 return v;
             }
+            function maybeWarnOnBareFunctionReference(node) {
+                if (!opts.enhancedErrors)
+                    return;
+                if (!node || node.kind !== pxtc.SK.Identifier)
+                    return;
+                if (hasPrecedingTsIgnoreComment(node))
+                    return;
+                const exprType = typeOf(node);
+                const signatures = exprType && !(exprType.flags & ts.TypeFlags.Any)
+                    && checker.getSignaturesOfType(exprType, ts.SignatureKind.Call);
+                if (signatures && signatures.length)
+                    warning(node, 9284, lf("Function reference used as a statement; did you mean to call it with '()'?"));
+            }
+            function hasPrecedingTsIgnoreComment(node) {
+                const src = node.getSourceFile();
+                const line = ts.getLineAndCharacterOfPosition(src, node.getStart(src)).line;
+                if (line <= 0)
+                    return false;
+                const lineStarts = src.getLineStarts();
+                const previousLineStart = lineStarts[line - 1];
+                const previousLineEnd = lineStarts[line];
+                const previousLine = src.text.slice(previousLineStart, previousLineEnd);
+                return /^\s*\/\/\s*@ts-ignore\b/.test(previousLine);
+            }
             function emitExprAsStmt(node) {
-                if (isNoopExpr(node))
+                if (isNoopExpr(node)) {
+                    maybeWarnOnBareFunctionReference(node);
                     return;
+                }
                 emitBrk(node);
                 let v = emitIgnored(node);
                 proc.emitExpr(v);
@@ -138640,6 +138802,14 @@ var ts;
             });
         }
         pxtc.patchUpDiagnostics = patchUpDiagnostics;
+        function hasErrorDiagnostics(diags) {
+            return diags.some(d => d.category == pxtc.DiagnosticCategory.Error);
+        }
+        pxtc.hasErrorDiagnostics = hasErrorDiagnostics;
+        function hasBlockingDiagnostics(opts, diags) {
+            return opts.enhancedErrors ? hasErrorDiagnostics(diags) : diags.length > 0;
+        }
+        pxtc.hasBlockingDiagnostics = hasBlockingDiagnostics;
         function py2tsIfNecessary(opts) {
             if (opts.target.preferredEditor == pxt.PYTHON_PROJECT_NAME) {
                 let res = pxtc.transpile.pyToTs(opts);
@@ -138766,26 +138936,26 @@ var ts;
             }
             else {
                 runConversionsAndStoreResults(opts, res);
-                if (res.diagnostics.length > 0)
+                if (hasBlockingDiagnostics(opts, res.diagnostics))
                     return res;
                 program = buildProgram(opts, res);
             }
             const entryPoint = opts.sourceFiles.filter(f => pxtc.U.endsWith(f, ".ts")).pop().replace(/.*\//, "");
             // First get and report any syntactic errors.
-            res.diagnostics = patchUpDiagnostics(program.getSyntacticDiagnostics(), opts.ignoreFileResolutionErrors);
-            if (res.diagnostics.length > 0) {
+            res.diagnostics = res.diagnostics.concat(patchUpDiagnostics(program.getSyntacticDiagnostics(), opts.ignoreFileResolutionErrors));
+            if (hasBlockingDiagnostics(opts, res.diagnostics)) {
                 if (opts.forceEmit) {
                     pxt.debug('syntactic errors, forcing emit');
                     pxtc.compileBinary(program, opts, res, entryPoint);
                 }
                 return res;
             }
-            // If we didn't have any syntactic errors, then also try getting the global and
+            // If we didn't have any blocking syntactic errors, then also try getting the global and
             // semantic errors.
-            res.diagnostics = patchUpDiagnostics(program.getOptionsDiagnostics().concat(pxtc.Util.toArray(program.getGlobalDiagnostics())), opts.ignoreFileResolutionErrors);
+            res.diagnostics = res.diagnostics.concat(patchUpDiagnostics(program.getOptionsDiagnostics().concat(pxtc.Util.toArray(program.getGlobalDiagnostics())), opts.ignoreFileResolutionErrors));
             const semStart = pxtc.U.cpuUs();
-            if (res.diagnostics.length == 0) {
-                res.diagnostics = patchUpDiagnostics(program.getSemanticDiagnostics(), opts.ignoreFileResolutionErrors);
+            if (!hasBlockingDiagnostics(opts, res.diagnostics)) {
+                res.diagnostics = res.diagnostics.concat(patchUpDiagnostics(program.getSemanticDiagnostics(), opts.ignoreFileResolutionErrors));
             }
             const emitStart = pxtc.U.cpuUs();
             res.times["typescript-syn"] = semStart - startTime;
@@ -138794,12 +138964,12 @@ var ts;
             if (opts.ast) {
                 res.ast = program;
             }
-            if (opts.ast || opts.forceEmit || res.diagnostics.length == 0) {
+            if (opts.ast || opts.forceEmit || !hasBlockingDiagnostics(opts, res.diagnostics)) {
                 const binOutput = pxtc.compileBinary(program, opts, res, entryPoint);
                 res.times["compilebinary"] = pxtc.U.cpuUs() - emitStart;
                 res.diagnostics = res.diagnostics.concat(patchUpDiagnostics(binOutput.diagnostics));
             }
-            if (res.diagnostics.length == 0)
+            if (!hasBlockingDiagnostics(opts, res.diagnostics))
                 res.success = true;
             for (let f of opts.sourceFiles) {
                 if (pxtc.Util.startsWith(f, "built/"))
@@ -142580,6 +142750,11 @@ var ts;
                         if (param.labelLocalizationKey && param.label) {
                             locStrings[param.labelLocalizationKey] = param.label;
                         }
+                        const defaultString = pxt.blocks.parameterDefaultToLocalizationString(param.defaultValue, param.type);
+                        const defaultLocalizationKey = pxt.blocks.parameterDefaultLocalizationKey(si.qName, param.actualName);
+                        if (defaultLocalizationKey && defaultString !== undefined) {
+                            locStrings[defaultLocalizationKey] = defaultString;
+                        }
                     }
                     if ((_a = comp.handlerArgs) === null || _a === void 0 ? void 0 : _a.length) {
                         for (const arg of comp.handlerArgs) {
@@ -142587,6 +142762,9 @@ var ts;
                         }
                     }
                 }
+                if (si.attributes.ariaLabel) {
+                    locStrings[`${si.qName}|ariaLabel`] = si.attributes.ariaLabel;
+                }
             };
             const mapLocs = (m, name) => {
                 if (!options.locs)
@@ -142609,6 +142787,8 @@ var ts;
                 enumMembers.forEach(em => {
                     if (em.attributes.block)
                         locStrings[`${em.qName}|block`] = em.attributes.block;
+                    if (em.attributes.ariaLabel)
+                        locStrings[`${em.qName}|ariaLabel`] = em.attributes.ariaLabel;
                     if (em.attributes.jsDoc)
                         locStrings[em.qName] = em.attributes.jsDoc;
                 });
@@ -143519,7 +143699,8 @@ var ts;
                 for (let k of Object.keys(newFS))
                     service_1.host.setFile(k, newFS[k]); // update version numbers
                 res.fileSystem = pxtc.U.flatClone(newFS);
-                if (res.diagnostics.length == 0) {
+                if (!pxtc.hasBlockingDiagnostics(service_1.host.opts, res.diagnostics)) {
+                    const conversionDiagnostics = res.diagnostics;
                     service_1.host.opts.skipPxtModulesEmit = false;
                     service_1.host.opts.skipPxtModulesTSC = false;
                     const currKey = service_1.host.opts.target.isNative ? "native" : "js";
@@ -143534,13 +143715,13 @@ var ts;
                             service_1.host.opts.skipPxtModulesEmit = true;
                     }
                     let ts2asm = pxtc.compile(service_1.host.opts, service_1.service);
-                    res = Object.assign({ sourceMap: res.sourceMap, fileSystem: res.fileSystem }, ts2asm);
-                    if (res.needsFullRecompile || ((!res.success || res.diagnostics.length) && service_1.host.opts.clearIncrBuildAndRetryOnError)) {
+                    res = Object.assign(Object.assign({ sourceMap: res.sourceMap, fileSystem: res.fileSystem }, ts2asm), { diagnostics: conversionDiagnostics.concat(ts2asm.diagnostics) });
+                    if (res.needsFullRecompile || ((!res.success || pxtc.hasBlockingDiagnostics(service_1.host.opts, res.diagnostics)) && service_1.host.opts.clearIncrBuildAndRetryOnError)) {
                         pxt.debug("triggering full recompile");
                         pxt.tickEvent("compile.fullrecompile");
                         service_1.host.opts.skipPxtModulesEmit = false;
                         ts2asm = pxtc.compile(service_1.host.opts, service_1.service);
-                        res = Object.assign({ sourceMap: res.sourceMap }, ts2asm);
+                        res = Object.assign(Object.assign({ sourceMap: res.sourceMap }, ts2asm), { diagnostics: conversionDiagnostics.concat(ts2asm.diagnostics) });
                     }
                     if (res.diagnostics.every(d => !pxtc.isPxtModulesFilename(d.fileName)))
                         service_1.host.pxtModulesOK = currKey;
@@ -164195,8 +164376,8 @@ class FileGithubDb {
     loadConfigAsync(repopath, tag) {
         return this.loadAsync(repopath, tag, "pxt", (r, t) => this.db.loadConfigAsync(r, t));
     }
-    loadPackageAsync(repopath, tag) {
-        return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t));
+    loadPackageAsync(repopath, tag, fallbackPackageFiles) {
+        return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t, fallbackPackageFiles));
     }
     loadTutorialMarkdown(repopath, tag) {
         return this.loadAsync(repopath, tag, "tutorial", (r, t) => this.db.loadTutorialMarkdown(r, t));

package/built/pxtcompiler.d.ts

@@ -753,6 +753,12 @@ declare namespace ts.pxtc {
     function getTsCompilerOptions(opts: CompileOptions): any;
     function nodeLocationInfo(node: ts.Node): LocationInfo;
     function patchUpDiagnostics(diags: ReadonlyArray<Diagnostic>, ignoreFileResolutionErorrs?: boolean): KsDiagnostic[];
+    function hasErrorDiagnostics(diags: ReadonlyArray<{
+        category: DiagnosticCategory;
+    }>): boolean;
+    function hasBlockingDiagnostics(opts: CompileOptions, diags: ReadonlyArray<{
+        category: DiagnosticCategory;
+    }>): boolean;
     function py2tsIfNecessary(opts: CompileOptions): transpile.TranspileResult | undefined;
     function storeGeneratedFiles(opts: CompileOptions, res: CompileResult): void;
     function runConversionsAndStoreResults(opts: CompileOptions, res?: CompileResult): CompileResult;