@beyondwork/docx-react-component 1.0.18 → 1.0.20

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,
+      ),
+    )
+  );
+}