pxt-core 9.3.13 → 9.3.15

package/README.md

@@ -114,6 +114,17 @@ npm install -g svgo
 svgo svgicons/myicon.svg
 ```
 
+### Shared Styling
+
+When adding a CSS color or other style element that will be shared across editor targets (e.g. micro:bit, Arcade) and sub-applications (a.k.a. "CRAs", like skillmap, teachertool, etc.). Declare a CSS variable for it in `theme/themepacks.less`:
+
+1. Add the new variable to the `:root` pseudo-class. Choose a reasonable default value according to the guidlines in the file.
+2. Add the new variable to all theme classes defined in that file. At the time of this writing, only `theme-highcontrast` is defined. Choose a value that works well for the given theme.
+3. Add the new variable to the theme overrides for each target. This will be done in the target repo's `theme/themepacks.less` file (e.g. pxt-microbit, pxt-arcade).
+
+Variables declared this way will be available to CRAs at runtime, and they will be initialized with the override values defined by the target in which they're running.
+
+
 ### Documentation Highlighting
 
 In the documentation, highlighting of code snippets uses highlight.js (hljs).

package/built/cli.js

@@ -2403,8 +2403,13 @@ async function buildAndWatchTargetAsync(includeSourceMaps, rebundle) {
         }
         else {
             console.log("rebuilding css");
-            await buildSemanticUIAsync();
-            console.log("css build complete");
+            try {
+                await buildSemanticUIAsync();
+                console.log("css build complete");
+            }
+            catch (e) {
+                console.error("css build failed", e);
+            }
         }
         return lessFiles;
     };

package/built/pxt.js

@@ -99066,6 +99066,11 @@ var ts;
                 }
             }
             Util.fileReadAsTextAsync = fileReadAsTextAsync;
+            function sanitizeFileName(name) {
+                /* eslint-disable no-control-regex */
+                return name.replace(/[()\\\/.,?*^:<>!;'#$%^&|"@+=«»°{}\[\]¾½¼³²¦¬¤¢£~­¯¸`±\x00-\x1F]/g, '').trim().replace(/\s+/g, '-');
+            }
+            Util.sanitizeFileName = sanitizeFileName;
             function repeatMap(n, fn) {
                 n = n || 0;
                 let r = [];
@@ -100104,7 +100109,7 @@ var ts;
                 "sk": { englishName: "Slovak", localizedName: "Slovenčina" },
                 "sl": { englishName: "Slovenian", localizedName: "Slovenski" },
                 "sq": { englishName: "Albanian", localizedName: "shqip" },
-                "sr": { englishName: "Serbian (Latin)", localizedName: "Srpski" },
+                "sr": { englishName: "Serbian (Cyrillic)", localizedName: "Srpski" },
                 "su": { englishName: "Sundanese", localizedName: "ᮘᮞ ᮞᮥᮔ᮪ᮓ" },
                 "sv-SE": { englishName: "Swedish", localizedName: "Svenska" },
                 "sw": { englishName: "Swahili", localizedName: "Kiswahili" },
@@ -101617,6 +101622,7 @@ var pxt;
     var blocks;
     (function (blocks) {
         const THIS_NAME = "this";
+        blocks.showBlockIdInTooltip = false;
         // The JS Math functions supported in the blocks. The order of this array
         // determines the order of the dropdown in the math_js_op block
         blocks.MATH_FUNCTIONS = {
@@ -102318,6 +102324,21 @@ var pxt;
                     }));
                 });
             }
+            if (pxt.blocks.showBlockIdInTooltip) {
+                for (const id of Object.keys(_blockDefinitions)) {
+                    const tooltip = _blockDefinitions[id].tooltip;
+                    if (typeof tooltip === "object" && tooltip !== null) {
+                        for (const innerKey in tooltip) {
+                            if (tooltip.hasOwnProperty(innerKey)) {
+                                _blockDefinitions[id].tooltip[innerKey] = `${tooltip[innerKey]} (id: ${id})`;
+                            }
+                        }
+                    }
+                    else {
+                        _blockDefinitions[id].tooltip = `${_blockDefinitions[id].tooltip} (id: ${id})`;
+                    }
+                }
+            }
         }
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
@@ -103680,6 +103701,26 @@ var pxt;
             }
         }
         BrowserUtils.legacyCopyText = legacyCopyText;
+        /**
+         * Sets the theme of the application by adding a class to the body. Themes
+         * are defined in CSS variable packs. The default theme is defined in
+         * `themes/themepacks.less`, in the `:root` pseudoclass. `highcontrast` is
+         * also defined there. Target-specific themes are defined in the target
+         * repo's `theme/themepack.less`.
+         */
+        function setApplicationTheme(theme) {
+            const body = document.body;
+            const classes = body.classList;
+            for (let i = 0; i < classes.length; i++) {
+                if (/^theme-/.test(classes[i])) {
+                    body.classList.remove(classes[i]);
+                }
+            }
+            if (theme) {
+                body.classList.add(`theme-${theme}`);
+            }
+        }
+        BrowserUtils.setApplicationTheme = setApplicationTheme;
     })(BrowserUtils = pxt.BrowserUtils || (pxt.BrowserUtils = {}));
 })(pxt || (pxt = {}));
 var pxt;
@@ -117164,6 +117205,14 @@ var pxt;
     })(svgUtil = pxt.svgUtil || (pxt.svgUtil = {}));
 })(pxt || (pxt = {}));
 var pxt;
+(function (pxt) {
+    var editor;
+    (function (editor) {
+        editor.initExtensionsAsync = opts => Promise.resolve({});
+        editor.initFieldExtensionsAsync = opts => Promise.resolve({});
+    })(editor = pxt.editor || (pxt.editor = {}));
+})(pxt || (pxt = {}));
+var pxt;
 (function (pxt) {
     pxt.IMAGE_MIME_TYPE = "image/x-mkcd-f4";
     pxt.TILEMAP_MIME_TYPE = "application/mkcd-tilemap";
@@ -162971,8 +163020,13 @@ async function buildAndWatchTargetAsync(includeSourceMaps, rebundle) {
         }
         else {
             console.log("rebuilding css");
-            await buildSemanticUIAsync();
-            console.log("css build complete");
+            try {
+                await buildSemanticUIAsync();
+                console.log("css build complete");
+            }
+            catch (e) {
+                console.error("css build failed", e);
+            }
         }
         return lessFiles;
     };

package/built/pxtblockly.js

@@ -7919,7 +7919,7 @@ var pxt;
             const hasHandlers = hasArrowFunction(fn);
             block.setPreviousStatement(!(hasHandlers && !fn.attributes.handlerStatement) && fn.retType == "void");
             block.setNextStatement(!(hasHandlers && !fn.attributes.handlerStatement) && fn.retType == "void");
-            block.setTooltip(/^__/.test(fn.namespace) ? "" : fn.attributes.jsDoc);
+            block.setTooltip((/^__/.test(fn.namespace) ? "" : fn.attributes.jsDoc) + (pxt.blocks.showBlockIdInTooltip ? " (id: '" + fn.attributes.blockId + "')" : ""));
             function buildBlockFromDef(def, expanded = false) {
                 let anonIndex = 0;
                 let firstParam = !expanded && !!comp.thisParameter;
@@ -11525,66 +11525,56 @@ var pxt;
 (function (pxt) {
     var blocks;
     (function (blocks) {
-        class Rubric {
-            constructor(criteria) {
-                this.criteria = criteria;
-            }
-        }
-        blocks.Rubric = Rubric;
-        function parseRubric(rubric) {
-            let rubricObj;
-            try {
-                rubricObj = JSON.parse(rubric);
-            }
-            catch (e) {
-                console.error(`Error parsing rubric! ${e}`);
-                return null;
-            }
-            if (!rubricObj.criteria) {
-                console.error(`No criteria found in rubric`);
-                return null;
-            }
-            const criteria = rubricObj.criteria.map((c) => {
-                return blocks.getCriteria(c);
-            }).filter((r) => !!r);
-            return new Rubric(criteria);
+        const maxConcurrentChecks = 4;
+        async function runValidatorPlanAsync(usedBlocks, plan) {
+            // Each plan can have multiple checks it needs to run.
+            // Run all of them in parallel, and then check if the number of successes is greater than the specified threshold.
+            // TBD if it's faster to run in parallel without short-circuiting once the threshold is reached, or if it's faster to run sequentially and short-circuit.
+            const startTime = Date.now();
+            const checkRuns = pxt.Util.promisePoolAsync(maxConcurrentChecks, plan.checks, async (check) => {
+                switch (check.validator) {
+                    case "blocksExist":
+                        return runBlocksExistValidation(usedBlocks, check);
+                    case "blockCommentsExist":
+                        return runValidateBlockCommentsExist(usedBlocks, check);
+                    case "specificBlockCommentsExist":
+                        return runValidateSpecificBlockCommentsExist(usedBlocks, check);
+                    case "blocksInSetExist":
+                        return runBlocksInSetExistValidation(usedBlocks, check);
+                    default:
+                        pxt.debug(`Unrecognized validator: ${check.validator}`);
+                        return false;
+                }
+            });
+            const results = await checkRuns;
+            const successCount = results.filter((r) => r).length;
+            const passed = successCount >= plan.threshold;
+            pxt.tickEvent("validation.evaluation_complete", {
+                plan: plan.name,
+                durationMs: Date.now() - startTime,
+                passed: `${passed}`,
+            });
+            return passed;
         }
-        blocks.parseRubric = parseRubric;
-    })(blocks = pxt.blocks || (pxt.blocks = {}));
-})(pxt || (pxt = {}));
-var pxt;
-(function (pxt) {
-    var blocks;
-    (function (blocks) {
-        function getCriteria(data) {
-            switch (data.criteriaId) {
-                case "blockCheck":
-                    return new BlockCheckCriteria(data.displayText, data.blockRequirements);
-                case "comment":
-                    return new CommentCriteria(data.displayText, data.count);
-                default:
-                    console.error(`Unrecognized criteriaId: ${data.criteriaId}`);
-                    return null;
-            }
+        blocks.runValidatorPlanAsync = runValidatorPlanAsync;
+        function runBlocksExistValidation(usedBlocks, inputs) {
+            const blockResults = blocks.validateBlocksExist({ usedBlocks, requiredBlockCounts: inputs.blockCounts });
+            const success = blockResults.disabledBlocks.length === 0 &&
+                blockResults.missingBlocks.length === 0 &&
+                blockResults.insufficientBlocks.length === 0;
+            return success;
         }
-        blocks.getCriteria = getCriteria;
-        class RubricCriteria {
-            constructor(displayText) {
-                this.displayText = displayText;
-            }
+        function runValidateBlockCommentsExist(usedBlocks, inputs) {
+            const blockResults = blocks.validateBlockCommentsExist({ usedBlocks, numRequired: inputs.count });
+            return blockResults.passed;
         }
-        blocks.RubricCriteria = RubricCriteria;
-        class BlockCheckCriteria extends RubricCriteria {
-            constructor(displayText, blockRequirements) {
-                super(displayText);
-                this.blockRequirements = blockRequirements;
-            }
+        function runValidateSpecificBlockCommentsExist(usedBlocks, inputs) {
+            const blockResults = blocks.validateSpecificBlockCommentsExist({ usedBlocks, blockType: inputs.blockType });
+            return blockResults.passed;
         }
-        class CommentCriteria extends RubricCriteria {
-            constructor(displayText, count) {
-                super(displayText);
-                this.count = count;
-            }
+        function runBlocksInSetExistValidation(usedBlocks, inputs) {
+            const blockResults = blocks.validateBlocksInSetExist({ usedBlocks, blockIdsToCheck: inputs.blocks, count: inputs.count });
+            return blockResults.passed;
         }
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
@@ -11624,6 +11614,56 @@ var pxt;
         blocks.validateBlocksExist = validateBlocksExist;
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var blocks;
+    (function (blocks) {
+        // validates that a combination of blocks in the set satisfies the required count
+        // returns the blocks that make the validator pass
+        function validateBlocksInSetExist({ usedBlocks, blockIdsToCheck, count, requireUnique }) {
+            const successfulBlocks = [];
+            const enabledBlocks = usedBlocks.filter((block) => block.isEnabled());
+            for (const block of blockIdsToCheck) {
+                const blockInstances = enabledBlocks.filter((b) => b.type === block);
+                if (requireUnique && blockInstances.length >= 1) {
+                    successfulBlocks.push(blockInstances[0]);
+                }
+                else {
+                    successfulBlocks.push(...blockInstances);
+                }
+            }
+            return { successfulBlocks, passed: successfulBlocks.length >= count };
+        }
+        blocks.validateBlocksInSetExist = validateBlocksInSetExist;
+    })(blocks = pxt.blocks || (pxt.blocks = {}));
+})(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var blocks;
+    (function (blocks) {
+        // validates that one or more blocks comments are in the project
+        // returns the blocks that have comments for teacher tool scenario
+        function validateBlockCommentsExist({ usedBlocks, numRequired }) {
+            const commentedBlocks = usedBlocks.filter((block) => !!block.getCommentText());
+            return { commentedBlocks, passed: commentedBlocks.length >= numRequired };
+        }
+        blocks.validateBlockCommentsExist = validateBlockCommentsExist;
+    })(blocks = pxt.blocks || (pxt.blocks = {}));
+})(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var blocks;
+    (function (blocks) {
+        // validates that all of a specific block type have comments
+        // returns the blocks that do not have comments for a tutorial validation scenario
+        function validateSpecificBlockCommentsExist({ usedBlocks, blockType }) {
+            const allSpecifcBlocks = usedBlocks.filter((block) => block.type === blockType);
+            const uncommentedBlocks = allSpecifcBlocks.filter((block) => !block.getCommentText());
+            return { uncommentedBlocks, passed: uncommentedBlocks.length === 0 };
+        }
+        blocks.validateSpecificBlockCommentsExist = validateSpecificBlockCommentsExist;
+    })(blocks = pxt.blocks || (pxt.blocks = {}));
+})(pxt || (pxt = {}));
 var pxtblockly;
 (function (pxtblockly) {
     class FieldBase extends Blockly.Field {

package/built/pxtblocks.d.ts

@@ -393,30 +393,12 @@ declare namespace pxt.blocks {
     function initMathRoundBlock(): void;
 }
 declare namespace pxt.blocks {
-    class Rubric {
-        criteria: RubricCriteria[];
-        constructor(criteria: RubricCriteria[]);
+    interface EvaluationResult {
+        result: boolean;
     }
-    function parseRubric(rubric: string): Rubric;
 }
 declare namespace pxt.blocks {
-    interface BlockSet {
-        blocks: string[];
-        count: number;
-    }
-    export interface CriteriaData {
-        criteriaId: string;
-        displayText: string;
-        blockRequirements?: BlockSet[];
-        count?: number;
-    }
-    export function getCriteria(data: CriteriaData): RubricCriteria;
-    export abstract class RubricCriteria {
-        displayText: string;
-        abstract criteriaId: string;
-        constructor(displayText: string);
-    }
-    export {};
+    function runValidatorPlanAsync(usedBlocks: Blockly.Block[], plan: ValidatorPlan): Promise<boolean>;
 }
 declare namespace pxt.blocks {
     function validateBlocksExist({ usedBlocks, requiredBlockCounts }: {
@@ -428,6 +410,62 @@ declare namespace pxt.blocks {
         insufficientBlocks: string[];
     };
 }
+declare namespace pxt.blocks {
+    function validateBlocksInSetExist({ usedBlocks, blockIdsToCheck, count, requireUnique }: {
+        usedBlocks: Blockly.Block[];
+        blockIdsToCheck: string[];
+        count: number;
+        requireUnique?: boolean;
+    }): {
+        successfulBlocks: Blockly.Block[];
+        passed: boolean;
+    };
+}
+declare namespace pxt.blocks {
+    function validateBlockCommentsExist({ usedBlocks, numRequired }: {
+        usedBlocks: Blockly.Block[];
+        numRequired: number;
+    }): {
+        commentedBlocks: Blockly.Block[];
+        passed: boolean;
+    };
+}
+declare namespace pxt.blocks {
+    function validateSpecificBlockCommentsExist({ usedBlocks, blockType }: {
+        usedBlocks: Blockly.Block[];
+        blockType: string;
+    }): {
+        uncommentedBlocks: Blockly.Block[];
+        passed: boolean;
+    };
+}
+declare namespace pxt.blocks {
+    interface ValidatorPlan {
+        name: string;
+        threshold: number;
+        checks: ValidatorCheckBase[];
+    }
+    interface ValidatorCheckBase {
+        validator: string;
+    }
+    interface BlocksExistValidatorCheck extends ValidatorCheckBase {
+        validator: "blocksExist";
+        blockCounts: pxt.Map<number>;
+    }
+    interface BlockCommentsExistValidatorCheck extends ValidatorCheckBase {
+        validator: "blockCommentsExist";
+        count: number;
+    }
+    interface SpecificBlockCommentsExistValidatorCheck extends ValidatorCheckBase {
+        validator: "specificBlockCommentsExist";
+        blockType: string;
+    }
+    interface BlocksInSetExistValidatorCheck extends ValidatorCheckBase {
+        validator: "blocksInSetExist";
+        blocks: string[];
+        count: number;
+    }
+}
 declare namespace pxtblockly {
     abstract class FieldBase<U> extends Blockly.Field implements Blockly.FieldCustom {
         isFieldCustom_: true;

package/built/pxtblocks.js

@@ -4357,7 +4357,7 @@ var pxt;
             const hasHandlers = hasArrowFunction(fn);
             block.setPreviousStatement(!(hasHandlers && !fn.attributes.handlerStatement) && fn.retType == "void");
             block.setNextStatement(!(hasHandlers && !fn.attributes.handlerStatement) && fn.retType == "void");
-            block.setTooltip(/^__/.test(fn.namespace) ? "" : fn.attributes.jsDoc);
+            block.setTooltip((/^__/.test(fn.namespace) ? "" : fn.attributes.jsDoc) + (pxt.blocks.showBlockIdInTooltip ? " (id: '" + fn.attributes.blockId + "')" : ""));
             function buildBlockFromDef(def, expanded = false) {
                 let anonIndex = 0;
                 let firstParam = !expanded && !!comp.thisParameter;
@@ -7963,66 +7963,56 @@ var pxt;
 (function (pxt) {
     var blocks;
     (function (blocks) {
-        class Rubric {
-            constructor(criteria) {
-                this.criteria = criteria;
-            }
-        }
-        blocks.Rubric = Rubric;
-        function parseRubric(rubric) {
-            let rubricObj;
-            try {
-                rubricObj = JSON.parse(rubric);
-            }
-            catch (e) {
-                console.error(`Error parsing rubric! ${e}`);
-                return null;
-            }
-            if (!rubricObj.criteria) {
-                console.error(`No criteria found in rubric`);
-                return null;
-            }
-            const criteria = rubricObj.criteria.map((c) => {
-                return blocks.getCriteria(c);
-            }).filter((r) => !!r);
-            return new Rubric(criteria);
+        const maxConcurrentChecks = 4;
+        async function runValidatorPlanAsync(usedBlocks, plan) {
+            // Each plan can have multiple checks it needs to run.
+            // Run all of them in parallel, and then check if the number of successes is greater than the specified threshold.
+            // TBD if it's faster to run in parallel without short-circuiting once the threshold is reached, or if it's faster to run sequentially and short-circuit.
+            const startTime = Date.now();
+            const checkRuns = pxt.Util.promisePoolAsync(maxConcurrentChecks, plan.checks, async (check) => {
+                switch (check.validator) {
+                    case "blocksExist":
+                        return runBlocksExistValidation(usedBlocks, check);
+                    case "blockCommentsExist":
+                        return runValidateBlockCommentsExist(usedBlocks, check);
+                    case "specificBlockCommentsExist":
+                        return runValidateSpecificBlockCommentsExist(usedBlocks, check);
+                    case "blocksInSetExist":
+                        return runBlocksInSetExistValidation(usedBlocks, check);
+                    default:
+                        pxt.debug(`Unrecognized validator: ${check.validator}`);
+                        return false;
+                }
+            });
+            const results = await checkRuns;
+            const successCount = results.filter((r) => r).length;
+            const passed = successCount >= plan.threshold;
+            pxt.tickEvent("validation.evaluation_complete", {
+                plan: plan.name,
+                durationMs: Date.now() - startTime,
+                passed: `${passed}`,
+            });
+            return passed;
         }
-        blocks.parseRubric = parseRubric;
-    })(blocks = pxt.blocks || (pxt.blocks = {}));
-})(pxt || (pxt = {}));
-var pxt;
-(function (pxt) {
-    var blocks;
-    (function (blocks) {
-        function getCriteria(data) {
-            switch (data.criteriaId) {
-                case "blockCheck":
-                    return new BlockCheckCriteria(data.displayText, data.blockRequirements);
-                case "comment":
-                    return new CommentCriteria(data.displayText, data.count);
-                default:
-                    console.error(`Unrecognized criteriaId: ${data.criteriaId}`);
-                    return null;
-            }
+        blocks.runValidatorPlanAsync = runValidatorPlanAsync;
+        function runBlocksExistValidation(usedBlocks, inputs) {
+            const blockResults = blocks.validateBlocksExist({ usedBlocks, requiredBlockCounts: inputs.blockCounts });
+            const success = blockResults.disabledBlocks.length === 0 &&
+                blockResults.missingBlocks.length === 0 &&
+                blockResults.insufficientBlocks.length === 0;
+            return success;
         }
-        blocks.getCriteria = getCriteria;
-        class RubricCriteria {
-            constructor(displayText) {
-                this.displayText = displayText;
-            }
+        function runValidateBlockCommentsExist(usedBlocks, inputs) {
+            const blockResults = blocks.validateBlockCommentsExist({ usedBlocks, numRequired: inputs.count });
+            return blockResults.passed;
         }
-        blocks.RubricCriteria = RubricCriteria;
-        class BlockCheckCriteria extends RubricCriteria {
-            constructor(displayText, blockRequirements) {
-                super(displayText);
-                this.blockRequirements = blockRequirements;
-            }
+        function runValidateSpecificBlockCommentsExist(usedBlocks, inputs) {
+            const blockResults = blocks.validateSpecificBlockCommentsExist({ usedBlocks, blockType: inputs.blockType });
+            return blockResults.passed;
         }
-        class CommentCriteria extends RubricCriteria {
-            constructor(displayText, count) {
-                super(displayText);
-                this.count = count;
-            }
+        function runBlocksInSetExistValidation(usedBlocks, inputs) {
+            const blockResults = blocks.validateBlocksInSetExist({ usedBlocks, blockIdsToCheck: inputs.blocks, count: inputs.count });
+            return blockResults.passed;
         }
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
@@ -8062,6 +8052,56 @@ var pxt;
         blocks.validateBlocksExist = validateBlocksExist;
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var blocks;
+    (function (blocks) {
+        // validates that a combination of blocks in the set satisfies the required count
+        // returns the blocks that make the validator pass
+        function validateBlocksInSetExist({ usedBlocks, blockIdsToCheck, count, requireUnique }) {
+            const successfulBlocks = [];
+            const enabledBlocks = usedBlocks.filter((block) => block.isEnabled());
+            for (const block of blockIdsToCheck) {
+                const blockInstances = enabledBlocks.filter((b) => b.type === block);
+                if (requireUnique && blockInstances.length >= 1) {
+                    successfulBlocks.push(blockInstances[0]);
+                }
+                else {
+                    successfulBlocks.push(...blockInstances);
+                }
+            }
+            return { successfulBlocks, passed: successfulBlocks.length >= count };
+        }
+        blocks.validateBlocksInSetExist = validateBlocksInSetExist;
+    })(blocks = pxt.blocks || (pxt.blocks = {}));
+})(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var blocks;
+    (function (blocks) {
+        // validates that one or more blocks comments are in the project
+        // returns the blocks that have comments for teacher tool scenario
+        function validateBlockCommentsExist({ usedBlocks, numRequired }) {
+            const commentedBlocks = usedBlocks.filter((block) => !!block.getCommentText());
+            return { commentedBlocks, passed: commentedBlocks.length >= numRequired };
+        }
+        blocks.validateBlockCommentsExist = validateBlockCommentsExist;
+    })(blocks = pxt.blocks || (pxt.blocks = {}));
+})(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var blocks;
+    (function (blocks) {
+        // validates that all of a specific block type have comments
+        // returns the blocks that do not have comments for a tutorial validation scenario
+        function validateSpecificBlockCommentsExist({ usedBlocks, blockType }) {
+            const allSpecifcBlocks = usedBlocks.filter((block) => block.type === blockType);
+            const uncommentedBlocks = allSpecifcBlocks.filter((block) => !block.getCommentText());
+            return { uncommentedBlocks, passed: uncommentedBlocks.length === 0 };
+        }
+        blocks.validateSpecificBlockCommentsExist = validateSpecificBlockCommentsExist;
+    })(blocks = pxt.blocks || (pxt.blocks = {}));
+})(pxt || (pxt = {}));
 var pxtblockly;
 (function (pxtblockly) {
     class FieldBase extends Blockly.Field {

package/built/pxtlib.d.ts

@@ -276,6 +276,7 @@ declare namespace ts.pxtc.Util {
     export function blobReadAsDataURL(blob: Blob): Promise<string>;
     export function fileReadAsBufferAsync(f: File): Promise<Uint8Array>;
     export function fileReadAsTextAsync(f: File): Promise<string>;
+    export function sanitizeFileName(name: string): string;
     export function repeatMap<T>(n: number, fn: (index: number) => T): T[];
     export function listsEqual<T>(a: T[], b: T[]): boolean;
     export function oops(msg?: string): Error;
@@ -632,6 +633,7 @@ declare namespace pxt {
     function isOutputText(trg?: pxtc.CompileTarget): boolean;
 }
 declare namespace pxt.blocks {
+    let showBlockIdInTooltip: boolean;
     const MATH_FUNCTIONS: {
         unary: string[];
         binary: string[];
@@ -888,6 +890,14 @@ declare namespace pxt.BrowserUtils {
     export function setCookieLang(langId: string, docs?: boolean): void;
     export function cacheBustingUrl(url: string): string;
     export function legacyCopyText(element: HTMLInputElement | HTMLTextAreaElement): boolean;
+    /**
+     * Sets the theme of the application by adding a class to the body. Themes
+     * are defined in CSS variable packs. The default theme is defined in
+     * `themes/themepacks.less`, in the `:root` pseudoclass. `highcontrast` is
+     * also defined there. Target-specific themes are defined in the target
+     * repo's `theme/themepack.less`.
+     */
+    export function setApplicationTheme(theme: string | undefined): void;
     export {};
 }
 declare namespace pxt.cloud {
@@ -2710,6 +2720,18 @@ declare namespace pxt.svgUtil.helpers {
         protected rePosition(): void;
     }
 }
+declare namespace pxt.editor {
+    let initExtensionsAsync: (opts: pxt.editor.ExtensionOptions) => Promise<pxt.editor.ExtensionResult>;
+    let initFieldExtensionsAsync: (opts: pxt.editor.FieldExtensionOptions) => Promise<pxt.editor.FieldExtensionResult>;
+    interface ExtensionOptions {
+    }
+    interface FieldExtensionResult {
+    }
+    interface ExtensionResult {
+    }
+    interface FieldExtensionOptions {
+    }
+}
 declare namespace pxt {
     export const IMAGE_MIME_TYPE = "image/x-mkcd-f4";
     export const TILEMAP_MIME_TYPE = "application/mkcd-tilemap";