@likec4/core 1.30.0 → 1.32.0

package/src/types/view-changes.ts

@@ -1,8 +1,7 @@
 import type { NonEmptyArray } from './_common'
-import type { BorderStyle, ElementShape } from './element'
-import type { Fqn } from './scalars'
-import type { ThemeColor } from './theme'
-import type { AutoLayoutDirection, ViewManualLayout } from './view'
+import type * as scalar from './scalar'
+import type { BorderStyle, ElementShape, ThemeColor } from './styles'
+import type { AutoLayoutDirection, ViewManualLayout } from './view-common'
 
 export namespace ViewChange {
   export interface ChangeElementStyle {
@@ -13,7 +12,7 @@ export namespace ViewChange {
       shape?: ElementShape
       color?: ThemeColor
     }
-    targets: NonEmptyArray<Fqn>
+    targets: NonEmptyArray<scalar.Fqn | scalar.DeploymentFqn>
   }
 
   export interface SaveManualLayout {

package/src/types/view-common.ts

@@ -0,0 +1,157 @@
+import type { NonEmptyArray } from './_common'
+import type * as aux from './aux'
+import type { AnyAux } from './aux'
+import type { _stage } from './const'
+
+import type { BBox, Point, XYPoint } from './geometry'
+import type { GlobalPredicateId, GlobalStyleID } from './global'
+import * as scalar from './scalar'
+import type {
+  BorderStyle,
+  Color,
+  ElementShape,
+  ShapeSize,
+  SpacingSize,
+  TextSize,
+} from './styles'
+
+export interface AnyIncludePredicate<Expr> {
+  include: Expr[]
+  exclude?: never
+}
+export interface AnyExcludePredicate<Expr> {
+  include?: never
+  exclude: Expr[]
+}
+
+export interface AnyViewRuleStyle<Expr> {
+  targets: Expr[]
+  notation?: string
+  style: {
+    border?: BorderStyle
+    opacity?: number
+    multiple?: boolean
+    size?: ShapeSize
+    padding?: SpacingSize
+    textSize?: TextSize
+    color?: Color
+    shape?: ElementShape
+    icon?: scalar.Icon
+  }
+}
+
+export interface ViewRuleGlobalStyle {
+  styleId: GlobalStyleID
+}
+export function isViewRuleGlobalStyle(rule: object): rule is ViewRuleGlobalStyle {
+  return 'styleId' in rule
+}
+
+export interface ViewRuleGlobalPredicateRef {
+  predicateId: GlobalPredicateId
+}
+export function isViewRuleGlobalPredicateRef(rule: object): rule is ViewRuleGlobalPredicateRef {
+  return 'predicateId' in rule
+}
+
+export type AutoLayoutDirection = 'TB' | 'BT' | 'LR' | 'RL'
+export function isAutoLayoutDirection(autoLayout: unknown): autoLayout is AutoLayoutDirection {
+  return autoLayout === 'TB' || autoLayout === 'BT' || autoLayout === 'LR' || autoLayout === 'RL'
+}
+
+export interface ViewRuleAutoLayout {
+  direction: AutoLayoutDirection
+  nodeSep?: number
+  rankSep?: number
+}
+
+export function isViewRuleAutoLayout(rule: object): rule is ViewRuleAutoLayout {
+  return 'direction' in rule
+}
+
+export interface ViewAutoLayout {
+  direction: ViewRuleAutoLayout['direction']
+  rankSep?: number
+  nodeSep?: number
+}
+
+export type ViewManualLayout = {
+  // Object hash of previous layout
+  readonly hash: string
+  readonly x: number
+  readonly y: number
+  readonly width: number
+  readonly height: number
+  readonly autoLayout: ViewAutoLayout
+  readonly nodes: Record<string, {
+    isCompound: boolean
+    x: number
+    y: number
+    width: number
+    height: number
+  }>
+  readonly edges: Record<string, {
+    // Graphviz edge POS
+    dotpos?: string
+    // Bezier points
+    points: NonEmptyArray<Point>
+    // Control points to adjust the edge
+    controlPoints?: NonEmptyArray<XYPoint>
+    labelBBox?: BBox
+  }>
+}
+
+export type ViewType = 'element' | 'dynamic' | 'deployment'
+
+export interface BaseViewProperties<A extends AnyAux> extends aux.WithOptionalTags<A>, aux.WithOptionalLinks {
+  readonly id: aux.StrictViewId<A>
+  readonly title: string | null
+  readonly description: string | null
+  /**
+   * For all views we find common ancestor path.
+   * This is used to generate relative paths, i.e.:
+   * - "/home/project/index.c4" becomes "index.c4"
+   * - "/home/project/subdir/views.c4" becomes "subdir/views.c4"
+   *
+   * Undefined if the view is auto-generated.
+   */
+  readonly relativePath?: string | undefined
+}
+
+export interface BaseParsedViewProperties<A extends AnyAux> extends BaseViewProperties<A> {
+  /**
+   * Internal field to identify the stage of the view.
+   * This is used to create the correct type of the view.
+   */
+  readonly [_stage]: 'parsed'
+  /**
+   * URI to the source file of this view.
+   * Undefined if the view is auto-generated.
+   */
+  readonly docUri?: string | undefined
+
+  /**
+   * If the view is changed manually this field contains the layout data.
+   */
+  readonly manualLayout?: ViewManualLayout | undefined
+}
+
+export type NodeNotation = {
+  kinds: string[]
+  shape: ElementShape
+  color: Color
+  title: string
+}
+
+export interface ViewWithNotation {
+  notation?: {
+    nodes: NodeNotation[]
+  }
+}
+export interface ViewWithHash {
+  /**
+   * Hash of the view object.
+   * This is used to detect changes in layout
+   */
+  hash: string
+}

package/src/types/view-computed.ts

@@ -0,0 +1,113 @@
+import type * as aux from './aux'
+import type { Any } from './aux'
+import type { _stage, _type } from './const'
+import type { ElementStyle } from './model-logical'
+import type * as scalar from './scalar'
+import {
+  type Icon,
+} from './scalar'
+import type {
+  Color,
+  ElementShape,
+  RelationshipArrowType,
+  RelationshipLineType,
+} from './styles'
+import type {
+  BaseViewProperties,
+  ViewAutoLayout,
+  ViewManualLayout,
+  ViewWithHash,
+  ViewWithNotation,
+} from './view-common'
+
+export interface ComputedNode<A extends Any = Any> extends aux.WithOptionalLinks {
+  id: scalar.NodeId
+  kind: aux.ElementKind<A> | aux.DeploymentKind<A> | '@group'
+  parent: scalar.NodeId | null
+  /**
+   * Reference to model element
+   * If 1 - node id is a reference
+   */
+  modelRef?: aux.Fqn<A> | undefined
+  /**
+   * Reference to deployment element
+   * If 1 - node id is a reference
+   */
+  deploymentRef?: aux.DeploymentFqn<A> | undefined
+  title: string
+  description?: string | null
+  technology?: string | null
+  notation?: string
+  children: scalar.NodeId[]
+  inEdges: scalar.EdgeId[]
+  outEdges: scalar.EdgeId[]
+  tags: aux.Tags<A>
+  shape: ElementShape
+  color: Color
+  icon?: Icon
+  style: ElementStyle
+  navigateTo?: aux.StrictViewId<A> | null
+  level: number
+  // For compound nodes, the max depth of nested nodes
+  depth?: number
+  /**
+   * If this node was customized in the view
+   */
+  isCustomized?: boolean
+}
+
+export interface ComputedEdge<A extends Any = Any> extends aux.WithOptionalTags<A> {
+  id: scalar.EdgeId
+  parent: scalar.NodeId | null
+  source: scalar.NodeId
+  target: scalar.NodeId
+  label: string | null
+  description?: string
+  technology?: string
+  relations: scalar.RelationId[]
+  kind?: aux.RelationKind<A> | typeof scalar.StepEdgeKind
+  notation?: string
+  // Notes for walkthrough
+  notes?: string
+  color?: Color
+  line?: RelationshipLineType
+  head?: RelationshipArrowType
+  tail?: RelationshipArrowType
+  // Link to dynamic view
+  navigateTo?: aux.StrictViewId<A> | null
+  /**
+   * If this edge is derived from custom relationship predicate
+   */
+  isCustomized?: boolean
+  /**
+   * For layouting purposes
+   * @default 'forward'
+   */
+  dir?: 'forward' | 'back' | 'both'
+}
+
+interface BaseComputedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+  readonly [_stage]: 'computed'
+  readonly autoLayout: ViewAutoLayout
+  readonly nodes: ComputedNode<A>[]
+  readonly edges: ComputedEdge<A>[]
+
+  /**
+   * If the view is changed manually this field contains the layout data.
+   */
+  readonly manualLayout?: ViewManualLayout | undefined
+}
+
+export interface ComputedElementView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'element'
+  readonly viewOf?: aux.StrictFqn<A>
+  readonly extends?: aux.StrictViewId<A>
+}
+
+export interface ComputedDeploymentView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'deployment'
+}
+
+export interface ComputedDynamicView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'dynamic'
+}

package/src/types/view-layouted.ts

@@ -0,0 +1,82 @@
+import type { NonEmptyArray } from './_common'
+import type * as aux from './aux'
+import type { AnyAux } from './aux'
+import type { _stage, _type } from './const'
+import type { BBox, Point, XYPoint } from './geometry'
+import type {
+  BaseViewProperties,
+  ViewAutoLayout,
+  ViewWithHash,
+  ViewWithNotation,
+} from './view-common'
+import type { ComputedEdge, ComputedNode } from './view-computed'
+
+export interface DiagramNode<A extends AnyAux = AnyAux> extends ComputedNode<A>, BBox {
+  x: number
+  y: number
+  width: number
+  height: number
+  /**
+   * Absolute position, top left
+   * @deprecated Use `x` and `y` instead
+   */
+  position: Point
+  /**
+   * Bounding box of label
+   * (Absolute coordinates)
+   */
+  labelBBox: BBox
+}
+
+export interface DiagramEdge<A extends AnyAux = AnyAux> extends ComputedEdge<A> {
+  /**
+   * Bezier points
+   * (Absolute coordinates)
+   */
+  points: NonEmptyArray<Point>
+  /**
+   * Control points to adjust the edge
+   * (Absolute coordinates)
+   */
+  controlPoints?: NonEmptyArray<XYPoint>
+  /**
+   * Bounding box of label
+   * (Absolute coordinates)
+   */
+  labelBBox?: BBox | null
+  /**
+   * Graphviz edge POS
+   *
+   * TODO: temporary solution, should be moved out
+   * @deprecated
+   */
+  dotpos?: string
+}
+
+interface BaseLayoutedViewProperties<A extends AnyAux> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+  readonly [_stage]: 'layouted'
+  readonly autoLayout: ViewAutoLayout
+  readonly nodes: DiagramNode<A>[]
+  readonly edges: DiagramEdge<A>[]
+  readonly bounds: BBox
+
+  /**
+   * If diagram has manual layout
+   * But was changed and layout should be recalculated
+   */
+  hasLayoutDrift?: boolean
+}
+
+export interface LayoutedElementView<A extends AnyAux = AnyAux> extends BaseLayoutedViewProperties<A> {
+  readonly [_type]: 'element'
+  readonly viewOf?: aux.Fqn<A>
+  readonly extends?: aux.StrictViewId<A>
+}
+
+export interface LayoutedDeploymentView<A extends AnyAux = AnyAux> extends BaseLayoutedViewProperties<A> {
+  readonly [_type]: 'deployment'
+}
+
+export interface LayoutedDynamicView<A extends AnyAux = AnyAux> extends BaseLayoutedViewProperties<A> {
+  readonly [_type]: 'dynamic'
+}

package/src/types/view-parsed.deployment.ts

@@ -0,0 +1,40 @@
+import type { MergeExclusive, Simplify } from 'type-fest'
+import type { ExclusiveUnion } from './_common'
+import type { AnyAux, Unknown } from './aux'
+import type { _type } from './const'
+import type { Expression, FqnExpr } from './expression'
+import type {
+  AnyExcludePredicate,
+  AnyIncludePredicate,
+  AnyViewRuleStyle,
+  BaseParsedViewProperties,
+  ViewRuleAutoLayout,
+} from './view-common'
+
+/**
+ * Predicates scoped to deployment model
+ */
+export interface DeploymentViewIncludePredicate<A extends AnyAux = Unknown>
+  extends AnyIncludePredicate<Expression<A>>
+{}
+export interface DeploymentViewExcludePredicate<A extends AnyAux = Unknown>
+  extends AnyExcludePredicate<Expression<A>>
+{}
+
+export type DeploymentViewPredicate<A extends AnyAux = Unknown> =
+  | DeploymentViewIncludePredicate<A>
+  | DeploymentViewExcludePredicate<A>
+
+export interface DeploymentViewRuleStyle<A extends AnyAux = Unknown> extends AnyViewRuleStyle<FqnExpr<A>> {}
+
+export type DeploymentViewRule<A extends AnyAux = Unknown> = ExclusiveUnion<{
+  Include: DeploymentViewIncludePredicate<A>
+  Exclude: DeploymentViewExcludePredicate<A>
+  Style: DeploymentViewRuleStyle<A>
+  AutoLayout: ViewRuleAutoLayout
+}>
+
+export interface ParsedDeploymentView<A extends AnyAux = Unknown> extends BaseParsedViewProperties<A> {
+  [_type]: 'deployment'
+  readonly rules: DeploymentViewRule<A>[]
+}

package/src/types/view-parsed.dynamic.ts

@@ -0,0 +1,78 @@
+import { isArray } from 'remeda'
+import type { MergeExclusive, Simplify } from 'type-fest'
+import type { ExclusiveUnion } from './_common'
+import type * as aux from './aux'
+import type { AnyAux } from './aux'
+import type { _type } from './const'
+import type { ModelFqnExpr } from './expression-model'
+import { isStepEdgeId } from './scalar'
+import type { Color, RelationshipArrowType, RelationshipLineType } from './styles'
+import type {
+  BaseParsedViewProperties,
+  ViewRuleAutoLayout,
+  ViewRuleGlobalPredicateRef,
+  ViewRuleGlobalStyle,
+} from './view-common'
+import type { ElementViewRuleStyle } from './view-parsed.element'
+
+export interface DynamicViewStep<A extends AnyAux = AnyAux> {
+  readonly source: aux.StrictFqn<A>
+  readonly target: aux.StrictFqn<A>
+  readonly title: string | null
+  readonly description?: string
+  readonly technology?: string
+  readonly notation?: string
+  // Notes for walkthrough
+  readonly notes?: string
+  readonly color?: Color
+  readonly line?: RelationshipLineType
+  readonly head?: RelationshipArrowType
+  readonly tail?: RelationshipArrowType
+  readonly isBackward?: boolean
+  // Link to dynamic view
+  readonly navigateTo?: aux.StrictViewId<A>
+}
+
+export interface DynamicViewParallelSteps<A extends AnyAux = AnyAux> {
+  readonly __parallel: DynamicViewStep<A>[]
+}
+
+// Get the prefix of the parallel steps
+// i.e. step-01.1 -> step-01.
+export function getParallelStepsPrefix(id: string): string | null {
+  if (isStepEdgeId(id) && id.includes('.')) {
+    return id.slice(0, id.indexOf('.') + 1)
+  }
+  return null
+}
+
+export type DynamicViewStepOrParallel<A extends AnyAux = AnyAux> = Simplify<
+  MergeExclusive<
+    DynamicViewStep<A>,
+    DynamicViewParallelSteps<A>
+  >
+>
+
+export interface DynamicViewIncludeRule<A extends AnyAux = AnyAux> {
+  include: ModelFqnExpr.Any<A>[]
+}
+
+export type DynamicViewRule<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+  Include: DynamicViewIncludeRule<A>
+  GlobalPredicateRef: ViewRuleGlobalPredicateRef
+  ElementViewRuleStyle: ElementViewRuleStyle<A>
+  GlobalStyle: ViewRuleGlobalStyle
+  AutoLayout: ViewRuleAutoLayout
+}>
+
+export interface ParsedDynamicView<A extends AnyAux = AnyAux> extends BaseParsedViewProperties<A> {
+  [_type]: 'dynamic'
+  readonly steps: DynamicViewStepOrParallel<A>[]
+  readonly rules: DynamicViewRule<A>[]
+}
+
+export function isDynamicViewParallelSteps<A extends AnyAux>(
+  step: DynamicViewStepOrParallel<A>,
+): step is DynamicViewParallelSteps<A> {
+  return '__parallel' in step && isArray(step.__parallel)
+}

package/src/types/view-parsed.element.ts

@@ -0,0 +1,65 @@
+import type { ExclusiveUnion } from './_common'
+import type * as aux from './aux'
+import type { AnyAux } from './aux'
+import type { _type } from './const'
+import type { ModelExpression, ModelFqnExpr } from './expression-model'
+import type { BorderStyle, Color, ShapeSize, SpacingSize, TextSize } from './styles'
+import type {
+  AnyExcludePredicate,
+  AnyIncludePredicate,
+  AnyViewRuleStyle,
+  BaseParsedViewProperties,
+  ViewRuleAutoLayout,
+  ViewRuleGlobalPredicateRef,
+  ViewRuleGlobalStyle,
+} from './view-common'
+
+/**
+ * Predicates scoped to logical model
+ */
+export interface ElementViewIncludePredicate<A extends AnyAux = AnyAux>
+  extends AnyIncludePredicate<ModelExpression<A>>
+{}
+export interface ElementViewExcludePredicate<A extends AnyAux = AnyAux>
+  extends AnyExcludePredicate<ModelExpression<A>>
+{}
+
+export type ElementViewPredicate<A extends AnyAux = AnyAux> =
+  | ElementViewIncludePredicate<A>
+  | ElementViewExcludePredicate<A>
+
+export interface ElementViewRuleGroup<A extends AnyAux = AnyAux> {
+  groupRules: Array<ElementViewPredicate<A> | ElementViewRuleGroup<A>>
+  title: string | null
+  color?: Color
+  border?: BorderStyle
+  // 0-100
+  opacity?: number
+  multiple?: boolean
+  size?: ShapeSize
+  padding?: SpacingSize
+  textSize?: TextSize
+}
+
+export function isViewRuleGroup<A extends AnyAux>(rule: ElementViewRule<A>): rule is ElementViewRuleGroup<A> {
+  return 'title' in rule && 'groupRules' in rule && Array.isArray(rule.groupRules)
+}
+
+export interface ElementViewRuleStyle<A extends AnyAux = AnyAux> extends AnyViewRuleStyle<ModelFqnExpr<A>> {}
+
+export type ElementViewRule<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+  IncludePredicate: ElementViewIncludePredicate<A>
+  ExcludePredicate: ElementViewExcludePredicate<A>
+  Group: ElementViewRuleGroup<A>
+  Style: ElementViewRuleStyle<A>
+  GlobalStyle: ViewRuleGlobalStyle
+  GlobalPredicateRef: ViewRuleGlobalPredicateRef
+  AutoLayout: ViewRuleAutoLayout
+}>
+
+export interface ParsedElementView<A extends AnyAux = AnyAux> extends BaseParsedViewProperties<A> {
+  [_type]: 'element'
+  readonly rules: ElementViewRule<A>[]
+  readonly viewOf?: aux.StrictFqn<A>
+  readonly extends?: aux.StrictViewId<A>
+}