@beyondwork/docx-react-component 1.0.28 → 1.0.29

package/src/api/session-state.ts

@@ -1,60 +0,0 @@
-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,
-  });
-}
-
-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,
-  });
-}

package/src/compare/diff-engine.ts

@@ -1,623 +0,0 @@
-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);
-}