@likec4/core 1.41.0 → 1.42.1

package/src/model/index.ts

@@ -1,72 +0,0 @@
-export { ElementModel } from './ElementModel'
-export { type AnyLikeC4Model, LikeC4Model } from './LikeC4Model'
-export { type AnyRelationshipModel, RelationshipModel } from './RelationModel'
-
-export {
-  Connection,
-  ConnectionModel,
-  deployment as deploymentConnection,
-  DeploymentConnectionModel,
-  differenceConnections,
-  findAscendingConnections,
-  findDeepestNestedConnection,
-  findDescendantConnections,
-  hasSameSource,
-  hasSameSourceTarget,
-  hasSameTarget,
-  isAnyInOut,
-  isIncoming,
-  isNestedConnection,
-  isOutgoing,
-  mergeConnections,
-  model as modelConnection,
-  sortConnectionsByBoundaryHierarchy,
-  sortDeepestFirst,
-} from './connection'
-
-export {
-  DeployedInstanceModel,
-  type DeploymentElementModel,
-  DeploymentNodeModel,
-  type DeploymentRelationEndpoint,
-  DeploymentRelationModel,
-  RelationshipsAccum,
-} from './DeploymentElementModel'
-export { LikeC4DeploymentModel } from './DeploymentModel'
-
-export { EdgeModel } from './view/EdgeModel'
-export { LikeC4ViewModel } from './view/LikeC4ViewModel'
-export { LikeC4ViewsFolder } from './view/LikeC4ViewsFolder'
-export { NodeModel } from './view/NodeModel'
-
-export type {
-  DeploymentOrFqn,
-  EdgeOrId,
-  ElementOrFqn,
-  IncomingFilter,
-  NodeOrId,
-  OutgoingFilter,
-  WithMetadata,
-  WithTags,
-} from './types'
-
-export * from './guards'
-
-export type {
-  Any,
-  AnyAux,
-  Aux,
-  aux,
-  AuxFromDump,
-  AuxFromLikeC4ModelData,
-  SpecAux,
-} from '../types'
-
-export { RichText, type RichTextEmpty, type RichTextOrEmpty } from '../types'
-
-export {
-  extractViewTitleFromPath,
-  getViewFolderPath,
-  normalizeViewPath,
-  VIEW_FOLDERS_SEPARATOR,
-} from './utils'

package/src/model/types.ts

@@ -1,67 +0,0 @@
-import type { Tagged } from 'type-fest'
-import type {
-  AnyAux,
-  ComputedLikeC4ModelData,
-  ComputedView,
-  DiagramView,
-  LayoutedLikeC4ModelData,
-  ParsedLikeC4ModelData,
-  scalar,
-  ViewType,
-  ViewWithType,
-} from '../types'
-import type * as aux from '../types/_aux'
-import type { LikeC4ViewModel } from './view/LikeC4ViewModel'
-
-export type IncomingFilter = 'all' | 'direct' | 'to-descendants'
-export type OutgoingFilter = 'all' | 'direct' | 'from-descendants'
-
-export type AnyScalar<V extends string> =
-  | Tagged<V, 'Fqn'>
-  | Tagged<V, 'DeploymentFqn'>
-  | Tagged<V, 'ViewId'>
-  | Tagged<V, 'NodeId'>
-  | Tagged<V, 'EdgeId'>
-  | Tagged<V, 'RelationId'>
-
-export type ElementOrFqn<A extends AnyAux> = aux.ElementId<A> | { id: aux.Fqn<A> }
-
-export type DeploymentOrFqn<A extends AnyAux> = aux.DeploymentId<A> | { id: aux.DeploymentFqn<A> }
-
-export type ViewOrId<A extends AnyAux> = aux.ViewId<A> | { id: aux.StrictViewId<A> }
-
-export type NodeOrId = string | { id: scalar.NodeId }
-export type EdgeOrId = string | { id: scalar.EdgeId }
-export type RelationOrId = string | { id: scalar.RelationId }
-
-export type $View<A extends AnyAux> = {
-  parsed: never
-  computed: ComputedView<A>
-  layouted: DiagramView<A>
-}[aux.Stage<A>]
-
-export type $ViewWithType<A extends AnyAux, V extends ViewType> = ViewWithType<$View<A>, V>
-
-export type $ViewModel<A extends AnyAux> = {
-  parsed: never
-  computed: LikeC4ViewModel<A>
-  layouted: LikeC4ViewModel<A>
-}[aux.Stage<A>]
-
-// export type $ModelData<A> = A extends infer T extends Any ? {
-export type $ModelData<A extends AnyAux> = {
-  parsed: ParsedLikeC4ModelData<A>
-  computed: ComputedLikeC4ModelData<A>
-  layouted: LayoutedLikeC4ModelData<A>
-}[aux.Stage<A>]
-
-export interface WithTags<A extends AnyAux> {
-  get tags(): aux.Tags<A>
-  isTagged(tag: aux.LooseTag<A>): boolean
-}
-
-export interface WithMetadata<A extends AnyAux> {
-  hasMetadata(): boolean
-  getMetadata(): aux.Metadata<A>
-  getMetadata(field: aux.MetadataKey<A>): string | undefined
-}

package/src/model/utils.ts

@@ -1,66 +0,0 @@
-import { hasAtLeast } from 'remeda'
-import type { NonEmptyArray } from '../types'
-import { invariant } from '../utils'
-import type { AnyScalar } from './types'
-
-/**
- * Utility function to extract `id` from the given element.
- */
-export const getId = <Id extends string, Scalar extends AnyScalar<Id>>(element: Id | { id: Scalar }): Scalar => {
-  return typeof element === 'string' ? element as unknown as Scalar : element.id
-}
-
-export const VIEW_FOLDERS_SEPARATOR = '/'
-
-const splitViewTitle = (title: string): NonEmptyArray<string> => {
-  invariant(!title.includes('\n'), 'View title cannot contain newlines')
-  if (title.includes(VIEW_FOLDERS_SEPARATOR)) {
-    const segments = title
-      .split(VIEW_FOLDERS_SEPARATOR)
-      .map(s => s.trim())
-      .filter(s => s.length > 0)
-    if (hasAtLeast(segments, 1)) {
-      return segments
-    }
-    return ['']
-  }
-  return [title.trim()]
-}
-
-/**
- * Normalizes view path by removing spaces from segments, removing empty segments,
- * and removing leading/trailing slashes
- * @example
- * normalizeViewPath('One / Tw o / Thre e') === 'One/Tw o/Thre e'
- */
-export const normalizeViewPath = (title: string): string => {
-  return splitViewTitle(title).join(VIEW_FOLDERS_SEPARATOR)
-}
-
-/**
- * Returns view group path if it is used as a path
- * Returns empty string if it is not a path
- * @example
- * getViewFolderPath('One / Tw o / Thre e') === 'One/Tw o'
- * getViewFolderPath('One') === ''
- */
-export const getViewFolderPath = (title: string): string | null => {
-  const segments = splitViewTitle(title)
-  if (!hasAtLeast(segments, 2)) {
-    return null
-  }
-  return segments.slice(0, -1).join(VIEW_FOLDERS_SEPARATOR)
-}
-
-/**
- * Returns view title if it is used as a path
- * @example
- * getViewTitleFromPath('One / Tw o / Thre e') === 'Thre e'
- * getViewTitleFromPath('One') === 'One'
- */
-export const extractViewTitleFromPath = (title: string): string => {
-  if (!title.includes(VIEW_FOLDERS_SEPARATOR)) {
-    return title.trim()
-  }
-  return splitViewTitle(title).pop() ?? title
-}

package/src/model/view/EdgeModel.ts

@@ -1,121 +0,0 @@
-import {
-  type Any,
-  type aux,
-  type Color,
-  type ComputedEdge,
-  type DiagramEdge,
-  type IteratorLike,
-  type RelationshipLineType,
-  type RichTextOrEmpty,
-  type scalar,
-  type StepEdgeId,
-  extractStep,
-  isStepEdgeId,
-  RichText,
-} from '../../types'
-import type { DeploymentRelationModel } from '../DeploymentElementModel'
-import type { RelationshipModel } from '../RelationModel'
-import type { $View, WithTags } from '../types'
-import type { LikeC4ViewModel } from './LikeC4ViewModel'
-import type { NodeModel } from './NodeModel'
-
-export type EdgesIterator<A extends Any, V extends $View<A>> = IteratorLike<EdgeModel<A, V>>
-
-export class EdgeModel<A extends Any = Any, View extends $View<A> = $View<A>> implements WithTags<A> {
-  #edge: ComputedEdge<A> | DiagramEdge<A>
-  constructor(
-    public readonly view: LikeC4ViewModel<A, View>,
-    public readonly $edge: View['edges'][number],
-    public readonly source: NodeModel<A, View>,
-    public readonly target: NodeModel<A, View>,
-  ) {
-    this.#edge = $edge
-  }
-
-  get id(): scalar.EdgeId {
-    return this.#edge.id
-  }
-
-  get parent(): NodeModel<A, View> | null {
-    return this.#edge.parent ? this.view.node(this.#edge.parent) : null
-  }
-
-  get label(): string | null {
-    return this.#edge.label ?? null
-  }
-
-  get description(): RichTextOrEmpty {
-    return RichText.memoize(this, 'description', this.#edge.description)
-  }
-
-  get technology(): string | null {
-    return this.#edge.technology ?? null
-  }
-
-  public hasParent(): this is EdgeModel.WithParent<A, View> {
-    return this.#edge.parent !== null
-  }
-
-  get tags(): aux.Tags<A> {
-    return this.#edge.tags ?? []
-  }
-
-  get stepNumber(): number | null {
-    return this.isStep() ? extractStep(this.id) : null
-  }
-
-  get navigateTo(): LikeC4ViewModel<A> | null {
-    return this.#edge.navigateTo ? this.view.$model.view(this.#edge.navigateTo) : null
-  }
-
-  get color(): Color {
-    return this.#edge.color ?? 'gray'
-  }
-
-  get line(): RelationshipLineType {
-    return this.#edge.line ?? 'dashed'
-  }
-
-  public isStep(): this is EdgeModel.StepEdge<A, View> {
-    return isStepEdgeId(this.id)
-  }
-
-  public relationships(type: 'model'): IteratorLike<RelationshipModel<A>>
-  public relationships(type: 'deployment'): IteratorLike<DeploymentRelationModel<A>>
-  public relationships(type?: 'model' | 'deployment'): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>>
-  public *relationships(
-    type: 'model' | 'deployment' | undefined,
-  ): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>> {
-    for (const id of this.#edge.relations) {
-      // if type is provided, then we need to filter relationships
-      if (type) {
-        const rel = this.view.$model.findRelationship(id, type)
-        if (rel) {
-          yield rel
-        }
-      } else {
-        yield this.view.$model.relationship(id)
-      }
-    }
-    return
-  }
-
-  public includesRelation(rel: aux.RelationId | { id: aux.RelationId }): boolean {
-    const id = typeof rel === 'string' ? rel : rel.id
-    return this.#edge.relations.includes(id)
-  }
-
-  public isTagged(tag: aux.LooseTag<A>): boolean {
-    return this.tags.includes(tag as aux.Tag<A>)
-  }
-}
-
-namespace EdgeModel {
-  export interface StepEdge<A extends Any, V extends $View<A>> extends EdgeModel<A, V> {
-    id: StepEdgeId
-    stepNumber: number
-  }
-  export interface WithParent<A extends Any, V extends $View<A>> extends EdgeModel<A, V> {
-    parent: NodeModel<A, V>
-  }
-}

package/src/model/view/LikeC4ViewModel.ts

@@ -1,361 +0,0 @@
-import { isTruthy } from 'remeda'
-import type {
-  Any,
-  AnyView,
-  DynamicViewDisplayVariant,
-  IteratorLike,
-  Link,
-  scalar,
-  ViewWithType,
-} from '../../types'
-import { type RichTextOrEmpty, _stage, _type, RichText } from '../../types'
-import type * as aux from '../../types/_aux'
-import { DefaultMap, ifind, memoizeProp, nonNullable } from '../../utils'
-import type { ElementModel } from '../ElementModel'
-import type { LikeC4Model } from '../LikeC4Model'
-import {
-  type $View,
-  type EdgeOrId,
-  type NodeOrId,
-  type WithTags,
-} from '../types'
-import { extractViewTitleFromPath, getId, normalizeViewPath } from '../utils'
-import { type EdgesIterator, EdgeModel } from './EdgeModel'
-import type { LikeC4ViewsFolder } from './LikeC4ViewsFolder'
-import { type NodesIterator, NodeModel } from './NodeModel'
-
-export type ViewsIterator<A extends Any, V extends $View<A> = $View<A>> = IteratorLike<LikeC4ViewModel<A, V>>
-
-export type InferViewType<V> = V extends AnyView<any> ? V[_type] : never
-
-export class LikeC4ViewModel<A extends Any = Any, V extends $View<A> = $View<A>> implements WithTags<A> {
-  /**
-   * Don't use in runtime, only for type inference
-   */
-  readonly Aux!: A
-
-  readonly #rootnodes = new Set<NodeModel<A, V>>()
-  readonly #nodes = new Map<scalar.NodeId, NodeModel<A, V>>()
-  readonly #edges = new Map<scalar.EdgeId, EdgeModel<A, V>>()
-  readonly #includeElements = new Set<aux.Fqn<A>>()
-  readonly #includeDeployments = new Set<aux.DeploymentFqn<A>>()
-  readonly #includeRelations = new Set<scalar.RelationId>()
-  readonly #allTags = new DefaultMap((_key: aux.Tag<A>) => new Set<NodeModel<A, V> | EdgeModel<A, V>>())
-
-  public readonly $view: V
-  public readonly $model: LikeC4Model<A>
-
-  public readonly title: string | null
-
-  /**
-   * View folder this view belongs to.
-   * If view is top-level, this is the root folder.
-   */
-  public readonly folder: LikeC4ViewsFolder<A>
-  /**
-   * Path to this view, processed by {@link normalizeViewPath}
-   *
-   * @example
-   * "Group 1/Group 2/View"
-   */
-  public readonly viewPath: string
-
-  constructor(
-    model: LikeC4Model<A>,
-    view: V,
-    folder: LikeC4ViewsFolder<A>,
-  ) {
-    this.$model = model
-    this.$view = view
-    this.folder = folder
-    for (const node of view.nodes) {
-      const el = new NodeModel<A, V>(this, Object.freeze(node))
-      this.#nodes.set(node.id, el)
-      if (!node.parent) {
-        this.#rootnodes.add(el)
-      }
-      if (el.hasDeployment()) {
-        this.#includeDeployments.add(el.deployment.id)
-      }
-      if (el.hasElement()) {
-        this.#includeElements.add(el.element.id)
-      }
-      for (const tag of el.tags) {
-        this.#allTags.get(tag).add(el)
-      }
-    }
-
-    for (const edge of view.edges) {
-      const edgeModel = new EdgeModel(
-        this,
-        Object.freeze(edge),
-        this.node(edge.source),
-        this.node(edge.target),
-      )
-      for (const tag of edgeModel.tags) {
-        this.#allTags.get(tag).add(edgeModel)
-      }
-      for (const rel of edge.relations) {
-        this.#includeRelations.add(rel)
-      }
-      this.#edges.set(edge.id, edgeModel)
-    }
-
-    this.title = this.$view.title ? extractViewTitleFromPath(this.$view.title) : null
-    this.viewPath = this.$view.title ? normalizeViewPath(this.$view.title) : this.$view.id
-  }
-
-  get _type(): V[_type] {
-    return this.$view[_type]
-  }
-
-  get id(): aux.StrictViewId<A> {
-    return this.$view.id
-  }
-
-  /**
-   * Returns title if defined, otherwise returns title of the element it is based on, otherwise returns its {@link id}
-   */
-  get titleOrId(): string {
-    return this.title ?? this.viewOf?.title ?? this.id
-  }
-
-  /**
-   * Returns title if defined, otherwise returns `Untitled`.
-   */
-  get titleOrUntitled(): string {
-    return this.title ?? 'Untitled'
-  }
-
-  /**
-   * Returns path to this view as an array of groups and this view as the last element
-   * If view is top-level, returns only this view.
-   *
-   * @example
-   * viewPath = "Group 1/Group 2/View"
-   *
-   * breadcrumbs = [
-   *   "Group 1",             // folder
-   *   "Group 1/Group 2",     // folder
-   *   "Group 1/Group 2/View" // view
-   * ]
-   */
-  get breadcrumbs(): [...LikeC4ViewsFolder<A>[], this] {
-    return memoizeProp(this, 'breadcrumbs', () => {
-      if (!this.folder.isRoot) {
-        return [...this.folder.breadcrumbs, this]
-      }
-      return [this]
-    })
-  }
-
-  get description(): RichTextOrEmpty {
-    return RichText.memoize(this, 'description', this.$view.description)
-  }
-
-  get tags(): aux.Tags<A> {
-    return this.$view.tags ?? []
-  }
-
-  get links(): ReadonlyArray<Link> {
-    return this.$view.links ?? []
-  }
-
-  get viewOf(): ElementModel<A> | null {
-    if (this.isElementView()) {
-      const viewOf = this.$view.viewOf
-      return viewOf ? this.$model.element(viewOf) : null
-    }
-    return null
-  }
-
-  /**
-   * Available for dynamic views only
-   * throws error if view is not dynamic
-   */
-  get mode(): DynamicViewDisplayVariant {
-    if (this.isDynamicView()) {
-      return this.$view.variant ?? 'diagram'
-    }
-    throw new Error('View is not dynamic')
-  }
-
-  /**
-   * All tags from nodes and edges.
-   */
-  get includedTags(): aux.Tags<A> {
-    return [...this.#allTags.keys()] as unknown as aux.Tags<A>
-  }
-
-  public roots(): NodesIterator<A, V> {
-    return this.#rootnodes.values()
-  }
-
-  /**
-   * Iterate over all nodes that have children.
-   */
-  public *compounds(): NodesIterator<A, V> {
-    for (const node of this.#nodes.values()) {
-      if (node.hasChildren()) {
-        yield node
-      }
-    }
-    return
-  }
-
-  /**
-   * Get node by id.
-   * @throws Error if node is not found.
-   */
-  public node(node: NodeOrId): NodeModel<A, V> {
-    const nodeId = getId(node)
-    return nonNullable(this.#nodes.get(nodeId), `Node ${nodeId} not found in view ${this.$view.id}`)
-  }
-
-  /**
-   * Find node by id.
-   */
-  public findNode(node: NodeOrId): NodeModel<A, V> | null {
-    return this.#nodes.get(getId(node)) ?? null
-  }
-
-  public findNodeWithElement(element: aux.LooseElementId<A> | { id: aux.Fqn<A> }): NodeModel.WithElement<A, V> | null {
-    const id = getId(element)
-    return ifind(
-      this.#nodes.values(),
-      (node): node is NodeModel.WithElement<A, V> => node.hasElement() && node.element.id === id,
-    ) ?? null
-  }
-
-  /**
-   * Iterate over all nodes.
-   */
-  public nodes(): NodesIterator<A, V> {
-    return this.#nodes.values()
-  }
-
-  /**
-   * Get edge by id, throws error if edge is not found.
-   * Use {@link findEdge} if you are not sure if the edge exists.
-   *
-   * @param edge Edge or id
-   * @returns {@link EdgeModel}
-   */
-  public edge(edge: EdgeOrId): EdgeModel<A, V> {
-    const edgeId = getId(edge)
-    return nonNullable(this.#edges.get(edgeId), `Edge ${edgeId} not found in view ${this.$view.id}`)
-  }
-
-  /**
-   * Find edge by id.
-   * @param edge Edge or id
-   * @returns {@link EdgeModel} or null if edge is not found
-   */
-  public findEdge(edge: EdgeOrId): EdgeModel<A, V> | null {
-    return this.#edges.get(getId(edge)) ?? null
-  }
-
-  /**
-   * Iterate over all edges.
-   */
-  public edges(): EdgesIterator<A, V> {
-    return this.#edges.values()
-  }
-
-  /**
-   * Iterate over all edges.
-   */
-  public *edgesWithRelation(relation: aux.RelationId): EdgesIterator<A, V> {
-    for (const edge of this.#edges.values()) {
-      if (edge.includesRelation(relation)) {
-        yield edge
-      }
-    }
-    return
-  }
-
-  /**
-   * Nodes that have references to elements from logical model.
-   */
-  public *elements(): IteratorLike<NodeModel.WithElement<A, V>> {
-    // return this.#nodes.values().filter(node => node.hasElement())
-    for (const node of this.#nodes.values()) {
-      if (node.hasElement()) {
-        yield node
-      }
-    }
-    return
-  }
-
-  /**
-   * Checks if the view has the given tag.
-   */
-  public isTagged(tag: aux.LooseTag<A>): boolean {
-    return this.tags.includes(tag as aux.Tag<A>)
-  }
-
-  public includesElement(element: aux.LooseElementId<A> | { id: aux.Fqn<A> }): boolean {
-    return this.#includeElements.has(getId(element))
-  }
-
-  public includesDeployment(deployment: aux.LooseDeploymentId<A> | { id: aux.DeploymentFqn<A> }): boolean {
-    return this.#includeDeployments.has(getId(deployment))
-  }
-
-  public includesRelation(relation: scalar.RelationId | { id: scalar.RelationId }): boolean {
-    return this.#includeRelations.has(getId(relation))
-  }
-
-  /**
-   * Below are type guards.
-   */
-  public isComputed(
-    this: LikeC4ViewModel<any, any>,
-  ): this is LikeC4ViewModel<aux.toComputed<A>> {
-    return this.$view[_stage] === 'computed'
-  }
-
-  public isDiagram(
-    this: LikeC4ViewModel<any, any>,
-  ): this is LikeC4ViewModel<aux.toLayouted<A>> {
-    return this.$view[_stage] === 'layouted'
-  }
-
-  public isElementView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.ElementView<A, V> {
-    return this.$view[_type] === 'element'
-  }
-
-  public isScopedElementView(
-    this: LikeC4ViewModel<any, any>,
-  ): this is LikeC4ViewModel.ScopedElementView<A> {
-    return this.$view[_type] === 'element' && isTruthy(this.$view.viewOf)
-  }
-
-  public isDeploymentView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.DeploymentView<A, V> {
-    return this.$view[_type] === 'deployment'
-  }
-
-  public isDynamicView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.DynamicView<A, V> {
-    return this.$view[_type] === 'dynamic'
-  }
-}
-
-export namespace LikeC4ViewModel {
-  export interface ElementView<A extends Any, V extends $View<A> = $View<A>>
-    extends LikeC4ViewModel<A, ViewWithType<V, 'element'>>
-  {
-  }
-
-  export interface ScopedElementView<A extends Any>
-    extends LikeC4ViewModel<A, ViewWithType<$View<A>, 'element'> & { viewOf: aux.StrictFqn<A> }>
-  {
-    viewOf: ElementModel<A>
-  }
-
-  export interface DeploymentView<A extends Any, V extends $View<A> = $View<A>>
-    extends LikeC4ViewModel<A, ViewWithType<V, 'deployment'>>
-  {
-  }
-
-  export type DynamicView<A extends Any, V extends $View<A> = $View<A>> = LikeC4ViewModel<A, ViewWithType<V, 'dynamic'>>
-}