@wordpress/data 9.9.0 → 9.10.1

package/build/redux-store/index.js

@@ -1,42 +1,25 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = createReduxStore;
-
 var _redux = require("redux");
-
 var _turboCombineReducers = _interopRequireDefault(require("turbo-combine-reducers"));
-
 var _equivalentKeyMap = _interopRequireDefault(require("equivalent-key-map"));
-
 var _reduxRoutine = _interopRequireDefault(require("@wordpress/redux-routine"));
-
 var _compose = require("@wordpress/compose");
-
 var _controls = require("../controls");
-
 var _lockUnlock = require("../lock-unlock");
-
 var _promiseMiddleware = _interopRequireDefault(require("../promise-middleware"));
-
 var _resolversCacheMiddleware = _interopRequireDefault(require("../resolvers-cache-middleware"));
-
 var _thunkMiddleware = _interopRequireDefault(require("./thunk-middleware"));
-
 var _reducer = _interopRequireDefault(require("./metadata/reducer"));
-
 var metadataSelectors = _interopRequireWildcard(require("./metadata/selectors"));
-
 var metadataActions = _interopRequireWildcard(require("./metadata/actions"));
-
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 /**
  * External dependencies
  */
@@ -50,31 +33,28 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
  */
 
 /** @typedef {import('../types').DataRegistry} DataRegistry */
-
 /** @typedef {import('../types').ListenerFunction} ListenerFunction */
-
 /**
  * @typedef {import('../types').StoreDescriptor<C>} StoreDescriptor
  * @template {import('../types').AnyConfig} C
  */
-
 /**
  * @typedef {import('../types').ReduxStoreConfig<State,Actions,Selectors>} ReduxStoreConfig
  * @template State
  * @template {Record<string,import('../../types').ActionCreator>} Actions
  * @template Selectors
  */
+
 const trimUndefinedValues = array => {
   const result = [...array];
-
   for (let i = result.length - 1; i >= 0; i--) {
     if (result[i] === undefined) {
       result.splice(i, 1);
     }
   }
-
   return result;
 };
+
 /**
  * Creates a new object with the same keys, but with `callback()` called as
  * a transformer function on each of the values.
@@ -83,65 +63,54 @@ const trimUndefinedValues = array => {
  * @param {Function} callback The function to transform each object value.
  * @return {Array} Transformed object.
  */
+const mapValues = (obj, callback) => Object.fromEntries(Object.entries(obj !== null && obj !== void 0 ? obj : {}).map(([key, value]) => [key, callback(value, key)]));
 
-
-const mapValues = (obj, callback) => Object.fromEntries(Object.entries(obj !== null && obj !== void 0 ? obj : {}).map(([key, value]) => [key, callback(value, key)])); // Convert Map objects to plain objects
-
-
+// Convert Map objects to plain objects
 const mapToObject = (key, state) => {
   if (state instanceof Map) {
     return Object.fromEntries(state);
   }
-
   return state;
 };
+
 /**
  * Create a cache to track whether resolvers started running or not.
  *
  * @return {Object} Resolvers Cache.
  */
-
-
 function createResolversCache() {
   const cache = {};
   return {
     isRunning(selectorName, args) {
       return cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args));
     },
-
     clear(selectorName, args) {
       if (cache[selectorName]) {
         cache[selectorName].delete(trimUndefinedValues(args));
       }
     },
-
     markAsRunning(selectorName, args) {
       if (!cache[selectorName]) {
         cache[selectorName] = new _equivalentKeyMap.default();
       }
-
       cache[selectorName].set(trimUndefinedValues(args), true);
     }
-
   };
 }
-
 function createBindingCache(bind) {
   const cache = new WeakMap();
   return {
     get(item, itemName) {
       let boundItem = cache.get(item);
-
       if (!boundItem) {
         boundItem = bind(item, itemName);
         cache.set(item, boundItem);
       }
-
       return boundItem;
     }
-
   };
 }
+
 /**
  * Creates a data store descriptor for the provided Redux store configuration containing
  * properties describing reducer, actions, selectors, controls and resolvers.
@@ -168,8 +137,6 @@ function createBindingCache(bind) {
  *
  * @return   {StoreDescriptor<ReduxStoreConfig<State,Actions,Selectors>>} Store Object.
  */
-
-
 function createReduxStore(key, options) {
   const privateActions = {};
   const privateSelectors = {};
@@ -202,31 +169,26 @@ function createReduxStore(key, options) {
       const reducer = options.reducer;
       const thunkArgs = {
         registry,
-
         get dispatch() {
           return thunkActions;
         },
-
         get select() {
           return thunkSelectors;
         },
-
         get resolveSelect() {
           return getResolveSelectors();
         }
-
       };
-      const store = instantiateReduxStore(key, options, registry, thunkArgs); // Expose the private registration functions on the store
+      const store = instantiateReduxStore(key, options, registry, thunkArgs);
+      // Expose the private registration functions on the store
       // so they can be copied to a sub registry in registry.js.
-
       (0, _lockUnlock.lock)(store, privateRegistrationFunctions);
       const resolversCache = createResolversCache();
-
       function bindAction(action) {
         return (...args) => Promise.resolve(store.dispatch(action(...args)));
       }
-
-      const actions = { ...mapValues(metadataActions, bindAction),
+      const actions = {
+        ...mapValues(metadataActions, bindAction),
         ...mapValues(options.actions, bindAction)
       };
       const boundPrivateActions = createBindingCache(bindAction);
@@ -241,49 +203,40 @@ function createReduxStore(key, options) {
       });
       (0, _lockUnlock.lock)(actions, allActions);
       const resolvers = options.resolvers ? mapResolvers(options.resolvers) : {};
-
       function bindSelector(selector, selectorName) {
         if (selector.isRegistrySelector) {
           selector.registry = registry;
         }
-
         const boundSelector = (...args) => {
           const state = store.__unstableOriginalGetState();
-
           return selector(state.root, ...args);
         };
-
         const resolver = resolvers[selectorName];
-
         if (!resolver) {
           boundSelector.hasResolver = false;
           return boundSelector;
         }
-
         return mapSelectorWithResolver(boundSelector, selectorName, resolver, store, resolversCache);
       }
-
       function bindMetadataSelector(selector) {
         const boundSelector = (...args) => {
           const state = store.__unstableOriginalGetState();
-
           return selector(state.metadata, ...args);
         };
-
         boundSelector.hasResolver = false;
         return boundSelector;
       }
-
-      const selectors = { ...mapValues(metadataSelectors, bindMetadataSelector),
+      const selectors = {
+        ...mapValues(metadataSelectors, bindMetadataSelector),
         ...mapValues(options.selectors, bindSelector)
       };
-      const boundPrivateSelectors = createBindingCache(bindSelector); // Pre-bind the private selectors that have been registered by the time of
-      // instantiation, so that registry selectors are bound to the registry.
+      const boundPrivateSelectors = createBindingCache(bindSelector);
 
+      // Pre-bind the private selectors that have been registered by the time of
+      // instantiation, so that registry selectors are bound to the registry.
       for (const [selectorName, selector] of Object.entries(privateSelectors)) {
         boundPrivateSelectors.get(selector, selectorName);
       }
-
       const allSelectors = new Proxy(() => {}, {
         get: (target, prop) => {
           const privateSelector = privateSelectors[prop];
@@ -296,45 +249,37 @@ function createReduxStore(key, options) {
       (0, _lockUnlock.lock)(selectors, allSelectors);
       const resolveSelectors = mapResolveSelectors(selectors, store);
       const suspendSelectors = mapSuspendSelectors(selectors, store);
-
       const getSelectors = () => selectors;
-
       const getActions = () => actions;
-
       const getResolveSelectors = () => resolveSelectors;
+      const getSuspendSelectors = () => suspendSelectors;
 
-      const getSuspendSelectors = () => suspendSelectors; // We have some modules monkey-patching the store object
+      // We have some modules monkey-patching the store object
       // It's wrong to do so but until we refactor all of our effects to controls
       // We need to keep the same "store" instance here.
-
-
       store.__unstableOriginalGetState = store.getState;
+      store.getState = () => store.__unstableOriginalGetState().root;
 
-      store.getState = () => store.__unstableOriginalGetState().root; // Customize subscribe behavior to call listeners only on effective change,
+      // Customize subscribe behavior to call listeners only on effective change,
       // not on every dispatch.
-
-
       const subscribe = store && (listener => {
         listeners.add(listener);
         return () => listeners.delete(listener);
       });
-
       let lastState = store.__unstableOriginalGetState();
-
       store.subscribe(() => {
         const state = store.__unstableOriginalGetState();
-
         const hasChanged = state !== lastState;
         lastState = state;
-
         if (hasChanged) {
           for (const listener of listeners) {
             listener();
           }
         }
-      }); // This can be simplified to just { subscribe, getSelectors, getActions }
-      // Once we remove the use function.
+      });
 
+      // This can be simplified to just { subscribe, getSelectors, getActions }
+      // Once we remove the use function.
       return {
         reducer,
         store,
@@ -348,13 +293,15 @@ function createReduxStore(key, options) {
         subscribe
       };
     }
-  }; // Expose the private registration functions on the store
+  };
+
+  // Expose the private registration functions on the store
   // descriptor. That's a natural choice since that's where the
   // public actions and selectors are stored .
-
   (0, _lockUnlock.lock)(storeDescriptor, privateRegistrationFunctions);
   return storeDescriptor;
 }
+
 /**
  * Creates a redux store for a namespace.
  *
@@ -366,16 +313,14 @@ function createReduxStore(key, options) {
  * @param {Object}       thunkArgs Argument object for the thunk middleware.
  * @return {Object} Newly created redux store.
  */
-
-
 function instantiateReduxStore(key, options, registry, thunkArgs) {
-  const controls = { ...options.controls,
+  const controls = {
+    ...options.controls,
     ..._controls.builtinControls
   };
   const normalizedControls = mapValues(controls, control => control.isRegistryControl ? control(registry) : control);
   const middlewares = [(0, _resolversCacheMiddleware.default)(registry, key), _promiseMiddleware.default, (0, _reduxRoutine.default)(normalizedControls), (0, _thunkMiddleware.default)(thunkArgs)];
   const enhancers = [(0, _redux.applyMiddleware)(...middlewares)];
-
   if (typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__) {
     enhancers.push(window.__REDUX_DEVTOOLS_EXTENSION__({
       name: key,
@@ -385,7 +330,6 @@ function instantiateReduxStore(key, options, registry, thunkArgs) {
       }
     }));
   }
-
   const {
     reducer,
     initialState
@@ -398,6 +342,7 @@ function instantiateReduxStore(key, options, registry, thunkArgs) {
     root: initialState
   }, (0, _compose.compose)(enhancers));
 }
+
 /**
  * Maps selectors to functions that return a resolution promise for them
  *
@@ -406,8 +351,6 @@ function instantiateReduxStore(key, options, registry, thunkArgs) {
  *
  * @return {Object} Selectors mapped to their resolution functions.
  */
-
-
 function mapResolveSelectors(selectors, store) {
   const {
     getIsResolving,
@@ -427,14 +370,11 @@ function mapResolveSelectors(selectors, store) {
     if (!selector.hasResolver) {
       return async (...args) => selector.apply(null, args);
     }
-
     return (...args) => {
       return new Promise((resolve, reject) => {
         const hasFinished = () => selectors.hasFinishedResolution(selectorName, args);
-
         const finalize = result => {
           const hasFailed = selectors.hasResolutionFailed(selectorName, args);
-
           if (hasFailed) {
             const error = selectors.getResolutionError(selectorName, args);
             reject(error);
@@ -442,16 +382,12 @@ function mapResolveSelectors(selectors, store) {
             resolve(result);
           }
         };
-
-        const getResult = () => selector.apply(null, args); // Trigger the selector (to trigger the resolver)
-
-
+        const getResult = () => selector.apply(null, args);
+        // Trigger the selector (to trigger the resolver)
         const result = getResult();
-
         if (hasFinished()) {
           return finalize(result);
         }
-
         const unsubscribe = store.subscribe(() => {
           if (hasFinished()) {
             unsubscribe();
@@ -462,6 +398,7 @@ function mapResolveSelectors(selectors, store) {
     };
   });
 }
+
 /**
  * Maps selectors to functions that throw a suspense promise if not yet resolved.
  *
@@ -470,26 +407,20 @@ function mapResolveSelectors(selectors, store) {
  *
  * @return {Object} Selectors mapped to their suspense functions.
  */
-
-
 function mapSuspendSelectors(selectors, store) {
   return mapValues(selectors, (selector, selectorName) => {
     // Selector without a resolver doesn't have any extra suspense behavior.
     if (!selector.hasResolver) {
       return selector;
     }
-
     return (...args) => {
       const result = selector.apply(null, args);
-
       if (selectors.hasFinishedResolution(selectorName, args)) {
         if (selectors.hasResolutionFailed(selectorName, args)) {
           throw selectors.getResolutionError(selectorName, args);
         }
-
         return result;
       }
-
       throw new Promise(resolve => {
         const unsubscribe = store.subscribe(() => {
           if (selectors.hasFinishedResolution(selectorName, args)) {
@@ -501,27 +432,26 @@ function mapSuspendSelectors(selectors, store) {
     };
   });
 }
+
 /**
  * Convert resolvers to a normalized form, an object with `fulfill` method and
  * optional methods like `isFulfilled`.
  *
  * @param {Object} resolvers Resolver to convert
  */
-
-
 function mapResolvers(resolvers) {
   return mapValues(resolvers, resolver => {
     if (resolver.fulfill) {
       return resolver;
     }
-
-    return { ...resolver,
+    return {
+      ...resolver,
       // Copy the enumerable properties of the resolver function.
       fulfill: resolver // Add the fulfill method.
-
     };
   });
 }
+
 /**
  * Returns a selector with a matched resolver.
  * Resolvers are side effects invoked once per argument set of a given selector call,
@@ -533,48 +463,37 @@ function mapResolvers(resolvers) {
  * @param {Object} store          The redux store to which the resolvers should be mapped.
  * @param {Object} resolversCache Resolvers Cache.
  */
-
-
 function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache) {
   function fulfillSelector(args) {
     const state = store.getState();
-
     if (resolversCache.isRunning(selectorName, args) || typeof resolver.isFulfilled === 'function' && resolver.isFulfilled(state, ...args)) {
       return;
     }
-
     const {
       metadata
     } = store.__unstableOriginalGetState();
-
     if (metadataSelectors.hasStartedResolution(metadata, selectorName, args)) {
       return;
     }
-
     resolversCache.markAsRunning(selectorName, args);
     setTimeout(async () => {
       resolversCache.clear(selectorName, args);
       store.dispatch(metadataActions.startResolution(selectorName, args));
-
       try {
         const action = resolver.fulfill(...args);
-
         if (action) {
           await store.dispatch(action);
         }
-
         store.dispatch(metadataActions.finishResolution(selectorName, args));
       } catch (error) {
         store.dispatch(metadataActions.failResolution(selectorName, args, error));
       }
     }, 0);
   }
-
   const selectorResolver = (...args) => {
     fulfillSelector(args);
     return selector(...args);
   };
-
   selectorResolver.hasResolver = true;
   return selectorResolver;
 }