@likec4/core 1.40.0 → 1.42.0

package/src/compute-view/element-view/memory/stage-final.ts

@@ -1,129 +0,0 @@
-import { forEach, only, pipe } from 'remeda'
-import { isAncestor, sortByFqnHierarchically } from '../../../utils/fqn'
-import { isome, toArray } from '../../../utils/iterable'
-import { difference, union } from '../../../utils/set'
-import { treeFromMemoryState } from '../../memory/ops'
-import type { Elem } from '../_types'
-import { findRedundantConnections } from '../clean-connections'
-import type { Ctx, Memory } from './memory'
-
-/**
- * This patch:
- * 1. Keeps connections between leafs or having direct deployment relations
- * 2. Removes cross-boundary model relations, that already exist inside boundaries
- *    (e.g. prefer relations inside same deployment node over relations between nodes)
- * 3. Removes implicit connections between elements, if their descendants have same connection
- */
-export class StageFinal {
-  static for(memory: Memory) {
-    return new StageFinal(memory)
-  }
-
-  private constructor(
-    protected readonly memory: Memory,
-  ) {
-  }
-
-  public step1CleanConnections(memory: Memory): Memory {
-    if (memory.connections.length < 2) {
-      return memory
-    }
-
-    const connectionsToExclude = findRedundantConnections(memory.connections)
-    if (connectionsToExclude.length === 0) {
-      return memory
-    }
-    const stage = memory.stageExclude({} as any)
-
-    stage.excludeConnections(connectionsToExclude, true)
-
-    return stage.commit()
-  }
-
-  public step2ProcessImplicits(memory: Memory): Memory {
-    const implicits = union(this.memory.elements, memory.elements)
-    const final = union(memory.final, this.memory.explicits)
-
-    const snapshot = new Set(final)
-    const isFinalOrHasIncludedDescendant = (el: Elem) => {
-      for (const final of snapshot) {
-        if (el === final || isAncestor(el, final)) {
-          return true
-        }
-      }
-      return false
-    }
-
-    // Pick from implicit elements
-    pipe(
-      difference(implicits, snapshot),
-      toArray(),
-      sortByFqnHierarchically,
-      forEach((el) => {
-        // if (memory.scope && !memory.scope.isAncestorOf(el)) {
-        //   return
-        // }
-        // If element has more 2 or more children included
-        // It can "box" around
-        const childrensToWrap = [...el.children()].filter(isFinalOrHasIncludedDescendant).length
-        if (childrensToWrap >= 2) {
-          final.add(el)
-          return
-        }
-        // If Element has only one child included
-        // and has "similar" sibling with included descendant
-        if (childrensToWrap === 1 && isome(el.siblings(), isFinalOrHasIncludedDescendant)) {
-          final.add(el)
-        }
-      }),
-    )
-
-    return memory.update({ final })
-  }
-
-  public step3ProcessBoundaries(memory: Memory): Memory {
-    const boundaries = new Set<Elem>()
-    for (const conn of memory.connections) {
-      if (conn.boundary && conn.boundary !== conn.source && conn.boundary !== conn.target) {
-        boundaries.add(conn.boundary)
-      }
-    }
-    const tree = treeFromMemoryState<Ctx>(memory, 'final')
-    const stage = memory.stageExclude({} as any)
-
-    const isRemovable = (el: Elem) =>
-      !(
-        boundaries.has(el)
-        || memory.explicits.has(el)
-        || tree.hasInOut(el)
-        || tree.root.has(el)
-      )
-
-    const singleRoot = only([...tree.root])
-    if (singleRoot && !memory.explicits.has(singleRoot)) {
-      stage.exclude(singleRoot)
-    }
-
-    for (const el of memory.final) {
-      const singleChild = only(tree.children(el))
-      if (singleChild && !tree.hasInOut(singleChild) && isRemovable(el)) {
-        stage.exclude(el)
-      }
-    }
-
-    if (stage.isDirty()) {
-      return stage.commit()
-    }
-    return memory
-  }
-
-  public commit(): Memory {
-    // return []
-    const step1 = this.step1CleanConnections(this.memory)
-    const step2 = this.step2ProcessImplicits(step1)
-    return this.step3ProcessBoundaries(step2)
-    // return step2memory
-    // const step3m?emory = this.step3FlatNodes(step2memory)
-    // return step3memory
-  }
-}

package/src/compute-view/element-view/memory/stage-include.ts

@@ -1,130 +0,0 @@
-import { dropWhile, forEach, pipe, take, zip } from 'remeda'
-import { modelConnection } from '../../../model'
-import { ModelExpression } from '../../../types'
-import { difference, isAncestor, isIterable } from '../../../utils'
-import { toArray } from '../../../utils/iterable'
-import { type CtxConnection, type StageExpression, AbstractStageInclude } from '../../memory'
-import { type ActiveGroupCtx, type ActiveGroupMemory, type Ctx } from './memory'
-
-const { findConnection, findConnectionsBetween } = modelConnection
-
-export type Elem = Ctx['Element']
-
-export class StageInclude<C extends Ctx = Ctx> extends AbstractStageInclude<C> {
-  /**
-   * Connects elements with existing ones in the memory
-   */
-  public override connectWithExisting(
-    elements: Elem | Iterable<Elem>,
-    direction: 'in' | 'out' | 'both' = 'both',
-  ): boolean {
-    const before = this._connections.length
-    const hasChanged = () => this._connections.length > before
-    if (!isIterable(elements)) {
-      if (direction === 'in' || direction === 'both') {
-        for (const el of this.memory.elements) {
-          this.addConnections(
-            findConnection(el, elements, 'directed'),
-          )
-        }
-      }
-      if (direction === 'out' || direction === 'both') {
-        this.addConnections(
-          findConnectionsBetween(elements, this.memory.elements, 'directed'),
-        )
-      }
-      return hasChanged()
-    }
-
-    const targets = [...elements]
-    if (direction === 'in' || direction === 'both') {
-      for (const el of this.memory.elements) {
-        this.addConnections(
-          findConnectionsBetween(el, targets, 'directed'),
-        )
-      }
-    }
-    if (direction === 'out' || direction === 'both') {
-      for (const el of targets) {
-        this.addConnections(
-          findConnectionsBetween(el, this.memory.elements, 'directed'),
-        )
-      }
-    }
-    return hasChanged()
-  }
-
-  protected addImplicitWithinScope(element: Elem | undefined | null) {
-    if (!element) {
-      return
-    }
-    if (!this.memory.scope || isAncestor(this.memory.scope, element)) {
-      this.addImplicit(element)
-    }
-  }
-
-  protected override processConnections(connections: CtxConnection<Ctx>[]) {
-    if (ModelExpression.isRelationExpr(this.expression)) {
-      return connections
-    }
-
-    pipe(
-      connections,
-      forEach(({ source, target, boundary }) => {
-        pipe(
-          zip(
-            [...toArray(source.ancestors()).reverse(), source],
-            [...toArray(target.ancestors()).reverse(), target],
-          ),
-          // Filter out common ancestors
-          dropWhile(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor),
-          take(1),
-          forEach(([sourceAncestor, targetAncestor]) => {
-            if (sourceAncestor === source && targetAncestor === target) {
-              this.addImplicitWithinScope(boundary)
-              return
-            }
-            if (sourceAncestor !== source) {
-              this.addImplicitWithinScope(sourceAncestor)
-            }
-            if (targetAncestor !== target) {
-              this.addImplicitWithinScope(targetAncestor)
-            }
-          }),
-        )
-      }),
-    )
-    return connections
-  }
-
-  protected override postcommit(state: ActiveGroupCtx['MutableState']) {
-    const newExplicits = difference(state.explicits, this.memory.explicits)
-    for (const explicit of newExplicits) {
-      state.explicitFirstSeenIn.set(explicit, '@root' as any)
-    }
-
-    return state
-  }
-}
-
-export class ActiveGroupStageInclude extends StageInclude<ActiveGroupCtx> {
-  constructor(
-    public override readonly memory: ActiveGroupMemory,
-    public override readonly expression: StageExpression<ActiveGroupCtx>,
-  ) {
-    super(memory, expression)
-  }
-
-  protected override postcommit(state: ActiveGroupCtx['MutableState']) {
-    const newExplicits = difference(state.explicits, this.memory.explicits)
-    for (const explicit of newExplicits) {
-      state.explicitFirstSeenIn.set(explicit, this.memory.activeGroupId)
-    }
-
-    for (const implicit of [...this.explicits, ...this.implicits]) {
-      state.lastSeenIn.set(implicit, this.memory.activeGroupId)
-    }
-
-    return state
-  }
-}

package/src/compute-view/element-view/predicates/_utils.ts

@@ -1,91 +0,0 @@
-import { anyPass } from 'remeda'
-import type { ElementModel, LikeC4Model } from '../../../model'
-import { modelConnection } from '../../../model'
-import { type AnyAux, FqnRef, ModelFqnExpr } from '../../../types'
-import { ifilter, isDescendantOf, nonexhaustive, toArray } from '../../../utils'
-import type { Elem, Memory, PredicateCtx } from '../_types'
-
-export const { findConnection, findConnectionsBetween, findConnectionsWithin } = modelConnection
-
-/**
- * Resolve elements from the model based on the given expression
- */
-
-export function resolveElements<A extends AnyAux>(
-  model: LikeC4Model<A>,
-  expr: ModelFqnExpr.NonWildcard<A>,
-): ElementModel<A>[] {
-  switch (true) {
-    case ModelFqnExpr.isElementKindExpr(expr): {
-      return [...ifilter(model.elements(), el => {
-        return expr.isEqual === (el.kind === expr.elementKind)
-      })]
-    }
-    case ModelFqnExpr.isElementTagExpr(expr): {
-      return [...ifilter(model.elements(), el => {
-        return expr.isEqual === el.tags.includes(expr.elementTag)
-      })]
-    }
-    case expr.selector === 'expanded': {
-      const element = model.element(FqnRef.flatten(expr.ref))
-      return [
-        element,
-        ...element.children(),
-      ]
-    }
-    case expr.selector === 'children':
-    case expr.selector === 'descendants': {
-      const element = model.element(FqnRef.flatten(expr.ref))
-      let children = expr.selector === 'children' ? toArray(element.children()) : toArray(element.descendants())
-      return children && children.length > 0 ? children : [element]
-    }
-    case ModelFqnExpr.isModelRef(expr): {
-      return [model.element(FqnRef.flatten(expr.ref))]
-    }
-    default:
-      nonexhaustive(expr)
-  }
-}
-
-/**
- * Include elements that are not in the given set but are descendants of the current set
- * Consider the following example:
- *    a1.* -> b1
- * If there are a1.a2.a3 and b1.b2 in the memory, but not connected yet - we connect them
- */
-export function includeDescendantsFromMemory(elements: Elem[], memory: Memory): Elem[] {
-  if (memory.isEmpty() || elements.length === 0) {
-    return elements
-  }
-  const descedantsOf = anyPass(elements.map(e => isDescendantOf(e)))
-  const fromMemory = toArray(
-    ifilter(
-      memory.elements,
-      el => !elements.includes(el) && descedantsOf(el),
-    ),
-  )
-  return [
-    ...elements,
-    ...fromMemory,
-  ]
-}
-
-/**
- * Combination of `resolveElements` and `includeDescendantsFromMemory`
- */
-export function resolveAndIncludeFromMemory(
-  nonWildcard: ModelFqnExpr.NonWildcard,
-  { memory, model }: Pick<PredicateCtx, 'model' | 'memory'>,
-): Elem[] {
-  const resolved = resolveElements(model, nonWildcard)
-  // We include from memory only if the expression is:
-  // - expanded element
-  // - element reference with or with children (but not descendants - they are already included)
-  if (ModelFqnExpr.isModelRef(nonWildcard)) {
-    if (nonWildcard.selector === 'descendants') {
-      return resolved
-    }
-    return includeDescendantsFromMemory(resolved, memory)
-  }
-  return resolved
-}

package/src/compute-view/element-view/predicates/element-expand.ts

@@ -1,29 +0,0 @@
-import { type AnyAux, type ModelFqnExpr, FqnRef } from '../../../types'
-import type { Elem, PredicateExecutor } from '../_types'
-import { findConnectionsWithin, resolveElements } from './_utils'
-
-export const ExpandedElementPredicate: PredicateExecutor<ModelFqnExpr.Ref<AnyAux>> = {
-  include: ({ expr, model, stage, where }) => {
-    const parent = model.element(FqnRef.flatten(expr.ref))
-    if (where(parent)) {
-      stage.addExplicit(parent)
-      stage.connectWithExisting(parent)
-    }
-
-    const children = [...parent.children()].filter(where)
-    const expanded = [] as Elem[]
-    for (const child of children) {
-      stage.addImplicit(child)
-      if (stage.connectWithExisting(child)) {
-        expanded.push(child)
-      }
-    }
-    stage.addConnections(findConnectionsWithin(expanded))
-    return stage
-  },
-  exclude: ({ expr, model, stage, filterWhere }) => {
-    const elements = filterWhere(resolveElements(model, expr))
-    stage.exclude(elements)
-    return stage
-  },
-}

package/src/compute-view/element-view/predicates/element-kind-tag.ts

@@ -1,27 +0,0 @@
-import type { AnyAux, ModelFqnExpr } from '../../../types'
-import type { PredicateExecutor } from '../_types'
-import { findConnectionsWithin, resolveElements } from './_utils'
-
-export const ElementKindOrTagPredicate: PredicateExecutor<
-  ModelFqnExpr.ElementKindExpr<AnyAux> | ModelFqnExpr.ElementTagExpr<AnyAux>
-> = {
-  include: ({ expr, model, stage, filterWhere }) => {
-    const elements = filterWhere(resolveElements(model, expr))
-    if (elements.length === 0) {
-      return
-    }
-
-    stage.addExplicit(elements)
-    stage.connectWithExisting(elements)
-    stage.addConnections(findConnectionsWithin(elements))
-
-    return stage
-  },
-
-  exclude: ({ expr, model, stage, filterWhere }) => {
-    const elements = filterWhere(resolveElements(model, expr))
-    stage.exclude(elements)
-
-    return stage
-  },
-}

package/src/compute-view/element-view/predicates/element-ref.ts

@@ -1,24 +0,0 @@
-import type { AnyAux, ModelFqnExpr } from '../../../types'
-import type { Elem, PredicateExecutor } from '../_types'
-import { findConnectionsWithin, resolveElements } from './_utils'
-
-export const ElementRefPredicate: PredicateExecutor<ModelFqnExpr.Ref<AnyAux>> = {
-  include: ({ expr, model, stage, filterWhere }) => {
-    const elements = filterWhere(resolveElements(model, expr))
-    if (elements.length === 0) {
-      return
-    }
-
-    stage.addExplicit(elements)
-    stage.connectWithExisting(elements)
-    stage.addConnections(findConnectionsWithin(elements))
-
-    return stage
-  },
-  exclude: ({ expr, model, stage, filterWhere }) => {
-    const elements = filterWhere(resolveElements(model, expr))
-    stage.exclude(elements)
-
-    return stage
-  },
-}