@likec4/core 1.18.0 → 1.19.0

package/src/compute-view/utils/sortNodes.ts

@@ -1,101 +0,0 @@
-import { difference, filter, map, pipe, sort, tap } from 'remeda'
-import { invariant, nonNullable } from '../../errors'
-import type { Fqn } from '../../types/element'
-import type { ComputedEdge, ComputedNode, EdgeId } from '../../types/view'
-import { compareByFqnHierarchically } from '../../utils/fqn'
-import { Graph, postorder } from '../../utils/graphlib'
-import { compareRelations } from '../../utils/relations'
-
-// side effect
-function sortChildren(nodes: readonly ComputedNode[]) {
-  nodes.forEach(parent => {
-    if (parent.children.length > 0) {
-      parent.children = nodes.flatMap(n => (n.parent === parent.id ? n.id : []))
-    }
-  })
-}
-
-export function sortNodes({
-  nodes,
-  edges
-}: {
-  nodes: ComputedNode[]
-  edges: ComputedEdge[]
-}): ComputedNode[] {
-  if (nodes.length < 2) {
-    return nodes
-  }
-  if (edges.length === 0) {
-    return pipe(
-      nodes,
-      sort(compareByFqnHierarchically),
-      tap(sortChildren)
-    )
-  }
-
-  const g = new Graph({
-    compound: false,
-    directed: true,
-    multigraph: false
-  })
-
-  const getNode = (id: Fqn) =>
-    nonNullable(
-      nodes.find(n => n.id === id),
-      'Edge not found'
-    )
-  const getEdge = (id: EdgeId) =>
-    nonNullable(
-      edges.find(edge => edge.id === id),
-      'Edge not found'
-    )
-
-  for (const e of [...edges].sort(compareRelations)) {
-    g.setEdge(e.source, e.target)
-  }
-
-  for (const n of nodes) {
-    g.setNode(n.id, n.id)
-    if (n.children.length > 0) {
-      n.inEdges.forEach(e => {
-        const edge = getEdge(e)
-        // if this edge from leaf to the child of this node
-        if (edge.target !== n.id && getNode(edge.source).children.length === 0) {
-          // const id = `${edge.source}:${n.id}`
-          g.setEdge(edge.source, n.id)
-        }
-      })
-      // n.outEdges.forEach(e => {
-      //   const edge = getEdge(e)
-      //   if (edge.source !== n.id) {
-      //     const id = `${n.id}:${edge.target}`
-      //     g.setEdge(n.id, edge.target, undefined, id)
-      //   }
-      // })
-    }
-    if (n.parent) {
-      g.setEdge(n.parent, n.id)
-    }
-  }
-
-  let sources = g.sources() as unknown as Fqn[]
-  if (sources.length === 0) {
-    sources = pipe(
-      nodes,
-      filter(n => n.inEdges.length === 0 || n.parent === null),
-      sort(compareByFqnHierarchically),
-      map(n => n.id)
-    )
-  }
-  // sources = sources.sort(compareFqnHierarchically)
-  const orderedIds = postorder(g, sources).reverse() as Fqn[]
-  const sorted = orderedIds.map(getNode)
-  if (sorted.length < nodes.length) {
-    const unsorted = difference(nodes, sorted).sort(compareByFqnHierarchically)
-    sorted.push(...unsorted)
-  }
-
-  invariant(sorted.length === nodes.length, 'Not all nodes were processed by graphlib')
-  sortChildren(sorted)
-  return sorted
-}

package/src/model/connection/ConnectionModel.ts

@@ -1,94 +0,0 @@
-import { invariant } from '../../errors'
-import { difference, equals, union } from '../../utils/set'
-import { stringHash } from '../../utils/string-hash'
-import type { ElementModel } from '../ElementModel'
-import type { RelationshipModel } from '../RelationModel'
-import type { AnyAux } from '../types'
-
-export interface Connection<Elem = any, Id = any> {
-  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<any, any>, other: typeof this): typeof this
-
-  nonEmpty(): boolean
-
-  difference(this: Connection<Elem, Id>, other: Connection<Elem, Id>): typeof this
-}
-
-/**
- * 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<M extends AnyAux = AnyAux> implements Connection<ElementModel<M>, M['EdgeId']> {
-  public readonly id: M['EdgeId']
-
-  /**
-   * Common ancestor of the source and target elements.
-   * Represents the boundary of the connection.
-   */
-  public readonly boundary: ElementModel<M> | null
-
-  constructor(
-    public readonly source: ElementModel<M>,
-    public readonly target: ElementModel<M>,
-    public readonly relations: ReadonlySet<RelationshipModel<M>>
-  ) {
-    this.id = stringHash(`model:${source.id}:${target.id}`) as M['EdgeId']
-    this.boundary = source.commonAncestor(target)
-  }
-
-  /**
-   * Human readable expression of the connection
-   * Mostly used for testing and debugging
-   */
-  get expression(): string {
-    return `${this.source.id} -> ${this.target.id}`
-  }
-
-  nonEmpty(): boolean {
-    return this.relations.size > 0
-  }
-
-  mergeWith(other: ConnectionModel<M>): ConnectionModel<M> {
-    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<M>): ConnectionModel<M> {
-    invariant(this.source.id === other.source.id, 'Cannot difference connection with different sources')
-    invariant(this.target.id === other.target.id, 'Cannot difference connection with different targets')
-    return new ConnectionModel(
-      this.source,
-      this.target,
-      difference(this.relations, other.relations)
-    )
-  }
-
-  equals(other: ConnectionModel<M>): boolean {
-    return this.id === other.id
-      && this.source.id === other.source.id
-      && this.target.id === other.target.id
-      && equals(this.relations, other.relations)
-  }
-}

package/src/model/connection/DeploymentConnectionModel.ts

@@ -1,99 +0,0 @@
-import { invariant } from '../../errors'
-import { stringHash } from '../../utils'
-import { equals } from '../../utils/set'
-import {
-  type DeploymentElementModel,
-  DeploymentNodeModel,
-  type DeploymentRelationModel,
-  RelationshipsAccum
-} from '../DeploymentElementModel'
-import type { RelationshipModel } from '../RelationModel'
-import type { AnyAux, IteratorLike } from '../types'
-import type { Connection } from './ConnectionModel'
-
-/**
- * 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<M extends AnyAux = AnyAux>
-  implements Connection<DeploymentElementModel<M>, M['EdgeId']>
-{
-  /**
-   * Common ancestor of the source and target elements.
-   * Represents the boundary of the connection.
-   */
-  readonly boundary: DeploymentNodeModel<M> | null
-
-  constructor(
-    public readonly source: DeploymentElementModel<M>,
-    public readonly target: DeploymentElementModel<M>,
-    public readonly relations: RelationshipsAccum<M>
-  ) {
-    this.id = stringHash(`deployment:${source.id}:${target.id}`) as M['EdgeId']
-    this.boundary = source.commonAncestor(target)
-  }
-
-  readonly id: M['EdgeId']
-
-  /**
-   * Human readable expression of the connection
-   * Mostly used for testing and debugging
-   */
-  get expression(): string {
-    return `${this.source.id} -> ${this.target.id}`
-  }
-
-  nonEmpty(): boolean {
-    return this.relations.nonEmpty
-  }
-
-  /**
-   * 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<M> | DeploymentRelationModel<M>> {
-    yield* this.relations.model
-    yield* this.relations.deployment
-  }
-
-  /**
-   * Merge with another connection, if it has the same source and target.
-   * Returns new connection with union of relationships.
-   */
-  public mergeWith(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M> {
-    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<M>): DeploymentConnectionModel<M> {
-    invariant(this.source.id === other.source.id, 'Cannot difference connection with different sources')
-    invariant(this.target.id === other.target.id, 'Cannot difference connection with different targets')
-    return new DeploymentConnectionModel(
-      this.source,
-      this.target,
-      this.relations.difference(other.relations)
-    )
-  }
-
-  public equals(other: DeploymentConnectionModel<M>): boolean {
-    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)
-  }
-}