@likec4/core 1.1.1 → 1.2.1

package/dist/colors/element.d.ts

@@ -66,3 +66,4 @@ export declare const ElementColors: {
         readonly loContrast: "#c7d2fe";
     };
 };
+//# sourceMappingURL=element.d.ts.map

package/dist/colors/index.d.ts

@@ -130,3 +130,4 @@ export declare const defaultTheme: {
     shadow: "#0a0a0a";
 };
 export { ElementColors, RelationshipColors };
+//# sourceMappingURL=index.d.ts.map

package/dist/colors/relationships.d.ts

@@ -55,3 +55,4 @@ export declare const RelationshipColors: {
         labelColor: "#cbd5e1";
     };
 };
+//# sourceMappingURL=relationships.d.ts.map

package/dist/errors/errors.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=errors.spec.d.ts.map

package/dist/errors/errors.spec.js

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+import { BaseError, InvalidArgError, InvalidModelError, invariant, InvariantError, NonExhaustiveError, normalizeError, NullableError, RelationRefError, UnknownError } from './index';
+describe('errors', () => {
+    describe('normalizeError', () => {
+        it.each([
+            { error: new BaseError('BaseError') },
+            { error: new RelationRefError('RelationRefError') },
+            { error: new UnknownError('UnknownError') },
+            { error: new InvariantError('InvariantError') },
+            { error: new NonExhaustiveError('NonExhaustiveError') },
+            { error: new InvalidModelError('InvalidModelError') },
+            { error: new NullableError('NullableError') },
+            { error: new InvalidArgError('InvalidArgError') }
+        ])('should return $error.name as-is', ({ error }) => {
+            expect(normalizeError(error)).toBe(error);
+        });
+        it.skip('should wrap an error', () => {
+            const cause = new Error('original test');
+            const error = normalizeError(cause);
+            expect(error).toBeInstanceOf(UnknownError);
+            expect(error).to.include({
+                name: 'UnknownError',
+                message: 'original test'
+            });
+            expect(error).to.have.property('cause').that.eq(cause);
+            expect(error)
+                .to.have.property('stack')
+                .that.is.a('string')
+                .and.includes('UnknownError: original test');
+        });
+        it('should wrap a string', () => {
+            const cause = 'error string';
+            const error = normalizeError(cause);
+            expect(error).toBeInstanceOf(UnknownError);
+            expect(error).to.include({
+                name: 'UnknownError',
+                message: cause
+            });
+            expect(error).not.to.have.property('cause');
+            expect(error).to.have.property('stack').that.is.a('string');
+        });
+        // Fails on serializiation of AST
+        it.skip('should wrap an object', () => {
+            const cause = { foo: 'bar' };
+            const error = normalizeError(cause);
+            expect(error).toBeInstanceOf(UnknownError);
+            expect(error).to.include({
+                name: 'UnknownError',
+                message: '{"foo":"bar"}'
+            });
+            expect(error).not.to.have.property('cause');
+            expect(error).to.have.property('stack').that.is.a('string');
+        });
+    });
+});
+describe('invariant', () => {
+    it('should throw an error if the condition fails', () => {
+        expect(() => invariant(false)).toThrow('Invariant failed');
+    });
+    it('should throw an error if the condition is null', () => {
+        expect(() => invariant(null)).toThrow(InvariantError);
+    });
+    it('should not throw an error if the condition passes', () => {
+        expect(() => invariant(true)).not.toThrow();
+    });
+    it('should throw an error with the provided message if the condition fails', () => {
+        expect(() => invariant(false, 'test')).toThrow('test');
+    });
+});

package/dist/errors/index.d.ts

@@ -36,3 +36,4 @@ export declare function nonexhaustive(value: never): never;
 export declare class InvalidModelError extends BaseError {
     constructor(message: string, options?: BaseErrorOptions);
 }
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.js

@@ -63,7 +63,13 @@ export function normalizeError(e) {
     }
     const message = isString(e) ? e : String(e);
     const error = new UnknownError(message);
-    Error.captureStackTrace(error, normalizeError);
+    try {
+        // @ts-ignore
+        Error.captureStackTrace(error, normalizeError);
+    }
+    catch {
+        // Ignore
+    }
     return error;
 }
 // Throw an error if the condition fails

package/dist/index.d.ts

@@ -4,3 +4,4 @@ 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/_common.d.ts

@@ -1,3 +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/element.d.ts

@@ -32,3 +32,4 @@ export interface Element {
     readonly color?: ThemeColor;
     readonly style?: ElementStyle;
 }
+//# sourceMappingURL=element.d.ts.map

package/dist/types/expression.d.ts

@@ -79,3 +79,4 @@ export type AnyRelationExpression = RelationExpr | InOutExpr | IncomingExpr | Ou
 export declare function isAnyRelation(expr: Expression): expr is AnyRelationExpression;
 export type Expression = ElementExpression | CustomElementExpr | AnyRelationExpression;
 export {};
+//# sourceMappingURL=expression.d.ts.map

package/dist/types/index.d.ts

@@ -1,6 +1,4 @@
 export * from './_common';
-export * from './computed-view';
-export * from './diagram';
 export * from './element';
 export * from './expression';
 export * from './model';
@@ -9,3 +7,4 @@ export * from './relation';
 export * from './theme';
 export * from './view';
 export * as Expr from './expression';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -1,6 +1,4 @@
 export * from './_common';
-export * from './computed-view';
-export * from './diagram';
 export * from './element';
 export * from './expression';
 export * from './model';
@@ -8,4 +6,5 @@ export * from './opaque';
 export * from './relation';
 export * from './theme';
 export * from './view';
-export * as Expr from './expression';
+import * as Expr_1 from './expression';
+export { Expr_1 as Expr };

package/dist/types/model.d.ts

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

package/dist/types/opaque.d.ts

@@ -100,3 +100,4 @@ type WontWork = UnwrapOpaque<string>;
 */
 export type UnwrapOpaque<OpaqueType extends Tagged<unknown>> = OpaqueType extends Opaque<infer Type, OpaqueType[typeof tag]> ? Type : OpaqueType;
 export {};
+//# sourceMappingURL=opaque.d.ts.map

package/dist/types/relation.d.ts

@@ -22,3 +22,4 @@ export interface Relation {
     readonly tail?: RelationshipArrowType;
     readonly links?: NonEmptyArray<string>;
 }
+//# sourceMappingURL=relation.d.ts.map

package/dist/types/theme.d.ts

@@ -24,3 +24,4 @@ export interface LikeC4Theme {
     relationships: RelationshipThemeColors;
     elements: ElementThemeColors;
 }
+//# sourceMappingURL=theme.d.ts.map

package/dist/types/view.d.ts

@@ -1,8 +1,9 @@
 import type { IconUrl, NonEmptyArray } from './_common';
-import type { ElementShape, ElementStyle, Fqn, Tag } from './element';
-import type { ElementExpression, Expression } from './expression';
+import type { ElementKind, ElementShape, ElementStyle, Fqn, Tag } from './element';
+import type { CustomElementExpr, ElementExpression, Expression } from './expression';
 import type { Opaque } from './opaque';
-import type { ThemeColor } from './theme';
+import type { RelationID, RelationshipArrowType, RelationshipLineType } from './relation';
+import type { ColorLiteral, ThemeColor } from './theme';
 export type ViewID = Opaque<string, 'ViewID'>;
 export type ViewRuleExpression = {
     include: Expression[];
@@ -27,14 +28,13 @@ export interface ViewRuleAutoLayout {
 }
 export declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
 export type ViewRule = ViewRuleExpression | ViewRuleStyle | ViewRuleAutoLayout;
-export interface BasicElementView {
+export interface BasicView<ViewType extends 'element' | 'dynamic' = 'element' | 'dynamic'> {
+    readonly __?: ViewType;
     readonly id: ViewID;
-    readonly viewOf?: Fqn;
     readonly title: string | null;
     readonly description: string | null;
     readonly tags: NonEmptyArray<Tag> | null;
     readonly links: NonEmptyArray<string> | null;
-    readonly rules: ViewRule[];
     /**
      * URI to the source file of this view.
      * Undefined if the view is auto-generated.
@@ -51,12 +51,137 @@ export interface BasicElementView {
      */
     readonly relativePath?: string;
 }
+export interface BasicElementView extends BasicView<'element'> {
+    readonly viewOf?: Fqn;
+    readonly rules: ViewRule[];
+}
 export interface StrictElementView extends BasicElementView {
     readonly viewOf: Fqn;
 }
-export declare function isStrictElementView(view: ElementView): view is StrictElementView;
 export interface ExtendsElementView extends BasicElementView {
     readonly extends: ViewID;
 }
-export declare function isExtendsElementView(view: ElementView): view is ExtendsElementView;
 export type ElementView = StrictElementView | ExtendsElementView | BasicElementView;
+export interface DynamicViewStep {
+    readonly source: Fqn;
+    readonly target: Fqn;
+    readonly title: string | null;
+    readonly isBackward?: boolean;
+}
+export type DynamicViewIncludeRule = {
+    include: (ElementExpression | CustomElementExpr)[];
+};
+export declare function isDynamicViewIncludeRule(rule: DynamicViewRule): rule is DynamicViewIncludeRule;
+export type DynamicViewRule = DynamicViewIncludeRule | ViewRuleStyle | ViewRuleAutoLayout;
+export interface DynamicView extends BasicView<'dynamic'> {
+    readonly __: 'dynamic';
+    readonly steps: DynamicViewStep[];
+    readonly rules: DynamicViewRule[];
+}
+export type View = ElementView | DynamicView;
+export declare function isDynamicView(view: View): view is DynamicView;
+export declare function isElementView(view: View): view is ElementView;
+export declare function isExtendsElementView(view: View): view is ExtendsElementView;
+export declare function isStrictElementView(view: View): view is StrictElementView;
+export type NodeId = Fqn;
+export type EdgeId = Opaque<string, 'EdgeId'>;
+export type StepEdgeIdLiteral = `step-${number}`;
+export type StepEdgeId = Opaque<StepEdgeIdLiteral, 'EdgeId'>;
+export declare function StepEdgeId(step: number): StepEdgeId;
+export declare function isStepEdgeId(id: string): id is StepEdgeId;
+export declare function extractStep(id: EdgeId): number;
+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;
+    /**
+     * @deprecated Use `style` instead
+     */
+    color: ThemeColor;
+    /**
+     * @deprecated Use `style` instead
+     */
+    icon?: IconUrl;
+    style: ElementStyle;
+    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;
+    /**
+     * For layouting purposes
+     * @default 'forward'
+     */
+    dir?: 'forward' | 'back';
+}
+export interface ComputedElementView extends Omit<ElementView, 'rules'> {
+    readonly extends?: ViewID;
+    readonly autoLayout: ViewRuleAutoLayout['autoLayout'];
+    readonly nodes: ComputedNode[];
+    readonly edges: ComputedEdge[];
+}
+export interface ComputedDynamicView extends Omit<DynamicView, 'rules' | 'steps'> {
+    readonly autoLayout: ViewRuleAutoLayout['autoLayout'];
+    readonly nodes: ComputedNode[];
+    readonly edges: ComputedEdge[];
+}
+export declare function isComputedDynamicView(view: ComputedView): view is ComputedDynamicView;
+export type ComputedView = ComputedElementView | ComputedDynamicView;
+export declare function isComputedElementView(view: ComputedView): view is ComputedElementView;
+export type Point = readonly [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 {
+    width: number;
+    height: number;
+    position: Point;
+    labels: DiagramLabel[];
+}
+export interface DiagramEdge extends ComputedEdge {
+    points: NonEmptyArray<Point>;
+    headArrow?: NonEmptyArray<Point>;
+    headArrowPoint?: Point;
+    tailArrow?: NonEmptyArray<Point>;
+    tailArrowPoint?: 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=view.d.ts.map

package/dist/types/view.js

@@ -1,3 +1,4 @@
+import { isNullish } from 'remeda';
 export function isViewRuleExpression(rule) {
     return (('include' in rule && Array.isArray(rule.include))
         || ('exclude' in rule && Array.isArray(rule.exclude)));
@@ -8,9 +9,36 @@ export function isViewRuleStyle(rule) {
 export function isViewRuleAutoLayout(rule) {
     return 'autoLayout' in rule;
 }
-export function isStrictElementView(view) {
-    return 'viewOf' in view;
+export function isDynamicViewIncludeRule(rule) {
+    return 'include' in rule && Array.isArray(rule.include);
+}
+export function isDynamicView(view) {
+    return view.__ === 'dynamic';
+}
+export function isElementView(view) {
+    return isNullish(view.__) || view.__ === 'element';
 }
 export function isExtendsElementView(view) {
-    return 'extends' in view;
+    return isElementView(view) && 'extends' in view;
+}
+export function isStrictElementView(view) {
+    return isElementView(view) && 'viewOf' in view;
+}
+export function StepEdgeId(step) {
+    return `step-${String(step).padStart(3, '0')}`;
+}
+export function isStepEdgeId(id) {
+    return id.startsWith('step-');
+}
+export function extractStep(id) {
+    if (!isStepEdgeId(id)) {
+        throw new Error(`Invalid step edge id: ${id}`);
+    }
+    return Number(id.slice('step-'.length));
+}
+export function isComputedDynamicView(view) {
+    return view.__ === 'dynamic';
+}
+export function isComputedElementView(view) {
+    return isNullish(view.__) || view.__ === 'element';
 }

package/dist/utils/fqn.d.ts

@@ -31,3 +31,4 @@ export declare function compareFqnHierarchically<T extends string = string>(a: T
 export declare function compareByFqnHierarchically<T extends {
     id: string;
 }>(a: T, b: T): number;
+//# sourceMappingURL=fqn.d.ts.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fqn.spec.d.ts.map

package/dist/utils/fqn.spec.js

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+import { ancestorsFqn, commonAncestor, compareFqnHierarchically, isAncestor, isDescendantOf, notDescendantOf, parentFqn } from './fqn';
+const el = (id) => ({ id });
+describe('parentFqn', () => {
+    it('should return null if no parent', () => {
+        expect(parentFqn('a')).toBeNull();
+    });
+    it('should return parent', () => {
+        expect(parentFqn('a.b')).toBe('a');
+        expect(parentFqn('a.b.c')).toBe('a.b');
+    });
+});
+describe('ancestorsFqn', () => {
+    it('should return empty array if no parent', () => {
+        expect(ancestorsFqn('a')).toEqual([]);
+    });
+    it('should return ancestors', () => {
+        expect(ancestorsFqn('a.b.c.d.e')).toEqual(['a.b.c.d', 'a.b.c', 'a.b', 'a']);
+    });
+});
+describe('commonAncestor', () => {
+    it('should return null if no common ancestor', () => {
+        expect(commonAncestor('a', 'b')).toBeNull();
+        expect(commonAncestor('a.b', 'c.d')).toBeNull();
+    });
+    it('should return common ancestor', () => {
+        expect(commonAncestor('a.b', 'a.c')).toBe('a');
+        expect(commonAncestor('a.b.c', 'a.b.e')).toBe('a.b');
+        expect(commonAncestor('a.b.c.d.e', 'a.b.c.d')).toBe('a.b.c');
+    });
+});
+describe('isAncestor', () => {
+    it('should return true if ancestor', () => {
+        expect(isAncestor('a', 'a.b')).toBe(true);
+        expect(isAncestor('a.b', 'a.b.c')).toBe(true);
+    });
+    it('should return false if not ancestor', () => {
+        expect(isAncestor('a', 'b')).toBe(false);
+        expect(isAncestor('a.b', 'a')).toBe(false);
+        expect(isAncestor('a.b', 'b.a')).toBe(false);
+    });
+});
+describe('isDescendantOf', () => {
+    const predicate = isDescendantOf(['a', 'b', 'a.b', 'a.b.c'].map(el));
+    it('should return true if isDescendantOf', () => {
+        expect(predicate(el('a'))).toBe(true);
+        expect(predicate(el('b.c'))).toBe(true);
+        expect(predicate(el('a.b.c.d.e'))).toBe(true);
+    });
+    it('should return false if not descendantOf', () => {
+        expect(predicate(el('c'))).toBe(false);
+        expect(predicate(el('ac'))).toBe(false);
+        expect(predicate(el('d.a.c'))).toBe(false);
+    });
+});
+describe('notDescendantOf', () => {
+    const predicate = notDescendantOf(['a', 'b', 'a.b', 'a.b.c'].map(el));
+    it('should return true if notDescendantOf', () => {
+        expect(predicate(el('c'))).toBe(true);
+        expect(predicate(el('ac'))).toBe(true);
+        expect(predicate(el('d.a.c'))).toBe(true);
+    });
+    it('should return false if descendantOf', () => {
+        expect(predicate(el('a'))).toBe(false);
+        expect(predicate(el('b.c'))).toBe(false);
+        expect(predicate(el('a.b.c.d.e'))).toBe(false);
+    });
+});
+describe('compareFqnHierarchically', () => {
+    it('should compare hierarchically', () => {
+        expect(['a', 'b', 'a.b', 'a.b.c', 'a.c.c'].sort(compareFqnHierarchically)).toEqual([
+            'a',
+            'b',
+            'a.b',
+            'a.b.c',
+            'a.c.c'
+        ]);
+    });
+    it('should preserve initial order', () => {
+        expect(['aaa', 'aa', 'a', 'aaa.c', 'aa.b', 'a.c', 'a.b'].sort(compareFqnHierarchically)).toEqual(['aaa', 'aa', 'a', 'aaa.c', 'aa.b', 'a.c', 'a.b']);
+    });
+});

package/dist/utils/guards.d.ts

@@ -2,3 +2,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> | undefined): arr is NonEmptyArray<A>;
+//# sourceMappingURL=guards.d.ts.map

package/dist/utils/index.d.ts

@@ -2,3 +2,4 @@ export * from './fqn';
 export * from './guards';
 export * from './promises';
 export * from './relations';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/promises.d.ts

@@ -1 +1,2 @@
 export declare function delay(ms?: number): Promise<unknown>;
+//# sourceMappingURL=promises.d.ts.map

package/dist/utils/relations.d.ts

@@ -27,3 +27,4 @@ export declare const Relations: {
     }>(element: E) => boolean;
 };
 export {};
+//# sourceMappingURL=relations.d.ts.map

package/dist/utils/relations.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=relations.spec.d.ts.map