@wordpress/data/build-module/plugins/persistence/index.js

Data module for WordPress.

// packages/data/src/plugins/persistence/index.js
import { isPlainObject } from "is-plain-object";
import deepmerge from "deepmerge";
import defaultStorage from "./storage/default";
import { combineReducers } from "../../";
var DEFAULT_STORAGE = defaultStorage;
var DEFAULT_STORAGE_KEY = "WP_DATA";
var withLazySameState = (reducer) => (state, action) => {
  if (action.nextState === state) {
    return state;
  }
  return reducer(state, action);
};
function createPersistenceInterface(options) {
  const { storage = DEFAULT_STORAGE, storageKey = DEFAULT_STORAGE_KEY } = options;
  let data;
  function getData() {
    if (data === void 0) {
      const persisted = storage.getItem(storageKey);
      if (persisted === null) {
        data = {};
      } else {
        try {
          data = JSON.parse(persisted);
        } catch (error) {
          data = {};
        }
      }
    }
    return data;
  }
  function setData(key, value) {
    data = { ...data, [key]: value };
    storage.setItem(storageKey, JSON.stringify(data));
  }
  return {
    get: getData,
    set: setData
  };
}
function persistencePlugin(registry, pluginOptions) {
  const persistence = createPersistenceInterface(pluginOptions);
  function createPersistOnChange(getState, storeName, keys) {
    let getPersistedState;
    if (Array.isArray(keys)) {
      const reducers = keys.reduce(
        (accumulator, key) => Object.assign(accumulator, {
          [key]: (state, action) => action.nextState[key]
        }),
        {}
      );
      getPersistedState = withLazySameState(
        combineReducers(reducers)
      );
    } else {
      getPersistedState = (state, action) => action.nextState;
    }
    let lastState = getPersistedState(void 0, {
      nextState: getState()
    });
    return () => {
      const state = getPersistedState(lastState, {
        nextState: getState()
      });
      if (state !== lastState) {
        persistence.set(storeName, state);
        lastState = state;
      }
    };
  }
  return {
    registerStore(storeName, options) {
      if (!options.persist) {
        return registry.registerStore(storeName, options);
      }
      const persistedState = persistence.get()[storeName];
      if (persistedState !== void 0) {
        let initialState = options.reducer(options.initialState, {
          type: "@@WP/PERSISTENCE_RESTORE"
        });
        if (isPlainObject(initialState) && isPlainObject(persistedState)) {
          initialState = deepmerge(initialState, persistedState, {
            isMergeableObject: isPlainObject
          });
        } else {
          initialState = persistedState;
        }
        options = {
          ...options,
          initialState
        };
      }
      const store = registry.registerStore(storeName, options);
      store.subscribe(
        createPersistOnChange(
          store.getState,
          storeName,
          options.persist
        )
      );
      return store;
    }
  };
}
persistencePlugin.__unstableMigrate = () => {
};
var persistence_default = persistencePlugin;
export {
  createPersistenceInterface,
  persistence_default as default,
  withLazySameState
};
//# sourceMappingURL=index.js.map