@stll/folio-core 0.54.2 → 0.55.0

package/dist/controller/canonicalOperations.js

@@ -0,0 +1,85 @@
+import { visitDocxParagraphs } from "../docx/paragraphTraversal.js";
+import { generateHexId, isValidHexId } from "../utils/hexId.js";
+import { DOCUMENT_OP_TYPES, DOCUMENT_OP_TYPES as DOCUMENT_OP_TYPES$1 } from "@stll/docx-core/ops";
+//#region src/controller/canonicalOperations.ts
+/** Adapter command boundaries allocate identities; journaled operations remain deterministic. */
+const canonicalFinalSectionIndex = (document) => document.package.document.content.filter((block) => block.type === "paragraph" && block.sectionProperties !== void 0).length;
+const withCanonicalParagraphIds = (content, document) => {
+	const taken = /* @__PURE__ */ new Set();
+	const { document: documentBody, headers, footers, footnotes, endnotes } = document.package;
+	visitDocxParagraphs({
+		documentBody,
+		headers,
+		footers,
+		footnotes,
+		endnotes
+	}, (paragraph) => {
+		if (paragraph.paraId) taken.add(paragraph.paraId.toUpperCase());
+	});
+	const owned = structuredClone(content);
+	visitDocxParagraphs({ documentBody: { content: owned } }, (paragraph) => {
+		if (paragraph.paraId && isValidHexId(paragraph.paraId) && Number.parseInt(paragraph.paraId, 16) > 0 && Number.parseInt(paragraph.paraId, 16) < 2147483647 && !taken.has(paragraph.paraId.toUpperCase())) {
+			taken.add(paragraph.paraId.toUpperCase());
+			return;
+		}
+		let paraId = generateHexId();
+		while (taken.has(paraId)) paraId = generateHexId();
+		taken.add(paraId);
+		paragraph.paraId = paraId;
+	});
+	return owned;
+};
+const createCanonicalHeaderFooterOperation = ({ document, position, referenceType, sectionIndex = canonicalFinalSectionIndex(document) }) => {
+	const occupied = /* @__PURE__ */ new Set([
+		...document.package.headers?.keys() ?? [],
+		...document.package.footers?.keys() ?? [],
+		...document.package.relationships?.keys() ?? []
+	]);
+	const base = `rId_new_${position}_${referenceType}`;
+	let rId = base;
+	let suffix = 2;
+	while (occupied.has(rId)) rId = `${base}_${suffix++}`;
+	return {
+		type: DOCUMENT_OP_TYPES$1.CREATE_HEADER_FOOTER,
+		sectionIndex,
+		story: {
+			kind: position,
+			rId
+		},
+		referenceType,
+		content: withCanonicalParagraphIds([{
+			type: "paragraph",
+			content: []
+		}], document)
+	};
+};
+/** Remove each explicit binding, leaving inherited sections to inherit the remaining parts. */
+const removeCanonicalHeaderFooterOperations = ({ document, position, rId }) => {
+	const properties = [];
+	for (const block of document.package.document.content) if (block.type === "paragraph" && block.sectionProperties) properties.push(block.sectionProperties);
+	properties.push(document.package.document.finalSectionProperties ?? {});
+	const operations = [];
+	for (const [sectionIndex, section] of properties.entries()) {
+		const references = position === "header" ? section.headerReferences : section.footerReferences;
+		for (const reference of references ?? []) {
+			if (reference.rId !== rId) continue;
+			operations.push({
+				type: DOCUMENT_OP_TYPES$1.REMOVE_HEADER_FOOTER,
+				sectionIndex,
+				story: {
+					kind: position,
+					rId
+				},
+				referenceType: reference.type
+			});
+		}
+	}
+	return operations;
+};
+const createCanonicalSectionPropertiesOperation = (document, patch) => ({
+	type: DOCUMENT_OP_TYPES$1.SET_SECTION_PROPS,
+	sectionIndex: canonicalFinalSectionIndex(document),
+	patch
+});
+//#endregion
+export { DOCUMENT_OP_TYPES, canonicalFinalSectionIndex, createCanonicalHeaderFooterOperation, createCanonicalSectionPropertiesOperation, removeCanonicalHeaderFooterOperations, withCanonicalParagraphIds };

package/dist/controller/canonicalReview.d.ts

@@ -0,0 +1,12 @@
+import { FolioEditor } from "./folioEditor.js";
+//#region src/controller/canonicalReview.d.ts
+type ResolveCanonicalReviewRangeOptions = {
+  editor: Pick<FolioEditor, "getCanonicalDocument" | "getState" | "resolveCanonicalRevisions"> | null | undefined;
+  from: number;
+  to: number;
+  resolution: "accept" | "reject";
+};
+/** Null delegates to the default session's ProseMirror review commands. */
+declare const resolveCanonicalReviewRange: ({ editor, from, to, resolution }: ResolveCanonicalReviewRangeOptions) => boolean | null;
+//#endregion
+export { resolveCanonicalReviewRange };

package/dist/controller/canonicalReview.js

@@ -0,0 +1,19 @@
+import { getTrackedChangeGroupIdsFromDoc, getTrackedChangesFromDoc } from "../ai-edits/read.js";
+import { findAIEditRevisionRange } from "../prosemirror/commands/comments.js";
+//#region src/controller/canonicalReview.ts
+/** Null delegates to the default session's ProseMirror review commands. */
+const resolveCanonicalReviewRange = ({ editor, from, to, resolution }) => {
+	if (!editor?.getCanonicalDocument()) return null;
+	const state = editor.getState();
+	if (!state) return false;
+	const ids = /* @__PURE__ */ new Set();
+	for (const change of getTrackedChangesFromDoc(state.doc)) {
+		const groupIds = getTrackedChangeGroupIdsFromDoc(state.doc, change.id);
+		const range = findAIEditRevisionRange(state, groupIds);
+		if (!range) continue;
+		if (from === to ? range.from <= from && range.to >= to : range.from < to && range.to > from) for (const id of groupIds) ids.add(id);
+	}
+	return ids.size > 0 && editor.resolveCanonicalRevisions([...ids], resolution);
+};
+//#endregion
+export { resolveCanonicalReviewRange };

package/dist/controller/canonicalSession.d.ts

@@ -0,0 +1,149 @@
+import { document_d_exports } from "../types/document.js";
+import { Node } from "prosemirror-model";
+import { EditorState, Transaction } from "prosemirror-state";
+import { Result } from "better-result";
+import { DocumentOp, EditorIntent, OpStory, TextPosition, TouchedBlocks } from "@stll/docx-core/ops";
+//#region src/controller/canonicalSession.d.ts
+declare const CanonicalSessionError_base: import("better-result").TaggedErrorClass<"CanonicalSessionError">;
+declare class CanonicalSessionError extends CanonicalSessionError_base<{
+  message: string;
+  reason: "refused" | "noChange";
+}> {}
+type CanonicalSelection = {
+  anchor: TextPosition;
+  head: TextPosition;
+};
+type CanonicalOrigin = "input" | "undo" | "redo";
+type CanonicalSessionMode = {
+  type: "editing";
+} | {
+  type: "suggesting";
+  author: string;
+};
+declare const CANONICAL_PROJECTION_META = "folioCanonicalProjection";
+type ParagraphAddress = {
+  blockId: string;
+  start: number;
+  text: string;
+  boundaries: readonly (readonly number[])[];
+  node: Node;
+  source: document_d_exports.Paragraph;
+};
+type CanonicalProjectionOptions = {
+  doc: Node;
+  paragraphs: readonly ParagraphAddress[];
+  story: OpStory;
+};
+/** Paragraph gaps map logical UTF-16 units and zero-width note marks to PM positions. */
+declare class CanonicalProjection {
+  readonly doc: Node;
+  readonly story: OpStory;
+  private readonly paragraphs;
+  private readonly paragraphsById;
+  constructor({ doc, paragraphs, story }: CanonicalProjectionOptions);
+  addressAt(position: number): Result<TextPosition, CanonicalSessionError>;
+  inputAddressAt(position: number): Result<TextPosition, CanonicalSessionError>;
+  positionAt(address: TextPosition): Result<number, CanonicalSessionError>;
+  selectionAt(state: EditorState): Result<CanonicalSelection, CanonicalSessionError>;
+  paragraph(blockId: string): ParagraphAddress | undefined;
+}
+/** Input intent, never projection-step adjacency, determines the journal partition. */
+type CanonicalInputSemantic = "typing" | "deleteBackward" | "deleteForward" | "paste" | "composition" | "replacement" | "structure";
+type CanonicalCommit = {
+  transaction: Transaction;
+  document: document_d_exports.Document;
+  projection: CanonicalProjection;
+  bodyProjection: CanonicalProjection;
+  touched: TouchedBlocks;
+  version: number;
+  origin: CanonicalOrigin;
+  /** Publish only after every projection/plugin transaction has been accepted. */
+  publish: () => Result<void, CanonicalSessionError>;
+};
+/** Metadata is descriptive; transaction identity and session version authorize mutations. */
+declare const isCanonicalProjectionTransaction: (transaction: Transaction, session: CanonicalSession) => boolean;
+type PublishCanonicalProjectionOptions = {
+  state: EditorState;
+  commit: CanonicalCommit;
+  session: CanonicalSession;
+};
+/** The model publishes only after PM and every plugin accept its exact projection. */
+declare const publishCanonicalProjection: ({ state, commit, session }: PublishCanonicalProjectionOptions) => import("better-result").Err<never, CanonicalSessionError> | import("better-result").Ok<{
+  state: EditorState;
+  transactions: readonly Transaction[];
+}, never>;
+type CanonicalSessionSeedOptions = {
+  document: document_d_exports.Document;
+  projection: CanonicalProjection;
+  styles: document_d_exports.StyleDefinitions | null | undefined;
+};
+type CanonicalReplaceTextInput = {
+  from: number;
+  to: number;
+  text: string;
+  story?: OpStory;
+  semantic?: CanonicalInputSemantic;
+  time?: number;
+};
+/** Immutable model authority with a journal staged independently of the PM view. */
+declare class CanonicalSession {
+  private currentDocument;
+  private currentProjection;
+  private currentVersion;
+  private readonly allocateIntentIds;
+  private mode;
+  private readonly allocatedBlockIds;
+  private nextBlockId;
+  private readonly sourceOwners;
+  private readonly storyProjections;
+  private currentSelection;
+  private readonly applied;
+  private groupingBoundary;
+  private lifecycle;
+  private readonly undone;
+  private readonly styles;
+  constructor({ document, projection, styles }: CanonicalSessionSeedOptions);
+  setMode(mode: CanonicalSessionMode): void;
+  hasStyle(styleId: string): boolean;
+  private advanceBlockId;
+  private freshBlockId;
+  private intentMode;
+  private intentNeedsIdentityIds;
+  private rememberSources;
+  get document(): document_d_exports.Document;
+  get projection(): CanonicalProjection;
+  get selection(): CanonicalSelection | null;
+  get version(): number;
+  get canUndo(): boolean;
+  get canRedo(): boolean;
+  get isComposing(): boolean;
+  breakUndoGroup(): void;
+  beginComposition(): Result<void, CanonicalSessionError>;
+  endComposition(): void;
+  private checkState;
+  prepareReplace(state: EditorState, { from, to, text, story, semantic, time }: CanonicalReplaceTextInput): Result<CanonicalCommit, CanonicalSessionError>;
+  prepareIntent(state: EditorState, intent: EditorIntent): Result<CanonicalCommit, CanonicalSessionError>;
+  prepareIntents(state: EditorState, intents: readonly EditorIntent[]): Result<CanonicalCommit, CanonicalSessionError>;
+  prepareOps(state: EditorState, ops: readonly DocumentOp[], postSelection: CanonicalSelection): Result<CanonicalCommit, CanonicalSessionError>;
+  private prepareJournalledOps;
+  prepareSplit(state: EditorState): Result<CanonicalCommit, CanonicalSessionError>;
+  prepareJoin(state: EditorState, direction: "backward" | "forward"): Result<CanonicalCommit, CanonicalSessionError>;
+  prepareResolve(state: EditorState, { revisionIds, resolution }: {
+    revisionIds: readonly number[];
+    resolution: "accept" | "reject";
+  }): Result<CanonicalCommit, CanonicalSessionError>;
+  projectStory(story: OpStory): Result<CanonicalProjection, CanonicalSessionError>;
+  prepareOperations(state: EditorState, ops: readonly DocumentOp[]): Result<CanonicalCommit, CanonicalSessionError>;
+  prepareUndo(state: EditorState, story?: OpStory): Result<CanonicalCommit, CanonicalSessionError>;
+  prepareRedo(state: EditorState, story?: OpStory): Result<CanonicalCommit, CanonicalSessionError>;
+  private stage;
+}
+declare const createCanonicalSession: (document: document_d_exports.Document, styles?: document_d_exports.StyleDefinitions | null) => Result<CanonicalSession, CanonicalSessionError>;
+declare const isCanonicalJoinBoundary: (state: EditorState, direction: "backward" | "forward") => boolean;
+/** Native character deletion consumes one whole visible grapheme. */
+declare const deletionRange: (state: EditorState, direction: "backward" | "forward") => Result<{
+  from: number;
+  to: number;
+}, CanonicalSessionError>;
+//#endregion
+export { CANONICAL_PROJECTION_META, CanonicalCommit, CanonicalInputSemantic, CanonicalOrigin, type CanonicalProjection, CanonicalSelection, type CanonicalSession, CanonicalSessionError, CanonicalSessionMode, createCanonicalSession, deletionRange, isCanonicalJoinBoundary, isCanonicalProjectionTransaction, publishCanonicalProjection };