@portabletext/editor 8.0.2 → 8.0.3

package/lib/index.js

@@ -1179,13 +1179,14 @@ function mapPointThroughStep(step, point, options = {}) {
 			};
 		}
 		case "rekey": {
-			let path;
-			for (let i = 0; i < point.path.length; i++) {
-				let segment = point.path[i];
-				isKeyedSegment(segment) && segment._key === step.oldKey && (path === void 0 && (path = [...point.path]), path[i] = { _key: step.newKey });
-			}
-			return path === void 0 ? point : {
-				path,
+			if (point.path.length <= step.path.length || !pathEquals(point.path.slice(0, step.path.length), step.path)) return point;
+			let segment = point.path[step.path.length];
+			return !isKeyedSegment(segment) || segment._key !== step.oldKey ? point : {
+				path: [
+					...step.path,
+					{ _key: step.newKey },
+					...point.path.slice(step.path.length + 1)
+				],
 				offset: point.offset
 			};
 		}
@@ -1303,6 +1304,7 @@ function operationToSteps(op) {
 				let oldKey = op.inverse?.type === "set" && typeof op.inverse.value == "string" ? op.inverse.value : void 0;
 				return oldKey ? [{
 					type: "rekey",
+					path: nodePath.slice(0, -1),
 					oldKey,
 					newKey: op.value
 				}] : [];
@@ -6892,13 +6894,17 @@ function applyOperation(editor, op) {
 		case "set": {
 			let { path, value } = op;
 			if (!op.inverse && !editor.isProcessingRemoteChanges) {
-				let previousValue = getValue(editor.snapshot.context.value, path);
+				let previousValue = getValue(editor.snapshot.context.value, path), inversePath = path[path.length - 1] === "_key" && typeof value == "string" && isKeyedSegment(path[path.length - 2]) ? [
+					...path.slice(0, -2),
+					{ _key: value },
+					"_key"
+				] : path;
 				op.inverse = previousValue === void 0 ? {
 					type: "unset",
-					path
+					path: inversePath
 				} : {
 					type: "set",
-					path,
+					path: inversePath,
 					value: previousValue
 				};
 			}
@@ -7675,23 +7681,20 @@ function setNodeProperties(editor, props, path) {
 	keyIndex !== -1 && (keys.splice(keyIndex, 1), keys.unshift("_key"));
 	let currentPath = path;
 	for (let key of keys) if (propsRecord[key] !== nodeRecord[key]) if (propsRecord[key] != null) {
-		let hadProperty = nodeRecord.hasOwnProperty(key);
-		if (editor.apply({
+		let hadProperty = nodeRecord.hasOwnProperty(key), lastSegment = currentPath[currentPath.length - 1], renamedPath = key === "_key" && typeof propsRecord[key] == "string" && isKeyedSegment(lastSegment) ? [...currentPath.slice(0, -1), { _key: propsRecord[key] }] : void 0, inversePath = renamedPath ? [...renamedPath, key] : [...currentPath, key];
+		editor.apply({
 			type: "set",
 			path: [...currentPath, key],
 			value: propsRecord[key],
 			inverse: hadProperty ? {
 				type: "set",
-				path: [...currentPath, key],
+				path: inversePath,
 				value: nodeRecord[key]
 			} : {
 				type: "unset",
-				path: [...currentPath, key]
+				path: inversePath
 			}
-		}), key === "_key" && typeof propsRecord[key] == "string") {
-			let lastSegment = currentPath[currentPath.length - 1];
-			isKeyedSegment(lastSegment) && (currentPath = [...currentPath.slice(0, -1), { _key: propsRecord[key] }]);
-		}
+		}), renamedPath && (currentPath = renamedPath);
 	} else nodeRecord.hasOwnProperty(key) && editor.apply({
 		type: "unset",
 		path: [...currentPath, key],
@@ -13132,16 +13135,24 @@ const abstractAnnotationBehaviors = [
 			let previousBlock = {
 				node: previousSibling.node,
 				path: previousSibling.path
-			};
+			}, previousBlockEndPoint = getBlockEndPoint({
+				context: snapshot.context,
+				block: previousBlock
+			}), { renamedBlock, renameActions } = planMergeKeyRenames({
+				context: snapshot.context,
+				mergingBlockPath: focusTextBlock.path,
+				mergingBlock: focusTextBlock.node,
+				destinationBlock: previousBlock.node
+			});
 			return {
-				previousBlockEndPoint: getBlockEndPoint({
-					context: snapshot.context,
-					block: previousBlock
-				}),
-				focusTextBlock
+				previousBlockEndPoint,
+				focusTextBlock,
+				renamedBlock,
+				renameActions
 			};
 		},
-		actions: [(_, { previousBlockEndPoint, focusTextBlock }) => [
+		actions: [(_, { previousBlockEndPoint, focusTextBlock, renamedBlock, renameActions }) => [
+			...renameActions,
 			raise$1({
 				type: "delete.block",
 				at: focusTextBlock.path
@@ -13155,7 +13166,7 @@ const abstractAnnotationBehaviors = [
 			}),
 			raise$1({
 				type: "insert.block",
-				block: focusTextBlock.node,
+				block: renamedBlock,
 				placement: "auto",
 				select: "start"
 			})
@@ -13224,20 +13235,32 @@ const abstractAnnotationBehaviors = [
 			}, focusTextBlock = getFocusTextBlock(adjustedSnapshot);
 			if (!focusTextBlock) return !1;
 			let nextSibling = getSibling(adjustedSnapshot, focusTextBlock.path, { direction: "next" });
-			return !nextSibling || !isAtTheEndOfBlock(focusTextBlock)(adjustedSnapshot) || !isTextBlockNode(snapshot.context, nextSibling.node) ? !1 : { nextBlock: {
-				node: nextSibling.node,
-				path: nextSibling.path
-			} };
+			if (!nextSibling || !isAtTheEndOfBlock(focusTextBlock)(adjustedSnapshot) || !isTextBlock(snapshot.context, nextSibling.node)) return !1;
+			let { renamedBlock, renameActions } = planMergeKeyRenames({
+				context: snapshot.context,
+				mergingBlockPath: nextSibling.path,
+				mergingBlock: nextSibling.node,
+				destinationBlock: focusTextBlock.node
+			});
+			return {
+				nextBlockPath: nextSibling.path,
+				renamedBlock,
+				renameActions
+			};
 		},
-		actions: [(_, { nextBlock }) => [raise$1({
-			type: "delete.block",
-			at: nextBlock.path
-		}), raise$1({
-			type: "insert.block",
-			block: nextBlock.node,
-			placement: "auto",
-			select: "none"
-		})]]
+		actions: [(_, { nextBlockPath, renamedBlock, renameActions }) => [
+			...renameActions,
+			raise$1({
+				type: "delete.block",
+				at: nextBlockPath
+			}),
+			raise$1({
+				type: "insert.block",
+				block: renamedBlock,
+				placement: "auto",
+				select: "none"
+			})
+		]]
 	}),
 	defineBehavior({
 		on: "delete.block",
@@ -13307,7 +13330,71 @@ const abstractAnnotationBehaviors = [
 			type: "delete"
 		})]]
 	})
-], mimeTypePriority = [
+];
+/**
+* A block merge folds `mergingBlock`'s children (and markDefs) into
+* `destinationBlock` by key. Any key the merging block shares with the
+* destination has to be renamed before the merge, or `insert.block`'s own
+* collision handling mints a fresh key for it, which reads on the wire as
+* that node being destroyed and a new one created instead of moved.
+*
+* Renames are raised as `set`/`child.set` events against the still-living
+* `mergingBlock`, so they land on the wire before the merge's `unset`.
+* `renamedBlock` mirrors the same renames applied to the value the caller
+* already captured, since raising the rename events now doesn't change
+* that captured value.
+*/
+function planMergeKeyRenames(args) {
+	let { context, mergingBlockPath, mergingBlock, destinationBlock } = args, destinationChildKeys = new Set(destinationBlock.children.map((child) => child._key)), destinationMarkDefKeys = new Set((destinationBlock.markDefs ?? []).map((markDef) => markDef._key)), markDefKeyMap = /* @__PURE__ */ new Map(), renamedMarkDefs = mergingBlock.markDefs?.map((markDef) => {
+		if (!destinationMarkDefKeys.has(markDef._key)) return markDef;
+		let newKey = context.keyGenerator();
+		return markDefKeyMap.set(markDef._key, newKey), {
+			...markDef,
+			_key: newKey
+		};
+	}), renameActions = [];
+	for (let markDef of mergingBlock.markDefs ?? []) {
+		let newKey = markDefKeyMap.get(markDef._key);
+		newKey && renameActions.push(raise$1({
+			type: "set",
+			at: [
+				...mergingBlockPath,
+				"markDefs",
+				{ _key: markDef._key },
+				"_key"
+			],
+			value: newKey
+		}));
+	}
+	let renamedChildren = mergingBlock.children.map((child) => {
+		let currentMarks = isSpan(context, child) ? child.marks : void 0, remappedMarks = currentMarks?.map((mark) => markDefKeyMap.get(mark) ?? mark), marksChanged = !!(remappedMarks && !isEqualMarks(remappedMarks, currentMarks)), newKey = destinationChildKeys.has(child._key) ? context.keyGenerator() : child._key, props = {};
+		return newKey !== child._key && (props._key = newKey), marksChanged && (props.marks = remappedMarks), Object.keys(props).length > 0 && renameActions.push(raise$1({
+			type: "child.set",
+			at: [
+				...mergingBlockPath,
+				"children",
+				{ _key: child._key }
+			],
+			props
+		})), marksChanged ? {
+			...child,
+			_key: newKey,
+			marks: remappedMarks
+		} : {
+			...child,
+			_key: newKey
+		};
+	});
+	return {
+		renamedBlock: {
+			...mergingBlock,
+			children: renamedChildren,
+			...mergingBlock.markDefs ? { markDefs: renamedMarkDefs } : {}
+		},
+		renameActions
+	};
+}
+const mimeTypePriority = [
 	"application/x-portable-text",
 	"application/json",
 	"text/markdown",