@likec4/core 1.30.0 → 1.32.0

package/src/compute-view/utils/topological-sort.ts

@@ -2,8 +2,8 @@ import Graph from 'graphology'
 import { topologicalSort as topsort } from 'graphology-dag/topological-sort'
 import willCreateCycle from 'graphology-dag/will-create-cycle'
 import { forEach, map, partition, pipe, takeWhile } from 'remeda'
-import { invariant, nonNullable } from '../../errors'
-import type { ComputedEdge, ComputedNode, Fqn, NodeId } from '../../types'
+import type { AnyAux, ComputedEdge, ComputedNode, NodeId } from '../../types'
+import { invariant, nonNullable } from '../../utils'
 import { ancestorsOfNode } from './ancestorsOfNode'
 
 /**
@@ -41,7 +41,7 @@ function ensureParentsFirst<T extends { id: string; parent: string | null }>(
 /**
  * Side effect, mutates node.children field to preserve same order as in the input
  */
-function updateChildren(nodes: ComputedNode[]) {
+function updateChildren<A extends AnyAux = AnyAux>(nodes: ComputedNode<A>[]): ComputedNode<A>[] {
   nodes.forEach(parent => {
     if (parent.children.length > 0) {
       parent.children = nodes.reduce((acc, n) => {
@@ -55,15 +55,15 @@ function updateChildren(nodes: ComputedNode[]) {
   return nodes
 }
 
-type TopologicalSortParam = {
-  nodes: ReadonlyMap<Fqn, ComputedNode>
-  edges: Iterable<ComputedEdge>
+type TopologicalSortParam<A extends AnyAux> = {
+  nodes: ReadonlyMap<string, ComputedNode<A>>
+  edges: Iterable<ComputedEdge<A>>
 }
-export function topologicalSort(
-  param: TopologicalSortParam,
+export function topologicalSort<A extends AnyAux>(
+  param: TopologicalSortParam<A>,
 ): {
-  nodes: ComputedNode[]
-  edges: ComputedEdge[]
+  nodes: ComputedNode<A>[]
+  edges: ComputedEdge<A>[]
 } {
   let nodes = ensureParentsFirst([...param.nodes.values()])
   let edges = [...param.edges]
@@ -74,7 +74,7 @@ export function topologicalSort(
     }
   }
 
-  const getNode = (id: Fqn) => nonNullable(param.nodes.get(id))
+  const getNode = (id: string) => nonNullable(param.nodes.get(id))
   // const nodeLevel = (id: string) => getNode(id).level + 1
   //
 
@@ -140,9 +140,9 @@ export function topologicalSort(
   //   // }
   //   // return Math.min(nodes.indexOf(a.source), nodes.indexOf(a.target)) - Math.min(nodes.indexOf(b.source), nodes.indexOf(b.target))
   // })
-  const sortedEdges = [] as ComputedEdge[]
+  const sortedEdges = [] as ComputedEdge<A>[]
 
-  const addEdgeToGraph = (edge: ComputedEdge) => {
+  const addEdgeToGraph = (edge: ComputedEdge<A>) => {
     g.mergeNode(edge.source)
     g.mergeNode(edge.target)
     sortedEdges.push(edge)
@@ -221,7 +221,7 @@ export function topologicalSort(
   // }
 
   const sortedIds = topsort(g)
-  let sorted = [] as ComputedNode[]
+  let sorted = [] as ComputedNode<A>[]
   let unsorted = nodes.slice()
   for (const sortedId of sortedIds) {
     const indx = unsorted.findIndex(n => n.id === sortedId)

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

@@ -1,12 +1,12 @@
 import { isTruthy, map, mapToObj, pick, pipe } from 'remeda'
 import type { SetOptional } from 'type-fest'
 import type { ComputedView } from '../../types'
-import { objectHash } from '../../utils/object-hash'
+import { objectHash } from '../../utils'
 
 export function calcViewLayoutHash<V extends ComputedView>(view: SetOptional<V, 'hash'>): V {
   const tohash = {
     id: view.id,
-    __: view.__ ?? 'element',
+    __: view._type ?? 'element',
     autoLayout: view.autoLayout,
     nodes: pipe(
       view.nodes,

package/src/compute-view/utils/with-readable-edges.ts

@@ -1,12 +1,14 @@
 import { map, mapToObj, mapValues, omit } from 'remeda'
-import type { ComputedLikeC4ModelData } from '../../types'
-import type { ComputedView, EdgeId } from '../../types/view'
+import type { AnyAux, ComputedLikeC4ModelData, ComputedView, EdgeId } from '../../types'
 
 /**
  * Convert hashed edge ids to human-readable
  * Mostly for testing purposes
  */
-export function withReadableEdges<T extends ComputedView>({ edges, nodes, ...view }: T, separator = ':'): T & {
+export function withReadableEdges<V extends ComputedView<any>>(
+  { edges, nodes, ...view }: V,
+  separator = ':',
+): V & {
   nodeIds: string[]
   edgeIds: string[]
 } {
@@ -28,9 +30,11 @@ export function withReadableEdges<T extends ComputedView>({ edges, nodes, ...vie
   } as any
 }
 
-export function viewsWithReadableEdges<M extends ComputedLikeC4ModelData>({ views, ...model }: M): M {
+export function viewsWithReadableEdges<A extends AnyAux>(
+  { views, ...model }: ComputedLikeC4ModelData<A>,
+): ComputedLikeC4ModelData<A> {
   return {
     ...model,
-    views: mapValues(views, v => omit(withReadableEdges(v), ['nodeIds', 'edgeIds'])),
+    views: mapValues(views as Record<string, ComputedView<A>>, v => omit(withReadableEdges(v), ['nodeIds', 'edgeIds'])),
   } as any
 }

package/src/index.ts

@@ -5,38 +5,6 @@ export {
   RelationshipColors,
 } from './theme'
 
-export {
-  invariant,
-  nonexhaustive,
-  nonNullable,
-} from './errors'
-
-export {
-  type AnyAux,
-  type Aux,
-  Connection,
-  ConnectionModel,
-  DeployedInstanceModel,
-  DeploymentConnectionModel,
-  type DeploymentElementModel,
-  DeploymentNodeModel,
-  DeploymentRelationModel,
-  EdgeModel,
-  ElementModel,
-  LikeC4DeploymentModel,
-  LikeC4Model,
-  LikeC4ViewModel,
-  NodeModel,
-  RelationshipModel,
-} from './model'
 export * from './types'
 
 export * from './utils'
-
-export {
-  computeView,
-  computeViews,
-  unsafeComputeView,
-} from './compute-view'
-
-export type { ComputeViewResult } from './compute-view'