@beyondwork/docx-react-component 1.0.29 → 1.0.30

package/src/runtime/page-layout-estimation.ts

@@ -0,0 +1,305 @@
+import type {
+  PageLayoutSnapshot,
+  SurfaceBlockSnapshot,
+  SurfaceInlineSegment,
+} from "../api/public-types";
+
+const DEFAULT_FONT_SIZE_POINTS = 12;
+const DEFAULT_LINE_HEIGHT_TWIPS = 280;
+const MIN_BLOCK_HEIGHT_TWIPS = 240;
+const TABLE_ROW_PADDING_TWIPS = 120;
+
+export const DEFAULT_PAGE_ESTIMATE_PX_PER_TWIP = 1 / 15;
+
+export function estimateBlockHeight(
+  block: SurfaceBlockSnapshot | undefined,
+  columnWidth: number,
+): number {
+  if (!block) {
+    return 0;
+  }
+
+  switch (block.kind) {
+    case "paragraph":
+      return estimateParagraphHeight(block, columnWidth);
+    case "table":
+      return estimateTableHeight(block, columnWidth);
+    case "sdt_block":
+      return Math.max(
+        MIN_BLOCK_HEIGHT_TWIPS,
+        block.children.reduce((total, child) => total + estimateBlockHeight(child, columnWidth), 0),
+      );
+    case "opaque_block":
+      return block.label === "Section break" ? 0 : MIN_BLOCK_HEIGHT_TWIPS;
+  }
+}
+
+export function estimateParagraphHeight(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+  columnWidth: number,
+): number {
+  const spacing = resolveParagraphSpacing(block);
+  const lineHeight = estimateParagraphLineHeight(block);
+  const lineCount = estimateParagraphLineCount(block, columnWidth);
+  const spacingBefore = spacing?.before ?? 0;
+  const spacingAfter = spacing?.after ?? 0;
+  return Math.max(
+    MIN_BLOCK_HEIGHT_TWIPS,
+    lineHeight * lineCount + spacingBefore + spacingAfter,
+  );
+}
+
+export function estimateParagraphLineHeight(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+): number {
+  const explicitLine = resolveParagraphSpacing(block)?.line;
+  if (typeof explicitLine === "number" && explicitLine > 0) {
+    return explicitLine;
+  }
+
+  const fontSizeHalfPoints = block.segments.find(
+    (segment): segment is Extract<SurfaceInlineSegment, { kind: "text" }> =>
+      segment.kind === "text" && typeof segment.markAttrs?.fontSize === "number",
+  )?.markAttrs?.fontSize;
+  const fontSizePoints =
+    typeof fontSizeHalfPoints === "number"
+      ? fontSizeHalfPoints / 2
+      : DEFAULT_FONT_SIZE_POINTS;
+  return Math.max(
+    DEFAULT_LINE_HEIGHT_TWIPS,
+    Math.round(fontSizePoints * 20 * 1.35),
+  );
+}
+
+export function estimateParagraphLineCount(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+  columnWidth: number,
+): number {
+  const averageCharWidth = estimateAverageCharWidth(block);
+  const lineMetrics = resolveParagraphLineMetrics(block, columnWidth, averageCharWidth);
+  let lineCount = 1;
+  let currentLineChars = lineMetrics.initialLineChars;
+  let currentLineCapacity = lineMetrics.firstLineCapacity;
+
+  for (const segment of block.segments) {
+    switch (segment.kind) {
+      case "text":
+        currentLineChars += Array.from(segment.text).length;
+        while (currentLineChars > currentLineCapacity) {
+          lineCount += 1;
+          currentLineChars -= currentLineCapacity;
+          currentLineCapacity = lineMetrics.subsequentLineCapacity;
+        }
+        break;
+      case "tab":
+        currentLineChars += 4;
+        while (currentLineChars > currentLineCapacity) {
+          lineCount += 1;
+          currentLineChars -= currentLineCapacity;
+          currentLineCapacity = lineMetrics.subsequentLineCapacity;
+        }
+        break;
+      case "hard_break":
+        lineCount += 1;
+        currentLineChars = 0;
+        currentLineCapacity = lineMetrics.subsequentLineCapacity;
+        break;
+      case "image":
+        lineCount += Math.max(1, Math.round(segment.display === "floating" ? 2 : 1));
+        currentLineChars = 0;
+        currentLineCapacity = lineMetrics.subsequentLineCapacity;
+        break;
+      case "note_ref":
+        currentLineChars += 1;
+        while (currentLineChars > currentLineCapacity) {
+          lineCount += 1;
+          currentLineChars -= currentLineCapacity;
+          currentLineCapacity = lineMetrics.subsequentLineCapacity;
+        }
+        break;
+      case "opaque_inline":
+        if (segment.presentation !== "quiet-marker") {
+          currentLineChars += segment.label.length > 0 ? 1 : 0;
+          while (currentLineChars > currentLineCapacity) {
+            lineCount += 1;
+            currentLineChars -= currentLineCapacity;
+            currentLineCapacity = lineMetrics.subsequentLineCapacity;
+          }
+        }
+        break;
+    }
+  }
+
+  return Math.max(1, lineCount);
+}
+
+export function getUsablePageHeight(layout: PageLayoutSnapshot): number {
+  return Math.max(
+    1440,
+    layout.pageHeight - layout.marginTop - layout.marginBottom,
+  );
+}
+
+export interface PageColumnMetric {
+  width: number;
+  space: number;
+}
+
+export function getUsableColumnMetrics(
+  layout: PageLayoutSnapshot,
+): PageColumnMetric[] {
+  const usableWidth = Math.max(
+    1440,
+    layout.pageWidth - layout.marginLeft - layout.marginRight - layout.gutter,
+  );
+  const columnCount = Math.max(1, layout.columns);
+  if (
+    !layout.equalWidthColumns &&
+    layout.columnDefinitions.length > 0
+  ) {
+    return layout.columnDefinitions.map((column, index) => ({
+      width: Math.max(720, column.width),
+      space:
+        index < layout.columnDefinitions.length - 1
+          ? Math.max(0, column.space ?? 0)
+          : 0,
+    }));
+  }
+
+  const width = columnCount <= 1
+    ? usableWidth
+    : Math.max(720, Math.floor(usableWidth / columnCount));
+  return Array.from({ length: columnCount }, () => ({
+    width,
+    space: 0,
+  }));
+}
+
+export function getUsableColumnWidth(layout: PageLayoutSnapshot): number {
+  return getUsableColumnMetrics(layout)[0]?.width ?? 1440;
+}
+
+function estimateTableHeight(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  columnWidth: number,
+): number {
+  let totalHeight = 0;
+  for (const row of block.rows) {
+    const explicitHeight = row.height ?? 0;
+    if (explicitHeight > 0) {
+      totalHeight += explicitHeight;
+      continue;
+    }
+
+    let rowHeight = MIN_BLOCK_HEIGHT_TWIPS;
+    for (const cell of row.cells) {
+      const cellHeight = cell.content.reduce(
+        (total, child) => total + estimateBlockHeight(child, columnWidth),
+        0,
+      );
+      rowHeight = Math.max(rowHeight, cellHeight + TABLE_ROW_PADDING_TWIPS);
+    }
+    totalHeight += rowHeight;
+  }
+  return Math.max(MIN_BLOCK_HEIGHT_TWIPS, totalHeight);
+}
+
+function estimateAverageCharWidth(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+): number {
+  const fontSizeHalfPoints = block.segments.find(
+    (segment): segment is Extract<SurfaceInlineSegment, { kind: "text" }> =>
+      segment.kind === "text" && typeof segment.markAttrs?.fontSize === "number",
+  )?.markAttrs?.fontSize;
+  const fontSizePoints =
+    typeof fontSizeHalfPoints === "number"
+      ? fontSizeHalfPoints / 2
+      : DEFAULT_FONT_SIZE_POINTS;
+  return Math.max(96, Math.round(fontSizePoints * 12));
+}
+
+function resolveParagraphSpacing(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+): Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>["spacing"] | undefined {
+  return block.resolvedNumbering?.geometry.spacing ?? block.spacing;
+}
+
+function resolveParagraphLineMetrics(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+  columnWidth: number,
+  averageCharWidth: number,
+): {
+  initialLineChars: number;
+  firstLineCapacity: number;
+  subsequentLineCapacity: number;
+} {
+  const textColumn =
+    block.resolvedNumbering?.geometry.textColumn ??
+    deriveParagraphTextColumn(block.indentation);
+  const hasResolvedTextColumn = Boolean(textColumn);
+  const baseLineWidth = resolveTextColumnWidth(columnWidth, textColumn);
+  const firstLineWidth =
+    textColumn?.firstLine && textColumn.firstLine > 0
+      ? Math.max(averageCharWidth, baseLineWidth - textColumn.firstLine)
+      : baseLineWidth;
+
+  return {
+    initialLineChars: hasResolvedTextColumn ? 0 : estimatedPrefixLength(block),
+    firstLineCapacity: resolveCharsPerLine(firstLineWidth, averageCharWidth),
+    subsequentLineCapacity: resolveCharsPerLine(baseLineWidth, averageCharWidth),
+  };
+}
+
+function deriveParagraphTextColumn(
+  indentation: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>["indentation"],
+): { start: number; right?: number; firstLine?: number; hanging?: number } | undefined {
+  if (!indentation) {
+    return undefined;
+  }
+  const hanging =
+    indentation.hanging ??
+    (typeof indentation.firstLine === "number" && indentation.firstLine < 0
+      ? Math.abs(indentation.firstLine)
+      : undefined);
+  const hasGeometry =
+    indentation.left !== undefined ||
+    indentation.right !== undefined ||
+    indentation.firstLine !== undefined ||
+    hanging !== undefined;
+  if (!hasGeometry) {
+    return undefined;
+  }
+  return {
+    start: indentation.left ?? 0,
+    ...(indentation.right !== undefined ? { right: indentation.right } : {}),
+    ...(indentation.firstLine !== undefined ? { firstLine: indentation.firstLine } : {}),
+    ...(hanging !== undefined ? { hanging } : {}),
+  };
+}
+
+function resolveTextColumnWidth(
+  columnWidth: number,
+  textColumn: { start: number; right?: number; firstLine?: number; hanging?: number } | undefined,
+): number {
+  if (!textColumn) {
+    return columnWidth;
+  }
+  return Math.max(1, columnWidth - textColumn.start - (textColumn.right ?? 0));
+}
+
+function resolveCharsPerLine(width: number, averageCharWidth: number): number {
+  return Math.max(1, Math.floor(width / averageCharWidth));
+}
+
+function estimatedPrefixLength(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+): number {
+  const prefix = block.numberingPrefix ?? "";
+  const suffix =
+    block.numberingSuffix === "space"
+      ? 1
+      : block.numberingSuffix === "tab"
+        ? 4
+        : 0;
+  return prefix.length + suffix;
+}

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

@@ -0,0 +1,241 @@
+import type {
+  CompatibilityReport,
+  EditorWarning,
+  ExportDocxOptions,
+  ExportResult,
+  PersistedEditorSnapshot,
+  RuntimeRenderSnapshot,
+} from "../api/public-types.ts";
+import { createCanonicalDocumentId } from "../core/state/editor-state.ts";
+import type { ImportDiagnosticsResult } from "../validation/import-diagnostics.ts";
+
+export interface ReadOnlyDiagnosticsRuntime {
+  getRenderSnapshot(): RuntimeRenderSnapshot;
+  getPersistedSnapshot(): PersistedEditorSnapshot;
+  getCompatibilityReport(): CompatibilityReport;
+  getWarnings(): EditorWarning[];
+  dispatch(command: { type: string }): never;
+  undo(): never;
+  redo(): never;
+  exportDocx(options?: ExportDocxOptions): Promise<ExportResult>;
+}
+
+export function createReadOnlyDiagnosticsRuntime(input: {
+  documentId: string;
+  sourceLabel?: string;
+  editorBuild: string;
+  generatedAt: string;
+  diagnostics: ImportDiagnosticsResult;
+}): ReadOnlyDiagnosticsRuntime {
+  const persistedSnapshot = createDiagnosticsSnapshot(input);
+  const renderSnapshot = createDiagnosticsRenderSnapshot(input, persistedSnapshot);
+
+  return {
+    getRenderSnapshot() {
+      return renderSnapshot;
+    },
+    getPersistedSnapshot() {
+      return persistedSnapshot;
+    },
+    getCompatibilityReport() {
+      return persistedSnapshot.compatibility;
+    },
+    getWarnings() {
+      return persistedSnapshot.warningLog;
+    },
+    dispatch(command) {
+      throw createReadOnlyDiagnosticsModeError(command.type);
+    },
+    undo() {
+      throw createReadOnlyDiagnosticsModeError("history.undo");
+    },
+    redo() {
+      throw createReadOnlyDiagnosticsModeError("history.redo");
+    },
+    async exportDocx(options) {
+      void options;
+      throw new Error(
+        "DOCX export is blocked in read-only diagnostics mode because the imported package is not safe to rewrite.",
+      );
+    },
+  };
+}
+
+function createDiagnosticsSnapshot(input: {
+  documentId: string;
+  editorBuild: string;
+  generatedAt: string;
+  diagnostics: ImportDiagnosticsResult;
+}): PersistedEditorSnapshot {
+  const docId = createCanonicalDocumentId(input.documentId);
+  const diagnosticId = `diagnostic:${sanitizeDiagnosticsToken(input.documentId)}`;
+
+  return {
+    snapshotVersion: "persisted-editor-snapshot/2",
+    schemaVersion: "cds/1.0.0",
+    documentId: input.documentId,
+    docId,
+    createdAt: input.generatedAt,
+    updatedAt: input.generatedAt,
+    savedAt: input.generatedAt,
+    editorBuild: input.editorBuild,
+    canonicalDocument: {
+      schemaVersion: "cds/1.0.0",
+      docId,
+      createdAt: input.generatedAt,
+      updatedAt: input.generatedAt,
+      metadata: {
+        customProperties: {},
+        importMode: input.diagnostics.mode,
+      },
+      styles: {
+        paragraphs: {},
+        characters: {},
+        tables: {},
+      },
+      numbering: {
+        abstractDefinitions: {},
+        instances: {},
+      },
+      media: {
+        items: {},
+      },
+      content: {
+        type: "doc",
+        children: [{ type: "paragraph", children: [] }],
+      },
+      review: {
+        comments: {},
+        revisions: {},
+      },
+      preservation: {
+        opaqueFragments: {},
+        packageParts: {},
+      },
+      diagnostics: {
+        warnings: [],
+        errors: [
+          {
+            diagnosticId,
+            code: input.diagnostics.fatalError.code,
+            message: input.diagnostics.fatalError.message,
+            isFatal: input.diagnostics.fatalError.isFatal,
+            source: input.diagnostics.fatalError.source,
+            details: input.diagnostics.fatalError.details,
+          },
+        ],
+      },
+    },
+    compatibility: {
+      reportVersion: "compatibility-report/1",
+      generatedAt: input.generatedAt,
+      blockExport: true,
+      featureEntries: [...input.diagnostics.diagnostics.featureEntries],
+      warnings: [...input.diagnostics.diagnostics.warnings],
+      errors: [...input.diagnostics.diagnostics.errors],
+    },
+    warningLog: [],
+  };
+}
+
+function createDiagnosticsRenderSnapshot(
+  input: {
+    documentId: string;
+    sourceLabel?: string;
+    diagnostics: ImportDiagnosticsResult;
+  },
+  persistedSnapshot: PersistedEditorSnapshot,
+): RuntimeRenderSnapshot {
+  return {
+    documentId: input.documentId,
+    sessionId: `${input.documentId}-diagnostics`,
+    sourceLabel: input.sourceLabel,
+    revisionToken: `${input.documentId}:diagnostics`,
+    isReady: true,
+    isDirty: false,
+    readOnly: true,
+    selection: collapsedSelection(),
+    activeStory: { kind: "main" },
+    documentStats: {
+      storyLength: 0,
+      commentCount: 0,
+      revisionCount: 0,
+      opaqueFragmentCount: 0,
+    },
+    comments: {
+      openCommentIds: [],
+      resolvedCommentIds: [],
+      detachedCommentIds: [],
+      totalCount: 0,
+      threads: [],
+    },
+    trackedChanges: {
+      pendingChangeIds: [],
+      acceptedChangeIds: [],
+      rejectedChangeIds: [],
+      detachedChangeIds: [],
+      actionableChangeIds: [],
+      preserveOnlyChangeIds: [],
+      totalCount: 0,
+      revisions: [],
+    },
+    compatibility: {
+      blockExport: true,
+      blockExportReasons: [persistedSnapshot.compatibility.errors[0]?.message ?? input.diagnostics.featureEntry.message],
+      warningCount: persistedSnapshot.compatibility.warnings.length,
+      errorCount: persistedSnapshot.compatibility.errors.length,
+      featureEntries: [...persistedSnapshot.compatibility.featureEntries],
+    },
+    warnings: [],
+    fatalError: input.diagnostics.fatalError,
+    commandState: {
+      canUndo: false,
+      canRedo: false,
+      readOnly: true,
+    },
+    documentMode: "viewing",
+    protectionSnapshot: {
+      hasDocumentProtection: false,
+      enforcementActive: false,
+      ranges: [],
+      enforcedRangeCount: 0,
+      preservedRangeCount: 0,
+    },
+  };
+}
+
+function collapsedSelection(): RuntimeRenderSnapshot["selection"] {
+  return {
+    anchor: 0,
+    head: 0,
+    isCollapsed: true,
+    activeRange: {
+      kind: "range",
+      from: 0,
+      to: 0,
+      assoc: {
+        start: -1,
+        end: 1,
+      },
+    },
+  };
+}
+
+function createReadOnlyDiagnosticsModeError(commandType: string): Error {
+  const error = new Error(
+    `Command ${commandType} is blocked in read-only diagnostics mode.`,
+  );
+  Object.assign(error, {
+    code: "import_failed",
+    details: {
+      mode: "read-only-diagnostics",
+      commandType,
+    },
+  });
+  return error;
+}
+
+function sanitizeDiagnosticsToken(documentId: string): string {
+  const collapsed = documentId.replace(/[^A-Za-z0-9._-]/g, "-");
+  return collapsed.length > 0 ? `read-only-${collapsed}` : "read-only-diagnostics";
+}