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

package/src/factory.js

@@ -36,7 +36,7 @@
  * @return {Function} Registry selector that can be registered with a store.
  */
 export function createRegistrySelector( registrySelector ) {
-	// create a selector function that is bound to the registry referenced by `selector.registry`
+	// Create a selector function that is bound to the registry referenced by `selector.registry`
 	// and that has the same API as a regular selector. Binding it in such a way makes it
 	// possible to call the selector directly from another selector.
 	const selector = ( ...args ) =>

package/src/plugins/persistence/index.js

@@ -222,6 +222,128 @@ function persistencePlugin( registry, pluginOptions ) {
 	};
 }
 
+/**
+ * Move the 'features' object in local storage from the sourceStoreName to the
+ * preferences store.
+ *
+ * @param {Object} persistence     The persistence interface.
+ * @param {string} sourceStoreName The name of the store that has persisted
+ *                                 preferences to migrate to the preferences
+ *                                 package.
+ */
+export function migrateFeaturePreferencesToPreferencesStore(
+	persistence,
+	sourceStoreName
+) {
+	const preferencesStoreName = 'core/preferences';
+	const interfaceStoreName = 'core/interface';
+
+	const state = persistence.get();
+
+	// Features most recently (and briefly) lived in the interface package.
+	// If data exists there, prioritize using that for the migration. If not
+	// also check the original package as the user may have updated from an
+	// older block editor version.
+	const interfaceFeatures =
+		state[ interfaceStoreName ]?.preferences?.features?.[ sourceStoreName ];
+	const sourceFeatures = state[ sourceStoreName ]?.preferences?.features;
+	const featuresToMigrate = interfaceFeatures
+		? interfaceFeatures
+		: sourceFeatures;
+
+	if ( featuresToMigrate ) {
+		const targetFeatures = state[ preferencesStoreName ]?.preferences;
+
+		// Avoid migrating features again if they've previously been migrated.
+		if ( ! targetFeatures?.[ sourceStoreName ] ) {
+			// Set the feature values in the interface store, the features
+			// object is keyed by 'scope', which matches the store name for
+			// the source.
+			persistence.set( preferencesStoreName, {
+				preferences: {
+					...targetFeatures,
+					[ sourceStoreName ]: featuresToMigrate,
+				},
+			} );
+
+			// Remove migrated feature preferences from `interface`.
+			if ( interfaceFeatures ) {
+				const otherInterfaceFeatures =
+					state[ interfaceStoreName ]?.preferences?.features;
+
+				persistence.set( interfaceStoreName, {
+					preferences: {
+						features: {
+							...otherInterfaceFeatures,
+							[ sourceStoreName ]: undefined,
+						},
+					},
+				} );
+			}
+
+			// Remove migrated feature preferences from the source.
+			if ( sourceFeatures ) {
+				const sourcePreferences = state[ sourceStoreName ]?.preferences;
+
+				persistence.set( sourceStoreName, {
+					preferences: {
+						...sourcePreferences,
+						features: undefined,
+					},
+				} );
+			}
+		}
+	}
+}
+
+export function migrateIndividualPreferenceToPreferencesStore(
+	persistence,
+	sourceStoreName,
+	key
+) {
+	const preferencesStoreName = 'core/preferences';
+	const state = persistence.get();
+	const sourcePreference = state[ sourceStoreName ]?.preferences?.[ key ];
+
+	// There's nothing to migrate, exit early.
+	if ( ! sourcePreference ) {
+		return;
+	}
+
+	const targetPreference =
+		state[ preferencesStoreName ]?.preferences?.[ sourceStoreName ]?.[
+			key
+		];
+
+	// There's existing data at the target, so don't overwrite it, exit early.
+	if ( targetPreference ) {
+		return;
+	}
+
+	const allPreferences = state[ preferencesStoreName ]?.preferences;
+	const targetPreferences =
+		state[ preferencesStoreName ]?.preferences?.[ sourceStoreName ];
+
+	persistence.set( preferencesStoreName, {
+		preferences: {
+			...allPreferences,
+			[ sourceStoreName ]: {
+				...targetPreferences,
+				[ key ]: sourcePreference,
+			},
+		},
+	} );
+
+	// Remove migrated feature preferences from the source.
+	const allSourcePreferences = state[ sourceStoreName ]?.preferences;
+	persistence.set( sourceStoreName, {
+		preferences: {
+			...allSourcePreferences,
+			[ key ]: undefined,
+		},
+	} );
+}
+
 /**
  * Move the 'features' object in local storage from the sourceStoreName to the
  * interface store.
@@ -269,23 +391,35 @@ export function migrateFeaturePreferencesToInterfaceStore(
 	}
 }
 
-/**
- * Deprecated: Remove this function and the code in WordPress Core that calls
- * it once WordPress 6.0 is released.
- */
-
 persistencePlugin.__unstableMigrate = ( pluginOptions ) => {
 	const persistence = createPersistenceInterface( pluginOptions );
 
-	migrateFeaturePreferencesToInterfaceStore(
+	migrateFeaturePreferencesToPreferencesStore(
 		persistence,
 		'core/edit-widgets'
 	);
-	migrateFeaturePreferencesToInterfaceStore(
+	migrateFeaturePreferencesToPreferencesStore(
 		persistence,
 		'core/customize-widgets'
 	);
-	migrateFeaturePreferencesToInterfaceStore( persistence, 'core/edit-post' );
+	migrateFeaturePreferencesToPreferencesStore(
+		persistence,
+		'core/edit-post'
+	);
+	migrateIndividualPreferenceToPreferencesStore(
+		persistence,
+		'core/edit-post',
+		'hiddenBlockTypes'
+	);
+	migrateFeaturePreferencesToPreferencesStore(
+		persistence,
+		'core/edit-site'
+	);
+	migrateIndividualPreferenceToPreferencesStore(
+		persistence,
+		'core/edit-site',
+		'editorMode'
+	);
 };
 
 export default persistencePlugin;

package/src/plugins/persistence/test/index.js

@@ -10,6 +10,8 @@ import plugin, {
 	createPersistenceInterface,
 	withLazySameState,
 	migrateFeaturePreferencesToInterfaceStore,
+	migrateFeaturePreferencesToPreferencesStore,
+	migrateIndividualPreferenceToPreferencesStore,
 } from '../';
 import objectStorage from '../storage/object';
 import { createRegistry } from '../../../';
@@ -492,4 +494,407 @@ describe( 'migrateFeaturePreferencesToInterfaceStore', () => {
 			},
 		} );
 	} );
+
+	describe( 'migrateFeaturePreferencesToPreferencesStore', () => {
+		it( 'migrates multiple preferences from persisted source stores to preferences', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const sourceStateA = {
+				preferences: {
+					features: {
+						featureA: true,
+						featureB: false,
+						featureC: true,
+					},
+				},
+			};
+
+			const sourceStateB = {
+				preferences: {
+					features: {
+						featureD: true,
+						featureE: false,
+						featureF: true,
+					},
+				},
+			};
+
+			persistenceInterface.set( 'core/test-a', sourceStateA );
+			persistenceInterface.set( 'core/test-b', sourceStateB );
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-a'
+			);
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-b'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test-a': {
+							featureA: true,
+							featureB: false,
+							featureC: true,
+						},
+						'core/test-b': {
+							featureD: true,
+							featureE: false,
+							featureF: true,
+						},
+					},
+				},
+				'core/test-a': {
+					preferences: {
+						features: undefined,
+					},
+				},
+				'core/test-b': {
+					preferences: {
+						features: undefined,
+					},
+				},
+			} );
+		} );
+
+		it( 'migrates multiple preferences from the persisted interface store to preferences, with interface state taking precedence over source stores', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const sourceStateA = {
+				preferences: {
+					features: {
+						featureA: true,
+						featureB: false,
+						featureC: true,
+					},
+				},
+			};
+
+			const sourceStateB = {
+				preferences: {
+					features: {
+						featureD: true,
+						featureE: false,
+						featureF: true,
+					},
+				},
+			};
+
+			const interfaceState = {
+				preferences: {
+					features: {
+						'core/test-a': {
+							featureG: true,
+							featureH: false,
+							featureI: true,
+						},
+						'core/test-b': {
+							featureJ: true,
+							featureK: false,
+							featureL: true,
+						},
+					},
+				},
+			};
+
+			persistenceInterface.set( 'core/test-a', sourceStateA );
+			persistenceInterface.set( 'core/test-b', sourceStateB );
+			persistenceInterface.set( 'core/interface', interfaceState );
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-a'
+			);
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-b'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test-a': {
+							featureG: true,
+							featureH: false,
+							featureI: true,
+						},
+						'core/test-b': {
+							featureJ: true,
+							featureK: false,
+							featureL: true,
+						},
+					},
+				},
+				'core/interface': {
+					preferences: {
+						features: {
+							'core/test-a': undefined,
+							'core/test-b': undefined,
+						},
+					},
+				},
+				'core/test-a': {
+					preferences: {
+						features: undefined,
+					},
+				},
+				'core/test-b': {
+					preferences: {
+						features: undefined,
+					},
+				},
+			} );
+		} );
+
+		it( 'only migrates persisted data for the source name from source stores', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const sourceStateA = {
+				preferences: {
+					features: {
+						featureA: true,
+						featureB: false,
+						featureC: true,
+					},
+				},
+			};
+
+			const sourceStateB = {
+				preferences: {
+					features: {
+						featureD: true,
+						featureE: false,
+						featureF: true,
+					},
+				},
+			};
+
+			persistenceInterface.set( 'core/test-a', sourceStateA );
+			persistenceInterface.set( 'core/test-b', sourceStateB );
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-a'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test-a': {
+							featureA: true,
+							featureB: false,
+							featureC: true,
+						},
+					},
+				},
+				'core/test-a': {
+					preferences: {
+						features: undefined,
+					},
+				},
+				'core/test-b': {
+					preferences: {
+						features: {
+							featureD: true,
+							featureE: false,
+							featureF: true,
+						},
+					},
+				},
+			} );
+		} );
+
+		it( 'only migrates persisted data for the source name from interface', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const interfaceState = {
+				preferences: {
+					features: {
+						'core/test-a': {
+							featureG: true,
+							featureH: false,
+							featureI: true,
+						},
+						'core/test-b': {
+							featureJ: true,
+							featureK: false,
+							featureL: true,
+						},
+					},
+				},
+			};
+
+			persistenceInterface.set( 'core/interface', interfaceState );
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-a'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test-a': {
+							featureG: true,
+							featureH: false,
+							featureI: true,
+						},
+					},
+				},
+				'core/interface': {
+					preferences: {
+						features: {
+							'core/test-a': undefined,
+							'core/test-b': {
+								featureJ: true,
+								featureK: false,
+								featureL: true,
+							},
+						},
+					},
+				},
+			} );
+		} );
+	} );
+
+	describe( 'migrateIndividualPreferenceToPreferencesStore', () => {
+		it( 'migrates an individual preference from the source to the preferences store', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const initialState = {
+				preferences: {
+					myPreference: '123',
+				},
+			};
+
+			persistenceInterface.set( 'core/test', initialState );
+
+			migrateIndividualPreferenceToPreferencesStore(
+				persistenceInterface,
+				'core/test',
+				'myPreference'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test': {
+							myPreference: '123',
+						},
+					},
+				},
+				'core/test': {
+					preferences: {
+						myPreference: undefined,
+					},
+				},
+			} );
+		} );
+
+		it( 'does not overwrite other preferences in the preferences store', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const initialState = {
+				preferences: {
+					myPreference: '123',
+				},
+			};
+
+			persistenceInterface.set( 'core/test', initialState );
+			persistenceInterface.set( 'core/preferences', {
+				preferences: {
+					'core/other-store': {
+						preferenceA: 1,
+						preferenceB: 2,
+					},
+					'core/test': {
+						unrelatedPreference: 'unrelated-value',
+					},
+				},
+			} );
+
+			migrateIndividualPreferenceToPreferencesStore(
+				persistenceInterface,
+				'core/test',
+				'myPreference'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/other-store': {
+							preferenceA: 1,
+							preferenceB: 2,
+						},
+						'core/test': {
+							unrelatedPreference: 'unrelated-value',
+							myPreference: '123',
+						},
+					},
+				},
+				'core/test': {
+					preferences: {
+						myPreference: undefined,
+					},
+				},
+			} );
+		} );
+
+		it( 'does not migrate data if there is already a matching preference key at the target', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			persistenceInterface.set( 'core/test', {
+				preferences: {
+					myPreference: '123',
+				},
+			} );
+
+			persistenceInterface.set( 'core/preferences', {
+				preferences: {
+					'core/test': {
+						myPreference: 'already-set',
+					},
+				},
+			} );
+
+			migrateIndividualPreferenceToPreferencesStore(
+				persistenceInterface,
+				'core/test',
+				'myPreference'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test': {
+							myPreference: 'already-set',
+						},
+					},
+				},
+				'core/test': {
+					preferences: {
+						myPreference: '123',
+					},
+				},
+			} );
+		} );
+	} );
 } );

package/src/redux-store/index.js

@@ -232,12 +232,9 @@ function instantiateReduxStore( key, options, registry, thunkArgs ) {
 		createResolversCacheMiddleware( registry, key ),
 		promise,
 		createReduxRoutineMiddleware( normalizedControls ),
+		createThunkMiddleware( thunkArgs ),
 	];
 
-	if ( options.__experimentalUseThunks ) {
-		middlewares.push( createThunkMiddleware( thunkArgs ) );
-	}
-
 	const enhancers = [ applyMiddleware( ...middlewares ) ];
 	if (
 		typeof window !== 'undefined' &&
@@ -333,20 +330,35 @@ function mapResolveSelectors( selectors, store ) {
 			'getCachedResolvers',
 		] ),
 		( selector, selectorName ) => ( ...args ) =>
-			new Promise( ( resolve ) => {
+			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)
+				// Trigger the selector (to trigger the resolver)
 				const result = getResult();
 				if ( hasFinished() ) {
-					return resolve( result );
+					return finalize( result );
 				}
 
 				const unsubscribe = store.subscribe( () => {
 					if ( hasFinished() ) {
 						unsubscribe();
-						resolve( getResult() );
+						finalize( getResult() );
 					}
 				} );
 			} )
@@ -373,8 +385,8 @@ function mapResolvers( resolvers, selectors, store, resolversCache ) {
 		}
 
 		return {
-			...resolver, // copy the enumerable properties of the resolver function
-			fulfill: resolver, // add the fulfill method
+			...resolver, // Copy the enumerable properties of the resolver function.
+			fulfill: resolver, // Add the fulfill method.
 		};
 	} );
 
@@ -416,15 +428,28 @@ function mapResolvers( resolvers, selectors, store, resolversCache ) {
 					store.dispatch(
 						metadataActions.startResolution( selectorName, args )
 					);
-					await fulfillResolver(
-						store,
-						mappedResolvers,
-						selectorName,
-						...args
-					);
-					store.dispatch(
-						metadataActions.finishResolution( selectorName, args )
-					);
+					try {
+						await fulfillResolver(
+							store,
+							mappedResolvers,
+							selectorName,
+							...args
+						);
+						store.dispatch(
+							metadataActions.finishResolution(
+								selectorName,
+								args
+							)
+						);
+					} catch ( error ) {
+						store.dispatch(
+							metadataActions.failResolution(
+								selectorName,
+								args,
+								error
+							)
+						);
+					}
 				} );
 			}