@beyondwork/docx-react-component 1.0.29 → 1.0.31

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

package/src/runtime/suggestions-snapshot.ts

@@ -0,0 +1,137 @@
+import type {
+  SuggestionEntrySnapshot,
+  SuggestionsSnapshot,
+  TrackedChangeEntrySnapshot,
+  TrackedChangesSnapshot,
+} from "../api/public-types";
+
+function compareSuggestions(
+  left: SuggestionEntrySnapshot,
+  right: SuggestionEntrySnapshot,
+): number {
+  return (
+    Date.parse(right.createdAt) - Date.parse(left.createdAt) ||
+    left.suggestionId.localeCompare(right.suggestionId)
+  );
+}
+
+function toSemanticKind(
+  revision: TrackedChangeEntrySnapshot,
+): SuggestionEntrySnapshot["kind"] {
+  if (revision.semanticKind) {
+    return revision.semanticKind;
+  }
+  switch (revision.kind) {
+    case "insertion":
+      return "insertion";
+    case "deletion":
+      return "deletion";
+    case "formatting":
+      return "formatting-change";
+    case "property-change":
+      return "paragraph-property-change";
+    case "move":
+      return "structural-change";
+  }
+}
+
+function pickPrimaryRevision(
+  revisions: TrackedChangeEntrySnapshot[],
+): TrackedChangeEntrySnapshot {
+  return (
+    revisions.find((revision) => toSemanticKind(revision) === "replacement" && revision.kind === "insertion") ??
+    revisions.find((revision) => revision.kind === "insertion") ??
+    revisions[0]!
+  );
+}
+
+function summarizeStatus(
+  revisions: TrackedChangeEntrySnapshot[],
+): SuggestionEntrySnapshot["status"] {
+  if (revisions.every((revision) => revision.status === "accepted")) {
+    return "accepted";
+  }
+  if (revisions.every((revision) => revision.status === "rejected")) {
+    return "rejected";
+  }
+  if (revisions.every((revision) => revision.status === "detached")) {
+    return "detached";
+  }
+  return "active";
+}
+
+function summarizeActionability(
+  revisions: TrackedChangeEntrySnapshot[],
+): SuggestionEntrySnapshot["actionability"] {
+  return revisions.every((revision) => revision.actionability === "preserve-only")
+    ? "preserve-only"
+    : "actionable";
+}
+
+export function createSuggestionsSnapshot(
+  trackedChanges: TrackedChangesSnapshot,
+): SuggestionsSnapshot {
+  const groups = new Map<string, TrackedChangeEntrySnapshot[]>();
+
+  for (const revision of trackedChanges.revisions) {
+    const suggestionId = revision.suggestionId ?? revision.revisionId;
+    const group = groups.get(suggestionId);
+    if (group) {
+      group.push(revision);
+    } else {
+      groups.set(suggestionId, [revision]);
+    }
+  }
+
+  const suggestions = Array.from(groups.entries())
+    .map(([suggestionId, revisions]): SuggestionEntrySnapshot => {
+      const primary = pickPrimaryRevision(revisions);
+      const kind = toSemanticKind(primary);
+      const status = summarizeStatus(revisions);
+      const actionability = summarizeActionability(revisions);
+      return {
+        suggestionId,
+        kind,
+        source: primary.source ?? "runtime",
+        status,
+        actionability,
+        storyTarget: primary.storyTarget ?? { kind: "main" },
+        anchor: primary.anchor,
+        anchorLabel: primary.anchorLabel,
+        createdAt: primary.createdAt,
+        authorId: primary.authorId,
+        changeIds: revisions.map((revision) => revision.revisionId),
+        editable: status === "active" && actionability === "actionable",
+        canAccept: revisions.some((revision) => revision.canAccept),
+        canReject: revisions.some((revision) => revision.canReject),
+        isReplacement: kind === "replacement",
+        preserveOnlyReason: primary.preserveOnlyReason,
+        excerpt: primary.excerpt,
+        detail: primary.detail,
+      };
+    })
+    .sort(compareSuggestions);
+
+  return {
+    totalCount: suggestions.length,
+    actionableSuggestionIds: suggestions
+      .filter((suggestion) => suggestion.actionability === "actionable")
+      .map((suggestion) => suggestion.suggestionId),
+    preserveOnlySuggestionIds: suggestions
+      .filter((suggestion) => suggestion.actionability === "preserve-only")
+      .map((suggestion) => suggestion.suggestionId),
+    activeSuggestionIds: suggestions
+      .filter((suggestion) => suggestion.status === "active")
+      .map((suggestion) => suggestion.suggestionId),
+    acceptedSuggestionIds: suggestions
+      .filter((suggestion) => suggestion.status === "accepted")
+      .map((suggestion) => suggestion.suggestionId),
+    rejectedSuggestionIds: suggestions
+      .filter((suggestion) => suggestion.status === "rejected")
+      .map((suggestion) => suggestion.suggestionId),
+    detachedSuggestionIds: suggestions
+      .filter((suggestion) => suggestion.status === "detached")
+      .map((suggestion) => suggestion.suggestionId),
+    suggestions,
+  };
+}