@likec4/core 1.40.0 → 1.42.0

package/src/types/geometry.ts

@@ -1,159 +0,0 @@
-import { hasAtLeast } from 'remeda'
-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(hasAtLeast(boxes, 1), 'No boxes provided')
-    if (boxes.length === 1) {
-      return boxes[0]
-    }
-    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 function expand(box: BBox, plus: number): BBox {
-    if (plus === 0) {
-      return box
-    }
-    return {
-      x: box.x - plus,
-      y: box.y - plus,
-      width: box.width + plus * 2,
-      height: box.height + plus * 2,
-    }
-  }
-
-  export function shrink(box: BBox, minus: number): BBox {
-    if (minus === 0) {
-      return box
-    }
-    return {
-      x: box.x + minus,
-      y: box.y + minus,
-      width: box.width - minus * 2,
-      height: box.height - minus * 2,
-    }
-  }
-}
-
-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,21 +0,0 @@
-import type { NonEmptyTuple, Tagged } from 'type-fest'
-import type { Any } from './_aux'
-import type { NonEmptyArray } from './_common'
-import type { DynamicViewIncludeRule } from './view-parsed.dynamic'
-import type { ElementViewPredicate, ElementViewRuleStyle } from './view-parsed.element'
-
-export type GlobalPredicateId = Tagged<string, 'GlobalPredicateId'>
-
-export type GlobalPredicates<A extends Any = Any> = NonEmptyArray<ElementViewPredicate<A>>
-
-export type GlobalDynamicPredicates<A extends Any = Any> = NonEmptyArray<DynamicViewIncludeRule<A>>
-
-export type GlobalStyleID = Tagged<string, 'GlobalStyleID'>
-
-export type GlobalStyles<A extends Any = Any> = NonEmptyTuple<ElementViewRuleStyle<A>>
-
-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,42 +0,0 @@
-export * from './_common'
-
-export * 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 './project'
-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 * as scalar from './scalar'
-
-export { RichText, type RichTextEmpty, type RichTextOrEmpty } from './RichText'

package/src/types/model-data.ts

@@ -1,77 +0,0 @@
-import type { IsAny } from 'type-fest'
-import type * as aux from './_aux'
-import type { Any } from './_aux'
-import type { NonEmptyArray } from './_common'
-import type { _stage } from './const'
-import type { ModelGlobals } from './global'
-import type { DeploymentElement, DeploymentRelationship } from './model-deployment'
-import type { Element, Relationship } from './model-logical'
-import type { Specification } from './model-spec'
-import type { LikeC4Project } from './project'
-import type * as scalar from './scalar'
-import type { ComputedView, LayoutedView, ParsedView } from './view'
-
-interface BaseLikeC4ModelData<A extends aux.Any> {
-  projectId: aux.ProjectId<A>
-  project: LikeC4Project
-  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,
- * parsed from DSL or result from Builder
- *
- * !IMPORTANT: This is a low-level type, use `LikeC4Model` instead.
- * !NOTE: Views are not computed yet.
- *
- * @typeParam ElementKinds - Types of elements in the model (defaults to string)
- * @typeParam RelationKinds - Types of relationships (defaults to string)
- * @typeParam Tags - Types of tags that can be applied (defaults to string)
- * @typeParam Fqns - Fully Qualified Names for elements (defaults to string)
- * @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<A extends Any = aux.UnknownParsed> extends BaseLikeC4ModelData<A> {
-  [_stage]: 'parsed'
-  // globals: ModelGlobals<A
-  views: Record<aux.ViewId<A>, ParsedView<A>>
-}
-
-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>>
-}
-
-export interface LayoutedLikeC4ModelData<A extends Any = aux.UnknownLayouted> extends BaseLikeC4ModelData<A> {
-  [_stage]: 'layouted'
-  // globals: ModelGlobals<A>
-  views: Record<aux.ViewId<A>, LayoutedView<A>>
-}
-
-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

@@ -1,88 +0,0 @@
-import { isTruthy } from 'remeda'
-import type * as aux from './_aux'
-import type { AnyAux, Unknown } from './_aux'
-import type { Link } from './_common'
-import type { FqnRef } from './fqnRef'
-import type { AbstractRelationship, ElementStyle } from './model-logical'
-import type { Icon } from './scalar'
-import type * as scalar 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?: scalar.MarkdownOrString | null
-  readonly technology?: string | null
-  readonly tags?: aux.Tags<A> | null
-  readonly links?: readonly Link[] | null
-  readonly style: DeploymentElementStyle
-  readonly notation?: string | null
-  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?: scalar.MarkdownOrString | 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>

package/src/types/model-dump.ts

@@ -1,79 +0,0 @@
-import type * as aux from './_aux'
-import type { KeysOf } from './_common'
-import type { _stage } from './const'
-import type { ParsedLikeC4ModelData } from './model-data'
-
-/**
- * JSON representation of {@link Specification}
- */
-export interface SpecificationDump {
-  elements: {
-    [kind: string]: object
-  }
-  tags?: {
-    [tag: string]: object
-  }
-  deployments?: {
-    [kind: string]: object
-  }
-  relationships?: {
-    [kind: string]: object
-  }
-  metadataKeys?: string[]
-  customColors?: {
-    [kind: string]: object
-  }
-}
-export type SpecTypesFromDump<J> = J extends SpecificationDump ? aux.SpecAux<
-    KeysOf<J['elements']>,
-    KeysOf<J['deployments']>,
-    KeysOf<J['relationships']>,
-    KeysOf<J['tags']>,
-    J['metadataKeys'] extends readonly [string, ...string[]] ? J['metadataKeys'][number] : never
-  >
-  : aux.SpecAux<never, never, never, never, never>
-
-/**
- * Dump differs from {@link ParsedLikeC4ModelData} by the fact that it is computed or layouted
- */
-export type LikeC4ModelDump = {
-  [_stage]?: 'computed' | 'layouted'
-  projectId?: string
-  project?: ProjectDump
-  specification: SpecificationDump
-  elements?: {
-    [kind: string]: object
-  }
-  deployments: {
-    elements?: {
-      [kind: string]: object
-    }
-    relations?: {}
-  }
-  views?: {
-    [kind: string]: object
-  }
-  relations?: {}
-  globals?: {
-    predicates?: {}
-    dynamicPredicates?: {}
-    styles?: {}
-  }
-  imports?: {}
-}
-
-export type ProjectDump = {
-  id: string
-  name?: string
-  title?: string | undefined
-}
-
-export type AuxFromDump<D> = D extends LikeC4ModelDump ? aux.Aux<
-    D[_stage] extends infer S extends string & 'computed' | 'layouted' ? S : 'computed' | 'layouted' | 'parsed',
-    KeysOf<D['elements']>,
-    KeysOf<D['deployments']['elements']>,
-    KeysOf<D['views']>,
-    D['projectId'] extends infer PID extends string ? PID : never,
-    SpecTypesFromDump<D['specification']>
-  >
-  : aux.Never

package/src/types/model-logical.ts

@@ -1,135 +0,0 @@
-import type * as aux from './_aux'
-import type { AnyAux } from './_aux'
-import type { Link } from './_common'
-import type { FqnRef } from './fqnRef'
-import type * as scalar from './scalar'
-import type {
-  BorderStyle,
-  Color,
-  ElementShape,
-  RelationshipArrowType,
-  RelationshipLineType,
-  ShapeSize,
-  SpacingSize,
-  TextSize,
-  ThemeColor,
-} from './styles'
-
-export const DefaultThemeColor: ThemeColor = 'primary'
-export const DefaultElementShape: ElementShape = 'rectangle'
-export const DefaultSize = 'md'
-export const DefaultShapeSize: ShapeSize = DefaultSize
-export const DefaultPaddingSize: SpacingSize = DefaultSize
-export const DefaultTextSize: TextSize = DefaultSize
-
-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
-}
-
-type WithSizes = Pick<ElementStyle, 'size' | 'padding' | 'textSize'>
-
-/**
- * Ensures that the sizes are set to default values if they are not set
- */
-export function ensureSizes<S extends WithSizes>({
-  size,
-  padding,
-  textSize,
-  ...rest
-}: S): Omit<S, 'size' | 'padding' | 'textSize'> & Required<WithSizes> {
-  size ??= DefaultSize
-  textSize ??= size
-  padding ??= size
-
-  return {
-    ...rest,
-    size,
-    padding,
-    textSize,
-  }
-}
-
-// dprint-ignore
-export interface Element<A extends AnyAux = AnyAux>
-  extends
-    aux.WithOptionalTags<A>,
-    aux.WithOptionalLinks,
-    aux.WithMetadata<A>
-{
-  readonly id: aux.StrictFqn<A>
-  readonly kind: aux.ElementKind<A>
-  readonly title: string
-  readonly description?: scalar.MarkdownOrString | null
-  readonly technology?: string | null
-  readonly tags?: aux.Tags<A> | null
-  readonly links?: readonly Link[] | null
-  readonly icon?: scalar.Icon
-  readonly shape?: ElementShape
-  readonly color?: Color
-  readonly style?: ElementStyle
-  readonly notation?: string | null
-  readonly metadata?: aux.Metadata<A>
-}
-
-export const DefaultLineStyle: RelationshipLineType = 'dashed'
-export const DefaultArrowType: RelationshipArrowType = 'normal'
-export const DefaultRelationshipColor: ThemeColor = 'gray'
-
-// dprint-ignore
-export interface AbstractRelationship<A extends AnyAux>
-  extends
-    aux.WithOptionalTags<A>,
-    aux.WithOptionalLinks,
-    aux.WithMetadata<A>
-{
-  readonly id: scalar.RelationId
-  readonly title?: string | null
-  readonly description?: scalar.MarkdownOrString | null
-  readonly technology?: string | null
-  readonly kind?: aux.RelationKind<A>
-  readonly color?: Color
-  readonly line?: RelationshipLineType
-  readonly head?: RelationshipArrowType
-  readonly tail?: RelationshipArrowType
-  readonly tags?: aux.Tags<A> | null
-  readonly links?: readonly Link[] | null
-  // Link to dynamic view
-  readonly navigateTo?: aux.ViewId<A>
-  readonly metadata?: aux.Metadata<A>
-}
-
-/**
- * Relationship between two model elements
- */
-export interface Relationship<A extends AnyAux = AnyAux> extends AbstractRelationship<A> {
-  readonly source: FqnRef.ModelRef<A>
-  readonly target: FqnRef.ModelRef<A>
-}
-
-/**
- * Backward compatibility alias
- * @deprecated Use {@link Relationship} instead
- */
-export type ModelRelation<A extends AnyAux = AnyAux> = Relationship<A>

package/src/types/model-spec.ts

@@ -1,85 +0,0 @@
-import type { IsNever } from 'type-fest'
-import type * as aux from './_aux'
-import type { Any } from './_aux'
-import type { Link, NonEmptyArray } from './_common'
-import type * as scalar from './scalar'
-import type {
-  Icon,
-} from './scalar'
-import type {
-  BorderStyle,
-  Color,
-  ColorLiteral,
-  CustomColorDefinitions,
-  ElementShape,
-  RelationshipArrowType,
-  RelationshipLineType,
-  ShapeSize,
-  SpacingSize,
-  TextSize,
-  ThemeColor,
-} from './styles'
-
-/**
- * Element and deployment kind specification
- */
-export interface ElementSpecification {
-  tags?: scalar.Tag[]
-  title?: string
-  description?: scalar.MarkdownOrString
-  technology?: string
-  notation?: string
-  links?: NonEmptyArray<Link>
-  style: {
-    shape?: ElementShape
-    icon?: Icon
-    color?: Color
-    border?: BorderStyle
-    opacity?: number
-    size?: ShapeSize
-    padding?: SpacingSize
-    textSize?: TextSize
-    multiple?: boolean
-  }
-}
-
-export interface TagSpecification {
-  color: ThemeColor | ColorLiteral
-}
-
-/**
- * Checks if tag color is defined in the specification
- * Expects HEX, `rgb(...)` or `rgba(...)` color
- */
-export function isTagColorSpecified(spec: string | TagSpecification): spec is { color: ColorLiteral } {
-  const color = typeof spec === 'string' ? spec : spec.color
-  return color.startsWith('#') || color.startsWith('rgb')
-}
-
-export interface RelationshipSpecification {
-  technology?: string
-  notation?: string
-  color?: Color
-  line?: RelationshipLineType
-  head?: RelationshipArrowType
-  tail?: RelationshipArrowType
-}
-
-export type Specification<A> = A extends Any ? {
-    tags: {
-      [key in aux.Tag<A>]: TagSpecification
-    }
-    elements: {
-      [key in aux.ElementKind<A>]: Partial<ElementSpecification>
-    }
-    deployments: {
-      [key in aux.DeploymentKind<A>]: Partial<ElementSpecification>
-    }
-    relationships: {
-      [key in aux.RelationKind<A>]: Partial<RelationshipSpecification>
-    }
-    // dprint-ignore
-    metadataKeys?: IsNever<aux.MetadataKey<A>> extends true ? never : aux.MetadataKey<A>[]
-    customColors?: CustomColorDefinitions
-  } :
-  never