@likec4/core 1.40.0 → 1.42.0

package/src/compute-view/memory/ops.ts

@@ -1,43 +0,0 @@
-import { Connection } from '../../model'
-import { isAncestor, sortParentsFirst } from '../../utils'
-import { toArray } from '../../utils/iterable'
-import { DefaultMap } from '../../utils/mnemonist'
-import type { AnyCtx, ComputeMemory, CtxElement } from './_types'
-
-export function treeFromMemoryState<T extends AnyCtx, M extends ComputeMemory<T> = ComputeMemory<T>>(
-  memory: M,
-  filter: 'all' | 'final' = 'final',
-) {
-  const sorted = sortParentsFirst(toArray(filter === 'final' ? memory.final : memory.elements))
-  const connected = new Set(memory.connections.flatMap(c => [c.source, c.target]))
-  const root = new Set(sorted)
-  const parents = new DefaultMap<CtxElement<T>, CtxElement<T> | null>(() => null)
-  const children = sorted.reduce((acc, parent, index, all) => {
-    acc.set(
-      parent,
-      all
-        .slice(index + 1)
-        .filter(e => isAncestor(parent, e))
-        .map(e => {
-          root.delete(e)
-          return e
-        })
-        .reduce((acc, el) => {
-          if (!acc.some(e => isAncestor(e, el))) {
-            acc.push(el)
-            parents.set(el, parent)
-          }
-          return acc
-        }, [] as CtxElement<T>[]),
-    )
-    return acc
-  }, new DefaultMap<CtxElement<T>, ReadonlyArray<CtxElement<T>>>(() => []))
-
-  return {
-    root: root as ReadonlySet<CtxElement<T>>,
-    connected: connected as ReadonlySet<CtxElement<T>>,
-    hasInOut: (el: CtxElement<T>) => memory.connections.some(Connection.isAnyInOut(el.id)),
-    parent: (el: CtxElement<T>) => parents.get(el),
-    children: (el: CtxElement<T>) => children.get(el),
-  }
-}

package/src/compute-view/relationships-view/_types.ts

@@ -1,16 +0,0 @@
-import type { ElementModel, RelationshipModel } from '../../model'
-import type { AnyAux, Unknown } from '../../types'
-
-// type Pair = {
-//   left: ReadonlySet<ElementModel>
-//   relationships: ReadonlySet<RelationshipModel>
-//   right: ReadonlySet<ElementModel>
-// }
-
-export type RelationshipsViewData<M extends AnyAux = Unknown> = {
-  incomers: ReadonlySet<ElementModel<M>>
-  incoming: ReadonlySet<RelationshipModel<M>>
-  subjects: ReadonlySet<ElementModel<M>>
-  outgoing: ReadonlySet<RelationshipModel<M>>
-  outgoers: ReadonlySet<ElementModel<M>>
-}

package/src/compute-view/relationships-view/compute.ts

@@ -1,159 +0,0 @@
-import { pipe } from 'remeda'
-import type { ElementModel, LikeC4Model, LikeC4ViewModel, RelationshipModel } from '../../model'
-import type { AnyAux, aux } from '../../types'
-import { invariant } from '../../utils'
-import { isDescendantOf, sortParentsFirst } from '../../utils/fqn'
-import { ifilter, imap, toArray, toSet } from '../../utils/iterable'
-import type { RelationshipsViewData } from './_types'
-import { treeFromElements } from './utils'
-
-const finalize = <M extends AnyAux>(
-  elements: Set<ElementModel<M>>,
-  explicits: Set<ElementModel<M>>,
-): Set<ElementModel<M>> => {
-  if (elements.size > 2 && explicits.size !== elements.size) {
-    return new Set(sortParentsFirst([
-      ...treeFromElements(elements).flatten(),
-      ...explicits,
-    ]))
-  }
-  if (elements.size > 1) {
-    return new Set(sortParentsFirst([...elements]))
-  }
-  return elements
-}
-
-function computeRelationships<const M extends AnyAux>(
-  subject: ElementModel<M>,
-  others: Set<ElementModel<M>>,
-  relationships: {
-    incoming: ReadonlyArray<RelationshipModel<M>>
-    outgoing: ReadonlyArray<RelationshipModel<M>>
-  },
-): Omit<RelationshipsViewData<M>, 'subjectExistsInScope'> {
-  const isOther = (e: ElementModel<M>) => others.has(e)
-  let subjects = new Set([subject])
-  const explicits = {
-    incomers: new Set<ElementModel<M>>(),
-    subjects: new Set([subject]),
-    outgoers: new Set<ElementModel<M>>(),
-  }
-
-  // Iterate over incoming and outgoing relationships
-  // and add the source and target elements to appropriate sets.
-  // If element is deeper in the hierarchy - add all ancestors until that is a sibling of the subject
-  let incomers = new Set(relationships.incoming.flatMap((r) => {
-    explicits.subjects.add(r.target)
-    explicits.incomers.add(r.source)
-
-    subjects.add(r.target)
-    if (r.target !== subject) {
-      let target = r.target.parent
-      while (target && target !== subject) {
-        subjects.add(target)
-        target = target.parent
-      }
-    }
-
-    let source = r.source
-    const incomerBranch = [] as ElementModel<M>[]
-    while (true) {
-      incomerBranch.push(source)
-      if (isOther(source) || !source.parent) {
-        break
-      }
-      source = source.parent
-    }
-    return incomerBranch
-  }))
-
-  let outgoers = new Set(relationships.outgoing.flatMap((r) => {
-    explicits.subjects.add(r.source)
-    explicits.outgoers.add(r.target)
-
-    subjects.add(r.source)
-    if (r.source !== subject) {
-      let source = r.source.parent
-      while (source && source !== subject) {
-        subjects.add(source)
-        source = source.parent
-      }
-    }
-
-    let target = r.target
-    const outgoerBranch = [] as ElementModel<M>[]
-    while (true) {
-      outgoerBranch.push(target)
-      if (isOther(target) || !target.parent) {
-        break
-      }
-      target = target.parent
-    }
-    return outgoerBranch
-  }))
-
-  return {
-    incomers: finalize(incomers, explicits.incomers),
-    incoming: new Set(relationships.incoming),
-    subjects: finalize(subjects, explicits.subjects),
-    outgoing: new Set(relationships.outgoing),
-    outgoers: finalize(outgoers, explicits.outgoers),
-  }
-}
-
-export function computeRelationshipsView<M extends AnyAux>(
-  subjectId: aux.ElementId<M>,
-  likec4model: LikeC4Model<M>,
-  scopeViewId: aux.ViewId<M> | null,
-  scope: 'global' | 'view' = 'global',
-): RelationshipsViewData<M> {
-  let subjectExistsInScope = true
-  const view = scopeViewId ? likec4model.findView(scopeViewId) : null
-  if (scope === 'view') {
-    invariant(
-      view,
-      'Scope view id is required when scope is "view"',
-    )
-    return computeScopedRelationshipsView(subjectId, view, likec4model)
-  }
-
-  const subject = likec4model.element(subjectId)
-  const subjectSiblings = toSet(subject.ascendingSiblings())
-  return computeRelationships(
-    subject,
-    subjectSiblings,
-    {
-      incoming: [...subject.incoming()],
-      outgoing: [...subject.outgoing()],
-    },
-  )
-}
-
-function computeScopedRelationshipsView<M extends AnyAux>(
-  subjectId: NoInfer<aux.ElementId<M>>,
-  view: LikeC4ViewModel<M>,
-  likec4model: LikeC4Model<M>,
-): RelationshipsViewData<M> {
-  const subject = likec4model.element(subjectId)
-  let relationships = {
-    incoming: toArray(ifilter(subject.incoming(), (r) => view.includesRelation(r.id))),
-    outgoing: toArray(ifilter(subject.outgoing(), (r) => view.includesRelation(r.id))),
-  }
-
-  const isDescendant = isDescendantOf(subject)
-
-  const others = new Set([
-    ...subject.ascendingSiblings(),
-    ...pipe(
-      view.elements(),
-      imap((e) => e.element),
-      ifilter((e): e is ElementModel<M> => e !== subject && isDescendant(e)),
-    ),
-  ])
-
-  return computeRelationships(
-    subject,
-    others,
-    relationships,
-  )
-}

package/src/compute-view/relationships-view/index.ts

@@ -1,3 +0,0 @@
-export type { RelationshipsViewData } from './_types'
-export { computeRelationshipsView } from './compute'
-export { treeFromElements } from './utils'

package/src/compute-view/relationships-view/layout.ts

@@ -1,357 +0,0 @@
-import dagre, { type EdgeConfig, type GraphLabel } from '@dagrejs/dagre'
-import { concat, filter, forEachObj, groupBy, map, mapToObj, pipe, prop, reduce, tap } from 'remeda'
-import type { ElementModel } from '../../model/ElementModel'
-import type { RelationshipModel } from '../../model/RelationModel'
-import type { DiagramNode, DiagramView, Fqn, NodeId } from '../../types'
-import { invariant, sortParentsFirst } from '../../utils'
-import { toArray } from '../../utils/iterable'
-import { DefaultMap } from '../../utils/mnemonist'
-import type { RelationshipsViewData } from './_types'
-import { treeFromElements } from './utils'
-
-/**
- * All constants related to the layout
- */
-const Sizes = {
-  dagre: {
-    ranksep: 60,
-    nodesep: 35,
-    edgesep: 25,
-  } satisfies GraphLabel,
-  edgeLabel: {
-    width: 120,
-    height: 10,
-    minlen: 1,
-    weight: 1,
-  } satisfies EdgeConfig,
-
-  emptyNodeOffset: 120,
-
-  nodeWidth: 320,
-  nodeHeight: 180,
-
-  // Spacer between elements in a compound node
-  // 0 means no spacer
-  spacerHeight: 0,
-
-  compound: {
-    labelHeight: 1,
-    paddingTop: 60,
-    paddingBottom: 32,
-  },
-}
-type NodeData = {
-  portId: string
-  element: ElementModel<any>
-  isCompound: boolean
-}
-function createGraph() {
-  const g = new dagre.graphlib.Graph<NodeData>({
-    directed: true,
-    compound: true,
-    multigraph: true,
-  })
-  g.setGraph({
-    ...Sizes.dagre,
-    rankdir: 'LR',
-  })
-  g.setDefaultEdgeLabel(() => ({ ...Sizes.edgeLabel }))
-  g.setDefaultNodeLabel(() => ({}))
-
-  // columns.reduce((prev, column) => {
-  //   const c = graphColumn(column)
-  //   g.setNode(c.id, {})
-  //   g.setNode(c.anchor, { width: 40, height: 2 })
-  //   g.setParent(c.anchor, c.id)
-  //   if (prev) {
-  //     g.setEdge(prev, c.anchor, {
-  //       width: 0
-  //     })
-  //   }
-  //   return c.anchor
-  // }, null as string | null)
-
-  return g
-}
-type G = ReturnType<typeof createGraph>
-
-const PortSuffix = '-port'
-
-function createNodes(
-  prefix: string,
-  elements: ReadonlySet<ElementModel<any>>,
-  g: G,
-) {
-  const graphNodes = new DefaultMap<Fqn, { id: string; portId: string }>(key => ({
-    id: `${prefix}-${key}`,
-    portId: `${prefix}-${key}`,
-  }))
-  const tree = treeFromElements(elements)
-  for (const element of tree.sorted) {
-    const isCompound = tree.children(element).length > 0
-    const fqn = element.id
-    const id = `${prefix}-${fqn}`
-    const portId = isCompound ? `${id}${PortSuffix}` : id
-    graphNodes.set(fqn, {
-      id,
-      portId,
-    })
-    g.setNode(id, {
-      element,
-      isCompound,
-      portId,
-      width: Sizes.nodeWidth,
-      height: Sizes.nodeHeight,
-    })
-
-    if (isCompound) {
-      g.setNode(portId, {
-        element,
-        portId,
-        isCompound,
-        width: Sizes.nodeWidth - Sizes.dagre.ranksep,
-        height: Sizes.compound.labelHeight,
-      })
-      g.setParent(portId, id)
-      // g.node(id).padding = 60
-    }
-
-    const parent = tree.parent(element)
-    if (parent) {
-      g.setParent(id, `${prefix}-${parent.id}`)
-    }
-  }
-  return {
-    ...tree,
-    byId: (id: string) => {
-      const element = tree.byId(id)
-      const graph = graphNodes.get(element.id)
-      return {
-        element,
-        graph,
-      }
-    },
-    graphNodes,
-  }
-}
-
-/**
- * Apply dagre layout to the graph
- * And return a function to get node bounds for xyflow
- */
-function applyDagreLayout(g: G) {
-  dagre.layout(g, {
-    // disableOptimalOrderHeuristic: true,
-  })
-  return (nodeId: string) => {
-    const node = g.node(nodeId)
-    const { x, y, width, height } = node
-    return {
-      position: {
-        x: x - Math.round(width / 2),
-        y: y - Math.round(height / 2),
-      },
-      width,
-      height,
-    }
-  }
-}
-
-export function layoutRelationshipsView(data: RelationshipsViewData): Pick<DiagramView, 'nodes' | 'edges' | 'bounds'> {
-  const g = createGraph()
-
-  const incomers = createNodes('in', data.incomers, g),
-    subjects = createNodes('subject', data.subjects, g),
-    outgoers = createNodes('out', data.outgoers, g)
-
-  const edges = [] as Array<{
-    name: string
-    source: string // node id
-    target: string // node id
-    relations: RelationshipModel[]
-  }>
-
-  pipe(
-    concat(
-      pipe(
-        toArray(data.incoming),
-        map(r => ({
-          id: r.source.id,
-          source: incomers.byId(r.source.id).graph,
-          target: subjects.byId(r.target.id).graph,
-          relation: r,
-        })),
-        // Sort by source
-        sortParentsFirst,
-      ),
-      pipe(
-        toArray(data.outgoing),
-        map(r => ({
-          id: r.target.id,
-          source: subjects.byId(r.source.id).graph,
-          target: outgoers.byId(r.target.id).graph,
-          relation: r,
-        })),
-        // Sort by target
-        sortParentsFirst,
-      ),
-    ),
-    map(r => ({
-      ...r,
-      expr: `${r.source.id}->${r.target.id}`,
-    })),
-    // Group if same source and target
-    groupBy(prop('expr')),
-    forEachObj((grouped) => {
-      const source = grouped[0].source
-      const target = grouped[0].target
-      const name = grouped[0].expr
-
-      g.setEdge(source.portId, target.portId, {
-        ...Sizes.edgeLabel,
-      }, name)
-      edges.push({
-        name,
-        source: source.id,
-        target: target.id,
-        relations: map(grouped, prop('relation')),
-      })
-    }),
-  )
-
-  // Grow nodes with more than 2 ports
-  for (const subjectNode of subjects.graphNodes.values()) {
-    const nodeId = subjectNode.id
-    const node = g.node(nodeId)
-    if (node.isCompound) {
-      continue
-    }
-    const edgeCount = Math.max(g.inEdges(nodeId)?.length ?? 0, g.outEdges(nodeId)?.length ?? 0)
-    if (edgeCount > 2) {
-      node.height = node.height + (edgeCount - 3) * 14
-    }
-  }
-
-  const dagreBounds = applyDagreLayout(g)
-
-  const nodeIds = [
-    ...incomers.graphNodes.values(),
-    ...subjects.graphNodes.values(),
-    ...outgoers.graphNodes.values(),
-  ]
-
-  // Calculate bounds for all nodes except compounds
-  // We shrink compounds to fit their children
-  const _calculatedNodeBounds = pipe(
-    nodeIds,
-    // Compound nodes have different portId
-    filter(n => n.id === n.portId),
-    mapToObj(n => [n.id, dagreBounds(n.id)]),
-  )
-
-  function nodeBounds(nodeId: string): ReturnType<typeof dagreBounds> {
-    return _calculatedNodeBounds[nodeId] ??= pipe(
-      g.children(nodeId) as string[] | undefined ?? [],
-      filter(id => !id.endsWith(PortSuffix)),
-      map(id => nodeBounds(id)),
-      tap(bounds => {
-        invariant(bounds.length > 0, `Node ${nodeId} has no nested nodes`)
-      }),
-      reduce((acc, bounds) => {
-        return {
-          minY: Math.min(acc.minY, bounds.position.y),
-          maxY: Math.max(acc.maxY, bounds.position.y + bounds.height),
-        }
-      }, { minY: Infinity, maxY: -Infinity }),
-      ({ minY, maxY }) => {
-        const {
-          position: { x },
-          width,
-        } = dagreBounds(nodeId)
-        minY = minY - Sizes.compound.paddingTop
-        maxY = maxY + Sizes.compound.paddingBottom
-
-        return {
-          position: {
-            x,
-            y: minY,
-          },
-          width,
-          height: maxY - minY,
-        }
-      },
-    )
-  }
-
-  function nodeLevel(nodeId: string): number {
-    const parent = g.parent(nodeId)
-    if (parent) {
-      return nodeLevel(parent) + 1
-    }
-    return 0
-  }
-  function nodeDepth(nodeId: string): number {
-    const children = g.children(nodeId) as string[] | undefined ?? []
-    if (children.length === 0) {
-      return 0
-    }
-    return 1 + Math.max(...children.map(nodeDepth))
-  }
-
-  const nodes = nodeIds.map(({ id }): DiagramNode => {
-    const { element } = g.node(id)
-    let { position, width, height } = nodeBounds(id)
-    const parentId = g.parent(id)
-    // if (parentId) {
-    //   const parentPos = nodeBounds(parentId).position
-    //   position = {
-    //     x: position.x - parentPos.x,
-    //     y: position.y - parentPos.y,
-    //   }
-    // }
-    const children = (g.children(id) as NodeId[] | undefined ?? []).filter(c => !c.endsWith(PortSuffix))
-
-    return {
-      id: id as NodeId,
-      parent: parentId as NodeId ?? null,
-      title: element.title,
-      ...position,
-      position: [position.x, position.y],
-      description: element.description?.$source ?? null,
-      technology: element.technology,
-      tags: [],
-      links: null,
-      color: element.color,
-      shape: element.shape,
-      modelRef: element.id,
-      kind: element.kind,
-      level: nodeLevel(id),
-      labelBBox: {
-        x: position.x,
-        y: position.y,
-        width: width,
-        height: height,
-      },
-      style: {
-        ...element.$element.style,
-      },
-      inEdges: [],
-      outEdges: [],
-      ...(children.length > 0 && { depth: nodeDepth(id) }),
-      children,
-      width,
-      height,
-    }
-  })
-
-  return {
-    bounds: {
-      x: 0,
-      y: 0,
-      width: g.graph().width ?? 100,
-      height: g.graph().height ?? 100,
-    },
-    nodes,
-    edges: [],
-  }
-}

package/src/compute-view/relationships-view/utils.ts

@@ -1,73 +0,0 @@
-import type { ElementModel } from '../../model/ElementModel'
-import type { AnyAux, aux } from '../../types'
-import { nonNullable } from '../../utils'
-import { isAncestor, isDescendantOf, sortParentsFirst } from '../../utils/fqn'
-import { DefaultMap } from '../../utils/mnemonist'
-
-export function treeFromElements<M extends AnyAux>(elements: Iterable<ElementModel<M>>) {
-  const sorted = sortParentsFirst([...elements]) as ReadonlyArray<ElementModel<M>>
-  const root = new Set(sorted)
-  const map = new Map(sorted.map(e => [e._literalId, e]))
-  const parents = new DefaultMap<ElementModel<M>, ElementModel<M> | null>(() => null)
-  const children = sorted.reduce((acc, parent, index, all) => {
-    acc.set(
-      parent,
-      all
-        .slice(index + 1)
-        .filter(isDescendantOf(parent))
-        .map(e => {
-          root.delete(e)
-          return e
-        })
-        .reduce((acc, el) => {
-          if (!acc.some(isAncestor(el))) {
-            acc.push(el)
-            parents.set(el, parent)
-          }
-          return acc
-        }, [] as ElementModel<M>[]),
-    )
-    return acc
-  }, new DefaultMap<ElementModel<M>, ElementModel<M>[]>(() => []))
-
-  return {
-    sorted,
-    byId: (id: aux.ElementId<M>): ElementModel<M> => nonNullable(map.get(id), `Element not found by id: ${id}`),
-    root: root as ReadonlySet<ElementModel<M>>,
-    parent: (el: ElementModel<M>): ElementModel<M> | null => parents.get(el),
-    children: (el: ElementModel<M>): ReadonlyArray<ElementModel<M>> => children.get(el),
-    /**
-     * Flattens the tree structure by removing redundant hierarchy levels.
-     * @example
-     *   A
-     *   └── B
-     *       ├── C
-     *       │   └── D
-     *       │       └── E
-     *       └── F
-     *           └── G
-     * becomes
-     *   A
-     *   ├── C
-     *   │   └── E
-     *   └── F
-     *       └── G
-     */
-    flatten: (): Set<ElementModel<M>> => {
-      return new Set([
-        ...root,
-        ...sorted.reduce((acc, el) => {
-          const _children = children.get(el)
-          if (_children.length === 0) {
-            acc.push(el)
-            return acc
-          }
-          if (_children.length > 1) {
-            acc.push(..._children)
-          }
-          return acc
-        }, [] as ElementModel<M>[]),
-      ])
-    },
-  }
-}

package/src/compute-view/utils/ancestorsOfNode.ts

@@ -1,19 +0,0 @@
-import type { AnyAux, ComputedNode } from '../../types'
-import { nonNullable } from '../../utils'
-
-/**
- * Returns the ancestors of given computed node, starting with the direct parent and ending with the root node.
- */
-export function ancestorsOfNode<A extends AnyAux>(
-  node: ComputedNode<A>,
-  nodes: ReadonlyMap<string, ComputedNode<A>>,
-): ReadonlyArray<ComputedNode<A>> {
-  const ancestors = [] as ComputedNode<A>[]
-  let parentId = node.parent
-  while (parentId) {
-    const parentNode = nonNullable(nodes.get(parentId), `Parent node ${parentId} not found`)
-    ancestors.push(parentNode)
-    parentId = parentNode.parent
-  }
-  return ancestors
-}