@likec4/core 1.41.0 → 1.42.0

package/src/types/view-computed.ts

@@ -1,126 +0,0 @@
-import type * as aux from './_aux'
-import type { AnyAux } 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'
-import type { DynamicViewDisplayVariant } from './view-parsed.dynamic'
-
-// dprint-ignore
-export interface ComputedNode<A extends AnyAux = AnyAux>
-  extends
-    aux.WithTags<A>,
-    aux.WithOptionalLinks
-{  
-  id: scalar.NodeId
-  kind: aux.ElementKind<A> | aux.DeploymentKind<A> | '@group'
-  parent: scalar.NodeId | null
-  /**
-   * Reference to model element
-   */
-  modelRef?: aux.Fqn<A>
-  /**
-   * Reference to deployment element
-   */
-  deploymentRef?: aux.DeploymentFqn<A>
-  title: string
-  /**
-   * Description of the node
-   * either summary or description
-   */
-  description?: scalar.MarkdownOrString | null
-  technology?: string | null
-  children: scalar.NodeId[]
-  inEdges: scalar.EdgeId[]
-  outEdges: scalar.EdgeId[]
-  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 | null
-  /**
-   * If this node was customized in the view
-   */
-  isCustomized?: boolean
-  notation?: string | null
-}
-
-export interface ComputedEdge<A extends AnyAux = AnyAux> extends aux.WithOptionalTags<A> {
-  id: scalar.EdgeId
-  parent: scalar.NodeId | null
-  source: scalar.NodeId
-  target: scalar.NodeId
-  label: string | null
-  description?: scalar.MarkdownOrString | null
-  technology?: string | null
-  relations: scalar.RelationId[]
-  kind?: aux.RelationKind<A> | typeof scalar.StepEdgeKind
-  notation?: string
-  // Notes for walkthrough
-  notes?: scalar.MarkdownOrString
-  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 AnyAux> 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 AnyAux = AnyAux> extends BaseComputedViewProperties<A> {
-  readonly [_type]: 'element'
-  readonly viewOf?: aux.StrictFqn<A>
-  readonly extends?: aux.StrictViewId<A>
-}
-
-export interface ComputedDeploymentView<A extends AnyAux = AnyAux> extends BaseComputedViewProperties<A> {
-  readonly [_type]: 'deployment'
-}
-
-export interface ComputedDynamicView<A extends AnyAux = AnyAux> extends BaseComputedViewProperties<A> {
-  readonly [_type]: 'dynamic'
-  /**
-   * How to display the dynamic view
-   * - `diagram`: display as a regular likec4 view
-   * - `sequence`: display as a sequence diagram
-   */
-  readonly variant: DynamicViewDisplayVariant
-}

package/src/types/view-layouted.ts

@@ -1,94 +0,0 @@
-import type * as aux from './_aux'
-import type { AnyAux } from './_aux'
-import type { NonEmptyArray } from './_common'
-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'
-import type { DynamicViewDisplayVariant } from './view-parsed.dynamic'
-
-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
-  // label: scalar.HtmlOrString | null
-  // description?: scalar.HtmlOrString | null
-  // technology?: scalar.HtmlOrString | null
-  // notation?: scalar.HtmlOrString | null
-  // notes?: scalar.HtmlOrString | null
-}
-
-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'
-  /**
-   * How to display the dynamic view
-   * - `diagram`: display as a regular likec4 view
-   * - `sequence`: display as a sequence diagram
-   */
-  readonly variant: DynamicViewDisplayVariant
-}

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

@@ -1,39 +0,0 @@
-import type { AnyAux, Unknown } from './_aux'
-import type { ExclusiveUnion } from './_common'
-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

@@ -1,89 +0,0 @@
-import { isArray } from 'remeda'
-import type { MergeExclusive, Simplify } from 'type-fest'
-import type * as aux from './_aux'
-import type { AnyAux } from './_aux'
-import type { ExclusiveUnion } from './_common'
-import type { _type } from './const'
-import type { ModelFqnExpr } from './expression-model'
-import { type MarkdownOrString, 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?: MarkdownOrString
-  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 type DynamicViewDisplayVariant = 'diagram' | 'sequence'
-
-export interface ParsedDynamicView<A extends AnyAux = AnyAux> extends BaseParsedViewProperties<A> {
-  [_type]: 'dynamic'
-  /**
-   * How to display the dynamic view
-   * - `diagram`: display as a regular likec4 view
-   * - `sequence`: display as a sequence diagram
-   *
-   * @default 'diagram'
-   */
-  readonly variant?: DynamicViewDisplayVariant
-
-  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

@@ -1,65 +0,0 @@
-import type * as aux from './_aux'
-import type { AnyAux } from './_aux'
-import type { ExclusiveUnion } from './_common'
-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>
-}

package/src/types/view.ts

@@ -1,113 +0,0 @@
-import { isTruthy } from 'remeda'
-import type { Any } from './_aux'
-import * as aux from './_aux'
-import type { _stage, _type, ExtractOnStage, ModelStage } from './const'
-import type { ViewType } from './view-common'
-import type {
-  ComputedDeploymentView,
-  ComputedDynamicView,
-  ComputedElementView,
-} from './view-computed'
-import type {
-  LayoutedDeploymentView,
-  LayoutedDynamicView,
-  LayoutedElementView,
-} from './view-layouted'
-import type { ParsedDeploymentView } from './view-parsed.deployment'
-import type { ParsedDynamicView } from './view-parsed.dynamic'
-import type { ParsedElementView } from './view-parsed.element'
-
-export type ParsedView<A extends Any = Any> =
-  | ParsedElementView<A>
-  | ParsedDeploymentView<A>
-  | ParsedDynamicView<A>
-
-/**
- * Should be `ParsedView` but keep it for backward compatibility
- * @deprecated use `ParsedView`
- */
-export type { ParsedView as LikeC4View }
-
-export type ComputedView<A extends Any = Any> =
-  | ComputedElementView<A>
-  | ComputedDeploymentView<A>
-  | ComputedDynamicView<A>
-
-export type LayoutedView<A extends Any = Any> =
-  | LayoutedElementView<A>
-  | LayoutedDeploymentView<A>
-  | LayoutedDynamicView<A>
-
-export type ProcessedView<A extends Any = Any> =
-  | ComputedView<A>
-  | LayoutedView<A>
-
-/**
- * @alias DiagramView
- */
-export type { LayoutedView as DiagramView }
-export type AnyView<A extends Any = Any> =
-  | ParsedElementView<A>
-  | ParsedDeploymentView<A>
-  | ParsedDynamicView<A>
-  | ComputedElementView<A>
-  | ComputedDeploymentView<A>
-  | ComputedDynamicView<A>
-  | LayoutedElementView<A>
-  | LayoutedDeploymentView<A>
-  | LayoutedDynamicView<A>
-
-export type ViewOnStage<V extends AnyView<Any>, T extends ModelStage> = Extract<V, { [_stage]: T }>
-export type ViewWithType<V extends AnyView<Any>, T extends ViewType> = Extract<V, { [_type]: T }>
-
-export type ViewRule<A extends Any = Any> = ParsedView<A>['rules'][number]
-export type ViewRulePredicate<A extends Any = Any> = Extract<
-  ViewRule<A>,
-  { include: any[] } | { exclude: any[] }
->
-
-export function isViewRulePredicate<V extends ViewRule<any>>(rule: V): rule is Extract<
-  V,
-  { include: any[] } | { exclude: any[] }
-> {
-  return 'include' in rule || 'exclude' in rule
-}
-
-export function isViewRuleStyle<V extends ViewRule<any>>(
-  rule: V,
-): rule is Extract<V, { targets: any[]; style: {} }> {
-  return 'targets' in rule && 'style' in rule
-}
-
-export function isComputedView<V extends AnyView<any>>(view: V): view is ExtractOnStage<V, 'computed'> {
-  return view._stage === 'computed'
-}
-
-export function isDiagramView<V extends AnyView<any>>(view: V): view is ExtractOnStage<V, 'layouted'> {
-  return view._stage === 'layouted'
-}
-export { isDiagramView as isLayoutedView }
-
-export function isElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'> {
-  return view._type === 'element'
-}
-
-export function isScopedElementView<V extends AnyView<any>>(
-  view: V,
-): view is ViewWithType<V, 'element'> & { viewOf: aux.StrictFqn<Any> } {
-  return isElementView(view) && isTruthy(view.viewOf)
-}
-
-export function isExtendsElementView<V extends AnyView<any>>(
-  view: V,
-): view is ViewWithType<V, 'element'> & { extends: aux.StrictViewId<Any> } {
-  return isElementView(view) && isTruthy(view.extends)
-}
-
-export function isDeploymentView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'deployment'> {
-  return view._type === 'deployment'
-}
-
-export function isDynamicView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'dynamic'> {
-  return view._type === 'dynamic'
-}

package/src/utils/common-head.ts

@@ -1,22 +0,0 @@
-import { map, pipe, takeWhile, zip } from 'remeda'
-
-/**
- * Common head of two arrays
- *
- * @param equals - Equality function, defaults to `Object.is`
- */
-export function commonHead<T>(
-  sources: ReadonlyArray<T>,
-  targets: ReadonlyArray<T>,
-  equals?: (a: T, b: T) => boolean
-): T[] {
-  if (sources.length === 0 || targets.length === 0) {
-    return []
-  }
-  equals ??= Object.is
-  return pipe(
-    zip(sources, targets),
-    takeWhile(([source, target]) => equals(source, target)),
-    map(([source, _]) => source)
-  )
-}

package/src/utils/compare-natural.ts

@@ -1,60 +0,0 @@
-import compare from 'natural-compare-lite'
-import { isString } from 'remeda'
-
-export function compareNatural(a: string | undefined, b: string | undefined): -1 | 0 | 1 {
-  if (a === b) return 0
-  if (isString(a)) {
-    if (isString(b)) {
-      return compare(a, b)
-    }
-    return 1
-  }
-  return isString(b) ? -1 : 0
-}
-
-/**
- * Compares two strings lexicographically first, then hierarchically based on their depth.\
- * From parent nodes to leaves
- *
- * @example
- * const lines = [
- *   'b.c',
- *   'b',
- *   'a.b.c',
- * ]
- * lines.sort(compareNaturalHierarchically('.'))
- * // [
- * //   'a.b.c',
- * //   'b',
- * //   'b.c',
- * // ]
- */
-export function compareNaturalHierarchically(
-  separator = '.',
-  deepestFirst = false,
-): (a: string | undefined, b: string | undefined) => number {
-  return (a, b) => {
-    if (a === b) return 0
-    if (!a) return -1
-    if (!b) return 1
-    const aParts = a.split(separator)
-    const bParts = b.split(separator)
-
-    // Find the minimum length to avoid out-of-bounds access
-    const minLength = Math.min(aParts.length, bParts.length)
-
-    // Compare segments until we find a difference
-    for (let i = 0; i < minLength; i++) {
-      const aPart = aParts[i]!
-      const bPart = bParts[i]!
-      const comparison = compare(aPart, bPart)
-      if (comparison !== 0) {
-        return comparison
-      }
-    }
-
-    // If all common segments are equal, shorter paths come first (if deepestFirst is false)
-    const diff = aParts.length - bParts.length
-    return deepestFirst ? -1 * diff : diff
-  }
-}

package/src/utils/const.ts

@@ -1 +0,0 @@
-export const customInspectSymbol = Symbol.for('nodejs.util.inspect.custom')