@beyondwork/docx-react-component 1.0.28 → 1.0.30

package/src/runtime/resolved-numbering-geometry.ts

@@ -0,0 +1,293 @@
+import type {
+  NumberingCatalog,
+  NumberingLevelDefinition,
+  NumberingLevelOverrideDefinition,
+  NumberingLevelParagraphGeometry,
+  ParagraphIndentation,
+  ParagraphNode,
+  ParagraphSpacing,
+  TabStop,
+} from "../model/canonical-document.ts";
+
+export const DEFAULT_NUMBERING_START_AT = 1;
+
+export interface ResolvedNumberingGeometry {
+  markerJustification?: NumberingLevelParagraphGeometry["justification"];
+  spacing?: ParagraphSpacing;
+  indentation?: ParagraphIndentation;
+  tabStops?: TabStop[];
+  markerLane?: {
+    start: number;
+    width: number;
+    textStart: number;
+  };
+  textColumn?: {
+    start: number;
+    right?: number;
+    firstLine?: number;
+    hanging?: number;
+  };
+}
+
+export interface ResolvedNumberingDefinitionSet {
+  instance: NumberingCatalog["instances"][string];
+  abstractDefinition: NumberingCatalog["abstractDefinitions"][string];
+  effectiveLevels: Map<number, NumberingLevelDefinition>;
+  effectiveLevel: NumberingLevelDefinition;
+  geometry: ResolvedNumberingGeometry;
+}
+
+export function resolveNumberingDefinitionSet(
+  catalog: NumberingCatalog,
+  numbering: ParagraphNode["numbering"] | undefined,
+  paragraph?: Pick<ParagraphNode, "spacing" | "indentation" | "tabStops">,
+): ResolvedNumberingDefinitionSet | null {
+  if (!numbering) {
+    return null;
+  }
+
+  const instance = catalog.instances[numbering.numberingInstanceId];
+  if (!instance) {
+    return null;
+  }
+
+  const abstractDefinition = catalog.abstractDefinitions[instance.abstractNumberingId];
+  if (!abstractDefinition) {
+    return null;
+  }
+
+  const effectiveLevels = buildEffectiveLevelDefinitions(abstractDefinition.levels, instance.overrides);
+  const effectiveLevel = effectiveLevels.get(numbering.level);
+  if (!effectiveLevel) {
+    return null;
+  }
+
+  return {
+    instance,
+    abstractDefinition,
+    effectiveLevels,
+    effectiveLevel,
+    geometry: resolveNumberingGeometry(effectiveLevel.paragraphGeometry, paragraph),
+  };
+}
+
+function buildEffectiveLevelDefinitions(
+  abstractLevels: readonly NumberingLevelDefinition[],
+  overrides: NumberingCatalog["instances"][string]["overrides"],
+): Map<number, NumberingLevelDefinition> {
+  const effectiveLevels = new Map<number, NumberingLevelDefinition>();
+
+  for (const level of abstractLevels) {
+    effectiveLevels.set(level.level, withDefaultStartAt(level));
+  }
+
+  for (const override of overrides) {
+    const base = effectiveLevels.get(override.level);
+    const merged = mergeLevelDefinition(base, override.levelDefinition, override.startAt, override.level);
+    if (merged) {
+      effectiveLevels.set(override.level, merged);
+    }
+  }
+
+  return effectiveLevels;
+}
+
+function mergeLevelDefinition(
+  base: NumberingLevelDefinition | undefined,
+  override: NumberingLevelOverrideDefinition | undefined,
+  startOverride: number | undefined,
+  fallbackLevel: number,
+): NumberingLevelDefinition | null {
+  if (!base && !override) {
+    return null;
+  }
+
+  const level = base?.level ?? override?.level ?? fallbackLevel;
+  const format = override?.format ?? base?.format ?? "decimal";
+  const text = override?.text ?? base?.text ?? `%${level + 1}.`;
+  const startAt = startOverride ?? override?.startAt ?? base?.startAt ?? DEFAULT_NUMBERING_START_AT;
+  const paragraphGeometry = mergeLevelParagraphGeometry(
+    base?.paragraphGeometry,
+    override?.paragraphGeometry,
+  );
+
+  return {
+    level,
+    format,
+    text,
+    startAt,
+    ...(override?.paragraphStyleId ?? base?.paragraphStyleId
+      ? { paragraphStyleId: override?.paragraphStyleId ?? base?.paragraphStyleId }
+      : {}),
+    ...((override?.isLegalNumbering ?? base?.isLegalNumbering) === true
+      ? { isLegalNumbering: true }
+      : {}),
+    ...(override?.suffix ?? base?.suffix ? { suffix: override?.suffix ?? base?.suffix } : {}),
+    ...(paragraphGeometry ? { paragraphGeometry } : {}),
+  };
+}
+
+function withDefaultStartAt(level: NumberingLevelDefinition): NumberingLevelDefinition {
+  return {
+    ...level,
+    startAt: level.startAt ?? DEFAULT_NUMBERING_START_AT,
+    ...(level.paragraphGeometry
+      ? { paragraphGeometry: cloneLevelParagraphGeometry(level.paragraphGeometry) }
+      : {}),
+  };
+}
+
+function cloneLevelParagraphGeometry(
+  geometry: NumberingLevelParagraphGeometry,
+): NumberingLevelParagraphGeometry {
+  return {
+    ...(geometry.justification ? { justification: geometry.justification } : {}),
+    ...(geometry.spacing ? { spacing: { ...geometry.spacing } } : {}),
+    ...(geometry.indentation ? { indentation: { ...geometry.indentation } } : {}),
+    ...(geometry.tabStops && geometry.tabStops.length > 0
+      ? { tabStops: cloneTabStops(geometry.tabStops) }
+      : {}),
+  };
+}
+
+function mergeLevelParagraphGeometry(
+  base: NumberingLevelParagraphGeometry | undefined,
+  override: NumberingLevelParagraphGeometry | undefined,
+): NumberingLevelParagraphGeometry | undefined {
+  if (!base && !override) {
+    return undefined;
+  }
+
+  const spacing = mergeParagraphSpacing(base?.spacing, override?.spacing);
+  const indentation = mergeParagraphIndentation(base?.indentation, override?.indentation);
+  const tabStops = override?.tabStops?.length
+    ? cloneTabStops(override.tabStops)
+    : base?.tabStops?.length
+      ? cloneTabStops(base.tabStops)
+      : undefined;
+
+  return {
+    ...(override?.justification ?? base?.justification
+      ? { justification: override?.justification ?? base?.justification }
+      : {}),
+    ...(spacing ? { spacing } : {}),
+    ...(indentation ? { indentation } : {}),
+    ...(tabStops && tabStops.length > 0 ? { tabStops } : {}),
+  };
+}
+
+function resolveNumberingGeometry(
+  levelGeometry: NumberingLevelParagraphGeometry | undefined,
+  paragraph: Pick<ParagraphNode, "spacing" | "indentation" | "tabStops"> | undefined,
+): ResolvedNumberingGeometry {
+  const spacing = mergeParagraphSpacing(levelGeometry?.spacing, paragraph?.spacing);
+  const indentation = mergeParagraphIndentation(levelGeometry?.indentation, paragraph?.indentation);
+  const tabStops = paragraph?.tabStops?.length
+    ? cloneTabStops(paragraph.tabStops)
+    : levelGeometry?.tabStops?.length
+      ? cloneTabStops(levelGeometry.tabStops)
+      : undefined;
+  const markerLane = deriveMarkerLane(indentation);
+  const textColumn = deriveTextColumn(indentation);
+
+  return {
+    ...(levelGeometry?.justification ? { markerJustification: levelGeometry.justification } : {}),
+    ...(spacing ? { spacing } : {}),
+    ...(indentation ? { indentation } : {}),
+    ...(tabStops && tabStops.length > 0 ? { tabStops } : {}),
+    ...(markerLane ? { markerLane } : {}),
+    ...(textColumn ? { textColumn } : {}),
+  };
+}
+
+function mergeParagraphSpacing(
+  base: ParagraphSpacing | undefined,
+  override: ParagraphSpacing | undefined,
+): ParagraphSpacing | undefined {
+  if (!base && !override) {
+    return undefined;
+  }
+
+  const spacing: ParagraphSpacing = {
+    ...(base ?? {}),
+    ...(override ?? {}),
+  };
+
+  return Object.keys(spacing).length > 0 ? spacing : undefined;
+}
+
+function mergeParagraphIndentation(
+  base: ParagraphIndentation | undefined,
+  override: ParagraphIndentation | undefined,
+): ParagraphIndentation | undefined {
+  if (!base && !override) {
+    return undefined;
+  }
+
+  const indentation: ParagraphIndentation = {
+    ...(base ?? {}),
+    ...(override ?? {}),
+  };
+
+  return Object.keys(indentation).length > 0 ? indentation : undefined;
+}
+
+function cloneTabStops(tabStops: readonly TabStop[]): TabStop[] {
+  return tabStops.map((tabStop) => ({ ...tabStop }));
+}
+
+function deriveMarkerLane(
+  indentation: ParagraphIndentation | undefined,
+): ResolvedNumberingGeometry["markerLane"] | undefined {
+  if (!indentation) {
+    return undefined;
+  }
+
+  const width = resolveHangingWidth(indentation);
+  if (width === undefined || width <= 0) {
+    return undefined;
+  }
+
+  const textStart = indentation.left ?? 0;
+  return {
+    start: textStart - width,
+    width,
+    textStart,
+  };
+}
+
+function deriveTextColumn(
+  indentation: ParagraphIndentation | undefined,
+): ResolvedNumberingGeometry["textColumn"] | undefined {
+  if (!indentation) {
+    return undefined;
+  }
+
+  const hanging = resolveHangingWidth(indentation);
+  const hasGeometry =
+    indentation.left !== undefined ||
+    indentation.right !== undefined ||
+    indentation.firstLine !== undefined ||
+    hanging !== undefined;
+
+  if (!hasGeometry) {
+    return undefined;
+  }
+
+  return {
+    start: indentation.left ?? 0,
+    ...(indentation.right !== undefined ? { right: indentation.right } : {}),
+    ...(indentation.firstLine !== undefined ? { firstLine: indentation.firstLine } : {}),
+    ...(hanging !== undefined ? { hanging } : {}),
+  };
+}
+
+function resolveHangingWidth(indentation: ParagraphIndentation): number | undefined {
+  if (indentation.hanging !== undefined) {
+    return indentation.hanging;
+  }
+  if (indentation.firstLine !== undefined && indentation.firstLine < 0) {
+    return Math.abs(indentation.firstLine);
+  }
+  return undefined;
+}

package/src/runtime/session-capabilities.ts

@@ -140,10 +140,10 @@ export function deriveCapabilities(
   // stays reachable in both modes).
   const hasTrustConcerns = exportBlocked || preserveOnlyCount > 0 || unsupportedFatalCount > 0
     || snapshot.warnings.length > 0 || hasFatalError;
-  const reviewRailVisible = workflowOverlayPresent
+  const reviewRailVisible = isReady && (workflowOverlayPresent
     ? false
     : mode === "review" || mode === "read-only-diagnostics"
-      || (mode === "editing" && hasTrustConcerns);
+      || (mode === "editing" && hasTrustConcerns));
 
   const healthIssueCount = preserveOnlyCount + unsupportedFatalCount + snapshot.warnings.length;
 

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