@likec4/core 0.18.0 → 0.19.0

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

@@ -1,4 +1,4 @@
-import { anyPass, filter, head, uniq } from 'rambdax';
+import { anyPass, filter, head, uniq, isNil } from 'rambdax';
 import { DefaultThemeColor, DefaultElementShape } from '../types';
 import * as Expression from '../types/expression';
 import { isViewRuleAutoLayout, isViewRuleExpression, isViewRuleStyle } from '../types/view';
@@ -12,7 +12,7 @@ import invariant from 'tiny-invariant';
 function transformToNodes(elementsIterator, index, currentViewid) {
     return Array.from(elementsIterator)
         .sort(compareByFqnHierarchically)
-        .reduce((map, { id, title, color, shape, description }) => {
+        .reduce((map, { id, kind, title, color, shape, description }) => {
         let parent = parentFqn(id);
         while (parent) {
             if (map.has(parent)) {
@@ -28,6 +28,7 @@ function transformToNodes(elementsIterator, index, currentViewid) {
         }
         const node = {
             id,
+            kind,
             parent,
             title,
             color: color ?? DefaultThemeColor,
@@ -52,6 +53,16 @@ function applyViewRuleStyles(rules, nodes) {
                 predicates.push(() => true);
                 break;
             }
+            if (Expression.isElementKindExpr(target)) {
+                predicates.push(target.isEqual ? n => n.kind === target.elementKind : n => n.kind !== target.elementKind);
+                continue;
+            }
+            if (Expression.isElementTagExpr(target)) {
+                predicates.push(target.isEqual
+                    ? ({ tags }) => !!tags && tags.includes(target.elementTag)
+                    : ({ tags }) => isNil(tags) || !tags.includes(target.elementTag));
+                continue;
+            }
             if (Expression.isElementRef(target)) {
                 const { element, isDescedants } = target;
                 predicates.push(isDescedants ? n => n.id.startsWith(element + '.') : n => n.id === element);
@@ -100,6 +111,37 @@ const excludeElementRef = (ctx, expr) => {
     const relations = [...ctx.relations].filter(r => elementsIds.includes(r.source) || elementsIds.includes(r.target));
     return ctx.exclude({ elements, relations });
 };
+const asElementPredicate = (expr) => {
+    if (expr.isEqual) {
+        if (Expression.isElementKindExpr(expr)) {
+            return e => e.kind === expr.elementKind;
+        }
+        else {
+            return ({ tags }) => !!tags && tags.includes(expr.elementTag);
+        }
+    }
+    else {
+        if (Expression.isElementKindExpr(expr)) {
+            return e => e.kind !== expr.elementKind;
+        }
+        else {
+            return ({ tags }) => isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
+        }
+    }
+};
+const includeElementKindOrTag = (ctx, expr) => {
+    const elements = ctx.index.elements.filter(asElementPredicate(expr));
+    return elements.reduce((accCtx, el) => includeElementRef(accCtx, {
+        element: el.id,
+        isDescedants: false
+    }), ctx);
+};
+const excludeElementKindOrTag = (ctx, expr) => {
+    const predicate = asElementPredicate(expr);
+    const elements = [...ctx.elements].filter(predicate);
+    const implicits = [...ctx.implicits].filter(predicate);
+    return ctx.exclude({ elements, implicits });
+};
 const includeWildcardRef = (ctx, _expr) => {
     const { root } = ctx;
     if (root) {
@@ -122,10 +164,7 @@ const includeWildcardRef = (ctx, _expr) => {
         }
         return ctx.include({
             elements,
-            relations: [
-                ...ctx.index.filterRelations(isInside(root)),
-                ...relations,
-            ],
+            relations: [...ctx.index.filterRelations(isInside(root)), ...relations],
             implicits: implicits
         });
     }
@@ -165,13 +204,28 @@ const resolveElements = (ctx, expr) => {
             return ctx.index.rootElements();
         }
     }
+    if (Expression.isElementKindExpr(expr)) {
+        return ctx.index.elements.filter(el => {
+            if (expr.isEqual) {
+                return el.kind === expr.elementKind;
+            }
+            return el.kind !== expr.elementKind;
+        });
+    }
+    if (Expression.isElementTagExpr(expr)) {
+        return ctx.index.elements.filter(el => {
+            const tags = el.tags;
+            if (expr.isEqual) {
+                return !!tags && tags.includes(expr.elementTag);
+            }
+            return isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
+        });
+    }
+    if (expr.isDescedants) {
+        return ctx.index.children(expr.element);
+    }
     else {
-        if (expr.isDescedants) {
-            return ctx.index.children(expr.element);
-        }
-        else {
-            return [ctx.index.find(expr.element)];
-        }
+        return [ctx.index.find(expr.element)];
     }
 };
 const includeIncomingExpr = (ctx, expr) => {
@@ -349,6 +403,10 @@ export function computeElementView(view, index) {
     }
     for (const { isInclude, exprs } of rulesInclude) {
         for (const expr of exprs) {
+            if (Expression.isElementKindExpr(expr) || Expression.isElementTagExpr(expr)) {
+                ctx = isInclude ? includeElementKindOrTag(ctx, expr) : excludeElementKindOrTag(ctx, expr);
+                continue;
+            }
             if (Expression.isElementRef(expr)) {
                 ctx = isInclude ? includeElementRef(ctx, expr) : excludeElementRef(ctx, expr);
                 continue;

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

@@ -1,15 +1,17 @@
 import type { Opaque } from './opaque';
-import type { ElementShape, Fqn, ThemeColor } from './element';
+import type { ElementKind, ElementShape, Fqn, Tag, ThemeColor } from './element';
 import type { RelationID } from './relation';
 import type { ElementView, ViewID, ViewRuleAutoLayout } from './view';
 export type NodeId = Fqn;
 export type EdgeId = Opaque<string, 'EdgeId'>;
 export interface ComputedNode {
     id: NodeId;
+    kind: ElementKind;
     parent: NodeId | null;
     title: string;
     description?: string;
     technology?: string;
+    tags?: Tag[];
     children: NodeId[];
     shape: ElementShape;
     color: ThemeColor;

package/dist/types/expression.d.ts

@@ -1,6 +1,9 @@
-import type { Fqn } from './element';
+import type { ElementKind, Fqn, Tag } from './element';
 interface BaseExr {
     element?: never;
+    elementKind?: never;
+    elementTag?: never;
+    isEqual?: never;
     isDescedants?: never;
     wildcard?: never;
     source?: never;
@@ -18,7 +21,17 @@ export interface WildcardExpr extends Omit<BaseExr, 'wildcard'> {
     wildcard: true;
 }
 export declare function isWildcard(expr: Expression): expr is WildcardExpr;
-export type ElementExpression = ElementRefExpr | WildcardExpr;
+export interface ElementKindExpr extends Omit<BaseExr, 'elementKind' | 'isEqual'> {
+    elementKind: ElementKind;
+    isEqual: boolean;
+}
+export declare function isElementKindExpr(expr: Expression): expr is ElementKindExpr;
+export interface ElementTagExpr extends Omit<BaseExr, 'elementTag' | 'isEqual'> {
+    elementTag: Tag;
+    isEqual: boolean;
+}
+export declare function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
+export type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr;
 export declare function isElement(expr: Expression): expr is ElementExpression;
 export interface RelationExpr extends Omit<BaseExr, 'source' | 'target'> {
     source: ElementExpression;

package/dist/types/expression.js

@@ -4,8 +4,14 @@ export function isElementRef(expr) {
 export function isWildcard(expr) {
     return 'wildcard' in expr;
 }
+export function isElementKindExpr(expr) {
+    return 'elementKind' in expr && 'isEqual' in expr;
+}
+export function isElementTagExpr(expr) {
+    return 'elementTag' in expr && 'isEqual' in expr;
+}
 export function isElement(expr) {
-    return isElementRef(expr) || isWildcard(expr);
+    return isElementRef(expr) || isWildcard(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
 }
 export function isRelation(expr) {
     return 'source' in expr && 'target' in expr;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",