@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/api/session-state.ts

@@ -0,0 +1,62 @@
+import type {
+  EditorSessionState,
+  PersistedEditorSnapshot,
+} from "./public-types.ts";
+
+export const EDITOR_SESSION_STATE_VERSION = "editor-session-state/1" as const;
+
+function cloneStructuredValue<T>(value: T): T {
+  return structuredClone(value);
+}
+
+export function createEditorSessionState(
+  input: Omit<EditorSessionState, "sessionVersion">,
+): EditorSessionState {
+  return cloneStructuredValue({
+    sessionVersion: EDITOR_SESSION_STATE_VERSION,
+    ...input,
+  });
+}
+
+export function editorSessionStateFromPersistedSnapshot(
+  snapshot: PersistedEditorSnapshot,
+): EditorSessionState {
+  return createEditorSessionState({
+    schemaVersion: snapshot.schemaVersion,
+    documentId: snapshot.documentId,
+    docId: snapshot.docId,
+    createdAt: snapshot.createdAt,
+    updatedAt: snapshot.updatedAt,
+    editorBuild: snapshot.editorBuild,
+    canonicalDocument: snapshot.canonicalDocument,
+    compatibility: snapshot.compatibility,
+    warningLog: snapshot.warningLog,
+    protectionSnapshot: snapshot.protectionSnapshot,
+    sourcePackage: snapshot.sourcePackage,
+    workflowMetadata: snapshot.workflowMetadata,
+  });
+}
+
+export function persistedSnapshotFromEditorSessionState(
+  sessionState: EditorSessionState,
+  options: {
+    savedAt: string;
+  },
+): PersistedEditorSnapshot {
+  return cloneStructuredValue({
+    snapshotVersion: "persisted-editor-snapshot/2",
+    schemaVersion: sessionState.schemaVersion,
+    documentId: sessionState.documentId,
+    docId: sessionState.docId,
+    createdAt: sessionState.createdAt,
+    updatedAt: sessionState.updatedAt,
+    savedAt: options.savedAt,
+    editorBuild: sessionState.editorBuild,
+    canonicalDocument: sessionState.canonicalDocument,
+    compatibility: sessionState.compatibility,
+    warningLog: sessionState.warningLog,
+    protectionSnapshot: sessionState.protectionSnapshot,
+    sourcePackage: sessionState.sourcePackage,
+    workflowMetadata: sessionState.workflowMetadata,
+  });
+}

package/src/compare/diff-engine.ts

@@ -0,0 +1,623 @@
+import {
+  createCanonicalDocumentSignature,
+  projectCanonicalDocument,
+  type BlockNode,
+  type CanonicalDocument,
+  type HyperlinkNode,
+  type InlineNode,
+  type ParagraphNode,
+  type RevisionRecord,
+  type TextNode,
+} from "../model/canonical-document.ts";
+import type { DocumentVersionSnapshot } from "./snapshot.ts";
+
+export interface CompareVersionRef {
+  versionId: string;
+  name: string;
+  signature: string;
+}
+
+export type CompareChangeKind =
+  | "paragraph-insertion"
+  | "paragraph-deletion"
+  | "paragraph-modification"
+  | "structural-insertion"
+  | "structural-deletion";
+
+export interface CompareChange {
+  changeId: string;
+  kind: CompareChangeKind;
+  tracked: boolean;
+  blockType: BlockNode["type"];
+  beforeText?: string;
+  afterText?: string;
+  targetIndex: number;
+}
+
+export interface VersionCompareResult {
+  compareVersion: "version-compare-result/1";
+  comparedAt: string;
+  base: CompareVersionRef;
+  target: CompareVersionRef;
+  changes: CompareChange[];
+  comparedDocument: CanonicalDocument;
+}
+
+export interface CompareDocumentVersionsOptions {
+  comparedAt?: string;
+  authorId?: string;
+}
+
+interface BuildEntry {
+  changeId?: string;
+  block: BlockNode;
+  trackChange?: "insertion" | "deletion";
+  tracked: boolean;
+  blockType: BlockNode["type"];
+  beforeText?: string;
+  afterText?: string;
+}
+
+interface PendingRevision {
+  changeId: string;
+  kind: "insertion" | "deletion";
+  paragraphIndex: number;
+}
+
+interface LcsMatch {
+  baseIndex: number;
+  targetIndex: number;
+}
+
+export function compareDocumentSnapshots(
+  base: DocumentVersionSnapshot,
+  target: DocumentVersionSnapshot,
+  options: CompareDocumentVersionsOptions = {},
+): VersionCompareResult {
+  const comparedAt = options.comparedAt ?? target.createdAt;
+  const authorId = options.authorId ?? "Version Compare";
+  const baseDocument = base.canonicalDocument;
+  const targetDocument = target.canonicalDocument;
+  const baseBlocks = baseDocument.content.children;
+  const targetBlocks = targetDocument.content.children;
+  const matches = computeLcs(
+    baseBlocks.map(getComparableBlockKey),
+    targetBlocks.map(getComparableBlockKey),
+  );
+
+  const buildEntries: BuildEntry[] = [];
+  const changes: CompareChange[] = [];
+  let nextBaseIndex = 0;
+  let nextTargetIndex = 0;
+  let nextChangeNumber = 1;
+
+  for (const match of [...matches, { baseIndex: baseBlocks.length, targetIndex: targetBlocks.length }]) {
+    while (nextBaseIndex < match.baseIndex || nextTargetIndex < match.targetIndex) {
+      const deleteBlock = nextBaseIndex < match.baseIndex ? baseBlocks[nextBaseIndex] : undefined;
+      const insertBlock = nextTargetIndex < match.targetIndex ? targetBlocks[nextTargetIndex] : undefined;
+
+      if (deleteBlock && insertBlock) {
+        if (deleteBlock.type === "paragraph" && insertBlock.type === "paragraph") {
+          const modificationId = `change-${nextChangeNumber}`;
+          nextChangeNumber += 1;
+          addParagraphModificationEntry(
+            buildEntries,
+            changes,
+            modificationId,
+            deleteBlock,
+            insertBlock,
+            nextTargetIndex,
+          );
+          nextBaseIndex += 1;
+          nextTargetIndex += 1;
+          continue;
+        }
+
+        const deletionId = `change-${nextChangeNumber}`;
+        nextChangeNumber += 1;
+        addTrackedOrStructuralEntry(
+          buildEntries,
+          changes,
+          deletionId,
+          deleteBlock,
+          "deletion",
+          nextTargetIndex,
+        );
+
+        const insertionId = `change-${nextChangeNumber}`;
+        nextChangeNumber += 1;
+        addTrackedOrStructuralEntry(
+          buildEntries,
+          changes,
+          insertionId,
+          insertBlock,
+          "insertion",
+          nextTargetIndex,
+        );
+        nextBaseIndex += 1;
+        nextTargetIndex += 1;
+        continue;
+      }
+
+      if (deleteBlock) {
+        const changeId = `change-${nextChangeNumber}`;
+        nextChangeNumber += 1;
+        addTrackedOrStructuralEntry(
+          buildEntries,
+          changes,
+          changeId,
+          deleteBlock,
+          "deletion",
+          nextTargetIndex,
+        );
+        nextBaseIndex += 1;
+        continue;
+      }
+
+      if (insertBlock) {
+        const changeId = `change-${nextChangeNumber}`;
+        nextChangeNumber += 1;
+        addTrackedOrStructuralEntry(
+          buildEntries,
+          changes,
+          changeId,
+          insertBlock,
+          "insertion",
+          nextTargetIndex,
+        );
+        nextTargetIndex += 1;
+      }
+    }
+
+    if (match.baseIndex < baseBlocks.length && match.targetIndex < targetBlocks.length) {
+      const baseText = getBlockDisplayText(baseBlocks[match.baseIndex]);
+      const targetText = getBlockDisplayText(targetBlocks[match.targetIndex]);
+      const isModified =
+        baseBlocks[match.baseIndex].type === "paragraph" &&
+        targetBlocks[match.targetIndex].type === "paragraph" &&
+        baseText !== targetText;
+
+      if (isModified) {
+        const modChangeId = `change-${nextChangeNumber}`;
+        nextChangeNumber += 1;
+        addParagraphModificationEntry(
+          buildEntries,
+          changes,
+          modChangeId,
+          baseBlocks[match.baseIndex] as ParagraphNode,
+          targetBlocks[match.targetIndex] as ParagraphNode,
+          match.targetIndex,
+        );
+      } else {
+        buildEntries.push({
+          block: cloneBlock(targetBlocks[match.targetIndex]),
+          tracked: false,
+          blockType: targetBlocks[match.targetIndex].type,
+          beforeText: baseText,
+          afterText: targetText,
+        });
+      }
+
+      nextBaseIndex = match.baseIndex + 1;
+      nextTargetIndex = match.targetIndex + 1;
+    }
+  }
+
+  const built = buildComparedDocument(baseDocument, targetDocument, buildEntries, comparedAt, authorId);
+  return {
+    compareVersion: "version-compare-result/1",
+    comparedAt,
+    base: {
+      versionId: base.versionId,
+      name: base.name,
+      signature: base.documentSignature,
+    },
+    target: {
+      versionId: target.versionId,
+      name: target.name,
+      signature: target.documentSignature,
+    },
+    changes,
+    comparedDocument: built,
+  };
+}
+
+function addTrackedOrStructuralEntry(
+  buildEntries: BuildEntry[],
+  changes: CompareChange[],
+  changeId: string,
+  block: BlockNode,
+  direction: "insertion" | "deletion",
+  targetIndex: number,
+): void {
+  const tracked = block.type === "paragraph";
+  const cloned = cloneBlock(block);
+  const text = getBlockDisplayText(block);
+
+  buildEntries.push({
+    ...(tracked ? { changeId } : {}),
+    block: cloned,
+    ...(tracked ? { trackChange: direction } : {}),
+    tracked,
+    blockType: cloned.type,
+    ...(direction === "deletion" ? { beforeText: text } : { afterText: text }),
+  });
+
+  changes.push({
+    changeId,
+    kind:
+      block.type === "paragraph"
+        ? direction === "insertion"
+          ? "paragraph-insertion"
+          : "paragraph-deletion"
+        : direction === "insertion"
+          ? "structural-insertion"
+          : "structural-deletion",
+    tracked,
+    blockType: cloned.type,
+    ...(direction === "deletion" ? { beforeText: text } : { afterText: text }),
+    targetIndex,
+  });
+}
+
+function addParagraphModificationEntry(
+  buildEntries: BuildEntry[],
+  changes: CompareChange[],
+  changeId: string,
+  baseParagraph: ParagraphNode,
+  targetParagraph: ParagraphNode,
+  targetIndex: number,
+): void {
+  const beforeText = getBlockDisplayText(baseParagraph);
+  const afterText = getBlockDisplayText(targetParagraph);
+
+  buildEntries.push({
+    changeId: `${changeId}-before`,
+    block: cloneBlock(baseParagraph),
+    trackChange: "deletion",
+    tracked: true,
+    blockType: "paragraph",
+    beforeText,
+  });
+  buildEntries.push({
+    changeId: `${changeId}-after`,
+    block: cloneBlock(targetParagraph),
+    trackChange: "insertion",
+    tracked: true,
+    blockType: "paragraph",
+    afterText,
+  });
+
+  changes.push({
+    changeId,
+    kind: "paragraph-modification",
+    tracked: true,
+    blockType: "paragraph",
+    beforeText,
+    afterText,
+    targetIndex,
+  });
+}
+
+function buildComparedDocument(
+  base: CanonicalDocument,
+  target: CanonicalDocument,
+  entries: readonly BuildEntry[],
+  comparedAt: string,
+  authorId: string,
+): CanonicalDocument {
+  const contentChildren: BlockNode[] = [];
+  const pendingRevisions: PendingRevision[] = [];
+  const diagnosticsWarnings = [...target.diagnostics.warnings];
+  let paragraphIndex = 0;
+  let warningNumber = 1;
+
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (!entry) {
+      continue;
+    }
+
+    contentChildren.push(entry.block);
+    if (entry.block.type === "paragraph") {
+      if (entry.trackChange) {
+        pendingRevisions.push({
+          changeId: entry.changeId ?? `change-${pendingRevisions.length + 1}`,
+          kind: entry.trackChange,
+          paragraphIndex,
+        });
+      }
+      paragraphIndex += 1;
+      continue;
+    }
+
+    if (!entry.tracked) {
+      diagnosticsWarnings.push({
+        diagnosticId: `diagnostic:compare-structural-${warningNumber}`,
+        warningId: `warning:compare-structural-${warningNumber}`,
+        source: "review",
+        message: `Version compare preserved a ${entry.blockType} ${entry.beforeText ? "deletion" : "insertion"} without a Word revision wrapper.`,
+      });
+      warningNumber += 1;
+    }
+  }
+
+  const revisions = createParagraphRevisionRecords(
+    contentChildren,
+    pendingRevisions,
+    comparedAt,
+    authorId,
+  );
+
+  return {
+    ...projectCanonicalDocument(target),
+    updatedAt: comparedAt,
+    styles: mergeStyleCatalogs(base.styles, target.styles),
+    numbering: mergeRecordCatalog(base.numbering, target.numbering),
+    media: mergeRecordCatalog(base.media, target.media),
+    content: {
+      type: "doc",
+      children: contentChildren,
+    },
+    review: {
+      comments: projectValue(target.review.comments),
+      revisions,
+    },
+    preservation: mergePreservationStores(base.preservation, target.preservation),
+    diagnostics: {
+      warnings: diagnosticsWarnings,
+      errors: [...target.diagnostics.errors],
+    },
+    ...(target.subParts ?? base.subParts ? { subParts: projectValue(target.subParts ?? base.subParts) } : {}),
+  };
+}
+
+function createParagraphRevisionRecords(
+  children: readonly BlockNode[],
+  pendingRevisions: readonly PendingRevision[],
+  createdAt: string,
+  authorId: string,
+): CanonicalDocument["review"]["revisions"] {
+  const positionByParagraphIndex = new Map<number, number>();
+  let cursor = 0;
+  let paragraphIndex = 0;
+  let previousWasParagraph = false;
+
+  for (const block of children) {
+    if (block.type === "paragraph") {
+      if (previousWasParagraph) {
+        cursor += 1;
+      }
+      cursor += getParagraphLength(block);
+      positionByParagraphIndex.set(paragraphIndex, cursor);
+      paragraphIndex += 1;
+      previousWasParagraph = true;
+      continue;
+    }
+
+    cursor += 1;
+    previousWasParagraph = false;
+  }
+
+  const entries: Array<[string, RevisionRecord]> = [];
+  pendingRevisions.forEach((revision) => {
+    const position = positionByParagraphIndex.get(revision.paragraphIndex);
+    if (position === undefined) {
+      return;
+    }
+
+    const record: RevisionRecord = {
+      changeId: revision.changeId,
+      kind: revision.kind,
+      anchor: {
+        kind: "range",
+        range: { from: position, to: position },
+        assoc: { start: -1, end: 1 },
+      },
+      authorId,
+      createdAt,
+      status: "open",
+      warningIds: [],
+      metadata: {
+        source: "runtime",
+        importedRevisionForm:
+          revision.kind === "insertion" ? "paragraph-insertion" : "paragraph-deletion",
+      },
+    };
+    entries.push([revision.changeId, record]);
+  });
+  return Object.fromEntries(entries);
+}
+
+function getComparableBlockKey(block: BlockNode): string {
+  if (block.type === "paragraph") {
+    return `paragraph:${createCanonicalDocumentSignature({
+      ...block,
+      children: normalizeInlineChildren(block.children),
+    })}`;
+  }
+
+  return `${block.type}:${createCanonicalDocumentSignature(block)}`;
+}
+
+function normalizeInlineChildren(children: readonly InlineNode[]): InlineNode[] {
+  return children.map((child) => {
+    if (child.type === "hyperlink") {
+      return {
+        ...child,
+        children: normalizeInlineChildren(child.children) as HyperlinkNode["children"],
+      };
+    }
+    if (child.type === "field") {
+      return {
+        ...child,
+        children: normalizeInlineChildren(child.children),
+      };
+    }
+    return projectValue(child);
+  });
+}
+
+function computeLcs(baseKeys: readonly string[], targetKeys: readonly string[]): LcsMatch[] {
+  const widths = targetKeys.length + 1;
+  const matrix = Array.from({ length: baseKeys.length + 1 }, () =>
+    Array.from({ length: widths }, () => 0),
+  );
+
+  for (let baseIndex = baseKeys.length - 1; baseIndex >= 0; baseIndex -= 1) {
+    for (let targetIndex = targetKeys.length - 1; targetIndex >= 0; targetIndex -= 1) {
+      matrix[baseIndex][targetIndex] =
+        baseKeys[baseIndex] === targetKeys[targetIndex]
+          ? matrix[baseIndex + 1][targetIndex + 1] + 1
+          : Math.max(matrix[baseIndex + 1][targetIndex], matrix[baseIndex][targetIndex + 1]);
+    }
+  }
+
+  const matches: LcsMatch[] = [];
+  let baseIndex = 0;
+  let targetIndex = 0;
+  while (baseIndex < baseKeys.length && targetIndex < targetKeys.length) {
+    if (baseKeys[baseIndex] === targetKeys[targetIndex]) {
+      matches.push({ baseIndex, targetIndex });
+      baseIndex += 1;
+      targetIndex += 1;
+      continue;
+    }
+
+    if (matrix[baseIndex + 1][targetIndex] >= matrix[baseIndex][targetIndex + 1]) {
+      baseIndex += 1;
+    } else {
+      targetIndex += 1;
+    }
+  }
+
+  return matches;
+}
+
+function getParagraphLength(paragraph: ParagraphNode): number {
+  return paragraph.children.reduce((length, child) => length + getInlineLength(child), 0);
+}
+
+function getInlineLength(node: InlineNode): number {
+  switch (node.type) {
+    case "text":
+      return Array.from(node.text).length;
+    case "hyperlink":
+      return node.children.reduce((length, child) => length + getInlineLength(child), 0);
+    case "field":
+      return node.children.reduce((length, child) => length + getInlineLength(child), 0);
+    case "tab":
+    case "hard_break":
+    case "column_break":
+    case "symbol":
+    case "image":
+    case "opaque_inline":
+    case "footnote_ref":
+    case "bookmark_start":
+    case "bookmark_end":
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+      return 1;
+  }
+}
+
+function getBlockDisplayText(block: BlockNode): string {
+  switch (block.type) {
+    case "paragraph":
+      return block.children.map(getInlineDisplayText).join("");
+    case "table":
+      return "[Table]";
+    case "sdt":
+      return "[Structured content]";
+    case "custom_xml":
+      return "[Custom XML block]";
+    case "alt_chunk":
+      return "[Alt chunk]";
+    case "section_break":
+      return "[Section break]";
+    case "opaque_block":
+      return "[Preserved block]";
+  }
+}
+
+function getInlineDisplayText(node: InlineNode): string {
+  switch (node.type) {
+    case "text":
+      return node.text;
+    case "tab":
+      return "\t";
+    case "hard_break":
+    case "column_break":
+      return "\n";
+    case "symbol":
+      return node.char;
+    case "hyperlink":
+      return node.children.map(getInlineDisplayText).join("");
+    case "field":
+      return node.children.map(getInlineDisplayText).join("");
+    case "image":
+      return node.altText ?? "[Image]";
+    case "opaque_inline":
+      return "[Preserved]";
+    case "footnote_ref":
+      return "[Footnote]";
+    case "bookmark_start":
+    case "bookmark_end":
+      return "";
+    case "chart_preview":
+      return "[Chart]";
+    case "smartart_preview":
+      return "[SmartArt]";
+    case "shape":
+      return node.text ?? "[Shape]";
+    case "wordart":
+      return node.text;
+    case "vml_shape":
+      return node.text ?? "[VML Shape]";
+  }
+}
+
+function mergeStyleCatalogs(
+  base: CanonicalDocument["styles"],
+  target: CanonicalDocument["styles"],
+): CanonicalDocument["styles"] {
+  return {
+    paragraphs: { ...base.paragraphs, ...target.paragraphs },
+    characters: { ...base.characters, ...target.characters },
+    tables: { ...base.tables, ...target.tables },
+    ...((base.latentStyles || target.latentStyles)
+      ? { latentStyles: { ...(base.latentStyles ?? {}), ...(target.latentStyles ?? {}) } }
+      : {}),
+  };
+}
+
+function mergePreservationStores(
+  base: CanonicalDocument["preservation"],
+  target: CanonicalDocument["preservation"],
+): CanonicalDocument["preservation"] {
+  return {
+    opaqueFragments: {
+      ...base.opaqueFragments,
+      ...target.opaqueFragments,
+    },
+    packageParts: {
+      ...base.packageParts,
+      ...target.packageParts,
+    },
+  };
+}
+
+function mergeRecordCatalog<T extends object>(base: T, target: T): T {
+  return projectValue({ ...base, ...target });
+}
+
+function cloneBlock<T extends BlockNode>(block: T): T {
+  return projectValue(block);
+}
+
+function projectValue<T>(value: T): T {
+  return structuredClone(value);
+}