@likec4/language-server 1.42.1 → 1.43.0

package/dist/lsp/SemanticTokenProvider.d.ts

@@ -1,7 +1,12 @@
 import type { AstNode } from 'langium';
 import { type SemanticTokenAcceptor, AbstractSemanticTokenProvider } from 'langium/lsp';
+import type { LikeC4Services } from '../module';
 export declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
+    private rules;
+    constructor(services: LikeC4Services);
+    protected initRules(): void;
     protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
     private highlightNameAndKind;
     private highlightView;
+    private mark;
 }

package/dist/lsp/SemanticTokenProvider.mjs

@@ -1,350 +1,276 @@
-import { AbstractSemanticTokenProvider } from "langium/lsp";
+import { invariant, isAnyOf, nonNullable } from "@likec4/core/utils";
+import {
+  AbstractSemanticTokenProvider
+} from "langium/lsp";
 import { isTruthy } from "remeda";
 import { SemanticTokenModifiers, SemanticTokenTypes } from "vscode-languageserver-types";
 import { ast } from "../ast.mjs";
+import { logger } from "../logger.mjs";
+const SemanticTypes = { ...SemanticTokenTypes };
+const SemanticModifiers = { ...SemanticTokenModifiers };
+function createSemanticTypeMethods(applyHighlight) {
+  const modifier = [];
+  const self = new Proxy({}, {
+    get(_, prop) {
+      if (prop === "modifier") {
+        return (mod) => {
+          modifier.push(mod);
+          return self;
+        };
+      }
+      if (prop in SemanticModifiers) {
+        modifier.push(SemanticModifiers[prop]);
+        return self;
+      }
+      if (prop in SemanticTypes) {
+        return () => applyHighlight(SemanticTypes[prop], modifier);
+      }
+      throw new Error(`Unknown semantic token type or modifier: ${prop}`);
+    }
+  });
+  return self;
+}
+const PRUNE = "Stop Highlighting";
+const stopHighlight = () => {
+  throw PRUNE;
+};
 export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+  rules = [];
+  constructor(services) {
+    super(services);
+    this.initRules();
+  }
+  initRules() {
+    this.rules = [];
+    const when = (predicate, highlightFn) => {
+      const rule = { predicate, highlightFn };
+      this.rules.push(rule);
+    };
+    when(ast.isRelationshipKind, (mark) => {
+      mark.property("name").function();
+    });
+    when(isAnyOf(ast.isRelation, ast.isOutgoingRelationExpr, ast.isDeploymentRelation), (mark) => {
+      mark.property("kind").function();
+    });
+    when(ast.isLibIcon, (mark) => {
+      mark.property("name").definition.function();
+      stopHighlight();
+    });
+    when(isAnyOf(ast.isNavigateToProperty, ast.isRelationNavigateToProperty), (mark) => {
+      mark.property("value").readonly.definition.interface();
+      stopHighlight();
+    });
+    when(isAnyOf(ast.isFqnRefExpr, ast.isWildcardExpression), (mark) => {
+      mark.cst().readonly.definition.variable();
+      stopHighlight();
+    });
+    when(ast.isTagRef, (mark) => {
+      mark.cst().type();
+      stopHighlight();
+    });
+    when(ast.isRelationKindDotRef, (mark) => {
+      mark.cst().function();
+      stopHighlight();
+    });
+    when(ast.isWhereRelationKind, (mark) => {
+      if (isTruthy(mark.node.value)) {
+        mark.property("value").function();
+      }
+    });
+    when(isAnyOf(ast.isWhereElement, ast.isWhereRelation), (mark) => {
+      if (isTruthy(mark.node.value)) {
+        mark.property("value").readonly.definition.type();
+      }
+    });
+    when(isAnyOf(ast.isWhereRelationParticipantKind, ast.isWhereRelationParticipantTag), (mark) => {
+      mark.property("participant").keyword();
+    });
+    when(ast.isElementKindExpression, (mark) => {
+      if (isTruthy(mark.node.kind)) {
+        mark.property("kind").definition.type();
+      }
+    });
+    when(isAnyOf(ast.isGlobalStyleGroup, ast.isGlobalStyle), (mark) => {
+      mark.property("id").readonly.definition.variable();
+    });
+    when(ast.isViewRuleGlobalStyle, (mark) => {
+      mark.property("style").readonly.definition.variable();
+    });
+    when(isAnyOf(ast.isGlobalPredicateGroup, ast.isGlobalDynamicPredicateGroup), (mark) => {
+      mark.property("name").readonly.definition.variable();
+    });
+    when(ast.isViewRuleGlobalPredicateRef, (mark) => {
+      mark.property("predicate").readonly.definition.variable();
+    });
+    when(ast.isElementTagExpression, (mark) => {
+      if (isTruthy(mark.node.tag)) {
+        mark.property("tag").definition.type();
+      }
+    });
+    when(isAnyOf(ast.isFqnRef, ast.isStrictFqnRef), (mark) => {
+      mark.property("value").readonly.definition.variable();
+      if (!mark.node.parent) {
+        stopHighlight();
+      }
+    });
+    when(ast.isStrictFqnElementRef, (mark) => {
+      mark.property("el").readonly.definition.variable();
+      if (!mark.node.parent) {
+        stopHighlight();
+      }
+    });
+    when(ast.isSpecificationColor, (mark) => {
+      mark.keyword("color").keyword();
+      mark.property("name").readonly.declaration.type();
+    });
+    when(ast.isSpecificationTag, (mark) => {
+      if (isTruthy(mark.node.color)) {
+        mark.keyword("color").property();
+      }
+    });
+    when(
+      isAnyOf(
+        ast.isSpecificationElementKind,
+        ast.isSpecificationRelationshipKind,
+        ast.isSpecificationDeploymentNodeKind
+      ),
+      (mark) => {
+        mark.property("kind").readonly.declaration.type();
+      }
+    );
+    when(ast.isTag, (mark) => {
+      mark.property("name").definition.type();
+    });
+    when(ast.isOpacityProperty, (mark) => {
+      mark.property("value").number();
+    });
+    when(ast.isIconProperty, (mark) => {
+      if (mark.node.libicon || mark.node.value === "none") {
+        mark.property(mark.node.libicon ? "libicon" : "value").defaultLibrary.enum();
+        return;
+      }
+      mark.property("value").string();
+    });
+    when(ast.isLinkProperty, (mark) => {
+      if (isTruthy(mark.node.value)) {
+        mark.property("value").string();
+      }
+    });
+    when(ast.isColorProperty, (mark) => {
+      if (isTruthy(mark.node.customColor)) {
+        mark.property("customColor").enum();
+      }
+      if (isTruthy(mark.node.themeColor)) {
+        mark.property("themeColor").enum();
+      }
+    });
+    when(
+      isAnyOf(
+        ast.isShapeProperty,
+        ast.isArrowProperty,
+        ast.isLineProperty,
+        ast.isBorderProperty,
+        ast.isSizeProperty,
+        ast.isDynamicViewDisplayVariantProperty
+      ),
+      (mark) => {
+        if (isTruthy(mark.node.value)) {
+          mark.property("value").enum();
+        }
+      }
+    );
+  }
   highlightElement(node, acceptor) {
-    if (ast.isElement(node) || ast.isDeploymentNode(node) || ast.isDeployedInstance(node)) {
-      return this.highlightNameAndKind(node, acceptor);
-    }
-    if (ast.isLikeC4View(node)) {
-      return this.highlightView(node, acceptor);
-    }
-    if (ast.isRelationshipKind(node)) {
-      return acceptor({
-        node,
-        property: "name",
-        type: SemanticTokenTypes.function
-      });
-    }
-    if (ast.isLibIcon(node)) {
-      acceptor({
-        node,
-        property: "name",
-        type: SemanticTokenTypes.type,
-        modifier: [SemanticTokenModifiers.definition]
-      });
-      return "prune";
-    }
-    if ((ast.isRelation(node) || ast.isOutgoingRelationExpr(node) || ast.isDeploymentRelation(node)) && "kind" in node) {
-      acceptor({
-        node,
-        property: "kind",
-        type: SemanticTokenTypes.function
-      });
-    }
-    if (ast.isNavigateToProperty(node) || ast.isRelationNavigateToProperty(node)) {
-      acceptor({
-        node,
-        property: "key",
-        type: SemanticTokenTypes.property
-      });
-      acceptor({
-        node,
-        property: "value",
-        type: SemanticTokenTypes.interface,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-      return "prune";
-    }
-    if (ast.isFqnRefExpr(node) || ast.isWildcardExpression(node)) {
-      acceptor({
-        cst: node.$cstNode,
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-      return "prune";
-    }
-    if (ast.isRelationKindDotRef(node)) {
-      acceptor({
-        cst: node.$cstNode,
-        type: SemanticTokenTypes.function
-      });
-      return "prune";
-    }
-    if (ast.isWhereRelationKind(node) && isTruthy(node.value)) {
-      acceptor({
-        node,
-        property: "value",
-        type: SemanticTokenTypes.function
-      });
-      return;
-    }
-    if ((ast.isWhereElement(node) || ast.isWhereRelation(node)) && isTruthy(node.value)) {
-      acceptor({
-        node,
-        property: "value",
-        type: SemanticTokenTypes.type,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-      return;
-    }
-    if (ast.isWhereRelationParticipantKind(node) || ast.isWhereRelationParticipantTag(node)) {
-      acceptor({
-        node,
-        property: "participant",
-        type: SemanticTokenTypes.keyword
-      });
-    }
-    if (ast.isElementKindExpression(node) && isTruthy(node.kind)) {
-      acceptor({
-        node,
-        property: "kind",
-        type: SemanticTokenTypes.type,
-        modifier: [SemanticTokenModifiers.definition]
-      });
-      return;
-    }
-    if (ast.isGlobalStyleGroup(node) || ast.isGlobalStyle(node)) {
-      acceptor({
-        node,
-        property: "id",
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-      return;
-    }
-    if (ast.isViewRuleGlobalStyle(node)) {
-      acceptor({
-        node,
-        property: "style",
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-      return;
-    }
-    if (ast.isGlobalPredicateGroup(node) || ast.isGlobalDynamicPredicateGroup(node)) {
-      acceptor({
-        node,
-        property: "name",
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-      return;
-    }
-    if (ast.isViewRuleGlobalPredicateRef(node)) {
-      acceptor({
-        node,
-        property: "predicate",
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-      return;
-    }
-    if (ast.isElementTagExpression(node) && isTruthy(node.tag)) {
-      acceptor({
-        node,
-        property: "tag",
-        type: SemanticTokenTypes.type,
-        modifier: [SemanticTokenModifiers.definition]
-      });
-      return;
-    }
-    if (ast.isFqnRef(node) || ast.isStrictFqnRef(node)) {
-      acceptor({
-        node,
-        property: "value",
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-      return !node.parent ? "prune" : void 0;
-    }
-    if (ast.isStrictFqnElementRef(node)) {
-      acceptor({
-        node,
-        property: "el",
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-      return !node.parent ? "prune" : void 0;
-    }
-    if (ast.isSpecificationColor(node)) {
-      acceptor({
-        node,
-        keyword: "color",
-        type: SemanticTokenTypes.keyword
-      });
-      acceptor({
-        node,
-        property: "name",
-        type: SemanticTokenTypes.type,
-        modifier: [
-          SemanticTokenModifiers.declaration,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-      return;
-    }
-    if (ast.isSpecificationTag(node) && isTruthy(node.color)) {
-      acceptor({
-        node,
-        keyword: "color",
-        type: SemanticTokenTypes.property
-      });
-      return;
-    }
-    if (ast.isSpecificationElementKind(node) || ast.isSpecificationRelationshipKind(node) || ast.isSpecificationDeploymentNodeKind(node)) {
-      acceptor({
-        node,
-        property: "kind",
-        type: SemanticTokenTypes.type,
-        modifier: [
-          SemanticTokenModifiers.declaration,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-    }
-    if (ast.isTagRef(node)) {
-      acceptor({
-        cst: node.$cstNode,
-        type: SemanticTokenTypes.type
-      });
-      return "prune";
-    }
-    if (ast.isTag(node)) {
-      return acceptor({
-        node,
-        property: "name",
-        type: SemanticTokenTypes.type,
-        modifier: [SemanticTokenModifiers.definition]
-      });
-    }
-    if (ast.isRelationStyleProperty(node) || ast.isElementStyleProperty(node)) {
-      acceptor({
-        node,
-        property: "key",
-        type: SemanticTokenTypes.property
-      });
-    }
-    if (ast.isOpacityProperty(node)) {
-      acceptor({
-        node,
-        property: "key",
-        type: SemanticTokenTypes.property
-      });
-      acceptor({
-        node,
-        property: "value",
-        type: SemanticTokenTypes.number
-      });
-      return "prune";
-    }
-    if (ast.isLinkProperty(node) || ast.isIconProperty(node) || ast.isStringProperty(node)) {
-      acceptor({
-        node,
-        property: "key",
-        type: SemanticTokenTypes.property
-      });
-      if (ast.isIconProperty(node) && (node.libicon || node.value === "none")) {
-        acceptor({
-          node,
-          property: node.libicon ? "libicon" : "value",
-          type: SemanticTokenTypes.enum,
-          modifier: [SemanticTokenModifiers.defaultLibrary]
-        });
-        return "prune";
+    try {
+      if (isAnyOf(ast.isElement, ast.isDeploymentNode, ast.isDeployedInstance)(node)) {
+        return this.highlightNameAndKind(node);
       }
-      if ("value" in node && node.value && !ast.isStringProperty(node)) {
-        acceptor({
-          node,
-          property: "value",
-          type: SemanticTokenTypes.string
-        });
+      if (ast.isLikeC4View(node)) {
+        return this.highlightView(node);
       }
-      return "prune";
-    }
-    if (ast.isColorProperty(node) || ast.isShapeProperty(node) || ast.isArrowProperty(node) || ast.isLineProperty(node) || ast.isBorderProperty(node) || ast.isSizeProperty(node) || ast.isDynamicViewDisplayVariantProperty(node)) {
-      acceptor({
-        node,
-        property: "key",
-        type: SemanticTokenTypes.property
-      });
-      if ("value" in node) {
+      if (ast.isAnyProperty(node) && !isAnyOf(
+        ast.isMetadataProperty,
+        ast.isElementStyleProperty,
+        ast.isRelationStyleProperty
+      )(node)) {
+        invariant(node.key);
         acceptor({
           node,
-          property: "value",
-          type: SemanticTokenTypes.enum
+          property: "key",
+          type: SemanticTokenTypes.property
         });
       }
-      return "prune";
+      for (const { predicate, highlightFn } of this.rules) {
+        if (predicate(node)) {
+          highlightFn(this.mark(node));
+          break;
+        }
+      }
+    } catch (error) {
+      if (error === PRUNE) {
+        return "prune";
+      }
+      logger.warn(`Error highlighting node of type ${node._type}`, { error });
     }
   }
-  highlightNameAndKind(node, acceptor) {
-    acceptor({
-      node,
-      property: "name",
-      type: SemanticTokenTypes.variable,
-      modifier: [
-        SemanticTokenModifiers.declaration,
-        SemanticTokenModifiers.readonly
-      ]
-    });
+  highlightNameAndKind(node) {
+    const mark = this.mark(node);
+    mark.property("name").declaration.readonly.variable();
     if (!ast.isDeployedInstance(node)) {
-      acceptor({
-        node,
-        property: "kind",
-        type: SemanticTokenTypes.keyword,
-        modifier: []
-      });
+      this.mark(node).property("kind").keyword();
     }
     if (ast.isElement(node)) {
       if (node.props.length > 0) {
-        acceptor({
-          node,
-          property: "props",
-          type: SemanticTokenTypes.string
-        });
+        this.mark(node).property("props").string();
       }
       return;
     }
     if (node.title) {
-      acceptor({
-        node,
-        property: "title",
-        type: SemanticTokenTypes.string
-      });
+      this.mark(node).property("title").string();
     }
   }
-  highlightView(node, acceptor) {
+  highlightView(node) {
     if (node.name) {
-      acceptor({
-        node,
-        property: "name",
-        type: SemanticTokenTypes.interface,
-        modifier: [
-          SemanticTokenModifiers.declaration,
-          SemanticTokenModifiers.readonly,
-          "local"
-        ]
-      });
+      const mark = this.mark(node);
+      mark.property("name").modifier("local").declaration.readonly.interface();
     }
   }
+  mark(node) {
+    const cst = (cstNode) => {
+      return createSemanticTypeMethods(
+        (type, modifier) => this.highlightToken({
+          range: nonNullable(cstNode ?? node.$cstNode, "AST node has no CST node").range,
+          type,
+          modifier
+        })
+      );
+    };
+    const keyword = (keyword2) => {
+      return createSemanticTypeMethods(
+        (type, modifier) => this.highlightKeyword({
+          node,
+          keyword: keyword2,
+          type,
+          modifier
+        })
+      );
+    };
+    const property = (property2, index) => {
+      return createSemanticTypeMethods(
+        (type, modifier) => this.highlightProperty({
+          node,
+          property: property2,
+          type,
+          modifier,
+          ...index !== void 0 ? { index } : {}
+        })
+      );
+    };
+    return {
+      node,
+      cst,
+      keyword,
+      property
+    };
+  }
 }

package/dist/mcp/tools/read-deployment.mjs

@@ -87,7 +87,7 @@ Example response (deployed instance):
     technology: z.string().nullable(),
     tags: z.array(z.string()),
     project: z.string(),
-    metadata: z.record(z.string()),
+    metadata: z.record(z.union([z.string(), z.array(z.string())])),
     shape: z.string(),
     color: z.string(),
     children: z.array(z.string()).describe("Children of this deployment node (Array of Deployment ids)"),

package/dist/mcp/tools/read-element.mjs

@@ -102,7 +102,7 @@ Example response:
     technology: z.string().nullable(),
     tags: z.array(z.string()),
     project: z.string(),
-    metadata: z.record(z.string()),
+    metadata: z.record(z.union([z.string(), z.array(z.string())])),
     shape: z.string(),
     color: z.string(),
     children: z.array(z.string()).describe("Children of this element (Array of FQNs)"),

package/dist/mcp/tools/search-element.mjs

@@ -14,7 +14,7 @@ const searchResultSchema = z.array(
       technology: z.string().nullable(),
       shape: z.string(),
       includedInViews: includedInViewsSchema,
-      metadata: z.record(z.string()),
+      metadata: z.record(z.union([z.string(), z.array(z.string())])),
       tags: z.array(z.string())
     }),
     z.object({
@@ -27,7 +27,7 @@ const searchResultSchema = z.array(
       technology: z.string().nullable(),
       shape: z.string(),
       includedInViews: includedInViewsSchema,
-      metadata: z.record(z.string()),
+      metadata: z.record(z.union([z.string(), z.array(z.string())])),
       tags: z.array(z.string())
     })
   ])

package/dist/model/builder/MergedExtends.d.ts

@@ -2,11 +2,12 @@ import type * as c4 from '@likec4/core';
 import type { ParsedAstExtend } from '../../ast';
 export declare class MergedExtends {
     private mergedData;
+    private mergeMetadata;
     merge(parsedExtends: ParsedAstExtend[]): void;
     applyExtended<E extends {
         id: string;
         tags?: readonly string[] | null;
         links?: readonly c4.Link[] | null;
-        metadata?: Record<string, string>;
+        metadata?: Record<string, string | string[]>;
     }>(el: E): E;
 }