first commit

wp-includes/js/dist/preferences-persistence.js

@@ -0,0 +1,510 @@
+var wp;
+(wp ||= {}).preferencesPersistence = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // package-external:@wordpress/api-fetch
+  var require_api_fetch = __commonJS({
+    "package-external:@wordpress/api-fetch"(exports, module) {
+      module.exports = window.wp.apiFetch;
+    }
+  });
+
+  // packages/preferences-persistence/build-module/index.mjs
+  var index_exports = {};
+  __export(index_exports, {
+    __unstableCreatePersistenceLayer: () => __unstableCreatePersistenceLayer,
+    create: () => create
+  });
+
+  // packages/preferences-persistence/build-module/create/index.mjs
+  var import_api_fetch = __toESM(require_api_fetch(), 1);
+
+  // packages/preferences-persistence/build-module/create/debounce-async.mjs
+  function debounceAsync(func, delayMS) {
+    let timeoutId;
+    let activePromise;
+    return async function debounced(...args) {
+      if (!activePromise && !timeoutId) {
+        return new Promise((resolve, reject) => {
+          activePromise = func(...args).then((...thenArgs) => {
+            resolve(...thenArgs);
+          }).catch((error) => {
+            reject(error);
+          }).finally(() => {
+            activePromise = null;
+          });
+        });
+      }
+      if (activePromise) {
+        await activePromise;
+      }
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      return new Promise((resolve, reject) => {
+        timeoutId = setTimeout(() => {
+          activePromise = func(...args).then((...thenArgs) => {
+            resolve(...thenArgs);
+          }).catch((error) => {
+            reject(error);
+          }).finally(() => {
+            activePromise = null;
+            timeoutId = null;
+          });
+        }, delayMS);
+      });
+    };
+  }
+
+  // packages/preferences-persistence/build-module/create/index.mjs
+  var EMPTY_OBJECT = {};
+  var localStorage = window.localStorage;
+  function create({
+    preloadedData,
+    localStorageRestoreKey = "WP_PREFERENCES_RESTORE_DATA",
+    requestDebounceMS = 2500
+  } = {}) {
+    let cache = preloadedData;
+    const debouncedApiFetch = debounceAsync(import_api_fetch.default, requestDebounceMS);
+    async function get() {
+      if (cache) {
+        return cache;
+      }
+      const user = await (0, import_api_fetch.default)({
+        path: "/wp/v2/users/me?context=edit"
+      });
+      const serverData = user?.meta?.persisted_preferences;
+      const localData = JSON.parse(
+        localStorage.getItem(localStorageRestoreKey)
+      );
+      const serverTimestamp = Date.parse(serverData?._modified) || 0;
+      const localTimestamp = Date.parse(localData?._modified) || 0;
+      if (serverData && serverTimestamp >= localTimestamp) {
+        cache = serverData;
+      } else if (localData) {
+        cache = localData;
+      } else {
+        cache = EMPTY_OBJECT;
+      }
+      return cache;
+    }
+    function set(newData) {
+      const dataWithTimestamp = {
+        ...newData,
+        _modified: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      cache = dataWithTimestamp;
+      localStorage.setItem(
+        localStorageRestoreKey,
+        JSON.stringify(dataWithTimestamp)
+      );
+      debouncedApiFetch({
+        path: "/wp/v2/users/me",
+        method: "PUT",
+        // `keepalive` will still send the request in the background,
+        // even when a browser unload event might interrupt it.
+        // This should hopefully make things more resilient.
+        // This does have a size limit of 64kb, but the data is usually
+        // much less.
+        keepalive: true,
+        data: {
+          meta: {
+            persisted_preferences: dataWithTimestamp
+          }
+        }
+      }).catch(() => {
+      });
+    }
+    return {
+      get,
+      set
+    };
+  }
+
+  // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/move-feature-preferences.mjs
+  function moveFeaturePreferences(state, sourceStoreName) {
+    const preferencesStoreName = "core/preferences";
+    const interfaceStoreName = "core/interface";
+    const interfaceFeatures = state?.[interfaceStoreName]?.preferences?.features?.[sourceStoreName];
+    const sourceFeatures = state?.[sourceStoreName]?.preferences?.features;
+    const featuresToMigrate = interfaceFeatures ? interfaceFeatures : sourceFeatures;
+    if (!featuresToMigrate) {
+      return state;
+    }
+    const existingPreferences = state?.[preferencesStoreName]?.preferences;
+    if (existingPreferences?.[sourceStoreName]) {
+      return state;
+    }
+    let updatedInterfaceState;
+    if (interfaceFeatures) {
+      const otherInterfaceState = state?.[interfaceStoreName];
+      const otherInterfaceScopes = state?.[interfaceStoreName]?.preferences?.features;
+      updatedInterfaceState = {
+        [interfaceStoreName]: {
+          ...otherInterfaceState,
+          preferences: {
+            features: {
+              ...otherInterfaceScopes,
+              [sourceStoreName]: void 0
+            }
+          }
+        }
+      };
+    }
+    let updatedSourceState;
+    if (sourceFeatures) {
+      const otherSourceState = state?.[sourceStoreName];
+      const sourcePreferences = state?.[sourceStoreName]?.preferences;
+      updatedSourceState = {
+        [sourceStoreName]: {
+          ...otherSourceState,
+          preferences: {
+            ...sourcePreferences,
+            features: void 0
+          }
+        }
+      };
+    }
+    return {
+      ...state,
+      [preferencesStoreName]: {
+        preferences: {
+          ...existingPreferences,
+          [sourceStoreName]: featuresToMigrate
+        }
+      },
+      ...updatedInterfaceState,
+      ...updatedSourceState
+    };
+  }
+
+  // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/move-third-party-feature-preferences.mjs
+  function moveThirdPartyFeaturePreferencesToPreferences(state) {
+    const interfaceStoreName = "core/interface";
+    const preferencesStoreName = "core/preferences";
+    const interfaceScopes = state?.[interfaceStoreName]?.preferences?.features;
+    const interfaceScopeKeys = interfaceScopes ? Object.keys(interfaceScopes) : [];
+    if (!interfaceScopeKeys?.length) {
+      return state;
+    }
+    return interfaceScopeKeys.reduce(function(convertedState, scope) {
+      if (scope.startsWith("core")) {
+        return convertedState;
+      }
+      const featuresToMigrate = interfaceScopes?.[scope];
+      if (!featuresToMigrate) {
+        return convertedState;
+      }
+      const existingMigratedData = convertedState?.[preferencesStoreName]?.preferences?.[scope];
+      if (existingMigratedData) {
+        return convertedState;
+      }
+      const otherPreferencesScopes = convertedState?.[preferencesStoreName]?.preferences;
+      const otherInterfaceState = convertedState?.[interfaceStoreName];
+      const otherInterfaceScopes = convertedState?.[interfaceStoreName]?.preferences?.features;
+      return {
+        ...convertedState,
+        [preferencesStoreName]: {
+          preferences: {
+            ...otherPreferencesScopes,
+            [scope]: featuresToMigrate
+          }
+        },
+        [interfaceStoreName]: {
+          ...otherInterfaceState,
+          preferences: {
+            features: {
+              ...otherInterfaceScopes,
+              [scope]: void 0
+            }
+          }
+        }
+      };
+    }, state);
+  }
+
+  // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/move-individual-preference.mjs
+  var identity = (arg) => arg;
+  function moveIndividualPreferenceToPreferences(state, { from: sourceStoreName, to: scope }, key, convert = identity) {
+    const preferencesStoreName = "core/preferences";
+    const sourcePreference = state?.[sourceStoreName]?.preferences?.[key];
+    if (sourcePreference === void 0) {
+      return state;
+    }
+    const targetPreference = state?.[preferencesStoreName]?.preferences?.[scope]?.[key];
+    if (targetPreference) {
+      return state;
+    }
+    const otherScopes = state?.[preferencesStoreName]?.preferences;
+    const otherPreferences = state?.[preferencesStoreName]?.preferences?.[scope];
+    const otherSourceState = state?.[sourceStoreName];
+    const allSourcePreferences = state?.[sourceStoreName]?.preferences;
+    const convertedPreferences = convert({ [key]: sourcePreference });
+    return {
+      ...state,
+      [preferencesStoreName]: {
+        preferences: {
+          ...otherScopes,
+          [scope]: {
+            ...otherPreferences,
+            ...convertedPreferences
+          }
+        }
+      },
+      [sourceStoreName]: {
+        ...otherSourceState,
+        preferences: {
+          ...allSourcePreferences,
+          [key]: void 0
+        }
+      }
+    };
+  }
+
+  // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/move-interface-enable-items.mjs
+  function moveInterfaceEnableItems(state) {
+    const interfaceStoreName = "core/interface";
+    const preferencesStoreName = "core/preferences";
+    const sourceEnableItems = state?.[interfaceStoreName]?.enableItems;
+    if (!sourceEnableItems) {
+      return state;
+    }
+    const allPreferences = state?.[preferencesStoreName]?.preferences ?? {};
+    const sourceComplementaryAreas = sourceEnableItems?.singleEnableItems?.complementaryArea ?? {};
+    const preferencesWithConvertedComplementaryAreas = Object.keys(
+      sourceComplementaryAreas
+    ).reduce((accumulator, scope) => {
+      const data = sourceComplementaryAreas[scope];
+      if (accumulator?.[scope]?.complementaryArea) {
+        return accumulator;
+      }
+      return {
+        ...accumulator,
+        [scope]: {
+          ...accumulator[scope],
+          complementaryArea: data
+        }
+      };
+    }, allPreferences);
+    const sourcePinnedItems = sourceEnableItems?.multipleEnableItems?.pinnedItems ?? {};
+    const allConvertedData = Object.keys(sourcePinnedItems).reduce(
+      (accumulator, scope) => {
+        const data = sourcePinnedItems[scope];
+        if (accumulator?.[scope]?.pinnedItems) {
+          return accumulator;
+        }
+        return {
+          ...accumulator,
+          [scope]: {
+            ...accumulator[scope],
+            pinnedItems: data
+          }
+        };
+      },
+      preferencesWithConvertedComplementaryAreas
+    );
+    const otherInterfaceItems = state[interfaceStoreName];
+    return {
+      ...state,
+      [preferencesStoreName]: {
+        preferences: allConvertedData
+      },
+      [interfaceStoreName]: {
+        ...otherInterfaceItems,
+        enableItems: void 0
+      }
+    };
+  }
+
+  // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/convert-edit-post-panels.mjs
+  function convertEditPostPanels(preferences) {
+    const panels = preferences?.panels ?? {};
+    return Object.keys(panels).reduce(
+      (convertedData, panelName) => {
+        const panel = panels[panelName];
+        if (panel?.enabled === false) {
+          convertedData.inactivePanels.push(panelName);
+        }
+        if (panel?.opened === true) {
+          convertedData.openPanels.push(panelName);
+        }
+        return convertedData;
+      },
+      { inactivePanels: [], openPanels: [] }
+    );
+  }
+
+  // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/index.mjs
+  function getLegacyData(userId) {
+    const key = `WP_DATA_USER_${userId}`;
+    const unparsedData = window.localStorage.getItem(key);
+    return JSON.parse(unparsedData);
+  }
+  function convertLegacyData(data) {
+    if (!data) {
+      return;
+    }
+    data = moveFeaturePreferences(data, "core/edit-widgets");
+    data = moveFeaturePreferences(data, "core/customize-widgets");
+    data = moveFeaturePreferences(data, "core/edit-post");
+    data = moveFeaturePreferences(data, "core/edit-site");
+    data = moveThirdPartyFeaturePreferencesToPreferences(data);
+    data = moveInterfaceEnableItems(data);
+    data = moveIndividualPreferenceToPreferences(
+      data,
+      { from: "core/edit-post", to: "core/edit-post" },
+      "hiddenBlockTypes"
+    );
+    data = moveIndividualPreferenceToPreferences(
+      data,
+      { from: "core/edit-post", to: "core/edit-post" },
+      "editorMode"
+    );
+    data = moveIndividualPreferenceToPreferences(
+      data,
+      { from: "core/edit-post", to: "core/edit-post" },
+      "panels",
+      convertEditPostPanels
+    );
+    data = moveIndividualPreferenceToPreferences(
+      data,
+      { from: "core/editor", to: "core" },
+      "isPublishSidebarEnabled"
+    );
+    data = moveIndividualPreferenceToPreferences(
+      data,
+      { from: "core/edit-post", to: "core" },
+      "isPublishSidebarEnabled"
+    );
+    data = moveIndividualPreferenceToPreferences(
+      data,
+      { from: "core/edit-site", to: "core/edit-site" },
+      "editorMode"
+    );
+    return data?.["core/preferences"]?.preferences;
+  }
+  function convertLegacyLocalStorageData(userId) {
+    const data = getLegacyData(userId);
+    return convertLegacyData(data);
+  }
+
+  // packages/preferences-persistence/build-module/migrations/preferences-package-data/convert-complementary-areas.mjs
+  function convertComplementaryAreas(state) {
+    return Object.keys(state).reduce((stateAccumulator, scope) => {
+      const scopeData = state[scope];
+      if (scopeData?.complementaryArea) {
+        const updatedScopeData = { ...scopeData };
+        delete updatedScopeData.complementaryArea;
+        updatedScopeData.isComplementaryAreaVisible = true;
+        stateAccumulator[scope] = updatedScopeData;
+        return stateAccumulator;
+      }
+      return stateAccumulator;
+    }, state);
+  }
+
+  // packages/preferences-persistence/build-module/migrations/preferences-package-data/convert-editor-settings.mjs
+  function convertEditorSettings(data) {
+    let newData = data;
+    const settingsToMoveToCore = [
+      "allowRightClickOverrides",
+      "distractionFree",
+      "editorMode",
+      "fixedToolbar",
+      "focusMode",
+      "hiddenBlockTypes",
+      "inactivePanels",
+      "keepCaretInsideBlock",
+      "mostUsedBlocks",
+      "openPanels",
+      "showBlockBreadcrumbs",
+      "showIconLabels",
+      "showListViewByDefault",
+      "isPublishSidebarEnabled",
+      "isComplementaryAreaVisible",
+      "pinnedItems"
+    ];
+    settingsToMoveToCore.forEach((setting) => {
+      if (data?.["core/edit-post"]?.[setting] !== void 0) {
+        newData = {
+          ...newData,
+          core: {
+            ...newData?.core,
+            [setting]: data["core/edit-post"][setting]
+          }
+        };
+        delete newData["core/edit-post"][setting];
+      }
+      if (data?.["core/edit-site"]?.[setting] !== void 0) {
+        delete newData["core/edit-site"][setting];
+      }
+    });
+    if (Object.keys(newData?.["core/edit-post"] ?? {})?.length === 0) {
+      delete newData["core/edit-post"];
+    }
+    if (Object.keys(newData?.["core/edit-site"] ?? {})?.length === 0) {
+      delete newData["core/edit-site"];
+    }
+    return newData;
+  }
+
+  // packages/preferences-persistence/build-module/migrations/preferences-package-data/index.mjs
+  function convertPreferencesPackageData(data) {
+    let newData = convertComplementaryAreas(data);
+    newData = convertEditorSettings(newData);
+    return newData;
+  }
+
+  // packages/preferences-persistence/build-module/index.mjs
+  function __unstableCreatePersistenceLayer(serverData, userId) {
+    const localStorageRestoreKey = `WP_PREFERENCES_USER_${userId}`;
+    const localData = JSON.parse(
+      window.localStorage.getItem(localStorageRestoreKey)
+    );
+    const serverModified = Date.parse(serverData && serverData._modified) || 0;
+    const localModified = Date.parse(localData && localData._modified) || 0;
+    let preloadedData;
+    if (serverData && serverModified >= localModified) {
+      preloadedData = convertPreferencesPackageData(serverData);
+    } else if (localData) {
+      preloadedData = convertPreferencesPackageData(localData);
+    } else {
+      preloadedData = convertLegacyLocalStorageData(userId);
+    }
+    return create({
+      preloadedData,
+      localStorageRestoreKey
+    });
+  }
+  return __toCommonJS(index_exports);
+})();