@likec4/core 1.27.3 → 1.28.1

package/dist/shared/core.30yYKXcZ.d.mts

@@ -1,186 +0,0 @@
-import { LiteralUnion, Tagged, Simplify, UnionToIntersection, TupleToUnion } from 'type-fest';
-
-declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
-type ThemeColor = typeof ThemeColors[number];
-type HexColorLiteral = `#${string}`;
-type ColorLiteral = HexColorLiteral;
-type Color = LiteralUnion<ThemeColor, string>;
-type ShapeSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-/**
- * For padding, margin, etc.
- */
-type SpacingSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-type TextSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-declare function isThemeColor(color: Color): color is ThemeColor;
-interface ElementThemeColorValues {
-    fill: ColorLiteral;
-    stroke: ColorLiteral;
-    hiContrast: ColorLiteral;
-    loContrast: ColorLiteral;
-}
-type ElementThemeColors = {
-    [key in ThemeColor]: ElementThemeColorValues;
-};
-interface RelationshipThemeColorValues {
-    lineColor: ColorLiteral;
-    labelBgColor: ColorLiteral;
-    labelColor: ColorLiteral;
-}
-interface ThemeColorValues {
-    elements: ElementThemeColorValues;
-    relationships: RelationshipThemeColorValues;
-}
-type RelationshipThemeColors = {
-    [key in ThemeColor]: RelationshipThemeColorValues;
-};
-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;
-    };
-}
-
-type ProjectId = Tagged<string, 'ProjectID'>;
-type NonEmptyArray<T> = [T, ...T[]];
-type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
-type IconUrl = Tagged<string, 'IconUrl'> | 'none';
-type CustomColor = string;
-type Point = readonly [x: number, y: number];
-interface XYPoint {
-    x: number;
-    y: number;
-}
-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
- *   type Variant1 = {
- *     a: string
- *   }
- *   type Variant2 = {
- *     b: number
- *   }
- *
- *   type Variants = ExclusiveUnion<{
- *     Variant1: Variant1,
- *     Variant2: Variant2
- *   }>
- *
- *   Fail here
- *   const variant1: Variants = {
- *      a: 'one',
- *      b: 1
- *   }
- */
-type ExclusiveUnion<Expressions> = Expressions extends object ? {
-    [Name in keyof Expressions]: Simplify<Omit<AllNever<Expressions>, keyof Expressions[Name]> & Expressions[Name]>;
-}[keyof Expressions] : Expressions;
-/**
- * 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!
- */
-type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
-type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>;
-type Predicate<T> = (x: T) => boolean;
-
-type Fqn<Id extends string = string> = Tagged<Id, 'Fqn'>;
-declare function AsFqn(name: string, parent?: Fqn | null): Fqn;
-declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
-type BorderStyle = TupleToUnion<typeof BorderStyles>;
-type ElementKind<Kinds extends string = string> = Tagged<Kinds, 'ElementKind'>;
-declare namespace ElementKind {
-    const Group: ElementKind;
-}
-declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
-type ElementShape = TupleToUnion<typeof ElementShapes>;
-declare const DefaultThemeColor: ThemeColor;
-declare const DefaultElementShape: ElementShape;
-declare const DefaultShapeSize: ShapeSize;
-declare const DefaultPaddingSize: SpacingSize;
-declare const DefaultTextSize: TextSize;
-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 Tag<Tags extends string = string> = Tagged<Tags, 'Tag'>;
-interface TagSpec {
-    readonly id: Tag;
-    readonly style: ElementStyle;
-}
-interface Link {
-    readonly title?: string;
-    readonly url: string;
-    readonly relative?: string;
-}
-interface TypedElement<Ids extends string, Kinds extends string, Tags extends string, MetadataKeys extends string = never> {
-    readonly id: Fqn<Ids>;
-    readonly kind: ElementKind<Kinds>;
-    readonly title: string;
-    readonly description: string | null;
-    readonly technology: string | null;
-    readonly tags: NonEmptyArray<Tag<Tags>> | null;
-    readonly links: NonEmptyArray<Link> | null;
-    readonly icon?: IconUrl;
-    readonly shape?: ElementShape;
-    readonly color?: Color;
-    readonly style?: ElementStyle;
-    readonly notation?: string;
-    readonly metadata?: Record<MetadataKeys, string>;
-}
-interface Element extends TypedElement<string, string, string, string> {
-}
-interface ElementKindSpecificationStyle {
-    shape?: ElementShape;
-    icon?: IconUrl;
-    color?: Color;
-    border?: BorderStyle;
-    opacity?: number;
-    size?: ShapeSize;
-    padding?: SpacingSize;
-    textSize?: TextSize;
-}
-interface ElementKindSpecification {
-    readonly technology?: string;
-    readonly notation?: string;
-    readonly style: ElementKindSpecificationStyle;
-}
-
-export { AsFqn as A, BorderStyles as B, type CustomColor as C, DefaultElementShape as D, type ExclusiveUnion as E, type Fqn as F, type ElementThemeColorValues as G, type HexColorLiteral as H, type IconUrl as I, type RelationshipThemeColorValues as J, type KeysOf as K, type LikeC4Theme as L, type SpacingSize as M, type NonEmptyArray as N, type TextSize as O, type Point as P, type ThemeColor as Q, type RelationshipThemeColors as R, type ShapeSize as S, type ThemeColorValues as T, type XYPoint as X, type IteratorLike as a, type NonEmptyReadonlyArray as b, type NTuple as c, type Predicate as d, type ProjectId as e, DefaultPaddingSize as f, DefaultShapeSize as g, DefaultTextSize as h, DefaultThemeColor as i, ElementKind as j, ElementShapes as k, type BorderStyle as l, type Element as m, type ElementKindSpecification as n, type ElementKindSpecificationStyle as o, type ElementShape as p, type ElementStyle as q, type Link as r, type Tag as s, type TagSpec as t, type TypedElement as u, isThemeColor as v, ThemeColors as w, type Color as x, type ColorLiteral as y, type ElementThemeColors as z };

package/src/types/expression.ts

@@ -1,207 +0,0 @@
-import type { IconUrl } from './_common'
-import type { BorderStyle, ElementKind, ElementShape, Fqn, Tag } from './element'
-import type { WhereOperator } from './operators'
-import type { RelationshipArrowType, RelationshipLineType } from './relation'
-import type { Color, ShapeSize } from './theme'
-import type { ViewId } from './view'
-
-interface BaseExpr {
-  where?: never
-  element?: never
-  custom?: never
-  expanded?: never
-  elementKind?: never
-  elementTag?: never
-  isEqual?: never
-  isChildren?: never
-  isDescendants?: never
-  wildcard?: never
-  source?: never
-  target?: never
-  inout?: never
-  incoming?: never
-  outgoing?: never
-  customRelation?: never
-}
-
-export interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isChildren' | 'isDescendants'> {
-  element: Fqn
-  isChildren?: boolean
-  isDescendants?: boolean
-}
-export function isElementRef(expr: Expression): expr is ElementRefExpr {
-  return 'element' in expr
-}
-
-export interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
-  expanded: Fqn
-}
-export function isExpandedElementExpr(expr: Expression): expr is ExpandedElementExpr {
-  return 'expanded' in expr
-}
-
-export interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
-  custom: {
-    expr: ElementExpression | ElementWhereExpr
-    title?: string
-    description?: string
-    technology?: string
-    notation?: string
-    shape?: ElementShape
-    color?: Color
-    icon?: IconUrl
-    border?: BorderStyle
-    opacity?: number
-    navigateTo?: ViewId
-    multiple?: boolean
-    size?: ShapeSize
-    padding?: ShapeSize
-    textSize?: ShapeSize
-  }
-}
-
-export function isCustomElement(expr: Expression): expr is CustomElementExpr {
-  return 'custom' in expr && (isElement(expr.custom.expr) || isElementWhere(expr.custom.expr))
-}
-
-export interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
-  wildcard: true
-}
-export function isWildcard(expr: Expression): expr is WildcardExpr {
-  return 'wildcard' in expr
-}
-export interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
-  elementKind: ElementKind
-  isEqual: boolean
-}
-export function isElementKindExpr(expr: Expression): expr is ElementKindExpr {
-  return 'elementKind' in expr && 'isEqual' in expr
-}
-
-export interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
-  elementTag: Tag
-  isEqual: boolean
-}
-export function isElementTagExpr(expr: Expression): expr is ElementTagExpr {
-  return 'elementTag' in expr && 'isEqual' in expr
-}
-
-export type NonWilcard =
-  | ElementRefExpr
-  | ElementKindExpr
-  | ElementTagExpr
-  | ExpandedElementExpr
-
-export type ElementExpression =
-  | NonWilcard
-  | WildcardExpr
-
-export function isElement(expr: Expression): expr is ElementExpression {
-  return isElementRef(expr)
-    || isWildcard(expr)
-    || isElementKindExpr(expr)
-    || isElementTagExpr(expr)
-    || isExpandedElementExpr(expr)
-}
-
-export interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
-  where: {
-    expr: ElementExpression
-    condition: WhereOperator<string, string>
-  }
-}
-export function isElementWhere(expr: Expression): expr is ElementWhereExpr {
-  return 'where' in expr && isElement(expr.where.expr)
-}
-
-export type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr
-export function isElementPredicateExpr(expr: Expression): expr is ElementPredicateExpression {
-  return isElement(expr) || isElementWhere(expr) || isCustomElement(expr)
-}
-
-export interface DirectRelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
-  source: ElementExpression
-  target: ElementExpression
-  isBidirectional?: boolean
-}
-export function isRelation(expr: Expression): expr is DirectRelationExpr {
-  return 'source' in expr && 'target' in expr
-}
-
-export interface InOutExpr extends Omit<BaseExpr, 'inout'> {
-  inout: ElementExpression
-}
-export function isInOut(expr: Expression): expr is InOutExpr {
-  return 'inout' in expr
-}
-
-export interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
-  incoming: ElementExpression
-}
-export function isIncoming(expr: Expression): expr is IncomingExpr {
-  return 'incoming' in expr
-}
-export interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
-  outgoing: ElementExpression
-}
-export function isOutgoing(expr: Expression): expr is OutgoingExpr {
-  return 'outgoing' in expr
-}
-
-export type RelationExpression = DirectRelationExpr | InOutExpr | IncomingExpr | OutgoingExpr
-
-export function isRelationExpression(expr: Expression): expr is RelationExpression {
-  return isRelation(expr) || isInOut(expr) || isIncoming(expr) || isOutgoing(expr)
-}
-
-export interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
-  where: {
-    expr: RelationExpression
-    condition: WhereOperator<string, string>
-  }
-}
-export function isRelationWhere(expr: Expression): expr is RelationWhereExpr {
-  return 'where' in expr && isRelationExpression(expr.where.expr)
-}
-
-export interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
-  customRelation: {
-    relation: RelationExpression | RelationWhereExpr
-    title?: string
-    description?: string
-    technology?: string
-    notation?: string
-    // Link to dynamic view
-    navigateTo?: ViewId
-    // Notes for walkthrough
-    notes?: string
-    color?: Color
-    line?: RelationshipLineType
-    head?: RelationshipArrowType
-    tail?: RelationshipArrowType
-  }
-}
-export function isCustomRelationExpr(expr: Expression): expr is CustomRelationExpr {
-  return 'customRelation' in expr
-}
-
-export type RelationPredicateExpression = RelationExpression | RelationWhereExpr | CustomRelationExpr
-
-export function isRelationPredicateExpr(expr: Expression): expr is RelationPredicateExpression {
-  return isRelationExpression(expr) || isRelationWhere(expr) || isCustomRelationExpr(expr)
-}
-
-export type Expression = ElementPredicateExpression | RelationPredicateExpression
-
-// export const Expr = {
-//   isElementRef,
-//   isWildcard,
-//   isElementKindExpr,
-//   isElementTagExpr,
-//   isElement,
-//   isRelation,
-//   isInOut,
-//   isIncoming,
-//   isOutgoing,
-//   isAnyRelation,
-// }