@likec4/core 1.40.0 → 1.42.0

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

@@ -1,65 +0,0 @@
-import { filter, hasAtLeast, only } from 'remeda'
-import type { ConnectionModel } from '../../model'
-import {
-  type AnyAux,
-  type ComputedEdge,
-  type ComputedNode,
-  type scalar,
-} from '../../types'
-import { invariant } from '../../utils'
-import { buildComputedNodes, elementModelToNodeSource } from '../utils/buildComputedNodes'
-import { mergePropsFromRelationships } from '../utils/merge-props-from-relationships'
-import type { Memory } from './_types'
-
-export const NoWhere = () => true
-export const NoFilter = <T>(x: T[] | readonly T[]): T[] => x as T[]
-
-export function toComputedEdges<A extends AnyAux>(
-  connections: ReadonlyArray<ConnectionModel<A>>,
-): ComputedEdge<A>[] {
-  return connections.reduce((acc, e) => {
-    // const modelRelations = []
-    // const deploymentRelations = []
-    const relations = [
-      ...e.relations,
-    ]
-    invariant(hasAtLeast(relations, 1), 'Edge must have at least one relation')
-
-    const source = e.source.id
-    const target = e.target.id
-
-    const {
-      title,
-      ...props
-    } = mergePropsFromRelationships(
-      relations.map(r => r.$relationship),
-      // Prefer only single relationship
-      // https://github.com/likec4/likec4/issues/1423
-      only(
-        filter(relations, r => r.source.id === source && r.target.id === target),
-      )?.$relationship,
-    )
-
-    const edge: ComputedEdge<A> = {
-      id: e.id,
-      parent: e.boundary?.id as scalar.NodeId ?? null,
-      source: source as scalar.NodeId,
-      target: target as scalar.NodeId,
-      label: title ?? null,
-      relations: relations.map((r) => r.id),
-      ...props,
-    }
-
-    acc.push(edge)
-    return acc
-  }, [] as ComputedEdge<A>[])
-}
-
-export function buildNodes<A extends AnyAux>(
-  memory: Memory,
-): ReadonlyMap<scalar.NodeId, ComputedNode<A>> {
-  return buildComputedNodes(
-    [...memory.final].map(elementModelToNodeSource),
-    memory.groups,
-  )
-}

package/src/compute-view/index.ts

@@ -1,4 +0,0 @@
-export { computeLikeC4Model, computeParsedModelData, computeView, unsafeComputeView } from './compute-view'
-export type { ComputeViewResult } from './compute-view'
-export { resolveRulesExtendedViews } from './utils/resolve-extended-views'
-export { viewsWithReadableEdges, withReadableEdges } from './utils/with-readable-edges'

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

@@ -1,45 +0,0 @@
-import type { AnyCtx, ComputeMemory, GenericCtx, MutableState, StageExpression } from './_types'
-
-export abstract class AbstractMemory<T extends AnyCtx = GenericCtx> implements ComputeMemory<T> {
-  /**
-   * Provides access to context types
-   * !IMPORTANT: Should not be called in runtime
-   *
-   * @example
-   * ```ts
-   *   type State = SomeMemory['Ctx']['MutableState']
-   * ```
-   */
-  public get Ctx(): T {
-    throw new Error('Should not be called in runtime')
-  }
-
-  protected constructor(protected state: MutableState<T>) {
-  }
-
-  public get elements(): ReadonlySet<T['Element']> {
-    return this.state.elements
-  }
-  public get explicits(): ReadonlySet<T['Element']> {
-    return this.state.explicits
-  }
-  public get final(): ReadonlySet<T['Element']> {
-    return this.state.final
-  }
-  public get connections(): ReadonlyArray<T['Connection']> {
-    return this.state.connections
-  }
-
-  public isEmpty(): boolean {
-    return this.elements.size === 0 && this.connections.length === 0
-      && this.explicits.size === 0 && this.final.size === 0
-  }
-
-  abstract mutableState(): MutableState<T>
-
-  abstract stageInclude(expr: StageExpression<T>): T['StageInclude']
-
-  abstract stageExclude(expr: StageExpression<T>): T['StageExclude']
-
-  abstract update(newstate: Partial<MutableState<T>>): T['Memory']
-}

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

@@ -1,215 +0,0 @@
-import { isBoolean, pipe } from 'remeda'
-import { findAscendingConnections } from '../../model'
-import { difference, intersection, invariant, isDescendantOf, isIterable } from '../../utils'
-import { ifilter, isome, toSet } from '../../utils/iterable'
-import type { AnyCtx, CtxConnection, CtxElement, MutableState, StageExclude, StageExpression } from './_types'
-
-export abstract class AbstractStageExclude<T extends AnyCtx> implements StageExclude<T> {
-  // Removed elements
-  protected excluded = {
-    elements: new Set<CtxElement<T>>(),
-    connections: [] as CtxConnection<T>[],
-  }
-
-  constructor(
-    public readonly memory: T['Memory'],
-    public readonly expression: StageExpression<T>,
-  ) {
-  }
-
-  protected markedToMoveExplicitToImplicit = false
-
-  protected _removeElement(element: CtxElement<T>): void {
-    this.excluded.elements.add(element)
-  }
-
-  public exclude(element: CtxElement<T> | Iterable<CtxElement<T>> | false | undefined | null): this {
-    if (!element) {
-      return this
-    }
-    if (isIterable(element)) {
-      for (const el of element) {
-        this._removeElement(el)
-      }
-      return this
-    }
-    this._removeElement(element)
-    return this
-  }
-
-  protected _removeConnection(connection: CtxConnection<T>): void {
-    this.excluded.connections.push(connection)
-  }
-  /**
-   * Excludes from the memory relationships from given connections (still connection may be included, but without given relationships)
-   * @param moveExplicitToImplicit - if true, disconnected explicit elements will be moved to implicit
-   * @default false
-   */
-  public excludeConnections(
-    connection: CtxConnection<T> | Iterable<CtxConnection<T>>,
-    moveExplicitToImplicit?: boolean,
-  ) {
-    if (isBoolean(moveExplicitToImplicit)) {
-      invariant(!this.markedToMoveExplicitToImplicit, 'Already marked to move explicits')
-      this.markedToMoveExplicitToImplicit = moveExplicitToImplicit
-    }
-    if (isIterable(connection)) {
-      for (const c of connection) {
-        this._removeConnection(c)
-      }
-      return this
-    }
-    this._removeConnection(connection)
-    return this
-  }
-
-  public isDirty(): boolean {
-    return this.excluded.elements.size > 0 || this.excluded.connections.length > 0
-  }
-
-  public isEmpty(): boolean {
-    return !this.isDirty()
-  }
-
-  /**
-   * Determines whether disconnected explicits should become implicits.
-   * By default moves all disconnected explicits to implicits, if there were operation to exclude elements.
-   *
-   * Override this method to change the behavior.
-   */
-  protected filterForMoveToImplicits(disconnectedExplicits: Set<CtxElement<T>>): Set<CtxElement<T>> {
-    if (this.markedToMoveExplicitToImplicit || this.excluded.elements.size > 0) {
-      return disconnectedExplicits
-    }
-    return new Set()
-  }
-
-  // Check if Leaf EXPLICIT elements are becoming IMPLICIT
-  // (it means that they are not connected anymore)
-  protected moveDisconnectedExplicitsToImplicits(state: MutableState<T>): MutableState<T> {
-    // Check if EXPLICIT elements are becoming IMPLICIT
-    let disconnected = difference(
-      new Set(this.memory.connections.flatMap(c => [c.source, c.target])),
-      new Set(state.connections.flatMap(c => [c.source, c.target])),
-    )
-    // Ensure existing in implicits
-    disconnected = intersection(
-      disconnected,
-      state.elements,
-    )
-    // Ensure this is a leaf explici element
-    disconnected = pipe(
-      disconnected,
-      ifilter(el => {
-        return state.explicits.has(el) && !isome(state.final, isDescendantOf(el))
-      }),
-      toSet(),
-    )
-    if (disconnected.size > 0) {
-      disconnected = this.filterForMoveToImplicits(disconnected)
-      state.explicits = difference(state.explicits, disconnected)
-      // Exclude from final elements
-      state.final = difference(state.final, disconnected)
-    }
-    return state
-  }
-
-  protected removeElements(state: MutableState<T>): MutableState<T> {
-    state.elements = difference(state.elements, this.excluded.elements)
-    state.explicits = difference(state.explicits, this.excluded.elements)
-    state.final = difference(state.final, this.excluded.elements)
-    return state
-  }
-
-  protected removeConnections(state: MutableState<T>): MutableState<T> {
-    const excludedMap = this.excluded.connections.reduce((acc, c) => {
-      const existing = acc.get(c.id)
-      if (existing) {
-        acc.set(c.id, existing.mergeWith(c) as CtxConnection<T>)
-      } else {
-        acc.set(c.id, c)
-      }
-      return acc
-    }, new Map<string, CtxConnection<T>>())
-
-    // were connected before and not anymore
-    let disconnected = new Set<CtxElement<T>>()
-
-    state.connections = state.connections.reduce((acc, c) => {
-      const excluded = excludedMap.get(c.id)
-      if (excluded) {
-        disconnected.add(c.source)
-        disconnected.add(c.target)
-        const diff = c.difference(excluded) as CtxConnection<T>
-        if (diff.nonEmpty()) {
-          acc.push(diff)
-        }
-      } else {
-        acc.push(c)
-      }
-      return acc
-    }, [] as CtxConnection<T>[])
-
-    for (const stillExists of state.connections) {
-      disconnected.delete(stillExists.source)
-      disconnected.delete(stillExists.target)
-      if (stillExists.boundary && state.elements.has(stillExists.boundary)) {
-        disconnected.delete(stillExists.boundary)
-      }
-    }
-
-    if (disconnected.size === 0) {
-      return state
-    }
-    // Keep explicits
-    disconnected = difference(disconnected, state.explicits)
-    // Even if not connected, implicit elements should be kept
-    // state.elements = difference(state.elements, excludedElements)
-    state.final = difference(state.final, disconnected)
-
-    return state
-  }
-
-  /**
-   * Precommit hook
-   */
-  protected precommit(state: MutableState<T>): MutableState<T> {
-    return state
-  }
-
-  /**
-   * Postcommit hook
-   */
-  protected postcommit(state: MutableState<T>): MutableState<T> {
-    invariant(difference(state.explicits, state.elements).size === 0, 'Explicits must be subset of elements')
-    invariant(difference(state.final, state.elements).size === 0, 'Final elements must be subset of elements')
-    return state
-  }
-
-  public commit(): T['Memory'] {
-    let state = this.precommit(this.memory.mutableState())
-
-    // Exclude connections from excluded elements
-    if (this.excluded.elements.size > 0) {
-      const excludedConnections = state.connections
-        .filter(c => this.excluded.elements.has(c.source) || this.excluded.elements.has(c.target))
-        .flatMap(c => [
-          c,
-          ...findAscendingConnections(state.connections, c)
-            .map(asc => asc.intersect(c) as CtxConnection<T>),
-        ])
-        .filter(asc => asc.nonEmpty())
-      this.excludeConnections(excludedConnections)
-    }
-    if (this.excluded.connections.length > 0) {
-      state = this.removeConnections(state)
-    }
-    if (this.excluded.elements.size > 0) {
-      state = this.removeElements(state)
-    }
-
-    // state = this.moveDisconnectedExplicitsToImplicits(state)
-
-    return this.memory.update(this.postcommit(state))
-  }
-}

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

@@ -1,200 +0,0 @@
-import { partition } from 'remeda'
-import { mergeConnections } from '../../model'
-import { intersection, isIterable, union } from '../../utils'
-import type {
-  AnyCtx,
-  CtxConnection as Connection,
-  CtxElement as Elem,
-  GenericCtx,
-  MutableState,
-  StageExpression,
-  StageInclude,
-} from './_types'
-
-export abstract class AbstractStageInclude<T extends AnyCtx = GenericCtx> implements StageInclude<T> {
-  // New elements
-  protected explicits = new Set<Elem<T>>()
-  protected implicits = new Set<Elem<T>>()
-
-  // Ordered Set of explicit and implicit elements
-  protected _ordered = new Set<Elem<T>>()
-
-  protected _connections = [] as Connection<T>[]
-
-  constructor(
-    public readonly memory: T['Memory'],
-    public readonly expression: StageExpression<T>,
-  ) {
-  }
-
-  get elements(): ReadonlySet<Elem<T>> {
-    return this.explicits
-  }
-
-  /**
-   * Connections from this stage
-   */
-  get connections(): readonly Connection<T>[] {
-    return this._connections
-  }
-
-  mergedConnections(): readonly Connection<T>[] {
-    return mergeConnections([
-      ...this.memory.connections,
-      ...this._connections,
-    ])
-  }
-
-  public connectWithExisting(
-    _element: Elem<T> | Iterable<Elem<T>>,
-    _direction?: 'in' | 'out' | 'both',
-  ): boolean {
-    throw new Error('Method not implements, depends on the model')
-  }
-
-  /**
-   * Possible to override
-   */
-  protected _addExplicit(elements: Elem<T>): void {
-    this._ordered.add(elements)
-    this.explicits.add(elements)
-    this.implicits.delete(elements)
-  }
-
-  public addExplicit(element: Elem<T> | Iterable<Elem<T>> | false | undefined | null): this {
-    if (!element) {
-      return this
-    }
-    if (isIterable(element)) {
-      for (const el of element) {
-        this._addExplicit(el)
-      }
-      return this
-    }
-    this._addExplicit(element)
-    return this
-  }
-
-  /**
-   * Possible to override
-   */
-  protected _addImplicit(elements: Elem<T>): void {
-    if (this.explicits.has(elements)) {
-      return
-    }
-    this._ordered.add(elements)
-    this.implicits.add(elements)
-  }
-
-  public addImplicit(elements: Elem<T> | Iterable<Elem<T>> | false | undefined | null): this {
-    if (!elements) {
-      return this
-    }
-    if (isIterable(elements)) {
-      for (const el of elements) {
-        this._addImplicit(el)
-      }
-      return this
-    }
-    this._addImplicit(elements)
-    return this
-  }
-
-  /**
-   * Possible to override
-   */
-  protected _addConnection(connection: Connection<T>): void {
-    this._connections.push(connection)
-    this._addImplicit(connection.source)
-    this._addImplicit(connection.target)
-  }
-
-  public addConnections(connection: Connection<T> | Iterable<Connection<T>>): this {
-    if (isIterable(connection)) {
-      for (const c of connection) {
-        this._addConnection(c)
-      }
-      return this
-    }
-    this._addConnection(connection)
-    return this
-  }
-
-  public isDirty(): boolean {
-    return this.explicits.size > 0 || this.implicits.size > 0 || this._connections.length > 0
-  }
-
-  public isEmpty(): boolean {
-    return !this.isDirty()
-  }
-
-  /**
-   * Precommit hook
-   */
-  protected precommit(state: MutableState<T>): MutableState<T> {
-    return state
-  }
-
-  /**
-   * Postcommit hook
-   */
-  protected postcommit(state: MutableState<T>): MutableState<T> {
-    return state
-  }
-
-  protected processConnections(connections: Connection<T>[]): Connection<T>[] { // To preserve order, we split new connections into two sets
-    return connections
-  }
-
-  public commit(): T['Memory'] {
-    let state = this.precommit(this.memory.mutableState())
-
-    let fromConnections = new Set<Elem<T>>()
-
-    if (this._connections.length > 0) {
-      // To preserve order, we split new connections into two sets
-      // First are outgoing from known elements (in memory.elements)
-      const [fromKnown, rest] = partition(
-        this._connections,
-        c => state.final.has(c.source),
-      )
-
-      state.connections = this.processConnections(
-        mergeConnections([
-          ...state.connections,
-          ...fromKnown,
-          ...rest,
-        ]),
-      )
-
-      fromConnections = new Set(state.connections.flatMap(c => [c.source, c.target]))
-    }
-
-    state.elements = union(
-      state.elements,
-      this._ordered,
-      this.explicits,
-      fromConnections,
-      this.implicits,
-    )
-
-    state.explicits = intersection(
-      state.elements,
-      union(
-        state.explicits,
-        this.explicits,
-      ),
-    )
-
-    state.final = intersection(
-      state.elements,
-      union(
-        state.final,
-        this.explicits,
-        fromConnections,
-      ),
-    )
-
-    return this.memory.update(this.postcommit(state))
-  }
-}

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

@@ -1,148 +0,0 @@
-import type { Connection } from '../../model/connection'
-import type { DeploymentElementModel } from '../../model/DeploymentElementModel'
-import type { ElementModel } from '../../model/ElementModel'
-import type { AnyAux } from '../../types'
-
-type Element<A extends AnyAux> = ElementModel<A> | DeploymentElementModel<A>
-
-export interface ComputeCtx<
-  E extends Element<AnyAux>,
-  C extends Connection<E, any>,
-  M extends ComputeMemory<any>,
-  Inc extends StageInclude<any>,
-  Exc extends StageExclude<any>,
-  Expr = unknown,
-> {
-  Element: E
-  Connection: C
-  Memory: M
-  StageInclude: Inc
-  StageExclude: Exc
-  Expr: Expr
-  MutableState: State<this>
-}
-
-// export type AnyCtx = ComputeCtx<any, any, ComputeMemory<any>, StageInclude<any>, StageExclude<any>, any>
-export type AnyCtx = GenericCtx
-
-export type GenericCtx = ComputeCtx<
-  any,
-  Connection<any, any>,
-  ComputeMemory<GenericCtx>,
-  StageInclude<GenericCtx>,
-  StageExclude<GenericCtx>,
-  unknown
->
-
-export interface State<T extends AnyCtx> {
-  elements: Set<CtxElement<T>>
-  explicits: Set<CtxElement<T>>
-  final: Set<CtxElement<T>>
-  connections: Array<CtxConnection<T>>
-}
-
-export type MutableState<T extends AnyCtx> = T['MutableState']
-
-export type StageExpression<T extends AnyCtx> = T['Expr']
-
-export type CtxElement<T extends AnyCtx> = T['Element']
-export type CtxConnection<T extends AnyCtx> = T['Connection']
-export type CtxMemory<T extends AnyCtx> = T['Memory']
-
-export interface ComputeMemory<T extends AnyCtx> {
-  /**
-   * All resolved elements, includes:
-   * - explicit elements (included by element predicates, always appear in the view unless excluded)
-   * - elements from resolved connections (may be excluded, if connection is redundant @see excludeRedundantRelationships
-   * - implicit elements (not added directly, not included in the view, used for resolving connections)
-   */
-  readonly elements: ReadonlySet<CtxElement<T>>
-
-  /**
-   * Explicit elements
-   */
-  readonly explicits: ReadonlySet<CtxElement<T>>
-
-  /**
-   * Final set of elements to be included in the view
-   * (`elements` excluding implicits)
-   * Keeps order in which elements were added
-   */
-  readonly final: ReadonlySet<CtxElement<T>>
-
-  /**
-   * Resolved connections
-   */
-  readonly connections: ReadonlyArray<CtxConnection<T>>
-
-  isEmpty(): boolean
-
-  stageInclude(expression: T['Expr']): T['StageInclude']
-
-  stageExclude(expression: T['Expr']): T['StageExclude']
-
-  /**
-   * Returns shallow copy of state
-   */
-  mutableState(): T['MutableState']
-
-  /**
-   * Returns new memory with updated state
-   */
-  update(newstate: Partial<T['MutableState']>): T['Memory']
-}
-
-interface Stage<T extends AnyCtx> {
-  readonly memory: CtxMemory<T>
-
-  readonly expression: StageExpression<T>
-
-  /**
-   * Has changes
-   */
-  isDirty(): boolean
-
-  /**
-   * Has no changes
-   */
-  isEmpty(): boolean
-
-  commit(): T['Memory']
-}
-
-export interface StageInclude<T extends AnyCtx> extends Stage<T> {
-  readonly elements: ReadonlySet<CtxElement<T>>
-
-  readonly connections: ReadonlyArray<CtxConnection<T>>
-
-  addExplicit(element: CtxElement<T> | Iterable<CtxElement<T>> | false | undefined | null): this
-
-  addImplicit(element: CtxElement<T> | Iterable<CtxElement<T>> | false | undefined | null): this
-
-  /**
-   * Connects element with existing ones in the memory
-   *
-   * @param direction - direction of the connection
-   * @default 'both'
-   */
-  connectWithExisting(
-    element: CtxElement<T> | Iterable<CtxElement<T>>,
-    direction?: 'in' | 'out' | 'both',
-  ): boolean
-
-  addConnections(connection: CtxConnection<T> | Iterable<CtxConnection<T>>): this
-}
-
-export interface StageExclude<T extends AnyCtx> extends Stage<T> {
-  /**
-   * Excludes from the memory relationships from given connections (still connection may be included, but without given relationships)
-   * @param moveExplicitToImplicit - if true, disconnected explicit elements will be moved to implicit
-   * @default false
-   */
-  excludeConnections(
-    connection: CtxConnection<T> | Iterable<CtxConnection<T>>,
-    moveExplicitToImplicit?: boolean,
-  ): this
-
-  exclude(element: CtxElement<T> | Iterable<CtxElement<T>> | false | undefined | null): this
-}

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

@@ -1,5 +0,0 @@
-export type * from './_types'
-export { AbstractMemory } from './AbstractMemory'
-export { AbstractStageExclude } from './AbstractStageExclude'
-export { AbstractStageInclude } from './AbstractStageInclude'
-export { treeFromMemoryState } from './ops'