@wordpress/data 6.2.1 → 6.3.1-next.a55ed9455a.0

package/src/redux-store/metadata/test/selectors.js

@@ -1,106 +1,327 @@
 /**
- * External dependencies
+ * WordPress dependencies
  */
-import EquivalentKeyMap from 'equivalent-key-map';
+import { createRegistry } from '@wordpress/data';
 
-/**
- * Internal dependencies
- */
-import {
-	getIsResolving,
-	hasStartedResolution,
-	hasFinishedResolution,
-	isResolving,
-} from '../selectors';
+jest.useRealTimers();
+const testStore = {
+	reducer: ( state = null, action ) => {
+		if ( action.type === 'RECEIVE' ) {
+			return action.items;
+		}
+
+		return state;
+	},
+	selectors: {
+		getFoo: ( state ) => state,
+	},
+};
+
+async function resolve( registry, selector ) {
+	try {
+		await registry.resolveSelect( 'store' )[ selector ]();
+	} catch ( e ) {}
+}
 
 describe( 'getIsResolving', () => {
+	let registry;
+	beforeEach( () => {
+		registry = createRegistry();
+		registry.registerStore( 'testStore', testStore );
+	} );
+
 	it( 'should return undefined if no state by reducerKey, selectorName', () => {
-		const state = {};
-		const result = getIsResolving( state, 'getFoo', [] );
+		const result = registry
+			.select( 'testStore' )
+			.getIsResolving( 'getFoo', [] );
 
 		expect( result ).toBe( undefined );
 	} );
 
 	it( 'should return undefined if state by reducerKey, selectorName, but not args', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], true ] ] ),
-		};
-		const result = getIsResolving( state, 'getFoo', [ 'bar' ] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const result = registry
+			.select( 'testStore' )
+			.getIsResolving( 'getFoo', [ 'bar' ] );
 
 		expect( result ).toBe( undefined );
 	} );
 
 	it( 'should return value by reducerKey, selectorName', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], true ] ] ),
-		};
-		const result = getIsResolving( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const result = registry
+			.select( 'testStore' )
+			.getIsResolving( 'getFoo', [] );
 
 		expect( result ).toBe( true );
 	} );
+
+	it( 'should normalize args ard return the right value', () => {
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const { getIsResolving } = registry.select( 'testStore' );
+
+		expect( getIsResolving( 'getFoo' ) ).toBe( true );
+		expect( getIsResolving( 'getFoo', [ undefined ] ) ).toBe( true );
+		expect( getIsResolving( 'getFoo', [ undefined, undefined ] ) ).toBe(
+			true
+		);
+	} );
 } );
 
 describe( 'hasStartedResolution', () => {
+	let registry;
+	beforeEach( () => {
+		registry = createRegistry();
+		registry.registerStore( 'testStore', testStore );
+	} );
+
 	it( 'returns false if not has started', () => {
-		const state = {};
-		const result = hasStartedResolution( state, 'getFoo', [] );
+		const result = registry
+			.select( 'testStore' )
+			.hasStartedResolution( 'getFoo', [] );
 
 		expect( result ).toBe( false );
 	} );
 
 	it( 'returns true if has started', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], true ] ] ),
-		};
-		const result = hasStartedResolution( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const { hasStartedResolution } = registry.select( 'testStore' );
+		const result = hasStartedResolution( 'getFoo', [] );
 
 		expect( result ).toBe( true );
 	} );
 } );
 
 describe( 'hasFinishedResolution', () => {
+	let registry;
+	beforeEach( () => {
+		registry = createRegistry();
+		registry.registerStore( 'testStore', testStore );
+	} );
+
 	it( 'returns false if not has finished', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], true ] ] ),
-		};
-		const result = hasFinishedResolution( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const { hasFinishedResolution } = registry.select( 'testStore' );
+		const result = hasFinishedResolution( 'getFoo', [] );
 
 		expect( result ).toBe( false );
 	} );
 
 	it( 'returns true if has finished', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], false ] ] ),
-		};
-		const result = hasFinishedResolution( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).finishResolution( 'getFoo', [] );
+		const { hasFinishedResolution } = registry.select( 'testStore' );
+		const result = hasFinishedResolution( 'getFoo', [] );
 
 		expect( result ).toBe( true );
 	} );
 } );
 
 describe( 'isResolving', () => {
+	let registry;
+	beforeEach( () => {
+		registry = createRegistry();
+		registry.registerStore( 'testStore', testStore );
+	} );
+
 	it( 'returns false if not has started', () => {
-		const state = {};
-		const result = isResolving( state, 'getFoo', [] );
+		const { isResolving } = registry.select( 'testStore' );
+		const result = isResolving( 'getFoo', [] );
 
 		expect( result ).toBe( false );
 	} );
 
 	it( 'returns false if has finished', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], false ] ] ),
-		};
-		const result = isResolving( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		registry.dispatch( 'testStore' ).finishResolution( 'getFoo', [] );
+		const { isResolving } = registry.select( 'testStore' );
+		const result = isResolving( 'getFoo', [] );
 
 		expect( result ).toBe( false );
 	} );
 
 	it( 'returns true if has started but not finished', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], true ] ] ),
-		};
-		const result = isResolving( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const { isResolving } = registry.select( 'testStore' );
+		const result = isResolving( 'getFoo', [] );
 
 		expect( result ).toBe( true );
 	} );
 } );
+
+describe( 'hasResolutionFailed', () => {
+	let registry;
+
+	beforeEach( () => {
+		registry = createRegistry();
+	} );
+
+	it( 'returns false if the resolution has succeeded', async () => {
+		registry.registerStore( 'store', {
+			reducer: ( state = null, action ) => {
+				if ( action.type === 'RECEIVE' ) {
+					return action.items;
+				}
+
+				return state;
+			},
+			selectors: {
+				getFoo: ( state ) => state,
+			},
+			resolvers: {
+				getFoo: () => {},
+			},
+		} );
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeFalsy();
+
+		registry.select( 'store' ).getFoo();
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeFalsy();
+	} );
+
+	it( 'returns true if the resolution has failed', async () => {
+		registry.registerStore( 'store', {
+			reducer: ( state = null, action ) => {
+				if ( action.type === 'RECEIVE' ) {
+					return action.items;
+				}
+
+				return state;
+			},
+			selectors: {
+				getFoo: ( state ) => state,
+			},
+			resolvers: {
+				getFoo: () => {
+					throw new Error( 'cannot fetch items' );
+				},
+			},
+		} );
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeFalsy();
+
+		await resolve( registry, 'getFoo' );
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeTruthy();
+	} );
+
+	it( 'returns true if the resolution has failed even if the error is falsy', async () => {
+		registry.registerStore( 'store', {
+			reducer: ( state = null, action ) => {
+				if ( action.type === 'RECEIVE' ) {
+					return action.items;
+				}
+
+				return state;
+			},
+			selectors: {
+				getFoo: ( state ) => state,
+			},
+			resolvers: {
+				getFoo: () => {
+					throw null;
+				},
+			},
+		} );
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeFalsy();
+
+		await resolve( registry, 'getFoo' );
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeTruthy();
+	} );
+} );
+
+describe( 'getResolutionError', () => {
+	let registry;
+	let shouldFail;
+
+	beforeEach( () => {
+		shouldFail = false;
+		registry = createRegistry();
+
+		registry.registerStore( 'store', {
+			reducer: ( state = null, action ) => {
+				if ( action.type === 'RECEIVE' ) {
+					return action.items;
+				}
+
+				return state;
+			},
+			selectors: {
+				getFoo: ( state ) => state,
+			},
+			resolvers: {
+				getFoo: () => {
+					if ( shouldFail ) {
+						throw new Error( 'cannot fetch items' );
+					}
+				},
+			},
+		} );
+	} );
+
+	it( 'returns undefined if the resolution has succeeded', async () => {
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+
+		registry.select( 'store' ).getFoo();
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+	} );
+
+	it( 'returns error if the resolution has failed', async () => {
+		shouldFail = true;
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+
+		await resolve( registry, 'getFoo' );
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' ).toString()
+		).toBe( 'Error: cannot fetch items' );
+	} );
+
+	it( 'returns undefined if the failed resolution succeeded after retry', async () => {
+		shouldFail = true;
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+
+		await resolve( registry, 'getFoo' );
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeTruthy();
+
+		registry.dispatch( 'store' ).invalidateResolution( 'getFoo', [] );
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+
+		shouldFail = false;
+		registry.select( 'store' ).getFoo();
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+	} );
+} );

package/src/redux-store/metadata/test/utils.js

@@ -1,7 +1,7 @@
 /**
  * Internal dependencies
  */
-import { onSubKey } from '../utils';
+import { selectorArgsToStateKey, onSubKey } from '../utils';
 
 describe( 'onSubKey', () => {
 	function createEnhancedReducer( actionProperty ) {
@@ -39,3 +39,30 @@ describe( 'onSubKey', () => {
 		} );
 	} );
 } );
+
+describe( 'selectorArgsToStateKey', () => {
+	it( 'should default to an empty array', () => {
+		expect( selectorArgsToStateKey( undefined ) ).toEqual( [] );
+	} );
+
+	it( 'should remove trailing undefined values', () => {
+		expect( selectorArgsToStateKey( [ 1, 2, undefined ] ) ).toEqual( [
+			1,
+			2,
+		] );
+		expect(
+			selectorArgsToStateKey( [ 1, 2, undefined, undefined ] )
+		).toEqual( [ 1, 2 ] );
+	} );
+
+	it( 'should leave non-trailing undefined values alone', () => {
+		expect(
+			selectorArgsToStateKey( [ 1, undefined, 2, undefined ] )
+		).toEqual( [ 1, undefined, 2 ] );
+	} );
+
+	it( 'should return already normalized array unchanged', () => {
+		const args = [ 1, 2, 3 ];
+		expect( selectorArgsToStateKey( args ) ).toBe( args );
+	} );
+} );

package/src/redux-store/metadata/utils.ts

@@ -0,0 +1,59 @@
+/**
+ * External dependencies
+ */
+import type { AnyAction, Reducer } from 'redux';
+
+/**
+ * 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 = < TState extends unknown, TAction extends AnyAction >(
+	actionProperty: string
+) => (
+	reducer: Reducer< TState, TAction >
+): Reducer< Record< string, TState >, TAction > => (
+	state: Record< string, TState > = {},
+	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: unknown[] | null | undefined ) {
+	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 );
+}

package/src/redux-store/test/index.js

@@ -235,3 +235,45 @@ describe( 'controls', () => {
 		} );
 	} );
 } );
+
+describe( 'resolveSelect', () => {
+	let registry;
+	let shouldFail;
+
+	beforeEach( () => {
+		shouldFail = false;
+		registry = createRegistry();
+
+		registry.registerStore( 'store', {
+			reducer: ( state = null ) => {
+				return state;
+			},
+			selectors: {
+				getItems: () => 'items',
+			},
+			resolvers: {
+				getItems: () => {
+					if ( shouldFail ) {
+						throw new Error( 'cannot fetch items' );
+					}
+				},
+			},
+		} );
+	} );
+
+	it( 'resolves when the resolution succeeded', async () => {
+		shouldFail = false;
+		const promise = registry.resolveSelect( 'store' ).getItems();
+		jest.runAllTimers();
+		await expect( promise ).resolves.toEqual( 'items' );
+	} );
+
+	it( 'rejects when the resolution failed', async () => {
+		shouldFail = true;
+		const promise = registry.resolveSelect( 'store' ).getItems();
+		jest.runAllTimers();
+		await expect( promise ).rejects.toEqual(
+			new Error( 'cannot fetch items' )
+		);
+	} );
+} );

package/src/registry.js

@@ -150,7 +150,6 @@ export function createRegistry( storeConfigs = {}, parent = null ) {
 	//
 	// Deprecated
 	// TODO: Remove this after `use()` is removed.
-	//
 	function withPlugins( attributes ) {
 		return mapValues( attributes, ( attribute, key ) => {
 			if ( typeof attribute !== 'function' ) {
@@ -289,7 +288,6 @@ export function createRegistry( storeConfigs = {}, parent = null ) {
 	//
 	// TODO:
 	// This function will be deprecated as soon as it is no longer internally referenced.
-	//
 	function use( plugin, options ) {
 		if ( ! plugin ) {
 			return;

package/src/resolvers-cache-middleware.js

@@ -38,10 +38,11 @@ const createResolversCacheMiddleware = ( registry, reducerKey ) => () => (
 			}
 			resolversByArgs.forEach( ( value, args ) => {
 				// resolversByArgs is the map Map([ args ] => boolean) storing the cache resolution status for a given selector.
-				// If the value is false it means this resolver has finished its resolution which means we need to invalidate it,
-				// if it's true it means it's inflight and the invalidation is not necessary.
+				// If the value is "finished" or "error" it means this resolver has finished its resolution which means we need
+				// to invalidate it, if it's true it means it's inflight and the invalidation is not necessary.
 				if (
-					value !== false ||
+					( value?.status !== 'finished' &&
+						value?.status !== 'error' ) ||
 					! resolver.shouldInvalidate( action, ...args )
 				) {
 					return;

package/src/test/controls.js

@@ -6,7 +6,7 @@ import { createRegistry, controls } from '..';
 jest.useRealTimers();
 
 describe( 'controls', () => {
-	// create a registry with store to test select controls
+	// Create a registry with store to test select controls.
 	function createSelectTestRegistry() {
 		const registry = createRegistry();
 
@@ -21,13 +21,13 @@ describe( 'controls', () => {
 			}
 		};
 
-		// Select state both without and with a resolver
+		// Select state both without and with a resolver.
 		const selectors = {
 			selectorWithoutResolver: ( state ) => state,
 			selectorWithResolver: ( state ) => state,
 		};
 
-		// The resolver receives data after a little delay
+		// The resolver receives data after a little delay.
 		const resolvers = {
 			*selectorWithResolver() {
 				yield new Promise( ( r ) => setTimeout( r, 10 ) );
@@ -35,7 +35,7 @@ describe( 'controls', () => {
 			},
 		};
 
-		// actions that call the tested controls and return the selected value
+		// actions that call the tested controls and return the selected value.
 		const actions = {
 			*resolveWithoutResolver() {
 				const value = yield controls.resolveSelect(
@@ -130,7 +130,7 @@ describe( 'controls', () => {
 		function createDispatchTestRegistry() {
 			const registry = createRegistry();
 
-			// store stores a counter that can be incremented
+			// Store stores a counter that can be incremented.
 			const reducer = ( state = 0, action ) => {
 				switch ( action.type ) {
 					case 'INC':
@@ -141,11 +141,11 @@ describe( 'controls', () => {
 			};
 
 			const actions = {
-				// increment the counter
+				// increment the counter.
 				inc() {
 					return { type: 'INC' };
 				},
-				// increment the counter twice in an async routine with controls
+				// Increment the counter twice in an async routine with controls.
 				*doubleInc() {
 					yield controls.dispatch( 'test/dispatch', 'inc' );
 					yield controls.dispatch( 'test/dispatch', 'inc' );

package/src/test/registry.js

@@ -467,7 +467,7 @@ describe( 'createRegistry', () => {
 			let promise = subscribeUntil(
 				() => registry.select( 'demo' ).getValue() === 'OK'
 			);
-			registry.select( 'demo' ).getValue(); // Triggers resolver switches to OK
+			registry.select( 'demo' ).getValue(); // Triggers resolver switches to OK.
 			jest.runAllTimers();
 			await promise;
 
@@ -477,7 +477,7 @@ describe( 'createRegistry', () => {
 			promise = subscribeUntil(
 				() => registry.select( 'demo' ).getValue() === 'NOTOK'
 			);
-			registry.select( 'demo' ).getValue(); // Triggers the resolver again and switch to NOTOK
+			registry.select( 'demo' ).getValue(); // Triggers the resolver again and switch to NOTOK.
 			jest.runAllTimers();
 			await promise;
 		} );
@@ -609,10 +609,10 @@ describe( 'createRegistry', () => {
 			} );
 			const action = { type: 'dummy' };
 
-			store.dispatch( action ); // increment the data by => data = 2
+			store.dispatch( action ); // Increment the data by => data = 2.
 			expect( incrementedValue ).toBe( 2 );
 
-			store.dispatch( action ); // increment the data by => data = 3
+			store.dispatch( action ); // Increment the data by => data = 3.
 			expect( incrementedValue ).toBe( 3 );
 
 			unsubscribe(); // Store subscribe to changes, the data variable stops upgrading.
@@ -685,7 +685,7 @@ describe( 'createRegistry', () => {
 					increment,
 				},
 			} );
-			// state = 1
+			// State = 1.
 			const dispatchResult = await registry
 				.dispatch( 'counter' )
 				.increment();
@@ -693,7 +693,7 @@ describe( 'createRegistry', () => {
 				type: 'increment',
 				count: 1,
 			} );
-			registry.dispatch( 'counter' ).increment( 4 ); // state = 5
+			registry.dispatch( 'counter' ).increment( 4 ); // State = 5.
 			expect( store.getState() ).toBe( 5 );
 		} );
 	} );

package/src/types.ts

@@ -49,9 +49,7 @@ export interface DataEmitter {
 	isPaused: boolean;
 }
 
-//
-// Type Helpers
-//
+// Type Helpers.
 
 type ActionCreatorsOf<
 	Config extends AnyConfig