pxt-core 12.3.20 → 12.3.21

package/built/pxtlib.js

@@ -4236,6 +4236,8 @@ 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.PACKAGED_EXT_INFO = "_packaged-ext-info.json";
     pxt.BREAKPOINT_TABLET = 991; // TODO (shakao) revisit when tutorial stuff is more settled
     pxt.PALETTES_FILE = "_palettes.json";
     pxt.HISTORY_FILE = "_history";
@@ -4282,6 +4284,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 = {
@@ -8063,6 +8089,19 @@ 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 storeHexInfoCacheEntryAsync(host, sha, cachedHexInfo) {
+            if (!sha || !cachedHexInfo)
+                return Promise.resolve();
+            return storeWithLimitAsync(host, "hex-keys", "hex-" + sha, cachedHexInfo);
+        }
+        hexloader.storeHexInfoCacheEntryAsync = storeHexInfoCacheEntryAsync;
         function getHexInfoAsync(host, extInfo, cloudModule) {
             if (!extInfo.sha)
                 return Promise.resolve(null);
@@ -8091,10 +8130,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 => {
@@ -10686,6 +10722,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";
@@ -10797,7 +10845,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";
@@ -10805,45 +10853,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);
@@ -11199,7 +11248,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');
@@ -11212,9 +11261,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]);
@@ -11239,7 +11296,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) {
@@ -11247,14 +11308,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";
@@ -17304,7 +17370,10 @@ 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 packagedExtInfo = this.packagedExtensionHexInfo(opts);
+                if (Object.keys(packagedExtInfo).length)
+                    files[pxt.PACKAGED_EXT_INFO] = JSON.stringify(packagedExtInfo);
                 const headerString = JSON.stringify({
                     name: this.config.name,
                     comment: this.config.description,
@@ -17376,25 +17445,75 @@ 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;
+                    const seenKey = `${dep.id}:${dep.version()}`;
+                    if (seen[seenKey])
                         continue;
-                    let str = this.readFile(f);
-                    if (str == null)
-                        pxt.U.userError("referenced file missing: " + f);
-                    files[f] = str;
+                    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;
+        }
+        packagedExtensionHexInfo(opts) {
+            var _a;
+            const packaged = {};
+            const targets = [opts, ...(opts.otherMultiVariants || [])];
+            for (const target of targets) {
+                const extInfo = target.extinfo;
+                if (!(extInfo === null || extInfo === void 0 ? void 0 : extInfo.sha) || !((_a = extInfo.hexinfo) === null || _a === void 0 ? void 0 : _a.hex))
+                    continue;
+                const serialized = pxt.hexloader.stringifyHexInfoForCache(extInfo.hexinfo);
+                if (serialized)
+                    packaged[extInfo.sha] = serialized;
+            }
+            return packaged;
         }
         saveToJsonAsync() {
             return this.filesToBePublishedAsync(true)
@@ -18351,6 +18470,10 @@ var ts;
                     fn.attributes.jsDoc = fn.attributes._untranslatedJsDoc;
                 if (fn.attributes._untranslatedBlock)
                     fn.attributes.jsDoc = fn.attributes._untranslatedBlock;
+                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])
@@ -18386,15 +18509,30 @@ 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);
+                            }
                         }
                     }
                 }
@@ -18461,6 +18599,13 @@ var ts;
             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))