@wordpress/block-editor 8.5.0 → 8.5.3

package/build-module/store/selectors.js

@@ -12,6 +12,12 @@ import { Platform } from '@wordpress/element';
 import { applyFilters } from '@wordpress/hooks';
 import { symbol } from '@wordpress/icons';
 import { __ } from '@wordpress/i18n';
+import { create, remove, toHTMLString } from '@wordpress/rich-text';
+/**
+ * Internal dependencies
+ */
+
+import { mapRichTextSettings } from './utils';
 /**
  * A block selection object.
  *
@@ -853,6 +859,19 @@ export function __unstableIsFullySelected(state) {
   const selectionFocus = getSelectionEnd(state);
   return !selectionAnchor.attributeKey && !selectionFocus.attributeKey && typeof selectionAnchor.offset === 'undefined' && typeof selectionFocus.offset === 'undefined';
 }
+/**
+ * Returns true if the selection is collapsed.
+ *
+ * @param {Object} state Editor state.
+ *
+ * @return {boolean} Whether the selection is collapsed.
+ */
+
+export function __unstableIsSelectionCollapsed(state) {
+  const selectionAnchor = getSelectionStart(state);
+  const selectionFocus = getSelectionEnd(state);
+  return !!selectionAnchor && !!selectionFocus && selectionAnchor.clientId === selectionFocus.clientId && selectionAnchor.attributeKey === selectionFocus.attributeKey && selectionAnchor.offset === selectionFocus.offset;
+}
 /**
  * Check whether the selection is mergeable.
  *
@@ -904,6 +923,75 @@ export function __unstableIsSelectionMergeable(state, isForward) {
   const blocksToMerge = switchToBlockType(blockToMerge, targetBlock.name);
   return blocksToMerge && blocksToMerge.length;
 }
+/**
+ * Get partial selected blocks with their content updated
+ * based on the selection.
+ *
+ * @param {Object} state Editor state.
+ *
+ * @return {Object[]} Updated partial selected blocks.
+ */
+
+export const __unstableGetSelectedBlocksWithPartialSelection = state => {
+  const selectionAnchor = getSelectionStart(state);
+  const selectionFocus = getSelectionEnd(state);
+
+  if (selectionAnchor.clientId === selectionFocus.clientId) {
+    return EMPTY_ARRAY;
+  } // Can't split if the selection is not set.
+
+
+  if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === 'undefined' || typeof selectionFocus.offset === 'undefined') {
+    return EMPTY_ARRAY;
+  }
+
+  const anchorRootClientId = getBlockRootClientId(state, selectionAnchor.clientId);
+  const focusRootClientId = getBlockRootClientId(state, 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 EMPTY_ARRAY;
+  }
+
+  const blockOrder = getBlockOrder(state, anchorRootClientId);
+  const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
+  const focusIndex = blockOrder.indexOf(selectionFocus.clientId); // Reassign selection start and end based on order.
+
+  const [selectionStart, selectionEnd] = anchorIndex > focusIndex ? [selectionFocus, selectionAnchor] : [selectionAnchor, selectionFocus];
+  const blockA = getBlock(state, selectionStart.clientId);
+  const blockAType = getBlockType(blockA.name);
+  const blockB = getBlock(state, selectionEnd.clientId);
+  const blockBType = getBlockType(blockB.name);
+  const htmlA = blockA.attributes[selectionStart.attributeKey];
+  const htmlB = blockB.attributes[selectionEnd.attributeKey];
+  const attributeDefinitionA = blockAType.attributes[selectionStart.attributeKey];
+  const attributeDefinitionB = blockBType.attributes[selectionEnd.attributeKey];
+  let valueA = create({
+    html: htmlA,
+    ...mapRichTextSettings(attributeDefinitionA)
+  });
+  let valueB = create({
+    html: htmlB,
+    ...mapRichTextSettings(attributeDefinitionB)
+  });
+  valueA = remove(valueA, 0, selectionStart.offset);
+  valueB = remove(valueB, selectionEnd.offset, valueB.text.length);
+  return [{ ...blockA,
+    attributes: { ...blockA.attributes,
+      [selectionStart.attributeKey]: toHTMLString({
+        value: valueA,
+        ...mapRichTextSettings(attributeDefinitionA)
+      })
+    }
+  }, { ...blockB,
+    attributes: { ...blockB.attributes,
+      [selectionEnd.attributeKey]: toHTMLString({
+        value: valueB,
+        ...mapRichTextSettings(attributeDefinitionB)
+      })
+    }
+  }];
+};
 /**
  * Returns an array containing all block client IDs in the editor in the order
  * they appear. Optionally accepts a root client ID of the block list for which
@@ -1379,7 +1467,7 @@ export function canRemoveBlock(state, clientId) {
   const {
     lock
   } = attributes;
-  const parentIsLocked = !!getTemplateLock(state, rootClientId); // If we don't have a lock on the blockType level, we differ to the parent templateLock.
+  const parentIsLocked = !!getTemplateLock(state, rootClientId); // If we don't have a lock on the blockType level, we defer to the parent templateLock.
 
   if (lock === undefined || (lock === null || lock === void 0 ? void 0 : lock.remove) === undefined) {
     return !parentIsLocked;
@@ -1423,7 +1511,7 @@ export function canMoveBlock(state, clientId) {
   const {
     lock
   } = attributes;
-  const parentIsLocked = getTemplateLock(state, rootClientId) === 'all'; // If we don't have a lock on the blockType level, we differ to the parent templateLock.
+  const parentIsLocked = getTemplateLock(state, rootClientId) === 'all'; // If we don't have a lock on the blockType level, we defer to the parent templateLock.
 
   if (lock === undefined || (lock === null || lock === void 0 ? void 0 : lock.move) === undefined) {
     return !parentIsLocked;
@@ -1446,6 +1534,28 @@ export function canMoveBlocks(state, clientIds) {
   let rootClientId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
   return clientIds.every(clientId => canMoveBlock(state, clientId, rootClientId));
 }
+/**
+ * Determines if the given block is allowed to be edited.
+ *
+ * @param {Object} state    Editor state.
+ * @param {string} clientId The block client Id.
+ *
+ * @return {boolean} Whether the given block is allowed to be edited.
+ */
+
+export function canEditBlock(state, clientId) {
+  const attributes = getBlockAttributes(state, clientId);
+
+  if (attributes === null) {
+    return true;
+  }
+
+  const {
+    lock
+  } = attributes; // When the edit is true, we cannot edit the block.
+
+  return !(lock !== null && lock !== void 0 && lock.edit);
+}
 /**
  * Determines if the given block type can be locked/unlocked by a user.
  *