@likec4/core 1.8.0 → 1.9.0

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.d.ts

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

package/dist/types/expression.js

@@ -1,67 +0,0 @@
-export function isElementRef(expr) {
-    return 'element' in expr;
-}
-export function isExpandedElementExpr(expr) {
-    return 'expanded' in expr;
-}
-export function isCustomElement(expr) {
-    return 'custom' in expr && (isElement(expr.custom.expr) || isElementWhere(expr.custom.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)
-        || isExpandedElementExpr(expr);
-}
-export function isElementWhere(expr) {
-    return 'where' in expr && isElement(expr.where.expr);
-}
-export function isElementPredicateExpr(expr) {
-    return isElement(expr) || isElementWhere(expr) || isCustomElement(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 isRelationExpression(expr) {
-    return isRelation(expr) || isInOut(expr) || isIncoming(expr) || isOutgoing(expr);
-}
-export function isRelationWhere(expr) {
-    return 'where' in expr && isRelationExpression(expr.where.expr);
-}
-export function isCustomRelationExpr(expr) {
-    return 'customRelation' in expr;
-}
-export function isRelationPredicateExpr(expr) {
-    return isRelationExpression(expr) || isRelationWhere(expr) || isCustomRelationExpr(expr);
-}
-// export const Expr = {
-//   isElementRef,
-//   isWildcard,
-//   isElementKindExpr,
-//   isElementTagExpr,
-//   isElement,
-//   isRelation,
-//   isInOut,
-//   isIncoming,
-//   isOutgoing,
-//   isAnyRelation,
-// }

package/dist/types/index.d.ts

@@ -1,14 +0,0 @@
-export * from './_common';
-export * from './element';
-export * from './expression';
-export * from './model';
-export * from './opaque';
-export * from './operators';
-export * from './overview-graph';
-export * from './relation';
-export * from './theme';
-export * from './view';
-export * from './view-changes';
-export * from './view-notation';
-export * as Expr from './expression';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -1,14 +0,0 @@
-export * from './_common';
-export * from './element';
-export * from './expression';
-export * from './model';
-export * from './opaque';
-export * from './operators';
-export * from './overview-graph';
-export * from './relation';
-export * from './theme';
-export * from './view';
-export * from './view-changes';
-export * from './view-notation';
-import * as Expr_1 from './expression';
-export { Expr_1 as Expr };

package/dist/types/model.d.ts

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

package/dist/types/model.js

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

package/dist/types/opaque.d.ts

@@ -1,103 +0,0 @@
-declare const tag: unique symbol;
-type Tagged<Token> = {
-    readonly [tag]: Token;
-};
-/**
-Create an opaque type, which hides its internal details from the public, and can only be created by being used explicitly.
-
-The generic type parameter can be anything. It doesn't have to be an object.
-
-[Read more about opaque types.](https://codemix.com/opaque-types-in-javascript/)
-
-There have been several discussions about adding this feature to TypeScript via the `opaque type` operator, similar to how Flow does it. Unfortunately, nothing has (yet) moved forward:
-    - [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
-    - [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
-    - [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
-
-@example
-```
-import type {Opaque} from 'type-fest';
-
-type AccountNumber = Opaque<number, 'AccountNumber'>;
-type AccountBalance = Opaque<number, 'AccountBalance'>;
-
-// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
-type ThingOne = Opaque<string>;
-type ThingTwo = Opaque<string>;
-
-// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
-// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
-type NewThingOne = Opaque<string, 'ThingOne'>;
-type NewThingTwo = Opaque<string, 'ThingTwo'>;
-
-// Now they're completely separate types, so the following will fail to compile.
-function createNewThingOne (): NewThingOne {
-    // As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
-    return 'new thing one' as NewThingOne;
-}
-
-// This will fail to compile, as they are fundamentally different types.
-const thingTwo = createNewThingOne() as NewThingTwo;
-
-// Here's another example of opaque typing.
-function createAccountNumber(): AccountNumber {
-    return 2 as AccountNumber;
-}
-
-function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
-    return 4 as AccountBalance;
-}
-
-// This will compile successfully.
-getMoneyForAccount(createAccountNumber());
-
-// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
-getMoneyForAccount(2);
-
-// You can use opaque values like they aren't opaque too.
-const accountNumber = createAccountNumber();
-
-// This will not compile successfully.
-const newAccountNumber = accountNumber + 2;
-
-// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
-type Person = {
-    id: Opaque<number, Person>;
-    name: string;
-};
-```
-
-@category Type
-*/
-export type Opaque<Type, Token = unknown> = Type & Tagged<Token>;
-/**
-Revert an opaque type back to its original type by removing the readonly `[tag]`.
-
-Why is this necessary?
-
-1. Use an `Opaque` type as object keys
-2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
-
-@example
-```
-import type {Opaque, UnwrapOpaque} from 'type-fest';
-
-type AccountType = Opaque<'SAVINGS' | 'CHECKING', 'AccountType'>;
-
-const moneyByAccountType: Record<UnwrapOpaque<AccountType>, number> = {
-    SAVINGS: 99,
-    CHECKING: 0.1
-};
-
-// Without UnwrapOpaque, the following expression would throw a type error.
-const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
-
-// Attempting to pass an non-Opaque type to UnwrapOpaque will raise a type error.
-type WontWork = UnwrapOpaque<string>;
-```
-
-@category Type
-*/
-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/opaque.js

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

package/dist/types/operators.d.ts

@@ -1,44 +0,0 @@
-import type { NonEmptyArray } from './_common';
-export type EqualOperator<V> = {
-    eq: V;
-    neq?: never;
-} | {
-    eq?: never;
-    neq: V;
-};
-type AllNever = {
-    not?: never;
-    and?: never;
-    or?: never;
-    tag?: never;
-    kind?: never;
-};
-export type TagEqual<Tag> = Omit<AllNever, 'tag'> & {
-    tag: EqualOperator<Tag>;
-};
-export declare const isTagEqual: <Tag>(operator: WhereOperator<Tag, any>) => operator is TagEqual<Tag>;
-export type KindEqual<Kind> = Omit<AllNever, 'kind'> & {
-    kind: EqualOperator<Kind>;
-};
-export declare const isKindEqual: <Kind>(operator: WhereOperator<any, Kind>) => operator is KindEqual<Kind>;
-export type NotOperator<Tag, Kind> = Omit<AllNever, 'not'> & {
-    not: WhereOperator<Tag, Kind>;
-};
-export declare const isNotOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is NotOperator<Tag, Kind>;
-export type AndOperator<Tag, Kind> = Omit<AllNever, 'and'> & {
-    and: NonEmptyArray<WhereOperator<Tag, Kind>>;
-};
-export declare const isAndOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is AndOperator<Tag, Kind>;
-export type OrOperator<Tag, Kind> = Omit<AllNever, 'or'> & {
-    or: NonEmptyArray<WhereOperator<Tag, Kind>>;
-};
-export declare const isOrOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is OrOperator<Tag, Kind>;
-export type WhereOperator<Tag, Kind> = TagEqual<Tag> | KindEqual<Kind> | NotOperator<Tag, Kind> | AndOperator<Tag, Kind> | OrOperator<Tag, Kind>;
-type Filterable<FTag extends string = string, FKind extends string = string> = {
-    tags?: FTag[] | null;
-    kind?: FKind;
-};
-type OperatorPredicate<V extends Filterable> = (value: V) => boolean;
-export declare function whereOperatorAsPredicate<FTag extends string = string, FKind extends string = string>(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable<FTag, FKind>>;
-export {};
-//# sourceMappingURL=operators.d.ts.map

package/dist/types/operators.js

@@ -1,59 +0,0 @@
-import { allPass, anyPass, isNot, isNullish } from 'remeda';
-import { nonexhaustive } from '../errors';
-export const isTagEqual = (operator) => {
-    return 'tag' in operator;
-};
-export const isKindEqual = (operator) => {
-    return 'kind' in operator;
-};
-export const isNotOperator = (operator) => {
-    return 'not' in operator;
-};
-export const isAndOperator = (operator) => {
-    return 'and' in operator;
-};
-export const isOrOperator = (operator) => {
-    return 'or' in operator;
-};
-export function whereOperatorAsPredicate(operator) {
-    switch (true) {
-        case isTagEqual(operator): {
-            if ('eq' in operator.tag) {
-                const tag = operator.tag.eq;
-                return (value) => {
-                    return Array.isArray(value.tags) && value.tags.includes(tag);
-                };
-            }
-            const tag = operator.tag.neq;
-            return (value) => {
-                return !Array.isArray(value.tags) || !value.tags.includes(tag);
-            };
-        }
-        case isKindEqual(operator): {
-            if ('eq' in operator.kind) {
-                const kind = operator.kind.eq;
-                return (value) => {
-                    return value.kind === kind;
-                };
-            }
-            const kind = operator.kind.neq;
-            return (value) => {
-                return isNullish(value.kind) || value.kind !== kind;
-            };
-        }
-        case isNotOperator(operator): {
-            const predicate = whereOperatorAsPredicate(operator.not);
-            return isNot(predicate);
-        }
-        case isAndOperator(operator): {
-            const predicates = operator.and.map(whereOperatorAsPredicate);
-            return allPass(predicates);
-        }
-        case isOrOperator(operator): {
-            const predicates = operator.or.map(whereOperatorAsPredicate);
-            return anyPass(predicates);
-        }
-        default:
-            nonexhaustive(operator);
-    }
-}