setImmutably: don't clone all objects

packages/block-editor/src/utils/object.js

@@ -4,27 +4,6 @@
 import { paramCase } from 'change-case';
 import memoize from 'memize';
 
-/**
- * Converts a path to an array of its fragments.
- * Supports strings, numbers and arrays:
- *
- * 'foo' => [ 'foo' ]
- * 2 => [ '2' ]
- * [ 'foo', 'bar' ] => [ 'foo', 'bar' ]
- *
- * @param {string|number|Array} path Path
- * @return {Array} Normalized path.
- */
-function normalizePath( path ) {
-	if ( Array.isArray( path ) ) {
-		return path;
-	} else if ( typeof path === 'number' ) {
-		return [ path.toString() ];
-	}
-
-	return [ path ];
-}
-
 /**
  * Converts any string to kebab case.
  * Backwards compatible with Lodash's `_.kebabCase()`.
@@ -55,33 +34,6 @@ export function kebabCase( str ) {
 	} );
 }
 
-/**
- * Clones an object.
- * Arrays are also cloned as arrays.
- * Non-object values are returned unchanged.
- *
- * @param {*} object Object to clone.
- * @return {*} Cloned object, or original literal non-object value.
- */
-function cloneObject( object ) {
-	if ( Array.isArray( object ) ) {
-		return object.map( cloneObject );
-	}
-
-	if ( object && typeof object === 'object' ) {
-		return {
-			...Object.fromEntries(
-				Object.entries( object ).map( ( [ key, value ] ) => [
-					key,
-					cloneObject( value ),
-				] )
-			),
-		};
-	}
-
-	return object;
-}
-
 /**
  * Immutably sets a value inside an object. Like `lodash#set`, but returning a
  * new object. Treats nullish initial values as empty objects. Clones any
@@ -93,24 +45,27 @@ function cloneObject( object ) {
  * @return {Object} Cloned object with the new value set.
  */
 export function setImmutably( object, path, value ) {
-	const normalizedPath = normalizePath( path );
-	const newObject = object ? cloneObject( object ) : {};
+	// Normalize path
+	path = Array.isArray( path ) ? path : [ path ];
 
-	normalizedPath.reduce( ( acc, key, i ) => {
-		if ( acc[ key ] === undefined ) {
-			if ( Number.isInteger( path[ i + 1 ] ) ) {
-				acc[ key ] = [];
-			} else {
-				acc[ key ] = {};
-			}
-		}
-		if ( i === normalizedPath.length - 1 ) {
-			acc[ key ] = value;
+	// Shallowly clone the base of the object
+	object = Array.isArray( object ) ? [ ...object ] : { ...object };
+
+	// Traverse object from root to leaf, shallowly cloning at each level
+	let prev = object;
+	for ( const i in path ) {
+		const branch = path[ i ];
+		if ( i < path.length - 1 ) {
+			prev[ branch ] = Array.isArray( prev[ branch ] )
+				? [ ...prev[ branch ] ]
+				: { ...prev[ branch ] };
+		} else {
+			prev[ branch ] = value;
 		}
-		return acc[ key ];
-	}, newObject );
+		prev = prev[ branch ];
+	}
 
-	return newObject;
+	return object;
 }
 
 const stringToPath = memoize( ( path ) => path.split( '.' ) );