@likec4/core 1.19.2 → 1.20.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@likec4/core",
-  "version": "1.19.2",
+  "version": "1.20.0",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
   "repository": {
     "type": "git",
-    "url": "https://github.com/likec4/likec4.git",
+    "url": "git+https://github.com/likec4/likec4.git",
     "directory": "packages/core"
   },
   "bugs": "https://github.com/likec4/likec4/issues",
@@ -16,7 +16,8 @@
     "lint": "run -T eslint src/ --fix",
     "test": "vitest run --no-isolate",
     "test:watch": "vitest",
-    "clean": "rm -r -f dist"
+    "clean": "rm -r -f dist",
+    "package": "yarn pack"
   },
   "files": [
     "dist",
@@ -30,50 +31,74 @@
   "exports": {
     ".": {
       "sources": "./src/index.ts",
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
       "default": {
-        "types": "./dist/index.d.ts",
-        "import": "./dist/index.js",
-        "default": "./dist/index.js"
+        "types": "./dist/index.d.mts",
+        "import": "./dist/index.mjs",
+        "default": "./dist/index.mjs"
       }
     },
     "./builder": {
       "sources": "./src/builder/index.ts",
+      "require": {
+        "types": "./dist/builder/index.d.cts",
+        "default": "./dist/builder/index.cjs"
+      },
       "default": {
-        "types": "./dist/builder/index.d.ts",
-        "import": "./dist/builder/index.js",
-        "default": "./dist/builder/index.js"
+        "types": "./dist/builder/index.d.mts",
+        "import": "./dist/builder/index.mjs",
+        "default": "./dist/builder/index.mjs"
       }
     },
     "./compute-view": {
       "sources": "./src/compute-view/index.ts",
+      "require": {
+        "types": "./dist/compute-view/index.d.cts",
+        "default": "./dist/compute-view/index.cjs"
+      },
       "default": {
-        "types": "./dist/compute-view/index.d.ts",
-        "import": "./dist/compute-view/index.js",
-        "default": "./dist/compute-view/index.js"
+        "types": "./dist/compute-view/index.d.mts",
+        "import": "./dist/compute-view/index.mjs",
+        "default": "./dist/compute-view/index.mjs"
       }
     },
     "./model": {
       "sources": "./src/model/index.ts",
+      "require": {
+        "types": "./dist/model/index.d.cts",
+        "default": "./dist/model/index.cjs"
+      },
       "default": {
-        "types": "./dist/model/index.d.ts",
-        "import": "./dist/model/index.js",
-        "default": "./dist/model/index.js"
+        "types": "./dist/model/index.d.mts",
+        "import": "./dist/model/index.mjs",
+        "default": "./dist/model/index.mjs"
       }
     },
     "./utils": {
       "sources": "./src/utils/index.ts",
+      "require": {
+        "types": "./dist/utils/index.d.cts",
+        "default": "./dist/utils/index.cjs"
+      },
       "default": {
-        "types": "./dist/utils/index.d.ts",
-        "import": "./dist/utils/index.js",
-        "default": "./dist/utils/index.js"
+        "types": "./dist/utils/index.d.mts",
+        "import": "./dist/utils/index.mjs",
+        "default": "./dist/utils/index.mjs"
       }
     },
     "./types": {
       "sources": "./src/types/index.ts",
+      "require": {
+        "types": "./dist/types/index.d.cts",
+        "default": "./dist/types/index.cjs"
+      },
       "default": {
-        "types": "./dist/types/index.d.ts",
-        "import": "./dist/types/index.js",
-        "default": "./dist/types/index.js"
+        "types": "./dist/types/index.d.mts",
+        "import": "./dist/types/index.mjs",
+        "default": "./dist/types/index.mjs"
       }
     }
   },
@@ -85,7 +110,8 @@
     "type-fest": "4.28.1"
   },
   "devDependencies": {
-    "@likec4/tsconfig": "1.19.2",
+    "@dagrejs/dagre": "1.1.4",
+    "@likec4/tsconfig": "1.20.0",
     "@mantine/colors-generator": "7.15.2",
     "@types/natural-compare-lite": "^1.4.2",
     "@types/object-hash": "^3.0.6",
@@ -98,10 +124,10 @@
     "natural-compare-lite": "^1.4.0",
     "object-hash": "^3.0.0",
     "obliterator": "^2.0.4",
-    "remeda": "^2.17.4",
+    "remeda": "^2.19.0",
     "turbo": "^2.3.3",
-    "typescript": "^5.7.2",
-    "unbuild": "^3.1.0",
+    "typescript": "^5.7.3",
+    "unbuild": "^3.2.0",
     "vitest": "^2.1.8"
   },
   "packageManager": "yarn@4.6.0"

package/src/builder/Builder.view-common.ts

@@ -6,11 +6,12 @@ import {
   type CustomRelationExpr,
   type ElementExpression as C4ElementExpression,
   type Expression as C4Expression,
-  isElementPredicateExpr,
   type NonEmptyArray,
   type ViewRuleStyle,
   type WhereOperator,
+  isElementPredicateExpr,
 } from '../types'
+import type { KindEqual, Participant, TagEqual } from '../types/operators'
 import type { AnyTypes, Types } from './_types'
 
 export interface LikeC4ViewBuilder<
@@ -59,10 +60,14 @@ export namespace ViewPredicate {
 
   export type WhereTag<Tag extends string> = `tag ${'is' | 'is not'} #${Tag}`
   export type WhereKind<Kind extends string> = `kind ${'is' | 'is not'} ${Kind}`
+  export type WhereParticipant<Types extends AnyTypes> = `${Participant}.${
+    | WhereTag<Types['Tag']>
+    | WhereKind<Types['ElementKind']>}`
 
   export type WhereEq<Types extends AnyTypes> =
     | ViewPredicate.WhereTag<Types['Tag']>
     | ViewPredicate.WhereKind<Types['ElementKind']>
+    | ViewPredicate.WhereParticipant<Types>
 
   export type WhereOperator<Types extends AnyTypes> = ViewPredicate.WhereEq<Types> | {
     and: NonEmptyArray<ViewPredicate.WhereOperator<Types>>
@@ -116,6 +121,20 @@ function parseWhere(where: ViewPredicate.WhereOperator<AnyTypes>): WhereOperator
             eq: op.replace('kind is ', ''),
           },
         }
+      case op.startsWith('source.'):
+        return {
+          operator: parseWhere(op.replace('source.', '') as ViewPredicate.WhereOperator<AnyTypes>) as
+            | KindEqual<string>
+            | TagEqual<string>,
+          participant: 'source',
+        }
+      case op.startsWith('target.'):
+        return {
+          operator: parseWhere(op.replace('target.', '') as ViewPredicate.WhereOperator<AnyTypes>) as
+            | KindEqual<string>
+            | TagEqual<string>,
+          participant: 'target',
+        }
       default:
         throw new Error(`Unknown where operator: ${where}`)
     }

package/src/compute-view/deployment-view/predicates/relation-direct.ts

@@ -1,4 +1,4 @@
-import { filter, flatMap, isNonNullish, pick, pipe } from 'remeda'
+import { filter, flatMap, isNonNullish, map, pick, pipe } from 'remeda'
 import { invariant } from '../../../errors'
 import type {
   ConnectionModel,
@@ -53,10 +53,14 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
     switch (true) {
       // * -> *
       case sourceIsWildcard && targetIsWildcard: {
-        connections = findConnectionsWithin(model.instances()).map(c => {
-          stage.addImplicit(c.boundary)
-          return c
-        })
+        connections = pipe(
+          findConnectionsWithin(model.instances()),
+          applyPredicate(where),
+          map(c => {
+            stage.addImplicit(c.boundary)
+            return c
+          }),
+        )
         break
       }
 
@@ -71,12 +75,15 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
           postFilter = c => isSource(c) !== isTarget(c)
         }
 
-        connections = sources
-          .flatMap(source => {
+        connections = pipe(
+          sources,
+          flatMap(source => {
             const targets = resolveAscendingSiblings(source)
             return findConnectionsBetween(source, targets, dir)
-          })
-          .filter(postFilter)
+          }),
+          filter(postFilter),
+          applyPredicate(where),
+        )
         break
       }
       // * -> target; * <-> target
@@ -90,12 +97,15 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
           postFilter = c => isSource(c) !== isTarget(c)
         }
 
-        connections = targets
-          .flatMap(target => {
+        connections = pipe(
+          targets,
+          flatMap(target => {
             const sources = resolveAscendingSiblings(target)
             return [...sources].flatMap(source => findConnection(source, target, dir))
-          })
-          .filter(postFilter)
+          }),
+          filter(postFilter),
+          applyPredicate(where),
+        )
         break
       }
       default: {
@@ -109,8 +119,9 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
 
         connections = pipe(
           sources,
-          flatMap(s => matchConnections(findConnectionsBetween(s, targets, dir), where)),
+          flatMap(s => findConnectionsBetween(s, targets, dir)),
           filter(c => isSource(c) && isTarget(c)),
+          applyPredicate(where),
         )
       }
     }
@@ -134,7 +145,7 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
     switch (true) {
       // * -> *
       case FqnExpr.isWildcard(expr.source) && FqnExpr.isWildcard(expr.target):
-        stage.excludeConnections(matchConnections(memory.connections, where))
+        stage.excludeConnections(applyPredicate(memory.connections, where))
         return stage
 
       // model -> model
@@ -250,17 +261,3 @@ function matchConnection<M extends AnyAux>(
   ]
     .filter(where).length > 0
 }
-
-function matchConnections<M extends AnyAux>(
-  connections: readonly DeploymentConnectionModel<M>[],
-  where: OperatorPredicate<Filterable> | null,
-): readonly DeploymentConnectionModel[] {
-  if (!where) {
-    return connections
-  }
-
-  return pipe(
-    connections,
-    filter(c => matchConnection(c, where)),
-  )
-}

package/src/compute-view/deployment-view/predicates/relation-incoming.ts

@@ -8,7 +8,7 @@ import { isAncestor } from '../../../utils'
 import type { Connection, Elem, PredicateExecutor } from '../_types'
 import { resolveElements, resolveModelElements } from '../utils'
 import { resolveAscendingSiblings } from './relation-direct'
-import { applyPredicate, excludeModelRelations, matchConnection, matchConnections } from './utils'
+import { applyPredicate, excludeModelRelations } from './utils'
 
 // from visible element incoming to this
 export const IncomingRelationPredicate: PredicateExecutor<RelationExpr.Incoming> = {

package/src/compute-view/deployment-view/predicates/utils.ts

@@ -1,7 +1,13 @@
 import { filter, isArray, map, pick, pipe } from 'remeda'
 import { nonexhaustive } from '../../../errors'
-import type { DeploymentConnectionModel } from '../../../model'
-import type { DeploymentElementModel, DeploymentRelationModel } from '../../../model/DeploymentElementModel'
+import { type DeploymentConnectionModel, ElementModel, isDeployedInstance, isDeploymentNode } from '../../../model'
+import type {
+  DeploymentElementModel,
+  DeploymentRelationEndpoint,
+  DeploymentRelationModel,
+} from '../../../model/DeploymentElementModel'
+import { isElementModel } from '../../../model/ElementModel'
+import { isDeploymentElementModel, isNestedElementOfDeployedInstanceModel } from '../../../model/guards'
 import type { RelationshipModel } from '../../../model/RelationModel'
 import type { AnyAux } from '../../../model/types'
 import { type Filterable, type OperatorPredicate, FqnExpr, RelationExpr } from '../../../types'
@@ -143,10 +149,9 @@ export function applyPredicate<M extends AnyAux>(
       .filter(x => x.nonEmpty())
   }
 
-  const map = toFilterableRelation(c.source, c.target)
   return c.update({
-    model: new Set([...c.relations.model.values()].filter(r => where(map(r)))),
-    deployment: new Set([...c.relations.deployment.values()].filter(r => where(map(r)))),
+    model: new Set([...c.relations.model.values()].filter(r => where(toFilterableRelation(c)(r)))),
+    deployment: new Set([...c.relations.deployment.values()].filter(r => where(toFilterableRelation(c)(r)))),
   })
 }
 
@@ -164,20 +169,46 @@ export function matchConnections<M extends AnyAux>(
   )
 }
 
-function elementToFilterable<M extends AnyAux>(element: DeploymentElementModel<M>) {
-  return pick(element, ['tags', 'kind'])
+/**
+ * Builds filterable presentation for relation endpoint. Enriches model properties with deployment properties when needed.
+ * @param relationEndpoint Endpoint for which to build presentation
+ * @param connectionEndpoint Endpoint of connection which was build from the relation.
+ * @returns Presentation of the endpoint for usage in predicates
+ */
+function toFilterable<M extends AnyAux>(
+  relationEndpoint: ElementModel<M> | DeploymentRelationEndpoint<M>,
+  connectionEndpoint: DeploymentRelationEndpoint<M>,
+): Filterable {
+  if (isElementModel(relationEndpoint)) { // Element itself. Extend with tags of the deployed instance (TODO)
+    const deployedInstance = isDeploymentElementModel(connectionEndpoint) && isDeployedInstance(connectionEndpoint)
+      ? connectionEndpoint
+      : null
+    return {
+      kind: relationEndpoint.kind,
+      tags: [...relationEndpoint.tags, ...(deployedInstance?.tags ?? [])],
+    }
+  }
+  if (isNestedElementOfDeployedInstanceModel(relationEndpoint)) { // Nested element. Has no own instance. No need to extend
+    return pick(relationEndpoint.element, ['tags', 'kind'])
+  }
+  if (isDeployedInstance(relationEndpoint)) { // Deployed instance. Extend with tags of the model element
+    return {
+      kind: relationEndpoint.element.kind,
+      tags: [...relationEndpoint.tags, ...relationEndpoint.element.tags],
+    }
+  }
+  if (isDeploymentNode(relationEndpoint)) { // Deployment node. Has no representation in model. No need to extend
+    return pick(relationEndpoint, ['tags', 'kind'])
+  }
+
+  nonexhaustive(relationEndpoint)
 }
 
-function toFilterableRelation<M extends AnyAux>(
-  source: DeploymentElementModel<M>,
-  target: DeploymentElementModel<M>,
-) {
-  return (
-    relation: RelationshipModel<M> | DeploymentRelationModel<M>,
-  ) => ({
+function toFilterableRelation<M extends AnyAux>(c: DeploymentConnectionModel<M>) {
+  return (relation: RelationshipModel<M> | DeploymentRelationModel<M>) => ({
     tags: relation.tags,
     kind: relation.kind,
-    source: elementToFilterable(source),
-    target: elementToFilterable(target),
+    source: toFilterable(relation.source, c.source),
+    target: toFilterable(relation.target, c.target),
   })
 }

package/src/compute-view/element-view/__test__/fixture.ts

@@ -18,10 +18,7 @@ import {
   type IconUrl,
   type IncomingExpr as C4IncomingExpr,
   type InOutExpr as C4InOutExpr,
-  isElementRef,
-  isElementWhere,
-  isRelationExpression,
-  isRelationWhere,
+  type KindEqual,
   type ModelRelation,
   type NonEmptyArray,
   type OutgoingExpr as C4OutgoingExpr,
@@ -30,6 +27,7 @@ import {
   type RelationshipLineType,
   type RelationWhereExpr,
   type Tag,
+  type TagEqual,
   type ViewId,
   type ViewRule,
   type ViewRuleGlobalPredicateRef,
@@ -38,8 +36,13 @@ import {
   type ViewRulePredicate,
   type ViewRuleStyle,
   type WhereOperator,
+  isElementRef,
+  isElementWhere,
+  isRelationExpression,
+  isRelationWhere,
 } from '../../../types'
 import { type DirectRelationExpr as C4RelationExpr } from '../../../types/expression'
+import type { Participant } from '../../../types/operators'
 import { withReadableEdges } from '../../utils/with-readable-edges'
 import { computeElementView } from '../compute'
 
@@ -482,6 +485,16 @@ export function $where(
   }
 }
 
+export function $participant(
+  participant: Participant,
+  operator: TagEqual<TestTag> | KindEqual<TestTag>,
+): WhereOperator<TestTag, string> {
+  return {
+    participant,
+    operator,
+  }
+}
+
 export function $inout(
   expr: InOutExpr | C4ElementExpression,
 ): C4InOutExpr {

package/src/compute-view/element-view/compute.ts

@@ -1,8 +1,9 @@
 import DefaultMap from 'mnemonist/default-map'
 import { filter, findLast, forEach, map, pipe } from 'remeda'
 import { invariant, nonexhaustive, nonNullable } from '../../errors'
-import { type ElementModel, LikeC4Model } from '../../model'
 import { ConnectionModel } from '../../model/connection/model/ConnectionModel'
+import { type ElementModel } from '../../model/ElementModel'
+import { LikeC4Model } from '../../model/LikeC4Model'
 import type { RelationshipModel } from '../../model/RelationModel'
 import type { AnyAux } from '../../model/types'
 import type {
@@ -15,7 +16,7 @@ import type {
 } from '../../types'
 import { isViewRuleAutoLayout, isViewRuleGroup, isViewRulePredicate, whereOperatorAsPredicate } from '../../types'
 import * as Expr from '../../types/expression'
-import { sortNaturalByFqn, sortParentsFirst } from '../../utils'
+import { sortParentsFirst } from '../../utils'
 import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
 import { applyCustomRelationProperties } from '../utils/applyCustomRelationProperties'
 import { applyViewRuleStyles } from '../utils/applyViewRuleStyles'