@likec4/core 1.47.0 → 1.48.0

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

@@ -1,79 +1,108 @@
-import { A as Any, t as toComputed, d as AnyParsed, m as _stage } from '../shared/core.D00YbOhQ.mjs';
-import { f as LikeC4Model } from '../shared/core.BfCKSW-g.mjs';
-import { P as ParsedLikeC4ModelData, C as ComputedLikeC4ModelData, p as ParsedView, r as ComputedView, J as DiagramNode, K as DiagramEdge } from '../shared/core.osFs8tU7.mjs';
-import { H as BaseViewProperties, O as ComputedNode, P as ComputedEdge, B as ViewAutoLayout } from '../shared/core.Dojz4bvg.mjs';
-import { P as ProjectId } from '../shared/core.C_3y3eqV.mjs';
-import { B as BBox } from '../shared/core.BPGOjone.mjs';
-import { N as NonEmptyArray } from '../shared/core.DB0Ue5Wx.mjs';
-import 'type-fest';
-import '../shared/core.CAgYpDtM.mjs';
-import '../shared/core.DC5IAaDT.mjs';
-import '../types/fqnRef.mjs';
-import '../shared/core.CywrQs86.mjs';
-import '../types/expression-model.mjs';
+import { ct as toComputed, ht as _type, mt as _stage, n as Any, o as AnyParsed, wt as NonEmptyArray } from "../_chunks/_aux.mjs";
+import "../_chunks/scalar.mjs";
+import "../_chunks/expression.mjs";
+import "../_chunks/fqnRef.mjs";
+import { t as ModelExpression } from "../_chunks/expression-model.mjs";
+import { $t as AnyIncludePredicate, J as ComputedEdge, Qt as AnyExcludePredicate, X as ComputedNode, c as ComputedLikeC4ModelData, d as ParsedLikeC4ModelData, h as ParsedView, on as ViewAutoLayout, p as ComputedView, rn as BaseViewProperties } from "../_chunks/index2.mjs";
+import "../_chunks/RichText.mjs";
+import "../_chunks/index3.mjs";
+import { n as LikeC4Model } from "../_chunks/LikeC4Model.mjs";
+import { B as ViewPredicate } from "../_chunks/_types.mjs";
+import "../_chunks/const.mjs";
+import "../_chunks/find.mjs";
+import "../_chunks/find2.mjs";
+import "../_chunks/index4.mjs";
+import "../_chunks/index5.mjs";
+import { a as LayoutedProjectNode, i as LayoutedProjectEdge, n as ComputedProjectNode, o as LayoutedProjectsView, r as ComputedProjectsView, t as ComputedProjectEdge } from "../_chunks/_types2.mjs";
+import { n as computeRelationshipsView, r as RelationshipsViewData, t as treeFromElements } from "../_chunks/index6.mjs";
 
+//#region src/compute-view/compute-view.d.ts
 type ComputeViewResult<V> = {
-    isSuccess: true;
-    error?: undefined;
-    view: V;
+  isSuccess: true;
+  error?: undefined;
+  view: V;
 } | {
-    isSuccess: false;
-    error: Error;
-    view: undefined;
+  isSuccess: false;
+  error: Error;
+  view: undefined;
 };
 declare function unsafeComputeView<A extends Any>(viewsource: ParsedView<A>, likec4model: LikeC4Model<any>): ComputedView<A>;
 declare function computeView<A extends Any>(viewsource: ParsedView<A>, likec4model: LikeC4Model<A>): ComputeViewResult<ComputedView<A>>;
 declare function computeParsedModelData<A extends AnyParsed, B extends toComputed<A> = toComputed<A>>(parsed: ParsedLikeC4ModelData<A>): ComputedLikeC4ModelData<B>;
 declare function computeLikeC4Model<A extends Any, B extends toComputed<A> = toComputed<A>>(parsed: ParsedLikeC4ModelData<A>): LikeC4Model<B>;
-
+//#endregion
+//#region src/compute-view/utils/resolve-extended-views.d.ts
 /**
  * Resolve rules of extended views
  * (Removes invalid views)
  */
 declare function resolveRulesExtendedViews<A extends Any, V extends Record<any, ParsedView<A>>>(unresolvedViews: V): V;
-
+//#endregion
+//#region src/compute-view/utils/with-readable-edges.d.ts
 /**
  * Convert hashed edge ids to human-readable
  * Mostly for testing purposes
  */
-declare function withReadableEdges<V extends ComputedView<any>>({ edges, nodes, ...view }: V, separator?: string): V & {
-    nodeIds: string[];
-    edgeIds: string[];
+declare function withReadableEdges<V extends ComputedView<any>>({
+  edges,
+  nodes,
+  ...view
+}: V, separator?: string): V & {
+  nodeIds: string[];
+  edgeIds: string[];
 };
-declare function viewsWithReadableEdges<A extends Any>({ views, ...model }: ComputedLikeC4ModelData<A>): ComputedLikeC4ModelData<A>;
-
-interface ComputedProjectNode extends ComputedNode {
-    readonly projectId: ProjectId;
-}
-interface ComputedProjectEdge extends ComputedEdge {
-    readonly projectId: ProjectId;
-}
-interface LayoutedProjectNode extends DiagramNode {
-    readonly projectId: ProjectId;
-}
-interface LayoutedProjectEdge extends DiagramEdge {
-    readonly projectId: ProjectId;
-}
+declare function viewsWithReadableEdges<A extends Any>({
+  views,
+  ...model
+}: ComputedLikeC4ModelData<A>): ComputedLikeC4ModelData<A>;
+//#endregion
+//#region src/compute-view/projects-view/compute.d.ts
 /**
- * An overview of projects and their relationships, presented as a graph with nodes and edges.
- * Even though it has same structure as other likec4 views, it is not mixed with them, as it represents a different kind.
+ * Computes an overview of projects and their relationships
  */
-interface ComputedProjectsView extends BaseViewProperties<any> {
-    readonly [_stage]: 'computed';
-    readonly nodes: ReadonlyArray<ComputedProjectNode>;
-    readonly edges: ReadonlyArray<ComputedProjectEdge>;
-    readonly autoLayout: ViewAutoLayout;
-}
-interface LayoutedProjectsView extends BaseViewProperties<any> {
-    readonly [_stage]: 'layouted';
-    readonly nodes: ReadonlyArray<LayoutedProjectNode>;
-    readonly edges: ReadonlyArray<LayoutedProjectEdge>;
-    readonly bounds: BBox;
+declare function computeProjectsView(likec4models: NonEmptyArray<LikeC4Model>): ComputedProjectsView;
+//#endregion
+//#region src/compute-view/adhoc-view/compute.d.ts
+interface AdhocViewIncludePredicate<A extends Any> extends AnyIncludePredicate<ModelExpression<A>> {}
+interface AdhocViewExcludePredicate<A extends Any> extends AnyExcludePredicate<ModelExpression<A>> {}
+type AdhocViewPredicate<A extends Any = Any> = AdhocViewIncludePredicate<A> | AdhocViewExcludePredicate<A>;
+interface ComputedAdhocView extends BaseViewProperties<Any> {
+  readonly [_type]: 'adhoc';
+  readonly [_stage]: 'computed';
+  readonly nodes: ReadonlyArray<ComputedNode>;
+  readonly edges: ReadonlyArray<ComputedEdge>;
+  readonly autoLayout: ViewAutoLayout;
 }
-
 /**
- * Computes an overview of projects and their relationships
+ * Computes an adhoc view based on the given predicates.
+ * Adhoc views are not defined in the model, but computed on demand.
+ * Available for logical model only.
+ *
+ * @param predicates accepts the same predicates as element view.
+ * @param likec4model The LikeC4 model to compute view.
+ * @returns The computed adhoc view.
  */
-declare function computeProjectsView(likec4models: NonEmptyArray<LikeC4Model>): ComputedProjectsView;
-
-export { type ComputeViewResult, type ComputedProjectEdge, type ComputedProjectNode, type ComputedProjectsView, type LayoutedProjectEdge, type LayoutedProjectNode, type LayoutedProjectsView, computeLikeC4Model, computeParsedModelData, computeProjectsView, computeView, resolveRulesExtendedViews, unsafeComputeView, viewsWithReadableEdges, withReadableEdges };
+declare function computeAdhocView<A extends Any>(likec4model: LikeC4Model<A>, predicates: AdhocViewPredicate<NoInfer<A>>[]): ComputedAdhocView;
+//#endregion
+//#region src/compute-view/adhoc-view/builder.d.ts
+/**
+ * Allows you to define type-safe adhoc views using types from the model.
+ */
+declare class AdhocView<A extends Any> {
+  #private;
+  private readonly model;
+  /**
+   * Creates a new adhoc view builder.
+   */
+  static use<A extends Any>(model: LikeC4Model<A>): AdhocView<A>;
+  private constructor();
+  /**
+   * Used to cache the type of the predicates.
+   */
+  readonly Expr: ViewPredicate.AllExpression<ViewPredicate.ElementExpr<A['ElementId']>>;
+  include(...predicates: this['Expr'][]): this;
+  exclude(...predicates: this['Expr'][]): this;
+  compute(): ComputedAdhocView;
+}
+//#endregion
+export { AdhocView, type AdhocViewExcludePredicate, type AdhocViewIncludePredicate, type AdhocViewPredicate, type ComputeViewResult, type ComputedAdhocView, ComputedProjectEdge, ComputedProjectNode, ComputedProjectsView, LayoutedProjectEdge, LayoutedProjectNode, LayoutedProjectsView, type RelationshipsViewData, computeAdhocView, computeLikeC4Model, computeParsedModelData, computeProjectsView, computeRelationshipsView, computeView, resolveRulesExtendedViews, treeFromElements, unsafeComputeView, viewsWithReadableEdges, withReadableEdges };

package/dist/compute-view/index.mjs

@@ -1,229 +1,262 @@
-import { w as willCreateCycle, t as topologicalSortExports, a as t$4, n as n$1, b as t$9, l as linkNodesWithEdges, c as topologicalSort } from '../shared/core.Dh119QSP.mjs';
-export { d as computeLikeC4Model, e as computeParsedModelData, f as computeView, u as unsafeComputeView } from '../shared/core.Dh119QSP.mjs';
-import { n } from '../shared/core.BhNcrwzK.mjs';
-import { t as t$2 } from '../shared/core.DU5SRqNF.mjs';
-import { r as isExtendsElementView, p as isElementView, _ as _stage } from '../shared/core.DH7TXqXf.mjs';
-import { G as Graph } from '../shared/core.CmGY9blO.mjs';
-import { c as isNonEmptyArray } from '../shared/core.CdNCAwq7.mjs';
-import { t as t$5 } from '../shared/core.CbT8JVYL.mjs';
-import { t as t$3, b as t$8 } from '../shared/core.DjcWextK.mjs';
-import { t as t$1, a as t$7 } from '../shared/core.BsSXS-_R.mjs';
-import { t as t$6, e as e$1 } from '../shared/core.Coi_LOUZ.mjs';
-import { e } from '../shared/core.BP_QHEXs.mjs';
-import { D as DefaultMap } from '../shared/core.BbE4y-yl.mjs';
-import { a as nonNullable, i as invariant } from '../shared/core.D4npX2q8.mjs';
-import { s as stringHash } from '../shared/core.oSV6SRfk.mjs';
-import { preferSummary } from '../types/_aux.mjs';
-import { a as GlobalFqn, P as ProjectId } from '../shared/core.D0WZutNd.mjs';
-
-function t(...t){return t$1(Object.keys,t)}
+import { r as __toESM } from "../_chunks/rolldown-runtime.mjs";
+import { C as t$1, E as t$4, G as t$7, I as e, S as t$3, Y as t$5, Z as t$6, i as n, m as e$1, r as t, w as t$2, x as n$1, y as t$8 } from "../_chunks/libs/remeda.mjs";
+import { N as _stage, P as _type, _ as isExtendsElementView, g as isElementView } from "../_chunks/LikeC4Styles.mjs";
+import "../_chunks/libs/natural-compare-lite.mjs";
+import { N as isNonEmptyArray, r as stringHash } from "../_chunks/utils.mjs";
+import { n as nonNullable, t as invariant } from "../_chunks/invariant.mjs";
+import "../_chunks/libs/@mantine/colors-generator.mjs";
+import { n as require_topological_sort, t as require_will_create_cycle } from "../_chunks/libs/graphology-dag.mjs";
+import { n as import_default_map } from "../_chunks/libs/mnemonist.mjs";
+import "../_chunks/libs/defu.mjs";
+import "../_chunks/libs/extend.mjs";
+import { n as preferSummary } from "../_chunks/_aux.mjs";
+import { c as ProjectId, d as ViewId, i as GlobalFqn } from "../_chunks/scalar.mjs";
+import { a as unsafeComputeView, c as linkNodesWithEdges, i as computeView, n as computeLikeC4Model, o as computeElementView, r as computeParsedModelData, s as topologicalSort$1, t as $expr } from "../_chunks/Builder.view-element.mjs";
+import { t as Graph } from "../_chunks/libs/graphology.mjs";
+import { n as treeFromElements, t as computeRelationshipsView } from "../_chunks/relationships-view.mjs";
 
+//#region src/compute-view/utils/resolve-extended-views.ts
+var import_topological_sort = require_topological_sort();
+var import_will_create_cycle = /* @__PURE__ */ __toESM(require_will_create_cycle(), 1);
+/**
+* Resolve rules of extended views
+* (Removes invalid views)
+*/
 function resolveRulesExtendedViews(unresolvedViews) {
-  const g = new Graph({
-    type: "directed"
-  });
-  const extendedViews = [];
-  for (const view of t$2(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;
-    }
-    const tags = n([
-      ...extendsFrom.tags ?? [],
-      ...view.tags ?? []
-    ]);
-    const links = [
-      ...extendsFrom.links ?? [],
-      ...view.links ?? []
-    ];
-    acc[view.id] = {
-      ...extendsFrom,
-      ...view,
-      title: view.title ?? extendsFrom.title ?? null,
-      description: view.description ?? extendsFrom.description ?? null,
-      tags,
-      links: isNonEmptyArray(links) ? links : null,
-      rules: [...extendsFrom.rules, ...view.rules]
-    };
-    return acc;
-  }, {});
+	const g = new Graph({ type: "directed" });
+	const extendedViews = [];
+	for (const view of t(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 ((0, import_will_create_cycle.default)(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);
+	}
+	return (0, import_topological_sort.topologicalSort)(g).reverse().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;
+		const tags = n([...extendsFrom.tags ?? [], ...view.tags ?? []]);
+		const links = [...extendsFrom.links ?? [], ...view.links ?? []];
+		acc[view.id] = {
+			...extendsFrom,
+			...view,
+			title: view.title ?? extendsFrom.title ?? null,
+			description: view.description ?? extendsFrom.description ?? null,
+			tags,
+			links: isNonEmptyArray(links) ? links : null,
+			rules: [...extendsFrom.rules, ...view.rules]
+		};
+		return acc;
+	}, {});
 }
 
+//#endregion
+//#region src/compute-view/utils/with-readable-edges.ts
+/**
+* Convert hashed edge ids to human-readable
+* Mostly for testing purposes
+*/
 function withReadableEdges({ edges, nodes, ...view }, separator = ":") {
-  const edgeids = t$4(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: t$5(n.inEdges, (e) => edgeids[e]),
-      outEdges: t$5(n.outEdges, (e) => edgeids[e])
-    })),
-    nodeIds: nodes.map((n) => n.id),
-    edgeIds: edges.map((e) => edgeids[e.id])
-  };
+	const edgeids = t$1(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: t$2(n.inEdges, (e) => edgeids[e]),
+			outEdges: t$2(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: t$3(views, (v) => n$1(withReadableEdges(v), ["nodeIds", "edgeIds"]))
-  };
+	return {
+		...model,
+		views: t$3(views, (v) => n$1(withReadableEdges(v), ["nodeIds", "edgeIds"]))
+	};
 }
 
-const keysCount = (object) => t(object).length;
+//#endregion
+//#region src/compute-view/projects-view/compute.ts
+const keysCount = (object) => t$4(object).length;
 const nodeId = (projectId) => stringHash(projectId);
+/**
+* Computes an overview of projects and their relationships
+*/
 function computeProjectsView(likec4models) {
-  const nodesMap = buildNodesForEachModel(likec4models);
-  const key = (from, to) => `${from}->${to}`;
-  const relationships = new DefaultMap((key2) => {
-    const [from, to] = key2.split("->");
-    return {
-      from,
-      to,
-      relationships: /* @__PURE__ */ new Set()
-    };
-  });
-  const relationshipsFromTo = (from, to) => relationships.get(key(from, to)).relationships;
-  const processImportedElement = (model, importedElement) => {
-    const projectId = importedElement.projectId;
-    invariant(projectId !== model.projectId, "Imported element must have a different project id");
-    const incoming = relationshipsFromTo(model.projectId, projectId);
-    for (const rel of importedElement.incoming("direct")) {
-      if (rel.source.projectId === model.projectId) {
-        incoming.add(rel);
-      }
-    }
-    const outgoing = relationshipsFromTo(projectId, model.projectId);
-    for (const rel of importedElement.outgoing("direct")) {
-      if (rel.target.projectId === model.projectId) {
-        outgoing.add(rel);
-      }
-    }
-  };
-  for (const model of likec4models) {
-    if (e(model.$data.imports)) {
-      continue;
-    }
-    for (const [projectId, imported] of t$6(model.$data.imports)) {
-      for (const importedElement of imported) {
-        const fqn = GlobalFqn(projectId, importedElement.id);
-        processImportedElement(
-          model,
-          nonNullable(
-            model.findElement(fqn),
-            `Element ${importedElement.id} from project ${projectId} not found in model ${model.projectId}`
-          )
-        );
-      }
-    }
-  }
-  const edges = Array.from(relationships.entries()).filter(([_, { relationships: relationships2 }]) => relationships2.size > 0).map(([key2, { from, to, relationships: relationshipsSet }]) => {
-    const relationships2 = [...relationshipsSet];
-    invariant(t$7(relationships2, 1), "Relationships set must have at least one relationship");
-    const edge = {
-      id: stringHash(key2),
-      source: nodeId(from),
-      target: nodeId(to),
-      projectId: from,
-      relations: t$5(relationships2, e$1("id")),
-      label: null,
-      color: "gray",
-      parent: null,
-      line: "solid",
-      tags: n(t$8(relationships2, e$1("tags")))
-    };
-    const onlyOne = t$9(relationships2);
-    if (onlyOne) {
-      edge.label = onlyOne.title;
-      edge.description = preferSummary(onlyOne.$relationship) ?? null;
-      edge.technology = onlyOne.technology;
-      edge.color = onlyOne.color;
-      edge.line = onlyOne.line;
-      if (onlyOne.kind) {
-        edge.kind = onlyOne.kind;
-      }
-      if (onlyOne.$relationship.navigateTo) {
-        edge.navigateTo = onlyOne.$relationship.navigateTo;
-      }
-    }
-    return edge;
-  });
-  linkNodesWithEdges(nodesMap, edges);
-  const sorted = topologicalSort({
-    nodes: nodesMap,
-    edges
-  });
-  return {
-    id: "projects-view",
-    [_stage]: "computed",
-    title: "Projects",
-    description: {
-      txt: "Overview of all projects and their relationships"
-    },
-    autoLayout: {
-      direction: "TB"
-    },
-    ...sorted
-  };
+	const nodesMap = buildNodesForEachModel(likec4models);
+	const key = (from, to) => `${from}->${to}`;
+	const relationships = new import_default_map.default((key) => {
+		const [from, to] = key.split("->");
+		return {
+			from,
+			to,
+			relationships: /* @__PURE__ */ new Set()
+		};
+	});
+	const relationshipsFromTo = (from, to) => relationships.get(key(from, to)).relationships;
+	const processImportedElement = (model, importedElement) => {
+		const projectId = importedElement.projectId;
+		invariant(projectId !== model.projectId, "Imported element must have a different project id");
+		const incoming = relationshipsFromTo(model.projectId, projectId);
+		for (const rel of importedElement.incoming("direct")) if (rel.source.projectId === model.projectId) incoming.add(rel);
+		const outgoing = relationshipsFromTo(projectId, model.projectId);
+		for (const rel of importedElement.outgoing("direct")) if (rel.target.projectId === model.projectId) outgoing.add(rel);
+	};
+	for (const model of likec4models) {
+		if (e(model.$data.imports)) continue;
+		for (const [projectId, imported] of t$5(model.$data.imports)) for (const importedElement of imported) {
+			const fqn = GlobalFqn(projectId, importedElement.id);
+			processImportedElement(model, nonNullable(model.findElement(fqn), `Element ${importedElement.id} from project ${projectId} not found in model ${model.projectId}`));
+		}
+	}
+	const edges = Array.from(relationships.entries()).filter(([_, { relationships }]) => relationships.size > 0).map(([key, { from, to, relationships: relationshipsSet }]) => {
+		const relationships = [...relationshipsSet];
+		invariant(t$6(relationships, 1), "Relationships set must have at least one relationship");
+		const edge = {
+			id: stringHash(key),
+			source: nodeId(from),
+			target: nodeId(to),
+			projectId: from,
+			relations: t$2(relationships, e$1("id")),
+			label: null,
+			color: "gray",
+			parent: null,
+			line: "solid",
+			tags: n(t$7(relationships, e$1("tags")))
+		};
+		const onlyOne = t$8(relationships);
+		if (onlyOne) {
+			edge.label = onlyOne.title;
+			edge.description = /* @__PURE__ */ preferSummary(onlyOne.$relationship) ?? null;
+			edge.technology = onlyOne.technology;
+			edge.color = onlyOne.color;
+			edge.line = onlyOne.line;
+			if (onlyOne.kind) edge.kind = onlyOne.kind;
+			if (onlyOne.$relationship.navigateTo) edge.navigateTo = onlyOne.$relationship.navigateTo;
+		}
+		return edge;
+	});
+	linkNodesWithEdges(nodesMap, edges);
+	const sorted = topologicalSort$1({
+		nodes: nodesMap,
+		edges
+	});
+	return {
+		id: "projects-view",
+		[_type]: "projects",
+		[_stage]: "computed",
+		title: "Projects",
+		description: { txt: "Overview of all projects and their relationships" },
+		autoLayout: { direction: "TB" },
+		...sorted
+	};
 }
 function buildNodesForEachModel(likec4models) {
-  const nodesMap = /* @__PURE__ */ new Map();
-  for (const model of likec4models) {
-    const projectId = ProjectId(model.projectId);
-    const node = {
-      id: nodeId(projectId),
-      kind: "@project",
-      parent: null,
-      projectId,
-      title: model.project.title ?? model.project.id,
-      description: {
-        txt: [
-          `Elements: ${keysCount(model.$data.elements)}`,
-          `Relationships: ${keysCount(model.$data.relations)}`,
-          `Views: ${keysCount(model.$data.views)}`
-        ].join("\n")
-      },
-      shape: "rectangle",
-      children: [],
-      inEdges: [],
-      outEdges: [],
-      color: "primary",
-      level: 0,
-      style: {},
-      tags: []
-    };
-    nodesMap.set(node.id, node);
-  }
-  return nodesMap;
+	const nodesMap = /* @__PURE__ */ new Map();
+	for (const model of likec4models) {
+		const projectId = ProjectId(model.projectId);
+		const node = {
+			id: nodeId(projectId),
+			kind: "@project",
+			parent: null,
+			projectId,
+			title: model.project.title ?? model.project.id,
+			description: { txt: [
+				`Elements: ${keysCount(model.$data.elements)}`,
+				`Relationships: ${keysCount(model.$data.relations)}`,
+				`Views: ${keysCount(model.$data.views)}`
+			].join("\n") },
+			shape: "rectangle",
+			children: [],
+			inEdges: [],
+			outEdges: [],
+			color: "primary",
+			level: 0,
+			style: {},
+			tags: []
+		};
+		nodesMap.set(node.id, node);
+	}
+	return nodesMap;
+}
+
+//#endregion
+//#region src/compute-view/adhoc-view/compute.ts
+/**
+* Computes an adhoc view based on the given predicates.
+* Adhoc views are not defined in the model, but computed on demand.
+* Available for logical model only.
+*
+* @param predicates accepts the same predicates as element view.
+* @param likec4model The LikeC4 model to compute view.
+* @returns The computed adhoc view.
+*/
+function computeAdhocView(likec4model, predicates) {
+	return {
+		...computeElementView(likec4model, {
+			id: ViewId("adhoc"),
+			_stage: "parsed",
+			_type: "element",
+			rules: predicates,
+			title: null,
+			description: null
+		}),
+		_type: "adhoc",
+		_stage: "computed"
+	};
 }
 
-export { computeProjectsView, resolveRulesExtendedViews, viewsWithReadableEdges, withReadableEdges };
+//#endregion
+//#region src/compute-view/adhoc-view/builder.ts
+/**
+* Allows you to define type-safe adhoc views using types from the model.
+*/
+var AdhocView = class AdhocView {
+	/**
+	* Creates a new adhoc view builder.
+	*/
+	static use(model) {
+		return new AdhocView(model);
+	}
+	#predicates = [];
+	constructor(model) {
+		this.model = model;
+	}
+	/**
+	* Used to cache the type of the predicates.
+	*/
+	Expr;
+	include(...predicates) {
+		this.#predicates.push({ include: predicates.map((predicate) => $expr(predicate)) });
+		return this;
+	}
+	exclude(...predicates) {
+		this.#predicates.push({ exclude: predicates.map((predicate) => $expr(predicate)) });
+		return this;
+	}
+	compute() {
+		return computeAdhocView(this.model, this.#predicates);
+	}
+};
+
+//#endregion
+export { AdhocView, computeAdhocView, computeLikeC4Model, computeParsedModelData, computeProjectsView, computeRelationshipsView, computeView, resolveRulesExtendedViews, treeFromElements, unsafeComputeView, viewsWithReadableEdges, withReadableEdges };