@diagrammo/dgmo 0.4.2 → 0.4.3

package/src/sequence/tag-resolution.ts

@@ -0,0 +1,163 @@
+// ============================================================
+// Sequence Diagram Tag Resolution
+// ============================================================
+//
+// Resolves effective tag values for participants and messages
+// using the priority chain: explicit > group > receiver-inherit > default > neutral
+
+import type { TagGroup } from '../utils/tag-groups';
+import type {
+  ParsedSequenceDgmo,
+  SequenceParticipant,
+  SequenceMessage,
+  SequenceGroup,
+} from './parser';
+
+/**
+ * Resolved tag values for all sequence elements.
+ * Used by the renderer to look up colors via tag group entries.
+ */
+export interface ResolvedTagMap {
+  /** participantId → resolved tag value for the active group */
+  participants: Map<string, string | undefined>;
+  /** message lineNumber → tag value from explicit metadata */
+  messages: Map<number, string | undefined>;
+}
+
+/**
+ * Propagate group-level tag metadata to contained participants.
+ * Only sets values for keys not already present on the participant.
+ *
+ * Mutates `participantMeta` in-place.
+ */
+export function propagateGroupTags(
+  participantMeta: Map<string, Record<string, string>>,
+  groups: ReadonlyArray<SequenceGroup>,
+): void {
+  for (const group of groups) {
+    if (!group.metadata) continue;
+    for (const id of group.participantIds) {
+      const meta = participantMeta.get(id);
+      if (!meta) continue;
+      for (const [key, value] of Object.entries(group.metadata)) {
+        if (!(key in meta)) {
+          meta[key] = value;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Compute receiver inheritance for a specific tag group key.
+ *
+ * For each participant without an explicit value for `groupKey`,
+ * collect values from all incoming tagged messages. If exactly one
+ * unique value exists, the participant inherits it.
+ *
+ * Returns a map of participantId → inherited value.
+ */
+export function computeReceiverInheritance(
+  participants: ReadonlyArray<SequenceParticipant>,
+  messages: ReadonlyArray<SequenceMessage>,
+  groupKey: string,
+  participantMeta: Map<string, Record<string, string>>,
+): Map<string, string> {
+  const inheritance = new Map<string, string>();
+
+  for (const p of participants) {
+    const meta = participantMeta.get(p.id);
+    // Skip if already has a value for this group key
+    if (meta?.[groupKey]) continue;
+
+    const incomingValues = new Set<string>();
+    for (const msg of messages) {
+      if (msg.to === p.id && msg.metadata?.[groupKey]) {
+        incomingValues.add(msg.metadata[groupKey]);
+      }
+    }
+
+    if (incomingValues.size === 1) {
+      inheritance.set(p.id, [...incomingValues][0]);
+    }
+  }
+
+  return inheritance;
+}
+
+/**
+ * Full tag resolution for sequence diagrams.
+ *
+ * Priority: explicit metadata > group propagation > receiver inheritance > default > neutral
+ *
+ * Pure function — does not mutate `parsed`.
+ */
+export function resolveSequenceTags(
+  parsed: ParsedSequenceDgmo,
+  activeTagGroup: string,
+): ResolvedTagMap {
+  const result: ResolvedTagMap = {
+    participants: new Map(),
+    messages: new Map(),
+  };
+
+  // Find the active tag group
+  const group = parsed.tagGroups.find(
+    (g) => g.name.toLowerCase() === activeTagGroup.toLowerCase(),
+  );
+  if (!group) {
+    // No matching group — all neutral
+    for (const p of parsed.participants) {
+      result.participants.set(p.id, undefined);
+    }
+    for (const m of parsed.messages) {
+      result.messages.set(m.lineNumber, undefined);
+    }
+    return result;
+  }
+
+  const groupKey = group.name.toLowerCase();
+
+  // Clone participant metadata (don't mutate parsed data)
+  const participantMeta = new Map<string, Record<string, string>>();
+  for (const p of parsed.participants) {
+    participantMeta.set(p.id, { ...(p.metadata || {}) });
+  }
+
+  // Step 1: Group propagation
+  propagateGroupTags(participantMeta, parsed.groups);
+
+  // Step 2: Receiver inheritance
+  const inherited = computeReceiverInheritance(
+    parsed.participants,
+    parsed.messages,
+    groupKey,
+    participantMeta,
+  );
+  for (const [id, value] of inherited) {
+    const meta = participantMeta.get(id)!;
+    meta[groupKey] = value;
+  }
+
+  // Step 3: Default value injection
+  if (group.defaultValue) {
+    for (const p of parsed.participants) {
+      const meta = participantMeta.get(p.id)!;
+      if (!(groupKey in meta)) {
+        meta[groupKey] = group.defaultValue;
+      }
+    }
+  }
+
+  // Build result maps
+  for (const p of parsed.participants) {
+    const meta = participantMeta.get(p.id)!;
+    result.participants.set(p.id, meta[groupKey] || undefined);
+  }
+
+  for (const msg of parsed.messages) {
+    result.messages.set(msg.lineNumber, msg.metadata?.[groupKey] || undefined);
+  }
+
+  return result;
+}

package/src/sitemap/collapse.ts

@@ -0,0 +1,187 @@
+// ============================================================
+// Sitemap Collapse/Expand — prune subtrees + re-terminate arrows
+// ============================================================
+
+import type { SitemapNode, SitemapEdge, ParsedSitemap } from './types';
+
+// ============================================================
+// Types
+// ============================================================
+
+export interface CollapsedSitemapResult {
+  /** ParsedSitemap with collapsed subtrees pruned (deep-cloned, never mutates original) */
+  parsed: ParsedSitemap;
+  /** nodeId → count of hidden descendants */
+  hiddenCounts: Map<string, number>;
+}
+
+// ============================================================
+// Helpers
+// ============================================================
+
+function cloneNode(node: SitemapNode): SitemapNode {
+  return {
+    id: node.id,
+    label: node.label,
+    metadata: { ...node.metadata },
+    children: node.children.map(cloneNode),
+    parentId: node.parentId,
+    isContainer: node.isContainer,
+    lineNumber: node.lineNumber,
+    color: node.color,
+  };
+}
+
+function countDescendants(node: SitemapNode): number {
+  let count = 0;
+  for (const child of node.children) {
+    count += (child.isContainer ? 0 : 1) + countDescendants(child);
+  }
+  return count;
+}
+
+/** Compute hidden counts from the ORIGINAL (unpruned) tree. */
+function computeHiddenCounts(
+  nodes: SitemapNode[],
+  collapsedIds: Set<string>,
+  hiddenCounts: Map<string, number>,
+): void {
+  for (const node of nodes) {
+    if (collapsedIds.has(node.id) && node.children.length > 0) {
+      hiddenCounts.set(node.id, countDescendants(node));
+    }
+    computeHiddenCounts(node.children, collapsedIds, hiddenCounts);
+  }
+}
+
+/** Remove children of collapsed nodes on the cloned tree. */
+function pruneCollapsed(node: SitemapNode, collapsedIds: Set<string>): void {
+  for (const child of node.children) {
+    pruneCollapsed(child, collapsedIds);
+  }
+  if (collapsedIds.has(node.id) && node.children.length > 0) {
+    node.children = [];
+  }
+}
+
+/** Collect all node IDs reachable in a tree. */
+function collectNodeIds(nodes: SitemapNode[], ids: Set<string>): void {
+  for (const node of nodes) {
+    ids.add(node.id);
+    collectNodeIds(node.children, ids);
+  }
+}
+
+/**
+ * Find the outermost visible ancestor for a hidden node.
+ * Walk up the original tree to find which collapsed container should absorb the arrow.
+ */
+function findVisibleAncestor(
+  nodeId: string,
+  parentMap: Map<string, string>,
+  visibleIds: Set<string>,
+  collapsedIds: Set<string>,
+): string | null {
+  let current = nodeId;
+  while (true) {
+    const parentId = parentMap.get(current);
+    if (!parentId) return null;
+    // If the parent is visible and is a collapsed container, re-terminate here
+    if (visibleIds.has(parentId) && collapsedIds.has(parentId)) {
+      return parentId;
+    }
+    current = parentId;
+  }
+}
+
+/** Build nodeId → parentId map from the original tree. */
+function buildParentMap(nodes: SitemapNode[], map: Map<string, string>): void {
+  for (const node of nodes) {
+    for (const child of node.children) {
+      map.set(child.id, node.id);
+      buildParentMap([child], map);
+    }
+  }
+}
+
+// ============================================================
+// Main
+// ============================================================
+
+export function collapseSitemapTree(
+  original: ParsedSitemap,
+  collapsedIds: Set<string>,
+): CollapsedSitemapResult {
+  const hiddenCounts = new Map<string, number>();
+
+  if (collapsedIds.size === 0) {
+    return { parsed: original, hiddenCounts };
+  }
+
+  // Compute counts from the ORIGINAL tree before pruning
+  computeHiddenCounts(original.roots, collapsedIds, hiddenCounts);
+
+  // Deep-clone roots and prune collapsed subtrees
+  const clonedRoots = original.roots.map(cloneNode);
+  for (const root of clonedRoots) {
+    pruneCollapsed(root, collapsedIds);
+  }
+
+  // Collect visible node IDs after pruning
+  const visibleIds = new Set<string>();
+  collectNodeIds(clonedRoots, visibleIds);
+
+  // Build parent map from the ORIGINAL tree for ancestor lookup
+  const parentMap = new Map<string, string>();
+  buildParentMap(original.roots, parentMap);
+
+  // Re-terminate edges that reference hidden nodes.
+  // No deduplication — multiple edges between the same collapsed pair are kept
+  // so each retains its own label (e.g. "settings" and "billing" both show).
+  // Layout uses dagre multigraph to route each edge separately.
+  const newEdges: SitemapEdge[] = [];
+
+  for (const edge of original.edges) {
+    let sourceId = edge.sourceId;
+    let targetId = edge.targetId;
+
+    const sourceVisible = visibleIds.has(sourceId);
+    const targetVisible = visibleIds.has(targetId);
+
+    if (sourceVisible && targetVisible) {
+      // Both visible — keep as-is
+      newEdges.push({ ...edge });
+      continue;
+    }
+
+    // Re-terminate hidden endpoints
+    if (!sourceVisible) {
+      const ancestor = findVisibleAncestor(sourceId, parentMap, visibleIds, collapsedIds);
+      if (!ancestor) continue; // both endpoints hidden with no visible ancestor
+      sourceId = ancestor;
+    }
+    if (!targetVisible) {
+      const ancestor = findVisibleAncestor(targetId, parentMap, visibleIds, collapsedIds);
+      if (!ancestor) continue;
+      targetId = ancestor;
+    }
+
+    // Remove self-loops (both endpoints re-terminated to same collapsed group)
+    if (sourceId === targetId) continue;
+
+    newEdges.push({
+      ...edge,
+      sourceId,
+      targetId,
+    });
+  }
+
+  return {
+    parsed: {
+      ...original,
+      roots: clonedRoots,
+      edges: newEdges,
+    },
+    hiddenCounts,
+  };
+}