@likec4/core 1.8.1 → 1.10.0

package/dist/colors/index.d.ts

@@ -1,133 +0,0 @@
-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: "#f5b2a3";
-        };
-        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: "#f9b27c";
-        };
-        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: "#f5b2a3";
-        };
-        secondary: {
-            lineColor: "#0ea5e9";
-            labelBgColor: "#082f49";
-            labelColor: "#38bdf8";
-        };
-        sky: {
-            lineColor: "#0ea5e9";
-            labelBgColor: "#082f49";
-            labelColor: "#38bdf8";
-        };
-        slate: {
-            lineColor: "#64748b";
-            labelBgColor: "#0f172a";
-            labelColor: "#cbd5e1";
-        };
-    };
-    font: "Arial";
-    shadow: "#0a0a0a";
-};
-export { ElementColors, RelationshipColors };
-//# sourceMappingURL=index.d.ts.map

package/dist/colors/index.js

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

package/dist/colors/relationships.d.ts

@@ -1,58 +0,0 @@
-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: "#f5b2a3";
-    };
-    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/colors/relationships.js

@@ -1,49 +0,0 @@
-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: '#FFE0C2'
-    },
-    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: '#AC4D39',
-        labelBgColor: '#b91c1c',
-        labelColor: '#f5b2a3'
-    },
-    secondary: sky,
-    sky,
-    slate
-};

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

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

package/dist/errors/errors.spec.js

@@ -1,69 +0,0 @@
-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

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

package/dist/errors/index.js

@@ -1,104 +0,0 @@
-import { CustomError } from 'ts-custom-error';
-import { isString } from '../utils/guards';
-/**
- * Base class for all errors in the LikeC4 library.
- */
-export class BaseError extends CustomError {
-    constructor(message, options) {
-        super(message, options);
-        // Set name explicitly as minification can mangle class names
-        Object.defineProperty(this, 'name', { value: 'BaseError' });
-    }
-}
-export class InvalidArgError extends BaseError {
-    constructor(message, options) {
-        super(message, options);
-        // Set name explicitly as minification can mangle class names
-        Object.defineProperty(this, 'name', { value: 'InvalidArgError' });
-    }
-}
-/**
- * Unknown error, mosly probably a bug, unhandled case or coming from a third-party library.
- */
-export class UnknownError extends BaseError {
-    constructor(message, options) {
-        super(message, options);
-        // Set name explicitly as minification can mangle class names
-        Object.defineProperty(this, 'name', { value: 'UnknownError' });
-    }
-}
-export class NullableError extends BaseError {
-    constructor(message, options) {
-        super(message, options);
-        // Set name explicitly as minification can mangle class names
-        Object.defineProperty(this, 'name', { value: 'NullableError' });
-    }
-}
-export class InvariantError extends BaseError {
-    constructor(message, options) {
-        super(message, options);
-        // Set name explicitly as minification can mangle class names
-        Object.defineProperty(this, 'name', { value: 'InvariantError' });
-    }
-}
-// Ensure that the value is NonNullable
-// Mostly as safer `value!`
-// eslint-disable-next-line @typescript-eslint/ban-types
-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);
-        // Set name explicitly as minification can mangle class names
-        Object.defineProperty(this, 'name', { value: 'RelationRefError' });
-    }
-}
-export function normalizeError(e) {
-    if (e instanceof BaseError || e instanceof Error) {
-        return e;
-    }
-    const message = isString(e) ? e : String(e);
-    const error = new UnknownError(message);
-    try {
-        // @ts-ignore
-        Error.captureStackTrace(error, normalizeError);
-    }
-    catch {
-        // Ignore
-    }
-    return error;
-}
-// Throw an error if the condition fails
-// > Not providing an inline default argument for message as the result is smaller
-export function invariant(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-condition, 
-// Can provide a string, or a function that returns a string for cases where
-// the message takes a fair amount of effort to compute
-message) {
-    if (condition) {
-        return;
-    }
-    throw new InvariantError(message ?? 'Invariant failed');
-}
-export class NonExhaustiveError extends BaseError {
-    constructor(message, options) {
-        super(message, options);
-        // Set name explicitly as minification can mangle class names
-        Object.defineProperty(this, 'name', { value: 'NonExhaustiveError' });
-    }
-}
-export function nonexhaustive(value) {
-    throw new NonExhaustiveError(`NonExhaustive value: ${value}`);
-}
-export class InvalidModelError extends BaseError {
-    constructor(message, options) {
-        super(message, options);
-        // Set name explicitly as minification can mangle class names
-        Object.defineProperty(this, 'name', { value: 'InvalidModelError' });
-    }
-}

package/dist/index.js

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

package/dist/types/_common.d.ts

@@ -1,9 +0,0 @@
-import type { Opaque } from './opaque';
-export type NonEmptyArray<T> = [T, ...T[]];
-export type IconUrl = Opaque<string, 'IconUrl'>;
-export type Point = readonly [x: number, y: number];
-export interface XYPoint {
-    x: number;
-    y: number;
-}
-//# sourceMappingURL=_common.d.ts.map

package/dist/types/_common.js

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

package/dist/types/element.d.ts

@@ -1,55 +0,0 @@
-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 declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
-export type BorderStyle = typeof BorderStyles[number];
-export type ElementKind = Opaque<string, 'ElementKind'>;
-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 {
-    border?: BorderStyle;
-    opacity?: number;
-}
-export type Tag = Opaque<string, 'Tag'>;
-export interface TagSpec {
-    readonly id: Tag;
-    readonly style: ElementStyle;
-}
-export interface Link {
-    readonly title?: string;
-    readonly url: string;
-}
-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<Link> | null;
-    readonly icon?: IconUrl;
-    readonly shape?: ElementShape;
-    readonly color?: ThemeColor;
-    readonly style?: ElementStyle;
-    readonly notation?: string;
-    readonly metadata?: {
-        [key: string]: string;
-    };
-}
-export interface ElementKindSpecificationStyle {
-    shape?: ElementShape;
-    icon?: IconUrl;
-    color?: ThemeColor;
-    border?: BorderStyle;
-    opacity?: number;
-}
-export interface ElementKindSpecification {
-    readonly technology?: string;
-    readonly notation?: string;
-    readonly style: ElementKindSpecificationStyle;
-}
-//# sourceMappingURL=element.d.ts.map

package/dist/types/element.js

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

package/dist/types/expression.d.ts

@@ -1,119 +0,0 @@
-import type { IconUrl } from './_common';
-import type { BorderStyle, ElementKind, ElementShape, Fqn, Tag } from './element';
-import type { WhereOperator } from './operators';
-import type { RelationshipArrowType, RelationshipLineType } from './relation';
-import type { ThemeColor } from './theme';
-import type { ViewID } from './view';
-interface BaseExpr {
-    where?: never;
-    element?: never;
-    custom?: never;
-    expanded?: never;
-    elementKind?: never;
-    elementTag?: never;
-    isEqual?: never;
-    isDescedants?: never;
-    wildcard?: never;
-    source?: never;
-    target?: never;
-    inout?: never;
-    incoming?: never;
-    outgoing?: never;
-    customRelation?: never;
-}
-export interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
-    element: Fqn;
-    isDescedants?: boolean;
-}
-export declare function isElementRef(expr: Expression): expr is ElementRefExpr;
-export interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
-    expanded: Fqn;
-}
-export declare function isExpandedElementExpr(expr: Expression): expr is ExpandedElementExpr;
-export interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
-    custom: {
-        expr: ElementExpression | ElementWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        shape?: ElementShape;
-        color?: ThemeColor;
-        icon?: IconUrl;
-        border?: BorderStyle;
-        opacity?: number;
-        navigateTo?: ViewID;
-    };
-}
-export declare function isCustomElement(expr: Expression): expr is CustomElementExpr;
-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 | ExpandedElementExpr;
-export declare function isElement(expr: Expression): expr is ElementExpression;
-export interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: ElementExpression;
-        condition: WhereOperator<string, string>;
-    };
-}
-export declare function isElementWhere(expr: Expression): expr is ElementWhereExpr;
-export type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
-export declare function isElementPredicateExpr(expr: Expression): expr is ElementPredicateExpression;
-export interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
-    source: ElementExpression;
-    target: ElementExpression;
-    isBidirectional?: boolean;
-}
-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 RelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
-export declare function isRelationExpression(expr: Expression): expr is RelationExpression;
-export interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: RelationExpression;
-        condition: WhereOperator<string, string>;
-    };
-}
-export declare function isRelationWhere(expr: Expression): expr is RelationWhereExpr;
-export interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
-    customRelation: {
-        relation: RelationExpression | RelationWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        color?: ThemeColor;
-        line?: RelationshipLineType;
-        head?: RelationshipArrowType;
-        tail?: RelationshipArrowType;
-    };
-}
-export declare function isCustomRelationExpr(expr: Expression): expr is CustomRelationExpr;
-export type RelationPredicateExpression = RelationExpression | RelationWhereExpr | CustomRelationExpr;
-export declare function isRelationPredicateExpr(expr: Expression): expr is RelationPredicateExpression;
-export type Expression = ElementPredicateExpression | RelationPredicateExpression;
-export {};
-//# sourceMappingURL=expression.d.ts.map