emdash 0.32.0 → 0.34.0

package/src/content/converters/mark-safety.ts

@@ -0,0 +1,120 @@
+import type { PortableTextBlock, ProseMirrorDocument, ProseMirrorNode } from "./types.js";
+
+const SUPPORTED_PORTABLE_TEXT_DECORATORS = new Set([
+	"strong",
+	"em",
+	"underline",
+	"strike-through",
+	"subscript",
+	"superscript",
+	"code",
+]);
+
+const SUPPORTED_PROSEMIRROR_MARKS = new Set([
+	"bold",
+	"strong",
+	"italic",
+	"em",
+	"underline",
+	"strike",
+	"strikethrough",
+	"subscript",
+	"superscript",
+	"code",
+	"link",
+]);
+
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function collectPortableTextMarks(
+	value: unknown,
+	inheritedMarkDefs: ReadonlyMap<string, UnknownRecord>,
+	unsupported: Set<string>,
+): void {
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			collectPortableTextMarks(item, inheritedMarkDefs, unsupported);
+		}
+		return;
+	}
+	if (!isRecord(value)) return;
+
+	let markDefs: ReadonlyMap<string, UnknownRecord> = inheritedMarkDefs;
+	if (Array.isArray(value.markDefs)) {
+		const localMarkDefs = new Map(inheritedMarkDefs);
+		for (const markDef of value.markDefs) {
+			if (isRecord(markDef) && typeof markDef._key === "string") {
+				localMarkDefs.set(markDef._key, markDef);
+			}
+		}
+		markDefs = localMarkDefs;
+	}
+
+	if (value._type === "span" && Array.isArray(value.marks)) {
+		for (const mark of value.marks) {
+			if (typeof mark !== "string" || SUPPORTED_PORTABLE_TEXT_DECORATORS.has(mark)) continue;
+			const markDef = markDefs.get(mark);
+			if (markDef?._type === "link") continue;
+			unsupported.add(typeof markDef?._type === "string" ? markDef._type : mark);
+		}
+	}
+
+	for (const [key, child] of Object.entries(value)) {
+		if (key !== "markDefs") {
+			collectPortableTextMarks(child, markDefs, unsupported);
+		}
+	}
+}
+
+function collectProseMirrorMarks(node: ProseMirrorNode, unsupported: Set<string>): void {
+	for (const mark of node.marks ?? []) {
+		if (!SUPPORTED_PROSEMIRROR_MARKS.has(mark.type)) {
+			unsupported.add(mark.type);
+		}
+	}
+	for (const child of node.content ?? []) {
+		collectProseMirrorMarks(child, unsupported);
+	}
+}
+
+export class UnsupportedPortableTextMarksError extends Error {
+	readonly marks: string[];
+
+	constructor(marks: Iterable<string>) {
+		const sortedMarks = [...new Set(marks)].toSorted();
+		super(`Unsupported Portable Text marks: ${sortedMarks.join(", ")}`);
+		this.name = "UnsupportedPortableTextMarksError";
+		this.marks = sortedMarks;
+	}
+}
+
+export function findUnsupportedPortableTextMarks(blocks: PortableTextBlock[]): string[] {
+	const unsupported = new Set<string>();
+	for (const block of blocks) {
+		if (block._type === "block" || block._type === "table") {
+			collectPortableTextMarks(block, new Map(), unsupported);
+		}
+	}
+	return [...unsupported].toSorted();
+}
+
+export function assertPortableTextMarksSupported(blocks: PortableTextBlock[]): void {
+	const unsupported = findUnsupportedPortableTextMarks(blocks);
+	if (unsupported.length > 0) {
+		throw new UnsupportedPortableTextMarksError(unsupported);
+	}
+}
+
+export function assertProseMirrorMarksSupported(document: ProseMirrorDocument): void {
+	const unsupported = new Set<string>();
+	for (const node of document.content) {
+		collectProseMirrorMarks(node, unsupported);
+	}
+	if (unsupported.size > 0) {
+		throw new UnsupportedPortableTextMarksError(unsupported);
+	}
+}

package/src/content/converters/numbered-list.ts

@@ -0,0 +1,148 @@
+import type { ProseMirrorDocument, ProseMirrorNode } from "./types.js";
+
+export const MAX_ORDERED_LIST_START = 2_147_483_647;
+
+export interface OrderedListMetadata {
+	listId: string;
+	listStart: number;
+}
+
+export function normalizeListId(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const normalized = value.trim();
+	return normalized.length > 0 && normalized.length <= 128 ? normalized : undefined;
+}
+
+export function normalizeListStart(value: unknown): number | undefined {
+	return typeof value === "number" &&
+		Number.isInteger(value) &&
+		value >= 1 &&
+		value <= MAX_ORDERED_LIST_START
+		? value
+		: undefined;
+}
+
+export function deriveLegacyListId(seed: string): string {
+	const readable = `legacy:${seed}`;
+	if (readable.length <= 128) return readable;
+	let hash = 2_166_136_261;
+	for (let i = 0; i < seed.length; i++) {
+		hash ^= seed.charCodeAt(i);
+		hash = Math.imul(hash, 16_777_619);
+	}
+	return `legacy:${seed.slice(0, 96)}:${(hash >>> 0).toString(36)}:${seed.length.toString(36)}`;
+}
+
+export function readOrderedListMetadata(
+	attrs: Record<string, unknown> | undefined,
+	fallbackId: string,
+): OrderedListMetadata {
+	return {
+		listId: normalizeListId(attrs?.listId) ?? deriveLegacyListId(fallbackId),
+		listStart: normalizeListStart(attrs?.listStart) ?? normalizeListStart(attrs?.start) ?? 1,
+	};
+}
+
+interface ProseMirrorListDescriptor {
+	node: ProseMirrorNode;
+	path: string;
+	depth: number;
+	context: string;
+}
+
+function collectProseMirrorOrderedLists(doc: ProseMirrorDocument): ProseMirrorListDescriptor[] {
+	const lists: ProseMirrorListDescriptor[] = [];
+	const visit = (node: ProseMirrorNode, path: string, depth: number, context: string) => {
+		if (node.type === "orderedList") lists.push({ node, path, depth, context });
+		for (const [index, child] of (node.content ?? []).entries()) {
+			const childPath = `${path}:${index}`;
+			visit(
+				child,
+				childPath,
+				depth + 1,
+				child.type === "listItem" ? `listItem:${childPath}` : context,
+			);
+		}
+	};
+	for (const [index, node] of doc.content.entries()) {
+		visit(node, `root:${index}`, 0, "root");
+	}
+	return lists;
+}
+
+function cloneProseMirrorNode(node: ProseMirrorNode): ProseMirrorNode {
+	return {
+		...node,
+		attrs: node.attrs ? { ...node.attrs } : undefined,
+		content: node.content?.map(cloneProseMirrorNode),
+		marks: node.marks?.map((mark) => ({
+			...mark,
+			attrs: mark.attrs ? { ...mark.attrs } : undefined,
+		})),
+	};
+}
+
+function createRepairId(sourceId: string, scope: string, attempt: number): string {
+	const base = deriveLegacyListId(`repair:${sourceId}:${scope}`);
+	const suffix = `:${attempt.toString(36)}`;
+	return `${base.slice(0, 128 - suffix.length)}${suffix}`;
+}
+
+export function normalizeProseMirrorOrderedListJson(doc: ProseMirrorDocument): ProseMirrorDocument {
+	const normalized = {
+		...doc,
+		content: doc.content.map(cloneProseMirrorNode),
+	};
+	const canonicalBySourceScope = new Map<string, string>();
+	const assignedCanonicalIds = new Set<string>();
+	const lists = collectProseMirrorOrderedLists(normalized).map((list) => {
+		const sourceId =
+			normalizeListId(list.node.attrs?.listId) ??
+			deriveLegacyListId(`pm-json:${list.path}:${list.depth}:${list.context}`);
+		const scope = JSON.stringify([list.depth, list.context]);
+		const sourceScope = JSON.stringify([sourceId, scope]);
+		let listId = canonicalBySourceScope.get(sourceScope);
+		if (!listId) {
+			if (!assignedCanonicalIds.has(sourceId)) {
+				listId = sourceId;
+			} else {
+				let attempt = 0;
+				do {
+					listId = createRepairId(sourceId, scope, attempt++);
+				} while (assignedCanonicalIds.has(listId));
+			}
+			canonicalBySourceScope.set(sourceScope, listId);
+			assignedCanonicalIds.add(listId);
+		}
+		return {
+			...list,
+			listId,
+			scopeKey: JSON.stringify([listId, list.depth, list.context]),
+		};
+	});
+
+	const bases = new Map<string, number>();
+	for (const list of lists) {
+		const listStart = normalizeListStart(list.node.attrs?.listStart);
+		if (listStart !== undefined && !bases.has(list.scopeKey)) {
+			bases.set(list.scopeKey, listStart);
+		}
+	}
+	for (const list of lists) {
+		if (!bases.has(list.scopeKey)) {
+			bases.set(list.scopeKey, normalizeListStart(list.node.attrs?.start) ?? 1);
+		}
+	}
+
+	const counts = new Map<string, number>();
+	for (const list of lists) {
+		const listStart = bases.get(list.scopeKey)!;
+		const count = counts.get(list.scopeKey) ?? 0;
+		const start = normalizeListStart(listStart + count) ?? 1;
+		const directItemCount =
+			list.node.content?.filter((node) => node.type === "listItem").length ?? 0;
+		counts.set(list.scopeKey, count + directItemCount);
+		list.node.attrs = { ...list.node.attrs, listId: list.listId, listStart, start };
+	}
+	return normalized;
+}

package/src/content/converters/portable-text-to-prosemirror.ts

@@ -5,6 +5,16 @@
  */
 
 import { sanitizeGalleryImages } from "./gallery.js";
+import {
+	UnsupportedPortableTextMarksError,
+	assertPortableTextMarksSupported,
+} from "./mark-safety.js";
+import {
+	deriveLegacyListId,
+	normalizeProseMirrorOrderedListJson,
+	normalizeListId,
+	normalizeListStart,
+} from "./numbered-list.js";
 import type {
 	ProseMirrorDocument,
 	ProseMirrorNode,
@@ -28,6 +38,7 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 			content: [{ type: "paragraph" }],
 		};
 	}
+	assertPortableTextMarksSupported(blocks);
 
 	const content: ProseMirrorNode[] = [];
 	let i = 0;
@@ -48,12 +59,20 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 			// child).
 			const listBlocks: PortableTextTextBlock[] = [];
 			const listType = block.listItem;
+			const runStart = i;
+			const rootId = listType === "number" ? normalizeListId(block.listId) : undefined;
 
 			while (i < blocks.length) {
 				const current = blocks[i];
 				if (!isTextBlock(current) || !current.listItem) break;
 				const level = current.level || 1;
-				if (level > 1 || current.listItem === listType) {
+				const currentId =
+					current.listItem === "number" ? normalizeListId(current.listId) : undefined;
+				const sameRootIdentity =
+					listType !== "number" ||
+					level > 1 ||
+					(rootId ? currentId === rootId : currentId === undefined);
+				if (level > 1 || (current.listItem === listType && sameRootIdentity)) {
 					listBlocks.push(current);
 					i++;
 				} else {
@@ -61,14 +80,14 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 				}
 			}
 
-			content.push(convertList(listBlocks, listType));
+			content.push(convertList(listBlocks, listType, `root:${runStart}`));
 		} else if (isTextBlock(block) && block.style === "blockquote") {
 			// Collect a blockquote "run": Portable Text is flat, so a
 			// multi-paragraph quote is stored as consecutive blocks with
 			// style "blockquote" (that's what the Gutenberg importer emits
 			// and what prosemirrorToPortableText serializes back to).
 			// Without this grouping each paragraph became its own quote
-			// node, and editor merges reverted on reload (#1884).
+			// node, and editor merges reverted on reload.
 			const quoteBlocks: PortableTextTextBlock[] = [];
 			while (i < blocks.length) {
 				const current = blocks[i];
@@ -102,12 +121,38 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 		}
 	}
 
-	return {
+	return normalizeProseMirrorOrderedListJson({
 		type: "doc",
 		content: content.length > 0 ? content : [{ type: "paragraph" }],
+	});
+}
+
+function getListMetadata(
+	item: PortableTextTextBlock,
+	fallbackSeed: string,
+): { listId: string; listStart?: number } {
+	const listId = normalizeListId(item.listId) ?? deriveLegacyListId(fallbackSeed);
+	const listStart = normalizeListStart(item.listStart);
+	return {
+		listId,
+		...(listStart === undefined ? {} : { listStart }),
 	};
 }
 
+function belongsToNestedGroup(
+	item: PortableTextTextBlock,
+	minLevel: number,
+	parentListType: "bullet" | "number",
+	anchorType: "bullet" | "number",
+	anchorId: string | undefined,
+): boolean {
+	if ((item.level || 2) > minLevel) return true;
+	if ((item.listItem || parentListType) !== anchorType) return false;
+	if (anchorType !== "number") return true;
+	const itemId = normalizeListId(item.listId);
+	return anchorId ? itemId === anchorId : itemId === undefined;
+}
+
 /**
  * Type guard for text blocks
  */
@@ -249,6 +294,7 @@ function convertTextBlock(block: PortableTextTextBlock): ProseMirrorNode | null
 function convertList(
 	items: PortableTextTextBlock[],
 	listType: "bullet" | "number",
+	context: string,
 ): ProseMirrorNode {
 	// Group items by level
 	const rootItems: ProseMirrorNode[] = [];
@@ -268,16 +314,22 @@ function convertList(
 				i++;
 			}
 
-			rootItems.push(convertListItem(item, nestedItems, listType));
+			rootItems.push(
+				convertListItem(item, nestedItems, listType, `${context}:${rootItems.length}`),
+			);
 		} else {
 			// Orphan nested item - treat as root
-			rootItems.push(convertListItem(item, [], listType));
+			rootItems.push(convertListItem(item, [], listType, `${context}:${rootItems.length}`));
 			i++;
 		}
 	}
 
+	const metadata =
+		listType === "number" ? getListMetadata(items[0], `${context}:${items[0]._key}`) : undefined;
+
 	return {
 		type: listType === "bullet" ? "bulletList" : "orderedList",
+		attrs: metadata ? { ...metadata, start: metadata.listStart ?? 1 } : undefined,
 		content: rootItems,
 	};
 }
@@ -289,6 +341,7 @@ function convertListItem(
 	item: PortableTextTextBlock,
 	nestedItems: PortableTextTextBlock[],
 	parentListType: "bullet" | "number",
+	context: string,
 ): ProseMirrorNode {
 	const content: ProseMirrorNode[] = [];
 
@@ -319,6 +372,7 @@ function convertListItem(
 		let j = 0;
 		while (j < nestedItems.length) {
 			const anchorType: "bullet" | "number" = nestedItems[j].listItem || parentListType;
+			const anchorId = anchorType === "number" ? normalizeListId(nestedItems[j].listId) : undefined;
 			const nestedGroup: PortableTextTextBlock[] = [];
 
 			do {
@@ -326,8 +380,7 @@ function convertListItem(
 				j++;
 			} while (
 				j < nestedItems.length &&
-				((nestedItems[j].level || 2) > minLevel ||
-					(nestedItems[j].listItem || parentListType) === anchorType)
+				belongsToNestedGroup(nestedItems[j], minLevel, parentListType, anchorType, anchorId)
 			);
 
 			if (nestedGroup.length > 0) {
@@ -336,7 +389,9 @@ function convertListItem(
 					...ni,
 					level: (ni.level || 2) - 1,
 				}));
-				content.push(convertList(adjustedGroup, anchorType));
+				content.push(
+					convertList(adjustedGroup, anchorType, `${context}:nested:${j - nestedGroup.length}`),
+				);
 			}
 		}
 	}
@@ -416,6 +471,14 @@ function convertMarks(
 				pmMarks.push({ type: "strike" });
 				break;
 
+			case "subscript":
+				pmMarks.push({ type: "subscript" });
+				break;
+
+			case "superscript":
+				pmMarks.push({ type: "superscript" });
+				break;
+
 			case "code":
 				pmMarks.push({ type: "code" });
 				break;
@@ -423,22 +486,18 @@ function convertMarks(
 			default: {
 				// Check if it's a mark definition reference
 				const markDef = markDefs.get(mark);
-				if (markDef) {
-					if (markDef._type === "link") {
-						pmMarks.push({
-							type: "link",
-							attrs: {
-								href: markDef.href,
-								target: markDef.blank ? "_blank" : null,
-							},
-						});
-					} else {
-						// Unknown mark def type - preserve attrs
-						pmMarks.push({
-							type: markDef._type,
-							attrs: markDef,
-						});
-					}
+				if (markDef?._type === "link") {
+					pmMarks.push({
+						type: "link",
+						attrs: {
+							href: markDef.href,
+							target: markDef.blank ? "_blank" : null,
+						},
+					});
+				} else {
+					throw new UnsupportedPortableTextMarksError([
+						typeof markDef?._type === "string" ? markDef._type : mark,
+					]);
 				}
 				break;
 			}

package/src/content/converters/prosemirror-to-portable-text.ts

@@ -5,6 +5,11 @@
  */
 
 import { sanitizeGalleryImages } from "./gallery.js";
+import {
+	UnsupportedPortableTextMarksError,
+	assertProseMirrorMarksSupported,
+} from "./mark-safety.js";
+import { readOrderedListMetadata, type OrderedListMetadata } from "./numbered-list.js";
 import type {
 	ProseMirrorDocument,
 	ProseMirrorNode,
@@ -33,11 +38,12 @@ export function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTex
 	if (!doc || doc.type !== "doc" || !doc.content) {
 		return [];
 	}
+	assertProseMirrorMarksSupported(doc);
 
 	const blocks: PortableTextBlock[] = [];
 
-	for (const node of doc.content) {
-		const converted = convertNode(node);
+	for (const [i, node] of doc.content.entries()) {
+		const converted = convertNode(node, `root:${i}`);
 		if (converted) {
 			if (Array.isArray(converted)) {
 				blocks.push(...converted);
@@ -53,7 +59,10 @@ export function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTex
 /**
  * Convert a single ProseMirror node to Portable Text block(s)
  */
-function convertNode(node: ProseMirrorNode): PortableTextBlock | PortableTextBlock[] | null {
+function convertNode(
+	node: ProseMirrorNode,
+	path: string,
+): PortableTextBlock | PortableTextBlock[] | null {
 	switch (node.type) {
 		case "paragraph":
 			return convertParagraph(node);
@@ -62,10 +71,10 @@ function convertNode(node: ProseMirrorNode): PortableTextBlock | PortableTextBlo
 			return convertHeading(node);
 
 		case "bulletList":
-			return convertList(node, "bullet");
+			return convertList(node, "bullet", path);
 
 		case "orderedList":
-			return convertList(node, "number");
+			return convertList(node, "number", path);
 
 		case "blockquote":
 			return convertBlockquote(node);
@@ -175,12 +184,14 @@ function convertHeading(node: ProseMirrorNode): PortableTextTextBlock | null {
 function convertList(
 	node: ProseMirrorNode,
 	listItem: "bullet" | "number",
+	path: string,
 ): PortableTextTextBlock[] {
 	const blocks: PortableTextTextBlock[] = [];
+	const metadata = listItem === "number" ? readOrderedListMetadata(node.attrs, path) : undefined;
 
-	for (const item of node.content || []) {
+	for (const [i, item] of (node.content ?? []).entries()) {
 		if (item.type === "listItem") {
-			const itemBlocks = convertListItem(item, listItem, 1);
+			const itemBlocks = convertListItem(item, listItem, 1, `${path}:${i}`, metadata);
 			blocks.push(...itemBlocks);
 		}
 	}
@@ -195,10 +206,12 @@ function convertListItem(
 	item: ProseMirrorNode,
 	listItem: "bullet" | "number",
 	level: number,
+	path: string,
+	metadata?: OrderedListMetadata,
 ): PortableTextTextBlock[] {
 	const blocks: PortableTextTextBlock[] = [];
 
-	for (const child of item.content || []) {
+	for (const [i, child] of (item.content ?? []).entries()) {
 		if (child.type === "paragraph") {
 			const { children, markDefs } = convertInlineContent(child.content || []);
 
@@ -209,14 +222,15 @@ function convertListItem(
 					style: "normal",
 					listItem,
 					level,
+					...metadata,
 					children,
 					markDefs: markDefs.length > 0 ? markDefs : undefined,
 				});
 			}
 		} else if (child.type === "bulletList") {
-			blocks.push(...convertListItemNested(child, "bullet", level + 1));
+			blocks.push(...convertListItemNested(child, "bullet", level + 1, `${path}:${i}`));
 		} else if (child.type === "orderedList") {
-			blocks.push(...convertListItemNested(child, "number", level + 1));
+			blocks.push(...convertListItemNested(child, "number", level + 1, `${path}:${i}`));
 		}
 	}
 
@@ -230,12 +244,14 @@ function convertListItemNested(
 	node: ProseMirrorNode,
 	listItem: "bullet" | "number",
 	level: number,
+	path: string,
 ): PortableTextTextBlock[] {
 	const blocks: PortableTextTextBlock[] = [];
+	const metadata = listItem === "number" ? readOrderedListMetadata(node.attrs, path) : undefined;
 
-	for (const item of node.content || []) {
+	for (const [i, item] of (node.content ?? []).entries()) {
 		if (item.type === "listItem") {
-			blocks.push(...convertListItem(item, listItem, level));
+			blocks.push(...convertListItem(item, listItem, level, `${path}:${i}`, metadata));
 		}
 	}
 
@@ -424,6 +440,12 @@ function convertMark(
 		case "strikethrough":
 			return "strike-through";
 
+		case "subscript":
+			return "subscript";
+
+		case "superscript":
+			return "superscript";
+
 		case "code":
 			return "code";
 
@@ -449,7 +471,6 @@ function convertMark(
 		}
 
 		default:
-			// Unknown mark - preserve as-is
-			return mark.type;
+			throw new UnsupportedPortableTextMarksError([mark.type]);
 	}
 }

package/src/content/converters/types.ts

@@ -41,6 +41,8 @@ export interface PortableTextTextBlock {
 	style?: "normal" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "blockquote";
 	listItem?: "bullet" | "number";
 	level?: number;
+	listId?: string;
+	listStart?: number;
 	children: PortableTextSpan[];
 	markDefs?: PortableTextMarkDef[];
 	textAlign?: "left" | "center" | "right" | "justify";