@likec4/core 0.32.0 → 0.33.0

package/dist/model-index/ModelIndex.js

@@ -1,137 +1,140 @@
-import { pipe, sort, values } from 'remeda';
-import { InvalidModelError, ensureModel } from '../errors';
-import { compareByFqnHierarchically, parentFqn } from '../utils/fqn';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+var _remeda = require("remeda");
+var _errors = require("../errors");
+var _fqn = require("../utils/fqn");
 function childrenOf(trie) {
-    const children = [];
-    for (const { el } of values(trie.children)) {
-        if (el) {
-            children.push(el);
-        }
+  const children = [];
+  for (const {
+    el
+  } of (0, _remeda.values)(trie.children)) {
+    if (el) {
+      children.push(el);
     }
-    return children;
+  }
+  return children;
 }
 function asPath(id) {
-    return id.split('.');
+  return id.split(".");
 }
-export default class ModelIndex {
-    root = {
-        children: {}
-    };
-    _elements = new Map();
-    _relations = new Map();
-    // private _taggedElements = new Map<Tag, Set<Element>>()
-    // private _taggedRelations = new Map<Tag, Set<Relation>>()
-    get relations() {
-        return Array.from(this._relations.values());
+class ModelIndex {
+  root = {
+    children: {}
+  };
+  _elements = /* @__PURE__ */new Map();
+  _relations = /* @__PURE__ */new Map();
+  // private _taggedElements = new Map<Tag, Set<Element>>()
+  // private _taggedRelations = new Map<Tag, Set<Relation>>()
+  get relations() {
+    return Array.from(this._relations.values());
+  }
+  filterRelations(predicate) {
+    return this.relations.filter(predicate);
+  }
+  static from({
+    elements,
+    relations
+  }) {
+    const index = new ModelIndex();
+    const sortedElements = (0, _remeda.pipe)((0, _remeda.values)(elements), (0, _remeda.sort)(_fqn.compareByFqnHierarchically));
+    for (const el of sortedElements) {
+      index.addElement(el);
     }
-    filterRelations(predicate) {
-        return this.relations.filter(predicate);
+    for (const rel of (0, _remeda.values)(relations)) {
+      index.addRelation(rel);
     }
-    static from({ elements, relations }) {
-        const index = new ModelIndex();
-        const sortedElements = pipe(values(elements), sort(compareByFqnHierarchically));
-        for (const el of sortedElements) {
-            index.addElement(el);
-        }
-        for (const rel of values(relations)) {
-            index.addRelation(rel);
-        }
-        return index;
+    return index;
+  }
+  addElement(el) {
+    if (this.hasElement(el.id)) {
+      throw new _errors.InvalidModelError(`Element already exists with id ${el.id}`);
     }
-    addElement(el) {
-        if (this.hasElement(el.id)) {
-            throw new InvalidModelError(`Element already exists with id ${el.id}`);
-        }
-        const path = asPath(el.id);
-        let scope = this.root;
-        for (const name of path) {
-            const next = scope.children[name] ?? {
-                children: {}
-            };
-            scope.children[name] = next;
-            scope = next;
-        }
-        scope.el = el;
-        this._elements.set(el.id, el);
+    const path = asPath(el.id);
+    let scope = this.root;
+    for (const name of path) {
+      const next = scope.children[name] ?? {
+        children: {}
+      };
+      scope.children[name] = next;
+      scope = next;
     }
-    locateTrie = (id) => {
-        let scope = this.root;
-        for (const name of asPath(id)) {
-            const next = scope.children[name];
-            ensureModel(next, `Invalid index, Element not found at path ${name} of ${id}`);
-            scope = next;
-        }
-        return scope;
-    };
-    find = (id) => {
-        const el = this._elements.get(id);
-        ensureModel(el, `Element not found with id ${id}`);
-        return el;
-    };
-    children = (id) => {
-        return childrenOf(this.locateTrie(id));
-    };
-    siblings = (id) => {
-        const parent = parentFqn(id);
-        const trie = parent ? this.locateTrie(parent) : this.root;
-        return childrenOf(trie).filter(e => e.id !== id);
-    };
-    /**
-     * Ancestors from closest parent to root
-     */
-    ancestors(id) {
-        const path = asPath(id);
-        const ancestors = [];
-        // The root
-        if (path.length === 1) {
-            return ancestors;
-        }
-        // Remove the element itself
-        path.pop();
-        let name = path.shift();
-        let trie = this.root;
-        while (name) {
-            const next = trie.children[name];
-            ensureModel(next, `Invalid index, Element not found at path ${name} of ${id}`);
-            trie = next;
-            ensureModel(trie.el, `invalid index, no element ${name} found in ${id}`);
-            ancestors.unshift(trie.el);
-            name = path.shift();
-        }
-        return ancestors;
+    scope.el = el;
+    this._elements.set(el.id, el);
+  }
+  locateTrie = id => {
+    let scope = this.root;
+    for (const name of asPath(id)) {
+      const next = scope.children[name];
+      (0, _errors.ensureModel)(next, `Invalid index, Element not found at path ${name} of ${id}`);
+      scope = next;
     }
-    // tagged = (tag?: Tag): TaggedResult => {
-    //   return tag ? {
-    //     elements: [...this._taggedElements.get(tag)?.values() ?? []],
-    //     relations: [...this._taggedRelations.get(tag)?.values() ?? []],
-    //   } : {
-    //     elements: uniq([...this._taggedElements.values()].flatMap(s => [...s.values()])),
-    //     relations: uniq([...this._taggedRelations.values()].flatMap(s => [...s.values()]))
-    //   }
-    // }
-    rootElements() {
-        return childrenOf(this.root);
+    return scope;
+  };
+  find = id => {
+    const el = this._elements.get(id);
+    (0, _errors.ensureModel)(el, `Element not found with id ${id}`);
+    return el;
+  };
+  children = id => {
+    return childrenOf(this.locateTrie(id));
+  };
+  siblings = id => {
+    const parent = (0, _fqn.parentFqn)(id);
+    const trie = parent ? this.locateTrie(parent) : this.root;
+    return childrenOf(trie).filter(e => e.id !== id);
+  };
+  /**
+   * Ancestors from closest parent to root
+   */
+  ancestors(id) {
+    const path = asPath(id);
+    const ancestors = [];
+    if (path.length === 1) {
+      return ancestors;
     }
-    get elements() {
-        return Array.from(this._elements.values());
+    path.pop();
+    let name = path.shift();
+    let trie = this.root;
+    while (name) {
+      const next = trie.children[name];
+      (0, _errors.ensureModel)(next, `Invalid index, Element not found at path ${name} of ${id}`);
+      trie = next;
+      (0, _errors.ensureModel)(trie.el, `invalid index, no element ${name} found in ${id}`);
+      ancestors.unshift(trie.el);
+      name = path.shift();
     }
-    hasElement(fqn) {
-        return this._elements.has(fqn);
+    return ancestors;
+  }
+  // tagged = (tag?: Tag): TaggedResult => {
+  //   return tag ? {
+  //     elements: [...this._taggedElements.get(tag)?.values() ?? []],
+  //     relations: [...this._taggedRelations.get(tag)?.values() ?? []],
+  //   } : {
+  //     elements: uniq([...this._taggedElements.values()].flatMap(s => [...s.values()])),
+  //     relations: uniq([...this._taggedRelations.values()].flatMap(s => [...s.values()]))
+  //   }
+  // }
+  rootElements() {
+    return childrenOf(this.root);
+  }
+  get elements() {
+    return Array.from(this._elements.values());
+  }
+  hasElement(fqn) {
+    return this._elements.has(fqn);
+  }
+  addRelation(rel) {
+    if (!this.hasElement(rel.source)) {
+      throw new _errors.InvalidModelError(`Source of relation not found ${rel.source}`);
     }
-    addRelation(rel) {
-        // Validate source and target
-        if (!this.hasElement(rel.source)) {
-            throw new InvalidModelError(`Source of relation not found ${rel.source}`);
-        }
-        if (!this.hasElement(rel.target)) {
-            throw new InvalidModelError(`Target of relation not found ${rel.target}`);
-        }
-        this._relations.set(rel.id, rel);
-        // for (const tag of rel.tags) {
-        //   const tagged = this._taggedRelations.get(tag) ?? new Set()
-        //   tagged.add(rel)
-        //   this._taggedRelations.set(tag, tagged)
-        // }
+    if (!this.hasElement(rel.target)) {
+      throw new _errors.InvalidModelError(`Target of relation not found ${rel.target}`);
     }
+    this._relations.set(rel.id, rel);
+  }
 }
-//# sourceMappingURL=ModelIndex.js.map
+module.exports = ModelIndex;

package/dist/model-index/ModelIndex.mjs

@@ -0,0 +1,128 @@
+import { pipe, sort, values } from "remeda";
+import { InvalidModelError, ensureModel } from "../errors/index.mjs";
+import { compareByFqnHierarchically, parentFqn } from "../utils/fqn.mjs";
+function childrenOf(trie) {
+  const children = [];
+  for (const { el } of values(trie.children)) {
+    if (el) {
+      children.push(el);
+    }
+  }
+  return children;
+}
+function asPath(id) {
+  return id.split(".");
+}
+export default class ModelIndex {
+  root = {
+    children: {}
+  };
+  _elements = /* @__PURE__ */ new Map();
+  _relations = /* @__PURE__ */ new Map();
+  // private _taggedElements = new Map<Tag, Set<Element>>()
+  // private _taggedRelations = new Map<Tag, Set<Relation>>()
+  get relations() {
+    return Array.from(this._relations.values());
+  }
+  filterRelations(predicate) {
+    return this.relations.filter(predicate);
+  }
+  static from({ elements, relations }) {
+    const index = new ModelIndex();
+    const sortedElements = pipe(values(elements), sort(compareByFqnHierarchically));
+    for (const el of sortedElements) {
+      index.addElement(el);
+    }
+    for (const rel of values(relations)) {
+      index.addRelation(rel);
+    }
+    return index;
+  }
+  addElement(el) {
+    if (this.hasElement(el.id)) {
+      throw new InvalidModelError(`Element already exists with id ${el.id}`);
+    }
+    const path = asPath(el.id);
+    let scope = this.root;
+    for (const name of path) {
+      const next = scope.children[name] ?? {
+        children: {}
+      };
+      scope.children[name] = next;
+      scope = next;
+    }
+    scope.el = el;
+    this._elements.set(el.id, el);
+  }
+  locateTrie = (id) => {
+    let scope = this.root;
+    for (const name of asPath(id)) {
+      const next = scope.children[name];
+      ensureModel(next, `Invalid index, Element not found at path ${name} of ${id}`);
+      scope = next;
+    }
+    return scope;
+  };
+  find = (id) => {
+    const el = this._elements.get(id);
+    ensureModel(el, `Element not found with id ${id}`);
+    return el;
+  };
+  children = (id) => {
+    return childrenOf(this.locateTrie(id));
+  };
+  siblings = (id) => {
+    const parent = parentFqn(id);
+    const trie = parent ? this.locateTrie(parent) : this.root;
+    return childrenOf(trie).filter((e) => e.id !== id);
+  };
+  /**
+   * Ancestors from closest parent to root
+   */
+  ancestors(id) {
+    const path = asPath(id);
+    const ancestors = [];
+    if (path.length === 1) {
+      return ancestors;
+    }
+    path.pop();
+    let name = path.shift();
+    let trie = this.root;
+    while (name) {
+      const next = trie.children[name];
+      ensureModel(next, `Invalid index, Element not found at path ${name} of ${id}`);
+      trie = next;
+      ensureModel(trie.el, `invalid index, no element ${name} found in ${id}`);
+      ancestors.unshift(trie.el);
+      name = path.shift();
+    }
+    return ancestors;
+  }
+  // tagged = (tag?: Tag): TaggedResult => {
+  //   return tag ? {
+  //     elements: [...this._taggedElements.get(tag)?.values() ?? []],
+  //     relations: [...this._taggedRelations.get(tag)?.values() ?? []],
+  //   } : {
+  //     elements: uniq([...this._taggedElements.values()].flatMap(s => [...s.values()])),
+  //     relations: uniq([...this._taggedRelations.values()].flatMap(s => [...s.values()]))
+  //   }
+  // }
+  rootElements() {
+    return childrenOf(this.root);
+  }
+  get elements() {
+    return Array.from(this._elements.values());
+  }
+  hasElement(fqn) {
+    return this._elements.has(fqn);
+  }
+  addRelation(rel) {
+    if (!this.hasElement(rel.source)) {
+      throw new InvalidModelError(`Source of relation not found ${rel.source}`);
+    }
+    if (!this.hasElement(rel.target)) {
+      throw new InvalidModelError(`Target of relation not found ${rel.target}`);
+    }
+    this._relations.set(rel.id, rel);
+  }
+}

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

@@ -1,2 +1 @@
 export { default as ModelIndex } from './ModelIndex';
-//# sourceMappingURL=index.d.ts.map

package/dist/model-index/index.js

@@ -1,2 +1,13 @@
-export { default as ModelIndex } from './ModelIndex';
-//# sourceMappingURL=index.js.map
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ModelIndex", {
+  enumerable: true,
+  get: function () {
+    return _ModelIndex.default;
+  }
+});
+var _ModelIndex = _interopRequireDefault(require("./ModelIndex"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/dist/model-index/index.mjs

@@ -0,0 +1 @@
+export { default as ModelIndex } from "./ModelIndex.mjs";

package/dist/types/_common.d.ts

@@ -1,4 +1,3 @@
 import type { Opaque } from './opaque';
 export type NonEmptyArray<T> = [T, ...T[]];
 export type IconUrl = Opaque<string, 'IconUrl'>;
-//# sourceMappingURL=_common.d.ts.map

package/dist/types/_common.js

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

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

@@ -1,8 +1,9 @@
 import type { Opaque } from './opaque';
-import type { ElementKind, ElementShape, Fqn, Tag, ThemeColor } from './element';
+import type { ElementKind, ElementShape, Fqn, Tag } from './element';
 import type { RelationID } from './relation';
 import type { ElementView, ViewID, ViewRuleAutoLayout } from './view';
 import type { IconUrl, NonEmptyArray } from './_common';
+import type { ThemeColor } from './theme';
 export type NodeId = Fqn;
 export type EdgeId = Opaque<string, 'EdgeId'>;
 export interface ComputedNode {
@@ -15,6 +16,8 @@ export interface ComputedNode {
     tags: NonEmptyArray<Tag> | null;
     links: NonEmptyArray<string> | null;
     children: NodeId[];
+    inEdges: EdgeId[];
+    outEdges: EdgeId[];
     shape: ElementShape;
     color: ThemeColor;
     icon?: IconUrl;
@@ -28,10 +31,8 @@ export interface ComputedEdge {
     label: string | null;
     relations: RelationID[];
 }
-export interface ComputedView<Node extends ComputedNode = ComputedNode, Edge extends ComputedEdge = ComputedEdge> extends ElementView {
+export interface ComputedView extends ElementView {
     autoLayout: ViewRuleAutoLayout['autoLayout'];
-    nodes: Node[];
-    edges: Edge[];
+    nodes: ComputedNode[];
+    edges: ComputedEdge[];
 }
-export type ComputeResult<V extends ElementView> = V & Pick<ComputedView, 'autoLayout' | 'nodes' | 'edges'>;
-//# sourceMappingURL=computed-view.d.ts.map

package/dist/types/computed-view.js

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

package/dist/types/diagram.d.ts

@@ -1,8 +1,10 @@
+import type { ColorLiteral } from './theme';
 import type { ComputedEdge, ComputedNode, ComputedView } from './computed-view';
 export type Point = [x: number, y: number];
 export interface DiagramLabel {
     align: 'left' | 'right' | 'center';
     fontStyle?: 'bold' | 'normal';
+    color?: ColorLiteral;
     fontSize: number;
     pt: Point;
     width: number;
@@ -21,7 +23,9 @@ export interface DiagramEdge extends ComputedEdge {
     headArrow?: Point[];
     labels: DiagramLabel[];
 }
-export interface DiagramView extends ComputedView<DiagramNode, DiagramEdge> {
+export interface DiagramView extends Omit<ComputedView, 'nodes' | 'edges'> {
+    readonly nodes: DiagramNode[];
+    readonly edges: DiagramEdge[];
     width: number;
     height: number;
     boundingBox: {
@@ -31,4 +35,3 @@ export interface DiagramView extends ComputedView<DiagramNode, DiagramEdge> {
         height: number;
     };
 }
-//# sourceMappingURL=diagram.d.ts.map

package/dist/types/diagram.js

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

package/dist/types/element.d.ts

@@ -1,15 +1,12 @@
 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 type ElementKind = Opaque<string, 'ElementKind'>;
-/**
- * TailwindCSS based color palette
- */
-export type ThemeColor = 'amber' | 'blue' | 'gray' | 'slate' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky';
 export type ElementShape = 'rectangle' | 'person' | 'browser' | 'mobile' | 'cylinder' | 'storage' | 'queue';
-export declare const DefaultThemeColor: ThemeColor;
-export declare const DefaultElementShape: ElementShape;
+export declare const DefaultThemeColor = "primary";
+export declare const DefaultElementShape = "rectangle";
 export interface ElementStyle {
     shape?: ElementShape;
 }
@@ -30,4 +27,3 @@ export interface Element {
     readonly shape?: ElementShape;
     readonly color?: ThemeColor;
 }
-//# sourceMappingURL=element.d.ts.map

package/dist/types/element.js

@@ -1,6 +1,14 @@
-export function AsFqn(name, parent) {
-    return (parent ? parent + '.' + name : name);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AsFqn = AsFqn;
+exports.DefaultThemeColor = exports.DefaultElementShape = void 0;
+function AsFqn(name, parent) {
+  return parent ? parent + "." + name : name;
 }
-export const DefaultThemeColor = 'primary';
-export const DefaultElementShape = 'rectangle';
-//# sourceMappingURL=element.js.map
+const DefaultThemeColor = "primary";
+exports.DefaultThemeColor = DefaultThemeColor;
+const DefaultElementShape = "rectangle";
+exports.DefaultElementShape = DefaultElementShape;

package/dist/types/element.mjs

@@ -0,0 +1,5 @@
+export function AsFqn(name, parent) {
+  return parent ? parent + "." + name : name;
+}
+export const DefaultThemeColor = "primary";
+export const DefaultElementShape = "rectangle";

package/dist/types/expression.d.ts

@@ -54,4 +54,3 @@ export type AnyRelationExpression = RelationExpr | InOutExpr | IncomingExpr | Ou
 export declare function isAnyRelation(expr: Expression): expr is AnyRelationExpression;
 export type Expression = ElementExpression | AnyRelationExpression;
 export {};
-//# sourceMappingURL=expression.d.ts.map

package/dist/types/expression.js

@@ -1,31 +1,45 @@
-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);
-}
-//# sourceMappingURL=expression.js.map
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isAnyRelation = isAnyRelation;
+exports.isElement = isElement;
+exports.isElementKindExpr = isElementKindExpr;
+exports.isElementRef = isElementRef;
+exports.isElementTagExpr = isElementTagExpr;
+exports.isInOut = isInOut;
+exports.isIncoming = isIncoming;
+exports.isOutgoing = isOutgoing;
+exports.isRelation = isRelation;
+exports.isWildcard = isWildcard;
+function isElementRef(expr) {
+  return "element" in expr && "isDescedants" in expr;
+}
+function isWildcard(expr) {
+  return "wildcard" in expr;
+}
+function isElementKindExpr(expr) {
+  return "elementKind" in expr && "isEqual" in expr;
+}
+function isElementTagExpr(expr) {
+  return "elementTag" in expr && "isEqual" in expr;
+}
+function isElement(expr) {
+  return isElementRef(expr) || isWildcard(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
+}
+function isRelation(expr) {
+  return "source" in expr && "target" in expr;
+}
+function isInOut(expr) {
+  return "inout" in expr;
+}
+function isIncoming(expr) {
+  return "incoming" in expr;
+}
+function isOutgoing(expr) {
+  return "outgoing" in expr;
+}
+function isAnyRelation(expr) {
+  return isRelation(expr) || isInOut(expr) || isIncoming(expr) || isOutgoing(expr);
+}