@likec4/core 1.18.0 → 1.19.1

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

@@ -1,35 +1,35 @@
-import { hasAtLeast, isEmpty } from 'remeda'
+import { hasAtLeast, isEmpty, isNumber, isString } from 'remeda'
 import { invariant, nonexhaustive } from '../../errors'
 import type { LikeC4DeploymentModel } from '../../model'
 import type { DeploymentConnectionModel } from '../../model/connection/deployment'
+import type { ElementModel } from '../../model/ElementModel'
 import type { AnyAux } from '../../model/types'
 import {
   type ComputedEdge,
   type ComputedNode,
   DefaultArrowType,
-  DeploymentElementExpression,
   type DeploymentNodeKind,
   type DeploymentViewRule,
   type Fqn,
+  FqnExpr,
   isViewRuleStyle,
   type NonEmptyArray,
-  type Tag
+  type Tag,
 } from '../../types'
 import { nameFromFqn, parentFqn } from '../../utils'
 import { applyViewRuleStyle } from '../utils/applyViewRuleStyles'
 import { buildComputedNodes, type ComputedNodeSource } from '../utils/buildComputedNodes'
-import { deriveEdgePropsFromRelationships } from '../utils/derive-edge-props-from-relationships'
+import { mergePropsFromRelationships } from '../utils/merge-props-from-relationships'
 import { uniqueTags } from '../utils/uniqueTags'
-import type { Elem } from './_types'
-import { type Memory, MutableMemory } from './Memory'
+import type { Elem, Memory } from './_types'
 
 type Predicate<T> = (x: T) => boolean
 
 export function resolveElements(
   model: LikeC4DeploymentModel,
-  expr: DeploymentElementExpression.Ref
-) {
-  const ref = model.element(expr.ref)
+  expr: FqnExpr.DeploymentRef,
+): Elem[] {
+  const ref = model.element(expr.ref.deployment)
   if (ref.isDeploymentNode()) {
     if (expr.selector === 'children') {
       return [...ref.children()]
@@ -44,14 +44,31 @@ export function resolveElements(
   return [ref]
 }
 
-export function deploymentExpressionToPredicate<T extends { id: string }>(
-  target: DeploymentElementExpression
+export function resolveModelElements(
+  model: LikeC4DeploymentModel,
+  expr: FqnExpr.ModelRef,
+): ElementModel[] {
+  const ref = model.$model.element(expr.ref.model)
+  if (expr.selector === 'children') {
+    return [...ref.children()]
+  }
+  if (expr.selector === 'expanded') {
+    return [ref, ...ref.children()]
+  }
+  if (expr.selector === 'descendants') {
+    return [...ref.descendants()]
+  }
+  return [ref]
+}
+
+export function deploymentExpressionToPredicate<T extends { id: string; modelRef?: number | string }>(
+  target: FqnExpr,
 ): Predicate<T> {
-  if (DeploymentElementExpression.isWildcard(target)) {
+  if (FqnExpr.isWildcard(target)) {
     return () => true
   }
-  if (DeploymentElementExpression.isRef(target)) {
-    const fqn = target.ref.id
+  if (FqnExpr.isDeploymentRef(target)) {
+    const fqn = target.ref.deployment
     if (target.selector === 'expanded') {
       const fqnWithDot = fqn + '.'
       return n => n.id === fqn || n.id.startsWith(fqnWithDot)
@@ -65,6 +82,55 @@ export function deploymentExpressionToPredicate<T extends { id: string }>(
     }
     return n => n.id === fqn
   }
+  if (FqnExpr.isModelRef(target)) {
+    const modelFqn = (node: T) => {
+      if (isString(node.modelRef)) {
+        return node.modelRef
+      }
+      if (isNumber(node.modelRef)) {
+        return node.id
+      }
+      return null
+    }
+
+    const fqn = target.ref.model
+    if (target.selector === 'expanded') {
+      const fqnWithDot = fqn + '.'
+      return (n) => {
+        const m = modelFqn(n)
+        if (!m) {
+          return true
+        }
+        return m === fqn || m.startsWith(fqnWithDot)
+      }
+    }
+    if (target.selector === 'descendants') {
+      const fqnWithDot = fqn + '.'
+      return (n) => {
+        const m = modelFqn(n)
+        if (!m) {
+          return true
+        }
+        return m.startsWith(fqnWithDot)
+      }
+    }
+    if (target.selector === 'children') {
+      return (n) => {
+        const m = modelFqn(n)
+        if (!m) {
+          return true
+        }
+        return parentFqn(m) === fqn
+      }
+    }
+    return (n) => {
+      const m = modelFqn(n)
+      if (!m) {
+        return true
+      }
+      return m === fqn
+    }
+  }
   nonexhaustive(target)
 }
 
@@ -82,7 +148,7 @@ export function toNodeSource(el: Elem): ComputedNodeSource {
     return {
       ...(onlyOneInstance && {
         ...toNodeSource(onlyOneInstance),
-        modelRef: onlyOneInstance.$element.id
+        modelRef: onlyOneInstance.element.id,
       }),
       title,
       ...$node,
@@ -90,16 +156,16 @@ export function toNodeSource(el: Elem): ComputedNodeSource {
       ...(color && { color }),
       ...(shape && { shape }),
       style: {
-        ...style
+        ...style,
       },
       deploymentRef: 1,
       kind,
-      id
+      id,
     }
   }
   invariant(el.isInstance(), 'Expected Instance')
   const instance = el.$instance
-  const element = el.$element.$element
+  const element = el.element.$element
 
   const icon = instance.style?.icon ?? element.icon
   const color = instance.style?.color ?? element.color
@@ -107,12 +173,12 @@ export function toNodeSource(el: Elem): ComputedNodeSource {
 
   const links = [
     ...(element.links ?? []),
-    ...(instance.links ?? [])
+    ...(instance.links ?? []),
   ]
 
   const metadata = {
     ...element.metadata,
-    ...instance.metadata
+    ...instance.metadata,
   }
 
   const notation = instance.notation ?? element.notation
@@ -130,24 +196,24 @@ export function toNodeSource(el: Elem): ComputedNodeSource {
     ...shape && { shape },
     style: {
       ...element.style,
-      ...instance.style
+      ...instance.style,
     },
     deploymentRef: el.id === instance.id ? 1 : instance.id,
     modelRef: el.id === element.id ? 1 : element.id,
     ...notation && { notation },
-    ...!isEmpty(metadata) && ({ metadata })
+    ...!isEmpty(metadata) && ({ metadata }),
   }
 }
 
 export function toComputedEdges<M extends AnyAux>(
-  connections: ReadonlyArray<DeploymentConnectionModel<M>>
+  connections: ReadonlyArray<DeploymentConnectionModel<M>>,
 ): ComputedEdge[] {
   return connections.reduce((acc, e) => {
     // const modelRelations = []
     // const deploymentRelations = []
     const relations = [
       ...e.relations.model,
-      ...e.relations.deployment
+      ...e.relations.deployment,
     ]
     invariant(hasAtLeast(relations, 1), 'Edge must have at least one relation')
 
@@ -157,7 +223,7 @@ export function toComputedEdges<M extends AnyAux>(
     const {
       title,
       ...props
-    } = deriveEdgePropsFromRelationships(relations.map(r => r.$relationship)) // || relations.find(r => r.source === source && r.target === target)
+    } = mergePropsFromRelationships(relations.map(r => r.$relationship)) // || relations.find(r => r.source === source && r.target === target)
 
     const edge: ComputedEdge = {
       id: e.id,
@@ -166,7 +232,7 @@ export function toComputedEdges<M extends AnyAux>(
       target,
       label: title ?? null,
       relations: relations.map((r) => r.id as M['RelationId']),
-      ...props
+      ...props,
     }
 
     // If exists same edge but in opposite direction
@@ -192,15 +258,13 @@ export function toComputedEdges<M extends AnyAux>(
 }
 
 export function buildNodes(memory: Memory): ReadonlyMap<Fqn, ComputedNode> {
-  // typecast to MutableMemory
-  invariant(memory instanceof MutableMemory, 'Expected MutableMemory')
-  return buildComputedNodes([...memory.finalElements].map(toNodeSource))
+  return buildComputedNodes([...memory.final].map(toNodeSource))
 }
 
 export function applyDeploymentViewRuleStyles(
   rules: DeploymentViewRule[],
-  nodes: ComputedNode[]
-) {
+  nodes: ComputedNode[],
+): ComputedNode[] {
   for (const rule of rules) {
     if (!isViewRuleStyle(rule) || rule.targets.length === 0) {
       continue

package/src/compute-view/dynamic-view/__test__/fixture.ts

@@ -1,7 +1,7 @@
 import { partition } from 'remeda'
 import type { DynamicViewRule, DynamicViewStep, Fqn, ViewId, ViewRulePredicate } from '../../../types'
 import { type FakeElementIds, fakeModel } from '../../element-view/__test__/fixture'
-import { DynamicViewComputeCtx } from '../compute'
+import { computeDynamicView } from '../compute'
 
 const emptyView = {
   __: 'dynamic' as const,
@@ -43,13 +43,13 @@ export function $step(expr: StepExpr, props?: string | Partial<StepProps>): Dyna
 
 export function compute(stepsAndRules: (DynamicViewStep | ViewRulePredicate)[]) {
   const [steps, rules] = partition(stepsAndRules, (s): s is DynamicViewStep => 'source' in s)
-  const view = DynamicViewComputeCtx.compute(
+  let view = computeDynamicView(
+    fakeModel,
     {
       ...emptyView,
       steps,
       rules: rules as DynamicViewRule[]
-    },
-    fakeModel
+    }
   )
   return Object.assign(view, {
     nodeIds: view.nodes.map((node) => node.id) as string[],

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

@@ -1,5 +1,9 @@
-import { filter, findLast, flatMap, hasAtLeast, isTruthy, map, only, pipe, unique } from 'remeda'
+import { filter, findLast, flatMap, hasAtLeast, isTruthy, map, only, pipe, reduce, unique } from 'remeda'
 import { nonNullable } from '../../errors'
+import type { LikeC4Model } from '../../model'
+import { findConnection } from '../../model/connection/model'
+import type { ElementModel } from '../../model/ElementModel'
+import type { AnyAux } from '../../model/types'
 import {
   type Color,
   type ComputedDynamicView,
@@ -9,7 +13,6 @@ import {
   DefaultRelationshipColor,
   type DynamicView,
   type DynamicViewStep,
-  type Element,
   isDynamicViewParallelSteps,
   isViewRuleAutoLayout,
   isViewRulePredicate,
@@ -23,7 +26,6 @@ import {
   type ViewId
 } from '../../types'
 import { ancestorsFqn, commonAncestor, parentFqn } from '../../utils/fqn'
-import type { LikeC4ModelGraph } from '../LikeC4ModelGraph'
 import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
 import { applyViewRuleStyles } from '../utils/applyViewRuleStyles'
 import { buildComputedNodesFromElements } from '../utils/buildComputedNodes'
@@ -32,7 +34,9 @@ import { elementExprToPredicate } from '../utils/elementExpressionToPredicate'
 import { resolveGlobalRulesInDynamicView } from '../utils/resolve-global-rules'
 import { calcViewLayoutHash } from '../utils/view-hash'
 
-export namespace DynamicViewComputeCtx {
+type Element = ElementModel
+
+namespace DynamicViewCompute {
   export interface Step {
     id: StepEdgeId
     source: Element
@@ -51,18 +55,14 @@ export namespace DynamicViewComputeCtx {
   }
 }
 
-export class DynamicViewComputeCtx {
+class DynamicViewCompute {
   // Intermediate state
   private explicits = new Set<Element>()
-  private steps = [] as DynamicViewComputeCtx.Step[]
-
-  public static compute(view: DynamicView, graph: LikeC4ModelGraph): ComputedDynamicView {
-    return new DynamicViewComputeCtx(view, graph).compute()
-  }
+  private steps = [] as DynamicViewCompute.Step[]
 
-  private constructor(
-    protected view: DynamicView,
-    protected graph: LikeC4ModelGraph
+  constructor(
+    protected model: LikeC4Model,
+    protected view: DynamicView
   ) {}
 
   private addStep(
@@ -78,8 +78,8 @@ export class DynamicViewComputeCtx {
     parent?: number
   ) {
     const id = parent ? stepEdgeId(parent, index) : stepEdgeId(index)
-    const source = this.graph.element(stepSource)
-    const target = this.graph.element(stepTarget)
+    const source = this.model.element(stepSource)
+    const target = this.model.element(stepTarget)
 
     this.explicits.add(source)
     this.explicits.add(target)
@@ -116,7 +116,7 @@ export class DynamicViewComputeCtx {
     })
   }
 
-  protected compute(): ComputedDynamicView {
+  compute(): ComputedDynamicView {
     const {
       docUri: _docUri, // exclude docUri
       rules: _rules, // exclude rules
@@ -141,18 +141,22 @@ export class DynamicViewComputeCtx {
       stepNum++
     }
 
-    const rules = resolveGlobalRulesInDynamicView(this.view, this.graph.globals)
+    const rules = resolveGlobalRulesInDynamicView(_rules, this.model.globals())
 
     for (const rule of rules) {
       if (isViewRulePredicate(rule)) {
         for (const expr of rule.include) {
-          const predicate = elementExprToPredicate(expr)
-          this.graph.elements.filter(predicate).forEach(e => this.explicits.add(e))
+          const satisfies = elementExprToPredicate(expr)
+          for (const e of this.model.elements()) {
+            if (satisfies(e)) {
+              this.explicits.add(e)
+            }
+          }
         }
       }
     }
 
-    const elements = [...this.explicits]
+    const elements = [...this.explicits].map(e => e.$element)
     const nodesMap = buildComputedNodesFromElements(elements)
 
     const edges = this.steps.map(({ source, target, relations, title, isBackward, ...step }) => {
@@ -243,7 +247,7 @@ export class DynamicViewComputeCtx {
     line: RelationshipLineType | null
     notation: string | null
   } {
-    const relationships = unique(this.graph.edgesBetween(source, target).flatMap(e => e.relations))
+    const relationships = findConnection(source, target, 'directed').flatMap(r => [...r.relations])
     if (relationships.length === 0) {
       return {
         title: null,
@@ -267,44 +271,54 @@ export class DynamicViewComputeCtx {
     const relations = hasAtLeast(relationships, 1) ? map(relationships, r => r.id) : null
 
     // Most closest relation
-    const relation = only(relationships) || relationships.find(r => r.source === source.id && r.target === target.id)
+    const relation = only(relationships) || relationships.find(r => r.source === source && r.target === target)
+    const relationNavigateTo = relation?.$relationship.navigateTo ?? null
 
-    const navigateTo = !!relation?.navigateTo && relation.navigateTo !== this.view.id ? relation.navigateTo : pipe(
+    const navigateTo = relationNavigateTo && relationNavigateTo !== this.view.id ? relationNavigateTo : pipe(
       relationships,
-      map(r => r.navigateTo),
+      map(r => r.$relationship.navigateTo),
       filter(isTruthy),
       filter(v => v !== this.view.id),
       unique(),
       only()
     )
 
-    const commonProperties = relationships.reduce((acc, r) => {
-      isTruthy(r.title) && acc.title.push(r.title)
-      isTruthy(r.tail) && acc.tail.push(r.tail)
-      isTruthy(r.head) && acc.head.push(r.head)
-      isTruthy(r.color) && acc.color.push(r.color)
-      isTruthy(r.line) && acc.line.push(r.line)
+    const commonProperties = pipe(
+      relationships,
+      reduce((acc, { title, $relationship: r }) => {
+        isTruthy(title) && acc.title.add(title)
+        isTruthy(r.tail) && acc.tail.add(r.tail)
+        isTruthy(r.head) && acc.head.add(r.head)
+        isTruthy(r.color) && acc.color.add(r.color)
+        isTruthy(r.line) && acc.line.add(r.line)
 
-      return acc
-    }, {
-      title: [] as string[],
-      tail: [] as RelationshipArrowType[],
-      head: [] as RelationshipArrowType[],
-      color: [] as Color[],
-      line: [] as RelationshipLineType[],
-      notation: [] as string[]
-    })
+        return acc
+      }, {
+        tail: new Set<RelationshipArrowType>(),
+        head: new Set<RelationshipArrowType>(),
+        color: new Set<Color>(),
+        line: new Set<RelationshipLineType>(),
+        notation: new Set<string>(),
+        title: new Set<string>()
+      })
+    )
 
     return {
       tags,
       relations,
       navigateTo: navigateTo ?? null,
-      title: pipe(commonProperties.title, unique(), only()) ?? null,
-      tail: pipe(commonProperties.tail, unique(), only()) ?? null,
-      head: pipe(commonProperties.head, unique(), only()) ?? null,
-      color: pipe(commonProperties.color, unique(), only()) ?? null,
-      line: pipe(commonProperties.line, unique(), only()) ?? null,
-      notation: pipe(commonProperties.notation, unique(), only()) ?? null
+      title: only([...commonProperties.title]) ?? null,
+      tail: only([...commonProperties.tail]) ?? null,
+      head: only([...commonProperties.head]) ?? null,
+      color: only([...commonProperties.color]) ?? null,
+      line: only([...commonProperties.line]) ?? null,
+      notation: only([...commonProperties.notation]) ?? null
     }
   }
 }
+export function computeDynamicView<M extends AnyAux>(
+  model: LikeC4Model<M>,
+  view: DynamicView
+): ComputedDynamicView {
+  return new DynamicViewCompute(model, view).compute()
+}