@wordpress/block-editor 10.5.0 → 11.0.0

package/build-module/store/reducer.js

@@ -1,7 +1,8 @@
 /**
  * External dependencies
  */
-import { omit, mapValues, isEqual, isEmpty } from 'lodash';
+import fastDeepEqual from 'fast-deep-equal/es6';
+import { omit, isEmpty } from 'lodash';
 /**
  * WordPress dependencies
  */
@@ -31,16 +32,18 @@ const identity = x => x;
 
 function mapBlockOrder(blocks) {
   let rootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  const result = {
-    [rootClientId]: []
-  };
+  const result = new Map();
+  const current = [];
+  result.set(rootClientId, current);
   blocks.forEach(block => {
     const {
       clientId,
       innerBlocks
     } = block;
-    result[rootClientId].push(clientId);
-    Object.assign(result, mapBlockOrder(innerBlocks, clientId));
+    current.push(clientId);
+    mapBlockOrder(innerBlocks, clientId).forEach((order, subClientId) => {
+      result.set(subClientId, order);
+    });
   });
   return result;
 }
@@ -57,9 +60,25 @@ function mapBlockOrder(blocks) {
 
 function mapBlockParents(blocks) {
   let rootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  return blocks.reduce((result, block) => Object.assign(result, {
-    [block.clientId]: rootClientId
-  }, mapBlockParents(block.innerBlocks, block.clientId)), {});
+  const result = [];
+  const stack = [[rootClientId, blocks]];
+
+  while (stack.length) {
+    const [parent, currentBlocks] = stack.shift();
+    currentBlocks.forEach(_ref => {
+      let {
+        innerBlocks,
+        ...block
+      } = _ref;
+      result.push([block.clientId, parent]);
+
+      if (innerBlocks !== null && innerBlocks !== void 0 && innerBlocks.length) {
+        stack.push([block.clientId, innerBlocks]);
+      }
+    });
+  }
+
+  return result;
 }
 /**
  * Helper method to iterate through all blocks, recursing into inner blocks,
@@ -69,12 +88,28 @@ function mapBlockParents(blocks) {
  * @param {Array}    blocks    Blocks to flatten.
  * @param {Function} transform Transforming function to be applied to each block.
  *
- * @return {Object} Flattened object.
+ * @return {Array} Flattened object.
  */
 
 
 function flattenBlocks(blocks) {
   let transform = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
+  const result = [];
+  const stack = [...blocks];
+
+  while (stack.length) {
+    const {
+      innerBlocks,
+      ...block
+    } = stack.shift();
+    stack.push(...innerBlocks);
+    result.push([block.clientId, transform(block)]);
+  }
+
+  return result;
+}
+
+function getFlattenedClientIds(blocks) {
   const result = {};
   const stack = [...blocks];
 
@@ -84,7 +119,7 @@ function flattenBlocks(blocks) {
       ...block
     } = stack.shift();
     stack.push(...innerBlocks);
-    result[block.clientId] = transform(block);
+    result[block.clientId] = true;
   }
 
   return result;
@@ -96,7 +131,7 @@ function flattenBlocks(blocks) {
  *
  * @param {Array} blocks Blocks to flatten.
  *
- * @return {Object} Flattened block attributes object.
+ * @return {Array} Flattened block attributes object.
  */
 
 
@@ -110,32 +145,13 @@ function getFlattenedBlocksWithoutAttributes(blocks) {
  *
  * @param {Array} blocks Blocks to flatten.
  *
- * @return {Object} Flattened block attributes object.
+ * @return {Array} Flattened block attributes object.
  */
 
 
 function getFlattenedBlockAttributes(blocks) {
   return flattenBlocks(blocks, block => block.attributes);
 }
-/**
- * Returns an object against which it is safe to perform mutating operations,
- * given the original object and its current working copy.
- *
- * @param {Object} original Original object.
- * @param {Object} working  Working object.
- *
- * @return {Object} Mutation-safe object.
- */
-
-
-function getMutateSafeObject(original, working) {
-  if (original === working) {
-    return { ...original
-    };
-  }
-
-  return working;
-}
 /**
  * Returns true if the two object arguments have the same keys, or false
  * otherwise.
@@ -148,7 +164,7 @@ function getMutateSafeObject(original, working) {
 
 
 export function hasSameKeys(a, b) {
-  return isEqual(Object.keys(a), Object.keys(b));
+  return fastDeepEqual(Object.keys(a), Object.keys(b));
 }
 /**
  * Returns true if, given the currently dispatching action and the previously
@@ -162,11 +178,11 @@ export function hasSameKeys(a, b) {
  */
 
 export function isUpdatingSameBlockAttribute(action, lastAction) {
-  return action.type === 'UPDATE_BLOCK_ATTRIBUTES' && lastAction !== undefined && lastAction.type === 'UPDATE_BLOCK_ATTRIBUTES' && isEqual(action.clientIds, lastAction.clientIds) && hasSameKeys(action.attributes, lastAction.attributes);
+  return action.type === 'UPDATE_BLOCK_ATTRIBUTES' && lastAction !== undefined && lastAction.type === 'UPDATE_BLOCK_ATTRIBUTES' && fastDeepEqual(action.clientIds, lastAction.clientIds) && hasSameKeys(action.attributes, lastAction.attributes);
 }
 
-function buildBlockTree(state, blocks) {
-  const result = {};
+function updateBlockTreeForBlocks(state, blocks) {
+  const treeToUpdate = state.tree;
   const stack = [...blocks];
   const flattenedBlocks = [...blocks];
 
@@ -178,26 +194,25 @@ function buildBlockTree(state, blocks) {
 
 
   for (const block of flattenedBlocks) {
-    result[block.clientId] = {};
+    treeToUpdate.set(block.clientId, {});
   }
 
   for (const block of flattenedBlocks) {
-    result[block.clientId] = Object.assign(result[block.clientId], { ...state.byClientId[block.clientId],
-      attributes: state.attributes[block.clientId],
-      innerBlocks: block.innerBlocks.map(subBlock => result[subBlock.clientId])
-    });
+    treeToUpdate.set(block.clientId, Object.assign(treeToUpdate.get(block.clientId), { ...state.byClientId.get(block.clientId),
+      attributes: state.attributes.get(block.clientId),
+      innerBlocks: block.innerBlocks.map(subBlock => treeToUpdate.get(subBlock.clientId))
+    }));
   }
-
-  return result;
 }
 
-function updateParentInnerBlocksInTree(state, tree, updatedClientIds) {
-  let updateChildrenOfUpdatedClientIds = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+function updateParentInnerBlocksInTree(state, updatedClientIds) {
+  let updateChildrenOfUpdatedClientIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  const treeToUpdate = state.tree;
   const uncontrolledParents = new Set([]);
   const controlledParents = new Set();
 
   for (const clientId of updatedClientIds) {
-    let current = updateChildrenOfUpdatedClientIds ? clientId : state.parents[clientId];
+    let current = updateChildrenOfUpdatedClientIds ? clientId : state.parents.get(clientId);
 
     do {
       if (state.controlledInnerBlocks[current]) {
@@ -208,7 +223,7 @@ function updateParentInnerBlocksInTree(state, tree, updatedClientIds) {
       } else {
         // Else continue traversing up through parents.
         uncontrolledParents.add(current);
-        current = state.parents[current];
+        current = state.parents.get(current);
       }
     } while (current !== undefined);
   } // To make sure the order of assignments doesn't matter,
@@ -216,23 +231,21 @@ function updateParentInnerBlocksInTree(state, tree, updatedClientIds) {
 
 
   for (const clientId of uncontrolledParents) {
-    tree[clientId] = { ...tree[clientId]
-    };
+    treeToUpdate.set(clientId, { ...treeToUpdate.get(clientId)
+    });
   }
 
   for (const clientId of uncontrolledParents) {
-    tree[clientId].innerBlocks = (state.order[clientId] || []).map(subClientId => tree[subClientId]);
+    treeToUpdate.get(clientId).innerBlocks = (state.order.get(clientId) || []).map(subClientId => treeToUpdate.get(subClientId));
   } // Controlled parent blocks, need a dedicated key for their inner blocks
   // to be used when doing getBlocks( controlledBlockClientId ).
 
 
   for (const clientId of controlledParents) {
-    tree['controlled||' + clientId] = {
-      innerBlocks: (state.order[clientId] || []).map(subClientId => tree[subClientId])
-    };
+    treeToUpdate.set('controlled||' + clientId, {
+      innerBlocks: (state.order.get(clientId) || []).map(subClientId => treeToUpdate.get(subClientId))
+    });
   }
-
-  return tree;
 }
 /**
  * Higher-order reducer intended to compute full block objects key for each block in the post.
@@ -254,61 +267,61 @@ const withBlockTree = reducer => function () {
     return state;
   }
 
-  newState.tree = state.tree ? state.tree : {};
+  newState.tree = state.tree ? state.tree : new Map();
 
   switch (action.type) {
     case 'RECEIVE_BLOCKS':
     case 'INSERT_BLOCKS':
       {
-        const subTree = buildBlockTree(newState, action.blocks);
-        newState.tree = updateParentInnerBlocksInTree(newState, { ...newState.tree,
-          ...subTree
-        }, action.rootClientId ? [action.rootClientId] : [''], true);
+        newState.tree = new Map(newState.tree);
+        updateBlockTreeForBlocks(newState, action.blocks);
+        updateParentInnerBlocksInTree(newState, action.rootClientId ? [action.rootClientId] : [''], true);
         break;
       }
 
     case 'UPDATE_BLOCK':
-      newState.tree = updateParentInnerBlocksInTree(newState, { ...newState.tree,
-        [action.clientId]: { ...newState.tree[action.clientId],
-          ...newState.byClientId[action.clientId],
-          attributes: newState.attributes[action.clientId]
-        }
-      }, [action.clientId], false);
+      newState.tree = new Map(newState.tree);
+      newState.tree.set(action.clientId, { ...newState.tree.get(action.clientId),
+        ...newState.byClientId.get(action.clientId),
+        attributes: newState.attributes.get(action.clientId)
+      });
+      updateParentInnerBlocksInTree(newState, [action.clientId], false);
       break;
 
     case 'UPDATE_BLOCK_ATTRIBUTES':
       {
-        const newSubTree = action.clientIds.reduce((result, clientId) => {
-          result[clientId] = { ...newState.tree[clientId],
-            attributes: newState.attributes[clientId]
-          };
-          return result;
-        }, {});
-        newState.tree = updateParentInnerBlocksInTree(newState, { ...newState.tree,
-          ...newSubTree
-        }, action.clientIds, false);
+        newState.tree = new Map(newState.tree);
+        action.clientIds.forEach(clientId => {
+          newState.tree.set(clientId, { ...newState.tree.get(clientId),
+            attributes: newState.attributes.get(clientId)
+          });
+        });
+        updateParentInnerBlocksInTree(newState, action.clientIds, false);
         break;
       }
 
     case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
       {
-        const subTree = buildBlockTree(newState, action.blocks);
-        newState.tree = updateParentInnerBlocksInTree(newState, { ...omit(newState.tree, action.replacedClientIds.concat( // Controlled inner blocks are only removed
-          // if the block doesn't move to another position
-          // otherwise their content will be lost.
-          action.replacedClientIds.filter(clientId => !subTree[clientId]).map(clientId => 'controlled||' + clientId))),
-          ...subTree
-        }, action.blocks.map(b => b.clientId), false); // If there are no replaced blocks, it means we're removing blocks so we need to update their parent.
+        const inserterClientIds = getFlattenedClientIds(action.blocks);
+        newState.tree = new Map(newState.tree);
+        action.replacedClientIds.concat( // Controlled inner blocks are only removed
+        // if the block doesn't move to another position
+        // otherwise their content will be lost.
+        action.replacedClientIds.filter(clientId => !inserterClientIds[clientId]).map(clientId => 'controlled||' + clientId)).forEach(key => {
+          newState.tree.delete(key);
+        });
+        updateBlockTreeForBlocks(newState, action.blocks);
+        updateParentInnerBlocksInTree(newState, action.blocks.map(b => b.clientId), false); // If there are no replaced blocks, it means we're removing blocks so we need to update their parent.
 
         const parentsOfRemovedBlocks = [];
 
         for (const clientId of action.clientIds) {
-          if (state.parents[clientId] !== undefined && (state.parents[clientId] === '' || newState.byClientId[state.parents[clientId]])) {
-            parentsOfRemovedBlocks.push(state.parents[clientId]);
+          if (state.parents.get(clientId) !== undefined && (state.parents.get(clientId) === '' || newState.byClientId.get(state.parents.get(clientId)))) {
+            parentsOfRemovedBlocks.push(state.parents.get(clientId));
           }
         }
 
-        newState.tree = updateParentInnerBlocksInTree(newState, newState.tree, parentsOfRemovedBlocks, true);
+        updateParentInnerBlocksInTree(newState, parentsOfRemovedBlocks, true);
         break;
       }
 
@@ -316,12 +329,16 @@ const withBlockTree = reducer => function () {
       const parentsOfRemovedBlocks = [];
 
       for (const clientId of action.clientIds) {
-        if (state.parents[clientId] !== undefined && (state.parents[clientId] === '' || newState.byClientId[state.parents[clientId]])) {
-          parentsOfRemovedBlocks.push(state.parents[clientId]);
+        if (state.parents.get(clientId) !== undefined && (state.parents.get(clientId) === '' || newState.byClientId.get(state.parents.get(clientId)))) {
+          parentsOfRemovedBlocks.push(state.parents.get(clientId));
         }
       }
 
-      newState.tree = updateParentInnerBlocksInTree(newState, omit(newState.tree, action.removedClientIds.concat(action.removedClientIds.map(clientId => 'controlled||' + clientId))), parentsOfRemovedBlocks, true);
+      newState.tree = new Map(newState.tree);
+      action.removedClientIds.concat(action.removedClientIds.map(clientId => 'controlled||' + clientId)).forEach(key => {
+        newState.tree.delete(key);
+      });
+      updateParentInnerBlocksInTree(newState, parentsOfRemovedBlocks, true);
       break;
 
     case 'MOVE_BLOCKS_TO_POSITION':
@@ -338,7 +355,8 @@ const withBlockTree = reducer => function () {
           updatedBlockUids.push(action.toRootClientId);
         }
 
-        newState.tree = updateParentInnerBlocksInTree(newState, newState.tree, updatedBlockUids, true);
+        newState.tree = new Map(newState.tree);
+        updateParentInnerBlocksInTree(newState, updatedBlockUids, true);
         break;
       }
 
@@ -346,28 +364,27 @@ const withBlockTree = reducer => function () {
     case 'MOVE_BLOCKS_DOWN':
       {
         const updatedBlockUids = [action.rootClientId ? action.rootClientId : ''];
-        newState.tree = updateParentInnerBlocksInTree(newState, newState.tree, updatedBlockUids, true);
+        newState.tree = new Map(newState.tree);
+        updateParentInnerBlocksInTree(newState, updatedBlockUids, true);
         break;
       }
 
     case 'SAVE_REUSABLE_BLOCK_SUCCESS':
       {
-        const updatedBlockUids = Object.entries(newState.attributes).filter(_ref => {
-          let [clientId, attributes] = _ref;
-          return newState.byClientId[clientId].name === 'core/block' && attributes.ref === action.updatedId;
-        }).map(_ref2 => {
-          let [clientId] = _ref2;
-          return clientId;
+        const updatedBlockUids = [];
+        newState.attributes.forEach((attributes, clientId) => {
+          if (newState.byClientId.get(clientId).name === 'core/block' && attributes.ref === action.updatedId) {
+            updatedBlockUids.push(clientId);
+          }
         });
-        newState.tree = updateParentInnerBlocksInTree(newState, { ...newState.tree,
-          ...updatedBlockUids.reduce((result, clientId) => {
-            result[clientId] = { ...newState.byClientId[clientId],
-              attributes: newState.attributes[clientId],
-              innerBlocks: newState.tree[clientId].innerBlocks
-            };
-            return result;
-          }, {})
-        }, updatedBlockUids, false);
+        newState.tree = new Map(newState.tree);
+        updatedBlockUids.forEach(clientId => {
+          newState.tree.set(clientId, { ...newState.byClientId.get(clientId),
+            attributes: newState.attributes.get(clientId),
+            innerBlocks: newState.tree.get(clientId).innerBlocks
+          });
+        });
+        updateParentInnerBlocksInTree(newState, updatedBlockUids, false);
       }
   }
 
@@ -464,7 +481,7 @@ const withInnerBlocksRemoveCascade = reducer => (state, action) => {
     let result = clientIds;
 
     for (let i = 0; i < result.length; i++) {
-      if (!state.order[result[i]] || action.keepControlledInnerBlocks && action.keepControlledInnerBlocks[result[i]]) {
+      if (!state.order.get(result[i]) || action.keepControlledInnerBlocks && action.keepControlledInnerBlocks[result[i]]) {
         continue;
       }
 
@@ -472,7 +489,7 @@ const withInnerBlocksRemoveCascade = reducer => (state, action) => {
         result = [...result];
       }
 
-      result.push(...state.order[result[i]]);
+      result.push(...state.order.get(result[i]));
     }
 
     return result;
@@ -513,19 +530,17 @@ const withInnerBlocksRemoveCascade = reducer => (state, action) => {
 const withBlockReset = reducer => (state, action) => {
   if (action.type === 'RESET_BLOCKS') {
     const newState = { ...state,
-      byClientId: getFlattenedBlocksWithoutAttributes(action.blocks),
-      attributes: getFlattenedBlockAttributes(action.blocks),
+      byClientId: new Map(getFlattenedBlocksWithoutAttributes(action.blocks)),
+      attributes: new Map(getFlattenedBlockAttributes(action.blocks)),
       order: mapBlockOrder(action.blocks),
-      parents: mapBlockParents(action.blocks),
+      parents: new Map(mapBlockParents(action.blocks)),
       controlledInnerBlocks: {}
     };
-    const subTree = buildBlockTree(newState, action.blocks);
-    newState.tree = { ...subTree,
-      // Root.
-      '': {
-        innerBlocks: action.blocks.map(subBlock => subTree[subBlock.clientId])
-      }
-    };
+    newState.tree = new Map(state === null || state === void 0 ? void 0 : state.tree);
+    updateBlockTreeForBlocks(newState, action.blocks);
+    newState.tree.set('', {
+      innerBlocks: action.blocks.map(subBlock => newState.tree.get(subBlock.clientId))
+    });
     return newState;
   }
 
@@ -578,11 +593,11 @@ const withReplaceInnerBlocks = reducer => (state, action) => {
 
   let stateAfterBlocksRemoval = state;
 
-  if (state.order[action.rootClientId]) {
+  if (state.order.get(action.rootClientId)) {
     stateAfterBlocksRemoval = reducer(stateAfterBlocksRemoval, {
       type: 'REMOVE_BLOCKS',
       keepControlledInnerBlocks: nestedControllers,
-      clientIds: state.order[action.rootClientId]
+      clientIds: state.order.get(action.rootClientId)
     });
   }
 
@@ -596,26 +611,21 @@ const withReplaceInnerBlocks = reducer => (state, action) => {
     // preserve their block order. Otherwise, an inner block controller's blocks
     // will be deleted entirely from its entity.
 
-    stateAfterInsert.order = { ...stateAfterInsert.order,
-      ...Object.keys(nestedControllers).reduce((result, key) => {
-        if (state.order[key]) {
-          result[key] = state.order[key];
-        }
-
-        return result;
-      }, {})
-    };
-    stateAfterInsert.tree = { ...stateAfterInsert.tree,
-      ...Object.keys(nestedControllers).reduce((result, _key) => {
-        const key = `controlled||${_key}`;
-
-        if (state.tree[key]) {
-          result[key] = state.tree[key];
-        }
+    const stateAfterInsertOrder = new Map(stateAfterInsert.order);
+    Object.keys(nestedControllers).forEach(key => {
+      if (state.order.get(key)) {
+        stateAfterInsertOrder.set(key, state.order.get(key));
+      }
+    });
+    stateAfterInsert.order = stateAfterInsertOrder;
+    stateAfterInsert.tree = new Map(stateAfterInsert.tree);
+    Object.keys(nestedControllers).forEach(_key => {
+      const key = `controlled||${_key}`;
 
-        return result;
-      }, {})
-    };
+      if (state.tree.has(key)) {
+        stateAfterInsert.tree.set(key, state.tree.get(key));
+      }
+    });
   }
 
   return stateAfterInsert;
@@ -645,18 +655,17 @@ const withSaveReusableBlock = reducer => (state, action) => {
 
     state = { ...state
     };
-    state.attributes = mapValues(state.attributes, (attributes, clientId) => {
+    state.attributes = new Map(state.attributes);
+    state.attributes.forEach((attributes, clientId) => {
       const {
         name
-      } = state.byClientId[clientId];
+      } = state.byClientId.get(clientId);
 
       if (name === 'core/block' && attributes.ref === id) {
-        return { ...attributes,
+        state.attributes.set(clientId, { ...attributes,
           ref: updatedId
-        };
+        });
       }
-
-      return attributes;
     });
   }
 
@@ -699,137 +708,202 @@ export const blocks = pipe(combineReducers, withSaveReusableBlock, // Needs to b
 withBlockTree, // Needs to be before withInnerBlocksRemoveCascade.
 withInnerBlocksRemoveCascade, withReplaceInnerBlocks, // Needs to be after withInnerBlocksRemoveCascade.
 withBlockReset, withPersistentBlockChange, withIgnoredBlockChange, withResetControlledBlocks)({
+  // The state is using a Map instead of a plain object for performance reasons.
+  // You can run the "./test/performance.js" unit test to check the impact
+  // code changes can have on this reducer.
   byClientId() {
-    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Map();
     let action = arguments.length > 1 ? arguments[1] : undefined;
 
     switch (action.type) {
       case 'RECEIVE_BLOCKS':
       case 'INSERT_BLOCKS':
-        return { ...state,
-          ...getFlattenedBlocksWithoutAttributes(action.blocks)
-        };
+        {
+          const newState = new Map(state);
+          getFlattenedBlocksWithoutAttributes(action.blocks).forEach(_ref2 => {
+            let [key, value] = _ref2;
+            newState.set(key, value);
+          });
+          return newState;
+        }
 
       case 'UPDATE_BLOCK':
-        // Ignore updates if block isn't known.
-        if (!state[action.clientId]) {
-          return state;
-        } // Do nothing if only attributes change.
+        {
+          // Ignore updates if block isn't known.
+          if (!state.has(action.clientId)) {
+            return state;
+          } // Do nothing if only attributes change.
 
 
-        const changes = omit(action.updates, 'attributes');
+          const changes = omit(action.updates, 'attributes');
 
-        if (isEmpty(changes)) {
-          return state;
-        }
+          if (isEmpty(changes)) {
+            return state;
+          }
 
-        return { ...state,
-          [action.clientId]: { ...state[action.clientId],
+          const newState = new Map(state);
+          newState.set(action.clientId, { ...state.get(action.clientId),
             ...changes
-          }
-        };
+          });
+          return newState;
+        }
 
       case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
-        if (!action.blocks) {
-          return state;
-        }
+        {
+          if (!action.blocks) {
+            return state;
+          }
 
-        return { ...omit(state, action.replacedClientIds),
-          ...getFlattenedBlocksWithoutAttributes(action.blocks)
-        };
+          const newState = new Map(state);
+          action.replacedClientIds.forEach(clientId => {
+            newState.delete(clientId);
+          });
+          getFlattenedBlocksWithoutAttributes(action.blocks).forEach(_ref3 => {
+            let [key, value] = _ref3;
+            newState.set(key, value);
+          });
+          return newState;
+        }
 
       case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
-        return omit(state, action.removedClientIds);
+        {
+          const newState = new Map(state);
+          action.removedClientIds.forEach(clientId => {
+            newState.delete(clientId);
+          });
+          return newState;
+        }
     }
 
     return state;
   },
 
+  // The state is using a Map instead of a plain object for performance reasons.
+  // You can run the "./test/performance.js" unit test to check the impact
+  // code changes can have on this reducer.
   attributes() {
-    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Map();
     let action = arguments.length > 1 ? arguments[1] : undefined;
 
     switch (action.type) {
       case 'RECEIVE_BLOCKS':
       case 'INSERT_BLOCKS':
-        return { ...state,
-          ...getFlattenedBlockAttributes(action.blocks)
-        };
+        {
+          const newState = new Map(state);
+          getFlattenedBlockAttributes(action.blocks).forEach(_ref4 => {
+            let [key, value] = _ref4;
+            newState.set(key, value);
+          });
+          return newState;
+        }
 
       case 'UPDATE_BLOCK':
-        // Ignore updates if block isn't known or there are no attribute changes.
-        if (!state[action.clientId] || !action.updates.attributes) {
-          return state;
-        }
+        {
+          // Ignore updates if block isn't known or there are no attribute changes.
+          if (!state.get(action.clientId) || !action.updates.attributes) {
+            return state;
+          }
 
-        return { ...state,
-          [action.clientId]: { ...state[action.clientId],
+          const newState = new Map(state);
+          newState.set(action.clientId, { ...state.get(action.clientId),
             ...action.updates.attributes
-          }
-        };
+          });
+          return newState;
+        }
 
       case 'UPDATE_BLOCK_ATTRIBUTES':
         {
           // Avoid a state change if none of the block IDs are known.
-          if (action.clientIds.every(id => !state[id])) {
+          if (action.clientIds.every(id => !state.get(id))) {
             return state;
           }
 
-          const next = action.clientIds.reduce((accumulator, id) => {
-            var _action$attributes;
+          let hasChange = false;
+          const newState = new Map(state);
 
-            return { ...accumulator,
-              [id]: Object.entries(action.uniqueByBlock ? action.attributes[id] : (_action$attributes = action.attributes) !== null && _action$attributes !== void 0 ? _action$attributes : {}).reduce((result, _ref3) => {
-                let [key, value] = _ref3;
+          for (const clientId of action.clientIds) {
+            var _action$attributes;
 
-                // Consider as updates only changed values.
-                if (value !== result[key]) {
-                  result = getMutateSafeObject(state[id], result);
-                  result[key] = value;
-                }
+            const updatedAttributeEntries = Object.entries(action.uniqueByBlock ? action.attributes[clientId] : (_action$attributes = action.attributes) !== null && _action$attributes !== void 0 ? _action$attributes : {});
 
-                return result;
-              }, state[id])
-            };
-          }, {});
+            if (updatedAttributeEntries.length === 0) {
+              continue;
+            }
 
-          if (action.clientIds.every(id => next[id] === state[id])) {
-            return state;
+            let hasUpdatedAttributes = false;
+            const existingAttributes = state.get(clientId);
+            const newAttributes = {};
+            updatedAttributeEntries.forEach(_ref5 => {
+              let [key, value] = _ref5;
+
+              if (existingAttributes[key] !== value) {
+                hasUpdatedAttributes = true;
+                newAttributes[key] = value;
+              }
+            });
+            hasChange = hasChange || hasUpdatedAttributes;
+
+            if (hasUpdatedAttributes) {
+              newState.set(clientId, { ...existingAttributes,
+                ...newAttributes
+              });
+            }
           }
 
-          return { ...state,
-            ...next
-          };
+          return hasChange ? newState : state;
         }
 
       case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
-        if (!action.blocks) {
-          return state;
-        }
+        {
+          if (!action.blocks) {
+            return state;
+          }
 
-        return { ...omit(state, action.replacedClientIds),
-          ...getFlattenedBlockAttributes(action.blocks)
-        };
+          const newState = new Map(state);
+          action.replacedClientIds.forEach(clientId => {
+            newState.delete(clientId);
+          });
+          getFlattenedBlockAttributes(action.blocks).forEach(_ref6 => {
+            let [key, value] = _ref6;
+            newState.set(key, value);
+          });
+          return newState;
+        }
 
       case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
-        return omit(state, action.removedClientIds);
+        {
+          const newState = new Map(state);
+          action.removedClientIds.forEach(clientId => {
+            newState.delete(clientId);
+          });
+          return newState;
+        }
     }
 
     return state;
   },
 
+  // The state is using a Map instead of a plain object for performance reasons.
+  // You can run the "./test/performance.js" unit test to check the impact
+  // code changes can have on this reducer.
   order() {
-    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Map();
     let action = arguments.length > 1 ? arguments[1] : undefined;
 
     switch (action.type) {
       case 'RECEIVE_BLOCKS':
         {
+          var _state$get;
+
           const blockOrder = mapBlockOrder(action.blocks);
-          return { ...state,
-            ...omit(blockOrder, ''),
-            '': ((state === null || state === void 0 ? void 0 : state['']) || []).concat(blockOrder[''])
-          };
+          const newState = new Map(state);
+          blockOrder.forEach((order, clientId) => {
+            if (clientId !== '') {
+              newState.set(clientId, order);
+            }
+          });
+          newState.set('', ((_state$get = state.get('')) !== null && _state$get !== void 0 ? _state$get : []).concat(blockOrder['']));
+          return newState;
         }
 
       case 'INSERT_BLOCKS':
@@ -837,20 +911,22 @@ withBlockReset, withPersistentBlockChange, withIgnoredBlockChange, withResetCont
           const {
             rootClientId = ''
           } = action;
-          const subState = state[rootClientId] || [];
+          const subState = state.get(rootClientId) || [];
           const mappedBlocks = mapBlockOrder(action.blocks, rootClientId);
           const {
             index = subState.length
           } = action;
-          return { ...state,
-            ...mappedBlocks,
-            [rootClientId]: insertAt(subState, mappedBlocks[rootClientId], index)
-          };
+          const newState = new Map(state);
+          mappedBlocks.forEach((order, clientId) => {
+            newState.set(clientId, order);
+          });
+          newState.set(rootClientId, insertAt(subState, mappedBlocks.get(rootClientId), index));
+          return newState;
         }
 
       case 'MOVE_BLOCKS_TO_POSITION':
         {
-          var _state$fromRootClient, _state$fromRootClient2;
+          var _state$get$filter, _state$get2;
 
           const {
             fromRootClientId = '',
@@ -858,22 +934,22 @@ withBlockReset, withPersistentBlockChange, withIgnoredBlockChange, withResetCont
             clientIds
           } = action;
           const {
-            index = state[toRootClientId].length
+            index = state.get(toRootClientId).length
           } = action; // Moving inside the same parent block.
 
           if (fromRootClientId === toRootClientId) {
-            const subState = state[toRootClientId];
+            const subState = state.get(toRootClientId);
             const fromIndex = subState.indexOf(clientIds[0]);
-            return { ...state,
-              [toRootClientId]: moveTo(state[toRootClientId], fromIndex, index, clientIds.length)
-            };
+            const newState = new Map(state);
+            newState.set(toRootClientId, moveTo(state.get(toRootClientId), fromIndex, index, clientIds.length));
+            return newState;
           } // Moving from a parent block to another.
 
 
-          return { ...state,
-            [fromRootClientId]: (_state$fromRootClient = (_state$fromRootClient2 = state[fromRootClientId]) === null || _state$fromRootClient2 === void 0 ? void 0 : _state$fromRootClient2.filter(id => !clientIds.includes(id))) !== null && _state$fromRootClient !== void 0 ? _state$fromRootClient : [],
-            [toRootClientId]: insertAt(state[toRootClientId], clientIds, index)
-          };
+          const newState = new Map(state);
+          newState.set(fromRootClientId, (_state$get$filter = (_state$get2 = state.get(fromRootClientId)) === null || _state$get2 === void 0 ? void 0 : _state$get2.filter(id => !clientIds.includes(id))) !== null && _state$get$filter !== void 0 ? _state$get$filter : []);
+          newState.set(toRootClientId, insertAt(state.get(toRootClientId), clientIds, index));
+          return newState;
         }
 
       case 'MOVE_BLOCKS_UP':
@@ -883,16 +959,16 @@ withBlockReset, withPersistentBlockChange, withIgnoredBlockChange, withResetCont
             rootClientId = ''
           } = action;
           const firstClientId = clientIds[0];
-          const subState = state[rootClientId];
+          const subState = state.get(rootClientId);
 
           if (!subState.length || firstClientId === subState[0]) {
             return state;
           }
 
           const firstIndex = subState.indexOf(firstClientId);
-          return { ...state,
-            [rootClientId]: moveTo(subState, firstIndex, firstIndex - 1, clientIds.length)
-          };
+          const newState = new Map(state);
+          newState.set(rootClientId, moveTo(subState, firstIndex, firstIndex - 1, clientIds.length));
+          return newState;
         }
 
       case 'MOVE_BLOCKS_DOWN':
@@ -903,16 +979,16 @@ withBlockReset, withPersistentBlockChange, withIgnoredBlockChange, withResetCont
           } = action;
           const firstClientId = clientIds[0];
           const lastClientId = clientIds[clientIds.length - 1];
-          const subState = state[rootClientId];
+          const subState = state.get(rootClientId);
 
           if (!subState.length || lastClientId === subState[subState.length - 1]) {
             return state;
           }
 
           const firstIndex = subState.indexOf(firstClientId);
-          return { ...state,
-            [rootClientId]: moveTo(subState, firstIndex, firstIndex + 1, clientIds.length)
-          };
+          const newState = new Map(state);
+          newState.set(rootClientId, moveTo(subState, firstIndex, firstIndex + 1, clientIds.length));
+          return newState;
         }
 
       case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
@@ -926,29 +1002,50 @@ withBlockReset, withPersistentBlockChange, withIgnoredBlockChange, withResetCont
           }
 
           const mappedBlocks = mapBlockOrder(action.blocks);
-          return pipe([nextState => omit(nextState, action.replacedClientIds), nextState => ({ ...nextState,
-            ...omit(mappedBlocks, '')
-          }), nextState => mapValues(nextState, subState => Object.values(subState).reduce((result, clientId) => {
-            if (clientId === clientIds[0]) {
-              return [...result, ...mappedBlocks['']];
+          const newState = new Map(state);
+          action.replacedClientIds.forEach(clientId => {
+            newState.delete(clientId);
+          });
+          mappedBlocks.forEach((order, clientId) => {
+            if (clientId !== '') {
+              newState.set(clientId, order);
             }
-
-            if (clientIds.indexOf(clientId) === -1) {
-              result.push(clientId);
-            }
-
-            return result;
-          }, []))])(state);
+          });
+          newState.forEach((order, clientId) => {
+            const newSubOrder = Object.values(order).reduce((result, subClientId) => {
+              if (subClientId === clientIds[0]) {
+                return [...result, ...mappedBlocks.get('')];
+              }
+
+              if (clientIds.indexOf(subClientId) === -1) {
+                result.push(subClientId);
+              }
+
+              return result;
+            }, []);
+            newState.set(clientId, newSubOrder);
+          });
+          return newState;
         }
 
       case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
-        return pipe([// Remove inner block ordering for removed blocks.
-        nextState => omit(nextState, action.removedClientIds), // Remove deleted blocks from other blocks' orderings.
-        nextState => mapValues(nextState, subState => {
-          var _subState$filter;
+        {
+          const newState = new Map(state); // Remove inner block ordering for removed blocks.
 
-          return (_subState$filter = subState === null || subState === void 0 ? void 0 : subState.filter(id => !action.removedClientIds.includes(id))) !== null && _subState$filter !== void 0 ? _subState$filter : [];
-        })])(state);
+          action.removedClientIds.forEach(clientId => {
+            newState.delete(clientId);
+          });
+          newState.forEach((order, clientId) => {
+            var _order$filter;
+
+            const newSubOrder = (_order$filter = order === null || order === void 0 ? void 0 : order.filter(id => !action.removedClientIds.includes(id))) !== null && _order$filter !== void 0 ? _order$filter : [];
+
+            if (newSubOrder.length !== order.length) {
+              newState.set(clientId, newSubOrder);
+            }
+          });
+          return newState;
+        }
     }
 
     return state;
@@ -957,37 +1054,60 @@ withBlockReset, withPersistentBlockChange, withIgnoredBlockChange, withResetCont
   // While technically redundant data as the inverse of `order`, it serves as
   // an optimization for the selectors which derive the ancestry of a block.
   parents() {
-    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Map();
     let action = arguments.length > 1 ? arguments[1] : undefined;
 
     switch (action.type) {
       case 'RECEIVE_BLOCKS':
-        return { ...state,
-          ...mapBlockParents(action.blocks)
-        };
+        {
+          const newState = new Map(state);
+          mapBlockParents(action.blocks).forEach(_ref7 => {
+            let [key, value] = _ref7;
+            newState.set(key, value);
+          });
+          return newState;
+        }
 
       case 'INSERT_BLOCKS':
-        return { ...state,
-          ...mapBlockParents(action.blocks, action.rootClientId || '')
-        };
+        {
+          const newState = new Map(state);
+          mapBlockParents(action.blocks, action.rootClientId || '').forEach(_ref8 => {
+            let [key, value] = _ref8;
+            newState.set(key, value);
+          });
+          return newState;
+        }
 
       case 'MOVE_BLOCKS_TO_POSITION':
         {
-          return { ...state,
-            ...action.clientIds.reduce((accumulator, id) => {
-              accumulator[id] = action.toRootClientId || '';
-              return accumulator;
-            }, {})
-          };
+          const newState = new Map(state);
+          action.clientIds.forEach(id => {
+            newState.set(id, action.toRootClientId || '');
+          });
+          return newState;
         }
 
       case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
-        return { ...omit(state, action.replacedClientIds),
-          ...mapBlockParents(action.blocks, state[action.clientIds[0]])
-        };
+        {
+          const newState = new Map(state);
+          action.replacedClientIds.forEach(clientId => {
+            newState.delete(clientId);
+          });
+          mapBlockParents(action.blocks, state.get(action.clientIds[0])).forEach(_ref9 => {
+            let [key, value] = _ref9;
+            newState.set(key, value);
+          });
+          return newState;
+        }
 
       case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
-        return omit(state, action.removedClientIds);
+        {
+          const newState = new Map(state);
+          action.removedClientIds.forEach(clientId => {
+            newState.delete(clientId);
+          });
+          return newState;
+        }
     }
 
     return state;
@@ -1388,7 +1508,7 @@ export function insertionPoint() {
           operation
         }; // Bail out updates if the states are the same.
 
-        return isEqual(state, nextState) ? state : nextState;
+        return fastDeepEqual(state, nextState) ? state : nextState;
       }
 
     case 'HIDE_INSERTION_POINT':
@@ -1528,7 +1648,7 @@ export const blockListSettings = function () {
           return state;
         }
 
-        if (isEqual(state[clientId], action.settings)) {
+        if (fastDeepEqual(state[clientId], action.settings)) {
           return state;
         }