@beyondwork/docx-react-component 1.0.18 → 1.0.20

package/src/runtime/story-context.ts

@@ -0,0 +1,164 @@
+import type { EditorStoryTarget } from "../api/public-types";
+import type { CanonicalDocumentEnvelope } from "../core/state/editor-state.ts";
+import type {
+  FooterDocument,
+  HeaderDocument,
+  SectionProperties,
+} from "../model/canonical-document.ts";
+
+export interface DocumentSectionContext {
+  index: number;
+  properties?: SectionProperties;
+}
+
+export type HeaderFooterStoryTarget =
+  | Extract<EditorStoryTarget, { kind: "header" }>
+  | Extract<EditorStoryTarget, { kind: "footer" }>;
+
+export function collectSectionContexts(
+  document: CanonicalDocumentEnvelope,
+): DocumentSectionContext[] {
+  const sections: DocumentSectionContext[] = [];
+  let sectionIndex = 0;
+
+  for (const block of document.content.children) {
+    if (block.type !== "section_break") {
+      continue;
+    }
+    sections.push({
+      index: sectionIndex,
+      properties: block.sectionProperties,
+    });
+    sectionIndex += 1;
+  }
+
+  sections.push({
+    index: sectionIndex,
+    properties: document.subParts?.finalSectionProperties,
+  });
+
+  return sections;
+}
+
+export function resolveSectionVariants(
+  kind: "header" | "footer",
+  sectionIndex: number,
+  explicitReferences:
+    | SectionProperties["headerReferences"]
+    | SectionProperties["footerReferences"]
+    | undefined,
+  documents: HeaderDocument[] | FooterDocument[],
+): Array<{ variant: "default" | "first" | "even"; relationshipId: string }> {
+  if (explicitReferences && explicitReferences.length > 0) {
+    return explicitReferences.map((ref) => ({
+      variant: ref.variant,
+      relationshipId: ref.relationshipId,
+    }));
+  }
+
+  return documents
+    .filter(
+      (entry) =>
+        entry.sectionIndex === undefined || entry.sectionIndex === sectionIndex,
+    )
+    .map((entry) => ({
+      variant: entry.variant,
+      relationshipId: entry.relationshipId,
+    }));
+}
+
+export function findHeaderFooterDocumentEntry(
+  document: CanonicalDocumentEnvelope,
+  target: HeaderFooterStoryTarget,
+): HeaderDocument | FooterDocument | undefined {
+  const documents =
+    target.kind === "header"
+      ? document.subParts?.headers ?? []
+      : document.subParts?.footers ?? [];
+  const matches = documents.filter(
+    (entry) =>
+      entry.relationshipId === target.relationshipId &&
+      entry.variant === target.variant,
+  );
+  if (matches.length === 0) {
+    return undefined;
+  }
+  if (target.sectionIndex !== undefined) {
+    return (
+      matches.find((entry) => entry.sectionIndex === target.sectionIndex) ??
+      matches.find((entry) => entry.sectionIndex === undefined) ??
+      matches[0]
+    );
+  }
+  return matches[0];
+}
+
+export function sectionSupportsStoryTarget(
+  document: CanonicalDocumentEnvelope,
+  sectionIndex: number,
+  target: HeaderFooterStoryTarget,
+): boolean {
+  if (!findHeaderFooterDocumentEntry(document, target)) {
+    return false;
+  }
+
+  const section = collectSectionContexts(document).find(
+    (candidate) => candidate.index === sectionIndex,
+  );
+  if (!section) {
+    return false;
+  }
+
+  const variants = resolveSectionVariants(
+    target.kind,
+    sectionIndex,
+    target.kind === "header"
+      ? section.properties?.headerReferences
+      : section.properties?.footerReferences,
+    target.kind === "header"
+      ? document.subParts?.headers ?? []
+      : document.subParts?.footers ?? [],
+  );
+
+  return variants.some(
+    (variant) =>
+      variant.relationshipId === target.relationshipId &&
+      variant.variant === target.variant,
+  );
+}
+
+export function normalizeHeaderFooterTarget(
+  document: CanonicalDocumentEnvelope,
+  target: HeaderFooterStoryTarget,
+  preferredSectionIndex?: number,
+): HeaderFooterStoryTarget | undefined {
+  if (!findHeaderFooterDocumentEntry(document, target)) {
+    return undefined;
+  }
+
+  if (target.sectionIndex !== undefined) {
+    return sectionSupportsStoryTarget(document, target.sectionIndex, target)
+      ? target
+      : undefined;
+  }
+
+  const candidateIndexes = collectSectionContexts(document)
+    .map((section) => section.index)
+    .filter((sectionIndex) =>
+      sectionSupportsStoryTarget(document, sectionIndex, target),
+    );
+  if (candidateIndexes.length === 0) {
+    return undefined;
+  }
+
+  const resolvedSectionIndex =
+    preferredSectionIndex !== undefined &&
+    candidateIndexes.includes(preferredSectionIndex)
+      ? preferredSectionIndex
+      : candidateIndexes[0];
+
+  return {
+    ...target,
+    sectionIndex: resolvedSectionIndex,
+  };
+}

package/src/runtime/story-targeting.ts

@@ -0,0 +1,162 @@
+import type { EditorStoryTarget } from "../api/public-types";
+import type { CanonicalDocumentEnvelope } from "../core/state/editor-state.ts";
+import type { BlockNode } from "../model/canonical-document.ts";
+import {
+  findHeaderFooterDocumentEntry,
+  normalizeHeaderFooterTarget,
+} from "./story-context.ts";
+
+export function storyTargetKey(target: EditorStoryTarget): string {
+  switch (target.kind) {
+    case "main":
+      return "main";
+    case "header":
+      return `header:${target.relationshipId}:${target.variant}:${target.sectionIndex ?? "*"}`;
+    case "footer":
+      return `footer:${target.relationshipId}:${target.variant}:${target.sectionIndex ?? "*"}`;
+    case "footnote":
+      return `footnote:${target.noteId}`;
+    case "endnote":
+      return `endnote:${target.noteId}`;
+  }
+}
+
+export function getStoryBlocks(
+  document: CanonicalDocumentEnvelope,
+  target: EditorStoryTarget,
+): readonly BlockNode[] {
+  if (target.kind === "main") {
+    return document.content.children;
+  }
+
+  const subParts = document.subParts;
+  if (!subParts) {
+    return [];
+  }
+
+  switch (target.kind) {
+    case "header": {
+      const resolvedTarget = normalizeHeaderFooterTarget(document, target);
+      return (
+        resolvedTarget &&
+        findHeaderFooterDocumentEntry(document, resolvedTarget)?.blocks
+      ) ?? [];
+    }
+    case "footer": {
+      const resolvedTarget = normalizeHeaderFooterTarget(document, target);
+      return (
+        resolvedTarget &&
+        findHeaderFooterDocumentEntry(document, resolvedTarget)?.blocks
+      ) ?? [];
+    }
+    case "footnote":
+      return subParts.footnoteCollection?.footnotes[target.noteId]?.blocks ?? [];
+    case "endnote":
+      return subParts.footnoteCollection?.endnotes[target.noteId]?.blocks ?? [];
+  }
+}
+
+export function replaceStoryBlocks(
+  document: CanonicalDocumentEnvelope,
+  target: EditorStoryTarget,
+  blocks: readonly BlockNode[],
+): CanonicalDocumentEnvelope {
+  if (target.kind === "main") {
+    return {
+      ...document,
+      content: {
+        ...document.content,
+        children: [...blocks],
+      },
+    };
+  }
+
+  if (!document.subParts) {
+    return document;
+  }
+
+  switch (target.kind) {
+    case "header": {
+      const resolvedTarget = normalizeHeaderFooterTarget(document, target);
+      const matchedEntry = resolvedTarget
+        ? findHeaderFooterDocumentEntry(document, resolvedTarget)
+        : undefined;
+      if (!matchedEntry) {
+        return document;
+      }
+      return {
+        ...document,
+        subParts: {
+          ...document.subParts,
+          headers: document.subParts.headers.map((header) =>
+            header.relationshipId === matchedEntry.relationshipId &&
+              header.variant === matchedEntry.variant &&
+              header.partPath === matchedEntry.partPath
+              ? { ...header, blocks: [...blocks] }
+              : header,
+          ),
+        },
+      };
+    }
+    case "footer": {
+      const resolvedTarget = normalizeHeaderFooterTarget(document, target);
+      const matchedEntry = resolvedTarget
+        ? findHeaderFooterDocumentEntry(document, resolvedTarget)
+        : undefined;
+      if (!matchedEntry) {
+        return document;
+      }
+      return {
+        ...document,
+        subParts: {
+          ...document.subParts,
+          footers: document.subParts.footers.map((footer) =>
+            footer.relationshipId === matchedEntry.relationshipId &&
+              footer.variant === matchedEntry.variant &&
+              footer.partPath === matchedEntry.partPath
+              ? { ...footer, blocks: [...blocks] }
+              : footer,
+          ),
+        },
+      };
+    }
+    case "footnote":
+      return !document.subParts.footnoteCollection?.footnotes[target.noteId]
+        ? document
+        : {
+            ...document,
+            subParts: {
+              ...document.subParts,
+              footnoteCollection: {
+                ...document.subParts.footnoteCollection,
+                footnotes: {
+                  ...document.subParts.footnoteCollection.footnotes,
+                  [target.noteId]: {
+                    ...document.subParts.footnoteCollection.footnotes[target.noteId],
+                    blocks: [...blocks],
+                  },
+                },
+              },
+            },
+          };
+    case "endnote":
+      return !document.subParts.footnoteCollection?.endnotes[target.noteId]
+        ? document
+        : {
+            ...document,
+            subParts: {
+              ...document.subParts,
+              footnoteCollection: {
+                ...document.subParts.footnoteCollection,
+                endnotes: {
+                  ...document.subParts.footnoteCollection.endnotes,
+                  [target.noteId]: {
+                    ...document.subParts.footnoteCollection.endnotes[target.noteId],
+                    blocks: [...blocks],
+                  },
+                },
+              },
+            },
+          };
+  }
+}