@stll/folio-core 0.54.2 → 0.56.0

package/dist/controller/canonicalComposition.js

@@ -0,0 +1,296 @@
+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;
+		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;
+		while (oldEnd > from && newEnd > from && before[oldEnd - 1] === after[newEnd - 1]) {
+			oldEnd--;
+			newEnd--;
+		}
+		while (splitsSurrogatePair(before, oldEnd) || splitsSurrogatePair(after, newEnd)) {
+			oldEnd++;
+			newEnd++;
+		}
+		const text = after.slice(from, newEnd);
+		if (!baseline.tr.insertText(text, start + from, start + oldEnd).doc.eq(proposed.doc)) return null;
+		return {
+			from: start + from,
+			to: start + oldEnd,
+			text,
+			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 { 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) {
+			if (view.composing) view.dom.dispatchEvent(new Event("compositionend", { bubbles: true }));
+			view.updateState(pending.baseline);
+		}
+		options.end();
+		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 {
+				type: "refused",
+				text: committedText
+			};
+		}
+		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 = setCanonicalInputTimer(() => finish(view, true), COMPOSITION_FLUSH_DELAY_MS);
+	};
+	return {
+		get status() {
+			return state.type;
+		},
+		get active() {
+			return state.type !== "committed";
+		},
+		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;
+			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;
+		},
+		flushed: (view) => {
+			const authorized = authorizedNativeState;
+			queueMicrotask(() => {
+				if (authorizedNativeState === authorized) authorizedNativeState = null;
+			});
+			if (state.type !== "committed" && state.phase === "ended") schedule(view);
+		},
+		recover: (view) => finish(view, true),
+		cancel: (view) => finish(view, false),
+		reset: () => {
+			completed = { type: "idle" };
+			if (state.type !== "committed") finish(state.view, false);
+			else {
+				clearTimer();
+				authorizedNativeState = null;
+			}
+		},
+		accept: (view, transaction) => {
+			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;
+			}
+			if (typeof transaction.getMeta("composition") !== "number" && authorizedNativeState !== view.state) {
+				options.refuse("Other edits must wait until composition finishes.");
+				return true;
+			}
+			authorizedNativeState = null;
+			const applied = applyNative(view, transaction);
+			if (applied.isErr()) {
+				view.updateState(state.baseline);
+				state = {
+					type: "refused",
+					baseline: state.baseline,
+					view: state.view,
+					phase: state.phase,
+					text: selectedText(state.baseline, transaction)
+				};
+				options.refuse(applied.error.message);
+				return true;
+			}
+			if (!replacement(state.baseline, applied.value.state)) {
+				view.updateState(state.baseline);
+				state = {
+					type: "refused",
+					baseline: state.baseline,
+					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;
+			}
+			view.updateState(applied.value.state);
+			return true;
+		}
+	};
+};
+//#endregion
+export { createCanonicalComposition };

package/dist/controller/canonicalInlineProjection.d.ts

@@ -0,0 +1,113 @@
+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>;
+};
+/** Bind rendered gaps to the operation owner's source leaf ordinals, including collapsed pairs. */
+declare const projectCanonicalInline: ({ source, paragraph, pairedBookmarkIds }: CanonicalInlineProjectionArgs) => Result<InlineProjection, InlineProjectionError>;
+//#endregion
+export { CANONICAL_NATIVE_INLINE_POLICIES, CANONICAL_SOURCE_INLINE_POLICIES, CanonicalInlineGap, canonicalInlineSourceIssue, canonicalNativeCells, projectCanonicalInline };