@beyondwork/docx-react-component 1.0.10 → 1.0.12

package/src/model/snapshot.ts

@@ -1,8 +1,10 @@
 import {
   CDS_SCHEMA_VERSION,
   COMPATIBILITY_REPORT_VERSION,
+  LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION,
   PERSISTED_EDITOR_SNAPSHOT_VERSION,
   type CompatibilityReportVersion,
+  type Base64,
   type ISO8601DateTime,
   type ModelValidationIssue,
   type PersistedEditorSnapshotVersion,
@@ -87,6 +89,15 @@ export interface CompatibilityReport {
   errors: EditorError[];
 }
 
+export interface PersistedSourcePackage {
+  format: "docx";
+  storage: "embedded-base64";
+  mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+  sourceLabel?: string;
+  sha256Hex: string;
+  bytesBase64: Base64;
+}
+
 export interface PersistedEditorSnapshot {
   snapshotVersion: PersistedEditorSnapshotVersion;
   schemaVersion: typeof CDS_SCHEMA_VERSION;
@@ -99,9 +110,10 @@ export interface PersistedEditorSnapshot {
   canonicalDocument: CanonicalDocument;
   compatibility: CompatibilityReport;
   warningLog: EditorWarning[];
+  sourcePackage?: PersistedSourcePackage;
 }
 
-const SNAPSHOT_TOP_LEVEL_KEYS = [
+const SNAPSHOT_REQUIRED_TOP_LEVEL_KEYS = [
   "snapshotVersion",
   "schemaVersion",
   "documentId",
@@ -115,6 +127,56 @@ const SNAPSHOT_TOP_LEVEL_KEYS = [
   "warningLog",
 ] as const;
 
+const SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS = ["sourcePackage"] as const;
+
+const PERSISTED_EDITOR_SNAPSHOT_VERSIONS = new Set<PersistedEditorSnapshotVersion>([
+  LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION,
+  PERSISTED_EDITOR_SNAPSHOT_VERSION,
+]);
+
+const DOCX_SOURCE_PACKAGE_MIME_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+const COMPATIBILITY_FEATURE_CLASSES = new Set<CompatibilityFeatureClass>([
+  "supported-roundtrip",
+  "preserve-only",
+  "unsupported-fatal",
+]);
+const EDITOR_WARNING_CODES = new Set<EditorWarningCode>([
+  "unsupported_ooxml_preserved",
+  "unsupported_ooxml_locked",
+  "import_normalized",
+  "export_roundtrip_risk",
+  "comment_anchor_detached",
+  "revision_anchor_detached",
+  "large_document_degraded",
+  "font_substitution",
+  "image_missing",
+]);
+const EDITOR_WARNING_SEVERITIES = new Set<EditorWarning["severity"]>(["info", "warning"]);
+const EDITOR_WARNING_SOURCES = new Set<EditorWarning["source"]>([
+  "import",
+  "runtime",
+  "review",
+  "preservation",
+  "validation",
+  "export",
+]);
+const EDITOR_ERROR_CODES = new Set<EditorErrorCode>([
+  "import_failed",
+  "export_failed",
+  "package_corrupt",
+  "validation_failed",
+  "datastore_failed",
+  "internal_invariant",
+]);
+const EDITOR_ERROR_SOURCES = new Set<EditorError["source"]>([
+  "import",
+  "runtime",
+  "validation",
+  "datastore",
+  "export",
+]);
+
 export function serializePersistedEditorSnapshot(
   snapshot: PersistedEditorSnapshot,
 ): string {
@@ -146,14 +208,15 @@ export function validatePersistedEditorSnapshot(
     return issues;
   }
 
-  validateExactObjectKeys(record, SNAPSHOT_TOP_LEVEL_KEYS, "$", issues);
-
-  expectExactString(
-    record.snapshotVersion,
-    PERSISTED_EDITOR_SNAPSHOT_VERSION,
-    "$.snapshotVersion",
+  validateExactObjectKeys(
+    record,
+    SNAPSHOT_REQUIRED_TOP_LEVEL_KEYS,
+    SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS,
+    "$",
     issues,
   );
+
+  validateSnapshotVersion(record.snapshotVersion, "$.snapshotVersion", issues);
   expectExactString(
     record.schemaVersion,
     CDS_SCHEMA_VERSION,
@@ -193,6 +256,10 @@ export function validatePersistedEditorSnapshot(
     });
   }
 
+  if (record.sourcePackage !== undefined) {
+    validatePersistedSourcePackage(record.sourcePackage, "$.sourcePackage", issues);
+  }
+
   return issues;
 }
 
@@ -280,7 +347,15 @@ function validateCompatibilityFeatureEntry(
 
   expectString(record.featureEntryId, `${path}.featureEntryId`, issues);
   expectString(record.featureKey, `${path}.featureKey`, issues);
-  expectString(record.featureClass, `${path}.featureClass`, issues);
+  if (
+    typeof record.featureClass !== "string" ||
+    !COMPATIBILITY_FEATURE_CLASSES.has(record.featureClass as CompatibilityFeatureClass)
+  ) {
+    issues.push({
+      path: `${path}.featureClass`,
+      message: "featureClass must be supported-roundtrip, preserve-only, or unsupported-fatal.",
+    });
+  }
   expectString(record.message, `${path}.message`, issues);
 }
 
@@ -295,10 +370,31 @@ function validateEditorWarning(
   }
 
   expectString(record.warningId, `${path}.warningId`, issues);
-  expectString(record.code, `${path}.code`, issues);
-  expectString(record.severity, `${path}.severity`, issues);
+  if (typeof record.code !== "string" || !EDITOR_WARNING_CODES.has(record.code as EditorWarningCode)) {
+    issues.push({
+      path: `${path}.code`,
+      message: `code must be one of ${JSON.stringify([...EDITOR_WARNING_CODES])}.`,
+    });
+  }
+  if (
+    typeof record.severity !== "string" ||
+    !EDITOR_WARNING_SEVERITIES.has(record.severity as EditorWarning["severity"])
+  ) {
+    issues.push({
+      path: `${path}.severity`,
+      message: "severity must be info or warning.",
+    });
+  }
   expectString(record.message, `${path}.message`, issues);
-  expectString(record.source, `${path}.source`, issues);
+  if (
+    typeof record.source !== "string" ||
+    !EDITOR_WARNING_SOURCES.has(record.source as EditorWarning["source"])
+  ) {
+    issues.push({
+      path: `${path}.source`,
+      message: `source must be one of ${JSON.stringify([...EDITOR_WARNING_SOURCES])}.`,
+    });
+  }
 }
 
 function validateEditorError(
@@ -312,9 +408,22 @@ function validateEditorError(
   }
 
   expectString(record.errorId, `${path}.errorId`, issues);
-  expectString(record.code, `${path}.code`, issues);
+  if (typeof record.code !== "string" || !EDITOR_ERROR_CODES.has(record.code as EditorErrorCode)) {
+    issues.push({
+      path: `${path}.code`,
+      message: `code must be one of ${JSON.stringify([...EDITOR_ERROR_CODES])}.`,
+    });
+  }
   expectString(record.message, `${path}.message`, issues);
-  expectString(record.source, `${path}.source`, issues);
+  if (
+    typeof record.source !== "string" ||
+    !EDITOR_ERROR_SOURCES.has(record.source as EditorError["source"])
+  ) {
+    issues.push({
+      path: `${path}.source`,
+      message: `source must be one of ${JSON.stringify([...EDITOR_ERROR_SOURCES])}.`,
+    });
+  }
 
   if (typeof record.isFatal !== "boolean") {
     issues.push({
@@ -326,24 +435,25 @@ function validateEditorError(
 
 function validateExactObjectKeys(
   record: Record<string, unknown>,
-  expectedKeys: readonly string[],
+  requiredKeys: readonly string[],
+  optionalKeys: readonly string[],
   path: string,
   issues: ModelValidationIssue[],
 ): void {
   const actualKeys = new Set(Object.keys(record));
-  const expected = new Set(expectedKeys);
+  const allowedKeys = new Set([...requiredKeys, ...optionalKeys]);
 
-  for (const expectedKey of expectedKeys) {
-    if (!actualKeys.has(expectedKey)) {
+  for (const requiredKey of requiredKeys) {
+    if (!actualKeys.has(requiredKey)) {
       issues.push({
         path,
-        message: `Missing required key ${JSON.stringify(expectedKey)}.`,
+        message: `Missing required key ${JSON.stringify(requiredKey)}.`,
       });
     }
   }
 
   for (const actualKey of actualKeys) {
-    if (!expected.has(actualKey)) {
+    if (!allowedKeys.has(actualKey)) {
       issues.push({
         path: `${path}.${actualKey}`,
         message:
@@ -360,6 +470,65 @@ function prefixIssue(basePath: string) {
   });
 }
 
+function validateSnapshotVersion(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): PersistedEditorSnapshotVersion | null {
+  if (typeof value !== "string" || !PERSISTED_EDITOR_SNAPSHOT_VERSIONS.has(value as never)) {
+    issues.push({
+      path,
+      message: `Expected one of ${JSON.stringify([...PERSISTED_EDITOR_SNAPSHOT_VERSIONS])}.`,
+    });
+    return null;
+  }
+
+  return value as PersistedEditorSnapshotVersion;
+}
+
+function validatePersistedSourcePackage(
+  sourcePackage: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(sourcePackage, path, issues);
+  if (!record) {
+    return;
+  }
+
+  validateExactObjectKeys(
+    record,
+    ["format", "storage", "mimeType", "sha256Hex", "bytesBase64"],
+    ["sourceLabel"],
+    path,
+    issues,
+  );
+  expectExactString(record.format, "docx", `${path}.format`, issues);
+  expectExactString(record.storage, "embedded-base64", `${path}.storage`, issues);
+  expectExactString(
+    record.mimeType,
+    DOCX_SOURCE_PACKAGE_MIME_TYPE,
+    `${path}.mimeType`,
+    issues,
+  );
+  expectString(record.sha256Hex, `${path}.sha256Hex`, issues);
+  expectString(record.bytesBase64, `${path}.bytesBase64`, issues);
+
+  if (
+    typeof record.sha256Hex === "string" &&
+    !/^[0-9a-f]{64}$/u.test(record.sha256Hex)
+  ) {
+    issues.push({
+      path: `${path}.sha256Hex`,
+      message: "Expected a lowercase SHA-256 hex digest.",
+    });
+  }
+
+  if (record.sourceLabel !== undefined) {
+    expectString(record.sourceLabel, `${path}.sourceLabel`, issues);
+  }
+}
+
 export function createPersistedEditorSnapshot(params: {
   documentId: string;
   savedAt: ISO8601DateTime;
@@ -367,6 +536,7 @@ export function createPersistedEditorSnapshot(params: {
   canonicalDocument: CanonicalDocument;
   compatibility: CompatibilityReport;
   warningLog?: EditorWarning[];
+  sourcePackage?: PersistedSourcePackage;
 }): PersistedEditorSnapshot {
   assertCanonicalDocument(params.canonicalDocument);
   assertCompatibilityReport(params.compatibility);
@@ -383,6 +553,7 @@ export function createPersistedEditorSnapshot(params: {
     canonicalDocument: params.canonicalDocument,
     compatibility: params.compatibility,
     warningLog: params.warningLog ?? params.compatibility.warnings,
+    sourcePackage: params.sourcePackage,
   };
 }
 

package/src/preservation/package-preservation.ts

@@ -5,14 +5,7 @@ import type { OpcPackage } from "../io/opc/package-reader.ts";
 const CORE_NON_PRESERVED_PART_PATHS = new Set([
   "/docProps/app.xml",
   "/docProps/core.xml",
-  "/docProps/custom.xml",
-  "/word/fontTable.xml",
   "/word/numbering.xml",
-  "/word/settings.xml",
-  "/word/styles.xml",
-  "/word/stylesWithEffects.xml",
-  "/word/theme/theme1.xml",
-  "/word/webSettings.xml",
 ]);
 
 export function collectPreservedPackageParts(

package/src/runtime/document-runtime.ts

@@ -48,6 +48,7 @@ import {
   type RevisionStore,
 } from "../review/store/revision-store.ts";
 import { buildCompatibilityReport } from "../validation/compatibility-engine.ts";
+import { mergeCompatibilityReports } from "../validation/compatibility-report.ts";
 import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
 
 export type Unsubscribe = () => void;
@@ -724,12 +725,17 @@ function countOpaqueFragments(opaqueFragments: Record<string, unknown>): number
 }
 
 function createDerivedCompatibility(state: EditorState): InternalCompatibilityReport {
-  return buildCompatibilityReport({
+  const derived = buildCompatibilityReport({
     document: state.document,
     warnings: state.warnings,
     fatalError: state.fatalError,
     generatedAt: state.document.updatedAt,
   });
+
+  return mergeCompatibilityReports([state.compatibility as never, derived as never], {
+    generatedAt: state.document.updatedAt,
+    blockExport: state.compatibility.blockExport || derived.blockExport,
+  }) as InternalCompatibilityReport;
 }
 
 function toPublicCommentSidebarSnapshot(

package/src/runtime/read-only-diagnostics-runtime.ts

@@ -71,7 +71,7 @@ function createDiagnosticsSnapshot(input: {
   const diagnosticId = `diagnostic:${sanitizeDiagnosticsToken(input.documentId)}`;
 
   return {
-    snapshotVersion: "persisted-editor-snapshot/1",
+    snapshotVersion: "persisted-editor-snapshot/2",
     schemaVersion: "cds/1.0.0",
     documentId: input.documentId,
     docId,

package/src/runtime/surface-projection.ts

@@ -4,6 +4,7 @@ import type {
   SurfaceInlineSegment,
   SurfaceTableCellSnapshot,
   SurfaceTableRowSnapshot,
+  SurfaceTextMark,
 } from "../api/public-types";
 import type {
   CanonicalDocumentEnvelope,
@@ -208,10 +209,11 @@ function createTableBlock(
   const lockedFragmentIds: string[] = [];
   let innerCursor = cursor;
   const rows: SurfaceTableRowSnapshot[] = [];
+  const rowSpans = computeTableRowSpans(table);
 
-  for (const row of table.rows) {
+  for (const [rowIndex, row] of table.rows.entries()) {
     const cells: SurfaceTableCellSnapshot[] = [];
-    for (const cell of row.cells) {
+    for (const [cellIndex, cell] of row.cells.entries()) {
       const cellContent: SurfaceBlockSnapshot[] = [];
       for (const child of cell.children) {
         const result = createSurfaceBlock(child, document, innerCursor, counters);
@@ -223,7 +225,7 @@ function createTableBlock(
         gridSpan: cell.gridSpan ?? 1,
         verticalMerge: cell.verticalMerge ?? null,
         colspan: cell.gridSpan ?? 1,
-        rowspan: cell.verticalMerge === "restart" ? 1 : 1,
+        rowspan: rowSpans.get(`${rowIndex}:${cellIndex}`) ?? 1,
         content: cellContent,
       });
     }
@@ -245,6 +247,55 @@ function createTableBlock(
   };
 }
 
+function computeTableRowSpans(table: TableNode): Map<string, number> {
+  const positionedRows = table.rows.map((row) => {
+    let startColumn = 0;
+
+    return row.cells.map((cell, cellIndex) => {
+      const width = cell.gridSpan ?? 1;
+      const positionedCell = {
+        cell,
+        cellIndex,
+        startColumn,
+        endColumn: startColumn + width - 1,
+      };
+      startColumn += width;
+      return positionedCell;
+    });
+  });
+
+  const rowSpans = new Map<string, number>();
+
+  for (const [rowIndex, row] of positionedRows.entries()) {
+    for (const positionedCell of row) {
+      if (positionedCell.cell.verticalMerge !== "restart") {
+        rowSpans.set(`${rowIndex}:${positionedCell.cellIndex}`, 1);
+        continue;
+      }
+
+      let rowspan = 1;
+      for (let nextRowIndex = rowIndex + 1; nextRowIndex < positionedRows.length; nextRowIndex += 1) {
+        const continuedCell = positionedRows[nextRowIndex]?.find(
+          (candidate) =>
+            candidate.cell.verticalMerge === "continue" &&
+            candidate.startColumn === positionedCell.startColumn &&
+            candidate.endColumn === positionedCell.endColumn,
+        );
+
+        if (!continuedCell) {
+          break;
+        }
+
+        rowspan += 1;
+      }
+
+      rowSpans.set(`${rowIndex}:${positionedCell.cellIndex}`, rowspan);
+    }
+  }
+
+  return rowSpans;
+}
+
 function createSdtBlock(
   sdtIndex: number,
   block: SdtNode,
@@ -304,6 +355,17 @@ function createParagraphBlock(
     to: start,
     ...(paragraph.styleId ? { styleId: paragraph.styleId } : {}),
     ...(paragraph.numbering ? { numbering: paragraph.numbering } : {}),
+    ...(paragraph.alignment ? { alignment: paragraph.alignment } : {}),
+    ...(paragraph.spacing ? { spacing: paragraph.spacing } : {}),
+    ...(paragraph.indentation ? { indentation: paragraph.indentation } : {}),
+    ...(paragraph.borders ? { borders: paragraph.borders } : {}),
+    ...(paragraph.shading ? { shading: paragraph.shading } : {}),
+    ...(paragraph.tabStops && paragraph.tabStops.length > 0 ? { tabStops: paragraph.tabStops } : {}),
+    ...(paragraph.keepNext ? { keepNext: true } : {}),
+    ...(paragraph.keepLines ? { keepLines: true } : {}),
+    ...(paragraph.pageBreakBefore ? { pageBreakBefore: true } : {}),
+    ...(paragraph.outlineLevel !== undefined ? { outlineLevel: paragraph.outlineLevel } : {}),
+    ...(paragraph.bidi ? { bidi: true } : {}),
     segments: [],
   };
   const lockedFragmentIds: string[] = [];
@@ -339,7 +401,13 @@ function appendInlineSegments(
         from: start,
         to: start + Array.from(node.text).length,
         text: node.text,
-        ...(node.marks ? { marks: cloneMarks(node.marks) } : {}),
+        ...(node.marks ? (() => {
+          const result = cloneMarks(node.marks);
+          return {
+            ...(result.marks.length > 0 ? { marks: result.marks } : {}),
+            ...(result.markAttrs ? { markAttrs: result.markAttrs } : {}),
+          };
+        })() : {}),
         ...(hyperlinkHref ? { hyperlinkHref } : {}),
       });
       return { nextCursor: start + Array.from(node.text).length, lockedFragmentIds: [] };
@@ -415,12 +483,66 @@ function appendInlineSegments(
       return appendComplexPreviewSegment(paragraph, node, start, "WordArt", createWordArtDetail(node));
     case "vml_shape":
       return appendComplexPreviewSegment(paragraph, node, start, "VML shape", createVmlDetail(node));
-    case "column_break":
     case "symbol":
-    case "field":
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "text",
+        from: start,
+        to: start + 1,
+        text: node.char ? String.fromCodePoint(parseInt(node.char, 16)) : "\uFFFD",
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+    case "column_break":
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "opaque_inline",
+        from: start,
+        to: start + 1,
+        fragmentId: "",
+        warningId: "",
+        label: "Column break",
+        detail: "Column break marker preserved for export.",
+        state: "locked-preserve-only",
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+    case "footnote_ref":
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "text",
+        from: start,
+        to: start + 1,
+        text: node.noteId ?? "*",
+        marks: ["superscript" as SurfaceTextMark],
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+    case "field": {
+      if (node.children && node.children.length > 0) {
+        let cursor = start;
+        const lockedIds: string[] = [];
+        for (const child of node.children) {
+          const result = appendInlineSegments(paragraph, child, document, cursor);
+          cursor = result.nextCursor;
+          lockedIds.push(...result.lockedFragmentIds);
+        }
+        return { nextCursor: cursor, lockedFragmentIds: lockedIds };
+      }
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "opaque_inline",
+        from: start,
+        to: start + 1,
+        fragmentId: "",
+        warningId: "",
+        label: "Field",
+        detail: "Field code preserved for export.",
+        state: "locked-preserve-only",
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+    }
     case "bookmark_start":
     case "bookmark_end":
-    case "footnote_ref":
+      // Zero-width markers — no visual, no cursor advancement
+      return { nextCursor: start, lockedFragmentIds: [] };
     default:
       return { nextCursor: start + 1, lockedFragmentIds: [] };
   }
@@ -527,19 +649,79 @@ function createPlainText(
   return text.join("");
 }
 
-function cloneMarks(marks: TextMark[]): Array<"bold" | "italic" | "underline" | "strikethrough"> {
-  const supported: Array<"bold" | "italic" | "underline" | "strikethrough"> = [];
+function cloneMarks(marks: TextMark[]): {
+  marks: SurfaceTextMark[];
+  markAttrs?: {
+    backgroundColor?: string;
+    charSpacing?: number;
+    kerning?: number;
+    textFill?: string;
+    fontFamily?: string;
+    fontSize?: number;
+    textColor?: string;
+  };
+} {
+  const supported: SurfaceTextMark[] = [];
+  const attrs: {
+    backgroundColor?: string;
+    charSpacing?: number;
+    kerning?: number;
+    textFill?: string;
+    fontFamily?: string;
+    fontSize?: number;
+    textColor?: string;
+  } = {};
   for (const mark of marks) {
-    if (
-      mark.type === "bold" ||
-      mark.type === "italic" ||
-      mark.type === "underline" ||
-      mark.type === "strikethrough"
-    ) {
-      supported.push(mark.type);
+    switch (mark.type) {
+      case "bold":
+      case "italic":
+      case "underline":
+      case "strikethrough":
+      case "doubleStrikethrough":
+      case "vanish":
+      case "emboss":
+      case "imprint":
+      case "shadow":
+        supported.push(mark.type);
+        break;
+      case "position":
+        if (mark.val > 0) supported.push("superscript");
+        else if (mark.val < 0) supported.push("subscript");
+        break;
+      case "backgroundColor":
+        attrs.backgroundColor = mark.color;
+        break;
+      case "charSpacing":
+        attrs.charSpacing = mark.val;
+        break;
+      case "kerning":
+        attrs.kerning = mark.val;
+        break;
+      case "textFill":
+        attrs.textFill = mark.xml;
+        break;
+      case "fontFamily":
+        attrs.fontFamily = mark.val;
+        break;
+      case "fontSize":
+        attrs.fontSize = mark.val;
+        break;
+      case "textColor":
+        attrs.textColor = mark.color;
+        break;
+      case "smallCaps":
+        supported.push("smallCaps");
+        break;
+      case "allCaps":
+        supported.push("allCaps");
+        break;
+      case "lang":
+        // no visual effect — skip
+        break;
     }
   }
-  return supported;
+  const hasAttrs = Object.keys(attrs).length > 0;
+  return hasAttrs ? { marks: supported, markAttrs: attrs } : { marks: supported };
 }
 
 function normalizeDocumentRoot(content: unknown): DocumentRootNode {