@likec4/core 0.36.0 → 0.37.0

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

@@ -5,6 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ComputeCtx = void 0;
 var _rambdax = require("rambdax");
+var _types = require("../types/index.cjs");
+var _computePredicates = require("./compute-predicates.cjs");
+var _errors = require("../errors/index.cjs");
 class ComputeCtx {
   constructor(index, root, elements = /* @__PURE__ */new Set(), relations = /* @__PURE__ */new Set(), implicits = /* @__PURE__ */new Set()) {
     this.index = index;
@@ -31,5 +34,56 @@ class ComputeCtx {
     }
     return new ComputeCtx(this.index, this.root, elements ? new Set((0, _rambdax.difference)([...this.elements], elements)) : this.elements, relations ? new Set((0, _rambdax.difference)([...this.relations], relations)) : this.relations, newImplicits);
   }
+  processViewRules(viewRules) {
+    let ctx = this;
+    for (const {
+      isInclude,
+      exprs
+    } of viewRules) {
+      for (const expr of exprs) {
+        if (_types.Expr.isElementKindExpr(expr) || _types.Expr.isElementTagExpr(expr)) {
+          ctx = isInclude ? (0, _computePredicates.includeElementKindOrTag)(ctx, expr) : (0, _computePredicates.excludeElementKindOrTag)(ctx, expr);
+          continue;
+        }
+        if (_types.Expr.isElementRef(expr)) {
+          ctx = isInclude ? (0, _computePredicates.includeElementRef)(ctx, expr) : (0, _computePredicates.excludeElementRef)(ctx, expr);
+          continue;
+        }
+        if (_types.Expr.isWildcard(expr)) {
+          ctx = isInclude ? (0, _computePredicates.includeWildcardRef)(ctx, expr) : (0, _computePredicates.excludeWildcardRef)(ctx, expr);
+          continue;
+        }
+        if (_types.Expr.isIncoming(expr)) {
+          ctx = isInclude ? (0, _computePredicates.includeIncomingExpr)(ctx, expr) : (0, _computePredicates.excludeIncomingExpr)(ctx, expr);
+          continue;
+        }
+        if (_types.Expr.isOutgoing(expr)) {
+          ctx = isInclude ? (0, _computePredicates.includeOutgoingExpr)(ctx, expr) : (0, _computePredicates.excludeOutgoingExpr)(ctx, expr);
+          continue;
+        }
+        if (_types.Expr.isInOut(expr)) {
+          ctx = isInclude ? (0, _computePredicates.includeInOutExpr)(ctx, expr) : (0, _computePredicates.excludeInOutExpr)(ctx, expr);
+          continue;
+        }
+        if (_types.Expr.isRelation(expr)) {
+          ctx = isInclude ? (0, _computePredicates.includeRelationExpr)(ctx, expr) : (0, _computePredicates.excludeRelationExpr)(ctx, expr);
+          continue;
+        }
+        (0, _errors.nonexhaustive)(expr);
+      }
+    }
+    return ctx;
+  }
+  static create(view, index) {
+    const rootElement = (0, _types.isStrictElementView)(view) ? view.viewOf : null;
+    let ctx = new ComputeCtx(index, rootElement);
+    const rulesInclude = view.rules.filter(_types.isViewRuleExpression);
+    if (rootElement && rulesInclude.length == 0) {
+      ctx = ctx.include({
+        elements: [index.find(rootElement)]
+      });
+    }
+    return ctx.processViewRules(rulesInclude);
+  }
 }
 exports.ComputeCtx = ComputeCtx;

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

@@ -1,5 +1,5 @@
 import type { ModelIndex } from '../model-index';
-import type { Fqn, Element, Relation } from '../types';
+import type { Fqn, Element, Relation, ViewRuleExpression, ElementView } from '../types';
 export type ComputeCtxPatch = {
     elements?: Element[];
     relations?: Relation[];
@@ -14,4 +14,6 @@ export declare class ComputeCtx {
     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;
+    processViewRules(viewRules: ViewRuleExpression[]): ComputeCtx;
+    static create(view: ElementView, index: ModelIndex): ComputeCtx;
 }

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

@@ -1,4 +1,22 @@
 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;
@@ -7,11 +25,7 @@ export class ComputeCtx {
     this.relations = relations;
     this.implicits = implicits;
   }
-  include({
-    elements,
-    relations,
-    implicits
-  }) {
+  include({ elements, relations, implicits }) {
     return new ComputeCtx(
       this.index,
       this.root,
@@ -20,16 +34,10 @@ export class ComputeCtx {
       implicits ? /* @__PURE__ */ new Set([...this.implicits, ...implicits]) : this.implicits
     );
   }
-  exclude({
-    elements,
-    relations,
-    implicits
-  }) {
+  exclude({ elements, relations, implicits }) {
     let newImplicits = implicits ? new Set(difference([...this.implicits], implicits)) : this.implicits;
     if (elements) {
-      newImplicits = new Set(
-        difference([...newImplicits], elements)
-      );
+      newImplicits = new Set(difference([...newImplicits], elements));
     }
     return new ComputeCtx(
       this.index,
@@ -39,4 +47,52 @@ export class ComputeCtx {
       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/compute-view/compute-element-view.cjs

@@ -10,7 +10,6 @@ var _types = require("../types/index.cjs");
 var _utils = require("../utils/index.cjs");
 var _EdgeBuilder = require("./EdgeBuilder.cjs");
 var _computeCtx = require("./compute-ctx.cjs");
-var _computePredicates = require("./compute-predicates.cjs");
 var _applyViewRuleStyles = require("./utils/applyViewRuleStyles.cjs");
 var _sortNodes = require("./utils/sortNodes.cjs");
 function reduceToMap(elementsIterator) {
@@ -46,50 +45,7 @@ function reduceToMap(elementsIterator) {
   }, /* @__PURE__ */new Map());
 }
 function computeElementView(view, index) {
-  const rootElement = view.viewOf ?? null;
-  let ctx = new _computeCtx.ComputeCtx(index, rootElement);
-  const rulesInclude = view.rules.filter(_types.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 (_types.Expr.isElementKindExpr(expr) || _types.Expr.isElementTagExpr(expr)) {
-        ctx = isInclude ? (0, _computePredicates.includeElementKindOrTag)(ctx, expr) : (0, _computePredicates.excludeElementKindOrTag)(ctx, expr);
-        continue;
-      }
-      if (_types.Expr.isElementRef(expr)) {
-        ctx = isInclude ? (0, _computePredicates.includeElementRef)(ctx, expr) : (0, _computePredicates.excludeElementRef)(ctx, expr);
-        continue;
-      }
-      if (_types.Expr.isWildcard(expr)) {
-        ctx = isInclude ? (0, _computePredicates.includeWildcardRef)(ctx, expr) : (0, _computePredicates.excludeWildcardRef)(ctx, expr);
-        continue;
-      }
-      if (_types.Expr.isIncoming(expr)) {
-        ctx = isInclude ? (0, _computePredicates.includeIncomingExpr)(ctx, expr) : (0, _computePredicates.excludeIncomingExpr)(ctx, expr);
-        continue;
-      }
-      if (_types.Expr.isOutgoing(expr)) {
-        ctx = isInclude ? (0, _computePredicates.includeOutgoingExpr)(ctx, expr) : (0, _computePredicates.excludeOutgoingExpr)(ctx, expr);
-        continue;
-      }
-      if (_types.Expr.isInOut(expr)) {
-        ctx = isInclude ? (0, _computePredicates.includeInOutExpr)(ctx, expr) : (0, _computePredicates.excludeInOutExpr)(ctx, expr);
-        continue;
-      }
-      if (_types.Expr.isRelation(expr)) {
-        ctx = isInclude ? (0, _computePredicates.includeRelationExpr)(ctx, expr) : (0, _computePredicates.excludeRelationExpr)(ctx, expr);
-        continue;
-      }
-      (0, _errors.nonexhaustive)(expr);
-    }
-  }
+  const ctx = _computeCtx.ComputeCtx.create(view, index);
   const allElements = [...ctx.elements, ...ctx.implicits].sort(_utils.compareByFqnHierarchically).reverse();
   const elementsWithRelations = /* @__PURE__ */new Set();
   const edgeBuilder = new _EdgeBuilder.EdgeBuilder();

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

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

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

@@ -1,32 +1,14 @@
 import { allPass, find } from "remeda";
-import { nonNullable, nonexhaustive } from "../errors/index.js";
+import { nonNullable } from "../errors/index.js";
 import {
   DefaultElementShape,
   DefaultThemeColor,
-  Expr,
   isViewRuleAutoLayout,
-  isViewRuleExpression,
   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 {
-  excludeElementKindOrTag,
-  excludeElementRef,
-  excludeInOutExpr,
-  excludeIncomingExpr,
-  excludeOutgoingExpr,
-  excludeRelationExpr,
-  excludeWildcardRef,
-  includeElementKindOrTag,
-  includeElementRef,
-  includeInOutExpr,
-  includeIncomingExpr,
-  includeOutgoingExpr,
-  includeRelationExpr,
-  includeWildcardRef
-} from "./compute-predicates.js";
 import { applyViewRuleStyles } from "./utils/applyViewRuleStyles.js";
 import { sortNodes } from "./utils/sortNodes.js";
 function reduceToMap(elementsIterator) {
@@ -57,47 +39,7 @@ function reduceToMap(elementsIterator) {
   }, /* @__PURE__ */ new Map());
 }
 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 (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);
-    }
-  }
+  const ctx = ComputeCtx.create(view, index);
   const allElements = [...ctx.elements, ...ctx.implicits].sort(compareByFqnHierarchically).reverse();
   const elementsWithRelations = /* @__PURE__ */ new Set();
   const edgeBuilder = new EdgeBuilder();
@@ -108,10 +50,7 @@ export function computeElementView(view, index) {
     if (!source) {
       continue;
     }
-    const target = find(
-      allElements,
-      allPass([anscestorOf(rel.target), (e) => !isSameHierarchy(e, source)])
-    );
+    const target = find(allElements, allPass([anscestorOf(rel.target), (e) => !isSameHierarchy(e, source)]));
     if (!target) {
       continue;
     }

package/dist/compute-view/compute.cjs

@@ -5,11 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.assignNavigateTo = assignNavigateTo;
 exports.computeView = computeView;
-exports.computeViews = computeViews;
-var _remeda = require("remeda");
-var _modelIndex = require("../model-index/index.cjs");
+var _rambdax = require("rambdax");
+var _errors = require("../errors/index.cjs");
 var _computeElementView = require("./compute-element-view.cjs");
-var _ = require("../index.cjs");
 function computeView(view, index) {
   try {
     return {
@@ -19,30 +17,18 @@ function computeView(view, index) {
   } catch (e) {
     return {
       isSuccess: false,
-      error: (0, _.normalizeError)(e),
+      error: (0, _errors.normalizeError)(e),
       view: void 0
     };
   }
 }
-function computeViews(model) {
-  const index = _modelIndex.ModelIndex.from(model);
-  const computedViews = (0, _remeda.compact)((0, _remeda.map)(model.views, view => computeView(view, index).view));
-  return {
-    elements: model.elements,
-    relations: model.relations,
-    views: (0, _remeda.mapToObj)(computedViews, view => [view.id, view])
-  };
-}
 function assignNavigateTo(views) {
   const allElementViews = /* @__PURE__ */new Map();
-  for (const {
-    id,
-    viewOf
-  } of views) {
-    if (viewOf) {
-      const viewsOf = allElementViews.get(viewOf) ?? [];
-      viewsOf.push(id);
-      allElementViews.set(viewOf, viewsOf);
+  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 {
@@ -50,7 +36,7 @@ function assignNavigateTo(views) {
     nodes
   } of views) {
     for (const node of nodes) {
-      const navigateTo = (0, _remeda.find)(allElementViews.get(node.id) ?? [], v => v !== id);
+      const navigateTo = (0, _rambdax.find)(v => v !== id, allElementViews.get(node.id) ?? []);
       if (navigateTo) {
         node.navigateTo = navigateTo;
       }

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

@@ -1,6 +1,6 @@
-import { ModelIndex } from '../model-index';
-import type { ComputedView, Element, ElementView, Fqn, Relation, RelationID, ViewID } from '../types';
-import { type BaseError } from '..';
+import type { BaseError } from '../errors';
+import type { ModelIndex } from '../model-index';
+import { type ComputedView, type ElementView } from '../types';
 type ComputeViewResult = {
     isSuccess: true;
     view: ComputedView;
@@ -10,16 +10,5 @@ type ComputeViewResult = {
     view: undefined;
 };
 export declare function computeView(view: ElementView, index: ModelIndex): ComputeViewResult;
-export type CmpInputModel = {
-    elements: Record<Fqn, Element>;
-    relations: Record<RelationID, Relation>;
-    views: ElementView[];
-};
-export type CmpOutputModel = {
-    elements: Record<Fqn, Element>;
-    relations: Record<RelationID, Relation>;
-    views: Record<ViewID, ComputedView>;
-};
-export declare function computeViews(model: CmpInputModel): CmpOutputModel;
 export declare function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R;
 export {};

package/dist/compute-view/compute.js

@@ -1,7 +1,6 @@
-import { compact, find, map, mapToObj } from "remeda";
-import { ModelIndex } from "../model-index/index.js";
+import { find } from "rambdax";
+import { normalizeError } from "../errors/index.js";
 import { computeElementView } from "./compute-element-view.js";
-import { normalizeError } from "../index.js";
 export function computeView(view, index) {
   try {
     return {
@@ -16,27 +15,18 @@ export function computeView(view, index) {
     };
   }
 }
-export function computeViews(model) {
-  const index = ModelIndex.from(model);
-  const computedViews = compact(map(model.views, (view) => computeView(view, index).view));
-  return {
-    elements: model.elements,
-    relations: model.relations,
-    views: mapToObj(computedViews, (view) => [view.id, view])
-  };
-}
 export function assignNavigateTo(views) {
   const allElementViews = /* @__PURE__ */ new Map();
-  for (const { id, viewOf } of views) {
-    if (viewOf) {
-      const viewsOf = allElementViews.get(viewOf) ?? [];
-      viewsOf.push(id);
-      allElementViews.set(viewOf, viewsOf);
+  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(allElementViews.get(node.id) ?? [], (v) => v !== id);
+      const navigateTo = find((v) => v !== id, allElementViews.get(node.id) ?? []);
       if (navigateTo) {
         node.navigateTo = navigateTo;
       }

package/dist/compute-view/index.cjs

@@ -14,6 +14,17 @@ Object.keys(_compute).forEach(function (key) {
     }
   });
 });
+var _resolveExtendedViews = require("./resolve-extended-views.cjs");
+Object.keys(_resolveExtendedViews).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _resolveExtendedViews[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _resolveExtendedViews[key];
+    }
+  });
+});
 var _EdgeBuilder = require("./EdgeBuilder.cjs");
 Object.keys(_EdgeBuilder).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

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

@@ -1,2 +1,3 @@
 export * from './compute';
+export * from './resolve-extended-views';
 export * from './EdgeBuilder';

package/dist/compute-view/index.js

@@ -1,2 +1,3 @@
 export * from "./compute.js";
+export * from "./resolve-extended-views.js";
 export * from "./EdgeBuilder.js";

package/dist/compute-view/resolve-extended-views.cjs

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveRulesExtendedViews = resolveRulesExtendedViews;
+var _graphlib = _interopRequireDefault(require("@dagrejs/graphlib"));
+var _errors = require("../errors/index.cjs");
+var _types = require("../types/index.cjs");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  Graph,
+  alg
+} = _graphlib.default;
+function resolveRulesExtendedViews(unresolvedViews) {
+  const g = new Graph({
+    directed: true,
+    multigraph: false,
+    compound: false
+  });
+  for (const view of Object.values(unresolvedViews)) {
+    if (!(0, _types.isExtendsElementView)(view)) {
+      g.setNode(view.id);
+      continue;
+    }
+    if (unresolvedViews[view.extends]) {
+      g.setEdge(view.extends, view.id);
+    }
+  }
+  if (!alg.isAcyclic(g)) {
+    alg.findCycles(g).flat().map(id => g.removeNode(id));
+  }
+  return alg.topsort(g).reduce((acc, id) => {
+    const view = (0, _errors.nonNullable)(unresolvedViews[id], `Cannot find view ${id}`);
+    if ((0, _types.isExtendsElementView)(view)) {
+      const extendsFrom = acc[view.extends];
+      (0, _errors.invariant)(extendsFrom, `Cannot find base view '${view.extends}' for '${view.id}'`);
+      return Object.assign(acc, {
+        [view.id]: {
+          ...extendsFrom,
+          ...view,
+          rules: [...extendsFrom.rules, ...view.rules]
+        }
+      });
+    }
+    return Object.assign(acc, {
+      [view.id]: view
+    });
+  }, {});
+}

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

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

package/dist/compute-view/resolve-extended-views.js

@@ -0,0 +1,38 @@
+import pkg from "@dagrejs/graphlib";
+import { invariant, nonNullable } from "../errors/index.js";
+import { isExtendsElementView } from "../types/index.js";
+const { Graph, alg } = pkg;
+export function resolveRulesExtendedViews(unresolvedViews) {
+  const g = new Graph({
+    directed: true,
+    multigraph: false,
+    compound: false
+  });
+  for (const view of Object.values(unresolvedViews)) {
+    if (!isExtendsElementView(view)) {
+      g.setNode(view.id);
+      continue;
+    }
+    if (unresolvedViews[view.extends]) {
+      g.setEdge(view.extends, view.id);
+    }
+  }
+  if (!alg.isAcyclic(g)) {
+    alg.findCycles(g).flat().map((id) => g.removeNode(id));
+  }
+  return alg.topsort(g).reduce((acc, id) => {
+    const view = nonNullable(unresolvedViews[id], `Cannot find view ${id}`);
+    if (isExtendsElementView(view)) {
+      const extendsFrom = acc[view.extends];
+      invariant(extendsFrom, `Cannot find base view '${view.extends}' for '${view.id}'`);
+      return Object.assign(acc, {
+        [view.id]: {
+          ...extendsFrom,
+          ...view,
+          rules: [...extendsFrom.rules, ...view.rules]
+        }
+      });
+    }
+    return Object.assign(acc, { [view.id]: view });
+  }, {});
+}

package/dist/errors/non-nullable.cjs

@@ -15,9 +15,9 @@ class NullableError extends _base.BaseError {
   }
 }
 exports.NullableError = NullableError;
-function nonNullable(value) {
+function nonNullable(value, message) {
   if (typeof value === "undefined" || value == null) {
-    throw new NullableError(`Expected defined value, but received ${value}`);
+    throw new NullableError(message ?? `Expected defined value, but received ${value}`);
   }
   return value;
 }

package/dist/errors/non-nullable.d.ts

@@ -3,4 +3,4 @@ import { BaseError } from './_base';
 export declare class NullableError extends BaseError {
     constructor(message: string, options?: BaseErrorOptions);
 }
-export declare function nonNullable<T>(value: T): NonNullable<T>;
+export declare function nonNullable<T>(value: T, message?: string): T & {};

package/dist/errors/non-nullable.js

@@ -5,9 +5,9 @@ export class NullableError extends BaseError {
     Object.defineProperty(this, "name", { value: "UnexpectedNullableError" });
   }
 }
-export function nonNullable(value) {
+export function nonNullable(value, message) {
   if (typeof value === "undefined" || value == null) {
-    throw new NullableError(`Expected defined value, but received ${value}`);
+    throw new NullableError(message ?? `Expected defined value, but received ${value}`);
   }
   return value;
 }

package/dist/types/computed-view.d.ts

@@ -1,7 +1,7 @@
 import type { Opaque } from './opaque';
 import type { ElementKind, ElementShape, Fqn, Tag } from './element';
 import type { RelationID } from './relation';
-import type { ElementView, ViewID, ViewRuleAutoLayout } from './view';
+import type { BasicElementView, ViewID, ViewRuleAutoLayout } from './view';
 import type { IconUrl, NonEmptyArray } from './_common';
 import type { ThemeColor } from './theme';
 export type NodeId = Fqn;
@@ -31,7 +31,9 @@ export interface ComputedEdge {
     label: string | null;
     relations: RelationID[];
 }
-export interface ComputedView extends ElementView {
+export interface ComputedView extends BasicElementView {
+    viewOf?: Fqn;
+    extends?: ViewID;
     autoLayout: ViewRuleAutoLayout['autoLayout'];
     nodes: ComputedNode[];
     edges: ComputedEdge[];

package/dist/types/model.d.ts

@@ -1,7 +1,12 @@
-import type { Fqn, Element } from './element';
-import type { RelationID, Relation } from './relation';
-import type { ViewID } from './view';
 import type { ComputedView } from './computed-view';
+import type { Element, Fqn } from './element';
+import type { Relation, RelationID } from './relation';
+import type { ElementView, ViewID } from './view';
+export interface LikeC4RawModel {
+    elements: Record<Fqn, Element>;
+    relations: Record<RelationID, Relation>;
+    views: Record<ViewID, ElementView>;
+}
 export interface LikeC4Model {
     elements: Record<Fqn, Element>;
     relations: Record<RelationID, Relation>;

package/dist/types/view.cjs

@@ -3,6 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.isExtendsElementView = isExtendsElementView;
+exports.isStrictElementView = isStrictElementView;
 exports.isViewRuleAutoLayout = isViewRuleAutoLayout;
 exports.isViewRuleExpression = isViewRuleExpression;
 exports.isViewRuleStyle = isViewRuleStyle;
@@ -14,4 +16,10 @@ function isViewRuleStyle(rule) {
 }
 function isViewRuleAutoLayout(rule) {
   return "autoLayout" in rule;
+}
+function isStrictElementView(view) {
+  return "viewOf" in view;
+}
+function isExtendsElementView(view) {
+  return "extends" in view;
 }

package/dist/types/view.d.ts

@@ -23,7 +23,7 @@ export interface ViewRuleAutoLayout {
 }
 export declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
 export type ViewRule = ViewRuleExpression | ViewRuleStyle | ViewRuleAutoLayout;
-export interface ElementView {
+export interface BasicElementView {
     readonly id: ViewID;
     readonly viewOf?: Fqn;
     readonly title: string | null;
@@ -32,3 +32,12 @@ export interface ElementView {
     readonly links: NonEmptyArray<string> | null;
     readonly rules: ViewRule[];
 }
+export interface StrictElementView extends BasicElementView {
+    readonly viewOf: Fqn;
+}
+export declare function isStrictElementView(view: ElementView): view is StrictElementView;
+export interface ExtendsElementView extends BasicElementView {
+    readonly extends: ViewID;
+}
+export declare function isExtendsElementView(view: ElementView): view is ExtendsElementView;
+export type ElementView = StrictElementView | ExtendsElementView | BasicElementView;

package/dist/types/view.js

@@ -7,3 +7,9 @@ export function isViewRuleStyle(rule) {
 export function isViewRuleAutoLayout(rule) {
   return "autoLayout" in rule;
 }
+export function isStrictElementView(view) {
+  return "viewOf" in view;
+}
+export function isExtendsElementView(view) {
+  return "extends" in view;
+}

package/dist/utils/relations.cjs

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.compareRelations = exports.Relations = void 0;
-var _remeda = require("remeda");
 var _fqn = require("./fqn.cjs");
 var _rambdax = require("rambdax");
 const compareRelations = (a, b) => {
@@ -25,7 +24,7 @@ const isBetween = (source, target) => {
   };
 };
 const isAnyBetween = (source, target) => {
-  return (0, _remeda.anyPass)([isBetween(source, target), isBetween(target, source)]);
+  return (0, _rambdax.either)(isBetween(source, target), isBetween(target, source));
 };
 const isIncoming = target => {
   const targetPrefix = target + ".";

package/dist/utils/relations.js

@@ -1,4 +1,3 @@
-import { anyPass } from "remeda";
 import { compareFqnHierarchically, isAncestor } from "./fqn.js";
 import { either } from "rambdax";
 export const compareRelations = (a, b) => {
@@ -18,7 +17,7 @@ const isBetween = (source, target) => {
   };
 };
 const isAnyBetween = (source, target) => {
-  return anyPass([isBetween(source, target), isBetween(target, source)]);
+  return either(isBetween(source, target), isBetween(target, source));
 };
 const isIncoming = (target) => {
   const targetPrefix = target + ".";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",