@likec4/core 1.40.0 → 1.42.0

package/src/compute-view/element-view/predicates/relation-direct.ts

@@ -1,321 +0,0 @@
-import { concat, constant, filter, flatMap, hasAtLeast, map, partition, pipe, piped, prop, when } from 'remeda'
-import type { ElementModel, RelationshipModel } from '../../../model'
-import { ConnectionModel } from '../../../model'
-import { type AnyAux, type ModelRelationExpr, FqnRef, ModelFqnExpr } from '../../../types'
-import { invariant, isSameHierarchy } from '../../../utils'
-import { ifilter, iflat, iunique, toArray, toSet } from '../../../utils/iterable'
-import { intersection, union } from '../../../utils/set'
-import type { Elem, PredicateCtx, PredicateExecutor } from '../_types'
-import { NoWhere } from '../utils'
-import {
-  findConnectionsBetween,
-  findConnectionsWithin,
-  includeDescendantsFromMemory,
-  resolveAndIncludeFromMemory,
-  resolveElements,
-} from './_utils'
-
-const isWildcard = ModelFqnExpr.isWildcard
-const isAncestorOrDescendantOf = (a: ElementModel<AnyAux>, b: ElementModel<AnyAux>) =>
-  a.isAncestorOf(b) || a.isDescendantOf(b)
-
-export const DirectRelationExprPredicate: PredicateExecutor<ModelRelationExpr.Direct<AnyAux>> = {
-  include: ({ expr: { source, target, isBidirectional = false }, memory, model, stage, where, filterWhere }) => {
-    const sourceIsWildcard = isWildcard(source)
-    const targetIsWildcard = isWildcard(target)
-
-    const connections = [] as ConnectionModel<AnyAux>[]
-    switch (true) {
-      // This is a special case, we look for all relationships that satisfy the where clause
-      // * -> * ; Empty memory; Where clause
-      case sourceIsWildcard && targetIsWildcard && memory.isEmpty() && where !== NoWhere: {
-        const connections = pipe(
-          model.relationships(),
-          ifilter(where),
-          toArray(),
-          map(r => new ConnectionModel(r.source, r.target, new Set([r]))),
-        )
-        stage.addConnections(connections)
-        return stage
-      }
-
-      // This is a special case, we look for all relationships between elements that satisfy the where clause
-      // * -> *; Not empty memory; Where clause
-      case sourceIsWildcard && targetIsWildcard && !memory.isEmpty() && where !== NoWhere: {
-        connections.push(
-          ...findConnectionsWithin(memory.elements),
-        )
-        break
-      }
-
-      // * -> *
-      case sourceIsWildcard && targetIsWildcard: {
-        connections.push(
-          ...findConnectionsWithin(model.roots()),
-        )
-        break
-      }
-
-      // This is a special case, we look for all relationships that satisfy the where clause
-      // element -> *; Where clause
-      case !sourceIsWildcard && targetIsWildcard && where !== NoWhere: {
-        const sources = resolveElements(model, source)
-        const connections = pipe(
-          sources,
-          flatMap(source =>
-            pipe(
-              source,
-              when(constant(isBidirectional === true), {
-                onTrue: s => union(s.allIncoming, s.allOutgoing),
-                onFalse: s => s.allOutgoing,
-              }),
-              ifilter(where),
-              iunique(),
-              toArray(),
-              partition(r => r.source === source),
-              ([outgoing, incoming]) =>
-                concat(
-                  pipe(
-                    outgoing,
-                    filter(r => !isAncestorOrDescendantOf(source, r.target)),
-                    map(outgoing =>
-                      new ConnectionModel(
-                        source,
-                        outgoing.target,
-                        new Set([outgoing]),
-                      )
-                    ),
-                  ),
-                  pipe(
-                    incoming,
-                    filter(r => !isAncestorOrDescendantOf(source, r.source)),
-                    map(incoming =>
-                      new ConnectionModel(
-                        incoming.source,
-                        source,
-                        new Set([incoming]),
-                      )
-                    ),
-                  ),
-                ),
-            )
-          ),
-        )
-        stage.addConnections(connections)
-        return stage
-      }
-
-      // element -> *
-      case !sourceIsWildcard && targetIsWildcard: {
-        const [sources, targets] = resolveWildcard(source, { memory, model })
-        const dir = isBidirectional ? 'both' : 'directed'
-        for (const source of sources) {
-          connections.push(
-            ...findConnectionsBetween(source, targets, dir),
-          )
-        }
-        break
-      }
-
-      // This is a special case, we look for all relationships that satisfy the where clause
-      // * -> element; Where clause
-      case sourceIsWildcard && !targetIsWildcard && where !== NoWhere: {
-        const targets = resolveElements(model, target)
-        const connections = pipe(
-          targets,
-          flatMap(target =>
-            pipe(
-              target,
-              when(constant(isBidirectional === true), {
-                onTrue: s => union(s.allIncoming, s.allOutgoing),
-                onFalse: s => s.allIncoming,
-              }),
-              ifilter(where),
-              toArray(),
-              partition(r => r.target === target),
-              ([incoming, outgoing]) =>
-                concat(
-                  pipe(
-                    outgoing,
-                    filter(r => !isAncestorOrDescendantOf(target, r.target)),
-                    map(outgoing =>
-                      new ConnectionModel(
-                        target,
-                        outgoing.target,
-                        new Set([outgoing]),
-                      )
-                    ),
-                  ),
-                  pipe(
-                    incoming,
-                    filter(r => !isAncestorOrDescendantOf(target, r.source)),
-                    map(incoming =>
-                      new ConnectionModel(
-                        incoming.source,
-                        target,
-                        new Set([incoming]),
-                      )
-                    ),
-                  ),
-                ),
-            )
-          ),
-        )
-        stage.addConnections(connections)
-        return stage
-      }
-
-      // * -> element
-      case sourceIsWildcard && !targetIsWildcard: {
-        const [targets, sources] = resolveWildcard(target, { memory, model })
-        const dir = isBidirectional ? 'both' : 'directed'
-        for (const source of sources) {
-          connections.push(
-            ...findConnectionsBetween(source, targets, dir),
-          )
-        }
-        break
-      }
-
-      default: {
-        invariant(!isWildcard(source), 'Inference failed - source must be not a wildcard')
-        invariant(!isWildcard(target), 'Inference failed - target must be not a wildcard')
-        const sources = resolveAndIncludeFromMemory(source, { memory, model })
-        const targets = resolveAndIncludeFromMemory(target, { memory, model })
-        const dir = isBidirectional ? 'both' : 'directed'
-        for (const source of sources) {
-          connections.push(
-            ...findConnectionsBetween(source, targets, dir),
-          )
-        }
-      }
-    }
-
-    stage.addConnections(
-      filterWhere(connections),
-    )
-
-    return stage
-  },
-  exclude: ({ expr: { source, target, isBidirectional }, model, memory, stage, where }) => {
-    const sourceIsWildcard = isWildcard(source)
-    const targetIsWildcard = isWildcard(target)
-
-    let relations: Set<RelationshipModel<AnyAux>>
-
-    switch (true) {
-      // * -> *
-      case sourceIsWildcard && targetIsWildcard: {
-        relations = pipe(
-          memory.connections,
-          flatMap(piped(
-            prop('relations'),
-            ifilter(where),
-            toArray(),
-          )),
-          toSet(),
-        )
-        break
-      }
-
-      // element -> *
-      case !sourceIsWildcard && targetIsWildcard: {
-        const sources = resolveElements(model, source)
-        relations = pipe(
-          sources,
-          flatMap(source =>
-            pipe(
-              source,
-              when(constant(isBidirectional === true), {
-                onTrue: s => union(s.allIncoming, s.allOutgoing),
-                onFalse: s => s.allOutgoing,
-              }),
-              ifilter(where),
-              toArray(),
-            )
-          ),
-          toSet(),
-        )
-        break
-      }
-
-      // * -> element
-      case sourceIsWildcard && !targetIsWildcard: {
-        const targets = resolveElements(model, target)
-        relations = pipe(
-          targets,
-          flatMap(target =>
-            pipe(
-              target,
-              when(constant(isBidirectional === true), {
-                onTrue: s => union(s.allIncoming, s.allOutgoing),
-                onFalse: s => s.allIncoming,
-              }),
-              ifilter(where),
-              toArray(),
-            )
-          ),
-          toSet(),
-        )
-        break
-      }
-
-      default: {
-        invariant(!isWildcard(source), 'Inferrence failed - source must be not a wildcard')
-        invariant(!isWildcard(target), 'Inferrence failed - target must be not a wildcard')
-        const sources = resolveElements(model, source)
-        const targets = resolveElements(model, target)
-
-        let accum = new Set<RelationshipModel<AnyAux>>()
-        for (const source of sources) {
-          for (const target of targets) {
-            if (isSameHierarchy(source, target)) {
-              continue
-            }
-            accum = union(
-              accum,
-              intersection(source.allOutgoing, target.allIncoming),
-              isBidirectional ? intersection(target.allOutgoing, source.allIncoming) : new Set(),
-            )
-          }
-        }
-
-        relations = toSet(ifilter(accum, where))
-      }
-    }
-
-    stage.excludeRelations(relations)
-    return stage
-  },
-}
-
-/**
- * Resolve elements for both source and target, when one of them is a wildcard
- */
-function resolveWildcard(
-  nonWildcard: ModelFqnExpr.NonWildcard,
-  { memory, model }: Pick<PredicateCtx, 'model' | 'memory'>,
-): [elements: Elem[], wildcard: Elem[]] {
-  let sources = resolveElements(model, nonWildcard)
-  if (!hasAtLeast(sources, 1)) {
-    return [[], []]
-  }
-
-  if (ModelFqnExpr.isModelRef(nonWildcard)) {
-    const parent = model.element(FqnRef.flatten(nonWildcard.ref))
-    const targets = toArray(parent.ascendingSiblings())
-    return [
-      includeDescendantsFromMemory(sources, memory),
-      includeDescendantsFromMemory(targets, memory),
-    ]
-  }
-  const targets = pipe(
-    sources,
-    map(el => el.ascendingSiblings()),
-    iflat(),
-    iunique(),
-    toArray(),
-    all => includeDescendantsFromMemory(all, memory),
-  )
-  return [sources, targets]
-}

package/src/compute-view/element-view/predicates/relation-in-out.ts

@@ -1,64 +0,0 @@
-import { unique } from 'remeda'
-import { type ConnectionModel } from '../../../model'
-import type { RelationshipModel } from '../../../model'
-import { type AnyAux, type ModelRelationExpr, ModelFqnExpr } from '../../../types'
-import { toArray, toSet } from '../../../utils/iterable/to'
-import type { PredicateExecutor } from '../_types'
-import { findConnectionsBetween, resolveAndIncludeFromMemory, resolveElements } from './_utils'
-
-export const InOutRelationPredicate: PredicateExecutor<ModelRelationExpr.InOut<AnyAux>> = {
-  include: ({ expr: { inout }, scope, model, memory, stage, filterWhere }) => {
-    const connections = [] as ConnectionModel<AnyAux>[]
-    if (ModelFqnExpr.isWildcard(inout)) {
-      if (!scope) {
-        return
-      }
-      connections.push(
-        ...findConnectionsBetween(
-          scope,
-          scope.ascendingSiblings(),
-        ),
-      )
-    } else {
-      const elements = resolveAndIncludeFromMemory(inout, { memory, model })
-      let visibleElements = [...memory.elements]
-      if (visibleElements.length === 0) {
-        visibleElements = unique(
-          elements.flatMap(el => toArray(el.ascendingSiblings())),
-        )
-      }
-      for (const el of elements) {
-        connections.push(
-          ...findConnectionsBetween(
-            el,
-            visibleElements,
-          ),
-        )
-      }
-    }
-
-    stage.addConnections(
-      filterWhere(connections),
-    )
-
-    return stage
-  },
-  exclude: ({ expr: { inout }, model, scope, stage, where }) => {
-    const excluded = [] as RelationshipModel[]
-    if (ModelFqnExpr.isWildcard(inout)) {
-      if (!scope) {
-        return
-      }
-      excluded.push(...scope.allOutgoing)
-      excluded.push(...scope.allIncoming)
-    } else {
-      const elements = resolveElements(model, inout)
-      excluded.push(
-        ...elements.flatMap(e => [...e.allOutgoing, ...e.allIncoming]),
-      )
-    }
-    stage.excludeRelations(toSet(excluded.filter(where)))
-
-    return stage
-  },
-}

package/src/compute-view/element-view/predicates/relation-in.ts

@@ -1,115 +0,0 @@
-import { anyPass, unique } from 'remeda'
-import { type ConnectionModel, type LikeC4Model, type RelationshipModel, Connection } from '../../../model'
-import type { ModelRelationExpr } from '../../../types'
-import { type AnyAux, FqnRef, ModelFqnExpr } from '../../../types'
-import { nonexhaustive } from '../../../utils'
-import { elementExprToPredicate } from '../../utils/elementExpressionToPredicate'
-import type { ConnectionWhere, PredicateExecutor } from '../_types'
-import { findConnection, findConnectionsBetween, resolveAndIncludeFromMemory, resolveElements } from './_utils'
-
-export const IncomingExprPredicate: PredicateExecutor<ModelRelationExpr.Incoming<AnyAux>> = {
-  include: ({ expr, scope, model, memory, stage, filterWhere }) => {
-    const target = expr.incoming
-    const connections = [] as ConnectionModel<AnyAux>[]
-    if (ModelFqnExpr.isWildcard(target)) {
-      if (!scope) {
-        return
-      }
-      for (const sibling of scope.ascendingSiblings()) {
-        connections.push(
-          ...findConnection(
-            sibling,
-            scope,
-            'directed',
-          ),
-        )
-      }
-    } else {
-      const targets = resolveAndIncludeFromMemory(target, { memory, model })
-      const visibleElements = [...memory.elements]
-      if (visibleElements.length === 0) {
-        visibleElements.push(
-          ...unique(
-            targets.flatMap(el => [...el.ascendingSiblings()]),
-          ),
-        )
-      }
-      const ensureIncoming = incomingConnectionPredicate(model, target)
-      for (const visible of visibleElements) {
-        connections.push(
-          ...findConnectionsBetween(
-            visible,
-            targets,
-            'directed',
-          ).filter(ensureIncoming),
-        )
-      }
-    }
-
-    stage.addConnections(
-      filterWhere(connections),
-    )
-
-    return stage
-  },
-  exclude: ({ expr: { incoming }, model, scope, stage, where }) => {
-    const excluded = [] as RelationshipModel[]
-    if (ModelFqnExpr.isWildcard(incoming)) {
-      if (!scope) {
-        return
-      }
-      excluded.push(...scope.allIncoming)
-    } else {
-      const elements = resolveElements(model, incoming)
-      excluded.push(
-        ...elements.flatMap(e => [...e.allIncoming]),
-      )
-    }
-    stage.excludeRelations(new Set(excluded.filter(where)))
-
-    return stage
-  },
-}
-
-export function incomingConnectionPredicate(
-  model: LikeC4Model,
-  expr: ModelFqnExpr.NonWildcard,
-): ConnectionWhere {
-  switch (true) {
-    case ModelFqnExpr.isElementKindExpr(expr):
-    case ModelFqnExpr.isElementTagExpr(expr): {
-      const isElement = elementExprToPredicate(expr)
-      return (connection) => isElement(connection.target)
-    }
-    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'children': {
-      const fqn = FqnRef.flatten(expr.ref)
-      return anyPass(
-        [...model.children(fqn)].map(
-          el => Connection.isIncoming(el.id),
-        ),
-      )
-    }
-    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'descendants': {
-      const fqn = FqnRef.flatten(expr.ref)
-      return anyPass([
-        Connection.isInside(fqn),
-        ...[...model.children(fqn)].map(
-          el => Connection.isIncoming(el.id),
-        ),
-      ])
-    }
-    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
-      const fqn = FqnRef.flatten(expr.ref)
-      return anyPass([
-        Connection.isIncoming(fqn),
-        Connection.isInside(fqn),
-      ])
-    }
-    case ModelFqnExpr.isModelRef(expr): {
-      const fqn = FqnRef.flatten(expr.ref)
-      return Connection.isIncoming(fqn)
-    }
-    default:
-      nonexhaustive(expr)
-  }
-}

package/src/compute-view/element-view/predicates/relation-out.ts

@@ -1,119 +0,0 @@
-import { anyPass, unique } from 'remeda'
-import type { LikeC4Model, RelationshipModel } from '../../../model'
-import { type ConnectionModel, Connection } from '../../../model'
-import type { AnyAux } from '../../../types'
-import { type ModelRelationExpr, FqnRef, ModelFqnExpr } from '../../../types'
-import { nonexhaustive } from '../../../utils'
-import { toSet } from '../../../utils/iterable/to'
-import { elementExprToPredicate } from '../../utils/elementExpressionToPredicate'
-import type { ConnectionWhere, PredicateExecutor } from '../_types'
-import { findConnectionsBetween, resolveAndIncludeFromMemory, resolveElements } from './_utils'
-
-export const OutgoingExprPredicate: PredicateExecutor<ModelRelationExpr.Outgoing<AnyAux>> = {
-  include: ({ expr, scope, model, memory, stage, filterWhere }) => {
-    const target = expr.outgoing
-    const connections = [] as ConnectionModel<AnyAux>[]
-    if (ModelFqnExpr.isWildcard(target)) {
-      if (!scope) {
-        return
-      }
-
-      connections.push(
-        ...findConnectionsBetween(
-          scope,
-          scope.ascendingSiblings(),
-          'directed',
-        ),
-      )
-    } else {
-      const elements = resolveAndIncludeFromMemory(target, { memory, model })
-      const visibleElements = [...memory.elements]
-      if (visibleElements.length === 0) {
-        visibleElements.push(
-          ...unique(
-            elements.flatMap(el => [...el.ascendingSiblings()]),
-          ),
-        )
-      }
-      const ensureOutgoing = outgoingConnectionPredicate(model, target)
-
-      for (const source of elements) {
-        connections.push(
-          ...findConnectionsBetween(
-            source,
-            visibleElements,
-            'directed',
-          ).filter(ensureOutgoing),
-        )
-      }
-    }
-
-    stage.addConnections(
-      filterWhere(connections),
-    )
-
-    return stage
-  },
-  exclude: ({ expr: { outgoing }, model, scope, stage, where }) => {
-    const excluded = [] as RelationshipModel[]
-    if (ModelFqnExpr.isWildcard(outgoing)) {
-      if (!scope) {
-        return
-      }
-      excluded.push(...scope.allOutgoing)
-    } else {
-      const elements = resolveElements(model, outgoing)
-      excluded.push(
-        ...elements.flatMap(e => [...e.allOutgoing]),
-      )
-    }
-    stage.excludeRelations(
-      toSet(excluded.filter(where)),
-    )
-
-    return stage
-  },
-}
-
-export function outgoingConnectionPredicate(
-  model: LikeC4Model,
-  expr: ModelFqnExpr.NonWildcard,
-): ConnectionWhere {
-  switch (true) {
-    case ModelFqnExpr.isElementKindExpr(expr):
-    case ModelFqnExpr.isElementTagExpr(expr): {
-      const isElement = elementExprToPredicate(expr)
-      return (connection) => isElement(connection.source)
-    }
-    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'children': {
-      const fqn = FqnRef.flatten(expr.ref)
-      return anyPass(
-        [...model.children(fqn)].map(
-          el => Connection.isOutgoing(el.id),
-        ),
-      )
-    }
-    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'descendants': {
-      const fqn = FqnRef.flatten(expr.ref)
-      return anyPass([
-        Connection.isInside(fqn),
-        ...[...model.children(fqn)].map(
-          el => Connection.isOutgoing(el.id),
-        ),
-      ])
-    }
-    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
-      const fqn = FqnRef.flatten(expr.ref)
-      return anyPass([
-        Connection.isOutgoing(fqn),
-        Connection.isInside(fqn),
-      ])
-    }
-    case ModelFqnExpr.isModelRef(expr): {
-      const fqn = FqnRef.flatten(expr.ref)
-      return Connection.isOutgoing(fqn)
-    }
-    default:
-      nonexhaustive(expr)
-  }
-}

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

@@ -1,88 +0,0 @@
-import { filter } from 'remeda'
-import type { ModelFqnExpr } from '../../../types'
-import { ifilter, toArray } from '../../../utils/iterable'
-import { toSet } from '../../../utils/iterable/to'
-import { type PredicateExecutor, Memory } from '../_types'
-import { NoWhere } from '../utils'
-import { findConnectionsBetween, findConnectionsWithin } from './_utils'
-
-export const WildcardPredicate: PredicateExecutor<ModelFqnExpr.Wildcard> = {
-  include: ({ scope, model, stage, memory, where }) => {
-    if (!scope) {
-      const rootElements = [...model.roots()].filter(where)
-      if (rootElements.length === 0) {
-        return
-      }
-      stage.addExplicit(rootElements)
-      stage.addConnections(findConnectionsWithin(rootElements))
-
-      stage.connectWithExisting(rootElements)
-
-      return stage
-    }
-    const root = where(scope) ? scope : null
-
-    const children = toArray(ifilter(scope.children(), where))
-    const hasChildren = children.length > 0
-    if (!hasChildren) {
-      if (!root) {
-        return stage
-      } else {
-        // Any edges with siblings?
-        const edgesWithSiblings = findConnectionsBetween(root, root.siblings())
-        if (edgesWithSiblings.length === 0) {
-          // If no edges with siblings, i.e. root is orphan
-          // Lets add parent for better view
-          const parent = root.parent
-          if (parent && where(parent)) {
-            stage.addExplicit(parent)
-          }
-        }
-        children.push(root)
-      }
-    }
-
-    if (root) {
-      stage.addExplicit(root)
-    }
-
-    const neighbours = toSet([
-      ...memory.elements,
-      ...scope.descendingSiblings(),
-    ])
-
-    // Add incoming connections
-    for (const neighbour of neighbours) {
-      stage.addConnections(findConnectionsBetween(neighbour, children, 'directed'))
-    }
-
-    // connection between children
-    if (hasChildren) {
-      stage.addConnections(findConnectionsWithin(children))
-      stage.addExplicit(children)
-    }
-
-    // Add outgoing connections
-    for (const child of children) {
-      stage.addConnections(findConnectionsBetween(child, neighbours, 'directed'))
-    }
-
-    return stage
-  },
-  exclude: ({ scope, memory, stage, where }) => {
-    if (where !== NoWhere) {
-      stage.exclude(
-        filter(
-          [...memory.elements],
-          where,
-        ),
-      )
-      return stage
-    }
-    if (scope) {
-      stage.exclude([scope, ...scope.descendants()])
-      return stage
-    }
-    return Memory.empty(memory.scope).stageExclude(stage.expression)
-  },
-}