@likec4/core 0.40.0 → 0.42.0

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

@@ -4,10 +4,13 @@ import type { ElementExpression, Expression } from './expression';
 import type { IconUrl, NonEmptyArray } from './_common';
 import type { ThemeColor } from './theme';
 export type ViewID = Opaque<string, 'ViewID'>;
-export interface ViewRuleExpression {
-    isInclude: boolean;
-    exprs: Expression[];
-}
+export type ViewRuleExpression = {
+    include: Expression[];
+    exclude?: never;
+} | {
+    include?: never;
+    exclude: Expression[];
+};
 export declare function isViewRuleExpression(rule: ViewRule): rule is ViewRuleExpression;
 export interface ViewRuleStyle {
     targets: ElementExpression[];

package/dist/esm/types/view.js

@@ -1,5 +1,5 @@
 export function isViewRuleExpression(rule) {
-  return "exprs" in rule && "isInclude" in rule;
+  return "include" in rule && Array.isArray(rule.include) || "exclude" in rule && Array.isArray(rule.exclude);
 }
 export function isViewRuleStyle(rule) {
   return "style" in rule && "targets" in rule;

package/dist/esm/utils/fqn.d.ts

@@ -5,13 +5,18 @@ export declare function isAncestor<E extends {
 }>(...args: [ancestor: Fqn, another: Fqn] | [ancestor: E, another: E]): boolean;
 export declare function isSameHierarchy<E extends {
     id: Fqn;
-}>(...args: [one: Fqn, another: Fqn] | [one: E, another: E]): boolean;
+}>(one: E | Fqn, another: E | Fqn): boolean;
 export declare function isDescendantOf<E extends {
     id: Fqn;
 }>(ancestors: E[]): (e: E) => boolean;
 export declare function notDescendantOf(ancestors: Element[]): (e: Element) => boolean;
 export declare function commonAncestor(first: Fqn, second: Fqn): Fqn | null;
 export declare function parentFqn(fqn: Fqn): Fqn | null;
+/**
+ * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+ * (from closest to root)
+ */
+export declare function ancestorsFqn(fqn: Fqn): Fqn[];
 /**
  * Compares two fully qualified names (fqns) hierarchically based on their depth.
  * From parent nodes to leaves

package/dist/esm/utils/fqn.js

@@ -13,10 +13,10 @@ export function isAncestor(...args) {
   const another = isString(args[1]) ? args[1] : args[1].id;
   return another.startsWith(ancestor + ".");
 }
-export function isSameHierarchy(...args) {
-  const one = isString(args[0]) ? args[0] : args[0].id;
-  const another = isString(args[1]) ? args[1] : args[1].id;
-  return one === another || another.startsWith(one + ".") || one.startsWith(another + ".");
+export function isSameHierarchy(one, another) {
+  const first = isString(one) ? one : one.id;
+  const second = isString(another) ? another : another.id;
+  return first === second || second.startsWith(first + ".") || first.startsWith(second + ".");
 }
 export function isDescendantOf(ancestors) {
   const predicates = ancestors.flatMap((a) => [(e) => e.id === a.id, (e) => isAncestor(a, e)]);
@@ -52,6 +52,18 @@ export function parentFqn(fqn) {
   }
   return null;
 }
+export function ancestorsFqn(fqn) {
+  const path = fqn.split(".");
+  path.pop();
+  if (path.length === 0) {
+    return [];
+  }
+  return path.reduce((acc, _, idx) => {
+    const ancestor = path.slice(0, idx + 1).join(".");
+    acc.unshift(ancestor);
+    return acc;
+  }, []);
+}
 export function compareFqnHierarchically(a, b) {
   const depthA = a.split(".").length;
   const depthB = b.split(".").length;

package/dist/esm/utils/guards.d.ts

@@ -1,3 +1,4 @@
 import type { NonEmptyArray } from '../types';
+export { hasAtLeast } from 'remeda';
 export declare function isString(value: unknown): value is string;
 export declare function isNonEmptyArray<A>(arr: ArrayLike<A>): arr is NonEmptyArray<A>;

package/dist/esm/utils/guards.js

@@ -1,3 +1,4 @@
+export { hasAtLeast } from "remeda";
 export function isString(value) {
   return value != null && typeof value === "string";
 }

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

@@ -1,4 +1,3 @@
 export * from './fqn';
 export * from './guards';
-export * from './compute-node-levels';
 export * from './relations';

package/dist/esm/utils/index.js

@@ -1,4 +1,3 @@
 export * from "./fqn.js";
 export * from "./guards.js";
-export * from "./compute-node-levels.js";
 export * from "./relations.js";

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

@@ -0,0 +1,69 @@
+export declare const ElementColors: {
+    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";
+    };
+};
+//# sourceMappingURL=element.d.ts.map

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

@@ -0,0 +1,133 @@
+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 };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,58 @@
+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";
+    };
+};
+//# sourceMappingURL=relationships.d.ts.map

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

@@ -0,0 +1,46 @@
+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;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './colors';
+export * from './errors';
+export * from './types';
+export * from './utils';
+export type * as likec4 from './types';
+export type * as c4 from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { Opaque } from './opaque';
+export type NonEmptyArray<T> = [T, ...T[]];
+export type IconUrl = Opaque<string, 'IconUrl'>;
+//# sourceMappingURL=_common.d.ts.map

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

@@ -0,0 +1,45 @@
+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[];
+}
+//# sourceMappingURL=computed-view.d.ts.map

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

@@ -0,0 +1,42 @@
+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;
+}
+//# sourceMappingURL=diagram.d.ts.map

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

@@ -0,0 +1,30 @@
+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;
+}
+//# sourceMappingURL=element.d.ts.map

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

@@ -0,0 +1,57 @@
+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 {};
+//# sourceMappingURL=expression.d.ts.map

package/dist/types/types/index.d.ts

@@ -0,0 +1,12 @@
+export * from './opaque';
+export * from './_common';
+export * from './theme';
+export * from './element';
+export * from './relation';
+export * from './model';
+export * from './view';
+export * from './expression';
+export * from './computed-view';
+export * from './diagram';
+export * as Expr from './expression';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/types/model.d.ts

@@ -0,0 +1,15 @@
+import type { ComputedView } from './computed-view';
+import type { Element, Fqn } from './element';
+import type { Relation, RelationID } from './relation';
+import type { ElementView, ViewID } from './view';
+export interface LikeC4RawModel {
+    elements: Record<Fqn, Element>;
+    relations: Record<RelationID, Relation>;
+    views: Record<ViewID, ElementView>;
+}
+export interface LikeC4Model {
+    elements: Record<Fqn, Element>;
+    relations: Record<RelationID, Relation>;
+    views: Record<ViewID, ComputedView>;
+}
+//# sourceMappingURL=model.d.ts.map