@likec4/core 1.40.0 → 1.42.0

package/src/model/DeploymentModel.ts

@@ -1,393 +0,0 @@
-import { values } from 'remeda'
-import {
-  type Any,
-  type DeploymentElement,
-  type DeploymentRelationship,
-  type IteratorLike,
-  FqnRef,
-  isDeploymentNode,
-} from '../types'
-import * as aux from '../types/_aux'
-import { invariant, nonNullable } from '../utils'
-import { ancestorsFqn, parentFqn, sortParentsFirst } from '../utils/fqn'
-import { getOrCreate } from '../utils/getOrCreate'
-import { DefaultMap } from '../utils/mnemonist'
-import {
-  type DeployedInstancesIterator,
-  type DeploymentElementModel,
-  type DeploymentElementsIterator,
-  type DeploymentNodesIterator,
-  DeployedInstanceModel,
-  DeploymentNodeModel,
-  DeploymentRelationModel,
-  NestedElementOfDeployedInstanceModel,
-} from './DeploymentElementModel'
-import type { LikeC4Model } from './LikeC4Model'
-import {
-  type $ModelData,
-  type DeploymentOrFqn,
-  type ElementOrFqn,
-  type IncomingFilter,
-  type OutgoingFilter,
-  type RelationOrId,
-} from './types'
-import { getId } from './utils'
-import type { LikeC4ViewModel } from './view/LikeC4ViewModel'
-
-export class LikeC4DeploymentModel<A extends Any = Any> {
-  readonly #elements = new Map<aux.DeploymentFqn<A>, DeploymentElementModel<A>>()
-  // Parent element for given FQN
-  readonly #parents = new Map<aux.DeploymentFqn<A>, DeploymentNodeModel<A>>()
-  // Children elements for given FQN
-  readonly #children = new DefaultMap<aux.DeploymentFqn<A>, Set<DeploymentElementModel<A>>>(() => new Set())
-
-  // Keep track of instances of the logical element
-  readonly #instancesOf = new DefaultMap<aux.Fqn<A>, Set<DeployedInstanceModel<A>>>(() => new Set())
-
-  readonly #rootElements = new Set<DeploymentNodeModel<A>>()
-
-  readonly #relations = new Map<aux.RelationId, DeploymentRelationModel<A>>()
-
-  // Incoming to an element or its descendants
-  readonly #incoming = new DefaultMap<aux.DeploymentFqn<A>, Set<DeploymentRelationModel<A>>>(() => new Set())
-
-  // Outgoing from an element or its descendants
-  readonly #outgoing = new DefaultMap<aux.DeploymentFqn<A>, Set<DeploymentRelationModel<A>>>(() => new Set())
-
-  // Relationships inside the element, among descendants
-  readonly #internal = new DefaultMap<aux.DeploymentFqn<A>, Set<DeploymentRelationModel<A>>>(() => new Set())
-
-  // readonly #views = new Map<ViewID, LikeC4ViewModel<A>>()
-
-  readonly #allTags = new DefaultMap<aux.Tag<A>, Set<DeploymentElementModel<A> | DeploymentRelationModel<A>>>(
-    () => new Set(),
-  )
-
-  readonly #nestedElementsOfDeployment = new Map<
-    `${aux.DeploymentId<A>}@${aux.ElementId<A>}`,
-    NestedElementOfDeployedInstanceModel<A>
-  >()
-
-  public readonly $deployments: $ModelData<A>['deployments']
-
-  constructor(
-    public readonly $model: LikeC4Model<A>,
-  ) {
-    const $deployments = this.$deployments = $model.$data.deployments
-    const elements = values($deployments.elements as Record<string, DeploymentElement<A>>)
-    for (const element of sortParentsFirst(elements)) {
-      const el = this.addElement(element)
-      for (const tag of el.tags) {
-        this.#allTags.get(tag).add(el)
-      }
-      if (el.isInstance()) {
-        this.#instancesOf.get(el.element.id).add(el)
-      }
-    }
-    for (const relation of values($deployments.relations)) {
-      const el = this.addRelation(relation)
-      for (const tag of el.tags) {
-        this.#allTags.get(tag).add(el)
-      }
-    }
-  }
-
-  public element(el: DeploymentOrFqn<A>): DeploymentElementModel<A> {
-    if (el instanceof DeploymentNodeModel || el instanceof DeployedInstanceModel) {
-      return el
-    }
-    const id = getId(el)
-    return nonNullable(this.#elements.get(id), `Element ${id} not found`)
-  }
-  public findElement(el: aux.LooseDeploymentId<A>): DeploymentElementModel<A> | null {
-    return this.#elements.get(el as aux.DeploymentFqn<A>) ?? null
-  }
-
-  public node(el: DeploymentOrFqn<A>): DeploymentNodeModel<A> {
-    const element = this.element(el)
-    invariant(element.isDeploymentNode(), `Element ${element.id} is not a deployment node`)
-    return element
-  }
-  public findNode(el: aux.LooseDeploymentId<A>): DeploymentNodeModel<A> | null {
-    const element = this.findElement(el)
-    if (!element) {
-      return null
-    }
-    invariant(element.isDeploymentNode(), `Element ${element?.id} is not a deployment node`)
-    return element
-  }
-
-  public instance(el: DeploymentOrFqn<A>): DeployedInstanceModel<A> {
-    const element = this.element(el)
-    invariant(element.isInstance(), `Element ${element.id} is not a deployed instance`)
-    return element
-  }
-  public findInstance(el: aux.LooseDeploymentId<A>): DeployedInstanceModel<A> | null {
-    const element = this.findElement(el)
-    if (!element) {
-      return null
-    }
-    invariant(element.isInstance(), `Element ${element?.id} is not a deployed instance`)
-    return element
-  }
-
-  /**
-   * Returns the root elements of the model.
-   */
-  public roots(): DeploymentNodesIterator<A> {
-    return this.#rootElements.values()
-  }
-
-  /**
-   * Returns all elements in the model.
-   */
-  public elements(): DeploymentElementsIterator<A> {
-    return this.#elements.values()
-  }
-
-  /**
-   * Returns all elements in the model.
-   */
-  public *nodes(): DeploymentNodesIterator<A> {
-    for (const element of this.#elements.values()) {
-      if (element.isDeploymentNode()) {
-        yield element
-      }
-    }
-    return
-  }
-
-  public *nodesOfKind(kind: aux.DeploymentKind<A>): DeploymentNodesIterator<A> {
-    for (const node of this.#elements.values()) {
-      if (node.isDeploymentNode() && node.kind === kind) {
-        yield node
-      }
-    }
-    return
-  }
-
-  public *instances(): DeployedInstancesIterator<A> {
-    for (const element of this.#elements.values()) {
-      if (element.isInstance()) {
-        yield element
-      }
-    }
-    return
-  }
-
-  /**
-   * Iterate over all instances of the given logical element.
-   */
-  public *instancesOf(element: ElementOrFqn<A>): DeployedInstancesIterator<A> {
-    const id = getId(element)
-    const instances = this.#instancesOf.get(id)
-    if (instances) {
-      yield* instances
-    }
-    return
-  }
-
-  public deploymentRef(
-    ref: FqnRef.DeploymentRef<A>,
-  ): DeploymentElementModel<A> | NestedElementOfDeployedInstanceModel<A> {
-    if (FqnRef.isInsideInstanceRef(ref)) {
-      const { deployment, element } = ref
-      return getOrCreate(this.#nestedElementsOfDeployment, `${deployment}@${element}`, () => {
-        return new NestedElementOfDeployedInstanceModel(this.instance(deployment), this.$model.element(element))
-      })
-    }
-    return this.element(ref.deployment)
-  }
-
-  /**
-   * Returns all relationships in the model.
-   */
-  public relationships(): IteratorLike<DeploymentRelationModel<A>> {
-    return this.#relations.values()
-  }
-
-  /**
-   * Returns a specific relationship by its ID.
-   */
-  public relationship(id: RelationOrId): DeploymentRelationModel<A> {
-    return nonNullable(this.#relations.get(getId(id)), `DeploymentRelationModel ${id} not found`)
-  }
-  public findRelationship(id: string): DeploymentRelationModel<A> | null {
-    return this.#relations.get(id as aux.RelationId) ?? null
-  }
-
-  /**
-   * Returns all deployment views in the model.
-   */
-  public *views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>> {
-    for (const view of this.$model.views()) {
-      if (view.isDeploymentView()) {
-        yield view
-      }
-    }
-    return
-  }
-
-  /**
-   * Returns the parent element of given element.
-   * @see ancestors
-   */
-  public parent(element: DeploymentOrFqn<A>): DeploymentNodeModel<A> | null {
-    const id = getId(element)
-    return this.#parents.get(id) || null
-  }
-
-  /**
-   * Get all children of the element (only direct children),
-   * @see descendants
-   */
-  public children(element: DeploymentOrFqn<A>): ReadonlySet<DeploymentElementModel<A>> {
-    const id = getId(element)
-    return this.#children.get(id)
-  }
-
-  /**
-   * Get all sibling (i.e. same parent)
-   */
-  public *siblings(element: DeploymentOrFqn<A>): DeploymentElementsIterator<A> {
-    const id = getId(element)
-    const siblings = this.parent(element)?.children() ?? this.roots()
-    for (const sibling of siblings) {
-      if (sibling.id !== id) {
-        yield sibling
-      }
-    }
-    return
-  }
-
-  /**
-   * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-   * (from closest to root)
-   */
-  public *ancestors(element: DeploymentOrFqn<A>): DeploymentNodesIterator<A> {
-    let id = getId(element)
-    let parent
-    while (parent = this.#parents.get(id)) {
-      yield parent
-      id = parent.id
-    }
-    return
-  }
-
-  /**
-   * Get all descendant elements (i.e. children, children’s children, etc.)
-   */
-  public *descendants(
-    element: DeploymentOrFqn<A>,
-    sort: 'asc' | 'desc' = 'desc',
-  ): DeploymentElementsIterator<A> {
-    for (const child of this.children(element)) {
-      if (sort === 'asc') {
-        yield child
-        yield* this.descendants(child.id)
-      } else {
-        yield* this.descendants(child.id)
-        yield child
-      }
-    }
-    return
-  }
-
-  /**
-   * Incoming relationships to the element and its descendants
-   * @see incomers
-   */
-  public *incoming(
-    element: DeploymentOrFqn<A>,
-    filter: IncomingFilter = 'all',
-  ): IteratorLike<DeploymentRelationModel<A>> {
-    const id = getId(element)
-    for (const rel of this.#incoming.get(id)) {
-      switch (true) {
-        case filter === 'all':
-        case filter === 'direct' && rel.target.id === id:
-        case filter === 'to-descendants' && rel.target.id !== id:
-          yield rel
-          break
-      }
-    }
-    return
-  }
-
-  /**
-   * Outgoing relationships from the element and its descendants
-   * @see outgoers
-   */
-  public *outgoing(
-    element: DeploymentOrFqn<A>,
-    filter: OutgoingFilter = 'all',
-  ): IteratorLike<DeploymentRelationModel<A>> {
-    const id = getId(element)
-    for (const rel of this.#outgoing.get(id)) {
-      switch (true) {
-        case filter === 'all':
-        case filter === 'direct' && rel.source.id === id:
-        case filter === 'from-descendants' && rel.source.id !== id:
-          yield rel
-          break
-      }
-    }
-    return
-  }
-
-  private addElement(element: DeploymentElement<A>) {
-    if (this.#elements.has(element.id)) {
-      throw new Error(`Element ${element.id} already exists`)
-    }
-    const el = isDeploymentNode(element)
-      ? new DeploymentNodeModel(this, Object.freeze(element))
-      : new DeployedInstanceModel(this, Object.freeze(element), this.$model.element(element.element))
-    this.#elements.set(el.id, el)
-    const parentId = parentFqn(el.id)
-    if (parentId) {
-      invariant(this.#elements.has(parentId), `Parent ${parentId} of ${el.id} not found`)
-      this.#parents.set(el.id, this.node(parentId))
-      this.#children.get(parentId).add(el)
-    } else {
-      invariant(el.isDeploymentNode(), `Root element ${el.id} is not a deployment node`)
-      this.#rootElements.add(el)
-    }
-    return el
-  }
-
-  private addRelation(relation: DeploymentRelationship<A>) {
-    if (this.#relations.has(relation.id)) {
-      throw new Error(`Relation ${relation.id} already exists`)
-    }
-    const rel = new DeploymentRelationModel(
-      this,
-      Object.freeze(relation),
-    )
-    this.#relations.set(rel.id, rel)
-    this.#incoming.get(rel.target.id).add(rel)
-    this.#outgoing.get(rel.source.id).add(rel)
-
-    const relParent = rel.boundary?.id ?? null
-    // Process internal relationships
-    if (relParent) {
-      for (const ancestor of [relParent, ...ancestorsFqn(relParent)]) {
-        this.#internal.get(ancestor).add(rel)
-      }
-    }
-    // Process source hierarchy
-    for (const sourceAncestor of ancestorsFqn(rel.source.id)) {
-      if (sourceAncestor === relParent) {
-        break
-      }
-      this.#outgoing.get(sourceAncestor).add(rel)
-    }
-    // Process target hierarchy
-    for (const targetAncestor of ancestorsFqn(rel.target.id)) {
-      if (targetAncestor === relParent) {
-        break
-      }
-      this.#incoming.get(targetAncestor).add(rel)
-    }
-    return rel
-  }
-}

package/src/model/ElementModel.ts

@@ -1,293 +0,0 @@
-import { isEmpty, isTruthy, unique } from 'remeda'
-import type { SetRequired } from 'type-fest'
-import type { Any, AnyAux, Color, IteratorLike } from '../types'
-import {
-  type Element as C4Element,
-  type ElementShape as C4ElementShape,
-  type ElementStyle,
-  type IconUrl,
-  type Link,
-  type ProjectId,
-  type RichTextOrEmpty,
-  DefaultElementShape,
-  DefaultShapeSize,
-  DefaultThemeColor,
-  RichText,
-  splitGlobalFqn,
-} from '../types'
-import * as aux from '../types/_aux'
-import { commonAncestor, hierarchyLevel, ihead, isAncestor, memoizeProp, nameFromFqn, sortNaturalByFqn } from '../utils'
-import { type DeployedInstancesIterator } from './DeploymentElementModel'
-import type { LikeC4Model } from './LikeC4Model'
-import type { RelationshipModel, RelationshipsIterator } from './RelationModel'
-import type { IncomingFilter, OutgoingFilter, WithMetadata, WithTags } from './types'
-import type { LikeC4ViewModel } from './view/LikeC4ViewModel'
-
-export type ElementsIterator<M extends AnyAux> = IteratorLike<ElementModel<M>>
-
-export class ElementModel<A extends AnyAux = Any> implements WithTags<A>, WithMetadata<A> {
-  readonly id: aux.Fqn<A>
-  readonly _literalId: aux.ElementId<A>
-  readonly hierarchyLevel: number
-
-  readonly imported: null | {
-    from: ProjectId
-    fqn: aux.Fqn<A>
-  }
-
-  constructor(
-    public readonly $model: LikeC4Model<A>,
-    public readonly $element: C4Element<A>,
-  ) {
-    this.id = this.$element.id
-    this._literalId = this.$element.id
-    const [projectId, fqn] = splitGlobalFqn(this.id)
-    if (projectId) {
-      this.imported = {
-        from: projectId,
-        fqn,
-      }
-      this.hierarchyLevel = hierarchyLevel(fqn)
-    } else {
-      this.imported = null
-      this.hierarchyLevel = hierarchyLevel(this.id)
-    }
-  }
-
-  get name(): string {
-    return nameFromFqn(this.id)
-  }
-
-  get parent(): ElementModel<A> | null {
-    return this.$model.parent(this)
-  }
-
-  get kind(): aux.ElementKind<A> {
-    return this.$element.kind
-  }
-
-  get shape(): C4ElementShape {
-    return this.$element.shape ?? DefaultElementShape
-  }
-
-  get color(): Color {
-    return this.$element.color as Color ?? DefaultThemeColor
-  }
-
-  get icon(): IconUrl | null {
-    return this.$element.icon ?? null
-  }
-
-  /**
-   * Returns all tags of the element.
-   * It includes tags from the element and its kind.
-   */
-  get tags(): aux.Tags<A> {
-    return memoizeProp(this, Symbol.for('tags'), () => {
-      return unique([
-        ...(this.$element.tags ?? []),
-        ...(this.$model.specification.elements[this.$element.kind]?.tags ?? []),
-      ] as aux.Tags<A>)
-    })
-  }
-
-  get title(): string {
-    return this.$element.title
-  }
-
-  get description(): RichTextOrEmpty {
-    return RichText.memoize(this, this.$element.description)
-  }
-
-  get technology(): string | null {
-    return this.$element.technology ?? null
-  }
-
-  get links(): ReadonlyArray<Link> {
-    return this.$element.links ?? []
-  }
-
-  get defaultView(): LikeC4ViewModel.ScopedElementView<A> | null {
-    return memoizeProp(this, Symbol.for('defaultView'), () => ihead(this.scopedViews()) ?? null)
-  }
-
-  get isRoot(): boolean {
-    return this.parent === null
-  }
-
-  get style(): SetRequired<ElementStyle, 'size'> {
-    return {
-      size: DefaultShapeSize,
-      ...this.$element.style,
-    }
-  }
-
-  public isAncestorOf(another: ElementModel<A>): boolean {
-    return isAncestor(this, another)
-  }
-
-  public isDescendantOf(another: ElementModel<A>): boolean {
-    return isAncestor(another, this)
-  }
-
-  /**
-   * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-   * (from closest to root)
-   */
-  public ancestors(): ElementsIterator<A> {
-    return this.$model.ancestors(this)
-  }
-
-  /**
-   * Returns the common ancestor of this element and another element.
-   */
-  public commonAncestor(another: ElementModel<A>): ElementModel<A> | null {
-    const common = commonAncestor(this.id, another.id)
-    return common ? this.$model.element(common) : null
-  }
-
-  public children(): ReadonlySet<ElementModel<A>> {
-    return this.$model.children(this)
-  }
-
-  /**
-   * Get all descendant elements (i.e. children, children’s children, etc.)
-   */
-  public descendants(sort?: 'asc' | 'desc'): ElementsIterator<A> {
-    if (sort) {
-      const sorted = sortNaturalByFqn([...this.$model.descendants(this)], sort)
-      return sorted[Symbol.iterator]()
-    }
-    return this.$model.descendants(this)
-  }
-
-  /**
-   * Get all sibling (i.e. same parent)
-   */
-  public siblings(): ElementsIterator<A> {
-    return this.$model.siblings(this)
-  }
-
-  /**
-   * Resolve siblings of the element and its ancestors
-   * (from closest parent to root)
-   */
-  public *ascendingSiblings(): ElementsIterator<A> {
-    yield* this.siblings()
-    for (const ancestor of this.ancestors()) {
-      yield* ancestor.siblings()
-    }
-    return
-  }
-
-  /**
-   * Resolve siblings of the element and its ancestors
-   *  (from root to closest)
-   */
-  public *descendingSiblings(): ElementsIterator<A> {
-    for (const ancestor of [...this.ancestors()].reverse()) {
-      yield* ancestor.siblings()
-    }
-    yield* this.siblings()
-    return
-  }
-
-  public incoming(filter: IncomingFilter = 'all'): RelationshipsIterator<A> {
-    return this.$model.incoming(this, filter)
-  }
-  public *incomers(filter: IncomingFilter = 'all'): ElementsIterator<A> {
-    const unique = new Set<aux.StrictFqn<A>>()
-    for (const r of this.incoming(filter)) {
-      if (unique.has(r.source.id)) {
-        continue
-      }
-      unique.add(r.source.id)
-      yield r.source
-    }
-    return
-  }
-  public outgoing(filter: OutgoingFilter = 'all'): RelationshipsIterator<A> {
-    return this.$model.outgoing(this, filter)
-  }
-  public *outgoers(filter: OutgoingFilter = 'all'): ElementsIterator<A> {
-    const unique = new Set<aux.StrictFqn<A>>()
-    for (const r of this.outgoing(filter)) {
-      if (unique.has(r.target.id)) {
-        continue
-      }
-      unique.add(r.target.id)
-      yield r.target
-    }
-    return
-  }
-
-  public get allOutgoing(): ReadonlySet<RelationshipModel<A>> {
-    return memoizeProp(this, Symbol.for('allOutgoing'), () => new Set(this.outgoing()))
-  }
-
-  public get allIncoming(): ReadonlySet<RelationshipModel<A>> {
-    return memoizeProp(this, Symbol.for('allIncoming'), () => new Set(this.incoming()))
-  }
-
-  /**
-   * Iterate over all views that include this element.
-   */
-  public views(): ReadonlySet<LikeC4ViewModel<A>> {
-    return memoizeProp(this, Symbol.for('views'), () => {
-      const views = new Set<LikeC4ViewModel<A>>()
-      for (const view of this.$model.views()) {
-        if (view.includesElement(this.id)) {
-          views.add(view)
-        }
-      }
-      return views
-    })
-  }
-
-  /**
-   * Iterate over all views that scope this element.
-   * It is possible that element is not included in the view.
-   */
-  public scopedViews(): ReadonlySet<LikeC4ViewModel.ScopedElementView<A>> {
-    return memoizeProp(this, Symbol.for('scopedViews'), () => {
-      const views = new Set<LikeC4ViewModel.ScopedElementView<A>>()
-      for (const vm of this.$model.views()) {
-        if (vm.isScopedElementView() && vm.viewOf.id === this.id) {
-          views.add(vm)
-        }
-      }
-      return views
-    })
-  }
-
-  /**
-   * @returns true if the element is deployed
-   */
-  public isDeployed(): boolean {
-    return isTruthy(ihead(this.deployments()))
-  }
-
-  public deployments(): DeployedInstancesIterator<A> {
-    return this.$model.deployment.instancesOf(this)
-  }
-
-  public hasMetadata(): boolean {
-    return !!this.$element.metadata && !isEmpty(this.$element.metadata)
-  }
-
-  public getMetadata(): aux.Metadata<A>
-  public getMetadata(field: aux.MetadataKey<A>): string | undefined
-  public getMetadata(field?: aux.MetadataKey<A>) {
-    if (field) {
-      return this.$element.metadata?.[field]
-    }
-    return this.$element.metadata ?? {}
-  }
-
-  /**
-   * Checks if the element has the given tag.
-   */
-  public isTagged(tag: aux.LooseTag<A>): boolean {
-    return this.tags.includes(tag as aux.Tag<A>)
-  }
-}