@likec4/core 1.18.0 → 1.19.0

package/src/types/deployments.ts

@@ -1,13 +1,12 @@
-import type { MergeExclusive, Simplify, Tagged, UnionToIntersection } from 'type-fest'
+import type { MergeExclusive, Simplify, Tagged } from 'type-fest'
 import type { IconUrl, NonEmptyArray } from './_common'
 import type { ElementShape, ElementStyle, Fqn, Link, Tag } from './element'
-import type { RelationId, RelationshipArrowType, RelationshipKind, RelationshipLineType } from './relation'
+import type { AbstractRelation, RelationId } from './relation'
 import type { Color } from './theme'
-import type { ViewId } from './view'
 
 export type DeploymentNodeKind<Kinds extends string = string> = Tagged<Kinds, 'DeploymentNodeKind'>
 
-export type PhysicalElementStyle = ElementStyle & {
+export type DeploymentElementStyle = ElementStyle & {
   readonly icon?: IconUrl
   readonly shape?: ElementShape
   readonly color?: Color
@@ -16,7 +15,7 @@ export type PhysicalElementStyle = ElementStyle & {
 export interface DeploymentNodeKindSpecification {
   readonly technology?: string
   readonly notation?: string
-  readonly style: PhysicalElementStyle
+  readonly style: DeploymentElementStyle
 }
 
 export interface DeploymentNode {
@@ -28,7 +27,7 @@ export interface DeploymentNode {
   readonly technology?: string | null
   readonly tags?: NonEmptyArray<Tag> | null
   readonly links?: NonEmptyArray<Link> | null
-  readonly style?: PhysicalElementStyle
+  readonly style?: DeploymentElementStyle
   readonly notation?: string
   readonly metadata?: Record<string, string>
 }
@@ -45,7 +44,7 @@ export interface DeployedInstance {
   readonly technology?: string | null
   readonly tags?: NonEmptyArray<Tag> | null
   readonly links?: NonEmptyArray<Link> | null
-  readonly style?: PhysicalElementStyle
+  readonly style?: DeploymentElementStyle
   readonly notation?: string
   readonly metadata?: Record<string, string>
 }
@@ -61,6 +60,11 @@ export namespace DeploymentElement {
   }
 }
 
+export type PredicateSelector =
+  | 'children' // ele.*
+  | 'expanded' // ele._
+  | 'descendants' // ele.**
+
 export interface DeploymentRef {
   // Reference to DeploymentNode or DeployedInstance
   readonly id: Fqn
@@ -68,170 +72,98 @@ export interface DeploymentRef {
   readonly element?: Fqn
 }
 
-// export namespace DeploymentRef {
-//   export interface Node {
-//     readonly id: Fqn
-//   }
-//   export interface Instance {
-//     readonly id: Fqn
-//     readonly element?: Fqn
-//   }
-//   export interface LogicalElement {
-//     readonly element: Fqn
-//   }
-
-//   export const isDeploymentElement = (ref: DeploymentRef): ref is Node | Instance => {
-//     return 'id' in ref
-//   }
-
-//   export const isLogicalElement = (ref: DeploymentRef): ref is LogicalElement => {
-//     return 'element' in ref && !('id' in ref)
-//   }
-// }
-// export type DeploymentRef = ExclusiveUnion<{
-//   Node: DeploymentRef.Node
-//   Instance: DeploymentRef.Instance
-//   Element: DeploymentRef.LogicalElement
-// }>
-
 /**
  * NOTE:
  */
-export interface DeploymentRelation {
+export interface DeploymentRelation extends AbstractRelation {
   readonly id: RelationId
   readonly source: DeploymentRef
   readonly target: DeploymentRef
-  readonly title?: string
-  readonly tags?: NonEmptyArray<Tag> | null
-  readonly description?: string
-  readonly technology?: string
-  readonly kind?: RelationshipKind
-  readonly color?: Color
-  readonly line?: RelationshipLineType
-  readonly head?: RelationshipArrowType
-  readonly tail?: RelationshipArrowType
-  readonly links?: NonEmptyArray<Link> | null
-  // Link to dynamic view
-  readonly navigateTo?: ViewId
-  readonly metadata?: { [key: string]: string }
 }
-// export interface DeploymentRelation
 
-// interface Expressions {
-//   DeploymentRef: {
-//     ref: DeploymentRef
-//     isExpanded?: boolean
-//     isNested?: never
-//   } | {
-//     ref: DeploymentRef
-//     isExpanded?: never
-//     isNested?: boolean
+// export namespace DeploymentRelationExpression {
+//   // type LogicalRefEndpoint = {
+//   //   logicalRef: ElementRefExpr
+//   // }
+//   // export type DirectEndpoint = ExclusiveUnion<{
+//   //   DeploymentElementExpression: DeploymentElementExpression
+//   //   Logical: LogicalRefEndpoint
+//   // }>
+
+//   // export const isLogicalEndpoint = (expr: DirectEndpoint): expr is LogicalRefEndpoint => {
+//   //   return 'logicalRef' in expr
+//   // }
+
+//   export type Direct = {
+//     source: FqnExpression.Element
+//     target: FqnExpression.Element
+//     isBidirectional?: boolean
 //   }
-
-//   Wildcard: {
-//     wildcard: true
+//   export const isDirect = (expr: DeploymentExpression): expr is Direct => {
+//     return 'source' in expr && 'target' in expr
+//   }
+//   export type Incoming = {
+//     incoming: FqnExpression.Element
+//   }
+//   export const isIncoming = (expr: DeploymentExpression): expr is Incoming => {
+//     return 'incoming' in expr
+//   }
+//   export type Outgoing = {
+//     outgoing: FqnExpression.Element
+//   }
+//   export const isOutgoing = (expr: DeploymentExpression): expr is Outgoing => {
+//     return 'outgoing' in expr
+//   }
+//   export type InOut = {
+//     inout: FqnExpression.Element
+//   }
+//   export const isInOut = (expr: DeploymentExpression): expr is InOut => {
+//     return 'inout' in expr
 //   }
 // }
 
-type AllNever<Expressions> = UnionToIntersection<
-  {
-    [Name in keyof Expressions]: {
-      -readonly [Key in keyof Expressions[Name]]?: never
-    }
-  }[keyof Expressions]
->
-
-type ExclusiveUnion<Expressions> = Expressions extends object ? {
-    [Name in keyof Expressions]: Simplify<Omit<AllNever<Expressions>, keyof Expressions[Name]> & Expressions[Name]>
-  }[keyof Expressions]
-  : Expressions
-
-export namespace DeploymentRelationExpression {
-  // type LogicalRefEndpoint = {
-  //   logicalRef: ElementRefExpr
-  // }
-  // export type DirectEndpoint = ExclusiveUnion<{
-  //   DeploymentElementExpression: DeploymentElementExpression
-  //   Logical: LogicalRefEndpoint
-  // }>
-
-  // export const isLogicalEndpoint = (expr: DirectEndpoint): expr is LogicalRefEndpoint => {
-  //   return 'logicalRef' in expr
-  // }
-
-  export type Direct = {
-    source: DeploymentElementExpression
-    target: DeploymentElementExpression
-    isBidirectional?: boolean
-  }
-  export const isDirect = (expr: DeploymentExpression): expr is Direct => {
-    return 'source' in expr && 'target' in expr
-  }
-  export type Incoming = {
-    incoming: DeploymentElementExpression
-  }
-  export const isIncoming = (expr: DeploymentExpression): expr is Incoming => {
-    return 'incoming' in expr
-  }
-  export type Outgoing = {
-    outgoing: DeploymentElementExpression
-  }
-  export const isOutgoing = (expr: DeploymentExpression): expr is Outgoing => {
-    return 'outgoing' in expr
-  }
-  export type InOut = {
-    inout: DeploymentElementExpression
-  }
-  export const isInOut = (expr: DeploymentExpression): expr is InOut => {
-    return 'inout' in expr
-  }
-}
+// export type DeploymentRelationExpression = ExclusiveUnion<{
+//   Direct: DeploymentRelationExpression.Direct
+//   Incoming: DeploymentRelationExpression.Incoming
+//   Outgoing: DeploymentRelationExpression.Outgoing
+//   InOut: DeploymentRelationExpression.InOut
+// }>
 
-export type DeploymentRelationExpression = ExclusiveUnion<{
-  Direct: DeploymentRelationExpression.Direct
-  Incoming: DeploymentRelationExpression.Incoming
-  Outgoing: DeploymentRelationExpression.Outgoing
-  InOut: DeploymentRelationExpression.InOut
-}>
-
-export namespace DeploymentElementExpression {
-  export type Ref = {
-    ref: DeploymentRef
-    selector?:
-      | 'children' // ele.*
-      | 'expanded' // ele._
-      | 'descendants' // ele.**
-  }
-  export const isRef = (expr: DeploymentExpression): expr is Ref => {
-    return 'ref' in expr
-  }
+// export namespace DeploymentElementExpression {
+//   export type Ref = {
+//     ref: DeploymentRef
+//     selector?: PredicateSelector
+//   }
+//   export const isRef = (expr: DeploymentExpression): expr is Ref => {
+//     return 'ref' in expr
+//   }
 
-  export type Wildcard = {
-    wildcard: true
-  }
-  export const isWildcard = (expr: DeploymentExpression): expr is Wildcard => {
-    return 'wildcard' in expr && expr.wildcard === true
-  }
-}
+//   export type Wildcard = {
+//     wildcard: true
+//   }
+//   export const isWildcard = (expr: DeploymentExpression): expr is Wildcard => {
+//     return 'wildcard' in expr && expr.wildcard === true
+//   }
+// }
 
-export type DeploymentElementExpression = ExclusiveUnion<{
-  DeploymentRef: DeploymentElementExpression.Ref
-  Wildcard: DeploymentElementExpression.Wildcard
-}>
+// export type DeploymentElementExpression = ExclusiveUnion<{
+//   DeploymentRef: DeploymentElementExpression.Ref
+//   Wildcard: DeploymentElementExpression.Wildcard
+// }>
 
-export type DeploymentExpression = ExclusiveUnion<{
-  Element: DeploymentElementExpression
-  Relation: DeploymentRelationExpression
-}>
+// export type DeploymentExpression = ExclusiveUnion<{
+//   Element: DeploymentElementExpression
+//   Relation: DeploymentRelationExpression
+// }>
 
-export namespace DeploymentExpression {
-  export type Element = DeploymentElementExpression
-  export type Relation = DeploymentRelationExpression
+// export namespace DeploymentExpression {
+//   export type Element = DeploymentElementExpression
+//   export type Relation = DeploymentRelationExpression
 
-  export const isElement = (expr: DeploymentExpression): expr is DeploymentElementExpression => {
-    return DeploymentElementExpression.isRef(expr) || DeploymentElementExpression.isWildcard(expr)
-  }
-  export const isRelation = (expr: DeploymentExpression): expr is DeploymentRelationExpression => {
-    return !DeploymentExpression.isElement(expr)
-  }
-}
+//   export const isElement = (expr: DeploymentExpression): expr is DeploymentElementExpression => {
+//     return DeploymentElementExpression.isRef(expr) || DeploymentElementExpression.isWildcard(expr)
+//   }
+//   export const isRelation = (expr: DeploymentExpression): expr is DeploymentRelationExpression => {
+//     return !DeploymentExpression.isElement(expr)
+//   }
+// }

package/src/types/element.ts

@@ -28,8 +28,8 @@ export const ElementShapes = [
 ] as const
 
 export type ElementShape = TupleToUnion<typeof ElementShapes>
-export const DefaultThemeColor = 'primary' satisfies ThemeColor
-export const DefaultElementShape = 'rectangle' satisfies ElementShape
+export const DefaultThemeColor: ThemeColor = 'primary'
+export const DefaultElementShape: ElementShape = 'rectangle'
 
 export interface ElementStyle {
   readonly border?: BorderStyle

package/src/types/expression-v2.ts

@@ -0,0 +1,172 @@
+import { invariant } from '../errors'
+import type { ExclusiveUnion } from './_common'
+import type { DeploymentRef as DeploymentModelRef, PredicateSelector } from './deployments'
+import type { Fqn } from './element'
+
+export namespace FqnRef {
+  /**
+   * Represents a reference to an instance within a deployment.
+   *
+   * @template D - The type representing the deployment fqn. Defaults to `Fqn`.
+   * @template M - The type representing the model fqn. Defaults to `Fqn`.
+   *
+   * @property {D} deployment - TThe fully qualified name (FQN) of the deployed instance.
+   * @property {M} element - The element reference within the deployment.
+   */
+  export type InsideInstanceRef<D = Fqn, M = Fqn> = {
+    deployment: D
+    element: M
+  }
+  export const isInsideInstanceRef = (ref: FqnRef): ref is InsideInstanceRef => {
+    return 'deployment' in ref && 'element' in ref
+  }
+
+  /**
+   * Represents a reference to a deployment element.
+   *
+   * @template F - The type of the fully qualified name (FQN) of the deployment element. Defaults to `Fqn`.
+   * @property {F} deployment - The fully qualified name (FQN) of the deployment element.
+   */
+  export type DeploymentElementRef<F = Fqn> = {
+    deployment: F
+  }
+  export const isDeploymentElementRef = (ref: FqnRef): ref is DeploymentElementRef => {
+    return 'deployment' in ref && !('element' in ref)
+  }
+
+  export type DeploymentRef<D = Fqn, M = Fqn> = DeploymentElementRef<D> | InsideInstanceRef<D, M>
+  export const isDeploymentRef = (ref: FqnRef): ref is DeploymentRef => {
+    return !isModelRef(ref)
+  }
+
+  /**
+   * Reference to logical model element
+   */
+  export type ModelRef<F = Fqn> = {
+    model: F
+  }
+  export const isModelRef = (ref: FqnRef): ref is ModelRef => {
+    return 'model' in ref
+  }
+
+  export const toDeploymentRef = (ref: FqnRef): DeploymentModelRef => {
+    invariant(isDeploymentRef(ref), 'Expected DeploymentRef')
+    return isInsideInstanceRef(ref)
+      ? {
+        id: ref.deployment,
+        element: ref.element,
+      }
+      : {
+        id: ref.deployment,
+      }
+  }
+}
+
+export type FqnRef<D = Fqn, M = Fqn> = ExclusiveUnion<{
+  InsideInstanceRef: FqnRef.InsideInstanceRef<D, M>
+  DeploymentRef: FqnRef.DeploymentRef<D>
+  ModelRef: FqnRef.ModelRef<M>
+}>
+
+export namespace FqnExpr {
+  export type Wildcard = {
+    wildcard: true
+  }
+  export const isWildcard = (expr: ExpressionV2): expr is Wildcard => {
+    return 'wildcard' in expr && expr.wildcard === true
+  }
+
+  export type ModelRef<M = Fqn> = {
+    ref: FqnRef.ModelRef<M>
+    selector?: PredicateSelector
+  }
+  export const isModelRef = (ref: ExpressionV2): ref is ModelRef => {
+    return 'ref' in ref && FqnRef.isModelRef(ref.ref)
+  }
+
+  export type DeploymentRef<D = Fqn, M = Fqn> = {
+    ref: FqnRef.DeploymentRef<D> | FqnRef.InsideInstanceRef<D, M>
+    selector?: PredicateSelector
+  }
+  export const isDeploymentRef = (ref: ExpressionV2): ref is FqnExpr.DeploymentRef => {
+    return 'ref' in ref && FqnRef.isDeploymentRef(ref.ref)
+  }
+
+  export type NonWildcard<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    ModelRef: ModelRef<M>
+    DeploymentRef: DeploymentRef<D, M>
+  }>
+}
+
+export type FqnExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
+  Wildcard: FqnExpr.Wildcard
+  ModelRef: FqnExpr.ModelRef<M>
+  DeploymentRef: FqnExpr.DeploymentRef<D, M>
+}>
+
+export namespace RelationExpr {
+  export type Direct<D = Fqn, M = Fqn> = {
+    source: FqnExpr<D, M>
+    target: FqnExpr<D, M>
+    isBidirectional?: boolean
+  }
+  export const isDirect = (expr: ExpressionV2): expr is Direct => {
+    return 'source' in expr && 'target' in expr
+  }
+  export type Incoming<D = Fqn, M = Fqn> = {
+    incoming: FqnExpr<D, M>
+  }
+  export const isIncoming = (expr: ExpressionV2): expr is Incoming => {
+    return 'incoming' in expr
+  }
+  export type Outgoing<D = Fqn, M = Fqn> = {
+    outgoing: FqnExpr<D, M>
+  }
+  export const isOutgoing = (expr: ExpressionV2): expr is Outgoing => {
+    return 'outgoing' in expr
+  }
+  export type InOut<D = Fqn, M = Fqn> = {
+    inout: FqnExpr<D, M>
+  }
+  export const isInOut = (expr: ExpressionV2): expr is InOut => {
+    return 'inout' in expr
+  }
+}
+
+export type RelationExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
+  Direct: RelationExpr.Direct<D, M>
+  Incoming: RelationExpr.Incoming<D, M>
+  Outgoing: RelationExpr.Outgoing<D, M>
+  InOut: RelationExpr.InOut<D, M>
+}>
+
+/**
+ * Represents a version 2 expression which can be one of several types.
+ *
+ * @template D - The type for the deployment FQN, defaults to `Fqn`.
+ * @template M - The type for the model FQN, defaults to `Fqn`.
+ */
+export type ExpressionV2<D = Fqn, M = Fqn> = ExclusiveUnion<{
+  Wildcard: FqnExpr.Wildcard
+  ModelRef: FqnExpr.ModelRef<M>
+  DeploymentRef: FqnExpr.DeploymentRef<D, M>
+  Direct: RelationExpr.Direct<D, M>
+  Incoming: RelationExpr.Incoming<D, M>
+  Outgoing: RelationExpr.Outgoing<D, M>
+  InOut: RelationExpr.InOut<D, M>
+}>
+
+export namespace ExpressionV2 {
+  export const isFqnExpr = (expr: ExpressionV2): expr is FqnExpr => {
+    return FqnExpr.isWildcard(expr)
+      || FqnExpr.isModelRef(expr)
+      || FqnExpr.isDeploymentRef(expr)
+  }
+
+  export const isRelation = (expr: ExpressionV2): expr is RelationExpr => {
+    return RelationExpr.isDirect(expr)
+      || RelationExpr.isIncoming(expr)
+      || RelationExpr.isOutgoing(expr)
+      || RelationExpr.isInOut(expr)
+  }
+}

package/src/types/expression.ts

@@ -82,12 +82,16 @@ export function isElementTagExpr(expr: Expression): expr is ElementTagExpr {
   return 'elementTag' in expr && 'isEqual' in expr
 }
 
-export type ElementExpression =
+export type NonWilcard =
   | ElementRefExpr
-  | WildcardExpr
   | ElementKindExpr
   | ElementTagExpr
   | ExpandedElementExpr
+
+export type ElementExpression =
+  | NonWilcard
+  | WildcardExpr
+
 export function isElement(expr: Expression): expr is ElementExpression {
   return isElementRef(expr)
     || isWildcard(expr)
@@ -111,12 +115,12 @@ export function isElementPredicateExpr(expr: Expression): expr is ElementPredica
   return isElement(expr) || isElementWhere(expr) || isCustomElement(expr)
 }
 
-export interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
+export interface DirectRelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
   source: ElementExpression
   target: ElementExpression
   isBidirectional?: boolean
 }
-export function isRelation(expr: Expression): expr is RelationExpr {
+export function isRelation(expr: Expression): expr is DirectRelationExpr {
   return 'source' in expr && 'target' in expr
 }
 
@@ -140,7 +144,7 @@ export function isOutgoing(expr: Expression): expr is OutgoingExpr {
   return 'outgoing' in expr
 }
 
-export type RelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr
+export type RelationExpression = DirectRelationExpr | InOutExpr | IncomingExpr | OutgoingExpr
 
 export function isRelationExpression(expr: Expression): expr is RelationExpression {
   return isRelation(expr) || isInOut(expr) || isIncoming(expr) || isOutgoing(expr)

package/src/types/global.ts

@@ -13,7 +13,7 @@ export type GlobalStyleID = Tagged<string, 'GlobalStyleID'>
 export type GlobalStyles = NonEmptyTuple<ViewRuleStyle>
 
 export interface ModelGlobals {
-  predicates: Record<GlobalPredicateId, GlobalPredicates>
-  dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates>
-  styles: Record<GlobalStyleID, GlobalStyles>
+  readonly predicates: Record<GlobalPredicateId, GlobalPredicates>
+  readonly dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates>
+  readonly styles: Record<GlobalStyleID, GlobalStyles>
 }