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

package/src/components/use-select/{index.js → index.ts}

@@ -16,10 +16,21 @@ import { isShallowEqual } from '@wordpress/is-shallow-equal';
  */
 import useRegistry from '../registry-provider/use-registry';
 import useAsyncMode from '../async-mode-provider/use-async-mode';
+import type {
+	MapSelect,
+	SelectFunction,
+	StoreDescriptor,
+	AnyConfig,
+	UseSelectReturn,
+	DataRegistry,
+} from '../../types';
 
 const renderQueue = createQueue();
 
-function warnOnUnstableReference( a, b ) {
+function warnOnUnstableReference(
+	a: Record< string, unknown >,
+	b: Record< string, unknown >
+): void {
 	if ( ! a || ! b ) {
 		return;
 	}
@@ -38,41 +49,32 @@ function warnOnUnstableReference( a, b ) {
 	);
 }
 
-/**
- * @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
- */
-/** @typedef {import('../../types').MapSelect} MapSelect */
-/**
- * @typedef {import('../../types').UseSelectReturn<T>} UseSelectReturn
- * @template {MapSelect|StoreDescriptor<any>} T
- */
+interface StoreSubscriber {
+	subscribe: ( listener: () => void ) => () => void;
+	updateStores: ( newStores: string[] ) => void;
+}
 
-function Store( registry, suspense ) {
-	const select = suspense ? registry.suspendSelect : registry.select;
+function Store( registry: DataRegistry, suspense: boolean ) {
+	const select = ( suspense
+		? registry.suspendSelect
+		: registry.select ) as unknown as SelectFunction;
 	const queueContext = {};
-	let lastMapSelect;
-	let lastMapResult;
+	let lastMapSelect: MapSelect | undefined;
+	let lastMapResult: unknown;
 	let lastMapResultValid = false;
-	let lastIsAsync;
-	let subscriber;
-	let didWarnUnstableReference;
-	const storeStatesOnMount = new Map();
+	let lastIsAsync: boolean | undefined;
+	let subscriber: StoreSubscriber | undefined;
+	let didWarnUnstableReference: boolean | undefined;
+	const storeStatesOnMount = new Map< string, unknown >();
 
-	function getStoreState( name ) {
+	function getStoreState( name: string ): unknown {
 		// If there's no store property (custom generic store), return an empty
 		// object. When comparing the state, the empty objects will cause the
 		// equality check to fail, setting `lastMapResultValid` to false.
 		return registry.stores[ name ]?.store?.getState?.() ?? {};
 	}
 
-	const createSubscriber = ( stores ) => {
+	const createSubscriber = ( stores: string[] ): StoreSubscriber => {
 		// The set of stores the `subscribe` function is supposed to subscribe to. Here it is
 		// initialized, and then the `updateStores` function can add new stores to it.
 		const activeStores = [ ...stores ];
@@ -80,9 +82,9 @@ function Store( registry, suspense ) {
 		// The `subscribe` function, which is passed to the `useSyncExternalStore` hook, could
 		// be called multiple times to establish multiple subscriptions. That's why we need to
 		// keep a set of active subscriptions;
-		const activeSubscriptions = new Set();
+		const activeSubscriptions = new Set< ( storeName: string ) => void >();
 
-		function subscribe( listener ) {
+		function subscribe( listener: () => void ): () => void {
 			// Maybe invalidate the value right after subscription was created.
 			// React will call `getValue` after subscribing, to detect store
 			// updates that happened in the interval between the `getValue` call
@@ -116,8 +118,8 @@ function Store( registry, suspense ) {
 				}
 			};
 
-			const unsubs = [];
-			function subscribeStore( storeName ) {
+			const unsubs: Array< VoidFunction > = [];
+			function subscribeStore( storeName: string ) {
 				unsubs.push( registry.subscribe( onChange, storeName ) );
 			}
 
@@ -140,7 +142,7 @@ function Store( registry, suspense ) {
 		}
 
 		// Check if `newStores` contains some stores we're not subscribed to yet, and add them.
-		function updateStores( newStores ) {
+		function updateStores( newStores: string[] ) {
 			for ( const newStore of newStores ) {
 				if ( activeStores.includes( newStore ) ) {
 					continue;
@@ -159,22 +161,22 @@ function Store( registry, suspense ) {
 		return { subscribe, updateStores };
 	};
 
-	return ( mapSelect, isAsync ) => {
-		function updateValue() {
+	return ( mapSelect: MapSelect, isAsync: boolean ) => {
+		function updateValue(): void {
 			// If the last value is valid, and the `mapSelect` callback hasn't changed,
 			// then we can safely return the cached value. The value can change only on
 			// store update, and in that case value will be invalidated by the listener.
 			if ( lastMapResultValid && mapSelect === lastMapSelect ) {
-				return lastMapResult;
+				return;
 			}
 
-			const listeningStores = { current: null };
+			const listeningStores = { current: null as string[] | null };
 			const mapResult = registry.__unstableMarkListeningStores(
 				() => mapSelect( select, registry ),
 				listeningStores
 			);
 
-			if ( globalThis.SCRIPT_DEBUG ) {
+			if ( ( globalThis as any ).SCRIPT_DEBUG ) {
 				if ( ! didWarnUnstableReference ) {
 					const secondMapResult = mapSelect( select, registry );
 					if ( ! isShallowEqual( mapResult, secondMapResult ) ) {
@@ -185,12 +187,12 @@ function Store( registry, suspense ) {
 			}
 
 			if ( ! subscriber ) {
-				for ( const name of listeningStores.current ) {
+				for ( const name of listeningStores.current! ) {
 					storeStatesOnMount.set( name, getStoreState( name ) );
 				}
-				subscriber = createSubscriber( listeningStores.current );
+				subscriber = createSubscriber( listeningStores.current! );
 			} else {
-				subscriber.updateStores( listeningStores.current );
+				subscriber.updateStores( listeningStores.current! );
 			}
 
 			// If the new value is shallow-equal to the old one, keep the old one so
@@ -221,15 +223,19 @@ function Store( registry, suspense ) {
 		lastIsAsync = isAsync;
 
 		// Return a pair of functions that can be passed to `useSyncExternalStore`.
-		return { subscribe: subscriber.subscribe, getValue };
+		return { subscribe: subscriber!.subscribe, getValue };
 	};
 }
 
-function _useStaticSelect( storeName ) {
+function _useStaticSelect( storeName: StoreDescriptor< AnyConfig > | string ) {
 	return useRegistry().select( storeName );
 }
 
-function _useMappingSelect( suspense, mapSelect, deps ) {
+function _useMappingSelect(
+	suspense: boolean,
+	mapSelect: MapSelect,
+	deps: unknown[]
+) {
 	const registry = useRegistry();
 	const isAsync = useAsyncMode();
 	const store = useMemo(
@@ -239,6 +245,7 @@ function _useMappingSelect( suspense, mapSelect, deps ) {
 
 	// These are "pass-through" dependencies from the parent hook,
 	// and the parent should catch any hook rule violations.
+	// eslint-disable-next-line react-hooks/exhaustive-deps
 	const selector = useCallback( mapSelect, deps );
 	const { subscribe, getValue } = store( selector, isAsync );
 	const result = useSyncExternalStore( subscribe, getValue, getValue );
@@ -252,16 +259,15 @@ function _useMappingSelect( suspense, mapSelect, deps ) {
  * In general, this custom React hook follows the
  * [rules of hooks](https://react.dev/reference/rules/rules-of-hooks).
  *
- * @template {MapSelect | StoreDescriptor<any>} T
- * @param {T}          mapSelect Function called on every state change. The returned value is
- *                               exposed to the component implementing this hook. The function
- *                               receives the `registry.select` method on the first argument
- *                               and the `registry` on the second argument.
- *                               When a store key is passed, all selectors for the store will be
- *                               returned. This is only meant for usage of these selectors in event
- *                               callbacks, not for data needed to create the element tree.
- * @param {unknown[]=} deps      If provided, this memoizes the mapSelect so the same `mapSelect` is
- *                               invoked on every state change unless the dependencies change.
+ * @param mapSelect Function called on every state change. The returned value is
+ *                  exposed to the component implementing this hook. The function
+ *                  receives the `registry.select` method on the first argument
+ *                  and the `registry` on the second argument.
+ *                  When a store key is passed, all selectors for the store will be
+ *                  returned. This is only meant for usage of these selectors in event
+ *                  callbacks, not for data needed to create the element tree.
+ * @param deps      If provided, this memoizes the mapSelect so the same `mapSelect` is
+ *                  invoked on every state change unless the dependencies change.
  *
  * @example
  * ```js
@@ -308,9 +314,12 @@ function _useMappingSelect( suspense, mapSelect, deps ) {
  *   return <div onPaste={ onPaste }>{ children }</div>;
  * }
  * ```
- * @return {UseSelectReturn<T>} A custom react hook.
+ *
+ * @return The selected data or store selectors.
  */
-export default function useSelect( mapSelect, deps ) {
+export default function useSelect<
+	T extends MapSelect | StoreDescriptor< AnyConfig >,
+>( mapSelect: T, deps?: unknown[] ): UseSelectReturn< T > {
 	// On initial call, on mount, determine the mode of this `useSelect` call
 	// and then never allow it to change on subsequent updates.
 	const staticSelectMode = typeof mapSelect !== 'function';
@@ -326,30 +335,35 @@ export default function useSelect( mapSelect, deps ) {
 
 	// `staticSelectMode` is not allowed to change during the hook instance's,
 	// lifetime, so the rules of hooks are not really violated.
-	return staticSelectMode
-		? _useStaticSelect( mapSelect )
-		: _useMappingSelect( false, mapSelect, deps );
+
+	return (
+		staticSelectMode
+			? _useStaticSelect( mapSelect as StoreDescriptor< AnyConfig > )
+			: _useMappingSelect( false, mapSelect as MapSelect, deps! )
+	) as UseSelectReturn< T >;
 }
 
 /**
  * A variant of the `useSelect` hook that has the same API, but is a compatible
  * Suspense-enabled data source.
  *
- * @template {MapSelect} T
- * @param {T}     mapSelect Function called on every state change. The
- *                          returned value is exposed to the component
- *                          using this hook. The function receives the
- *                          `registry.suspendSelect` method as the first
- *                          argument and the `registry` as the second one.
- * @param {Array} deps      A dependency array used to memoize the `mapSelect`
- *                          so that the same `mapSelect` is invoked on every
- *                          state change unless the dependencies change.
+ * @param mapSelect Function called on every state change. The
+ *                  returned value is exposed to the component
+ *                  using this hook. The function receives the
+ *                  `registry.suspendSelect` method as the first
+ *                  argument and the `registry` as the second one.
+ * @param deps      A dependency array used to memoize the `mapSelect`
+ *                  so that the same `mapSelect` is invoked on every
+ *                  state change unless the dependencies change.
  *
- * @throws {Promise} A suspense Promise that is thrown if any of the called
+ * @throws A suspense Promise that is thrown if any of the called
  * selectors is in an unresolved state.
  *
- * @return {ReturnType<T>} Data object returned by the `mapSelect` function.
+ * @return Data object returned by the `mapSelect` function.
  */
-export function useSuspenseSelect( mapSelect, deps ) {
-	return _useMappingSelect( true, mapSelect, deps );
+export function useSuspenseSelect< T extends MapSelect >(
+	mapSelect: T,
+	deps: unknown[]
+): ReturnType< T > {
+	return _useMappingSelect( true, mapSelect, deps ) as ReturnType< T >;
 }

package/src/components/with-dispatch/{index.js → index.tsx}

@@ -7,19 +7,18 @@ import { createHigherOrderComponent } from '@wordpress/compose';
  * Internal dependencies
  */
 import { useDispatchWithMap } from '../use-dispatch';
-
-/** @typedef {React.ComponentType} ComponentType */
+import type { DataRegistry } from '../../types';
 
 /**
  * Higher-order component used to add dispatch props using registered action
  * creators.
  *
- * @param {Function} mapDispatchToProps A function of returning an object of
- *                                      prop names where value is a
- *                                      dispatch-bound action creator, or a
- *                                      function to be called with the
- *                                      component's props and returning an
- *                                      action creator.
+ * @param mapDispatchToProps A function of returning an object of
+ *                           prop names where value is a
+ *                           dispatch-bound action creator, or a
+ *                           function to be called with the
+ *                           component's props and returning an
+ *                           action creator.
  *
  * @example
  * ```jsx
@@ -89,13 +88,21 @@ import { useDispatchWithMap } from '../use-dispatch';
  * returns an object with the same keys. For example, it should not contain
  * conditions under which a different value would be returned.
  *
- * @return {ComponentType} Enhanced component with merged dispatcher props.
+ * @return Enhanced component with merged dispatcher props.
  */
-const withDispatch = ( mapDispatchToProps ) =>
+const withDispatch = (
+	mapDispatchToProps: (
+		dispatch: DataRegistry[ 'dispatch' ],
+		ownProps: Record< string, unknown >,
+		registry: DataRegistry
+	) => Record< string, ( ...args: unknown[] ) => unknown >
+) =>
 	createHigherOrderComponent(
-		( WrappedComponent ) => ( ownProps ) => {
-			const mapDispatch = ( dispatch, registry ) =>
-				mapDispatchToProps( dispatch, ownProps, registry );
+		( WrappedComponent ) => ( ownProps: Record< string, unknown > ) => {
+			const mapDispatch = (
+				dispatch: DataRegistry[ 'dispatch' ],
+				registry: DataRegistry
+			) => mapDispatchToProps( dispatch, ownProps, registry );
 			const dispatchProps = useDispatchWithMap( mapDispatch, [] );
 			return <WrappedComponent { ...ownProps } { ...dispatchProps } />;
 		},

package/src/components/with-registry/{index.js → index.tsx}

@@ -11,13 +11,9 @@ import { RegistryConsumer } from '../registry-provider';
 /**
  * Higher-order component which renders the original component with the current
  * registry context passed as its `registry` prop.
- *
- * @param {Component} OriginalComponent Original component.
- *
- * @return {Component} Enhanced component.
  */
 const withRegistry = createHigherOrderComponent(
-	( OriginalComponent ) => ( props ) => (
+	( OriginalComponent ) => ( props: Record< string, unknown > ) => (
 		<RegistryConsumer>
 			{ ( registry ) => (
 				<OriginalComponent { ...props } registry={ registry } />

package/src/components/with-select/{index.js → index.tsx}

@@ -7,16 +7,15 @@ import { createHigherOrderComponent, pure } from '@wordpress/compose';
  * Internal dependencies
  */
 import useSelect from '../use-select';
-
-/** @typedef {React.ComponentType} ComponentType */
+import type { SelectFunction, DataRegistry } from '../../types';
 
 /**
  * Higher-order component used to inject state-derived props using registered
  * selectors.
  *
- * @param {Function} mapSelectToProps Function called on every state change,
- *                                    expected to return object of props to
- *                                    merge with the component's own props.
+ * @param mapSelectToProps Function called on every state change,
+ *                         expected to return object of props to
+ *                         merge with the component's own props.
  *
  * @example
  * ```js
@@ -48,14 +47,22 @@ import useSelect from '../use-select';
  * component and update automatically if the price of a hammer ever changes in
  * the store.
  *
- * @return {ComponentType} Enhanced component with merged state data props.
+ * @return Enhanced component with merged state data props.
  */
-const withSelect = ( mapSelectToProps ) =>
+const withSelect = (
+	mapSelectToProps: (
+		select: SelectFunction,
+		ownProps: Record< string, unknown >,
+		registry: DataRegistry
+	) => Record< string, unknown >
+) =>
 	createHigherOrderComponent(
 		( WrappedComponent ) =>
-			pure( ( ownProps ) => {
-				const mapSelect = ( select, registry ) =>
-					mapSelectToProps( select, ownProps, registry );
+			pure( ( ownProps: Record< string, unknown > ) => {
+				const mapSelect = (
+					select: SelectFunction,
+					registry: DataRegistry
+				) => mapSelectToProps( select, ownProps, registry );
 				const mergeProps = useSelect( mapSelect );
 				return <WrappedComponent { ...ownProps } { ...mergeProps } />;
 			} ),

package/src/{controls.js → controls.ts}

@@ -2,14 +2,13 @@
  * Internal dependencies
  */
 import { createRegistryControl } from './factory';
-
-/** @typedef {import('./types').StoreDescriptor} StoreDescriptor */
+import type { StoreDescriptor } from './types';
 
 const SELECT = '@@data/SELECT';
 const RESOLVE_SELECT = '@@data/RESOLVE_SELECT';
 const DISPATCH = '@@data/DISPATCH';
 
-function isObject( object ) {
+function isStoreDescriptor( object: unknown ): object is StoreDescriptor {
 	return object !== null && typeof object === 'object';
 }
 
@@ -19,9 +18,9 @@ function isObject( object ) {
  * Note: This control synchronously returns the current selector value, triggering the
  * resolution, but not waiting for it.
  *
- * @param {string|StoreDescriptor} storeNameOrDescriptor Unique namespace identifier for the store
- * @param {string}                 selectorName          The name of the selector.
- * @param {Array}                  args                  Arguments for the selector.
+ * @param storeNameOrDescriptor Unique namespace identifier for the store
+ * @param selectorName          The name of the selector.
+ * @param args                  Arguments for the selector.
  *
  * @example
  * ```js
@@ -34,12 +33,16 @@ function isObject( object ) {
  * }
  * ```
  *
- * @return {Object} The control descriptor.
+ * @return The control descriptor.
  */
-function select( storeNameOrDescriptor, selectorName, ...args ) {
+function select(
+	storeNameOrDescriptor: string | StoreDescriptor,
+	selectorName: string,
+	...args: unknown[]
+) {
 	return {
 		type: SELECT,
-		storeKey: isObject( storeNameOrDescriptor )
+		storeKey: isStoreDescriptor( storeNameOrDescriptor )
 			? storeNameOrDescriptor.name
 			: storeNameOrDescriptor,
 		selectorName,
@@ -54,9 +57,9 @@ function select( storeNameOrDescriptor, selectorName, ...args ) {
  * selectors that may have a resolver. In such case, it will return a `Promise` that resolves
  * after the selector finishes resolving, with the final result value.
  *
- * @param {string|StoreDescriptor} storeNameOrDescriptor Unique namespace identifier for the store
- * @param {string}                 selectorName          The name of the selector
- * @param {Array}                  args                  Arguments for the selector.
+ * @param storeNameOrDescriptor Unique namespace identifier for the store
+ * @param selectorName          The name of the selector
+ * @param args                  Arguments for the selector.
  *
  * @example
  * ```js
@@ -69,12 +72,16 @@ function select( storeNameOrDescriptor, selectorName, ...args ) {
  * }
  * ```
  *
- * @return {Object} The control descriptor.
+ * @return The control descriptor.
  */
-function resolveSelect( storeNameOrDescriptor, selectorName, ...args ) {
+function resolveSelect(
+	storeNameOrDescriptor: string | StoreDescriptor< any >,
+	selectorName: string,
+	...args: any[]
+) {
 	return {
 		type: RESOLVE_SELECT,
-		storeKey: isObject( storeNameOrDescriptor )
+		storeKey: isStoreDescriptor( storeNameOrDescriptor )
 			? storeNameOrDescriptor.name
 			: storeNameOrDescriptor,
 		selectorName,
@@ -85,9 +92,9 @@ function resolveSelect( storeNameOrDescriptor, selectorName, ...args ) {
 /**
  * Dispatches a control action for triggering a registry dispatch.
  *
- * @param {string|StoreDescriptor} storeNameOrDescriptor Unique namespace identifier for the store
- * @param {string}                 actionName            The name of the action to dispatch
- * @param {Array}                  args                  Arguments for the dispatch action.
+ * @param storeNameOrDescriptor Unique namespace identifier for the store
+ * @param actionName            The name of the action to dispatch
+ * @param args                  Arguments for the dispatch action.
  *
  * @example
  * ```js
@@ -100,12 +107,16 @@ function resolveSelect( storeNameOrDescriptor, selectorName, ...args ) {
  * }
  * ```
  *
- * @return {Object}  The control descriptor.
+ * @return   The control descriptor.
  */
-function dispatch( storeNameOrDescriptor, actionName, ...args ) {
+function dispatch(
+	storeNameOrDescriptor: string | StoreDescriptor,
+	actionName: string,
+	...args: unknown[]
+) {
 	return {
 		type: DISPATCH,
-		storeKey: isObject( storeNameOrDescriptor )
+		storeKey: isStoreDescriptor( storeNameOrDescriptor )
 			? storeNameOrDescriptor.name
 			: storeNameOrDescriptor,
 		actionName,
@@ -115,17 +126,33 @@ function dispatch( storeNameOrDescriptor, actionName, ...args ) {
 
 export const controls = { select, resolveSelect, dispatch };
 
+type SelectorControlArgs = {
+	storeKey: string;
+	selectorName: string;
+	args: unknown[];
+};
+
+type ActionControlArgs = {
+	storeKey: string;
+	actionName: string;
+	args: unknown[];
+};
+
 export const builtinControls = {
 	[ SELECT ]: createRegistryControl(
 		( registry ) =>
-			( { storeKey, selectorName, args } ) =>
+			( { storeKey, selectorName, args }: SelectorControlArgs ) =>
 				registry.select( storeKey )[ selectorName ]( ...args )
 	),
 	[ RESOLVE_SELECT ]: createRegistryControl(
 		( registry ) =>
-			( { storeKey, selectorName, args } ) => {
-				const method = registry.select( storeKey )[ selectorName ]
-					.hasResolver
+			( { storeKey, selectorName, args }: SelectorControlArgs ) => {
+				const selector = registry.select( storeKey )[
+					selectorName
+				] as ( ( ...a: any[] ) => any ) & {
+					hasResolver?: boolean;
+				};
+				const method = selector.hasResolver
 					? 'resolveSelect'
 					: 'select';
 				return registry[ method ]( storeKey )[ selectorName ](
@@ -135,7 +162,7 @@ export const builtinControls = {
 	),
 	[ DISPATCH ]: createRegistryControl(
 		( registry ) =>
-			( { storeKey, actionName, args } ) =>
+			( { storeKey, actionName, args }: ActionControlArgs ) =>
 				registry.dispatch( storeKey )[ actionName ]( ...args )
 	),
 };

package/src/{default-registry.js → default-registry.ts}

@@ -3,4 +3,6 @@
  */
 import { createRegistry } from './registry';
 
-export default createRegistry();
+const defaultRegistry = createRegistry();
+
+export default defaultRegistry;

package/src/dispatch.ts

@@ -11,6 +11,10 @@ import defaultRegistry from './default-registry';
  * Note: Action creators returned by the dispatch will return a promise when
  * they are called.
  *
+ * Warning: This global `dispatch` function only works with the default registry.
+ * It will not work with custom `RegistryProvider` or `BlockEditorProvider` contexts.
+ * In React components, prefer the `useDispatch` hook instead, which is registry-aware.
+ *
  * @param storeNameOrDescriptor The store descriptor. The legacy calling convention of passing
  *                              the store name is also supported.
  *
@@ -28,5 +32,7 @@ export function dispatch<
 >(
 	storeNameOrDescriptor: StoreNameOrDescriptor
 ): DispatchReturn< StoreNameOrDescriptor > {
-	return defaultRegistry.dispatch( storeNameOrDescriptor );
+	return defaultRegistry.dispatch(
+		storeNameOrDescriptor
+	) as DispatchReturn< StoreNameOrDescriptor >;
 }

package/src/factory.ts

@@ -2,6 +2,7 @@
  * Internal dependencies
  */
 import type { select as globalSelect } from './select';
+import type { DataRegistry } from './types';
 
 type RegistrySelector< Selector extends ( ...args: any[] ) => any > = {
 	( ...args: Parameters< Selector > ): ReturnType< Selector >;
@@ -101,9 +102,9 @@ export function createRegistrySelector<
  *
  * @return Registry control that can be registered with a store.
  */
-export function createRegistryControl< T extends ( ...args: any ) => any >(
-	registryControl: T & { isRegistryControl?: boolean }
-) {
+export function createRegistryControl<
+	T extends ( registry: DataRegistry ) => ( ...args: any ) => any,
+>( registryControl: T & { isRegistryControl?: boolean } ) {
 	registryControl.isRegistryControl = true;
 
 	return registryControl;

package/src/index.ts

@@ -1,7 +1,7 @@
 /**
  * Internal dependencies
  */
-import defaultRegistryUntyped from './default-registry';
+import defaultRegistry from './default-registry';
 import * as plugins from './plugins';
 import { combineReducers as combineReducersModule } from './redux-store';
 
@@ -13,12 +13,6 @@ import type {
 	CurriedSelectorsResolveOf,
 } from './types';
 
-// The runtime registry is created from the JavaScript implementation in `registry.js`.
-// Its JSDoc type (`WPDataRegistry`) doesn't include some newer methods like
-// `resolveSelect` or `suspendSelect`, so we widen the type here for the typed
-// exports in this module.
-const defaultRegistry: any = defaultRegistryUntyped;
-
 export { default as withSelect } from './components/with-select';
 export { default as withDispatch } from './components/with-dispatch';
 export { default as withRegistry } from './components/with-registry';
@@ -115,7 +109,9 @@ export const combineReducers =
 export function resolveSelect< T extends StoreDescriptor< AnyConfig > >(
 	storeNameOrDescriptor: T | string
 ): CurriedSelectorsResolveOf< T > {
-	return defaultRegistry.resolveSelect( storeNameOrDescriptor );
+	return defaultRegistry.resolveSelect(
+		storeNameOrDescriptor
+	) as CurriedSelectorsResolveOf< T >;
 }
 
 /**