@likec4/core 1.0.0-next.2 → 1.0.0

package/dist/esm/types/expression.d.ts

@@ -1,71 +0,0 @@
-import type { ElementKind, ElementShape, Fqn, Tag } from './element';
-import type { ThemeColor } from './theme';
-import type { ViewID } from './view';
-interface BaseExpr {
-    element?: never;
-    custom?: never;
-    elementKind?: never;
-    elementTag?: never;
-    isEqual?: never;
-    isDescedants?: never;
-    wildcard?: never;
-    source?: never;
-    target?: never;
-    inout?: never;
-    incoming?: never;
-    outgoing?: never;
-}
-export interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
-    element: Fqn;
-    isDescedants?: boolean;
-}
-export declare function isElementRef(expr: Expression): expr is ElementRefExpr;
-export interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
-    custom: {
-        element: Fqn;
-        title?: string;
-        description?: string;
-        technology?: string;
-        shape?: ElementShape;
-        color?: ThemeColor;
-        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;
-export declare function isElement(expr: Expression): expr is ElementExpression;
-export interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
-    source: ElementExpression;
-    target: ElementExpression;
-}
-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 AnyRelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
-export declare function isAnyRelation(expr: Expression): expr is AnyRelationExpression;
-export type Expression = ElementExpression | CustomElementExpr | AnyRelationExpression;
-export {};

package/dist/esm/types/expression.js

@@ -1,33 +0,0 @@
-export function isElementRef(expr) {
-  return "element" in expr;
-}
-export function isCustomElement(expr) {
-  return "custom" in 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);
-}
-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 isAnyRelation(expr) {
-  return isRelation(expr) || isInOut(expr) || isIncoming(expr) || isOutgoing(expr);
-}

package/dist/esm/types/index.d.ts

@@ -1,11 +0,0 @@
-export * from './_common';
-export * from './computed-view';
-export * from './diagram';
-export * from './element';
-export * from './expression';
-export * from './model';
-export * from './opaque';
-export * from './relation';
-export * from './theme';
-export * from './view';
-export * as Expr from './expression';

package/dist/esm/types/index.js

@@ -1,11 +0,0 @@
-export * from "./_common.js";
-export * from "./computed-view.js";
-export * from "./diagram.js";
-export * from "./element.js";
-export * from "./expression.js";
-export * from "./model.js";
-export * from "./opaque.js";
-export * from "./relation.js";
-export * from "./theme.js";
-export * from "./view.js";
-export * as Expr from "./expression.js";

package/dist/esm/types/model.d.ts

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

package/dist/esm/types/opaque.d.ts

@@ -1,102 +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 {};

package/dist/esm/types/relation.d.ts

@@ -1,24 +0,0 @@
-import type { NonEmptyArray } from './_common';
-import type { Fqn, 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' | '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 tags?: NonEmptyArray<Tag>;
-    readonly kind?: RelationshipKind;
-    readonly color?: ThemeColor;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-    readonly links?: NonEmptyArray<string>;
-}

package/dist/esm/types/relation.js

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

package/dist/esm/types/theme.d.ts

@@ -1,26 +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: 'Helvetica';
-    shadow: ColorLiteral;
-    relationships: RelationshipThemeColors;
-    elements: ElementThemeColors;
-}

package/dist/esm/types/view.d.ts

@@ -1,62 +0,0 @@
-import type { IconUrl, NonEmptyArray } from './_common';
-import type { ElementShape, Fqn, Tag } from './element';
-import type { ElementExpression, Expression } from './expression';
-import type { Opaque } from './opaque';
-import type { ThemeColor } from './theme';
-export type ViewID = Opaque<string, 'ViewID'>;
-export type ViewRuleExpression = {
-    include: Expression[];
-    exclude?: never;
-} | {
-    include?: never;
-    exclude: Expression[];
-};
-export declare function isViewRuleExpression(rule: ViewRule): rule is ViewRuleExpression;
-export interface ViewRuleStyle {
-    targets: ElementExpression[];
-    style: {
-        color?: ThemeColor;
-        shape?: ElementShape;
-        icon?: IconUrl;
-    };
-}
-export declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;
-export type AutoLayoutDirection = 'TB' | 'BT' | 'LR' | 'RL';
-export interface ViewRuleAutoLayout {
-    autoLayout: AutoLayoutDirection;
-}
-export declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
-export type ViewRule = ViewRuleExpression | ViewRuleStyle | ViewRuleAutoLayout;
-export interface BasicElementView {
-    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.
-     */
-    readonly docUri?: string;
-    /**
-     * For all views we find common ancestor path.
-     * This is used to generate relative paths, i.e.:
-     * - "" for views in the common ancestor directory (or root)
-     * - "subdir" for views in "<root>/subdir"
-     * - "subdir/subdir1" for views in "<root>/subdir/subdir1"
-     *
-     * Undefined if the view is auto-generated.
-     */
-    readonly relativePath?: string;
-}
-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;

package/dist/esm/types/view.js

@@ -1,15 +0,0 @@
-export function isViewRuleExpression(rule) {
-  return "include" in rule && Array.isArray(rule.include) || "exclude" in rule && Array.isArray(rule.exclude);
-}
-export function isViewRuleStyle(rule) {
-  return "style" in rule && "targets" in rule;
-}
-export function isViewRuleAutoLayout(rule) {
-  return "autoLayout" in rule;
-}
-export function isStrictElementView(view) {
-  return "viewOf" in view;
-}
-export function isExtendsElementView(view) {
-  return "extends" in view;
-}

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

@@ -1,33 +0,0 @@
-import type { Element, Fqn } from '../types';
-export declare function nameFromFqn(fqn: Fqn): string;
-export declare function isAncestor<E extends {
-    id: Fqn;
-}>(...args: [ancestor: string, another: string] | [ancestor: E, another: E]): boolean;
-export declare function isSameHierarchy<E extends {
-    id: Fqn;
-}>(one: E | Fqn, another: E | Fqn): boolean;
-export declare function isDescendantOf<E extends {
-    id: Fqn;
-}>(ancestors: E[]): (e: E) => boolean;
-export declare function notDescendantOf(ancestors: Element[]): (e: Element) => boolean;
-export declare function commonAncestor(first: Fqn, second: Fqn): Fqn | null;
-export declare function parentFqn(fqn: Fqn): Fqn | null;
-/**
- * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
- * (from closest to root)
- */
-export declare function ancestorsFqn(fqn: Fqn): Fqn[];
-/**
- * Compares two fully qualified names (fqns) hierarchically based on their depth.
- * From parent nodes to leaves
- *
- * @param {string} a - The first fqn to compare.
- * @param {string} b - The second fqn to compare.
- * @returns {number} - 0 if the fqns have the same depth.
- *                    - Positive number if a is deeper than b.
- *                    - Negative number if b is deeper than a.
- */
-export declare function compareFqnHierarchically<T extends string = string>(a: T, b: T): number;
-export declare function compareByFqnHierarchically<T extends {
-    id: string;
-}>(a: T, b: T): number;

package/dist/esm/utils/fqn.js

@@ -1,83 +0,0 @@
-import { isString } from "./guards.js";
-export function nameFromFqn(fqn) {
-  const lastDot = fqn.lastIndexOf(".");
-  if (lastDot > 0) {
-    return fqn.slice(lastDot + 1);
-  } else {
-    return fqn;
-  }
-}
-export function isAncestor(...args) {
-  const ancestor = isString(args[0]) ? args[0] : args[0].id;
-  const another = isString(args[1]) ? args[1] : args[1].id;
-  return another.startsWith(ancestor + ".");
-}
-export function isSameHierarchy(one, another) {
-  const first = isString(one) ? one : one.id;
-  const second = isString(another) ? another : another.id;
-  return first === second || second.startsWith(first + ".") || first.startsWith(second + ".");
-}
-export function isDescendantOf(ancestors) {
-  const predicates = ancestors.flatMap((a) => [(e) => e.id === a.id, (e) => isAncestor(a, e)]);
-  return (e) => predicates.some((p) => p(e));
-}
-export function notDescendantOf(ancestors) {
-  const isDescendant = isDescendantOf(ancestors);
-  return (e) => !isDescendant(e);
-}
-export function commonAncestor(first, second) {
-  const parentA = parentFqn(first);
-  const parentB = parentFqn(second);
-  if (parentA === parentB) {
-    return parentA;
-  }
-  if (!parentA || !parentB) {
-    return null;
-  }
-  const a = first.split(".");
-  const b = second.split(".");
-  let ancestor = null;
-  while (a.length > 1 && b.length > 1 && !!a[0] && a[0] === b[0]) {
-    ancestor = ancestor ? `${ancestor}.${a[0]}` : a[0];
-    a.shift();
-    b.shift();
-  }
-  return ancestor;
-}
-export function parentFqn(fqn) {
-  const lastDot = fqn.lastIndexOf(".");
-  if (lastDot > 0) {
-    return fqn.substring(0, lastDot);
-  }
-  return null;
-}
-export function ancestorsFqn(fqn) {
-  const path = fqn.split(".");
-  path.pop();
-  if (path.length === 0) {
-    return [];
-  }
-  return path.reduce((acc, _, idx) => {
-    const ancestor = path.slice(0, idx + 1).join(".");
-    acc.unshift(ancestor);
-    return acc;
-  }, []);
-}
-export function compareFqnHierarchically(a, b) {
-  const depthA = a.split(".").length;
-  const depthB = b.split(".").length;
-  switch (true) {
-    case depthA > depthB: {
-      return 1;
-    }
-    case depthA < depthB: {
-      return -1;
-    }
-    default: {
-      return 0;
-    }
-  }
-}
-export function compareByFqnHierarchically(a, b) {
-  return compareFqnHierarchically(a.id, b.id);
-}

package/dist/esm/utils/guards.d.ts

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

package/dist/esm/utils/guards.js

@@ -1,7 +0,0 @@
-export { hasAtLeast } from "remeda";
-export function isString(value) {
-  return value != null && typeof value === "string";
-}
-export function isNonEmptyArray(arr) {
-  return !!arr && Array.isArray(arr) && arr.length > 0;
-}

package/dist/esm/utils/index.d.ts

@@ -1,3 +0,0 @@
-export * from './fqn';
-export * from './guards';
-export * from './relations';

package/dist/esm/utils/index.js

@@ -1,3 +0,0 @@
-export * from "./fqn.js";
-export * from "./guards.js";
-export * from "./relations.js";

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

@@ -1,29 +0,0 @@
-import type { Fqn } from '../types';
-type Relation = {
-    source: string;
-    target: string;
-};
-type RelationPredicate = (rel: Relation) => boolean;
-/**
- * Compares two relations hierarchically.
- * From the most general (implicit) to the most specific.
- */
-export declare const compareRelations: <T extends {
-    source: string;
-    target: string;
-}>(a: T, b: T) => number;
-export declare const Relations: {
-    readonly isInside: (parent: Fqn) => RelationPredicate;
-    readonly isBetween: (source: Fqn, target: Fqn) => RelationPredicate;
-    readonly isAnyBetween: (source: Fqn, target: Fqn) => RelationPredicate;
-    readonly isIncoming: (target: Fqn) => RelationPredicate;
-    readonly isOutgoing: (source: Fqn) => RelationPredicate;
-    readonly isAnyInOut: (source: Fqn) => RelationPredicate;
-    readonly hasRelation: <R extends {
-        source: Fqn;
-        target: Fqn;
-    }>(rel: R) => <E extends {
-        id: Fqn;
-    }>(element: E) => boolean;
-};
-export {};

package/dist/esm/utils/relations.js

@@ -1,69 +0,0 @@
-import { commonAncestor, compareFqnHierarchically, isAncestor } from "./fqn.js";
-export const compareRelations = (a, b) => {
-  const parentA = commonAncestor(a.source, a.target);
-  const parentB = commonAncestor(b.source, b.target);
-  if (parentA && !parentB) {
-    return 1;
-  }
-  if (!parentA && parentB) {
-    return -1;
-  }
-  const compareParents = parentA && parentB ? compareFqnHierarchically(parentA, parentB) : 0;
-  if (compareParents === 0) {
-    const compareSource = compareFqnHierarchically(a.source, b.source);
-    if (compareSource !== 0) {
-      return compareSource;
-    }
-    return compareFqnHierarchically(a.target, b.target);
-  }
-  return compareParents;
-};
-const isInside = (parent) => {
-  const prefix = parent + ".";
-  return (rel) => {
-    return rel.source.startsWith(prefix) && rel.target.startsWith(prefix);
-  };
-};
-const isBetween = (source, target) => {
-  const sourcePrefix = source + ".";
-  const targetPrefix = target + ".";
-  return (rel) => {
-    return (rel.source === source || (rel.source + ".").startsWith(sourcePrefix)) && (rel.target === target || (rel.target + ".").startsWith(targetPrefix));
-  };
-};
-const isAnyBetween = (source, target) => {
-  const predicates = [isBetween(source, target), isBetween(target, source)];
-  return (rel) => predicates.some((p) => p(rel));
-};
-const isIncoming = (target) => {
-  const targetPrefix = target + ".";
-  return (rel) => {
-    return !(rel.source + ".").startsWith(targetPrefix) && (rel.target === target || (rel.target + ".").startsWith(targetPrefix));
-  };
-};
-const isOutgoing = (source) => {
-  const sourcePrefix = source + ".";
-  return (rel) => {
-    return (rel.source === source || (rel.source + ".").startsWith(sourcePrefix)) && !(rel.target + ".").startsWith(sourcePrefix);
-  };
-};
-const isAnyInOut = (source) => {
-  const predicates = [isIncoming(source), isOutgoing(source)];
-  return (rel) => {
-    return predicates.some((p) => p(rel));
-  };
-};
-const hasRelation = (rel) => {
-  return (element) => {
-    return rel.source === element.id || rel.target === element.id || isAncestor(element.id, rel.source) || isAncestor(element.id, rel.target);
-  };
-};
-export const Relations = {
-  isInside,
-  isBetween,
-  isAnyBetween,
-  isIncoming,
-  isOutgoing,
-  isAnyInOut,
-  hasRelation
-};