@likec4/core 1.40.0 → 1.42.0

package/src/types/operators.ts

@@ -1,156 +0,0 @@
-import { allPass, anyPass, isNot, isNullish, isString } from 'remeda'
-import { nonexhaustive } from '../utils/invariant'
-import type * as aux from './_aux'
-import type { Any } from './_aux'
-import type { NonEmptyArray } from './_common'
-
-export type EqualOperator<V> = {
-  eq: V
-  neq?: never
-} | {
-  eq?: never
-  neq: V
-}
-
-type AllNever = {
-  not?: never
-  and?: never
-  or?: never
-  tag?: never
-  kind?: never
-  participant?: never
-  operator?: never
-}
-
-export type TagEqual<A extends Any> = Omit<AllNever, 'tag'> & {
-  tag: EqualOperator<aux.Tag<A>> | aux.Tag<A>
-}
-export function isTagEqual<A extends Any>(operator: WhereOperator<A>): operator is TagEqual<A> {
-  return 'tag' in operator
-}
-
-export type KindEqual<A extends Any> = Omit<AllNever, 'kind'> & {
-  kind: EqualOperator<aux.AllKinds<A>> | aux.AllKinds<A>
-}
-export function isKindEqual<A extends Any>(operator: WhereOperator<A>): operator is KindEqual<A> {
-  return 'kind' in operator
-}
-
-export type Participant = 'source' | 'target'
-export type ParticipantOperator<A extends Any> = Omit<AllNever, 'participant' | 'operator'> & {
-  participant: Participant
-  operator: KindEqual<A> | TagEqual<A>
-}
-export function isParticipantOperator<A extends Any>(
-  operator: WhereOperator<A>,
-): operator is ParticipantOperator<A> {
-  return 'participant' in operator
-}
-
-export type NotOperator<A extends Any> = Omit<AllNever, 'not'> & {
-  not: WhereOperator<A>
-}
-export function isNotOperator<A extends Any>(operator: WhereOperator<A>): operator is NotOperator<A> {
-  return 'not' in operator
-}
-
-export type AndOperator<A extends Any> = Omit<AllNever, 'and'> & {
-  and: NonEmptyArray<WhereOperator<A>>
-}
-export function isAndOperator<A extends Any>(operator: WhereOperator<A>): operator is AndOperator<A> {
-  return 'and' in operator
-}
-
-export type OrOperator<A extends Any> = Omit<AllNever, 'or'> & {
-  or: NonEmptyArray<WhereOperator<A>>
-}
-export function isOrOperator<A extends Any>(operator: WhereOperator<A>): operator is OrOperator<A> {
-  return 'or' in operator
-}
-
-export type WhereOperator<A extends Any = Any> =
-  | TagEqual<A>
-  | KindEqual<A>
-  | ParticipantOperator<A>
-  | NotOperator<A>
-  | AndOperator<A>
-  | OrOperator<A>
-
-export type Filterable<A extends Any> = {
-  tags?: aux.Tags<A> | null | undefined
-  kind?: aux.AllKinds<A> | null | undefined
-  source?: Filterable<A>
-  target?: Filterable<A>
-}
-
-export type OperatorPredicate<A extends Any> = (value: Filterable<A>) => boolean
-
-export function whereOperatorAsPredicate<A extends Any>(
-  operator: WhereOperator<A>,
-): OperatorPredicate<A> {
-  switch (true) {
-    case isParticipantOperator(operator): {
-      const participant = operator.participant
-      const participantPredicate = whereOperatorAsPredicate(operator.operator)
-
-      return participantIs(participant, participantPredicate)
-    }
-    case isTagEqual(operator): {
-      if (isString(operator.tag) || 'eq' in operator.tag) {
-        const tag = isString(operator.tag) ? operator.tag : operator.tag.eq
-        return (value) => {
-          return Array.isArray(value.tags) && value.tags.includes(tag)
-        }
-      }
-      const tag = operator.tag.neq
-      return (value) => {
-        return !Array.isArray(value.tags) || !value.tags.includes(tag)
-      }
-    }
-    case isKindEqual(operator): {
-      if (isString(operator.kind) || 'eq' in operator.kind) {
-        const kind = isString(operator.kind) ? operator.kind : operator.kind.eq
-        return (value) => {
-          return value.kind === kind
-        }
-      }
-      const kind = operator.kind.neq
-      return (value) => {
-        return isNullish(value.kind) || value.kind !== kind
-      }
-    }
-    case isNotOperator(operator): {
-      const predicate = whereOperatorAsPredicate(operator.not)
-      return isNot(predicate)
-    }
-    case isAndOperator(operator): {
-      const predicates = operator.and.map(whereOperatorAsPredicate)
-      return allPass(predicates)
-    }
-    case isOrOperator(operator): {
-      const predicates = operator.or.map(whereOperatorAsPredicate)
-      return anyPass(predicates)
-    }
-    default:
-      nonexhaustive(operator)
-  }
-}
-
-function participantIs<A extends Any>(
-  participant: Participant,
-  predicate: OperatorPredicate<A>,
-): OperatorPredicate<A> {
-  return (value) => {
-    if (!value.source || !value.target) {
-      return false
-    }
-    switch (participant) {
-      case 'source': {
-        return predicate(value.source)
-      }
-      case 'target': {
-        return predicate(value.target)
-      }
-    }
-  }
-}

package/src/types/project.ts

@@ -1,14 +0,0 @@
-import * as scalar from './scalar'
-
-/**
- * Configuration of the project, as read from the config file.
- * LikeC4 projects encapsulate models, and can import from each other
- */
-export interface LikeC4Project {
-  /**
-   * ID of the project, casted to {@link scalar.ProjectId}
-   */
-  readonly id: scalar.ProjectId
-
-  title?: string
-}

package/src/types/scalar.ts

@@ -1,162 +0,0 @@
-import { isString, isTruthy } from 'remeda'
-import type { Tagged } from 'type-fest'
-import { invariant } from '../utils'
-
-export type ProjectId<T = string> = Tagged<T, 'ProjectID'>
-export function ProjectId(name: string): ProjectId {
-  return name as unknown as ProjectId
-}
-
-export type MarkdownOrString = { txt: string; md?: never } | { md: string; txt?: never }
-
-/**
- * Converts a MarkdownOrString object or a plain string into a simple string representation.
- * This utility function handles different types of text content and normalizes them to a string format.
- *
- * @param value - The content to be flattened.
- *   Can be one of:
- *   - A plain string
- *   - A MarkdownOrString object with either txt or md property
- *   - undefined or null
- *
- * @returns The string content contained within the input value.
- *   - Returns the input directly if it's already a string
- *   - Returns the txt property if available in a MarkdownOrString object
- *   - Falls back to the md property if txt is not available
- *   - Returns null if:
- *     - The input is null or undefined
- *     - The resulting string value is empty, whitespace, or null
- *
- * @example
- * // String input
- * flattenMarkdownOrString("Hello world") // Returns: "Hello world"
- * flattenMarkdownOrString("   ") // Returns: null
- *
- * // MarkdownOrString with txt property
- * flattenMarkdownOrString({ txt: "Plain text" }) // Returns: "Plain text"
- * flattenMarkdownOrString({ txt: "   " }) // Returns: null
- *
- * // MarkdownOrString with md property
- * flattenMarkdownOrString({ md: "**Bold markdown**" }) // Returns: "**Bold markdown**"
- *
- * // Null input
- * flattenMarkdownOrString(null) // Returns: null
- */
-export function flattenMarkdownOrString(value: MarkdownOrString | string): string
-export function flattenMarkdownOrString(value: MarkdownOrString | string | undefined | null): string | null
-export function flattenMarkdownOrString(value: MarkdownOrString | string | undefined | null): string | null {
-  if (value === null || value === undefined) {
-    return null
-  }
-  const content = isString(value) ? value : value.txt ?? value.md
-  return isTruthy(content?.trim()) ? content : null
-}
-
-export type BuiltInIcon = 'none' | `${'aws' | 'azure' | 'gcp' | 'tech'}:${string}`
-export type Icon = Tagged<string, 'Icon'> | BuiltInIcon
-export type IconUrl = Icon
-
-/**
- * Full-qualified-name for model elements
- *
- * @param This - Fqn of the element (specific element)
- * @param All - The type of all known FQNs
- *
- * @example
- * ```ts
- * type ElementAFqn = Fqn<'a', 'a' | ' | 'b'>
- *
- * ```
- */
-export type Fqn<Id = string> = Tagged<Id, 'Fqn'>
-export function Fqn(name: string, parent?: Fqn | null): Fqn {
-  return (parent ? parent + '.' + name : name) as unknown as Fqn
-}
-
-export type ElementKind<Kinds = string> = Tagged<Kinds, 'ElementKind'>
-export const GroupElementKind = '@group' as ElementKind<'@group'>
-export type GroupElementKind = typeof GroupElementKind
-
-export function isGroupElementKind<V extends { kind?: any }>(v: V): v is V & { kind: GroupElementKind } {
-  return v.kind === GroupElementKind
-}
-
-/**
- * Full-qualified-name for deployment elements
- */
-export type DeploymentFqn<T = string> = Tagged<T, 'DeploymentFqn'>
-export function DeploymentFqn(name: string, parent?: DeploymentFqn | null): DeploymentFqn {
-  return (parent ? parent + '.' + name : name) as unknown as DeploymentFqn
-}
-
-export type DeploymentKind<Kinds = string> = Tagged<Kinds, 'DeploymentKind'>
-export type ViewId<Id = string> = Tagged<Id, 'ViewId'>
-export function ViewId(id: string): ViewId {
-  return id as any
-}
-
-export type AnyFqn<T = string> = DeploymentFqn<T> | Fqn<T>
-
-/**
- * @deprecated Use {@link RelationshipKind} instead
- */
-export type RelationKind<Kinds = string> = RelationshipKind<Kinds>
-
-export type RelationshipKind<Kinds = string> = Tagged<Kinds, 'RelationshipKind'>
-export type RelationId<Id = string> = Tagged<Id, 'RelationId'>
-export function RelationId(id: string): RelationId {
-  return id as any
-}
-
-export type Tag<T = string> = Tagged<T, 'Tag'>
-
-export type GlobalFqn<Id = string> = Tagged<Fqn<Id>, 'GlobalFqn'>
-export function GlobalFqn<A>(projectId: A | ProjectId<A>, name: string): GlobalFqn<A> {
-  invariant(isTruthy(projectId), 'Project ID must start with @')
-  return '@' + projectId + '.' + name as any
-}
-
-export function isGlobalFqn<A extends string>(fqn: A): fqn is GlobalFqn<A> {
-  return fqn.startsWith('@')
-}
-
-export function splitGlobalFqn<I extends string>(fqn: Fqn<I> | GlobalFqn<I>): [ProjectId | null, Fqn<I>] {
-  if (!fqn.startsWith('@')) {
-    return [null, fqn]
-  }
-  const firstDot = fqn.indexOf('.')
-  if (firstDot < 2) {
-    throw new Error('Invalid global FQN')
-  }
-  const projectId = fqn.slice(1, firstDot) as ProjectId<I>
-  const name = fqn.slice(firstDot + 1) as Fqn<I>
-  return [projectId, name]
-}
-
-export type NodeId = Tagged<string, 'NodeId' | 'Fqn' | 'DeploymentFqn'>
-export function NodeId(id: string): NodeId {
-  return id as any
-}
-export type EdgeId = Tagged<string, 'EdgeId'>
-export function EdgeId(id: string): EdgeId {
-  return id as any
-}
-
-export type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`
-export type StepEdgeId = Tagged<StepEdgeIdLiteral, 'EdgeId'>
-export function stepEdgeId(step: number, parallelStep?: number): StepEdgeId {
-  const id = `step-${String(step).padStart(2, '0')}` as StepEdgeId
-  return parallelStep ? `${id}.${parallelStep}` as StepEdgeId : id
-}
-export const StepEdgeKind = '@step'
-
-export function isStepEdgeId(id: string): id is StepEdgeId {
-  return id.startsWith('step-')
-}
-
-export function extractStep(id: EdgeId): number {
-  if (!isStepEdgeId(id)) {
-    throw new Error(`Invalid step edge id: ${id}`)
-  }
-  return parseFloat(id.slice('step-'.length))
-}

package/src/types/styles.ts

@@ -1,122 +0,0 @@
-import type { Tagged, TupleToUnion } from 'type-fest'
-
-/**
- * For padding, margin, etc.
- */
-export type SpacingSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl'
-export type TextSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl'
-export type ShapeSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl'
-
-export const BorderStyles = ['solid', 'dashed', 'dotted', 'none'] as const
-
-export type BorderStyle = TupleToUnion<typeof BorderStyles>
-
-export const ElementShapes = [
-  'rectangle',
-  'person',
-  'browser',
-  'mobile',
-  'cylinder',
-  'storage',
-  'queue',
-] as const
-
-export type ElementShape = TupleToUnion<typeof ElementShapes>
-
-export type HexColor = `#${string}`
-
-export type ColorLiteral =
-  | HexColor
-  | `rgb(${number},${number},${number})`
-  | `rgba(${number},${number},${number},${number})`
-
-export type CustomColor<T = string> = Tagged<T, 'CustomColor'>
-
-export type CustomColorDefinitions = { [key: string]: ThemeColorValues }
-
-export type RelationshipLineType = 'dashed' | 'solid' | 'dotted'
-
-// reference: https://graphviz.org/docs/attr-types/arrowType/
-export type RelationshipArrowType =
-  | 'none'
-  | 'normal'
-  | 'onormal'
-  | 'dot'
-  | 'odot'
-  | 'diamond'
-  | 'odiamond'
-  | 'crow'
-  | 'open'
-  | 'vee'
-
-export const ThemeColors = [
-  'amber',
-  'blue',
-  'gray',
-  'slate',
-  'green',
-  'indigo',
-  'muted',
-  'primary',
-  'red',
-  'secondary',
-  'sky',
-] as const
-export type ThemeColor = typeof ThemeColors[number]
-
-/**
- * Backward compatibility alias
- * @deprecated Use {@link ThemeColor} instead
- */
-export type Color = ThemeColor | ColorLiteral
-
-export function isThemeColor(color: string): color is ThemeColor {
-  return ThemeColors.includes(color as ThemeColor)
-}
-
-export interface ElementThemeColorValues {
-  fill: ColorLiteral
-  stroke: ColorLiteral
-  // Main text (title, etc.)
-  hiContrast: ColorLiteral
-  // Secondary text (description, etc.)
-  loContrast: ColorLiteral
-}
-
-export type ElementThemeColors = {
-  [key in ThemeColor]: ElementThemeColorValues
-}
-
-export interface RelationshipThemeColorValues {
-  lineColor: ColorLiteral
-  labelBgColor: ColorLiteral
-  labelColor: ColorLiteral
-}
-
-export interface ThemeColorValues {
-  elements: ElementThemeColorValues
-  relationships: RelationshipThemeColorValues
-}
-
-export type RelationshipThemeColors = {
-  [key in ThemeColor]: RelationshipThemeColorValues
-}
-
-export interface LikeC4Theme {
-  font: 'Arial'
-  shadow: ColorLiteral
-  relationships: RelationshipThemeColors
-  elements: ElementThemeColors
-  sizes: {
-    [key in ShapeSize]: {
-      width: number
-      height: number
-    }
-  }
-  spacing: {
-    [key in SpacingSize]: number
-  }
-  textSizes: {
-    [key in TextSize]: number
-  }
-}

package/src/types/view-changes.ts

@@ -1,32 +0,0 @@
-import type { NonEmptyArray } from './_common'
-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 {
-    op: 'change-element-style'
-    style: {
-      border?: BorderStyle
-      opacity?: number
-      shape?: ElementShape
-      color?: ThemeColor
-    }
-    targets: NonEmptyArray<scalar.Fqn | scalar.DeploymentFqn>
-  }
-
-  export interface SaveManualLayout {
-    op: 'save-manual-layout'
-    layout: ViewManualLayout
-  }
-
-  export interface ChangeAutoLayout {
-    op: 'change-autolayout'
-    layout: {
-      direction: AutoLayoutDirection
-      nodeSep?: number | null
-      rankSep?: number | null
-    }
-  }
-}
-export type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout

package/src/types/view-common.ts

@@ -1,157 +0,0 @@
-import type * as aux from './_aux'
-import type { AnyAux } from './_aux'
-import type { NonEmptyArray } from './_common'
-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: scalar.MarkdownOrString | 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
-}