@likec4/language-server 1.27.3 → 1.28.1

package/dist/model/parser/PredicatesParser.d.ts

@@ -1,22 +1,42 @@
 import type * as c4 from '@likec4/core';
 import { ast } from '../../ast';
-import { type Base } from './Base';
+import type { WithExpressionV2 } from './FqnRefParser';
 export type WithPredicates = ReturnType<typeof PredicatesParser>;
-export declare function PredicatesParser<TBase extends Base>(B: TBase): {
+export declare function PredicatesParser<TBase extends WithExpressionV2>(B: TBase): {
     new (...args: any[]): {
-        parsePredicate(astNode: ast.Predicate): c4.Expression;
-        parseElementPredicate(astNode: ast.ElementPredicate): c4.ElementPredicateExpression;
-        parseElementExpressionsIterator(astNode: ast.ElementExpressionsIterator): c4.ElementExpression[];
-        parseElementExpression(astNode: ast.ElementExpression): c4.ElementExpression;
-        parseElementPredicateWhere(astNode: ast.ElementPredicateWhere): c4.ElementWhereExpr;
-        parseElementPredicateWith(astNode: ast.ElementPredicateWith): c4.CustomElementExpr;
-        parseRelationPredicate(astNode: ast.RelationPredicate): c4.RelationPredicateExpression;
-        parseRelationPredicateWhere(astNode: ast.RelationPredicateWhere): c4.RelationWhereExpr;
-        parseRelationPredicateWith(astNode: ast.RelationPredicateWith, relation: c4.RelationExpression | c4.RelationWhereExpr): c4.CustomRelationExpr;
-        parseRelationExpression(astNode: ast.RelationExpression): c4.RelationExpression;
+        parsePredicate(astNode: ast.ExpressionV2): c4.ModelLayer.Expression;
+        parseElementPredicate(astNode: ast.FqnExprOrWith): c4.ModelLayer.AnyFqnExpr;
+        parseElementPredicateOrWhere(astNode: ast.FqnExprOrWhere): c4.ModelLayer.FqnExprOrWhere;
+        parseElementExpression(astNode: ast.FqnExpr): c4.ModelLayer.FqnExpr;
+        parseElementPredicateWhere(astNode: ast.FqnExprWhere): c4.ModelLayer.FqnExpr.Where;
+        parseElementPredicateWith(astNode: ast.FqnExprWith): c4.ModelLayer.FqnExpr.Custom;
+        parseRelationPredicate(astNode: ast.RelationExprOrWith): c4.ModelLayer.AnyRelationExpr;
+        parseRelationPredicateOrWhere(astNode: ast.RelationExprOrWhere): c4.ModelLayer.RelationExprOrWhere;
+        parseRelationPredicateWhere(astNode: ast.RelationExprWhere): c4.ModelLayer.RelationExpr.Where;
+        parseRelationPredicateWith(astNode: ast.RelationExprWith): c4.ModelLayer.RelationExpr.Custom;
+        parseRelationExpression(astNode: ast.RelationExpr): c4.ModelLayer.RelationExpr;
+        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
+        parseExpressionV2(astNode: ast.ExpressionV2): c4.ExpressionV2;
+        parseFqnExprOrWith(astNode: ast.FqnExprOrWith): c4.FqnExpr.Any;
+        parseFqnExprWith(astNode: ast.FqnExprWith): c4.FqnExpr.Custom;
+        parseFqnExprOrWhere(astNode: ast.FqnExprOrWhere): c4.FqnExpr.OrWhere;
+        parseFqnExprWhere(astNode: ast.FqnExprWhere): c4.FqnExpr.Where;
+        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
+        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
+        parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
+        parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
+        parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        readonly project: {
+            id: c4.ProjectId;
+            folder: c4;
+            config: Readonly<import("../../config").ProjectConfig>;
+        };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
         getAstNodePath(node: c4): any;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
@@ -30,5 +50,8 @@ export declare function PredicatesParser<TBase extends Base>(B: TBase): {
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
         convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
         parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseIconProperty(prop: ast.IconProperty | undefined): c4.IconUrl | undefined;
+        parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
+        parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
     };
 } & TBase;

package/dist/model/parser/PredicatesParser.js

@@ -1,296 +1,45 @@
-import { invariant, nonexhaustive } from "@likec4/core";
-import { isBoolean, isDefined, isTruthy } from "remeda";
-import { ast, parseAstOpacityProperty, parseAstSizeValue, toColor } from "../../ast.js";
-import { logWarnError } from "../../logger.js";
-import { elementRef } from "../../utils/elementRef.js";
-import { parseWhereClause } from "../model-parser-where.js";
-import { removeIndent } from "./Base.js";
+import { nonexhaustive } from "@likec4/core";
+import { ast } from "../../ast.js";
 export function PredicatesParser(B) {
   return class PredicatesParser extends B {
     parsePredicate(astNode) {
-      if (ast.isElementPredicate(astNode)) {
-        return this.parseElementPredicate(astNode);
-      }
-      if (ast.isRelationPredicate(astNode)) {
-        return this.parseRelationPredicate(astNode);
-      }
-      nonexhaustive(astNode);
+      return this.parseExpressionV2(astNode);
     }
     parseElementPredicate(astNode) {
-      if (ast.isElementPredicateWith(astNode)) {
-        return this.parseElementPredicateWith(astNode);
+      if (ast.isFqnExprWith(astNode)) {
+        return this.parseFqnExprWith(astNode);
       }
-      if (ast.isElementPredicateWhere(astNode)) {
-        return this.parseElementPredicateWhere(astNode);
-      }
-      if (ast.isElementExpression(astNode)) {
-        return this.parseElementExpression(astNode);
+      if (ast.isFqnExprOrWhere(astNode)) {
+        return this.parseFqnExprOrWhere(astNode);
       }
       nonexhaustive(astNode);
     }
-    parseElementExpressionsIterator(astNode) {
-      const exprs = [];
-      let iter = astNode;
-      while (iter) {
-        try {
-          if (iter.value) {
-            exprs.unshift(this.parseElementExpression(iter.value));
-          }
-        } catch (e) {
-          logWarnError(e);
-        }
-        iter = iter.prev;
-      }
-      return exprs;
+    parseElementPredicateOrWhere(astNode) {
+      return this.parseFqnExprOrWhere(astNode);
     }
     parseElementExpression(astNode) {
-      if (ast.isWildcardExpression(astNode)) {
-        return {
-          wildcard: true
-        };
-      }
-      if (ast.isElementKindExpression(astNode)) {
-        invariant(astNode.kind?.ref, "ElementKindExpr kind is not resolved: " + astNode.$cstNode?.text);
-        return {
-          elementKind: astNode.kind.ref.name,
-          isEqual: astNode.isEqual
-        };
-      }
-      if (ast.isElementTagExpression(astNode)) {
-        invariant(astNode.tag?.ref, "ElementTagExpr tag is not resolved: " + astNode.$cstNode?.text);
-        let elementTag = astNode.tag.$refText;
-        if (elementTag.startsWith("#")) {
-          elementTag = elementTag.slice(1);
-        }
-        return {
-          elementTag,
-          isEqual: astNode.isEqual
-        };
-      }
-      if (ast.isExpandElementExpression(astNode)) {
-        const elementNode = elementRef(astNode.expand);
-        invariant(elementNode, "Element not found " + astNode.expand.$cstNode?.text);
-        const expanded = this.resolveFqn(elementNode);
-        return {
-          expanded
-        };
-      }
-      if (ast.isElementDescedantsExpression(astNode)) {
-        const elementNode = elementRef(astNode.parent);
-        invariant(elementNode, "Element not found " + astNode.parent.$cstNode?.text);
-        const element = this.resolveFqn(elementNode);
-        return {
-          element,
-          isChildren: astNode.suffix === ".*",
-          isDescendants: astNode.suffix === ".**"
-        };
-      }
-      if (ast.isElementRef(astNode)) {
-        const elementNode = elementRef(astNode);
-        invariant(elementNode, "Element not found " + astNode.$cstNode?.text);
-        const element = this.resolveFqn(elementNode);
-        return {
-          element
-        };
-      }
-      nonexhaustive(astNode);
+      return this.parseFqnExpr(astNode);
     }
     parseElementPredicateWhere(astNode) {
-      const expr = this.parseElementExpression(astNode.subject);
-      return {
-        where: {
-          expr,
-          condition: astNode.where ? parseWhereClause(astNode.where) : {
-            kind: { neq: "--always-true--" }
-          }
-        }
-      };
+      return this.parseFqnExprWhere(astNode);
     }
     parseElementPredicateWith(astNode) {
-      const expr = this.parseElementPredicate(astNode.subject);
-      const props = astNode.custom?.props ?? [];
-      return props.reduce(
-        (acc, prop) => {
-          if (!this.isValid(prop)) {
-            return acc;
-          }
-          if (ast.isNavigateToProperty(prop)) {
-            const viewId = prop.value.view.$refText;
-            if (isTruthy(viewId)) {
-              acc.custom.navigateTo = viewId;
-            }
-            return acc;
-          }
-          if (ast.isElementStringProperty(prop)) {
-            if (isDefined(prop.value)) {
-              acc.custom[prop.key] = removeIndent(prop.value) || "";
-            }
-            return acc;
-          }
-          if (ast.isIconProperty(prop)) {
-            const value = prop.libicon?.ref?.name ?? prop.value;
-            if (isDefined(value)) {
-              acc.custom[prop.key] = value;
-            }
-            return acc;
-          }
-          if (ast.isColorProperty(prop)) {
-            const value = toColor(prop);
-            if (isDefined(value)) {
-              acc.custom[prop.key] = value;
-            }
-            return acc;
-          }
-          if (ast.isShapeProperty(prop)) {
-            if (isDefined(prop.value)) {
-              acc.custom[prop.key] = prop.value;
-            }
-            return acc;
-          }
-          if (ast.isBorderProperty(prop)) {
-            if (isDefined(prop.value)) {
-              acc.custom[prop.key] = prop.value;
-            }
-            return acc;
-          }
-          if (ast.isOpacityProperty(prop)) {
-            if (isDefined(prop.value)) {
-              acc.custom[prop.key] = parseAstOpacityProperty(prop);
-            }
-            return acc;
-          }
-          if (ast.isNotationProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc.custom[prop.key] = removeIndent(prop.value);
-            }
-            return acc;
-          }
-          if (ast.isMultipleProperty(prop)) {
-            if (isBoolean(prop.value)) {
-              acc.custom[prop.key] = prop.value;
-            }
-            return acc;
-          }
-          if (ast.isShapeSizeProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc.custom[prop.key] = parseAstSizeValue(prop);
-            }
-            return acc;
-          }
-          if (ast.isTextSizeProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc.custom[prop.key] = parseAstSizeValue(prop);
-            }
-            return acc;
-          }
-          if (ast.isPaddingSizeProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc.custom[prop.key] = parseAstSizeValue(prop);
-            }
-            return acc;
-          }
-          nonexhaustive(prop);
-        },
-        {
-          custom: {
-            expr
-          }
-        }
-      );
+      return this.parseFqnExprWith(astNode);
     }
     parseRelationPredicate(astNode) {
-      if (ast.isRelationPredicateWith(astNode)) {
-        let relation = ast.isRelationPredicateWhere(astNode.subject) ? this.parseRelationPredicateWhere(astNode.subject) : this.parseRelationExpression(astNode.subject);
-        return this.parseRelationPredicateWith(astNode, relation);
-      }
-      if (ast.isRelationPredicateWhere(astNode)) {
-        return this.parseRelationPredicateWhere(astNode);
-      }
-      if (ast.isRelationExpression(astNode)) {
-        return this.parseRelationExpression(astNode);
-      }
-      nonexhaustive(astNode);
+      return this.parseRelationExprOrWith(astNode);
+    }
+    parseRelationPredicateOrWhere(astNode) {
+      return this.parseRelationExprOrWhere(astNode);
     }
     parseRelationPredicateWhere(astNode) {
-      const expr = this.parseRelationExpression(astNode.subject);
-      return {
-        where: {
-          expr,
-          condition: astNode.where ? parseWhereClause(astNode.where) : {
-            kind: { neq: "--always-true--" }
-          }
-        }
-      };
+      return this.parseRelationExprWhere(astNode);
     }
-    parseRelationPredicateWith(astNode, relation) {
-      const props = astNode.custom?.props ?? [];
-      return props.reduce(
-        (acc, prop) => {
-          if (ast.isRelationStringProperty(prop) || ast.isNotationProperty(prop) || ast.isNotesProperty(prop)) {
-            if (isDefined(prop.value)) {
-              acc.customRelation[prop.key] = removeIndent(prop.value) ?? "";
-            }
-            return acc;
-          }
-          if (ast.isArrowProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc.customRelation[prop.key] = prop.value;
-            }
-            return acc;
-          }
-          if (ast.isColorProperty(prop)) {
-            const value = toColor(prop);
-            if (isTruthy(value)) {
-              acc.customRelation[prop.key] = value;
-            }
-            return acc;
-          }
-          if (ast.isLineProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc.customRelation[prop.key] = prop.value;
-            }
-            return acc;
-          }
-          if (ast.isRelationNavigateToProperty(prop)) {
-            const viewId = prop.value.view.ref?.name;
-            if (isTruthy(viewId)) {
-              acc.customRelation.navigateTo = viewId;
-            }
-            return acc;
-          }
-          nonexhaustive(prop);
-        },
-        {
-          customRelation: {
-            relation
-          }
-        }
-      );
+    parseRelationPredicateWith(astNode) {
+      return this.parseRelationExprWith(astNode);
     }
     parseRelationExpression(astNode) {
-      if (ast.isDirectedRelationExpression(astNode)) {
-        return {
-          source: this.parseElementExpression(astNode.source.from),
-          target: this.parseElementExpression(astNode.target),
-          isBidirectional: astNode.source.isBidirectional
-        };
-      }
-      if (ast.isInOutRelationExpression(astNode)) {
-        return {
-          inout: this.parseElementExpression(astNode.inout.to)
-        };
-      }
-      if (ast.isOutgoingRelationExpression(astNode)) {
-        return {
-          outgoing: this.parseElementExpression(astNode.from)
-        };
-      }
-      if (ast.isIncomingRelationExpression(astNode)) {
-        return {
-          incoming: this.parseElementExpression(astNode.to)
-        };
-      }
-      nonexhaustive(astNode);
+      return this.parseRelationExpr(astNode);
     }
   };
 }

package/dist/model/parser/SpecificationParser.d.ts

@@ -10,6 +10,11 @@ export declare function SpecificationParser<TBase extends Base>(B: TBase): {
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        readonly project: {
+            id: c4.ProjectId;
+            folder: c4;
+            config: Readonly<import("../../config").ProjectConfig>;
+        };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
         getAstNodePath(node: c4): any;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
@@ -23,5 +28,8 @@ export declare function SpecificationParser<TBase extends Base>(B: TBase): {
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
         convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
         parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseIconProperty(prop: ast.IconProperty | undefined): c4.IconUrl | undefined;
+        parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
+        parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
     };
 } & TBase;

package/dist/model/parser/SpecificationParser.js

@@ -1,5 +1,5 @@
 import { filter, isNonNullish, isTruthy, mapToObj, pipe } from "remeda";
-import { ast, toElementStyle, toRelationshipStyleExcludeDefaults } from "../../ast.js";
+import { ast, toRelationshipStyleExcludeDefaults } from "../../ast.js";
 import { logger, logWarnError } from "../../logger.js";
 import { removeIndent } from "./Base.js";
 export function SpecificationParser(B) {
@@ -25,7 +25,7 @@ export function SpecificationParser(B) {
             logger.warn(`Element kind "${kindName}" is already defined`);
             continue;
           }
-          const style = props.find(ast.isElementStyleProperty);
+          const style = this.parseElementStyle(props.find(ast.isElementStyleProperty));
           const bodyProps = pipe(
             props.filter(ast.isSpecificationElementStringProperty) ?? [],
             filter((p) => this.isValid(p) && isNonNullish(p.value)),
@@ -33,9 +33,7 @@ export function SpecificationParser(B) {
           );
           c4Specification.elements[kindName] = {
             ...bodyProps,
-            style: {
-              ...toElementStyle(style?.props, this.isValid)
-            }
+            style
           };
         } catch (e) {
           logWarnError(e);
@@ -101,7 +99,7 @@ export function SpecificationParser(B) {
       if (!isTruthy(kindName)) {
         throw new Error("DeploymentNodeKind name is not resolved");
       }
-      const style = props.find(ast.isElementStyleProperty);
+      const style = this.parseElementStyle(props.find(ast.isElementStyleProperty));
       const bodyProps = pipe(
         props.filter(ast.isSpecificationElementStringProperty) ?? [],
         filter((p) => this.isValid(p) && isNonNullish(p.value)),
@@ -110,9 +108,7 @@ export function SpecificationParser(B) {
       return {
         [kindName]: {
           ...bodyProps,
-          style: {
-            ...toElementStyle(style?.props, this.isValid)
-          }
+          style
         }
       };
     }

package/dist/model/parser/ViewsParser.d.ts

@@ -1,5 +1,5 @@
 import type * as c4 from '@likec4/core';
-import { ast, type ParsedAstDynamicView, type ParsedAstElementView } from '../../ast';
+import { type ParsedAstDynamicView, type ParsedAstElementView, ast } from '../../ast';
 import type { NotationProperty } from '../../generated/ast';
 import type { WithDeploymentView } from './DeploymentViewParser';
 import type { WithPredicates } from './PredicatesParser';
@@ -14,26 +14,46 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ViewRuleStyleOrGlobalRef;
         parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ViewRuleGroup;
         parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ViewRuleStyle;
-        parseRuleStyle(styleProperties: ast.StyleProperty[], elementExpressionsIterator: ast.ElementExpressionsIterator, notationProperty?: NotationProperty): c4.ViewRuleStyle;
+        parseRuleStyle(styleProperties: ast.StyleProperty[], elementExpressionsIterator: ast.FqnExpressions, notationProperty?: NotationProperty): c4.ViewRuleStyle;
         parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle;
         parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: c4.ViewRuleStyleOrGlobalRef[]): ParsedAstDynamicView;
         parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule;
         parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule;
         parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicViewParallelSteps;
         parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicViewStep;
-        parsePredicate(astNode: ast.Predicate): c4.Expression;
-        parseElementPredicate(astNode: ast.ElementPredicate): c4.ElementPredicateExpression;
-        parseElementExpressionsIterator(astNode: ast.ElementExpressionsIterator): c4.ElementExpression[];
-        parseElementExpression(astNode: ast.ElementExpression): c4.ElementExpression;
-        parseElementPredicateWhere(astNode: ast.ElementPredicateWhere): c4.ElementWhereExpr;
-        parseElementPredicateWith(astNode: ast.ElementPredicateWith): c4.CustomElementExpr;
-        parseRelationPredicate(astNode: ast.RelationPredicate): c4.RelationPredicateExpression;
-        parseRelationPredicateWhere(astNode: ast.RelationPredicateWhere): c4.RelationWhereExpr;
-        parseRelationPredicateWith(astNode: ast.RelationPredicateWith, relation: c4.RelationExpression | c4.RelationWhereExpr): c4.CustomRelationExpr;
-        parseRelationExpression(astNode: ast.RelationExpression): c4.RelationExpression;
+        parsePredicate(astNode: ast.ExpressionV2): c4.ModelLayer.Expression;
+        parseElementPredicate(astNode: ast.FqnExprOrWith): c4.ModelLayer.AnyFqnExpr;
+        parseElementPredicateOrWhere(astNode: ast.FqnExprOrWhere): c4.ModelLayer.FqnExprOrWhere;
+        parseElementExpression(astNode: ast.FqnExpr): c4.ModelLayer.FqnExpr;
+        parseElementPredicateWhere(astNode: ast.FqnExprWhere): c4.ModelLayer.FqnExpr.Where;
+        parseElementPredicateWith(astNode: ast.FqnExprWith): c4.ModelLayer.FqnExpr.Custom;
+        parseRelationPredicate(astNode: ast.RelationExprOrWith): c4.ModelLayer.AnyRelationExpr;
+        parseRelationPredicateOrWhere(astNode: ast.RelationExprOrWhere): c4.ModelLayer.RelationExprOrWhere;
+        parseRelationPredicateWhere(astNode: ast.RelationExprWhere): c4.ModelLayer.RelationExpr.Where;
+        parseRelationPredicateWith(astNode: ast.RelationExprWith): c4.ModelLayer.RelationExpr.Custom;
+        parseRelationExpression(astNode: ast.RelationExpr): c4.ModelLayer.RelationExpr;
+        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
+        parseExpressionV2(astNode: ast.ExpressionV2): c4.ExpressionV2;
+        parseFqnExprOrWith(astNode: ast.FqnExprOrWith): c4.FqnExpr.Any;
+        parseFqnExprWith(astNode: ast.FqnExprWith): c4.FqnExpr.Custom;
+        parseFqnExprOrWhere(astNode: ast.FqnExprOrWhere): c4.FqnExpr.OrWhere;
+        parseFqnExprWhere(astNode: ast.FqnExprWhere): c4.FqnExpr.Where;
+        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
+        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
+        parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
+        parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
+        parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        readonly project: {
+            id: c4.ProjectId;
+            folder: c4;
+            config: Readonly<import("../../config").ProjectConfig>;
+        };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
         getAstNodePath(node: c4): any;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
@@ -47,21 +67,18 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
         convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
         parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseIconProperty(prop: ast.IconProperty | undefined): c4.IconUrl | undefined;
+        parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
+        parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
         parseDeploymentView(astNode: ast.DeploymentView): import("../../ast").ParsedAstDeploymentView;
         parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule;
         parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewRulePredicate;
         parseDeploymentViewRuleStyle(astRule: ast.DeploymentViewRuleStyle): c4.DeploymentViewRuleStyle;
-        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
-        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
-        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
-        parseElementWhereExpr(astNode: ast.ElementPredicateWhereV2): c4.RelationExpr;
-        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
-        parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
-        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
         parseDeployment(): void;
         parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
         parseExtendDeployment(astNode: ast.ExtendDeployment): import("../../ast").ParsedAstExtend | null;
+        _resolveDeploymentRelationSource(node: ast.DeploymentRelation): c4;
         parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
     };
 } & TBase;

package/dist/model/parser/ViewsParser.js

@@ -1,10 +1,9 @@
-import { invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
+import { invariant, isNonEmptyArray, ModelLayer, nonexhaustive } from "@likec4/core";
 import { isArray, isDefined, isNonNullish, isTruthy } from "remeda";
 import {
   ast,
   toAutoLayout,
   toColor,
-  toElementStyle,
   ViewOps
 } from "../../ast.js";
 import { logger, logWarnError } from "../../logger.js";
@@ -128,12 +127,13 @@ export function ViewsParser(B) {
     }
     parseViewRulePredicate(astNode) {
       const exprs = [];
-      let predicate = astNode.predicates;
+      let predicate = astNode.exprs;
       while (predicate) {
         const { value, prev } = predicate;
         try {
           if (isTruthy(value) && this.isValid(value)) {
-            exprs.unshift(this.parsePredicate(value));
+            const expr = this.parsePredicate(value);
+            exprs.unshift(expr);
           }
         } catch (e) {
           logWarnError(e);
@@ -143,7 +143,7 @@ export function ViewsParser(B) {
         }
         predicate = prev;
       }
-      return ast.isIncludePredicate(astNode) ? { include: exprs } : { exclude: exprs };
+      return astNode.isInclude ? { include: exprs } : { exclude: exprs };
     }
     parseViewRuleGlobalPredicateRef(astRule) {
       return {
@@ -182,19 +182,21 @@ export function ViewsParser(B) {
       return {
         title: toSingleLine(astNode.title) ?? null,
         groupRules,
-        ...toElementStyle(astNode.props, this.isValid)
+        ...this.parseStyleProps(astNode.props)
       };
     }
     parseViewRuleStyle(astRule) {
       const styleProps = astRule.props.filter(ast.isStyleProperty);
-      const targets = astRule.target;
+      const targets = astRule.targets;
       const notation = astRule.props.find(ast.isNotationProperty);
       return this.parseRuleStyle(styleProps, targets, notation);
     }
     parseRuleStyle(styleProperties, elementExpressionsIterator, notationProperty) {
-      const styleProps = toElementStyle(styleProperties, this.isValid);
+      const styleProps = this.parseStyleProps(styleProperties);
       const notation = removeIndent(notationProperty?.value);
-      const targets = this.parseElementExpressionsIterator(elementExpressionsIterator);
+      const targets = this.parseFqnExpressions(elementExpressionsIterator).filter(
+        (e) => ModelLayer.Expression.isFqnExpr(e)
+      );
       return {
         targets,
         ...notation && { notation },
@@ -280,12 +282,14 @@ export function ViewsParser(B) {
     }
     parseDynamicViewIncludePredicate(astRule) {
       const include = [];
-      let iter = astRule.predicates;
+      let iter = astRule.exprs;
       while (iter) {
         try {
           if (isNonNullish(iter.value) && this.isValid(iter.value)) {
-            const c4expr = this.parseElementPredicate(iter.value);
-            include.unshift(c4expr);
+            if (ast.isFqnExprOrWith(iter.value)) {
+              const c4expr = this.parseElementPredicate(iter.value);
+              include.unshift(c4expr);
+            }
           }
         } catch (e) {
           logWarnError(e);

package/dist/model-change/changeElementStyle.d.ts

@@ -1,6 +1,6 @@
 import { type Fqn, type NonEmptyArray, type ViewChange } from '@likec4/core';
 import { type Range, TextEdit } from 'vscode-languageserver-types';
-import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast';
+import { type ParsedAstView, type ParsedLikeC4LangiumDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
 type ChangeElementStyleArg = {
     view: ParsedAstView;
@@ -9,7 +9,7 @@ type ChangeElementStyleArg = {
     targets: NonEmptyArray<Fqn>;
     style: ViewChange.ChangeElementStyle['style'];
 };
-export declare function changeElementStyle(services: LikeC4Services, { view, viewAst, targets, style }: ChangeElementStyleArg): {
+export declare function changeElementStyle(services: LikeC4Services, { view, viewAst, targets, style, }: ChangeElementStyleArg): {
     modifiedRange: Range;
     edits: TextEdit[];
 };