@portabletext/editor 7.8.1 → 7.9.0

package/lib/index.js

@@ -8890,22 +8890,20 @@ const normalizeNode = (editor, entry) => {
     return;
   }
   if (path2.length > 0 && nodeRecord._key !== void 0) {
-    const parent = getParent(editor.snapshot, path2), siblingList = [...parent ? getChildren(editor.snapshot, parent.path) : editor.snapshot.context.value.map((child, index) => ({
-      node: child,
-      path: [{
-        _key: child._key
-      }],
-      index
-    }))], key = nodeRecord._key;
-    let firstIndex = -1;
-    for (let i = 0; i < siblingList.length; i++)
-      if (siblingList[i].node._key === key)
-        if (firstIndex === -1)
-          firstIndex = i;
-        else {
+    const parent = getParent(editor.snapshot, path2), key = nodeRecord._key, childFieldName = parent ? path2[parent.path.length] : void 0, rawSiblings = parent && typeof childFieldName == "string" ? parent.node[childFieldName] : void 0, siblingNodes = parent ? Array.isArray(rawSiblings) ? rawSiblings : getChildren(editor.snapshot, parent.path).map((entry2) => entry2.node) : editor.snapshot.context.value;
+    if (siblingNodes.length > 1) {
+      const groupId2 = parent && typeof childFieldName == "string" ? serializePath([...parent.path, childFieldName]) : "";
+      if (!editor.verifiedUniqueChildGroups.has(groupId2)) {
+        const seenKeys = /* @__PURE__ */ new Set();
+        let groupIsUnique = !0, duplicateIndexOfKey = -1;
+        for (let index = 0; index < siblingNodes.length; index++) {
+          const siblingKey = siblingNodes[index]?._key;
+          siblingKey !== void 0 && (seenKeys.has(siblingKey) ? (groupIsUnique = !1, siblingKey === key && duplicateIndexOfKey === -1 && (duplicateIndexOfKey = index)) : seenKeys.add(siblingKey));
+        }
+        if (duplicateIndexOfKey !== -1) {
           const newKey = editor.snapshot.context.keyGenerator();
           debug.normalization("Fixing duplicate key on node");
-          const dupParentPath = parent ? parent.path : [], numericPath = dupParentPath.length === 0 ? [i] : [...dupParentPath, getChildFieldName(editor.snapshot.context, parent.path) ?? "children", i];
+          const numericPath = parent && typeof childFieldName == "string" ? [...parent.path, childFieldName, duplicateIndexOfKey] : [duplicateIndexOfKey];
           editor.apply({
             type: "set",
             path: [...numericPath, "_key"],
@@ -8918,6 +8916,9 @@ const normalizeNode = (editor, entry) => {
           });
           return;
         }
+        groupIsUnique && editor.verifiedUniqueChildGroups.add(groupId2);
+      }
+    }
   }
   if (isTextBlockNode({
     schema: editor.snapshot.context.schema
@@ -10374,7 +10375,7 @@ function transformBlockIndexMap(map, op, beforeValue, afterValue, context) {
     case "set.selection":
       return;
     case "insert": {
-      const lastSegment = op.path[op.path.length - 1], anchorIndex = typeof lastSegment == "number" ? lastSegment : resolveChildIndexInValue(beforeValue, op.path);
+      const anchorIndex = childIndexFromMap(map, beforeValue, op.path);
       if (anchorIndex < 0)
         return;
       const siblingContext = resolveSiblingContext(context, afterValue, op.path);
@@ -10391,12 +10392,11 @@ function transformBlockIndexMap(map, op, beforeValue, afterValue, context) {
         map.clear();
         return;
       }
-      const lastSegment = op.path[op.path.length - 1];
-      if (typeof lastSegment == "string") {
+      if (typeof op.path[op.path.length - 1] == "string") {
         hasKeyedEntries(resolveValueAtPath(beforeValue, op.path)) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
         return;
       }
-      const removeIndex = typeof lastSegment == "number" ? lastSegment : resolveChildIndexInValue(beforeValue, op.path);
+      const removeIndex = childIndexFromMap(map, beforeValue, op.path);
       if (pruneSubtreeAtPath(map, beforeValue, op.path), removeIndex >= 0) {
         const siblingContext = resolveSiblingContext(context, afterValue, op.path);
         siblingContext && reindexSiblings(map, siblingContext, removeIndex);
@@ -10424,12 +10424,31 @@ function transformBlockIndexMap(map, op, beforeValue, afterValue, context) {
         (op.value !== null && typeof op.value == "object" || hasKeyedEntries(resolveValueAtPath(beforeValue, op.path))) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
         return;
       }
-      const childIndex = resolveChildIndexInValue(beforeValue, op.path);
+      const childIndex = childIndexFromMap(map, beforeValue, op.path);
       pruneSubtreeAtPath(map, beforeValue, op.path), childIndex >= 0 && addSubtree(map, context, afterValue, [...op.path.slice(0, -1), childIndex]);
       return;
     }
   }
 }
+function childIndexFromMap(map, beforeValue, path2) {
+  const last = path2[path2.length - 1];
+  if (typeof last == "number")
+    return last;
+  if (isKeyedSegment(last)) {
+    let keyed = !0;
+    for (let i = 0; i < path2.length - 1; i++)
+      if (typeof path2[i] == "number") {
+        keyed = !1;
+        break;
+      }
+    if (keyed) {
+      const index = map.get(serializePath(path2));
+      if (index !== void 0)
+        return index;
+    }
+  }
+  return resolveChildIndexInValue(beforeValue, path2);
+}
 function resolveChildIndexInValue(value, path2) {
   let currentChildren = value;
   for (let i = 0; i < path2.length - 1; i++) {
@@ -10640,6 +10659,69 @@ function resolveNodeAtPath(value, path2) {
   }
   return currentNode;
 }
+function groupId(prefix) {
+  for (const segment of prefix)
+    if (typeof segment == "number")
+      return null;
+  return serializePath(prefix);
+}
+function invalidateVerifiedGroups(groups, operation) {
+  if (groups.size === 0)
+    return;
+  if (operation.path.length === 0) {
+    groups.clear();
+    return;
+  }
+  const drop = (prefix) => {
+    const id = groupId(prefix);
+    return id === null ? (groups.clear(), !1) : (groups.delete(id), !0);
+  }, dropSubtreeGroups = (node, nodePath) => {
+    walkKeyedChildrenInValue(node, nodePath, (childPath) => {
+      const id = groupId(childPath.slice(0, -1));
+      id !== null && groups.delete(id);
+    });
+  }, path2 = operation.path, lastSegment = path2[path2.length - 1];
+  if (operation.type === "insert") {
+    const groupPath = path2.slice(0, -1);
+    drop(groupPath) && operation.node._key !== void 0 && dropSubtreeGroups(operation.node, [...groupPath, {
+      _key: operation.node._key
+    }]);
+    return;
+  }
+  if (operation.type === "unset") {
+    if (typeof lastSegment == "string" && lastSegment !== "_key") {
+      drop(path2);
+      return;
+    }
+    const nodePath = lastSegment === "_key" ? path2.slice(0, -1) : path2;
+    drop(nodePath.slice(0, -1));
+    return;
+  }
+  if (typeof lastSegment == "number" || isKeyedSegment(lastSegment) || lastSegment === "_key") {
+    const nodePath = lastSegment === "_key" ? path2.slice(0, -1) : path2;
+    if (drop(nodePath.slice(0, -1)) && lastSegment !== "_key") {
+      const replacement = operation.value;
+      if (replacement !== null && typeof replacement == "object" && !Array.isArray(replacement)) {
+        const replacementKey = replacement._key;
+        replacementKey !== void 0 && dropSubtreeGroups(replacement, [...nodePath.slice(0, -1), {
+          _key: replacementKey
+        }]);
+      }
+    }
+    return;
+  }
+  if (typeof lastSegment == "string") {
+    if (Array.isArray(operation.value)) {
+      if (drop(path2))
+        for (const child of operation.value)
+          child && child._key !== void 0 && dropSubtreeGroups(child, [...path2, {
+            _key: child._key
+          }]);
+      return;
+    }
+    operation.value !== null && typeof operation.value == "object" && groups.clear();
+  }
+}
 function subscribeUpdateValue(context, editor) {
   const unsubscribeNormalizationLog = debug.normalization.enabled ? subscribeToOperations(editor, (event) => {
     event.isNormalizingNode && debug.normalization(`((engine operation))
@@ -10651,7 +10733,7 @@ ${safeStringify(event.operation, 2)}`);
     operation.type !== "set.selection" && (operation.type === "insert.text" || operation.type === "remove.text" || (transformBlockIndexMap(editor.blockIndexMap, operation, event.beforeValue, editor.snapshot.context.value, {
       schema: context.schema,
       containers: editor.snapshot.context.containers
-    }), editor.listIndexMapDirty = !0));
+    }), editor.listIndexMapDirty = !0, invalidateVerifiedGroups(editor.verifiedUniqueChildGroups, operation)));
   });
   return () => {
     unsubscribeNormalizationLog?.(), unsubscribeIndexMaps();
@@ -10685,7 +10767,7 @@ function createEditorEngine(config) {
   }, editor.containers = /* @__PURE__ */ new Map(), editor.blockObjects = /* @__PURE__ */ new Map(), editor.inlineObjects = /* @__PURE__ */ new Map(), editor.spans = /* @__PURE__ */ new Map(), editor.textBlocks = /* @__PURE__ */ new Map(), editor.decoratedRanges = [], editor.blockIndexMap = blockIndexMap, editor.history = {
     undos: [],
     redos: []
-  }, editor.listIndexMap = /* @__PURE__ */ new Map(), editor.listIndexMapDirty = !1, editor.remotePatches = [], editor.undoStepId = void 0, editor.isDeferringMutations = !1, editor.isNormalizingNode = !1, editor.isPatching = !0, editor.isPerformingBehaviorOperation = !1, editor.isProcessingRemoteChanges = !1, editor.isRedoing = !1, editor.isUndoing = !1, editor.withHistory = !0;
+  }, editor.listIndexMap = /* @__PURE__ */ new Map(), editor.listIndexMapDirty = !1, editor.verifiedUniqueChildGroups = /* @__PURE__ */ new Set(), editor.remotePatches = [], editor.undoStepId = void 0, editor.isDeferringMutations = !1, editor.isNormalizingNode = !1, editor.isPatching = !0, editor.isPerformingBehaviorOperation = !1, editor.isProcessingRemoteChanges = !1, editor.isRedoing = !1, editor.isUndoing = !1, editor.withHistory = !0;
   const editorEngine = plugins(withDOM(editor), {
     editorActor: config.editorActor
   });
@@ -11640,7 +11722,7 @@ const coreDndBehaviors = [
           ...snapshot.context,
           selection: dragSelection
         }
-      }, draggingEntireBlocks = isSelectingEntireBlocks(dragSnapshot), draggedNodes = getFragment(dragSnapshot), fittedBlocks = fitBlocksToDestination({
+      }, draggingEntireBlocks = isSelectingEntireBlocks(dragSnapshot), movedInlineObjectKey = !draggingEntireBlocks && isCollapsedRange(dragSelection) ? getFocusInlineObject(dragSnapshot)?.node._key : void 0, draggedNodes = getFragment(dragSnapshot), fittedBlocks = fitBlocksToDestination({
         ...snapshot,
         context: {
           ...snapshot.context,
@@ -11653,7 +11735,8 @@ const coreDndBehaviors = [
         draggedNodes,
         dragOrigin,
         originEvent: event.originEvent,
-        fittedBlocks
+        fittedBlocks,
+        movedInlineObjectKey
       };
     },
     actions: [(_, {
@@ -11662,9 +11745,21 @@ const coreDndBehaviors = [
       dragOrigin,
       dropPosition,
       originEvent,
-      fittedBlocks
+      fittedBlocks,
+      movedInlineObjectKey
     }) => {
-      const deleteEvents = draggingEntireBlocks ? draggedNodes.map((entry) => raise({
+      const movedInlineObjectPath = movedInlineObjectKey ? [...dropPosition.anchor.path.slice(0, -2), "children", {
+        _key: movedInlineObjectKey
+      }] : void 0, movedInlineObjectSelection = movedInlineObjectPath ? {
+        anchor: {
+          path: movedInlineObjectPath,
+          offset: 0
+        },
+        focus: {
+          path: movedInlineObjectPath,
+          offset: 0
+        }
+      } : void 0, deleteEvents = draggingEntireBlocks ? draggedNodes.map((entry) => raise({
         type: "unset",
         at: entry.path
       })) : [raise({
@@ -11677,8 +11772,12 @@ const coreDndBehaviors = [
       }), ...deleteEvents, raise({
         type: "insert.blocks",
         blocks: fittedBlocks,
-        placement: draggingEntireBlocks ? originEvent.position.block === "start" ? "before" : originEvent.position.block === "end" ? "after" : "auto" : "auto"
-      })];
+        placement: draggingEntireBlocks ? originEvent.position.block === "start" ? "before" : originEvent.position.block === "end" ? "after" : "auto" : "auto",
+        select: movedInlineObjectSelection ? "none" : void 0
+      }), ...movedInlineObjectSelection ? [raise({
+        type: "select",
+        at: movedInlineObjectSelection
+      })] : []];
     }]
   })
 ], coreInsertBehaviors = [defineBehavior({
@@ -12957,19 +13056,17 @@ const childSetOperationImplementation = ({
 function unhangRange(snapshot, range2) {
   const {
     context
-  } = snapshot;
-  let [start2, end2] = rangeEdges(range2, {
+  } = snapshot, [start2, end2] = rangeEdges(range2, {
     value: context.value
   });
   if (start2.offset !== 0 || end2.offset !== 0 || isCollapsedRange(range2) || getSibling(snapshot, end2.path, {
     direction: "previous"
-  }) !== void 0)
-    return range2;
-  const endBlock = getParent(snapshot, end2.path, {
+  }) !== void 0 || !getParent(snapshot, end2.path, {
     match: (node) => isTextBlock({
       schema: snapshot.context.schema
     }, node)
-  }), blockPath = endBlock ? endBlock.path : [];
+  }))
+    return range2;
   for (const {
     path: path2
   } of getNodes(snapshot, {
@@ -12979,7 +13076,7 @@ function unhangRange(snapshot, range2) {
   }))
     if (!isAncestorPath(path2, start2.path) && !isAncestorPath(path2, end2.path))
       return range2;
-  let skip = !0;
+  let skip = !0, sawEmpty = !1;
   for (const {
     node,
     path: nodePath
@@ -12997,20 +13094,21 @@ function unhangRange(snapshot, range2) {
     }
     if (isSpan({
       schema: context.schema
-    }, node) && (node.text !== "" || isBeforePath(nodePath, blockPath, {
-      value: context.value
-    }))) {
-      end2 = {
-        path: nodePath,
-        offset: node.text.length
+    }, node)) {
+      if (node.text === "") {
+        sawEmpty = !0;
+        continue;
+      }
+      return sawEmpty ? range2 : {
+        anchor: start2,
+        focus: {
+          path: nodePath,
+          offset: node.text.length
+        }
       };
-      break;
     }
   }
-  return {
-    anchor: start2,
-    focus: end2
-  };
+  return range2;
 }
 function pointRef(editor, point2, options = {}) {
   const {
@@ -18469,17 +18567,14 @@ function updateBlock({
       if (isChildChanged) {
         if (currentBlockChild._key === oldBlockChild?._key && currentBlockChild._type === oldBlockChild?._type) {
           debug.syncValue("Updating changed child", currentBlockChild, oldBlockChild);
-          const {
-            text: _text,
-            ...childProps
-          } = currentBlockChild;
-          setNodeProperties(editorEngine, childProps, path2);
           const isSpanNode2 = isSpan({
             schema: context.schema
           }, currentBlockChild) && isSpan({
             schema: context.schema
-          }, oldBlockChild);
-          isSpanNode2 && isTextChanged ? (oldBlockChild.text.length > 0 && deleteRange(editorEngine, {
+          }, oldBlockChild), childProps = {
+            ...currentBlockChild
+          };
+          isSpanNode2 && delete childProps.text, setNodeProperties(editorEngine, childProps, path2), isSpanNode2 && isTextChanged ? (oldBlockChild.text.length > 0 && deleteRange(editorEngine, {
             focus: {
               path: path2,
               offset: 0