fix: prevent asset conflicts between React and Grid.js versions

Add coexistence checks to all enqueue methods to prevent loading
both React and Grid.js assets simultaneously.

Changes:
- ReactAdmin.php: Only enqueue React assets when ?react=1
- Init.php: Skip Grid.js when React active on admin pages
- Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0
- Customer.php, Product.php, License.php: Add coexistence checks

Now the toggle between Classic and React versions works correctly.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

node_modules/@wordpress/data/build-module/redux-store/combine-reducers.js

@@ -0,0 +1,16 @@
+export function combineReducers(reducers) {
+  const keys = Object.keys(reducers);
+  return function combinedReducer(state = {}, action) {
+    const nextState = {};
+    let hasChanged = false;
+    for (const key of keys) {
+      const reducer = reducers[key];
+      const prevStateForKey = state[key];
+      const nextStateForKey = reducer(prevStateForKey, action);
+      nextState[key] = nextStateForKey;
+      hasChanged = hasChanged || nextStateForKey !== prevStateForKey;
+    }
+    return hasChanged ? nextState : state;
+  };
+}
+//# sourceMappingURL=combine-reducers.js.map

node_modules/@wordpress/data/build-module/redux-store/combine-reducers.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["combineReducers","reducers","keys","Object","combinedReducer","state","action","nextState","hasChanged","key","reducer","prevStateForKey","nextStateForKey"],"sources":["@wordpress/data/src/redux-store/combine-reducers.js"],"sourcesContent":["export function combineReducers( reducers ) {\n\tconst keys = Object.keys( reducers );\n\n\treturn function combinedReducer( state = {}, action ) {\n\t\tconst nextState = {};\n\t\tlet hasChanged = false;\n\t\tfor ( const key of keys ) {\n\t\t\tconst reducer = reducers[ key ];\n\t\t\tconst prevStateForKey = state[ key ];\n\t\t\tconst nextStateForKey = reducer( prevStateForKey, action );\n\t\t\tnextState[ key ] = nextStateForKey;\n\t\t\thasChanged = hasChanged || nextStateForKey !== prevStateForKey;\n\t\t}\n\n\t\treturn hasChanged ? nextState : state;\n\t};\n}\n"],"mappings":"AAAA,OAAO,SAASA,eAAeA,CAAEC,QAAQ,EAAG;EAC3C,MAAMC,IAAI,GAAGC,MAAM,CAACD,IAAI,CAAED,QAAS,CAAC;EAEpC,OAAO,SAASG,eAAeA,CAAEC,KAAK,GAAG,CAAC,CAAC,EAAEC,MAAM,EAAG;IACrD,MAAMC,SAAS,GAAG,CAAC,CAAC;IACpB,IAAIC,UAAU,GAAG,KAAK;IACtB,KAAM,MAAMC,GAAG,IAAIP,IAAI,EAAG;MACzB,MAAMQ,OAAO,GAAGT,QAAQ,CAAEQ,GAAG,CAAE;MAC/B,MAAME,eAAe,GAAGN,KAAK,CAAEI,GAAG,CAAE;MACpC,MAAMG,eAAe,GAAGF,OAAO,CAAEC,eAAe,EAAEL,MAAO,CAAC;MAC1DC,SAAS,CAAEE,GAAG,CAAE,GAAGG,eAAe;MAClCJ,UAAU,GAAGA,UAAU,IAAII,eAAe,KAAKD,eAAe;IAC/D;IAEA,OAAOH,UAAU,GAAGD,SAAS,GAAGF,KAAK;EACtC,CAAC;AACF","ignoreList":[]}

node_modules/@wordpress/data/build-module/redux-store/index.js

@@ -0,0 +1,531 @@
+/**
+ * External dependencies
+ */
+import { createStore, applyMiddleware } from 'redux';
+import EquivalentKeyMap from 'equivalent-key-map';
+
+/**
+ * WordPress dependencies
+ */
+import createReduxRoutineMiddleware from '@wordpress/redux-routine';
+import { compose } from '@wordpress/compose';
+
+/**
+ * Internal dependencies
+ */
+import { combineReducers } from './combine-reducers';
+import { builtinControls } from '../controls';
+import { lock } from '../lock-unlock';
+import promise from '../promise-middleware';
+import createResolversCacheMiddleware from '../resolvers-cache-middleware';
+import createThunkMiddleware from './thunk-middleware';
+import metadataReducer from './metadata/reducer';
+import * as metadataSelectors from './metadata/selectors';
+import * as metadataActions from './metadata/actions';
+export { combineReducers };
+
+/** @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.
+ *
+ * @param {Object}   obj      The object to transform.
+ * @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)]));
+
+// Convert  non serializable types to plain objects
+const devToolsReplacer = (key, state) => {
+  if (state instanceof Map) {
+    return Object.fromEntries(state);
+  }
+  if (state instanceof window.HTMLElement) {
+    return null;
+  }
+  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();
+      }
+      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.
+ *
+ * @example
+ * ```js
+ * import { createReduxStore } from '@wordpress/data';
+ *
+ * const store = createReduxStore( 'demo', {
+ *     reducer: ( state = 'OK' ) => state,
+ *     selectors: {
+ *         getValue: ( state ) => state,
+ *     },
+ * } );
+ * ```
+ *
+ * @template State
+ * @template {Record<string,import('../types').ActionCreator>} Actions
+ * @template Selectors
+ * @param {string}                                    key     Unique namespace identifier.
+ * @param {ReduxStoreConfig<State,Actions,Selectors>} options Registered store options, with properties
+ *                                                            describing reducer, actions, selectors,
+ *                                                            and resolvers.
+ *
+ * @return   {StoreDescriptor<ReduxStoreConfig<State,Actions,Selectors>>} Store Object.
+ */
+export default function createReduxStore(key, options) {
+  const privateActions = {};
+  const privateSelectors = {};
+  const privateRegistrationFunctions = {
+    privateActions,
+    registerPrivateActions: actions => {
+      Object.assign(privateActions, actions);
+    },
+    privateSelectors,
+    registerPrivateSelectors: selectors => {
+      Object.assign(privateSelectors, selectors);
+    }
+  };
+  const storeDescriptor = {
+    name: key,
+    instantiate: registry => {
+      /**
+       * Stores listener functions registered with `subscribe()`.
+       *
+       * When functions register to listen to store changes with
+       * `subscribe()` they get added here. Although Redux offers
+       * its own `subscribe()` function directly, by wrapping the
+       * subscription in this store instance it's possible to
+       * optimize checking if the state has changed before calling
+       * each listener.
+       *
+       * @type {Set<ListenerFunction>}
+       */
+      const listeners = new Set();
+      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
+      // so they can be copied to a sub registry in registry.js.
+      lock(store, privateRegistrationFunctions);
+      const resolversCache = createResolversCache();
+      function bindAction(action) {
+        return (...args) => Promise.resolve(store.dispatch(action(...args)));
+      }
+      const actions = {
+        ...mapValues(metadataActions, bindAction),
+        ...mapValues(options.actions, bindAction)
+      };
+      const boundPrivateActions = createBindingCache(bindAction);
+      const allActions = new Proxy(() => {}, {
+        get: (target, prop) => {
+          const privateAction = privateActions[prop];
+          return privateAction ? boundPrivateActions.get(privateAction, prop) : actions[prop];
+        }
+      });
+      const thunkActions = new Proxy(allActions, {
+        apply: (target, thisArg, [action]) => store.dispatch(action)
+      });
+      lock(actions, allActions);
+      const resolvers = options.resolvers ? mapResolvers(options.resolvers) : {};
+      function bindSelector(selector, selectorName) {
+        if (selector.isRegistrySelector) {
+          selector.registry = registry;
+        }
+        const boundSelector = (...args) => {
+          args = normalize(selector, args);
+          const state = store.__unstableOriginalGetState();
+          // Before calling the selector, switch to the correct
+          // registry.
+          if (selector.isRegistrySelector) {
+            selector.registry = registry;
+          }
+          return selector(state.root, ...args);
+        };
+
+        // Expose normalization method on the bound selector
+        // in order that it can be called when fullfilling
+        // the resolver.
+        boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
+        const resolver = resolvers[selectorName];
+        if (!resolver) {
+          boundSelector.hasResolver = false;
+          return boundSelector;
+        }
+        return mapSelectorWithResolver(boundSelector, selectorName, resolver, store, resolversCache);
+      }
+      function bindMetadataSelector(metaDataSelector) {
+        const boundSelector = (...args) => {
+          const state = store.__unstableOriginalGetState();
+          const originalSelectorName = args && args[0];
+          const originalSelectorArgs = args && args[1];
+          const targetSelector = options?.selectors?.[originalSelectorName];
+
+          // Normalize the arguments passed to the target selector.
+          if (originalSelectorName && targetSelector) {
+            args[1] = normalize(targetSelector, originalSelectorArgs);
+          }
+          return metaDataSelector(state.metadata, ...args);
+        };
+        boundSelector.hasResolver = false;
+        return boundSelector;
+      }
+      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.
+      for (const [selectorName, selector] of Object.entries(privateSelectors)) {
+        boundPrivateSelectors.get(selector, selectorName);
+      }
+      const allSelectors = new Proxy(() => {}, {
+        get: (target, prop) => {
+          const privateSelector = privateSelectors[prop];
+          return privateSelector ? boundPrivateSelectors.get(privateSelector, prop) : selectors[prop];
+        }
+      });
+      const thunkSelectors = new Proxy(allSelectors, {
+        apply: (target, thisArg, [selector]) => selector(store.__unstableOriginalGetState())
+      });
+      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;
+
+      // 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;
+
+      // 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.
+      return {
+        reducer,
+        store,
+        actions,
+        selectors,
+        resolvers,
+        getSelectors,
+        getResolveSelectors,
+        getSuspendSelectors,
+        getActions,
+        subscribe
+      };
+    }
+  };
+
+  // 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 .
+  lock(storeDescriptor, privateRegistrationFunctions);
+  return storeDescriptor;
+}
+
+/**
+ * Creates a redux store for a namespace.
+ *
+ * @param {string}       key       Unique namespace identifier.
+ * @param {Object}       options   Registered store options, with properties
+ *                                 describing reducer, actions, selectors,
+ *                                 and resolvers.
+ * @param {DataRegistry} registry  Registry reference.
+ * @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,
+    ...builtinControls
+  };
+  const normalizedControls = mapValues(controls, control => control.isRegistryControl ? control(registry) : control);
+  const middlewares = [createResolversCacheMiddleware(registry, key), promise, createReduxRoutineMiddleware(normalizedControls), createThunkMiddleware(thunkArgs)];
+  const enhancers = [applyMiddleware(...middlewares)];
+  if (typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__) {
+    enhancers.push(window.__REDUX_DEVTOOLS_EXTENSION__({
+      name: key,
+      instanceId: key,
+      serialize: {
+        replacer: devToolsReplacer
+      }
+    }));
+  }
+  const {
+    reducer,
+    initialState
+  } = options;
+  const enhancedReducer = combineReducers({
+    metadata: metadataReducer,
+    root: reducer
+  });
+  return createStore(enhancedReducer, {
+    root: initialState
+  }, compose(enhancers));
+}
+
+/**
+ * Maps selectors to functions that return a resolution promise for them
+ *
+ * @param {Object} selectors Selectors to map.
+ * @param {Object} store     The redux store the selectors select from.
+ *
+ * @return {Object} Selectors mapped to their resolution functions.
+ */
+function mapResolveSelectors(selectors, store) {
+  const {
+    getIsResolving,
+    hasStartedResolution,
+    hasFinishedResolution,
+    hasResolutionFailed,
+    isResolving,
+    getCachedResolvers,
+    getResolutionState,
+    getResolutionError,
+    hasResolvingSelectors,
+    countSelectorsByStatus,
+    ...storeSelectors
+  } = selectors;
+  return mapValues(storeSelectors, (selector, selectorName) => {
+    // If the selector doesn't have a resolver, just convert the return value
+    // (including exceptions) to a Promise, no additional extra behavior is needed.
+    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);
+          } else {
+            resolve(result);
+          }
+        };
+        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();
+            finalize(getResult());
+          }
+        });
+      });
+    };
+  });
+}
+
+/**
+ * Maps selectors to functions that throw a suspense promise if not yet resolved.
+ *
+ * @param {Object} selectors Selectors to map.
+ * @param {Object} store     The redux store the selectors select from.
+ *
+ * @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)) {
+            resolve();
+            unsubscribe();
+          }
+        });
+      });
+    };
+  });
+}
+
+/**
+ * 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,
+      // 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,
+ * used in ensuring that the data needs for the selector are satisfied.
+ *
+ * @param {Object} selector       The selector function to be bound.
+ * @param {string} selectorName   The selector name.
+ * @param {Object} resolver       Resolver to call.
+ * @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) => {
+    args = normalize(selector, args);
+    fulfillSelector(args);
+    return selector(...args);
+  };
+  selectorResolver.hasResolver = true;
+  return selectorResolver;
+}
+
+/**
+ * Applies selector's normalization function to the given arguments
+ * if it exists.
+ *
+ * @param {Object} selector The selector potentially with a normalization method property.
+ * @param {Array}  args     selector arguments to normalize.
+ * @return {Array} Potentially normalized arguments.
+ */
+function normalize(selector, args) {
+  if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === 'function' && args?.length) {
+    return selector.__unstableNormalizeArgs(args);
+  }
+  return args;
+}
+//# sourceMappingURL=index.js.map

node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js

@@ -0,0 +1,153 @@
+/**
+ * Returns an action object used in signalling that selector resolution has
+ * started.
+ *
+ * @param {string}    selectorName Name of selector for which resolver triggered.
+ * @param {unknown[]} args         Arguments to associate for uniqueness.
+ *
+ * @return {{ type: 'START_RESOLUTION', selectorName: string, args: unknown[] }} Action object.
+ */
+export function startResolution(selectorName, args) {
+  return {
+    type: 'START_RESOLUTION',
+    selectorName,
+    args
+  };
+}
+
+/**
+ * Returns an action object used in signalling that selector resolution has
+ * completed.
+ *
+ * @param {string}    selectorName Name of selector for which resolver triggered.
+ * @param {unknown[]} args         Arguments to associate for uniqueness.
+ *
+ * @return {{ type: 'FINISH_RESOLUTION', selectorName: string, args: unknown[] }} Action object.
+ */
+export function finishResolution(selectorName, args) {
+  return {
+    type: 'FINISH_RESOLUTION',
+    selectorName,
+    args
+  };
+}
+
+/**
+ * Returns an action object used in signalling that selector resolution has
+ * failed.
+ *
+ * @param {string}        selectorName Name of selector for which resolver triggered.
+ * @param {unknown[]}     args         Arguments to associate for uniqueness.
+ * @param {Error|unknown} error        The error that caused the failure.
+ *
+ * @return {{ type: 'FAIL_RESOLUTION', selectorName: string, args: unknown[], error: Error|unknown }} Action object.
+ */
+export function failResolution(selectorName, args, error) {
+  return {
+    type: 'FAIL_RESOLUTION',
+    selectorName,
+    args,
+    error
+  };
+}
+
+/**
+ * Returns an action object used in signalling that a batch of selector resolutions has
+ * started.
+ *
+ * @param {string}      selectorName Name of selector for which resolver triggered.
+ * @param {unknown[][]} args         Array of arguments to associate for uniqueness, each item
+ *                                   is associated to a resolution.
+ *
+ * @return {{ type: 'START_RESOLUTIONS', selectorName: string, args: unknown[][] }} Action object.
+ */
+export function startResolutions(selectorName, args) {
+  return {
+    type: 'START_RESOLUTIONS',
+    selectorName,
+    args
+  };
+}
+
+/**
+ * Returns an action object used in signalling that a batch of selector resolutions has
+ * completed.
+ *
+ * @param {string}      selectorName Name of selector for which resolver triggered.
+ * @param {unknown[][]} args         Array of arguments to associate for uniqueness, each item
+ *                                   is associated to a resolution.
+ *
+ * @return {{ type: 'FINISH_RESOLUTIONS', selectorName: string, args: unknown[][] }} Action object.
+ */
+export function finishResolutions(selectorName, args) {
+  return {
+    type: 'FINISH_RESOLUTIONS',
+    selectorName,
+    args
+  };
+}
+
+/**
+ * Returns an action object used in signalling that a batch of selector resolutions has
+ * completed and at least one of them has failed.
+ *
+ * @param {string}            selectorName Name of selector for which resolver triggered.
+ * @param {unknown[]}         args         Array of arguments to associate for uniqueness, each item
+ *                                         is associated to a resolution.
+ * @param {(Error|unknown)[]} errors       Array of errors to associate for uniqueness, each item
+ *                                         is associated to a resolution.
+ * @return {{ type: 'FAIL_RESOLUTIONS', selectorName: string, args: unknown[], errors: Array<Error|unknown> }} Action object.
+ */
+export function failResolutions(selectorName, args, errors) {
+  return {
+    type: 'FAIL_RESOLUTIONS',
+    selectorName,
+    args,
+    errors
+  };
+}
+
+/**
+ * Returns an action object used in signalling that we should invalidate the resolution cache.
+ *
+ * @param {string}    selectorName Name of selector for which resolver should be invalidated.
+ * @param {unknown[]} args         Arguments to associate for uniqueness.
+ *
+ * @return {{ type: 'INVALIDATE_RESOLUTION', selectorName: string, args: any[] }} Action object.
+ */
+export function invalidateResolution(selectorName, args) {
+  return {
+    type: 'INVALIDATE_RESOLUTION',
+    selectorName,
+    args
+  };
+}
+
+/**
+ * Returns an action object used in signalling that the resolution
+ * should be invalidated.
+ *
+ * @return {{ type: 'INVALIDATE_RESOLUTION_FOR_STORE' }} Action object.
+ */
+export function invalidateResolutionForStore() {
+  return {
+    type: 'INVALIDATE_RESOLUTION_FOR_STORE'
+  };
+}
+
+/**
+ * Returns an action object used in signalling that the resolution cache for a
+ * given selectorName should be invalidated.
+ *
+ * @param {string} selectorName Name of selector for which all resolvers should
+ *                              be invalidated.
+ *
+ * @return  {{ type: 'INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR', selectorName: string }} Action object.
+ */
+export function invalidateResolutionForStoreSelector(selectorName) {
+  return {
+    type: 'INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR',
+    selectorName
+  };
+}
+//# sourceMappingURL=actions.js.map

node_modules/@wordpress/data/build-module/redux-store/metadata/equivalent-key-map.d.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=equivalent-key-map.d.js.map

node_modules/@wordpress/data/build-module/redux-store/metadata/equivalent-key-map.d.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["@wordpress/data/src/redux-store/metadata/equivalent-key-map.d.ts"],"sourcesContent":["declare module 'equivalent-key-map' {\n\tclass EquivalentKeyMap< K, V > extends Map< K, V > {}\n\texport = EquivalentKeyMap;\n}\n"],"mappings":"","ignoreList":[]}

node_modules/@wordpress/data/build-module/redux-store/metadata/reducer.js

@@ -0,0 +1,125 @@
+/**
+ * External dependencies
+ */
+import EquivalentKeyMap from 'equivalent-key-map';
+/**
+ * Internal dependencies
+ */
+import { selectorArgsToStateKey, onSubKey } from './utils';
+/**
+ * Reducer function returning next state for selector resolution of
+ * subkeys, object form:
+ *
+ *  selectorName -> EquivalentKeyMap<Array,boolean>
+ */
+const subKeysIsResolved = onSubKey('selectorName')((state = new EquivalentKeyMap(), action) => {
+  switch (action.type) {
+    case 'START_RESOLUTION':
+      {
+        const nextState = new EquivalentKeyMap(state);
+        nextState.set(selectorArgsToStateKey(action.args), {
+          status: 'resolving'
+        });
+        return nextState;
+      }
+    case 'FINISH_RESOLUTION':
+      {
+        const nextState = new EquivalentKeyMap(state);
+        nextState.set(selectorArgsToStateKey(action.args), {
+          status: 'finished'
+        });
+        return nextState;
+      }
+    case 'FAIL_RESOLUTION':
+      {
+        const nextState = new EquivalentKeyMap(state);
+        nextState.set(selectorArgsToStateKey(action.args), {
+          status: 'error',
+          error: action.error
+        });
+        return nextState;
+      }
+    case 'START_RESOLUTIONS':
+      {
+        const nextState = new EquivalentKeyMap(state);
+        for (const resolutionArgs of action.args) {
+          nextState.set(selectorArgsToStateKey(resolutionArgs), {
+            status: 'resolving'
+          });
+        }
+        return nextState;
+      }
+    case 'FINISH_RESOLUTIONS':
+      {
+        const nextState = new EquivalentKeyMap(state);
+        for (const resolutionArgs of action.args) {
+          nextState.set(selectorArgsToStateKey(resolutionArgs), {
+            status: 'finished'
+          });
+        }
+        return nextState;
+      }
+    case 'FAIL_RESOLUTIONS':
+      {
+        const nextState = new EquivalentKeyMap(state);
+        action.args.forEach((resolutionArgs, idx) => {
+          const resolutionState = {
+            status: 'error',
+            error: undefined
+          };
+          const error = action.errors[idx];
+          if (error) {
+            resolutionState.error = error;
+          }
+          nextState.set(selectorArgsToStateKey(resolutionArgs), resolutionState);
+        });
+        return nextState;
+      }
+    case 'INVALIDATE_RESOLUTION':
+      {
+        const nextState = new EquivalentKeyMap(state);
+        nextState.delete(selectorArgsToStateKey(action.args));
+        return nextState;
+      }
+  }
+  return state;
+});
+
+/**
+ * Reducer function returning next state for selector resolution, object form:
+ *
+ *   selectorName -> EquivalentKeyMap<Array, boolean>
+ *
+ * @param state  Current state.
+ * @param action Dispatched action.
+ *
+ * @return Next state.
+ */
+const isResolved = (state = {}, action) => {
+  switch (action.type) {
+    case 'INVALIDATE_RESOLUTION_FOR_STORE':
+      return {};
+    case 'INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR':
+      {
+        if (action.selectorName in state) {
+          const {
+            [action.selectorName]: removedSelector,
+            ...restState
+          } = state;
+          return restState;
+        }
+        return state;
+      }
+    case 'START_RESOLUTION':
+    case 'FINISH_RESOLUTION':
+    case 'FAIL_RESOLUTION':
+    case 'START_RESOLUTIONS':
+    case 'FINISH_RESOLUTIONS':
+    case 'FAIL_RESOLUTIONS':
+    case 'INVALIDATE_RESOLUTION':
+      return subKeysIsResolved(state, action);
+  }
+  return state;
+};
+export default isResolved;
+//# sourceMappingURL=reducer.js.map

node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js

@@ -0,0 +1,194 @@
+/**
+ * WordPress dependencies
+ */
+import deprecated from '@wordpress/deprecated';
+
+/**
+ * Internal dependencies
+ */
+import { createSelector } from '../../create-selector';
+import { selectorArgsToStateKey } from './utils';
+
+/** @typedef {Record<string, import('./reducer').State>} State */
+/** @typedef {import('./reducer').StateValue} StateValue */
+/** @typedef {import('./reducer').Status} Status */
+
+/**
+ * Returns the raw resolution state value for a given selector name,
+ * and arguments set. May be undefined if the selector has never been resolved
+ * or not resolved for the given set of arguments, otherwise true or false for
+ * resolution started and completed respectively.
+ *
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
+ *
+ * @return {StateValue|undefined} isResolving value.
+ */
+export function getResolutionState(state, selectorName, args) {
+  const map = state[selectorName];
+  if (!map) {
+    return;
+  }
+  return map.get(selectorArgsToStateKey(args));
+}
+
+/**
+ * Returns an `isResolving`-like value for a given selector name and arguments set.
+ * Its value is either `undefined` if the selector has never been resolved or has been
+ * invalidated, or a `true`/`false` boolean value if the resolution is in progress or
+ * has finished, respectively.
+ *
+ * This is a legacy selector that was implemented when the "raw" internal data had
+ * this `undefined | boolean` format. Nowadays the internal value is an object that
+ * can be retrieved with `getResolutionState`.
+ *
+ * @deprecated
+ *
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
+ *
+ * @return {boolean | undefined} isResolving value.
+ */
+export function getIsResolving(state, selectorName, args) {
+  deprecated('wp.data.select( store ).getIsResolving', {
+    since: '6.6',
+    version: '6.8',
+    alternative: 'wp.data.select( store ).getResolutionState'
+  });
+  const resolutionState = getResolutionState(state, selectorName, args);
+  return resolutionState && resolutionState.status === 'resolving';
+}
+
+/**
+ * Returns true if resolution has already been triggered for a given
+ * selector name, and arguments set.
+ *
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
+ *
+ * @return {boolean} Whether resolution has been triggered.
+ */
+export function hasStartedResolution(state, selectorName, args) {
+  return getResolutionState(state, selectorName, args) !== undefined;
+}
+
+/**
+ * Returns true if resolution has completed for a given selector
+ * name, and arguments set.
+ *
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
+ *
+ * @return {boolean} Whether resolution has completed.
+ */
+export function hasFinishedResolution(state, selectorName, args) {
+  const status = getResolutionState(state, selectorName, args)?.status;
+  return status === 'finished' || status === 'error';
+}
+
+/**
+ * Returns true if resolution has failed for a given selector
+ * name, and arguments set.
+ *
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
+ *
+ * @return {boolean} Has resolution failed
+ */
+export function hasResolutionFailed(state, selectorName, args) {
+  return getResolutionState(state, selectorName, args)?.status === 'error';
+}
+
+/**
+ * Returns the resolution error for a given selector name, and arguments set.
+ * Note it may be of an Error type, but may also be null, undefined, or anything else
+ * that can be `throw`-n.
+ *
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
+ *
+ * @return {Error|unknown} Last resolution error
+ */
+export function getResolutionError(state, selectorName, args) {
+  const resolutionState = getResolutionState(state, selectorName, args);
+  return resolutionState?.status === 'error' ? resolutionState.error : null;
+}
+
+/**
+ * Returns true if resolution has been triggered but has not yet completed for
+ * a given selector name, and arguments set.
+ *
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
+ *
+ * @return {boolean} Whether resolution is in progress.
+ */
+export function isResolving(state, selectorName, args) {
+  return getResolutionState(state, selectorName, args)?.status === 'resolving';
+}
+
+/**
+ * Returns the list of the cached resolvers.
+ *
+ * @param {State} state Data state.
+ *
+ * @return {State} Resolvers mapped by args and selectorName.
+ */
+export function getCachedResolvers(state) {
+  return state;
+}
+
+/**
+ * Whether the store has any currently resolving selectors.
+ *
+ * @param {State} state Data state.
+ *
+ * @return {boolean} True if one or more selectors are resolving, false otherwise.
+ */
+export function hasResolvingSelectors(state) {
+  return Object.values(state).some(selectorState =>
+  /**
+   * This uses the internal `_map` property of `EquivalentKeyMap` for
+   * optimization purposes, since the `EquivalentKeyMap` implementation
+   * does not support a `.values()` implementation.
+   *
+   * @see https://github.com/aduth/equivalent-key-map
+   */
+  Array.from(selectorState._map.values()).some(resolution => resolution[1]?.status === 'resolving'));
+}
+
+/**
+ * Retrieves the total number of selectors, grouped per status.
+ *
+ * @param {State} state Data state.
+ *
+ * @return {Object} Object, containing selector totals by status.
+ */
+export const countSelectorsByStatus = createSelector(state => {
+  const selectorsByStatus = {};
+  Object.values(state).forEach(selectorState =>
+  /**
+   * This uses the internal `_map` property of `EquivalentKeyMap` for
+   * optimization purposes, since the `EquivalentKeyMap` implementation
+   * does not support a `.values()` implementation.
+   *
+   * @see https://github.com/aduth/equivalent-key-map
+   */
+  Array.from(selectorState._map.values()).forEach(resolution => {
+    var _resolution$1$status;
+    const currentStatus = (_resolution$1$status = resolution[1]?.status) !== null && _resolution$1$status !== void 0 ? _resolution$1$status : 'error';
+    if (!selectorsByStatus[currentStatus]) {
+      selectorsByStatus[currentStatus] = 0;
+    }
+    selectorsByStatus[currentStatus]++;
+  }));
+  return selectorsByStatus;
+}, state => [state]);
+//# sourceMappingURL=selectors.js.map

node_modules/@wordpress/data/build-module/redux-store/metadata/utils.js

@@ -0,0 +1,50 @@
+/**
+ * External dependencies
+ */
+
+/**
+ * Higher-order reducer creator which creates a combined reducer object, keyed
+ * by a property on the action object.
+ *
+ * @param actionProperty Action property by which to key object.
+ * @return Higher-order reducer.
+ */
+export const onSubKey = actionProperty => reducer => (state = {}, action) => {
+  // Retrieve subkey from action. Do not track if undefined; useful for cases
+  // where reducer is scoped by action shape.
+  const key = action[actionProperty];
+  if (key === undefined) {
+    return state;
+  }
+
+  // Avoid updating state if unchanged. Note that this also accounts for a
+  // reducer which returns undefined on a key which is not yet tracked.
+  const nextKeyState = reducer(state[key], action);
+  if (nextKeyState === state[key]) {
+    return state;
+  }
+  return {
+    ...state,
+    [key]: nextKeyState
+  };
+};
+
+/**
+ * Normalize selector argument array by defaulting `undefined` value to an empty array
+ * and removing trailing `undefined` values.
+ *
+ * @param args Selector argument array
+ * @return Normalized state key array
+ */
+export function selectorArgsToStateKey(args) {
+  if (args === undefined || args === null) {
+    return [];
+  }
+  const len = args.length;
+  let idx = len;
+  while (idx > 0 && args[idx - 1] === undefined) {
+    idx--;
+  }
+  return idx === len ? args : args.slice(0, idx);
+}
+//# sourceMappingURL=utils.js.map

node_modules/@wordpress/data/build-module/redux-store/metadata/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["onSubKey","actionProperty","reducer","state","action","key","undefined","nextKeyState","selectorArgsToStateKey","args","len","length","idx","slice"],"sources":["@wordpress/data/src/redux-store/metadata/utils.ts"],"sourcesContent":["/**\n * External dependencies\n */\nimport type { AnyAction, Reducer } from 'redux';\n\n/**\n * Higher-order reducer creator which creates a combined reducer object, keyed\n * by a property on the action object.\n *\n * @param actionProperty Action property by which to key object.\n * @return Higher-order reducer.\n */\nexport const onSubKey =\n\t< TState extends unknown, TAction extends AnyAction >(\n\t\tactionProperty: string\n\t) =>\n\t(\n\t\treducer: Reducer< TState, TAction >\n\t): Reducer< Record< string, TState >, TAction > =>\n\t( state: Record< string, TState > = {}, action ) => {\n\t\t// Retrieve subkey from action. Do not track if undefined; useful for cases\n\t\t// where reducer is scoped by action shape.\n\t\tconst key = action[ actionProperty ];\n\t\tif ( key === undefined ) {\n\t\t\treturn state;\n\t\t}\n\n\t\t// Avoid updating state if unchanged. Note that this also accounts for a\n\t\t// reducer which returns undefined on a key which is not yet tracked.\n\t\tconst nextKeyState = reducer( state[ key ], action );\n\t\tif ( nextKeyState === state[ key ] ) {\n\t\t\treturn state;\n\t\t}\n\n\t\treturn {\n\t\t\t...state,\n\t\t\t[ key ]: nextKeyState,\n\t\t};\n\t};\n\n/**\n * Normalize selector argument array by defaulting `undefined` value to an empty array\n * and removing trailing `undefined` values.\n *\n * @param args Selector argument array\n * @return Normalized state key array\n */\nexport function selectorArgsToStateKey( args: unknown[] | null | undefined ) {\n\tif ( args === undefined || args === null ) {\n\t\treturn [];\n\t}\n\n\tconst len = args.length;\n\tlet idx = len;\n\twhile ( idx > 0 && args[ idx - 1 ] === undefined ) {\n\t\tidx--;\n\t}\n\treturn idx === len ? args : args.slice( 0, idx );\n}\n"],"mappings":"AAAA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,QAAQ,GAEnBC,cAAsB,IAGtBC,OAAmC,IAEpC,CAAEC,KAA+B,GAAG,CAAC,CAAC,EAAEC,MAAM,KAAM;EACnD;EACA;EACA,MAAMC,GAAG,GAAGD,MAAM,CAAEH,cAAc,CAAE;EACpC,IAAKI,GAAG,KAAKC,SAAS,EAAG;IACxB,OAAOH,KAAK;EACb;;EAEA;EACA;EACA,MAAMI,YAAY,GAAGL,OAAO,CAAEC,KAAK,CAAEE,GAAG,CAAE,EAAED,MAAO,CAAC;EACpD,IAAKG,YAAY,KAAKJ,KAAK,CAAEE,GAAG,CAAE,EAAG;IACpC,OAAOF,KAAK;EACb;EAEA,OAAO;IACN,GAAGA,KAAK;IACR,CAAEE,GAAG,GAAIE;EACV,CAAC;AACF,CAAC;;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,sBAAsBA,CAAEC,IAAkC,EAAG;EAC5E,IAAKA,IAAI,KAAKH,SAAS,IAAIG,IAAI,KAAK,IAAI,EAAG;IAC1C,OAAO,EAAE;EACV;EAEA,MAAMC,GAAG,GAAGD,IAAI,CAACE,MAAM;EACvB,IAAIC,GAAG,GAAGF,GAAG;EACb,OAAQE,GAAG,GAAG,CAAC,IAAIH,IAAI,CAAEG,GAAG,GAAG,CAAC,CAAE,KAAKN,SAAS,EAAG;IAClDM,GAAG,EAAE;EACN;EACA,OAAOA,GAAG,KAAKF,GAAG,GAAGD,IAAI,GAAGA,IAAI,CAACI,KAAK,CAAE,CAAC,EAAED,GAAI,CAAC;AACjD","ignoreList":[]}

node_modules/@wordpress/data/build-module/redux-store/thunk-middleware.js

@@ -0,0 +1,9 @@
+export default function createThunkMiddleware(args) {
+  return () => next => action => {
+    if (typeof action === 'function') {
+      return action(args);
+    }
+    return next(action);
+  };
+}
+//# sourceMappingURL=thunk-middleware.js.map

node_modules/@wordpress/data/build-module/redux-store/thunk-middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createThunkMiddleware","args","next","action"],"sources":["@wordpress/data/src/redux-store/thunk-middleware.js"],"sourcesContent":["export default function createThunkMiddleware( args ) {\n\treturn () => ( next ) => ( action ) => {\n\t\tif ( typeof action === 'function' ) {\n\t\t\treturn action( args );\n\t\t}\n\n\t\treturn next( action );\n\t};\n}\n"],"mappings":"AAAA,eAAe,SAASA,qBAAqBA,CAAEC,IAAI,EAAG;EACrD,OAAO,MAAQC,IAAI,IAAQC,MAAM,IAAM;IACtC,IAAK,OAAOA,MAAM,KAAK,UAAU,EAAG;MACnC,OAAOA,MAAM,CAAEF,IAAK,CAAC;IACtB;IAEA,OAAOC,IAAI,CAAEC,MAAO,CAAC;EACtB,CAAC;AACF","ignoreList":[]}