@likec4/core 1.8.1 → 1.10.0

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.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);
-    }
-}

package/dist/types/overview-graph.d.ts

@@ -1,41 +0,0 @@
-import type { NonEmptyArray, Point, XYPoint } from './_common';
-import type { BBox, ViewID } from './view';
-/**
- * OverviewGraph is a graph representation of all views in a model
- */
-export declare namespace OverviewGraph {
-    type Node = {
-        id: string;
-        type: 'folder' | 'file';
-        path: string;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
-    } | {
-        id: string;
-        type: 'view';
-        viewId: ViewID;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
-    };
-    /**
-     * Edge represents a navigational link from one view to another
-     */
-    type Edge = {
-        id: string;
-        source: string;
-        target: string;
-        points: NonEmptyArray<Point>;
-    };
-}
-export interface OverviewGraph {
-    nodes: OverviewGraph.Node[];
-    edges: OverviewGraph.Edge[];
-    bounds: BBox;
-}
-//# sourceMappingURL=overview-graph.d.ts.map

package/dist/types/overview-graph.js

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

package/dist/types/relation.d.ts

@@ -1,30 +0,0 @@
-import type { NonEmptyArray } from './_common';
-import type { Fqn, Link, Tag } from './element';
-import type { Opaque } from './opaque';
-import type { ThemeColor } from './theme';
-export type RelationID = Opaque<string, 'RelationID'>;
-export type RelationshipKind = Opaque<string, 'RelationshipKind'>;
-export type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
-export type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
-export declare const DefaultLineStyle = "dashed";
-export declare const DefaultArrowType = "normal";
-export declare const DefaultRelationshipColor = "gray";
-export interface Relation {
-    readonly id: RelationID;
-    readonly source: Fqn;
-    readonly target: Fqn;
-    readonly title: string;
-    readonly description?: string;
-    readonly technology?: string;
-    readonly tags?: NonEmptyArray<Tag>;
-    readonly kind?: RelationshipKind;
-    readonly color?: ThemeColor;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-    readonly links?: NonEmptyArray<Link>;
-    readonly metadata?: {
-        [key: string]: string;
-    };
-}
-//# sourceMappingURL=relation.d.ts.map

package/dist/types/relation.js

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

package/dist/types/theme.d.ts

@@ -1,27 +0,0 @@
-export type ThemeColor = 'amber' | 'blue' | 'gray' | 'slate' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky';
-export type HexColorLiteral = `#${string}`;
-export type ColorLiteral = HexColorLiteral;
-export interface ElementThemeColorValues {
-    fill: ColorLiteral;
-    stroke: ColorLiteral;
-    hiContrast: ColorLiteral;
-    loContrast: ColorLiteral;
-}
-export type ElementThemeColors = {
-    [key in ThemeColor]: ElementThemeColorValues;
-};
-export interface RelationshipThemeColorValues {
-    lineColor: ColorLiteral;
-    labelBgColor: ColorLiteral;
-    labelColor: ColorLiteral;
-}
-export type RelationshipThemeColors = {
-    [key in ThemeColor]: RelationshipThemeColorValues;
-};
-export interface LikeC4Theme {
-    font: 'Arial';
-    shadow: ColorLiteral;
-    relationships: RelationshipThemeColors;
-    elements: ElementThemeColors;
-}
-//# sourceMappingURL=theme.d.ts.map

package/dist/types/theme.js

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

package/dist/types/view-changes.d.ts

@@ -1,26 +0,0 @@
-import type { NonEmptyArray } from './_common';
-import type { BorderStyle, ElementShape, Fqn } from './element';
-import type { ThemeColor } from './theme';
-import type { AutoLayoutDirection, ViewManualLayout } from './view';
-export declare namespace ViewChange {
-    interface ChangeElementStyle {
-        op: 'change-element-style';
-        style: {
-            border?: BorderStyle;
-            opacity?: number;
-            shape?: ElementShape;
-            color?: ThemeColor;
-        };
-        targets: NonEmptyArray<Fqn>;
-    }
-    interface SaveManualLayout {
-        op: 'save-manual-layout';
-        layout: ViewManualLayout;
-    }
-    interface ChangeAutoLayout {
-        op: 'change-autolayout';
-        layout: AutoLayoutDirection;
-    }
-}
-export type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
-//# sourceMappingURL=view-changes.d.ts.map

package/dist/types/view-changes.js

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

package/dist/types/view-notation.d.ts

@@ -1,9 +0,0 @@
-import type { ElementKind, ElementShape } from './element';
-import type { ThemeColor } from './theme';
-export type ElementNotation = {
-    kinds: ElementKind[];
-    shape: ElementShape;
-    color: ThemeColor;
-    title: string;
-};
-//# sourceMappingURL=view-notation.d.ts.map

package/dist/types/view-notation.js

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