@wordpress/block-editor 8.3.0 → 8.5.0

package/build/store/actions.js

@@ -5,10 +5,11 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.__unstableMarkAutomaticChange = void 0;
+exports.__unstableMarkAutomaticChange = exports.__unstableExpandSelection = exports.__unstableDeleteSelection = void 0;
 exports.__unstableMarkLastChangeAsPersistent = __unstableMarkLastChangeAsPersistent;
 exports.__unstableMarkNextChangeAsNotPersistent = __unstableMarkNextChangeAsNotPersistent;
 exports.__unstableSaveReusableBlock = __unstableSaveReusableBlock;
+exports.__unstableSplitSelection = void 0;
 exports.clearSelectedBlock = clearSelectedBlock;
 exports.duplicateBlocks = void 0;
 exports.enterFormattedText = enterFormattedText;
@@ -163,6 +164,15 @@ const validateBlocksToTemplate = blocks => _ref3 => {
  *                                 text value. See `wp.richText.create`.
  */
 
+/**
+ * A selection object.
+ *
+ * @typedef {Object} WPSelection
+ *
+ * @property {WPBlockSelection} start The selection start.
+ * @property {WPBlockSelection} end   The selection end.
+ */
+
 /* eslint-disable jsdoc/valid-types */
 
 /**
@@ -690,7 +700,7 @@ const insertBlocks = function (blocks, index, rootClientId) {
  * @param {?string} rootClientId      Optional root client ID of block list on
  *                                    which to insert.
  * @param {?number} index             Index at which block should be inserted.
- * @param {Object}  __unstableOptions Wether or not to show an inserter button.
+ * @param {Object}  __unstableOptions Whether or not to show an inserter button.
  *
  * @return {Object} Action object.
  */
@@ -758,6 +768,251 @@ const synchronizeTemplate = () => _ref11 => {
   const updatedBlockList = (0, _blocks.synchronizeBlocksWithTemplate)(blocks, template);
   dispatch.resetBlocks(updatedBlockList);
 };
+
+exports.synchronizeTemplate = synchronizeTemplate;
+
+function mapRichTextSettings(attributeDefinition) {
+  const {
+    multiline: multilineTag,
+    __unstableMultilineWrapperTags: multilineWrapperTags,
+    __unstablePreserveWhiteSpace: preserveWhiteSpace
+  } = attributeDefinition;
+  return {
+    multilineTag,
+    multilineWrapperTags,
+    preserveWhiteSpace
+  };
+}
+/**
+ * Delete the current selection.
+ *
+ * @param {boolean} isForward
+ */
+
+
+const __unstableDeleteSelection = isForward => _ref12 => {
+  let {
+    registry,
+    select,
+    dispatch
+  } = _ref12;
+  const selectionAnchor = select.getSelectionStart();
+  const selectionFocus = select.getSelectionEnd();
+  if (selectionAnchor.clientId === selectionFocus.clientId) return; // It's not mergeable if there's no rich text selection.
+
+  if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === 'undefined' || typeof selectionFocus.offset === 'undefined') return false;
+  const anchorRootClientId = select.getBlockRootClientId(selectionAnchor.clientId);
+  const focusRootClientId = select.getBlockRootClientId(selectionFocus.clientId); // It's not mergeable if the selection doesn't start and end in the same
+  // block list. Maybe in the future it should be allowed.
+
+  if (anchorRootClientId !== focusRootClientId) {
+    return;
+  }
+
+  const blockOrder = select.getBlockOrder(anchorRootClientId);
+  const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
+  const focusIndex = blockOrder.indexOf(selectionFocus.clientId); // Reassign selection start and end based on order.
+
+  let selectionStart, selectionEnd;
+
+  if (anchorIndex > focusIndex) {
+    selectionStart = selectionFocus;
+    selectionEnd = selectionAnchor;
+  } else {
+    selectionStart = selectionAnchor;
+    selectionEnd = selectionFocus;
+  }
+
+  const targetSelection = isForward ? selectionEnd : selectionStart;
+  const targetBlock = select.getBlock(targetSelection.clientId);
+  const targetBlockType = (0, _blocks.getBlockType)(targetBlock.name);
+
+  if (!targetBlockType.merge) {
+    return;
+  }
+
+  const selectionA = selectionStart;
+  const selectionB = selectionEnd;
+  const blockA = select.getBlock(selectionA.clientId);
+  const blockAType = (0, _blocks.getBlockType)(blockA.name);
+  const blockB = select.getBlock(selectionB.clientId);
+  const blockBType = (0, _blocks.getBlockType)(blockB.name);
+  const htmlA = blockA.attributes[selectionA.attributeKey];
+  const htmlB = blockB.attributes[selectionB.attributeKey];
+  const attributeDefinitionA = blockAType.attributes[selectionA.attributeKey];
+  const attributeDefinitionB = blockBType.attributes[selectionB.attributeKey];
+  let valueA = (0, _richText.create)({
+    html: htmlA,
+    ...mapRichTextSettings(attributeDefinitionA)
+  });
+  let valueB = (0, _richText.create)({
+    html: htmlB,
+    ...mapRichTextSettings(attributeDefinitionB)
+  }); // A robust way to retain selection position through various transforms
+  // is to insert a special character at the position and then recover it.
+
+  const START_OF_SELECTED_AREA = '\u0086';
+  valueA = (0, _richText.remove)(valueA, selectionA.offset, valueA.text.length);
+  valueB = (0, _richText.insert)(valueB, START_OF_SELECTED_AREA, 0, selectionB.offset); // Clone the blocks so we don't manipulate the original.
+
+  const cloneA = (0, _blocks.cloneBlock)(blockA, {
+    [selectionA.attributeKey]: (0, _richText.toHTMLString)({
+      value: valueA,
+      ...mapRichTextSettings(attributeDefinitionA)
+    })
+  });
+  const cloneB = (0, _blocks.cloneBlock)(blockB, {
+    [selectionB.attributeKey]: (0, _richText.toHTMLString)({
+      value: valueB,
+      ...mapRichTextSettings(attributeDefinitionB)
+    })
+  });
+  const followingBlock = isForward ? cloneA : cloneB; // We can only merge blocks with similar types
+  // thus, we transform the block to merge first
+
+  const blocksWithTheSameType = blockA.name === blockB.name ? [followingBlock] : (0, _blocks.switchToBlockType)(followingBlock, targetBlockType.name); // If the block types can not match, do nothing
+
+  if (!blocksWithTheSameType || !blocksWithTheSameType.length) {
+    return;
+  }
+
+  let updatedAttributes;
+
+  if (isForward) {
+    const blockToMerge = blocksWithTheSameType.pop();
+    updatedAttributes = targetBlockType.merge(blockToMerge.attributes, cloneB.attributes);
+  } else {
+    const blockToMerge = blocksWithTheSameType.shift();
+    updatedAttributes = targetBlockType.merge(cloneA.attributes, blockToMerge.attributes);
+  }
+
+  const newAttributeKey = (0, _lodash.findKey)(updatedAttributes, v => typeof v === 'string' && v.indexOf(START_OF_SELECTED_AREA) !== -1);
+  const convertedHtml = updatedAttributes[newAttributeKey];
+  const convertedValue = (0, _richText.create)({
+    html: convertedHtml,
+    ...mapRichTextSettings(targetBlockType.attributes[newAttributeKey])
+  });
+  const newOffset = convertedValue.text.indexOf(START_OF_SELECTED_AREA);
+  const newValue = (0, _richText.remove)(convertedValue, newOffset, newOffset + 1);
+  const newHtml = (0, _richText.toHTMLString)({
+    value: newValue,
+    ...mapRichTextSettings(targetBlockType.attributes[newAttributeKey])
+  });
+  updatedAttributes[newAttributeKey] = newHtml;
+  const selectedBlockClientIds = select.getSelectedBlockClientIds();
+  const replacement = [...(isForward ? blocksWithTheSameType : []), { // Preserve the original client ID.
+    ...targetBlock,
+    attributes: { ...targetBlock.attributes,
+      ...updatedAttributes
+    }
+  }, ...(isForward ? [] : blocksWithTheSameType)];
+  registry.batch(() => {
+    dispatch.selectionChange(targetBlock.clientId, newAttributeKey, newOffset, newOffset);
+    dispatch.replaceBlocks(selectedBlockClientIds, replacement, 0, // If we don't pass the `indexToSelect` it will default to the last block.
+    select.getSelectedBlocksInitialCaretPosition());
+  });
+};
+/**
+ * Split the current selection.
+ */
+
+
+exports.__unstableDeleteSelection = __unstableDeleteSelection;
+
+const __unstableSplitSelection = () => _ref13 => {
+  let {
+    select,
+    dispatch
+  } = _ref13;
+  const selectionAnchor = select.getSelectionStart();
+  const selectionFocus = select.getSelectionEnd();
+  if (selectionAnchor.clientId === selectionFocus.clientId) return; // Can't split if the selection is not set.
+
+  if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === 'undefined' || typeof selectionFocus.offset === 'undefined') return;
+  const anchorRootClientId = select.getBlockRootClientId(selectionAnchor.clientId);
+  const focusRootClientId = select.getBlockRootClientId(selectionFocus.clientId); // It's not splittable if the selection doesn't start and end in the same
+  // block list. Maybe in the future it should be allowed.
+
+  if (anchorRootClientId !== focusRootClientId) {
+    return;
+  }
+
+  const blockOrder = select.getBlockOrder(anchorRootClientId);
+  const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
+  const focusIndex = blockOrder.indexOf(selectionFocus.clientId); // Reassign selection start and end based on order.
+
+  let selectionStart, selectionEnd;
+
+  if (anchorIndex > focusIndex) {
+    selectionStart = selectionFocus;
+    selectionEnd = selectionAnchor;
+  } else {
+    selectionStart = selectionAnchor;
+    selectionEnd = selectionFocus;
+  }
+
+  const selectionA = selectionStart;
+  const selectionB = selectionEnd;
+  const blockA = select.getBlock(selectionA.clientId);
+  const blockAType = (0, _blocks.getBlockType)(blockA.name);
+  const blockB = select.getBlock(selectionB.clientId);
+  const blockBType = (0, _blocks.getBlockType)(blockB.name);
+  const htmlA = blockA.attributes[selectionA.attributeKey];
+  const htmlB = blockB.attributes[selectionB.attributeKey];
+  const attributeDefinitionA = blockAType.attributes[selectionA.attributeKey];
+  const attributeDefinitionB = blockBType.attributes[selectionB.attributeKey];
+  let valueA = (0, _richText.create)({
+    html: htmlA,
+    ...mapRichTextSettings(attributeDefinitionA)
+  });
+  let valueB = (0, _richText.create)({
+    html: htmlB,
+    ...mapRichTextSettings(attributeDefinitionB)
+  });
+  valueA = (0, _richText.remove)(valueA, selectionA.offset, valueA.text.length);
+  valueB = (0, _richText.remove)(valueB, 0, selectionB.offset);
+  dispatch.replaceBlocks(select.getSelectedBlockClientIds(), [{ // Preserve the original client ID.
+    ...blockA,
+    attributes: { ...blockA.attributes,
+      [selectionA.attributeKey]: (0, _richText.toHTMLString)({
+        value: valueA,
+        ...mapRichTextSettings(attributeDefinitionA)
+      })
+    }
+  }, (0, _blocks.createBlock)((0, _blocks.getDefaultBlockName)()), { // Preserve the original client ID.
+    ...blockB,
+    attributes: { ...blockB.attributes,
+      [selectionB.attributeKey]: (0, _richText.toHTMLString)({
+        value: valueB,
+        ...mapRichTextSettings(attributeDefinitionB)
+      })
+    }
+  }], 1, // If we don't pass the `indexToSelect` it will default to the last block.
+  select.getSelectedBlocksInitialCaretPosition());
+};
+/**
+ * Expand the selection to cover the entire blocks, removing partial selection.
+ */
+
+
+exports.__unstableSplitSelection = __unstableSplitSelection;
+
+const __unstableExpandSelection = () => _ref14 => {
+  let {
+    select,
+    dispatch
+  } = _ref14;
+  const selectionAnchor = select.getSelectionStart();
+  const selectionFocus = select.getSelectionEnd();
+  dispatch.selectionChange({
+    start: {
+      clientId: selectionAnchor.clientId
+    },
+    end: {
+      clientId: selectionFocus.clientId
+    }
+  });
+};
 /**
  * Action that merges two blocks.
  *
@@ -766,13 +1021,13 @@ const synchronizeTemplate = () => _ref11 => {
  */
 
 
-exports.synchronizeTemplate = synchronizeTemplate;
+exports.__unstableExpandSelection = __unstableExpandSelection;
 
-const mergeBlocks = (firstBlockClientId, secondBlockClientId) => _ref12 => {
+const mergeBlocks = (firstBlockClientId, secondBlockClientId) => _ref15 => {
   let {
     select,
     dispatch
-  } = _ref12;
+  } = _ref15;
   const blocks = [firstBlockClientId, secondBlockClientId];
   dispatch({
     type: 'MERGE_BLOCKS',
@@ -820,21 +1075,13 @@ const mergeBlocks = (firstBlockClientId, secondBlockClientId) => _ref12 => {
   if (canRestoreTextSelection) {
     const selectedBlock = clientId === clientIdA ? cloneA : cloneB;
     const html = selectedBlock.attributes[attributeKey];
-    const {
-      multiline: multilineTag,
-      __unstableMultilineWrapperTags: multilineWrapperTags,
-      __unstablePreserveWhiteSpace: preserveWhiteSpace
-    } = attributeDefinition;
     const value = (0, _richText.insert)((0, _richText.create)({
       html,
-      multilineTag,
-      multilineWrapperTags,
-      preserveWhiteSpace
+      ...mapRichTextSettings(attributeDefinition)
     }), START_OF_SELECTED_AREA, offset, offset);
     selectedBlock.attributes[attributeKey] = (0, _richText.toHTMLString)({
       value,
-      multilineTag,
-      preserveWhiteSpace
+      ...mapRichTextSettings(attributeDefinition)
     });
   } // We can only merge blocks with similar types
   // thus, we transform the block to merge first.
@@ -852,23 +1099,15 @@ const mergeBlocks = (firstBlockClientId, secondBlockClientId) => _ref12 => {
   if (canRestoreTextSelection) {
     const newAttributeKey = (0, _lodash.findKey)(updatedAttributes, v => typeof v === 'string' && v.indexOf(START_OF_SELECTED_AREA) !== -1);
     const convertedHtml = updatedAttributes[newAttributeKey];
-    const {
-      multiline: multilineTag,
-      __unstableMultilineWrapperTags: multilineWrapperTags,
-      __unstablePreserveWhiteSpace: preserveWhiteSpace
-    } = blockAType.attributes[newAttributeKey];
     const convertedValue = (0, _richText.create)({
       html: convertedHtml,
-      multilineTag,
-      multilineWrapperTags,
-      preserveWhiteSpace
+      ...mapRichTextSettings(blockAType.attributes[newAttributeKey])
     });
     const newOffset = convertedValue.text.indexOf(START_OF_SELECTED_AREA);
     const newValue = (0, _richText.remove)(convertedValue, newOffset, newOffset + 1);
     const newHtml = (0, _richText.toHTMLString)({
       value: newValue,
-      multilineTag,
-      preserveWhiteSpace
+      ...mapRichTextSettings(blockAType.attributes[newAttributeKey])
     });
     updatedAttributes[newAttributeKey] = newHtml;
     dispatch.selectionChange(blockA.clientId, newAttributeKey, newOffset, newOffset);
@@ -895,11 +1134,11 @@ exports.mergeBlocks = mergeBlocks;
 
 const removeBlocks = function (clientIds) {
   let selectPrevious = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  return _ref13 => {
+  return _ref16 => {
     let {
       select,
       dispatch
-    } = _ref13;
+    } = _ref16;
 
     if (!clientIds || !clientIds.length) {
       return;
@@ -1066,22 +1305,29 @@ function exitFormattedText() {
 /**
  * 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.
- * @param {number} startOffset  The start offset.
- * @param {number} endOffset    The end offset.
+ * @param {string|WPSelection} clientId     The selected block client ID.
+ * @param {string}             attributeKey The selected block attribute key.
+ * @param {number}             startOffset  The start offset.
+ * @param {number}             endOffset    The end offset.
  *
  * @return {Object} Action object.
  */
 
 
 function selectionChange(clientId, attributeKey, startOffset, endOffset) {
+  if (typeof clientId === 'string') {
+    return {
+      type: 'SELECTION_CHANGE',
+      clientId,
+      attributeKey,
+      startOffset,
+      endOffset
+    };
+  }
+
   return {
     type: 'SELECTION_CHANGE',
-    clientId,
-    attributeKey,
-    startOffset,
-    endOffset
+    ...clientId
   };
 }
 /**
@@ -1094,10 +1340,10 @@ function selectionChange(clientId, attributeKey, startOffset, endOffset) {
  */
 
 
-const insertDefaultBlock = (attributes, rootClientId, index) => _ref14 => {
+const insertDefaultBlock = (attributes, rootClientId, index) => _ref17 => {
   let {
     dispatch
-  } = _ref14;
+  } = _ref17;
   // Abort if there is no default block type (if it has been unregistered).
   const defaultBlockName = (0, _blocks.getDefaultBlockName)();
 
@@ -1194,10 +1440,10 @@ function __unstableMarkNextChangeAsNotPersistent() {
  */
 
 
-const __unstableMarkAutomaticChange = () => _ref15 => {
+const __unstableMarkAutomaticChange = () => _ref18 => {
   let {
     dispatch
-  } = _ref15;
+  } = _ref18;
   dispatch({
     type: 'MARK_AUTOMATIC_CHANGE'
   });
@@ -1221,10 +1467,10 @@ exports.__unstableMarkAutomaticChange = __unstableMarkAutomaticChange;
 
 const setNavigationMode = function () {
   let isNavigationMode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-  return _ref16 => {
+  return _ref19 => {
     let {
       dispatch
-    } = _ref16;
+    } = _ref19;
     dispatch({
       type: 'SET_NAVIGATION_MODE',
       isNavigationMode
@@ -1248,10 +1494,10 @@ exports.setNavigationMode = setNavigationMode;
 
 const setBlockMovingClientId = function () {
   let hasBlockMovingClientId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-  return _ref17 => {
+  return _ref20 => {
     let {
       dispatch
-    } = _ref17;
+    } = _ref20;
     dispatch({
       type: 'SET_BLOCK_MOVING_MODE',
       hasBlockMovingClientId
@@ -1274,11 +1520,11 @@ exports.setBlockMovingClientId = setBlockMovingClientId;
 
 const duplicateBlocks = function (clientIds) {
   let updateSelection = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  return _ref18 => {
+  return _ref21 => {
     let {
       select,
       dispatch
-    } = _ref18;
+    } = _ref21;
 
     if (!clientIds || !clientIds.length) {
       return;
@@ -1319,11 +1565,11 @@ const duplicateBlocks = function (clientIds) {
 
 exports.duplicateBlocks = duplicateBlocks;
 
-const insertBeforeBlock = clientId => _ref19 => {
+const insertBeforeBlock = clientId => _ref22 => {
   let {
     select,
     dispatch
-  } = _ref19;
+  } = _ref22;
 
   if (!clientId) {
     return;
@@ -1348,11 +1594,11 @@ const insertBeforeBlock = clientId => _ref19 => {
 
 exports.insertBeforeBlock = insertBeforeBlock;
 
-const insertAfterBlock = clientId => _ref20 => {
+const insertAfterBlock = clientId => _ref23 => {
   let {
     select,
     dispatch
-  } = _ref20;
+  } = _ref23;
 
   if (!clientId) {
     return;
@@ -1392,10 +1638,10 @@ function toggleBlockHighlight(clientId, isHighlighted) {
  */
 
 
-const flashBlock = clientId => async _ref21 => {
+const flashBlock = clientId => async _ref24 => {
   let {
     dispatch
-  } = _ref21;
+  } = _ref24;
   dispatch(toggleBlockHighlight(clientId, true));
   await new Promise(resolve => setTimeout(resolve, 150));
   dispatch(toggleBlockHighlight(clientId, false));