@likec4/core 1.18.0 → 1.19.0

package/src/model/ElementModel.ts

@@ -1,32 +1,38 @@
 import { isTruthy } from 'remeda'
 import {
-  DefaultElementShape,
-  DefaultThemeColor,
   type Element as C4Element,
   type ElementKind as C4ElementKind,
   type ElementShape as C4ElementShape,
+  type IteratorLike,
   type Link,
   type Tag as C4Tag,
-  type ThemeColor
+  type ThemeColor,
+  DefaultElementShape,
+  DefaultThemeColor,
 } from '../types'
-import { commonAncestor } from '../utils'
+import { commonAncestor, hierarchyLevel, isAncestor, sortNaturalByFqn } from '../utils'
 import { type DeployedInstancesIterator } from './DeploymentElementModel'
 import type { LikeC4Model } from './LikeC4Model'
 import type { RelationshipModel, RelationshipsIterator } from './RelationModel'
-import type { AnyAux, IncomingFilter, IteratorLike, OutgoingFilter } from './types'
+import type { AnyAux, IncomingFilter, OutgoingFilter } from './types'
 import type { LikeC4ViewModel, ViewsIterator } from './view/LikeC4ViewModel'
 
 export type ElementsIterator<M extends AnyAux> = IteratorLike<ElementModel<M>>
 
-export class ElementModel<M extends AnyAux> {
+export class ElementModel<M extends AnyAux = AnyAux> {
+  readonly id: M['Fqn']
+  readonly hierarchyLevel: number
+
   constructor(
-    public readonly model: LikeC4Model<M>,
-    public readonly $element: C4Element
+    public readonly $model: LikeC4Model<M>,
+    public readonly $element: C4Element,
   ) {
+    this.id = this.$element.id
+    this.hierarchyLevel = hierarchyLevel(this.id)
   }
 
-  get id(): M['Fqn'] {
-    return this.$element.id
+  get parent(): ElementModel<M> | null {
+    return this.$model.parent(this)
   }
 
   get kind(): C4ElementKind {
@@ -61,20 +67,24 @@ export class ElementModel<M extends AnyAux> {
     return this.$element.links ?? []
   }
 
-  get parent(): ElementModel<M> | null {
-    return this.model.parent(this)
-  }
-
   get defaultView(): LikeC4ViewModel<M> | null {
     return this.scopedViews().next().value ?? null
   }
 
+  public isAncestorOf(another: ElementModel<M>): boolean {
+    return isAncestor(this, another)
+  }
+
+  public isDescendantOf(another: ElementModel<M>): boolean {
+    return isAncestor(another, this)
+  }
+
   /**
    * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
    * (from closest to root)
    */
   public ancestors(): ElementsIterator<M> {
-    return this.model.ancestors(this)
+    return this.$model.ancestors(this)
   }
 
   /**
@@ -82,25 +92,29 @@ export class ElementModel<M extends AnyAux> {
    */
   public commonAncestor(another: ElementModel<M>): ElementModel<M> | null {
     const common = commonAncestor(this.id, another.id)
-    return common ? this.model.element(common) : null
+    return common ? this.$model.element(common) : null
   }
 
   public children(): ReadonlySet<ElementModel<M>> {
-    return this.model.children(this)
+    return this.$model.children(this)
   }
 
   /**
    * Get all descendant elements (i.e. children, children’s children, etc.)
    */
-  public descendants(): ElementsIterator<M> {
-    return this.model.descendants(this)
+  public descendants(sort?: 'asc' | 'desc'): ElementsIterator<M> {
+    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<M> {
-    return this.model.siblings(this)
+    return this.$model.siblings(this)
   }
 
   /**
@@ -115,8 +129,20 @@ export class ElementModel<M extends AnyAux> {
     return
   }
 
+  /**
+   * Resolve siblings of the element and its ancestors
+   *  (from root to closest)
+   */
+  public *descendingSiblings(): ElementsIterator<M> {
+    for (const ancestor of [...this.ancestors()].reverse()) {
+      yield* ancestor.siblings()
+    }
+    yield* this.siblings()
+    return
+  }
+
   public incoming(filter: IncomingFilter = 'all'): RelationshipsIterator<M> {
-    return this.model.incoming(this, filter)
+    return this.$model.incoming(this, filter)
   }
   public *incomers(filter: IncomingFilter = 'all'): ElementsIterator<M> {
     const unique = new Set<M['Fqn']>()
@@ -130,7 +156,7 @@ export class ElementModel<M extends AnyAux> {
     return
   }
   public outgoing(filter: OutgoingFilter = 'all'): RelationshipsIterator<M> {
-    return this.model.outgoing(this, filter)
+    return this.$model.outgoing(this, filter)
   }
   public *outgoers(filter: OutgoingFilter = 'all'): ElementsIterator<M> {
     const unique = new Set<M['Fqn']>()
@@ -161,7 +187,7 @@ export class ElementModel<M extends AnyAux> {
    * Iterate over all views that include this element.
    */
   public *views(): ViewsIterator<M> {
-    for (const view of this.model.views()) {
+    for (const view of this.$model.views()) {
       if (view.includesElement(this.id)) {
         yield view
       }
@@ -174,7 +200,7 @@ export class ElementModel<M extends AnyAux> {
    * It is possible that element is not included in the view.
    */
   public *scopedViews(): ViewsIterator<M> {
-    for (const vm of this.model.views()) {
+    for (const vm of this.$model.views()) {
       if (vm.isElementView() && vm.$view.viewOf === this.id) {
         yield vm
       }
@@ -190,6 +216,6 @@ export class ElementModel<M extends AnyAux> {
   }
 
   public deployments(): DeployedInstancesIterator<M> {
-    return this.model.deployment.instancesOf(this)
+    return this.$model.deployment.instancesOf(this)
   }
 }

package/src/model/LikeC4Model.test-d.ts

@@ -1,6 +1,5 @@
 import { expectTypeOf, test } from 'vitest'
 import { Builder } from '../builder'
-import { computeViews } from '../compute-view/compute-view'
 import type { ComputedView, Fqn, ViewId } from '../types'
 import { LikeC4Model } from './LikeC4Model'
 
@@ -80,8 +79,10 @@ test('LikeC4Model.create: should have types', () => {
     )
     .build()
 
-  const computed = computeViews(source)
-  const m = LikeC4Model.create(computed)
+  const m = LikeC4Model.compute(source)
+
+  // @ts-expect-error
+  m.element('wrong')
 
   expectTypeOf(m.Aux.Element).toEqualTypeOf(
     '' as 'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend'

package/src/model/LikeC4Model.ts

@@ -1,31 +1,33 @@
 import DefaultMap from 'mnemonist/default-map'
-import { pipe, sort, values } from 'remeda'
+import { mapValues, pipe, sort, values } from 'remeda'
 import type { LiteralUnion } from 'type-fest'
+import { computeView, unsafeComputeView } from '../compute-view'
+import type { ComputeViewResult } from '../compute-view/compute-view'
 import { invariant, nonNullable } from '../errors'
-import type { ComputedView, DiagramView } from '../types'
+import type { ComputedView, DiagramView, IteratorLike, LikeC4View, ModelGlobals } from '../types'
 import type { Element } from '../types/element'
 import { type Tag as C4Tag } from '../types/element'
-import type { AnyLikeC4Model, ParsedLikeC4ModelDump } from '../types/model'
-import type { Relation } from '../types/relation'
+import type { AnyParsedLikeC4Model, GenericLikeC4Model, LikeC4ModelDump } from '../types/model'
+import type { ModelRelation } from '../types/relation'
 import { compareNatural } from '../utils'
 import { ancestorsFqn, commonAncestor, parentFqn } from '../utils/fqn'
 import type {
   DeployedInstanceModel,
   DeploymentElementModel,
   DeploymentNodeModel,
-  DeploymentRelationModel
+  DeploymentRelationModel,
 } from './DeploymentElementModel'
 import { LikeC4DeploymentModel } from './DeploymentModel'
-import { ElementModel, type ElementsIterator } from './ElementModel'
-import { RelationshipModel, type RelationshipsIterator } from './RelationModel'
-import { type AnyAux, type Aux, getId, type IncomingFilter, type OutgoingFilter } from './types'
+import { type ElementsIterator, ElementModel } from './ElementModel'
+import { type RelationshipsIterator, RelationshipModel } from './RelationModel'
+import { type AnyAux, type Aux, type IncomingFilter, type OutgoingFilter, getId } from './types'
 import { EdgeModel } from './view/EdgeModel'
 import { LikeC4ViewModel } from './view/LikeC4ViewModel'
 import { NodeModel } from './view/NodeModel'
 
 export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
   /**
-   * Only available in compile time
+   * Only available in compile tim
    */
   readonly Aux!: M
 
@@ -48,7 +50,7 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
   // Relationships inside the element, among descendants
   readonly #internal = new DefaultMap<M['Element'], Set<RelationshipModel<M>>>(() => new Set())
 
-  readonly #views = new Map<M['ViewIdLiteral'], LikeC4ViewModel<M>>()
+  readonly #views = new Map<M['ViewId'], LikeC4ViewModel<M>>()
 
   readonly #allTags = new DefaultMap<C4Tag, Set<ElementModel<M> | RelationshipModel<M> | LikeC4ViewModel<M>>>(() =>
     new Set()
@@ -56,21 +58,62 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
 
   public readonly deployment: LikeC4DeploymentModel<M>
 
-  static create<const M extends AnyLikeC4Model>(model: M) {
-    type T = Aux.FromModel<M>
-    return new LikeC4Model<T>(model as any)
+  /**
+   * Computes views from the parsed model
+   * Creates a new LikeC4Model instance from a parsed model.
+   *
+   * May throw an error if the model is invalid.
+   *
+   * @typeParam M - The type of the parsed LikeC4 model, must extend ParsedLikeC4Model
+   * @param parsed - The parsed LikeC4 model to compute from
+   * @returns A new LikeC4Model instance with computed relationships and structure
+   */
+  static compute<const M extends AnyParsedLikeC4Model>(parsed: M): LikeC4Model<Aux.FromParsed<M>> {
+    let { views, ...rest } = parsed as Omit<M, '__'>
+    const model = new LikeC4Model({ ...rest, views: {} })
+    return new LikeC4Model({
+      ...rest,
+      views: mapValues(views, view => unsafeComputeView(view as LikeC4View, model)),
+    } as any)
+  }
+
+  /**
+   * Creates a function that computes a view using the data from the model.
+   *
+   * @example
+   * const compute = LikeC4Model.makeCompute(parsedModel);
+   * const result = compute(viewSource);
+   */
+  static makeCompute<M extends AnyParsedLikeC4Model>(parsed: M): (viewsource: LikeC4View) => ComputeViewResult {
+    let { views, ...rest } = parsed as Omit<M, '__'>
+    const model = new LikeC4Model(structuredClone({ ...rest, views: {} }))
+    return (viewsource) => computeView(viewsource, model)
   }
 
   /**
-   * This method is supposed to be used only in dumps
+   * Creates a new LikeC4Model instance from the provided model data.
+   *
+   * @typeParam M - Type parameter constrained to AnyLikeC4Model
+   * @param model - The model data to create a LikeC4Model from
+   * @returns A new LikeC4Model instance with the type derived from the input model
    */
-  static fromDump<const M extends ParsedLikeC4ModelDump>(dump: M) {
-    type T = Aux.FromDump<M>
-    return new LikeC4Model<T>(dump as any)
+  static create<const M extends GenericLikeC4Model>(model: M): LikeC4Model<Aux.FromModel<M>> {
+    return new LikeC4Model(model as any)
+  }
+
+  /**
+   * Creates a new LikeC4Model instance from a model dump.
+   *
+   * @typeParam M - A constant type parameter extending LikeC4ModelDump
+   * @param dump - The model dump to create the instance from
+   * @returns A new LikeC4Model instance with types inferred from the dump
+   */
+  static fromDump<const M extends LikeC4ModelDump>(dump: M): LikeC4Model<Aux.FromDump<M>> {
+    return new LikeC4Model(dump as any)
   }
 
   private constructor(
-    public readonly $model: M['Model']
+    public readonly $model: M['Model'],
   ) {
     for (const element of values($model.elements)) {
       const el = this.addElement(element)
@@ -87,10 +130,10 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
     this.deployment = new LikeC4DeploymentModel(this, $model.deployments)
     const views = pipe(
       values($model.views),
-      sort((a, b) => compareNatural(a.title ?? 'untitled', b.title ?? 'untitled'))
+      sort((a, b) => compareNatural(a.title ?? 'untitled', b.title ?? 'untitled')),
     )
     for (const view of views) {
-      const vm = new LikeC4ViewModel(this, view as M['ViewType'])
+      const vm = new LikeC4ViewModel(this, Object.freeze(view as M['ViewType']))
       this.#views.set(view.id, vm)
       for (const tag of vm.tags) {
         this.#allTags.get(tag).add(vm)
@@ -110,7 +153,6 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
     return nonNullable(this.findElement(id), `Element ${getId(el)} not found`)
   }
   public findElement(el: LiteralUnion<M['Element'], string>): ElementModel<M> | null {
-    // const id = getId(el) as C4Fqn
     return this.#elements.get(el) ?? null
   }
 
@@ -144,11 +186,11 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
   public relationship(id: M['RelationId'], type: 'deployment'): DeploymentRelationModel<M>
   public relationship(
     id: M['RelationId'],
-    type?: 'model' | 'deployment'
+    type?: 'model' | 'deployment',
   ): RelationshipModel<M> | DeploymentRelationModel<M>
   public relationship(
     id: M['RelationId'],
-    type: 'model' | 'deployment' | undefined
+    type: 'model' | 'deployment' | undefined,
   ): RelationshipModel<M> | DeploymentRelationModel<M> {
     if (type === 'deployment') {
       return this.deployment.relationship(id)
@@ -164,15 +206,15 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
   public findRelationship(id: LiteralUnion<M['RelationId'], string>, type: 'model'): RelationshipModel<M> | null
   public findRelationship(
     id: LiteralUnion<M['RelationId'], string>,
-    type: 'deployment'
+    type: 'deployment',
   ): DeploymentRelationModel<M> | null
   public findRelationship(
     id: LiteralUnion<M['RelationId'], string>,
-    type?: 'model' | 'deployment'
+    type?: 'model' | 'deployment',
   ): RelationshipModel<M> | DeploymentRelationModel<M> | null
   public findRelationship(
     id: LiteralUnion<M['RelationId'], string>,
-    type: 'model' | 'deployment' | undefined
+    type: 'model' | 'deployment' | undefined,
   ): RelationshipModel<M> | DeploymentRelationModel<M> | null {
     if (type === 'deployment') {
       return this.deployment.findRelationship(id)
@@ -187,18 +229,18 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
   /**
    * Returns all views in the model.
    */
-  public views() {
+  public views(): IteratorLike<LikeC4ViewModel<M>> {
     return this.#views.values()
   }
 
   /**
    * Returns a specific view by its ID.
    */
-  public view(viewId: M['ViewIdLiteral']): LikeC4ViewModel<M> {
-    return nonNullable(this.#views.get(viewId), `View ${viewId} not found`)
+  public view(viewId: M['View']): LikeC4ViewModel<M> {
+    return nonNullable(this.#views.get(viewId as any), `View ${viewId} not found`)
   }
-  public findView(viewId: LiteralUnion<M['ViewId'], string>): LikeC4ViewModel<M> {
-    return nonNullable(this.#views.get(viewId), `View ${viewId} not found`)
+  public findView(viewId: M['View']): LikeC4ViewModel<M> {
+    return nonNullable(this.#views.get(viewId as M['ViewId']), `View ${viewId} not found`)
   }
 
   /**
@@ -265,7 +307,7 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
    */
   public *incoming(
     element: M['ElementOrFqn'],
-    filter: IncomingFilter = 'all'
+    filter: IncomingFilter = 'all',
   ): RelationshipsIterator<M> {
     const id = getId(element)
     for (const rel of this.#incoming.get(id)) {
@@ -286,7 +328,7 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
    */
   public *outgoing(
     element: M['ElementOrFqn'],
-    filter: OutgoingFilter = 'all'
+    filter: OutgoingFilter = 'all',
   ): RelationshipsIterator<M> {
     const id = getId(element)
     for (const rel of this.#outgoing.get(id)) {
@@ -301,11 +343,25 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
     return
   }
 
+  public globals(): ModelGlobals {
+    return {
+      predicates: {
+        ...this.$model.globals?.predicates,
+      },
+      dynamicPredicates: {
+        ...this.$model.globals?.dynamicPredicates,
+      },
+      styles: {
+        ...this.$model.globals?.styles,
+      },
+    }
+  }
+
   private addElement(element: Element) {
     if (this.#elements.has(element.id)) {
       throw new Error(`Element ${element.id} already exists`)
     }
-    const el = new ElementModel(this, element)
+    const el = new ElementModel(this, Object.freeze(structuredClone(element)))
     this.#elements.set(el.id, el)
     const parentId = parentFqn(el.id)
     if (parentId) {
@@ -318,13 +374,13 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
     return el
   }
 
-  private addRelation(relation: Relation) {
+  private addRelation(relation: ModelRelation) {
     if (this.#relations.has(relation.id)) {
       throw new Error(`Relation ${relation.id} already exists`)
     }
     const rel = new RelationshipModel(
       this,
-      relation
+      Object.freeze(structuredClone(relation)),
     )
     const { source, target } = rel
     this.#relations.set(rel.id, rel)
@@ -374,17 +430,17 @@ export namespace LikeC4Model {
 
   export type View<
     M extends AnyAux = Any,
-    V extends ComputedView | DiagramView = M['ViewType']
+    V extends ComputedView | DiagramView = M['ViewType'],
   > = LikeC4ViewModel<M, V>
 
   export type Node<
     M extends AnyAux = Any,
-    V extends ComputedView | DiagramView = M['ViewType']
+    V extends ComputedView | DiagramView = M['ViewType'],
   > = NodeModel<M, V>
 
   export type Edge<
     M extends AnyAux = Any,
-    V extends ComputedView | DiagramView = M['ViewType']
+    V extends ComputedView | DiagramView = M['ViewType'],
   > = EdgeModel<M, V>
 
   export type DeploymentModel<M extends AnyAux = AnyAux> = LikeC4DeploymentModel<M>
@@ -397,18 +453,18 @@ export namespace LikeC4Model {
     Elements extends string = string,
     Deployments extends string = string,
     Views extends string = string,
-    ViewType = DiagramView<Views> | ComputedView<Views>
+    ViewType = DiagramView<Views> | ComputedView<Views>,
   > = Aux<Elements, Deployments, Views, ViewType>
 
   export type Computed<
     Elements extends string = string,
     Deployments extends string = string,
-    Views extends string = string
+    Views extends string = string,
   > = LikeC4Model<Typed<Elements, Deployments, Views, ComputedView<Views>>>
 
   export type Layouted<
     Elements extends string = string,
     Deployments extends string = string,
-    Views extends string = string
+    Views extends string = string,
   > = LikeC4Model<Typed<Elements, Deployments, Views, DiagramView<Views>>>
 }

package/src/model/RelationModel.ts

@@ -1,15 +1,16 @@
 import { isEmpty } from 'remeda'
+import type { IteratorLike } from '../types'
 import type { Link, Tag } from '../types/element'
-import type { Relation } from '../types/relation'
+import type { ModelRelation } from '../types/relation'
 import { commonAncestor } from '../utils/fqn'
 import type { ElementModel } from './ElementModel'
 import type { LikeC4Model } from './LikeC4Model'
-import type { AnyAux, IteratorLike } from './types'
+import type { AnyAux } from './types'
 import type { LikeC4ViewModel, ViewsIterator } from './view/LikeC4ViewModel'
 
 export type RelationshipsIterator<M extends AnyAux> = IteratorLike<RelationshipModel<M>>
 
-export class RelationshipModel<M extends AnyAux> {
+export class RelationshipModel<M extends AnyAux = AnyAux> {
   public readonly source: ElementModel<M>
   public readonly target: ElementModel<M>
 
@@ -21,7 +22,7 @@ export class RelationshipModel<M extends AnyAux> {
 
   constructor(
     public readonly model: LikeC4Model<M>,
-    public readonly $relationship: Relation
+    public readonly $relationship: ModelRelation,
   ) {
     this.source = model.element($relationship.source)
     this.target = model.element($relationship.target)

package/src/model/__test__/fixture.ts

@@ -26,9 +26,7 @@ const {
     viewOf,
     deploymentView,
     $rules,
-    $include,
-    $exclude,
-    $style
+    $include
   }
 } = Builder.forSpecification({
   elements: {
@@ -102,6 +100,7 @@ const local = b
       $m.rel('cloud.backend.api', 'cloud.media', 'uploads media'),
       $m.rel('cloud.backend.api', 'aws.rds', 'reads/writes'),
       $m.rel('cloud.backend.api', 'email', 'sends emails'),
+      $m.rel('cloud', 'email', 'uses'),
       $m.rel('cloud.media', 'aws.s3', 'uploads'),
       $m.rel('email', 'customer', 'sends emails')
     ),
@@ -138,12 +137,9 @@ const local = b
           $include('cloud.frontend.dashboard')
         )
       ),
-      deploymentView(
-        'prod',
-        $rules(
-          $include('customer.instance'),
-          $include('prod.eu.zone1.ui')
-        )
+      deploymentView('prod').with(
+        $include('customer.instance'),
+        $include('prod.eu.zone1.ui')
       )
     )
   )

package/src/model/connection/Connection.ts

@@ -0,0 +1,72 @@
+import type { Fqn } from '../../types'
+import { isAncestor } from '../../utils'
+import type { DeploymentElementModel } from '../DeploymentElementModel'
+import type { ElementModel } from '../ElementModel'
+
+export interface Connection<Elem = ElementModel | DeploymentElementModel, 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)
+  }
+}