pxt-core 7.5.2 → 7.5.5

package/built/pxtblocks.d.ts

@@ -39,6 +39,7 @@ declare namespace pxt.blocks {
         alreadyDeclared?: BlockDeclarationType;
         firstReference?: Blockly.Block;
         isAssigned?: boolean;
+        isFunctionParameter?: boolean;
     }
     function compileExpression(e: Environment, b: Blockly.Block, comments: string[]): JsNode;
     interface Environment {

package/built/pxtblocks.js

@@ -179,7 +179,7 @@ var pxt;
                 }
                 else if (b.type == "argument_reporter_array") {
                     if (!tp) {
-                        tp = ground("any[]");
+                        tp = lookup(e, b, b.getFieldValue("VALUE")).type;
                     }
                 }
                 if (tp)
@@ -492,8 +492,14 @@ var pxt;
             // Last pass: if some variable has no type (because it was never used or
             // assigned to), just unify it with int...
             e.allVariables.forEach((v) => {
-                if (getConcreteType(v.type).type == null)
-                    union(v.type, ground(v.type.isArrayType ? "number[]" : pNumber.type));
+                if (getConcreteType(v.type).type == null) {
+                    if (!v.isFunctionParameter) {
+                        union(v.type, ground(v.type.isArrayType ? "number[]" : pNumber.type));
+                    }
+                    else if (v.type.isArrayType) {
+                        v.type.type = "any[]";
+                    }
+                }
             });
             function connectionCheck(i) {
                 return i.name ? i.connection && i.connection.check_ && i.connection.check_.length ? i.connection.check_[0] : "T" : undefined;
@@ -582,9 +588,31 @@ var pxt;
         function compileNumber(e, b, comments) {
             return blocks_1.H.mkNumberLiteral(extractNumber(b));
         }
+        function isNumericLiteral(e, b) {
+            if (!b)
+                return false;
+            if (b.type === "math_number" || b.type === "math_integer" || b.type === "math_number_minmax" || b.type === "math_whole_number") {
+                return true;
+            }
+            const blockInfo = e.stdCallTable[b.type];
+            if (!blockInfo)
+                return false;
+            const { comp } = blockInfo;
+            if (blockInfo.attrs.shim === "TD_ID" && comp.parameters.length === 1) {
+                const fieldValue = b.getFieldValue(comp.parameters[0].definitionName);
+                if (fieldValue) {
+                    return !isNaN(parseInt(fieldValue));
+                }
+                else {
+                    return isNumericLiteral(e, getInputTargetBlock(b, comp.parameters[0].definitionName));
+                }
+            }
+            return false;
+        }
+        function isLiteral(e, b) {
+            return isNumericLiteral(e, b) || b.type === "logic_boolean" || b.type === "text";
+        }
         let opToTok = {
-            // POWER gets a special treatment because there's no operator for it in
-            // TouchDevelop
             "ADD": "+",
             "MINUS": "-",
             "MULTIPLY": "*",
@@ -599,11 +627,21 @@ var pxt;
             "NEQ": "!=",
             "POWER": "**"
         };
+        function isComparisonOp(op) {
+            return ["LT", "LTE", "GT", "GTE", "EQ", "NEQ"].indexOf(op) !== -1;
+        }
         function compileArithmetic(e, b, comments) {
             let bOp = b.getFieldValue("OP");
             let left = getInputTargetBlock(b, "A");
             let right = getInputTargetBlock(b, "B");
             let args = [compileExpression(e, left, comments), compileExpression(e, right, comments)];
+            // Special handling for the case of comparing two literals (e.g. 0 === 5). TypeScript
+            // throws an error if we don't first cast to any
+            if (isComparisonOp(bOp) && isLiteral(e, left) && isLiteral(e, right)) {
+                if (blocks_1.flattenNode([args[0]]).output !== blocks_1.flattenNode([args[1]]).output) {
+                    args = args.map(arg => blocks_1.H.mkParenthesizedExpression(blocks_1.mkGroup([arg, blocks_1.mkText(" as any")])));
+                }
+            }
             let t = returnType(e, left).type;
             if (t == pString.type) {
                 if (bOp == "EQ")
@@ -711,7 +749,10 @@ var pxt;
             const stmts = getInputTargetBlock(b, "STACK");
             const argsDeclaration = b.getArguments().map(a => {
                 if (a.type == "Array") {
-                    return `${escapeVarName(a.name, e)}: any[]`;
+                    const binding = lookup(e, b, a.name);
+                    const declaredType = getConcreteType(binding.type);
+                    const paramType = ((declaredType === null || declaredType === void 0 ? void 0 : declaredType.type) && declaredType.type !== "Array") ? declaredType.type : "any[]";
+                    return `${escapeVarName(a.name, e)}: ${paramType}`;
                 }
                 return `${escapeVarName(a.name, e)}: ${a.type}`;
             });
@@ -1859,7 +1900,7 @@ var pxt;
             return res;
         }
         function getEscapedCBParameters(b, stdfun, e) {
-            return getCBParameters(b, stdfun).map(binding => lookup(e, b, binding[0]).escapedName);
+            return getCBParameters(b, stdfun).map(binding => lookup(e, b, binding.name).escapedName);
         }
         function getCBParameters(b, stdfun) {
             let handlerArgs = [];
@@ -1875,7 +1916,10 @@ var pxt;
                         varName = varBlock && varBlock.getField("VAR").getText();
                     }
                     if (varName !== null) {
-                        handlerArgs.push([varName, mkPoint(arg.type)]);
+                        handlerArgs.push({
+                            name: varName,
+                            type: mkPoint(arg.type)
+                        });
                     }
                     else {
                         break;
@@ -1888,7 +1932,10 @@ var pxt;
                     const varField = b.getField("HANDLER_" + arg.name);
                     const varName = varField && varField.getText();
                     if (varName !== null) {
-                        handlerArgs.push([varName, mkPoint(arg.type)]);
+                        handlerArgs.push({
+                            name: varName,
+                            type: mkPoint(arg.type)
+                        });
                     }
                     else {
                         break;
@@ -2091,11 +2138,7 @@ var pxt;
                 }
                 if (hasStatementInput(block)) {
                     const vars = getDeclaredVariables(block, e).map(binding => {
-                        return {
-                            name: binding[0],
-                            type: binding[1],
-                            id: id++
-                        };
+                        return Object.assign(Object.assign({}, binding), { id: id++ });
                     });
                     let parentScope = currentScope;
                     if (vars.length) {
@@ -2179,17 +2222,37 @@ var pxt;
             switch (block.type) {
                 case 'pxt_controls_for':
                 case 'controls_simple_for':
-                    return [[getLoopVariableField(block).getField("VAR").getText(), pNumber]];
+                    return [{
+                            name: getLoopVariableField(block).getField("VAR").getText(),
+                            type: pNumber
+                        }];
                 case 'pxt_controls_for_of':
                 case 'controls_for_of':
-                    return [[getLoopVariableField(block).getField("VAR").getText(), mkPoint(null)]];
+                    return [{
+                            name: getLoopVariableField(block).getField("VAR").getText(),
+                            type: mkPoint(null)
+                        }];
+                case 'function_definition':
+                    return block.getArguments().filter(arg => arg.type === "Array")
+                        .map(arg => {
+                        const point = mkPoint(null);
+                        point.isArrayType = true;
+                        return {
+                            name: arg.name,
+                            type: point,
+                            isFunctionParameter: true
+                        };
+                    });
                 default:
                     break;
             }
             if (isMutatingBlock(block)) {
                 const declarations = block.mutation.getDeclaredVariables();
                 if (declarations) {
-                    return Object.keys(declarations).map(varName => [varName, mkPoint(declarations[varName])]);
+                    return Object.keys(declarations).map(varName => ({
+                        name: varName,
+                        type: mkPoint(declarations[varName])
+                    }));
                 }
             }
             let stdFunc = e.stdCallTable[block.type];
@@ -4078,21 +4141,9 @@ var pxt;
                 || (nsinfo && nsinfo.attributes.color)
                 || pxt.toolbox.getNamespaceColor(ns)
                 || 255;
-            if (fn.attributes.help) {
-                const helpUrl = fn.attributes.help.replace(/^\//, '');
-                if (/^github:/.test(helpUrl)) {
-                    block.setHelpUrl(helpUrl);
-                }
-                else if (helpUrl !== "none") {
-                    block.setHelpUrl("/reference/" + helpUrl);
-                }
-            }
-            else if (fn.pkg && !pxt.appTarget.bundledpkgs[fn.pkg]) { // added package
-                let anchor = fn.qName.toLowerCase().split('.');
-                if (anchor[0] == fn.pkg)
-                    anchor.shift();
-                block.setHelpUrl(`/pkg/${fn.pkg}#${encodeURIComponent(anchor.join('-'))}`);
-            }
+            const helpUrl = pxt.blocks.getHelpUrl(fn);
+            if (helpUrl)
+                block.setHelpUrl(helpUrl);
             block.setColour(color);
             let blockShape = Blockly.OUTPUT_SHAPE_ROUND;
             if (fn.retType == "boolean")
@@ -5428,10 +5479,13 @@ var pxt;
                         }
                     }
                     xmlList[xmlList.length - 1].setAttribute('gap', '24');
-                    if (Blockly.Blocks['variables_set']) {
-                        let gap = Blockly.Blocks['variables_change'] ? 8 : 24;
+                    if (Blockly.Blocks['variables_change'] || Blockly.Blocks['variables_set']) {
+                        xmlList.unshift(createFlyoutGroupLabel("Your Variables"));
+                    }
+                    if (Blockly.Blocks['variables_change']) {
+                        let gap = Blockly.Blocks['variables_get'] ? 20 : 8;
                         let blockText = '<xml>' +
-                            '<block type="variables_set" gap="' + gap + '">' +
+                            '<block type="variables_change" gap="' + gap + '">' +
                             Blockly.Variables.generateVariableFieldXmlString(mostRecentVariable) +
                             '</block>' +
                             '</xml>';
@@ -5444,16 +5498,16 @@ var pxt;
                             value.appendChild(shadow);
                             let field = goog.dom.createDom('field');
                             field.setAttribute('name', 'NUM');
-                            field.appendChild(document.createTextNode("0"));
+                            field.appendChild(document.createTextNode("1"));
                             shadow.appendChild(field);
                             block.appendChild(value);
                         }
-                        xmlList.push(block);
+                        xmlList.unshift(block);
                     }
-                    if (Blockly.Blocks['variables_change']) {
-                        let gap = Blockly.Blocks['variables_get'] ? 20 : 8;
+                    if (Blockly.Blocks['variables_set']) {
+                        let gap = Blockly.Blocks['variables_change'] ? 8 : 24;
                         let blockText = '<xml>' +
-                            '<block type="variables_change" gap="' + gap + '">' +
+                            '<block type="variables_set" gap="' + gap + '">' +
                             Blockly.Variables.generateVariableFieldXmlString(mostRecentVariable) +
                             '</block>' +
                             '</xml>';
@@ -5466,11 +5520,11 @@ var pxt;
                             value.appendChild(shadow);
                             let field = goog.dom.createDom('field');
                             field.setAttribute('name', 'NUM');
-                            field.appendChild(document.createTextNode("1"));
+                            field.appendChild(document.createTextNode("0"));
                             shadow.appendChild(field);
                             block.appendChild(value);
                         }
-                        xmlList.push(block);
+                        xmlList.unshift(block);
                     }
                 }
                 return xmlList;
@@ -5862,6 +5916,8 @@ var pxt;
                 const elems = oldFlyout(workspace);
                 if (elems.length > 1) {
                     let returnBlock = mkReturnStatementBlock();
+                    // Add divider
+                    elems.splice(1, 0, createFlyoutGroupLabel("Your Functions"));
                     // Insert after the "make a function" button
                     elems.splice(1, 0, returnBlock);
                 }

package/built/pxtcompiler.js

@@ -32,6 +32,9 @@ var pxt;
                 });
             });
         }
+        latestVersionAsync(repopath, config) {
+            return this.db.latestVersionAsync(repopath, config);
+        }
         loadConfigAsync(repopath, tag) {
             return this.loadAsync(repopath, tag, "pxt", (r, t) => this.db.loadConfigAsync(r, t));
         }
@@ -4620,6 +4623,8 @@ ${output}</xml>`;
                                 return getTaggedTemplateExpression(n);
                             case SK.CallExpression:
                                 return getStatementBlock(n, undefined, undefined, true);
+                            case SK.AsExpression:
+                                return getOutputBlock(n.expression);
                             default:
                                 error(n, pxtc.Util.lf("Unsupported syntax kind for output expression block: {0}", SK[n.kind]));
                                 break;
@@ -5500,11 +5505,14 @@ ${output}</xml>`;
                         r.mutationChildren = [];
                         n.parameters.forEach(p => {
                             const paramName = p.name.getText();
+                            let type = normalizeType(p.type.getText());
+                            if (pxt.U.endsWith(type, "[]"))
+                                type = "Array";
                             r.mutationChildren.push({
                                 nodeName: "arg",
                                 attributes: {
                                     name: paramName,
-                                    type: p.type.getText(),
+                                    type,
                                     id: env.functionParamIds[name][paramName]
                                 }
                             });
@@ -5580,11 +5588,14 @@ ${output}</xml>`;
                                     env.declaredFunctions[name].parameters.forEach((p, i) => {
                                         const paramName = p.name.getText();
                                         const argId = env.functionParamIds[name][paramName];
+                                        let type = normalizeType(p.type.getText());
+                                        if (pxt.U.endsWith(type, "[]"))
+                                            type = "Array";
                                         r.mutationChildren.push({
                                             nodeName: "arg",
                                             attributes: {
                                                 name: paramName,
-                                                type: p.type.getText(),
+                                                type: type,
                                                 id: argId
                                             }
                                         });
@@ -6452,7 +6463,8 @@ ${output}</xml>`;
                                 if (!type) {
                                     return pxtc.Util.lf("Function parameters must declare a type");
                                 }
-                                if (env.opts.allowedArgumentTypes.indexOf(normalizeType(type)) === -1) {
+                                const normalized = normalizeType(type);
+                                if (env.opts.allowedArgumentTypes.indexOf(normalized) === -1 && !pxtc.U.endsWith(normalized, "[]")) {
                                     return pxtc.Util.lf("Only types that can be added in blocks can be used for function arguments");
                                 }
                             }
@@ -6727,6 +6739,8 @@ ${output}</xml>`;
                         return checkStatement(n, env, true, undefined);
                     case SK.TaggedTemplateExpression:
                         return checkTaggedTemplateExpression(n, env);
+                    case SK.AsExpression:
+                        return checkAsExpression(n);
                 }
                 return pxtc.Util.lf("Unsupported syntax kind for output expression block: {0}", SK[n.kind]);
                 function checkStringLiteral(n) {
@@ -6823,6 +6837,31 @@ ${output}</xml>`;
                 // The compiler will have already caught any invalid tags or templates
                 return undefined;
             }
+            function checkAsExpression(n) {
+                // The only time we allow casts to decompile is in the very special case where someone has
+                // written a program comparing two string, boolean, or numeric literals in blocks and
+                // converted to text. e.g. 3 == 5 or true != false
+                if (n.type.getText().trim() === "any" && (ts.isStringOrNumericLiteral(n.expression) ||
+                    n.expression.kind === SK.TrueKeyword || n.expression.kind === SK.FalseKeyword)) {
+                    const [parent] = getParent(n);
+                    if (parent.kind === SK.BinaryExpression) {
+                        switch (parent.operatorToken.kind) {
+                            case SK.EqualsEqualsToken:
+                            case SK.EqualsEqualsEqualsToken:
+                            case SK.ExclamationEqualsToken:
+                            case SK.ExclamationEqualsEqualsToken:
+                            case SK.LessThanToken:
+                            case SK.LessThanEqualsToken:
+                            case SK.GreaterThanToken:
+                            case SK.GreaterThanEqualsToken:
+                                return undefined;
+                            default:
+                                break;
+                        }
+                    }
+                }
+                return pxtc.Util.lf("Casting not supported in blocks");
+            }
             function getParent(node) {
                 if (!node.parent) {
                     return [undefined, node];
@@ -12615,8 +12654,10 @@ ${lbl}: .short 0xffff
                     return needsNumberConversions() ? pxtc.ir.rtcall("pxt::toInt", [e]) : e;
                 };
                 // c = a[i]
-                if (iterVar)
+                if (iterVar) {
                     proc.emitExpr(iterVar.storeByRef(pxtc.ir.rtcall(indexer, [collectionVar.loadCore(), toInt(intVarIter.loadCore())])));
+                    emitBrk(node.initializer);
+                }
                 flushHoistedFunctionDefinitions();
                 emit(node.statement);
                 proc.emitLblDirect(l.cont);

package/built/pxtlib.d.ts

@@ -552,6 +552,7 @@ declare namespace pxt {
         multiUrl?: string;
         asseteditorUrl?: string;
         skillmapUrl?: string;
+        authcodeUrl?: string;
         isStatic?: boolean;
         verprefix?: string;
     }
@@ -656,6 +657,7 @@ declare namespace pxt.blocks {
     function normalizeBlock(b: string, err?: (msg: string) => void): string;
     function compileInfo(fn: pxtc.SymbolInfo): BlockCompileInfo;
     function hasHandler(fn: pxtc.SymbolInfo): boolean;
+    function getHelpUrl(fn: pxtc.SymbolInfo): string;
     /**
      * Returns which Blockly block type to use for an argument reporter based
      * on the specified TypeScript type.
@@ -1215,16 +1217,19 @@ declare namespace pxt.github {
         files: Map<string>;
     }
     interface IGithubDb {
+        latestVersionAsync(repopath: string, config: PackagesConfig): Promise<string>;
         loadConfigAsync(repopath: string, tag: string): Promise<pxt.PackageConfig>;
         loadPackageAsync(repopath: string, tag: string): Promise<CachedPackage>;
     }
     function isOrgAsync(owner: string): Promise<boolean>;
     class MemoryGithubDb implements IGithubDb {
+        private latestVersions;
         private configs;
         private packages;
         private proxyWithCdnLoadPackageAsync;
         private cacheConfig;
         loadConfigAsync(repopath: string, tag: string): Promise<pxt.PackageConfig>;
+        latestVersionAsync(repopath: string, config: PackagesConfig): Promise<string>;
         loadPackageAsync(repopath: string, tag: string): Promise<CachedPackage>;
         private githubLoadPackageAsync;
     }
@@ -1260,7 +1265,7 @@ declare namespace pxt.github {
     function forkRepoAsync(repopath: string, commitid: string, pref?: string): Promise<string>;
     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): Promise<PackageConfig>;
+    function pkgConfigAsync(repopath: string, tag: string, config: pxt.PackagesConfig): Promise<PackageConfig>;
     function downloadPackageAsync(repoWithTag: string, config: pxt.PackagesConfig): Promise<CachedPackage>;
     function downloadLatestPackageAsync(repo: ParsedRepo): Promise<{
         version: string;
@@ -1311,7 +1316,7 @@ declare namespace pxt.github {
     function toGithubDependencyPath(path: string, tag?: string): string;
     function isGithubId(id: string): boolean;
     function stringifyRepo(p: ParsedRepo): string;
-    function normalizeRepoId(id: string): string;
+    function normalizeRepoId(id: string, defaultTag?: string): string;
     function join(...parts: string[]): string;
     function upgradedPackageReference(cfg: PackagesConfig, id: string): string;
     function upgradedPackageId(cfg: PackagesConfig, id: string): string;

package/built/pxtlib.js

@@ -3909,6 +3909,25 @@ var pxt;
             });
         }
         blocks.hasHandler = hasHandler;
+        function getHelpUrl(fn) {
+            if (fn.attributes.help) {
+                const helpUrl = fn.attributes.help.replace(/^\//, '');
+                if (/^github:/.test(helpUrl)) {
+                    return helpUrl;
+                }
+                else if (helpUrl !== "none") {
+                    return "/reference/" + helpUrl;
+                }
+            }
+            else if (fn.pkg && !pxt.appTarget.bundledpkgs[fn.pkg]) { // added package
+                let anchor = fn.qName.toLowerCase().split('.');
+                if (anchor[0] == fn.pkg)
+                    anchor.shift();
+                return `/pkg/${fn.pkg}#${encodeURIComponent(anchor.join('-'))}`;
+            }
+            return undefined;
+        }
+        blocks.getHelpUrl = getHelpUrl;
         /**
          * Returns which Blockly block type to use for an argument reporter based
          * on the specified TypeScript type.
@@ -3920,6 +3939,9 @@ var pxt;
             if (varType === "boolean" || varType === "number" || varType === "string") {
                 reporterType = `argument_reporter_${varType}`;
             }
+            if (/^(?:Array<(?:.+)>)|(?:(?:.+)\[\])$/.test(varType)) {
+                reporterType = "argument_reporter_array";
+            }
             return reporterType;
         }
         blocks.reporterTypeForArgType = reporterTypeForArgType;
@@ -9827,6 +9849,7 @@ var pxt;
         github.isOrgAsync = isOrgAsync;
         class MemoryGithubDb {
             constructor() {
+                this.latestVersions = {};
                 this.configs = {};
                 this.packages = {};
             }
@@ -9849,8 +9872,10 @@ var pxt;
                 return pxt.U.clone(cfg);
             }
             async loadConfigAsync(repopath, tag) {
-                if (!tag)
+                if (!tag) {
+                    pxt.debug(`dep: default to master branch`);
                     tag = "master";
+                }
                 // cache lookup
                 const key = `${repopath}/${tag}`;
                 let res = this.configs[key];
@@ -9873,9 +9898,19 @@ var pxt;
                 const cfg = await downloadTextAsync(repopath, tag, pxt.CONFIG_NAME);
                 return this.cacheConfig(key, cfg);
             }
+            async latestVersionAsync(repopath, config) {
+                let resolved = this.latestVersions[repopath];
+                if (!resolved) {
+                    pxt.debug(`dep: resolve latest version of ${repopath}`);
+                    this.latestVersions[repopath] = resolved = await pxt.github.latestVersionAsync(repopath, config, true, false);
+                }
+                return resolved;
+            }
             async loadPackageAsync(repopath, tag) {
-                if (!tag)
+                if (!tag) {
+                    pxt.debug(`load pkg: default to master branch`);
                     tag = "master";
+                }
                 // try using github proxy first
                 if (hasProxy()) {
                     try {
@@ -10191,34 +10226,38 @@ var pxt;
                 .then(resolveRefAsync, e => ghGetJsonAsync(`https://api.github.com/repos/${parsed.slug}/git/refs/heads/${tag}`)
                 .then(resolveRefAsync));
         }
-        function pkgConfigAsync(repopath, tag = "master") {
-            return github.db.loadConfigAsync(repopath, tag);
+        async function pkgConfigAsync(repopath, tag, config) {
+            if (!tag)
+                tag = await github.db.latestVersionAsync(repopath, config);
+            return await github.db.loadConfigAsync(repopath, tag);
         }
         github.pkgConfigAsync = pkgConfigAsync;
-        function downloadPackageAsync(repoWithTag, config) {
+        async function downloadPackageAsync(repoWithTag, config) {
             const p = parseRepoId(repoWithTag);
             if (!p) {
                 pxt.log('Unknown GitHub syntax');
-                return Promise.resolve(undefined);
+                return undefined;
             }
             if (isRepoBanned(p, config)) {
                 pxt.tickEvent("github.download.banned");
                 pxt.log('Github repo is banned');
-                return Promise.resolve(undefined);
+                return undefined;
             }
-            return github.db.loadPackageAsync(p.fullName, p.tag)
-                .then(cached => {
-                const dv = upgradedDisablesVariants(config, repoWithTag);
-                if (dv) {
-                    const cfg = pxt.Package.parseAndValidConfig(cached.files[pxt.CONFIG_NAME]);
-                    if (cfg) {
-                        pxt.log(`auto-disable ${dv.join(",")} due to targetconfig entry for ${repoWithTag}`);
-                        cfg.disablesVariants = dv;
-                        cached.files[pxt.CONFIG_NAME] = pxt.Package.stringifyConfig(cfg);
-                    }
+            // always try to upgrade unbound versions
+            if (!p.tag) {
+                p.tag = await github.db.latestVersionAsync(p.slug, config);
+            }
+            const cached = await github.db.loadPackageAsync(p.fullName, p.tag);
+            const dv = upgradedDisablesVariants(config, repoWithTag);
+            if (dv) {
+                const cfg = pxt.Package.parseAndValidConfig(cached.files[pxt.CONFIG_NAME]);
+                if (cfg) {
+                    pxt.log(`auto-disable ${dv.join(",")} due to targetconfig entry for ${repoWithTag}`);
+                    cfg.disablesVariants = dv;
+                    cached.files[pxt.CONFIG_NAME] = pxt.Package.stringifyConfig(cfg);
                 }
-                return cached;
-            });
+            }
+            return cached;
         }
         github.downloadPackageAsync = downloadPackageAsync;
         async function downloadLatestPackageAsync(repo) {
@@ -10228,7 +10267,7 @@ var pxt;
             const repoWithTag = `${repo.fullName}#${tag}`;
             await pxt.github.downloadPackageAsync(repoWithTag, packageConfig);
             // return config
-            const config = await pkgConfigAsync(repo.fullName, tag);
+            const config = await pkgConfigAsync(repo.fullName, tag, packageConfig);
             const version = `github:${repoWithTag}`;
             return { version, config };
         }
@@ -10558,14 +10597,15 @@ var pxt;
         }
         github.isGithubId = isGithubId;
         function stringifyRepo(p) {
-            return p ? "github:" + p.fullName.toLowerCase() + "#" + (p.tag || "master") : undefined;
+            return p ? "github:" + p.fullName.toLowerCase() + (p.tag ? `#${p.tag}` : '') : undefined;
         }
         github.stringifyRepo = stringifyRepo;
-        function normalizeRepoId(id) {
+        function normalizeRepoId(id, defaultTag) {
             const gid = parseRepoId(id);
             if (!gid)
                 return undefined;
-            gid.tag = gid.tag || "master";
+            if (!gid.tag && defaultTag)
+                gid.tag = defaultTag;
             return stringifyRepo(gid);
         }
         github.normalizeRepoId = normalizeRepoId;
@@ -13707,22 +13747,20 @@ var pxt;
                 && json.dependencies && Object.keys(json.dependencies).every(k => typeof json.dependencies[k] === "string")
                 && json;
         }
-        static getConfigAsync(pkgTargetVersion, id, fullVers) {
-            return Promise.resolve().then(() => {
-                if (pxt.github.isGithubId(fullVers)) {
-                    const repoInfo = pxt.github.parseRepoId(fullVers);
-                    return pxt.packagesConfigAsync()
-                        .then(config => pxt.github.repoAsync(repoInfo.fullName, config)) // Make sure repo exists and is whitelisted
-                        .then(gitRepo => gitRepo ? pxt.github.pkgConfigAsync(repoInfo.fullName, repoInfo.tag) : null);
-                }
-                else {
-                    // If it's not from GH, assume it's a bundled package
-                    // TODO: Add logic for shared packages if we enable that
-                    const updatedRef = pxt.patching.upgradePackageReference(pkgTargetVersion, id, fullVers);
-                    const bundledPkg = pxt.appTarget.bundledpkgs[updatedRef];
-                    return JSON.parse(bundledPkg[pxt.CONFIG_NAME]);
-                }
-            });
+        static async getConfigAsync(pkgTargetVersion, id, fullVers) {
+            if (pxt.github.isGithubId(fullVers)) {
+                const repoInfo = pxt.github.parseRepoId(fullVers);
+                const packagesConfig = await pxt.packagesConfigAsync();
+                const gitRepo = await pxt.github.repoAsync(repoInfo.fullName, packagesConfig); // Make sure repo exists and is whitelisted
+                return gitRepo ? await pxt.github.pkgConfigAsync(repoInfo.fullName, repoInfo.tag, packagesConfig) : null;
+            }
+            else {
+                // If it's not from GH, assume it's a bundled package
+                // TODO: Add logic for shared packages if we enable that
+                const updatedRef = pxt.patching.upgradePackageReference(pkgTargetVersion, id, fullVers);
+                const bundledPkg = pxt.appTarget.bundledpkgs[updatedRef];
+                return JSON.parse(bundledPkg[pxt.CONFIG_NAME]);
+            }
         }
         static corePackages() {
             const pkgs = pxt.appTarget.bundledpkgs;