pxt-core 12.3.20 → 12.3.22

package/built/pxtcompiler.js

@@ -38,8 +38,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));
@@ -9262,7 +9262,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;
@@ -12967,9 +12967,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);
@@ -13951,6 +13977,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);
@@ -14077,26 +14111,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;
@@ -14105,12 +14139,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/"))
@@ -17891,6 +17925,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) {
@@ -17898,6 +17937,9 @@ var ts;
                         }
                     }
                 }
+                if (si.attributes.ariaLabel) {
+                    locStrings[`${si.qName}|ariaLabel`] = si.attributes.ariaLabel;
+                }
             };
             const mapLocs = (m, name) => {
                 if (!options.locs)
@@ -17920,6 +17962,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;
                 });
@@ -18830,7 +18874,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";
@@ -18845,13 +18890,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;

package/built/pxtlib.d.ts

@@ -733,6 +733,7 @@ declare namespace pxt {
     const TUTORIAL_CODE_STOP = "_onCodeStop.ts";
     const TUTORIAL_INFO_FILE = "tutorial-info-cache.json";
     const TUTORIAL_CUSTOM_TS = "tutorial.custom.ts";
+    const PACKAGED_EXTENSIONS = "_packaged-extensions.json";
     const BREAKPOINT_TABLET = 991;
     const PALETTES_FILE = "_palettes.json";
     const HISTORY_FILE = "_history";
@@ -786,6 +787,9 @@ declare namespace pxt.blocks {
         inBlockDef: boolean;
         localizationKey: string;
     }
+    function parameterDefaultLocalizationKey(qName: string, actualName: string): string;
+    function parameterDefaultToLocalizationString(defaultValue: string, type?: string): string;
+    function localizationStringToParameterDefault(value: string): string;
     const builtinFunctionInfo: pxt.Map<{
         params: string[];
         blockId: string;
@@ -1159,6 +1163,7 @@ declare namespace pxt.hexloader {
     let hideLoading: () => void;
     function storeWithLimitAsync(host: Host, idxkey: string, newkey: string, newval: string, maxLen?: number): Promise<void>;
     function recordGetAsync(host: Host, idxkey: string, newkey: string): Promise<void>;
+    function stringifyHexInfoForCache(hexInfo: pxtc.HexInfo): string;
     function getHexInfoAsync(host: Host, extInfo: pxtc.ExtensionInfo, cloudModule?: any): Promise<pxtc.HexInfo>;
 }
 declare namespace pxt.crowdin {
@@ -1467,7 +1472,7 @@ declare namespace pxt.github {
     interface IGithubDb {
         latestVersionAsync(repopath: string, config: PackagesConfig): Promise<string>;
         loadConfigAsync(repopath: string, tag: string): Promise<pxt.PackageConfig>;
-        loadPackageAsync(repopath: string, tag: string): Promise<CachedPackage>;
+        loadPackageAsync(repopath: string, tag: string, fallbackPackageFiles?: pxt.Map<string>): Promise<CachedPackage>;
         loadTutorialMarkdown(repopath: string, tag?: string): Promise<CachedPackage>;
         cacheReposAsync(response: GHTutorialResponse): Promise<void>;
     }
@@ -1480,7 +1485,7 @@ declare namespace pxt.github {
         private cacheConfig;
         loadConfigAsync(repopath: string, tag: string): Promise<pxt.PackageConfig>;
         latestVersionAsync(repopath: string, config: PackagesConfig): Promise<string>;
-        loadPackageAsync(repopath: string, tag: string): Promise<CachedPackage>;
+        loadPackageAsync(repopath: string, tag: string, fallbackPackageFiles?: pxt.Map<string>): Promise<CachedPackage>;
         private githubLoadPackageAsync;
         loadTutorialMarkdown(repopath: string, tag?: string): Promise<GHTutorialRepoInfo>;
         cacheReposAsync(resp: GHTutorialResponse): Promise<void>;
@@ -1525,12 +1530,12 @@ declare namespace pxt.github {
     function listRefsAsync(repopath: string, namespace?: string, useProxy?: boolean, noCache?: boolean): Promise<string[]>;
     function listRefsExtAsync(repopath: string, namespace?: string, useProxy?: boolean, noCache?: boolean): Promise<RefsResult>;
     function pkgConfigAsync(repopath: string, tag: string, config: pxt.PackagesConfig): Promise<PackageConfig>;
-    function downloadPackageAsync(repoWithTag: string, config: pxt.PackagesConfig): Promise<CachedPackage>;
+    function downloadPackageAsync(repoWithTag: string, config: pxt.PackagesConfig, fallbackPackageFiles?: pxt.Map<string>): Promise<CachedPackage>;
     function downloadLatestPackageAsync(repo: ParsedRepo, useProxy?: boolean, noCache?: boolean): Promise<{
         version: string;
         config: pxt.PackageConfig;
     }>;
-    function cacheProjectDependenciesAsync(cfg: pxt.PackageConfig): Promise<void>;
+    function cacheProjectDependenciesAsync(cfg: pxt.PackageConfig, fallbackPackageFilesById?: pxt.Map<pxt.Map<string>>): Promise<void>;
     interface User {
         login: string;
         id: number;
@@ -2159,7 +2164,8 @@ declare namespace pxt {
         resolveBannedCategories(): string[];
         getCompileOptionsAsync(target?: pxtc.CompileTarget): Promise<pxtc.CompileOptions>;
         private prepareConfigToBePublished;
-        filesToBePublishedAsync(allowPrivate?: boolean): Promise<Map<string>>;
+        filesToBePublishedAsync(allowPrivate?: boolean, packExternalExtensions?: boolean): Promise<Map<string>>;
+        private packagedExternalExtensions;
         saveToJsonAsync(): Promise<pxt.cpp.HexFile>;
         compressToFileAsync(): Promise<Uint8Array>;
         computePartDefinitions(parts: string[]): pxt.Map<pxsim.PartDefinition>;