@stll/folio-core 0.55.0 → 0.57.0

package/dist/controller/canonicalComposition.js

@@ -1,54 +1,92 @@
 import { splitsSurrogatePair } from "../ai-edits/character-boundaries.js";
+import { CANONICAL_GAP } from "../types/canonicalCapabilities.js";
+import { setCanonicalInputTimer } from "./canonicalInputTimer.js";
 import { CanonicalSessionError } from "./canonicalSession.js";
 import { Result } from "better-result";
+import { EditorState, TextSelection } from "prosemirror-state";
 //#region src/controller/canonicalComposition.ts
-const COMPOSITION_FLUSH_DELAY_MS = 25;
 /** Native IME owns the provisional view; the captured canonical projection stays unchanged. */
 const createCanonicalComposition = (options) => {
 	let state = { type: "committed" };
 	let authorizedNativeState = null;
+	let completed = { type: "idle" };
 	let timer;
 	const clearTimer = () => {
 		if (timer !== void 0) clearTimeout(timer);
 		timer = void 0;
 	};
+	const selectedText = (baseline, proposed) => {
+		const { from, to } = baseline.selection;
+		const size = proposed.doc.content.size - baseline.doc.content.size + to - from;
+		if (size < 0 || from + size > proposed.doc.content.size) return null;
+		const text = proposed.doc.textBetween(from, from + size, "", "");
+		return text.length === size ? text : null;
+	};
+	const selectedReplacement = (baseline, proposed) => {
+		const { from, to } = baseline.selection;
+		const text = selectedText(baseline, proposed);
+		if (text === null || !baseline.tr.insertText(text, from, to).doc.eq(proposed.doc)) return null;
+		return {
+			from,
+			to,
+			text,
+			semantic: "composition"
+		};
+	};
 	const replacement = (baseline, proposed) => {
 		const { $from, $to } = baseline.selection;
 		if (!$from.parent.isTextblock || !$to.parent.isTextblock) return null;
-		if (!$from.sameParent($to)) {
-			const from = baseline.selection.from;
-			const to = baseline.selection.to;
-			const insertedSize = proposed.doc.content.size - (baseline.doc.content.size - (to - from));
-			if (insertedSize < 0 || from + insertedSize > proposed.doc.content.size) return null;
-			const text = proposed.doc.textBetween(from, from + insertedSize, "", "");
-			if (text.length !== insertedSize) return null;
-			if (!baseline.tr.insertText(text, from, to).doc.eq(proposed.doc)) return null;
-			return {
-				from,
-				to,
-				text,
+		const selected = selectedReplacement(baseline, proposed);
+		if (selected) {
+			if ($from.sameParent($to) && selected.text === baseline.doc.textBetween(selected.from, selected.to, "", "")) return {
+				from: selected.from,
+				to: selected.from,
+				text: "",
 				semantic: "composition"
 			};
+			return selected;
 		}
+		if (!$from.sameParent($to)) return null;
 		const start = $from.start();
 		const next = proposed.doc.nodeAt(start - 1);
-		if (!next || next.type !== $from.parent.type || next.content.size !== next.textContent.length) return null;
-		const before = $from.parent.textContent;
-		const after = next.textContent;
-		let from = 0;
-		while (from < before.length && from < after.length && before[from] === after[from]) from++;
-		while (splitsSurrogatePair(before, from) || splitsSurrogatePair(after, from)) from--;
-		let oldEnd = before.length;
-		let newEnd = after.length;
+		if (!next || next.type !== $from.parent.type) return null;
+		const previous = $from.parent.content;
+		const changedFrom = previous.findDiffStart(next.content);
+		if (changedFrom === null) {
+			if (!baseline.doc.eq(proposed.doc)) return null;
+			return {
+				from: baseline.selection.from,
+				to: baseline.selection.from,
+				text: "",
+				semantic: "composition"
+			};
+		}
+		const changedEnd = previous.findDiffEnd(next.content);
+		if (changedEnd === null) return null;
+		let from = changedFrom;
+		let oldEnd = changedEnd.a;
+		let newEnd = changedEnd.b;
+		const overlap = from - Math.min(oldEnd, newEnd);
+		if (overlap > 0) {
+			oldEnd += overlap;
+			newEnd += overlap;
+		}
+		const before = previous.textBetween(0, previous.size, "", "");
+		const after = next.content.textBetween(0, next.content.size, "", "");
+		while (from < oldEnd && from < newEnd && before[from] === after[from]) from++;
 		while (oldEnd > from && newEnd > from && before[oldEnd - 1] === after[newEnd - 1]) {
 			oldEnd--;
 			newEnd--;
 		}
+		while (splitsSurrogatePair(before, from) || splitsSurrogatePair(after, from)) from--;
 		while (splitsSurrogatePair(before, oldEnd) || splitsSurrogatePair(after, newEnd)) {
 			oldEnd++;
 			newEnd++;
 		}
-		const text = after.slice(from, newEnd);
+		const removed = previous.cut(from, oldEnd);
+		const inserted = next.content.cut(from, newEnd);
+		const text = inserted.textBetween(0, inserted.size, "", "");
+		if (removed.textBetween(0, removed.size, "", "").length !== removed.size || text.length !== inserted.size) return null;
 		if (!baseline.tr.insertText(text, start + from, start + oldEnd).doc.eq(proposed.doc)) return null;
 		return {
 			from: start + from,
@@ -57,26 +95,62 @@ const createCanonicalComposition = (options) => {
 			semantic: "composition"
 		};
 	};
+	const applyNative = (view, transaction) => Result.try({
+		try: () => view.state.applyTransaction(transaction),
+		catch: (cause) => new CanonicalSessionError({
+			gap: CANONICAL_GAP.dispatch,
+			reason: "refused",
+			message: `Composition projection failed: ${String(cause)}`
+		})
+	});
 	const finish = (view, commit) => {
 		clearTimer();
 		authorizedNativeState = null;
 		const pending = state;
-		if (pending.type === "committed") return;
+		if (pending.type === "committed") return { type: "idle" };
 		const input = commit && pending.type === "provisional" ? replacement(pending.baseline, view.state) : null;
+		const committedText = selectedText(pending.baseline, view.state);
+		const proposed = view.state;
+		const from = pending.baseline.selection.from;
+		completed = { type: "idle" };
 		state = { type: "committed" };
-		if (!view.isDestroyed) view.updateState(pending.baseline);
+		if (!view.isDestroyed) {
+			if (view.composing) view.dom.dispatchEvent(new Event("compositionend", { bubbles: true }));
+			view.updateState(pending.baseline);
+		}
 		options.end();
-		if (!commit || view.isDestroyed || pending.type === "refused") return;
-		if (input?.from === input?.to && input?.text === "") return;
+		if (!commit || view.isDestroyed) return { type: "cancelled" };
+		if (pending.type === "refused") return {
+			type: "refused",
+			text: pending.text
+		};
 		if (!input) {
 			options.refuse("Composition changed unsupported content; the canonical document was restored.");
-			return;
+			return {
+				type: "refused",
+				text: committedText
+			};
 		}
-		options.replace(input);
+		if (input.from !== input.to || input.text !== "") options.replace(input);
+		if (committedText !== null && !view.isDestroyed && view.state.doc.textContent === proposed.doc.textContent && from + committedText.length <= view.state.doc.content.size && view.state.doc.textBetween(from, from + committedText.length, "", "") === committedText) completed = {
+			type: "completed",
+			receipt: {
+				view,
+				state: view.state,
+				from,
+				to: from + committedText.length,
+				text: committedText,
+				marks: pending.baseline.storedMarks ?? pending.baseline.selection.$from.marksAcross(pending.baseline.selection.$to)
+			}
+		};
+		return {
+			type: "committed",
+			text: committedText
+		};
 	};
 	const schedule = (view) => {
 		clearTimer();
-		timer = setTimeout(() => finish(view, true), COMPOSITION_FLUSH_DELAY_MS);
+		timer = setCanonicalInputTimer(() => finish(view, true), 25);
 	};
 	return {
 		get status() {
@@ -85,24 +159,72 @@ const createCanonicalComposition = (options) => {
 		get active() {
 			return state.type !== "committed";
 		},
+		matchesCancellationRange: (view, range) => {
+			if (state.type === "committed" || state.view !== view) return false;
+			const text = selectedText(state.baseline, view.state);
+			if (text === null || text.length === 0) return false;
+			const from = state.baseline.selection.from;
+			if (range.from !== from || range.to !== from + text.length) return false;
+			const selection = view.dom.ownerDocument.getSelection();
+			if (!selection || selection.rangeCount !== 1) return false;
+			const selected = selection.getRangeAt(0);
+			if (!view.dom.contains(selected.startContainer) || !view.dom.contains(selected.endContainer)) return false;
+			return view.posAtDOM(selected.startContainer, selected.startOffset) === range.from && view.posAtDOM(selected.endContainer, selected.endOffset) === range.to;
+		},
 		start: (view) => {
 			if (state.type !== "committed") return;
 			if (!options.begin()) return;
 			state = {
 				type: "provisional",
 				baseline: view.state,
+				view,
 				phase: "active"
 			};
 		},
 		ended: (view) => {
 			if (state.type === "committed") return;
-			state = {
-				type: state.type,
-				baseline: state.baseline,
-				phase: "ended"
-			};
+			switch (state.type) {
+				case "provisional":
+					state = {
+						type: "provisional",
+						baseline: state.baseline,
+						view: state.view,
+						phase: "ended"
+					};
+					break;
+				case "refused":
+					state = {
+						type: "refused",
+						baseline: state.baseline,
+						view: state.view,
+						phase: "ended",
+						text: state.text
+					};
+					break;
+				default:
+			}
 			schedule(view);
 		},
+		forgetCompleted: () => {
+			completed = { type: "idle" };
+		},
+		get pendingFinal() {
+			return completed.type === "authorized";
+		},
+		authorizeLateFinal: (view, text) => {
+			if (completed.type === "idle") return false;
+			const { receipt } = completed;
+			if (view.isDestroyed || receipt.view !== view || receipt.state !== view.state || text === null) {
+				completed = { type: "idle" };
+				return false;
+			}
+			completed = {
+				type: "authorized",
+				receipt,
+				text
+			};
+			return true;
+		},
 		authorizeNative: (view) => {
 			authorizedNativeState = view.state;
 		},
@@ -116,13 +238,53 @@ const createCanonicalComposition = (options) => {
 		recover: (view) => finish(view, true),
 		cancel: (view) => finish(view, false),
 		reset: () => {
-			clearTimer();
-			authorizedNativeState = null;
-			if (state.type !== "committed") options.end();
-			state = { type: "committed" };
+			completed = { type: "idle" };
+			if (state.type !== "committed") finish(state.view, false);
+			else {
+				clearTimer();
+				authorizedNativeState = null;
+			}
 		},
 		accept: (view, transaction) => {
-			if (state.type === "committed") return false;
+			if (state.type === "committed") {
+				const final = completed;
+				if (final.type !== "authorized" || final.receipt.view !== view) return false;
+				completed = { type: "idle" };
+				if (view.isDestroyed || final.receipt.state !== view.state) return false;
+				const applied = applyNative(view, transaction);
+				const baseline = EditorState.create({
+					schema: final.receipt.state.schema,
+					doc: final.receipt.state.doc,
+					selection: TextSelection.create(final.receipt.state.doc, final.receipt.from, final.receipt.to),
+					storedMarks: final.receipt.marks
+				});
+				const input = applied.isOk() ? replacement(baseline, applied.value.state) : null;
+				if (applied.isErr() || !input || input.from < final.receipt.from || input.to > final.receipt.to || selectedText(baseline, applied.value.state) !== final.text) {
+					view.updateState(final.receipt.state);
+					options.refuse(applied.isErr() ? applied.error.message : "Final composition changed unsupported content; the canonical document was restored.");
+					return true;
+				}
+				if (final.receipt.text !== final.text) options.replace({
+					from: final.receipt.from,
+					to: final.receipt.to,
+					text: final.text,
+					semantic: "composition",
+					compositionPhase: "correction"
+				});
+				if (!view.isDestroyed) view.updateState(view.state);
+				if (!view.isDestroyed && view.state.doc.textContent === applied.value.state.doc.textContent && final.receipt.from + final.text.length <= view.state.doc.content.size && view.state.doc.textBetween(final.receipt.from, final.receipt.from + final.text.length, "", "") === final.text) completed = {
+					type: "completed",
+					receipt: {
+						view,
+						state: view.state,
+						from: final.receipt.from,
+						to: final.receipt.from + final.text.length,
+						text: final.text,
+						marks: final.receipt.marks
+					}
+				};
+				return true;
+			}
 			if (state.type === "refused") {
 				view.updateState(state.baseline);
 				return true;
@@ -132,19 +294,15 @@ const createCanonicalComposition = (options) => {
 				return true;
 			}
 			authorizedNativeState = null;
-			const applied = Result.try({
-				try: () => view.state.applyTransaction(transaction),
-				catch: (cause) => new CanonicalSessionError({
-					reason: "refused",
-					message: `Composition projection failed: ${String(cause)}`
-				})
-			});
+			const applied = applyNative(view, transaction);
 			if (applied.isErr()) {
 				view.updateState(state.baseline);
 				state = {
 					type: "refused",
 					baseline: state.baseline,
-					phase: state.phase
+					view: state.view,
+					phase: state.phase,
+					text: selectedText(state.baseline, transaction)
 				};
 				options.refuse(applied.error.message);
 				return true;
@@ -154,7 +312,9 @@ const createCanonicalComposition = (options) => {
 				state = {
 					type: "refused",
 					baseline: state.baseline,
-					phase: state.phase
+					view: state.view,
+					phase: state.phase,
+					text: selectedText(state.baseline, applied.value.state)
 				};
 				options.refuse("Composition changed unsupported content; the canonical document was restored.");
 				return true;

package/dist/controller/canonicalInlineProjection.d.ts

@@ -0,0 +1,118 @@
+import { document_d_exports } from "../types/document.js";
+import { Node } from "prosemirror-model";
+import { Result } from "better-result";
+//#region src/controller/canonicalInlineProjection.d.ts
+declare const CANONICAL_SOURCE_INLINE_POLICIES: {
+  readonly run: "container";
+  readonly hyperlink: "container";
+  readonly insertion: "container";
+  readonly deletion: "container";
+  readonly moveFrom: "container";
+  readonly moveTo: "container";
+  readonly inlineWrapper: "container";
+  readonly inlineSdt: "control";
+  readonly simpleField: "leaf";
+  readonly complexField: "leaf";
+  readonly mathEquation: "leaf";
+  readonly preservedInline: "leaf";
+  readonly bookmarkStart: "leaf";
+  readonly bookmarkEnd: "leaf";
+  readonly commentRangeStart: "leaf";
+  readonly commentRangeEnd: "leaf";
+  readonly commentReference: "leaf";
+  readonly moveFromRangeStart: "leaf";
+  readonly moveFromRangeEnd: "leaf";
+  readonly moveToRangeStart: "leaf";
+  readonly moveToRangeEnd: "leaf";
+  readonly text: "text";
+  readonly tab: "leaf";
+  readonly break: "leaf";
+  readonly symbol: "leaf";
+  readonly footnoteRef: "leaf";
+  readonly endnoteRef: "leaf";
+  readonly noteMarker: "leaf";
+  readonly fieldChar: "rawField";
+  readonly instrText: "rawField";
+  readonly softHyphen: "leaf";
+  readonly noBreakHyphen: "leaf";
+  readonly renderedPageBreak: "layout";
+  readonly preservedXml: "leaf";
+  readonly drawing: "leaf";
+  readonly shape: "leaf";
+};
+declare const CANONICAL_NATIVE_INLINE_POLICIES: {
+  readonly text: "text";
+  readonly bookmarkBoundary: "markers";
+  readonly moveRangeBoundary: "markers";
+  readonly rangeAnchor: "markers";
+  readonly noteMarker: "noteMarker";
+  readonly preservedXml: "capture";
+  readonly field: "unit";
+  readonly structuredField: "unit";
+  readonly hardBreak: "unit";
+  readonly image: "unit";
+  readonly math: "unit";
+  readonly pageBreakRun: "unit";
+  readonly shape: "unit";
+  readonly symbol: "unit";
+  readonly tab: "unit";
+  readonly textBoxAnchor: "unit";
+  readonly commentReference: "unit";
+  readonly renderedPageBreak: "refused";
+  readonly sdt: "refused";
+};
+declare const InlineProjectionError_base: import("better-result").TaggedErrorClass<"InlineProjectionError">;
+declare class InlineProjectionError extends InlineProjectionError_base<{
+  message: string;
+}> {}
+/** Every source variant makes a decision before conversion can discard its positions. */
+declare const canonicalInlineSourceIssue: (items: readonly (document_d_exports.ParagraphContent | document_d_exports.RunContent)[], context?: "paragraph" | "fieldPayload") => string | null;
+type NativeCell = {
+  type: "text";
+  text: string;
+  from: number;
+  to: number;
+  node: Node;
+} | {
+  type: "unit";
+  from: number;
+  to: number;
+  node: Node;
+} | {
+  type: "markedUnit";
+  sourceType: document_d_exports.NoteReferenceContent["type"];
+  label: string;
+  from: number;
+  to: number;
+  node: Node;
+} | {
+  type: "zeroWidth";
+  sources: readonly (document_d_exports.ParagraphContent | document_d_exports.RunContent)[];
+  from: number;
+  to: number;
+  node: Node;
+};
+/** Native positions and deletion geometry read the same inline-cell classification. */
+declare const canonicalNativeCells: (paragraph: Node) => Result<NativeCell[], InlineProjectionError>;
+type CanonicalInlineGap = {
+  position: number;
+  zeroWidthBefore: number;
+};
+type InlineProjection = {
+  text: string;
+  boundaries: CanonicalInlineGap[][];
+};
+type CanonicalInlineProjectionArgs = {
+  source: document_d_exports.Paragraph;
+  paragraph: Node;
+  pairedBookmarkIds: ReadonlySet<number>;
+  commentContext?: {
+    rangedIds: ReadonlySet<number>;
+    pointIds: ReadonlySet<number>;
+    openIds: ReadonlySet<number>;
+  };
+};
+/** Bind rendered gaps to the operation owner's source leaf ordinals, including collapsed pairs. */
+declare const projectCanonicalInline: ({ source, paragraph, pairedBookmarkIds, commentContext }: CanonicalInlineProjectionArgs) => Result<InlineProjection, InlineProjectionError>;
+//#endregion
+export { CANONICAL_NATIVE_INLINE_POLICIES, CANONICAL_SOURCE_INLINE_POLICIES, CanonicalInlineGap, canonicalInlineSourceIssue, canonicalNativeCells, projectCanonicalInline };