@likec4/core 1.17.0 → 1.18.0

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

@@ -0,0 +1,91 @@
+import { SetOptional } from 'type-fest';
+import { P as ParsedLikeC4Model, C as ComputedLikeC4ModelFromParsed, L as LikeC4View, a as ComputedView, M as ModelGlobals, E as Element, F as Fqn, R as Relation, b as RelationId, c as ComputedLikeC4Model } from '../shared/core.DMYY7C8s.mjs';
+
+type ComputeViewResult<V extends ComputedView = ComputedView> = {
+    isSuccess: true;
+    error?: undefined;
+    view: V;
+} | {
+    isSuccess: false;
+    error: Error;
+    view: undefined;
+};
+type ComputeViewFn = <V extends LikeC4View>(viewsource: V) => ComputeViewResult<ComputedView>;
+type Params$1 = SetOptional<ParsedLikeC4Model, 'views'>;
+declare function mkComputeView(model: Params$1): ComputeViewFn;
+declare function computeViews<const P extends ParsedLikeC4Model<any, any, any, any, any, any>>(parsed: P): ComputedLikeC4ModelFromParsed<P>;
+
+type Params = {
+    elements: Record<Fqn, Element>;
+    relations: Record<RelationId, Relation>;
+    globals?: ModelGlobals;
+};
+type RelationEdge = {
+    source: Element;
+    target: Element;
+    relations: Relation[];
+};
+type FqnOrElement = Fqn | Element;
+type FqnsOrElements = ReadonlyArray<Fqn> | ReadonlyArray<Element>;
+/**
+ * Used only for views calculations.
+ * Subject to change.
+ */
+declare class LikeC4ModelGraph {
+    #private;
+    readonly globals: ModelGlobals;
+    constructor({ elements, relations, globals }: Params);
+    get rootElements(): Element[];
+    get elements(): Element[];
+    element(id: Fqn): Element;
+    connectedRelations(id: Fqn): Relation[];
+    children(id: Fqn): Element[];
+    descendants(id: Fqn): Element[];
+    private descendantsDfs;
+    siblings(element: Fqn | Element): Element[];
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(element: Fqn | Element): Array<Element>;
+    /**
+     * Resolve siblings of the element and its ancestors
+     *  (from closest to root)
+     */
+    ascendingSiblings(element: Fqn | Element): ReadonlyArray<Element>;
+    incoming(element: Fqn | Element): ReadonlySet<Relation>;
+    outgoing(element: Fqn | Element): ReadonlySet<Relation>;
+    /**
+     * Resolve all RelationEdges between element and others (any direction)
+     */
+    anyEdgesBetween(_element: Fqn | Element, others: ReadonlyArray<Fqn> | ReadonlyArray<Element>): Array<RelationEdge>;
+    /**
+     * Resolve all RelationEdges between elements (any direction)
+     */
+    edgesWithin<T extends Fqn[] | Element[]>(elements: T): Array<RelationEdge>;
+    /**
+     * Get directed RelationEdge between source and target if exists
+     */
+    edgesBetween(_sources: FqnOrElement | FqnsOrElements, _targets: FqnOrElement | FqnsOrElements): RelationEdge[];
+    private addElement;
+    private addRelation;
+    private _childrenOf;
+    private _incomingTo;
+    private _outgoingFrom;
+    private _internalOf;
+}
+
+/**
+ * Resolve rules of extended views
+ * (Removes invalid views)
+ */
+declare function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(unresolvedViews: V): V;
+
+/**
+ * Convert hashed edge ids to human-readable
+ * Mostly for testing purposes
+ */
+declare function withReadableEdges<T extends ComputedView>({ edges, nodes, ...view }: T): T;
+declare function viewsWithReadableEdges<M extends ComputedLikeC4Model>({ views, ...model }: M): M;
+
+export { LikeC4ModelGraph, computeViews, mkComputeView, resolveRulesExtendedViews, viewsWithReadableEdges, withReadableEdges };

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

@@ -0,0 +1,91 @@
+import { SetOptional } from 'type-fest';
+import { P as ParsedLikeC4Model, C as ComputedLikeC4ModelFromParsed, L as LikeC4View, a as ComputedView, M as ModelGlobals, E as Element, F as Fqn, R as Relation, b as RelationId, c as ComputedLikeC4Model } from '../shared/core.DMYY7C8s.js';
+
+type ComputeViewResult<V extends ComputedView = ComputedView> = {
+    isSuccess: true;
+    error?: undefined;
+    view: V;
+} | {
+    isSuccess: false;
+    error: Error;
+    view: undefined;
+};
+type ComputeViewFn = <V extends LikeC4View>(viewsource: V) => ComputeViewResult<ComputedView>;
+type Params$1 = SetOptional<ParsedLikeC4Model, 'views'>;
+declare function mkComputeView(model: Params$1): ComputeViewFn;
+declare function computeViews<const P extends ParsedLikeC4Model<any, any, any, any, any, any>>(parsed: P): ComputedLikeC4ModelFromParsed<P>;
+
+type Params = {
+    elements: Record<Fqn, Element>;
+    relations: Record<RelationId, Relation>;
+    globals?: ModelGlobals;
+};
+type RelationEdge = {
+    source: Element;
+    target: Element;
+    relations: Relation[];
+};
+type FqnOrElement = Fqn | Element;
+type FqnsOrElements = ReadonlyArray<Fqn> | ReadonlyArray<Element>;
+/**
+ * Used only for views calculations.
+ * Subject to change.
+ */
+declare class LikeC4ModelGraph {
+    #private;
+    readonly globals: ModelGlobals;
+    constructor({ elements, relations, globals }: Params);
+    get rootElements(): Element[];
+    get elements(): Element[];
+    element(id: Fqn): Element;
+    connectedRelations(id: Fqn): Relation[];
+    children(id: Fqn): Element[];
+    descendants(id: Fqn): Element[];
+    private descendantsDfs;
+    siblings(element: Fqn | Element): Element[];
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(element: Fqn | Element): Array<Element>;
+    /**
+     * Resolve siblings of the element and its ancestors
+     *  (from closest to root)
+     */
+    ascendingSiblings(element: Fqn | Element): ReadonlyArray<Element>;
+    incoming(element: Fqn | Element): ReadonlySet<Relation>;
+    outgoing(element: Fqn | Element): ReadonlySet<Relation>;
+    /**
+     * Resolve all RelationEdges between element and others (any direction)
+     */
+    anyEdgesBetween(_element: Fqn | Element, others: ReadonlyArray<Fqn> | ReadonlyArray<Element>): Array<RelationEdge>;
+    /**
+     * Resolve all RelationEdges between elements (any direction)
+     */
+    edgesWithin<T extends Fqn[] | Element[]>(elements: T): Array<RelationEdge>;
+    /**
+     * Get directed RelationEdge between source and target if exists
+     */
+    edgesBetween(_sources: FqnOrElement | FqnsOrElements, _targets: FqnOrElement | FqnsOrElements): RelationEdge[];
+    private addElement;
+    private addRelation;
+    private _childrenOf;
+    private _incomingTo;
+    private _outgoingFrom;
+    private _internalOf;
+}
+
+/**
+ * Resolve rules of extended views
+ * (Removes invalid views)
+ */
+declare function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(unresolvedViews: V): V;
+
+/**
+ * Convert hashed edge ids to human-readable
+ * Mostly for testing purposes
+ */
+declare function withReadableEdges<T extends ComputedView>({ edges, nodes, ...view }: T): T;
+declare function viewsWithReadableEdges<M extends ComputedLikeC4Model>({ views, ...model }: M): M;
+
+export { LikeC4ModelGraph, computeViews, mkComputeView, resolveRulesExtendedViews, viewsWithReadableEdges, withReadableEdges };

package/dist/compute-view/index.mjs

@@ -0,0 +1,79 @@
+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 };