@likec4/core 1.27.3 → 1.28.1

package/src/types/expression-v2.ts

@@ -1,8 +1,12 @@
 import { invariant } from '../errors'
 import type { ExclusiveUnion } from './_common'
 import type { DeploymentRef as DeploymentModelRef, PredicateSelector } from './deployments'
-import type { Fqn } from './element'
+import type { BorderStyle, ElementKind, ElementShape } from './element'
 import type { WhereOperator } from './operators'
+import type { RelationshipArrowType, RelationshipLineType } from './relation'
+import { type Fqn, type IconUrl, type ProjectId, type Tag, GlobalFqn } from './scalars'
+import type { Color, ShapeSize } from './theme'
+import type { ViewId } from './view'
 
 export namespace FqnRef {
   /**
@@ -37,7 +41,7 @@ export namespace FqnRef {
 
   export type DeploymentRef<D = Fqn, M = Fqn> = DeploymentElementRef<D> | InsideInstanceRef<D, M>
   export const isDeploymentRef = (ref: FqnRef): ref is DeploymentRef => {
-    return !isModelRef(ref)
+    return !isModelRef(ref) && !isImportRef(ref)
   }
 
   /**
@@ -47,7 +51,18 @@ export namespace FqnRef {
     model: F
   }
   export const isModelRef = (ref: FqnRef): ref is ModelRef => {
-    return 'model' in ref
+    return 'model' in ref && !('project' in ref)
+  }
+
+  /**
+   * Reference to imported logical model element
+   */
+  export type ImportRef<F = Fqn> = {
+    project: ProjectId
+    model: F
+  }
+  export const isImportRef = (ref: FqnRef): ref is ImportRef => {
+    return 'project' in ref && 'model' in ref
   }
 
   export const toDeploymentRef = (ref: FqnRef): DeploymentModelRef => {
@@ -61,28 +76,39 @@ export namespace FqnRef {
         id: ref.deployment,
       }
   }
+
+  export const toModelFqn = (ref: FqnRef): Fqn => {
+    if (isImportRef(ref)) {
+      return GlobalFqn(ref.project, ref.model)
+    }
+    if (isModelRef(ref)) {
+      return ref.model
+    }
+    throw new Error('Expected FqnRef.ModelRef or FqnRef.ImportRef')
+  }
 }
 
 export type FqnRef<D = Fqn, M = Fqn> = ExclusiveUnion<{
   InsideInstanceRef: FqnRef.InsideInstanceRef<D, M>
   DeploymentRef: FqnRef.DeploymentRef<D>
   ModelRef: FqnRef.ModelRef<M>
+  ImportRef: FqnRef.ImportRef<M>
 }>
 
 export namespace FqnExpr {
   export type Wildcard = {
     wildcard: true
   }
-  export const isWildcard = (expr: ExpressionV2): expr is Wildcard => {
+  export const isWildcard = (expr: ExpressionV2): expr is FqnExpr.Wildcard => {
     return 'wildcard' in expr && expr.wildcard === true
   }
 
   export type ModelRef<M = Fqn> = {
-    ref: FqnRef.ModelRef<M>
+    ref: FqnRef.ModelRef<M> | FqnRef.ImportRef<M>
     selector?: PredicateSelector
   }
-  export const isModelRef = (ref: ExpressionV2): ref is ModelRef => {
-    return 'ref' in ref && FqnRef.isModelRef(ref.ref)
+  export const isModelRef = (ref: ExpressionV2): ref is FqnExpr.ModelRef => {
+    return 'ref' in ref && (FqnRef.isModelRef(ref.ref) || FqnRef.isImportRef(ref.ref))
   }
 
   export type DeploymentRef<D = Fqn, M = Fqn> = {
@@ -93,53 +119,216 @@ export namespace FqnExpr {
     return 'ref' in ref && FqnRef.isDeploymentRef(ref.ref)
   }
 
+  export type ElementKindExpr = {
+    elementKind: ElementKind
+    isEqual: boolean
+  }
+  export function isElementKindExpr(expr: ExpressionV2): expr is ElementKindExpr {
+    return 'elementKind' in expr && 'isEqual' in expr
+  }
+
+  export type ElementTagExpr = {
+    elementTag: Tag
+    isEqual: boolean
+  }
+  export function isElementTagExpr(expr: ExpressionV2): expr is ElementTagExpr {
+    return 'elementTag' in expr && 'isEqual' in expr
+  }
+
   export type NonWildcard<D = Fqn, M = Fqn> = ExclusiveUnion<{
     ModelRef: ModelRef<M>
     DeploymentRef: DeploymentRef<D, M>
+    ElementKind: ElementKindExpr
+    ElementTag: ElementTagExpr
+  }>
+
+  export type Where<D = Fqn, M = Fqn> = {
+    where: {
+      expr: ExclusiveUnion<{
+        Wildcard: Wildcard
+        ModelRef: ModelRef<M>
+        DeploymentRef: DeploymentRef<D, M>
+        ElementKind: ElementKindExpr
+        ElementTag: ElementTagExpr
+      }>
+      condition: WhereOperator<string, string>
+    }
+  }
+
+  export const isWhere = (expr: ExpressionV2): expr is FqnExpr.Where => {
+    return 'where' in expr && is(expr.where.expr)
+  }
+
+  export type Custom<D = Fqn, M = Fqn> = {
+    custom: {
+      expr: OrWhere<D, M>
+      title?: string
+      description?: string
+      technology?: string
+      notation?: string
+      shape?: ElementShape
+      color?: Color
+      icon?: IconUrl
+      border?: BorderStyle
+      opacity?: number
+      navigateTo?: ViewId
+      multiple?: boolean
+      size?: ShapeSize
+      padding?: ShapeSize
+      textSize?: ShapeSize
+    }
+  }
+
+  export const isCustom = (expr: ExpressionV2): expr is Custom => {
+    return 'custom' in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr))
+  }
+
+  export const is = (expr: ExpressionV2): expr is FqnExpr => {
+    return isWildcard(expr)
+      || isModelRef(expr)
+      || isDeploymentRef(expr)
+      || isElementKindExpr(expr)
+      || isElementTagExpr(expr)
+  }
+
+  export type OrWhere<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard
+    ModelRef: FqnExpr.ModelRef<M>
+    DeploymentRef: FqnExpr.DeploymentRef<D, M>
+    ElementKind: ElementKindExpr
+    ElementTag: ElementTagExpr
+    Where: FqnExpr.Where<D, M>
+  }>
+
+  export type Any<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Wildcard: Wildcard
+    ModelRef: ModelRef<M>
+    DeploymentRef: DeploymentRef<D, M>
+    ElementKind: ElementKindExpr
+    ElementTag: ElementTagExpr
+    Where: Where<D, M>
+    Custom: Custom<D, M>
   }>
+
+  export const unwrap = (expr: FqnExpr): Wildcard | ModelRef | DeploymentRef | ElementKindExpr | ElementTagExpr  => {
+    if (isCustom(expr)) {
+      expr = expr.custom.expr
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr
+    }
+    return expr
+  }
 }
 
 export type FqnExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
   Wildcard: FqnExpr.Wildcard
   ModelRef: FqnExpr.ModelRef<M>
   DeploymentRef: FqnExpr.DeploymentRef<D, M>
+  ElementKind: FqnExpr.ElementKindExpr
+  ElementTag: FqnExpr.ElementTagExpr
 }>
 
 export namespace RelationExpr {
+  export type Endpoint<D = Fqn, M = Fqn> = FqnExpr.Where<D, M>['where']['expr']
+
   export type Direct<D = Fqn, M = Fqn> = {
-    source: FqnExpr<D, M>
-    target: FqnExpr<D, M>
+    source: Endpoint<D, M>
+    target: Endpoint<D, M>
     isBidirectional?: boolean
   }
-  export const isDirect = (expr: ExpressionV2): expr is Direct => {
+  export const isDirect = (expr: ExpressionV2): expr is RelationExpr.Direct => {
     return 'source' in expr && 'target' in expr
   }
   export type Incoming<D = Fqn, M = Fqn> = {
-    incoming: FqnExpr<D, M>
+    incoming: Endpoint<D, M>
   }
-  export const isIncoming = (expr: ExpressionV2): expr is Incoming => {
+  export const isIncoming = (expr: ExpressionV2): expr is RelationExpr.Incoming => {
     return 'incoming' in expr
   }
   export type Outgoing<D = Fqn, M = Fqn> = {
-    outgoing: FqnExpr<D, M>
+    outgoing: Endpoint<D, M>
   }
-  export const isOutgoing = (expr: ExpressionV2): expr is Outgoing => {
+  export const isOutgoing = (expr: ExpressionV2): expr is RelationExpr.Outgoing => {
     return 'outgoing' in expr
   }
   export type InOut<D = Fqn, M = Fqn> = {
-    inout: FqnExpr<D, M>
+    inout: Endpoint<D, M>
   }
-  export const isInOut = (expr: ExpressionV2): expr is InOut => {
+  export const isInOut = (expr: ExpressionV2): expr is RelationExpr.InOut => {
     return 'inout' in expr
   }
   export type Where<D = Fqn, M = Fqn> = {
     where: {
-      expr: ExpressionV2<D, M>
+      expr: ExclusiveUnion<{
+        Direct: RelationExpr.Direct<D, M>
+        Incoming: RelationExpr.Incoming<D, M>
+        Outgoing: RelationExpr.Outgoing<D, M>
+        InOut: RelationExpr.InOut<D, M>
+      }>
       condition: WhereOperator<string, string>
     }
   }
-  export const isWhere = (expr: ExpressionV2): expr is Where => {
-    return 'where' in expr
+  export const isWhere = (expr: ExpressionV2): expr is RelationExpr.Where => {
+    return 'where' in expr &&
+      (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) ||
+        isInOut(expr.where.expr))
+  }
+
+  export type Custom<D = Fqn, M = Fqn> = {
+    customRelation: {
+      expr: OrWhere<D, M>
+      title?: string
+      description?: string
+      technology?: string
+      notation?: string
+      // Link to dynamic view
+      navigateTo?: ViewId
+      // Notes for walkthrough
+      notes?: string
+      color?: Color
+      line?: RelationshipLineType
+      head?: RelationshipArrowType
+      tail?: RelationshipArrowType
+    }
+  }
+
+  export const isCustom = (expr: ExpressionV2): expr is Custom => {
+    return 'customRelation' in expr
+  }
+
+  export const is = (expr: ExpressionV2): expr is RelationExpr => {
+    return isDirect(expr)
+      || isIncoming(expr)
+      || isOutgoing(expr)
+      || isInOut(expr)
+  }
+
+  export type OrWhere<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Direct: Direct<D, M>
+    Incoming: Incoming<D, M>
+    Outgoing: Outgoing<D, M>
+    InOut: InOut<D, M>
+    Where: Where<D, M>
+  }>
+
+  export type Any<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Direct: Direct<D, M>
+    Incoming: Incoming<D, M>
+    Outgoing: Outgoing<D, M>
+    InOut: InOut<D, M>
+    Where: Where<D, M>
+    Custom: Custom<D, M>
+  }>
+
+  export const unwrap = (expr: RelationExpr): Direct | Incoming | Outgoing | InOut => {
+    if (isCustom(expr)) {
+      expr = expr.customRelation.expr
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr
+    }
+    return expr
   }
 }
 
@@ -148,7 +337,6 @@ export type RelationExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
   Incoming: RelationExpr.Incoming<D, M>
   Outgoing: RelationExpr.Outgoing<D, M>
   InOut: RelationExpr.InOut<D, M>
-  Where: RelationExpr.Where<D, M>
 }>
 
 /**
@@ -161,24 +349,44 @@ export type ExpressionV2<D = Fqn, M = Fqn> = ExclusiveUnion<{
   Wildcard: FqnExpr.Wildcard
   ModelRef: FqnExpr.ModelRef<M>
   DeploymentRef: FqnExpr.DeploymentRef<D, M>
+  ElementKind: FqnExpr.ElementKindExpr
+  ElementTag: FqnExpr.ElementTagExpr
+  Custom: FqnExpr.Custom<D, M>
   Direct: RelationExpr.Direct<D, M>
   Incoming: RelationExpr.Incoming<D, M>
   Outgoing: RelationExpr.Outgoing<D, M>
   InOut: RelationExpr.InOut<D, M>
-  RelationPredicateOrWhere: RelationExpr.Where<D, M>
+  Where: ExpressionV2.Where<D, M>
+  CustomRelation: RelationExpr.Custom<D, M>
 }>
 
 export namespace ExpressionV2 {
-  export const isFqnExpr = (expr: ExpressionV2): expr is FqnExpr => {
-    return FqnExpr.isWildcard(expr)
-      || FqnExpr.isModelRef(expr)
-      || FqnExpr.isDeploymentRef(expr)
+  export type Where<D = Fqn, M = Fqn> = FqnExpr.Where<D, M> | RelationExpr.Where<D, M>
+  // export type Where<D = Fqn, M = Fqn> = {
+  //   where: ExclusiveUnion<{
+  //     Fqn: FqnExpr.Where<D, M>['where']['expr']
+  //     Relation: RelationExpr.Where<D, M>['where']['expr']
+  //   }>
+  //   condition: WhereOperator<string, string>
+  // }
+
+  export const isWhere = (expr: ExpressionV2): expr is ExpressionV2.Where => {
+    return 'where' in expr
+  }
+
+  export const isRelationWhere = (expr: ExpressionV2): expr is RelationExpr.Where => {
+    return RelationExpr.isWhere(expr)
+  }
+
+  export const isFqnExprWhere = (expr: ExpressionV2): expr is FqnExpr.Where => {
+    return FqnExpr.isWhere(expr)
+  }
+
+  export const isFqnExpr = (expr: ExpressionV2): expr is FqnExpr.Any => {
+    return FqnExpr.is(expr) || FqnExpr.isWhere(expr) || FqnExpr.isCustom(expr)
   }
 
-  export const isRelation = (expr: ExpressionV2): expr is RelationExpr => {
-    return RelationExpr.isDirect(expr)
-      || RelationExpr.isIncoming(expr)
-      || RelationExpr.isOutgoing(expr)
-      || RelationExpr.isInOut(expr)
+  export const isRelation = (expr: ExpressionV2): expr is RelationExpr.Any => {
+    return RelationExpr.is(expr) || RelationExpr.isWhere(expr) || RelationExpr.isCustom(expr)
   }
 }

package/src/types/index.ts

@@ -1,7 +1,6 @@
 export type {
   CustomColor,
   ExclusiveUnion,
-  IconUrl,
   IteratorLike,
   KeysOf,
   NonEmptyArray,
@@ -9,10 +8,23 @@ export type {
   NTuple,
   Point,
   Predicate,
-  ProjectId,
   XYPoint,
 } from './_common'
 
+export {
+  AsFqn,
+  GlobalFqn,
+  isGlobalFqn,
+  splitGlobalFqn,
+} from './scalars'
+
+export type {
+  Fqn,
+  IconUrl,
+  ProjectId,
+  Tag,
+} from './scalars'
+
 export { DeploymentElement } from './deployments'
 export type {
   DeployedInstance,
@@ -26,7 +38,6 @@ export type {
 } from './deployments'
 
 export {
-  AsFqn,
   BorderStyles,
   DefaultElementShape,
   DefaultPaddingSize,
@@ -43,55 +54,13 @@ export type {
   ElementKindSpecificationStyle,
   ElementShape,
   ElementStyle,
-  Fqn,
   Link,
-  Tag,
   TagSpec,
   TypedElement,
 } from './element'
 
-export {
-  isCustomElement,
-  isCustomRelationExpr,
-  isElement,
-  isElementKindExpr,
-  isElementPredicateExpr,
-  isElementRef,
-  isElementTagExpr,
-  isElementWhere,
-  isExpandedElementExpr,
-  isIncoming,
-  isInOut,
-  isOutgoing,
-  isRelation,
-  isRelationExpression,
-  isRelationPredicateExpr,
-  isRelationWhere,
-  isWildcard,
-} from './expression'
-export type {
-  CustomElementExpr,
-  CustomRelationExpr,
-  DirectRelationExpr,
-  ElementExpression,
-  ElementKindExpr,
-  ElementPredicateExpression,
-  ElementRefExpr,
-  ElementTagExpr,
-  ElementWhereExpr,
-  ExpandedElementExpr,
-  Expression,
-  IncomingExpr,
-  InOutExpr,
-  NonWilcard,
-  OutgoingExpr,
-  RelationExpression,
-  RelationPredicateExpression,
-  RelationWhereExpr,
-  WildcardExpr,
-} from './expression'
-
 export { ExpressionV2, FqnExpr, FqnRef, RelationExpr } from './expression-v2'
+export { ModelLayer } from './expression-v2-model'
 
 export type {
   GlobalDynamicPredicates,

package/src/types/model-data.ts

@@ -1,12 +1,14 @@
+import type { NonEmptyArray } from './_common'
 import type {
   DeploymentElement,
   DeploymentNodeKind,
   DeploymentNodeKindSpecification,
   DeploymentRelation,
 } from './deployments'
-import type { ElementKindSpecification, Tag, TypedElement } from './element'
+import type { Element, ElementKindSpecification, TypedElement } from './element'
 import type { ModelGlobals } from './global'
 import type { ModelRelation, RelationId, RelationshipKindSpecification } from './relation'
+import type { ProjectId, Tag } from './scalars'
 import type { ComputedView, DiagramView, LikeC4View } from './view'
 
 /**
@@ -50,6 +52,7 @@ export interface ParsedLikeC4ModelData<
     elements: Record<DeploymentFqns, DeploymentElement>
     relations: Record<RelationId, DeploymentRelation>
   }
+  imports: Record<ProjectId, NonEmptyArray<Element>>
 }
 
 export type AnyParsedLikeC4ModelData = ParsedLikeC4ModelData<any, any, any, any, any, any>

package/src/types/relation.ts

@@ -1,6 +1,7 @@
 import type { Tagged } from 'type-fest'
 import type { NonEmptyArray } from './_common'
-import type { Fqn, Link, Tag } from './element'
+import type { Link } from './element'
+import type { Fqn, Tag } from './scalars'
 import type { Color, ThemeColor } from './theme'
 import type { ViewId } from './view'
 

package/src/types/scalars.ts

@@ -0,0 +1,39 @@
+import { isTruthy } from 'remeda'
+import type { Tagged } from 'type-fest'
+import { invariant } from '../errors'
+
+export type ProjectId = Tagged<string, 'ProjectID'>
+
+export type IconUrl = Tagged<string, 'IconUrl'> | 'none'
+
+// Full-qualified-name
+export type Fqn<Id extends string = string> = Tagged<Id, 'Fqn'>
+
+export type Tag<Tags extends string = string> = Tagged<Tags, 'Tag'>
+
+export function AsFqn(name: string, parent?: Fqn | null): Fqn {
+  return (parent ? parent + '.' + name : name) as Fqn
+}
+
+export type GlobalFqn<Id extends string = string> = Tagged<Fqn<Id>, 'GlobalFqn'>
+export function GlobalFqn(projectId: ProjectId, name: string): GlobalFqn {
+  invariant(isTruthy(projectId), 'Project ID must start with @')
+  return '@' + projectId + '.' + name as GlobalFqn
+}
+
+export function isGlobalFqn(fqn: string): fqn is GlobalFqn {
+  return fqn.startsWith('@')
+}
+
+export function splitGlobalFqn<Id extends string>(fqn: Fqn<Id> | GlobalFqn<Id>): [ProjectId | null, Fqn<Id>] {
+  if (!fqn.startsWith('@')) {
+    return [null, fqn]
+  }
+  const firstDot = fqn.indexOf('.')
+  if (firstDot < 2) {
+    throw new Error('Invalid global FQN')
+  }
+  const projectId = fqn.slice(1, firstDot) as ProjectId
+  const name = fqn.slice(firstDot + 1) as Fqn<Id>
+  return [projectId, name]
+}

package/src/types/view-changes.ts

@@ -1,5 +1,6 @@
 import type { NonEmptyArray } from './_common'
-import type { BorderStyle, ElementShape, Fqn } from './element'
+import type { BorderStyle, ElementShape } from './element'
+import type { Fqn } from './scalars'
 import type { ThemeColor } from './theme'
 import type { AutoLayoutDirection, ViewManualLayout } from './view'
 

package/src/types/view.ts

@@ -1,19 +1,18 @@
 import { isArray, isNullish } from 'remeda'
 import type { Tagged } from 'type-fest'
-import type { IconUrl, NonEmptyArray, Point, XYPoint } from './_common'
+import type { NonEmptyArray, Point, XYPoint } from './_common'
 import {
   type BorderStyle,
   type ElementShape,
   type ElementStyle,
-  type Fqn,
   type Link,
-  type Tag,
   ElementKind,
 } from './element'
-import type { ElementExpression, ElementPredicateExpression, Expression } from './expression'
 import type { ExpressionV2, FqnExpr } from './expression-v2'
+import type { ModelLayer } from './expression-v2-model'
 import type { GlobalPredicateId, GlobalStyleID } from './global'
 import type { RelationId, RelationshipArrowType, RelationshipKind, RelationshipLineType } from './relation'
+import type { Fqn, IconUrl, Tag } from './scalars'
 import type { Color, ShapeSize, SpacingSize, TextSize, ThemeColorValues } from './theme'
 import type { ElementNotation } from './view-notation'
 
@@ -21,12 +20,12 @@ export type ViewId<Id extends string = string> = Tagged<Id, 'ViewID'>
 
 export type ViewRulePredicate =
   | {
-    include: Expression[]
+    include: ModelLayer.Expression[]
     exclude?: never
   }
   | {
     include?: never
-    exclude: Expression[]
+    exclude: ModelLayer.Expression[]
   }
 
 export function isViewRulePredicate(rule: DeploymentViewRule): rule is DeploymentViewRulePredicate
@@ -47,7 +46,7 @@ export function isViewRuleGlobalPredicateRef(rule: ViewRule): rule is ViewRuleGl
 }
 
 export interface ViewRuleStyle {
-  targets: ElementExpression[]
+  targets: ModelLayer.FqnExpr[]
   notation?: string
   style: ElementStyle & {
     color?: Color
@@ -198,7 +197,7 @@ export interface DynamicViewParallelSteps {
 export type DynamicViewStepOrParallel = DynamicViewStep | DynamicViewParallelSteps
 
 export type DynamicViewIncludeRule = {
-  include: ElementPredicateExpression[]
+  include: ModelLayer.AnyFqnExpr[]
 }
 
 export type DynamicViewRule =