@likec4/language-server 1.27.3 → 1.28.0

package/dist/model/parser/Base.js

@@ -1,7 +1,26 @@
-import { isNonEmptyArray } from "@likec4/core";
-import { filter, flatMap, fromEntries, isEmpty, isNonNullish, isTruthy, map, pipe, unique } from "remeda";
+import { GlobalFqn, isNonEmptyArray, nonexhaustive, nonNullable } from "@likec4/core";
+import {
+  filter,
+  flatMap,
+  fromEntries,
+  isArray,
+  isBoolean,
+  isEmpty,
+  isNonNullish,
+  isTruthy,
+  map,
+  pipe,
+  unique
+} from "remeda";
 import stripIndent from "strip-indent";
-import { ast } from "../../ast.js";
+import { hasLeadingSlash, hasProtocol, isRelative, joinRelativeURL, joinURL } from "ufo";
+import {
+  ast,
+  parseAstOpacityProperty,
+  parseAstSizeValue,
+  toColor
+} from "../../ast.js";
+import { projectIdFrom } from "../../utils/index.js";
 import { readStrictFqn } from "../../utils/elementRef.js";
 import { checksFromDiagnostics } from "../../validation/index.js";
 export function toSingleLine(str) {
@@ -17,7 +36,18 @@ export class BaseParser {
     this.isValid = checksFromDiagnostics(doc).isValid;
   }
   isValid;
+  get project() {
+    return this.services.shared.workspace.ProjectsManager.getProject(this.doc);
+  }
   resolveFqn(node) {
+    if (ast.isImported(node)) {
+      const project = projectIdFrom(node);
+      const fqn = this.resolveFqn(
+        nonNullable(node.imported.ref, `FqnRef is empty of imported: ${node.$cstNode?.text}`)
+      );
+      this.doc.c4Imports.set(project, fqn);
+      return GlobalFqn(project, fqn);
+    }
     if (ast.isExtendElement(node)) {
       return readStrictFqn(node.element);
     }
@@ -96,4 +126,109 @@ export class BaseParser {
       })
     );
   }
+  parseIconProperty(prop) {
+    if (!prop || !this.isValid(prop)) {
+      return void 0;
+    }
+    const { libicon, value } = prop;
+    switch (true) {
+      case !!libicon: {
+        return libicon.ref?.name;
+      }
+      case (value && hasProtocol(value)): {
+        return value;
+      }
+      case (value && isRelative(value)): {
+        return joinRelativeURL(this.doc.uri.toString(), "../", value);
+      }
+      case (value && hasLeadingSlash(value)): {
+        return joinURL(this.project.folder.toString(), value);
+      }
+      default: {
+        return void 0;
+      }
+    }
+  }
+  parseElementStyle(elementProps) {
+    if (!elementProps) {
+      return {};
+    }
+    if (isArray(elementProps)) {
+      const style = this.parseStyleProps(elementProps?.find(ast.isElementStyleProperty)?.props);
+      const iconProp = this.parseIconProperty(elementProps?.find(ast.isIconProperty));
+      if (iconProp) {
+        style.icon = iconProp;
+      }
+      return style;
+    }
+    return this.parseStyleProps(elementProps.props);
+  }
+  parseStyleProps(styleProps) {
+    const result = {};
+    if (!styleProps || styleProps.length === 0) {
+      return result;
+    }
+    for (const prop of styleProps) {
+      if (!this.isValid(prop)) {
+        continue;
+      }
+      switch (true) {
+        case ast.isBorderProperty(prop): {
+          if (isTruthy(prop.value)) {
+            result.border = prop.value;
+          }
+          break;
+        }
+        case ast.isColorProperty(prop): {
+          const color = toColor(prop);
+          if (isTruthy(color)) {
+            result.color = color;
+          }
+          break;
+        }
+        case ast.isShapeProperty(prop): {
+          if (isTruthy(prop.value)) {
+            result.shape = prop.value;
+          }
+          break;
+        }
+        case ast.isIconProperty(prop): {
+          const icon = this.parseIconProperty(prop);
+          if (isTruthy(icon)) {
+            result.icon = icon;
+          }
+          break;
+        }
+        case ast.isOpacityProperty(prop): {
+          result.opacity = parseAstOpacityProperty(prop);
+          break;
+        }
+        case ast.isMultipleProperty(prop): {
+          result.multiple = isBoolean(prop.value) ? prop.value : false;
+          break;
+        }
+        case ast.isShapeSizeProperty(prop): {
+          if (isTruthy(prop.value)) {
+            result.size = parseAstSizeValue(prop);
+          }
+          break;
+        }
+        case ast.isPaddingSizeProperty(prop): {
+          if (isTruthy(prop.value)) {
+            result.padding = parseAstSizeValue(prop);
+          }
+          break;
+        }
+        case ast.isTextSizeProperty(prop): {
+          if (isTruthy(prop.value)) {
+            result.textSize = parseAstSizeValue(prop);
+          }
+          break;
+        }
+        default:
+          nonexhaustive(prop);
+      }
+    }
+    return result;
+  }
 }

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

@@ -1,4 +1,5 @@
 import type * as c4 from '@likec4/core';
+import { FqnRef } from '@likec4/core';
 import { type ParsedAstDeployment, type ParsedAstDeploymentRelation, type ParsedAstExtend, ast } from '../../ast';
 import type { WithExpressionV2 } from './FqnRefParser';
 export type WithDeploymentModel = ReturnType<typeof DeploymentModelParser>;
@@ -8,17 +9,30 @@ export declare function DeploymentModelParser<TBase extends WithExpressionV2>(B:
         parseDeploymentNode(astNode: ast.DeploymentNode): ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: ast.DeployedInstance): ParsedAstDeployment.Instance;
         parseExtendDeployment(astNode: ast.ExtendDeployment): ParsedAstExtend | null;
+        _resolveDeploymentRelationSource(node: ast.DeploymentRelation): FqnRef;
         parseDeploymentRelation(astNode: ast.DeploymentRelation): ParsedAstDeploymentRelation;
         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;
-        parseElementWhereExpr(astNode: ast.ElementPredicateWhereV2): c4.RelationExpr;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
-        parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
+        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): {
@@ -32,5 +46,8 @@ export declare function DeploymentModelParser<TBase extends WithExpressionV2>(B:
         }>(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/DeploymentModelParser.js

@@ -1,12 +1,10 @@
-import { FqnRef, isNonEmptyArray, LinkedList, nameFromFqn, nonexhaustive, nonNullable } from "@likec4/core";
-import { filter, first, isEmpty, isTruthy, map, mapToObj, pipe } from "remeda";
+import { FqnRef, invariant, isNonEmptyArray, LinkedList, nameFromFqn, nonexhaustive, nonNullable } from "@likec4/core";
+import { filter, first, isDefined, isEmpty, isTruthy, map, mapToObj, pipe } from "remeda";
 import {
   ast,
-  toElementStyle,
   toRelationshipStyleExcludeDefaults
 } from "../../ast.js";
 import { logWarnError } from "../../logger.js";
-import { elementRef } from "../../utils/elementRef.js";
 import { stringHash } from "../../utils/stringHash.js";
 import { removeIndent, toSingleLine } from "./Base.js";
 function* streamDeploymentModel(doc) {
@@ -20,10 +18,6 @@ function* streamDeploymentModel(doc) {
       relations.push(el);
       continue;
     }
-    if (ast.isDeployedInstance(el)) {
-      yield el;
-      continue;
-    }
     if (el.body && el.body.elements.length > 0) {
       for (const child of el.body.elements) {
         traverseStack.push(child);
@@ -74,8 +68,7 @@ export function DeploymentModelParser(B) {
       const id = this.resolveFqn(astNode);
       const kind = nonNullable(astNode.kind.ref, "DeploymentKind not resolved").name;
       const tags = this.convertTags(astNode.body);
-      const stylePropsAst = astNode.body?.props.find(ast.isElementStyleProperty)?.props;
-      const style = toElementStyle(stylePropsAst, isValid);
+      const style = this.parseElementStyle(astNode.body?.props);
       const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
       const bodyProps = pipe(
         astNode.body?.props ?? [],
@@ -87,13 +80,6 @@ export function DeploymentModelParser(B) {
       const description = removeIndent(bodyProps.description);
       const technology = toSingleLine(bodyProps.technology);
       const links = this.convertLinks(astNode.body);
-      const iconProp = astNode.body?.props.find(ast.isIconProperty);
-      if (iconProp && isValid(iconProp)) {
-        const value = iconProp.libicon?.ref?.name ?? iconProp.value;
-        if (isTruthy(value)) {
-          style.icon = value;
-        }
-      }
       return {
         id,
         kind,
@@ -109,10 +95,10 @@ export function DeploymentModelParser(B) {
     parseDeployedInstance(astNode) {
       const isValid = this.isValid;
       const id = this.resolveFqn(astNode);
-      const element = this.resolveFqn(nonNullable(elementRef(astNode.element), "DeployedInstance element not found"));
+      const target = this.parseFqnRef(astNode.target.modelElement);
+      invariant(FqnRef.isModelRef(target) || FqnRef.isImportRef(target), "Target must be a model reference");
       const tags = this.convertTags(astNode.body);
-      const stylePropsAst = astNode.body?.props.find(ast.isElementStyleProperty)?.props;
-      const style = toElementStyle(stylePropsAst, isValid);
+      const style = this.parseElementStyle(astNode.body?.props);
       const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
       const bodyProps = pipe(
         astNode.body?.props ?? [],
@@ -124,16 +110,9 @@ export function DeploymentModelParser(B) {
       const description = removeIndent(bodyProps.description);
       const technology = toSingleLine(bodyProps.technology);
       const links = this.convertLinks(astNode.body);
-      const iconProp = astNode.body?.props.find(ast.isIconProperty);
-      if (iconProp && isValid(iconProp)) {
-        const value = iconProp.libicon?.ref?.name ?? iconProp.value;
-        if (isTruthy(value)) {
-          style.icon = value;
-        }
-      }
       return {
         id,
-        element,
+        element: target,
         ...metadata && { metadata },
         ...title && { title },
         ...tags && { tags },
@@ -163,10 +142,21 @@ export function DeploymentModelParser(B) {
         ...links && isNonEmptyArray(links) && { links }
       };
     }
+    _resolveDeploymentRelationSource(node) {
+      if (isDefined(node.source)) {
+        return this.parseFqnRef(node.source);
+      }
+      if (node.$container.$type === "DeploymentNodeBody" || node.$container.$type === "DeployedInstanceBody") {
+        return {
+          deployment: this.resolveFqn(node.$container.$container)
+        };
+      }
+      throw new Error("RelationRefError: Invalid container for sourceless relation");
+    }
     parseDeploymentRelation(astNode) {
       const isValid = this.isValid;
       const astPath = this.getAstNodePath(astNode);
-      const source = FqnRef.toDeploymentRef(this.parseFqnRef(astNode.source));
+      const source = FqnRef.toDeploymentRef(this._resolveDeploymentRelationSource(astNode));
       const target = FqnRef.toDeploymentRef(this.parseFqnRef(astNode.target));
       const tags = this.convertTags(astNode) ?? this.convertTags(astNode.body);
       const links = this.convertLinks(astNode.body);

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

@@ -10,15 +10,27 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewRulePredicate;
         parseDeploymentViewRuleStyle(astRule: ast.DeploymentViewRuleStyle): c4.DeploymentViewRuleStyle;
         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;
-        parseElementWhereExpr(astNode: ast.ElementPredicateWhereV2): c4.RelationExpr;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
-        parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
+        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): {
@@ -32,10 +44,14 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         }>(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;
         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/DeploymentViewParser.js

@@ -1,6 +1,6 @@
 import { invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
 import { isNonNullish } from "remeda";
-import { ast, toAutoLayout, toElementStyle, ViewOps } from "../../ast.js";
+import { ast, toAutoLayout, ViewOps } from "../../ast.js";
 import { logWarnError } from "../../logger.js";
 import { stringHash } from "../../utils/index.js";
 import { parseViewManualLayout } from "../../view-utils/manual-layout.js";
@@ -63,22 +63,7 @@ export function DeploymentViewParser(B) {
         try {
           const expr = iterator.value;
           if (isNonNullish(expr) && this.isValid(expr)) {
-            switch (true) {
-              case ast.isFqnExpr(expr):
-                exprs.unshift(this.parseFqnExpr(expr));
-                break;
-              case ast.isElementPredicateWhereV2(expr):
-                exprs.unshift(this.parseElementWhereExpr(expr));
-                break;
-              case ast.isRelationExpr(expr):
-                exprs.unshift(this.parseRelationExpr(expr));
-                break;
-              case ast.isRelationPredicateWhereV2(expr):
-                exprs.unshift(this.parseRelationWhereExpr(expr));
-                break;
-              default:
-                nonexhaustive(expr);
-            }
+            exprs.unshift(this.parseExpressionV2(expr));
           }
         } catch (e) {
           logWarnError(e);
@@ -88,16 +73,13 @@ export function DeploymentViewParser(B) {
       return astRule.isInclude ? { include: exprs } : { exclude: exprs };
     }
     parseDeploymentViewRuleStyle(astRule) {
-      const styleProps = astRule.props.filter(ast.isStyleProperty);
-      const notationProperty = astRule.props.find(ast.isNotationProperty);
-      const notation = removeIndent(notationProperty?.value);
+      const style = this.parseStyleProps(astRule.props.filter(ast.isStyleProperty));
+      const notation = removeIndent(astRule.props.find(ast.isNotationProperty)?.value);
       const targets = this.parseFqnExpressions(astRule.targets);
       return {
         targets,
-        ...notation && { notation },
-        style: {
-          ...toElementStyle(styleProps, this.isValid)
-        }
+        style,
+        ...notation && { notation }
       };
     }
   };

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

@@ -1,19 +1,31 @@
 import type * as c4 from '@likec4/core';
 import { ast } from '../../ast';
-import type { Base } from './Base';
+import { type Base } from './Base';
 export type WithExpressionV2 = ReturnType<typeof ExpressionV2Parser>;
 export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
     new (...args: any[]): {
         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;
-        parseElementWhereExpr(astNode: ast.ElementPredicateWhereV2): c4.RelationExpr;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
-        parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
+        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): {
@@ -27,5 +39,8 @@ export declare function ExpressionV2Parser<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;