[Summary view] [Print] [Text view]

   1  (function() {
   2  var wp;
   3  (wp ||= {}).preferencesPersistence = (() => {
   4    var __create = Object.create;
   5    var __defProp = Object.defineProperty;
   6    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   7    var __getOwnPropNames = Object.getOwnPropertyNames;
   8    var __getProtoOf = Object.getPrototypeOf;
   9    var __hasOwnProp = Object.prototype.hasOwnProperty;
  10    var __commonJS = (cb, mod) => function __require() {
  11      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  12    };
  13    var __export = (target, all) => {
  14      for (var name in all)
  15        __defProp(target, name, { get: all[name], enumerable: true });
  16    };
  17    var __copyProps = (to, from, except, desc) => {
  18      if (from && typeof from === "object" || typeof from === "function") {
  19        for (let key of __getOwnPropNames(from))
  20          if (!__hasOwnProp.call(to, key) && key !== except)
  21            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  22      }
  23      return to;
  24    };
  25    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  26      // If the importer is in node compatibility mode or this is not an ESM
  27      // file that has been converted to a CommonJS file using a Babel-
  28      // compatible transform (i.e. "__esModule" has not been set), then set
  29      // "default" to the CommonJS "module.exports" for node compatibility.
  30      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  31      mod
  32    ));
  33    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  34  
  35    // package-external:@wordpress/api-fetch
  36    var require_api_fetch = __commonJS({
  37      "package-external:@wordpress/api-fetch"(exports, module) {
  38        module.exports = window.wp.apiFetch;
  39      }
  40    });
  41  
  42    // packages/preferences-persistence/build-module/index.mjs
  43    var index_exports = {};
  44    __export(index_exports, {
  45      __unstableCreatePersistenceLayer: () => __unstableCreatePersistenceLayer,
  46      create: () => create
  47    });
  48  
  49    // packages/preferences-persistence/build-module/create/index.mjs
  50    var import_api_fetch = __toESM(require_api_fetch(), 1);
  51  
  52    // packages/preferences-persistence/build-module/create/debounce-async.mjs
  53    function debounceAsync(func, delayMS) {
  54      let timeoutId;
  55      let activePromise;
  56      return async function debounced(...args) {
  57        if (!activePromise && !timeoutId) {
  58          return new Promise((resolve, reject) => {
  59            activePromise = func(...args).then((...thenArgs) => {
  60              resolve(...thenArgs);
  61            }).catch((error) => {
  62              reject(error);
  63            }).finally(() => {
  64              activePromise = null;
  65            });
  66          });
  67        }
  68        if (activePromise) {
  69          await activePromise;
  70        }
  71        if (timeoutId) {
  72          clearTimeout(timeoutId);
  73          timeoutId = null;
  74        }
  75        return new Promise((resolve, reject) => {
  76          timeoutId = setTimeout(() => {
  77            activePromise = func(...args).then((...thenArgs) => {
  78              resolve(...thenArgs);
  79            }).catch((error) => {
  80              reject(error);
  81            }).finally(() => {
  82              activePromise = null;
  83              timeoutId = null;
  84            });
  85          }, delayMS);
  86        });
  87      };
  88    }
  89  
  90    // packages/preferences-persistence/build-module/create/index.mjs
  91    var EMPTY_OBJECT = {};
  92    var localStorage = window.localStorage;
  93    function create({
  94      preloadedData,
  95      localStorageRestoreKey = "WP_PREFERENCES_RESTORE_DATA",
  96      requestDebounceMS = 2500
  97    } = {}) {
  98      let cache = preloadedData;
  99      const debouncedApiFetch = debounceAsync(import_api_fetch.default, requestDebounceMS);
 100      async function get() {
 101        if (cache) {
 102          return cache;
 103        }
 104        const user = await (0, import_api_fetch.default)({
 105          path: "/wp/v2/users/me?context=edit"
 106        });
 107        const serverData = user?.meta?.persisted_preferences;
 108        const localData = JSON.parse(
 109          localStorage.getItem(localStorageRestoreKey)
 110        );
 111        const serverTimestamp = Date.parse(serverData?._modified) || 0;
 112        const localTimestamp = Date.parse(localData?._modified) || 0;
 113        if (serverData && serverTimestamp >= localTimestamp) {
 114          cache = serverData;
 115        } else if (localData) {
 116          cache = localData;
 117        } else {
 118          cache = EMPTY_OBJECT;
 119        }
 120        return cache;
 121      }
 122      function set(newData) {
 123        const dataWithTimestamp = {
 124          ...newData,
 125          _modified: (/* @__PURE__ */ new Date()).toISOString()
 126        };
 127        cache = dataWithTimestamp;
 128        localStorage.setItem(
 129          localStorageRestoreKey,
 130          JSON.stringify(dataWithTimestamp)
 131        );
 132        debouncedApiFetch({
 133          path: "/wp/v2/users/me",
 134          method: "PUT",
 135          // `keepalive` will still send the request in the background,
 136          // even when a browser unload event might interrupt it.
 137          // This should hopefully make things more resilient.
 138          // This does have a size limit of 64kb, but the data is usually
 139          // much less.
 140          keepalive: true,
 141          data: {
 142            meta: {
 143              persisted_preferences: dataWithTimestamp
 144            }
 145          }
 146        }).catch(() => {
 147        });
 148      }
 149      return {
 150        get,
 151        set
 152      };
 153    }
 154  
 155    // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/move-feature-preferences.mjs
 156    function moveFeaturePreferences(state, sourceStoreName) {
 157      const preferencesStoreName = "core/preferences";
 158      const interfaceStoreName = "core/interface";
 159      const interfaceFeatures = state?.[interfaceStoreName]?.preferences?.features?.[sourceStoreName];
 160      const sourceFeatures = state?.[sourceStoreName]?.preferences?.features;
 161      const featuresToMigrate = interfaceFeatures ? interfaceFeatures : sourceFeatures;
 162      if (!featuresToMigrate) {
 163        return state;
 164      }
 165      const existingPreferences = state?.[preferencesStoreName]?.preferences;
 166      if (existingPreferences?.[sourceStoreName]) {
 167        return state;
 168      }
 169      let updatedInterfaceState;
 170      if (interfaceFeatures) {
 171        const otherInterfaceState = state?.[interfaceStoreName];
 172        const otherInterfaceScopes = state?.[interfaceStoreName]?.preferences?.features;
 173        updatedInterfaceState = {
 174          [interfaceStoreName]: {
 175            ...otherInterfaceState,
 176            preferences: {
 177              features: {
 178                ...otherInterfaceScopes,
 179                [sourceStoreName]: void 0
 180              }
 181            }
 182          }
 183        };
 184      }
 185      let updatedSourceState;
 186      if (sourceFeatures) {
 187        const otherSourceState = state?.[sourceStoreName];
 188        const sourcePreferences = state?.[sourceStoreName]?.preferences;
 189        updatedSourceState = {
 190          [sourceStoreName]: {
 191            ...otherSourceState,
 192            preferences: {
 193              ...sourcePreferences,
 194              features: void 0
 195            }
 196          }
 197        };
 198      }
 199      return {
 200        ...state,
 201        [preferencesStoreName]: {
 202          preferences: {
 203            ...existingPreferences,
 204            [sourceStoreName]: featuresToMigrate
 205          }
 206        },
 207        ...updatedInterfaceState,
 208        ...updatedSourceState
 209      };
 210    }
 211  
 212    // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/move-third-party-feature-preferences.mjs
 213    function moveThirdPartyFeaturePreferencesToPreferences(state) {
 214      const interfaceStoreName = "core/interface";
 215      const preferencesStoreName = "core/preferences";
 216      const interfaceScopes = state?.[interfaceStoreName]?.preferences?.features;
 217      const interfaceScopeKeys = interfaceScopes ? Object.keys(interfaceScopes) : [];
 218      if (!interfaceScopeKeys?.length) {
 219        return state;
 220      }
 221      return interfaceScopeKeys.reduce(function(convertedState, scope) {
 222        if (scope.startsWith("core")) {
 223          return convertedState;
 224        }
 225        const featuresToMigrate = interfaceScopes?.[scope];
 226        if (!featuresToMigrate) {
 227          return convertedState;
 228        }
 229        const existingMigratedData = convertedState?.[preferencesStoreName]?.preferences?.[scope];
 230        if (existingMigratedData) {
 231          return convertedState;
 232        }
 233        const otherPreferencesScopes = convertedState?.[preferencesStoreName]?.preferences;
 234        const otherInterfaceState = convertedState?.[interfaceStoreName];
 235        const otherInterfaceScopes = convertedState?.[interfaceStoreName]?.preferences?.features;
 236        return {
 237          ...convertedState,
 238          [preferencesStoreName]: {
 239            preferences: {
 240              ...otherPreferencesScopes,
 241              [scope]: featuresToMigrate
 242            }
 243          },
 244          [interfaceStoreName]: {
 245            ...otherInterfaceState,
 246            preferences: {
 247              features: {
 248                ...otherInterfaceScopes,
 249                [scope]: void 0
 250              }
 251            }
 252          }
 253        };
 254      }, state);
 255    }
 256  
 257    // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/move-individual-preference.mjs
 258    var identity = (arg) => arg;
 259    function moveIndividualPreferenceToPreferences(state, { from: sourceStoreName, to: scope }, key, convert = identity) {
 260      const preferencesStoreName = "core/preferences";
 261      const sourcePreference = state?.[sourceStoreName]?.preferences?.[key];
 262      if (sourcePreference === void 0) {
 263        return state;
 264      }
 265      const targetPreference = state?.[preferencesStoreName]?.preferences?.[scope]?.[key];
 266      if (targetPreference) {
 267        return state;
 268      }
 269      const otherScopes = state?.[preferencesStoreName]?.preferences;
 270      const otherPreferences = state?.[preferencesStoreName]?.preferences?.[scope];
 271      const otherSourceState = state?.[sourceStoreName];
 272      const allSourcePreferences = state?.[sourceStoreName]?.preferences;
 273      const convertedPreferences = convert({ [key]: sourcePreference });
 274      return {
 275        ...state,
 276        [preferencesStoreName]: {
 277          preferences: {
 278            ...otherScopes,
 279            [scope]: {
 280              ...otherPreferences,
 281              ...convertedPreferences
 282            }
 283          }
 284        },
 285        [sourceStoreName]: {
 286          ...otherSourceState,
 287          preferences: {
 288            ...allSourcePreferences,
 289            [key]: void 0
 290          }
 291        }
 292      };
 293    }
 294  
 295    // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/move-interface-enable-items.mjs
 296    function moveInterfaceEnableItems(state) {
 297      const interfaceStoreName = "core/interface";
 298      const preferencesStoreName = "core/preferences";
 299      const sourceEnableItems = state?.[interfaceStoreName]?.enableItems;
 300      if (!sourceEnableItems) {
 301        return state;
 302      }
 303      const allPreferences = state?.[preferencesStoreName]?.preferences ?? {};
 304      const sourceComplementaryAreas = sourceEnableItems?.singleEnableItems?.complementaryArea ?? {};
 305      const preferencesWithConvertedComplementaryAreas = Object.keys(
 306        sourceComplementaryAreas
 307      ).reduce((accumulator, scope) => {
 308        const data = sourceComplementaryAreas[scope];
 309        if (accumulator?.[scope]?.complementaryArea) {
 310          return accumulator;
 311        }
 312        return {
 313          ...accumulator,
 314          [scope]: {
 315            ...accumulator[scope],
 316            complementaryArea: data
 317          }
 318        };
 319      }, allPreferences);
 320      const sourcePinnedItems = sourceEnableItems?.multipleEnableItems?.pinnedItems ?? {};
 321      const allConvertedData = Object.keys(sourcePinnedItems).reduce(
 322        (accumulator, scope) => {
 323          const data = sourcePinnedItems[scope];
 324          if (accumulator?.[scope]?.pinnedItems) {
 325            return accumulator;
 326          }
 327          return {
 328            ...accumulator,
 329            [scope]: {
 330              ...accumulator[scope],
 331              pinnedItems: data
 332            }
 333          };
 334        },
 335        preferencesWithConvertedComplementaryAreas
 336      );
 337      const otherInterfaceItems = state[interfaceStoreName];
 338      return {
 339        ...state,
 340        [preferencesStoreName]: {
 341          preferences: allConvertedData
 342        },
 343        [interfaceStoreName]: {
 344          ...otherInterfaceItems,
 345          enableItems: void 0
 346        }
 347      };
 348    }
 349  
 350    // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/convert-edit-post-panels.mjs
 351    function convertEditPostPanels(preferences) {
 352      const panels = preferences?.panels ?? {};
 353      return Object.keys(panels).reduce(
 354        (convertedData, panelName) => {
 355          const panel = panels[panelName];
 356          if (panel?.enabled === false) {
 357            convertedData.inactivePanels.push(panelName);
 358          }
 359          if (panel?.opened === true) {
 360            convertedData.openPanels.push(panelName);
 361          }
 362          return convertedData;
 363        },
 364        { inactivePanels: [], openPanels: [] }
 365      );
 366    }
 367  
 368    // packages/preferences-persistence/build-module/migrations/legacy-local-storage-data/index.mjs
 369    function getLegacyData(userId) {
 370      const key = `WP_DATA_USER_$userId}`;
 371      const unparsedData = window.localStorage.getItem(key);
 372      return JSON.parse(unparsedData);
 373    }
 374    function convertLegacyData(data) {
 375      if (!data) {
 376        return;
 377      }
 378      data = moveFeaturePreferences(data, "core/edit-widgets");
 379      data = moveFeaturePreferences(data, "core/customize-widgets");
 380      data = moveFeaturePreferences(data, "core/edit-post");
 381      data = moveFeaturePreferences(data, "core/edit-site");
 382      data = moveThirdPartyFeaturePreferencesToPreferences(data);
 383      data = moveInterfaceEnableItems(data);
 384      data = moveIndividualPreferenceToPreferences(
 385        data,
 386        { from: "core/edit-post", to: "core/edit-post" },
 387        "hiddenBlockTypes"
 388      );
 389      data = moveIndividualPreferenceToPreferences(
 390        data,
 391        { from: "core/edit-post", to: "core/edit-post" },
 392        "editorMode"
 393      );
 394      data = moveIndividualPreferenceToPreferences(
 395        data,
 396        { from: "core/edit-post", to: "core/edit-post" },
 397        "panels",
 398        convertEditPostPanels
 399      );
 400      data = moveIndividualPreferenceToPreferences(
 401        data,
 402        { from: "core/editor", to: "core" },
 403        "isPublishSidebarEnabled"
 404      );
 405      data = moveIndividualPreferenceToPreferences(
 406        data,
 407        { from: "core/edit-post", to: "core" },
 408        "isPublishSidebarEnabled"
 409      );
 410      data = moveIndividualPreferenceToPreferences(
 411        data,
 412        { from: "core/edit-site", to: "core/edit-site" },
 413        "editorMode"
 414      );
 415      return data?.["core/preferences"]?.preferences;
 416    }
 417    function convertLegacyLocalStorageData(userId) {
 418      const data = getLegacyData(userId);
 419      return convertLegacyData(data);
 420    }
 421  
 422    // packages/preferences-persistence/build-module/migrations/preferences-package-data/convert-complementary-areas.mjs
 423    function convertComplementaryAreas(state) {
 424      return Object.keys(state).reduce((stateAccumulator, scope) => {
 425        const scopeData = state[scope];
 426        if (scopeData?.complementaryArea) {
 427          const updatedScopeData = { ...scopeData };
 428          delete updatedScopeData.complementaryArea;
 429          updatedScopeData.isComplementaryAreaVisible = true;
 430          stateAccumulator[scope] = updatedScopeData;
 431          return stateAccumulator;
 432        }
 433        return stateAccumulator;
 434      }, state);
 435    }
 436  
 437    // packages/preferences-persistence/build-module/migrations/preferences-package-data/convert-editor-settings.mjs
 438    function convertEditorSettings(data) {
 439      let newData = data;
 440      const settingsToMoveToCore = [
 441        "allowRightClickOverrides",
 442        "distractionFree",
 443        "editorMode",
 444        "fixedToolbar",
 445        "focusMode",
 446        "hiddenBlockTypes",
 447        "inactivePanels",
 448        "keepCaretInsideBlock",
 449        "mostUsedBlocks",
 450        "openPanels",
 451        "showBlockBreadcrumbs",
 452        "showIconLabels",
 453        "showListViewByDefault",
 454        "isPublishSidebarEnabled",
 455        "isComplementaryAreaVisible",
 456        "pinnedItems"
 457      ];
 458      settingsToMoveToCore.forEach((setting) => {
 459        if (data?.["core/edit-post"]?.[setting] !== void 0) {
 460          newData = {
 461            ...newData,
 462            core: {
 463              ...newData?.core,
 464              [setting]: data["core/edit-post"][setting]
 465            }
 466          };
 467          delete newData["core/edit-post"][setting];
 468        }
 469        if (data?.["core/edit-site"]?.[setting] !== void 0) {
 470          delete newData["core/edit-site"][setting];
 471        }
 472      });
 473      if (Object.keys(newData?.["core/edit-post"] ?? {})?.length === 0) {
 474        delete newData["core/edit-post"];
 475      }
 476      if (Object.keys(newData?.["core/edit-site"] ?? {})?.length === 0) {
 477        delete newData["core/edit-site"];
 478      }
 479      return newData;
 480    }
 481  
 482    // packages/preferences-persistence/build-module/migrations/preferences-package-data/index.mjs
 483    function convertPreferencesPackageData(data) {
 484      let newData = convertComplementaryAreas(data);
 485      newData = convertEditorSettings(newData);
 486      return newData;
 487    }
 488  
 489    // packages/preferences-persistence/build-module/index.mjs
 490    function __unstableCreatePersistenceLayer(serverData, userId) {
 491      const localStorageRestoreKey = `WP_PREFERENCES_USER_$userId}`;
 492      const localData = JSON.parse(
 493        window.localStorage.getItem(localStorageRestoreKey)
 494      );
 495      const serverModified = Date.parse(serverData && serverData._modified) || 0;
 496      const localModified = Date.parse(localData && localData._modified) || 0;
 497      let preloadedData;
 498      if (serverData && serverModified >= localModified) {
 499        preloadedData = convertPreferencesPackageData(serverData);
 500      } else if (localData) {
 501        preloadedData = convertPreferencesPackageData(localData);
 502      } else {
 503        preloadedData = convertLegacyLocalStorageData(userId);
 504      }
 505      return create({
 506        preloadedData,
 507        localStorageRestoreKey
 508      });
 509    }
 510    return __toCommonJS(index_exports);
 511  })();
 512  (window.wp ||= {}).preferencesPersistence = wp.preferencesPersistence;
 513  })();