@beyondwork/docx-react-component 1.0.17 → 1.0.19

package/src/io/ooxml/parse-theme.ts

@@ -2,6 +2,7 @@ import type {
   ThemeColorScheme,
   ThemeDefinition,
   ThemeFontScheme,
+  ResolvedTheme,
 } from "../../model/canonical-document.ts";
 
 // ---- XML node types (inline, no external dep) ----
@@ -85,6 +86,37 @@ export function parseThemeXml(xml: string): ThemeDefinition {
   return result;
 }
 
+/**
+ * Resolve a ThemeDefinition into flattened runtime theme inputs.
+ * Maps OOXML theme slot names to CSS-usable color values and font families.
+ */
+export function resolveTheme(theme: ThemeDefinition): ResolvedTheme {
+  const colors: Record<string, string> = {};
+
+  if (theme.colorScheme?.colors) {
+    for (const [slot, value] of Object.entries(theme.colorScheme.colors)) {
+      colors[slot] = value;
+    }
+  }
+
+  return {
+    colors,
+    majorFont: theme.fontScheme?.majorFont,
+    minorFont: theme.fontScheme?.minorFont,
+  };
+}
+
+/**
+ * Resolve a theme color reference (e.g. "accent1", "dk1") to a CSS color string.
+ * Returns undefined if the theme does not contain the requested slot.
+ */
+export function resolveThemeColor(
+  theme: ResolvedTheme | undefined,
+  colorSlot: string,
+): string | undefined {
+  return theme?.colors[colorSlot];
+}
+
 // ---- Internal helpers ----
 
 function parseColorScheme(

package/src/model/canonical-document.ts

@@ -8,6 +8,7 @@ import {
   expectExactString,
   expectIso8601UtcTimestamp,
   expectString,
+  expectStringAllowEmpty,
   expectUuid,
   stableStringify,
 } from "./cds-1.0.0.ts";
@@ -79,12 +80,14 @@ export interface StylesCatalog {
   characters: Record<string, CharacterStyleDefinition>;
   tables: Record<string, TableStyleDefinition>;
   latentStyles?: Record<string, LatentStyleDefinition>;
+  fromPackage?: boolean;
 }
 
 export interface ParagraphStyleDefinition {
   styleId: string;
   basedOn?: string;
   nextStyle?: string;
+  outlineLevel?: number;
   displayName: string;
   kind: "paragraph";
   isDefault: boolean;
@@ -131,6 +134,8 @@ export interface NumberingLevelDefinition {
   text: string;
   startAt?: number;
   paragraphStyleId?: string;
+  isLegalNumbering?: boolean;
+  suffix?: "tab" | "space" | "nothing";
 }
 
 export interface NumberingInstance {
@@ -155,6 +160,9 @@ export interface MediaItem {
   relationshipId?: string;
   packagePartName: string;
   altText?: string;
+  display?: "inline" | "floating";
+  widthEmu?: number;
+  heightEmu?: number;
 }
 
 // ---- Sub-part canonical types ----
@@ -166,6 +174,7 @@ export interface HeaderDocument {
   partPath: string;
   relationshipId: string;
   blocks: BlockNode[];
+  sectionIndex?: number;
 }
 
 export interface FooterDocument {
@@ -173,6 +182,7 @@ export interface FooterDocument {
   partPath: string;
   relationshipId: string;
   blocks: BlockNode[];
+  sectionIndex?: number;
 }
 
 export interface FootnoteDefinition {
@@ -203,11 +213,25 @@ export interface ThemeDefinition {
   fontScheme?: ThemeFontScheme;
 }
 
+export interface DocumentSettings {
+  evenAndOddHeaders?: boolean;
+  zoomLevel?: "pageWidth" | "onePage" | number;
+}
+
 export interface SubPartsCatalog {
   headers: HeaderDocument[];
   footers: FooterDocument[];
   footnoteCollection?: FootnoteCollection;
   theme?: ThemeDefinition;
+  finalSectionProperties?: SectionProperties;
+  resolvedTheme?: ResolvedTheme;
+  settings?: DocumentSettings;
+}
+
+export interface ResolvedTheme {
+  colors: Record<string, string>;
+  majorFont?: string;
+  minorFont?: string;
 }
 
 // ---- Inline footnote reference node ----
@@ -407,6 +431,23 @@ export interface TableCellNode {
   verticalAlign?: "top" | "center" | "bottom";
 }
 
+export interface SdtCheckboxState {
+  checked: boolean;
+  checkedChar?: string;
+  uncheckedChar?: string;
+}
+
+export interface SdtDatePickerState {
+  fullDate?: string;
+  dateFormat?: string;
+  lid?: string;
+}
+
+export interface SdtDropdownListItem {
+  displayText?: string;
+  value: string;
+}
+
 export interface SdtNode {
   type: "sdt";
   properties: {
@@ -415,6 +456,11 @@ export interface SdtNode {
     tag?: string;
     lock?: string;
     propertiesXml?: string;
+    checkbox?: SdtCheckboxState;
+    datePicker?: SdtDatePickerState;
+    dropdownList?: SdtDropdownListItem[];
+    comboBox?: SdtDropdownListItem[];
+    showingPlcHdr?: boolean;
   };
   children: BlockNode[];
 }
@@ -451,7 +497,86 @@ export interface BookmarkEndNode {
 
 export interface SectionBreakNode {
   type: "section_break";
+  sectionPropertiesXml?: string;
+  /**
+   * @deprecated Legacy field from older snapshots. New exports should use
+   * sectionPropertiesXml and only contain raw <w:sectPr> content.
+   */
   propertiesXml?: string;
+  sectionProperties?: SectionProperties;
+}
+
+export interface SectionProperties {
+  pageSize?: PageSize;
+  pageMargins?: PageMargins;
+  columns?: ColumnProperties;
+  pageNumbering?: PageNumbering;
+  lineNumbering?: SectionLineNumbering;
+  pageBorders?: SectionPageBorders;
+  documentGrid?: SectionDocumentGrid;
+  headerReferences?: HeaderFooterReference[];
+  footerReferences?: HeaderFooterReference[];
+  sectionType?: "continuous" | "nextPage" | "evenPage" | "oddPage" | "nextColumn";
+  titlePage?: boolean;
+}
+
+export interface PageSize {
+  width: number;
+  height: number;
+  orientation?: "portrait" | "landscape";
+}
+
+export interface PageMargins {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+  header?: number;
+  footer?: number;
+  gutter?: number;
+}
+
+export interface ColumnProperties {
+  count?: number;
+  space?: number;
+  equalWidth?: boolean;
+  columns?: Array<{ width: number; space?: number }>;
+  separator?: boolean;
+}
+
+export interface PageNumbering {
+  format?: string;
+  start?: number;
+  chapStyle?: string;
+  chapSep?: string;
+}
+
+export interface SectionLineNumbering {
+  countBy?: number;
+  start?: number;
+  distance?: number;
+  restart?: "newPage" | "newSection" | "continuous";
+}
+
+export interface SectionPageBorders {
+  top?: BorderSpec;
+  left?: BorderSpec;
+  bottom?: BorderSpec;
+  right?: BorderSpec;
+  offsetFrom?: "page" | "text";
+  display?: "allPages" | "firstPage" | "notFirstPage";
+  zOrder?: "front" | "back";
+}
+
+export interface SectionDocumentGrid {
+  type?: "default" | "lines" | "linesAndChars" | "snapToChars";
+  linePitch?: number;
+  charSpace?: number;
+}
+
+export interface HeaderFooterReference {
+  variant: HeaderFooterVariant;
+  relationshipId: string;
 }
 
 export type InlineNode =
@@ -587,6 +712,7 @@ export interface ShapeNode {
   type: "shape";
   text?: string;
   geometry?: string;
+  isTextBox?: boolean;
   rawXml: string;
 }
 
@@ -781,7 +907,7 @@ export interface DiagnosticErrorEntry {
     | "internal_invariant";
   message: string;
   isFatal: boolean;
-  source: "import" | "runtime" | "validation" | "datastore" | "export";
+  source: "import" | "runtime" | "validation" | "datastore" | "host" | "export";
   details?: unknown;
 }
 
@@ -1343,7 +1469,11 @@ function validateReviewStore(
         );
       }
       if (threadRecord.body !== undefined) {
-        expectString(threadRecord.body, `${path}.comments.${commentId}.body`, issues);
+        expectStringAllowEmpty(
+          threadRecord.body,
+          `${path}.comments.${commentId}.body`,
+          issues,
+        );
       }
       if (!Array.isArray(threadRecord.warningIds)) {
         issues.push({
@@ -1489,7 +1619,7 @@ function validateCommentEntries(
     }
     expectString(record.entryId, `${path}[${index}].entryId`, issues);
     expectString(record.authorId, `${path}[${index}].authorId`, issues);
-    expectString(record.body, `${path}[${index}].body`, issues);
+    expectStringAllowEmpty(record.body, `${path}[${index}].body`, issues);
     expectIso8601UtcTimestamp(record.createdAt, `${path}[${index}].createdAt`, issues);
     if (record.metadata !== undefined) {
       validateCommentEntryMetadata(record.metadata, `${path}[${index}].metadata`, issues);

package/src/model/cds-1.0.0.ts

@@ -98,6 +98,19 @@ export function expectString(
   return value;
 }
 
+export function expectStringAllowEmpty(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): string | null {
+  if (typeof value !== "string") {
+    issues.push({ path, message: "Expected a string." });
+    return null;
+  }
+
+  return value;
+}
+
 export function expectExactString<T extends string>(
   value: unknown,
   expected: T,

package/src/model/snapshot.ts

@@ -62,7 +62,7 @@ export interface EditorError {
   code: EditorErrorCode;
   message: string;
   isFatal: boolean;
-  source: "import" | "runtime" | "validation" | "datastore" | "export";
+  source: "import" | "runtime" | "validation" | "datastore" | "host" | "export";
   details?: Record<string, unknown>;
 }
 
@@ -174,6 +174,7 @@ const EDITOR_ERROR_SOURCES = new Set<EditorError["source"]>([
   "runtime",
   "validation",
   "datastore",
+  "host",
   "export",
 ]);
 

package/src/runtime/document-layout.ts

@@ -0,0 +1,332 @@
+import type {
+  EditorStoryTarget,
+  PageLayoutSnapshot,
+} from "../api/public-types";
+import { MAIN_STORY_TARGET } from "../core/selection/mapping.ts";
+import {
+  createSelectionSnapshot,
+  type CanonicalDocumentEnvelope,
+  type EditorState,
+} from "../core/state/editor-state.ts";
+import type {
+  FooterDocument,
+  HeaderDocument,
+  SectionProperties,
+  SubPartsCatalog,
+} from "../model/canonical-document.ts";
+import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
+import {
+  resolveSectionVariants,
+  sectionSupportsStoryTarget,
+} from "./story-context.ts";
+import { storyTargetKey } from "./story-targeting.ts";
+
+export interface ResolvedDocumentSection {
+  index: number;
+  start: number;
+  end: number;
+  properties?: SectionProperties;
+}
+
+export function buildResolvedSections(
+  document: CanonicalDocumentEnvelope,
+): ResolvedDocumentSection[] {
+  const mainSurface = createEditorSurfaceSnapshot(
+    document,
+    createSelectionSnapshot(0, 0),
+    MAIN_STORY_TARGET,
+  );
+  const sections: ResolvedDocumentSection[] = [];
+  let sectionStart = 0;
+  let sectionIndex = 0;
+
+  for (const [index, block] of document.content.children.entries()) {
+    if (block.type !== "section_break") {
+      continue;
+    }
+
+    const surfaceBlock = mainSurface.blocks[index];
+    sections.push({
+      index: sectionIndex,
+      start: sectionStart,
+      end: surfaceBlock?.from ?? sectionStart,
+      properties: block.sectionProperties,
+    });
+    sectionStart = surfaceBlock?.to ?? sectionStart;
+    sectionIndex += 1;
+  }
+
+  sections.push({
+    index: sectionIndex,
+    start: sectionStart,
+    end: mainSurface.storySize,
+    properties: document.subParts?.finalSectionProperties,
+  });
+
+  return sections;
+}
+
+export function findSectionForPosition(
+  sections: ReadonlyArray<ResolvedDocumentSection>,
+  position: number,
+): ResolvedDocumentSection {
+  for (const section of sections) {
+    if (position < section.end) {
+      return section;
+    }
+  }
+
+  return sections[sections.length - 1] ?? {
+    index: 0,
+    start: 0,
+    end: 0,
+  };
+}
+
+export function buildPageLayoutSnapshot(
+  sectionIndex: number,
+  properties: SectionProperties | undefined,
+  subParts: SubPartsCatalog | undefined,
+): PageLayoutSnapshot {
+  const pageSize = properties?.pageSize ?? {
+    width: 12240,
+    height: 15840,
+    orientation: "portrait" as const,
+  };
+  const margins = properties?.pageMargins ?? {
+    top: 1440,
+    right: 1440,
+    bottom: 1440,
+    left: 1440,
+    header: 720,
+    footer: 720,
+    gutter: 0,
+  };
+  const columns = properties?.columns;
+  const explicitColumns = columns?.columns ?? [];
+  const differentOddEvenPages = Boolean(subParts?.settings?.evenAndOddHeaders);
+
+  return {
+    sectionIndex,
+    ...(properties?.sectionType ? { sectionType: properties.sectionType } : {}),
+    pageWidth: pageSize.width,
+    pageHeight: pageSize.height,
+    marginTop: margins.top,
+    marginBottom: margins.bottom,
+    marginLeft: margins.left,
+    marginRight: margins.right,
+    headerMargin: margins.header ?? 720,
+    footerMargin: margins.footer ?? 720,
+    gutter: margins.gutter ?? 0,
+    orientation: pageSize.orientation ?? "portrait",
+    columns:
+      explicitColumns.length > 0 ? explicitColumns.length : (columns?.count ?? 1),
+    differentFirstPage: Boolean(properties?.titlePage),
+    differentOddEvenPages,
+    ...(properties?.pageNumbering
+      ? {
+          pageNumbering: {
+            ...(properties.pageNumbering.format
+              ? { format: properties.pageNumbering.format }
+              : {}),
+            ...(properties.pageNumbering.start !== undefined
+              ? { start: properties.pageNumbering.start }
+              : {}),
+            ...(properties.pageNumbering.chapStyle
+              ? { chapterStyle: properties.pageNumbering.chapStyle }
+              : {}),
+            ...(properties.pageNumbering.chapSep
+              ? { chapterSeparator: properties.pageNumbering.chapSep }
+              : {}),
+          },
+        }
+      : {}),
+    ...(properties?.lineNumbering
+      ? {
+          lineNumbering: {
+            ...(properties.lineNumbering.countBy !== undefined
+              ? { countBy: properties.lineNumbering.countBy }
+              : {}),
+            ...(properties.lineNumbering.start !== undefined
+              ? { start: properties.lineNumbering.start }
+              : {}),
+            ...(properties.lineNumbering.distance !== undefined
+              ? { distance: properties.lineNumbering.distance }
+              : {}),
+            ...(properties.lineNumbering.restart
+              ? { restart: properties.lineNumbering.restart }
+              : {}),
+          },
+        }
+      : {}),
+    ...(properties?.pageBorders
+      ? {
+          pageBorders: {
+            ...(properties.pageBorders.top
+              ? { top: { ...properties.pageBorders.top } }
+              : {}),
+            ...(properties.pageBorders.left
+              ? { left: { ...properties.pageBorders.left } }
+              : {}),
+            ...(properties.pageBorders.bottom
+              ? { bottom: { ...properties.pageBorders.bottom } }
+              : {}),
+            ...(properties.pageBorders.right
+              ? { right: { ...properties.pageBorders.right } }
+              : {}),
+            ...(properties.pageBorders.offsetFrom
+              ? { offsetFrom: properties.pageBorders.offsetFrom }
+              : {}),
+            ...(properties.pageBorders.display
+              ? { display: properties.pageBorders.display }
+              : {}),
+            ...(properties.pageBorders.zOrder
+              ? { zOrder: properties.pageBorders.zOrder }
+              : {}),
+          },
+        }
+      : {}),
+    ...(properties?.documentGrid
+      ? {
+          documentGrid: {
+            ...(properties.documentGrid.type
+              ? { type: properties.documentGrid.type }
+              : {}),
+            ...(properties.documentGrid.linePitch !== undefined
+              ? { linePitch: properties.documentGrid.linePitch }
+              : {}),
+            ...(properties.documentGrid.charSpace !== undefined
+              ? { charSpace: properties.documentGrid.charSpace }
+              : {}),
+          },
+        }
+      : {}),
+    columnDefinitions: explicitColumns,
+    equalWidthColumns:
+      columns?.equalWidth ??
+      (explicitColumns.length === 0 || explicitColumns.length <= 1),
+    columnSeparator: Boolean(columns?.separator),
+    headerVariants: resolveSectionVariants(
+      "header",
+      sectionIndex,
+      properties?.headerReferences,
+      subParts?.headers ?? [],
+    ),
+    footerVariants: resolveSectionVariants(
+      "footer",
+      sectionIndex,
+      properties?.footerReferences,
+      subParts?.footers ?? [],
+    ),
+  };
+}
+
+export function resolveSectionForStoryTarget(
+  document: CanonicalDocumentEnvelope,
+  sections: ReadonlyArray<ResolvedDocumentSection>,
+  target: EditorStoryTarget,
+): ResolvedDocumentSection | undefined {
+  if (target.kind === "main" || sections.length === 0) {
+    return sections[0];
+  }
+
+  if (target.kind === "header") {
+    if (target.sectionIndex !== undefined) {
+      const section = sections.find((candidate) => candidate.index === target.sectionIndex);
+      return section &&
+        sectionSupportsStoryTarget(document, target.sectionIndex, target)
+        ? section
+        : undefined;
+    }
+    return (
+      findSectionByStoryReference(
+        document,
+        sections,
+        target,
+        "header",
+      ) ?? sections[0]
+    );
+  }
+
+  if (target.kind === "footer") {
+    if (target.sectionIndex !== undefined) {
+      const section = sections.find((candidate) => candidate.index === target.sectionIndex);
+      return section &&
+        sectionSupportsStoryTarget(document, target.sectionIndex, target)
+        ? section
+        : undefined;
+    }
+    return (
+      findSectionByStoryReference(
+        document,
+        sections,
+        target,
+        "footer",
+      ) ?? sections[0]
+    );
+  }
+
+  return undefined;
+}
+
+export function resolveActiveSection(
+  state: EditorState,
+  activeStory: EditorStoryTarget,
+  sections: ReadonlyArray<ResolvedDocumentSection>,
+  storySelections?: ReadonlyMap<string, EditorState["selection"]>,
+): ResolvedDocumentSection | undefined {
+  if (sections.length === 0) {
+    return undefined;
+  }
+
+  if (activeStory.kind === "main") {
+    return findSectionForPosition(sections, state.selection.head);
+  }
+
+  const referencedSection = resolveSectionForStoryTarget(
+    state.document,
+    sections,
+    activeStory,
+  );
+  if (referencedSection) {
+    return referencedSection;
+  }
+
+  const mainSelection =
+    storySelections?.get(storyTargetKey(MAIN_STORY_TARGET)) ?? state.selection;
+  return findSectionForPosition(sections, mainSelection.head);
+}
+
+function findSectionByStoryReference(
+  document: CanonicalDocumentEnvelope,
+  sections: ReadonlyArray<ResolvedDocumentSection>,
+  target:
+    | Extract<EditorStoryTarget, { kind: "header" }>
+    | Extract<EditorStoryTarget, { kind: "footer" }>,
+  kind: "header" | "footer",
+): ResolvedDocumentSection | undefined {
+  const propertyKey =
+    kind === "header" ? "headerReferences" : "footerReferences";
+  const documents =
+    kind === "header"
+      ? document.subParts?.headers ?? []
+      : document.subParts?.footers ?? [];
+
+  return (
+    sections.find((section) =>
+      section.properties?.[propertyKey]?.some(
+        (ref) =>
+          ref.relationshipId === target.relationshipId &&
+          ref.variant === target.variant,
+      ),
+    ) ??
+    sections.find((section) =>
+      documents.some(
+        (entry) =>
+          entry.relationshipId === target.relationshipId &&
+          entry.variant === target.variant &&
+          entry.sectionIndex === section.index,
+      ),
+    )
+  );
+}