pxt-core 9.1.9 → 9.1.10

package/built/backendutils.js

@@ -345,8 +345,7 @@ var pxt;
             "codeStop": "<!-- stop -->",
             "autoOpen": "<!-- autoOpen -->",
             "autoexpandOff": "<!-- autoexpandOff -->",
-            "preferredEditor": "<!-- preferredEditor -->",
-            "tutorialCodeValidation": "<!-- tutorialCodeValidation -->"
+            "preferredEditor": "<!-- preferredEditor -->"
         };
         function replaceAll(replIn, x, y) {
             return replIn.split(x).join(y);

package/built/pxt.js

@@ -106227,8 +106227,7 @@ var pxt;
             "codeStop": "<!-- stop -->",
             "autoOpen": "<!-- autoOpen -->",
             "autoexpandOff": "<!-- autoexpandOff -->",
-            "preferredEditor": "<!-- preferredEditor -->",
-            "tutorialCodeValidation": "<!-- tutorialCodeValidation -->"
+            "preferredEditor": "<!-- preferredEditor -->"
         };
         function replaceAll(replIn, x, y) {
             return replIn.split(x).join(y);
@@ -118857,7 +118856,7 @@ var pxt;
 var pxt;
 (function (pxt) {
     var tutorial;
-    (function (tutorial) {
+    (function (tutorial_1) {
         const _h2Regex = /^##[^#](.*)$([\s\S]*?)(?=^##[^#]|$(?![\r\n]))/gmi;
         const _h3Regex = /^###[^#](.*)$([\s\S]*?)(?=^###[^#]|$(?![\r\n]))/gmi;
         function parseTutorial(tutorialmd) {
@@ -118867,13 +118866,7 @@ var pxt;
             if (!steps)
                 return undefined; // error parsing steps
             // collect code and infer editor
-            const { code, templateCode, editor, language, jres, assetJson, customTs, tutorialValidationRulesStr, simThemeJson } = computeBodyMetadata(body);
-            // parses tutorial rules string into a map of rules and enablement flag
-            let tutorialValidationRules;
-            if (metadata.tutorialCodeValidation) {
-                tutorialValidationRules = pxt.Util.jsonTryParse(tutorialValidationRulesStr);
-                categorizingValidationRules(tutorialValidationRules, title);
-            }
+            const { code, templateCode, editor, language, jres, assetJson, customTs, simThemeJson } = computeBodyMetadata(body);
             // noDiffs legacy
             if (metadata.diffs === true // enabled in tutorial
                 || (metadata.diffs !== false && metadata.noDiffs !== true // not disabled
@@ -118891,7 +118884,6 @@ var pxt;
                 step.contentMd = stripHiddenSnippets(step.contentMd);
                 step.headerContentMd = stripHiddenSnippets(step.headerContentMd);
                 step.hintContentMd = stripHiddenSnippets(step.hintContentMd);
-                step.requiredBlockMd = stripHiddenSnippets(step.requiredBlockMd);
             });
             return {
                 editor,
@@ -118905,17 +118897,16 @@ var pxt;
                 jres,
                 assetFiles,
                 customTs,
-                tutorialValidationRules,
                 globalBlockConfig,
                 globalValidationConfig,
                 simTheme
             };
         }
-        tutorial.parseTutorial = parseTutorial;
+        tutorial_1.parseTutorial = parseTutorial;
         function getMetadataRegex() {
-            return /``` *(sim|block|blocks|filterblocks|spy|ghost|typescript|ts|js|javascript|template|python|jres|assetjson|customts|tutorialValidationRules|requiredTutorialBlock|simtheme)\s*\n([\s\S]*?)\n```/gmi;
+            return /``` *(sim|block|blocks|filterblocks|spy|ghost|typescript|ts|js|javascript|template|python|jres|assetjson|customts|simtheme)\s*\n([\s\S]*?)\n```/gmi;
         }
-        tutorial.getMetadataRegex = getMetadataRegex;
+        tutorial_1.getMetadataRegex = getMetadataRegex;
         function computeBodyMetadata(body) {
             // collect code and infer editor
             let editor = undefined;
@@ -118928,7 +118919,6 @@ var pxt;
             let assetJson;
             let customTs;
             let simThemeJson;
-            let tutorialValidationRulesStr;
             // Concatenate all blocks in separate code blocks and decompile so we can detect what blocks are used (for the toolbox)
             body
                 .replace(/((?!.)\s)+/g, "\n")
@@ -118938,7 +118928,6 @@ var pxt;
                     case "blocks":
                     case "blockconfig.local":
                     case "blockconfig.global":
-                    case "requiredTutorialBlock":
                     case "filterblocks":
                         if (!checkTutorialEditor(pxt.BLOCKS_PROJECT_NAME))
                             return undefined;
@@ -118973,9 +118962,6 @@ var pxt;
                         customTs = m2;
                         m2 = "";
                         break;
-                    case "tutorialValidationRules":
-                        tutorialValidationRulesStr = m2;
-                        break;
                 }
                 code.push(m1 == "python" ? `\n${m2}\n` : `{\n${m2}\n}`);
                 idx++;
@@ -118991,7 +118977,6 @@ var pxt;
                 jres,
                 assetJson,
                 customTs,
-                tutorialValidationRulesStr,
                 simThemeJson
             };
             function checkTutorialEditor(expected) {
@@ -119102,7 +119087,7 @@ ${code}
             let stepInfo = [];
             markdown.replace(stepRegex, function (match, flags, step) {
                 step = step.trim();
-                let { header, hint, requiredBlocks } = parseTutorialHint(step, metadata && metadata.explicitHints, metadata.tutorialCodeValidation);
+                let { header, hint } = parseTutorialHint(step, metadata && metadata.explicitHints);
                 const blockConfig = parseTutorialBlockConfig("local", step);
                 const validationConfig = parseTutorialValidationConfig("local", step);
                 // if title is not hidden ("{TITLE HERE}"), strip flags
@@ -119126,8 +119111,6 @@ ${code}
                     info.resetDiff = true;
                 if (hint)
                     info.hintContentMd = hint;
-                if (metadata.tutorialCodeValidation && requiredBlocks)
-                    info.requiredBlockMd = requiredBlocks;
                 stepInfo.push(info);
                 return "";
             });
@@ -119137,11 +119120,10 @@ ${code}
             }
             return stepInfo;
         }
-        function parseTutorialHint(step, explicitHints, tutorialCodeValidationEnabled) {
+        function parseTutorialHint(step, explicitHints) {
             // remove hidden code sections
             step = stripHiddenSnippets(step);
             let header = step, hint;
-            let requiredBlocks;
             if (explicitHints) {
                 // hint is explicitly set with hint syntax "#### ~ tutorialhint" and terminates at the next heading
                 const hintTextRegex = /#+ ~ tutorialhint([\s\S]*)/i;
@@ -119157,17 +119139,9 @@ ${code}
                 if (hintText && hintText.length > 2) {
                     header = hintText[1].trim();
                     hint = hintText[2].trim();
-                    if (tutorialCodeValidationEnabled) {
-                        let hintSnippet = hintText[2].trim();
-                        hintSnippet = hintSnippet.replace(/``` *(requiredTutorialBlock)\s*\n([\s\S]*?)\n```/gmi, function (m0, m1, m2) {
-                            requiredBlocks = `{\n${m2}\n}`;
-                            return "";
-                        });
-                        hint = hintSnippet;
-                    }
                 }
             }
-            return { header, hint, requiredBlocks };
+            return { header, hint };
         }
         function parseTutorialBlockConfig(scope, content) {
             let blockConfig = {
@@ -119200,17 +119174,6 @@ ${code}
             });
             return { validatorsMetadata: sectionedMetadata };
         }
-        function categorizingValidationRules(listOfRules, title) {
-            const ruleNames = Object.keys(listOfRules);
-            for (let i = 0; i < ruleNames.length; i++) {
-                const setValidationRule = {
-                    ruleName: ruleNames[i],
-                    enabled: listOfRules[ruleNames[i]] ? 'true' : 'false',
-                    tutorial: title,
-                };
-                pxt.tickEvent('tutorial.validation.setValidationRules', setValidationRule);
-            }
-        }
         /* Remove hidden snippets from text */
         function stripHiddenSnippets(str) {
             if (!str)
@@ -119272,7 +119235,7 @@ ${code}
                 }
             }
         }
-        tutorial.highlight = highlight;
+        tutorial_1.highlight = highlight;
         function getTutorialOptions(md, tutorialId, filename, reportId, recipe) {
             var _a;
             const tutorialInfo = pxt.tutorial.parseTutorial(md);
@@ -119297,14 +119260,13 @@ ${code}
                 jres: tutorialInfo.jres,
                 assetFiles: tutorialInfo.assetFiles,
                 customTs: tutorialInfo.customTs,
-                tutorialValidationRules: tutorialInfo.tutorialValidationRules,
                 globalBlockConfig: tutorialInfo.globalBlockConfig,
                 globalValidationConfig: tutorialInfo.globalValidationConfig,
                 simTheme: tutorialInfo.simTheme,
             };
             return { options: tutorialOptions, editor: tutorialInfo.editor };
         }
-        tutorial.getTutorialOptions = getTutorialOptions;
+        tutorial_1.getTutorialOptions = getTutorialOptions;
         function parseCachedTutorialInfo(json, id) {
             let cachedInfo = pxt.Util.jsonTryParse(json);
             if (!cachedInfo)
@@ -119325,7 +119287,7 @@ ${code}
                 }
             }).catch((err) => { });
         }
-        tutorial.parseCachedTutorialInfo = parseCachedTutorialInfo;
+        tutorial_1.parseCachedTutorialInfo = parseCachedTutorialInfo;
         function resolveLocalizedMarkdown(ghid, files, fileName) {
             // if non-default language, find localized file if any
             const mfn = (fileName || ghid.fileName || "README") + ".md";
@@ -119344,7 +119306,7 @@ ${code}
             md = md || files[mfn];
             return md;
         }
-        tutorial.resolveLocalizedMarkdown = resolveLocalizedMarkdown;
+        tutorial_1.resolveLocalizedMarkdown = resolveLocalizedMarkdown;
         function parseAssetJson(json) {
             if (!json)
                 return undefined;
@@ -119356,7 +119318,7 @@ ${code}
                 [pxt.IMAGES_CODE]: files[pxt.IMAGES_CODE]
             };
         }
-        tutorial.parseAssetJson = parseAssetJson;
+        tutorial_1.parseAssetJson = parseAssetJson;
         function parseSimThemeJson(json) {
             const pxtJson = pxt.Util.jsonTryParse(json);
             if (!pxtJson)
@@ -119370,225 +119332,32 @@ ${code}
             }
             return res;
         }
-        tutorial.parseSimThemeJson = parseSimThemeJson;
-    })(tutorial = pxt.tutorial || (pxt.tutorial = {}));
-})(pxt || (pxt = {}));
-var pxt;
-(function (pxt) {
-    var tutorial;
-    (function (tutorial_1) {
-        /**
-        * Check the user's code to the map of tutorial validation rules from TutorialOptions and returns an array of TutorialRuleStatus
-        * @param tutorial the tutorial
-        * @param workspaceBlocks Blockly blocks used of workspace
-        * @param blockinfo Typescripts of the workspace
-        * @return A TutorialRuleStatus
-        */
-        async function validate(tutorial, workspaceBlocks, blockinfo) {
-            const listOfRules = tutorial.tutorialValidationRules;
-            let TutorialRuleStatuses = classifyRules(listOfRules);
-            // Check to if there are rules to valdiate and to see if there are blocks are in the workspace to compare to
-            if (TutorialRuleStatuses.length > 0 && workspaceBlocks.length > 0) {
-                // User blocks
-                const userBlockTypes = workspaceBlocks.map(b => b.type);
-                const usersBlockUsed = blockCount(userBlockTypes);
-                // Tutorial blocks
-                const { tutorialStepInfo, tutorialStep } = tutorial;
-                const step = tutorialStepInfo[tutorialStep];
-                const indexdb = await tutorialBlockList(tutorial, step);
-                const tutorialBlockUsed = extractBlockSnippet(tutorial, indexdb);
-                for (let i = 0; i < TutorialRuleStatuses.length; i++) {
-                    let currRuleToValidate = TutorialRuleStatuses[i];
-                    const ruleName = TutorialRuleStatuses[i].ruleName;
-                    const isRuleEnabled = TutorialRuleStatuses[i].ruleTurnOn;
-                    if (isRuleEnabled) {
-                        switch (ruleName) {
-                            case "exact":
-                                currRuleToValidate = validateExactNumberOfBlocks(usersBlockUsed, tutorialBlockUsed, currRuleToValidate);
-                                break;
-                            case "atleast":
-                                currRuleToValidate = validateAtleastOneBlocks(usersBlockUsed, tutorialBlockUsed, currRuleToValidate);
-                                break;
-                            case "required":
-                                const requiredBlocksList = extractRequiredBlockSnippet(tutorial, indexdb);
-                                currRuleToValidate = validateMeetRequiredBlocks(usersBlockUsed, requiredBlocksList, currRuleToValidate);
-                                break;
-                        }
-                    }
-                }
-            }
-            return TutorialRuleStatuses;
-        }
-        tutorial_1.validate = validate;
-        /**
-        * Gives each rule from the markdown file a TutorialRuleStatus
-        * @param listOfRules a map of rules from makrdown file
-        * @return An array of TutorialRuleStatus
-        */
-        function classifyRules(listOfRules) {
-            let listOfRuleStatuses = [];
-            if (listOfRules != undefined) {
-                const ruleNames = Object.keys(listOfRules);
-                for (let i = 0; i < ruleNames.length; i++) {
-                    const currRule = ruleNames[i];
-                    const ruleVal = listOfRules[currRule];
-                    const currRuleStatus = { ruleName: currRule, ruleTurnOn: ruleVal };
-                    listOfRuleStatuses.push(currRuleStatus);
-                }
-            }
-            return listOfRuleStatuses;
-        }
-        /**
-        * Loops through an array of blocks and returns a map of blocks and the count for that block
-        * @param arr a string array of blocks
-        * @return a map <Block type, frequency>
-        */
-        function blockCount(arr) {
-            let frequencyMap = {};
-            for (let i = 0; i < arr.length; i++) {
-                if (!frequencyMap[arr[i]]) {
-                    frequencyMap[arr[i]] = 0;
-                }
-                frequencyMap[arr[i]] = frequencyMap[arr[i]] + 1;
-            }
-            return frequencyMap;
-        }
-        /**
-        * Returns information from index database
-        * @param tutorial Typescripts of the workspace
-        * @param step the current tutorial step
-        * @return indexdb's tutorial code snippets
-        */
-        function tutorialBlockList(tutorial, step) {
-            return pxt.BrowserUtils.tutorialInfoDbAsync()
-                .then(db => db.getAsync(tutorial.tutorial, tutorial.tutorialCode)
-                .then(entry => {
-                if (entry === null || entry === void 0 ? void 0 : entry.snippets) {
-                    return Promise.resolve(entry.snippets);
-                }
-                else {
-                    return Promise.resolve(undefined);
-                }
-            }));
+        tutorial_1.parseSimThemeJson = parseSimThemeJson;
+        async function getTutorialHighlightedBlocks(tutorial) {
+            const db = await pxt.BrowserUtils.tutorialInfoDbAsync();
+            const entry = await db.getAsync(tutorial.tutorial, tutorial.tutorialCode);
+            return entry === null || entry === void 0 ? void 0 : entry.highlightBlocks;
         }
-        /**
-        * Extract the tutorial blocks used from code snippet
-        * @param tutorial tutorial info
-        * @param indexdb database from index
-        * @return the tutorial blocks used for the current step
-        */
-        function extractBlockSnippet(tutorial, indexdb) {
+        tutorial_1.getTutorialHighlightedBlocks = getTutorialHighlightedBlocks;
+        function getTutorialStepHash(tutorial) {
             const { tutorialStepInfo, tutorialStep } = tutorial;
-            const body = tutorial.tutorialStepInfo[tutorialStep].hintContentMd;
-            let hintCode = "";
-            if (body != undefined) {
-                body.replace(/((?!.)\s)+/g, "\n").replace(/``` *(block|blocks)\s*\n([\s\S]*?)\n```/gmi, function (m0, m1, m2) {
-                    hintCode = `{\n${m2}\n}`;
-                    return "";
-                });
-            }
-            const snippetStepKey = pxt.BrowserUtils.getTutorialCodeHash([hintCode]);
-            let blockMap = {};
-            if (indexdb != undefined) {
-                blockMap = indexdb[snippetStepKey];
-            }
-            return blockMap;
-        }
-        /**
-        * Extract the required tutorial blocks  from code snippet
-        * @param tutorial tutorial info
-        * @param indexdb database from index
-        * @return the tutorial blocks used for the current step
-        */
-        function extractRequiredBlockSnippet(tutorial, indexdb) {
-            const { tutorialStep } = tutorial;
-            const body = tutorial.tutorialStepInfo[tutorialStep].requiredBlockMd;
-            const snippetStepKey = pxt.BrowserUtils.getTutorialCodeHash([body]);
-            let blockMap = {};
-            if (indexdb != undefined) {
-                blockMap = indexdb[snippetStepKey];
-            }
-            return blockMap;
-        }
-        /**
-        * Strict Rule: Checks if the all required number of blocks for a tutorial step is used, returns a TutorialRuleStatus
-        * @param usersBlockUsed an array of strings
-        * @param tutorialBlockUsed the next available index
-        * @param currRule the current rule with its TutorialRuleStatus
-        * @return a tutorial rule status for currRule
-        */
-        function validateExactNumberOfBlocks(usersBlockUsed, tutorialBlockUsed, currRule) {
-            currRule.isStrict = true;
-            const userBlockKeys = Object.keys(usersBlockUsed);
-            let tutorialBlockKeys = [];
-            let blockIds = [];
-            if (tutorialBlockUsed != undefined) {
-                tutorialBlockKeys = Object.keys(tutorialBlockUsed);
-            }
-            let isValid = userBlockKeys.length >= tutorialBlockKeys.length; // user has enough blocks
-            const message = lf("These are the blocks you seem to be missing:");
-            for (let i = 0; i < tutorialBlockKeys.length; i++) {
-                let tutorialBlockKey = tutorialBlockKeys[i];
-                if (!usersBlockUsed[tutorialBlockKey] // user did not use a specific block or
-                    || usersBlockUsed[tutorialBlockKey] < tutorialBlockUsed[tutorialBlockKey]) { // user did not use enough of a certain block
-                    blockIds.push(tutorialBlockKey);
-                    isValid = false;
-                }
-            }
-            currRule.ruleMessage = message;
-            currRule.ruleStatus = isValid;
-            currRule.blockIds = blockIds;
-            return currRule;
-        }
-        /**
-        * Passive Rule: Checks if the users has at least one block type for each rule
-        * @param usersBlockUsed an array of strings
-        * @param tutorialBlockUsed the next available index
-        * @param currRule the current rule with its TutorialRuleStatus
-        * @return a tutorial rule status for currRule
-        */
-        function validateAtleastOneBlocks(usersBlockUsed, tutorialBlockUsed, currRule) {
-            const userBlockKeys = Object.keys(usersBlockUsed);
-            const tutorialBlockKeys = Object.keys(tutorialBlockUsed !== null && tutorialBlockUsed !== void 0 ? tutorialBlockUsed : {});
-            let isValid = userBlockKeys.length >= tutorialBlockKeys.length; // user has enough blocks
-            for (let i = 0; i < tutorialBlockKeys.length; i++) {
-                let tutorialBlockKey = tutorialBlockKeys[i];
-                if (!usersBlockUsed[tutorialBlockKey]) { // user did not use a specific block
-                    isValid = false;
-                    break;
-                }
-            }
-            currRule.ruleStatus = isValid;
-            return currRule;
-        }
-        /**
-         * Strict Rule: Checks if the all required number of blocks for a tutorial step is used, returns a TutorialRuleStatus
-         * @param usersBlockUsed an array of strings
-         * @param tutorialBlockUsed the next available index
-         * @param currRule the current rule with its TutorialRuleStatus
-         * @return a tutorial rule status for currRule
-         */
-        function validateMeetRequiredBlocks(usersBlockUsed, requiredBlocks, currRule) {
-            currRule.isStrict = true;
-            const userBlockKeys = Object.keys(usersBlockUsed);
-            let requiredBlockKeys = [];
-            let blockIds = [];
-            if (requiredBlocks != undefined) {
-                requiredBlockKeys = Object.keys(requiredBlocks);
-            }
-            let isValid = true;
-            const message = lf("You are required to have the following block:");
-            for (let i = 0; i < requiredBlockKeys.length; i++) {
-                let requiredBlockKey = requiredBlockKeys[i];
-                if (!usersBlockUsed[requiredBlockKey]) {
-                    blockIds.push(requiredBlockKey);
-                    isValid = false;
-                }
-            }
-            currRule.ruleMessage = message;
-            currRule.ruleStatus = isValid;
-            currRule.blockIds = blockIds;
-            return currRule;
+            const body = tutorialStepInfo[tutorialStep].hintContentMd;
+            const codeSnippets = getBlockSnippetCode(body);
+            return pxt.BrowserUtils.getTutorialCodeHash(codeSnippets);
+        }
+        tutorial_1.getTutorialStepHash = getTutorialStepHash;
+        /** TODO: if this gets exported, we probably want to consider generalizing to 'parseMarkdownSnippets'
+         * that returns { snippetName: string[] }; e.g.
+         * { "blocks": ["block snippet 1", "block snippet 2"], "package": ["deplist 1"] }
+         * need to cover getMetadataRegex + stripHiddenSnippets types, maybe more if any happen to be around.
+         **/
+        function getBlockSnippetCode(mdSnippet) {
+            let hintCode = [];
+            mdSnippet === null || mdSnippet === void 0 ? void 0 : mdSnippet.replace(/((?!.)\s)+/g, "\n").replace(/``` *(block|blocks)\s*\n([\s\S]*?)\n```/gim, function (m0, m1, m2) {
+                hintCode.push(`{\n${m2}\n}`);
+                return "";
+            });
+            return hintCode;
         }
     })(tutorial = pxt.tutorial || (pxt.tutorial = {}));
 })(pxt || (pxt = {}));

package/built/pxtblockly.js

@@ -11520,6 +11520,42 @@ var pxt;
         blocks.initMathRoundBlock = initMathRoundBlock;
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var blocks;
+    (function (blocks) {
+        function validateBlocksExist({ usedBlocks, requiredBlockCounts }) {
+            let missingBlocks = [];
+            let disabledBlocks = [];
+            let insufficientBlocks = [];
+            const userBlocksEnabledByType = usedBlocks === null || usedBlocks === void 0 ? void 0 : usedBlocks.reduce((acc, block) => {
+                acc[block.type] = (acc[block.type] || 0) + (block.isEnabled() ? 1 : 0);
+                return acc;
+            }, {});
+            for (const [requiredBlockId, requiredCount] of Object.entries(requiredBlockCounts || {})) {
+                const countForBlock = userBlocksEnabledByType[requiredBlockId];
+                if (countForBlock === undefined) {
+                    // user did not use a specific block
+                    missingBlocks.push(requiredBlockId);
+                }
+                else if (!countForBlock) {
+                    // all instances of block are disabled
+                    disabledBlocks.push(requiredBlockId);
+                }
+                else if (countForBlock < requiredCount) {
+                    // instances of block exists, but not enough.
+                    insufficientBlocks.push(requiredBlockId);
+                }
+            }
+            return {
+                missingBlocks,
+                disabledBlocks,
+                insufficientBlocks,
+            };
+        }
+        blocks.validateBlocksExist = validateBlocksExist;
+    })(blocks = pxt.blocks || (pxt.blocks = {}));
+})(pxt || (pxt = {}));
 var pxtblockly;
 (function (pxtblockly) {
     class FieldBase extends Blockly.Field {

package/built/pxtblocks.d.ts

@@ -392,6 +392,16 @@ declare namespace pxt.blocks {
 declare namespace pxt.blocks {
     function initMathRoundBlock(): void;
 }
+declare namespace pxt.blocks {
+    function validateBlocksExist({ usedBlocks, requiredBlockCounts }: {
+        usedBlocks: Blockly.Block[];
+        requiredBlockCounts: pxt.Map<number>;
+    }): {
+        missingBlocks: string[];
+        disabledBlocks: string[];
+        insufficientBlocks: string[];
+    };
+}
 declare namespace pxtblockly {
     abstract class FieldBase<U> extends Blockly.Field implements Blockly.FieldCustom {
         isFieldCustom_: true;

package/built/pxtblocks.js

@@ -7958,6 +7958,42 @@ var pxt;
         blocks.initMathRoundBlock = initMathRoundBlock;
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var blocks;
+    (function (blocks) {
+        function validateBlocksExist({ usedBlocks, requiredBlockCounts }) {
+            let missingBlocks = [];
+            let disabledBlocks = [];
+            let insufficientBlocks = [];
+            const userBlocksEnabledByType = usedBlocks === null || usedBlocks === void 0 ? void 0 : usedBlocks.reduce((acc, block) => {
+                acc[block.type] = (acc[block.type] || 0) + (block.isEnabled() ? 1 : 0);
+                return acc;
+            }, {});
+            for (const [requiredBlockId, requiredCount] of Object.entries(requiredBlockCounts || {})) {
+                const countForBlock = userBlocksEnabledByType[requiredBlockId];
+                if (countForBlock === undefined) {
+                    // user did not use a specific block
+                    missingBlocks.push(requiredBlockId);
+                }
+                else if (!countForBlock) {
+                    // all instances of block are disabled
+                    disabledBlocks.push(requiredBlockId);
+                }
+                else if (countForBlock < requiredCount) {
+                    // instances of block exists, but not enough.
+                    insufficientBlocks.push(requiredBlockId);
+                }
+            }
+            return {
+                missingBlocks,
+                disabledBlocks,
+                insufficientBlocks,
+            };
+        }
+        blocks.validateBlocksExist = validateBlocksExist;
+    })(blocks = pxt.blocks || (pxt.blocks = {}));
+})(pxt || (pxt = {}));
 var pxtblockly;
 (function (pxtblockly) {
     class FieldBase extends Blockly.Field {

package/built/pxteditor.d.ts

@@ -256,7 +256,6 @@ declare namespace pxt.editor {
         showTutorialHint(): void;
         isTutorial(): boolean;
         onTutorialLoaded(): void;
-        setTutorialCodeStatus(step: number, status: pxt.tutorial.TutorialRuleStatus[]): void;
         pokeUserActivity(): void;
         stopPokeUserActivity(): void;
         clearUserPoke(): void;

package/built/pxtlib.d.ts

@@ -2983,24 +2983,8 @@ declare namespace pxt.tutorial {
     function resolveLocalizedMarkdown(ghid: pxt.github.ParsedRepo, files: pxt.Map<string>, fileName?: string): string;
     function parseAssetJson(json: string): pxt.Map<string>;
     function parseSimThemeJson(json: string): Partial<pxt.PackageConfig>;
-}
-declare namespace pxt.tutorial {
-    interface TutorialRuleStatus {
-        ruleName: string;
-        ruleTurnOn: boolean;
-        ruleStatus?: boolean;
-        ruleMessage?: string;
-        isStrict?: boolean;
-        blockIds?: string[];
-    }
-    /**
-    * Check the user's code to the map of tutorial validation rules from TutorialOptions and returns an array of TutorialRuleStatus
-    * @param tutorial the tutorial
-    * @param workspaceBlocks Blockly blocks used of workspace
-    * @param blockinfo Typescripts of the workspace
-    * @return A TutorialRuleStatus
-    */
-    function validate(tutorial: TutorialOptions, workspaceBlocks: Blockly.Block[], blockinfo: pxtc.BlocksInfo): Promise<TutorialRuleStatus[]>;
+    function getTutorialHighlightedBlocks(tutorial: TutorialOptions): Promise<pxt.Map<pxt.Map<number>> | undefined>;
+    function getTutorialStepHash(tutorial: TutorialOptions): string;
 }
 declare namespace ts.pxtc {
     function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;