@likec4/core 1.31.0 → 1.32.0

package/src/types/geometry.ts

@@ -0,0 +1,131 @@
+import { invariant } from '../utils/invariant'
+
+export type Point = readonly [x: number, y: number]
+
+export interface XYPoint {
+  x: number
+  y: number
+}
+
+// Bounding box
+export interface BBox {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+export namespace BBox {
+  export function center({ x, y, width, height }: BBox): XYPoint {
+    return {
+      x: x + width / 2,
+      y: y + height / 2,
+    }
+  }
+
+  export function fromPoints(points: Point[]): BBox {
+    const { x1, y1, x2, y2 } = RectBox.fromPoints(points)
+    return {
+      x: x1,
+      y: y1,
+      width: x2 - x1,
+      height: y2 - y1,
+    }
+  }
+
+  export function merge(...boxes: BBox[]): BBox {
+    invariant(boxes.length > 0, 'No boxes provided')
+    let minX = Infinity
+    let minY = Infinity
+    let maxX = -Infinity
+    let maxY = -Infinity
+    for (const box of boxes) {
+      minX = Math.min(minX, box.x)
+      minY = Math.min(minY, box.y)
+      maxX = Math.max(maxX, box.x + box.width)
+      maxY = Math.max(maxY, box.y + box.height)
+    }
+    return {
+      x: minX,
+      y: minY,
+      width: maxX - minX,
+      height: maxY - minY,
+    }
+  }
+
+  export function toRectBox(box: BBox): RectBox {
+    return {
+      x1: box.x,
+      y1: box.y,
+      x2: box.x + box.width,
+      y2: box.y + box.height,
+    }
+  }
+}
+
+export interface RectBox {
+  // Top left
+  x1: number
+  y1: number
+  // Bottom right
+  x2: number
+  y2: number
+}
+
+export namespace RectBox {
+  export function center({ x1, y1, x2, y2 }: RectBox): XYPoint {
+    return {
+      x: (x1 + x2) / 2,
+      y: (y1 + y2) / 2,
+    }
+  }
+
+  export function fromPoints(points: Point[]): RectBox {
+    invariant(points.length > 0, 'At least one point is required')
+    let minX = Infinity
+    let minY = Infinity
+    let maxX = -Infinity
+    let maxY = -Infinity
+    for (const [x, y] of points) {
+      minX = Math.min(minX, x)
+      minY = Math.min(minY, y)
+      maxX = Math.max(maxX, x)
+      maxY = Math.max(maxY, y)
+    }
+    return {
+      x1: minX,
+      y1: minY,
+      x2: maxX,
+      y2: maxY,
+    }
+  }
+
+  export function merge(...boxes: RectBox[]): RectBox {
+    invariant(boxes.length > 0, 'No boxes provided')
+    let minX = Infinity
+    let minY = Infinity
+    let maxX = -Infinity
+    let maxY = -Infinity
+    for (const box of boxes) {
+      minX = Math.min(minX, box.x1)
+      minY = Math.min(minY, box.y1)
+      maxX = Math.max(maxX, box.x2)
+      maxY = Math.max(maxY, box.y2)
+    }
+    return {
+      x1: minX,
+      y1: minY,
+      x2: maxX,
+      y2: maxY,
+    }
+  }
+
+  export function toBBox(box: RectBox): BBox {
+    return {
+      x: box.x1,
+      y: box.y1,
+      width: box.x2 - box.x1,
+      height: box.y2 - box.y1,
+    }
+  }
+}

package/src/types/global.ts

@@ -1,19 +1,21 @@
 import type { NonEmptyTuple, Tagged } from 'type-fest'
 import type { NonEmptyArray } from './_common'
-import type { DynamicViewIncludeRule, ViewRulePredicate, ViewRuleStyle } from './view'
+import type { Any } from './aux'
+import type { DynamicViewIncludeRule } from './view-parsed.dynamic'
+import type { ElementViewPredicate, ElementViewRuleStyle } from './view-parsed.element'
 
 export type GlobalPredicateId = Tagged<string, 'GlobalPredicateId'>
 
-export type GlobalPredicates = NonEmptyArray<ViewRulePredicate>
+export type GlobalPredicates<A extends Any = Any> = NonEmptyArray<ElementViewPredicate<A>>
 
-export type GlobalDynamicPredicates = NonEmptyArray<DynamicViewIncludeRule>
+export type GlobalDynamicPredicates<A extends Any = Any> = NonEmptyArray<DynamicViewIncludeRule<A>>
 
 export type GlobalStyleID = Tagged<string, 'GlobalStyleID'>
 
-export type GlobalStyles = NonEmptyTuple<ViewRuleStyle>
+export type GlobalStyles<A extends Any = Any> = NonEmptyTuple<ElementViewRuleStyle<A>>
 
-export interface ModelGlobals {
-  readonly predicates: Record<GlobalPredicateId, GlobalPredicates>
-  readonly dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates>
-  readonly styles: Record<GlobalStyleID, GlobalStyles>
+export interface ModelGlobals<A extends Any = Any> {
+  readonly predicates: Record<GlobalPredicateId, GlobalPredicates<A>>
+  readonly dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates<A>>
+  readonly styles: Record<GlobalStyleID, GlobalStyles<A>>
 }

package/src/types/index.ts

@@ -1,201 +1,39 @@
-export type {
-  CustomColor,
-  ExclusiveUnion,
-  IteratorLike,
-  KeysOf,
-  NonEmptyArray,
-  NonEmptyReadonlyArray,
-  NTuple,
-  Point,
-  Predicate,
-  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,
-  DeploymentElementStyle,
-  DeploymentNode,
-  DeploymentNodeKind,
-  DeploymentNodeKindSpecification,
-  DeploymentRef,
-  DeploymentRelation,
-  PredicateSelector,
-} from './deployments'
-
-export {
-  BorderStyles,
-  DefaultElementShape,
-  DefaultPaddingSize,
-  DefaultShapeSize,
-  DefaultTextSize,
-  DefaultThemeColor,
-  ElementKind,
-  ElementShapes,
-} from './element'
-export type {
-  BorderStyle,
-  Element,
-  ElementKindSpecification,
-  ElementKindSpecificationStyle,
-  ElementShape,
-  ElementStyle,
-  Link,
-  TagSpec,
-  TypedElement,
-} from './element'
-
-export { ExpressionV2, FqnExpr, FqnRef, RelationExpr } from './expression-v2'
-export { ModelLayer } from './expression-v2-model'
-
-export type {
-  GlobalDynamicPredicates,
-  GlobalPredicateId,
-  GlobalPredicates,
-  GlobalStyleID,
-  GlobalStyles,
-  ModelGlobals,
-} from './global'
-
-export type {
-  AnyParsedLikeC4ModelData,
-  ComputedLikeC4ModelData,
-  GenericLikeC4ModelData,
-  LayoutedLikeC4ModelData,
-  LikeC4ModelDump,
-  ParsedLikeC4ModelData,
-} from './model-data'
-
-export {
-  isAndOperator,
-  isKindEqual,
-  isNotOperator,
-  isOrOperator,
-  isParticipantOperator,
-  isTagEqual,
-  whereOperatorAsPredicate,
-} from './operators'
-export type {
-  AllNever,
-  AndOperator,
-  EqualOperator,
-  Filterable,
-  KindEqual,
-  NotOperator,
-  OperatorPredicate,
-  OrOperator,
-  Participant,
-  ParticipantOperator,
-  TagEqual,
-  WhereOperator,
-} from './operators'
-export type { OverviewGraph } from './overview-graph'
-export { DefaultArrowType, DefaultLineStyle, DefaultRelationshipColor } from './relation'
-export type {
-  AbstractRelation,
-  ModelRelation,
-  RelationId,
-  RelationshipArrowType,
-  RelationshipKind,
-  RelationshipKindSpecification,
-  RelationshipLineType,
-} from './relation'
-export { isThemeColor, ThemeColors } from './theme'
-export type {
-  Color,
-  ColorLiteral,
-  ElementThemeColors,
-  ElementThemeColorValues,
-  HexColorLiteral,
-  LikeC4Theme,
-  RelationshipThemeColors,
-  RelationshipThemeColorValues,
-  ShapeSize,
-  SpacingSize,
-  TextSize,
-  ThemeColor,
-  ThemeColorValues,
-} from './theme'
-export {
-  ComputedNode, // namespace
-  ComputedView, // namespace
-  DiagramNode, // namespace
-  extractStep,
-  getBBoxCenter,
-  getParallelStepsPrefix,
-  isAutoLayoutDirection,
-  isDeploymentView,
-  isDynamicView,
-  isDynamicViewParallelSteps,
-  isElementView,
-  isExtendsElementView,
-  isScopedElementView,
-  isStepEdgeId,
-  isViewRuleAutoLayout,
-  isViewRuleGlobalPredicateRef,
-  isViewRuleGlobalStyle,
-  isViewRuleGroup,
-  isViewRulePredicate,
-  isViewRuleStyle,
-  stepEdgeId,
-} from './view'
-export type {
-  AutoLayoutDirection,
-  BasicElementView,
-  BasicView,
-  BBox,
-  ComputedDeploymentView,
-  ComputedDynamicView,
-  ComputedEdge,
-  ComputedElementView,
-  CustomColorDefinitions,
-  DeploymentView,
-  DeploymentViewRule,
-  DeploymentViewRulePredicate,
-  DeploymentViewRuleStyle,
-  DiagramEdge,
-  DiagramView,
-  DynamicView,
-  DynamicViewIncludeRule,
-  DynamicViewParallelSteps,
-  DynamicViewRule,
-  DynamicViewStep,
-  DynamicViewStepOrParallel,
-  EdgeId,
-  ElementView,
-  ExtendsElementView,
-  LikeC4View,
-  NodeId,
-  ScopedElementView,
-  StepEdgeId,
-  StepEdgeIdLiteral,
-  ViewAutoLayout,
-  ViewId,
-  ViewManualLayout,
-  ViewRule,
-  ViewRuleAutoLayout,
-  ViewRuleGlobalPredicateRef,
-  ViewRuleGlobalStyle,
-  ViewRuleGroup,
-  ViewRulePredicate,
-  ViewRuleStyle,
-  ViewRuleStyleOrGlobalRef,
-  ViewWithHash,
-  ViewWithNotation,
-} from './view'
-export type { ViewChange } from './view-changes'
-export type { ElementNotation } from './view-notation'
+export * from './_common'
+
+export type * as aux from './aux'
+
+export type {
+  Any,
+  AnyAux,
+  Aux,
+  SpecAux,
+  Unknown,
+  UnknownComputed,
+  UnknownLayouted,
+  UnknownParsed,
+} from './aux'
+
+export * from './const'
+export * from './expression'
+export * from './expression-model'
+export * from './fqnRef'
+export * from './geometry'
+export * from './global'
+export * from './model-data'
+export * from './model-deployment'
+export * from './model-dump'
+export * from './model-logical'
+export * from './model-spec'
+export * from './operators'
+export * from './scalar'
+export * from './styles'
+export * from './view'
+export * from './view-changes'
+export * from './view-common'
+export * from './view-computed'
+export * from './view-layouted'
+export * from './view-parsed.deployment'
+export * from './view-parsed.dynamic'
+export * from './view-parsed.element'
+
+export type * as scalar from './scalar'

package/src/types/model-data.ts

@@ -1,15 +1,35 @@
+import type { IsAny } from 'type-fest'
 import type { NonEmptyArray } from './_common'
-import type {
-  DeploymentElement,
-  DeploymentNodeKind,
-  DeploymentNodeKindSpecification,
-  DeploymentRelation,
-} from './deployments'
-import type { Element, ElementKindSpecification, TypedElement } from './element'
+import type * as aux from './aux'
+import type { Any } from './aux'
+import type { _stage } from './const'
 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'
+import type { DeploymentElement, DeploymentRelationship } from './model-deployment'
+import type { Element, Relationship } from './model-logical'
+import type { Specification } from './model-spec'
+import type * as scalar from './scalar'
+import type { ComputedView, LayoutedView, ParsedView } from './view'
+
+interface BaseLikeC4ModelData<A extends aux.Any> {
+  projectId: aux.ProjectId<A>
+  specification: Specification<A>
+  elements: Record<aux.ElementId<A>, Element<A>>
+  deployments: {
+    elements: Record<aux.DeploymentId<A>, DeploymentElement<A>>
+    relations: Record<scalar.RelationId, DeploymentRelationship<A>>
+  }
+  relations: Record<scalar.RelationId, Relationship<A>>
+  globals: ModelGlobals
+  imports: Record<string, NonEmptyArray<Element<A>>>
+}
+
+export type AuxFromLikeC4ModelData<D> =
+  // dprint-ignore
+  D extends BaseLikeC4ModelData<infer A extends Any>
+    ? IsAny<A> extends true
+      ? never
+      : A
+    : never
 
 /**
  * Represents a LikeC4 model with customizable type parameters,
@@ -25,83 +45,31 @@ import type { ComputedView, DiagramView, LikeC4View } from './view'
  * @typeParam Views - Types of views in the model (defaults to string)
  * @typeParam DeploymentFqns - Fully Qualified Names for deployment nodes (defaults to string)
  */
-export interface ParsedLikeC4ModelData<
-  ElementKinds extends string = string,
-  RelationKinds extends string = string,
-  Tags extends string = string,
-  Fqns extends string = string,
-  Views extends string = string,
-  DeploymentFqns extends string = string,
-> {
-  // To prevent accidental use of this type
-  __?: never
-  specification: {
-    tags: Tag<Tags>[]
-    elements: Record<ElementKinds, ElementKindSpecification>
-    deployments: Record<DeploymentNodeKind, DeploymentNodeKindSpecification>
-    relationships: Record<RelationKinds, RelationshipKindSpecification>
-  }
-  elements: Record<Fqns, TypedElement<Fqns, ElementKinds, Tags>>
-  relations: Record<RelationId, ModelRelation>
-  globals: ModelGlobals
-  views: Record<Views, LikeC4View<Views, Tags>>
-  /**
-   * Deployment Model.
-   */
-  deployments: {
-    elements: Record<DeploymentFqns, DeploymentElement>
-    relations: Record<RelationId, DeploymentRelation>
-  }
-  imports: Record<ProjectId, NonEmptyArray<Element>>
+export interface ParsedLikeC4ModelData<A extends Any = aux.UnknownParsed> extends BaseLikeC4ModelData<A> {
+  [_stage]: 'parsed'
+  // globals: ModelGlobals<A
+  views: Record<aux.ViewId<A>, ParsedView<A>>
 }
 
-export type AnyParsedLikeC4ModelData = ParsedLikeC4ModelData<any, any, any, any, any, any>
-/**
- * Hook to get types from dump
- */
-export type LikeC4ModelDump = {
-  elements: {
-    [kind: string]: object
-  }
-  deployments: {
-    elements: {
-      [kind: string]: object
-    }
-  }
-  views: {
-    [kind: string]: object
-  }
+export interface ComputedLikeC4ModelData<A extends Any = aux.UnknownComputed> extends BaseLikeC4ModelData<A> {
+  [_stage]: 'computed'
+  // specification: Specification<A>
+  // globals: ModelGlobals<A>
+  views: Record<aux.ViewId<A>, ComputedView<A>>
 }
 
-/**
- * Same as {@link ParsedLikeC4ModelData}, but with computed views or layouted views.
- */
-export interface GenericLikeC4ModelData<
-  Fqns extends string = string,
-  DeploymentFqns extends string = string,
-  Views extends string = string,
-  Tags extends string = string,
-  T = 'computed' | 'layouted',
-> extends Omit<ParsedLikeC4ModelData<string, string, Tags, Fqns, Views, DeploymentFqns>, 'views' | '__'> {
-  __?: T
-  views: Record<Views, ComputedView<Views> | DiagramView<Views>>
+export interface LayoutedLikeC4ModelData<A extends Any = aux.UnknownLayouted> extends BaseLikeC4ModelData<A> {
+  [_stage]: 'layouted'
+  // globals: ModelGlobals<A>
+  views: Record<aux.ViewId<A>, LayoutedView<A>>
 }
 
-export interface ComputedLikeC4ModelData<
-  Fqns extends string = string,
-  DeploymentFqns extends string = string,
-  Views extends string = string,
-  Tags extends string = string,
-> extends Omit<GenericLikeC4ModelData<Fqns, DeploymentFqns, Views, Tags, 'computed'>, 'views'> {
-  views: Record<Views, ComputedView<Views>>
-}
-
-export interface LayoutedLikeC4ModelData<
-  Fqns extends string = string,
-  DeploymentFqns extends string = string,
-  Views extends string = string,
-  Tags extends string = string,
-> extends Omit<GenericLikeC4ModelData<Fqns, DeploymentFqns, Views, Tags, 'layouted'>, 'views'> {
-  __: 'layouted'
-  views: Record<Views, DiagramView<Views, Tags>>
-}
+export type LikeC4ModelData<A extends Any> =
+  | ParsedLikeC4ModelData<A>
+  | ComputedLikeC4ModelData<A>
+  | LayoutedLikeC4ModelData<A>
+// ExclusiveUnion<{
+//   Parsed: ParsedLikeC4ModelData<A>
+//   Computed: ComputedLikeC4ModelData<A>
+//   Layouted: LayoutedLikeC4ModelData<A>
+// }>

package/src/types/model-deployment.ts

@@ -0,0 +1,87 @@
+import { isTruthy } from 'remeda'
+import type { Link } from './_common'
+import type * as aux from './aux'
+import type { AnyAux, Unknown } from './aux'
+import type { FqnRef } from './fqnRef'
+import type { AbstractRelationship, ElementStyle } from './model-logical'
+import type { Icon } from './scalar'
+import type { Color, ElementShape } from './styles'
+
+export interface DeploymentElementStyle extends ElementStyle {
+  readonly icon?: Icon
+  readonly shape?: ElementShape
+  readonly color?: Color
+}
+
+// dprint-ignore
+export interface DeploymentNode<A extends AnyAux = Unknown>
+  extends
+    aux.WithOptionalTags<A>,
+    aux.WithOptionalLinks,
+    aux.WithMetadata<A>
+{
+  element?: never
+  // Full-qualified-name for Deployment model
+  readonly id: aux.StrictDeploymentFqn<A>
+  readonly kind: aux.DeploymentKind<A>
+  readonly title: string
+  readonly description?: string | null
+  readonly technology?: string | null
+  readonly tags?: aux.Tags<A> | null
+  readonly links?: readonly Link[] | null
+  readonly style: DeploymentElementStyle
+  readonly notation?: string
+  readonly metadata?: aux.Metadata<A>
+}
+
+// dprint-ignore
+export interface DeployedInstance<A extends AnyAux = Unknown>
+  extends
+    aux.WithOptionalTags<A>,
+    aux.WithOptionalLinks,
+    aux.WithMetadata<A>
+{
+  kind?: never
+  /**
+   * Format: `<DeploymentNode Fqn>.<Instance Id>`
+   * i.e parent fqn is deployment target
+   */
+  readonly id: aux.StrictDeploymentFqn<A>
+  readonly element: aux.StrictFqn<A>
+  readonly title?: string
+  readonly description?: string | null
+  readonly technology?: string | null
+  readonly tags?: aux.Tags<A> | null
+  readonly links?: readonly Link[] | null
+  readonly style?: DeploymentElementStyle
+  readonly notation?: string
+  readonly metadata?: aux.Metadata<A>
+}
+
+export type DeploymentElement<A extends AnyAux = Unknown> = DeploymentNode<A> | DeployedInstance<A>
+
+export type DeploymentElementRef<A extends AnyAux = Unknown> = {
+  readonly id: aux.StrictDeploymentFqn<A>
+  readonly element?: aux.StrictFqn<A>
+}
+
+export function isDeploymentNode<A extends AnyAux>(el: DeploymentElement<A>): el is DeploymentNode<A> {
+  return 'kind' in el && !isTruthy(el.element)
+}
+
+export function isDeployedInstance<A extends AnyAux>(el: DeploymentElement<A>): el is DeployedInstance<A> {
+  return 'element' in el && isTruthy(el.element)
+}
+
+/**
+ * Relationship in deployment model
+ */
+export interface DeploymentRelationship<A extends AnyAux = Unknown> extends AbstractRelationship<A> {
+  readonly source: FqnRef.DeploymentRef<A>
+  readonly target: FqnRef.DeploymentRef<A>
+}
+/**
+ * Backward compatibility alias
+ * @deprecated Use {@link DeploymentRelationship} instead
+ */
+export type DeploymentRelation<A extends AnyAux = Unknown> = DeploymentRelationship<A>