@likec4/core 0.37.1 → 0.41.0

package/dist/esm/colors/element.js

@@ -0,0 +1,82 @@
+const blue = {
+  fill: "#3b82f6",
+  stroke: "#2563eb",
+  hiContrast: "#eff6ff",
+  loContrast: "#bfdbfe"
+};
+const sky = {
+  fill: "#0284c7",
+  stroke: "#0369a1",
+  hiContrast: "#f0f9ff",
+  loContrast: "#e0f2fe"
+};
+const slate = {
+  fill: "#64748b",
+  stroke: "#475569",
+  hiContrast: "#f8fafc",
+  loContrast: "#e2e8f0"
+};
+export const ElementColors = {
+  primary: blue,
+  blue,
+  secondary: sky,
+  sky,
+  muted: slate,
+  slate,
+  gray: {
+    // fill: colors.neutral[500],
+    // stroke: colors.neutral[600],
+    // hiContrast: colors.neutral[50],
+    // loContrast: colors.neutral[200],
+    fill: "#737373",
+    stroke: "#525252",
+    hiContrast: "#fafafa",
+    loContrast: "#e5e5e5"
+  },
+  red: {
+    // fill: colors.red[500],
+    // stroke: colors.red[600],
+    // hiContrast: colors.red[50],
+    // loContrast: colors.red[200],
+    fill: "#b54548",
+    stroke: "#8c333a",
+    // hiContrast: '#fef2f2',
+    // loContrast: '#fecaca',
+    // hiContrast: '#191111', // colors.gray[900],
+    // loContrast: '#3b1219' // colors.gray[800],
+    hiContrast: "#f8fafc",
+    // hiContrast: '#f8fafc',
+    // loContrast: '#fdd8d8' // radix black red 12
+    loContrast: "#F9C6C6"
+  },
+  green: {
+    fill: "#428a4f",
+    stroke: "#2d5d39",
+    hiContrast: "#f8fafc",
+    loContrast: "#c2f0c2"
+  },
+  amber: {
+    // fill: colors.amber[600],
+    // stroke: colors.amber[700],
+    // hiContrast: colors.amber[50],
+    // loContrast: colors.amber[200],
+    fill: "#d97706",
+    stroke: "#b45309",
+    // hiContrast: '#fffbeb',
+    // loContrast: '#fde68a',
+    hiContrast: "#f8fafc",
+    // colors.gray[900],
+    loContrast: "#ffe0c2"
+    // colors.gray[800],
+  },
+  indigo: {
+    // fill: colors.indigo[500],
+    // stroke: colors.indigo[600],
+    // hiContrast: colors.indigo[50],
+    // loContrast: colors.indigo[200],
+    fill: "#6366f1",
+    stroke: "#4f46e5",
+    hiContrast: "#eef2ff",
+    loContrast: "#c7d2fe"
+  }
+};

package/dist/esm/colors/index.d.ts

@@ -0,0 +1,132 @@
+import { ElementColors } from './element';
+import { RelationshipColors } from './relationships';
+export declare const defaultTheme: {
+    elements: {
+        readonly primary: {
+            fill: "#3b82f6";
+            stroke: "#2563eb";
+            hiContrast: "#eff6ff";
+            loContrast: "#bfdbfe";
+        };
+        readonly blue: {
+            fill: "#3b82f6";
+            stroke: "#2563eb";
+            hiContrast: "#eff6ff";
+            loContrast: "#bfdbfe";
+        };
+        readonly secondary: {
+            fill: "#0284c7";
+            stroke: "#0369a1";
+            hiContrast: "#f0f9ff";
+            loContrast: "#e0f2fe";
+        };
+        readonly sky: {
+            fill: "#0284c7";
+            stroke: "#0369a1";
+            hiContrast: "#f0f9ff";
+            loContrast: "#e0f2fe";
+        };
+        readonly muted: {
+            fill: "#64748b";
+            stroke: "#475569";
+            hiContrast: "#f8fafc";
+            loContrast: "#e2e8f0";
+        };
+        readonly slate: {
+            fill: "#64748b";
+            stroke: "#475569";
+            hiContrast: "#f8fafc";
+            loContrast: "#e2e8f0";
+        };
+        readonly gray: {
+            readonly fill: "#737373";
+            readonly stroke: "#525252";
+            readonly hiContrast: "#fafafa";
+            readonly loContrast: "#e5e5e5";
+        };
+        readonly red: {
+            readonly fill: "#b54548";
+            readonly stroke: "#8c333a";
+            readonly hiContrast: "#f8fafc";
+            readonly loContrast: "#F9C6C6";
+        };
+        readonly green: {
+            readonly fill: "#428a4f";
+            readonly stroke: "#2d5d39";
+            readonly hiContrast: "#f8fafc";
+            readonly loContrast: "#c2f0c2";
+        };
+        readonly amber: {
+            readonly fill: "#d97706";
+            readonly stroke: "#b45309";
+            readonly hiContrast: "#f8fafc";
+            readonly loContrast: "#ffe0c2";
+        };
+        readonly indigo: {
+            readonly fill: "#6366f1";
+            readonly stroke: "#4f46e5";
+            readonly hiContrast: "#eef2ff";
+            readonly loContrast: "#c7d2fe";
+        };
+    };
+    relationships: {
+        amber: {
+            lineColor: "#b45309";
+            labelBgColor: "#78350f";
+            labelColor: "#f59e0b";
+        };
+        blue: {
+            lineColor: "#3b82f6";
+            labelBgColor: "#172554";
+            labelColor: "#60a5fa";
+        };
+        gray: {
+            lineColor: "#6E6E6E";
+            labelBgColor: "#18191b";
+            labelColor: "#C6C6C6";
+        };
+        green: {
+            lineColor: "#15803d";
+            labelBgColor: "#052e16";
+            labelColor: "#22c55e";
+        };
+        indigo: {
+            lineColor: "#6366f1";
+            labelBgColor: "#1e1b4b";
+            labelColor: "#818cf8";
+        };
+        muted: {
+            lineColor: "#64748b";
+            labelBgColor: "#0f172a";
+            labelColor: "#cbd5e1";
+        };
+        primary: {
+            lineColor: "#3b82f6";
+            labelBgColor: "#172554";
+            labelColor: "#60a5fa";
+        };
+        red: {
+            lineColor: "#b91c1c";
+            labelBgColor: "#b91c1c";
+            labelColor: "#dc2626";
+        };
+        secondary: {
+            lineColor: "#0ea5e9";
+            labelBgColor: "#082f49";
+            labelColor: "#38bdf8";
+        };
+        sky: {
+            lineColor: "#0ea5e9";
+            labelBgColor: "#082f49";
+            labelColor: "#38bdf8";
+        };
+        slate: {
+            lineColor: "#64748b";
+            labelBgColor: "#0f172a";
+            labelColor: "#cbd5e1";
+        };
+    };
+    font: "Helvetica";
+    shadow: "#0a0a0a";
+};
+export { ElementColors, RelationshipColors };

package/dist/esm/colors/index.js

@@ -0,0 +1,9 @@
+import { ElementColors } from "./element.js";
+import { RelationshipColors } from "./relationships.js";
+export const defaultTheme = {
+  elements: ElementColors,
+  relationships: RelationshipColors,
+  font: "Helvetica",
+  shadow: "#0a0a0a"
+};
+export { ElementColors, RelationshipColors };

package/dist/esm/colors/relationships.d.ts

@@ -0,0 +1,57 @@
+export declare const RelationshipColors: {
+    amber: {
+        lineColor: "#b45309";
+        labelBgColor: "#78350f";
+        labelColor: "#f59e0b";
+    };
+    blue: {
+        lineColor: "#3b82f6";
+        labelBgColor: "#172554";
+        labelColor: "#60a5fa";
+    };
+    gray: {
+        lineColor: "#6E6E6E";
+        labelBgColor: "#18191b";
+        labelColor: "#C6C6C6";
+    };
+    green: {
+        lineColor: "#15803d";
+        labelBgColor: "#052e16";
+        labelColor: "#22c55e";
+    };
+    indigo: {
+        lineColor: "#6366f1";
+        labelBgColor: "#1e1b4b";
+        labelColor: "#818cf8";
+    };
+    muted: {
+        lineColor: "#64748b";
+        labelBgColor: "#0f172a";
+        labelColor: "#cbd5e1";
+    };
+    primary: {
+        lineColor: "#3b82f6";
+        labelBgColor: "#172554";
+        labelColor: "#60a5fa";
+    };
+    red: {
+        lineColor: "#b91c1c";
+        labelBgColor: "#b91c1c";
+        labelColor: "#dc2626";
+    };
+    secondary: {
+        lineColor: "#0ea5e9";
+        labelBgColor: "#082f49";
+        labelColor: "#38bdf8";
+    };
+    sky: {
+        lineColor: "#0ea5e9";
+        labelBgColor: "#082f49";
+        labelColor: "#38bdf8";
+    };
+    slate: {
+        lineColor: "#64748b";
+        labelBgColor: "#0f172a";
+        labelColor: "#cbd5e1";
+    };
+};

package/dist/esm/colors/relationships.js

@@ -0,0 +1,64 @@
+const gray = {
+  lineColor: "#6E6E6E",
+  labelBgColor: "#18191b",
+  labelColor: "#C6C6C6"
+};
+const slate = {
+  lineColor: "#64748b",
+  // 500
+  labelBgColor: "#0f172a",
+  // 900
+  labelColor: "#cbd5e1"
+  // 300
+};
+const blue = {
+  lineColor: "#3b82f6",
+  // 500
+  labelBgColor: "#172554",
+  // 950
+  labelColor: "#60a5fa"
+  // 400
+};
+const sky = {
+  lineColor: "#0ea5e9",
+  // 500
+  labelBgColor: "#082f49",
+  // 950
+  labelColor: "#38bdf8"
+  // 400
+};
+export const RelationshipColors = {
+  amber: {
+    lineColor: "#b45309",
+    labelBgColor: "#78350f",
+    labelColor: "#f59e0b"
+  },
+  blue,
+  gray,
+  green: {
+    lineColor: "#15803d",
+    // 700
+    labelBgColor: "#052e16",
+    //950
+    labelColor: "#22c55e"
+    // 500
+  },
+  indigo: {
+    lineColor: "#6366f1",
+    // 500
+    labelBgColor: "#1e1b4b",
+    // 950
+    labelColor: "#818cf8"
+    // 400
+  },
+  muted: slate,
+  primary: blue,
+  red: {
+    lineColor: "#b91c1c",
+    labelBgColor: "#b91c1c",
+    labelColor: "#dc2626"
+  },
+  secondary: sky,
+  sky,
+  slate
+};

package/dist/esm/errors/index.d.ts

@@ -0,0 +1,45 @@
+import { CustomError } from 'ts-custom-error';
+export interface BaseErrorOptions {
+    cause?: unknown;
+}
+/**
+ * Base class for all errors in the LikeC4 library.
+ */
+export declare class BaseError extends CustomError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare class InvalidArgError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+/**
+ * Unknown error, mosly probably a bug, unhandled case or coming from a third-party library.
+ */
+export declare class UnknownError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare class NullableError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare class InvariantError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare function nonNullable<T>(value: T, message?: string): T & {};
+export declare class RelationRefError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare function normalizeError(e: unknown): BaseError;
+export declare function serializeError(e: unknown): {
+    name: string;
+    message: string;
+    error: BaseError;
+};
+export declare function throwNormalizedError(e: unknown): never;
+export declare function invariant(condition: any, message?: string): asserts condition;
+export declare class NonExhaustiveError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare function nonexhaustive(value: never): never;
+export declare class InvalidModelError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare function ensureModel(condition: any, message?: string): asserts condition;

package/dist/esm/errors/index.js

@@ -0,0 +1,97 @@
+import stringify from "safe-stable-stringify";
+import { CustomError } from "ts-custom-error";
+import { isString } from "../utils/guards.js";
+export class BaseError extends CustomError {
+  constructor(message, options) {
+    super(message, options);
+    Object.defineProperty(this, "name", { value: "BaseError" });
+  }
+}
+export class InvalidArgError extends BaseError {
+  constructor(message, options) {
+    super(message, options);
+    Object.defineProperty(this, "name", { value: "InvalidArgError" });
+  }
+}
+export class UnknownError extends BaseError {
+  constructor(message, options) {
+    super(message, options);
+    Object.defineProperty(this, "name", { value: "UnknownError" });
+  }
+}
+export class NullableError extends BaseError {
+  constructor(message, options) {
+    super(message, options);
+    Object.defineProperty(this, "name", { value: "NullableError" });
+  }
+}
+export class InvariantError extends BaseError {
+  constructor(message, options) {
+    super(message, options);
+    Object.defineProperty(this, "name", { value: "InvariantError" });
+  }
+}
+export function nonNullable(value, message) {
+  if (typeof value === "undefined" || value == null) {
+    throw new NullableError(message ?? `Expected defined value, but received ${value}`);
+  }
+  return value;
+}
+export class RelationRefError extends BaseError {
+  constructor(message, options) {
+    super(message, options);
+    Object.defineProperty(this, "name", { value: "RelationRefError" });
+  }
+}
+export function normalizeError(e) {
+  if (e instanceof BaseError) {
+    return e;
+  }
+  if (e instanceof Error) {
+    return new UnknownError(e.message, { cause: e });
+  }
+  if (e === null || e === void 0) {
+    return new UnknownError("Undefined error");
+  }
+  const message = isString(e) ? e : stringify(e);
+  return new UnknownError(message);
+}
+export function serializeError(e) {
+  const error = normalizeError(e);
+  return {
+    name: error.name,
+    message: error.stack ? error.stack : `${error.name}: ${error.message}`,
+    error
+  };
+}
+export function throwNormalizedError(e) {
+  throw normalizeError(e);
+}
+export function invariant(condition, message) {
+  if (condition) {
+    return;
+  }
+  throw new InvariantError(message ?? "Invariant failed");
+}
+export class NonExhaustiveError extends BaseError {
+  constructor(message, options) {
+    super(message, options);
+    Object.defineProperty(this, "name", { value: "NonExhaustiveError" });
+  }
+}
+export function nonexhaustive(value) {
+  const val = typeof value === "string" ? value : stringify(value);
+  throw new NonExhaustiveError(`NonExhaustive value: ${val}`);
+}
+export class InvalidModelError extends BaseError {
+  constructor(message, options) {
+    super(message, options);
+    Object.defineProperty(this, "name", { value: "InvalidModelError" });
+  }
+}
+export function ensureModel(condition, message) {
+  if (condition) {
+    return;
+  }
+  throw new InvalidModelError(message ?? "ModelIndex Invariant failed");
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,6 @@
+export * from './colors';
+export * from './errors';
+export * from './types';
+export * from './utils';
+export type * as likec4 from './types';
+export type * as c4 from './types';

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export * from "./colors/index.js";
+export * from "./errors/index.js";
+export * from "./types/index.js";
+export * from "./utils/index.js";

package/dist/esm/types/_common.d.ts

@@ -0,0 +1,3 @@
+import type { Opaque } from './opaque';
+export type NonEmptyArray<T> = [T, ...T[]];
+export type IconUrl = Opaque<string, 'IconUrl'>;

package/dist/esm/types/computed-view.d.ts

@@ -0,0 +1,44 @@
+import type { Opaque } from './opaque';
+import type { ElementKind, ElementShape, Fqn, Tag } from './element';
+import type { RelationID, RelationshipArrowType, RelationshipLineType } from './relation';
+import type { BasicElementView, ViewID, ViewRuleAutoLayout } from './view';
+import type { IconUrl, NonEmptyArray } from './_common';
+import type { ThemeColor } from './theme';
+export type NodeId = Fqn;
+export type EdgeId = Opaque<string, 'EdgeId'>;
+export interface ComputedNode {
+    id: NodeId;
+    kind: ElementKind;
+    parent: NodeId | null;
+    title: string;
+    description: string | null;
+    technology: string | null;
+    tags: NonEmptyArray<Tag> | null;
+    links: NonEmptyArray<string> | null;
+    children: NodeId[];
+    inEdges: EdgeId[];
+    outEdges: EdgeId[];
+    shape: ElementShape;
+    color: ThemeColor;
+    icon?: IconUrl;
+    navigateTo?: ViewID;
+    level: number;
+}
+export interface ComputedEdge {
+    id: EdgeId;
+    parent: NodeId | null;
+    source: NodeId;
+    target: NodeId;
+    label: string | null;
+    relations: RelationID[];
+    color?: ThemeColor;
+    line?: RelationshipLineType;
+    head?: RelationshipArrowType;
+    tail?: RelationshipArrowType;
+}
+export interface ComputedView extends Omit<BasicElementView, 'rules'> {
+    readonly extends?: ViewID;
+    readonly autoLayout: ViewRuleAutoLayout['autoLayout'];
+    readonly nodes: ComputedNode[];
+    readonly edges: ComputedEdge[];
+}

package/dist/esm/types/diagram.d.ts

@@ -0,0 +1,41 @@
+import type { ColorLiteral } from './theme';
+import type { ComputedEdge, ComputedNode, ComputedView } from './computed-view';
+import type { NonEmptyArray } from './_common';
+export type Point = [x: number, y: number];
+export type BBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export interface DiagramLabel {
+    align: 'left' | 'right' | 'center';
+    fontStyle?: 'bold' | 'normal';
+    color?: ColorLiteral;
+    fontSize: number;
+    pt: Point;
+    width: number;
+    text: string;
+}
+export interface DiagramNode extends ComputedNode {
+    size: {
+        width: number;
+        height: number;
+    };
+    labels: DiagramLabel[];
+    position: Point;
+    depth?: number;
+}
+export interface DiagramEdge extends ComputedEdge {
+    points: NonEmptyArray<Point>;
+    headArrow?: NonEmptyArray<Point>;
+    tailArrow?: NonEmptyArray<Point>;
+    labels?: NonEmptyArray<DiagramLabel>;
+    labelBBox?: BBox;
+}
+export interface DiagramView extends Omit<ComputedView, 'nodes' | 'edges'> {
+    readonly nodes: DiagramNode[];
+    readonly edges: DiagramEdge[];
+    readonly width: number;
+    readonly height: number;
+}

package/dist/esm/types/element.d.ts

@@ -0,0 +1,29 @@
+import type { IconUrl, NonEmptyArray } from './_common';
+import type { Opaque } from './opaque';
+import type { ThemeColor } from './theme';
+export type Fqn = Opaque<string, 'Fqn'>;
+export declare function AsFqn(name: string, parent?: Fqn | null): Fqn;
+export type ElementKind = Opaque<string, 'ElementKind'>;
+export type ElementShape = 'rectangle' | 'person' | 'browser' | 'mobile' | 'cylinder' | 'storage' | 'queue';
+export declare const DefaultThemeColor = "primary";
+export declare const DefaultElementShape = "rectangle";
+export interface ElementStyle {
+    shape?: ElementShape;
+}
+export type Tag = Opaque<string, 'Tag'>;
+export interface TagSpec {
+    readonly id: Tag;
+    readonly style: ElementStyle;
+}
+export interface Element {
+    readonly id: Fqn;
+    readonly kind: ElementKind;
+    readonly title: string;
+    readonly description: string | null;
+    readonly technology: string | null;
+    readonly tags: NonEmptyArray<Tag> | null;
+    readonly links: NonEmptyArray<string> | null;
+    readonly icon?: IconUrl;
+    readonly shape?: ElementShape;
+    readonly color?: ThemeColor;
+}

package/dist/esm/types/expression.d.ts

@@ -0,0 +1,56 @@
+import type { ElementKind, Fqn, Tag } from './element';
+interface BaseExpr {
+    element?: never;
+    elementKind?: never;
+    elementTag?: never;
+    isEqual?: never;
+    isDescedants?: never;
+    wildcard?: never;
+    source?: never;
+    target?: never;
+    inout?: never;
+    incoming?: never;
+    outgoing?: never;
+}
+export interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
+    element: Fqn;
+    isDescedants?: boolean;
+}
+export declare function isElementRef(expr: Expression): expr is ElementRefExpr;
+export interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
+    wildcard: true;
+}
+export declare function isWildcard(expr: Expression): expr is WildcardExpr;
+export interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
+    elementKind: ElementKind;
+    isEqual: boolean;
+}
+export declare function isElementKindExpr(expr: Expression): expr is ElementKindExpr;
+export interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
+    elementTag: Tag;
+    isEqual: boolean;
+}
+export declare function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
+export type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr;
+export declare function isElement(expr: Expression): expr is ElementExpression;
+export interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
+    source: ElementExpression;
+    target: ElementExpression;
+}
+export declare function isRelation(expr: Expression): expr is RelationExpr;
+export interface InOutExpr extends Omit<BaseExpr, 'inout'> {
+    inout: ElementExpression;
+}
+export declare function isInOut(expr: Expression): expr is InOutExpr;
+export interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
+    incoming: ElementExpression;
+}
+export declare function isIncoming(expr: Expression): expr is IncomingExpr;
+export interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
+    outgoing: ElementExpression;
+}
+export declare function isOutgoing(expr: Expression): expr is OutgoingExpr;
+export type AnyRelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
+export declare function isAnyRelation(expr: Expression): expr is AnyRelationExpression;
+export type Expression = ElementExpression | AnyRelationExpression;
+export {};