@likec4/core 1.41.0 → 1.42.1

package/src/compute-view/utils/merge-props-from-relationships.ts

@@ -1,161 +0,0 @@
-import { isDeepEqual, isTruthy, only, pickBy, pipe, reduce, unique } from 'remeda'
-import type {
-  AnyAux,
-  aux,
-  Color,
-  DeploymentRelationship,
-  Link,
-  NonEmptyArray,
-  Relationship,
-  RelationshipArrowType,
-  RelationshipLineType,
-  scalar,
-} from '../../types'
-import { isNonEmptyArray } from '../../utils'
-
-function pickRelationshipProps<A extends AnyAux>(relation: Relationship<A> | DeploymentRelationship<A>): {
-  title?: string
-  description?: scalar.MarkdownOrString | null
-  technology: string | null
-  kind: aux.RelationKind<A> | null
-  color: Color | null
-  line: RelationshipLineType | null
-  head: RelationshipArrowType | null
-  tail: RelationshipArrowType | null
-  navigateTo: aux.StrictViewId<A> | null
-} {
-  const {
-    title,
-    description = null,
-    technology = null,
-    kind = null,
-    color = null,
-    line = null,
-    head = null,
-    tail = null,
-    navigateTo = null,
-  } = relation
-  return {
-    // Pick description only if title is present
-    ...(title && {
-      title,
-      description,
-    }),
-    technology,
-    kind: kind as aux.RelationKind<A> | null,
-    color,
-    line,
-    head,
-    tail,
-    navigateTo: navigateTo as aux.StrictViewId<A> | null,
-  }
-}
-
-export type MergedRelationshipProps<A extends AnyAux> = {
-  title?: string | null
-  description?: scalar.MarkdownOrString | null
-  technology?: string
-  kind?: aux.RelationKind<A>
-  color?: Color
-  line?: RelationshipLineType
-  head?: RelationshipArrowType
-  tail?: RelationshipArrowType
-  navigateTo?: aux.StrictViewId<A>
-  tags?: NonEmptyArray<aux.Tag<A>>
-  links?: NonEmptyArray<Link>
-}
-
-/**
- * Merges properties from multiple relationships into a single object.
- * @param relations - The relationships to merge.
- * @param prefer - The relationship to prefer when merging.
- */
-export function mergePropsFromRelationships<A extends AnyAux>(
-  relations: Array<Relationship<A> | DeploymentRelationship<A>>,
-  prefer?: Relationship<A> | DeploymentRelationship<A>,
-): MergedRelationshipProps<A> {
-  const allprops = pipe(
-    relations,
-    reduce(
-      (acc, r) => {
-        if (isTruthy(r.title) && !acc.title.includes(r.title)) {
-          acc.title.push(r.title)
-        }
-        if (isTruthy(r.description) && !acc.description.some(isDeepEqual(r.description))) {
-          acc.description.push(r.description)
-        }
-        if (isTruthy(r.technology) && !acc.technology.includes(r.technology)) {
-          acc.technology.push(r.technology)
-        }
-        if (isTruthy(r.kind) && !acc.kind.includes(r.kind)) {
-          acc.kind.push(r.kind)
-        }
-        if (isTruthy(r.color) && !acc.color.includes(r.color)) {
-          acc.color.push(r.color)
-        }
-        if (isTruthy(r.line) && !acc.line.includes(r.line)) {
-          acc.line.push(r.line)
-        }
-        if (isTruthy(r.head) && !acc.head.includes(r.head)) {
-          acc.head.push(r.head)
-        }
-        if (isTruthy(r.tail) && !acc.tail.includes(r.tail)) {
-          acc.tail.push(r.tail)
-        }
-        if (isTruthy(r.navigateTo) && !acc.navigateTo.includes(r.navigateTo)) {
-          acc.navigateTo.push(r.navigateTo)
-        }
-        if (r.tags) {
-          acc.tags.push(...r.tags)
-        }
-        if (r.links) {
-          acc.links.push(...r.links)
-        }
-        return acc
-      },
-      {
-        title: [] as string[],
-        description: [] as scalar.MarkdownOrString[],
-        technology: [] as string[],
-        kind: [] as aux.RelationKind<A>[],
-        head: [] as RelationshipArrowType[],
-        tail: [] as RelationshipArrowType[],
-        color: [] as Color[],
-        tags: [] as aux.Tag<A>[],
-        links: [] as Link[],
-        line: [] as RelationshipLineType[],
-        navigateTo: [] as aux.ViewId<A>[],
-      },
-    ),
-  )
-
-  let technology = only(allprops.technology)
-  let title = only(allprops.title) ?? (allprops.title.length > 1 ? '[...]' : null)
-
-  const tags = unique(allprops.tags)
-  let merged = pickBy(
-    {
-      // If there is no title, but there is technology, use technology as title
-      title: title ?? (technology ? `[${technology}]` : null),
-      description: only(allprops.description),
-      technology,
-      kind: only(allprops.kind),
-      head: only(allprops.head),
-      tail: only(allprops.tail),
-      color: only(allprops.color),
-      line: only(allprops.line),
-      navigateTo: only(allprops.navigateTo),
-      ...isNonEmptyArray(allprops.links) && { links: allprops.links },
-      ...isNonEmptyArray(tags) && { tags },
-    },
-    isTruthy,
-  )
-
-  if (prefer) {
-    return {
-      ...merged,
-      ...pickBy(pickRelationshipProps(prefer), isTruthy),
-    }
-  }
-  return merged
-}

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

@@ -1,55 +0,0 @@
-import type { AnyAux, aux, ComputedNode } from '../../types'
-import { ModelRelationExpr, whereOperatorAsPredicate } from '../../types'
-import { nonexhaustive } from '../../utils'
-import { elementExprToPredicate } from './elementExpressionToPredicate'
-
-type Predicate<T> = (x: T) => boolean
-export type FilterableEdge<A extends AnyAux> = {
-  tags?: aux.Tags<A> | null | undefined
-  kind?: string
-  source: ComputedNode<A>
-  target: ComputedNode<A>
-}
-
-export function relationExpressionToPredicates<A extends AnyAux, T extends FilterableEdge<A>>(
-  expr: ModelRelationExpr.Any<A>,
-): Predicate<T> {
-  switch (true) {
-    case ModelRelationExpr.isCustom(expr): {
-      return relationExpressionToPredicates(expr.customRelation.expr)
-    }
-    case ModelRelationExpr.isWhere(expr): {
-      const predicate = relationExpressionToPredicates(expr.where.expr)
-      const where = whereOperatorAsPredicate(expr.where.condition)
-      return e =>
-        predicate(e) && where({
-          source: { tags: e.source.tags, kind: e.source.kind as aux.AllKinds<A> },
-          target: { tags: e.target.tags, kind: e.target.kind as aux.AllKinds<A> },
-          ...(e.tags && { tags: e.tags }),
-          ...(e.kind && { kind: e.kind as aux.AllKinds<A> }),
-        })
-    }
-    case ModelRelationExpr.isDirect(expr): {
-      const isSource = elementExprToPredicate(expr.source)
-      const isTarget = elementExprToPredicate(expr.target)
-      return edge => {
-        return (isSource(edge.source) && isTarget(edge.target))
-          || (!!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source))
-      }
-    }
-    case ModelRelationExpr.isInOut(expr): {
-      const isInOut = elementExprToPredicate(expr.inout)
-      return edge => isInOut(edge.source) || isInOut(edge.target)
-    }
-    case ModelRelationExpr.isIncoming(expr): {
-      const isTarget = elementExprToPredicate(expr.incoming)
-      return edge => isTarget(edge.target)
-    }
-    case ModelRelationExpr.isOutgoing(expr): {
-      const isSource = elementExprToPredicate(expr.outgoing)
-      return edge => isSource(edge.source)
-    }
-    default:
-      nonexhaustive(expr)
-  }
-}

package/src/compute-view/utils/resolve-extended-views.ts

@@ -1,85 +0,0 @@
-import { unique, values } from 'remeda'
-import { type LikeC4View, isElementView, isExtendsElementView } from '../../types/view'
-
-import Graph from 'graphology'
-import { topologicalSort } from 'graphology-dag/topological-sort'
-import willCreateCycle from 'graphology-dag/will-create-cycle'
-import type { AnyAux, aux, ParsedElementView } from '../../types'
-import { isNonEmptyArray } from '../../utils'
-/**
- * Resolve rules of extended views
- * (Removes invalid views)
- */
-export function resolveRulesExtendedViews<A extends AnyAux, V extends Record<any, LikeC4View<A>>>(
-  unresolvedViews: V,
-): V {
-  const g = new Graph<{ view: LikeC4View<A> }>({
-    type: 'directed',
-  })
-  const extendedViews = [] as ParsedElementView<A>[]
-  for (const view of values(unresolvedViews)) {
-    g.addNode(view.id, { view })
-    if (isExtendsElementView(view)) {
-      extendedViews.push(view)
-    }
-  }
-
-  if (extendedViews.length === 0) {
-    return unresolvedViews
-  }
-
-  for (const view of extendedViews) {
-    if (!g.hasNode(view.extends)) {
-      console.warn(`View "${view.id}" extends from "${view.extends}" which does not exist`)
-      continue
-    }
-    if (willCreateCycle(g, view.id, view.extends)) {
-      console.warn(`View "${view.id}" extends from "${view.extends}" which creates a cycle`)
-      continue
-    }
-
-    // view -> parent
-    g.addDirectedEdge(view.id, view.extends)
-  }
-
-  const sorted = topologicalSort(g).reverse()
-  return sorted.reduce((acc, id) => {
-    const view = g.getNodeAttribute(id, 'view')
-    if (!isExtendsElementView(view)) {
-      acc[view.id] = view
-      return acc
-    }
-
-    const extendsFrom = acc[view.extends]
-    if (!extendsFrom || !isElementView(extendsFrom)) {
-      return acc
-    }
-
-    const tags = unique([
-      ...(extendsFrom.tags ?? []),
-      ...(view.tags ?? []),
-    ]) as aux.Tags<A>
-
-    const links = [
-      ...(extendsFrom.links ?? []),
-      ...(view.links ?? []),
-    ]
-
-    acc[view.id] = {
-      ...extendsFrom,
-      ...view,
-      title: view.title ?? extendsFrom.title ?? null,
-      description: view.description ?? extendsFrom.description ?? null,
-      tags,
-      links: isNonEmptyArray(links) ? links : null,
-      rules: [...extendsFrom.rules, ...view.rules],
-    }
-    return acc
-  }, {} as Record<string, LikeC4View<A>>) as V
-
-  // forEachNodeInTopologicalOrder(g, (_id, { view }) => {
-
-  // })
-
-  // return ordered as V
-}

package/src/compute-view/utils/resolve-global-rules.ts

@@ -1,88 +0,0 @@
-import { isNullish } from 'remeda'
-import {
-  type AnyAux,
-  type DynamicViewIncludeRule,
-  type DynamicViewRule,
-  type ElementViewPredicate,
-  type ElementViewRule,
-  type ModelGlobals,
-  type ParsedDynamicView,
-  type ParsedElementView,
-  type ViewRuleGlobalPredicateRef,
-  type ViewRuleGlobalStyle,
-  isDynamicView,
-  isElementView,
-  isViewRuleGlobalPredicateRef,
-  isViewRuleGlobalStyle,
-} from '../../types'
-import { nonexhaustive } from '../../utils'
-
-export function resolveGlobalRules<A extends AnyAux>(
-  view: ParsedElementView<A> | ParsedDynamicView<A>,
-  globals: ModelGlobals<A>,
-) {
-  if (isElementView(view)) {
-    return {
-      ...view,
-      rules: resolveGlobalRulesInElementView(view.rules, globals),
-    }
-  }
-
-  if (isDynamicView(view)) {
-    return {
-      ...view,
-      rules: resolveGlobalRulesInDynamicView(view.rules, globals),
-    }
-  }
-  nonexhaustive(view)
-}
-
-type ViewRuleGlobal = ViewRuleGlobalPredicateRef | ViewRuleGlobalStyle
-
-export function resolveGlobalRulesInElementView<M extends AnyAux>(
-  rules: ElementViewRule<M>[],
-  globals: ModelGlobals<M>,
-): Array<Exclude<ElementViewRule<M>, ViewRuleGlobal>> {
-  return rules.reduce((acc, rule) => {
-    if (isViewRuleGlobalPredicateRef(rule)) {
-      const globalPredicates = globals.predicates[rule.predicateId]
-      if (isNullish(globalPredicates)) {
-        return acc
-      }
-      return acc.concat(globalPredicates as ElementViewPredicate<M>[])
-    }
-    if (isViewRuleGlobalStyle(rule)) {
-      const globalStyles = globals.styles[rule.styleId]
-      if (isNullish(globalStyles)) {
-        return acc
-      }
-      return acc.concat(globalStyles)
-    }
-    acc.push(rule)
-    return acc
-  }, [] as Array<Exclude<ElementViewRule<M>, ViewRuleGlobal>>)
-}
-
-export function resolveGlobalRulesInDynamicView<M extends AnyAux>(
-  rules: DynamicViewRule<M>[],
-  globals: ModelGlobals<M>,
-): Array<Exclude<DynamicViewRule<M>, ViewRuleGlobal>> {
-  return rules.reduce((acc, rule) => {
-    if (isViewRuleGlobalPredicateRef(rule)) {
-      const globalPredicates = globals.dynamicPredicates[rule.predicateId]
-      if (isNullish(globalPredicates)) {
-        return acc
-      }
-      return acc.concat(globalPredicates as DynamicViewIncludeRule<M>[])
-    }
-    if (isViewRuleGlobalStyle(rule)) {
-      const globalStyles = globals.styles[rule.styleId]
-      if (isNullish(globalStyles)) {
-        return acc
-      }
-      return acc.concat(globalStyles)
-    }
-    acc.push(rule)
-    return acc
-  }, [] as Array<Exclude<DynamicViewRule<M>, ViewRuleGlobal>>)
-}

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

@@ -1,256 +0,0 @@
-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 type { AnyAux, ComputedEdge, ComputedNode, NodeId } from '../../types'
-import { invariant, nonNullable } from '../../utils'
-import { ancestorsOfNode } from './ancestorsOfNode'
-
-/**
- * Keeps initial order of the elements, but ensures parents are placed before children
- */
-function ensureParentsFirst<T extends { id: string; parent: string | null }>(
-  array: ReadonlyArray<T>,
-): Array<T> {
-  const result = [] as T[]
-  const items = [...array]
-  let item
-  while ((item = items.shift())) {
-    let parent = item.parent
-    if (parent) {
-      const ancestors = [] as T[]
-      while (parent) {
-        const parentIndx = items.findIndex(i => i.id === parent)
-        if (parentIndx < 0) {
-          break
-        }
-        const [parentItem] = items.splice(parentIndx, 1)
-        if (!parentItem) {
-          throw new Error('Invalid state, should not happen')
-        }
-        ancestors.unshift(parentItem)
-        parent = parentItem.parent
-      }
-      result.push(...ancestors)
-    }
-    result.push(item)
-  }
-  return result as Array<T>
-}
-
-/**
- * Side effect, mutates node.children field to preserve same order as in the input
- */
-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) => {
-        if (n.parent === parent.id) {
-          acc.push(n.id)
-        }
-        return acc
-      }, [] as NodeId[])
-    }
-  })
-  return nodes
-}
-
-type TopologicalSortParam<A extends AnyAux> = {
-  nodes: ReadonlyMap<string, ComputedNode<A>>
-  edges: Iterable<ComputedEdge<A>>
-}
-export function topologicalSort<A extends AnyAux>(
-  param: TopologicalSortParam<A>,
-): {
-  nodes: ComputedNode<A>[]
-  edges: ComputedEdge<A>[]
-} {
-  let nodes = ensureParentsFirst([...param.nodes.values()])
-  let edges = [...param.edges]
-  if (nodes.length < 2 || edges.length === 0) {
-    return {
-      nodes,
-      edges,
-    }
-  }
-
-  const getNode = (id: string) => nonNullable(param.nodes.get(id))
-  // const nodeLevel = (id: string) => getNode(id).level + 1
-  //
-
-  const g = new Graph({
-    multi: true,
-    allowSelfLoops: true,
-    type: 'directed',
-  })
-
-  const enrichedEdges = pipe(
-    edges,
-    map((edge, __dirname) => {
-      const source = getNode(edge.source),
-        target = getNode(edge.target),
-        parent = edge.parent ? getNode(edge.parent) : null
-      return ({
-        id: edge.id,
-        edge,
-        parent,
-        source,
-        target,
-      })
-    }),
-    // sortBy(
-    //   [prop('sourceIndex'), 'asc'],
-    //   // [prop('sourceInCount'), 'asc'],
-    //   // [prop('sourceLevel'), 'asc'],
-    // ),
-  )
-
-  const [edgesBetweenLeafs, edgesWithCompounds] = partition(
-    enrichedEdges,
-    ({ source, target }) => source.children.length === 0 && target.children.length === 0,
-  )
-
-  // edgesBetweenLeafs.sort((a, b) => {
-  //   if (a.source === b.source) {
-  //     return 0
-  //   }
-  //   if (a.source.level === 0 && b.source.level === 0) {
-  //     return 0
-  //   }
-  //   if (isSameHierarchy(a.source, b.target) || isSameHierarchy(a.target, b.source)) {
-  //     return edges.indexOf(a.edge) - edges.indexOf(b.edge)
-  //   }
-  //   const aLevel = a.parent ? a.parent.level + 1 - a.source.level : a.source.level
-  //   const bLevel = b.parent ? b.parent.level + 1 - b.source.level : b.source.level
-  //   return aLevel - bLevel
-  //   // if (a.source.level === 0 && b.source.level === 0) {
-
-  //   //   // if (a.source.depth)
-  //   //   return nodes.indexOf(a.target) - nodes.indexOf(b.target)
-  //   // }
-  //   // if (a.source.level === 0 && b.source.level > 0) {
-  //   //   return -1
-  //   // }
-  //   // if (a.parent && b.parent && a.parent !== b.parent) {
-  //   //   if (a.parent.level !== b.parent.level) {
-  //   //     return b.parent.level - a.parent.level
-  //   //   } else {
-  //   //     return nodes.indexOf(a.parent) - nodes.indexOf(b.parent)
-  //   //   }
-  //   // }
-  //   // 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<A>[]
-
-  const addEdgeToGraph = (edge: ComputedEdge<A>) => {
-    g.mergeNode(edge.source)
-    g.mergeNode(edge.target)
-    sortedEdges.push(edge)
-    if (!willCreateCycle(g, edge.source, edge.target)) {
-      g.mergeDirectedEdge(edge.source, edge.target)
-    }
-  }
-
-  for (const { edge, source, target } of edgesBetweenLeafs) {
-    addEdgeToGraph(edge)
-    // Strengthen the graph by adding edges to parents
-    if (target.parent && target.parent !== edge.parent) {
-      pipe(
-        ancestorsOfNode(target, param.nodes),
-        takeWhile(ancestor => ancestor.inEdges.includes(edge.id)),
-        forEach(ancestor => {
-          g.mergeNode(ancestor.id)
-          if (!willCreateCycle(g, edge.source, ancestor.id)) {
-            g.mergeDirectedEdge(edge.source, ancestor.id)
-          }
-          if (!willCreateCycle(g, ancestor.id, edge.target)) {
-            g.mergeDirectedEdge(ancestor.id, edge.target)
-          }
-        }),
-      )
-    }
-    if (source.parent) {
-      const sourceParent = getNode(source.parent)
-      g.mergeNode(sourceParent.id)
-      if (!willCreateCycle(g, sourceParent.id, source.id)) {
-        g.mergeDirectedEdge(sourceParent.id, source.id)
-      }
-      if (target.parent && target.parent !== source.parent) {
-        if (!willCreateCycle(g, sourceParent.id, target.parent)) {
-          g.mergeDirectedEdge(sourceParent.id, target.parent)
-        }
-      }
-    }
-
-    // addEdgeToGraph(edge)
-  }
-  for (const { edge } of edgesWithCompounds) {
-    addEdgeToGraph(edge)
-  }
-
-  invariant(sortedEdges.length === edges.length, 'Not all edges were added to the graph')
-
-  // for (const compound of nodes) {
-  //   if (compound.children.length === 0 || compound.inEdges.length === 0) {
-  //     continue
-  //   }
-  //   // g.mergeNode(compound.id)
-  //   for (const inEdge of compound.inEdges) {
-  //     const { edge, source } = getEdge(inEdge)
-  //     // ignore if this edge is coming from compound node
-  //     if (source.children.length > 0) {
-  //       continue
-  //     }
-  //     // if this edge is coming to the compound node directly
-  //     if (edge.target === compound.id) {
-  //       // for (const child of compound.children) {
-  //       //   // g.mergeNode(child)
-  //       //   if (!willCreateCycle(g, edge.source, child)) {
-  //       //     g.mergeDirectedEdge(edge.source, child)
-  //       //   }
-  //       // }
-  //     } else {
-  //       if (!willCreateCycle(g, edge.source, compound.id)) {
-  //         g.mergeDirectedEdge(edge.source, compound.id)
-  //       }
-  //       if (!willCreateCycle(g, compound.id, edge.target)) {
-  //         g.mergeDirectedEdge(compound.id, edge.target)
-  //       }
-  //     }
-  //   }
-  // }
-
-  const sortedIds = topsort(g)
-  let sorted = [] as ComputedNode<A>[]
-  let unsorted = nodes.slice()
-  for (const sortedId of sortedIds) {
-    const indx = unsorted.findIndex(n => n.id === sortedId)
-    invariant(indx >= 0, `Node "${sortedId}" not found`)
-    sorted.push(...unsorted.splice(indx, 1))
-  }
-  // Merge unsorted nodes, keeping their initial order
-  if (unsorted.length > 0 && sorted.length > 0) {
-    sorted = sorted.flatMap(node => {
-      if (unsorted.length === 0) {
-        return node
-      }
-      const wereBefore = nodes
-        .slice(0, nodes.indexOf(node))
-        .filter(n => unsorted.includes(n))
-      if (wereBefore.length > 0) {
-        unsorted = unsorted.filter(n => !wereBefore.includes(n))
-        return [...wereBefore, node]
-      }
-
-      return node
-    })
-  }
-  // Add remaining unsorted nodes
-  sorted.push(...unsorted)
-  return {
-    nodes: updateChildren(
-      ensureParentsFirst(sorted),
-    ),
-    edges: sortedEdges,
-  }
-}

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

@@ -1,45 +0,0 @@
-import { isTruthy, map, mapToObj, pick, pipe } from 'remeda'
-import type { SetOptional } from 'type-fest'
-import type { ComputedView } from '../../types'
-import { objectHash } from '../../utils'
-
-export function calcViewLayoutHash<V extends ComputedView>(view: SetOptional<V, 'hash'>): V {
-  const tohash = {
-    id: view.id,
-    __: view._type ?? 'element',
-    autoLayout: view.autoLayout,
-    nodes: pipe(
-      view.nodes,
-      map(n => ({
-        id: n.id,
-        icon: isTruthy(n.icon) ? 'Y' : 'N',
-        title: n.title,
-        description: n.description?.md ?? n.description?.txt ?? null,
-        technology: n.technology ?? null,
-        shape: n.shape,
-        size: n.style.size ?? null,
-        textSize: n.style.textSize ?? null,
-        padding: n.style.padding ?? null,
-        children: n.children,
-      })),
-      mapToObj(({ id, ...node }) => [id, node]),
-    ),
-    edges: pipe(
-      view.edges,
-      map(e => ({
-        source: e.source,
-        target: e.target,
-        label: e.label,
-        description: e.description?.md ?? e.description?.txt ?? null,
-        technology: e.technology ?? null,
-        dir: e.dir,
-        head: e.head,
-        tail: e.tail,
-        line: e.line,
-      })),
-      mapToObj(({ source, target, ...edge }) => [`${source}:${target}`, edge]),
-    ),
-  }
-  view.hash = objectHash(tohash)
-  return view as unknown as V
-}