@likec4/core 1.2.0 → 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

@@ -7,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

@@ -6,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

@@ -11,3 +11,4 @@ export interface LikeC4ComputedModel {
     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

@@ -184,3 +184,4 @@ export interface DiagramView extends Omit<ComputedView, 'nodes' | 'edges'> {
     readonly width: number;
     readonly height: number;
 }
+//# sourceMappingURL=view.d.ts.map

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

package/dist/utils/relations.spec.js

@@ -0,0 +1,210 @@
+import { describe, expect, it } from 'vitest';
+import { compareRelations, Relations } from './relations';
+const { isAnyBetween, isAnyInOut, isBetween, isIncoming, isInside, isOutgoing } = Relations;
+const relations = [
+    {
+        id: 'customer:cloud.frontend.dashboard',
+        source: 'customer',
+        target: 'cloud.frontend.dashboard',
+        title: ''
+    },
+    {
+        id: 'support:cloud.frontend.adminPanel',
+        source: 'support',
+        target: 'cloud.frontend.adminPanel',
+        title: ''
+    },
+    {
+        id: 'cloud.backend.storage:amazon.s3',
+        source: 'cloud.backend.storage',
+        target: 'amazon.s3',
+        title: ''
+    },
+    {
+        id: 'amazon.api:cloud.backend.graphql',
+        source: 'amazon.api',
+        target: 'cloud.backend.graphql',
+        title: ''
+    },
+    {
+        id: 'cloud.backend.graphql:cloud.backend.storage',
+        source: 'cloud.backend.graphql',
+        target: 'cloud.backend.storage',
+        title: ''
+    },
+    {
+        id: 'cloud.frontend.dashboard:cloud.backend.graphql',
+        source: 'cloud.frontend.dashboard',
+        target: 'cloud.backend.graphql',
+        title: ''
+    },
+    {
+        id: 'cloud.frontend.adminPanel:cloud.backend.graphql',
+        source: 'cloud.frontend.adminPanel',
+        target: 'cloud.backend.graphql',
+        title: ''
+    }
+];
+describe('relation predicates', () => {
+    const expectRelations = (predicate) => expect(relations.filter(predicate).map(r => r.id));
+    const customer = 'customer';
+    const cloud = 'cloud';
+    const frontend = 'cloud.frontend';
+    const backend = 'cloud.backend';
+    it('isBetween: cloud.frontend -> cloud.backend', () => {
+        expectRelations(isBetween(frontend, backend)).toEqual([
+            'cloud.frontend.dashboard:cloud.backend.graphql',
+            'cloud.frontend.adminPanel:cloud.backend.graphql'
+        ]);
+    });
+    it('isBetween: cloud.frontend.dashboard -> cloud.backend', () => {
+        expectRelations(isBetween('cloud.frontend.dashboard', backend)).toEqual([
+            'cloud.frontend.dashboard:cloud.backend.graphql'
+        ]);
+    });
+    it('isBetween: cloud.backend -> cloud.frontend', () => {
+        expectRelations(isBetween(backend, frontend)).toEqual([]);
+    });
+    it('isBetween: cloud.backend -> cloud.backend', () => {
+        expectRelations(isBetween(backend, backend)).toEqual([
+            'cloud.backend.graphql:cloud.backend.storage'
+        ]);
+    });
+    it('isBetween: customer -> cloud', () => {
+        expectRelations(isBetween(customer, cloud)).toEqual(['customer:cloud.frontend.dashboard']);
+    });
+    it('isIncoming: customer', () => {
+        expectRelations(isIncoming(customer)).toEqual([]);
+    });
+    it('isIncoming: cloud', () => {
+        expectRelations(isIncoming(cloud)).toEqual([
+            'customer:cloud.frontend.dashboard',
+            'support:cloud.frontend.adminPanel',
+            'amazon.api:cloud.backend.graphql'
+        ]);
+    });
+    it('isIncoming: cloud.frontend', () => {
+        expectRelations(isIncoming(frontend)).toEqual([
+            'customer:cloud.frontend.dashboard',
+            'support:cloud.frontend.adminPanel'
+        ]);
+    });
+    it('isIncoming: cloud.frontend.dashboard', () => {
+        expectRelations(isIncoming('cloud.frontend.dashboard')).toEqual([
+            'customer:cloud.frontend.dashboard'
+        ]);
+    });
+    it('isOutgoing: cloud', () => {
+        expectRelations(isOutgoing(cloud)).toEqual(['cloud.backend.storage:amazon.s3']);
+    });
+    it('isOutgoing: cloud.frontend', () => {
+        expectRelations(isOutgoing(frontend)).toEqual([
+            'cloud.frontend.dashboard:cloud.backend.graphql',
+            'cloud.frontend.adminPanel:cloud.backend.graphql'
+        ]);
+    });
+    it('isOutgoing: cloud.backend.storage', () => {
+        expectRelations(isOutgoing('cloud.backend.storage')).toEqual([
+            'cloud.backend.storage:amazon.s3'
+        ]);
+    });
+    it('isInside: cloud', () => {
+        expectRelations(isInside(cloud)).toEqual([
+            'cloud.backend.graphql:cloud.backend.storage',
+            'cloud.frontend.dashboard:cloud.backend.graphql',
+            'cloud.frontend.adminPanel:cloud.backend.graphql'
+        ]);
+    });
+    it('isInside: cloud.frontend', () => {
+        expectRelations(isInside(frontend)).toEqual([]);
+    });
+    it('isInside: cloud.backend', () => {
+        expectRelations(isInside(backend)).toEqual(['cloud.backend.graphql:cloud.backend.storage']);
+    });
+    it('isAnyInOut: customer', () => {
+        expectRelations(isAnyInOut(customer)).toEqual(['customer:cloud.frontend.dashboard']);
+    });
+    it('isAnyInOut: cloud', () => {
+        expectRelations(isAnyInOut(cloud)).toEqual([
+            'customer:cloud.frontend.dashboard',
+            'support:cloud.frontend.adminPanel',
+            'cloud.backend.storage:amazon.s3',
+            'amazon.api:cloud.backend.graphql'
+        ]);
+    });
+    it('isAnyBetween: cloud and amazon', () => {
+        expectRelations(isAnyBetween(cloud, 'amazon')).toEqual([
+            'cloud.backend.storage:amazon.s3',
+            'amazon.api:cloud.backend.graphql'
+        ]);
+    });
+});
+describe('compareRelations', () => {
+    function rel(source, target) {
+        return {
+            source,
+            target
+        };
+    }
+    function sorted(...relations) {
+        return relations.sort(compareRelations).map(r => r.source + ' -> ' + r.target);
+    }
+    it('should sort by source and target', () => {
+        expect(sorted(rel('customer', 'cloud.ui'), rel('customer', 'cloud'))).toEqual([
+            'customer -> cloud',
+            'customer -> cloud.ui'
+        ]);
+        expect(sorted(rel('1', '2.1'), rel('1', '2'), rel('1.1.1', '2'), rel('1.1.1', '2.1'), rel('1.1', '2'))).toEqual(['1 -> 2', '1 -> 2.1', '1.1 -> 2', '1.1.1 -> 2', '1.1.1 -> 2.1']);
+    });
+    it('should sort by parent', () => {
+        expect(sorted(
+        // same parent
+        rel('cloud.1.1', 'cloud.2.1'), rel('cloud.1.1', 'cloud.2'), rel('cloud.1', 'cloud.2.1'), rel('cloud.1', 'cloud.2'), 
+        // no same parent
+        rel('cloud.1.1', 'aws.1'), rel('cloud.1', 'aws.1'), rel('cloud', 'aws'))).toEqual([
+            'cloud -> aws',
+            'cloud.1 -> aws.1',
+            'cloud.1.1 -> aws.1',
+            'cloud.1 -> cloud.2',
+            'cloud.1 -> cloud.2.1',
+            'cloud.1.1 -> cloud.2',
+            'cloud.1.1 -> cloud.2.1'
+        ]);
+    });
+    it('should sort by ancestors', () => {
+        expect(sorted(
+        // same parent 2nd level
+        rel('cloud.api.1', 'cloud.api.2'), rel('cloud.ui.1', 'cloud.ui.2'), rel('cloud.ui.2', 'cloud.ui.1'), 
+        // same ancestor cloud
+        rel('cloud.ui.1', 'cloud.api.1'), rel('cloud.ui.2', 'cloud.api.2'), rel('cloud.ui', 'cloud.api.1'), 
+        // same parent 1st level
+        rel('cloud.ui', 'cloud.api'), 
+        // no same parent
+        rel('cloud.api.1', 'aws.1'), rel('cloud.api', 'aws.1'), rel('cloud.api', 'aws'), rel('cloud.ui.1', 'aws.1'), rel('cloud.ui', 'aws'), rel('cloud', 'aws'))).toEqual([
+            'cloud -> aws',
+            'cloud.api -> aws',
+            'cloud.ui -> aws',
+            'cloud.api -> aws.1',
+            'cloud.api.1 -> aws.1',
+            'cloud.ui.1 -> aws.1',
+            'cloud.ui -> cloud.api',
+            'cloud.ui -> cloud.api.1',
+            'cloud.ui.1 -> cloud.api.1',
+            'cloud.ui.2 -> cloud.api.2',
+            'cloud.api.1 -> cloud.api.2',
+            'cloud.ui.1 -> cloud.ui.2',
+            'cloud.ui.2 -> cloud.ui.1'
+        ]);
+    });
+    it('should sort relations from example', () => {
+        expect(sorted(...relations)).toEqual([
+            'customer -> cloud.frontend.dashboard',
+            'support -> cloud.frontend.adminPanel',
+            'amazon.api -> cloud.backend.graphql',
+            'cloud.backend.storage -> amazon.s3',
+            'cloud.frontend.dashboard -> cloud.backend.graphql',
+            'cloud.frontend.adminPanel -> cloud.backend.graphql',
+            'cloud.backend.graphql -> cloud.backend.storage'
+        ]);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -11,16 +11,15 @@
   },
   "bugs": "https://github.com/likec4/likec4/issues",
   "scripts": {
-    "typecheck": "tsc -b",
-    "build": "tsc",
-    "prepack": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "prepack": "tsc",
     "lint": "run -T eslint src/ --fix",
     "test": "run -T vitest run",
     "clean": "run -T rimraf dist"
   },
   "files": [
     "dist",
-    "!dist/src/**",
+    "src",
     "!**/*.map"
   ],
   "type": "module",
@@ -71,10 +70,11 @@
     "type-fest": "^4.18.2"
   },
   "devDependencies": {
+    "@likec4/tsconfig": "1.2.1",
     "@total-typescript/ts-reset": "^0.5.1",
     "execa": "^9.1.0",
     "typescript": "^5.4.5",
-    "vitest": "~1.5.2"
+    "vitest": "~1.5.3"
   },
   "packageManager": "yarn@4.3.0"
 }

package/src/colors/element.ts

@@ -0,0 +1,80 @@
+import type { ElementThemeColors, ElementThemeColorValues } from '../types/theme'
+
+const blue = {
+  fill: '#3b82f6',
+  stroke: '#2563eb',
+  hiContrast: '#eff6ff',
+  loContrast: '#bfdbfe'
+} satisfies ElementThemeColorValues
+
+const sky = {
+  fill: '#0284c7',
+  stroke: '#0369a1',
+  hiContrast: '#f0f9ff',
+  loContrast: '#B6ECF7'
+} satisfies ElementThemeColorValues
+
+const slate = {
+  fill: '#64748b',
+  stroke: '#475569',
+  hiContrast: '#f8fafc',
+  loContrast: '#cbd5e1'
+} satisfies ElementThemeColorValues
+
+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: '#d4d4d4'
+  },
+  red: {
+    // fill: colors.red[500],
+    // stroke: colors.red[600],
+    // hiContrast: colors.red[50],
+    // loContrast: colors.red[200],
+    fill: '#AC4D39',
+    // fill: '#b54548',
+    stroke: '#853A2D',
+    // hiContrast: '#fef2f2',
+    // loContrast: '#fecaca',
+    // hiContrast: '#191111', // colors.gray[900],
+    // loContrast: '#3b1219' // colors.gray[800],
+    hiContrast: '#FBD3CB',
+    // hiContrast: '#f8fafc',
+    // loContrast: '#fdd8d8' // radix black red 12
+    loContrast: '#FF977D'
+  },
+  green: {
+    fill: '#428a4f',
+    stroke: '#2d5d39',
+    hiContrast: '#f8fafc',
+    loContrast: '#c2f0c2'
+  },
+  amber: {
+    fill: '#A35829',
+    stroke: '#7E451D',
+    hiContrast: '#FFE0C2',
+    loContrast: '#FFA057'
+  },
+  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'
+  }
+} as const satisfies ElementThemeColors

package/src/colors/index.ts

@@ -0,0 +1,12 @@
+import type { LikeC4Theme } from '../types/theme'
+import { ElementColors } from './element'
+import { RelationshipColors } from './relationships'
+
+export const defaultTheme = {
+  elements: ElementColors,
+  relationships: RelationshipColors,
+  font: 'Helvetica',
+  shadow: '#0a0a0a'
+} satisfies LikeC4Theme
+
+export { ElementColors, RelationshipColors }