@likec4/core 1.41.0 → 1.42.0

package/src/types/RichText.ts

@@ -1,205 +0,0 @@
-import { markdownToHtml, markdownToText, memoizeProp, nonexhaustive } from '../utils'
-import type { MarkdownOrString } from './scalar'
-
-const symb_text = Symbol.for('text')
-const symb_html = Symbol.for('html')
-
-const emptyTxt = ''
-
-export interface RichTextEmpty {
-  readonly isEmpty: true
-  readonly isMarkdown: false
-  readonly nonEmpty: false
-  readonly $source: null
-  readonly text: null
-  readonly md: null
-  readonly html: null
-  equals(other: unknown): boolean
-}
-
-export interface RichTextNonEmpty {
-  readonly isEmpty: false
-  readonly nonEmpty: true
-  readonly isMarkdown: boolean
-  readonly $source: MarkdownOrString
-  readonly text: string
-  readonly md: string
-  readonly html: string
-  equals(other: unknown): boolean
-}
-
-export type RichTextOrEmpty = RichTextNonEmpty | RichTextEmpty
-
-/**
- * RichText is a class that represents a potentially markdown string.
- * It can be either a plain text or a markdown.
- * It is used to represent the content of a node or a link.
- */
-export class RichText {
-  private static _cache = new WeakMap<MarkdownOrString, RichTextOrEmpty>()
-
-  /**
-   * Creates and memoizes a RichText instance.
-   * @see ElementModel.description
-   * @example
-   *
-   *  get description(): RichTextOrEmpty {
-   *    return RichText.memoize(this, this.$element.description)
-   *  }
-   */
-  static memoize(obj: object, tag: symbol | string, source: MarkdownOrString | null | undefined): RichTextOrEmpty {
-    return memoizeProp(obj, tag, () => RichText.from(source))
-  }
-
-  /**
-   * Creates a RichText instance from a source.
-   */
-  static from(source: RichTextOrEmpty | MarkdownOrString | string | null | undefined): RichTextOrEmpty {
-    if (source === null || source === undefined || source === RichText.EMPTY) {
-      return RichText.EMPTY
-    }
-    if (source instanceof RichText) {
-      return source as RichTextOrEmpty
-    }
-    if (typeof source === 'string') {
-      if (source.trim() === emptyTxt) {
-        return RichText.EMPTY
-      }
-      return new RichText({ txt: source }) as RichTextOrEmpty
-    }
-    if ('isEmpty' in source && source.isEmpty) {
-      return RichText.EMPTY
-    }
-    if ('md' in source && source.md.trim() === emptyTxt) {
-      return RichText.EMPTY
-    }
-    if ('txt' in source && source.txt.trim() === emptyTxt) {
-      return RichText.EMPTY
-    }
-    const _source = source as MarkdownOrString
-    const cached = RichText._cache.get(_source)
-    if (cached) {
-      return cached
-    }
-    const rt = new RichText(_source) as RichTextOrEmpty
-    RichText._cache.set(_source, rt)
-    return rt
-  }
-
-  /**
-   * This is a workaround for the fact that we need instance of RichText for `instanceof` checks
-   * It is invalid inheritance (returning `null` from getters), and we cast to @see RichTextEmpty
-   */
-  static EMPTY: RichTextEmpty = new class extends RichText {
-    public override readonly isEmpty: true = true
-    public override readonly nonEmpty: false = false
-    public override readonly isMarkdown: false = false
-    public override readonly $source: null = null
-    constructor() {
-      super({ txt: emptyTxt })
-    }
-
-    override get text(): any {
-      return null
-    }
-
-    override get md(): any {
-      return null
-    }
-
-    override get html(): any {
-      return null
-    }
-  }()
-
-  public readonly $source: Readonly<MarkdownOrString> | null
-
-  public readonly isEmpty: boolean
-  public readonly nonEmpty: boolean
-  public readonly isMarkdown: boolean
-
-  /**
-   * Private constructor to prevent direct instantiation.
-   * Use {@link RichText.from} or {@link RichText.memoize} instead.
-   */
-  private constructor(source: MarkdownOrString | string) {
-    this.isMarkdown = false
-    if (typeof source === 'string') {
-      this.$source = { txt: source }
-      this.isEmpty = source.trim() === emptyTxt
-    } else {
-      this.$source = source
-      this.isEmpty = true
-      if ('md' in source) {
-        this.isEmpty = source.md === emptyTxt
-        this.isMarkdown = true
-      } else {
-        this.isEmpty = source.txt === emptyTxt
-      }
-    }
-    this.nonEmpty = !this.isEmpty
-  }
-
-  /**
-   * Returns the text content of the rich text.
-   * If the source is a string, it returns the string.
-   * If the source is a markdown, it returns the markdown.
-   */
-  get text(): string {
-    if (this.isEmpty || this.$source === null) {
-      return emptyTxt
-    }
-    const source = this.$source
-    if ('txt' in source) {
-      return source.txt
-    }
-    return memoizeProp(this, symb_text, () => markdownToText(source.md!))
-  }
-
-  /**
-   * Returns the markdown content of the rich text.
-   * If the source is a string, it returns the string.
-   * If the source is a markdown, it returns the markdown.
-   */
-  get md(): string {
-    if (this.isEmpty || this.$source === null) {
-      return emptyTxt
-    }
-    const source = this.$source
-    if ('md' in source) {
-      return source.md
-    }
-    if ('txt' in source) {
-      return source.txt
-    }
-    nonexhaustive(source)
-  }
-
-  /**
-   * Returns the html content of the rich text.
-   * If the source is a string, it returns the string.
-   * If the source is a markdown, it returns the HTML.
-   */
-  get html(): string {
-    if (this.isEmpty || this.$source === null) {
-      return emptyTxt
-    }
-    const source = this.$source
-    if ('txt' in source) {
-      return source.txt
-    }
-    return memoizeProp(this, symb_html, () => markdownToHtml(source.md!))
-  }
-
-  equals(other: unknown): boolean {
-    if (this === other) return true
-    if (!(other instanceof RichText)) return false
-    if (this.isEmpty && other.isEmpty) return true
-    if (this.isEmpty !== other.isEmpty || this.isMarkdown !== other.isMarkdown) return false
-
-    if (this.isMarkdown) {
-      return this.$source?.md === other.$source?.md
-    }
-    return this.$source?.txt === other.$source?.txt
-  }
-}

package/src/types/_aux.ts

@@ -1,317 +0,0 @@
-import type { IfNever, IsLiteral, IsNever } from 'type-fest'
-import type { Coalesce, Link } from './_common'
-import type { ModelStage } from './const'
-import type * as scalar from './scalar'
-/**
- * Specification types (kinds, tags, metadata keys)
- *
- * @param ElementKind - Literal union of element kinds
- * @param DeploymentKind - Literal union of deployment kinds
- * @param RelationKind - Literal union of relationship kinds
- * @param Tag - Literal union of tags
- * @param MetadataKey - Literal union of metadata keys
- */
-export interface SpecAux<
-  ElementKind extends string,
-  DeploymentKind extends string,
-  RelationKind extends string,
-  Tag extends string,
-  MetadataKey extends string,
-> {
-  ElementKind: ElementKind
-  DeploymentKind: DeploymentKind
-  RelationKind: RelationKind
-  Tag: Tag
-  MetadataKey: MetadataKey
-}
-export type AnySpec = SpecAux<any, any, any, any, any>
-
-/**
- * Auxilary interface to keep inferred types
- *
- * @typeParam Stage - View stage
- * @typeParam Element - Literal union of FQNs of model elements
- * @typeParam Deployment - Literal union of FQNs of deployment elements
- * @typeParam View - Literal union of view identifiers
- * @typeParam Project - Project identifier type
- * @typeParam Spec - Specification types (kinds, tags, metadata keys)
- */
-export interface Aux<
-  Stage extends ModelStage,
-  Element extends string,
-  Deployment extends string,
-  View extends string,
-  Project extends string,
-  Spec extends SpecAux<string, string, string, string, string>,
-> {
-  Stage: Stage
-  ProjectId: Project
-  ElementId: Element
-  DeploymentId: Deployment
-
-  ViewId: View
-
-  ElementKind: Spec['ElementKind']
-  DeploymentKind: Spec['DeploymentKind']
-  RelationKind: Spec['RelationKind']
-  Tag: Spec['Tag']
-  MetadataKey: Spec['MetadataKey']
-}
-
-// export type AnyOnStage<Stage extends ModelStage> = Aux<Stage, any, any, any, any, SpecAux<any, any, any, any, any>>
-
-// export type AnyParsed = AnyOnStage<'parsed'>
-// export type AnyComputed = AnyOnStage<'computed'>
-// export type AnyLayouted = AnyOnStage<'layouted'>
-
-export type Any = Aux<any, any, any, any, any, SpecAux<any, any, any, any, any>>
-export type { Any as AnyAux }
-
-export type Never = Aux<never, never, never, never, never, SpecAux<never, never, never, never, never>>
-
-/**
- * Fallback when {@link Aux} can't be inferred.
- * By default assumes non parsed model
- */
-export type Unknown = Aux<
-  'layouted' | 'computed',
-  string,
-  string,
-  string,
-  string,
-  SpecAux<string, string, string, string, string>
->
-
-export type UnknownParsed = Aux<
-  'parsed',
-  string,
-  string,
-  string,
-  string,
-  SpecAux<string, string, string, string, string>
->
-
-export type UnknownComputed = Aux<
-  'computed',
-  string,
-  string,
-  string,
-  string,
-  SpecAux<string, string, string, string, string>
->
-export type UnknownLayouted = Aux<
-  'layouted',
-  string,
-  string,
-  string,
-  string,
-  SpecAux<string, string, string, string, string>
->
-
-/**
- * Reads stage from Aux
- */
-export type Stage<A> =
-  // dprint-ignore
-  A extends Aux<infer S, any, any, any, any, any>
-    ? IfNever<S, never, Coalesce<S, ModelStage>>
-    : never
-
-/**
- * Picks type based on stage from Aux
- */
-export type PickByStage<A extends Any, OnParsed, OnComputed, OnLayouted = OnComputed> = {
-  parsed: OnParsed
-  computed: OnComputed
-  layouted: OnLayouted
-}[A['Stage']]
-
-export type setStage<A, S extends ModelStage> =
-  // dprint-ignore
-  A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec>
-      ? Aux<S, E, D, V, P, Spec>
-      : never
-
-export type toParsed<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec>
-  ? Aux<'parsed', E, D, V, P, Spec>
-  : never
-
-export type toComputed<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec>
-  ? Aux<'computed', E, D, V, P, Spec>
-  : never
-
-export type toLayouted<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec>
-  ? Aux<'layouted', E, D, V, P, Spec>
-  : never
-
-/**
- * Project identifier from Aux
- */
-export type ProjectId<A> = A extends infer T extends Any ? Coalesce<T['ProjectId']> : never
-
-export type setProject<A, P extends string> =
-  // dprint-ignore
-  A extends Aux<infer S, infer E, infer D, infer V, any, infer Spec>
-      ? Aux<S, E, D, V, P, Spec>
-      : never
-
-/**
- * Element FQN from Aux as branded type
- */
-export type Fqn<A> = A extends infer T extends Any ? scalar.Fqn<ElementId<T>> : never
-
-/**
- * Element FQN from Aux as a literal union
- */
-export type ElementId<A> = A extends infer T extends Any ? Coalesce<T['ElementId']> : never
-
-/**
- * Deployment FQN from Aux as branded type
- */
-export type DeploymentFqn<A> = A extends infer T extends Any ? scalar.DeploymentFqn<DeploymentId<T>> : never
-
-/**
- * Deployment FQN from Aux as a literal union
- * @alias {@link DeploymentFqn}
- */
-export type DeploymentId<A> = A extends infer T extends Any ? Coalesce<T['DeploymentId']> : never
-
-/**
- * View identifier from Aux as a literal union
- */
-export type ViewId<A> = A extends infer T extends Any ? Coalesce<T['ViewId']> : never
-
-export type RelationId = scalar.RelationId
-export type NodeId = scalar.NodeId
-export type EdgeId = scalar.EdgeId
-
-/**
- * ElementKind from Aux as a literal union
- */
-export type ElementKind<A> = A extends infer T extends Any ? Coalesce<T['ElementKind']> : never
-
-/**
- * DeploymentKind from Aux as a literal union
- */
-export type DeploymentKind<A> = A extends infer T extends Any ? Coalesce<T['DeploymentKind']> : never
-
-/**
- * RelationKind from Aux as a literal union
- */
-export type RelationKind<A> = A extends infer T extends Any ? Coalesce<T['RelationKind']> : never
-
-/**
- * Tags from Aux as a literal union
- */
-export type Tag<A> = A extends infer T extends Any ? Coalesce<T['Tag']> : never
-
-/**
- * Array of tags from Aux
- */
-export type Tags<A extends Any> = readonly Tag<A>[]
-
-/**
- * Metadata key from Aux
- */
-export type MetadataKey<A> = A extends infer T extends Any ? Coalesce<T['MetadataKey']> : never
-
-/**
- * Metadata object from Aux
- */
-export type Metadata<A extends Any> =
-  // dprint-ignore
-  IsNever<A['MetadataKey']> extends true
-    ? never
-    : IsLiteral<A['MetadataKey']> extends true
-      ? {
-        [key in A['MetadataKey']]?: string
-      }
-      : Record<string, string>
-
-/**
- * All known kinds from Aux as a literal union.
- */
-export type AllKinds<A> = ElementKind<A> | DeploymentKind<A> | RelationKind<A>
-
-/**
- * Specification from Aux
- */
-export type Spec<A> = A extends Aux<any, any, any, any, any, infer S> ? S : never
-
-export type StrictProjectId<A> = A extends infer T extends Any ? scalar.ProjectId<ProjectId<T>> : never
-
-export type {
-  DeploymentFqn as StrictDeploymentFqn,
-  Fqn as StrictFqn,
-}
-
-export type StrictViewId<A> = A extends infer T extends Any ? scalar.ViewId<ViewId<T>> : never
-
-export type StrictTag<A> = A extends infer T extends Any ? scalar.Tag<Tag<T>> : never
-
-// dprint-ignore
-export type StrictElementKind<A> = A extends infer T extends Any ? scalar.ElementKind<ElementKind<T>> : never
-export type StrictDeploymentKind<A> = A extends infer T extends Any ? scalar.DeploymentKind<DeploymentKind<T>>
-  : never
-export type StrictRelationKind<A> = A extends infer T extends Any ? scalar.RelationshipKind<RelationKind<T>> : never
-
-export type WithDescriptionAndTech = {
-  // short summary (displayed in the diagram)
-  readonly summary?: scalar.MarkdownOrString | null
-  // long description (displayed in the details panel, or in the diagram if summary is not set)
-  readonly description?: scalar.MarkdownOrString | null
-  readonly technology?: string | null
-}
-
-/**
- * Returns summary if it is not null, otherwise returns description
- */
-export function preferSummary(a: WithDescriptionAndTech): scalar.MarkdownOrString | null | undefined {
-  return a.summary ?? a.description
-}
-
-/**
- * Returns description if it is not null, otherwise returns summary
- */
-export function preferDescription(a: WithDescriptionAndTech): scalar.MarkdownOrString | null | undefined {
-  return a.description ?? a.summary
-}
-
-export type WithTags<A extends Any> = {
-  readonly tags: Tags<A>
-}
-
-export type WithOptionalTags<A extends Any> = {
-  readonly tags?: Tags<A> | null
-}
-
-export type WithLinks = {
-  readonly links: readonly Link[]
-}
-
-export type WithOptionalLinks = {
-  readonly links?: readonly Link[] | null
-}
-
-export type WithMetadata<A extends Any> = {
-  readonly metadata?: Metadata<A>
-}
-
-export type WithNotation = {
-  readonly notation?: string | null
-}
-
-/**
- * @see {@link LiteralUnion} from type-fest (https://github.com/sindresorhus/type-fest/blob/main/source/literal-union.d.ts)
- */
-export type OrString = string & Record<never, never>
-
-export type LooseElementId<A extends Any> = Coalesce<A['ElementId']> | OrString
-export type LooseDeploymentId<A extends Any> = Coalesce<A['DeploymentId']> | OrString
-export type LooseViewId<A extends Any> = Coalesce<A['ViewId']> | OrString
-export type LooseTag<A extends Any> = Coalesce<A['Tag']> | OrString
-export type LooseTags<A extends Any> = readonly (Coalesce<A['Tag']> | OrString)[]
-
-export type LooseElementKind<A extends Any> = Coalesce<A['ElementKind']> | OrString
-export type LooseDeploymentKind<A extends Any> = Coalesce<A['DeploymentKind']> | OrString
-export type LooseRelationKind<A extends Any> = Coalesce<A['RelationKind']> | OrString

package/src/types/_common.ts

@@ -1,102 +0,0 @@
-import { omitBy } from 'remeda'
-import type {
-  Exact,
-  IsAny,
-  KeysOfUnion,
-  Simplify,
-  UnionToIntersection,
-} from 'type-fest'
-
-export type NonEmptyArray<T> = [T, ...T[]]
-
-export type NonEmptyReadonlyArray<T> = readonly [T, ...T[]]
-
-export type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly []
-
-export type ReorderedArray<T extends IterableContainer> = {
-  -readonly [P in keyof T]: T[number]
-}
-
-// dprint-ignore
-export type KeysOf<T> = keyof T extends infer K extends string ? K : never
-
-type AllNever<Expressions> = UnionToIntersection<
-  {
-    [Name in keyof Expressions]: {
-      -readonly [Key in keyof Expressions[Name]]?: never
-    }
-  }[keyof Expressions]
->
-
-/**
- * @example
- * ```ts
- *   type Variant1 = {
- *     a: string
- *   }
- *   type Variant2 = {
- *     b: number
- *   }
- *
- *   type Variants = ExclusiveUnion<{
- *     Variant1: Variant1,
- *     Variant2: Variant2
- *   }>
- *
- *   // Fail here
- *   const variant1: Variants = {
- *      a: 'one',
- *      b: 1
- *   }
- * ```
- */
-export type ExclusiveUnion<Expressions, All = AllNever<Expressions>> = Expressions extends object ? {
-    [Name in keyof Expressions]: Simplify<Omit<All, keyof Expressions[Name]> & Expressions[Name]>
-  }[keyof Expressions]
-  : never
-
-/**
- * Copy from https://github.com/remeda/remeda/blob/main/src/internal/types/NTuple.ts
- * An array with *exactly* N elements in it.
- *
- * Only literal N values are supported. For very large N the type might result
- * in a recurse depth error. For negative N the type would result in an infinite
- * recursion. None of these have protections because this is an internal type!
- */
-export type NTuple<
-  T,
-  N extends number,
-  Result extends Array<unknown> = [],
-> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>
-
-export type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn, unknown>
-
-export type Predicate<T> = (x: T) => boolean
-
-export interface Link {
-  title?: string
-  // Value from Likec4 DSL
-  url: string
-  // Relative to workspace root (if url is relative),
-  relative?: string
-}
-
-/**
- * Coalesce `V` to a string if it is `any`
- */
-export type Coalesce<V extends string, OrIfAny = string> = IsAny<V> extends true ? OrIfAny : V
-
-type ExactObject<T, InputType = unknown> =
-  & {
-    [KeyType in keyof T]: undefined extends T[KeyType] ? T[KeyType] | undefined : T[KeyType]
-  }
-  & Record<Exclude<keyof InputType, KeysOfUnion<T>>, never>
-
-/**
- * Allows only exact properties of `U` to be present in `T` and omits undefined values
- *
- * See {@link Exact} for more details (this version is non-deep)
- */
-export function omitUndefined<Expected, T extends ExactObject<Expected, T>>(a: T): Expected {
-  return omitBy(a, v => v === undefined) as Expected
-}

package/src/types/const.ts

@@ -1,34 +0,0 @@
-/**
- * Determines the stage of the model:
- * 1. `parsed` - parsed from DSL or returned from Builder
- * 2. `computed` - views are computed
- * 3. `layouted` - views are layouted
- *
- * @internal
- */
-export type ModelStage = 'parsed' | 'computed' | 'layouted'
-
-export type ExtractOnStage<T, S extends ModelStage> = Extract<T, { [_stage]: S }>
-
-export function isOnStage<T extends { [_stage]: ModelStage }, S extends ModelStage>(
-  value: T,
-  stage: S,
-): value is ExtractOnStage<T, S> {
-  return value[_stage] === stage
-}
-
-/**
- * Property name to store the stage of the model
- *
- * @internal
- */
-export const _stage = '_stage'
-export type _stage = typeof _stage
-
-/**
- * Property name to store type information, used to identify the type of the view
- *
- * @internal
- */
-export const _type = '_type'
-export type _type = typeof _type