pxt-core 7.4.6 → 7.4.10

package/built/pxt.js

@@ -97871,19 +97871,21 @@ var pxt;
             highContrast: false,
             language: pxt.appTarget.appTheme.defaultLocale,
             reader: "",
-            skillmap: { mapProgress: {}, completedTags: {} }
+            skillmap: { mapProgress: {}, completedTags: {} },
+            email: false
         });
         let _client;
         function client() { return _client; }
         auth.client = client;
-        const PREFERENCES_DEBOUNCE_MS = 5 * 1000;
-        const PREFERENCES_DEBOUNCE_MAX_MS = 30 * 1000;
+        const PREFERENCES_DEBOUNCE_MS = 1 * 1000;
+        const PREFERENCES_DEBOUNCE_MAX_MS = 10 * 1000;
         let debouncePreferencesChangedTimeout = 0;
         let debouncePreferencesChangedStarted = 0;
         class AuthClient {
             constructor() {
                 this.initialUserPreferences_ = undefined;
                 this.initialAuthCheck_ = undefined;
+                this.patchQueue = [];
                 pxt.Util.assert(!_client);
                 // Set global instance.
                 _client = this;
@@ -98073,40 +98075,87 @@ var pxt;
                 }
                 return result.success;
             }
-            async patchUserPreferencesAsync(ops) {
-                ops = Array.isArray(ops) ? ops : [ops];
-                if (!ops.length) {
-                    return;
-                }
+            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();
-                ts.pxtc.jsonPatch.patchInPlace(curPref, ops);
+                const diff = patchDiff(curPref, patchOps, opts.filter);
+                if (!diff.length) {
+                    return await defaultSuccessAsync();
+                }
+                // 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;
+                    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
+                // 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;
-                    const result = await this.apiAsync('/api/user/preferences', ops, '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);
+                    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: patchResult.success, res: patchResult.resp };
                 };
-                if (!debouncePreferencesChangedStarted) {
-                    debouncePreferencesChangedStarted = pxt.U.now();
-                }
-                if (PREFERENCES_DEBOUNCE_MAX_MS < pxt.U.now() - debouncePreferencesChangedStarted) {
-                    await savePrefs();
+                if (opts.immediate) {
+                    return await syncPrefs();
                 }
                 else {
-                    debouncePreferencesChangedTimeout = setTimeout(savePrefs, PREFERENCES_DEBOUNCE_MS);
+                    if (!debouncePreferencesChangedStarted) {
+                        debouncePreferencesChangedStarted = pxt.U.now();
+                    }
+                    if (PREFERENCES_DEBOUNCE_MAX_MS < pxt.U.now() - debouncePreferencesChangedStarted) {
+                        return await syncPrefs();
+                    }
+                    else {
+                        debouncePreferencesChangedTimeout = setTimeout(syncPrefs, PREFERENCES_DEBOUNCE_MS);
+                        return { success: false, res: undefined }; // This needs to be implemented correctly to return a promise with the debouncer
+                    }
                 }
             }
             /*protected*/ hasUserId() {
@@ -98900,6 +98949,18 @@ var ts;
                 return arr;
             }
             Util.reversed = reversed;
+            function arrayEquals(a, b, compare = (c, d) => c === d) {
+                if (a == b)
+                    return true;
+                if (!a && b || !b && a || a.length !== b.length)
+                    return false;
+                for (let i = 0; i < a.length; i++) {
+                    if (!compare(a[i], b[i]))
+                        return false;
+                }
+                return true;
+            }
+            Util.arrayEquals = arrayEquals;
             function iterMap(m, f) {
                 Object.keys(m).forEach(k => f(k, m[k]));
             }
@@ -99175,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;
@@ -100723,6 +100796,10 @@ var ts;
                 }
             }
             jsonPatch.patchInPlace = patchInPlace;
+            function opsAreEqual(a, b) {
+                return (a.op === b.op && pxtc.U.arrayEquals(a.path, b.path));
+            }
+            jsonPatch.opsAreEqual = opsAreEqual;
         })(jsonPatch = pxtc.jsonPatch || (pxtc.jsonPatch = {}));
     })(pxtc = ts.pxtc || (ts.pxtc = {}));
 })(ts || (ts = {}));
@@ -116191,8 +116268,8 @@ var pxt;
         if (a == b)
             return true;
         if (a.id !== b.id || a.type !== b.type ||
-            !arrayEquals(a.meta.tags, b.meta.tags) ||
-            !arrayEquals(a.meta.blockIDs, b.meta.blockIDs) ||
+            !pxt.U.arrayEquals(a.meta.tags, b.meta.tags) ||
+            !pxt.U.arrayEquals(a.meta.blockIDs, b.meta.blockIDs) ||
             a.meta.displayName !== b.meta.displayName)
             return false;
         switch (a.type) {
@@ -116201,7 +116278,7 @@ var pxt;
                 return pxt.sprite.bitmapEquals(a.bitmap, b.bitmap);
             case "animation" /* Animation */:
                 const bAnimation = b;
-                return a.interval === bAnimation.interval && arrayEquals(a.frames, bAnimation.frames, pxt.sprite.bitmapEquals);
+                return a.interval === bAnimation.interval && pxt.U.arrayEquals(a.frames, bAnimation.frames, pxt.sprite.bitmapEquals);
             case "tilemap" /* Tilemap */:
                 return a.data.equals(b.data);
         }
@@ -116323,17 +116400,6 @@ var pxt;
         }
         return id;
     }
-    function arrayEquals(a, b, compare = (c, d) => c === d) {
-        if (a == b)
-            return true;
-        if (!a && b || !b && a || a.length !== b.length)
-            return false;
-        for (let i = 0; i < a.length; i++) {
-            if (!compare(a[i], b[i]))
-                return false;
-        }
-        return true;
-    }
     function serializeTilemap(tilemap, id, name) {
         const tm = tilemap.tilemap.data();
         const data = new Uint8ClampedArray(5 + tm.data.length + tilemap.layers.data.length);