pxt-core 9.3.15 → 9.3.16

package/built/pxt.js

@@ -111066,6 +111066,8 @@ var pxt;
                     return proj.getTransparency(16);
                 case "myTiles.transparency8":
                     return proj.getTransparency(8);
+                case "myTiles.transparency4":
+                    return proj.getTransparency(4);
                 case "myTiles.transparency32":
                     return proj.getTransparency(32);
                 default:
@@ -111324,6 +111326,7 @@ var pxt;
         sprite_1.bitmapEquals = bitmapEquals;
         function tileWidthToTileScale(tileWidth) {
             switch (tileWidth) {
+                case 4: return `TileScale.Four`;
                 case 8: return `TileScale.Eight`;
                 case 16: return `TileScale.Sixteen`;
                 case 32: return `TileScale.ThirtyTwo`;
@@ -111334,6 +111337,7 @@ var pxt;
         function tileScaleToTileWidth(tileScale) {
             tileScale = tileScale.replace(/\s/g, "");
             switch (tileScale) {
+                case `TileScale.Four`: return 4;
                 case `TileScale.Eight`: return 8;
                 case `TileScale.Sixteen`: return 16;
                 case `TileScale.ThirtyTwo`: return 32;

package/built/pxtblockly.js

@@ -11521,149 +11521,6 @@ var pxt;
         blocks.initMathRoundBlock = initMathRoundBlock;
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
-var pxt;
-(function (pxt) {
-    var blocks;
-    (function (blocks) {
-        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.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;
-        }
-        function runValidateBlockCommentsExist(usedBlocks, inputs) {
-            const blockResults = blocks.validateBlockCommentsExist({ usedBlocks, numRequired: inputs.count });
-            return blockResults.passed;
-        }
-        function runValidateSpecificBlockCommentsExist(usedBlocks, inputs) {
-            const blockResults = blocks.validateSpecificBlockCommentsExist({ usedBlocks, blockType: inputs.blockType });
-            return blockResults.passed;
-        }
-        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 = {}));
-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 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 {
@@ -16652,6 +16509,9 @@ var pxtblockly;
         if (opts.tileWidth) {
             if (typeof opts.tileWidth === "number") {
                 switch (opts.tileWidth) {
+                    case 4:
+                        parsed.tileWidth = 4;
+                        break;
                     case 8:
                         parsed.tileWidth = 8;
                         break;
@@ -16666,6 +16526,10 @@ var pxtblockly;
             else {
                 const tw = opts.tileWidth.trim().toLowerCase();
                 switch (tw) {
+                    case "4":
+                    case "four":
+                        parsed.tileWidth = 4;
+                        break;
                     case "8":
                     case "eight":
                         parsed.tileWidth = 8;
@@ -16729,7 +16593,7 @@ var pxtblockly;
                 FieldTileset.cachedRevision = project.revision();
                 FieldTileset.cachedWorkspaceId = workspace.id;
                 const references = pxtblockly.getAllReferencedTiles(workspace);
-                const supportedTileWidths = [16, 8, 32];
+                const supportedTileWidths = [16, 4, 8, 32];
                 for (const width of supportedTileWidths) {
                     const projectTiles = project.getProjectTiles(width, width === 16);
                     if (!projectTiles)
@@ -16893,6 +16757,7 @@ var pxtblockly;
         switch (id) {
             case "myTiles.transparency16":
                 return 1;
+            case "myTiles.transparency4":
             case "myTiles.transparency8":
             case "myTiles.transparency32":
                 return 2;

package/built/pxtblocks.d.ts

@@ -392,80 +392,6 @@ declare namespace pxt.blocks {
 declare namespace pxt.blocks {
     function initMathRoundBlock(): void;
 }
-declare namespace pxt.blocks {
-    interface EvaluationResult {
-        result: boolean;
-    }
-}
-declare namespace pxt.blocks {
-    function runValidatorPlanAsync(usedBlocks: Blockly.Block[], plan: ValidatorPlan): Promise<boolean>;
-}
-declare namespace pxt.blocks {
-    function validateBlocksExist({ usedBlocks, requiredBlockCounts }: {
-        usedBlocks: Blockly.Block[];
-        requiredBlockCounts: pxt.Map<number>;
-    }): {
-        missingBlocks: string[];
-        disabledBlocks: string[];
-        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;
@@ -1404,7 +1330,7 @@ declare namespace pxtblockly {
         initWidth: number;
         initHeight: number;
         disableResize: boolean;
-        tileWidth: 8 | 16 | 32;
+        tileWidth: 4 | 8 | 16 | 32;
         filter?: string;
         lightMode: boolean;
     }

package/built/pxtblocks.js

@@ -7959,149 +7959,6 @@ var pxt;
         blocks.initMathRoundBlock = initMathRoundBlock;
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
-var pxt;
-(function (pxt) {
-    var blocks;
-    (function (blocks) {
-        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.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;
-        }
-        function runValidateBlockCommentsExist(usedBlocks, inputs) {
-            const blockResults = blocks.validateBlockCommentsExist({ usedBlocks, numRequired: inputs.count });
-            return blockResults.passed;
-        }
-        function runValidateSpecificBlockCommentsExist(usedBlocks, inputs) {
-            const blockResults = blocks.validateSpecificBlockCommentsExist({ usedBlocks, blockType: inputs.blockType });
-            return blockResults.passed;
-        }
-        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 = {}));
-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 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 {
@@ -13090,6 +12947,9 @@ var pxtblockly;
         if (opts.tileWidth) {
             if (typeof opts.tileWidth === "number") {
                 switch (opts.tileWidth) {
+                    case 4:
+                        parsed.tileWidth = 4;
+                        break;
                     case 8:
                         parsed.tileWidth = 8;
                         break;
@@ -13104,6 +12964,10 @@ var pxtblockly;
             else {
                 const tw = opts.tileWidth.trim().toLowerCase();
                 switch (tw) {
+                    case "4":
+                    case "four":
+                        parsed.tileWidth = 4;
+                        break;
                     case "8":
                     case "eight":
                         parsed.tileWidth = 8;
@@ -13167,7 +13031,7 @@ var pxtblockly;
                 FieldTileset.cachedRevision = project.revision();
                 FieldTileset.cachedWorkspaceId = workspace.id;
                 const references = pxtblockly.getAllReferencedTiles(workspace);
-                const supportedTileWidths = [16, 8, 32];
+                const supportedTileWidths = [16, 4, 8, 32];
                 for (const width of supportedTileWidths) {
                     const projectTiles = project.getProjectTiles(width, width === 16);
                     if (!projectTiles)
@@ -13331,6 +13195,7 @@ var pxtblockly;
         switch (id) {
             case "myTiles.transparency16":
                 return 1;
+            case "myTiles.transparency4":
             case "myTiles.transparency8":
             case "myTiles.transparency32":
                 return 2;

package/built/pxtlib.js

@@ -13380,6 +13380,8 @@ var pxt;
                     return proj.getTransparency(16);
                 case "myTiles.transparency8":
                     return proj.getTransparency(8);
+                case "myTiles.transparency4":
+                    return proj.getTransparency(4);
                 case "myTiles.transparency32":
                     return proj.getTransparency(32);
                 default:
@@ -13638,6 +13640,7 @@ var pxt;
         sprite_1.bitmapEquals = bitmapEquals;
         function tileWidthToTileScale(tileWidth) {
             switch (tileWidth) {
+                case 4: return `TileScale.Four`;
                 case 8: return `TileScale.Eight`;
                 case 16: return `TileScale.Sixteen`;
                 case 32: return `TileScale.ThirtyTwo`;
@@ -13648,6 +13651,7 @@ var pxt;
         function tileScaleToTileWidth(tileScale) {
             tileScale = tileScale.replace(/\s/g, "");
             switch (tileScale) {
+                case `TileScale.Four`: return 4;
                 case `TileScale.Eight`: return 8;
                 case `TileScale.Sixteen`: return 16;
                 case `TileScale.ThirtyTwo`: return 32;