@likec4/core 1.18.0 → 1.19.0

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

@@ -1,79 +1,7 @@
-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;
-}
+export { C as ComputeViewResult, c as computeView, a as computeViews, u as unsafeComputeView } from '../shared/core.BZ9Msq7w.mjs';
+import { L as LikeC4View, C as ComputedView, a as ComputedLikeC4Model } from '../shared/core.CmYMqgha.mjs';
+import 'type-fest';
+import '../shared/core.D74xkKkG.mjs';
 
 /**
  * Resolve rules of extended views
@@ -85,7 +13,10 @@ declare function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(un
  * Convert hashed edge ids to human-readable
  * Mostly for testing purposes
  */
-declare function withReadableEdges<T extends ComputedView>({ edges, nodes, ...view }: T): T;
+declare function withReadableEdges<T extends ComputedView>({ edges, nodes, ...view }: T, separator?: string): T & {
+    nodeIds: string[];
+    edgeIds: string[];
+};
 declare function viewsWithReadableEdges<M extends ComputedLikeC4Model>({ views, ...model }: M): M;
 
-export { LikeC4ModelGraph, computeViews, mkComputeView, resolveRulesExtendedViews, viewsWithReadableEdges, withReadableEdges };
+export { resolveRulesExtendedViews, viewsWithReadableEdges, withReadableEdges };

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

@@ -1,79 +1,7 @@
-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;
-}
+export { C as ComputeViewResult, c as computeView, a as computeViews, u as unsafeComputeView } from '../shared/core.BIfgabEw.js';
+import { L as LikeC4View, C as ComputedView, a as ComputedLikeC4Model } from '../shared/core.C05RDLhi.js';
+import 'type-fest';
+import '../shared/core.D74xkKkG.js';
 
 /**
  * Resolve rules of extended views
@@ -85,7 +13,10 @@ declare function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(un
  * Convert hashed edge ids to human-readable
  * Mostly for testing purposes
  */
-declare function withReadableEdges<T extends ComputedView>({ edges, nodes, ...view }: T): T;
+declare function withReadableEdges<T extends ComputedView>({ edges, nodes, ...view }: T, separator?: string): T & {
+    nodeIds: string[];
+    edgeIds: string[];
+};
 declare function viewsWithReadableEdges<M extends ComputedLikeC4Model>({ views, ...model }: M): M;
 
-export { LikeC4ModelGraph, computeViews, mkComputeView, resolveRulesExtendedViews, viewsWithReadableEdges, withReadableEdges };
+export { resolveRulesExtendedViews, viewsWithReadableEdges, withReadableEdges };

package/dist/compute-view/index.js

@@ -0,0 +1,78 @@
+import { G as Graph, r, w as willCreateCycle, t as topologicalSortExports, l, i as i$1 } from '../shared/index.-BdzdI2C.js';
+export { c as computeView, a as computeViews, u as unsafeComputeView } from '../shared/index.-BdzdI2C.js';
+import { i as isExtendsElementView, a as isElementView } from '../shared/view.CyZrG8BJ.js';
+import { i, m } from '../shared/object_hash.CE_oF3I3.js';
+import { u } from '../shared/chunk-RAAYCPUM.M-JWF7SS.js';
+
+function y(...t){return u(f,t)}function f(t,e){if(!i(e,1))return {...t};if(!i(e,2)){let{[e[0]]:r,...m}=t;return m}let o={...t};for(let r of e)delete o[r];return o}
+
+function resolveRulesExtendedViews(unresolvedViews) {
+  const g = new Graph({
+    type: "directed"
+  });
+  const extendedViews = [];
+  for (const view of r(unresolvedViews)) {
+    g.addNode(view.id, { view });
+    if (isExtendsElementView(view)) {
+      extendedViews.push(view);
+    }
+  }
+  if (extendedViews.length === 0) {
+    return unresolvedViews;
+  }
+  for (const view of extendedViews) {
+    if (!g.hasNode(view.extends)) {
+      console.warn(`View "${view.id}" extends from "${view.extends}" which does not exist`);
+      continue;
+    }
+    if (willCreateCycle(g, view.id, view.extends)) {
+      console.warn(`View "${view.id}" extends from "${view.extends}" which creates a cycle`);
+      continue;
+    }
+    g.addDirectedEdge(view.id, view.extends);
+  }
+  const sorted = topologicalSortExports.topologicalSort(g).reverse();
+  return sorted.reduce((acc, id) => {
+    const view = g.getNodeAttribute(id, "view");
+    if (!isExtendsElementView(view)) {
+      acc[view.id] = view;
+      return acc;
+    }
+    const extendsFrom = acc[view.extends];
+    if (!extendsFrom || !isElementView(extendsFrom)) {
+      return acc;
+    }
+    acc[view.id] = {
+      ...extendsFrom,
+      ...view,
+      rules: [...extendsFrom.rules, ...view.rules]
+    };
+    return acc;
+  }, {});
+}
+
+function withReadableEdges({ edges, nodes, ...view }, separator = ":") {
+  const edgeids = l(edges, (e) => [e.id, `${e.source}${separator}${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])
+    })),
+    nodeIds: nodes.map((n) => n.id),
+    edgeIds: edges.map((e) => edgeids[e.id])
+  };
+}
+function viewsWithReadableEdges({ views, ...model }) {
+  return {
+    ...model,
+    views: i$1(views, (v) => y(withReadableEdges(v), ["nodeIds", "edgeIds"]))
+  };
+}
+
+export { resolveRulesExtendedViews, viewsWithReadableEdges, withReadableEdges };