@wordpress/data 10.41.0 → 10.41.1-next.v.202603102151.0

package/src/types.ts

@@ -1,8 +1,21 @@
 /**
  * External dependencies
  */
-// eslint-disable-next-line no-restricted-imports
-import type { combineReducers as reduxCombineReducers } from 'redux';
+
+import type {
+	// eslint-disable-next-line no-restricted-imports
+	combineReducers as reduxCombineReducers,
+	Store as ReduxStore,
+} from 'redux';
+
+/**
+ * Internal dependencies
+ */
+import type { DataEmitter } from './utils/emitter';
+import type {
+	MetadataSelectors,
+	MetadataActions,
+} from './redux-store/metadata/types';
 
 type MapOf< T > = { [ name: string ]: T };
 
@@ -30,11 +43,7 @@ export interface StoreDescriptor< Config extends AnyConfig = AnyConfig > {
 	instantiate: ( registry: DataRegistry ) => StoreInstance< Config >;
 }
 
-export interface ReduxStoreConfig<
-	State,
-	ActionCreators extends MapOf< ActionCreator >,
-	Selectors,
-> {
+export interface ReduxStoreConfig< State, ActionCreators, Selectors > {
 	initialState?: State;
 	reducer: ( state: any, action: any ) => any;
 	actions?: ActionCreators;
@@ -54,7 +63,7 @@ export type UseSelectReturn< F extends MapSelect | StoreDescriptor< any > > =
 // Return type for the useDispatch() hook.
 export type UseDispatchReturn< StoreNameOrDescriptor > =
 	StoreNameOrDescriptor extends StoreDescriptor< any >
-		? ActionCreatorsOf< ConfigOf< StoreNameOrDescriptor > >
+		? ActionCreatorsOf< StoreNameOrDescriptor >
 		: StoreNameOrDescriptor extends undefined
 		? DispatchFunction
 		: any;
@@ -65,7 +74,7 @@ export type DispatchFunction = < StoreNameOrDescriptor >(
 
 export type DispatchReturn< StoreNameOrDescriptor > =
 	StoreNameOrDescriptor extends StoreDescriptor< any >
-		? ActionCreatorsOf< ConfigOf< StoreNameOrDescriptor > >
+		? ActionCreatorsOf< StoreNameOrDescriptor >
 		: unknown;
 
 export type MapSelect = (
@@ -84,7 +93,9 @@ export type ListenerFunction = () => void;
 export type CurriedSelectorsOf< S > = S extends StoreDescriptor<
 	ReduxStoreConfig< any, any, infer Selectors >
 >
-	? { [ key in keyof Selectors ]: CurriedState< Selectors[ key ] > }
+	? {
+			[ key in keyof Selectors ]: CurriedState< Selectors[ key ] >;
+	  } & MetadataSelectors< S >
 	: never;
 
 /**
@@ -193,39 +204,244 @@ export interface SelectorWithCustomCurrySignature {
 	PromiseCurriedSignature?: Function;
 }
 
+/**
+ * A store name or store descriptor, used throughout the API.
+ */
+export type StoreNameOrDescriptor = string | StoreDescriptor;
+
+/**
+ * An isolated orchestrator of store registrations.
+ *
+ * Returned by `createRegistry`. Provides methods to register stores,
+ * select data, dispatch actions, and subscribe to changes.
+ */
 export interface DataRegistry {
+	batch: ( callback: () => void ) => void;
+	stores: Record< string, InternalStoreInstance >;
+	namespaces: Record< string, InternalStoreInstance >;
+	subscribe: (
+		listener: ListenerFunction,
+		storeNameOrDescriptor?: StoreNameOrDescriptor
+	) => () => void;
+	select: {
+		< S extends StoreDescriptor< any > >(
+			store: S
+		): CurriedSelectorsOf< S >;
+		(
+			store: StoreNameOrDescriptor
+		): Record< string, ( ...args: any[] ) => any >;
+	};
+	resolveSelect: {
+		< S extends StoreDescriptor< any > >(
+			store: S
+		): CurriedSelectorsResolveOf< S >;
+		(
+			store: StoreNameOrDescriptor
+		): Record< string, ( ...args: any[] ) => Promise< any > >;
+	};
+	suspendSelect: {
+		< S extends StoreDescriptor< any > >(
+			store: S
+		): CurriedSelectorsOf< S >;
+		(
+			store: StoreNameOrDescriptor
+		): Record< string, ( ...args: any[] ) => any >;
+	};
+	dispatch: {
+		< S extends StoreDescriptor< any > >( store: S ): ActionCreatorsOf< S >;
+		(
+			store: StoreNameOrDescriptor
+		): Record< string, ( ...args: any[] ) => any >;
+	};
+	use: (
+		plugin: DataPlugin,
+		options?: Record< string, unknown >
+	) => DataRegistry;
 	register: ( store: StoreDescriptor< any > ) => void;
-	dispatch: < S extends StoreDescriptor< any > >(
-		store: S
-	) => ActionCreatorsOf< ConfigOf< S > >;
+	registerGenericStore: (
+		name: string,
+		store: StoreInstance< AnyConfig >
+	) => void;
+	registerStore: (
+		storeName: string,
+		options: ReduxStoreConfig< any, any, any >
+	) => ReduxStore;
+	__unstableMarkListeningStores: < T >(
+		callback: () => T,
+		ref: { current: string[] | null }
+	) => T;
+}
+
+/**
+ * The plugin function signature.
+ */
+export type DataPlugin = (
+	registry: DataRegistry,
+	options?: Record< string, unknown >
+) => Partial< DataRegistry >;
+
+/**
+ * Status of a selector resolution.
+ */
+export type ResolutionStatus = 'resolving' | 'finished' | 'error';
+
+/**
+ * State value for a single resolution.
+ */
+export type ResolutionState =
+	| { status: 'resolving' }
+	| { status: 'finished' }
+	| { status: 'error'; error: Error | unknown };
+
+/**
+ * A normalized resolver with a `fulfill` method and optional `isFulfilled`.
+ */
+export interface NormalizedResolver {
+	/**
+	 * The function to call to fulfill the resolver.
+	 */
+	fulfill: ( ...args: any[] ) => any;
+	/**
+	 * Optional function to check if the resolver is already fulfilled.
+	 */
+	isFulfilled?: ( state: any, ...args: any[] ) => boolean;
+	/**
+	 * Optional function to check if the resolver should be invalidated.
+	 */
+	shouldInvalidate?: ( action: any, ...args: any[] ) => boolean;
+}
+
+/**
+ * A bound selector with optional resolver metadata.
+ */
+export interface BoundSelector {
+	( ...args: any[] ): any;
+	/**
+	 * Whether this selector has a resolver attached.
+	 */
+	hasResolver: boolean;
+	/**
+	 * Optional function to normalize the arguments.
+	 */
+	__unstableNormalizeArgs?: ( args: any[] ) => any[];
+	/**
+	 * Whether this selector is a registry selector.
+	 */
+	isRegistrySelector?: boolean;
+	/**
+	 * The registry instance this selector is bound to.
+	 */
+	registry?: DataRegistry;
+}
+
+/**
+ * The shape of a store instance as seen internally by the registry.
+ * Extends the public StoreInstance with additional internal properties.
+ */
+export interface InternalStoreInstance< Config extends AnyConfig = AnyConfig >
+	extends StoreInstance< Config > {
+	/**
+	 * The Redux store instance (only for Redux-based stores).
+	 */
+	store?: ReduxStore;
+	/**
+	 * The internal emitter for pause/resume batching.
+	 */
+	emitter: DataEmitter;
+	/**
+	 * The combined reducer.
+	 */
+	reducer?: ( state: any, action: any ) => any;
+	/**
+	 * Bound actions object.
+	 */
+	actions?: Record< string, ActionCreator >;
+	/**
+	 * Bound selectors object.
+	 */
+	selectors?: Record< string, Selector >;
+	/**
+	 * Resolver definitions.
+	 */
+	resolvers?: Record< string, NormalizedResolver >;
+	/**
+	 * Returns resolve-wrapped selectors.
+	 */
+	getResolveSelectors?: () => Record<
+		string,
+		( ...args: any[] ) => Promise< any >
+	>;
+	/**
+	 * Returns suspense-wrapped selectors.
+	 */
+	getSuspendSelectors?: () => Record< string, ( ...args: any[] ) => any >;
+}
+
+/**
+ * Control descriptor for the controls system.
+ */
+export interface ControlDescriptor {
+	/**
+	 * The type of the control action.
+	 */
+	type: string;
+	/**
+	 * The store key to target.
+	 */
+	storeKey: string;
+	/**
+	 * The name of the selector (for select/resolveSelect controls).
+	 */
+	selectorName?: string;
+	/**
+	 * The name of the action (for dispatch controls).
+	 */
+	actionName?: string;
+	/**
+	 * Arguments for the selector or action.
+	 */
+	args: any[];
+}
+
+/**
+ * Storage interface (Web Storage API subset).
+ */
+export interface StorageInterface {
+	getItem: ( key: string ) => string | null;
+	setItem: ( key: string, value: string ) => void;
+	removeItem?: ( key: string ) => void;
+	clear?: VoidFunction;
 }
 
 // Type Helpers.
 
 export type ConfigOf< S > = S extends StoreDescriptor< infer C > ? C : never;
 
-export type ActionCreatorsOf< Config extends AnyConfig > =
-	Config extends ReduxStoreConfig< any, infer ActionCreators, any >
-		? PromisifiedActionCreators< ActionCreators >
-		: never;
+export type ActionCreatorsOf< T > = T extends StoreDescriptor<
+	ReduxStoreConfig< any, infer ActionCreators, any >
+>
+	? PromisifiedActionCreators< ActionCreators > & MetadataActions< T >
+	: T extends ReduxStoreConfig< any, infer ActionCreators, any >
+	? PromisifiedActionCreators< ActionCreators >
+	: never;
 
 // Takes an object containing all action creators for a store and updates the
 // return type of each action creator to account for internal registry details --
 // for example, dispatched actions are wrapped with a Promise.
-export type PromisifiedActionCreators<
-	ActionCreators extends MapOf< ActionCreator >,
-> = {
-	[ Action in keyof ActionCreators ]: PromisifyActionCreator<
-		ActionCreators[ Action ]
-	>;
+export type PromisifiedActionCreators< ActionCreators > = {
+	[ Action in keyof ActionCreators ]: ActionCreators[ Action ] extends ActionCreator
+		? PromisifyActionCreator< ActionCreators[ Action ] >
+		: ActionCreators[ Action ];
 };
 
-// Wraps action creator return types with a Promise and handles thunks.
+// Wraps action creator return types with a Promise and handles thunks and generators.
 export type PromisifyActionCreator< Action extends ActionCreator > = (
 	...args: Parameters< Action >
 ) => Promise<
 	ReturnType< Action > extends ( ..._args: any[] ) => any
 		? ThunkReturnType< Action >
+		: ReturnType< Action > extends Generator< any, infer TReturn, any >
+		? TReturn
 		: ReturnType< Action >
 >;
 
@@ -245,4 +461,27 @@ type SelectorsOf< Config extends AnyConfig > = Config extends ReduxStoreConfig<
 	? { [ name in keyof Selectors ]: Function }
 	: never;
 
+/**
+ * The argument object passed to every thunk function. When parameterized with
+ * a store descriptor, `dispatch`, `select`, and `resolveSelect` are fully
+ * typed against that store's actions and selectors.
+ *
+ * @example
+ * ```ts
+ * const myAction =
+ *     ( id: number ) =>
+ *     async ( { dispatch, select }: ThunkArgs< typeof myStore > ) => {
+ *         const record = select.getRecord( id );
+ *         dispatch.setLoading( true );
+ *     };
+ * ```
+ */
+export interface ThunkArgs< S extends StoreDescriptor = StoreDescriptor > {
+	dispatch: ActionCreatorsOf< S > &
+		( ( action: Record< string, unknown > | Function ) => unknown );
+	select: CurriedSelectorsOf< S >;
+	resolveSelect: CurriedSelectorsResolveOf< S >;
+	registry: DataRegistry;
+}
+
 export type combineReducers = typeof reduxCombineReducers;

package/src/plugins/persistence/storage/object.js

@@ -1,23 +0,0 @@
-let objectStorage;
-
-const storage = {
-	getItem( key ) {
-		if ( ! objectStorage || ! objectStorage[ key ] ) {
-			return null;
-		}
-
-		return objectStorage[ key ];
-	},
-	setItem( key, value ) {
-		if ( ! objectStorage ) {
-			storage.clear();
-		}
-
-		objectStorage[ key ] = String( value );
-	},
-	clear() {
-		objectStorage = Object.create( null );
-	},
-};
-
-export default storage;