@wordpress/data 6.5.0 → 6.6.0

package/src/plugins/persistence/index.js

@@ -1,7 +1,7 @@
 /**
  * External dependencies
  */
-import { merge, isPlainObject } from 'lodash';
+import { merge, isPlainObject, identity } from 'lodash';
 
 /**
  * Internal dependencies
@@ -300,40 +300,53 @@ export function migrateFeaturePreferencesToPreferencesStore(
 	}
 }
 
+/**
+ * Migrates an individual item inside the `preferences` object for a store.
+ *
+ * @param {Object}    persistence   The persistence interface.
+ * @param {Object}    migrate       An options object that contains details of the migration.
+ * @param {string}    migrate.from  The name of the store to migrate from.
+ * @param {string}    migrate.scope The scope in the preferences store to migrate to.
+ * @param {string}    key           The key in the preferences object to migrate.
+ * @param {?Function} convert       A function that converts preferences from one format to another.
+ */
 export function migrateIndividualPreferenceToPreferencesStore(
 	persistence,
-	sourceStoreName,
-	key
+	{ from: sourceStoreName, scope },
+	key,
+	convert = identity
 ) {
 	const preferencesStoreName = 'core/preferences';
 	const state = persistence.get();
 	const sourcePreference = state[ sourceStoreName ]?.preferences?.[ key ];
 
 	// There's nothing to migrate, exit early.
-	if ( ! sourcePreference ) {
+	if ( sourcePreference === undefined ) {
 		return;
 	}
 
 	const targetPreference =
-		state[ preferencesStoreName ]?.preferences?.[ sourceStoreName ]?.[
-			key
-		];
+		state[ preferencesStoreName ]?.preferences?.[ scope ]?.[ 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 ];
+	const otherScopes = state[ preferencesStoreName ]?.preferences;
+	const otherPreferences =
+		state[ preferencesStoreName ]?.preferences?.[ scope ];
+
+	// Pass an object with the key and value as this allows the convert
+	// function to convert to a data structure that has different keys.
+	const convertedPreferences = convert( { [ key ]: sourcePreference } );
 
 	persistence.set( preferencesStoreName, {
 		preferences: {
-			...allPreferences,
-			[ sourceStoreName ]: {
-				...targetPreferences,
-				[ key ]: sourcePreference,
+			...otherScopes,
+			[ scope ]: {
+				...otherPreferences,
+				...convertedPreferences,
 			},
 		},
 	} );
@@ -350,6 +363,57 @@ export function migrateIndividualPreferenceToPreferencesStore(
 	} );
 }
 
+/**
+ * Convert from:
+ * ```
+ * {
+ *     panels: {
+ *         tags: {
+ *             enabled: true,
+ *             opened: true,
+ *         },
+ *         permalinks: {
+ *             enabled: false,
+ *             opened: false,
+ *         },
+ *     },
+ * }
+ * ```
+ *
+ * to:
+ * {
+ *     inactivePanels: [
+ *         'permalinks',
+ *     ],
+ *     openPanels: [
+ *         'tags',
+ *     ],
+ * }
+ *
+ * @param {Object} preferences A preferences object.
+ *
+ * @return {Object} The converted data.
+ */
+export function convertEditPostPanels( preferences ) {
+	const panels = preferences?.panels ?? {};
+	return Object.keys( panels ).reduce(
+		( convertedData, panelName ) => {
+			const panel = panels[ panelName ];
+
+			if ( panel?.enabled === false ) {
+				convertedData.inactivePanels.push( panelName );
+			}
+
+			if ( panel?.opened === true ) {
+				convertedData.openPanels.push( panelName );
+			}
+
+			return convertedData;
+		},
+		{ inactivePanels: [], openPanels: [] }
+	);
+}
+
 export function migrateThirdPartyFeaturePreferencesToPreferencesStore(
 	persistence
 ) {
@@ -366,7 +430,7 @@ export function migrateThirdPartyFeaturePreferencesToPreferencesStore(
 			continue;
 		}
 
-		// Skip this scope if there are no features to migrates
+		// Skip this scope if there are no features to migrate.
 		const featuresToMigrate = interfaceScopes[ scope ];
 		if ( ! featuresToMigrate ) {
 			continue;
@@ -402,6 +466,125 @@ export function migrateThirdPartyFeaturePreferencesToPreferencesStore(
 	}
 }
 
+/**
+ * Migrates interface 'enableItems' data to the preferences store.
+ *
+ * The interface package stores this data in this format:
+ * ```js
+ * {
+ *     enableItems: {
+ *         singleEnableItems: {
+ * 	           complementaryArea: {
+ *                 'core/edit-post': 'edit-post/document',
+ *                 'core/edit-site': 'edit-site/global-styles',
+ *             }
+ *         },
+ *         multipleEnableItems: {
+ *             pinnedItems: {
+ *                 'core/edit-post': {
+ *                     'plugin-1': true,
+ *                 },
+ *                 'core/edit-site': {
+ *                     'plugin-2': true,
+ *                 },
+ *             },
+ *         }
+ *     }
+ * }
+ * ```
+ * and it should be migrated it to:
+ * ```js
+ * {
+ *     'core/edit-post': {
+ *         complementaryArea: 'edit-post/document',
+ *         pinnedItems: {
+ *             'plugin-1': true,
+ *         },
+ *     },
+ *     'core/edit-site': {
+ *         complementaryArea: 'edit-site/global-styles',
+ *         pinnedItems: {
+ *             'plugin-2': true,
+ *         },
+ *     },
+ * }
+ * ```
+ *
+ * @param {Object} persistence The persistence interface.
+ */
+export function migrateInterfaceEnableItemsToPreferencesStore( persistence ) {
+	const interfaceStoreName = 'core/interface';
+	const preferencesStoreName = 'core/preferences';
+	const state = persistence.get();
+	const sourceEnableItems = state[ interfaceStoreName ]?.enableItems;
+
+	// There's nothing to migrate, exit early.
+	if ( ! sourceEnableItems ) {
+		return;
+	}
+
+	const allPreferences = state[ preferencesStoreName ]?.preferences ?? {};
+
+	// First convert complementaryAreas into the right format.
+	// Use the existing preferences as the accumulator so that the data is
+	// merged.
+	const sourceComplementaryAreas =
+		sourceEnableItems?.singleEnableItems?.complementaryArea ?? {};
+
+	const convertedComplementaryAreas = Object.keys(
+		sourceComplementaryAreas
+	).reduce( ( accumulator, scope ) => {
+		const data = sourceComplementaryAreas[ scope ];
+
+		// Don't overwrite any existing data in the preferences store.
+		if ( accumulator[ scope ]?.complementaryArea ) {
+			return accumulator;
+		}
+
+		return {
+			...accumulator,
+			[ scope ]: {
+				...accumulator[ scope ],
+				complementaryArea: data,
+			},
+		};
+	}, allPreferences );
+
+	// Next feed the converted complementary areas back into a reducer that
+	// converts the pinned items, resulting in the fully migrated data.
+	const sourcePinnedItems =
+		sourceEnableItems?.multipleEnableItems?.pinnedItems ?? {};
+	const allConvertedData = Object.keys( sourcePinnedItems ).reduce(
+		( accumulator, scope ) => {
+			const data = sourcePinnedItems[ scope ];
+			// Don't overwrite any existing data in the preferences store.
+			if ( accumulator[ scope ]?.pinnedItems ) {
+				return accumulator;
+			}
+
+			return {
+				...accumulator,
+				[ scope ]: {
+					...accumulator[ scope ],
+					pinnedItems: data,
+				},
+			};
+		},
+		convertedComplementaryAreas
+	);
+
+	persistence.set( preferencesStoreName, {
+		preferences: allConvertedData,
+	} );
+
+	// Remove migrated preferences.
+	const otherInterfaceItems = state[ interfaceStoreName ];
+	persistence.set( interfaceStoreName, {
+		...otherInterfaceItems,
+		enableItems: undefined,
+	} );
+}
+
 persistencePlugin.__unstableMigrate = ( pluginOptions ) => {
 	const persistence = createPersistenceInterface( pluginOptions );
 
@@ -427,24 +610,36 @@ persistencePlugin.__unstableMigrate = ( pluginOptions ) => {
 	// Other ad-hoc preferences.
 	migrateIndividualPreferenceToPreferencesStore(
 		persistence,
-		'core/edit-post',
+		{ from: 'core/edit-post', scope: 'core/edit-post' },
 		'hiddenBlockTypes'
 	);
 	migrateIndividualPreferenceToPreferencesStore(
 		persistence,
-		'core/edit-post',
+		{ from: 'core/edit-post', scope: 'core/edit-post' },
 		'editorMode'
 	);
 	migrateIndividualPreferenceToPreferencesStore(
 		persistence,
-		'core/edit-post',
+		{ from: 'core/edit-post', scope: 'core/edit-post' },
 		'preferredStyleVariations'
 	);
 	migrateIndividualPreferenceToPreferencesStore(
 		persistence,
-		'core/edit-site',
+		{ from: 'core/edit-post', scope: 'core/edit-post' },
+		'panels',
+		convertEditPostPanels
+	);
+	migrateIndividualPreferenceToPreferencesStore(
+		persistence,
+		{ from: 'core/editor', scope: 'core/edit-post' },
+		'isPublishSidebarEnabled'
+	);
+	migrateIndividualPreferenceToPreferencesStore(
+		persistence,
+		{ from: 'core/edit-site', scope: 'core/edit-site' },
 		'editorMode'
 	);
+	migrateInterfaceEnableItemsToPreferencesStore( persistence );
 };
 
 export default persistencePlugin;

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

@@ -12,6 +12,8 @@ import plugin, {
 	migrateFeaturePreferencesToPreferencesStore,
 	migrateThirdPartyFeaturePreferencesToPreferencesStore,
 	migrateIndividualPreferenceToPreferencesStore,
+	convertEditPostPanels,
+	migrateInterfaceEnableItemsToPreferencesStore,
 } from '../';
 import objectStorage from '../storage/object';
 import { createRegistry } from '../../../';
@@ -692,7 +694,7 @@ describe( 'migrateIndividualPreferenceToPreferencesStore', () => {
 
 		migrateIndividualPreferenceToPreferencesStore(
 			persistenceInterface,
-			'core/test',
+			{ from: 'core/test', scope: 'core/test' },
 			'myPreference'
 		);
 
@@ -741,7 +743,7 @@ describe( 'migrateIndividualPreferenceToPreferencesStore', () => {
 
 		migrateIndividualPreferenceToPreferencesStore(
 			persistenceInterface,
-			'core/test',
+			{ from: 'core/test', scope: 'core/test' },
 			'myPreference'
 		);
 
@@ -769,6 +771,41 @@ describe( 'migrateIndividualPreferenceToPreferencesStore', () => {
 		} );
 	} );
 
+	it( 'supports moving data to a scope that is differently named to the source store', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
+
+		const initialState = {
+			preferences: {
+				myPreference: '123',
+			},
+		};
+
+		persistenceInterface.set( 'core/source', initialState );
+
+		migrateIndividualPreferenceToPreferencesStore(
+			persistenceInterface,
+			{ from: 'core/source', scope: 'core/destination' },
+			'myPreference'
+		);
+
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
+				preferences: {
+					'core/destination': {
+						myPreference: '123',
+					},
+				},
+			},
+			'core/source': {
+				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',
@@ -790,7 +827,7 @@ describe( 'migrateIndividualPreferenceToPreferencesStore', () => {
 
 		migrateIndividualPreferenceToPreferencesStore(
 			persistenceInterface,
-			'core/test',
+			{ from: 'core/test', scope: 'core/test' },
 			'myPreference'
 		);
 
@@ -809,6 +846,37 @@ describe( 'migrateIndividualPreferenceToPreferencesStore', () => {
 			},
 		} );
 	} );
+
+	it( 'migrates preferences that have a `false` value', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
+
+		persistenceInterface.set( 'core/test', {
+			preferences: {
+				myFalsePreference: false,
+			},
+		} );
+
+		migrateIndividualPreferenceToPreferencesStore(
+			persistenceInterface,
+			{ from: 'core/test', scope: 'core/test' },
+			'myFalsePreference'
+		);
+
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
+				preferences: {
+					'core/test': {
+						myFalsePreference: false,
+					},
+				},
+			},
+			'core/test': {
+				preferences: {},
+			},
+		} );
+	} );
 } );
 
 describe( 'migrateThirdPartyFeaturePreferencesToPreferencesStore', () => {
@@ -923,3 +991,165 @@ describe( 'migrateThirdPartyFeaturePreferencesToPreferencesStore', () => {
 		} );
 	} );
 } );
+
+describe( 'convertEditPostPanels', () => {
+	it( 'converts from one format to another', () => {
+		expect(
+			convertEditPostPanels( {
+				panels: {
+					tags: {
+						enabled: true,
+						opened: true,
+					},
+					permalinks: {
+						enabled: false,
+						opened: false,
+					},
+					categories: {
+						enabled: true,
+						opened: false,
+					},
+					excerpt: {
+						enabled: false,
+						opened: true,
+					},
+					discussion: {
+						enabled: false,
+					},
+					template: {
+						opened: true,
+					},
+				},
+			} )
+		).toEqual( {
+			inactivePanels: [ 'permalinks', 'excerpt', 'discussion' ],
+			openPanels: [ 'tags', 'excerpt', 'template' ],
+		} );
+	} );
+
+	it( 'returns empty arrays when there is no data to convert', () => {
+		expect( convertEditPostPanels( {} ) ).toEqual( {
+			inactivePanels: [],
+			openPanels: [],
+		} );
+	} );
+} );
+
+describe( 'migrateInterfaceEnableItemsToPreferencesStore', () => {
+	it( 'migrates enableItems to the preferences store', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
+
+		persistenceInterface.set( 'core/interface', {
+			enableItems: {
+				singleEnableItems: {
+					complementaryArea: {
+						'core/edit-post': 'edit-post/document',
+						'core/edit-site': 'edit-site/global-styles',
+					},
+				},
+				multipleEnableItems: {
+					pinnedItems: {
+						'core/edit-post': {
+							'plugin-1': true,
+						},
+						'core/edit-site': {
+							'plugin-2': true,
+						},
+					},
+				},
+			},
+		} );
+
+		migrateInterfaceEnableItemsToPreferencesStore( persistenceInterface );
+
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
+				preferences: {
+					'core/edit-post': {
+						complementaryArea: 'edit-post/document',
+						pinnedItems: {
+							'plugin-1': true,
+						},
+					},
+					'core/edit-site': {
+						complementaryArea: 'edit-site/global-styles',
+						pinnedItems: {
+							'plugin-2': true,
+						},
+					},
+				},
+			},
+			'core/interface': {
+				enableItems: undefined,
+			},
+		} );
+	} );
+
+	it( 'merges pinnedItems and complementaryAreas with existing preferences store data', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
+
+		persistenceInterface.set( 'core/interface', {
+			enableItems: {
+				singleEnableItems: {
+					complementaryArea: {
+						'core/edit-post': 'edit-post/document',
+						'core/edit-site': 'edit-site/global-styles',
+					},
+				},
+				multipleEnableItems: {
+					pinnedItems: {
+						'core/edit-post': {
+							'plugin-1': true,
+						},
+						'core/edit-site': {
+							'plugin-2': true,
+						},
+					},
+				},
+			},
+		} );
+
+		persistenceInterface.set( 'core/preferences', {
+			preferences: {
+				'core/edit-post': {
+					preferenceA: 1,
+					preferenceB: 2,
+				},
+				'core/edit-site': {
+					preferenceC: true,
+				},
+			},
+		} );
+
+		migrateInterfaceEnableItemsToPreferencesStore( persistenceInterface );
+
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
+				preferences: {
+					'core/edit-post': {
+						preferenceA: 1,
+						preferenceB: 2,
+						complementaryArea: 'edit-post/document',
+						pinnedItems: {
+							'plugin-1': true,
+						},
+					},
+					'core/edit-site': {
+						preferenceC: true,
+						complementaryArea: 'edit-site/global-styles',
+						pinnedItems: {
+							'plugin-2': true,
+						},
+					},
+				},
+			},
+			'core/interface': {
+				enableItems: undefined,
+			},
+		} );
+	} );
+} );

package/src/redux-store/index.js

@@ -321,16 +321,26 @@ function mapActions( actions, store ) {
  * @return {Object} Selectors mapped to their resolution functions.
  */
 function mapResolveSelectors( selectors, store ) {
-	return mapValues(
-		omit( selectors, [
-			'getIsResolving',
-			'hasStartedResolution',
-			'hasFinishedResolution',
-			'isResolving',
-			'getCachedResolvers',
-		] ),
-		( selector, selectorName ) => ( ...args ) =>
-			new Promise( ( resolve, reject ) => {
+	const storeSelectors = omit( selectors, [
+		'getIsResolving',
+		'hasStartedResolution',
+		'hasFinishedResolution',
+		'hasResolutionFailed',
+		'isResolving',
+		'getCachedResolvers',
+		'getResolutionState',
+		'getResolutionError',
+	] );
+
+	return mapValues( storeSelectors, ( selector, selectorName ) => {
+		// If the selector doesn't have a resolver, just convert the return value
+		// (including exceptions) to a Promise, no additional extra behavior is needed.
+		if ( ! selector.hasResolver ) {
+			return async ( ...args ) => selector.apply( null, args );
+		}
+
+		return ( ...args ) => {
+			return new Promise( ( resolve, reject ) => {
 				const hasFinished = () =>
 					selectors.hasFinishedResolution( selectorName, args );
 				const finalize = ( result ) => {
@@ -361,8 +371,9 @@ function mapResolveSelectors( selectors, store ) {
 						finalize( getResult() );
 					}
 				} );
-			} )
-	);
+			} );
+		};
+	} );
 }
 
 /**

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

@@ -4,7 +4,7 @@
 import { createRegistry } from '../../registry';
 import { createRegistryControl } from '../../factory';
 
-jest.useFakeTimers();
+jest.useRealTimers();
 
 describe( 'controls', () => {
 	let registry;
@@ -90,7 +90,6 @@ describe( 'controls', () => {
 			} );
 
 			registry.select( 'store' ).getItems();
-			jest.runAllTimers();
 		} );
 	} );
 	describe( 'selectors have expected value for the `hasResolver` property', () => {
@@ -250,6 +249,7 @@ describe( 'resolveSelect', () => {
 			},
 			selectors: {
 				getItems: () => 'items',
+				getItemsNoResolver: () => 'items-no-resolver',
 			},
 			resolvers: {
 				getItems: () => {
@@ -264,16 +264,26 @@ describe( 'resolveSelect', () => {
 	it( 'resolves when the resolution succeeded', async () => {
 		shouldFail = false;
 		const promise = registry.resolveSelect( 'store' ).getItems();
-		jest.runAllTimers();
-		await expect( promise ).resolves.toEqual( 'items' );
+		await expect( promise ).resolves.toBe( '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' )
 		);
 	} );
+
+	it( 'resolves when calling a sync selector without resolver', async () => {
+		const promise = registry.resolveSelect( 'store' ).getItemsNoResolver();
+		await expect( promise ).resolves.toBe( 'items-no-resolver' );
+	} );
+
+	it( 'returns only store native selectors and excludes all meta ones', () => {
+		expect( Object.keys( registry.resolveSelect( 'store' ) ) ).toEqual( [
+			'getItems',
+			'getItemsNoResolver',
+		] );
+	} );
 } );