@likec4/core 0.40.0 → 0.42.0

package/dist/esm/compute-view/resolve-extended-views.js

@@ -1,41 +0,0 @@
-import graphlib from "@dagrejs/graphlib";
-import { isExtendsElementView } from "../types/index.js";
-const { Graph, alg } = graphlib;
-export function resolveRulesExtendedViews(unresolvedViews) {
-  const g = new Graph({
-    directed: true,
-    multigraph: false,
-    compound: false
-  });
-  for (const view of Object.values(unresolvedViews)) {
-    g.setNode(view.id);
-    if (isExtendsElementView(view)) {
-      g.setEdge(view.id, view.extends);
-    }
-  }
-  const cycles = alg.findCycles(g);
-  if (cycles.length > 0) {
-    cycles.flat().forEach((id) => g.removeNode(id));
-  }
-  const ordered = alg.postorder(g, g.sources());
-  return ordered.reduce((acc, id) => {
-    const view = unresolvedViews[id];
-    if (!view) {
-      return acc;
-    }
-    if (isExtendsElementView(view)) {
-      const extendsFrom = acc[view.extends];
-      if (!extendsFrom) {
-        return acc;
-      }
-      return Object.assign(acc, {
-        [view.id]: {
-          ...extendsFrom,
-          ...view,
-          rules: [...extendsFrom.rules, ...view.rules]
-        }
-      });
-    }
-    return Object.assign(acc, { [view.id]: view });
-  }, {});
-}

package/dist/esm/compute-view/resolve-relative-paths.d.ts

@@ -1,2 +0,0 @@
-import type { ElementView } from '../types';
-export declare function resolveRelativePaths(views: ElementView[]): ElementView[];

package/dist/esm/compute-view/resolve-relative-paths.js

@@ -1,76 +0,0 @@
-import { uniq, zip } from "rambdax";
-import { hasAtLeast } from "remeda";
-import { invariant } from "../errors/index.js";
-function commonAncestorPath(views, sep = "/") {
-  if (views.length <= 1)
-    return "";
-  const uniqURIs = uniq(views.flatMap(({ docUri }) => docUri ? [docUri] : []));
-  if (uniqURIs.length === 0)
-    return "";
-  if (uniqURIs.length === 1) {
-    invariant(hasAtLeast(uniqURIs, 1));
-    return new URL(uniqURIs[0]).pathname;
-  }
-  invariant(hasAtLeast(uniqURIs, 2), "Expected at least 2 unique URIs");
-  const [baseUri, ...tail] = uniqURIs;
-  const parts = new URL(baseUri).pathname.split(sep);
-  let endOfPrefix = parts.length;
-  for (const uri of tail) {
-    if (uri === baseUri) {
-      continue;
-    }
-    const compare = new URL(uri).pathname.split(sep);
-    for (let i = 0; i < endOfPrefix; i++) {
-      if (compare[i] !== parts[i]) {
-        endOfPrefix = i;
-      }
-    }
-    if (endOfPrefix === 0)
-      return "";
-  }
-  const prefix = parts.slice(0, endOfPrefix).join(sep);
-  return prefix.endsWith(sep) ? prefix : prefix + sep;
-}
-export function resolveRelativePaths(views) {
-  const commonPrefix = commonAncestorPath(views);
-  return views.map((view) => {
-    if (!view.docUri) {
-      return {
-        ...view,
-        parts: []
-      };
-    }
-    const path = new URL(view.docUri).pathname;
-    const parts = path.replace(commonPrefix, "").split("/");
-    parts.pop();
-    return {
-      ...view,
-      parts
-    };
-  }).sort((a, b) => {
-    if (a.parts.length === b.parts.length) {
-      if (a.parts.length === 0) {
-        return 0;
-      }
-      if (a.parts.length === 1 && hasAtLeast(a.parts, 1) && hasAtLeast(b.parts, 1)) {
-        return a.parts[0].localeCompare(b.parts[0]);
-      }
-      for (const [_a, _b] of zip(a.parts, b.parts)) {
-        const compare = _a.localeCompare(_b);
-        if (compare !== 0) {
-          return compare;
-        }
-      }
-      return 0;
-    }
-    return a.parts.length - b.parts.length;
-  }).map(({ parts, ...view }) => {
-    if (view.docUri) {
-      return {
-        ...view,
-        relativePath: parts.join("/")
-      };
-    }
-    return view;
-  });
-}

package/dist/esm/compute-view/utils/anyPossibleRelations.d.ts

@@ -1,2 +0,0 @@
-import type { Element } from '../../types';
-export declare function anyPossibleRelations(elements: Element[]): Generator<[source: Element, target: Element]>;

package/dist/esm/compute-view/utils/anyPossibleRelations.js

@@ -1,12 +0,0 @@
-import { prop, uniqBy } from "rambdax";
-import { compareByFqnHierarchically, isAncestor } from "../../utils/index.js";
-export function* anyPossibleRelations(elements) {
-  const uniqElements = uniqBy(prop("id"), elements).sort(compareByFqnHierarchically).reverse();
-  for (const source of uniqElements) {
-    for (const target of uniqElements) {
-      if (source !== target && !isAncestor(source, target) && !isAncestor(target, source)) {
-        yield [source, target];
-      }
-    }
-  }
-}

package/dist/esm/compute-view/utils/applyViewRuleStyles.d.ts

@@ -1,2 +0,0 @@
-import type { ComputedNode, ViewRuleStyle } from '../../types';
-export declare function applyViewRuleStyles(rules: ViewRuleStyle[], _nodes: ComputedNode[]): ComputedNode[];

package/dist/esm/compute-view/utils/applyViewRuleStyles.js

@@ -1,50 +0,0 @@
-import { anyPass, clone, filter, isNil } from "rambdax";
-import { isDefined } from "remeda";
-import { nonexhaustive } from "../../errors/index.js";
-import { Expr } from "../../types/index.js";
-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/esm/compute-view/utils/sortNodes.d.ts

@@ -1,19 +0,0 @@
-import type { ComputedEdge, ComputedNode } from '../../types';
-export declare function sortNodes(_nodes: ComputedNode[], edges: ComputedEdge[]): {
-    children: import("../../types").Fqn[];
-    id: import("../../types").Fqn;
-    kind: import("../../types").ElementKind;
-    parent: import("../../types").Fqn | null;
-    title: string;
-    description: string | null;
-    technology: string | null;
-    tags: import("../../types").NonEmptyArray<import("../../types").Tag> | null;
-    links: import("../../types").NonEmptyArray<string> | null;
-    inEdges: import("../../types").EdgeId[];
-    outEdges: import("../../types").EdgeId[];
-    shape: import("../../types").ElementShape;
-    color: import("../../types").ThemeColor;
-    icon?: import("../../types").IconUrl | undefined;
-    navigateTo?: import("../../types").ViewID | undefined;
-    level: number;
-}[];

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

@@ -1,37 +0,0 @@
-import pkg from "@dagrejs/graphlib";
-const { Graph, alg } = pkg;
-function fillChildren(nodes) {
-  return nodes.map((node) => ({
-    ...node,
-    children: nodes.flatMap((n) => n.parent === node.id ? n.id : [])
-  }));
-}
-export function sortNodes(_nodes, edges) {
-  if (edges.length === 0) {
-    return fillChildren(_nodes);
-  }
-  const g = new Graph({
-    compound: true,
-    directed: true,
-    multigraph: false
-  });
-  for (const e of edges) {
-    g.setEdge(e.source, e.target);
-  }
-  for (const n of _nodes) {
-    g.setNode(n.id);
-    if (n.parent) {
-      g.setEdge(n.id, n.parent);
-    }
-  }
-  const unprocessed = [..._nodes];
-  const sorted = [];
-  const ordered = alg.postorder(g, g.sources()).reverse();
-  for (const id of ordered) {
-    const inx = unprocessed.findIndex((n) => n.id === id);
-    if (inx >= 0) {
-      sorted.push(...unprocessed.splice(inx, 1));
-    }
-  }
-  return fillChildren(sorted.concat(unprocessed));
-}

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

@@ -1,27 +0,0 @@
-import type { Element, Fqn, Relation, RelationID } from '../types';
-type ModelInput = {
-    elements: Record<Fqn, Element>;
-    relations: Record<RelationID, Relation>;
-};
-export default class ModelIndex {
-    private root;
-    private _elements;
-    private _relations;
-    get relations(): Relation[];
-    filterRelations(predicate: (r: Relation) => boolean): Relation[];
-    static from({ elements, relations }: ModelInput): ModelIndex;
-    addElement(el: Element): void;
-    private locateTrie;
-    find: (id: Fqn) => Element;
-    children: (id: Fqn) => Element[];
-    siblings: (id: Fqn) => Element[];
-    /**
-     * Ancestors from closest parent to root
-     */
-    ancestors(id: Fqn): Element[];
-    rootElements(): Element[];
-    get elements(): Element[];
-    hasElement(fqn: Fqn): boolean;
-    addRelation(rel: Relation): void;
-}
-export {};

package/dist/esm/model-index/ModelIndex.js

@@ -1,127 +0,0 @@
-import { values } from "remeda";
-import { InvalidModelError, ensureModel } from "../errors/index.js";
-import { parentFqn } from "../utils/index.js";
-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();
-    for (const el of values(elements)) {
-      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/esm/model-index/index.d.ts

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

package/dist/esm/model-index/index.js

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

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

@@ -1,7 +0,0 @@
-import type { ComputedView } from '../types';
-type NodeLevelDepth = {
-    level: number;
-    depth: number;
-};
-export declare const computeNodeLevels: ({ nodes }: ComputedView) => Record<import("../types").Fqn, NodeLevelDepth>;
-export {};

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

@@ -1,31 +0,0 @@
-import { invariant } from "../errors/index.js";
-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;
-};