@likec4/core 0.31.0 → 0.33.0

package/dist/types/expression.mjs

@@ -0,0 +1,30 @@
+export function isElementRef(expr) {
+  return "element" in expr && "isDescedants" 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/types/index.d.ts

@@ -3,6 +3,7 @@ export { isViewRuleExpression, isViewRuleAutoLayout, isViewRuleStyle } from './v
 export * as Expr from './expression';
 export type * from './_common';
 export type * from './opaque';
+export type * from './theme';
 export type * from './element';
 export type * from './relation';
 export type * from './model';
@@ -10,4 +11,3 @@ export type * from './view';
 export type * from './expression';
 export type * from './computed-view';
 export type * from './diagram';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -1,4 +1,48 @@
-export { AsFqn, DefaultThemeColor, DefaultElementShape } from './element';
-export { isViewRuleExpression, isViewRuleAutoLayout, isViewRuleStyle } from './view';
-export * as Expr from './expression';
-//# sourceMappingURL=index.js.map
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AsFqn", {
+  enumerable: true,
+  get: function () {
+    return _element.AsFqn;
+  }
+});
+Object.defineProperty(exports, "DefaultElementShape", {
+  enumerable: true,
+  get: function () {
+    return _element.DefaultElementShape;
+  }
+});
+Object.defineProperty(exports, "DefaultThemeColor", {
+  enumerable: true,
+  get: function () {
+    return _element.DefaultThemeColor;
+  }
+});
+exports.Expr = void 0;
+Object.defineProperty(exports, "isViewRuleAutoLayout", {
+  enumerable: true,
+  get: function () {
+    return _view.isViewRuleAutoLayout;
+  }
+});
+Object.defineProperty(exports, "isViewRuleExpression", {
+  enumerable: true,
+  get: function () {
+    return _view.isViewRuleExpression;
+  }
+});
+Object.defineProperty(exports, "isViewRuleStyle", {
+  enumerable: true,
+  get: function () {
+    return _view.isViewRuleStyle;
+  }
+});
+var _element = require("./element");
+var _view = require("./view");
+var _Expr = _interopRequireWildcard(require("./expression"));
+exports.Expr = _Expr;
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/dist/types/index.mjs

@@ -0,0 +1,3 @@
+export { AsFqn, DefaultThemeColor, DefaultElementShape } from "./element.mjs";
+export { isViewRuleExpression, isViewRuleAutoLayout, isViewRuleStyle } from "./view.mjs";
+export * as Expr from "./expression.mjs";

package/dist/types/model.d.ts

@@ -7,4 +7,3 @@ export interface LikeC4Model {
     relations: Record<RelationID, Relation>;
     views: Record<ViewID, ComputedView>;
 }
-//# sourceMappingURL=model.d.ts.map

package/dist/types/model.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=model.js.map
+"use strict";

package/dist/types/opaque.d.ts

@@ -100,4 +100,3 @@ 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/opaque.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=opaque.js.map
+"use strict";

package/dist/types/relation.d.ts

@@ -8,4 +8,3 @@ export interface Relation {
     readonly title: string;
     readonly tags?: Tag[];
 }
-//# sourceMappingURL=relation.d.ts.map

package/dist/types/relation.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=relation.js.map
+"use strict";

package/dist/types/theme.d.ts

@@ -0,0 +1,22 @@
+export type ThemeColor = 'amber' | 'blue' | 'gray' | 'slate' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky';
+export type HexColorLiteral = `#${string}`;
+export type ColorLiteral = HexColorLiteral;
+export interface ThemeColorValues {
+    fill: ColorLiteral;
+    stroke: ColorLiteral;
+    hiContrast: ColorLiteral;
+    loContrast: ColorLiteral;
+}
+export type ThemeColors = {
+    [key in ThemeColor]: ThemeColorValues;
+};
+export interface ThemeRelationColors {
+    lineColor: ColorLiteral;
+    labelColor: ColorLiteral;
+}
+export interface LikeC4Theme {
+    font: 'Helvetica';
+    shadow: ColorLiteral;
+    relation: ThemeRelationColors;
+    colors: ThemeColors;
+}

package/dist/types/theme.js

@@ -0,0 +1 @@
+"use strict";

package/dist/types/view.d.ts

@@ -1,7 +1,8 @@
 import type { Opaque } from './opaque';
-import type { ElementShape, Fqn, Tag, ThemeColor } from './element';
+import type { ElementShape, Fqn, Tag } from './element';
 import type { ElementExpression, Expression } from './expression';
-import type { NonEmptyArray } from './_common';
+import type { IconUrl, NonEmptyArray } from './_common';
+import type { ThemeColor } from './theme';
 export type ViewID = Opaque<string, 'ViewID'>;
 export interface ViewRuleExpression {
     isInclude: boolean;
@@ -13,6 +14,7 @@ export interface ViewRuleStyle {
     style: {
         color?: ThemeColor;
         shape?: ElementShape;
+        icon?: IconUrl;
     };
 }
 export declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;
@@ -30,4 +32,3 @@ export interface ElementView {
     readonly links: NonEmptyArray<string> | null;
     readonly rules: ViewRule[];
 }
-//# sourceMappingURL=view.d.ts.map

package/dist/types/view.js

@@ -1,10 +1,17 @@
-export function isViewRuleExpression(rule) {
-    return 'exprs' in rule && 'isInclude' in rule;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isViewRuleAutoLayout = isViewRuleAutoLayout;
+exports.isViewRuleExpression = isViewRuleExpression;
+exports.isViewRuleStyle = isViewRuleStyle;
+function isViewRuleExpression(rule) {
+  return "exprs" in rule && "isInclude" in rule;
 }
-export function isViewRuleStyle(rule) {
-    return 'style' in rule && 'targets' in rule;
+function isViewRuleStyle(rule) {
+  return "style" in rule && "targets" in rule;
 }
-export function isViewRuleAutoLayout(rule) {
-    return 'autoLayout' in rule;
-}
-//# sourceMappingURL=view.js.map
+function isViewRuleAutoLayout(rule) {
+  return "autoLayout" in rule;
+}

package/dist/types/view.mjs

@@ -0,0 +1,9 @@
+export function isViewRuleExpression(rule) {
+  return "exprs" in rule && "isInclude" in rule;
+}
+export function isViewRuleStyle(rule) {
+  return "style" in rule && "targets" in rule;
+}
+export function isViewRuleAutoLayout(rule) {
+  return "autoLayout" in rule;
+}

package/dist/utils/compute-node-levels.d.ts

@@ -5,4 +5,3 @@ type NodeLevelDepth = {
 };
 export declare const computeNodeLevels: ({ nodes }: ComputedView) => Record<import("..").Fqn, NodeLevelDepth>;
 export {};
-//# sourceMappingURL=compute-node-levels.d.ts.map

package/dist/utils/compute-node-levels.js

@@ -1,32 +1,48 @@
-import { invariant } from '../errors';
-export const computeNodeLevels = ({ nodes }) => {
-    const nodeLevels = {};
-    const compute = (node, level) => {
-        let levels = nodeLevels[node.id];
-        if (levels) {
-            return levels;
-        }
-        if (node.children.length === 0) {
-            levels = { level, depth: 0 };
-            nodeLevels[node.id] = levels;
-            return levels;
-        }
-        let depth = 1;
-        for (const childId of node.children) {
-            const child = nodes.find(n => n.id === childId);
-            invariant(child, `Child ${childId} not found`);
-            const { depth: childDepth } = compute(child, level + 1);
-            depth = Math.max(childDepth + 1, depth);
-        }
-        levels = { level, depth };
-        nodeLevels[node.id] = levels;
-        return levels;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeNodeLevels = void 0;
+var _errors = require("../errors");
+const computeNodeLevels = ({
+  nodes
+}) => {
+  const nodeLevels = {};
+  const compute = (node, level) => {
+    let levels = nodeLevels[node.id];
+    if (levels) {
+      return levels;
+    }
+    if (node.children.length === 0) {
+      levels = {
+        level,
+        depth: 0
+      };
+      nodeLevels[node.id] = levels;
+      return levels;
+    }
+    let depth = 1;
+    for (const childId of node.children) {
+      const child = nodes.find(n => n.id === childId);
+      (0, _errors.invariant)(child, `Child ${childId} not found`);
+      const {
+        depth: childDepth
+      } = compute(child, level + 1);
+      depth = Math.max(childDepth + 1, depth);
+    }
+    levels = {
+      level,
+      depth
     };
-    for (const node of nodes) {
-        if (!node.parent) {
-            compute(node, 0);
-        }
+    nodeLevels[node.id] = levels;
+    return levels;
+  };
+  for (const node of nodes) {
+    if (!node.parent) {
+      compute(node, 0);
     }
-    return nodeLevels;
+  }
+  return nodeLevels;
 };
-//# sourceMappingURL=compute-node-levels.js.map
+exports.computeNodeLevels = computeNodeLevels;

package/dist/utils/compute-node-levels.mjs

@@ -0,0 +1,31 @@
+import { invariant } from "../errors/index.mjs";
+export const computeNodeLevels = ({ nodes }) => {
+  const nodeLevels = {};
+  const compute = (node, level) => {
+    let levels = nodeLevels[node.id];
+    if (levels) {
+      return levels;
+    }
+    if (node.children.length === 0) {
+      levels = { level, depth: 0 };
+      nodeLevels[node.id] = levels;
+      return levels;
+    }
+    let depth = 1;
+    for (const childId of node.children) {
+      const child = nodes.find((n) => n.id === childId);
+      invariant(child, `Child ${childId} not found`);
+      const { depth: childDepth } = compute(child, level + 1);
+      depth = Math.max(childDepth + 1, depth);
+    }
+    levels = { level, depth };
+    nodeLevels[node.id] = levels;
+    return levels;
+  };
+  for (const node of nodes) {
+    if (!node.parent) {
+      compute(node, 0);
+    }
+  }
+  return nodeLevels;
+};

package/dist/utils/fqn.d.ts

@@ -1,8 +1,14 @@
 import type { Element, Fqn } from '../types';
 export declare function nameFromFqn(fqn: Fqn): string;
-export declare function isAncestor(...args: [ancestor: Fqn, another: Fqn] | [ancestor: Element, another: Element]): boolean;
-export declare function isSameHierarchy(...args: [one: Fqn, another: Fqn] | [one: Element, another: Element]): boolean;
-export declare function isDescendantOf(ancestors: Element[]): (e: Element) => boolean;
+export declare function isAncestor<E extends {
+    id: Fqn;
+}>(...args: [ancestor: Fqn, another: Fqn] | [ancestor: E, another: E]): boolean;
+export declare function isSameHierarchy<E extends {
+    id: Fqn;
+}>(...args: [one: Fqn, another: Fqn] | [one: E, another: E]): 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;
@@ -16,8 +22,7 @@ export declare function parentFqn(fqn: Fqn): Fqn | null;
  *                    - Positive number if a is deeper than b.
  *                    - Negative number if b is deeper than a.
  */
-export declare const compareFqnHierarchically: (a: string, b: string) => number;
-export declare const compareByFqnHierarchically: <T extends {
+export declare function compareFqnHierarchically(a: string, b: string): number;
+export declare function compareByFqnHierarchically<T extends {
     id: Fqn;
-}>(a: T, b: T) => number;
-//# sourceMappingURL=fqn.d.ts.map
+}>(a: T, b: T): number;

package/dist/utils/fqn.js

@@ -1,83 +1,80 @@
-import { anyPass } from 'remeda';
-import { isString } from './guards';
-export function nameFromFqn(fqn) {
-    const lastDot = fqn.lastIndexOf('.');
-    if (lastDot > 0) {
-        return fqn.slice(lastDot + 1);
-    }
-    else {
-        return fqn;
-    }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.commonAncestor = commonAncestor;
+exports.compareByFqnHierarchically = compareByFqnHierarchically;
+exports.compareFqnHierarchically = compareFqnHierarchically;
+exports.isAncestor = isAncestor;
+exports.isDescendantOf = isDescendantOf;
+exports.isSameHierarchy = isSameHierarchy;
+exports.nameFromFqn = nameFromFqn;
+exports.notDescendantOf = notDescendantOf;
+exports.parentFqn = parentFqn;
+var _remeda = require("remeda");
+var _guards = require("./guards");
+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 + '.');
+function isAncestor(...args) {
+  const ancestor = (0, _guards.isString)(args[0]) ? args[0] : args[0].id;
+  const another = (0, _guards.isString)(args[1]) ? args[1] : args[1].id;
+  return another.startsWith(ancestor + ".");
 }
-export function isSameHierarchy(...args) {
-    const one = isString(args[0]) ? args[0] : args[0].id;
-    const another = isString(args[1]) ? args[1] : args[1].id;
-    return one === another || another.startsWith(one + '.') || one.startsWith(another + '.');
+function isSameHierarchy(...args) {
+  const one = (0, _guards.isString)(args[0]) ? args[0] : args[0].id;
+  const another = (0, _guards.isString)(args[1]) ? args[1] : args[1].id;
+  return one === another || another.startsWith(one + ".") || one.startsWith(another + ".");
 }
-export function isDescendantOf(ancestors) {
-    const predicates = ancestors.flatMap(a => [
-        (e) => e.id === a.id,
-        (e) => isAncestor(a, e)
-    ]);
-    return anyPass(predicates);
+function isDescendantOf(ancestors) {
+  const predicates = ancestors.flatMap(a => [e => e.id === a.id, e => isAncestor(a, e)]);
+  return (0, _remeda.anyPass)(predicates);
 }
-export function notDescendantOf(ancestors) {
-    const isDescendant = isDescendantOf(ancestors);
-    return (e) => !isDescendant(e);
+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);
-    }
+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;
+}
+function parentFqn(fqn) {
+  const lastDot = fqn.lastIndexOf(".");
+  if (lastDot > 0) {
+    return fqn.substring(0, lastDot);
+  }
+  return null;
+}
+function compareFqnHierarchically(a, b) {
+  const depthA = a.split(".").length;
+  const depthB = b.split(".").length;
+  if (depthA === depthB) {
+    return 0;
+  } else {
+    return depthA - depthB;
+  }
 }
-/**
- * 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 const compareFqnHierarchically = (a, b) => {
-    const depthA = a.split('.').length;
-    const depthB = b.split('.').length;
-    if (depthA === depthB) {
-        // return a.localeCompare(b)
-        return 0;
-    }
-    else {
-        return depthA - depthB;
-    }
-};
-export const compareByFqnHierarchically = (a, b) => {
-    return compareFqnHierarchically(a.id, b.id);
-};
-//# sourceMappingURL=fqn.js.map
+function compareByFqnHierarchically(a, b) {
+  return compareFqnHierarchically(a.id, b.id);
+}

package/dist/utils/fqn.mjs

@@ -0,0 +1,66 @@
+import { anyPass } from "remeda";
+import { isString } from "./guards.mjs";
+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(...args) {
+  const one = isString(args[0]) ? args[0] : args[0].id;
+  const another = isString(args[1]) ? args[1] : args[1].id;
+  return one === another || another.startsWith(one + ".") || one.startsWith(another + ".");
+}
+export function isDescendantOf(ancestors) {
+  const predicates = ancestors.flatMap((a) => [(e) => e.id === a.id, (e) => isAncestor(a, e)]);
+  return anyPass(predicates);
+}
+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 compareFqnHierarchically(a, b) {
+  const depthA = a.split(".").length;
+  const depthB = b.split(".").length;
+  if (depthA === depthB) {
+    return 0;
+  } else {
+    return depthA - depthB;
+  }
+}
+export function compareByFqnHierarchically(a, b) {
+  return compareFqnHierarchically(a.id, b.id);
+}

package/dist/utils/guards.d.ts

@@ -1,6 +1,5 @@
-import type { NonEmptyArray } from "../types";
+import type { NonEmptyArray } from '../types';
 export declare function isString(value: unknown): value is string;
-export declare function failExpectedNever(arg: never): never;
+export declare function failUnexpected(arg: never): never;
 export declare function ignoreNeverInRuntime(arg: never): void;
 export declare function isNonEmptyArray<A>(arr: ArrayLike<A>): arr is NonEmptyArray<A>;
-//# sourceMappingURL=guards.d.ts.map

package/dist/utils/guards.js

@@ -1,14 +1,22 @@
-export function isString(value) {
-    return typeof value === 'string';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.failUnexpected = failUnexpected;
+exports.ignoreNeverInRuntime = ignoreNeverInRuntime;
+exports.isNonEmptyArray = isNonEmptyArray;
+exports.isString = isString;
+var _nonexhaustive = require("../errors/nonexhaustive");
+function isString(value) {
+  return typeof value === "string";
 }
-export function failExpectedNever(arg) {
-    throw new Error(`Unexpected value: ${JSON.stringify(arg)}`);
+function failUnexpected(arg) {
+  throw new _nonexhaustive.NonExhaustiveError(`Unexpected value: ${JSON.stringify(arg)}`);
 }
-export function ignoreNeverInRuntime(arg) {
-    console.warn(`Unexpected and ignored value: ${JSON.stringify(arg)}`);
-    // throw new Error(`Unexpected value: ${arg}`);
+function ignoreNeverInRuntime(arg) {
+  console.warn(`Unexpected and ignored value: ${JSON.stringify(arg)}`);
 }
-export function isNonEmptyArray(arr) {
-    return arr.length > 0;
-}
-//# sourceMappingURL=guards.js.map
+function isNonEmptyArray(arr) {
+  return arr.length > 0;
+}