@likec4/core 1.41.0 → 1.42.0

package/src/model/RelationModel.ts

@@ -1,152 +0,0 @@
-import { isEmpty, isTruthy } from 'remeda'
-import type { AnyAux, Color, IteratorLike, Link, scalar } from '../types'
-import {
-  type Relationship,
-  type RelationshipLineType,
-  type RichTextOrEmpty,
-  DefaultLineStyle,
-  DefaultRelationshipColor,
-  FqnRef,
-  RichText,
-} from '../types'
-import type * as aux from '../types/_aux'
-import { commonAncestor } from '../utils/fqn'
-import type { DeploymentRelationModel } from './DeploymentElementModel'
-import type { ElementModel } from './ElementModel'
-import type { isDeploymentRelationModel } from './guards'
-import type { LikeC4Model } from './LikeC4Model'
-import type { WithMetadata, WithTags } from './types'
-import type { LikeC4ViewModel, ViewsIterator } from './view/LikeC4ViewModel'
-
-export type RelationshipsIterator<A extends AnyAux> = IteratorLike<RelationshipModel<A>>
-
-/**
- * A relationship between two elements (in logical or deployment model)
- * use {@link isDeploymentRelationModel} guard to check if the relationship is a deployment relationship
- */
-export interface AnyRelationshipModel<A extends AnyAux = AnyAux> extends WithTags<A>, WithMetadata<A> {
-  readonly id: scalar.RelationId
-  readonly expression: string
-  readonly title: string | null
-  readonly technology: string | null
-  readonly description: RichTextOrEmpty
-  readonly navigateTo: LikeC4ViewModel<A> | null
-  readonly kind: aux.RelationKind<A> | null
-  readonly links: ReadonlyArray<Link>
-  readonly color: Color
-  readonly line: RelationshipLineType
-  isDeploymentRelation(): this is DeploymentRelationModel<A>
-  isModelRelation(): this is RelationshipModel<A>
-  views(): ViewsIterator<A>
-}
-
-export class RelationshipModel<A extends AnyAux = AnyAux> implements AnyRelationshipModel<A> {
-  public readonly source: ElementModel<A>
-  public readonly target: ElementModel<A>
-
-  /**
-   * Common ancestor of the source and target elements.
-   * Represents the boundary of the Relation.
-   */
-  public readonly boundary: ElementModel<A> | null
-
-  constructor(
-    public readonly model: LikeC4Model<A>,
-    public readonly $relationship: Relationship<A>,
-  ) {
-    this.source = model.element(FqnRef.flatten($relationship.source))
-    this.target = model.element(FqnRef.flatten($relationship.target))
-    const parent = commonAncestor(this.source.id, this.target.id)
-    this.boundary = parent ? this.model.element(parent) : null
-  }
-
-  get id(): scalar.RelationId {
-    return this.$relationship.id
-  }
-
-  get expression(): string {
-    return `${this.source.id} -> ${this.target.id}`
-  }
-
-  get title(): string | null {
-    if (!isTruthy(this.$relationship.title)) {
-      return null
-    }
-    return this.$relationship.title
-  }
-
-  get technology(): string | null {
-    if (!isTruthy(this.$relationship.technology)) {
-      return null
-    }
-    return this.$relationship.technology
-  }
-
-  get description(): RichTextOrEmpty {
-    return RichText.memoize(this, 'description', this.$relationship.description)
-  }
-
-  get navigateTo(): LikeC4ViewModel<A> | null {
-    return this.$relationship.navigateTo ? this.model.view(this.$relationship.navigateTo) : null
-  }
-
-  get tags(): aux.Tags<A> {
-    return this.$relationship.tags ?? []
-  }
-
-  get kind(): aux.RelationKind<A> | null {
-    return this.$relationship.kind ?? null
-  }
-
-  get links(): ReadonlyArray<Link> {
-    return this.$relationship.links ?? []
-  }
-
-  get color(): Color {
-    return this.$relationship.color ?? DefaultRelationshipColor
-  }
-
-  get line(): RelationshipLineType {
-    return this.$relationship.line ?? DefaultLineStyle
-  }
-
-  /**
-   * Iterate over all views that include this relationship.
-   */
-  public *views(): ViewsIterator<A> {
-    for (const view of this.model.views()) {
-      if (view.includesRelation(this.id)) {
-        yield view
-      }
-    }
-    return
-  }
-
-  public isDeploymentRelation(): this is DeploymentRelationModel<A> {
-    return false
-  }
-
-  public isModelRelation(): this is RelationshipModel<A> {
-    return true
-  }
-
-  public hasMetadata(): boolean {
-    return !!this.$relationship.metadata && !isEmpty(this.$relationship.metadata)
-  }
-
-  public getMetadata(): aux.Metadata<A>
-  public getMetadata(field: aux.MetadataKey<A>): string | undefined
-  public getMetadata(field?: aux.MetadataKey<A>) {
-    if (field) {
-      return this.$relationship.metadata?.[field]
-    }
-    return this.$relationship.metadata ?? {}
-  }
-
-  /**
-   * Checks if the relationship has the given tag.
-   */
-  public isTagged(tag: aux.LooseTag<A>): boolean {
-    return this.tags.includes(tag as aux.Tag<A>)
-  }
-}

package/src/model/connection/Connection.ts

@@ -1,72 +0,0 @@
-import type { AnyAux, Fqn } from '../../types'
-import { isAncestor } from '../../utils'
-import type { DeploymentElementModel } from '../DeploymentElementModel'
-import type { ElementModel } from '../ElementModel'
-
-export interface Connection<Elem = ElementModel<AnyAux> | DeploymentElementModel<AnyAux>, Id = string> {
-  readonly id: Id
-  readonly source: Elem
-  readonly target: Elem
-
-  /**
-   * Common ancestor of the source and target elements.
-   * Represents the boundary of the connection.
-   */
-  readonly boundary: Elem | null
-
-  /**
-   * Human readable expression of the connection
-   * Mostly used for testing and debugging
-   */
-  readonly expression: string
-
-  mergeWith(this: Connection<Elem, Id>, other: typeof this): typeof this
-
-  nonEmpty(): boolean
-
-  difference(this: Connection<Elem, Id>, other: typeof this): typeof this
-
-  intersect(this: Connection<Elem, Id>, other: typeof this): typeof this
-
-  equals(other: Connection): boolean
-}
-
-export namespace Connection {
-  type ConnectionPredicate = <C extends Connection<{ id: string }, any>>(connection: C) => boolean
-
-  type ElementId = Fqn | string
-
-  export const isInside = (fqn: ElementId): ConnectionPredicate => {
-    return (connection) => isAncestor(fqn, connection.source.id) && isAncestor(fqn, connection.target.id)
-  }
-
-  export const isDirectedBetween = (source: ElementId, target: ElementId): ConnectionPredicate => {
-    return (connection) =>
-      (connection.source.id === source || isAncestor(source, connection.source.id))
-      && (connection.target.id === target || isAncestor(target, connection.target.id))
-  }
-
-  export const isAnyBetween = (source: ElementId, target: ElementId): ConnectionPredicate => {
-    const forward = isDirectedBetween(source, target),
-      backward = isDirectedBetween(target, source)
-    return (connection) => forward(connection) || backward(connection)
-  }
-
-  export const isIncoming = (target: ElementId): ConnectionPredicate => {
-    return (connection) =>
-      (connection.target.id === target || isAncestor(target, connection.target.id))
-      && !isAncestor(target, connection.source.id)
-  }
-
-  export const isOutgoing = (source: ElementId): ConnectionPredicate => {
-    return (connection) =>
-      (connection.source.id === source || isAncestor(source, connection.source.id))
-      && !isAncestor(source, connection.target.id)
-  }
-
-  export const isAnyInOut = (source: ElementId): ConnectionPredicate => {
-    const isIn = isIncoming(source),
-      isOut = isOutgoing(source)
-    return (connection) => isIn(connection) || isOut(connection)
-  }
-}

package/src/model/connection/deployment/DeploymentConnectionModel.ts

@@ -1,185 +0,0 @@
-import type { AnyAux, aux, IteratorLike } from '../../../types'
-import { invariant, stringHash } from '../../../utils'
-import { customInspectSymbol } from '../../../utils/const'
-import { equals } from '../../../utils/set'
-import {
-  type DeploymentElementModel,
-  type DeploymentRelationModel,
-  DeploymentNodeModel,
-  RelationshipsAccum,
-} from '../../DeploymentElementModel'
-import type { RelationshipModel } from '../../RelationModel'
-import type { Connection } from '../Connection'
-
-/**
- * Connection is ephemeral entity, result of a resolving relationships between source and target.
- * Includes direct relationships and/or between their nested elements.
- */
-export class DeploymentConnectionModel<A extends AnyAux = AnyAux>
-  implements Connection<DeploymentElementModel<A>, aux.EdgeId>
-{
-  readonly id: aux.EdgeId
-
-  constructor(
-    public readonly source: DeploymentElementModel<A>,
-    public readonly target: DeploymentElementModel<A>,
-    public readonly relations: RelationshipsAccum<A>,
-  ) {
-    this.id = stringHash(`deployment:${source.id}:${target.id}`) as aux.EdgeId
-  }
-
-  /**
-   * Human readable expression of the connection
-   * Mostly used for testing and debugging
-   */
-  get expression(): string {
-    return `${this.source.id} -> ${this.target.id}`
-  }
-
-  private _boundary: DeploymentNodeModel<A> | null | undefined
-  /**
-   * Common ancestor of the source and target elements.
-   * Represents the boundary of the connection.
-   */
-  get boundary(): DeploymentNodeModel<A> | null {
-    this._boundary ??= this.source.commonAncestor(this.target)
-    return this._boundary
-  }
-
-  nonEmpty(): boolean {
-    return this.relations.nonEmpty
-  }
-
-  [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: DeploymentConnectionModel,
-      enumerable: false,
-    })
-
-    return asString
-  }
-
-  toString() {
-    const model = [...this.relations.model].map(c => '    ' + c.expression)
-    if (model.length) {
-      model.unshift('  model:')
-    } else {
-      model.unshift('  model: []')
-    }
-    const deployment = [...this.relations.deployment].map(c => '    ' + c.expression)
-    if (deployment.length) {
-      deployment.unshift('  deployment:')
-    } else {
-      deployment.unshift('  deployment: []')
-    }
-    return [
-      this.expression,
-      ...model,
-      ...deployment,
-    ].join('\n')
-  }
-
-  /**
-   * Check if connection contains deployment relation,
-   * that is directly connected to source or target.
-   */
-  public hasDirectDeploymentRelation(): boolean {
-    for (const relation of this.relations.deployment) {
-      if (relation.source.id === this.source.id || relation.target.id === this.target.id) {
-        return true
-      }
-    }
-    return false
-  }
-
-  public *values(): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>> {
-    yield* this.relations.model
-    yield* this.relations.deployment
-  }
-
-  /**
-   * Merge with another connections, if it has the same source and target.
-   * Returns new connection with union of relationships.
-   */
-  public mergeWith(others: DeploymentConnectionModel<A>[]): DeploymentConnectionModel<A>
-  /**
-   * Merge with another connection, if it has the same source and target.
-   * Returns new connection with union of relationships.
-   */
-  public mergeWith(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>
-  public mergeWith(other: DeploymentConnectionModel<A> | DeploymentConnectionModel<A>[]): DeploymentConnectionModel<A> {
-    if (Array.isArray(other)) {
-      return other.reduce((acc, o) => acc.mergeWith(o), this)
-    }
-
-    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 DeploymentConnectionModel(
-      this.source,
-      this.target,
-      this.relations.union(other.relations),
-    )
-  }
-
-  public difference(other: DeploymentConnectionModel<A>) {
-    return new DeploymentConnectionModel(
-      this.source,
-      this.target,
-      this.relations.difference(other.relations),
-    )
-  }
-
-  public intersect(other: DeploymentConnectionModel<A>) {
-    return new DeploymentConnectionModel(
-      this.source,
-      this.target,
-      this.relations.intersect(other.relations),
-    )
-  }
-
-  public equals(other: Connection): boolean {
-    invariant(other instanceof DeploymentConnectionModel, 'Other should ne DeploymentConnectionModel')
-    return this.id === other.id
-      && this.source.id === other.source.id
-      && this.target.id === other.target.id
-      && equals(this.relations.model, other.relations.model)
-      && equals(this.relations.deployment, other.relations.deployment)
-  }
-
-  /**
-   * Creates a clone of the current `DeploymentConnectionModel` instance with optional overrides.
-   * if `null` is provided in overrides, the corresponding relation set will be empty.
-   */
-  public update(overrides?: {
-    model?: ReadonlySet<RelationshipModel<A>> | null
-    deployment?: ReadonlySet<DeploymentRelationModel<A>> | null
-  }): DeploymentConnectionModel<A> {
-    if (overrides) {
-      overrides = {
-        model: this.relations.model,
-        deployment: this.relations.deployment,
-        ...overrides,
-      }
-    }
-    return new DeploymentConnectionModel(
-      this.source,
-      this.target,
-      overrides
-        ? new RelationshipsAccum(
-          overrides.model ?? new Set(),
-          overrides.deployment ?? new Set(),
-        )
-        : this.relations,
-    )
-  }
-}

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

@@ -1,120 +0,0 @@
-import type { AnyAux } from '../../../types'
-import { isSameHierarchy } from '../../../utils'
-import type { DeploymentElementModel } from '../../DeploymentElementModel'
-import { DeploymentConnectionModel } from './DeploymentConnectionModel'
-
-/**
- * Resolve connection from source to target
- * If direction is `both`, also look for reverse connection
- *
- * @default direction directed
- */
-export function findConnection<M extends AnyAux>(
-  source: DeploymentElementModel<M>,
-  target: DeploymentElementModel<NoInfer<M>>,
-  direction: 'directed',
-):
-  | readonly [DeploymentConnectionModel<M>]
-  | readonly []
-export function findConnection<M extends AnyAux>(
-  source: DeploymentElementModel<M>,
-  target: DeploymentElementModel<NoInfer<M>>,
-  direction: 'both',
-):
-  | readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>]
-  | readonly [DeploymentConnectionModel<M>]
-  | readonly []
-export function findConnection<M extends AnyAux>(
-  source: DeploymentElementModel<M>,
-  target: DeploymentElementModel<NoInfer<M>>,
-  direction?: 'directed' | 'both',
-):
-  | readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>]
-  | readonly [DeploymentConnectionModel<M>]
-  | readonly []
-export function findConnection<M extends AnyAux>(
-  source: DeploymentElementModel<M>,
-  target: DeploymentElementModel<NoInfer<M>>,
-  direction: 'directed' | 'both' = 'directed',
-) {
-  if (source === target) {
-    return []
-  }
-  if (isSameHierarchy(source, target)) {
-    return []
-  }
-  const directedIntersection = source.allOutgoing.intersect(target.allIncoming)
-
-  const directed = directedIntersection.nonEmpty
-    ? [
-      new DeploymentConnectionModel<M>(
-        source,
-        target,
-        directedIntersection,
-      ),
-    ] as const
-    : [] as const
-
-  if (direction === 'directed') {
-    return directed
-  }
-  return [
-    ...directed,
-    ...findConnection(target, source, 'directed'),
-  ] as const
-}
-
-/**
- * Resolve all connections between element and others
- * By default, look for both directions.
- *
- * @default direction both
- */
-export function findConnectionsBetween<M extends AnyAux>(
-  element: DeploymentElementModel<M>,
-  others: Iterable<DeploymentElementModel<NoInfer<M>>>,
-  direction: 'directed' | 'both' = 'both',
-): readonly DeploymentConnectionModel<M>[] {
-  if (element.allIncoming.isEmpty && element.allOutgoing.isEmpty) {
-    return []
-  }
-
-  // We separate resolved connection,
-  // because we want return outgoing first
-  const outgoing = [] as DeploymentConnectionModel<M>[]
-  const incoming = [] as DeploymentConnectionModel<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<DeploymentElementModel<M>>,
-): readonly DeploymentConnectionModel<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 DeploymentConnectionModel<M>[])
-}

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

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

package/src/model/connection/index.ts

@@ -1,22 +0,0 @@
-export { Connection } from './Connection'
-export { DeploymentConnectionModel } from './deployment/DeploymentConnectionModel'
-export { ConnectionModel } from './model/ConnectionModel'
-export {
-  differenceConnections,
-  findAscendingConnections,
-  findDeepestNestedConnection,
-  findDescendantConnections,
-  hasSameSource,
-  hasSameSourceTarget,
-  hasSameTarget,
-  isAnyInOut,
-  isIncoming,
-  isNestedConnection,
-  isOutgoing,
-  mergeConnections,
-  sortConnectionsByBoundaryHierarchy,
-  sortDeepestFirst,
-} from './ops'
-
-export * as deployment from './deployment/find'
-export * as model from './model/find'