@ddd-ts/event-tree-viewer 0.0.0-eventviz.10

package/src/domain/domain-grouping.ts

@@ -0,0 +1,217 @@
+import type { Node } from "./node"
+import { nodeId, type NodeId } from "./graph"
+
+export interface NodeDomain {
+  key: string
+  label: string
+}
+
+export function computeDomains(nodes: Node[]): Map<NodeId, NodeDomain> {
+  const chains = buildFolderChains(nodes)
+  const segmentCounts = countLastSegments(chains)
+  const picks = pickUniqueFolders(nodes, chains, segmentCounts)
+  const labels = labelDomains([...new Set(picks.values())])
+  return mergeIntoDomains(picks, labels)
+}
+
+export interface DomainGroup {
+  domain: NodeDomain
+  rootIds: NodeId[]
+}
+
+export function domainPrefixFromLabel(label: string): string {
+  if (!label || label === "·") return ""
+  return label.replace(/\s+/g, "")
+}
+
+export type StripPosition = "prefix" | "suffix" | null
+
+export interface StripResult {
+  stripped: string
+  position: StripPosition
+}
+
+export function isJustKind(text: string, kind: string): boolean {
+  return text.toLowerCase() === kind.toLowerCase()
+}
+
+export function stripDomainAffix(
+  name: string,
+  affix: string,
+  allowEmpty = false
+): StripResult {
+  const asPrefix = tryStripPrefix(name, affix, allowEmpty)
+  if (asPrefix !== null) return { stripped: asPrefix, position: "prefix" }
+  const asSuffix = tryStripSuffix(name, affix, allowEmpty)
+  if (asSuffix !== null) return { stripped: asSuffix, position: "suffix" }
+  return { stripped: name, position: null }
+}
+
+function tryStripPrefix(
+  name: string,
+  affix: string,
+  allowEmpty: boolean
+): string | null {
+  if (!affix) return null
+  if (!name.startsWith(affix)) return null
+  if (name.length === affix.length) return allowEmpty ? "" : null
+  const next = name[affix.length]
+  if (next !== next.toUpperCase()) return null
+  return name.slice(affix.length)
+}
+
+function tryStripSuffix(
+  name: string,
+  affix: string,
+  allowEmpty: boolean
+): string | null {
+  if (!affix) return null
+  if (!name.endsWith(affix)) return null
+  if (name.length === affix.length) return allowEmpty ? "" : null
+  const prev = name[name.length - affix.length - 1]
+  if (prev !== prev.toLowerCase()) return null
+  return name.slice(0, name.length - affix.length)
+}
+
+export function groupByDomain(
+  rootIds: NodeId[],
+  domains: ReadonlyMap<NodeId, NodeDomain>
+): DomainGroup[] {
+  const groups = new Map<string, DomainGroup>()
+  for (const id of rootIds) {
+    const domain = domains.get(id) ?? { key: "·", label: "·" }
+    const existing = groups.get(domain.key)
+    if (existing) existing.rootIds.push(id)
+    else groups.set(domain.key, { domain, rootIds: [id] })
+  }
+  return [...groups.values()].sort((a, b) =>
+    a.domain.label.localeCompare(b.domain.label)
+  )
+}
+
+function buildFolderChains(nodes: Node[]): Map<NodeId, string[]> {
+  const chains = new Map<NodeId, string[]>()
+  for (const n of nodes) {
+    chains.set(nodeId(n.type, n.name), folderChain(folderOf(n.source.file)))
+  }
+  return chains
+}
+
+function countLastSegments(chains: Map<NodeId, string[]>): Map<string, number> {
+  const unique = new Set<string>()
+  for (const chain of chains.values()) for (const f of chain) unique.add(f)
+
+  const counts = new Map<string, number>()
+  for (const folder of unique) {
+    const seg = lastSegment(folder)
+    if (seg) counts.set(seg, (counts.get(seg) ?? 0) + 1)
+  }
+  return counts
+}
+
+function pickUniqueFolders(
+  nodes: Node[],
+  chains: Map<NodeId, string[]>,
+  segmentCounts: Map<string, number>
+): Map<NodeId, string> {
+  const picks = new Map<NodeId, string>()
+  for (const n of nodes) {
+    const id = nodeId(n.type, n.name)
+    const chain = chains.get(id) ?? []
+    picks.set(id, pickDeepestUniqueFolder(chain, segmentCounts))
+  }
+  return picks
+}
+
+function pickDeepestUniqueFolder(
+  chain: string[],
+  segmentCounts: Map<string, number>
+): string {
+  for (const folder of chain) {
+    const seg = lastSegment(folder)
+    if (seg && (segmentCounts.get(seg) ?? 0) === 1) return folder
+  }
+  return chain[0] ?? ""
+}
+
+function labelDomains(paths: string[]): Map<string, string> {
+  const segmentsByPath = new Map<string, string[]>()
+  for (const p of paths) segmentsByPath.set(p, p.split("/").filter(Boolean))
+
+  const labels = new Map<string, string>()
+  for (const path of paths) {
+    const segments = segmentsByPath.get(path) ?? []
+    labels.set(path, humanCase(disambiguatedSegment(segments, segmentsByPath)))
+  }
+  return labels
+}
+
+function disambiguatedSegment(
+  segments: string[],
+  segmentsByPath: Map<string, string[]>
+): string {
+  if (segments.length === 0) return ""
+  for (let depth = 1; depth <= segments.length; depth++) {
+    const suffix = segments.slice(segments.length - depth).join("/")
+    if (countSuffixMatches(suffix, depth, segmentsByPath) === 1) {
+      return segments[segments.length - depth]
+    }
+  }
+  return segments[segments.length - 1]
+}
+
+function countSuffixMatches(
+  suffix: string,
+  depth: number,
+  segmentsByPath: Map<string, string[]>
+): number {
+  let count = 0
+  for (const segments of segmentsByPath.values()) {
+    if (segments.length < depth) continue
+    if (segments.slice(segments.length - depth).join("/") === suffix) count++
+  }
+  return count
+}
+
+function mergeIntoDomains(
+  picks: Map<NodeId, string>,
+  labels: Map<string, string>
+): Map<NodeId, NodeDomain> {
+  const out = new Map<NodeId, NodeDomain>()
+  for (const [id, key] of picks) {
+    out.set(id, { key, label: labels.get(key) || "·" })
+  }
+  return out
+}
+
+function folderOf(file: string): string {
+  const parts = file.split(/[\\/]/).filter((s) => s && s !== ".")
+  parts.pop()
+  return parts.join("/")
+}
+
+function folderChain(folder: string): string[] {
+  if (!folder) return []
+  const parts = folder.split("/")
+  const chain: string[] = []
+  for (let depth = parts.length; depth > 0; depth--) {
+    chain.push(parts.slice(0, depth).join("/"))
+  }
+  return chain
+}
+
+function lastSegment(folder: string): string | undefined {
+  return folder.split("/").filter(Boolean).pop()
+}
+
+function humanCase(name: string): string {
+  return name
+    .replace(/[-_.]+/g, " ")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+    .replace(/\s+/g, " ")
+    .trim()
+    .split(" ")
+    .map((w) => (w ? w[0].toUpperCase() + w.slice(1) : w))
+    .join(" ")
+}

package/src/domain/edge.ts

@@ -0,0 +1,37 @@
+import type { Direction } from "./direction"
+
+type EventRef = { type: "event"; name: string }
+type CommandRef = { type: "command"; name: string }
+type Reactor = {
+  type: "saga" | "aggregate" | "projection"
+  name: string
+}
+type Sender = { type: "saga" | "aggregate"; name: string }
+
+type Source = { file: string; start: number }
+
+export type Edge =
+  | { from: EventRef; to: Reactor; source: Source }
+  | { from: Sender; to: CommandRef; source: Source }
+  | { from: Sender; to: EventRef; source: Source }
+  | { from: CommandRef; to: EventRef; source: Source }
+
+export type EdgeKind = "reacts" | "sends" | "emits" | "handler-emits"
+
+export function edgeKind(edge: Edge): EdgeKind {
+  if (edge.from.type === "event") return "reacts"
+  if (edge.from.type === "command") return "handler-emits"
+  if (edge.to.type === "command") return "sends"
+  return "emits"
+}
+
+export function verbFor(direction: Direction, kind: EdgeKind): string {
+  if (direction === "forward") {
+    if (kind === "reacts") return "triggers"
+    if (kind === "sends") return "sends"
+    return "emits"
+  }
+  if (kind === "reacts") return "triggered by"
+  if (kind === "sends") return "sent by"
+  return "emitted by"
+}

package/src/domain/filter.ts

@@ -0,0 +1,21 @@
+import type { Node, NodeKind } from "./node"
+
+export interface NodeFilter {
+  search: string
+  kinds: ReadonlySet<NodeKind>
+}
+
+export function matchesFilter(node: Node, filter: NodeFilter): boolean {
+  if (!filter.kinds.has(node.type)) return false
+  if (!filter.search) return true
+  const q = filter.search.toLowerCase()
+  if (node.name.toLowerCase().includes(q)) return true
+  if (
+    "meta" in node &&
+    "alias" in node.meta &&
+    node.meta.alias.toLowerCase().includes(q)
+  ) {
+    return true
+  }
+  return false
+}

package/src/domain/flatten-tree.ts

@@ -0,0 +1,167 @@
+import type { GraphIndex, NodeId } from "./graph"
+import type { TraceNode } from "./traversal"
+import { traceFrom } from "./traversal"
+import type { Direction } from "./direction"
+import { domainPrefixFromLabel, type DomainGroup } from "./domain-grouping"
+
+export type FlatRow = DomainHeaderRow | TraceRowItem | HiddenIndicatorRow
+
+export interface DomainHeaderRow {
+  kind: "domain-header"
+  path: string
+  ancestors: readonly number[]
+  stickable: true
+  stickyTop: number
+  subtreeSize: number
+  label: string
+  count: number
+  expanded: boolean
+}
+
+export interface TraceRowItem {
+  kind: "trace-row"
+  path: string
+  ancestors: readonly number[]
+  stickable: boolean
+  stickyTop: number
+  subtreeSize: number
+  depth: number
+  trace: TraceNode
+  domainPrefix: string
+  hasChildren: boolean
+  expanded: boolean
+}
+
+export interface HiddenIndicatorRow {
+  kind: "hidden-indicator"
+  path: string
+  ancestors: readonly number[]
+  stickable: false
+  stickyTop: number
+  count: number
+  revealed: boolean
+  togglePath: string
+}
+
+export interface FlattenInput {
+  index: GraphIndex
+  groups: DomainGroup[]
+  direction: Direction
+  visibleIds: ReadonlySet<NodeId>
+  isExpanded: (path: string) => boolean
+  isRevealed: (path: string) => boolean
+  headerHeight: number
+  rowHeight: number
+}
+
+export function flattenTree(input: FlattenInput): FlatRow[] {
+  const out: FlatRow[] = []
+  for (const group of input.groups) emitGroup(group, input, out)
+  return out
+}
+
+function emitGroup(group: DomainGroup, input: FlattenInput, out: FlatRow[]) {
+  const sectionPath = `domain:${group.domain.key}`
+  const expanded = input.isExpanded(sectionPath)
+  const traces = group.rootIds
+    .map((id) => traceFrom(input.index, id, input.direction))
+    .filter((t): t is TraceNode => t !== null)
+
+  const headerIndex = out.length
+  out.push({
+    kind: "domain-header",
+    path: sectionPath,
+    ancestors: [],
+    stickable: true,
+    stickyTop: 0,
+    subtreeSize: 1,
+    label: group.domain.label,
+    count: traces.length,
+    expanded,
+  })
+
+  if (!expanded) return
+
+  const domainPrefix = domainPrefixFromLabel(group.domain.label)
+  const rootAncestors: readonly number[] = [headerIndex]
+  for (const trace of traces) {
+    emitTrace(
+      trace,
+      `${group.domain.key}/${trace.id}`,
+      0,
+      rootAncestors,
+      domainPrefix,
+      input,
+      out
+    )
+  }
+
+  ;(out[headerIndex] as DomainHeaderRow).subtreeSize = out.length - headerIndex
+}
+
+function emitTrace(
+  trace: TraceNode,
+  path: string,
+  depth: number,
+  ancestors: readonly number[],
+  domainPrefix: string,
+  input: FlattenInput,
+  out: FlatRow[]
+) {
+  const expanded = input.isExpanded(path)
+  const hasChildren = trace.children.length > 0
+  const stickable = hasChildren && expanded
+  const stickyTop = input.headerHeight + depth * input.rowHeight
+  const rowIndex = out.length
+
+  out.push({
+    kind: "trace-row",
+    path,
+    ancestors,
+    stickable,
+    stickyTop,
+    subtreeSize: 1,
+    depth,
+    trace,
+    domainPrefix,
+    hasChildren,
+    expanded,
+  })
+
+  if (!stickable) return
+
+  const visibleChildren = trace.children.filter((c) =>
+    input.visibleIds.has(c.id)
+  )
+  const revealed = input.isRevealed(path)
+  const childrenToRender = revealed ? trace.children : visibleChildren
+  const childAncestors: readonly number[] = [...ancestors, rowIndex]
+
+  childrenToRender.forEach((child, idx) => {
+    emitTrace(
+      child,
+      `${path}/${child.id}:${idx}`,
+      depth + 1,
+      childAncestors,
+      domainPrefix,
+      input,
+      out
+    )
+  })
+
+  const hiddenCount = trace.children.length - visibleChildren.length
+  if (hiddenCount > 0) {
+    out.push({
+      kind: "hidden-indicator",
+      path: `${path}#hidden`,
+      ancestors: childAncestors,
+      stickable: false,
+      stickyTop: input.headerHeight + (depth + 1) * input.rowHeight,
+      count: hiddenCount,
+      revealed,
+      togglePath: path,
+    })
+  }
+
+  ;(out[rowIndex] as TraceRowItem).subtreeSize = out.length - rowIndex
+}

package/src/domain/graph.ts

@@ -0,0 +1,42 @@
+import type { Edge } from "./edge"
+import type { Node, NodeKind } from "./node"
+
+export type Graph = { nodes: Node[]; edges: Edge[] }
+
+export type NodeId = `${NodeKind}:${string}`
+
+export function nodeId(kind: NodeKind, name: string): NodeId {
+  return `${kind}:${name}`
+}
+
+export interface GraphIndex {
+  graph: Graph
+  nodesById: ReadonlyMap<NodeId, Node>
+  outgoing: ReadonlyMap<NodeId, Edge[]>
+  incoming: ReadonlyMap<NodeId, Edge[]>
+}
+
+export function indexGraph(graph: Graph): GraphIndex {
+  const nodesById = new Map<NodeId, Node>()
+  const outgoing = new Map<NodeId, Edge[]>()
+  const incoming = new Map<NodeId, Edge[]>()
+
+  for (const node of graph.nodes) {
+    nodesById.set(nodeId(node.type, node.name), node)
+  }
+
+  for (const edge of graph.edges) {
+    const fromId = nodeId(edge.from.type, edge.from.name)
+    const toId = nodeId(edge.to.type, edge.to.name)
+
+    const outList = outgoing.get(fromId) ?? []
+    outList.push(edge)
+    outgoing.set(fromId, outList)
+
+    const inList = incoming.get(toId) ?? []
+    inList.push(edge)
+    incoming.set(toId, inList)
+  }
+
+  return { graph, nodesById, outgoing, incoming }
+}

package/src/domain/node.ts

@@ -0,0 +1,28 @@
+type Source = { file: string; start: number }
+
+export type Node =
+  | {
+      type: "event"
+      name: string
+      meta: { alias: string; base: string }
+      source: Source
+    }
+  | { type: "command"; name: string; meta: { base: string }; source: Source }
+  | { type: "saga"; name: string; source: Source }
+  | { type: "aggregate"; name: string; source: Source }
+  | {
+      type: "projection"
+      name: string
+      meta: { alias: string }
+      source: Source
+    }
+
+export type NodeKind = Node["type"]
+
+export const NODE_KINDS = [
+  "event",
+  "command",
+  "saga",
+  "aggregate",
+  "projection",
+] as const satisfies readonly NodeKind[]

package/src/domain/roots.ts

@@ -0,0 +1,18 @@
+import type { Direction } from "./direction"
+import type { GraphIndex, NodeId } from "./graph"
+import type { Node } from "./node"
+import { nodeId } from "./graph"
+
+export function effectiveRoots(
+  index: GraphIndex,
+  direction: Direction
+): NodeId[] {
+  return index.graph.nodes
+    .filter((n) => isRoot(n, direction))
+    .map((n) => nodeId(n.type, n.name))
+}
+
+function isRoot(node: Node, direction: Direction): boolean {
+  if (direction === "forward") return node.type === "event"
+  return node.type !== "event"
+}

package/src/domain/traversal.ts

@@ -0,0 +1,60 @@
+import type { Edge } from "./edge"
+import { type GraphIndex, nodeId, type NodeId } from "./graph"
+import type { Node } from "./node"
+import type { Direction } from "./direction"
+
+export interface TraceNode {
+  id: NodeId
+  node: Node
+  edge: Edge | null
+  children: TraceNode[]
+}
+
+export function traceFrom(
+  index: GraphIndex,
+  rootId: NodeId,
+  direction: Direction = "forward",
+  maxDepth = 100
+): TraceNode | null {
+  const root = index.nodesById.get(rootId)
+  if (!root) return null
+  return build(index, root, null, direction, new Set(), maxDepth)
+}
+
+function build(
+  index: GraphIndex,
+  node: Node,
+  edge: Edge | null,
+  direction: Direction,
+  seen: Set<NodeId>,
+  remaining: number
+): TraceNode {
+  const id = nodeId(node.type, node.name)
+  if (remaining <= 0 || seen.has(id)) {
+    return { id, node, edge, children: [] }
+  }
+  const next = new Set(seen).add(id)
+  const edges = stepEdges(index, id, direction)
+  const children: TraceNode[] = []
+  for (const e of edges) {
+    const peer = peerOf(e, direction)
+    const peerId = nodeId(peer.type, peer.name)
+    const target = index.nodesById.get(peerId)
+    if (!target) continue
+    children.push(build(index, target, e, direction, next, remaining - 1))
+  }
+  return { id, node, edge, children }
+}
+
+function stepEdges(
+  index: GraphIndex,
+  id: NodeId,
+  direction: Direction
+): Edge[] {
+  if (direction === "forward") return index.outgoing.get(id) ?? []
+  return index.incoming.get(id) ?? []
+}
+
+function peerOf(edge: Edge, direction: Direction) {
+  return direction === "forward" ? edge.to : edge.from
+}