@likec4/core 0.40.0 → 0.42.0

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

@@ -1,6 +0,0 @@
-import type { ComputedEdge, Fqn, Relation } from '../types';
-export declare class EdgeBuilder {
-    private _relationsObj;
-    add(source: Fqn, target: Fqn, relation: Relation): this;
-    build(): ComputedEdge[];
-}

package/dist/esm/compute-view/EdgeBuilder.js

@@ -1,30 +0,0 @@
-import { keys, pluck } from "rambdax";
-import { commonAncestor, compareRelations } from "../utils/index.js";
-export class EdgeBuilder {
-  _relationsObj = {};
-  add(source, target, relation) {
-    const bySource = this._relationsObj[source] ?? {};
-    const relations = bySource[target] ?? [];
-    relations.push(relation);
-    bySource[target] = relations;
-    this._relationsObj[source] = bySource;
-    return this;
-  }
-  build() {
-    return keys(this._relationsObj).flatMap((source) => {
-      const targets = this._relationsObj[source] ?? {};
-      return keys(targets).map((target) => {
-        const relations = (targets[target] ?? []).sort(compareRelations);
-        const label = relations.find((r) => r.title !== "")?.title ?? null;
-        return {
-          id: `${source}:${target}`,
-          parent: commonAncestor(source, target),
-          source,
-          target,
-          label,
-          relations: pluck("id", relations)
-        };
-      });
-    }).sort(compareRelations).reverse();
-  }
-}

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

@@ -1,20 +0,0 @@
-import type { ModelIndex } from '../model-index';
-import type { Fqn, Element, Relation, ViewRuleExpression, ElementView } from '../types';
-export type ComputeCtxPatch = {
-    elements?: Element[];
-    relations?: Relation[];
-    implicits?: Element[];
-};
-export declare class ComputeCtx {
-    index: ModelIndex;
-    root: Fqn | null;
-    elements: ReadonlySet<Element>;
-    relations: ReadonlySet<Relation>;
-    implicits: ReadonlySet<Element>;
-    readonly allElements: ReadonlySet<Element>;
-    constructor(index: ModelIndex, root: Fqn | null, elements?: ReadonlySet<Element>, relations?: ReadonlySet<Relation>, implicits?: ReadonlySet<Element>);
-    include({ elements, relations, implicits }: ComputeCtxPatch): ComputeCtx;
-    exclude({ elements, relations, implicits }: ComputeCtxPatch): ComputeCtx;
-    processViewRules(viewRules: ViewRuleExpression[]): ComputeCtx;
-    static create(view: ElementView, index: ModelIndex): ComputeCtx;
-}

package/dist/esm/compute-view/compute-ctx.js

@@ -1,100 +0,0 @@
-import { difference } from "rambdax";
-import { Expr, isStrictElementView, isViewRuleExpression } from "../types/index.js";
-import {
-  excludeElementKindOrTag,
-  excludeElementRef,
-  excludeInOutExpr,
-  excludeIncomingExpr,
-  excludeOutgoingExpr,
-  excludeRelationExpr,
-  excludeWildcardRef,
-  includeElementKindOrTag,
-  includeElementRef,
-  includeInOutExpr,
-  includeIncomingExpr,
-  includeOutgoingExpr,
-  includeRelationExpr,
-  includeWildcardRef
-} from "./compute-predicates.js";
-import { nonexhaustive } from "../errors/index.js";
-export class ComputeCtx {
-  constructor(index, root, elements = /* @__PURE__ */ new Set(), relations = /* @__PURE__ */ new Set(), implicits = /* @__PURE__ */ new Set()) {
-    this.index = index;
-    this.root = root;
-    this.elements = elements;
-    this.relations = relations;
-    this.implicits = implicits;
-    this.allElements = /* @__PURE__ */ new Set([...this.elements, ...this.implicits]);
-  }
-  allElements;
-  include({ elements, relations, implicits }) {
-    return new ComputeCtx(
-      this.index,
-      this.root,
-      elements ? /* @__PURE__ */ new Set([...this.elements, ...elements]) : this.elements,
-      relations ? /* @__PURE__ */ new Set([...this.relations, ...relations]) : this.relations,
-      implicits ? /* @__PURE__ */ new Set([...this.implicits, ...implicits]) : this.implicits
-    );
-  }
-  exclude({ elements, relations, implicits }) {
-    let newImplicits = implicits ? new Set(difference([...this.implicits], implicits)) : this.implicits;
-    if (elements) {
-      newImplicits = new Set(difference([...newImplicits], elements));
-    }
-    return new ComputeCtx(
-      this.index,
-      this.root,
-      elements ? new Set(difference([...this.elements], elements)) : this.elements,
-      relations ? new Set(difference([...this.relations], relations)) : this.relations,
-      newImplicits
-    );
-  }
-  processViewRules(viewRules) {
-    let ctx = this;
-    for (const { isInclude, exprs } of viewRules) {
-      for (const expr of exprs) {
-        if (Expr.isElementKindExpr(expr) || Expr.isElementTagExpr(expr)) {
-          ctx = isInclude ? includeElementKindOrTag(ctx, expr) : excludeElementKindOrTag(ctx, expr);
-          continue;
-        }
-        if (Expr.isElementRef(expr)) {
-          ctx = isInclude ? includeElementRef(ctx, expr) : excludeElementRef(ctx, expr);
-          continue;
-        }
-        if (Expr.isWildcard(expr)) {
-          ctx = isInclude ? includeWildcardRef(ctx, expr) : excludeWildcardRef(ctx, expr);
-          continue;
-        }
-        if (Expr.isIncoming(expr)) {
-          ctx = isInclude ? includeIncomingExpr(ctx, expr) : excludeIncomingExpr(ctx, expr);
-          continue;
-        }
-        if (Expr.isOutgoing(expr)) {
-          ctx = isInclude ? includeOutgoingExpr(ctx, expr) : excludeOutgoingExpr(ctx, expr);
-          continue;
-        }
-        if (Expr.isInOut(expr)) {
-          ctx = isInclude ? includeInOutExpr(ctx, expr) : excludeInOutExpr(ctx, expr);
-          continue;
-        }
-        if (Expr.isRelation(expr)) {
-          ctx = isInclude ? includeRelationExpr(ctx, expr) : excludeRelationExpr(ctx, expr);
-          continue;
-        }
-        nonexhaustive(expr);
-      }
-    }
-    return ctx;
-  }
-  static create(view, index) {
-    const rootElement = isStrictElementView(view) ? view.viewOf : null;
-    let ctx = new ComputeCtx(index, rootElement);
-    const rulesInclude = view.rules.filter(isViewRuleExpression);
-    if (rootElement && rulesInclude.length == 0) {
-      ctx = ctx.include({
-        elements: [index.find(rootElement)]
-      });
-    }
-    return ctx.processViewRules(rulesInclude);
-  }
-}

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

@@ -1,3 +0,0 @@
-import type { ModelIndex } from '../model-index';
-import { type ComputedView, type ElementView } from '../types';
-export declare function computeElementView(view: ElementView, index: ModelIndex): ComputedView;

package/dist/esm/compute-view/compute-element-view.js

@@ -1,98 +0,0 @@
-import { allPass, find } from "remeda";
-import { nonNullable } from "../errors/index.js";
-import {
-  DefaultElementShape,
-  DefaultThemeColor,
-  isViewRuleAutoLayout,
-  isViewRuleStyle
-} from "../types/index.js";
-import { compareByFqnHierarchically, isAncestor, isSameHierarchy, parentFqn } from "../utils/index.js";
-import { EdgeBuilder } from "./EdgeBuilder.js";
-import { ComputeCtx } from "./compute-ctx.js";
-import { applyViewRuleStyles } from "./utils/applyViewRuleStyles.js";
-import { sortNodes } from "./utils/sortNodes.js";
-function reduceToMap(elementsIterator) {
-  return Array.from(elementsIterator).sort(compareByFqnHierarchically).reduce((map, { id, color, shape, ...el }) => {
-    let parent = parentFqn(id);
-    let level = 0;
-    while (parent) {
-      if (map.has(parent)) {
-        break;
-      }
-      parent = parentFqn(parent);
-    }
-    if (parent) {
-      const parentNd = nonNullable(map.get(parent));
-      parentNd.children.push(id);
-      level = parentNd.level + 1;
-    }
-    const node = {
-      ...el,
-      id,
-      parent,
-      level,
-      color: color ?? DefaultThemeColor,
-      shape: shape ?? DefaultElementShape,
-      children: [],
-      inEdges: [],
-      outEdges: []
-    };
-    map.set(id, node);
-    return map;
-  }, /* @__PURE__ */ new Map());
-}
-const keepOriginalSortFromView = (_nodes, ctx) => {
-  const nodes = [...ctx.allElements].flatMap((e) => _nodes.get(e.id) || []);
-  for (const node of nodes) {
-    node.children = nodes.flatMap((n) => n.parent === node.id ? n.id : []);
-  }
-  return nodes;
-};
-export function computeElementView(view, index) {
-  const ctx = ComputeCtx.create(view, index);
-  const leafsFirst = [...ctx.allElements].sort((a, b) => -1 * compareByFqnHierarchically(a, b));
-  const elementsWithRelations = /* @__PURE__ */ new Set();
-  const edgeBuilder = new EdgeBuilder();
-  const anscestorOf = (id) => (e) => e.id === id || isAncestor(e.id, id);
-  const sortedRelations = [...ctx.relations];
-  for (const rel of sortedRelations) {
-    const source = find(leafsFirst, anscestorOf(rel.source));
-    if (!source) {
-      continue;
-    }
-    const target = find(
-      leafsFirst,
-      allPass([anscestorOf(rel.target), (e) => !isSameHierarchy(e, source)])
-    );
-    if (!target) {
-      continue;
-    }
-    elementsWithRelations.add(source);
-    elementsWithRelations.add(target);
-    edgeBuilder.add(source.id, target.id, rel);
-  }
-  const nodesMap = reduceToMap(/* @__PURE__ */ new Set([...ctx.elements, ...elementsWithRelations]));
-  const edges = edgeBuilder.build().map((edge) => {
-    while (edge.parent) {
-      if (nodesMap.has(edge.parent)) {
-        break;
-      }
-      edge.parent = parentFqn(edge.parent);
-    }
-    nonNullable(nodesMap.get(edge.source)).outEdges.push(edge.id);
-    nonNullable(nodesMap.get(edge.target)).inEdges.push(edge.id);
-    return edge;
-  });
-  const nodes = applyViewRuleStyles(
-    view.rules.filter(isViewRuleStyle),
-    sortNodes(keepOriginalSortFromView(nodesMap, ctx), edges)
-    // map(e => nodesMap.get(e.id)!, Array.from(elements))
-  );
-  const autoLayoutRule = view.rules.find(isViewRuleAutoLayout);
-  return {
-    ...view,
-    autoLayout: autoLayoutRule?.autoLayout ?? "TB",
-    nodes,
-    edges
-  };
-}

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

@@ -1,16 +0,0 @@
-import { Expr } from '../types';
-import { ComputeCtx } from './compute-ctx';
-export declare const includeElementRef: (ctx: ComputeCtx, expr: Expr.ElementRefExpr) => ComputeCtx;
-export declare const excludeElementRef: (ctx: ComputeCtx, expr: Expr.ElementRefExpr) => ComputeCtx;
-export declare const includeElementKindOrTag: (ctx: ComputeCtx, expr: Expr.ElementKindExpr | Expr.ElementTagExpr) => ComputeCtx;
-export declare const excludeElementKindOrTag: (ctx: ComputeCtx, expr: Expr.ElementKindExpr | Expr.ElementTagExpr) => ComputeCtx;
-export declare const includeWildcardRef: (ctx: ComputeCtx, _expr: Expr.WildcardExpr) => ComputeCtx;
-export declare const excludeWildcardRef: (ctx: ComputeCtx, _expr: Expr.WildcardExpr) => ComputeCtx;
-export declare const includeIncomingExpr: (ctx: ComputeCtx, expr: Expr.IncomingExpr) => ComputeCtx;
-export declare const excludeIncomingExpr: (ctx: ComputeCtx, expr: Expr.IncomingExpr) => ComputeCtx;
-export declare const includeOutgoingExpr: (ctx: ComputeCtx, expr: Expr.OutgoingExpr) => ComputeCtx;
-export declare const excludeOutgoingExpr: (ctx: ComputeCtx, expr: Expr.OutgoingExpr) => ComputeCtx;
-export declare const includeInOutExpr: (ctx: ComputeCtx, expr: Expr.InOutExpr) => ComputeCtx;
-export declare const excludeInOutExpr: (ctx: ComputeCtx, expr: Expr.InOutExpr) => ComputeCtx;
-export declare const includeRelationExpr: (ctx: ComputeCtx, expr: Expr.RelationExpr) => ComputeCtx;
-export declare const excludeRelationExpr: (ctx: ComputeCtx, expr: Expr.RelationExpr) => ComputeCtx;

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

@@ -1,324 +0,0 @@
-import { anyPass, both, either, isNil, uniq } from "rambdax";
-import { Expr } from "../types/index.js";
-import { Relations, commonAncestor, isAncestor, isSameHierarchy } 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(both(isInside(expr.element), isAnyInOut(child.id)));
-    });
-  }
-  const ctxElements = uniq([...ctx.elements, ...ctx.implicits]);
-  const excludeImplicits = [];
-  for (const el of elements) {
-    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 (!isSameHierarchy(el, ctxEl)) {
-        filters.push(isAnyBetween(el.id, ctxEl.id));
-      }
-    }
-  }
-  const relations = filters.length ? ctx.index.filterRelations(anyPass(filters)) : [];
-  if (excludeImplicits.length == 0) {
-    return ctx.include({ elements, relations });
-  }
-  return ctx.include({ elements, relations }).exclude({ implicits: excludeImplicits });
-};
-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 asElementPredicate = (expr) => {
-  if (expr.isEqual) {
-    if (Expr.isElementKindExpr(expr)) {
-      return (e) => e.kind === expr.elementKind;
-    } else {
-      return ({ tags }) => !!tags && tags.includes(expr.elementTag);
-    }
-  } else {
-    if (Expr.isElementKindExpr(expr)) {
-      return (e) => e.kind !== expr.elementKind;
-    } else {
-      return ({ tags }) => isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
-    }
-  }
-};
-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
-  );
-};
-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 });
-};
-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(isAnyInOut(root));
-    const implicits = [];
-    for (const implicit of allImplicits) {
-      if (inOut.some(isAnyInOut(implicit.id))) {
-        implicits.push(implicit);
-      }
-    }
-    return ctx.include({
-      elements,
-      relations: [...ctx.index.filterRelations(isInside(root)), ...inOut],
-      implicits
-    });
-  } else {
-    const elements = ctx.index.rootElements();
-    if (elements.length <= 1) {
-      return new ComputeCtx(ctx.index, ctx.root, new Set(elements));
-    }
-    const relations = ctx.index.filterRelations(
-      (rel) => isNil(commonAncestor(rel.source, rel.target))
-    );
-    return ctx.include({
-      elements,
-      relations
-    });
-  }
-};
-export const excludeWildcardRef = (ctx, _expr) => {
-  const { root } = ctx;
-  if (root) {
-    const relations = [...ctx.relations].filter(either(isInside(root), isAnyInOut(root)));
-    return ctx.exclude({
-      elements: [...ctx.elements].filter((e) => e.id === root || isAncestor(root, e.id)),
-      relations,
-      implicits: [...ctx.implicits].filter((e) => relations.some(isAnyInOut(e.id)))
-    });
-  } else {
-    return new ComputeCtx(ctx.index, ctx.root);
-  }
-};
-const resolveElements = (ctx, expr) => {
-  if (Expr.isWildcard(expr)) {
-    if (ctx.root) {
-      return [ctx.index.find(ctx.root)];
-    } else {
-      return ctx.index.rootElements();
-    }
-  }
-  if (Expr.isElementKindExpr(expr)) {
-    return ctx.index.elements.filter((el) => {
-      if (expr.isEqual) {
-        return el.kind === expr.elementKind;
-      }
-      return el.kind !== expr.elementKind;
-    });
-  }
-  if (Expr.isElementTagExpr(expr)) {
-    return ctx.index.elements.filter((el) => {
-      const tags = el.tags;
-      if (expr.isEqual) {
-        return !!tags && tags.includes(expr.elementTag);
-      }
-      return isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
-    });
-  }
-  if (expr.isDescedants) {
-    return ctx.index.children(expr.element);
-  } else {
-    return [ctx.index.find(expr.element)];
-  }
-};
-export const includeIncomingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.incoming) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.incoming);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (Expr.isElementRef(expr.incoming)) {
-    allrelations = allrelations.filter(isIncoming(expr.incoming.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const el of elements) {
-    const elRelations = allrelations.filter(isIncoming(el.id));
-    if (elRelations.length > 0) {
-      relations.push(...elRelations);
-      implicits.push(el);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-export const excludeIncomingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.incoming) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.incoming);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  const isIncomings = anyPass(elements.map((el) => isIncoming(el.id)));
-  const excluded = [...ctx.relations].filter(isIncomings);
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-export const includeOutgoingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.outgoing);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (Expr.isElementRef(expr.outgoing)) {
-    allrelations = allrelations.filter(isOutgoing(expr.outgoing.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const el of elements) {
-    const elRelations = allrelations.filter(isOutgoing(el.id));
-    if (elRelations.length > 0) {
-      relations.push(...elRelations);
-      implicits.push(el);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-export const excludeOutgoingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.outgoing);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  const isOutgoings = anyPass(elements.map((el) => isOutgoing(el.id)));
-  const excluded = [...ctx.relations].filter(isOutgoings);
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-export const includeInOutExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.inout) && !ctx.root) {
-    return ctx;
-  }
-  const targets = resolveElements(ctx, expr.inout);
-  if (targets.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (Expr.isElementRef(expr.inout)) {
-    allrelations = allrelations.filter(isAnyInOut(expr.inout.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const target of targets) {
-    const foundRelations = allrelations.filter(isAnyInOut(target.id));
-    if (foundRelations.length > 0) {
-      relations.push(...foundRelations);
-      implicits.push(target);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-export const excludeInOutExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.inout) && !ctx.root) {
-    return ctx;
-  }
-  const targets = resolveElements(ctx, expr.inout);
-  if (targets.length === 0) {
-    return ctx;
-  }
-  const excluded = [...ctx.relations].filter(anyPass(targets.map((t) => isAnyInOut(t.id))));
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-export const includeRelationExpr = (ctx, expr) => {
-  const sources = resolveElements(ctx, expr.source);
-  const targets = resolveElements(ctx, expr.target);
-  if (sources.length === 0 || targets.length === 0) {
-    return ctx;
-  }
-  const implicits = [];
-  const relations = [];
-  for (const source of sources) {
-    for (const target of targets) {
-      if (isSameHierarchy(source, target)) {
-        continue;
-      }
-      const foundRelations = ctx.index.filterRelations(isBetween(source.id, target.id));
-      if (foundRelations.length > 0) {
-        relations.push(...foundRelations);
-        implicits.push(source, target);
-      }
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-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 (isSameHierarchy(source, target)) {
-        continue;
-      }
-      filters.push(isBetween(source.id, target.id));
-    }
-  }
-  if (filters.length == 0) {
-    return ctx;
-  }
-  const excluded = [...ctx.relations].filter(anyPass(filters));
-  if (excluded.length == 0) {
-    return ctx;
-  }
-  return ctx.exclude({
-    relations: excluded
-  });
-};

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

@@ -1,14 +0,0 @@
-import type { BaseError } from '../errors';
-import type { ModelIndex } from '../model-index';
-import { type ComputedView, type ElementView } from '../types';
-type ComputeViewResult = {
-    isSuccess: true;
-    view: ComputedView;
-} | {
-    isSuccess: false;
-    error: BaseError;
-    view: undefined;
-};
-export declare function computeView(view: ElementView, index: ModelIndex): ComputeViewResult;
-export declare function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R;
-export {};

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

@@ -1,36 +0,0 @@
-import { find } from "rambdax";
-import { normalizeError } from "../errors/index.js";
-import { computeElementView } from "./compute-element-view.js";
-export function computeView(view, index) {
-  try {
-    return {
-      isSuccess: true,
-      view: computeElementView(view, index)
-    };
-  } catch (e) {
-    return {
-      isSuccess: false,
-      error: normalizeError(e),
-      view: void 0
-    };
-  }
-}
-export function assignNavigateTo(views) {
-  const allElementViews = /* @__PURE__ */ new Map();
-  for (const v of views) {
-    if (v.viewOf && !v.extends) {
-      const viewsOf = allElementViews.get(v.viewOf) ?? [];
-      viewsOf.push(v.id);
-      allElementViews.set(v.viewOf, viewsOf);
-    }
-  }
-  for (const { id, nodes } of views) {
-    for (const node of nodes) {
-      const navigateTo = find((v) => v !== id, allElementViews.get(node.id) ?? []);
-      if (navigateTo) {
-        node.navigateTo = navigateTo;
-      }
-    }
-  }
-  return views;
-}

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

@@ -1,4 +0,0 @@
-export * from './compute';
-export * from './resolve-extended-views';
-export * from './resolve-relative-paths';
-export * from './EdgeBuilder';

package/dist/esm/compute-view/index.js

@@ -1,4 +0,0 @@
-export * from "./compute.js";
-export * from "./resolve-extended-views.js";
-export * from "./resolve-relative-paths.js";
-export * from "./EdgeBuilder.js";

package/dist/esm/compute-view/resolve-extended-views.d.ts

@@ -1,6 +0,0 @@
-import { type ElementView } from '../types';
-/**
- * Resolve rules of extended views
- * (Removes invalid views)
- */
-export declare function resolveRulesExtendedViews<V extends Record<any, ElementView>>(unresolvedViews: V): V;