@wordpress/block-editor 8.3.1 → 8.5.1

package/build-module/store/selectors.js

@@ -1,16 +1,17 @@
 /**
  * External dependencies
  */
-import { castArray, flatMap, first, isArray, isBoolean, last, map, reduce, some, find, filter, mapKeys, orderBy } from 'lodash';
+import { castArray, first, isArray, isBoolean, last, map, reduce, some, find, filter, mapKeys, orderBy } from 'lodash';
 import createSelector from 'rememo';
 /**
  * WordPress dependencies
  */
 
-import { getBlockType, getBlockTypes, getBlockVariations, hasBlockSupport, getPossibleBlockTransformations, parse } from '@wordpress/blocks';
+import { getBlockType, getBlockTypes, getBlockVariations, hasBlockSupport, getPossibleBlockTransformations, parse, switchToBlockType } from '@wordpress/blocks';
 import { Platform } from '@wordpress/element';
 import { applyFilters } from '@wordpress/hooks';
 import { symbol } from '@wordpress/icons';
+import { __ } from '@wordpress/i18n';
 /**
  * A block selection object.
  *
@@ -182,8 +183,9 @@ export const __unstableGetClientIdsTree = createSelector(function (state) {
   return map(getBlockOrder(state, rootClientId), clientId => __unstableGetClientIdWithClientIdsTree(state, clientId));
 }, state => [state.blocks.order]);
 /**
- * Returns an array containing the clientIds of all descendants
- * of the blocks given.
+ * Returns an array containing the clientIds of all descendants of the blocks
+ * given. Returned ids are ordered first by the order of the ids given, then
+ * by the order that they appear in the editor.
  *
  * @param {Object} state     Global application state.
  * @param {Array}  clientIds Array of blocks to inspect.
@@ -191,13 +193,21 @@ export const __unstableGetClientIdsTree = createSelector(function (state) {
  * @return {Array} ids of descendants.
  */
 
-export const getClientIdsOfDescendants = (state, clientIds) => flatMap(clientIds, clientId => {
-  const descendants = getBlockOrder(state, clientId);
-  return [...descendants, ...getClientIdsOfDescendants(state, descendants)];
-});
+export const getClientIdsOfDescendants = createSelector((state, clientIds) => {
+  const collectedIds = [];
+
+  for (const givenId of clientIds) {
+    for (const descendantId of getBlockOrder(state, givenId)) {
+      collectedIds.push(descendantId, ...getClientIdsOfDescendants(state, [descendantId]));
+    }
+  }
+
+  return collectedIds;
+}, state => [state.blocks.order]);
 /**
- * Returns an array containing the clientIds of the top-level blocks
- * and their descendants of any depth (for nested blocks).
+ * Returns an array containing the clientIds of the top-level blocks and
+ * their descendants of any depth (for nested blocks). Ids are returned
+ * in the same order that they appear in the editor.
  *
  * @param {Object} state Global application state.
  *
@@ -205,8 +215,13 @@ export const getClientIdsOfDescendants = (state, clientIds) => flatMap(clientIds
  */
 
 export const getClientIdsWithDescendants = createSelector(state => {
-  const topLevelIds = getBlockOrder(state);
-  return [...topLevelIds, ...getClientIdsOfDescendants(state, topLevelIds)];
+  const collectedIds = [];
+
+  for (const topLevelId of getBlockOrder(state)) {
+    collectedIds.push(topLevelId, ...getClientIdsOfDescendants(state, [topLevelId]));
+  }
+
+  return collectedIds;
 }, state => [state.blocks.order]);
 /**
  * Returns the total number of blocks, or the total number of blocks with a specific name in a post.
@@ -230,6 +245,27 @@ export const getGlobalBlockCount = createSelector((state, blockName) => {
     return block.name === blockName ? accumulator + 1 : accumulator;
   }, 0);
 }, state => [state.blocks.order, state.blocks.byClientId]);
+/**
+ * Returns all global blocks that match a blockName. Results include nested blocks.
+ *
+ * @param {Object}  state     Global application state.
+ * @param {?string} blockName Optional block name, if not specified, returns an empty array.
+ *
+ * @return {Array} Array of clientIds of blocks with name equal to blockName.
+ */
+
+export const __experimentalGetGlobalBlocksByName = createSelector((state, blockName) => {
+  if (!blockName) {
+    return EMPTY_ARRAY;
+  }
+
+  const clientIds = getClientIdsWithDescendants(state);
+  const foundBlocks = clientIds.filter(clientId => {
+    const block = state.blocks.byClientId[clientId];
+    return block.name === blockName;
+  });
+  return foundBlocks.length > 0 ? foundBlocks : EMPTY_ARRAY;
+}, state => [state.blocks.order, state.blocks.byClientId]);
 /**
  * Given an array of block client IDs, returns the corresponding array of block
  * objects.
@@ -804,6 +840,70 @@ export function getMultiSelectedBlocksEndClientId(state) {
 
   return selectionEnd.clientId || null;
 }
+/**
+ * Returns true if the selection is not partial.
+ *
+ * @param {Object} state Editor state.
+ *
+ * @return {boolean} Whether the selection is mergeable.
+ */
+
+export function __unstableIsFullySelected(state) {
+  const selectionAnchor = getSelectionStart(state);
+  const selectionFocus = getSelectionEnd(state);
+  return !selectionAnchor.attributeKey && !selectionFocus.attributeKey && typeof selectionAnchor.offset === 'undefined' && typeof selectionFocus.offset === 'undefined';
+}
+/**
+ * Check whether the selection is mergeable.
+ *
+ * @param {Object}  state     Editor state.
+ * @param {boolean} isForward Whether to merge forwards.
+ *
+ * @return {boolean} Whether the selection is mergeable.
+ */
+
+export function __unstableIsSelectionMergeable(state, isForward) {
+  const selectionAnchor = getSelectionStart(state);
+  const selectionFocus = getSelectionEnd(state); // It's not mergeable if the start and end are within the same block.
+
+  if (selectionAnchor.clientId === selectionFocus.clientId) return false; // 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 = getBlockRootClientId(state, selectionAnchor.clientId);
+  const focusRootClientId = getBlockRootClientId(state, 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 false;
+  }
+
+  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.
+
+  let selectionStart, selectionEnd;
+
+  if (anchorIndex > focusIndex) {
+    selectionStart = selectionFocus;
+    selectionEnd = selectionAnchor;
+  } else {
+    selectionStart = selectionAnchor;
+    selectionEnd = selectionFocus;
+  }
+
+  const targetBlockClientId = isForward ? selectionEnd.clientId : selectionStart.clientId;
+  const blockToMergeClientId = isForward ? selectionStart.clientId : selectionEnd.clientId;
+  const targetBlock = getBlock(state, targetBlockClientId);
+  const targetBlockType = getBlockType(targetBlock.name);
+  if (!targetBlockType.merge) return false;
+  const blockToMerge = getBlock(state, blockToMergeClientId); // It's mergeable if the blocks are of the same type.
+
+  if (blockToMerge.name === targetBlock.name) return true; // If the blocks are of a different type, try to transform the block being
+  // merged into the same type of block.
+
+  const blocksToMerge = switchToBlockType(blockToMerge, targetBlock.name);
+  return blocksToMerge && blocksToMerge.length;
+}
 /**
  * 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
@@ -1196,7 +1296,15 @@ const canInsertBlockTypeUnmemoized = function (state, blockName) {
   const blockAllowedParentBlocks = blockType.parent;
   const parentName = getBlockName(state, rootClientId);
   const hasBlockAllowedParent = checkAllowList(blockAllowedParentBlocks, parentName);
-  const canInsert = hasParentAllowedBlock === null && hasBlockAllowedParent === null || hasParentAllowedBlock === true || hasBlockAllowedParent === true;
+  let hasBlockAllowedAncestor = true;
+  const blockAllowedAncestorBlocks = blockType.ancestor;
+
+  if (blockAllowedAncestorBlocks) {
+    const ancestors = [rootClientId, ...getBlockParents(state, rootClientId)];
+    hasBlockAllowedAncestor = some(ancestors, ancestorClientId => checkAllowList(blockAllowedAncestorBlocks, getBlockName(state, ancestorClientId)));
+  }
+
+  const canInsert = hasBlockAllowedAncestor && (hasParentAllowedBlock === null && hasBlockAllowedParent === null || hasParentAllowedBlock === true || hasBlockAllowedParent === true);
 
   if (!canInsert) {
     return canInsert;
@@ -1271,7 +1379,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;
@@ -1315,7 +1423,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;
@@ -1338,6 +1446,47 @@ 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.
+ *
+ * @param {Object}          state      Editor state.
+ * @param {(string|Object)} nameOrType Block name or type object.
+ *
+ * @return {boolean} Whether a given block type can be locked/unlocked.
+ */
+
+export function canLockBlockType(state, nameOrType) {
+  var _state$settings;
+
+  if (!hasBlockSupport(nameOrType, 'lock', true)) {
+    return false;
+  } // Use block editor settings as the default value.
+
+
+  return !!((_state$settings = state.settings) !== null && _state$settings !== void 0 && _state$settings.canLockBlocks);
+}
 /**
  * Returns information about how recently and frequently a block has been inserted.
  *
@@ -1666,7 +1815,10 @@ export const getInserterItems = createSelector(function (state) {
  */
 
 export const getBlockTransformItems = createSelector(function (state, blocks) {
+  var _itemsByName$sourceBl;
+
   let rootClientId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+  const [sourceBlock] = blocks;
   const buildBlockTypeTransformItem = buildBlockTypeItem(state, {
     buildScope: 'transform'
   });
@@ -1676,16 +1828,26 @@ export const getBlockTransformItems = createSelector(function (state, blocks) {
       name
     } = _ref5;
     return name;
-  });
+  }); // Consider unwraping the highest priority.
+
+  itemsByName['*'] = {
+    frecency: +Infinity,
+    id: '*',
+    isDisabled: false,
+    name: '*',
+    title: __('Unwrap'),
+    icon: (_itemsByName$sourceBl = itemsByName[sourceBlock.name]) === null || _itemsByName$sourceBl === void 0 ? void 0 : _itemsByName$sourceBl.icon
+  };
   const possibleTransforms = getPossibleBlockTransformations(blocks).reduce((accumulator, block) => {
-    if (itemsByName[block === null || block === void 0 ? void 0 : block.name]) {
+    if (block === '*') {
+      accumulator.push(itemsByName['*']);
+    } else if (itemsByName[block === null || block === void 0 ? void 0 : block.name]) {
       accumulator.push(itemsByName[block.name]);
     }
 
     return accumulator;
   }, []);
-  const possibleBlockTransformations = orderBy(possibleTransforms, block => itemsByName[block.name].frecency, 'desc');
-  return possibleBlockTransformations;
+  return orderBy(possibleTransforms, block => itemsByName[block.name].frecency, 'desc');
 }, (state, rootClientId) => [state.blockListSettings[rootClientId], state.blocks.byClientId, state.preferences.insertUsage, state.settings.allowedBlockTypes, state.settings.templateLock, getBlockTypes()]);
 /**
  * Determines whether there are items to show in the inserter.
@@ -1801,7 +1963,9 @@ export const __experimentalGetParsedPattern = createSelector((state, patternName
   }
 
   return { ...pattern,
-    blocks: parse(pattern.content)
+    blocks: parse(pattern.content, {
+      __unstableSkipMigrationLogs: true
+    })
   };
 }, state => [state.settings.__experimentalBlockPatterns]);
 const getAllAllowedPatterns = createSelector(state => {
@@ -2053,9 +2217,9 @@ export function __experimentalGetLastBlockAttributeChanges(state) {
  */
 
 function getReusableBlocks(state) {
-  var _state$settings$__exp, _state$settings;
+  var _state$settings$__exp, _state$settings2;
 
-  return (_state$settings$__exp = state === null || state === void 0 ? void 0 : (_state$settings = state.settings) === null || _state$settings === void 0 ? void 0 : _state$settings.__experimentalReusableBlocks) !== null && _state$settings$__exp !== void 0 ? _state$settings$__exp : EMPTY_ARRAY;
+  return (_state$settings$__exp = state === null || state === void 0 ? void 0 : (_state$settings2 = state.settings) === null || _state$settings2 === void 0 ? void 0 : _state$settings2.__experimentalReusableBlocks) !== null && _state$settings$__exp !== void 0 ? _state$settings$__exp : EMPTY_ARRAY;
 }
 /**
  * Returns whether the navigation mode is enabled.