@likec4/core 1.31.0 → 1.32.0

package/src/types/deployments.ts

@@ -1,170 +0,0 @@
-import type { MergeExclusive, Simplify, Tagged } from 'type-fest'
-import type { NonEmptyArray } from './_common'
-import type { ElementShape, ElementStyle, Link } from './element'
-import type { AbstractRelation, RelationId } from './relation'
-import type { Fqn, IconUrl, Tag } from './scalars'
-import type { Color } from './theme'
-
-export type DeploymentNodeKind<Kinds extends string = string> = Tagged<Kinds, 'DeploymentNodeKind'>
-
-export type DeploymentElementStyle = ElementStyle & {
-  readonly icon?: IconUrl
-  readonly shape?: ElementShape
-  readonly color?: Color
-}
-
-export interface DeploymentNodeKindSpecification {
-  readonly technology?: string
-  readonly notation?: string
-  readonly style: DeploymentElementStyle
-}
-
-export interface DeploymentNode {
-  // Full-qualified-name for Deployment model
-  readonly id: Fqn
-  readonly kind: DeploymentNodeKind
-  readonly title: string
-  readonly description?: string | null
-  readonly technology?: string | null
-  readonly tags?: NonEmptyArray<Tag> | null
-  readonly links?: NonEmptyArray<Link> | null
-  readonly style?: DeploymentElementStyle
-  readonly notation?: string
-  readonly metadata?: Record<string, string>
-}
-
-export interface DeployedInstance {
-  /**
-   * Format: `<DeploymentNode Fqn>.<Instance Id>`
-   * i.e parent fqn is deployment target
-   */
-  readonly id: Fqn
-  readonly element: Fqn
-  readonly title?: string
-  readonly description?: string | null
-  readonly technology?: string | null
-  readonly tags?: NonEmptyArray<Tag> | null
-  readonly links?: NonEmptyArray<Link> | null
-  readonly style?: DeploymentElementStyle
-  readonly notation?: string
-  readonly metadata?: Record<string, string>
-}
-
-export type DeploymentElement = Simplify<MergeExclusive<DeploymentNode, DeployedInstance>>
-
-export namespace DeploymentElement {
-  export const isDeploymentNode = (el: DeploymentElement): el is DeploymentNode => {
-    return 'kind' in el && !('element' in el)
-  }
-  export const isInstance = (el: DeploymentElement): el is DeployedInstance => {
-    return 'element' in el && !('kind' in el)
-  }
-}
-
-export type PredicateSelector =
-  | 'children' // ele.*
-  | 'expanded' // ele._
-  | 'descendants' // ele.**
-
-export interface DeploymentRef {
-  // Reference to DeploymentNode or DeployedInstance
-  readonly id: Fqn
-  // Reference to element within DeployedInstance
-  readonly element?: Fqn
-}
-
-/**
- * NOTE:
- */
-export interface DeploymentRelation extends AbstractRelation {
-  readonly id: RelationId
-  readonly source: DeploymentRef
-  readonly target: DeploymentRef
-}
-
-// 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
-//   }
-//   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
-//   }
-// }
-
-// 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?: 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 DeploymentElementExpression = ExclusiveUnion<{
-//   DeploymentRef: DeploymentElementExpression.Ref
-//   Wildcard: DeploymentElementExpression.Wildcard
-// }>
-
-// export type DeploymentExpression = ExclusiveUnion<{
-//   Element: DeploymentElementExpression
-//   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)
-//   }
-// }

package/src/types/element.ts

@@ -1,109 +0,0 @@
-import type { Tagged, TupleToUnion } from 'type-fest'
-import type { NonEmptyArray } from './_common'
-import type { Fqn, IconUrl, Tag } from './scalars'
-import type { Color, ShapeSize, SpacingSize, TextSize, ThemeColor } from './theme'
-
-export const BorderStyles = ['solid', 'dashed', 'dotted', 'none'] as const
-
-export type BorderStyle = TupleToUnion<typeof BorderStyles>
-
-export type ElementKind<Kinds extends string = string> = Tagged<Kinds, 'ElementKind'>
-export namespace ElementKind {
-  export const Group = '@group' as ElementKind
-}
-export const ElementShapes = [
-  'rectangle',
-  'person',
-  'browser',
-  'mobile',
-  'cylinder',
-  'storage',
-  'queue',
-] as const
-
-export type ElementShape = TupleToUnion<typeof ElementShapes>
-export const DefaultThemeColor: ThemeColor = 'primary'
-export const DefaultElementShape: ElementShape = 'rectangle'
-export const DefaultShapeSize: ShapeSize = 'md'
-export const DefaultPaddingSize: SpacingSize = 'md'
-export const DefaultTextSize: TextSize = 'md'
-
-export interface ElementStyle {
-  readonly border?: BorderStyle
-  /**
-   * In percentage 0-100, 0 is fully transparent
-   *
-   * @default 100
-   */
-  readonly opacity?: number
-  /**
-   * If true, the element is rendered as multiple shapes
-   * @default false
-   */
-  readonly multiple?: boolean
-
-  /**
-   * Shape size
-   *
-   * @default 'md'
-   */
-  readonly size?: ShapeSize
-
-  readonly padding?: SpacingSize
-
-  readonly textSize?: TextSize
-}
-
-export interface TagSpec {
-  readonly id: Tag
-  readonly style: ElementStyle
-}
-
-export interface Link {
-  readonly title?: string
-  // Value from Likec4 DSL
-  readonly url: string
-  // Relative to workspace root (if url is relative),
-  readonly relative?: string
-}
-
-export interface TypedElement<
-  Ids extends string,
-  Kinds extends string,
-  Tags extends string,
-  MetadataKeys extends string = never,
-> {
-  readonly id: Fqn<Ids>
-  readonly kind: ElementKind<Kinds>
-  readonly title: string
-  readonly description: string | null
-  readonly technology: string | null
-  readonly tags: NonEmptyArray<Tag<Tags>> | null
-  readonly links: NonEmptyArray<Link> | null
-  readonly icon?: IconUrl
-  readonly shape?: ElementShape
-  readonly color?: Color
-  readonly style?: ElementStyle
-  readonly notation?: string
-  readonly metadata?: Record<MetadataKeys, string>
-}
-
-export interface Element extends TypedElement<string, string, string, string> {
-}
-
-export interface ElementKindSpecificationStyle {
-  shape?: ElementShape
-  icon?: IconUrl
-  color?: Color
-  border?: BorderStyle
-  opacity?: number
-  size?: ShapeSize
-  padding?: SpacingSize
-  textSize?: TextSize
-}
-
-export interface ElementKindSpecification {
-  readonly technology?: string
-  readonly notation?: string
-  readonly style: ElementKindSpecificationStyle
-}

package/src/types/expression-v2-model.ts

@@ -1,314 +0,0 @@
-import type { ExclusiveUnion } from './_common'
-import type { PredicateSelector } from './deployments'
-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 ModelLayer {
-  export namespace FqnRef {
-    /**
-     * Reference to logical model element
-     */
-    export type ModelRef<F = Fqn> = {
-      model: F
-    }
-    export const isModelRef = (ref: FqnRef): ref is ModelRef => {
-      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 toFqn = (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<M = Fqn> = ExclusiveUnion<{
-    ModelRef: FqnRef.ModelRef<M>
-    ImportRef: FqnRef.ImportRef<M>
-  }>
-
-  export namespace FqnExpr {
-    export type Wildcard = {
-      wildcard: true
-    }
-    export const isWildcard = (expr: Expression): expr is FqnExpr.Wildcard => {
-      return 'wildcard' in expr && expr.wildcard === true
-    }
-
-    export type ModelRef<M = Fqn> = {
-      ref: FqnRef.ModelRef<M> | FqnRef.ImportRef<M>
-      selector?: PredicateSelector
-    }
-    export const isModelRef = (ref: Expression): ref is FqnExpr.ModelRef => {
-      return 'ref' in ref
-    }
-
-    export type ElementKindExpr = {
-      elementKind: ElementKind
-      isEqual: boolean
-    }
-    export function isElementKindExpr(expr: Expression): expr is ElementKindExpr {
-      return 'elementKind' in expr && 'isEqual' in expr
-    }
-
-    export type ElementTagExpr = {
-      elementTag: Tag
-      isEqual: boolean
-    }
-    export function isElementTagExpr(expr: Expression): expr is ElementTagExpr {
-      return 'elementTag' in expr && 'isEqual' in expr
-    }
-
-    export type NonWildcard<M = Fqn> = ExclusiveUnion<{
-      ModelRef: ModelRef<M>
-      ElementKind: ElementKindExpr
-      ElementTag: ElementTagExpr
-    }>
-
-    export type Where<M = Fqn> = {
-      where: {
-        expr: ExclusiveUnion<{
-          Wildcard: Wildcard
-          ModelRef: ModelRef<M>
-          ElementKind: ElementKindExpr
-          ElementTag: ElementTagExpr
-        }>
-        condition: WhereOperator<string, string>
-      }
-    }
-
-    export const isWhere = (expr: Expression): expr is FqnExpr.Where => {
-      return 'where' in expr && is(expr.where.expr)
-    }
-
-    export type Custom<M = Fqn> = {
-      custom: {
-        expr: FqnExprOrWhere<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: Expression): expr is FqnExpr.Custom => {
-      return 'custom' in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr))
-    }
-
-    export const is = (expr: Expression): expr is FqnExpr => {
-      return isWildcard(expr)
-        || isModelRef(expr)
-        || isElementKindExpr(expr)
-        || isElementTagExpr(expr)
-    }
-  }
-
-  export type FqnExpr<M = Fqn> = ExclusiveUnion<{
-    Wildcard: FqnExpr.Wildcard
-    ModelRef: FqnExpr.ModelRef<M>
-    ElementKind: FqnExpr.ElementKindExpr
-    ElementTag: FqnExpr.ElementTagExpr
-  }>
-
-  export type FqnExprOrWhere<M = Fqn> = ExclusiveUnion<{
-    Wildcard: FqnExpr.Wildcard
-    ModelRef: FqnExpr.ModelRef<M>
-    ElementKind: FqnExpr.ElementKindExpr
-    ElementTag: FqnExpr.ElementTagExpr
-    Where: FqnExpr.Where<M>
-  }>
-
-  export type AnyFqnExpr<M = Fqn> = ExclusiveUnion<{
-    Wildcard: FqnExpr.Wildcard
-    ModelRef: FqnExpr.ModelRef<M>
-    ElementKind: FqnExpr.ElementKindExpr
-    ElementTag: FqnExpr.ElementTagExpr
-    Where: FqnExpr.Where<M>
-    Custom: FqnExpr.Custom<M>
-  }>
-
-  export function isAnyFqnExpr(expr: Expression): expr is AnyFqnExpr {
-    return FqnExpr.is(expr)
-      || FqnExpr.isWhere(expr)
-      || FqnExpr.isCustom(expr)
-  }
-
-  export namespace RelationExpr {
-    export type Direct<M = Fqn> = {
-      source: FqnExpr<M>
-      target: FqnExpr<M>
-      isBidirectional?: boolean
-    }
-    export const isDirect = (expr: Expression): expr is RelationExpr.Direct => {
-      return 'source' in expr && 'target' in expr
-    }
-    export type Incoming<M = Fqn> = {
-      incoming: FqnExpr<M>
-    }
-    export const isIncoming = (expr: Expression): expr is RelationExpr.Incoming => {
-      return 'incoming' in expr
-    }
-    export type Outgoing<M = Fqn> = {
-      outgoing: FqnExpr<M>
-    }
-    export const isOutgoing = (expr: Expression): expr is RelationExpr.Outgoing => {
-      return 'outgoing' in expr
-    }
-    export type InOut<M = Fqn> = {
-      inout: FqnExpr<M>
-    }
-    export const isInOut = (expr: Expression): expr is RelationExpr.InOut => {
-      return 'inout' in expr
-    }
-    export type Where<M = Fqn> = {
-      where: {
-        expr: ExclusiveUnion<{
-          Direct: RelationExpr.Direct<M>
-          Incoming: RelationExpr.Incoming<M>
-          Outgoing: RelationExpr.Outgoing<M>
-          InOut: RelationExpr.InOut<M>
-        }>
-        condition: WhereOperator<string, string>
-      }
-    }
-    export const isWhere = (expr: Expression): expr is RelationExpr.Where => {
-      return 'where' in expr && is(expr.where.expr)
-    }
-
-    export type Custom<M = Fqn> = {
-      customRelation: {
-        expr: RelationExprOrWhere<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: Expression): expr is Custom => {
-      return 'customRelation' in expr
-    }
-
-    export const is = (expr: Expression): expr is RelationExpr => {
-      return isDirect(expr)
-        || isIncoming(expr)
-        || isOutgoing(expr)
-        || isInOut(expr)
-    }
-  }
-
-  export type RelationExpr<M = Fqn> = ExclusiveUnion<{
-    Direct: RelationExpr.Direct<M>
-    Incoming: RelationExpr.Incoming<M>
-    Outgoing: RelationExpr.Outgoing<M>
-    InOut: RelationExpr.InOut<M>
-  }>
-
-  export type RelationExprOrWhere<M = Fqn> = ExclusiveUnion<{
-    Direct: RelationExpr.Direct<M>
-    Incoming: RelationExpr.Incoming<M>
-    Outgoing: RelationExpr.Outgoing<M>
-    InOut: RelationExpr.InOut<M>
-    Where: RelationExpr.Where<M>
-  }>
-
-  export type AnyRelationExpr<M = Fqn> = ExclusiveUnion<{
-    Direct: RelationExpr.Direct<M>
-    Incoming: RelationExpr.Incoming<M>
-    Outgoing: RelationExpr.Outgoing<M>
-    InOut: RelationExpr.InOut<M>
-    Where: RelationExpr.Where<M>
-    CustomRelation: RelationExpr.Custom<M>
-  }>
-
-  export function isAnyRelationExpr(expr: Expression): expr is AnyRelationExpr {
-    return RelationExpr.is(expr)
-      || RelationExpr.isWhere(expr)
-      || RelationExpr.isCustom(expr)
-  }
-
-  /**
-   * Represents a version 2 expression which can be one of several types.
-   *
-   * @template M - The type for the model FQN, defaults to `Fqn`.
-   */
-  export type Expression<M = Fqn> = ExclusiveUnion<{
-    Wildcard: FqnExpr.Wildcard
-    ModelRef: FqnExpr.ModelRef<M>
-    ElementKind: FqnExpr.ElementKindExpr
-    ElementTag: FqnExpr.ElementTagExpr
-    Custom: FqnExpr.Custom<M>
-    Direct: RelationExpr.Direct<M>
-    Incoming: RelationExpr.Incoming<M>
-    Outgoing: RelationExpr.Outgoing<M>
-    InOut: RelationExpr.InOut<M>
-    CustomRelation: RelationExpr.Custom<M>
-    Where: Expression.Where<M>
-  }>
-
-  export function isExpression(expr: any): expr is Expression {
-    return isAnyFqnExpr(expr)
-      || isAnyRelationExpr(expr)
-  }
-
-  export namespace Expression {
-    export type Where<M = Fqn> = FqnExpr.Where<M> | RelationExpr.Where<M>
-
-    export const isWhere = (expr: Expression): expr is Expression.Where => {
-      return 'where' in expr
-    }
-
-    export const isCustomFqnExpr = (expr: Expression): expr is FqnExpr.Custom => {
-      return FqnExpr.isCustom(expr)
-    }
-
-    export const isCustomRelationExpr = (expr: Expression): expr is RelationExpr.Custom => {
-      return RelationExpr.isCustom(expr)
-    }
-
-    export const isFqnExpr = (expr: Expression): expr is FqnExpr => {
-      return FqnExpr.is(expr)
-    }
-
-    export const isRelation = (expr: Expression): expr is RelationExpr => {
-      return RelationExpr.is(expr)
-    }
-  }
-}