@likec4/core 1.41.0 → 1.42.0

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

@@ -1,324 +0,0 @@
-import { filter, findLast, forEach, map, pipe } from 'remeda'
-import { ConnectionModel } from '../../model/connection/model/ConnectionModel'
-import { LikeC4Model } from '../../model/LikeC4Model'
-import type { RelationshipModel } from '../../model/RelationModel'
-import {
-  type AnyAux,
-  type ComputedElementView,
-  type ElementViewRule,
-  type ModelGlobals,
-  type NodeId,
-  type ParsedElementView,
-  isViewRuleAutoLayout,
-  isViewRuleGroup,
-  isViewRulePredicate,
-  ModelExpression,
-  ModelFqnExpr,
-  ModelRelationExpr,
-  whereOperatorAsPredicate,
-} from '../../types'
-import { invariant, nonexhaustive, nonNullable, sortParentsFirst } from '../../utils'
-import { DefaultMap } from '../../utils/mnemonist'
-import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
-import { applyCustomRelationProperties } from '../utils/applyCustomRelationProperties'
-import { applyViewRuleStyles } from '../utils/applyViewRuleStyles'
-import { buildElementNotations } from '../utils/buildElementNotations'
-import { linkNodesWithEdges } from '../utils/link-nodes-with-edges'
-import { resolveGlobalRulesInElementView } from '../utils/resolve-global-rules'
-import { topologicalSort } from '../utils/topological-sort'
-import { calcViewLayoutHash } from '../utils/view-hash'
-import { type Connection, type Elem, type PredicateCtx } from './_types'
-import { type NodesGroup, type Stage, Memory } from './memory'
-import { ActiveGroupMemory } from './memory/memory'
-import { StageFinal } from './memory/stage-final'
-import { ExpandedElementPredicate } from './predicates/element-expand'
-import { ElementKindOrTagPredicate } from './predicates/element-kind-tag'
-import { ElementRefPredicate } from './predicates/element-ref'
-import { DirectRelationExprPredicate } from './predicates/relation-direct'
-import { IncomingExprPredicate } from './predicates/relation-in'
-import { InOutRelationPredicate } from './predicates/relation-in-out'
-import { OutgoingExprPredicate } from './predicates/relation-out'
-import { WildcardPredicate } from './predicates/wildcard'
-import { buildNodes, NoFilter, NoWhere, toComputedEdges } from './utils'
-
-function processElementPredicate(
-  // ...args:
-  //   | [expr: ModelAnyFqnExpr, op: 'include', IncludePredicateCtx<ModelAnyFqnExpr>]
-  //   | [expr: ModelAnyFqnExpr, op: 'exclude', ExcludePredicateCtx<ModelAnyFqnExpr>]
-  expr: ModelFqnExpr.Any,
-  op: 'include' | 'exclude',
-  ctx: Omit<PredicateCtx<ModelFqnExpr.Any>, 'expr'>,
-): Stage {
-  switch (true) {
-    case ModelFqnExpr.isCustom(expr): {
-      if (op === 'include') {
-        return processElementPredicate(expr.custom.expr, op, ctx)
-      }
-      return ctx.stage
-    }
-    case ModelFqnExpr.isWhere(expr): {
-      const where = whereOperatorAsPredicate(expr.where.condition)
-      const filterWhere = (elements: ReadonlyArray<Elem>) => {
-        return filter(elements, where)
-      }
-      return processElementPredicate(expr.where.expr, op, { ...ctx, where, filterWhere })
-    }
-    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
-      return ExpandedElementPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
-    }
-    case ModelFqnExpr.isWildcard(expr): {
-      return WildcardPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
-    }
-    case ModelFqnExpr.isElementKindExpr(expr):
-    case ModelFqnExpr.isElementTagExpr(expr): {
-      return ElementKindOrTagPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
-    }
-    case ModelFqnExpr.isModelRef(expr): {
-      return ElementRefPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
-    }
-    default:
-      nonexhaustive(expr)
-  }
-}
-function processRelationtPredicate(
-  expr: ModelRelationExpr.Any,
-  op: 'include' | 'exclude',
-  ctx: Omit<PredicateCtx<ModelRelationExpr.Any>, 'expr'>,
-): Stage {
-  switch (true) {
-    case ModelRelationExpr.isCustom(expr): {
-      if (op === 'include') {
-        return processRelationtPredicate(expr.customRelation.expr, op, ctx)
-      }
-      return ctx.stage
-    }
-    case ModelRelationExpr.isWhere(expr): {
-      const where = whereOperatorAsPredicate(expr.where.condition)
-      const filterRelations = (relations: ReadonlySet<RelationshipModel>) => {
-        return new Set(filter([...relations], where))
-      }
-      const filterWhere = (connections: ReadonlyArray<Connection>) => {
-        return pipe(
-          connections,
-          map(c => new ConnectionModel(c.source, c.target, filterRelations(c.relations))),
-          filter(c => c.nonEmpty()),
-        )
-      }
-      return processRelationtPredicate(expr.where.expr, op, {
-        ...ctx,
-        where,
-        filterWhere,
-      })
-    }
-    case ModelRelationExpr.isInOut(expr): {
-      return InOutRelationPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
-    }
-    case ModelRelationExpr.isDirect(expr): {
-      return DirectRelationExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
-    }
-    case ModelRelationExpr.isOutgoing(expr): {
-      return OutgoingExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
-    }
-    case ModelRelationExpr.isIncoming(expr): {
-      return IncomingExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
-    }
-    default:
-      nonexhaustive(expr)
-  }
-}
-
-export function processPredicates<A extends AnyAux>(
-  model: LikeC4Model<A>,
-  memory: Memory,
-  rules: ElementViewRule<A>[],
-): Memory {
-  const ctx = {
-    model,
-    scope: memory.scope,
-    where: NoWhere,
-    filterWhere: NoFilter,
-  }
-  for (const rule of rules) {
-    if (isViewRuleGroup(rule)) {
-      const groupMemory = ActiveGroupMemory.enter(memory, rule)
-      memory = processPredicates(model, groupMemory, rule.groupRules)
-      invariant(memory instanceof ActiveGroupMemory, 'processPredicates must return ActiveGroupMemory')
-      memory = memory.leave()
-      continue
-    }
-    if (isViewRulePredicate(rule)) {
-      const op = 'include' in rule ? 'include' : 'exclude'
-      const exprs = rule.include ?? rule.exclude
-      for (const expr of exprs) {
-        let stage = op === 'include' ? memory.stageInclude(expr) : memory.stageExclude(expr)
-        switch (true) {
-          case ModelExpression.isFqnExpr(expr):
-            stage = processElementPredicate(expr, op, {
-              ...ctx,
-              stage,
-              memory,
-            } as any) ?? stage
-            break
-          case ModelExpression.isRelationExpr(expr):
-            stage = processRelationtPredicate(expr, op, {
-              ...ctx,
-              stage,
-              memory,
-            }) ?? stage
-            break
-          default:
-            nonexhaustive(expr)
-        }
-        memory = stage.commit()
-      }
-    }
-  }
-  return StageFinal.for(memory).commit()
-}
-
-export function computeElementView<A extends AnyAux>(
-  likec4model: LikeC4Model<any>,
-  {
-    docUri: _docUri, // exclude docUri
-    rules: _rules, // exclude rules
-    ...view
-  }: ParsedElementView<A>,
-): ComputedElementView<A> {
-  const rules = resolveGlobalRulesInElementView(
-    _rules,
-    likec4model.globals as unknown as ModelGlobals<A>,
-  )
-  const scope = view.viewOf ? likec4model.asComputed.element(view.viewOf) : null
-  let memory = processPredicates(
-    likec4model,
-    Memory.empty(scope),
-    rules,
-  )
-  if (memory.isEmpty() && scope) {
-    memory = memory.update({
-      final: new Set([scope]),
-    })
-  }
-  memory = assignElementsToGroups(memory)
-
-  const nodesMap = buildNodes<A>(memory)
-
-  const computedEdges = toComputedEdges(memory.connections as unknown as readonly ConnectionModel<A>[])
-
-  linkNodesWithEdges(nodesMap, computedEdges)
-
-  const sorted = topologicalSort({
-    nodes: nodesMap,
-    edges: computedEdges,
-  })
-
-  const nodes = applyCustomElementProperties(
-    rules,
-    applyViewRuleStyles(
-      rules,
-      sorted.nodes,
-    ),
-  )
-
-  const autoLayoutRule = findLast(rules, isViewRuleAutoLayout)
-
-  const nodeNotations = buildElementNotations(nodes)
-
-  return calcViewLayoutHash({
-    ...view,
-    _stage: 'computed',
-    autoLayout: {
-      direction: autoLayoutRule?.direction ?? 'TB',
-      ...(autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep }),
-      ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }),
-    },
-    edges: applyCustomRelationProperties(rules, nodes, sorted.edges),
-    nodes: map(nodes, n => {
-      if (n.icon === 'none') {
-        delete n.icon
-      }
-      return n
-    }),
-    ...(nodeNotations.length > 0 && {
-      notation: {
-        nodes: nodeNotations,
-      },
-    }),
-  })
-}
-
-/**
- * Clean up group.explicits and group.implicits
- */
-function assignElementsToGroups(memory: Memory) {
-  if (memory.groups.length === 0) {
-    return memory
-  }
-  const groupAssignments = new DefaultMap<NodeId, Set<Elem>>(() => new Set())
-
-  const assignedTo = new Map<Elem, NodesGroup['id']>()
-
-  const isAncestorAssigned = (el: Elem) => {
-    for (const parent of el.ancestors()) {
-      const groupId = assignedTo.get(parent)
-      if (groupId) {
-        assignedTo.set(el, groupId)
-        groupAssignments.get(groupId).add(el)
-        return true
-      }
-    }
-    return false
-  }
-
-  const isDescendantAssigned = (el: Elem) => {
-    for (const descendant of el.descendants('asc')) {
-      const groupId = assignedTo.get(descendant)
-      if (groupId) {
-        assignedTo.set(el, groupId)
-        groupAssignments.get(groupId).add(el)
-        return true
-      }
-    }
-    return false
-  }
-
-  pipe(
-    sortParentsFirst([...memory.explicitFirstSeenIn.keys()]),
-    forEach((el) => {
-      if (!isAncestorAssigned(el)) {
-        const groupId = nonNullable(memory.explicitFirstSeenIn.get(el))
-        assignedTo.set(el, groupId)
-        groupAssignments.get(groupId).add(el)
-      }
-    }),
-  )
-
-  pipe(
-    sortParentsFirst([...memory.lastSeenIn.keys()]),
-    filter(el => !assignedTo.has(el)),
-    forEach((el) => {
-      if (isAncestorAssigned(el)) {
-        return
-      }
-      if (isDescendantAssigned(el)) {
-        return
-      }
-      const groupId = nonNullable(memory.lastSeenIn.get(el))
-      assignedTo.set(el, groupId)
-      groupAssignments.get(groupId).add(el)
-    }),
-  )
-
-  if (groupAssignments.size === 0) {
-    return memory
-  }
-
-  let groups = memory.groups.map(group => {
-    const explicits = groupAssignments.get(group.id)
-    if (!explicits) {
-      return group
-    }
-    return group.update(explicits)
-  })
-  return memory.update({ groups })
-}

package/src/compute-view/element-view/memory/NodeGroup.ts

@@ -1,31 +0,0 @@
-import type { ElementModel } from '../../../model'
-import { type AnyAux, type ElementViewRuleGroup, type NodeId, GroupElementKind } from '../../../types'
-
-export class NodesGroup<A extends AnyAux = AnyAux> {
-  static readonly kind = GroupElementKind
-
-  constructor(
-    public readonly id: NodeId,
-    public readonly viewRule: ElementViewRuleGroup<A>,
-    public readonly parent: NodeId | null = null,
-    public readonly elements: ReadonlySet<ElementModel<A>> = new Set<ElementModel<A>>(),
-  ) {
-  }
-
-  isEmpty() {
-    return this.elements.size === 0
-  }
-
-  update(elements: ReadonlySet<ElementModel<AnyAux>>): NodesGroup<A> {
-    return new NodesGroup(
-      this.id,
-      this.viewRule,
-      this.parent,
-      elements as unknown as ReadonlySet<ElementModel<A>>,
-    )
-  }
-
-  clone() {
-    return new NodesGroup(this.id, this.viewRule, this.parent, new Set(this.elements))
-  }
-}

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

@@ -1,10 +0,0 @@
-import type { StageExclude } from './stage-exclude'
-import type { StageInclude } from './stage-include'
-
-export type { Ctx } from './memory'
-export { Memory } from './memory'
-export { NodesGroup } from './NodeGroup'
-export { StageExclude } from './stage-exclude'
-export { StageInclude } from './stage-include'
-
-export type Stage = StageInclude | StageExclude

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

@@ -1,178 +0,0 @@
-import type { ConnectionModel, ElementModel } from '../../../model'
-import type { aux, ElementViewRuleGroup as ViewRuleGroup, ModelExpression, NodeId, scalar } from '../../../types'
-import { nonNullable } from '../../../utils'
-import { Stack } from '../../../utils/mnemonist'
-import { type ComputeCtx, type CtxElement, type MutableState, type StageExpression, AbstractMemory } from '../../memory'
-import { NodesGroup } from './NodeGroup'
-import { ActiveGroupStageExclude, StageExclude } from './stage-exclude'
-import { ActiveGroupStageInclude, StageInclude } from './stage-include'
-
-type A = aux.Any
-
-export interface Ctx extends
-  ComputeCtx<
-    ElementModel<A>,
-    ConnectionModel<A>,
-    Memory<Ctx>,
-    StageInclude<Ctx>,
-    StageExclude,
-    ModelExpression<A>
-  >
-{
-  MutableState: {
-    elements: Set<ElementModel<A>>
-    explicits: Set<ElementModel<A>>
-    final: Set<ElementModel<A>>
-    connections: ConnectionModel<A>[]
-    groups: NodesGroup<A>[]
-    /*
-     * The group where explict element was added first time
-     * May be a root group
-     */
-    explicitFirstSeenIn: Map<ElementModel<A>, scalar.NodeId>
-    /**
-     * The group where element (implicit or explicit) was last seen (added or updated)
-     * Exclude root group
-     */
-    lastSeenIn: Map<ElementModel<A>, scalar.NodeId>
-  }
-}
-
-export class Memory<C extends Ctx = Ctx> extends AbstractMemory<C> {
-  static empty<EC extends Ctx>(scope: ElementModel<any> | null): Memory<EC> {
-    return new Memory({
-      elements: new Set(),
-      explicits: new Set(),
-      final: new Set(),
-      connections: [],
-      groups: [],
-      explicitFirstSeenIn: new Map(),
-      lastSeenIn: new Map(),
-    }, scope)
-  }
-
-  protected constructor(
-    protected override state: MutableState<C>,
-    public readonly scope: CtxElement<C> | null,
-  ) {
-    super(state)
-  }
-
-  public get groups(): ReadonlyArray<NodesGroup<A>> {
-    return this.state.groups
-  }
-
-  public get explicitFirstSeenIn(): ReadonlyMap<ElementModel<A>, scalar.NodeId> {
-    return this.state.explicitFirstSeenIn
-  }
-
-  public get lastSeenIn(): ReadonlyMap<ElementModel<A>, scalar.NodeId> {
-    return this.state.lastSeenIn
-  }
-
-  override stageInclude(expr: StageExpression<C>): StageInclude {
-    return new StageInclude(this, expr)
-  }
-  override stageExclude(expr: StageExpression<C>): StageExclude {
-    return new StageExclude(this, expr)
-  }
-
-  override mutableState(): MutableState<C> {
-    return ({
-      elements: new Set(this.state.elements),
-      explicits: new Set(this.state.explicits),
-      final: new Set(this.state.final),
-      connections: [...this.state.connections],
-      groups: this.state.groups.map((g) => g.clone()),
-      explicitFirstSeenIn: new Map(this.state.explicitFirstSeenIn),
-      lastSeenIn: new Map(this.state.lastSeenIn),
-    })
-  }
-
-  override update(newstate: Partial<C['MutableState']>): Memory {
-    return new Memory({
-      ...this.state,
-      ...newstate,
-    }, this.scope)
-  }
-}
-
-type ActiveGroupState = Ctx['MutableState'] & {
-  // activeGroup: NodesGroup
-}
-
-export interface ActiveGroupCtx extends Ctx {
-  MutableState: ActiveGroupState
-}
-
-export class ActiveGroupMemory extends Memory<ActiveGroupCtx> {
-  static enter(
-    memory: Memory,
-    rule: ViewRuleGroup<any>,
-  ): ActiveGroupMemory {
-    const groupId = `@gr${memory.groups.length + 1}` as NodeId
-    if (memory instanceof ActiveGroupMemory) {
-      const stack = Stack.from([...memory.stack].reverse())
-      const state = memory.mutableState()
-      state.groups.push(new NodesGroup(groupId, rule, memory.activeGroupId))
-      stack.push(groupId)
-      return new ActiveGroupMemory(state, memory.scope, stack)
-    }
-    const state = memory.mutableState() as ActiveGroupState
-    state.groups.push(new NodesGroup(groupId, rule, null))
-    const stack = Stack.of(groupId)
-    return new ActiveGroupMemory(state, memory.scope, stack)
-  }
-
-  protected constructor(
-    protected override state: ActiveGroupState,
-    public override readonly scope: CtxElement<ActiveGroupCtx> | null,
-    // Stack of group ids
-    protected stack: Stack<NodeId>,
-  ) {
-    super(state, scope)
-  }
-
-  get activeGroupId(): NodeId {
-    return nonNullable(this.stack.peek(), 'Stack must not be empty')
-  }
-
-  override mutableState(): ActiveGroupState {
-    const state = super.mutableState()
-    return ({
-      ...state,
-      // activeGroup: this.findActiveGroup(state.groups)
-    })
-  }
-
-  // private findActiveGroup(groups: NodesGroup[]): NodesGroup {
-  //   return nonNullable(groups.find(g => g.id === this.activeGroup.id), 'Active group not found in groups')
-  // }
-
-  override update(newstate: Partial<ActiveGroupState>): ActiveGroupMemory {
-    const nextstate = {
-      ...this.state,
-      ...newstate,
-    }
-    // const activeGroup = this.findActiveGroup(nextstate.groups)
-    // invariant(Object.is(activeGroup, nextstate.activeGroup), 'Active group must strictly equal to the group in groups')
-    return new ActiveGroupMemory(nextstate, this.scope, this.stack)
-  }
-
-  override stageInclude(expr: StageExpression<Ctx>): ActiveGroupStageInclude {
-    return new ActiveGroupStageInclude(this, expr)
-  }
-  override stageExclude(expr: StageExpression<Ctx>): ActiveGroupStageExclude {
-    return new ActiveGroupStageExclude(this, expr)
-  }
-
-  public leave(): Memory {
-    const state = this.mutableState()
-    this.stack.pop()
-    const prevgroup = this.stack.peek()
-    if (prevgroup) {
-      return new ActiveGroupMemory(state, this.scope, this.stack)
-    }
-    return new Memory(state, this.scope)
-  }
-}

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

@@ -1,59 +0,0 @@
-import { filter, forEach, pipe } from 'remeda'
-import type { RelationshipModel } from '../../../model/RelationModel'
-import { difference, hasIntersection, intersection } from '../../../utils/set'
-import { AbstractStageExclude, type MutableState, type StageExpression } from '../../memory'
-import { type ActiveGroupCtx, type ActiveGroupMemory, type Ctx } from './memory'
-
-export class StageExclude<C extends Ctx = Ctx> extends AbstractStageExclude<C> {
-  public excludeRelations(excluded: ReadonlySet<RelationshipModel<any>>): this {
-    pipe(
-      this.memory.connections,
-      filter(c => hasIntersection(c.relations, excluded)),
-      forEach(c => {
-        this.excludeConnections(
-          c.update(intersection(c.relations, excluded)),
-        )
-      }),
-    )
-    return this
-  }
-
-  /**
-   * Precommit hook
-   */
-  protected override precommit(state: MutableState<C>): MutableState<C> {
-    if (this.excluded.elements.size > 0) {
-      const excludeRelationships = new Set(
-        [...this.excluded.elements].flatMap(el => [
-          ...el.incoming('direct'),
-          ...el.outgoing('direct'),
-        ]),
-      )
-      this.excludeRelations(excludeRelationships)
-    }
-    return state
-  }
-
-  protected override postcommit(state: C['MutableState']) {
-    const leftExplicits = difference(this.memory.explicits, state.explicits)
-    for (const explicit of leftExplicits) {
-      state.explicitFirstSeenIn.delete(explicit)
-    }
-
-    // Left elements
-    const left = difference(this.memory.elements, state.elements)
-    for (const el of left) {
-      state.lastSeenIn.delete(el)
-    }
-    return state
-  }
-}
-
-export class ActiveGroupStageExclude extends StageExclude {
-  constructor(
-    public override readonly memory: ActiveGroupMemory,
-    public override readonly expression: StageExpression<ActiveGroupCtx>,
-  ) {
-    super(memory, expression)
-  }
-}