@beyondwork/docx-react-component 1.0.29 → 1.0.30

package/src/runtime/document-outline.ts

@@ -0,0 +1,440 @@
+import type {
+  BlockNode,
+  InlineNode,
+} from "../model/canonical-document.ts";
+import type {
+  DocumentHeadingSnapshot,
+  DocumentLocationSnapshot,
+  DocumentNavigationSnapshot,
+  DocumentOutlineHeadingSnapshot,
+  DocumentOutlineSnapshot,
+  DocumentSectionSnapshot,
+  EditorAnchorProjection,
+  EditorStoryTarget,
+  PageLayoutSnapshot,
+  TocEntrySnapshot,
+  TocSnapshot,
+} from "../api/public-types";
+import type { CanonicalDocumentEnvelope } from "../core/state/editor-state.ts";
+import { createSelectionSnapshot } from "../core/state/editor-state.ts";
+import { MAIN_STORY_TARGET } from "../core/selection/mapping.ts";
+import { parseTocLevelRange } from "../io/ooxml/parse-fields.ts";
+import { buildPageLayoutSnapshot, buildResolvedSections } from "./document-layout.ts";
+import { createDocumentNavigationSnapshot } from "./document-navigation.ts";
+import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
+
+function getAnchorOffset(anchor: EditorAnchorProjection): number | undefined {
+  switch (anchor.kind) {
+    case "range":
+      return anchor.from;
+    case "node":
+      return anchor.at;
+    case "detached":
+      return anchor.lastKnownRange.from;
+  }
+}
+
+function createPublicRangeAnchor(from: number, to: number): EditorAnchorProjection {
+  return {
+    kind: "range",
+    from,
+    to,
+    assoc: { start: -1, end: 1 },
+  };
+}
+
+export function resolveHeadingPath(
+  headings: readonly DocumentHeadingSnapshot[],
+  offset: number | undefined,
+): { headingId?: string; headingPath: string[]; parentHeadingIds: string[] } {
+  if (offset === undefined) {
+    return { headingPath: [], parentHeadingIds: [] };
+  }
+
+  const stack: DocumentHeadingSnapshot[] = [];
+  let active: DocumentHeadingSnapshot | undefined;
+
+  for (const heading of headings) {
+    if (heading.offset > offset) {
+      break;
+    }
+    while (stack.length > 0 && stack[stack.length - 1]!.level >= heading.level) {
+      stack.pop();
+    }
+    stack.push(heading);
+    active = heading;
+  }
+
+  if (!active) {
+    return { headingPath: [], parentHeadingIds: [] };
+  }
+
+  return {
+    headingId: active.headingId,
+    headingPath: stack.map((heading) => heading.text),
+    parentHeadingIds: stack.slice(0, -1).map((heading) => heading.headingId),
+  };
+}
+
+export function createDocumentOutlineSnapshot(input: {
+  navigation: DocumentNavigationSnapshot;
+  activeStory: EditorStoryTarget;
+  selectionHead: number;
+}): DocumentOutlineSnapshot {
+  const activeHeading =
+    input.activeStory.kind === "main"
+      ? resolveHeadingPath(input.navigation.headings, input.selectionHead).headingId
+      : undefined;
+
+  const outlineHeadings: DocumentOutlineHeadingSnapshot[] = [];
+  const stack: Array<{ headingId: string; level: number }> = [];
+
+  for (const heading of input.navigation.headings) {
+    while (stack.length > 0 && stack[stack.length - 1]!.level >= heading.level) {
+      stack.pop();
+    }
+    outlineHeadings.push({
+      ...heading,
+      parentHeadingIds: stack.map((entry) => entry.headingId),
+    });
+    stack.push({
+      headingId: heading.headingId,
+      level: heading.level,
+    });
+  }
+
+  return {
+    ...(activeHeading ? { activeHeadingId: activeHeading } : {}),
+    headings: outlineHeadings,
+  };
+}
+
+function getSectionHeadingPath(
+  headings: readonly DocumentHeadingSnapshot[],
+  sectionStart: number,
+  sectionEnd: number,
+): { headingPath: string[]; primaryHeadingId?: string; primaryHeadingText?: string } {
+  const firstHeading = headings.find(
+    (heading) => heading.offset >= sectionStart && heading.offset < sectionEnd,
+  );
+  if (!firstHeading) {
+    return { headingPath: [] };
+  }
+  const path = resolveHeadingPath(headings, firstHeading.offset);
+  return {
+    headingPath: path.headingPath,
+    primaryHeadingId: firstHeading.headingId,
+    primaryHeadingText: firstHeading.text,
+  };
+}
+
+function createSectionStoryTargets(layout: PageLayoutSnapshot): EditorStoryTarget[] {
+  const targets: EditorStoryTarget[] = [MAIN_STORY_TARGET];
+  for (const header of layout.headerVariants) {
+    targets.push({
+      kind: "header",
+      relationshipId: header.relationshipId,
+      variant: header.variant,
+      sectionIndex: layout.sectionIndex,
+    });
+  }
+  for (const footer of layout.footerVariants) {
+    targets.push({
+      kind: "footer",
+      relationshipId: footer.relationshipId,
+      variant: footer.variant,
+      sectionIndex: layout.sectionIndex,
+    });
+  }
+  return targets;
+}
+
+export function createDocumentSectionSnapshots(
+  document: CanonicalDocumentEnvelope,
+  navigation?: DocumentNavigationSnapshot,
+): DocumentSectionSnapshot[] {
+  const resolvedNavigation =
+    navigation ?? createDocumentNavigationSnapshot(document, 0, MAIN_STORY_TARGET);
+  const sections = buildResolvedSections(document);
+
+  return sections.map((section) => {
+    const pageIndexes = resolvedNavigation.pages
+      .filter((page) => page.sectionIndex === section.index)
+      .map((page) => page.pageIndex);
+    const pageRange =
+      pageIndexes.length > 0
+        ? { start: pageIndexes[0]!, end: pageIndexes[pageIndexes.length - 1]! }
+        : { start: 0, end: 0 };
+    const layout = buildPageLayoutSnapshot(
+      section.index,
+      section.properties ?? document.subParts?.finalSectionProperties,
+      document.subParts,
+    );
+    const headingInfo = getSectionHeadingPath(
+      resolvedNavigation.headings,
+      section.start,
+      section.end,
+    );
+
+    return {
+      sectionId: `section-${section.index}`,
+      sectionIndex: section.index,
+      pageRange,
+      headingPath: headingInfo.headingPath,
+      ...(headingInfo.primaryHeadingId
+        ? {
+            primaryHeadingId: headingInfo.primaryHeadingId,
+            primaryHeadingText: headingInfo.primaryHeadingText,
+          }
+        : {}),
+      layout,
+      anchor: createPublicRangeAnchor(section.start, section.end),
+      storyTargets: createSectionStoryTargets(layout),
+    };
+  });
+}
+
+export function findDocumentSectionSnapshot(
+  sections: readonly DocumentSectionSnapshot[],
+  input: { sectionIndex?: number; headingId?: string; bookmarkName?: string },
+  locations?: readonly DocumentLocationSnapshot[],
+): DocumentSectionSnapshot | null {
+  if (typeof input.sectionIndex === "number") {
+    return sections.find((section) => section.sectionIndex === input.sectionIndex) ?? null;
+  }
+  if (input.headingId) {
+    return sections.find((section) => section.primaryHeadingId === input.headingId) ?? null;
+  }
+  if (input.bookmarkName && locations) {
+    const location = locations.find((entry) => entry.bookmarkName === input.bookmarkName);
+    if (location?.sectionIndex !== undefined) {
+      return sections.find((section) => section.sectionIndex === location.sectionIndex) ?? null;
+    }
+  }
+  return null;
+}
+
+export function createTocSnapshot(
+  document: CanonicalDocumentEnvelope,
+  navigation?: DocumentNavigationSnapshot,
+): TocSnapshot | null {
+  const registry = document.fieldRegistry;
+  const tocStructure = registry?.tocStructure;
+  const fallbackFields = document.fieldRegistry?.supported ?? [];
+  const tocFieldIndex = tocStructure
+    ? fallbackFields.find((entry) => entry.fieldFamily === "TOC")?.fieldIndex
+    : undefined;
+  const fallbackTocField = !tocStructure ? findFirstTocField(document.content.children) : undefined;
+
+  if (!tocStructure && !fallbackTocField) {
+    const hasTocField =
+      fallbackFields.some((entry) => entry.fieldFamily === "TOC") ||
+      document.fieldRegistry?.preserveOnly.some((entry) => entry.fieldFamily === "TOC");
+    return hasTocField ? { status: "missing", entries: [] } : null;
+  }
+
+  const resolvedNavigation =
+    navigation ?? createDocumentNavigationSnapshot(document, 0, MAIN_STORY_TARGET);
+  const headingRefs = buildHeadingRefs(document, resolvedNavigation);
+  const derivedEntries: Array<{
+    level: number;
+    text: string;
+    bookmarkName?: string;
+  }> = tocStructure
+    ? tocStructure.entries.map((entry) => {
+        const heading = resolveHeadingForTocEntry(entry, headingRefs);
+        return {
+          level: entry.level,
+          text: heading?.text ?? entry.text,
+          ...(entry.bookmarkName ? { bookmarkName: entry.bookmarkName } : {}),
+        };
+      })
+    : resolvedNavigation.headings
+        .filter((heading) => {
+          const levelRange = parseTocLevelRange(fallbackTocField!.instruction);
+          return heading.level >= levelRange.from && heading.level <= levelRange.to;
+        })
+        .map((heading) => ({
+          level: heading.level,
+          text: heading.text,
+          bookmarkName: findBookmarkNameForOffset(document, heading.offset),
+        }));
+  const entries: TocEntrySnapshot[] = derivedEntries.map((entry, index) => {
+    const heading = tocStructure
+      ? resolveHeadingForTocEntry(tocStructure.entries[index]!, headingRefs)
+      : resolvedNavigation.headings[index];
+    const bookmarkName = headingRefs.find((ref) => ref.heading.headingId === heading?.headingId)?.bookmarkName;
+    return {
+      tocEntryId: `toc-entry-${index}`,
+      level: entry.level,
+      text: entry.text,
+      ...(heading
+        ? {
+            pageIndex: heading.pageIndex,
+            anchor: createPublicRangeAnchor(heading.offset, heading.offset),
+            headingId: heading.headingId,
+            ...(bookmarkName ? { bookmarkName } : {}),
+          }
+        : {}),
+      ...(entry.bookmarkName ? { bookmarkName: entry.bookmarkName } : {}),
+    };
+  });
+
+  return {
+    status: tocStructure?.status ?? (fallbackTocField?.refreshStatus === "current" ? "current" : "stale"),
+    ...(typeof tocFieldIndex === "number" ? { sourceFieldIndex: tocFieldIndex } : {}),
+    instruction: tocStructure?.instruction ?? fallbackTocField?.instruction,
+    entries,
+  };
+}
+
+function buildHeadingRefs(
+  document: CanonicalDocumentEnvelope,
+  navigation: DocumentNavigationSnapshot,
+): Array<{
+  heading: DocumentHeadingSnapshot;
+  paragraphIndex?: number;
+  bookmarkName?: string;
+}> {
+  const surface = createEditorSurfaceSnapshot(
+    document,
+    createSelectionSnapshot(0, 0),
+    MAIN_STORY_TARGET,
+  );
+  const paragraphIndexByOffset = new Map<number, number>();
+  for (const block of surface.blocks) {
+    if (block.kind !== "paragraph") {
+      continue;
+    }
+    const match = /^paragraph-(\d+)$/.exec(block.blockId);
+    if (!match) {
+      continue;
+    }
+    paragraphIndexByOffset.set(block.from, parseInt(match[1]!, 10));
+  }
+  return navigation.headings.map((heading) => ({
+    heading,
+    paragraphIndex: paragraphIndexByOffset.get(heading.offset),
+    ...(findBookmarkNameForOffset(document, heading.offset)
+      ? { bookmarkName: findBookmarkNameForOffset(document, heading.offset) }
+      : {}),
+  }));
+}
+
+function resolveHeadingForTocEntry(
+  entry: { paragraphIndex: number; bookmarkName?: string },
+  headingRefs: ReadonlyArray<{
+    heading: DocumentHeadingSnapshot;
+    paragraphIndex?: number;
+    bookmarkName?: string;
+  }>,
+): DocumentHeadingSnapshot | undefined {
+  if (entry.bookmarkName) {
+    const bookmarkMatch = headingRefs.find((ref) => ref.bookmarkName === entry.bookmarkName);
+    if (bookmarkMatch) {
+      return bookmarkMatch.heading;
+    }
+  }
+  const paragraphMatch = headingRefs.find((ref) => ref.paragraphIndex === entry.paragraphIndex);
+  return paragraphMatch?.heading;
+}
+
+function findFirstTocField(blocks: readonly BlockNode[]): Extract<InlineNode, { type: "field" }> | undefined {
+  for (const block of blocks) {
+    if (block.type === "paragraph") {
+      const field = findTocFieldInline(block.children);
+      if (field) {
+        return field;
+      }
+      continue;
+    }
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          const field = findFirstTocField(cell.children);
+          if (field) {
+            return field;
+          }
+        }
+      }
+      continue;
+    }
+    if (block.type === "sdt" || block.type === "custom_xml") {
+      const field = findFirstTocField(block.children);
+      if (field) {
+        return field;
+      }
+    }
+  }
+  return undefined;
+}
+
+function findTocFieldInline(
+  nodes: readonly InlineNode[],
+): Extract<InlineNode, { type: "field" }> | undefined {
+  for (const node of nodes) {
+    if (node.type === "field" && node.fieldFamily === "TOC") {
+      return node;
+    }
+    if (node.type === "field" || node.type === "hyperlink") {
+      const childField = findTocFieldInline(node.children);
+      if (childField) {
+        return childField;
+      }
+    }
+  }
+  return undefined;
+}
+
+export function findBookmarkNameForOffset(
+  document: CanonicalDocumentEnvelope,
+  offset: number | undefined,
+): string | undefined {
+  if (offset === undefined) {
+    return undefined;
+  }
+
+  let runningOffset = 0;
+  for (const block of document.content.children) {
+    if (block.type !== "paragraph") {
+      continue;
+    }
+    const paragraphStart = runningOffset;
+    for (const child of block.children) {
+      if (child.type === "text") {
+        runningOffset += child.text.length;
+      } else if (child.type === "tab" || child.type === "hard_break") {
+        runningOffset += 1;
+      }
+    }
+    const paragraphEnd = runningOffset;
+    if (offset >= paragraphStart && offset <= paragraphEnd) {
+      const bookmarkStart = block.children.find(
+        (child): child is Extract<typeof child, { type: "bookmark_start" }> =>
+          child.type === "bookmark_start" && Boolean(child.name),
+      );
+      return bookmarkStart?.name;
+    }
+  }
+
+  return undefined;
+}
+
+export function createSectionLocations(
+  document: CanonicalDocumentEnvelope,
+  sections: readonly DocumentSectionSnapshot[],
+): DocumentLocationSnapshot[] {
+  return sections.map((section) => ({
+    locationId: `location:${section.sectionId}`,
+    anchor: section.anchor,
+    storyTarget: MAIN_STORY_TARGET,
+    sectionIndex: section.sectionIndex,
+    pageIndex: section.pageRange.start,
+    ...(section.primaryHeadingId ? { headingId: section.primaryHeadingId } : {}),
+    ...(section.headingPath.length > 0 ? { headingPath: section.headingPath } : {}),
+    source: { kind: "navigation" },
+    ...(findBookmarkNameForOffset(document, getAnchorOffset(section.anchor))
+      ? { bookmarkName: findBookmarkNameForOffset(document, getAnchorOffset(section.anchor)) }
+      : {}),
+  }));
+}