@likec4/core 0.33.1 → 0.34.0

package/dist/compute-view/compute-predicates.js

@@ -1,146 +1,120 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.includeWildcardRef = exports.includeRelationExpr = exports.includeOutgoingExpr = exports.includeIncomingExpr = exports.includeInOutExpr = exports.includeElementRef = exports.includeElementKindOrTag = exports.excludeWildcardRef = exports.excludeRelationExpr = exports.excludeOutgoingExpr = exports.excludeIncomingExpr = exports.excludeInOutExpr = exports.excludeElementRef = exports.excludeElementKindOrTag = void 0;
-var _rambdax = require("rambdax");
-var Expr = _interopRequireWildcard(require("../types/expression"));
-var _utils = require("../utils");
-var _relations = require("../utils/relations");
-var _computeCtx = require("./compute-ctx");
-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; }
-const includeElementRef = (ctx, expr) => {
+import { anyPass, both, either, isNil, uniq } from "rambdax";
+import { Expr } from "../types/index.js";
+import { commonAncestor, isAncestor, isSameHierarchy, Relations } from "../utils/index.js";
+import { ComputeCtx } from "./compute-ctx.js";
+const { isAnyInOut, isBetween, isIncoming, isInside, isOutgoing, isAnyBetween } = Relations;
+export const includeElementRef = (ctx, expr) => {
   const elements = expr.isDescedants ? ctx.index.children(expr.element) : [ctx.index.find(expr.element)];
   const filters = [];
   if (expr.isDescedants) {
-    elements.forEach(child => {
-      filters.push((0, _rambdax.both)(_utils.Relations.isInside(expr.element), _utils.Relations.isAnyInOut(child.id)));
+    elements.forEach((child) => {
+      filters.push(both(isInside(expr.element), isAnyInOut(child.id)));
     });
   }
-  const ctxElements = (0, _rambdax.uniq)([...ctx.elements, ...ctx.implicits]);
+  const ctxElements = uniq([...ctx.elements, ...ctx.implicits]);
   const excludeImplicits = [];
   for (const el of elements) {
-    if (ctx.root && ctx.root !== el.id && !(0, _utils.isAncestor)(el.id, ctx.root)) {
-      excludeImplicits.push(...[...ctx.implicits].filter(impl => (0, _utils.isAncestor)(el.id, impl.id)));
+    if (ctx.root && ctx.root !== el.id && !isAncestor(el.id, ctx.root)) {
+      excludeImplicits.push(...[...ctx.implicits].filter((impl) => isAncestor(el.id, impl.id)));
     }
     for (const ctxEl of ctxElements) {
-      if (!(0, _utils.isSameHierarchy)(el, ctxEl)) {
-        filters.push(_utils.Relations.isAnyBetween(el.id, ctxEl.id));
+      if (!isSameHierarchy(el, ctxEl)) {
+        filters.push(isAnyBetween(el.id, ctxEl.id));
       }
     }
   }
-  const relations = filters.length ? ctx.index.filterRelations((0, _rambdax.anyPass)(filters)) : [];
+  const relations = filters.length ? ctx.index.filterRelations(anyPass(filters)) : [];
   if (excludeImplicits.length == 0) {
-    return ctx.include({
-      elements,
-      relations
-    });
+    return ctx.include({ elements, relations });
   }
-  return ctx.include({
-    elements,
-    relations
-  }).exclude({
-    implicits: excludeImplicits
-  });
+  return ctx.include({ elements, relations }).exclude({ implicits: excludeImplicits });
 };
-exports.includeElementRef = includeElementRef;
-const excludeElementRef = (ctx, expr) => {
+export const excludeElementRef = (ctx, expr) => {
   const elements = expr.isDescedants ? ctx.index.children(expr.element) : [ctx.index.find(expr.element)];
-  const elementsIds = elements.map(e => e.id);
-  const relations = [...ctx.relations].filter(r => elementsIds.includes(r.source) || elementsIds.includes(r.target));
-  return ctx.exclude({
-    elements,
-    relations
-  });
+  const elementsIds = elements.map((e) => e.id);
+  const relations = [...ctx.relations].filter(
+    (r) => elementsIds.includes(r.source) || elementsIds.includes(r.target)
+  );
+  return ctx.exclude({ elements, relations });
 };
-exports.excludeElementRef = excludeElementRef;
-const asElementPredicate = expr => {
+const asElementPredicate = (expr) => {
   if (expr.isEqual) {
     if (Expr.isElementKindExpr(expr)) {
-      return e => e.kind === expr.elementKind;
+      return (e) => e.kind === expr.elementKind;
     } else {
-      return ({
-        tags
-      }) => !!tags && tags.includes(expr.elementTag);
+      return ({ tags }) => !!tags && tags.includes(expr.elementTag);
     }
   } else {
     if (Expr.isElementKindExpr(expr)) {
-      return e => e.kind !== expr.elementKind;
+      return (e) => e.kind !== expr.elementKind;
     } else {
-      return ({
-        tags
-      }) => (0, _rambdax.isNil)(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
+      return ({ tags }) => isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
     }
   }
 };
-const includeElementKindOrTag = (ctx, expr) => {
+export const includeElementKindOrTag = (ctx, expr) => {
   const elements = ctx.index.elements.filter(asElementPredicate(expr));
-  return elements.reduce((accCtx, el) => includeElementRef(accCtx, {
-    element: el.id,
-    isDescedants: false
-  }), ctx);
+  return elements.reduce(
+    (accCtx, el) => includeElementRef(accCtx, {
+      element: el.id,
+      isDescedants: false
+    }),
+    ctx
+  );
 };
-exports.includeElementKindOrTag = includeElementKindOrTag;
-const excludeElementKindOrTag = (ctx, expr) => {
+export const excludeElementKindOrTag = (ctx, expr) => {
   const predicate = asElementPredicate(expr);
   const elements = [...ctx.elements].filter(predicate);
   const implicits = [...ctx.implicits].filter(predicate);
-  return ctx.exclude({
-    elements,
-    implicits
-  });
+  return ctx.exclude({ elements, implicits });
 };
-exports.excludeElementKindOrTag = excludeElementKindOrTag;
-const includeWildcardRef = (ctx, _expr) => {
-  const {
-    root
-  } = ctx;
+export const includeWildcardRef = (ctx, _expr) => {
+  const { root } = ctx;
   if (root) {
     const elements = [ctx.index.find(root), ...ctx.index.children(root)];
-    const allImplicits = [...ctx.index.siblings(root), ...ctx.index.ancestors(root).flatMap(a => [...ctx.index.siblings(a.id)])];
-    const inOut = ctx.index.filterRelations((0, _relations.isAnyInOut)(root));
+    const allImplicits = [
+      ...ctx.index.siblings(root),
+      ...ctx.index.ancestors(root).flatMap((a) => [...ctx.index.siblings(a.id)])
+    ];
+    const inOut = ctx.index.filterRelations(isAnyInOut(root));
     const implicits = [];
     for (const implicit of allImplicits) {
-      if (inOut.some((0, _relations.isAnyInOut)(implicit.id))) {
+      if (inOut.some(isAnyInOut(implicit.id))) {
         implicits.push(implicit);
       }
     }
     return ctx.include({
       elements,
-      relations: [...ctx.index.filterRelations((0, _relations.isInside)(root)), ...inOut],
+      relations: [...ctx.index.filterRelations(isInside(root)), ...inOut],
       implicits
     });
   } else {
     const elements = ctx.index.rootElements();
     if (elements.length <= 1) {
-      return new _computeCtx.ComputeCtx(ctx.index, ctx.root, new Set(elements));
+      return new ComputeCtx(ctx.index, ctx.root, new Set(elements));
     }
-    const relations = ctx.index.filterRelations(rel => (0, _rambdax.isNil)((0, _utils.commonAncestor)(rel.source, rel.target)));
+    const relations = ctx.index.filterRelations(
+      (rel) => isNil(commonAncestor(rel.source, rel.target))
+    );
     return ctx.include({
       elements,
       relations
     });
   }
 };
-exports.includeWildcardRef = includeWildcardRef;
-const excludeWildcardRef = (ctx, _expr) => {
-  const {
-    root
-  } = ctx;
+export const excludeWildcardRef = (ctx, _expr) => {
+  const { root } = ctx;
   if (root) {
-    const relations = [...ctx.relations].filter((0, _rambdax.either)((0, _relations.isInside)(root), (0, _relations.isAnyInOut)(root)));
+    const relations = [...ctx.relations].filter(either(isInside(root), isAnyInOut(root)));
     return ctx.exclude({
-      elements: [...ctx.elements].filter(e => e.id === root || (0, _utils.isAncestor)(root, e.id)),
+      elements: [...ctx.elements].filter((e) => e.id === root || isAncestor(root, e.id)),
       relations,
-      implicits: [...ctx.implicits].filter(e => relations.some((0, _relations.isAnyInOut)(e.id)))
+      implicits: [...ctx.implicits].filter((e) => relations.some(isAnyInOut(e.id)))
     });
   } else {
-    return new _computeCtx.ComputeCtx(ctx.index, ctx.root);
+    return new ComputeCtx(ctx.index, ctx.root);
   }
 };
-exports.excludeWildcardRef = excludeWildcardRef;
 const resolveElements = (ctx, expr) => {
   if (Expr.isWildcard(expr)) {
     if (ctx.root) {
@@ -150,7 +124,7 @@ const resolveElements = (ctx, expr) => {
     }
   }
   if (Expr.isElementKindExpr(expr)) {
-    return ctx.index.elements.filter(el => {
+    return ctx.index.elements.filter((el) => {
       if (expr.isEqual) {
         return el.kind === expr.elementKind;
       }
@@ -158,12 +132,12 @@ const resolveElements = (ctx, expr) => {
     });
   }
   if (Expr.isElementTagExpr(expr)) {
-    return ctx.index.elements.filter(el => {
+    return ctx.index.elements.filter((el) => {
       const tags = el.tags;
       if (expr.isEqual) {
         return !!tags && tags.includes(expr.elementTag);
       }
-      return (0, _rambdax.isNil)(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
+      return isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
     });
   }
   if (expr.isDescedants) {
@@ -172,7 +146,7 @@ const resolveElements = (ctx, expr) => {
     return [ctx.index.find(expr.element)];
   }
 };
-const includeIncomingExpr = (ctx, expr) => {
+export const includeIncomingExpr = (ctx, expr) => {
   if (Expr.isWildcard(expr.incoming) && !ctx.root) {
     return ctx;
   }
@@ -182,12 +156,12 @@ const includeIncomingExpr = (ctx, expr) => {
   }
   let allrelations = ctx.index.relations;
   if (Expr.isElementRef(expr.incoming)) {
-    allrelations = allrelations.filter((0, _relations.isIncoming)(expr.incoming.element));
+    allrelations = allrelations.filter(isIncoming(expr.incoming.element));
   }
   const implicits = [];
   const relations = [];
   for (const el of elements) {
-    const elRelations = allrelations.filter((0, _relations.isIncoming)(el.id));
+    const elRelations = allrelations.filter(isIncoming(el.id));
     if (elRelations.length > 0) {
       relations.push(...elRelations);
       implicits.push(el);
@@ -198,8 +172,7 @@ const includeIncomingExpr = (ctx, expr) => {
     implicits
   });
 };
-exports.includeIncomingExpr = includeIncomingExpr;
-const excludeIncomingExpr = (ctx, expr) => {
+export const excludeIncomingExpr = (ctx, expr) => {
   if (Expr.isWildcard(expr.incoming) && !ctx.root) {
     return ctx;
   }
@@ -207,7 +180,7 @@ const excludeIncomingExpr = (ctx, expr) => {
   if (elements.length === 0) {
     return ctx;
   }
-  const isIncomings = (0, _rambdax.anyPass)(elements.map(el => (0, _relations.isIncoming)(el.id)));
+  const isIncomings = anyPass(elements.map((el) => isIncoming(el.id)));
   const excluded = [...ctx.relations].filter(isIncomings);
   if (excluded.length > 0) {
     return ctx.exclude({
@@ -216,8 +189,7 @@ const excludeIncomingExpr = (ctx, expr) => {
   }
   return ctx;
 };
-exports.excludeIncomingExpr = excludeIncomingExpr;
-const includeOutgoingExpr = (ctx, expr) => {
+export const includeOutgoingExpr = (ctx, expr) => {
   if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
     return ctx;
   }
@@ -227,12 +199,12 @@ const includeOutgoingExpr = (ctx, expr) => {
   }
   let allrelations = ctx.index.relations;
   if (Expr.isElementRef(expr.outgoing)) {
-    allrelations = allrelations.filter((0, _relations.isOutgoing)(expr.outgoing.element));
+    allrelations = allrelations.filter(isOutgoing(expr.outgoing.element));
   }
   const implicits = [];
   const relations = [];
   for (const el of elements) {
-    const elRelations = allrelations.filter((0, _relations.isOutgoing)(el.id));
+    const elRelations = allrelations.filter(isOutgoing(el.id));
     if (elRelations.length > 0) {
       relations.push(...elRelations);
       implicits.push(el);
@@ -243,8 +215,7 @@ const includeOutgoingExpr = (ctx, expr) => {
     implicits
   });
 };
-exports.includeOutgoingExpr = includeOutgoingExpr;
-const excludeOutgoingExpr = (ctx, expr) => {
+export const excludeOutgoingExpr = (ctx, expr) => {
   if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
     return ctx;
   }
@@ -252,7 +223,7 @@ const excludeOutgoingExpr = (ctx, expr) => {
   if (elements.length === 0) {
     return ctx;
   }
-  const isOutgoings = (0, _rambdax.anyPass)(elements.map(el => (0, _relations.isOutgoing)(el.id)));
+  const isOutgoings = anyPass(elements.map((el) => isOutgoing(el.id)));
   const excluded = [...ctx.relations].filter(isOutgoings);
   if (excluded.length > 0) {
     return ctx.exclude({
@@ -261,8 +232,7 @@ const excludeOutgoingExpr = (ctx, expr) => {
   }
   return ctx;
 };
-exports.excludeOutgoingExpr = excludeOutgoingExpr;
-const includeInOutExpr = (ctx, expr) => {
+export const includeInOutExpr = (ctx, expr) => {
   if (Expr.isWildcard(expr.inout) && !ctx.root) {
     return ctx;
   }
@@ -272,12 +242,12 @@ const includeInOutExpr = (ctx, expr) => {
   }
   let allrelations = ctx.index.relations;
   if (Expr.isElementRef(expr.inout)) {
-    allrelations = allrelations.filter((0, _relations.isAnyInOut)(expr.inout.element));
+    allrelations = allrelations.filter(isAnyInOut(expr.inout.element));
   }
   const implicits = [];
   const relations = [];
   for (const target of targets) {
-    const foundRelations = allrelations.filter((0, _relations.isAnyInOut)(target.id));
+    const foundRelations = allrelations.filter(isAnyInOut(target.id));
     if (foundRelations.length > 0) {
       relations.push(...foundRelations);
       implicits.push(target);
@@ -288,8 +258,7 @@ const includeInOutExpr = (ctx, expr) => {
     implicits
   });
 };
-exports.includeInOutExpr = includeInOutExpr;
-const excludeInOutExpr = (ctx, expr) => {
+export const excludeInOutExpr = (ctx, expr) => {
   if (Expr.isWildcard(expr.inout) && !ctx.root) {
     return ctx;
   }
@@ -297,7 +266,7 @@ const excludeInOutExpr = (ctx, expr) => {
   if (targets.length === 0) {
     return ctx;
   }
-  const excluded = [...ctx.relations].filter((0, _rambdax.anyPass)(targets.map(t => (0, _relations.isAnyInOut)(t.id))));
+  const excluded = [...ctx.relations].filter(anyPass(targets.map((t) => isAnyInOut(t.id))));
   if (excluded.length > 0) {
     return ctx.exclude({
       relations: excluded
@@ -305,8 +274,7 @@ const excludeInOutExpr = (ctx, expr) => {
   }
   return ctx;
 };
-exports.excludeInOutExpr = excludeInOutExpr;
-const includeRelationExpr = (ctx, expr) => {
+export const includeRelationExpr = (ctx, expr) => {
   const sources = resolveElements(ctx, expr.source);
   const targets = resolveElements(ctx, expr.target);
   if (sources.length === 0 || targets.length === 0) {
@@ -316,10 +284,10 @@ const includeRelationExpr = (ctx, expr) => {
   const relations = [];
   for (const source of sources) {
     for (const target of targets) {
-      if ((0, _utils.isSameHierarchy)(source, target)) {
+      if (isSameHierarchy(source, target)) {
         continue;
       }
-      const foundRelations = ctx.index.filterRelations((0, _relations.isBetween)(source.id, target.id));
+      const foundRelations = ctx.index.filterRelations(isBetween(source.id, target.id));
       if (foundRelations.length > 0) {
         relations.push(...foundRelations);
         implicits.push(source, target);
@@ -331,23 +299,22 @@ const includeRelationExpr = (ctx, expr) => {
     implicits
   });
 };
-exports.includeRelationExpr = includeRelationExpr;
-const excludeRelationExpr = (ctx, expr) => {
+export const excludeRelationExpr = (ctx, expr) => {
   const sources = resolveElements(ctx, expr.source);
   const targets = resolveElements(ctx, expr.target);
   const filters = [];
   for (const source of sources) {
     for (const target of targets) {
-      if ((0, _utils.isSameHierarchy)(source, target)) {
+      if (isSameHierarchy(source, target)) {
         continue;
       }
-      filters.push((0, _relations.isBetween)(source.id, target.id));
+      filters.push(isBetween(source.id, target.id));
     }
   }
   if (filters.length == 0) {
     return ctx;
   }
-  const excluded = [...ctx.relations].filter((0, _rambdax.anyPass)(filters));
+  const excluded = [...ctx.relations].filter(anyPass(filters));
   if (excluded.length == 0) {
     return ctx;
   }
@@ -355,4 +322,3 @@ const excludeRelationExpr = (ctx, expr) => {
     relations: excluded
   });
 };
-exports.excludeRelationExpr = excludeRelationExpr;

package/dist/compute-view/compute.cjs

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignNavigateTo = assignNavigateTo;
+exports.computeView = computeView;
+exports.computeViews = computeViews;
+var _remeda = require("remeda");
+var _modelIndex = require("../model-index/index.cjs");
+var _computeElementView = require("./compute-element-view.cjs");
+var _ = require("../index.cjs");
+function computeView(view, index) {
+  try {
+    return {
+      isSuccess: true,
+      view: (0, _computeElementView.computeElementView)(view, index)
+    };
+  } catch (e) {
+    return {
+      isSuccess: false,
+      error: (0, _.normalizeError)(e),
+      view: void 0
+    };
+  }
+}
+function computeViews(model) {
+  const index = _modelIndex.ModelIndex.from(model);
+  const computedViews = (0, _remeda.compact)((0, _remeda.map)(model.views, view => computeView(view, index).view));
+  return {
+    elements: model.elements,
+    relations: model.relations,
+    views: (0, _remeda.mapToObj)(computedViews, view => [view.id, view])
+  };
+}
+function assignNavigateTo(views) {
+  const allElementViews = /* @__PURE__ */new Map();
+  for (const {
+    id,
+    viewOf
+  } of views) {
+    if (viewOf) {
+      const viewsOf = allElementViews.get(viewOf) ?? [];
+      viewsOf.push(id);
+      allElementViews.set(viewOf, viewsOf);
+    }
+  }
+  for (const {
+    id,
+    nodes
+  } of views) {
+    for (const node of nodes) {
+      const navigateTo = (0, _remeda.find)(allElementViews.get(node.id) ?? [], v => v !== id);
+      if (navigateTo) {
+        node.navigateTo = navigateTo;
+      }
+    }
+  }
+  return views;
+}

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

@@ -1,16 +1,25 @@
 import { ModelIndex } from '../model-index';
 import type { ComputedView, Element, ElementView, Fqn, Relation, RelationID, ViewID } from '../types';
-export declare function computeView<V extends ElementView>(view: V, index: ModelIndex): ComputedView | null;
-type InputModel = {
+import { type BaseError } from '..';
+type ComputeViewResult = {
+    isSuccess: true;
+    view: ComputedView;
+} | {
+    isSuccess: false;
+    error: BaseError;
+    view: undefined;
+};
+export declare function computeView(view: ElementView, index: ModelIndex): ComputeViewResult;
+export type CmpInputModel = {
     elements: Record<Fqn, Element>;
     relations: Record<RelationID, Relation>;
     views: ElementView[];
 };
-type OutputModel = {
+export type CmpOutputModel = {
     elements: Record<Fqn, Element>;
     relations: Record<RelationID, Relation>;
     views: Record<ViewID, ComputedView>;
 };
-export declare function computeViews(model: InputModel): OutputModel;
+export declare function computeViews(model: CmpInputModel): CmpOutputModel;
 export declare function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R;
 export {};

package/dist/compute-view/compute.js

@@ -1,53 +1,46 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.assignNavigateTo = assignNavigateTo;
-exports.computeView = computeView;
-exports.computeViews = computeViews;
-var _remeda = require("remeda");
-var _modelIndex = require("../model-index");
-var _computeElementView = require("./compute-element-view");
-function computeView(view, index) {
+import { compact, find, map, mapToObj } from "remeda";
+import { ModelIndex } from "../model-index/index.js";
+import { computeElementView } from "./compute-element-view.js";
+import { normalizeError } from "../index.js";
+export function computeView(view, index) {
   try {
-    return (0, _computeElementView.computeElementView)(view, index);
+    return {
+      isSuccess: true,
+      view: computeElementView(view, index)
+    };
   } catch (e) {
-    console.error(e);
-    return null;
+    return {
+      isSuccess: false,
+      error: normalizeError(e),
+      view: void 0
+    };
   }
 }
-function computeViews(model) {
-  const index = _modelIndex.ModelIndex.from(model);
-  const computedViews = (0, _remeda.compact)((0, _remeda.map)(model.views, view => computeView(view, index)));
+export function computeViews(model) {
+  const index = ModelIndex.from(model);
+  const computedViews = compact(map(model.views, (view) => computeView(view, index).view));
   return {
     elements: model.elements,
     relations: model.relations,
-    views: (0, _remeda.mapToObj)(computedViews, view => [view.id, view])
+    views: mapToObj(computedViews, (view) => [view.id, view])
   };
 }
-function assignNavigateTo(views) {
-  const allElementViews = /* @__PURE__ */new Map();
-  for (const {
-    id,
-    viewOf
-  } of views) {
+export function assignNavigateTo(views) {
+  const allElementViews = /* @__PURE__ */ new Map();
+  for (const { id, viewOf } of views) {
     if (viewOf) {
       const viewsOf = allElementViews.get(viewOf) ?? [];
       viewsOf.push(id);
       allElementViews.set(viewOf, viewsOf);
     }
   }
-  for (const {
-    id,
-    nodes
-  } of views) {
+  for (const { id, nodes } of views) {
     for (const node of nodes) {
-      const navigateTo = (0, _remeda.find)(allElementViews.get(node.id) ?? [], v => v !== id);
+      const navigateTo = find(allElementViews.get(node.id) ?? [], (v) => v !== id);
       if (navigateTo) {
         node.navigateTo = navigateTo;
       }
     }
   }
   return views;
-}
+}

package/dist/compute-view/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _compute = require("./compute.cjs");
+Object.keys(_compute).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _compute[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _compute[key];
+    }
+  });
+});
+var _EdgeBuilder = require("./EdgeBuilder.cjs");
+Object.keys(_EdgeBuilder).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _EdgeBuilder[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _EdgeBuilder[key];
+    }
+  });
+});

package/dist/compute-view/index.d.ts

@@ -1,3 +1,2 @@
-export { computeView, computeViews, assignNavigateTo } from './compute';
-export type * from '../types/view';
-export type * from '../types/computed-view';
+export * from './compute';
+export * from './EdgeBuilder';

package/dist/compute-view/index.js

@@ -1,24 +1,2 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "assignNavigateTo", {
-  enumerable: true,
-  get: function () {
-    return _compute.assignNavigateTo;
-  }
-});
-Object.defineProperty(exports, "computeView", {
-  enumerable: true,
-  get: function () {
-    return _compute.computeView;
-  }
-});
-Object.defineProperty(exports, "computeViews", {
-  enumerable: true,
-  get: function () {
-    return _compute.computeViews;
-  }
-});
-var _compute = require("./compute");
+export * from "./compute.js";
+export * from "./EdgeBuilder.js";

package/dist/compute-view/utils/anyPossibleRelations.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.anyPossibleRelations = anyPossibleRelations;
+var _rambdax = require("rambdax");
+var _utils = require("../../utils/index.cjs");
+function* anyPossibleRelations(elements) {
+  const uniqElements = (0, _rambdax.uniqBy)((0, _rambdax.prop)("id"), elements).sort(_utils.compareByFqnHierarchically).reverse();
+  for (const source of uniqElements) {
+    for (const target of uniqElements) {
+      if (source !== target && !(0, _utils.isAncestor)(source, target) && !(0, _utils.isAncestor)(target, source)) {
+        yield [source, target];
+      }
+    }
+  }
+}