@likec4/core 1.18.0 → 1.19.1

package/src/utils/relations.ts

@@ -1,18 +1,18 @@
 import type { Fqn } from '../types'
 import { commonAncestor, compareFqnHierarchically, isAncestor } from './fqn'
 
-type Relation = {
+export type Relation = {
   source: string
   target: string
 }
 
-type RelationPredicate = (rel: Relation) => boolean
+export type RelationPredicate = (rel: Relation) => boolean
 
 /**
  * Compares two relations hierarchically.
  * From the most general (implicit) to the most specific.
  */
-export const compareRelations = <T extends { source: string; target: string }>(a: T, b: T) => {
+export const compareRelations = <T extends { source: string; target: string }>(a: T, b: T): number => {
   const parentA = commonAncestor(a.source as Fqn, a.target as Fqn)
   const parentB = commonAncestor(b.source as Fqn, b.target as Fqn)
   if (parentA && !parentB) {
@@ -31,64 +31,3 @@ export const compareRelations = <T extends { source: string; target: string }>(a
   }
   return compareFqnHierarchically(a.target, b.target)
 }
-
-export const isInside = (parent: Fqn): RelationPredicate => {
-  const prefix = parent + '.'
-  return (rel: Relation) => {
-    return rel.source.startsWith(prefix) && rel.target.startsWith(prefix)
-  }
-}
-
-export const isBetween = (source: Fqn, target: Fqn): RelationPredicate => {
-  const sourcePrefix = source + '.'
-  const targetPrefix = target + '.'
-  return (rel: Relation) => {
-    return (
-      (rel.source === source || (rel.source + '.').startsWith(sourcePrefix))
-      && (rel.target === target || (rel.target + '.').startsWith(targetPrefix))
-    )
-  }
-}
-
-export const isAnyBetween = (source: Fqn, target: Fqn): RelationPredicate => {
-  const predicates = [isBetween(source, target), isBetween(target, source)]
-  return (rel) => predicates.some(p => p(rel))
-}
-
-export const isIncoming = (target: Fqn): RelationPredicate => {
-  const targetPrefix = target + '.'
-  return (rel: Relation) => {
-    return (
-      !(rel.source + '.').startsWith(targetPrefix)
-      && (rel.target === target || (rel.target + '.').startsWith(targetPrefix))
-    )
-  }
-}
-
-export const isOutgoing = (source: Fqn): RelationPredicate => {
-  const sourcePrefix = source + '.'
-  return (rel: Relation) => {
-    return (
-      (rel.source === source || (rel.source + '.').startsWith(sourcePrefix))
-      && !(rel.target + '.').startsWith(sourcePrefix)
-    )
-  }
-}
-
-export const isAnyInOut = (source: Fqn): RelationPredicate => {
-  const predicates = [isIncoming(source), isOutgoing(source)]
-  return (rel: Relation) => {
-    return predicates.some(p => p(rel))
-  }
-}
-
-export const hasRelation = <R extends { source: Fqn; target: Fqn }>(rel: R) => {
-  return <E extends { id: Fqn }>(element: E) => {
-    return (
-      rel.source === element.id
-      || rel.target === element.id
-      || isAncestor(element.id, rel.source)
-      || isAncestor(element.id, rel.target)
-    )
-  }
-}

package/src/utils/set.ts

@@ -1,23 +1,25 @@
-import {
-  intersection as _intersection,
-  symmetricDifference as _symmetricDifference,
-  union as _union
-} from 'mnemonist/set'
+import { intersection as _intersection, symmetricDifference as _symmetricDifference } from 'mnemonist/set'
 import type { NonEmptyArray } from '../types/_common'
 
 /**
  * Returns new set as a union of given sets
  * Keeps order of elements
  */
-export function union<T>(...sets: NonEmptyArray<ReadonlySet<T>>): Set<T> {
-  return _union(...sets as any)
+export function union<T>(...sets: ReadonlySet<T>[]): Set<T> {
+  let result = new Set<T>()
+  for (const set of sets) {
+    for (const value of set) {
+      result.add(value)
+    }
+  }
+  return result
 }
 
 /**
  * Returns new set as an intersection of all sets
  * Keeps order from the first set
  */
-export function intersection<T>(first: ReadonlySet<T>, ...sets: NonEmptyArray<ReadonlySet<T>>): Set<T> {
+export function intersection<T>(first: ReadonlySet<T>, ...sets: NonEmptyArray<ReadonlySet<NoInfer<T>>>): Set<T> {
   let result = new Set<T>()
   // If first set is empty, return empty set
   if (first.size === 0) {
@@ -35,7 +37,7 @@ export function intersection<T>(first: ReadonlySet<T>, ...sets: NonEmptyArray<Re
   return result
 }
 
-export function difference<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): Set<T> {
+export function difference<T>(a: ReadonlySet<T>, b: ReadonlySet<NoInfer<T>>): Set<T> {
   if (a.size === 0) {
     return new Set<T>()
   }

package/src/utils/string-hash.ts

@@ -3,7 +3,7 @@ import { invariant } from '../errors'
 /**
  * @see https://gist.github.com/victor-homyakov/bcb7d7911e4a388b1c810f8c3ce17bcf
  */
-export function stringHash(str: string) {
+export function stringHash(str: string): string {
   let hash = 5381
   const len = str.length
   invariant(len > 0, 'stringHash: empty string')

package/dist/compute-view/index.mjs

@@ -1,79 +0,0 @@
-import { G as Graph, i as isAcyclic, d, f as findCycles, a, p as postorder, l, m, b as i } from '../shared/core.BQ4AbfvB.mjs';
-export { L as LikeC4ModelGraph, c as computeViews, e as mkComputeView } from '../shared/core.BQ4AbfvB.mjs';
-import { r } from '../shared/core.BPyJvuMU.mjs';
-import { i as isExtendsElementView } from '../shared/core.k12s_keD.mjs';
-import '../shared/core.BBgiAAv1.mjs';
-
-function resolveRulesExtendedViews(unresolvedViews) {
-  const g = new Graph({
-    directed: true,
-    multigraph: false,
-    compound: false
-  });
-  for (const view of r(unresolvedViews)) {
-    g.setNode(view.id, view.id);
-    if (isExtendsElementView(view)) {
-      g.setEdge(view.id, view.extends);
-    }
-  }
-  if (g.edgeCount() === 0) {
-    return unresolvedViews;
-  }
-  while (!isAcyclic(g)) {
-    const firstCycle = d(findCycles(g));
-    if (!firstCycle) {
-      break;
-    }
-    const cycledNode = a(firstCycle);
-    if (!cycledNode) {
-      break;
-    }
-    g.removeNode(cycledNode);
-  }
-  const ordered = 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) {
-        console.warn(`View "${view.id}" extends from "${view.extends}" which does not exist`);
-        return acc;
-      }
-      return Object.assign(acc, {
-        [view.id]: {
-          ...extendsFrom,
-          ...view,
-          rules: [...extendsFrom.rules, ...view.rules]
-        }
-      });
-    }
-    return Object.assign(acc, { [view.id]: view });
-  }, {});
-}
-
-function withReadableEdges({ edges, nodes, ...view }) {
-  const edgeids = l(edges, (e) => [e.id, `${e.source}:${e.target}`]);
-  return {
-    ...view,
-    edges: edges.map((e) => ({
-      ...e,
-      id: edgeids[e.id]
-    })),
-    nodes: nodes.map((n) => ({
-      ...n,
-      inEdges: m(n.inEdges, (e) => edgeids[e]),
-      outEdges: m(n.outEdges, (e) => edgeids[e])
-    }))
-  };
-}
-function viewsWithReadableEdges({ views, ...model }) {
-  return {
-    ...model,
-    views: i(views, withReadableEdges)
-  };
-}
-
-export { resolveRulesExtendedViews, viewsWithReadableEdges, withReadableEdges };

package/dist/model/index.mjs

@@ -1,2 +0,0 @@
-export { a as LikeC4DeploymentModel, L as LikeC4Model, b as LikeC4ViewModel } from '../shared/core.BPyJvuMU.mjs';
-import '../shared/core.k12s_keD.mjs';

package/dist/shared/core.BBgiAAv1.mjs

@@ -1,144 +0,0 @@
-import { u, n as nonexhaustive, a as n } from './core.k12s_keD.mjs';
-
-function o(a){return t=>!a(t)}
-
-function t(...a){return u(e,a)}var e=(a,o)=>o.every(l=>l(a));
-
-function y(...a){return u(r,a)}var r=(a,o)=>o.some(e=>e(a));
-
-function isElementRef(expr) {
-  return "element" in expr;
-}
-function isExpandedElementExpr(expr) {
-  return "expanded" in expr;
-}
-function isCustomElement(expr) {
-  return "custom" in expr && (isElement(expr.custom.expr) || isElementWhere(expr.custom.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) || isExpandedElementExpr(expr);
-}
-function isElementWhere(expr) {
-  return "where" in expr && isElement(expr.where.expr);
-}
-function isElementPredicateExpr(expr) {
-  return isElement(expr) || isElementWhere(expr) || isCustomElement(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 isRelationExpression(expr) {
-  return isRelation(expr) || isInOut(expr) || isIncoming(expr) || isOutgoing(expr);
-}
-function isRelationWhere(expr) {
-  return "where" in expr && isRelationExpression(expr.where.expr);
-}
-function isCustomRelationExpr(expr) {
-  return "customRelation" in expr;
-}
-function isRelationPredicateExpr(expr) {
-  return isRelationExpression(expr) || isRelationWhere(expr) || isCustomRelationExpr(expr);
-}
-
-const expression = {
-  __proto__: null,
-  isCustomElement: isCustomElement,
-  isCustomRelationExpr: isCustomRelationExpr,
-  isElement: isElement,
-  isElementKindExpr: isElementKindExpr,
-  isElementPredicateExpr: isElementPredicateExpr,
-  isElementRef: isElementRef,
-  isElementTagExpr: isElementTagExpr,
-  isElementWhere: isElementWhere,
-  isExpandedElementExpr: isExpandedElementExpr,
-  isInOut: isInOut,
-  isIncoming: isIncoming,
-  isOutgoing: isOutgoing,
-  isRelation: isRelation,
-  isRelationExpression: isRelationExpression,
-  isRelationPredicateExpr: isRelationPredicateExpr,
-  isRelationWhere: isRelationWhere,
-  isWildcard: isWildcard
-};
-
-const isTagEqual = (operator) => {
-  return "tag" in operator;
-};
-const isKindEqual = (operator) => {
-  return "kind" in operator;
-};
-const isNotOperator = (operator) => {
-  return "not" in operator;
-};
-const isAndOperator = (operator) => {
-  return "and" in operator;
-};
-const isOrOperator = (operator) => {
-  return "or" in operator;
-};
-function whereOperatorAsPredicate(operator) {
-  switch (true) {
-    case isTagEqual(operator): {
-      if ("eq" in operator.tag) {
-        const tag2 = operator.tag.eq;
-        return (value) => {
-          return Array.isArray(value.tags) && value.tags.includes(tag2);
-        };
-      }
-      const tag = operator.tag.neq;
-      return (value) => {
-        return !Array.isArray(value.tags) || !value.tags.includes(tag);
-      };
-    }
-    case isKindEqual(operator): {
-      if ("eq" in operator.kind) {
-        const kind2 = operator.kind.eq;
-        return (value) => {
-          return value.kind === kind2;
-        };
-      }
-      const kind = operator.kind.neq;
-      return (value) => {
-        return n(value.kind) || value.kind !== kind;
-      };
-    }
-    case isNotOperator(operator): {
-      const predicate = whereOperatorAsPredicate(operator.not);
-      return o(predicate);
-    }
-    case isAndOperator(operator): {
-      const predicates = operator.and.map(whereOperatorAsPredicate);
-      return t(predicates);
-    }
-    case isOrOperator(operator): {
-      const predicates = operator.or.map(whereOperatorAsPredicate);
-      return y(predicates);
-    }
-    default:
-      nonexhaustive(operator);
-  }
-}
-
-const DefaultLineStyle = "dashed";
-const DefaultArrowType = "normal";
-const DefaultRelationshipColor = "gray";
-
-export { y as A, o as B, t as C, DefaultLineStyle as D, isElementRef as a, isExpandedElementExpr as b, isCustomElement as c, isWildcard as d, expression as e, isElementKindExpr as f, isElementTagExpr as g, isElement as h, isElementPredicateExpr as i, isElementWhere as j, isRelation as k, isInOut as l, isIncoming as m, isOutgoing as n, isRelationExpression as o, isRelationWhere as p, isCustomRelationExpr as q, isRelationPredicateExpr as r, isTagEqual as s, isKindEqual as t, isNotOperator as u, isAndOperator as v, isOrOperator as w, whereOperatorAsPredicate as x, DefaultArrowType as y, DefaultRelationshipColor as z };