@beyondwork/docx-react-component 1.0.11 → 1.0.13

package/src/core/commands/text-commands.ts

@@ -1,8 +1,23 @@
-import type { CanonicalDocumentEnvelope, SelectionSnapshot } from "../state/editor-state.ts";
+import type { InsertTableOptions } from "../../api/public-types";
+import type { ParagraphNode } from "../../model/canonical-document.ts";
+import {
+  createSelectionSnapshot,
+  type CanonicalDocumentEnvelope,
+  type SelectionSnapshot,
+} from "../state/editor-state.ts";
 import {
   applyTextTransaction,
   type TextTransactionResult,
 } from "../state/text-transaction.ts";
+import {
+  createInsertedTableBlock,
+  createNoopStructuralMutation,
+  findTableCellParagraphSelection,
+  replaceParagraphScope,
+  resolveInsertedTableStyleId,
+  resolveParagraphScope,
+  type StructuralMutationResult,
+} from "./structural-helpers.ts";
 
 export interface TextCommandContext {
   timestamp: string;
@@ -117,3 +132,153 @@ export function splitParagraph(
     context,
   );
 }
+
+export function insertPageBreak(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  context: TextCommandContext,
+): StructuralMutationResult {
+  const scope = resolveParagraphScope(document, selection);
+  if (!scope) {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const localDocument: CanonicalDocumentEnvelope = {
+    ...document,
+    content: {
+      type: "doc",
+      children: [scope.paragraph],
+    },
+  };
+  const localSelection = createSelectionSnapshot(
+    selection.anchor - scope.paragraphStart,
+    selection.head - scope.paragraphStart,
+  );
+  const splitResult = splitParagraph(localDocument, localSelection, context);
+  const splitRoot = splitResult.document.content;
+  if (!splitRoot || splitRoot.type !== "doc") {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const replacementParagraphs = splitRoot.children
+    .filter((block): block is ParagraphNode => block.type === "paragraph")
+    .map((block, index) =>
+      index === 1
+        ? {
+            ...block,
+            pageBreakBefore: true,
+          }
+        : block,
+    );
+  if (replacementParagraphs.length < 2) {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const nextDocument = replaceParagraphScope(document, scope, replacementParagraphs);
+  return {
+    changed: true,
+    document: {
+      ...nextDocument,
+      updatedAt: context.timestamp,
+    },
+    selection: createSelectionSnapshot(
+      splitResult.selection.anchor + scope.paragraphStart,
+      splitResult.selection.head + scope.paragraphStart,
+    ),
+    mapping: {
+      ...splitResult.mapping,
+      steps: splitResult.mapping.steps.map((step) => ({
+        ...step,
+        from: step.from + scope.paragraphStart,
+        to: step.to + scope.paragraphStart,
+      })),
+    },
+  };
+}
+
+export function insertTable(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  options: InsertTableOptions,
+  context: TextCommandContext,
+): StructuralMutationResult {
+  const scope = resolveParagraphScope(document, selection);
+  if (!scope || scope.kind !== "top-level") {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const safeRows = Math.max(1, Math.floor(options.rows));
+  const safeColumns = Math.max(1, Math.floor(options.columns));
+  if (!Number.isFinite(safeRows) || !Number.isFinite(safeColumns)) {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const localDocument: CanonicalDocumentEnvelope = {
+    ...document,
+    content: {
+      type: "doc",
+      children: [scope.paragraph],
+    },
+  };
+  const localSelection = createSelectionSnapshot(
+    selection.anchor - scope.paragraphStart,
+    selection.head - scope.paragraphStart,
+  );
+  const splitResult = splitParagraph(localDocument, localSelection, context);
+  const splitRoot = splitResult.document.content;
+  if (!splitRoot || splitRoot.type !== "doc") {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const replacementParagraphs = splitRoot.children.filter(
+    (block): block is ParagraphNode => block.type === "paragraph",
+  );
+  if (replacementParagraphs.length < 2) {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const nextRoot = document.content;
+  if (!nextRoot || nextRoot.type !== "doc") {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const insertedTable = createInsertedTableBlock(
+    safeRows,
+    safeColumns,
+    resolveInsertedTableStyleId(document),
+  );
+  const nextDocument: CanonicalDocumentEnvelope = {
+    ...document,
+    updatedAt: context.timestamp,
+    content: {
+      ...nextRoot,
+      children: [
+        ...nextRoot.children.slice(0, scope.blockIndex),
+        replacementParagraphs[0],
+        insertedTable,
+        replacementParagraphs[1],
+        ...nextRoot.children.slice(scope.blockIndex + 1),
+      ],
+    },
+  };
+
+  return {
+    changed: true,
+    document: nextDocument,
+    selection:
+      findTableCellParagraphSelection(
+        nextDocument,
+        scope.blockIndex + 1,
+        0,
+        0,
+      ) ?? selection,
+    mapping: {
+      ...splitResult.mapping,
+      steps: splitResult.mapping.steps.map((step) => ({
+        ...step,
+        from: step.from + scope.paragraphStart,
+        to: step.to + scope.paragraphStart,
+      })),
+    },
+  };
+}

package/src/core/state/editor-state.ts

@@ -1,12 +1,15 @@
 import {
   DEFAULT_BOUNDARY_ASSOC,
   createDetachedAnchor,
+  createNodeAnchor,
   createRangeAnchor,
   type EditorAnchorProjection,
 } from "../selection/mapping.ts";
+import { isUuid } from "../../model/cds-1.0.0.ts";
 import {
   assertPersistedEditorSnapshot as assertModelPersistedEditorSnapshot,
   createPersistedEditorSnapshot as createModelPersistedEditorSnapshot,
+  validatePersistedEditorSnapshot as validateModelPersistedEditorSnapshot,
   type PersistedEditorSnapshot as ModelPersistedEditorSnapshot,
 } from "../../model/snapshot.ts";
 import {
@@ -175,6 +178,7 @@ export interface EditorState {
   documentId: string;
   sessionId: string;
   sourceLabel?: string;
+  sourcePackage?: ModelPersistedEditorSnapshot["sourcePackage"];
   revision: number;
   revisionToken: string;
   isDirty: boolean;
@@ -268,29 +272,32 @@ export function createEmptyCompatibilityReport(generatedAt: string): Compatibili
 
 export function createEditorState(options: CreateEditorStateOptions): EditorState {
   const timestamp = new Date(0).toISOString();
-  if (options.persistedSnapshot) {
-    assertModelPersistedEditorSnapshot(options.persistedSnapshot as unknown);
-  }
+  const normalizedSnapshot = options.persistedSnapshot
+    ? normalizePersistedSnapshotForRuntime(options.persistedSnapshot, options.documentId, timestamp)
+    : undefined;
   if (options.canonicalDocument) {
     assertCanonicalDocument(options.canonicalDocument as unknown);
   }
 
-  const normalizedDocument = options.persistedSnapshot
-    ? structuredClone(options.persistedSnapshot.canonicalDocument)
+  const normalizedDocument = normalizedSnapshot
+    ? structuredClone(normalizedSnapshot.canonicalDocument)
     : options.canonicalDocument
       ? structuredClone(options.canonicalDocument)
       : createDefaultCanonicalDocument(options.documentId, timestamp);
-  const warnings = options.persistedSnapshot?.warningLog ?? options.warnings ?? [];
+  const warnings = normalizedSnapshot
+    ? normalizeWarningLog(normalizedSnapshot.warningLog)
+    : options.warnings ?? [];
   const compatibility =
-    options.persistedSnapshot?.compatibility ??
-    options.compatibility ??
-    createEmptyCompatibilityReport(normalizedDocument.updatedAt);
+    normalizedSnapshot
+      ? normalizeCompatibilityReport(normalizedSnapshot.compatibility)
+      : options.compatibility ?? createEmptyCompatibilityReport(normalizedDocument.updatedAt);
 
   return {
     phase: options.fatalError ? "error" : "ready",
     documentId: options.documentId,
     sessionId: options.sessionId,
     sourceLabel: options.sourceLabel,
+    sourcePackage: normalizedSnapshot?.sourcePackage,
     revision: 0,
     revisionToken: `${options.sessionId}:0`,
     isDirty: false,
@@ -306,6 +313,265 @@ export function createEditorState(options: CreateEditorStateOptions): EditorStat
   };
 }
 
+function normalizePersistedSnapshotForRuntime(
+  snapshot: PersistedEditorSnapshot,
+  documentId: string,
+  timestamp: string,
+): PersistedEditorSnapshot {
+  const issues = validateModelPersistedEditorSnapshot(snapshot as unknown);
+  if (issues.length === 0) {
+    return snapshot;
+  }
+
+  if (!isRecord(snapshot) || !isRecord(snapshot.canonicalDocument)) {
+    assertModelPersistedEditorSnapshot(snapshot as unknown);
+  }
+
+  const normalizedDocument = normalizeCanonicalDocumentEnvelope(
+    snapshot.canonicalDocument,
+    documentId,
+    timestamp,
+  );
+  try {
+    assertCanonicalDocument(normalizedDocument as unknown);
+  } catch {
+    assertModelPersistedEditorSnapshot(snapshot as unknown);
+  }
+  const repairWarning = createSnapshotRepairWarning(issues.length);
+  const compatibility = coerceCompatibilityReport(
+    snapshot.compatibility,
+    normalizedDocument.updatedAt,
+    repairWarning,
+  );
+
+  return {
+    snapshotVersion:
+      snapshot.snapshotVersion === "persisted-editor-snapshot/1" ||
+      snapshot.snapshotVersion === "persisted-editor-snapshot/2"
+        ? snapshot.snapshotVersion
+        : "persisted-editor-snapshot/2",
+    schemaVersion: "cds/1.0.0",
+    documentId:
+      typeof snapshot.documentId === "string" && snapshot.documentId.length > 0
+        ? snapshot.documentId
+        : documentId,
+    docId: normalizedDocument.docId,
+    createdAt: normalizedDocument.createdAt,
+    updatedAt: normalizedDocument.updatedAt,
+    savedAt:
+      typeof snapshot.savedAt === "string" && snapshot.savedAt.length > 0
+        ? snapshot.savedAt
+        : normalizedDocument.updatedAt,
+    editorBuild:
+      typeof snapshot.editorBuild === "string" && snapshot.editorBuild.length > 0
+        ? snapshot.editorBuild
+        : "dev",
+    canonicalDocument: normalizedDocument,
+    compatibility,
+    warningLog: dedupeWarnings([
+      ...coerceWarnings(snapshot.warningLog),
+      repairWarning,
+    ]),
+    sourcePackage: snapshot.sourcePackage,
+  };
+}
+
+function normalizeCanonicalDocumentEnvelope(
+  value: unknown,
+  documentId: string,
+  timestamp: string,
+): CanonicalDocumentEnvelope {
+  const base = createDefaultCanonicalDocument(documentId, timestamp);
+  const record = isRecord(value) ? value : {};
+  const metadata = isRecord(record.metadata) ? record.metadata : {};
+
+  return {
+    ...base,
+    ...record,
+    schemaVersion: "cds/1.0.0",
+    docId: isUuid(record.docId) ? record.docId : createCanonicalDocumentId(documentId),
+    createdAt:
+      typeof record.createdAt === "string" && record.createdAt.length > 0
+        ? record.createdAt
+        : base.createdAt,
+    updatedAt:
+      typeof record.updatedAt === "string" && record.updatedAt.length > 0
+        ? record.updatedAt
+        : base.updatedAt,
+    metadata: {
+      ...base.metadata,
+      ...metadata,
+      customProperties: isRecord(metadata.customProperties)
+        ? (Object.fromEntries(
+            Object.entries(metadata.customProperties).filter(([, entry]) => typeof entry === "string"),
+          ) as Record<string, string>)
+        : {},
+    },
+    styles:
+      record.styles === undefined
+        ? base.styles
+        : (record.styles as CanonicalDocumentEnvelope["styles"]),
+    numbering:
+      record.numbering === undefined
+        ? base.numbering
+        : (record.numbering as CanonicalDocumentEnvelope["numbering"]),
+    media:
+      record.media === undefined
+        ? base.media
+        : (record.media as CanonicalDocumentEnvelope["media"]),
+    content: isRecord(record.content)
+      ? (record.content as unknown as CanonicalDocumentEnvelope["content"])
+      : base.content,
+    review:
+      record.review === undefined
+        ? base.review
+        : (record.review as CanonicalDocumentEnvelope["review"]),
+    preservation:
+      record.preservation === undefined
+        ? base.preservation
+        : (record.preservation as CanonicalDocumentEnvelope["preservation"]),
+    diagnostics:
+      record.diagnostics === undefined
+        ? base.diagnostics
+        : (record.diagnostics as CanonicalDocumentEnvelope["diagnostics"]),
+    ...(isRecord(record.subParts)
+      ? { subParts: record.subParts as unknown as CanonicalDocumentEnvelope["subParts"] }
+      : {}),
+  };
+}
+
+function coerceCompatibilityReport(
+  value: unknown,
+  generatedAt: string,
+  repairWarning: EditorWarning,
+): CompatibilityReport {
+  const record = isRecord(value) ? value : {};
+  const warnings = dedupeWarnings([
+    ...coerceWarnings(record.warnings),
+    repairWarning,
+  ]);
+
+  return {
+    reportVersion: "compatibility-report/1",
+    generatedAt:
+      typeof record.generatedAt === "string" && record.generatedAt.length > 0
+        ? record.generatedAt
+        : generatedAt,
+    blockExport: typeof record.blockExport === "boolean" ? record.blockExport : false,
+    featureEntries: Array.isArray(record.featureEntries)
+      ? record.featureEntries.flatMap((entry) => {
+          if (!isRecord(entry)) {
+            return [];
+          }
+          if (
+            typeof entry.featureEntryId !== "string" ||
+            typeof entry.featureKey !== "string" ||
+            typeof entry.featureClass !== "string" ||
+            typeof entry.message !== "string"
+          ) {
+            return [];
+          }
+          return [{
+            featureEntryId: entry.featureEntryId,
+            featureKey: entry.featureKey,
+            featureClass: entry.featureClass as CompatibilityFeatureEntry["featureClass"],
+            message: entry.message,
+            ...(entry.affectedAnchor && isRecord(entry.affectedAnchor)
+              ? { affectedAnchor: entry.affectedAnchor as unknown as EditorAnchorProjection }
+              : {}),
+            ...(isRecord(entry.details) ? { details: entry.details } : {}),
+          }];
+        })
+      : [],
+    warnings,
+    errors: Array.isArray(record.errors)
+      ? record.errors.flatMap((entry) => {
+          if (!isRecord(entry)) {
+            return [];
+          }
+          if (
+            typeof entry.errorId !== "string" ||
+            typeof entry.code !== "string" ||
+            typeof entry.message !== "string" ||
+            typeof entry.source !== "string" ||
+            typeof entry.isFatal !== "boolean"
+          ) {
+            return [];
+          }
+          return [{
+            errorId: entry.errorId,
+            code: entry.code as EditorError["code"],
+            message: entry.message,
+            source: entry.source as EditorError["source"],
+            isFatal: entry.isFatal,
+            ...(isRecord(entry.details) ? { details: entry.details } : {}),
+          }];
+        })
+      : [],
+  };
+}
+
+function coerceWarnings(value: unknown): EditorWarning[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value.flatMap((warning) => {
+    if (!isRecord(warning)) {
+      return [];
+    }
+    if (
+      typeof warning.warningId !== "string" ||
+      typeof warning.code !== "string" ||
+      typeof warning.severity !== "string" ||
+      typeof warning.message !== "string" ||
+      typeof warning.source !== "string"
+    ) {
+      return [];
+    }
+
+    return [{
+      warningId: warning.warningId,
+      code: warning.code as EditorWarning["code"],
+      severity: warning.severity as EditorWarning["severity"],
+      message: warning.message,
+      source: warning.source as EditorWarning["source"],
+      ...(warning.affectedAnchor && isRecord(warning.affectedAnchor)
+        ? { affectedAnchor: warning.affectedAnchor as unknown as EditorAnchorProjection }
+        : {}),
+      ...(typeof warning.featureEntryId === "string"
+        ? { featureEntryId: warning.featureEntryId }
+        : {}),
+      ...(isRecord(warning.details) ? { details: warning.details } : {}),
+    }];
+  });
+}
+
+function createSnapshotRepairWarning(issueCount: number): EditorWarning {
+  return {
+    warningId: `warning:snapshot-repair:${issueCount}`,
+    code: "import_normalized",
+    severity: "warning",
+    message: `Loaded a persisted snapshot after repairing ${issueCount} validation issue${issueCount === 1 ? "" : "s"}.`,
+    source: "validation",
+  };
+}
+
+function dedupeWarnings(warnings: EditorWarning[]): EditorWarning[] {
+  const seen = new Set<string>();
+  const result: EditorWarning[] = [];
+
+  for (const warning of warnings) {
+    if (!warning.warningId || seen.has(warning.warningId)) {
+      continue;
+    }
+    seen.add(warning.warningId);
+    result.push(warning);
+  }
+
+  return result;
+}
+
 export function deriveDocumentStats(state: Pick<EditorState, "document">): DocumentStats {
   const serializedContent = extractText(state.document.content);
 
@@ -381,6 +647,7 @@ export function createPersistedEditorSnapshot(
     canonicalDocument: state.document,
     compatibility: (options.compatibility ?? state.compatibility) as never,
     warningLog: state.warnings as never,
+    sourcePackage: state.sourcePackage,
   });
   return snapshot as PersistedEditorSnapshot;
 }
@@ -397,6 +664,48 @@ function estimateParagraphCount(content: unknown): number {
   return extractText(content).length > 0 ? 1 : 0;
 }
 
+function normalizeWarningLog(warnings: EditorWarning[]): EditorWarning[] {
+  return warnings.map((warning) => ({
+    ...warning,
+    affectedAnchor: warning.affectedAnchor
+      ? normalizeAnchorProjection(warning.affectedAnchor)
+      : undefined,
+  }));
+}
+
+function normalizeCompatibilityReport(report: CompatibilityReport): CompatibilityReport {
+  return {
+    ...report,
+    featureEntries: report.featureEntries.map((entry) => ({
+      ...entry,
+      affectedAnchor: entry.affectedAnchor
+        ? normalizeAnchorProjection(entry.affectedAnchor)
+        : undefined,
+    })),
+    warnings: normalizeWarningLog(report.warnings),
+  };
+}
+
+function normalizeAnchorProjection(anchor: EditorAnchorProjection): EditorAnchorProjection {
+  switch (anchor.kind) {
+    case "range": {
+      const rangeAnchor = anchor as EditorAnchorProjection & {
+        range?: { from: number; to: number };
+        from?: number;
+        to?: number;
+        assoc: { start: -1 | 1; end: -1 | 1 };
+      };
+      return rangeAnchor.range
+        ? createRangeAnchor(rangeAnchor.range.from, rangeAnchor.range.to, rangeAnchor.assoc)
+        : createRangeAnchor(rangeAnchor.from ?? 0, rangeAnchor.to ?? 0, rangeAnchor.assoc);
+    }
+    case "node":
+      return createNodeAnchor(anchor.at, anchor.assoc);
+    case "detached":
+      return createDetachedAnchor(anchor.lastKnownRange, anchor.reason);
+  }
+}
+
 function extractText(value: unknown): string {
   if (typeof value === "string") {
     return value;