@wordpress/core-data 6.18.0 → 6.19.0

package/src/test/reducer.js

@@ -9,7 +9,6 @@ import deepFreeze from 'deep-freeze';
 import {
 	terms,
 	entities,
-	undo,
 	embedPreviews,
 	userPermissions,
 	autosaves,
@@ -142,238 +141,6 @@ describe( 'entities', () => {
 	} );
 } );
 
-describe( 'undo', () => {
-	let lastValues;
-	let undoState;
-	let expectedUndoState;
-
-	const createExpectedDiff = ( property, { from, to } ) => ( {
-		kind: 'someKind',
-		name: 'someName',
-		recordId: 'someRecordId',
-		property,
-		from,
-		to,
-	} );
-	const createNextEditAction = ( edits, isCached ) => {
-		let action = {
-			kind: 'someKind',
-			name: 'someName',
-			recordId: 'someRecordId',
-			edits,
-		};
-		action = {
-			type: 'EDIT_ENTITY_RECORD',
-			...action,
-			meta: {
-				undo: {
-					isCached,
-					edits: lastValues,
-				},
-			},
-		};
-		lastValues = { ...lastValues, ...edits };
-		return action;
-	};
-	const createNextUndoState = ( ...args ) => {
-		let action = {};
-		if ( args[ 0 ] === 'isUndo' || args[ 0 ] === 'isRedo' ) {
-			// We need to "apply" the undo level here and build
-			// the action to move the offset.
-			const lastEdits =
-				undoState.list[
-					undoState.list.length -
-						( args[ 0 ] === 'isUndo' ? 1 : 0 ) +
-						undoState.offset
-				];
-			lastEdits.forEach( ( { property, from, to } ) => {
-				lastValues[ property ] = args[ 0 ] === 'isUndo' ? from : to;
-			} );
-			action = {
-				type: args[ 0 ] === 'isUndo' ? 'UNDO' : 'REDO',
-			};
-		} else if ( args[ 0 ] === 'isCreate' ) {
-			action = { type: 'CREATE_UNDO_LEVEL' };
-		} else if ( args.length ) {
-			action = createNextEditAction( ...args );
-		}
-		return deepFreeze( undo( undoState, action ) );
-	};
-	beforeEach( () => {
-		lastValues = {};
-		undoState = undefined;
-		expectedUndoState = { list: [], offset: 0 };
-	} );
-
-	it( 'initializes', () => {
-		expect( createNextUndoState() ).toEqual( expectedUndoState );
-	} );
-
-	it( 'stacks undo levels', () => {
-		undoState = createNextUndoState();
-
-		// Check that the first edit creates an undo level for the current state and
-		// one for the new one.
-		undoState = createNextUndoState( { value: 1 } );
-		expectedUndoState.list.push( [
-			createExpectedDiff( 'value', { from: undefined, to: 1 } ),
-		] );
-		expect( undoState ).toEqual( expectedUndoState );
-
-		// Check that the second and third edits just create an undo level for
-		// themselves.
-		undoState = createNextUndoState( { value: 2 } );
-		expectedUndoState.list.push( [
-			createExpectedDiff( 'value', { from: 1, to: 2 } ),
-		] );
-		expect( undoState ).toEqual( expectedUndoState );
-		undoState = createNextUndoState( { value: 3 } );
-		expectedUndoState.list.push( [
-			createExpectedDiff( 'value', { from: 2, to: 3 } ),
-		] );
-		expect( undoState ).toEqual( expectedUndoState );
-	} );
-
-	it( 'stacks multi-property undo levels', () => {
-		undoState = createNextUndoState();
-
-		undoState = createNextUndoState( { value: 1 } );
-		undoState = createNextUndoState( { value2: 2 } );
-		expectedUndoState.list.push(
-			[ createExpectedDiff( 'value', { from: undefined, to: 1 } ) ],
-			[ createExpectedDiff( 'value2', { from: undefined, to: 2 } ) ]
-		);
-		expect( undoState ).toEqual( expectedUndoState );
-
-		// Check that that creating another undo level merges the "edits"
-		undoState = createNextUndoState( { value: 2 } );
-		expectedUndoState.list.push( [
-			createExpectedDiff( 'value', { from: 1, to: 2 } ),
-		] );
-		expect( undoState ).toEqual( expectedUndoState );
-	} );
-
-	it( 'handles undos/redos', () => {
-		undoState = createNextUndoState();
-		undoState = createNextUndoState( { value: 1 } );
-		undoState = createNextUndoState( { value: 2 } );
-		undoState = createNextUndoState( { value: 3 } );
-		expectedUndoState.list.push(
-			[ createExpectedDiff( 'value', { from: undefined, to: 1 } ) ],
-			[ createExpectedDiff( 'value', { from: 1, to: 2 } ) ],
-			[ createExpectedDiff( 'value', { from: 2, to: 3 } ) ]
-		);
-		expect( undoState ).toEqual( expectedUndoState );
-
-		// Check that undoing and redoing an equal
-		// number of steps does not lose edits.
-		undoState = createNextUndoState( 'isUndo' );
-		expectedUndoState.offset--;
-		expect( undoState ).toEqual( expectedUndoState );
-		undoState = createNextUndoState( 'isUndo' );
-		expectedUndoState.offset--;
-		expect( undoState ).toEqual( expectedUndoState );
-		undoState = createNextUndoState( 'isRedo' );
-		expectedUndoState.offset++;
-		expect( undoState ).toEqual( expectedUndoState );
-		undoState = createNextUndoState( 'isRedo' );
-		expectedUndoState.offset++;
-		expect( undoState ).toEqual( expectedUndoState );
-
-		// Check that another edit will go on top when there
-		// is no undo level offset.
-		undoState = createNextUndoState( { value: 4 } );
-		expectedUndoState.list.push( [
-			createExpectedDiff( 'value', { from: 3, to: 4 } ),
-		] );
-		expect( undoState ).toEqual( expectedUndoState );
-
-		// Check that undoing and editing will slice of
-		// all the levels after the current one.
-		undoState = createNextUndoState( 'isUndo' );
-		undoState = createNextUndoState( 'isUndo' );
-
-		undoState = createNextUndoState( { value: 5 } );
-		expectedUndoState.list.pop();
-		expectedUndoState.list.pop();
-		expectedUndoState.list.push( [
-			createExpectedDiff( 'value', { from: 2, to: 5 } ),
-		] );
-		expect( undoState ).toEqual( expectedUndoState );
-	} );
-
-	it( 'handles flattened undos/redos', () => {
-		undoState = createNextUndoState();
-		undoState = createNextUndoState( { value: 1 } );
-		undoState = createNextUndoState( { transientValue: 2 }, true );
-		undoState = createNextUndoState( { value: 3 } );
-		expectedUndoState.list.push(
-			[
-				createExpectedDiff( 'value', { from: undefined, to: 1 } ),
-				createExpectedDiff( 'transientValue', {
-					from: undefined,
-					to: 2,
-				} ),
-			],
-			[ createExpectedDiff( 'value', { from: 1, to: 3 } ) ]
-		);
-		expect( undoState ).toEqual( expectedUndoState );
-	} );
-
-	it( 'handles explicit undo level creation', () => {
-		undoState = createNextUndoState();
-
-		// Check that nothing happens if there are no pending
-		// transient edits.
-		undoState = createNextUndoState( { value: 1 } );
-		undoState = createNextUndoState( 'isCreate' );
-		expectedUndoState.list.push( [
-			createExpectedDiff( 'value', { from: undefined, to: 1 } ),
-		] );
-		expect( undoState ).toEqual( expectedUndoState );
-
-		// Check that transient edits are merged into the last
-		// edits.
-		undoState = createNextUndoState( { transientValue: 2 }, true );
-		undoState = createNextUndoState( 'isCreate' );
-		expectedUndoState.list[ expectedUndoState.list.length - 1 ].push(
-			createExpectedDiff( 'transientValue', { from: undefined, to: 2 } )
-		);
-		expect( undoState ).toEqual( expectedUndoState );
-
-		// Check that create after undo does nothing.
-		undoState = createNextUndoState( { value: 3 } );
-		undoState = createNextUndoState( 'isUndo' );
-		undoState = createNextUndoState( 'isCreate' );
-		expectedUndoState.list.push( [
-			createExpectedDiff( 'value', { from: 1, to: 3 } ),
-		] );
-		expectedUndoState.offset = -1;
-		expect( undoState ).toEqual( expectedUndoState );
-	} );
-
-	it( 'explicitly creates an undo level when undoing while there are pending transient edits', () => {
-		undoState = createNextUndoState();
-		undoState = createNextUndoState( { value: 1 } );
-		undoState = createNextUndoState( { transientValue: 2 }, true );
-		undoState = createNextUndoState( 'isUndo' );
-		expectedUndoState.list.push( [
-			createExpectedDiff( 'value', { from: undefined, to: 1 } ),
-			createExpectedDiff( 'transientValue', { from: undefined, to: 2 } ),
-		] );
-		expectedUndoState.offset--;
-		expect( undoState ).toEqual( expectedUndoState );
-	} );
-
-	it( 'does not create new levels for the same function edits', () => {
-		const value = () => {};
-		undoState = createNextUndoState();
-		undoState = createNextUndoState( { value } );
-		undoState = createNextUndoState( { value: () => {} } );
-		expect( undoState ).toEqual( expectedUndoState );
-	} );
-} );
-
 describe( 'embedPreviews()', () => {
 	it( 'returns an empty object by default', () => {
 		const state = embedPreviews( undefined, {} );

package/src/test/selectors.js

@@ -22,7 +22,6 @@ import {
 	getAutosave,
 	getAutosaves,
 	getCurrentUser,
-	getReferenceByDistinctEdits,
 } from '../selectors';
 // getEntityRecord and __experimentalGetEntityRecordNoResolver selectors share the same tests.
 describe.each( [
@@ -835,56 +834,3 @@ describe( 'getCurrentUser', () => {
 		expect( getCurrentUser( state ) ).toEqual( currentUser );
 	} );
 } );
-
-describe( 'getReferenceByDistinctEdits', () => {
-	it( 'should return referentially equal values across empty states', () => {
-		const state = { undo: { list: [] } };
-		expect( getReferenceByDistinctEdits( state ) ).toBe(
-			getReferenceByDistinctEdits( state )
-		);
-
-		const beforeState = { undo: { list: [] } };
-		const afterState = { undo: { list: [] } };
-		expect( getReferenceByDistinctEdits( beforeState ) ).toBe(
-			getReferenceByDistinctEdits( afterState )
-		);
-	} );
-
-	it( 'should return referentially equal values across unchanging non-empty state', () => {
-		const undoStates = { list: [ {} ] };
-		const state = { undo: undoStates };
-		expect( getReferenceByDistinctEdits( state ) ).toBe(
-			getReferenceByDistinctEdits( state )
-		);
-
-		const beforeState = { undo: undoStates };
-		const afterState = { undo: undoStates };
-		expect( getReferenceByDistinctEdits( beforeState ) ).toBe(
-			getReferenceByDistinctEdits( afterState )
-		);
-	} );
-
-	describe( 'when adding edits', () => {
-		it( 'should return referentially different values across changing states', () => {
-			const beforeState = { undo: { list: [ {} ] } };
-			beforeState.undo.offset = 0;
-			const afterState = { undo: { list: [ {}, {} ] } };
-			afterState.undo.offset = 1;
-			expect( getReferenceByDistinctEdits( beforeState ) ).not.toBe(
-				getReferenceByDistinctEdits( afterState )
-			);
-		} );
-	} );
-
-	describe( 'when using undo', () => {
-		it( 'should return referentially different values across changing states', () => {
-			const beforeState = { undo: { list: [ {}, {} ] } };
-			beforeState.undo.offset = 1;
-			const afterState = { undo: { list: [ {}, {} ] } };
-			afterState.undo.offset = 0;
-			expect( getReferenceByDistinctEdits( beforeState ) ).not.toBe(
-				getReferenceByDistinctEdits( afterState )
-			);
-		} );
-	} );
-} );

package/src/utils/get-nested-value.js

@@ -0,0 +1,27 @@
+/**
+ * Helper util to return a value from a certain path of the object.
+ * Path is specified as either:
+ * - a string of properties, separated by dots, for example: "x.y".
+ * - an array of properties, for example `[ 'x', 'y' ]`.
+ * You can also specify a default value in case the result is nullish.
+ *
+ * @param {Object}       object       Input object.
+ * @param {string|Array} path         Path to the object property.
+ * @param {*}            defaultValue Default value if the value at the specified path is undefined.
+ * @return {*} Value of the object property at the specified path.
+ */
+export default function getNestedValue( object, path, defaultValue ) {
+	if (
+		! object ||
+		typeof object !== 'object' ||
+		( typeof path !== 'string' && ! Array.isArray( path ) )
+	) {
+		return object;
+	}
+	const normalizedPath = Array.isArray( path ) ? path : path.split( '.' );
+	let value = object;
+	normalizedPath.forEach( ( fieldName ) => {
+		value = value?.[ fieldName ];
+	} );
+	return value !== undefined ? value : defaultValue;
+}

package/src/utils/index.js

@@ -7,3 +7,4 @@ export { default as replaceAction } from './replace-action';
 export { default as withWeakMapCache } from './with-weak-map-cache';
 export { default as isRawAttribute } from './is-raw-attribute';
 export { default as setNestedValue } from './set-nested-value';
+export { default as getNestedValue } from './get-nested-value';

package/src/utils/set-nested-value.js

@@ -4,6 +4,10 @@
  * Arrays are created for missing index properties while objects are created
  * for all other missing properties.
  *
+ * Path is specified as either:
+ * - a string of properties, separated by dots, for example: "x.y".
+ * - an array of properties, for example `[ 'x', 'y' ]`.
+ *
  * This function intentionally mutates the input object.
  *
  * Inspired by _.set().
@@ -12,24 +16,26 @@
  *
  * @todo Needs to be deduplicated with its copy in `@wordpress/edit-site`.
  *
- * @param {Object} object Object to modify
- * @param {Array}  path   Path of the property to set.
- * @param {*}      value  Value to set.
+ * @param {Object}       object Object to modify
+ * @param {Array|string} path   Path of the property to set.
+ * @param {*}            value  Value to set.
  */
 export default function setNestedValue( object, path, value ) {
 	if ( ! object || typeof object !== 'object' ) {
 		return object;
 	}
 
-	path.reduce( ( acc, key, idx ) => {
+	const normalizedPath = Array.isArray( path ) ? path : path.split( '.' );
+
+	normalizedPath.reduce( ( acc, key, idx ) => {
 		if ( acc[ key ] === undefined ) {
-			if ( Number.isInteger( path[ idx + 1 ] ) ) {
+			if ( Number.isInteger( normalizedPath[ idx + 1 ] ) ) {
 				acc[ key ] = [];
 			} else {
 				acc[ key ] = {};
 			}
 		}
-		if ( idx === path.length - 1 ) {
+		if ( idx === normalizedPath.length - 1 ) {
 			acc[ key ] = value;
 		}
 		return acc[ key ];

package/src/utils/test/get-nested-value.js

@@ -0,0 +1,61 @@
+/**
+ * Internal dependencies
+ */
+import getNestedValue from '../get-nested-value';
+
+describe( 'getNestedValue', () => {
+	it( 'should return the same object unmodified if path is an empty array', () => {
+		const input = { x: 'y' };
+		const result = getNestedValue( input, [] );
+		expect( result ).toEqual( input );
+	} );
+
+	it( 'should return the nested value', () => {
+		const input = { x: { y: { z: 123 } } };
+		const result = getNestedValue( input, [ 'x', 'y', 'z' ] );
+
+		expect( result ).toEqual( 123 );
+	} );
+
+	it( 'should return the nested value if the path is a string', () => {
+		const input = { x: { y: { z: 123 } } };
+		const result = getNestedValue( input, 'x.y.z' );
+
+		expect( result ).toEqual( 123 );
+	} );
+
+	it( 'should return the shallow value', () => {
+		const input = { x: { y: { z: 123 } } };
+		const result = getNestedValue( input, 'x' );
+
+		expect( result ).toEqual( { y: { z: 123 } } );
+	} );
+
+	it( 'should return the default value if the nested value is undefined', () => {
+		const input = { x: { y: { z: undefined } } };
+		const result = getNestedValue( input, [ 'x', 'y', 'z' ], 456 );
+
+		expect( result ).toEqual( 456 );
+	} );
+
+	it( 'should return the nested value if it is different to undefined', () => {
+		const input = { x: { y: { z: null } } };
+		const result = getNestedValue( input, 'x.y.z', 456 );
+
+		expect( result ).toBeNull();
+	} );
+
+	it( 'should return the default value if the nested value does not exist', () => {
+		const input = { x: { y: { z: 123 } } };
+		const result = getNestedValue( input, [ 'x', 'y', 'z1' ], 456 );
+
+		expect( result ).toEqual( 456 );
+	} );
+
+	it( 'should return undefined if the nested value does not exist', () => {
+		const input = { x: { y: { z: 123 } } };
+		const result = getNestedValue( input, [ 'x', 'y', 'z1' ] );
+
+		expect( result ).toBeUndefined();
+	} );
+} );

package/src/utils/test/set-nested-value.js

@@ -19,6 +19,13 @@ describe( 'setNestedValue', () => {
 		expect( result ).toEqual( { x: { y: { z: 456 } } } );
 	} );
 
+	it( 'should set values at deep level having a string as path', () => {
+		const input = { x: { y: { z: 123 } } };
+		const result = setNestedValue( input, 'x.y.z', 456 );
+
+		expect( result ).toEqual( { x: { y: { z: 456 } } } );
+	} );
+
 	it( 'should create nested objects if necessary', () => {
 		const result = setNestedValue( {}, [ 'x', 'y', 'z' ], 123 );
 

package/tsconfig.json

@@ -19,6 +19,7 @@
 		{ "path": "../is-shallow-equal" },
 		{ "path": "../private-apis" },
 		{ "path": "../sync" },
+		{ "path": "../undo-manager" },
 		{ "path": "../url" }
 	],
 	"include": [ "src/**/*" ]