@portabletext/editor 7.10.0 → 7.10.2

package/lib/index.js

@@ -3,13 +3,13 @@ import { c } from "react/compiler-runtime";
 import { useSelector, useActorRef } from "@xstate/react";
 import React, { createContext, useContext, useRef, useEffect, useLayoutEffect, useState, useReducer, useCallback, memo, forwardRef, useMemo, Component, useSyncExternalStore, startTransition } from "react";
 import { serializePath, isKeyedSegment, getNode, getParent, parentPath, getChildren, getNodeChildren } from "./_chunks-es/get-parent.js";
-import { isPath, getLeaf, isRange, isPoint, isObject, isLeafObject, getAncestor, pathContains, getSpan, isBeforePoint, getText, rangeIntersects, getTextBlock, getUnionSchema, getFirstChild, getContainer } from "./_chunks-es/get-container.js";
+import { isPath, getLeaf, isRange, isPoint, isObject, isLeafObject, getAncestor, pathContains, getSpan, isBeforePoint, getText, rangeIntersects, getTextBlock, getFirstChild, getLastChild, getUnionSchema, getContainer } from "./_chunks-es/get-container.js";
 import { rangeEdges, isTextBlockNode, isBackwardRange, hasNode, getNodes, isAncestorPath, isEditableContainer, getSibling, isInline, isObject as isObject$1, isSpanNode, isBlock, getEnclosingBlock, getAncestors, getPathSubSchema, getBlock, resolveContainerAt, resolveChildEntryIndex, getEnclosingContainer, comparePoints$1 as comparePoints, comparePaths, isAfterPoint } from "./_chunks-es/get-path-sub-schema.js";
 import { isSpan, isTextBlock, getSubSchema, compileSchema } from "@portabletext/schema";
 import { defineSchema } from "@portabletext/schema";
 import scrollIntoView from "scroll-into-view-if-needed";
 import { createKeyboardShortcut, undo, redo, code, underline, italic as italic$1, bold as bold$1 } from "@portabletext/keyboard-shortcuts";
-import { rangesOverlap, getFocusInlineObject, isSelectionCollapsed as isSelectionCollapsed$1, getFocusTextBlock, getFocusSpan, getFragment, isSelectionExpanded, getSelectionStartBlock, getSelectionEndBlock, isOverlappingSelection, getFocusBlock, getSelectedBlocks, isSelectingEntireBlocks, getSelectedValue, isActiveAnnotation, getActiveAnnotationsMarks, getActiveDecorators, getCaretWordSelection, getSelectionStartChild, getSelectionStartPoint, getSelectionEndChild, getSelectionEndPoint, getPreviousSpan, getNextSpan, getFocusBlockObject, getLastBlock, getFirstBlock, isAtTheEndOfBlock, isAtTheStartOfBlock, getRootAcceptedTypes, getMarkState, getFocusListBlock, getNextBlock, getPreviousBlock, getSelectedTextBlocks, isActiveDecorator, getFocusChild, getActiveAnnotations, isActiveListItem, isActiveStyle } from "./_chunks-es/selector.is-at-the-start-of-block.js";
+import { rangesOverlap, getFocusInlineObject, isSelectionCollapsed as isSelectionCollapsed$1, getFocusTextBlock, getFocusSpan, getFragment, isSelectionExpanded, getSelectionStartBlock, getSelectionEndBlock, isOverlappingSelection, getFocusBlock, getSelectedBlocks, isSelectingEntireBlocks, getSelectedValue, isActiveAnnotation, getActiveAnnotationsMarks, getActiveDecorators, getCaretWordSelection, getSelectionStartChild, getSelectionStartPoint, getSelectionEndChild, getSelectionEndPoint, getPreviousSpan, getNextSpan, getFocusBlockObject, isAtTheEndOfBlock, isAtTheStartOfBlock, getLastBlock, getRootAcceptedTypes, getMarkState, getFocusListBlock, getNextBlock, getPreviousBlock, getSelectedTextBlocks, isActiveDecorator, getFocusChild, getActiveAnnotations, isActiveListItem, isActiveStyle } from "./_chunks-es/selector.is-at-the-start-of-block.js";
 import { isEqualSelectionPoints, blockOffsetToSpanSelectionPoint, getBlockKeyFromSelectionPoint, getBlockEndPoint, getBlockStartPoint, isSelectionCollapsed, defaultKeyGenerator, parseBlocks, parseBlock, isListBlock, getSelectionStartPoint as getSelectionStartPoint$1, getSelectionEndPoint as getSelectionEndPoint$1, parseAnnotation, parseMarkDefs, parseSpan, parseInlineObject } from "./_chunks-es/util.slice-blocks.js";
 import rawDebug from "debug";
 import { isEmptyTextBlock, isEqualSelections, getTextBlockText } from "./_chunks-es/util.is-equal-selections.js";
@@ -3900,7 +3900,14 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
         return;
     }
     leafEl.getBoundingClientRect = domFocusPoint.getBoundingClientRect.bind(domFocusPoint), scrollIntoView(leafEl, {
-      scrollMode: "if-needed"
+      scrollMode: "if-needed",
+      // Native-caret semantics: the minimal delta to the nearest edge. The
+      // library's default `block: 'center'` re-centered the viewport on
+      // every sync whose focus was even slightly clipped, yanking the
+      // editor around on programmatic selects (a table handle click whose
+      // rectangle ends in an off-screen column, for example).
+      block: "nearest",
+      inline: "nearest"
     }), delete leafEl.getBoundingClientRect;
   }
 }, isEventHandled = (event, handler) => handler ? handler(event) ?? (event.isDefaultPrevented() || event.isPropagationStopped()) : !1, isDOMEventTargetInput = (event) => isDOMNode(event.target) && (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement), isDOMEventHandled = (event, handler) => handler ? handler(event) ?? event.defaultPrevented : !1, handleNativeHistoryEvents = (editor, editorActor, event) => {
@@ -4127,7 +4134,7 @@ function getEventPosition({
         }
       }
     };
-  if (eventPositionBlock && !isEditor(eventNode) && isEditableContainer(editorEngine.snapshot, eventNode, eventPath) && isDragEvent(event))
+  if (eventPositionBlock && !isEditor(eventNode) && isEditableContainer(editorEngine.snapshot, eventNode, eventPath) && (isDragEvent(event) || event.type === "click"))
     return {
       block: eventPositionBlock,
       isEditor: !1,
@@ -7717,6 +7724,15 @@ function transformRangeRef(ref, op, root) {
   });
   ref.current = path2, path2 == null && ref.unref();
 }
+function splitNodePath(path2) {
+  let nodePathEnd = path2.length;
+  for (; nodePathEnd > 0 && typeof path2[nodePathEnd - 1] == "string"; )
+    nodePathEnd--;
+  return {
+    nodePath: path2.slice(0, nodePathEnd),
+    propertyPath: path2.slice(nodePathEnd)
+  };
+}
 function findNearestSpans(snapshot, path2) {
   return {
     previousSpan: findPreviousSpan(snapshot, path2),
@@ -7787,10 +7803,7 @@ function lastSpanIn(snapshot, path2) {
     return entry;
 }
 function nodeParentPath(path2) {
-  let end2 = path2.length - 1;
-  for (; end2 > 0 && typeof path2[end2 - 1] == "string"; )
-    end2--;
-  return path2.slice(0, end2);
+  return splitNodePath(path2.slice(0, -1)).nodePath;
 }
 function getValue(root, path2) {
   let current = root;
@@ -8021,7 +8034,7 @@ function applyOperation(editor, op) {
       const {
         nodePath: setNodePath,
         propertyPath: setPropertyPath
-      } = splitNodeAndPropertyPath(path2);
+      } = splitNodePath(path2);
       if (setNodePath.length === 0)
         break;
       if (setPropertyPath.length === 0) {
@@ -8122,7 +8135,7 @@ function applyOperation(editor, op) {
       const {
         nodePath: unsetNodePath,
         propertyPath: unsetPropertyPath
-      } = splitNodeAndPropertyPath(path2);
+      } = splitNodePath(path2);
       if (unsetPropertyPath.length === 0 || unsetNodePath.length === 0)
         break;
       if (!op.inverse && !editor.isProcessingRemoteChanges) {
@@ -8229,26 +8242,6 @@ function resolveBlockIndex(editor, segment) {
   const value = editor.snapshot.context.value, index = editor.blockIndexMap.get(serializePath([segment]));
   return index !== void 0 && value[index]?._key === segment._key ? index : value.findIndex((block) => block._key === segment._key);
 }
-function splitNodeAndPropertyPath(path2) {
-  let lastKeyedOrNumericIndex = -1;
-  for (let i = path2.length - 1; i >= 0; i--) {
-    const segment = path2[i];
-    if (isKeyedSegment(segment) || typeof segment == "number") {
-      lastKeyedOrNumericIndex = i;
-      break;
-    }
-  }
-  if (lastKeyedOrNumericIndex === -1)
-    return {
-      nodePath: [],
-      propertyPath: path2.filter((segment) => typeof segment == "string")
-    };
-  const nodePath = path2.slice(0, lastKeyedOrNumericIndex + 1), propertyPath = path2.slice(lastKeyedOrNumericIndex + 1).filter((segment) => typeof segment == "string");
-  return {
-    nodePath,
-    propertyPath
-  };
-}
 function deepSet(node, propertyPath, value) {
   if (propertyPath.length === 0)
     return node;
@@ -10489,7 +10482,7 @@ function transformBlockIndexMap(map, op, beforeValue, afterValue, context) {
         return;
       }
       if (typeof op.path[op.path.length - 1] == "string") {
-        hasKeyedEntries(resolveValueAtPath(beforeValue, op.path)) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
+        hasKeyedEntries(getValue(beforeValue, op.path)) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
         return;
       }
       const removeIndex = childIndexFromMap(map, beforeValue, op.path);
@@ -10517,7 +10510,7 @@ function transformBlockIndexMap(map, op, beforeValue, afterValue, context) {
           handleKeyChange(map, beforeValue, afterValue, op.path.slice(0, -1), context);
           return;
         }
-        (op.value !== null && typeof op.value == "object" || hasKeyedEntries(resolveValueAtPath(beforeValue, op.path))) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
+        (op.value !== null && typeof op.value == "object" || hasKeyedEntries(getValue(beforeValue, op.path))) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
         return;
       }
       const childIndex = childIndexFromMap(map, beforeValue, op.path);
@@ -10654,33 +10647,14 @@ function resolveIndexableNode(context, value, keyedPath) {
   };
 }
 function reconcileOwnerSubtree(map, context, beforeValue, afterValue, propertyPath) {
-  let ownerPathEnd = propertyPath.length;
-  for (; ownerPathEnd > 0 && typeof propertyPath[ownerPathEnd - 1] == "string"; )
-    ownerPathEnd--;
-  if (ownerPathEnd === 0)
-    return;
-  const ownerPath = propertyPath.slice(0, ownerPathEnd);
-  pruneSubtreeAtPath(
+  const ownerPath = splitNodePath(propertyPath).nodePath;
+  ownerPath.length !== 0 && (pruneSubtreeAtPath(
     map,
     beforeValue,
     ownerPath,
     /*keepSelf*/
     !0
-  ), addSubtree(map, context, afterValue, ownerPath);
-}
-function resolveValueAtPath(value, path2) {
-  let nodePathEnd = path2.length;
-  for (; nodePathEnd > 0 && typeof path2[nodePathEnd - 1] == "string"; )
-    nodePathEnd--;
-  if (nodePathEnd === 0)
-    return;
-  let current = resolveNodeAtPath(value, path2.slice(0, nodePathEnd));
-  for (let i = nodePathEnd; i < path2.length; i++) {
-    if (current === null || typeof current != "object")
-      return;
-    current = current[path2[i]];
-  }
-  return current;
+  ), addSubtree(map, context, afterValue, ownerPath));
 }
 function hasKeyedEntries(value) {
   return Array.isArray(value) && value.some((entry) => entry !== null && typeof entry == "object" && entry._key !== void 0);
@@ -11309,32 +11283,36 @@ const addAnnotationOnCollapsedSelection = defineBehavior({
   }) => {
     if (snapshot.context.readOnly || snapshot.context.selection && !isSelectionCollapsed$1(snapshot))
       return !1;
-    const positionSnapshot = {
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: event.position.selection
-      }
-    }, focusedBlockObject = getFocusBlockObject(positionSnapshot);
-    if (!focusedBlockObject)
+    const focusPath = event.position.selection.focus.path, focusBlock = event.position.isEditor ? focusPath.length >= 1 ? getNode(snapshot, focusPath.slice(0, 1)) : void 0 : event.position.isContainer ? getFirstChild(snapshot, focusPath) : void 0;
+    if (!focusBlock || isTextBlockNode(snapshot.context, focusBlock.node) || event.position.isContainer && !acceptsTextBlock(snapshot, focusBlock.path))
       return !1;
-    const previousSibling = getSibling(snapshot, focusedBlockObject.path, {
+    const previousSibling = getSibling(snapshot, focusBlock.path, {
       direction: "previous"
     });
-    return (event.position.isEditor || event.position.isContainer) && event.position.block === "start" && !previousSibling;
+    return (event.position.isEditor || event.position.isContainer) && event.position.block === "start" && !previousSibling ? {
+      blockPath: focusBlock.path
+    } : !1;
   },
   actions: [({
-    snapshot,
-    event
+    snapshot
+  }, {
+    blockPath
   }) => [raise({
-    type: "select",
-    at: event.position.selection
-  }), raise({
     type: "insert.block",
     block: {
       _type: snapshot.context.schema.block.name
     },
     placement: "before",
+    at: {
+      anchor: {
+        path: blockPath,
+        offset: 0
+      },
+      focus: {
+        path: blockPath,
+        offset: 0
+      }
+    },
     select: "start"
   })]]
 }), clickingBelowLonelyBlockObject = defineBehavior({
@@ -11345,35 +11323,44 @@ const addAnnotationOnCollapsedSelection = defineBehavior({
   }) => {
     if (snapshot.context.readOnly || snapshot.context.selection && !isSelectionCollapsed$1(snapshot))
       return !1;
-    const positionSnapshot = {
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: event.position.selection
-      }
-    }, focusedBlockObject = getFocusBlockObject(positionSnapshot);
-    if (!focusedBlockObject)
+    const focusPath = event.position.selection.focus.path, focusBlock = event.position.isEditor ? focusPath.length >= 1 ? getNode(snapshot, focusPath.slice(0, 1)) : void 0 : event.position.isContainer ? getLastChild(snapshot, focusPath) : void 0;
+    if (!focusBlock || isTextBlockNode(snapshot.context, focusBlock.node) || event.position.isContainer && !acceptsTextBlock(snapshot, focusBlock.path))
       return !1;
-    const nextSibling = getSibling(snapshot, focusedBlockObject.path, {
+    const nextSibling = getSibling(snapshot, focusBlock.path, {
       direction: "next"
     });
-    return (event.position.isEditor || event.position.isContainer) && event.position.block === "end" && !nextSibling;
+    return (event.position.isEditor || event.position.isContainer) && event.position.block === "end" && !nextSibling ? {
+      blockPath: focusBlock.path
+    } : !1;
   },
   actions: [({
-    snapshot,
-    event
+    snapshot
+  }, {
+    blockPath
   }) => [raise({
-    type: "select",
-    at: event.position.selection
-  }), raise({
     type: "insert.block",
     block: {
       _type: snapshot.context.schema.block.name
     },
     placement: "after",
+    at: {
+      anchor: {
+        path: blockPath,
+        offset: 0
+      },
+      focus: {
+        path: blockPath,
+        offset: 0
+      }
+    },
     select: "start"
   })]]
-}), deletingEmptyTextBlockAfterBlockObject = defineBehavior({
+});
+function acceptsTextBlock(snapshot, path2) {
+  const enclosing = getEnclosingContainer(snapshot, path2);
+  return !enclosing || enclosing.of.some((member) => member.type === snapshot.context.schema.block.name);
+}
+const deletingEmptyTextBlockAfterBlockObject = defineBehavior({
   on: "delete.backward",
   guard: ({
     snapshot
@@ -11459,34 +11446,80 @@ const addAnnotationOnCollapsedSelection = defineBehavior({
   clickingBelowLonelyBlockObject,
   deletingEmptyTextBlockAfterBlockObject,
   deletingEmptyTextBlockBeforeBlockObject
-}, arrowDownOutOfContainer = defineBehavior({
+}, anyArrowDown = createKeyboardShortcut({
+  default: [{
+    key: "ArrowDown"
+  }]
+}), anyArrowUp = createKeyboardShortcut({
+  default: [{
+    key: "ArrowUp"
+  }]
+}), arrowDownOutOfContainer = defineBehavior({
   on: "keyboard.keydown",
   guard: ({
     snapshot,
     event
-  }) => event.originEvent.key === "ArrowDown" && isAtContainerDeadEnd(snapshot, "end"),
-  actions: []
+  }) => !anyArrowDown.guard(event.originEvent) || !isAtContainerDeadEnd(snapshot, "end") ? !1 : {
+    escapeTarget: arrowEscapeTarget(snapshot, event.originEvent, "end")
+  },
+  actions: [({
+    snapshot
+  }, {
+    escapeTarget
+  }) => escapeTarget ? [escapeAction(snapshot, escapeTarget, "after")] : []]
 }), arrowUpOutOfContainer = defineBehavior({
   on: "keyboard.keydown",
   guard: ({
     snapshot,
     event
-  }) => event.originEvent.key === "ArrowUp" && isAtContainerDeadEnd(snapshot, "start"),
-  actions: []
+  }) => !anyArrowUp.guard(event.originEvent) || !isAtContainerDeadEnd(snapshot, "start") ? !1 : {
+    escapeTarget: arrowEscapeTarget(snapshot, event.originEvent, "start")
+  },
+  actions: [({
+    snapshot
+  }, {
+    escapeTarget
+  }) => escapeTarget ? [escapeAction(snapshot, escapeTarget, "before")] : []]
 });
+function arrowEscapeTarget(snapshot, originEvent, edge) {
+  if (!(edge === "end" ? defaultKeyboardShortcuts.arrowDown.guard(originEvent) : defaultKeyboardShortcuts.arrowUp.guard(originEvent)))
+    return;
+  const focusTextBlock = getFocusTextBlock(snapshot);
+  return focusTextBlock ? getEscapeTarget(snapshot, focusTextBlock.path) : void 0;
+}
+function escapeAction(snapshot, escapeTarget, placement) {
+  return raise({
+    type: "insert.block",
+    block: createPlaceholderBlock(snapshot, escapeTarget),
+    placement,
+    at: {
+      anchor: {
+        path: escapeTarget,
+        offset: 0
+      },
+      focus: {
+        path: escapeTarget,
+        offset: 0
+      }
+    },
+    select: "start"
+  });
+}
 function isAtContainerDeadEnd(snapshot, edge) {
   if (!isSelectionCollapsed$1(snapshot))
     return !1;
   const focusTextBlock = getFocusTextBlock(snapshot);
-  if (!focusTextBlock)
-    return !1;
-  const container = getAncestor(snapshot, focusTextBlock.path, {
+  if (!focusTextBlock || !getAncestor(snapshot, focusTextBlock.path, {
     match: (node, path2) => isEditableContainer(snapshot, node, path2)
-  });
-  if (!container)
+  }))
+    return !1;
+  const rootSegment = focusTextBlock.path[0];
+  if (!rootSegment)
     return !1;
-  const edgeBlock = edge === "end" ? getLastBlock(snapshot) : getFirstBlock(snapshot);
-  return !edgeBlock || !pathEquals(edgeBlock.path, focusTextBlock.path) || !(edge === "end" ? isAtTheEndOfBlock(focusTextBlock)(snapshot) : isAtTheStartOfBlock(focusTextBlock)(snapshot)) ? !1 : getSibling(snapshot, container.path, {
+  const outerPath = [rootSegment], edgeLeaf = getLeaf(snapshot, outerPath, {
+    edge
+  }), edgeBlock = edgeLeaf && getEnclosingBlock(snapshot, edgeLeaf.path);
+  return !edgeBlock || !pathEquals(edgeBlock.path, focusTextBlock.path) || !(edge === "end" ? isAtTheEndOfBlock(focusTextBlock)(snapshot) : isAtTheStartOfBlock(focusTextBlock)(snapshot)) ? !1 : getSibling(snapshot, outerPath, {
     direction: edge === "end" ? "next" : "previous"
   }) === void 0;
 }
@@ -16900,15 +16933,17 @@ function synthesizeBlockChildrenField(schema) {
     of: ofMembers
   };
 }
-function resolveFieldOn(fields, type, fieldName) {
+function resolveFieldOn(fields, fieldName) {
   const field = fields.find((candidate) => candidate.name === fieldName);
-  if (!(!field || !isChildArrayField(field))) {
-    if (containsOnlyPrimitiveTypes(field)) {
-      console.warn(`Field '${field.name}' on '${type}' doesn't contain block or container types and will be excluded`);
-      return;
-    }
-    return field;
-  }
+  return field ? isChildArrayField(field) ? containsOnlyPrimitiveTypes(field) ? {
+    failure: "field-primitive-only"
+  } : {
+    field
+  } : {
+    failure: "field-not-array"
+  } : {
+    failure: "field-missing"
+  };
 }
 function findInlineDeclarationIn(parentOf, type) {
   for (const member of parentOf)
@@ -16936,28 +16971,35 @@ function findInlineFields(schema, type) {
         isChildArrayField(field) && walk(field.of);
   return best;
 }
-function resolveContainerField(schema, type, fieldName, parentOf) {
+function resolveContainerFieldResolution(schema, type, fieldName, parentOf) {
   if (type === "block")
-    return fieldName !== "children" ? void 0 : synthesizeBlockChildrenField(schema);
+    return fieldName !== "children" ? {
+      failure: "field-missing"
+    } : {
+      field: synthesizeBlockChildrenField(schema)
+    };
   if (parentOf) {
     const inlineMatch = findInlineDeclarationIn(parentOf, type);
     if (inlineMatch)
-      return resolveFieldOn(inlineMatch, type, fieldName);
+      return resolveFieldOn(inlineMatch, fieldName);
   }
   const rootMatch = schema.blockObjects.find((blockObject) => blockObject.name === type), rootFields = rootMatch && "fields" in rootMatch && rootMatch.fields && rootMatch.fields.length > 0 ? rootMatch.fields : void 0, inlineFields = rootFields ? void 0 : findInlineFields(schema, type), fields = rootFields ?? inlineFields;
-  if (fields)
-    return resolveFieldOn(fields, type, fieldName);
+  return fields ? resolveFieldOn(fields, fieldName) : rootMatch ? {
+    failure: "field-missing"
+  } : {
+    failure: "unknown-type"
+  };
 }
 function resolveNestedContainer(schema, container, chain = [], onFailure = "warn", parentOf) {
-  const field = resolveContainerField(schema, container.type, container.arrayField, parentOf);
-  if (!field) {
-    const location = chain.length > 0 ? ` (nested inside ${chain.map((type) => `"${type}"`).join(" inside ")})` : "", message = `registerNode: field "${container.arrayField}" not found on type "${container.type}"${location}. Registration skipped.`;
+  const resolution = resolveContainerFieldResolution(schema, container.type, container.arrayField, parentOf);
+  if ("failure" in resolution) {
+    const location = chain.length > 0 ? ` (nested inside ${chain.map((type) => `"${type}"`).join(" inside ")})` : "", message = `registerNode: ${describeContainerFailure(resolution.failure, container)}${location}. Registration skipped.`;
     if (onFailure === "throw")
       throw new Error(message);
     console.warn(message);
     return;
   }
-  const nextChain = [...chain, container.type], resolvedOf = container.of ? container.of.flatMap((entry) => {
+  const field = resolution.field, nextChain = [...chain, container.type], resolvedOf = container.of ? container.of.flatMap((entry) => {
     if (entry.kind === "container") {
       const resolved = resolveNestedContainer(schema, entry, nextChain, onFailure, field.of);
       return resolved ? [resolved] : [];
@@ -16974,6 +17016,18 @@ function resolveNestedContainer(schema, container, chain = [], onFailure = "warn
     } : {}
   };
 }
+function describeContainerFailure(failure, container) {
+  switch (failure) {
+    case "unknown-type":
+      return `type "${container.type}" not found in the schema`;
+    case "field-missing":
+      return `field "${container.arrayField}" not found on type "${container.type}"`;
+    case "field-not-array":
+      return `field "${container.arrayField}" on type "${container.type}" is not an array`;
+    case "field-primitive-only":
+      return `field "${container.arrayField}" on type "${container.type}" contains only primitive types and cannot hold block content`;
+  }
+}
 function resolveTextBlockConfig(textBlock) {
   const resolvedOf = textBlock.of ? textBlock.of.flatMap((entry) => entry.kind === "span" ? [{
     span: entry