pxt-core 7.4.9 → 7.4.13

package/built/pxt.js

@@ -97885,7 +97885,7 @@ var pxt;
             constructor() {
                 this.initialUserPreferences_ = undefined;
                 this.initialAuthCheck_ = undefined;
-                this.prefPatchOps = [];
+                this.patchQueue = [];
                 pxt.Util.assert(!_client);
                 // Set global instance.
                 _client = this;
@@ -98075,63 +98075,85 @@ var pxt;
                 }
                 return result.success;
             }
-            async patchUserPreferencesAsync(ops, immediate = false) {
-                ops = Array.isArray(ops) ? ops : [ops];
-                ops = ops.filter(op => !!op);
+            async patchUserPreferencesAsync(patchOps, opts = {}) {
+                const defaultSuccessAsync = async () => ({ success: true, res: await this.userPreferencesAsync() });
+                patchOps = Array.isArray(patchOps) ? patchOps : [patchOps];
+                patchOps = patchOps.filter(op => !!op);
+                if (!patchOps.length) {
+                    return await defaultSuccessAsync();
+                }
+                const patchDiff = (pSrc, ops, filter) => {
+                    // Apply patches to pDst and return the diff as a set of new patch ops.
+                    const pDst = pxt.U.deepCopy(pSrc);
+                    ts.pxtc.jsonPatch.patchInPlace(pDst, ops);
+                    let diff = ts.pxtc.jsonPatch.diff(pSrc, pDst);
+                    // Run caller-provided filter
+                    if (diff.length && filter) {
+                        diff = diff.filter(filter);
+                    }
+                    return diff;
+                };
+                // Process incoming patch operations to produce a more fine-grained set of diffs. Incoming patches may be overly destructive
+                // Apply the patch in isolation and get the diff from original
                 const curPref = await this.userPreferencesAsync();
-                if (!ops.length) {
-                    return { success: true, res: curPref };
+                const diff = patchDiff(curPref, patchOps, opts.filter);
+                if (!diff.length) {
+                    return await defaultSuccessAsync();
                 }
-                ts.pxtc.jsonPatch.patchInPlace(curPref, ops);
+                // Apply the new diff to the current state
+                ts.pxtc.jsonPatch.patchInPlace(curPref, diff);
                 await this.setUserPreferencesAsync(curPref);
-                // If we're not logged in, non-persistent local state is all we'll use
+                // If the user is not logged in, non-persistent local state is all we'll use (no sync to cloud)
                 if (!await this.loggedInAsync()) {
-                    return { success: true, res: curPref };
+                    return await defaultSuccessAsync();
                 }
-                // If the user is logged in, save to cloud, but debounce the api call as this can be called frequently from skillmaps
-                // Replace matching patches in the queue
-                ops.forEach((incoming, iIncoming) => {
-                    this.prefPatchOps.some((existing, iExisting) => {
-                        if (!ts.pxtc.jsonPatch.opsAreEqual(existing, incoming))
-                            return false;
-                        // Patches are equivalent, replace in queue
-                        this.prefPatchOps[iExisting] = incoming;
-                        // Clear from incoming so we don't add it below
-                        ops[iIncoming] = null;
-                        return true;
-                    });
-                });
-                // Add remaining ops to the queue
-                ops.filter(op => !!op).forEach(op => this.prefPatchOps.push(op));
+                // If the user is logged in, sync to cloud, but debounce the api call as this can be called frequently from skillmaps
+                // Queue the patch for sync with backend
+                this.patchQueue.push({ ops: patchOps, filter: opts.filter });
                 clearTimeout(debouncePreferencesChangedTimeout);
-                const savePrefs = async () => {
+                const syncPrefs = async () => {
                     debouncePreferencesChangedStarted = 0;
-                    // Clear queued patch ops before send.
-                    const prefPatchOps = this.prefPatchOps;
-                    this.prefPatchOps = [];
-                    const result = await this.apiAsync('/api/user/preferences', prefPatchOps, 'PATCH');
-                    if (result.success) {
-                        pxt.debug("Updating local user preferences w/ cloud data after result of POST");
-                        // Set user profile from returned value so we stay in-sync
-                        this.setUserPreferencesAsync(result.resp);
+                    if (!this.patchQueue.length) {
+                        return await defaultSuccessAsync();
+                    }
+                    // Fetch latest prefs from remote
+                    const getResult = await this.apiAsync('/api/user/preferences');
+                    if (!getResult.success) {
+                        pxt.reportError("identity", "failed to fetch preferences for patch", getResult);
+                        return { success: false, res: undefined };
+                    }
+                    // Apply queued patches to the remote state in isolation and develop a final diff to send to the backend
+                    const remotePrefs = pxt.U.deepCopy(getResult.resp) || auth.DEFAULT_USER_PREFERENCES();
+                    const patchQueue = this.patchQueue;
+                    this.patchQueue = []; // Reset the queue
+                    patchQueue.forEach(patch => {
+                        const diff = patchDiff(remotePrefs, patch.ops, patch.filter);
+                        ts.pxtc.jsonPatch.patchInPlace(remotePrefs, diff);
+                    });
+                    // Diff the original and patched remote states to get a final set of patch operations
+                    const finalOps = pxtc.jsonPatch.diff(getResult.resp, remotePrefs);
+                    const patchResult = await this.apiAsync('/api/user/preferences', finalOps, 'PATCH');
+                    if (patchResult.success) {
+                        // Set user profile from returned value so we stay in sync
+                        this.setUserPreferencesAsync(patchResult.resp);
                     }
                     else {
-                        pxt.reportError("identity", "update preferences failed", result);
+                        pxt.reportError("identity", "failed to patch preferences", patchResult);
                     }
-                    return { success: result.success, res: result.resp };
+                    return { success: patchResult.success, res: patchResult.resp };
                 };
-                if (immediate) {
-                    return await savePrefs();
+                if (opts.immediate) {
+                    return await syncPrefs();
                 }
                 else {
                     if (!debouncePreferencesChangedStarted) {
                         debouncePreferencesChangedStarted = pxt.U.now();
                     }
                     if (PREFERENCES_DEBOUNCE_MAX_MS < pxt.U.now() - debouncePreferencesChangedStarted) {
-                        return await savePrefs();
+                        return await syncPrefs();
                     }
                     else {
-                        debouncePreferencesChangedTimeout = setTimeout(savePrefs, PREFERENCES_DEBOUNCE_MS);
+                        debouncePreferencesChangedTimeout = setTimeout(syncPrefs, PREFERENCES_DEBOUNCE_MS);
                         return { success: false, res: undefined }; // This needs to be implemented correctly to return a promise with the debouncer
                     }
                 }
@@ -99214,6 +99236,18 @@ var ts;
                 return r;
             }
             Util.toSet = toSet;
+            function deepCopy(src) {
+                if (typeof src !== "object" || src === null) {
+                    return src;
+                }
+                const dst = Array.isArray(src) ? [] : {};
+                for (const key in src) {
+                    const value = src[key];
+                    dst[key] = deepCopy(value);
+                }
+                return dst;
+            }
+            Util.deepCopy = deepCopy;
             function toArray(a) {
                 if (Array.isArray(a)) {
                     return a;
@@ -101633,7 +101667,7 @@ var pxt;
                 'pxt_controls_for': {
                     name: pxt.Util.lf("a loop that repeats the number of times you say"),
                     tooltip: pxt.Util.lf("Have the variable '{0}' take on the values from 0 to the end number, counting by 1, and do the specified blocks."),
-                    url: 'blocks/loops/for',
+                    url: '/blocks/loops/for',
                     category: 'loops',
                     block: {
                         message0: pxt.Util.lf("for %1 from 0 to %2"),
@@ -101644,7 +101678,7 @@ var pxt;
                 'controls_simple_for': {
                     name: pxt.Util.lf("a loop that repeats the number of times you say"),
                     tooltip: pxt.Util.lf("Have the variable '{0}' take on the values from 0 to the end number, counting by 1, and do the specified blocks."),
-                    url: 'blocks/loops/for',
+                    url: '/blocks/loops/for',
                     category: 'loops',
                     block: {
                         message0: pxt.Util.lf("for %1 from 0 to %2"),
@@ -101655,7 +101689,7 @@ var pxt;
                 'pxt_controls_for_of': {
                     name: pxt.Util.lf("a loop that repeats for each value in an array"),
                     tooltip: pxt.Util.lf("Have the variable '{0}' take the value of each item in the array one by one, and do the specified blocks."),
-                    url: 'blocks/loops/for-of',
+                    url: '/blocks/loops/for-of',
                     category: 'loops',
                     block: {
                         message0: pxt.Util.lf("for element %1 of %2"),
@@ -101666,7 +101700,7 @@ var pxt;
                 'controls_for_of': {
                     name: pxt.Util.lf("a loop that repeats for each value in an array"),
                     tooltip: pxt.Util.lf("Have the variable '{0}' take the value of each item in the array one by one, and do the specified blocks."),
-                    url: 'blocks/loops/for-of',
+                    url: '/blocks/loops/for-of',
                     category: 'loops',
                     block: {
                         message0: pxt.Util.lf("for element %1 of %2"),
@@ -101951,7 +101985,7 @@ var pxt;
                 'text': {
                     name: pxt.Util.lf("a piece of text"),
                     tooltip: pxt.Util.lf("A letter, word, or line of text."),
-                    url: 'types/string',
+                    url: '/types/string',
                     category: 'text',
                     block: {
                         search: pxt.Util.lf("a piece of text") // Only used for search; this string is not surfaced in the block's text
@@ -101960,7 +101994,7 @@ var pxt;
                 'text_length': {
                     name: pxt.Util.lf("number of characters in the string"),
                     tooltip: pxt.Util.lf("Returns the number of letters (including spaces) in the provided text."),
-                    url: 'reference/text/length',
+                    url: '/reference/text/length',
                     category: 'text',
                     block: {
                         TEXT_LENGTH_TITLE: pxt.Util.lf("length of %1")
@@ -101969,7 +102003,7 @@ var pxt;
                 'text_join': {
                     name: pxt.Util.lf("join items to create text"),
                     tooltip: pxt.Util.lf("Create a piece of text by joining together any number of items."),
-                    url: 'reference/text/join',
+                    url: '/reference/text/join',
                     category: 'text',
                     block: {
                         TEXT_JOIN_TITLE_CREATEWITH: pxt.Util.lf("join")
@@ -101978,7 +102012,7 @@ var pxt;
                 'procedures_defnoreturn': {
                     name: pxt.Util.lf("define the function"),
                     tooltip: pxt.Util.lf("Create a function."),
-                    url: 'types/function/define',
+                    url: '/types/function/define',
                     category: 'functions',
                     block: {
                         PROCEDURES_DEFNORETURN_TITLE: pxt.Util.lf("function"),
@@ -101988,7 +102022,7 @@ var pxt;
                 'procedures_callnoreturn': {
                     name: pxt.Util.lf("call the function"),
                     tooltip: pxt.Util.lf("Call the user-defined function."),
-                    url: 'types/function/call',
+                    url: '/types/function/call',
                     category: 'functions',
                     block: {
                         PROCEDURES_CALLNORETURN_TITLE: pxt.Util.lf("call function")
@@ -101997,7 +102031,7 @@ var pxt;
                 'function_return': {
                     name: pxt.Util.lf("return a value from within a function"),
                     tooltip: pxt.Util.lf("Return a value from within a user-defined function."),
-                    url: 'types/function/return',
+                    url: '/types/function/return',
                     category: 'functions',
                     block: {
                         message_with_value: pxt.Util.lf("return %1"),
@@ -102007,7 +102041,7 @@ var pxt;
                 'function_definition': {
                     name: pxt.Util.lf("define the function"),
                     tooltip: pxt.Util.lf("Create a function."),
-                    url: 'types/function/define',
+                    url: '/types/function/define',
                     category: 'functions',
                     block: {
                         FUNCTIONS_EDIT_OPTION: pxt.Util.lf("Edit Function")
@@ -102016,7 +102050,7 @@ var pxt;
                 'function_call': {
                     name: pxt.Util.lf("call the function"),
                     tooltip: pxt.Util.lf("Call the user-defined function."),
-                    url: 'types/function/call',
+                    url: '/types/function/call',
                     category: 'functions',
                     block: {
                         FUNCTIONS_CALL_TITLE: pxt.Util.lf("call"),
@@ -102026,7 +102060,7 @@ var pxt;
                 'function_call_output': {
                     name: pxt.Util.lf("call the function with a return value"),
                     tooltip: pxt.Util.lf("Call the user-defined function with a return value."),
-                    url: 'types/function/call',
+                    url: '/types/function/call',
                     category: 'functions',
                     block: {}
                 }
@@ -157644,94 +157678,105 @@ ${gcards.map(gcard => `[${gcard.name}](${gcard.url})`).join(',\n')}
     nodeutil.writeFileSync("built/target-strings.json", nodeutil.stringify(targetStringsSorted));
     pxt.log(`target-strings.json built`);
 }
-function buildSemanticUIAsync(parsed) {
-    const forceRedbuild = parsed && parsed.flags["force"] || false;
-    if (!fs.existsSync(path.join("theme", "style.less")) ||
-        !fs.existsSync(path.join("theme", "theme.config")))
-        return Promise.resolve();
-    let dirty = !fs.existsSync("built/web/semantic.css");
-    if (!dirty) {
-        const csstime = fs.statSync("built/web/semantic.css").mtime;
-        dirty = nodeutil.allFiles("theme")
-            .map(f => fs.statSync(f))
-            .some(stat => stat.mtime > csstime);
-    }
-    if (!dirty && !forceRedbuild)
-        return Promise.resolve();
-    let pkg = readJson("package.json");
+async function buildSemanticUIAsync(parsed) {
+    if (!fs.existsSync(path.join("theme", "style.less")) || !fs.existsSync(path.join("theme", "theme.config"))) {
+        return;
+    }
+    const pkg = readJson("package.json");
+    const isPxtCore = pkg["name"] === "pxt-core";
     nodeutil.mkdirP(path.join("built", "web"));
     const lessPath = require.resolve('less');
     const lessCPath = path.join(path.dirname(lessPath), '/bin/lessc');
-    return nodeutil.spawnAsync({
+    const lessIncludePaths = [
+        "node_modules/semantic-ui-less",
+        "node_modules/pxt-core/theme",
+        "theme/foo/bar",
+        "theme",
+        "node_modules/pxt-core/react-common/styles",
+        "react-common/styles"
+    ].join(":");
+    // Build semantic css
+    await nodeutil.spawnAsync({
         cmd: "node",
-        args: [lessCPath, "theme/style.less", "built/web/semantic.css", "--include-path=node_modules/semantic-ui-less:node_modules/pxt-core/theme:theme/foo/bar"]
-    }).then(() => {
-        function linkFont(font, semCss) {
-            const fontFile = fs.readFileSync("node_modules/semantic-ui-less/themes/default/assets/fonts/" + font + ".woff");
-            const url = "url(data:application/font-woff;charset=utf-8;base64,"
-                + fontFile.toString("base64") + ") format('woff')";
-            const r = new RegExp(`src:.*url\\("fonts\/${font}\\.woff.*`, "g");
-            semCss = semCss.replace('src: url("fonts/' + font + '.eot");', "")
-                .replace(r, "src: " + url + ";");
-            return semCss;
-        }
-        let semCss = fs.readFileSync('built/web/semantic.css', "utf8");
-        semCss = linkFont("icons", semCss);
-        semCss = linkFont("outline-icons", semCss);
-        semCss = linkFont("brand-icons", semCss);
-        return semCss;
-    }).then((semCss) => {
-        // Append icons.css to semantic.css (custom pxt icons)
-        const iconsFile = (pkg["name"] == "pxt-core") ? 'built/web/icons.css' : 'node_modules/pxt-core/built/web/icons.css';
-        const iconsCss = fs.readFileSync(iconsFile, "utf-8");
-        const reactCommonFile = (pkg["name"] == "pxt-core") ? 'built/web/react-common.css' : 'node_modules/pxt-core/built/web/react-common.css';
-        const reactCommonCss = fs.readFileSync(reactCommonFile, "utf-8");
-        semCss = semCss + "\n" + iconsCss + "\n" + reactCommonCss;
-        nodeutil.writeFileSync('built/web/semantic.css', semCss);
-    }).then(() => {
-        // generate blockly css
-        if (!fs.existsSync(path.join("theme", "blockly.less")))
-            return Promise.resolve();
-        return nodeutil.spawnAsync({
+        args: [
+            lessCPath,
+            "theme/style.less",
+            "built/web/semantic.css",
+            "--include-path=" + lessIncludePaths
+        ]
+    });
+    // Inline all of our icon fonts
+    let semCss = await readFileAsync('built/web/semantic.css', "utf8");
+    semCss = await linkFontAsync("icons", semCss);
+    semCss = await linkFontAsync("outline-icons", semCss);
+    semCss = await linkFontAsync("brand-icons", semCss);
+    // Append icons.css to semantic.css (custom pxt icons)
+    const iconsFile = isPxtCore ? 'built/web/icons.css' : 'node_modules/pxt-core/built/web/icons.css';
+    const iconsCss = await readFileAsync(iconsFile, "utf8");
+    semCss = semCss + "\n" + iconsCss;
+    nodeutil.writeFileSync('built/web/semantic.css', semCss);
+    // Generate blockly css
+    if (fs.existsSync(path.join("theme", "blockly.less"))) {
+        await nodeutil.spawnAsync({
             cmd: "node",
-            args: [lessCPath, "theme/blockly.less", "built/web/blockly.css", "--include-path=node_modules/semantic-ui-less:node_modules/pxt-core/theme:theme/foo/bar"]
-        });
-    }).then(() => {
-        // run postcss with autoprefixer and rtlcss
-        pxt.debug("running postcss");
-        const postcss = require('postcss');
-        const browserList = [
-            "Chrome >= 38",
-            "Firefox >= 31",
-            "Edge >= 12",
-            "ie >= 11",
-            "Safari >= 9",
-            "Opera >= 21",
-            "iOS >= 9",
-            "ChromeAndroid >= 59",
-            "FirefoxAndroid >= 55"
-        ];
-        const cssnano = require('cssnano')({
-            zindex: false,
-            autoprefixer: { browsers: browserList, add: true }
-        });
-        const rtlcss = require('rtlcss');
-        const files = ['semantic.css', 'blockly.css'];
-        files.forEach(cssFile => {
-            fs.readFile(`built/web/${cssFile}`, "utf8", (err, css) => {
-                postcss([cssnano])
-                    .process(css, { from: `built/web/${cssFile}`, to: `built/web/${cssFile}` }).then((result) => {
-                    fs.writeFile(`built/web/${cssFile}`, result.css, (err2) => {
-                        // process rtl css
-                        postcss([rtlcss])
-                            .process(result.css, { from: `built/web/${cssFile}`, to: `built/web/rtl${cssFile}` }).then((result2) => {
-                            nodeutil.writeFileSync(`built/web/rtl${cssFile}`, result2.css, { encoding: "utf8" });
-                        });
-                    });
-                });
-            });
+            args: [
+                lessCPath,
+                "theme/blockly.less",
+                "built/web/blockly.css",
+                "--include-path=" + lessIncludePaths
+            ]
         });
+    }
+    // Generate react-common css for skillmap
+    const skillmapFile = isPxtCore ? "react-common/styles/react-common-skillmap-core.less" :
+        "node_modules/pxt-core/react-common/styles/react-common-skillmap.less";
+    await nodeutil.spawnAsync({
+        cmd: "node",
+        args: [
+            lessCPath,
+            skillmapFile,
+            "built/web/react-common-skillmap.css",
+            "--include-path=" + lessIncludePaths
+        ]
     });
+    // Run postcss with autoprefixer and rtlcss
+    pxt.debug("running postcss");
+    const postcss = require('postcss');
+    const browserList = [
+        "Chrome >= 38",
+        "Firefox >= 31",
+        "Edge >= 12",
+        "ie >= 11",
+        "Safari >= 9",
+        "Opera >= 21",
+        "iOS >= 9",
+        "ChromeAndroid >= 59",
+        "FirefoxAndroid >= 55"
+    ];
+    const cssnano = require("cssnano")({
+        zindex: false,
+        autoprefixer: { browsers: browserList, add: true }
+    });
+    const rtlcss = require("rtlcss");
+    const files = ["semantic.css", "blockly.css", "react-common-skillmap.css"];
+    for (const cssFile of files) {
+        const css = await readFileAsync(`built/web/${cssFile}`, "utf8");
+        const processed = await postcss([cssnano])
+            .process(css, { from: `built/web/${cssFile}`, to: `built/web/${cssFile}` });
+        await writeFileAsync(`built/web/${cssFile}`, processed.css);
+        const processedRtl = await postcss([rtlcss])
+            .process(processed.css, { from: `built/web/${cssFile}`, to: `built/web/rtl${cssFile}` });
+        await writeFileAsync(`built/web/rtl${cssFile}`, processedRtl.css, "utf8");
+    }
+}
+async function linkFontAsync(font, semCss) {
+    const fontFile = await readFileAsync("node_modules/semantic-ui-less/themes/default/assets/fonts/" + font + ".woff");
+    const url = "url(data:application/font-woff;charset=utf-8;base64,"
+        + fontFile.toString("base64") + ") format('woff')";
+    const r = new RegExp(`src:.*url\\("fonts\/${font}\\.woff.*`, "g");
+    semCss = semCss.replace('src: url("fonts/' + font + '.eot");', "")
+        .replace(r, "src: " + url + ";");
+    return semCss;
 }
 function buildWebStringsAsync() {
     if (pxt.appTarget.id != "core")
@@ -157754,7 +157799,7 @@ function buildSkillMapAsync(parsed) {
         nodeutil.cp("node_modules/pxt-core/built/pxtlib.js", `${skillmapRoot}/public/blb`);
         nodeutil.cp("built/web/semantic.css", `${skillmapRoot}/public/blb`);
         nodeutil.cp("node_modules/pxt-core/built/web/icons.css", `${skillmapRoot}/public/blb`);
-        nodeutil.cp("node_modules/pxt-core/built/web/react-common.css", `${skillmapRoot}/public/blb`);
+        nodeutil.cp("node_modules/pxt-core/built/web/react-common-skillmap.css", `${skillmapRoot}/public/blb`);
         // copy 'assets' over from docs/static
         nodeutil.cpR("docs/static/skillmap/assets", `${skillmapRoot}/public/assets`);
         if (docsPath) {
@@ -162112,7 +162157,7 @@ ${pxt.crowdin.KEY_VARIABLE} - crowdin key
         help: "build required css files",
         flags: {
             force: {
-                description: "force re-compile of less files"
+                description: "deprecated; now on by default"
             }
         }
     }, buildSemanticUIAsync);