@likec4/core 0.60.2 → 1.0.0-next.0

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

@@ -1,7 +1,7 @@
-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];
+import type { ComputedEdge, ComputedNode, ComputedView } from './computed-view';
+import type { ColorLiteral } from './theme';
+export type Point = readonly [x: number, y: number];
 export type BBox = {
     x: number;
     y: number;
@@ -18,12 +18,10 @@ export interface DiagramLabel {
     text: string;
 }
 export interface DiagramNode extends ComputedNode {
-    size: {
-        width: number;
-        height: number;
-    };
-    labels: DiagramLabel[];
+    width: number;
+    height: number;
     position: Point;
+    labels: DiagramLabel[];
 }
 export interface DiagramEdge extends ComputedEdge {
     points: NonEmptyArray<Point>;

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

@@ -4,7 +4,8 @@ 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 ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
+export type ElementShape = typeof ElementShapes[number];
 export declare const DefaultThemeColor = "primary";
 export declare const DefaultElementShape = "rectangle";
 export interface ElementStyle {

package/dist/esm/types/element.js

@@ -1,5 +1,14 @@
 export function AsFqn(name, parent) {
   return parent ? parent + "." + name : name;
 }
+export const ElementShapes = [
+  "rectangle",
+  "person",
+  "browser",
+  "mobile",
+  "cylinder",
+  "storage",
+  "queue"
+];
 export const DefaultThemeColor = "primary";
 export const DefaultElementShape = "rectangle";

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

@@ -1,11 +1,11 @@
-export * from './opaque';
 export * from './_common';
-export * from './theme';
+export * from './computed-view';
+export * from './diagram';
 export * from './element';
-export * from './relation';
+export * from './expression';
 export * from './model';
+export * from './opaque';
+export * from './relation';
+export * from './theme';
 export * from './view';
-export * from './expression';
-export * from './computed-view';
-export * from './diagram';
 export * as Expr from './expression';

package/dist/esm/types/index.js

@@ -1,11 +1,11 @@
-export * from "./opaque.js";
 export * from "./_common.js";
-export * from "./theme.js";
+export * from "./computed-view.js";
+export * from "./diagram.js";
 export * from "./element.js";
-export * from "./relation.js";
+export * from "./expression.js";
 export * from "./model.js";
+export * from "./opaque.js";
+export * from "./relation.js";
+export * from "./theme.js";
 export * from "./view.js";
-export * from "./expression.js";
-export * from "./computed-view.js";
-export * from "./diagram.js";
 export * as Expr from "./expression.js";

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

@@ -2,12 +2,12 @@ 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 {
+export interface LikeC4Model {
     elements: Record<Fqn, Element>;
     relations: Record<RelationID, Relation>;
     views: Record<ViewID, ElementView>;
 }
-export interface LikeC4Model {
+export interface LikeC4ComputedModel {
     elements: Record<Fqn, Element>;
     relations: Record<RelationID, Relation>;
     views: Record<ViewID, ComputedView>;

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

@@ -1,7 +1,7 @@
-import type { Opaque } from './opaque';
+import type { IconUrl, NonEmptyArray } from './_common';
 import type { ElementShape, Fqn, Tag } from './element';
 import type { ElementExpression, Expression } from './expression';
-import type { IconUrl, NonEmptyArray } from './_common';
+import type { Opaque } from './opaque';
 import type { ThemeColor } from './theme';
 export type ViewID = Opaque<string, 'ViewID'>;
 export type ViewRuleExpression = {
@@ -21,8 +21,9 @@ export interface ViewRuleStyle {
     };
 }
 export declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;
+export type AutoLayoutDirection = 'TB' | 'BT' | 'LR' | 'RL';
 export interface ViewRuleAutoLayout {
-    autoLayout: 'TB' | 'BT' | 'LR' | 'RL';
+    autoLayout: AutoLayoutDirection;
 }
 export declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
 export type ViewRule = ViewRuleExpression | ViewRuleStyle | ViewRuleAutoLayout;

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

@@ -2,7 +2,7 @@ import type { Element, Fqn } from '../types';
 export declare function nameFromFqn(fqn: Fqn): string;
 export declare function isAncestor<E extends {
     id: Fqn;
-}>(...args: [ancestor: Fqn, another: Fqn] | [ancestor: E, another: E]): boolean;
+}>(...args: [ancestor: string, another: string] | [ancestor: E, another: E]): boolean;
 export declare function isSameHierarchy<E extends {
     id: Fqn;
 }>(one: E | Fqn, another: E | Fqn): boolean;
@@ -29,5 +29,5 @@ export declare function ancestorsFqn(fqn: Fqn): Fqn[];
  */
 export declare function compareFqnHierarchically<T extends string = string>(a: T, b: T): number;
 export declare function compareByFqnHierarchically<T extends {
-    id: Fqn;
+    id: string;
 }>(a: T, b: T): number;

package/dist/esm/utils/fqn.js

@@ -1,4 +1,3 @@
-import { anyPass } from "remeda";
 import { isString } from "./guards.js";
 export function nameFromFqn(fqn) {
   const lastDot = fqn.lastIndexOf(".");
@@ -20,7 +19,7 @@ export function isSameHierarchy(one, another) {
 }
 export function isDescendantOf(ancestors) {
   const predicates = ancestors.flatMap((a) => [(e) => e.id === a.id, (e) => isAncestor(a, e)]);
-  return anyPass(predicates);
+  return (e) => predicates.some((p) => p(e));
 }
 export function notDescendantOf(ancestors) {
   const isDescendant = isDescendantOf(ancestors);

package/dist/esm/utils/relations.js

@@ -1,5 +1,4 @@
 import { commonAncestor, compareFqnHierarchically, isAncestor } from "./fqn.js";
-import { either } from "rambdax";
 export const compareRelations = (a, b) => {
   const parentA = commonAncestor(a.source, a.target);
   const parentB = commonAncestor(b.source, b.target);
@@ -33,7 +32,8 @@ const isBetween = (source, target) => {
   };
 };
 const isAnyBetween = (source, target) => {
-  return either(isBetween(source, target), isBetween(target, source));
+  const predicates = [isBetween(source, target), isBetween(target, source)];
+  return (rel) => predicates.some((p) => p(rel));
 };
 const isIncoming = (target) => {
   const targetPrefix = target + ".";
@@ -48,7 +48,10 @@ const isOutgoing = (source) => {
   };
 };
 const isAnyInOut = (source) => {
-  return either(isIncoming(source), isOutgoing(source));
+  const predicates = [isIncoming(source), isOutgoing(source)];
+  return (rel) => {
+    return predicates.some((p) => p(rel));
+  };
 };
 const hasRelation = (rel) => {
   return (element) => {

package/dist/index.js

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

package/dist/types/_common.js

@@ -0,0 +1 @@
+export {};

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: "#B6ECF7";
+    };
+    readonly sky: {
+        fill: "#0284c7";
+        stroke: "#0369a1";
+        hiContrast: "#f0f9ff";
+        loContrast: "#B6ECF7";
+    };
+    readonly muted: {
+        fill: "#64748b";
+        stroke: "#475569";
+        hiContrast: "#f8fafc";
+        loContrast: "#cbd5e1";
+    };
+    readonly slate: {
+        fill: "#64748b";
+        stroke: "#475569";
+        hiContrast: "#f8fafc";
+        loContrast: "#cbd5e1";
+    };
+    readonly gray: {
+        readonly fill: "#737373";
+        readonly stroke: "#525252";
+        readonly hiContrast: "#fafafa";
+        readonly loContrast: "#d4d4d4";
+    };
+    readonly red: {
+        readonly fill: "#AC4D39";
+        readonly stroke: "#853A2D";
+        readonly hiContrast: "#FBD3CB";
+        readonly loContrast: "#FF977D";
+    };
+    readonly green: {
+        readonly fill: "#428a4f";
+        readonly stroke: "#2d5d39";
+        readonly hiContrast: "#f8fafc";
+        readonly loContrast: "#c2f0c2";
+    };
+    readonly amber: {
+        readonly fill: "#A35829";
+        readonly stroke: "#7E451D";
+        readonly hiContrast: "#FFE0C2";
+        readonly loContrast: "#FFA057";
+    };
+    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: "#B6ECF7";
+        };
+        readonly sky: {
+            fill: "#0284c7";
+            stroke: "#0369a1";
+            hiContrast: "#f0f9ff";
+            loContrast: "#B6ECF7";
+        };
+        readonly muted: {
+            fill: "#64748b";
+            stroke: "#475569";
+            hiContrast: "#f8fafc";
+            loContrast: "#cbd5e1";
+        };
+        readonly slate: {
+            fill: "#64748b";
+            stroke: "#475569";
+            hiContrast: "#f8fafc";
+            loContrast: "#cbd5e1";
+        };
+        readonly gray: {
+            readonly fill: "#737373";
+            readonly stroke: "#525252";
+            readonly hiContrast: "#fafafa";
+            readonly loContrast: "#d4d4d4";
+        };
+        readonly red: {
+            readonly fill: "#AC4D39";
+            readonly stroke: "#853A2D";
+            readonly hiContrast: "#FBD3CB";
+            readonly loContrast: "#FF977D";
+        };
+        readonly green: {
+            readonly fill: "#428a4f";
+            readonly stroke: "#2d5d39";
+            readonly hiContrast: "#f8fafc";
+            readonly loContrast: "#c2f0c2";
+        };
+        readonly amber: {
+            readonly fill: "#A35829";
+            readonly stroke: "#7E451D";
+            readonly hiContrast: "#FFE0C2";
+            readonly loContrast: "#FFA057";
+        };
+        readonly indigo: {
+            readonly fill: "#6366f1";
+            readonly stroke: "#4f46e5";
+            readonly hiContrast: "#eef2ff";
+            readonly loContrast: "#c7d2fe";
+        };
+    };
+    relationships: {
+        amber: {
+            lineColor: "#b45309";
+            labelBgColor: "#78350f";
+            labelColor: "#FFE0C2";
+        };
+        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: "#AC4D39";
+            labelBgColor: "#b91c1c";
+            labelColor: "#FF977D";
+        };
+        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: "#FFE0C2";
+    };
+    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: "#AC4D39";
+        labelBgColor: "#b91c1c";
+        labelColor: "#FF977D";
+    };
+    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/computed-view.js

@@ -0,0 +1 @@
+export {};

package/dist/types/diagram.js

@@ -0,0 +1 @@
+export {};

package/dist/types/element.js

@@ -0,0 +1,14 @@
+export function AsFqn(name, parent) {
+    return (parent ? parent + '.' + name : name);
+}
+export const ElementShapes = [
+    'rectangle',
+    'person',
+    'browser',
+    'mobile',
+    'cylinder',
+    'storage',
+    'queue'
+];
+export const DefaultThemeColor = 'primary';
+export const DefaultElementShape = 'rectangle';

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

@@ -0,0 +1,40 @@
+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): Error;
+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/expression.js

@@ -0,0 +1,45 @@
+export function isElementRef(expr) {
+    return 'element' in expr;
+}
+export function isCustomElement(expr) {
+    return 'custom' in expr;
+}
+export function isWildcard(expr) {
+    return 'wildcard' in expr;
+}
+export function isElementKindExpr(expr) {
+    return 'elementKind' in expr && 'isEqual' in expr;
+}
+export function isElementTagExpr(expr) {
+    return 'elementTag' in expr && 'isEqual' in expr;
+}
+export function isElement(expr) {
+    return isElementRef(expr) || isWildcard(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
+}
+export function isRelation(expr) {
+    return 'source' in expr && 'target' in expr;
+}
+export function isInOut(expr) {
+    return 'inout' in expr;
+}
+export function isIncoming(expr) {
+    return 'incoming' in expr;
+}
+export function isOutgoing(expr) {
+    return 'outgoing' in expr;
+}
+export function isAnyRelation(expr) {
+    return isRelation(expr) || isInOut(expr) || isIncoming(expr) || isOutgoing(expr);
+}
+// export const Expr = {
+//   isElementRef,
+//   isWildcard,
+//   isElementKindExpr,
+//   isElementTagExpr,
+//   isElement,
+//   isRelation,
+//   isInOut,
+//   isIncoming,
+//   isOutgoing,
+//   isAnyRelation,
+// }

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/index.js

@@ -0,0 +1,11 @@
+export * from './_common';
+export * from './computed-view';
+export * from './diagram';
+export * from './element';
+export * from './expression';
+export * from './model';
+export * from './opaque';
+export * from './relation';
+export * from './theme';
+export * from './view';
+export * as Expr from './expression';

package/dist/types/log.d.ts

@@ -0,0 +1,4 @@
+export declare const likec4log: import("roarr").Logger<Error | import("roarr/dist/types").JsonObject | {
+    error?: Error;
+}>;
+//# sourceMappingURL=log.d.ts.map

package/dist/types/model.js

@@ -0,0 +1 @@
+export {};

package/dist/types/opaque.js

@@ -0,0 +1 @@
+export {};

package/dist/types/relation.js

@@ -0,0 +1,3 @@
+export const DefaultLineStyle = 'dashed';
+export const DefaultArrowType = 'normal';
+export const DefaultRelationshipColor = 'gray';

package/dist/types/theme.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import type { Opaque } from './opaque';
+export type NonEmptyArray<T> = [T, ...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,46 @@
+import type { IconUrl, NonEmptyArray } from './_common';
+import type { ElementKind, ElementShape, Fqn, Tag } from './element';
+import type { Opaque } from './opaque';
+import type { RelationID, RelationshipArrowType, RelationshipLineType } from './relation';
+import type { ThemeColor } from './theme';
+import type { BasicElementView, ViewID, ViewRuleAutoLayout } from './view';
+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;
+    depth?: 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