@wordpress/block-editor 7.0.4 → 8.0.3

package/build-module/store/actions.js

@@ -9,56 +9,59 @@ import { castArray, findKey, first, isObject, last, some } from 'lodash';
 import { cloneBlock, __experimentalCloneSanitizedBlock, createBlock, doBlocksMatchTemplate, getBlockType, getDefaultBlockName, hasBlockSupport, switchToBlockType, synchronizeBlocksWithTemplate } from '@wordpress/blocks';
 import { speak } from '@wordpress/a11y';
 import { __, _n, sprintf } from '@wordpress/i18n';
-import { controls } from '@wordpress/data';
 import { create, insert, remove, toHTMLString } from '@wordpress/rich-text';
 import deprecated from '@wordpress/deprecated';
 /**
- * Internal dependencies
- */
-
-import { __unstableMarkAutomaticChangeFinalControl } from '../store/controls';
-import { STORE_NAME as blockEditorStoreName } from './constants';
-/**
- * Generator which will yield a default block insert action if there
- * are no other blocks at the root of the editor. This generator should be used
+ * Action which will insert a default block insert action if there
+ * are no other blocks at the root of the editor. This action should be used
  * in actions which may result in no blocks remaining in the editor (removal,
  * replacement, etc).
  */
 
-function* ensureDefaultBlock() {
-  const count = yield controls.select(blockEditorStoreName, 'getBlockCount'); // To avoid a focus loss when removing the last block, assure there is
+const ensureDefaultBlock = () => _ref => {
+  let {
+    select,
+    dispatch
+  } = _ref;
+  // To avoid a focus loss when removing the last block, assure there is
   // always a default block if the last of the blocks have been removed.
+  const count = select.getBlockCount();
 
-  if (count === 0) {
-    const {
-      __unstableHasCustomAppender
-    } = yield controls.select(blockEditorStoreName, 'getSettings'); // If there's an custom appender, don't insert default block.
-    // We have to remember to manually move the focus elsewhere to
-    // prevent it from being lost though.
+  if (count > 0) {
+    return;
+  } // If there's an custom appender, don't insert default block.
+  // We have to remember to manually move the focus elsewhere to
+  // prevent it from being lost though.
 
-    if (__unstableHasCustomAppender) {
-      return;
-    }
 
-    return yield insertDefaultBlock();
+  const {
+    __unstableHasCustomAppender
+  } = select.getSettings();
+
+  if (__unstableHasCustomAppender) {
+    return;
   }
-}
+
+  dispatch.insertDefaultBlock();
+};
 /**
- * Returns an action object used in signalling that blocks state should be
- * reset to the specified array of blocks, taking precedence over any other
- * content reflected as an edit in state.
+ * Action that resets blocks state to the specified array of blocks, taking precedence
+ * over any other content reflected as an edit in state.
  *
  * @param {Array} blocks Array of blocks.
  */
 
 
-export function* resetBlocks(blocks) {
-  yield {
+export const resetBlocks = blocks => _ref2 => {
+  let {
+    dispatch
+  } = _ref2;
+  dispatch({
     type: 'RESET_BLOCKS',
     blocks
-  };
-  return yield* validateBlocksToTemplate(blocks);
-}
+  });
+  dispatch(validateBlocksToTemplate(blocks));
+};
 /**
  * Block validity is a function of blocks state (at the point of a
  * reset) and the template setting. As a compromise to its placement
@@ -68,20 +71,24 @@ export function* resetBlocks(blocks) {
  * @param {Array} blocks Array of blocks.
  */
 
-export function* validateBlocksToTemplate(blocks) {
-  const template = yield controls.select(blockEditorStoreName, 'getTemplate');
-  const templateLock = yield controls.select(blockEditorStoreName, 'getTemplateLock'); // Unlocked templates are considered always valid because they act
+export const validateBlocksToTemplate = blocks => _ref3 => {
+  let {
+    select,
+    dispatch
+  } = _ref3;
+  const template = select.getTemplate();
+  const templateLock = select.getTemplateLock(); // Unlocked templates are considered always valid because they act
   // as default values only.
 
   const isBlocksValidToTemplate = !template || templateLock !== 'all' || doBlocksMatchTemplate(blocks, template); // Update if validity has changed.
 
-  const isValidTemplate = yield controls.select(blockEditorStoreName, 'isValidTemplate');
+  const isValidTemplate = select.isValidTemplate();
 
   if (isBlocksValidToTemplate !== isValidTemplate) {
-    yield setTemplateValidity(isBlocksValidToTemplate);
+    dispatch.setTemplateValidity(isBlocksValidToTemplate);
     return isBlocksValidToTemplate;
   }
-}
+};
 /**
  * A block selection object.
  *
@@ -138,8 +145,7 @@ export function receiveBlocks(blocks) {
   };
 }
 /**
- * Returns an action object used in signalling that the multiple blocks'
- * attributes with the specified client IDs have been updated.
+ * Action that updates attributes of multiple blocks with the specified client IDs.
  *
  * @param {string|string[]} clientIds     Block client IDs.
  * @param {Object}          attributes    Block attributes to be merged. Should be keyed by clientIds if
@@ -148,7 +154,8 @@ export function receiveBlocks(blocks) {
  * @return {Object} Action object.
  */
 
-export function updateBlockAttributes(clientIds, attributes, uniqueByBlock = false) {
+export function updateBlockAttributes(clientIds, attributes) {
+  let uniqueByBlock = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   return {
     type: 'UPDATE_BLOCK_ATTRIBUTES',
     clientIds: castArray(clientIds),
@@ -157,8 +164,7 @@ export function updateBlockAttributes(clientIds, attributes, uniqueByBlock = fal
   };
 }
 /**
- * Returns an action object used in signalling that the block with the
- * specified client ID has been updated.
+ * Action that updates the block with the specified client ID.
  *
  * @param {string} clientId Block client ID.
  * @param {Object} updates  Block attributes to be merged.
@@ -188,7 +194,9 @@ export function updateBlock(clientId, updates) {
  * @return {Object} Action object.
  */
 
-export function selectBlock(clientId, initialPosition = 0) {
+export function selectBlock(clientId) {
+  let initialPosition = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
   /* eslint-enable jsdoc/valid-types */
   return {
     type: 'SELECT_BLOCK',
@@ -203,14 +211,17 @@ export function selectBlock(clientId, initialPosition = 0) {
  * @param {string} clientId Block client ID.
  */
 
-export function* selectPreviousBlock(clientId) {
-  const previousBlockClientId = yield controls.select(blockEditorStoreName, 'getPreviousBlockClientId', clientId);
+export const selectPreviousBlock = clientId => _ref4 => {
+  let {
+    select,
+    dispatch
+  } = _ref4;
+  const previousBlockClientId = select.getPreviousBlockClientId(clientId);
 
   if (previousBlockClientId) {
-    yield selectBlock(previousBlockClientId, -1);
-    return [previousBlockClientId];
+    dispatch.selectBlock(previousBlockClientId, -1);
   }
-}
+};
 /**
  * Yields action objects used in signalling that the block following the given
  * clientId should be selected.
@@ -218,16 +229,19 @@ export function* selectPreviousBlock(clientId) {
  * @param {string} clientId Block client ID.
  */
 
-export function* selectNextBlock(clientId) {
-  const nextBlockClientId = yield controls.select(blockEditorStoreName, 'getNextBlockClientId', clientId);
+export const selectNextBlock = clientId => _ref5 => {
+  let {
+    select,
+    dispatch
+  } = _ref5;
+  const nextBlockClientId = select.getNextBlockClientId(clientId);
 
   if (nextBlockClientId) {
-    yield selectBlock(nextBlockClientId);
-    return [nextBlockClientId];
+    dispatch.selectBlock(nextBlockClientId);
   }
-}
+};
 /**
- * Returns an action object used in signalling that a block multi-selection has started.
+ * Action that starts block multi-selection.
  *
  * @return {Object} Action object.
  */
@@ -238,7 +252,7 @@ export function startMultiSelect() {
   };
 }
 /**
- * Returns an action object used in signalling that block multi-selection stopped.
+ * Action that stops block multi-selection.
  *
  * @return {Object} Action object.
  */
@@ -249,32 +263,36 @@ export function stopMultiSelect() {
   };
 }
 /**
- * Returns an action object used in signalling that block multi-selection changed.
+ * Action that changes block multi-selection.
  *
  * @param {string} start First block of the multi selection.
  * @param {string} end   Last block of the multiselection.
  */
 
-export function* multiSelect(start, end) {
-  const startBlockRootClientId = yield controls.select(blockEditorStoreName, 'getBlockRootClientId', start);
-  const endBlockRootClientId = yield controls.select(blockEditorStoreName, 'getBlockRootClientId', end); // Only allow block multi-selections at the same level.
+export const multiSelect = (start, end) => _ref6 => {
+  let {
+    select,
+    dispatch
+  } = _ref6;
+  const startBlockRootClientId = select.getBlockRootClientId(start);
+  const endBlockRootClientId = select.getBlockRootClientId(end); // Only allow block multi-selections at the same level.
 
   if (startBlockRootClientId !== endBlockRootClientId) {
     return;
   }
 
-  yield {
+  dispatch({
     type: 'MULTI_SELECT',
     start,
     end
-  };
-  const blockCount = yield controls.select(blockEditorStoreName, 'getSelectedBlockCount');
+  });
+  const blockCount = select.getSelectedBlockCount();
   speak(sprintf(
   /* translators: %s: number of selected blocks */
   _n('%s block selected.', '%s blocks selected.', blockCount), blockCount), 'assertive');
-}
+};
 /**
- * Returns an action object used in signalling that the block selection is cleared.
+ * Action that clears the block selection.
  *
  * @return {Object} Action object.
  */
@@ -285,7 +303,7 @@ export function clearSelectedBlock() {
   };
 }
 /**
- * Returns an action object that enables or disables block selection.
+ * Action that enables or disables block selection.
  *
  * @param {boolean} [isSelectionEnabled=true] Whether block selection should
  *                                            be enabled.
@@ -293,7 +311,8 @@ export function clearSelectedBlock() {
  * @return {Object} Action object.
  */
 
-export function toggleSelection(isSelectionEnabled = true) {
+export function toggleSelection() {
+  let isSelectionEnabled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
   return {
     type: 'TOGGLE_SELECTION',
     isSelectionEnabled
@@ -337,8 +356,7 @@ function getBlocksWithDefaultStylesApplied(blocks, blockEditorSettings) {
 /* eslint-disable jsdoc/valid-types */
 
 /**
- * Returns an action object signalling that a blocks should be replaced with
- * one or more replacement blocks.
+ * Action that replaces given blocks with one or more replacement blocks.
  *
  * @param {(string|string[])} clientIds       Block client ID(s) to replace.
  * @param {(Object|Object[])} blocks          Replacement block(s).
@@ -346,39 +364,47 @@ function getBlocksWithDefaultStylesApplied(blocks, blockEditorSettings) {
  * @param {0|-1|null}         initialPosition Index of caret after in the selected block after the operation.
  * @param {?Object}           meta            Optional Meta values to be passed to the action object.
  *
- * @yield {Object} Action object.
+ * @return {Object} Action object.
  */
 
 
-export function* replaceBlocks(clientIds, blocks, indexToSelect, initialPosition = 0, meta) {
-  /* eslint-enable jsdoc/valid-types */
-  clientIds = castArray(clientIds);
-  blocks = getBlocksWithDefaultStylesApplied(castArray(blocks), yield controls.select(blockEditorStoreName, 'getSettings'));
-  const rootClientId = yield controls.select(blockEditorStoreName, 'getBlockRootClientId', first(clientIds)); // Replace is valid if the new blocks can be inserted in the root block.
+export const replaceBlocks = function (clientIds, blocks, indexToSelect) {
+  let initialPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  let meta = arguments.length > 4 ? arguments[4] : undefined;
+  return _ref7 => {
+    let {
+      select,
+      dispatch
+    } = _ref7;
 
-  for (let index = 0; index < blocks.length; index++) {
-    const block = blocks[index];
-    const canInsertBlock = yield controls.select(blockEditorStoreName, 'canInsertBlockType', block.name, rootClientId);
+    /* eslint-enable jsdoc/valid-types */
+    clientIds = castArray(clientIds);
+    blocks = getBlocksWithDefaultStylesApplied(castArray(blocks), select.getSettings());
+    const rootClientId = select.getBlockRootClientId(first(clientIds)); // Replace is valid if the new blocks can be inserted in the root block.
 
-    if (!canInsertBlock) {
-      return;
+    for (let index = 0; index < blocks.length; index++) {
+      const block = blocks[index];
+      const canInsertBlock = select.canInsertBlockType(block.name, rootClientId);
+
+      if (!canInsertBlock) {
+        return;
+      }
     }
-  }
 
-  yield {
-    type: 'REPLACE_BLOCKS',
-    clientIds,
-    blocks,
-    time: Date.now(),
-    indexToSelect,
-    initialPosition,
-    meta
+    dispatch({
+      type: 'REPLACE_BLOCKS',
+      clientIds,
+      blocks,
+      time: Date.now(),
+      indexToSelect,
+      initialPosition,
+      meta
+    });
+    dispatch(ensureDefaultBlock());
   };
-  yield* ensureDefaultBlock();
-}
+};
 /**
- * Returns an action object signalling that a single block should be replaced
- * with one or more replacement blocks.
+ * Action that replaces a single block with one or more replacement blocks.
  *
  * @param {(string|string[])} clientId Block client ID to replace.
  * @param {(Object|Object[])} block    Replacement block(s).
@@ -398,87 +424,93 @@ export function replaceBlock(clientId, block) {
  * @return {Function} Action creator.
  */
 
-function createOnMove(type) {
-  return function* (clientIds, rootClientId) {
-    const canMoveBlocks = yield controls.select(blockEditorStoreName, 'canMoveBlocks', clientIds, rootClientId); // If one of the blocks is locked or the parent is locked, we cannot move any block.
+const createOnMove = type => (clientIds, rootClientId) => _ref8 => {
+  let {
+    select,
+    dispatch
+  } = _ref8;
+  // If one of the blocks is locked or the parent is locked, we cannot move any block.
+  const canMoveBlocks = select.canMoveBlocks(clientIds, rootClientId);
 
-    if (!canMoveBlocks) {
-      return;
-    }
+  if (!canMoveBlocks) {
+    return;
+  }
 
-    yield {
-      clientIds: castArray(clientIds),
-      type,
-      rootClientId
-    };
-  };
-}
+  dispatch({
+    type,
+    clientIds: castArray(clientIds),
+    rootClientId
+  });
+};
 
 export const moveBlocksDown = createOnMove('MOVE_BLOCKS_DOWN');
 export const moveBlocksUp = createOnMove('MOVE_BLOCKS_UP');
 /**
- * Returns an action object signalling that the given blocks should be moved to
- * a new position.
+ * Action that moves given blocks to a new position.
  *
  * @param {?string} clientIds        The client IDs of the blocks.
  * @param {?string} fromRootClientId Root client ID source.
  * @param {?string} toRootClientId   Root client ID destination.
  * @param {number}  index            The index to move the blocks to.
- *
- * @yield {Object} Action object.
  */
 
-export function* moveBlocksToPosition(clientIds, fromRootClientId = '', toRootClientId = '', index) {
-  const canMoveBlocks = yield controls.select(blockEditorStoreName, 'canMoveBlocks', clientIds, fromRootClientId);
-  const canRemoveBlocks = yield controls.select(blockEditorStoreName, 'canRemoveBlocks', clientIds, fromRootClientId); // If one of the blocks is locked or the parent is locked, we cannot move any block.
+export const moveBlocksToPosition = function (clientIds) {
+  let fromRootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let toRootClientId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  let index = arguments.length > 3 ? arguments[3] : undefined;
+  return _ref9 => {
+    let {
+      select,
+      dispatch
+    } = _ref9;
+    const canMoveBlocks = select.canMoveBlocks(clientIds, fromRootClientId); // If one of the blocks is locked or the parent is locked, we cannot move any block.
 
-  if (!canMoveBlocks) {
-    return;
-  }
+    if (!canMoveBlocks) {
+      return;
+    } // If moving inside the same root block the move is always possible.
 
-  const action = {
-    type: 'MOVE_BLOCKS_TO_POSITION',
-    fromRootClientId,
-    toRootClientId,
-    clientIds,
-    index
-  }; // If moving inside the same root block the move is always possible.
 
-  if (fromRootClientId === toRootClientId) {
-    yield action;
-    return;
-  } // If we're moving to another block, it means we're deleting blocks from
-  // the original block, so we need to check if removing is possible.
+    if (fromRootClientId !== toRootClientId) {
+      const canRemoveBlocks = select.canRemoveBlocks(clientIds, fromRootClientId); // If we're moving to another block, it means we're deleting blocks from
+      // the original block, so we need to check if removing is possible.
 
+      if (!canRemoveBlocks) {
+        return;
+      }
 
-  if (!canRemoveBlocks) {
-    return;
-  }
+      const canInsertBlocks = select.canInsertBlocks(clientIds, toRootClientId); // If moving to other parent block, the move is possible if we can insert a block of the same type inside the new parent block.
 
-  const canInsertBlocks = yield controls.select(blockEditorStoreName, 'canInsertBlocks', clientIds, toRootClientId); // If moving to other parent block, the move is possible if we can insert a block of the same type inside the new parent block.
+      if (!canInsertBlocks) {
+        return;
+      }
+    }
 
-  if (canInsertBlocks) {
-    yield action;
-  }
-}
+    dispatch({
+      type: 'MOVE_BLOCKS_TO_POSITION',
+      fromRootClientId,
+      toRootClientId,
+      clientIds,
+      index
+    });
+  };
+};
 /**
- * Returns an action object signalling that the given block should be moved to a
- * new position.
+ * Action that moves given block to a new position.
  *
  * @param {?string} clientId         The client ID of the block.
  * @param {?string} fromRootClientId Root client ID source.
  * @param {?string} toRootClientId   Root client ID destination.
  * @param {number}  index            The index to move the block to.
- *
- * @yield {Object} Action object.
  */
 
-export function* moveBlockToPosition(clientId, fromRootClientId = '', toRootClientId = '', index) {
-  yield moveBlocksToPosition([clientId], fromRootClientId, toRootClientId, index);
+export function moveBlockToPosition(clientId) {
+  let fromRootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let toRootClientId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  let index = arguments.length > 3 ? arguments[3] : undefined;
+  return moveBlocksToPosition([clientId], fromRootClientId, toRootClientId, index);
 }
 /**
- * Returns an action object used in signalling that a single block should be
- * inserted, optionally at a specific index respective a root block list.
+ * Action that inserts a single block, optionally at a specific index respective a root block list.
  *
  * @param {Object}   block           Block object to insert.
  * @param {?number}  index           Index at which block should be inserted.
@@ -489,14 +521,13 @@ export function* moveBlockToPosition(clientId, fromRootClientId = '', toRootClie
  * @return {Object} Action object.
  */
 
-export function insertBlock(block, index, rootClientId, updateSelection = true, meta) {
+export function insertBlock(block, index, rootClientId, updateSelection, meta) {
   return insertBlocks([block], index, rootClientId, updateSelection, 0, meta);
 }
 /* eslint-disable jsdoc/valid-types */
 
 /**
- * Returns an action object used in signalling that an array of blocks should
- * be inserted, optionally at a specific index respective a root block list.
+ * Action that inserts an array of blocks, optionally at a specific index respective a root block list.
  *
  * @param {Object[]}  blocks          Block objects to insert.
  * @param {?number}   index           Index at which block should be inserted.
@@ -507,45 +538,54 @@ export function insertBlock(block, index, rootClientId, updateSelection = true,
  * @return {Object} Action object.
  */
 
-export function* insertBlocks(blocks, index, rootClientId, updateSelection = true, initialPosition = 0, meta) {
-  /* eslint-enable jsdoc/valid-types */
-  if (isObject(initialPosition)) {
-    meta = initialPosition;
-    initialPosition = 0;
-    deprecated("meta argument in wp.data.dispatch('core/block-editor')", {
-      since: '10.1',
-      plugin: 'Gutenberg',
-      hint: 'The meta argument is now the 6th argument of the function'
-    });
-  }
+export const insertBlocks = function (blocks, index, rootClientId) {
+  let updateSelection = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  let initialPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+  let meta = arguments.length > 5 ? arguments[5] : undefined;
+  return _ref10 => {
+    let {
+      select,
+      dispatch
+    } = _ref10;
+
+    /* eslint-enable jsdoc/valid-types */
+    if (isObject(initialPosition)) {
+      meta = initialPosition;
+      initialPosition = 0;
+      deprecated("meta argument in wp.data.dispatch('core/block-editor')", {
+        since: '10.1',
+        plugin: 'Gutenberg',
+        hint: 'The meta argument is now the 6th argument of the function'
+      });
+    }
 
-  blocks = getBlocksWithDefaultStylesApplied(castArray(blocks), yield controls.select(blockEditorStoreName, 'getSettings'));
-  const allowedBlocks = [];
+    blocks = getBlocksWithDefaultStylesApplied(castArray(blocks), select.getSettings());
+    const allowedBlocks = [];
 
-  for (const block of blocks) {
-    const isValid = yield controls.select(blockEditorStoreName, 'canInsertBlockType', block.name, rootClientId);
+    for (const block of blocks) {
+      const isValid = select.canInsertBlockType(block.name, rootClientId);
 
-    if (isValid) {
-      allowedBlocks.push(block);
+      if (isValid) {
+        allowedBlocks.push(block);
+      }
     }
-  }
 
-  if (allowedBlocks.length) {
-    return {
-      type: 'INSERT_BLOCKS',
-      blocks: allowedBlocks,
-      index,
-      rootClientId,
-      time: Date.now(),
-      updateSelection,
-      initialPosition: updateSelection ? initialPosition : null,
-      meta
-    };
-  }
-}
+    if (allowedBlocks.length) {
+      dispatch({
+        type: 'INSERT_BLOCKS',
+        blocks: allowedBlocks,
+        index,
+        rootClientId,
+        time: Date.now(),
+        updateSelection,
+        initialPosition: updateSelection ? initialPosition : null,
+        meta
+      });
+    }
+  };
+};
 /**
- * Returns an action object used in signalling that the insertion point should
- * be shown.
+ * Action that shows the insertion point.
  *
  * @param {?string} rootClientId      Optional root client ID of block list on
  *                                    which to insert.
@@ -555,7 +595,9 @@ export function* insertBlocks(blocks, index, rootClientId, updateSelection = tru
  * @return {Object} Action object.
  */
 
-export function showInsertionPoint(rootClientId, index, __unstableOptions = {}) {
+export function showInsertionPoint(rootClientId, index) {
+  let __unstableOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
   const {
     __unstableWithInserter
   } = __unstableOptions;
@@ -567,7 +609,7 @@ export function showInsertionPoint(rootClientId, index, __unstableOptions = {})
   };
 }
 /**
- * Returns an action object hiding the insertion point.
+ * Action that hides the insertion point.
  *
  * @return {Object} Action object.
  */
@@ -578,7 +620,7 @@ export function hideInsertionPoint() {
   };
 }
 /**
- * Returns an action object resetting the template validity.
+ * Action that resets the template validity.
  *
  * @param {boolean} isValid template validity flag.
  *
@@ -592,49 +634,57 @@ export function setTemplateValidity(isValid) {
   };
 }
 /**
- * Returns an action object synchronize the template with the list of blocks
+ * Action that synchronizes the template with the list of blocks.
  *
  * @return {Object} Action object.
  */
 
-export function* synchronizeTemplate() {
-  yield {
+export const synchronizeTemplate = () => _ref11 => {
+  let {
+    select,
+    dispatch
+  } = _ref11;
+  dispatch({
     type: 'SYNCHRONIZE_TEMPLATE'
-  };
-  const blocks = yield controls.select(blockEditorStoreName, 'getBlocks');
-  const template = yield controls.select(blockEditorStoreName, 'getTemplate');
+  });
+  const blocks = select.getBlocks();
+  const template = select.getTemplate();
   const updatedBlockList = synchronizeBlocksWithTemplate(blocks, template);
-  return yield resetBlocks(updatedBlockList);
-}
+  dispatch.resetBlocks(updatedBlockList);
+};
 /**
- * Returns an action object used in signalling that two blocks should be merged
+ * Action that merges two blocks.
  *
  * @param {string} firstBlockClientId  Client ID of the first block to merge.
  * @param {string} secondBlockClientId Client ID of the second block to merge.
  */
 
-export function* mergeBlocks(firstBlockClientId, secondBlockClientId) {
+export const mergeBlocks = (firstBlockClientId, secondBlockClientId) => _ref12 => {
+  let {
+    select,
+    dispatch
+  } = _ref12;
   const blocks = [firstBlockClientId, secondBlockClientId];
-  yield {
+  dispatch({
     type: 'MERGE_BLOCKS',
     blocks
-  };
+  });
   const [clientIdA, clientIdB] = blocks;
-  const blockA = yield controls.select(blockEditorStoreName, 'getBlock', clientIdA);
+  const blockA = select.getBlock(clientIdA);
   const blockAType = getBlockType(blockA.name); // Only focus the previous block if it's not mergeable
 
   if (blockAType && !blockAType.merge) {
-    yield selectBlock(blockA.clientId);
+    dispatch.selectBlock(blockA.clientId);
     return;
   }
 
-  const blockB = yield controls.select(blockEditorStoreName, 'getBlock', clientIdB);
+  const blockB = select.getBlock(clientIdB);
   const blockBType = getBlockType(blockB.name);
   const {
     clientId,
     attributeKey,
     offset
-  } = yield controls.select(blockEditorStoreName, 'getSelectionStart');
+  } = select.getSelectionStart();
   const selectedBlockType = clientId === clientIdA ? blockAType : blockBType;
   const attributeDefinition = selectedBlockType.attributes[attributeKey];
   const canRestoreTextSelection = (clientId === clientIdA || clientId === clientIdB) && attributeKey !== undefined && offset !== undefined && // We cannot restore text selection if the RichText identifier
@@ -712,16 +762,16 @@ export function* mergeBlocks(firstBlockClientId, secondBlockClientId) {
       preserveWhiteSpace
     });
     updatedAttributes[newAttributeKey] = newHtml;
-    yield selectionChange(blockA.clientId, newAttributeKey, newOffset, newOffset);
+    dispatch.selectionChange(blockA.clientId, newAttributeKey, newOffset, newOffset);
   }
 
-  yield* replaceBlocks([blockA.clientId, blockB.clientId], [{ ...blockA,
+  dispatch.replaceBlocks([blockA.clientId, blockB.clientId], [{ ...blockA,
     attributes: { ...blockA.attributes,
       ...updatedAttributes
     }
   }, ...blocksWithTheSameType.slice(1)], 0 // If we don't pass the `indexToSelect` it will default to the last block.
   );
-}
+};
 /**
  * Yields action objects used in signalling that the blocks corresponding to
  * the set of specified client IDs are to be removed.
@@ -731,36 +781,39 @@ export function* mergeBlocks(firstBlockClientId, secondBlockClientId) {
  *                                         selected when a block is removed.
  */
 
-export function* removeBlocks(clientIds, selectPrevious = true) {
-  if (!clientIds || !clientIds.length) {
-    return;
-  }
+export const removeBlocks = function (clientIds) {
+  let selectPrevious = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  return _ref13 => {
+    let {
+      select,
+      dispatch
+    } = _ref13;
 
-  clientIds = castArray(clientIds);
-  const rootClientId = yield controls.select(blockEditorStoreName, 'getBlockRootClientId', clientIds[0]);
-  const canRemoveBlocks = yield controls.select(blockEditorStoreName, 'canRemoveBlocks', clientIds, rootClientId);
+    if (!clientIds || !clientIds.length) {
+      return;
+    }
 
-  if (!canRemoveBlocks) {
-    return;
-  }
+    clientIds = castArray(clientIds);
+    const rootClientId = select.getBlockRootClientId(clientIds[0]);
+    const canRemoveBlocks = select.canRemoveBlocks(clientIds, rootClientId);
 
-  let previousBlockId;
+    if (!canRemoveBlocks) {
+      return;
+    }
 
-  if (selectPrevious) {
-    previousBlockId = yield selectPreviousBlock(clientIds[0]);
-  } else {
-    previousBlockId = yield controls.select(blockEditorStoreName, 'getPreviousBlockClientId', clientIds[0]);
-  }
+    if (selectPrevious) {
+      dispatch.selectPreviousBlock(clientIds[0]);
+    }
 
-  yield {
-    type: 'REMOVE_BLOCKS',
-    clientIds
-  }; // To avoid a focus loss when removing the last block, assure there is
-  // always a default block if the last of the blocks have been removed.
+    dispatch({
+      type: 'REMOVE_BLOCKS',
+      clientIds
+    }); // To avoid a focus loss when removing the last block, assure there is
+    // always a default block if the last of the blocks have been removed.
 
-  const defaultBlockId = yield* ensureDefaultBlock();
-  return [previousBlockId || defaultBlockId];
-}
+    dispatch(ensureDefaultBlock());
+  };
+};
 /**
  * Returns an action object used in signalling that the block with the
  * specified client ID is to be removed.
@@ -788,7 +841,10 @@ export function removeBlock(clientId, selectPrevious) {
  * @return {Object} Action object.
  */
 
-export function replaceInnerBlocks(rootClientId, blocks, updateSelection = false, initialPosition = 0) {
+export function replaceInnerBlocks(rootClientId, blocks) {
+  let updateSelection = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  let initialPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+
   /* eslint-enable jsdoc/valid-types */
   return {
     type: 'REPLACE_INNER_BLOCKS',
@@ -844,7 +900,8 @@ export function stopTyping() {
  * @return {Object} Action object.
  */
 
-export function startDraggingBlocks(clientIds = []) {
+export function startDraggingBlocks() {
+  let clientIds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   return {
     type: 'START_DRAGGING_BLOCKS',
     clientIds
@@ -884,8 +941,7 @@ export function exitFormattedText() {
   };
 }
 /**
- * Returns an action object used in signalling that the user caret has changed
- * position.
+ * Action that changes the position of the user caret.
  *
  * @param {string} clientId     The selected block client ID.
  * @param {string} attributeKey The selected block attribute key.
@@ -905,8 +961,7 @@ export function selectionChange(clientId, attributeKey, startOffset, endOffset)
   };
 }
 /**
- * Returns an action object used in signalling that a new block of the default
- * type should be added to the block list.
+ * Action that adds a new block of the default type to the block list.
  *
  * @param {?Object} attributes   Optional attributes of the block to assign.
  * @param {?string} rootClientId Optional root client ID of block list on which
@@ -928,7 +983,7 @@ export function insertDefaultBlock(attributes, rootClientId, index) {
   return insertBlock(block, index, rootClientId);
 }
 /**
- * Returns an action object that changes the nested settings of a given block.
+ * Action that changes the nested settings of a given block.
  *
  * @param {string} clientId Client ID of the block whose nested setting are
  *                          being received.
@@ -945,7 +1000,7 @@ export function updateBlockListSettings(clientId, settings) {
   };
 }
 /**
- * Returns an action object used in signalling that the block editor settings have been updated.
+ * Action that updates the block editor settings.
  *
  * @param {Object} settings Updated settings
  *
@@ -959,7 +1014,7 @@ export function updateSettings(settings) {
   };
 }
 /**
- * Returns an action object used in signalling that a temporary reusable blocks have been saved
+ * Action that signals that a temporary reusable block has been saved
  * in order to switch its temporary id with the real id.
  *
  * @param {string} id        Reusable block's id.
@@ -976,7 +1031,7 @@ export function __unstableSaveReusableBlock(id, updatedId) {
   };
 }
 /**
- * Returns an action object used in signalling that the last block change should be marked explicitly as persistent.
+ * Action that marks the last block change explicitly as persistent.
  *
  * @return {Object} Action object.
  */
@@ -987,7 +1042,7 @@ export function __unstableMarkLastChangeAsPersistent() {
   };
 }
 /**
- * Returns an action object used in signalling that the next block change should be marked explicitly as not persistent.
+ * Action that signals that the next block change should be marked explicitly as not persistent.
  *
  * @return {Object} Action object.
  */
@@ -998,138 +1053,174 @@ export function __unstableMarkNextChangeAsNotPersistent() {
   };
 }
 /**
- * Returns an action object used in signalling that the last block change is
- * an automatic change, meaning it was not performed by the user, and can be
- * undone using the `Escape` and `Backspace` keys. This action must be called
- * after the change was made, and any actions that are a consequence of it, so
- * it is recommended to be called at the next idle period to ensure all
+ * Action that marks the last block change as an automatic change, meaning it was not
+ * performed by the user, and can be undone using the `Escape` and `Backspace` keys.
+ * This action must be called after the change was made, and any actions that are a
+ * consequence of it, so it is recommended to be called at the next idle period to ensure all
  * selection changes have been recorded.
  */
 
-export function* __unstableMarkAutomaticChange() {
-  yield {
+export const __unstableMarkAutomaticChange = () => _ref14 => {
+  let {
+    dispatch
+  } = _ref14;
+  dispatch({
     type: 'MARK_AUTOMATIC_CHANGE'
-  };
-  yield __unstableMarkAutomaticChangeFinalControl();
-}
-export function __unstableMarkAutomaticChangeFinal() {
-  return {
-    type: 'MARK_AUTOMATIC_CHANGE_FINAL'
-  };
-}
+  });
+  const {
+    requestIdleCallback = cb => setTimeout(cb, 100)
+  } = window;
+  requestIdleCallback(() => {
+    dispatch({
+      type: 'MARK_AUTOMATIC_CHANGE_FINAL'
+    });
+  });
+};
 /**
- * Generators that triggers an action used to enable or disable the navigation mode.
+ * Action that enables or disables the navigation mode.
  *
  * @param {string} isNavigationMode Enable/Disable navigation mode.
  */
 
-export function* setNavigationMode(isNavigationMode = true) {
-  yield {
-    type: 'SET_NAVIGATION_MODE',
-    isNavigationMode
-  };
+export const setNavigationMode = function () {
+  let isNavigationMode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  return _ref15 => {
+    let {
+      dispatch
+    } = _ref15;
+    dispatch({
+      type: 'SET_NAVIGATION_MODE',
+      isNavigationMode
+    });
 
-  if (isNavigationMode) {
-    speak(__('You are currently in navigation mode. Navigate blocks using the Tab key and Arrow keys. Use Left and Right Arrow keys to move between nesting levels. To exit navigation mode and edit the selected block, press Enter.'));
-  } else {
-    speak(__('You are currently in edit mode. To return to the navigation mode, press Escape.'));
-  }
-}
+    if (isNavigationMode) {
+      speak(__('You are currently in navigation mode. Navigate blocks using the Tab key and Arrow keys. Use Left and Right Arrow keys to move between nesting levels. To exit navigation mode and edit the selected block, press Enter.'));
+    } else {
+      speak(__('You are currently in edit mode. To return to the navigation mode, press Escape.'));
+    }
+  };
+};
 /**
- * Generator that triggers an action used to enable or disable the block moving mode.
+ * Action that enables or disables the block moving mode.
  *
  * @param {string|null} hasBlockMovingClientId Enable/Disable block moving mode.
  */
 
-export function* setBlockMovingClientId(hasBlockMovingClientId = null) {
-  yield {
-    type: 'SET_BLOCK_MOVING_MODE',
-    hasBlockMovingClientId
-  };
+export const setBlockMovingClientId = function () {
+  let hasBlockMovingClientId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  return _ref16 => {
+    let {
+      dispatch
+    } = _ref16;
+    dispatch({
+      type: 'SET_BLOCK_MOVING_MODE',
+      hasBlockMovingClientId
+    });
 
-  if (hasBlockMovingClientId) {
-    speak(__('Use the Tab key and Arrow keys to choose new block location. Use Left and Right Arrow keys to move between nesting levels. Once location is selected press Enter or Space to move the block.'));
-  }
-}
+    if (hasBlockMovingClientId) {
+      speak(__('Use the Tab key and Arrow keys to choose new block location. Use Left and Right Arrow keys to move between nesting levels. Once location is selected press Enter or Space to move the block.'));
+    }
+  };
+};
 /**
- * Generator that triggers an action used to duplicate a list of blocks.
+ * Action that duplicates a list of blocks.
  *
  * @param {string[]} clientIds
  * @param {boolean}  updateSelection
  */
 
-export function* duplicateBlocks(clientIds, updateSelection = true) {
-  if (!clientIds && !clientIds.length) {
-    return;
-  }
+export const duplicateBlocks = function (clientIds) {
+  let updateSelection = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  return _ref17 => {
+    let {
+      select,
+      dispatch
+    } = _ref17;
 
-  const blocks = yield controls.select(blockEditorStoreName, 'getBlocksByClientId', clientIds);
-  const rootClientId = yield controls.select(blockEditorStoreName, 'getBlockRootClientId', clientIds[0]); // Return early if blocks don't exist.
+    if (!clientIds || !clientIds.length) {
+      return;
+    } // Return early if blocks don't exist.
 
-  if (some(blocks, block => !block)) {
-    return;
-  }
 
-  const blockNames = blocks.map(block => block.name); // Return early if blocks don't support multiple usage.
+    const blocks = select.getBlocksByClientId(clientIds);
 
-  if (some(blockNames, blockName => !hasBlockSupport(blockName, 'multiple', true))) {
-    return;
-  }
+    if (some(blocks, block => !block)) {
+      return;
+    } // Return early if blocks don't support multiple usage.
 
-  const lastSelectedIndex = yield controls.select(blockEditorStoreName, 'getBlockIndex', last(castArray(clientIds)), rootClientId);
-  const clonedBlocks = blocks.map(block => __experimentalCloneSanitizedBlock(block));
-  yield insertBlocks(clonedBlocks, lastSelectedIndex + 1, rootClientId, updateSelection);
 
-  if (clonedBlocks.length > 1 && updateSelection) {
-    yield multiSelect(first(clonedBlocks).clientId, last(clonedBlocks).clientId);
-  }
+    const blockNames = blocks.map(block => block.name);
 
-  return clonedBlocks.map(block => block.clientId);
-}
+    if (blockNames.some(blockName => !hasBlockSupport(blockName, 'multiple', true))) {
+      return;
+    }
+
+    const rootClientId = select.getBlockRootClientId(clientIds[0]);
+    const lastSelectedIndex = select.getBlockIndex(last(castArray(clientIds)), rootClientId);
+    const clonedBlocks = blocks.map(block => __experimentalCloneSanitizedBlock(block));
+    dispatch.insertBlocks(clonedBlocks, lastSelectedIndex + 1, rootClientId, updateSelection);
+
+    if (clonedBlocks.length > 1 && updateSelection) {
+      dispatch.multiSelect(first(clonedBlocks).clientId, last(clonedBlocks).clientId);
+    }
+
+    return clonedBlocks.map(block => block.clientId);
+  };
+};
 /**
- * Generator used to insert an empty block after a given block.
+ * Action that inserts an empty block before a given block.
  *
  * @param {string} clientId
  */
 
-export function* insertBeforeBlock(clientId) {
+export const insertBeforeBlock = clientId => _ref18 => {
+  let {
+    select,
+    dispatch
+  } = _ref18;
+
   if (!clientId) {
     return;
   }
 
-  const rootClientId = yield controls.select(blockEditorStoreName, 'getBlockRootClientId', clientId);
-  const isLocked = yield controls.select(blockEditorStoreName, 'getTemplateLock', rootClientId);
+  const rootClientId = select.getBlockRootClientId(clientId);
+  const isLocked = select.getTemplateLock(rootClientId);
 
   if (isLocked) {
     return;
   }
 
-  const firstSelectedIndex = yield controls.select(blockEditorStoreName, 'getBlockIndex', clientId, rootClientId);
-  return yield insertDefaultBlock({}, rootClientId, firstSelectedIndex);
-}
+  const firstSelectedIndex = select.getBlockIndex(clientId, rootClientId);
+  return dispatch.insertDefaultBlock({}, rootClientId, firstSelectedIndex);
+};
 /**
- * Generator used to insert an empty block before a given block.
+ * Action that inserts an empty block after a given block.
  *
  * @param {string} clientId
  */
 
-export function* insertAfterBlock(clientId) {
+export const insertAfterBlock = clientId => _ref19 => {
+  let {
+    select,
+    dispatch
+  } = _ref19;
+
   if (!clientId) {
     return;
   }
 
-  const rootClientId = yield controls.select(blockEditorStoreName, 'getBlockRootClientId', clientId);
-  const isLocked = yield controls.select(blockEditorStoreName, 'getTemplateLock', rootClientId);
+  const rootClientId = select.getBlockRootClientId(clientId);
+  const isLocked = select.getTemplateLock(rootClientId);
 
   if (isLocked) {
     return;
   }
 
-  const firstSelectedIndex = yield controls.select(blockEditorStoreName, 'getBlockIndex', clientId, rootClientId);
-  return yield insertDefaultBlock({}, rootClientId, firstSelectedIndex + 1);
-}
+  const firstSelectedIndex = select.getBlockIndex(clientId, rootClientId);
+  return dispatch.insertDefaultBlock({}, rootClientId, firstSelectedIndex + 1);
+};
 /**
- * Returns an action object that toggles the highlighted block state.
+ * Action that toggles the highlighted block state.
  *
  * @param {string}  clientId      The block's clientId.
  * @param {boolean} isHighlighted The highlight state.
@@ -1143,22 +1234,21 @@ export function toggleBlockHighlight(clientId, isHighlighted) {
   };
 }
 /**
- * Yields action objects used in signalling that the block corresponding to the
- * given clientId should appear to "flash" by rhythmically highlighting it.
+ * Action that "flashes" the block with a given `clientId` by rhythmically highlighting it.
  *
  * @param {string} clientId Target block client ID.
  */
 
-export function* flashBlock(clientId) {
-  yield toggleBlockHighlight(clientId, true);
-  yield {
-    type: 'SLEEP',
-    duration: 150
-  };
-  yield toggleBlockHighlight(clientId, false);
-}
+export const flashBlock = clientId => async _ref20 => {
+  let {
+    dispatch
+  } = _ref20;
+  dispatch(toggleBlockHighlight(clientId, true));
+  await new Promise(resolve => setTimeout(resolve, 150));
+  dispatch(toggleBlockHighlight(clientId, false));
+};
 /**
- * Returns an action object that sets whether the block has controlled innerblocks.
+ * Action that sets whether a block has controlled inner blocks.
  *
  * @param {string}  clientId                 The block's clientId.
  * @param {boolean} hasControlledInnerBlocks True if the block's inner blocks are controlled.