@likec4/core 0.6.3 → 0.18.0

package/dist/colors.d.ts

@@ -0,0 +1,79 @@
+export interface ElementColors {
+    fill: string;
+    stroke: string;
+    hiContrast: string;
+    loContrast: string;
+}
+export declare const RelationColors: {
+    readonly lineColor: "#a3a3a3";
+    readonly labelColor: "#d4d4d4";
+};
+export declare const Colors: {
+    readonly primary: {
+        fill: string;
+        stroke: string;
+        hiContrast: string;
+        loContrast: string;
+    };
+    readonly blue: {
+        fill: string;
+        stroke: string;
+        hiContrast: string;
+        loContrast: string;
+    };
+    readonly secondary: {
+        fill: string;
+        stroke: string;
+        hiContrast: string;
+        loContrast: string;
+    };
+    readonly sky: {
+        fill: string;
+        stroke: string;
+        hiContrast: string;
+        loContrast: string;
+    };
+    readonly muted: {
+        fill: string;
+        stroke: string;
+        hiContrast: string;
+        loContrast: string;
+    };
+    readonly slate: {
+        fill: string;
+        stroke: string;
+        hiContrast: string;
+        loContrast: string;
+    };
+    readonly gray: {
+        readonly fill: "#737373";
+        readonly stroke: "#525252";
+        readonly hiContrast: "#fafafa";
+        readonly loContrast: "#e5e5e5";
+    };
+    readonly red: {
+        readonly fill: "#ef4444";
+        readonly stroke: "#dc2626";
+        readonly hiContrast: "#fef2f2";
+        readonly loContrast: "#fecaca";
+    };
+    readonly green: {
+        readonly fill: "#16a34a";
+        readonly stroke: "#15803d";
+        readonly hiContrast: "#f0fdf4";
+        readonly loContrast: "#bbf7d0";
+    };
+    readonly amber: {
+        readonly fill: "#d97706";
+        readonly stroke: "#b45309";
+        readonly hiContrast: "#fffbeb";
+        readonly loContrast: "#fde68a";
+    };
+    readonly indigo: {
+        readonly fill: "#6366f1";
+        readonly stroke: "#4f46e5";
+        readonly hiContrast: "#eef2ff";
+        readonly loContrast: "#c7d2fe";
+    };
+};
+//# sourceMappingURL=colors.d.ts.map

package/dist/colors.js

@@ -0,0 +1,94 @@
+const blue = {
+    // fill: colors.blue[500],
+    // stroke: colors.blue[600],
+    // hiContrast: colors.blue[50],
+    // loContrast: colors.blue[100],
+    fill: '#3b82f6',
+    stroke: '#2563eb',
+    hiContrast: '#eff6ff',
+    loContrast: '#dbeafe'
+};
+const sky = {
+    // fill: colors.sky[600],
+    // stroke: colors.sky[700],
+    // hiContrast: colors.sky[50],
+    // loContrast: colors.sky[100],
+    fill: '#0284c7',
+    stroke: '#0369a1',
+    hiContrast: '#f0f9ff',
+    loContrast: '#e0f2fe'
+};
+const slate = {
+    // fill: colors.slate[500],
+    // stroke: colors.slate[600],
+    // hiContrast: colors.slate[50],
+    // loContrast: colors.slate[200],
+    fill: '#64748b',
+    stroke: '#475569',
+    hiContrast: '#f8fafc',
+    loContrast: '#e2e8f0'
+};
+export const RelationColors = {
+    // lineColor: colors.neutral[400],
+    // labelColor: colors.neutral[300],
+    lineColor: '#a3a3a3',
+    labelColor: '#d4d4d4',
+};
+export const Colors = {
+    primary: blue,
+    blue,
+    secondary: sky,
+    sky,
+    muted: slate,
+    slate,
+    gray: {
+        // fill: colors.neutral[500],
+        // stroke: colors.neutral[600],
+        // hiContrast: colors.neutral[50],
+        // loContrast: colors.neutral[200],
+        fill: '#737373',
+        stroke: '#525252',
+        hiContrast: '#fafafa',
+        loContrast: '#e5e5e5'
+    },
+    red: {
+        // fill: colors.red[500],
+        // stroke: colors.red[600],
+        // hiContrast: colors.red[50],
+        // loContrast: colors.red[200],
+        fill: '#ef4444',
+        stroke: '#dc2626',
+        hiContrast: '#fef2f2',
+        loContrast: '#fecaca'
+    },
+    green: {
+        // fill: colors.green[600],
+        // stroke: colors.green[700],
+        // hiContrast: colors.green[50],
+        // loContrast: colors.green[200],
+        fill: '#16a34a',
+        stroke: '#15803d',
+        hiContrast: '#f0fdf4',
+        loContrast: '#bbf7d0'
+    },
+    amber: {
+        // fill: colors.amber[600],
+        // stroke: colors.amber[700],
+        // hiContrast: colors.amber[50],
+        // loContrast: colors.amber[200],
+        fill: '#d97706',
+        stroke: '#b45309',
+        hiContrast: '#fffbeb',
+        loContrast: '#fde68a'
+    },
+    indigo: {
+        // fill: colors.indigo[500],
+        // stroke: colors.indigo[600],
+        // hiContrast: colors.indigo[50],
+        // loContrast: colors.indigo[200],
+        fill: '#6366f1',
+        stroke: '#4f46e5',
+        hiContrast: '#eef2ff',
+        loContrast: '#c7d2fe'
+    }
+};

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

@@ -5,3 +5,4 @@ export declare class EdgeBuilder {
     add(source: Fqn, target: Fqn, relation: Relation): this;
     build(): ComputedEdge[];
 }
+//# sourceMappingURL=EdgeBuilder.d.ts.map

package/dist/compute-view/EdgeBuilder.js

@@ -1,5 +1,5 @@
 import { equals, head, keys, pluck, reject } from 'rambdax';
-import { commonAncestor, compareFqnHierarchically } from '../utils/fqn';
+import { commonAncestor } from '../utils/fqn';
 import { compareRelations } from '../utils/relations';
 export class EdgeBuilder {
     _relationsObj = {};

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

@@ -0,0 +1,18 @@
+import type { ModelIndex } from '../model-index';
+import type { Fqn, Element, Relation } from '../types';
+export type ComputeCtxPatch = {
+    elements?: Element[];
+    relations?: Relation[];
+    implicits?: Element[];
+};
+export declare class ComputeCtx {
+    index: ModelIndex;
+    root: Fqn | null;
+    elements: Set<Element>;
+    relations: Set<Relation>;
+    implicits: Set<Element>;
+    constructor(index: ModelIndex, root: Fqn | null, elements?: Set<Element>, relations?: Set<Relation>, implicits?: Set<Element>);
+    include({ elements, relations, implicits }: ComputeCtxPatch): ComputeCtx;
+    exclude({ elements, relations, implicits }: ComputeCtxPatch): ComputeCtx;
+}
+//# sourceMappingURL=compute-ctx.d.ts.map

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

@@ -0,0 +1,25 @@
+import { difference } from 'rambdax';
+export class ComputeCtx {
+    index;
+    root;
+    elements;
+    relations;
+    implicits;
+    constructor(index, root, elements = new Set(), relations = new Set(), implicits = new Set()) {
+        this.index = index;
+        this.root = root;
+        this.elements = elements;
+        this.relations = relations;
+        this.implicits = implicits;
+    }
+    include({ elements, relations, implicits }) {
+        return new ComputeCtx(this.index, this.root, elements ? new Set([...this.elements, ...elements]) : this.elements, relations ? new Set([...this.relations, ...relations]) : this.relations, implicits ? 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);
+    }
+}

package/dist/compute-view/{compute.element-view.d.ts → compute-element-view.d.ts}

@@ -1,4 +1,4 @@
 import type { ModelIndex } from '../model-index';
-import { type ElementView } from '../types';
-import type { ComputedView } from '../types/computed-view';
+import { type ElementView, type ComputedView } from '../types';
 export declare function computeElementView(view: ElementView, index: ModelIndex): ComputedView;
+//# sourceMappingURL=compute-element-view.d.ts.map

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

@@ -0,0 +1,416 @@
+import { anyPass, filter, head, uniq } from 'rambdax';
+import { DefaultThemeColor, DefaultElementShape } from '../types';
+import * as Expression from '../types/expression';
+import { isViewRuleAutoLayout, isViewRuleExpression, isViewRuleStyle } from '../types/view';
+import { compareByFqnHierarchically, failExpectedNever, ignoreNeverInRuntime, isAncestor, isSameHierarchy, parentFqn, Relations } from '../utils';
+import { hasRelation, isAnyInOut, isBetween, isIncoming, isInside, isOutgoing } from '../utils/relations';
+import { EdgeBuilder } from './EdgeBuilder';
+import { sortNodes } from './utils/sortNodes';
+import { ComputeCtx } from './compute-ctx';
+import { anyPossibleRelations } from './utils/anyPossibleRelations';
+import invariant from 'tiny-invariant';
+function transformToNodes(elementsIterator, index, currentViewid) {
+    return Array.from(elementsIterator)
+        .sort(compareByFqnHierarchically)
+        .reduce((map, { id, title, color, shape, description }) => {
+        let parent = parentFqn(id);
+        while (parent) {
+            if (map.has(parent)) {
+                break;
+            }
+            parent = parentFqn(parent);
+        }
+        const navigateTo = head(index.defaultViewOf(id).filter(v => v !== currentViewid));
+        if (parent) {
+            const parentNd = map.get(parent);
+            invariant(parentNd, `parent node ${parent} not found`);
+            parentNd.children.push(id);
+        }
+        const node = {
+            id,
+            parent,
+            title,
+            color: color ?? DefaultThemeColor,
+            shape: shape ?? DefaultElementShape,
+            children: [],
+            ...(description ? { description } : {}),
+            ...(navigateTo ? { navigateTo } : {})
+        };
+        map.set(id, node);
+        return map;
+    }, new Map());
+}
+function applyViewRuleStyles(rules, nodes) {
+    for (const rule of rules) {
+        const predicates = [];
+        if (!rule.style.color && !rule.style.shape) {
+            // skip empty
+            continue;
+        }
+        for (const target of rule.targets) {
+            if (Expression.isWildcard(target)) {
+                predicates.push(() => true);
+                break;
+            }
+            if (Expression.isElementRef(target)) {
+                const { element, isDescedants } = target;
+                predicates.push(isDescedants ? n => n.id.startsWith(element + '.') : n => n.id === element);
+                continue;
+            }
+            failExpectedNever(target);
+        }
+        filter(anyPass(predicates), nodes).forEach(n => {
+            n.shape = rule.style.shape ?? n.shape;
+            n.color = rule.style.color ?? n.color;
+        });
+    }
+    return nodes;
+}
+const includeElementRef = (ctx, expr) => {
+    const elements = expr.isDescedants
+        ? ctx.index.children(expr.element)
+        : [ctx.index.find(expr.element)];
+    const filters = [];
+    if (expr.isDescedants) {
+        filters.push(Relations.isInside(expr.element));
+    }
+    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(Relations.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 });
+};
+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 includeWildcardRef = (ctx, _expr) => {
+    const { root } = ctx;
+    if (root) {
+        const elements = [ctx.index.find(root), ...ctx.index.children(root)];
+        // All neighbors that may have relations with root or its children
+        const allImplicits = [
+            ...ctx.index.siblings(root),
+            ...ctx.index.ancestors(root).flatMap(a => [...ctx.index.siblings(a.id)])
+        ];
+        const allInOut = ctx.index.filterRelations(isAnyInOut(root));
+        // Neighbors that have relations with root or its children
+        const implicits = [];
+        const relations = [];
+        for (const implicit of allImplicits) {
+            const relationsWithImplicit = allInOut.filter(isAnyInOut(implicit.id));
+            if (relationsWithImplicit.length) {
+                implicits.push(implicit);
+                relations.push(...relationsWithImplicit);
+            }
+        }
+        return ctx.include({
+            elements,
+            relations: [
+                ...ctx.index.filterRelations(isInside(root)),
+                ...relations,
+            ],
+            implicits: implicits
+        });
+    }
+    else {
+        const elements = ctx.index.rootElements();
+        if (elements.length <= 1) {
+            return new ComputeCtx(ctx.index, ctx.root, new Set(elements));
+        }
+        const predicates = [];
+        for (const [source, target] of anyPossibleRelations(elements)) {
+            predicates.push(Relations.isAnyBetween(source.id, target.id));
+        }
+        const relations = predicates.length ? ctx.index.filterRelations(anyPass(predicates)) : [];
+        return new ComputeCtx(ctx.index, ctx.root, new Set(elements), new Set(relations));
+    }
+};
+const excludeWildcardRef = (ctx, _expr) => {
+    const { root } = ctx;
+    if (root) {
+        const relations = [...ctx.relations].filter(anyPass([isInside(root), isIncoming(root), isOutgoing(root)]));
+        return ctx.exclude({
+            elements: [...ctx.elements].filter(e => isAncestor(root, e.id)),
+            relations,
+            implicits: [...ctx.implicits].filter(anyPass(relations.map(r => hasRelation(r))))
+        });
+    }
+    else {
+        return new ComputeCtx(ctx.index, ctx.root);
+    }
+};
+const resolveElements = (ctx, expr) => {
+    if (Expression.isWildcard(expr)) {
+        if (ctx.root) {
+            return [ctx.index.find(ctx.root)];
+        }
+        else {
+            return ctx.index.rootElements();
+        }
+    }
+    else {
+        if (expr.isDescedants) {
+            return ctx.index.children(expr.element);
+        }
+        else {
+            return [ctx.index.find(expr.element)];
+        }
+    }
+};
+const includeIncomingExpr = (ctx, expr) => {
+    if (Expression.isWildcard(expr.incoming) && !ctx.root) {
+        return ctx;
+    }
+    const elements = resolveElements(ctx, expr.incoming);
+    if (elements.length === 0) {
+        return ctx;
+    }
+    const implicits = [];
+    const relations = [];
+    for (const el of elements) {
+        const elRelations = ctx.index.filterRelations(isIncoming(el.id));
+        if (elRelations.length > 0) {
+            relations.push(...elRelations);
+            implicits.push(el);
+        }
+    }
+    return ctx.include({
+        relations,
+        implicits
+    });
+};
+const excludeIncomingExpr = (ctx, expr) => {
+    if (Expression.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;
+};
+const includeOutgoingExpr = (ctx, expr) => {
+    if (Expression.isWildcard(expr.outgoing) && !ctx.root) {
+        return ctx;
+    }
+    const elements = resolveElements(ctx, expr.outgoing);
+    if (elements.length === 0) {
+        return ctx;
+    }
+    const implicits = [];
+    const relations = [];
+    for (const el of elements) {
+        const elRelations = ctx.index.filterRelations(isOutgoing(el.id));
+        if (elRelations.length > 0) {
+            relations.push(...elRelations);
+            implicits.push(el);
+        }
+    }
+    return ctx.include({
+        relations,
+        implicits
+    });
+};
+const excludeOutgoingExpr = (ctx, expr) => {
+    if (Expression.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;
+};
+const includeInOutExpr = (ctx, expr) => {
+    if (Expression.isWildcard(expr.inout) && !ctx.root) {
+        return ctx;
+    }
+    const targets = resolveElements(ctx, expr.inout);
+    if (targets.length === 0) {
+        return ctx;
+    }
+    const implicits = [];
+    const relations = [];
+    for (const target of targets) {
+        const foundRelations = ctx.index.filterRelations(isAnyInOut(target.id));
+        if (foundRelations.length > 0) {
+            relations.push(...foundRelations);
+            implicits.push(target);
+        }
+    }
+    return ctx.include({
+        relations,
+        implicits
+    });
+};
+const excludeInOutExpr = (ctx, expr) => {
+    if (Expression.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;
+};
+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
+    });
+};
+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
+    });
+};
+export function computeElementView(view, index) {
+    const rootElement = 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)]
+        });
+    }
+    for (const { isInclude, exprs } of rulesInclude) {
+        for (const expr of exprs) {
+            if (Expression.isElementRef(expr)) {
+                ctx = isInclude ? includeElementRef(ctx, expr) : excludeElementRef(ctx, expr);
+                continue;
+            }
+            if (Expression.isWildcard(expr)) {
+                ctx = isInclude ? includeWildcardRef(ctx, expr) : excludeWildcardRef(ctx, expr);
+                continue;
+            }
+            if (Expression.isIncoming(expr)) {
+                ctx = isInclude ? includeIncomingExpr(ctx, expr) : excludeIncomingExpr(ctx, expr);
+                continue;
+            }
+            if (Expression.isOutgoing(expr)) {
+                ctx = isInclude ? includeOutgoingExpr(ctx, expr) : excludeOutgoingExpr(ctx, expr);
+                continue;
+            }
+            if (Expression.isInOut(expr)) {
+                ctx = isInclude ? includeInOutExpr(ctx, expr) : excludeInOutExpr(ctx, expr);
+                continue;
+            }
+            if (Expression.isRelation(expr)) {
+                ctx = isInclude ? includeRelationExpr(ctx, expr) : excludeRelationExpr(ctx, expr);
+                continue;
+            }
+            ignoreNeverInRuntime(expr);
+        }
+    }
+    const elements = new Set([...ctx.elements]);
+    const edgeBuilder = new EdgeBuilder();
+    const resolvedRelations = [...ctx.relations];
+    for (const [source, target] of anyPossibleRelations([...elements, ...ctx.implicits])) {
+        if (!elements.has(source) && !elements.has(target)) {
+            continue;
+        }
+        const findPredicate = Relations.isBetween(source.id, target.id);
+        let idx = resolvedRelations.findIndex(findPredicate);
+        while (idx >= 0) {
+            const [rel] = resolvedRelations.splice(idx, 1);
+            if (rel) {
+                elements.add(source);
+                elements.add(target);
+                edgeBuilder.add(source.id, target.id, rel);
+            }
+            idx = resolvedRelations.findIndex(findPredicate);
+        }
+    }
+    const nodesreg = transformToNodes(elements, index, view.id);
+    const edges = edgeBuilder.build().map(edge => {
+        while (edge.parent) {
+            if (nodesreg.has(edge.parent)) {
+                break;
+            }
+            edge.parent = parentFqn(edge.parent);
+        }
+        return edge;
+    });
+    const nodes = applyViewRuleStyles(view.rules.filter(isViewRuleStyle), sortNodes(nodesreg, edges));
+    const autoLayoutRule = view.rules.find(isViewRuleAutoLayout);
+    return {
+        ...view,
+        autoLayout: autoLayoutRule?.autoLayout ?? 'TB',
+        nodes,
+        edges
+    };
+}

package/dist/compute-view/{compute-view.d.ts → compute.d.ts}

@@ -1,6 +1,5 @@
 import { ModelIndex } from '../model-index';
-import type { Element, ElementView, Fqn, LikeC4Model, Relation, RelationID, ViewID } from '../types';
-import type { ComputedView } from '../types/computed-view';
+import type { Element, ElementView, Fqn, LikeC4Model, Relation, ComputedView, RelationID, ViewID } from '../types';
 export declare function computeView(view: ElementView, index: ModelIndex): ComputedView;
 type InputModel = {
     elements: Record<Fqn, Element>;
@@ -9,3 +8,4 @@ type InputModel = {
 };
 export declare function computeViews(model: InputModel): LikeC4Model;
 export {};
+//# sourceMappingURL=compute.d.ts.map

package/dist/compute-view/{compute-view.js → compute.js}

@@ -1,6 +1,6 @@
 import { map } from 'rambdax';
 import { ModelIndex } from '../model-index';
-import { computeElementView } from './compute.element-view';
+import { computeElementView } from './compute-element-view';
 export function computeView(view, index) {
     return computeElementView(view, index);
 }

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

@@ -1,2 +1,3 @@
-export { computeView, computeViews } from './compute-view';
+export { computeView, computeViews } from './compute';
 export type * from '../types/computed-view';
+//# sourceMappingURL=index.d.ts.map

package/dist/compute-view/index.js

@@ -1 +1 @@
-export { computeView, computeViews } from './compute-view';
+export { computeView, computeViews } from './compute';

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

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