@likec4/core 0.32.0 → 0.33.0

package/dist/compute-view/utils/applyViewRuleStyles.mjs

@@ -0,0 +1,50 @@
+import { anyPass, filter, clone, isNil } from "rambdax";
+import { isDefined } from "remeda";
+import * as Expr from "../../types/expression.mjs";
+import { nonexhaustive } from "../../errors/index.mjs";
+export function applyViewRuleStyles(rules, _nodes) {
+  if (rules.length === 0) {
+    return _nodes;
+  }
+  const nodes = clone(_nodes);
+  for (const rule of rules) {
+    const predicates = [];
+    if (!rule.style.color && !rule.style.shape) {
+      continue;
+    }
+    for (const target of rule.targets) {
+      if (Expr.isWildcard(target)) {
+        predicates.push(() => true);
+        break;
+      }
+      if (Expr.isElementKindExpr(target)) {
+        predicates.push(
+          target.isEqual ? (n) => n.kind === target.elementKind : (n) => n.kind !== target.elementKind
+        );
+        continue;
+      }
+      if (Expr.isElementTagExpr(target)) {
+        predicates.push(
+          target.isEqual ? ({ tags }) => !!tags && tags.includes(target.elementTag) : ({ tags }) => isNil(tags) || !tags.includes(target.elementTag)
+        );
+        continue;
+      }
+      if (Expr.isElementRef(target)) {
+        const { element, isDescedants } = target;
+        predicates.push(
+          isDescedants ? (n) => n.id.startsWith(element + ".") : (n) => n.id === element
+        );
+        continue;
+      }
+      nonexhaustive(target);
+    }
+    filter(anyPass(predicates), nodes).forEach((n) => {
+      n.shape = rule.style.shape ?? n.shape;
+      n.color = rule.style.color ?? n.color;
+      if (isDefined.strict(rule.style.icon)) {
+        n.icon = rule.style.icon;
+      }
+    });
+  }
+  return nodes;
+}

package/dist/compute-view/utils/sortNodes.d.ts

@@ -1,3 +1,2 @@
 import type { ComputedEdge, ComputedNode, Fqn } from '../../types';
 export declare function sortNodes(_nodes: Map<Fqn, ComputedNode>, edges: ComputedEdge[]): ComputedNode[];
-//# sourceMappingURL=sortNodes.d.ts.map

package/dist/compute-view/utils/sortNodes.js

@@ -1,45 +1,50 @@
-import { isSameHierarchy } from '../../utils';
-import { Graph, alg } from '@dagrejs/graphlib';
-import { nonNullable } from '../../errors/invariant';
-export function sortNodes(_nodes, edges) {
-    const g = new Graph({
-        compound: true,
-        directed: true,
-        multigraph: false
-    });
-    for (const nd of _nodes.values()) {
-        g.setNode(nd.id);
-        // console.log(`add ${nd.id}`)
-        if (nd.parent) {
-            g.setEdge(nd.parent, nd.id);
-            // console.log(`${nd.parent} -> ${nd.id}`)
-        }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sortNodes = sortNodes;
+var _utils = require("../../utils");
+var _graphlib = _interopRequireDefault(require("@dagrejs/graphlib"));
+var _errors = require("../../errors");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  Graph,
+  alg
+} = _graphlib.default;
+function sortNodes(_nodes, edges) {
+  const g = new Graph({
+    compound: true,
+    directed: true,
+    multigraph: false
+  });
+  for (const nd of _nodes.values()) {
+    g.setNode(nd.id);
+    if (nd.parent) {
+      g.setEdge(nd.parent, nd.id);
     }
-    for (const edge of edges) {
-        const source = _nodes.get(edge.source);
-        let target = _nodes.get(edge.target);
-        while (source && target) {
-            if (!isSameHierarchy(source, target) && !g.hasEdge(source.id, target.id)) {
-                g.setEdge(source.id, target.id);
-                // console.log(`${source.id} -> ${target.id}`)
-                if (!alg.isAcyclic(g)) {
-                    g.removeEdge(source.id, target.id);
-                    // console.log(`remove ${source.id} -> ${target.id}`)
-                }
-            }
-            if (target.parent && target.parent !== edge.parent) {
-                target = _nodes.get(target.parent);
-            }
-            else {
-                target = undefined;
-            }
+  }
+  for (const edge of edges) {
+    const source = _nodes.get(edge.source);
+    let target = _nodes.get(edge.target);
+    while (source && target) {
+      if (!(0, _utils.isSameHierarchy)(source, target) && !g.hasEdge(source.id, target.id)) {
+        g.setEdge(source.id, target.id);
+        if (!alg.isAcyclic(g)) {
+          g.removeEdge(source.id, target.id);
         }
+      }
+      if (target.parent && target.parent !== edge.parent) {
+        target = _nodes.get(target.parent);
+      } else {
+        target = void 0;
+      }
     }
-    const sorted = alg.topsort(g);
-    const nodes = sorted.map(id => nonNullable(_nodes.get(id)));
-    for (const node of nodes) {
-        node.children = nodes.flatMap(n => (n.parent === node.id ? n.id : []));
-    }
-    return nodes;
-}
-//# sourceMappingURL=sortNodes.js.map
+  }
+  const sorted = alg.topsort(g);
+  const nodes = sorted.map(id => (0, _errors.nonNullable)(_nodes.get(id)));
+  for (const node of nodes) {
+    node.children = nodes.flatMap(n => n.parent === node.id ? n.id : []);
+  }
+  return nodes;
+}

package/dist/compute-view/utils/sortNodes.mjs

@@ -0,0 +1,40 @@
+import { isSameHierarchy } from "../../utils/index.mjs";
+import pkg from "@dagrejs/graphlib";
+import { nonNullable } from "../../errors/index.mjs";
+const { Graph, alg } = pkg;
+export function sortNodes(_nodes, edges) {
+  const g = new Graph({
+    compound: true,
+    directed: true,
+    multigraph: false
+  });
+  for (const nd of _nodes.values()) {
+    g.setNode(nd.id);
+    if (nd.parent) {
+      g.setEdge(nd.parent, nd.id);
+    }
+  }
+  for (const edge of edges) {
+    const source = _nodes.get(edge.source);
+    let target = _nodes.get(edge.target);
+    while (source && target) {
+      if (!isSameHierarchy(source, target) && !g.hasEdge(source.id, target.id)) {
+        g.setEdge(source.id, target.id);
+        if (!alg.isAcyclic(g)) {
+          g.removeEdge(source.id, target.id);
+        }
+      }
+      if (target.parent && target.parent !== edge.parent) {
+        target = _nodes.get(target.parent);
+      } else {
+        target = void 0;
+      }
+    }
+  }
+  const sorted = alg.topsort(g);
+  const nodes = sorted.map((id) => nonNullable(_nodes.get(id)));
+  for (const node of nodes) {
+    node.children = nodes.flatMap((n) => n.parent === node.id ? n.id : []);
+  }
+  return nodes;
+}

package/dist/errors/_base.d.ts

@@ -7,4 +7,3 @@ export declare const BaseError: import("modern-errors").ErrorSubclassCore<[], {}
  */
 export declare const UnknownError: import("modern-errors").ErrorSubclassCore<[], {}, import("modern-errors").CustomClass>;
 export declare const RelationRefError: import("modern-errors").ErrorSubclassCore<[], {}, import("modern-errors").CustomClass>;
-//# sourceMappingURL=_base.d.ts.map

package/dist/errors/_base.js

@@ -1,11 +1,14 @@
-import ModernError from 'modern-errors';
-/**
- * Base class for all errors in the LikeC4 library.
- */
-export const BaseError = ModernError.subclass('BaseError');
-/**
- * Unknown error, mosly probably a bug, unhandled case or coming from a third-party library.
- */
-export const UnknownError = BaseError.subclass('UnknownError');
-export const RelationRefError = BaseError.subclass('RelationRefError');
-//# sourceMappingURL=_base.js.map
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnknownError = exports.RelationRefError = exports.BaseError = void 0;
+var _modernErrors = _interopRequireDefault(require("modern-errors"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const BaseError = _modernErrors.default.subclass("BaseError");
+exports.BaseError = BaseError;
+const UnknownError = BaseError.subclass("UnknownError");
+exports.UnknownError = UnknownError;
+const RelationRefError = BaseError.subclass("RelationRefError");
+exports.RelationRefError = RelationRefError;

package/dist/errors/_base.mjs

@@ -0,0 +1,4 @@
+import ModernError from "modern-errors";
+export const BaseError = ModernError.subclass("BaseError");
+export const UnknownError = BaseError.subclass("UnknownError");
+export const RelationRefError = BaseError.subclass("RelationRefError");

package/dist/errors/index.d.ts

@@ -1,5 +1,5 @@
 export * from './_base';
 export * from './invariant';
+export * from './non-nullable';
 export * from './nonexhaustive';
 export * from './model-index';
-//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.js

@@ -1,5 +1,60 @@
-export * from './_base';
-export * from './invariant';
-export * from './nonexhaustive';
-export * from './model-index';
-//# sourceMappingURL=index.js.map
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _base = require("./_base");
+Object.keys(_base).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _base[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _base[key];
+    }
+  });
+});
+var _invariant = require("./invariant");
+Object.keys(_invariant).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _invariant[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _invariant[key];
+    }
+  });
+});
+var _nonNullable = require("./non-nullable");
+Object.keys(_nonNullable).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _nonNullable[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _nonNullable[key];
+    }
+  });
+});
+var _nonexhaustive = require("./nonexhaustive");
+Object.keys(_nonexhaustive).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _nonexhaustive[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _nonexhaustive[key];
+    }
+  });
+});
+var _modelIndex = require("./model-index");
+Object.keys(_modelIndex).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _modelIndex[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _modelIndex[key];
+    }
+  });
+});

package/dist/errors/index.mjs

@@ -0,0 +1,5 @@
+export * from "./_base.mjs";
+export * from "./invariant.mjs";
+export * from "./non-nullable.mjs";
+export * from "./nonexhaustive.mjs";
+export * from "./model-index.mjs";

package/dist/errors/invariant.d.ts

@@ -1,4 +1,2 @@
 export declare const InvariantError: import("modern-errors").ErrorSubclassCore<[], {}, import("modern-errors").CustomClass>;
 export declare function invariant(condition: any, message?: string): asserts condition;
-export declare function nonNullable<T>(value: T): NonNullable<T>;
-//# sourceMappingURL=invariant.d.ts.map

package/dist/errors/invariant.js

@@ -1,21 +1,16 @@
-import { BaseError } from './_base';
-export const InvariantError = BaseError.subclass('InvariantError');
-// 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');
-}
-// Throws an error if the value is null or undefined
-export function nonNullable(value) {
-    invariant(value != null, 'Expected value to exist');
-    return value;
-}
-//# sourceMappingURL=invariant.js.map
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InvariantError = void 0;
+exports.invariant = invariant;
+var _base = require("./_base");
+const InvariantError = _base.BaseError.subclass("InvariantError");
+exports.InvariantError = InvariantError;
+function invariant(condition, message) {
+  if (condition) {
+    return;
+  }
+  throw new InvariantError(message ?? "Invariant failed");
+}

package/dist/errors/invariant.mjs

@@ -0,0 +1,8 @@
+import { BaseError } from "./_base.mjs";
+export const InvariantError = BaseError.subclass("InvariantError");
+export function invariant(condition, message) {
+  if (condition) {
+    return;
+  }
+  throw new InvariantError(message ?? "Invariant failed");
+}

package/dist/errors/model-index.d.ts

@@ -1,3 +1,2 @@
 export declare const InvalidModelError: import("modern-errors").ErrorSubclassCore<[], {}, import("modern-errors").CustomClass>;
 export declare function ensureModel(condition: any, message?: string): asserts condition;
-//# sourceMappingURL=model-index.d.ts.map

package/dist/errors/model-index.js

@@ -1,14 +1,16 @@
-import { BaseError } from './_base';
-export const InvalidModelError = BaseError.subclass('InvalidModelError');
-export function ensureModel(
-// 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 InvalidModelError(message ?? 'ModelIndex Invariant failed');
-}
-//# sourceMappingURL=model-index.js.map
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InvalidModelError = void 0;
+exports.ensureModel = ensureModel;
+var _base = require("./_base");
+const InvalidModelError = _base.BaseError.subclass("InvalidModelError");
+exports.InvalidModelError = InvalidModelError;
+function ensureModel(condition, message) {
+  if (condition) {
+    return;
+  }
+  throw new InvalidModelError(message ?? "ModelIndex Invariant failed");
+}

package/dist/errors/model-index.mjs

@@ -0,0 +1,8 @@
+import { BaseError } from "./_base.mjs";
+export const InvalidModelError = BaseError.subclass("InvalidModelError");
+export function ensureModel(condition, message) {
+  if (condition) {
+    return;
+  }
+  throw new InvalidModelError(message ?? "ModelIndex Invariant failed");
+}

package/dist/errors/non-nullable.d.ts

@@ -0,0 +1,2 @@
+export declare const UnexpectedNullableError: import("modern-errors").ErrorSubclassCore<[], {}, import("modern-errors").CustomClass>;
+export declare function nonNullable<T>(value: T): NonNullable<T>;

package/dist/errors/non-nullable.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnexpectedNullableError = void 0;
+exports.nonNullable = nonNullable;
+var _base = require("./_base");
+const UnexpectedNullableError = _base.BaseError.subclass("UnexpectedNullableError");
+exports.UnexpectedNullableError = UnexpectedNullableError;
+function nonNullable(value) {
+  if (value == null) {
+    throw new UnexpectedNullableError("Expected value to not be null or undefined");
+  }
+  return value;
+}

package/dist/errors/non-nullable.mjs

@@ -0,0 +1,8 @@
+import { BaseError } from "./_base.mjs";
+export const UnexpectedNullableError = BaseError.subclass("UnexpectedNullableError");
+export function nonNullable(value) {
+  if (value == null) {
+    throw new UnexpectedNullableError("Expected value to not be null or undefined");
+  }
+  return value;
+}

package/dist/errors/nonexhaustive.d.ts

@@ -1,3 +1,2 @@
 export declare const NonExhaustiveError: import("modern-errors").ErrorSubclassCore<[], {}, import("modern-errors").CustomClass>;
 export declare function nonexhaustive(arg: never): never;
-//# sourceMappingURL=nonexhaustive.d.ts.map

package/dist/errors/nonexhaustive.js

@@ -1,6 +1,13 @@
-import { BaseError } from './_base';
-export const NonExhaustiveError = BaseError.subclass('NonExhaustiveError');
-export function nonexhaustive(arg) {
-    throw new NonExhaustiveError(`NonExhaustive value: ${JSON.stringify(arg)}`);
-}
-//# sourceMappingURL=nonexhaustive.js.map
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NonExhaustiveError = void 0;
+exports.nonexhaustive = nonexhaustive;
+var _base = require("./_base");
+const NonExhaustiveError = _base.BaseError.subclass("NonExhaustiveError");
+exports.NonExhaustiveError = NonExhaustiveError;
+function nonexhaustive(arg) {
+  throw new NonExhaustiveError(`NonExhaustive value: ${JSON.stringify(arg)}`);
+}

package/dist/errors/nonexhaustive.mjs

@@ -0,0 +1,5 @@
+import { BaseError } from "./_base.mjs";
+export const NonExhaustiveError = BaseError.subclass("NonExhaustiveError");
+export function nonexhaustive(arg) {
+  throw new NonExhaustiveError(`NonExhaustive value: ${JSON.stringify(arg)}`);
+}

package/dist/index.d.ts

@@ -1,8 +1,11 @@
-export type * from './types';
 export * from './types';
-export * from './compute-view';
 export * from './utils';
 export * from './model-index';
+export * from './compute-view';
 export * from './colors';
 export * from './errors';
-//# sourceMappingURL=index.d.ts.map
+export type * from './types';
+export type * from './model-index';
+export type * from './compute-view';
+export type * from './errors';
+export type * from './colors';

package/dist/index.js

@@ -1,7 +1,71 @@
-export * from './types';
-export * from './compute-view';
-export * from './utils';
-export * from './model-index';
-export * from './colors';
-export * from './errors';
-//# sourceMappingURL=index.js.map
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+var _utils = require("./utils");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});
+var _modelIndex = require("./model-index");
+Object.keys(_modelIndex).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _modelIndex[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _modelIndex[key];
+    }
+  });
+});
+var _computeView = require("./compute-view");
+Object.keys(_computeView).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _computeView[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _computeView[key];
+    }
+  });
+});
+var _colors = require("./colors");
+Object.keys(_colors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _colors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _colors[key];
+    }
+  });
+});
+var _errors = require("./errors");
+Object.keys(_errors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _errors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _errors[key];
+    }
+  });
+});

package/dist/index.mjs

@@ -0,0 +1,6 @@
+export * from "./types/index.mjs";
+export * from "./utils/index.mjs";
+export * from "./model-index/index.mjs";
+export * from "./compute-view/index.mjs";
+export * from "./colors.mjs";
+export * from "./errors/index.mjs";

package/dist/model-index/ModelIndex.d.ts

@@ -25,4 +25,3 @@ export default class ModelIndex {
     addRelation(rel: Relation): void;
 }
 export {};
-//# sourceMappingURL=ModelIndex.d.ts.map