@wordpress/data 6.12.0 → 6.15.0

package/build-types/default-registry.d.ts

@@ -0,0 +1,3 @@
+declare var _default: import("./registry").WPDataRegistry;
+export default _default;
+//# sourceMappingURL=default-registry.d.ts.map

package/build-types/default-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-registry.d.ts","sourceRoot":"","sources":["../src/default-registry.js"],"names":[],"mappings":""}

package/build-types/factory.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Creates a selector function that takes additional curried argument with the
+ * registry `select` function. While a regular selector has signature
+ * ```js
+ * ( state, ...selectorArgs ) => ( result )
+ * ```
+ * that allows to select data from the store's `state`, a registry selector
+ * has signature:
+ * ```js
+ * ( select ) => ( state, ...selectorArgs ) => ( result )
+ * ```
+ * that supports also selecting from other registered stores.
+ *
+ * @example
+ * ```js
+ * import { store as coreStore } from '@wordpress/core-data';
+ * import { store as editorStore } from '@wordpress/editor';
+ *
+ * const getCurrentPostId = createRegistrySelector( ( select ) => ( state ) => {
+ *   return select( editorStore ).getCurrentPostId();
+ * } );
+ *
+ * const getPostEdits = createRegistrySelector( ( select ) => ( state ) => {
+ *   // calling another registry selector just like any other function
+ *   const postType = getCurrentPostType( state );
+ *   const postId = getCurrentPostId( state );
+ *	 return select( coreStore ).getEntityRecordEdits( 'postType', postType, postId );
+ * } );
+ * ```
+ *
+ * Note how the `getCurrentPostId` selector can be called just like any other function,
+ * (it works even inside a regular non-registry selector) and we don't need to pass the
+ * registry as argument. The registry binding happens automatically when registering the selector
+ * with a store.
+ *
+ * @param {Function} registrySelector Function receiving a registry `select`
+ *                                    function and returning a state selector.
+ *
+ * @return {Function} Registry selector that can be registered with a store.
+ */
+export function createRegistrySelector(registrySelector: Function): Function;
+/**
+ * Creates a control function that takes additional curried argument with the `registry` object.
+ * While a regular control has signature
+ * ```js
+ * ( action ) => ( iteratorOrPromise )
+ * ```
+ * where the control works with the `action` that it's bound to, a registry control has signature:
+ * ```js
+ * ( registry ) => ( action ) => ( iteratorOrPromise )
+ * ```
+ * A registry control is typically used to select data or dispatch an action to a registered
+ * store.
+ *
+ * When registering a control created with `createRegistryControl` with a store, the store
+ * knows which calling convention to use when executing the control.
+ *
+ * @param {Function} registryControl Function receiving a registry object and returning a control.
+ *
+ * @return {Function} Registry control that can be registered with a store.
+ */
+export function createRegistryControl(registryControl: Function): Function;
+//# sourceMappingURL=factory.d.ts.map

package/build-types/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,6EAiBC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2EAIC"}

package/build-types/index.d.ts

@@ -0,0 +1,156 @@
+export { default as withSelect } from "./components/with-select";
+export { default as withDispatch } from "./components/with-dispatch";
+export { default as withRegistry } from "./components/with-registry";
+export { useDispatch } from "./components/use-dispatch";
+export { AsyncModeProvider } from "./components/async-mode-provider";
+export { createRegistry } from "./registry";
+export { controls } from "./controls";
+export { default as createReduxStore } from "./redux-store";
+/**
+ * Given a store descriptor, returns an object of the store's selectors.
+ * The selector functions are been pre-bound to pass the current state automatically.
+ * As a consumer, you need only pass arguments of the selector, if applicable.
+ *
+ * @param {StoreDescriptor|string} storeNameOrDescriptor The store descriptor. The legacy calling
+ *                                                       convention of passing the store name is
+ *                                                       also supported.
+ *
+ * @example
+ * ```js
+ * import { select } from '@wordpress/data';
+ * import { store as myCustomStore } from 'my-custom-store';
+ *
+ * select( myCustomStore ).getPrice( 'hammer' );
+ * ```
+ *
+ * @return {Object} Object containing the store's selectors.
+ */
+export const select: Function;
+/**
+ * Given a store descriptor, returns an object containing the store's selectors pre-bound to state
+ * so that you only need to supply additional arguments, and modified so that they return promises
+ * that resolve to their eventual values, after any resolvers have ran.
+ *
+ * @param {StoreDescriptor|string} storeNameOrDescriptor The store descriptor. The legacy calling
+ *                                                       convention of passing the store name is
+ *                                                       also supported.
+ *
+ * @example
+ * ```js
+ * import { resolveSelect } from '@wordpress/data';
+ * import { store as myCustomStore } from 'my-custom-store';
+ *
+ * resolveSelect( myCustomStore ).getPrice( 'hammer' ).then(console.log)
+ * ```
+ *
+ * @return {Object} Object containing the store's promise-wrapped selectors.
+ */
+export const resolveSelect: any;
+/**
+ * Given a store descriptor, returns an object containing the store's selectors pre-bound to state
+ * so that you only need to supply additional arguments, and modified so that they throw promises
+ * in case the selector is not resolved yet.
+ *
+ * @param {StoreDescriptor|string} storeNameOrDescriptor The store descriptor. The legacy calling
+ *                                                       convention of passing the store name is
+ *                                                       also supported.
+ *
+ * @return {Object} Object containing the store's suspense-wrapped selectors.
+ */
+export const suspendSelect: any;
+/**
+ * Given a store descriptor, returns an object of the store's action creators.
+ * Calling an action creator will cause it to be dispatched, updating the state value accordingly.
+ *
+ * Note: Action creators returned by the dispatch will return a promise when
+ * they are called.
+ *
+ * @param {StoreDescriptor|string} storeNameOrDescriptor The store descriptor. The legacy calling
+ *                                                       convention of passing the store name is
+ *                                                       also supported.
+ *
+ * @example
+ * ```js
+ * import { dispatch } from '@wordpress/data';
+ * import { store as myCustomStore } from 'my-custom-store';
+ *
+ * dispatch( myCustomStore ).setPrice( 'hammer', 9.75 );
+ * ```
+ * @return {Object} Object containing the action creators.
+ */
+export const dispatch: Function;
+/**
+ * Given a listener function, the function will be called any time the state value
+ * of one of the registered stores has changed. This function returns a `unsubscribe`
+ * function used to stop the subscription.
+ *
+ * @param {Function} listener Callback function.
+ *
+ * @example
+ * ```js
+ * import { subscribe } from '@wordpress/data';
+ *
+ * const unsubscribe = subscribe( () => {
+ * 	// You could use this opportunity to test whether the derived result of a
+ * 	// selector has subsequently changed as the result of a state update.
+ * } );
+ *
+ * // Later, if necessary...
+ * unsubscribe();
+ * ```
+ */
+export const subscribe: Function;
+/**
+ * Registers a generic store instance.
+ *
+ * @deprecated Use `register( storeDescriptor )` instead.
+ *
+ * @param {string} name  Store registry name.
+ * @param {Object} store Store instance (`{ getSelectors, getActions, subscribe }`).
+ */
+export const registerGenericStore: Function;
+/**
+ * Registers a standard `@wordpress/data` store.
+ *
+ * @deprecated Use `register` instead.
+ *
+ * @param {string} storeName Unique namespace identifier for the store.
+ * @param {Object} options   Store description (reducer, actions, selectors, resolvers).
+ *
+ * @return {Object} Registered store object.
+ */
+export const registerStore: Function;
+/**
+ * Extends a registry to inherit functionality provided by a given plugin. A
+ * plugin is an object with properties aligning to that of a registry, merged
+ * to extend the default registry behavior.
+ *
+ * @param {Object} plugin Plugin object.
+ */
+export const use: any;
+/**
+ * Registers a standard `@wordpress/data` store descriptor.
+ *
+ * @example
+ * ```js
+ * import { createReduxStore, register } from '@wordpress/data';
+ *
+ * const store = createReduxStore( 'demo', {
+ *     reducer: ( state = 'OK' ) => state,
+ *     selectors: {
+ *         getValue: ( state ) => state,
+ *     },
+ * } );
+ * register( store );
+ * ```
+ *
+ * @param {StoreDescriptor} store Store descriptor.
+ */
+export const register: any;
+export type StoreDescriptor = import("./types").StoreDescriptor<any>;
+import * as plugins from "./plugins";
+export { plugins, combineReducers };
+export { RegistryProvider, RegistryConsumer, useRegistry } from "./components/registry-provider";
+export { default as useSelect, useSuspenseSelect } from "./components/use-select";
+export { createRegistrySelector, createRegistryControl } from "./factory";
+//# sourceMappingURL=index.d.ts.map

package/build-types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";;;;;;;;AAiFA;;;;;;;;;;;;;;;;;;GAkBG;AACH,8BAA6C;AAE7C;;;;;;;;;;;;;;;;;;GAkBG;AACH,gCAA2D;AAE3D;;;;;;;;;;GAUG;AACH,gCAA2D;AAE3D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gCAAiD;AAEjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,iCAAmD;AAEnD;;;;;;;GAOG;AACH,4CAAyE;AAEzE;;;;;;;;;GASG;AACH,qCAA2D;AAE3D;;;;;;GAMG;AACH,sBAAuC;AAEvC;;;;;;;;;;;;;;;;;GAiBG;AACH,2BAAiD"}

package/build-types/plugins/index.d.ts

@@ -0,0 +1,2 @@
+export { default as persistence } from "./persistence";
+//# sourceMappingURL=index.d.ts.map

package/build-types/plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugins/index.js"],"names":[],"mappings":""}

package/build-types/plugins/persistence/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Creates a persistence interface, exposing getter and setter methods (`get`
+ * and `set` respectively).
+ *
+ * @param {WPDataPersistencePluginOptions} options Plugin options.
+ *
+ * @return {Object} Persistence interface.
+ */
+export function createPersistenceInterface(options: WPDataPersistencePluginOptions): Object;
+export function withLazySameState(reducer: Function): Function;
+export default persistencePlugin;
+export type WPDataRegistry = import('../../registry').WPDataRegistry;
+export type WPDataPlugin = import('../../registry').WPDataPlugin;
+/**
+ * Persistence plugin options.
+ */
+export type WPDataPersistencePluginOptions = {
+    /**
+     * Persistent storage implementation. This must
+     * at least implement `getItem` and `setItem` of
+     * the Web Storage API.
+     */
+    storage: Storage;
+    /**
+     * Key on which to set in persistent storage.
+     */
+    storageKey: string;
+};
+/**
+ * Data plugin to persist store state into a single storage key.
+ *
+ * @param {WPDataRegistry}                  registry      Data registry.
+ * @param {?WPDataPersistencePluginOptions} pluginOptions Plugin options.
+ *
+ * @return {WPDataPlugin} Data plugin.
+ */
+declare function persistencePlugin(registry: WPDataRegistry, pluginOptions: WPDataPersistencePluginOptions | null): WPDataPlugin;
+declare namespace persistencePlugin {
+    function __unstableMigrate(): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/build-types/plugins/persistence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/persistence/index.js"],"names":[],"mappings":"AAyDA;;;;;;;GAOG;AACH,oDAJW,8BAA8B,GAE7B,MAAM,CAiDjB;AA/DM,+DAMN;;6BA3Ca,OAAO,gBAAgB,EAAE,cAAc;2BAEvC,OAAO,gBAAgB,EAAE,YAAY;;;;;;;;;;aAKrC,OAAO;;;;gBAGP,MAAM;;AA4FpB;;;;;;;GAOG;AACH,6CALW,cAAc,iBACb,8BAA8B,UAE9B,YAAY,CAqGvB;;IAED,mCAA8C"}

package/build-types/plugins/persistence/storage/default.d.ts

@@ -0,0 +1,3 @@
+export default storage;
+declare let storage: any;
+//# sourceMappingURL=default.d.ts.map

package/build-types/plugins/persistence/storage/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../src/plugins/persistence/storage/default.js"],"names":[],"mappings":";AAKA,yBAAY"}

package/build-types/plugins/persistence/storage/object.d.ts

@@ -0,0 +1,10 @@
+export default storage;
+declare namespace storage {
+    function getItem(key: any): any;
+    function getItem(key: any): any;
+    function setItem(key: any, value: any): void;
+    function setItem(key: any, value: any): void;
+    function clear(): void;
+    function clear(): void;
+}
+//# sourceMappingURL=object.d.ts.map

package/build-types/plugins/persistence/storage/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../../src/plugins/persistence/storage/object.js"],"names":[],"mappings":";;IAGC,gCAMC;IAND,gCAMC;IACD,6CAMC;IAND,6CAMC;IACD,uBAEC;IAFD,uBAEC"}

package/build-types/redux-store/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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,Actions,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<State, Actions, Selectors>(key: string, options: import("../types").ReduxStoreConfig<State, Actions, Selectors>): import("../types").StoreDescriptor<import("../types").ReduxStoreConfig<State, Actions, Selectors>>;
+export type DataRegistry = import('../types').DataRegistry;
+export type StoreDescriptor<C> = import('../types').StoreDescriptor<C>;
+export type ReduxStoreConfig<State, Actions, Selectors> = import('../types').ReduxStoreConfig<State, Actions, Selectors>;
+//# sourceMappingURL=index.d.ts.map

package/build-types/redux-store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/redux-store/index.js"],"names":[],"mappings":"AA2EA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,yEAPW,MAAM,+KA8HhB;2BAlMa,OAAO,UAAU,EAAE,YAAY;iCAEhC,OAAO,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC;0DAIrC,OAAO,UAAU,EAAE,gBAAgB,CAAC,KAAK,EAAC,OAAO,EAAC,SAAS,CAAC"}

package/build-types/redux-store/thunk-middleware.d.ts

@@ -0,0 +1,2 @@
+export default function createThunkMiddleware(args: any): () => (next: any) => (action: any) => any;
+//# sourceMappingURL=thunk-middleware.d.ts.map

package/build-types/redux-store/thunk-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thunk-middleware.d.ts","sourceRoot":"","sources":["../../src/redux-store/thunk-middleware.js"],"names":[],"mappings":"AAAA,oGAQC"}

package/build-types/registry.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Creates a new store registry, given an optional object of initial store
+ * configurations.
+ *
+ * @param {Object}  storeConfigs Initial store configurations.
+ * @param {Object?} parent       Parent registry.
+ *
+ * @return {WPDataRegistry} Data registry.
+ */
+export function createRegistry(storeConfigs?: Object, parent?: Object | null): WPDataRegistry;
+export type StoreDescriptor = import("./types").StoreDescriptor<any>;
+/**
+ * An isolated orchestrator of store registrations.
+ */
+export type WPDataRegistry = {
+    /**
+     * Given a namespace key and settings
+     * object, registers a new generic
+     * store.
+     */
+    registerGenericStore: Function;
+    /**
+     * Given a namespace key and settings
+     * object, registers a new namespace
+     * store.
+     */
+    registerStore: Function;
+    /**
+     * Given a function callback, invokes
+     * the callback on any change to state
+     * within any registered store.
+     */
+    subscribe: Function;
+    /**
+     * Given a namespace key, returns an
+     * object of the  store's registered
+     * selectors.
+     */
+    select: Function;
+    /**
+     * Given a namespace key, returns an
+     * object of the store's registered
+     * action dispatchers.
+     */
+    dispatch: Function;
+};
+/**
+ * An object of registry function overrides.
+ */
+export type WPDataPlugin = {
+    /**
+     * registers store.
+     */
+    registerStore: Function;
+};
+//# sourceMappingURL=registry.d.ts.map

package/build-types/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.js"],"names":[],"mappings":"AAiDA;;;;;;;;GAQG;AACH,8CALW,MAAM,WACN,MAAM,UAEL,cAAc,CAiSzB"}

package/build-types/resolvers-cache-middleware.d.ts

@@ -0,0 +1,15 @@
+export default createResolversCacheMiddleware;
+export type WPDataRegistry = import('./registry').WPDataRegistry;
+/** @typedef {import('./registry').WPDataRegistry} WPDataRegistry */
+/**
+ * Creates a middleware handling resolvers cache invalidation.
+ *
+ * @param {WPDataRegistry} registry   The registry reference for which to create
+ *                                    the middleware.
+ * @param {string}         reducerKey The namespace for which to create the
+ *                                    middleware.
+ *
+ * @return {Function} Middleware function.
+ */
+declare function createResolversCacheMiddleware(registry: WPDataRegistry, reducerKey: string): Function;
+//# sourceMappingURL=resolvers-cache-middleware.d.ts.map

package/build-types/resolvers-cache-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvers-cache-middleware.d.ts","sourceRoot":"","sources":["../src/resolvers-cache-middleware.js"],"names":[],"mappings":";6BAUc,OAAO,YAAY,EAAE,cAAc;AAAjD,oEAAoE;AAEpE;;;;;;;;;GASG;AACH,0DAPW,cAAc,cAEd,MAAM,YAwCf"}

package/build-types/store/index.d.ts

@@ -0,0 +1,23 @@
+export default coreDataStore;
+declare namespace coreDataStore {
+    const name: string;
+    function instantiate(registry: any): {
+        getSelectors(): {
+            [k: string]: (key: any, ...args: any[]) => any;
+        };
+        getActions(): {
+            [k: string]: (key: any, ...args: any[]) => any;
+        };
+        subscribe(): () => () => void;
+    };
+    function instantiate(registry: any): {
+        getSelectors(): {
+            [k: string]: (key: any, ...args: any[]) => any;
+        };
+        getActions(): {
+            [k: string]: (key: any, ...args: any[]) => any;
+        };
+        subscribe(): () => () => void;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

package/build-types/store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/store/index.js"],"names":[],"mappings":";;;IAEC;;;;;;;;MAoDC;IApDD;;;;;;;;MAoDC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wordpress/data",
-	"version": "6.12.0",
+	"version": "6.15.0",
 	"description": "Data module for WordPress.",
 	"author": "The WordPress Contributors",
 	"license": "GPL-2.0-or-later",
@@ -28,13 +28,14 @@
 	"sideEffects": false,
 	"dependencies": {
 		"@babel/runtime": "^7.16.0",
-		"@wordpress/compose": "^5.10.0",
-		"@wordpress/deprecated": "^3.12.0",
-		"@wordpress/element": "^4.10.0",
-		"@wordpress/is-shallow-equal": "^4.12.0",
-		"@wordpress/priority-queue": "^2.12.0",
-		"@wordpress/redux-routine": "^4.12.0",
+		"@wordpress/compose": "^5.13.0",
+		"@wordpress/deprecated": "^3.15.0",
+		"@wordpress/element": "^4.13.0",
+		"@wordpress/is-shallow-equal": "^4.15.0",
+		"@wordpress/priority-queue": "^2.15.0",
+		"@wordpress/redux-routine": "^4.15.0",
 		"equivalent-key-map": "^0.2.2",
+		"is-plain-obj": "^4.1.0",
 		"is-promise": "^4.0.0",
 		"lodash": "^4.17.21",
 		"redux": "^4.1.2",
@@ -47,5 +48,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "a80eeb62ec7cb1418b9915c277e084a29d6665e3"
+	"gitHead": "08358f53b627a15148c3a3e433cdf58cf8714aa4"
 }

package/src/components/async-mode-provider/context.js

@@ -17,10 +17,11 @@ export const AsyncModeConsumer = Consumer;
  *
  * ```js
  * import { useSelect, AsyncModeProvider } from '@wordpress/data';
+ * import { store as blockEditorStore } from '@wordpress/block-editor';
  *
  * function BlockCount() {
  *   const count = useSelect( ( select ) => {
- *     return select( 'core/block-editor' ).getBlockCount()
+ *     return select( blockEditorStore ).getBlockCount()
  *   }, [] );
  *
  *   return count;

package/src/components/use-dispatch/use-dispatch.js

@@ -25,6 +25,7 @@ import useRegistry from '../registry-provider/use-registry';
  * ```jsx
  * import { useDispatch, useSelect } from '@wordpress/data';
  * import { useCallback } from '@wordpress/element';
+ * import { store as myCustomStore } from 'my-custom-store';
  *
  * function Button( { onClick, children } ) {
  *   return <button type="button" onClick={ onClick }>{ children }</button>
@@ -32,10 +33,10 @@ import useRegistry from '../registry-provider/use-registry';
  *
  * const SaleButton = ( { children } ) => {
  *   const { stockNumber } = useSelect(
- *     ( select ) => select( 'my-shop' ).getStockNumber(),
+ *     ( select ) => select( myCustomStore ).getStockNumber(),
  *     []
  *   );
- *   const { startSale } = useDispatch( 'my-shop' );
+ *   const { startSale } = useDispatch( myCustomStore );
  *   const onClick = useCallback( () => {
  *     const discountPercent = stockNumber > 50 ? 10: 20;
  *     startSale( discountPercent );

package/src/components/use-select/index.js

@@ -7,7 +7,13 @@ import { useMemoOne } from 'use-memo-one';
  * WordPress dependencies
  */
 import { createQueue } from '@wordpress/priority-queue';
-import { useRef, useCallback, useMemo, useReducer } from '@wordpress/element';
+import {
+	useRef,
+	useCallback,
+	useMemo,
+	useReducer,
+	useDebugValue,
+} from '@wordpress/element';
 import isShallowEqual from '@wordpress/is-shallow-equal';
 import { useIsomorphicLayoutEffect } from '@wordpress/compose';
 
@@ -54,10 +60,11 @@ const renderQueue = createQueue();
  * @example
  * ```js
  * import { useSelect } from '@wordpress/data';
+ * import { store as myCustomStore } from 'my-custom-store';
  *
  * function HammerPriceDisplay( { currency } ) {
  *   const price = useSelect( ( select ) => {
- *     return select( 'my-shop' ).getPrice( 'hammer', currency )
+ *     return select( myCustomStore ).getPrice( 'hammer', currency );
  *   }, [ currency ] );
  *   return new Intl.NumberFormat( 'en-US', {
  *     style: 'currency',
@@ -84,9 +91,10 @@ const renderQueue = createQueue();
  *
  * ```js
  * import { useSelect } from '@wordpress/data';
+ * import { store as myCustomStore } from 'my-custom-store';
  *
  * function Paste( { children } ) {
- *   const { getSettings } = useSelect( 'my-shop' );
+ *   const { getSettings } = useSelect( myCustomStore );
  *   function onPaste() {
  *     // Do something with the settings.
  *     const settings = getSettings();
@@ -246,6 +254,8 @@ export default function useSelect( mapSelect, deps ) {
 		// examining every individual value inside the `deps` array.
 	}, [ registry, wrapSelect, hasMappingFunction, depsChangedFlag ] );
 
+	useDebugValue( mapOutput );
+
 	return hasMappingFunction ? mapOutput : registry.select( mapSelect );
 }
 

package/src/components/with-dispatch/index.js

@@ -26,9 +26,10 @@ import { useDispatchWithMap } from '../use-dispatch';
  * }
  *
  * import { withDispatch } from '@wordpress/data';
+ * import { store as myCustomStore } from 'my-custom-store';
  *
  * const SaleButton = withDispatch( ( dispatch, ownProps ) => {
- *     const { startSale } = dispatch( 'my-shop' );
+ *     const { startSale } = dispatch( myCustomStore );
  *     const { discountPercent } = ownProps;
  *
  *     return {
@@ -63,11 +64,12 @@ import { useDispatchWithMap } from '../use-dispatch';
  * }
  *
  * import { withDispatch } from '@wordpress/data';
+ * import { store as myCustomStore } from 'my-custom-store';
  *
  * const SaleButton = withDispatch( ( dispatch, ownProps, { select } ) => {
  *    // Stock number changes frequently.
- *    const { getStockNumber } = select( 'my-shop' );
- *    const { startSale } = dispatch( 'my-shop' );
+ *    const { getStockNumber } = select( myCustomStore );
+ *    const { startSale } = dispatch( myCustomStore );
  *    return {
  *        onClick() {
  *            const discountPercent = getStockNumber() > 50 ? 10 : 20;

package/src/components/with-select/index.js

@@ -19,6 +19,7 @@ import useSelect from '../use-select';
  * @example
  * ```js
  * import { withSelect } from '@wordpress/data';
+ * import { store as myCustomStore } from 'my-custom-store';
  *
  * function PriceDisplay( { price, currency } ) {
  * 	return new Intl.NumberFormat( 'en-US', {
@@ -28,7 +29,7 @@ import useSelect from '../use-select';
  * }
  *
  * const HammerPriceDisplay = withSelect( ( select, ownProps ) => {
- * 	const { getPrice } = select( 'my-shop' );
+ * 	const { getPrice } = select( myCustomStore );
  * 	const { currency } = ownProps;
  *
  * 	return {

package/src/controls.js

@@ -1,8 +1,3 @@
-/**
- * External dependencies
- */
-import { isObject } from 'lodash';
-
 /**
  * Internal dependencies
  */
@@ -14,6 +9,10 @@ const SELECT = '@@data/SELECT';
 const RESOLVE_SELECT = '@@data/RESOLVE_SELECT';
 const DISPATCH = '@@data/DISPATCH';
 
+function isObject( object ) {
+	return object !== null && typeof object === 'object';
+}
+
 /**
  * Dispatches a control action for triggering a synchronous registry select.
  *