@likec4/core 1.41.0 → 1.42.1

package/src/model/connection/model/ConnectionModel.ts

@@ -1,158 +0,0 @@
-import { isNot } from 'remeda'
-import type { AnyAux, aux, Unknown } from '../../../types'
-import { invariant } from '../../../utils'
-import { customInspectSymbol } from '../../../utils/const'
-import { ifilter, isome } from '../../../utils/iterable'
-import { difference, equals, intersection, union } from '../../../utils/set'
-import { stringHash } from '../../../utils/string-hash'
-import type { ElementModel } from '../../ElementModel'
-import type { RelationshipModel } from '../../RelationModel'
-import type { Connection } from '../Connection'
-import { hasSameSourceTarget } from '../ops'
-import { findConnection } from './find'
-
-/**
- * Connection refers to any relationships between two elements,
- * both direct and implicit ones (between their nested elements).
- *
- * Merges relationships together to an single edge on the diagram.
- */
-export class ConnectionModel<A extends AnyAux = Unknown> implements Connection<ElementModel<A>, aux.EdgeId> {
-  public readonly id: aux.EdgeId
-
-  constructor(
-    public readonly source: ElementModel<A>,
-    public readonly target: ElementModel<A>,
-    public readonly relations: ReadonlySet<RelationshipModel<A>> = new Set(),
-  ) {
-    this.id = stringHash(`model:${source.id}:${target.id}`) as aux.EdgeId
-  }
-
-  private _boundary: ElementModel<A> | null | undefined
-  /**
-   * Common ancestor of the source and target elements.
-   * Represents the boundary of the connection.
-   */
-  get boundary(): ElementModel<A> | null {
-    return this._boundary ??= this.source.commonAncestor(this.target)
-  }
-
-  /**
-   * Human readable expression of the connection
-   * Mostly used for testing and debugging
-   */
-  get expression(): string {
-    return `${this.source.id} -> ${this.target.id}`
-  }
-
-  /**
-   * Returns true if only includes relations between the source and target elements.
-   */
-  get isDirect(): boolean {
-    return this.nonEmpty() && !this.isImplicit
-  }
-
-  /**
-   * Returns true if includes relations between nested elements of the source and target elements.
-   */
-  get isImplicit(): boolean {
-    return this.nonEmpty() && isome(this.relations, isNot(hasSameSourceTarget(this)))
-  }
-
-  get directRelations(): ReadonlySet<RelationshipModel<A>> {
-    return new Set(ifilter(this.relations, hasSameSourceTarget(this)))
-  }
-
-  nonEmpty(): boolean {
-    return this.relations.size > 0
-  }
-
-  mergeWith(other: ConnectionModel<A>) {
-    invariant(this.source.id === other.source.id, 'Cannot merge connections with different sources')
-    invariant(this.target.id === other.target.id, 'Cannot merge connections with different targets')
-    return new ConnectionModel(
-      this.source,
-      this.target,
-      union(this.relations, other.relations),
-    )
-  }
-
-  difference(other: ConnectionModel<A>) {
-    return new ConnectionModel(
-      this.source,
-      this.target,
-      difference(this.relations, other.relations),
-    )
-  }
-
-  intersect(other: ConnectionModel<A>) {
-    invariant(other instanceof ConnectionModel, 'Cannot intersect connection with different type')
-    return new ConnectionModel(
-      this.source,
-      this.target,
-      intersection(this.relations, other.relations),
-    )
-  }
-
-  equals(other: Connection): boolean {
-    invariant(other instanceof ConnectionModel, 'Cannot merge connection with different type')
-    const _other = other as ConnectionModel<A>
-    return this.id === _other.id
-      && this.source.id === _other.source.id
-      && this.target.id === _other.target.id
-      && equals(this.relations, _other.relations)
-  }
-
-  /**
-   * Returns a new instance with the updated relations.
-   *
-   * @param relations - A readonly set of `RelationshipModel` instances representing the new relations.
-   * @returns A new `ConnectionModel` instance with the updated relations.
-   */
-  update(relations: ReadonlySet<RelationshipModel<A>>): ConnectionModel<A> {
-    return new ConnectionModel(
-      this.source,
-      this.target,
-      relations,
-    )
-  }
-
-  [customInspectSymbol](
-    // @ts-ignore
-    depth,
-    // @ts-ignore
-    inspectOptions,
-    // @ts-ignore
-    inspect,
-  ) {
-    const asString = this.toString()
-
-    // Trick so that node displays the name of the constructor
-    Object.defineProperty(asString, 'constructor', {
-      value: ConnectionModel,
-      enumerable: false,
-    })
-
-    return asString
-  }
-
-  toString() {
-    return [
-      this.expression,
-      this.relations.size ? '  relations:' : '  relations: [ ]',
-      ...[...this.relations].map(c => '    ' + c.expression),
-    ].join('\n')
-  }
-
-  /**
-   * Creates a new connection with reversed direction (target becomes source and vice versa)
-   * @param search - When true, attempts to find an existing connection between the reversed nodes
-   */
-  reversed(search = false): ConnectionModel<A> {
-    if (!search) {
-      return new ConnectionModel(this.target, this.source)
-    }
-    const [found] = findConnection(this.target, this.source, 'directed')
-    return found ?? new ConnectionModel(this.target, this.source, new Set())
-  }
-}

package/src/model/connection/model/find.ts

@@ -1,117 +0,0 @@
-import type { AnyAux } from '../../../types'
-import { isSameHierarchy } from '../../../utils/fqn'
-import { intersection } from '../../../utils/set'
-import type { ElementModel } from '../../ElementModel'
-import { ConnectionModel } from './ConnectionModel'
-
-/**
- * Resolve connection from source to target
- *
- * @param direction - if 'both', also returns connection from target to source
- * @default `directed`
- */
-export function findConnection<A extends AnyAux>(
-  source: ElementModel<A>,
-  target: ElementModel<A>,
-  direction: 'directed' | 'both' = 'directed',
-):
-  | [ConnectionModel<A>, ConnectionModel<A>]
-  | [ConnectionModel<A>]
-  | []
-{
-  if (source === target) {
-    return []
-  }
-  if (isSameHierarchy(source, target)) {
-    return []
-  }
-
-  const directedIntersection = intersection(source.allOutgoing, target.allIncoming)
-
-  const directed = directedIntersection.size > 0
-    ? new ConnectionModel(
-      source,
-      target,
-      directedIntersection,
-    )
-    : null
-
-  if (direction === 'directed') {
-    return directed ? [directed] : []
-  }
-
-  const reverseIntersection = intersection(source.allIncoming, target.allOutgoing)
-  const reverse = reverseIntersection.size > 0
-    ? new ConnectionModel(
-      target,
-      source,
-      reverseIntersection,
-    )
-    : null
-
-  if (directed && reverse) {
-    return [directed, reverse]
-  }
-  if (directed) {
-    return [directed]
-  }
-  if (reverse) {
-    return [reverse]
-  }
-
-  return []
-}
-
-/**
- * Resolve all connections between element and others
- * @param direction - if 'directed', only look for outgoing connections from the element to others
- * @default `both`
- */
-export function findConnectionsBetween<M extends AnyAux>(
-  element: ElementModel<M>,
-  others: Iterable<ElementModel<M>>,
-  direction: 'directed' | 'both' = 'both',
-): readonly ConnectionModel<M>[] {
-  if (element.allIncoming.size === 0 && element.allOutgoing.size === 0) {
-    return []
-  }
-
-  // We separate resolved connection,
-  // because we want return outgoing first
-  const outgoing = [] as ConnectionModel<M>[]
-  const incoming = [] as ConnectionModel<M>[]
-  for (const _other of others) {
-    if (element === _other) {
-      continue
-    }
-    for (const found of findConnection(element, _other, direction)) {
-      if (found.source === element) {
-        outgoing.push(found)
-      } else {
-        incoming.push(found)
-      }
-    }
-  }
-  return [
-    ...outgoing,
-    ...incoming,
-  ]
-}
-
-/**
- * Resolve all connections within a given set of elements
- */
-export function findConnectionsWithin<M extends AnyAux>(
-  elements: Iterable<ElementModel<M>>,
-): readonly ConnectionModel<M>[] {
-  return [...elements].reduce((acc, el, index, array) => {
-    // skip for last element
-    if (index === array.length - 1) {
-      return acc
-    }
-    acc.push(
-      ...findConnectionsBetween(el, array.slice(index + 1), 'both'),
-    )
-    return acc
-  }, [] as ConnectionModel<M>[])
-}

package/src/model/connection/model/index.ts

@@ -1,8 +0,0 @@
-export { Connection } from '../Connection'
-export { ConnectionModel } from './ConnectionModel'
-
-export {
-  findConnection,
-  findConnectionsBetween,
-  findConnectionsWithin,
-} from './find'

package/src/model/connection/ops.ts

@@ -1,276 +0,0 @@
-import { map, pipe } from 'remeda'
-import type { IterableContainer, ReorderedArray } from '../../types'
-import { isString } from '../../utils'
-import {
-  isAncestor,
-  isDescendantOf,
-  sortNaturalByFqn,
-} from '../../utils/fqn'
-import type { Connection } from './Connection'
-
-/**
- * Check if connection is nested inside another connection
- * (i.e. between descendants)
- */
-export function isNestedConnection<T extends { id: string }>(
-  parent: WithSourceTarget<NoInfer<T>>,
-): (nested: WithSourceTarget<T>) => boolean
-export function isNestedConnection<T extends { id: string }>(
-  nested: WithSourceTarget<T>,
-  parent: WithSourceTarget<T>,
-): boolean
-export function isNestedConnection<T extends { id: string }>(
-  nested: WithSourceTarget<T>,
-  parent?: WithSourceTarget<T>,
-) {
-  if (!parent) {
-    const p = nested
-    return (n: WithSourceTarget<T>) => isNestedConnection(n, p)
-  }
-  const isSameSource = nested.source === parent.source
-  const isSameTarget = nested.target === parent.target
-  if (isSameSource && isSameTarget) {
-    return false
-  }
-  const isSourceNested = isAncestor(parent.source.id, nested.source.id)
-  const isTargetNested = isAncestor(parent.target.id, nested.target.id)
-  return (
-    (isSourceNested && isTargetNested)
-    || (isSameSource && isTargetNested)
-    || (isSameTarget && isSourceNested)
-  )
-}
-
-type ConnectionElemId = Connection<{ readonly id: string }, any>
-
-export function findDeepestNestedConnection<C extends ConnectionElemId>(
-  connections: ReadonlyArray<C>,
-  connection: C,
-): C | null {
-  let deepest = connection
-  for (const c of connections) {
-    if (isNestedConnection(c, deepest)) {
-      deepest = c
-    }
-  }
-  return deepest !== connection ? deepest : null
-}
-
-export function sortDeepestFirst<C extends ConnectionElemId>(
-  connections: ReadonlyArray<C>,
-): C[] {
-  const sorted = [] as C[]
-  const unsorted = connections.slice()
-  let next
-  while (next = unsorted.shift()) {
-    let deepest
-    while (deepest = findDeepestNestedConnection(unsorted, next)) {
-      const index = unsorted.indexOf(deepest)
-      sorted.push(unsorted.splice(index, 1)[0]!)
-    }
-    sorted.push(next)
-  }
-  return sorted
-}
-
-/**
- * To make {@link sortConnectionsByBoundaryHierarchy} work correctly we add '.' to boundary
- * Othwerwise connection without boundary will be considered same level as connection with top-level boundary
- */
-export function boundaryHierarchy<C extends WithBoundary>(conn: C): string {
-  return conn.boundary?.id ? `.${conn.boundary.id}` : ''
-}
-
-type WithBoundary = {
-  id: string
-  boundary: null | { id: string }
-}
-export function sortConnectionsByBoundaryHierarchy(
-  sort?: 'asc' | 'desc',
-): <T extends WithBoundary, A extends IterableContainer<T>>(array: A) => ReorderedArray<A>
-export function sortConnectionsByBoundaryHierarchy<T extends WithBoundary, A extends IterableContainer<T>>(
-  array: A,
-  sort?: 'asc' | 'desc',
-): ReorderedArray<A>
-export function sortConnectionsByBoundaryHierarchy<T extends WithBoundary, A extends IterableContainer<T>>(
-  connections?: A | 'asc' | 'desc',
-  sort?: 'asc' | 'desc',
-) {
-  if (!connections || isString(connections)) {
-    const dir = connections ?? 'asc'
-    return (arr: A) => _sortByBoundary(arr, dir)
-  }
-  return _sortByBoundary(connections, sort ?? 'asc')
-}
-
-function _sortByBoundary<C extends WithBoundary>(
-  connections: ReadonlyArray<C>,
-  order: 'asc' | 'desc',
-): C[] {
-  return pipe(
-    connections,
-    map(conn => ({
-      id: boundaryHierarchy(conn),
-      conn: conn,
-    })),
-    sortNaturalByFqn(order),
-    map(p => p.conn),
-  )
-}
-
-/**
- * Find connections that includes given connection (i.e between it's ancestors)
- */
-export function findAscendingConnections<C extends ConnectionElemId>(
-  connections: ReadonlyArray<C>,
-  connection: C,
-): Array<C> {
-  return connections.filter(c => isNestedConnection(connection, c))
-}
-
-/**
- * Find connections that given connection includes (i.e between it's descendants)
- */
-export function findDescendantConnections<C extends ConnectionElemId>(
-  connections: ReadonlyArray<C>,
-  connection: C,
-): Array<C> {
-  return connections.filter(isNestedConnection(connection))
-}
-
-export function mergeConnections<C extends IterableContainer<Connection<any, any>>>(
-  connections: C,
-): Array<C[number]> {
-  const map = new Map<C[number]['id'], C[number]>()
-  for (const conn of connections) {
-    const existing = map.get(conn.id)
-    if (existing) {
-      map.set(conn.id, conn.mergeWith(existing))
-    } else {
-      map.set(conn.id, conn)
-    }
-  }
-  return [...map.values()]
-}
-
-/**
- * Excludes the values existing in `other` array.
- * The output maintains the same order as the input.
- */
-export function differenceConnections<C extends Connection<any, any>>(
-  source: Iterable<C>,
-  exclude: Iterable<C>,
-): C[] {
-  const minus = new Map([...exclude].map(c => [c.id, c]))
-  return [...source].reduce((acc, c) => {
-    const other = minus.get(c.id)
-    if (!other) {
-      acc.push(c)
-      return acc
-    }
-    const updated = c.difference(other) as C
-    if (updated.nonEmpty()) {
-      acc.push(updated)
-    }
-    return acc
-  }, [] as C[])
-}
-
-type WithSourceTarget<T = unknown> = {
-  source: T
-  target: T
-}
-
-export function hasSameSourceTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean
-export function hasSameSourceTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean
-export function hasSameSourceTarget(a: WithSourceTarget, b?: WithSourceTarget) {
-  if (b) {
-    return a.source === b.source && a.target === b.target
-  }
-  return (b: WithSourceTarget) => a.source === b.source && a.target === b.target
-}
-
-export function hasSameSource<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean
-export function hasSameSource<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean
-export function hasSameSource(a: WithSourceTarget, b?: WithSourceTarget) {
-  if (b) {
-    return a.source === b.source
-  }
-  return (b: WithSourceTarget) => a.source === b.source
-}
-
-export function hasSameTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean
-export function hasSameTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean
-export function hasSameTarget(a: WithSourceTarget, b?: WithSourceTarget) {
-  if (b) {
-    return a.target === b.target
-  }
-  return (b: WithSourceTarget) => a.target === b.target
-}
-
-type WithId<T> = {
-  id: T
-}
-export function isOutgoing<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
-export function isOutgoing<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean
-export function isOutgoing<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, source?: WithId<T>) {
-  if (!source) {
-    const _source = a as WithId<T>
-    return (b: WithSourceTarget<WithId<T>>) => isOutgoing(b, _source)
-  }
-  const at = a as WithSourceTarget<WithId<T>>
-  return isDescendantOf(at.source, source) && !isDescendantOf(at.target, source)
-}
-
-export function isIncoming<T extends string>(target: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
-export function isIncoming<T extends string>(a: WithSourceTarget<WithId<T>>, target: WithId<T>): boolean
-export function isIncoming<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, target?: WithId<T>) {
-  if (!target) {
-    const _target = a as WithId<T>
-    return (b: WithSourceTarget<WithId<T>>) => isIncoming(b, _target)
-  }
-  const at = a as WithSourceTarget<WithId<T>>
-  return isDescendantOf(at.target, target) && !isDescendantOf(at.source, target)
-}
-
-export function isAnyInOut<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
-export function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean
-export function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, source?: WithId<T>) {
-  if (!source) {
-    const _source = a as WithId<T>
-    return (b: WithSourceTarget<WithId<T>>) => isAnyInOut(b, _source)
-  }
-  const at = a as WithSourceTarget<WithId<T>>
-  return isDescendantOf(at.source, source) !== isDescendantOf(at.target, source)
-}
-
-export function isInside<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
-export function isInside<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean
-export function isInside<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, source?: WithId<T>) {
-  if (!source) {
-    const _source = a as WithId<T>
-    return (b: WithSourceTarget<WithId<T>>) => isInside(b, _source)
-  }
-  const at = a as WithSourceTarget<WithId<T>>
-  return isDescendantOf(at.source, source) && isDescendantOf(at.target, source)
-}
-
-// export function isIncoming<T>(target: NoInfer<T>): (a: WithSourceTarget<T>) => boolean
-// export function isIncoming<T>(a: WithSourceTarget<T>, target: T): boolean
-// export function isIncoming<T = unknown>(a: WithSourceTarget<T> | T, target?: T) {
-//   if (target) {
-//     return (a as WithSourceTarget<T>).target === target
-//   }
-//   const _target = a as T
-//   return (b: WithSourceTarget) => b.target === _target
-// }
-
-// export function isAnyInOut<T>(source: NoInfer<T>): (a: WithSourceTarget<T>) => boolean
-// export function isAnyInOut<T>(a: WithSourceTarget<T>, source: T): boolean
-// export function isAnyInOut<T = unknown>(a: WithSourceTarget<T> | T, source?: T) {
-//   if (source) {
-//     return hasSameSource(a as WithSourceTarget<T>, source) || hasSameTarget(a as WithSourceTarget<T>, source)
-//   }
-//   const _source = a as T
-//   return (b: WithSourceTarget) => hasSameSource(b, _source) || hasSameTarget(b, _source)
-// }

package/src/model/guards.ts

@@ -1,77 +0,0 @@
-import type { Any, AnyAux } from '../types'
-import {
-  type DeploymentElementModel,
-  DeployedInstanceModel,
-  DeploymentNodeModel,
-  DeploymentRelationModel,
-  NestedElementOfDeployedInstanceModel,
-} from './DeploymentElementModel'
-import { ElementModel } from './ElementModel'
-import { type AnyRelationshipModel, RelationshipModel } from './RelationModel'
-import { EdgeModel } from './view/EdgeModel'
-import { LikeC4ViewModel } from './view/LikeC4ViewModel'
-import { NodeModel } from './view/NodeModel'
-
-type AnyModel<A extends AnyAux> =
-  | DeploymentNodeModel<A>
-  | DeployedInstanceModel<A>
-  | DeploymentRelationModel<A>
-  | AnyRelationshipModel<A>
-  | NestedElementOfDeployedInstanceModel<A>
-  | ElementModel<A>
-  | RelationshipModel<A>
-  | LikeC4ViewModel<A>
-  | NodeModel<A>
-  | EdgeModel<A>
-
-export function isDeploymentNodeModel<M extends AnyAux>(
-  model: AnyModel<M>,
-): model is DeploymentNodeModel<M> {
-  return model instanceof DeploymentNodeModel
-}
-
-export function isDeployedInstanceModel<M extends AnyAux>(
-  model: AnyModel<M>,
-): model is DeployedInstanceModel<M> {
-  return model instanceof DeployedInstanceModel
-}
-
-export function isDeploymentElementModel<M extends AnyAux>(model: AnyModel<M>): model is DeploymentElementModel<M> {
-  return isDeploymentNodeModel(model) || isDeployedInstanceModel(model)
-}
-
-export function isNestedElementOfDeployedInstanceModel<M extends AnyAux>(
-  model: AnyModel<M>,
-): model is NestedElementOfDeployedInstanceModel<M> {
-  return model instanceof NestedElementOfDeployedInstanceModel
-}
-
-export function isDeploymentRelationModel<M extends AnyAux>(
-  x: AnyModel<M>,
-): x is DeploymentRelationModel<M> {
-  return x instanceof DeploymentRelationModel
-}
-
-export function isRelationModel<M extends AnyAux>(x: AnyModel<M>): x is RelationshipModel<M> {
-  return x instanceof RelationshipModel
-}
-export {
-  isRelationModel as isModelRelation,
-  isRelationModel as isRelationshipModel,
-}
-
-export function isElementModel<M extends Any>(element: AnyModel<M>): element is ElementModel<M> {
-  return element instanceof ElementModel
-}
-
-export function isLikeC4ViewModel<M extends Any>(view: AnyModel<M>): view is LikeC4ViewModel<M> {
-  return view instanceof LikeC4ViewModel
-}
-
-export function isNodeModel<M extends Any>(node: AnyModel<M>): node is NodeModel<M> {
-  return node instanceof NodeModel
-}
-
-export function isEdgeModel<M extends Any>(edge: AnyModel<M>): edge is EdgeModel<M> {
-  return edge instanceof EdgeModel
-}