pxt-core 9.3.9 → 9.3.11

package/built/pxt.js

@@ -97781,6 +97781,17 @@ var pxt;
             };
         }
         analytics.enable = enable;
+        function trackPerformanceReport() {
+            if (pxt.perf.perfReportLogged)
+                return;
+            const data = pxt.perf.report();
+            if (data) {
+                const { durations, milestones } = data;
+                pxt.tickEvent("performance.milestones", milestones);
+                pxt.tickEvent("performance.durations", durations);
+            }
+        }
+        analytics.trackPerformanceReport = trackPerformanceReport;
     })(analytics = pxt.analytics || (pxt.analytics = {}));
 })(pxt || (pxt = {}));
 var pxt;
@@ -101171,7 +101182,7 @@ var pxt;
     // Sometimes these aren't initialized, for example in tests. We only care about them
     // doing anything in the browser.
     if (!pxt.perf.report)
-        pxt.perf.report = () => { };
+        pxt.perf.report = () => undefined;
     if (!pxt.perf.recordMilestone)
         pxt.perf.recordMilestone = () => { };
     if (!pxt.perf.measureStart)
@@ -101919,26 +101930,26 @@ var pxt;
                 },
                 'math_number': {
                     name: pxt.Util.lf("{id:block}number"),
-                    url: '/blocks/math/random',
+                    url: '/types/number',
                     category: 'math',
                     tooltip: (pxt.appTarget && pxt.appTarget.compile) ?
                         pxt.Util.lf("a decimal number") : pxt.Util.lf("an integer number")
                 },
                 'math_integer': {
                     name: pxt.Util.lf("{id:block}number"),
-                    url: '/blocks/math/random',
+                    url: '/types/number',
                     category: 'math',
                     tooltip: pxt.Util.lf("an integer number")
                 },
                 'math_whole_number': {
                     name: pxt.Util.lf("{id:block}number"),
-                    url: '/blocks/math/random',
+                    url: '/types/number',
                     category: 'math',
                     tooltip: pxt.Util.lf("a whole number")
                 },
                 'math_number_minmax': {
                     name: pxt.Util.lf("{id:block}number"),
-                    url: '/blocks/math/random',
+                    url: '/blocks/math',
                     category: 'math'
                 },
                 'math_arithmetic': {
@@ -103240,8 +103251,33 @@ var pxt;
                     request.onerror = () => this.errorHandler(request.error, "deleteAll", reject);
                 });
             }
+            getObjectStoreWrapper(storeName) {
+                return new IDBObjectStoreWrapper(this, storeName);
+            }
         }
         BrowserUtils.IDBWrapper = IDBWrapper;
+        class IDBObjectStoreWrapper {
+            constructor(db, storeName) {
+                this.db = db;
+                this.storeName = storeName;
+            }
+            getAsync(id) {
+                return this.db.getAsync(this.storeName, id);
+            }
+            getAllAsync() {
+                return this.db.getAllAsync(this.storeName);
+            }
+            setAsync(data) {
+                return this.db.setAsync(this.storeName, data);
+            }
+            async deleteAsync(id) {
+                await this.db.deleteAsync(this.storeName, id);
+            }
+            async deleteAllAsync() {
+                await this.db.deleteAllAsync(this.storeName);
+            }
+        }
+        BrowserUtils.IDBObjectStoreWrapper = IDBObjectStoreWrapper;
         class IndexedDbTranslationDb {
             constructor(db) {
                 this.db = db;
@@ -155574,6 +155610,7 @@ var pxsim;
             return wrapper;
         }
         preload(aspectRatio, clearRuntime) {
+            this.addEventListeners();
             if (clearRuntime) {
                 this._currentRuntime = undefined;
                 this.container.textContent = "";

package/built/pxtblockly.js

@@ -11522,6 +11522,73 @@ var pxt;
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
 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);
+        }
+        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.getCriteria = getCriteria;
+        class RubricCriteria {
+            constructor(displayText) {
+                this.displayText = displayText;
+            }
+        }
+        blocks.RubricCriteria = RubricCriteria;
+        class BlockCheckCriteria extends RubricCriteria {
+            constructor(displayText, blockRequirements) {
+                super(displayText);
+                this.blockRequirements = blockRequirements;
+            }
+        }
+        class CommentCriteria extends RubricCriteria {
+            constructor(displayText, count) {
+                super(displayText);
+                this.count = count;
+            }
+        }
+    })(blocks = pxt.blocks || (pxt.blocks = {}));
+})(pxt || (pxt = {}));
+var pxt;
 (function (pxt) {
     var blocks;
     (function (blocks) {

package/built/pxtblocks.d.ts

@@ -392,6 +392,32 @@ declare namespace pxt.blocks {
 declare namespace pxt.blocks {
     function initMathRoundBlock(): void;
 }
+declare namespace pxt.blocks {
+    class Rubric {
+        criteria: RubricCriteria[];
+        constructor(criteria: RubricCriteria[]);
+    }
+    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 {};
+}
 declare namespace pxt.blocks {
     function validateBlocksExist({ usedBlocks, requiredBlockCounts }: {
         usedBlocks: Blockly.Block[];

package/built/pxtblocks.js

@@ -7960,6 +7960,73 @@ var pxt;
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
 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);
+        }
+        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.getCriteria = getCriteria;
+        class RubricCriteria {
+            constructor(displayText) {
+                this.displayText = displayText;
+            }
+        }
+        blocks.RubricCriteria = RubricCriteria;
+        class BlockCheckCriteria extends RubricCriteria {
+            constructor(displayText, blockRequirements) {
+                super(displayText);
+                this.blockRequirements = blockRequirements;
+            }
+        }
+        class CommentCriteria extends RubricCriteria {
+            constructor(displayText, count) {
+                super(displayText);
+                this.count = count;
+            }
+        }
+    })(blocks = pxt.blocks || (pxt.blocks = {}));
+})(pxt || (pxt = {}));
+var pxt;
 (function (pxt) {
     var blocks;
     (function (blocks) {

package/built/pxteditor.js

@@ -613,10 +613,10 @@ var pxt;
 (function (pxt) {
     var workspace;
     (function (workspace) {
-        // 5 minutes
-        const DIFF_HISTORY_INTERVAL = 1000 * 60 * 5;
-        // 15 minutes
-        const SNAPSHOT_HISTORY_INTERVAL = 1000 * 60 * 15;
+        // 5 minutes. This is overridden in pxtarget.json
+        const DEFAULT_DIFF_HISTORY_INTERVAL = 1000 * 60 * 5;
+        // 15 minutes. This is overridden in pxtarget.json
+        const DEFAULT_SNAPSHOT_HISTORY_INTERVAL = 1000 * 60 * 15;
         const ONE_DAY = 1000 * 60 * 60 * 24;
         function collapseHistory(history, text, options, diff, patch) {
             var _a, _b;
@@ -863,7 +863,7 @@ var pxt;
             if (history.entries.length > 1) {
                 const topTime = history.entries[history.entries.length - 1].timestamp;
                 const prevTime = history.entries[history.entries.length - 2].timestamp;
-                if (currentTime - topTime < DIFF_HISTORY_INTERVAL && topTime - prevTime < DIFF_HISTORY_INTERVAL) {
+                if (currentTime - topTime < diffInterval() && topTime - prevTime < diffInterval()) {
                     shouldCombine = true;
                 }
             }
@@ -887,7 +887,7 @@ var pxt;
             if (history.snapshots.length == 0) {
                 history.snapshots.push(takeSnapshot(previousText, currentTime - 1));
             }
-            else if (currentTime - history.snapshots[history.snapshots.length - 1].timestamp >= SNAPSHOT_HISTORY_INTERVAL) {
+            else if (currentTime - history.snapshots[history.snapshots.length - 1].timestamp >= snapshotInterval()) {
                 history.snapshots.push(takeSnapshot(previousText, currentTime));
                 const trimmed = [];
                 let currentDay = Math.floor(currentTime / ONE_DAY) * ONE_DAY;
@@ -965,6 +965,20 @@ var pxt;
             }
             return true;
         }
+        function diffInterval() {
+            var _a, _b;
+            if (((_b = (_a = pxt.appTarget) === null || _a === void 0 ? void 0 : _a.appTheme) === null || _b === void 0 ? void 0 : _b.timeMachineDiffInterval) != undefined) {
+                return pxt.appTarget.appTheme.timeMachineDiffInterval;
+            }
+            return DEFAULT_DIFF_HISTORY_INTERVAL;
+        }
+        function snapshotInterval() {
+            var _a, _b;
+            if (((_b = (_a = pxt.appTarget) === null || _a === void 0 ? void 0 : _a.appTheme) === null || _b === void 0 ? void 0 : _b.timeMachineSnapshotInterval) != undefined) {
+                return pxt.appTarget.appTheme.timeMachineSnapshotInterval;
+            }
+            return DEFAULT_SNAPSHOT_HISTORY_INTERVAL;
+        }
     })(workspace = pxt.workspace || (pxt.workspace = {}));
 })(pxt || (pxt = {}));
 /// <reference path="../localtypings/monaco.d.ts" />

package/built/pxtlib.d.ts

@@ -22,6 +22,7 @@ declare namespace pxt.analytics {
     let consoleTicks: ConsoleTickOptions;
     function addDefaultProperties(props: Map<string | number>): void;
     function enable(lang: string): void;
+    function trackPerformanceReport(): void;
 }
 declare namespace pxt {
     let appTarget: TargetBundle;
@@ -484,7 +485,14 @@ declare namespace ts.pxtc.jsonPatch.tests {
 }
 declare namespace pxt.perf {
     let perfReportLogged: boolean;
-    function report(): void;
+    function report(): {
+        milestones: {
+            [index: string]: number;
+        };
+        durations: {
+            [index: string]: number;
+        };
+    } | undefined;
     function recordMilestone(msg: string, time?: number): void;
     function measureStart(name: string): void;
     function measureEnd(name: string): void;
@@ -816,6 +824,17 @@ declare namespace pxt.BrowserUtils {
         setAsync(storeName: string, data: any): Promise<void>;
         deleteAsync(storeName: string, id: string): Promise<void>;
         deleteAllAsync(storeName: string): Promise<void>;
+        getObjectStoreWrapper<T>(storeName: string): IDBObjectStoreWrapper<T>;
+    }
+    export class IDBObjectStoreWrapper<T> {
+        protected db: IDBWrapper;
+        protected storeName: string;
+        constructor(db: IDBWrapper, storeName: string);
+        getAsync(id: string): Promise<T>;
+        getAllAsync(): Promise<T[]>;
+        setAsync(data: T): Promise<void>;
+        deleteAsync(id: string): Promise<void>;
+        deleteAllAsync(): Promise<void>;
     }
     export function translationDbAsync(): Promise<ITranslationDb>;
     export function clearTranslationDbAsync(): Promise<void>;
@@ -3689,6 +3708,17 @@ declare namespace pxt.Cloud {
         thumb?: boolean;
         persistId?: string;
     }
+    interface JsonText {
+        "Readme.md"?: string;
+        "assets.json"?: string;
+        "images.g.jres"?: string;
+        "images.g.ts"?: string;
+        "main.blocks"?: string;
+        "main.ts"?: string;
+        "pxt.json"?: string;
+        "tilemap.g.jres"?: string;
+        "tilemap.g.ts"?: string;
+    }
 }
 declare namespace ts.pxtc {
     function f4EncodeImg(w: number, h: number, bpp: number, getPix: (x: number, y: number) => number): string;

package/built/pxtlib.js

@@ -95,6 +95,17 @@ var pxt;
             };
         }
         analytics.enable = enable;
+        function trackPerformanceReport() {
+            if (pxt.perf.perfReportLogged)
+                return;
+            const data = pxt.perf.report();
+            if (data) {
+                const { durations, milestones } = data;
+                pxt.tickEvent("performance.milestones", milestones);
+                pxt.tickEvent("performance.durations", durations);
+            }
+        }
+        analytics.trackPerformanceReport = trackPerformanceReport;
     })(analytics = pxt.analytics || (pxt.analytics = {}));
 })(pxt || (pxt = {}));
 var pxt;
@@ -3485,7 +3496,7 @@ var pxt;
     // Sometimes these aren't initialized, for example in tests. We only care about them
     // doing anything in the browser.
     if (!pxt.perf.report)
-        pxt.perf.report = () => { };
+        pxt.perf.report = () => undefined;
     if (!pxt.perf.recordMilestone)
         pxt.perf.recordMilestone = () => { };
     if (!pxt.perf.measureStart)
@@ -4233,26 +4244,26 @@ var pxt;
                 },
                 'math_number': {
                     name: pxt.Util.lf("{id:block}number"),
-                    url: '/blocks/math/random',
+                    url: '/types/number',
                     category: 'math',
                     tooltip: (pxt.appTarget && pxt.appTarget.compile) ?
                         pxt.Util.lf("a decimal number") : pxt.Util.lf("an integer number")
                 },
                 'math_integer': {
                     name: pxt.Util.lf("{id:block}number"),
-                    url: '/blocks/math/random',
+                    url: '/types/number',
                     category: 'math',
                     tooltip: pxt.Util.lf("an integer number")
                 },
                 'math_whole_number': {
                     name: pxt.Util.lf("{id:block}number"),
-                    url: '/blocks/math/random',
+                    url: '/types/number',
                     category: 'math',
                     tooltip: pxt.Util.lf("a whole number")
                 },
                 'math_number_minmax': {
                     name: pxt.Util.lf("{id:block}number"),
-                    url: '/blocks/math/random',
+                    url: '/blocks/math',
                     category: 'math'
                 },
                 'math_arithmetic': {
@@ -5554,8 +5565,33 @@ var pxt;
                     request.onerror = () => this.errorHandler(request.error, "deleteAll", reject);
                 });
             }
+            getObjectStoreWrapper(storeName) {
+                return new IDBObjectStoreWrapper(this, storeName);
+            }
         }
         BrowserUtils.IDBWrapper = IDBWrapper;
+        class IDBObjectStoreWrapper {
+            constructor(db, storeName) {
+                this.db = db;
+                this.storeName = storeName;
+            }
+            getAsync(id) {
+                return this.db.getAsync(this.storeName, id);
+            }
+            getAllAsync() {
+                return this.db.getAllAsync(this.storeName);
+            }
+            setAsync(data) {
+                return this.db.setAsync(this.storeName, data);
+            }
+            async deleteAsync(id) {
+                await this.db.deleteAsync(this.storeName, id);
+            }
+            async deleteAllAsync() {
+                await this.db.deleteAllAsync(this.storeName);
+            }
+        }
+        BrowserUtils.IDBObjectStoreWrapper = IDBObjectStoreWrapper;
         class IndexedDbTranslationDb {
             constructor(db) {
                 this.db = db;

package/built/pxtsim.js

@@ -6426,6 +6426,7 @@ var pxsim;
             return wrapper;
         }
         preload(aspectRatio, clearRuntime) {
+            this.addEventListeners();
             if (clearRuntime) {
                 this._currentRuntime = undefined;
                 this.container.textContent = "";

package/built/server.js

@@ -25,7 +25,7 @@ let serveOptions;
 const webappNames = [
     "kiosk",
     "multiplayer",
-    "teachertool"
+    "eval"
     // TODO: Add other webapp names here: "skillmap", "authcode"
 ];
 function setupDocfilesdirs() {