@likec4/language-server 0.46.1 → 0.48.0

package/dist/shared/NodeKindProvider.d.ts

@@ -1,10 +1,12 @@
-import { type AstNode, type AstNodeDescription } from 'langium';
+import { type AstNode, type AstNodeDescription, type LangiumSharedServices } from 'langium';
 import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-protocol';
 export declare class NodeKindProvider implements NodeKindProvider {
+    private services;
+    constructor(services: LangiumSharedServices);
     /**
      * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
      */
-    getSymbolKind(_node: AstNode | AstNodeDescription): SymbolKind;
+    getSymbolKind(node: AstNode | AstNodeDescription): SymbolKind;
     /**
      * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
      */

package/dist/shared/NodeKindProvider.js

@@ -1,29 +1,56 @@
-import { isAstNode } from "langium";
 import { CompletionItemKind, SymbolKind } from "vscode-languageserver-protocol";
 import { ast } from "../ast.js";
 export class NodeKindProvider {
+  constructor(services) {
+    this.services = services;
+  }
   /**
    * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
    */
-  getSymbolKind(_node) {
-    return SymbolKind.Field;
+  // prettier-ignore
+  getSymbolKind(node) {
+    const hasType = (type) => "type" in node && this.services.AstReflection.isSubtype(node.type, type);
+    switch (true) {
+      case (ast.isElement(node) || hasType(ast.Element) || (ast.isExtendElement(node) || hasType(ast.ExtendElement))): {
+        return SymbolKind.Constructor;
+      }
+      case (ast.isModel(node) || ast.isModelViews(node) || ast.isSpecificationRule(node) || hasType(ast.Model) || hasType(ast.ModelViews) || hasType(ast.SpecificationRule)): {
+        return SymbolKind.Namespace;
+      }
+      case (ast.isElementView(node) || hasType(ast.ElementView)): {
+        return SymbolKind.Class;
+      }
+      case (ast.isTag(node) || hasType(ast.Tag) || (ast.isSpecificationTag(node) || hasType(ast.SpecificationTag))): {
+        return SymbolKind.EnumMember;
+      }
+      case (ast.isRelationshipKind(node) || hasType(ast.RelationshipKind) || (ast.isSpecificationRelationshipKind(node) || hasType(ast.SpecificationRelationshipKind))): {
+        return SymbolKind.Event;
+      }
+      case (ast.isElementKind(node) || hasType(ast.ElementKind) || (ast.isSpecificationElementKind(node) || hasType(ast.SpecificationElementKind))): {
+        return SymbolKind.TypeParameter;
+      }
+    }
+    return SymbolKind.Constant;
   }
   /**
    * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
    */
   getCompletionItemKind(node) {
-    const hasType = (type) => "type" in node && node.type === type;
-    switch (true) {
-      case (isAstNode(node) ? ast.isElement(node) : node.type === ast.Element): {
-        return CompletionItemKind.Variable;
-      }
-      case (ast.isElementKind(node) || ast.isRelationshipKind(node) || hasType(ast.ElementKind) || hasType(ast.RelationshipKind)): {
+    switch (this.getSymbolKind(node)) {
+      case SymbolKind.Constructor:
+        return CompletionItemKind.Constructor;
+      case SymbolKind.Namespace:
+        return CompletionItemKind.Module;
+      case SymbolKind.Class:
         return CompletionItemKind.Class;
-      }
-      case (ast.isTag(node) || hasType(ast.Tag)): {
+      case SymbolKind.EnumMember:
         return CompletionItemKind.EnumMember;
-      }
+      case SymbolKind.TypeParameter:
+        return CompletionItemKind.TypeParameter;
+      case SymbolKind.Event:
+        return CompletionItemKind.Event;
+      default:
+        return CompletionItemKind.Constant;
     }
-    return CompletionItemKind.Reference;
   }
 }

package/dist/shared/WorkspaceSymbolProvider.d.ts

@@ -0,0 +1,4 @@
+import { DefaultWorkspaceSymbolProvider } from 'langium';
+export declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {
+}
+//# sourceMappingURL=WorkspaceSymbolProvider.d.ts.map

package/dist/shared/WorkspaceSymbolProvider.js

@@ -0,0 +1,3 @@
+import { DefaultWorkspaceSymbolProvider } from "langium";
+export class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {
+}

package/dist/shared/index.d.ts

@@ -1,2 +1,4 @@
 export * from './WorkspaceManager';
+export * from './NodeKindProvider';
+export * from './WorkspaceSymbolProvider';
 //# sourceMappingURL=index.d.ts.map

package/dist/shared/index.js

@@ -1 +1,3 @@
 export * from "./WorkspaceManager.js";
+export * from "./NodeKindProvider.js";
+export * from "./WorkspaceSymbolProvider.js";

package/dist/test/testServices.d.ts

@@ -5,12 +5,17 @@ export declare function createTestServices(workspace?: string): {
     validate: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<{
         document: LikeC4LangiumDocument;
         diagnostics: import("vscode-languageserver-types").Diagnostic[];
+        warnings: string[];
         errors: string[];
     }>;
     validateAll: () => Promise<{
         diagnostics: import("vscode-languageserver-types").Diagnostic[];
         errors: string[];
+        warnings: string[];
     }>;
     buildModel: () => Promise<import("@likec4/core").LikeC4Model>;
 };
+export type TestServices = ReturnType<typeof createTestServices>;
+export type TestParseFn = TestServices['validate'];
+export type TestValidateFn = TestServices['validate'];
 //# sourceMappingURL=testServices.d.ts.map

package/dist/test/testServices.js

@@ -2,6 +2,8 @@ import { createLanguageServices } from "../module.js";
 import { EmptyFileSystem } from "langium";
 import { URI, Utils } from "vscode-uri";
 import stripIndent from "strip-indent";
+import * as assert from "node:assert";
+import { DiagnosticSeverity } from "vscode-languageserver-protocol";
 export function createTestServices(workspace = "file:///test/workspace") {
   const services = createLanguageServices(EmptyFileSystem).likec4;
   const metaData = services.LanguageMetaData;
@@ -14,18 +16,15 @@ export function createTestServices(workspace = "file:///test/workspace") {
     uri: workspaceUri.toString()
   };
   let isInitialized = false;
-  const init = async () => {
-    if (isInitialized)
-      return Promise.resolve();
-    isInitialized = true;
-    await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
-    Object.assign(services.shared.workspace.WorkspaceManager, {
-      folders: [workspaceFolder]
-    });
-  };
   let documentIndex = 1;
   const parse = async (input, uri) => {
-    await init();
+    if (!isInitialized) {
+      isInitialized = true;
+      await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
+      Object.assign(services.shared.workspace.WorkspaceManager, {
+        folders: [workspaceFolder]
+      });
+    }
     const docUri = Utils.resolvePath(
       workspaceUri,
       "./src/",
@@ -43,21 +42,34 @@ export function createTestServices(workspace = "file:///test/workspace") {
     const document = typeof input === "string" ? await parse(input, uri) : input;
     await documentBuilder.build([document], { validation: true });
     const diagnostics = document.diagnostics ?? [];
-    const errors = diagnostics.map((d) => d.message);
+    const warnings = diagnostics.flatMap(
+      (d) => d.severity === DiagnosticSeverity.Warning ? d.message : []
+    );
+    const errors = diagnostics.flatMap(
+      (d) => d.severity === DiagnosticSeverity.Error ? d.message : []
+    );
     return {
       document,
       diagnostics,
+      warnings,
       errors
     };
   };
   const validateAll = async () => {
     const docs = langiumDocuments.all.toArray();
+    assert.ok(docs.length > 0, "no documents to validate");
     await documentBuilder.build(docs, { validation: true });
     const diagnostics = docs.flatMap((doc) => doc.diagnostics ?? []);
-    const errors = diagnostics.map((d) => d.message);
+    const warnings = diagnostics.flatMap(
+      (d) => d.severity === DiagnosticSeverity.Warning ? d.message : []
+    );
+    const errors = diagnostics.flatMap(
+      (d) => d.severity === DiagnosticSeverity.Error ? d.message : []
+    );
     return {
       diagnostics,
-      errors
+      errors,
+      warnings
     };
   };
   const buildModel = async () => {

package/dist/validation/index.js

@@ -10,23 +10,31 @@ import {
   tagChecks
 } from "./specification.js";
 import { viewChecks } from "./view.js";
-import { incomingExpressionChecks, outgoingExpressionChecks } from "./view-predicates/index.js";
+import {
+  customElementExprChecks,
+  incomingExpressionChecks,
+  outgoingExpressionChecks
+} from "./view-predicates/index.js";
 export function registerValidationChecks(services) {
   logger.info("registerValidationChecks");
   const registry = services.validation.ValidationRegistry;
-  registry.register({
-    SpecificationRule: specificationRuleChecks(services),
-    Model: modelRuleChecks(services),
-    ModelViews: modelViewsChecks(services),
-    ElementView: viewChecks(services),
-    Element: elementChecks(services),
-    ElementKind: elementKindChecks(services),
-    Relation: relationChecks(services),
-    Tag: tagChecks(services),
-    RelationshipKind: relationshipChecks(services),
-    IncomingExpression: incomingExpressionChecks(services),
-    OutgoingExpression: outgoingExpressionChecks(services)
-  }, "slow");
+  registry.register(
+    {
+      SpecificationRule: specificationRuleChecks(services),
+      Model: modelRuleChecks(services),
+      ModelViews: modelViewsChecks(services),
+      ElementView: viewChecks(services),
+      Element: elementChecks(services),
+      ElementKind: elementKindChecks(services),
+      Relation: relationChecks(services),
+      Tag: tagChecks(services),
+      CustomElementExpr: customElementExprChecks(services),
+      RelationshipKind: relationshipChecks(services),
+      IncomingExpr: incomingExpressionChecks(services),
+      OutgoingExpr: outgoingExpressionChecks(services)
+    },
+    "slow"
+  );
   const connection = services.shared.lsp.Connection;
   if (connection) {
     services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {

package/dist/validation/specification.js

@@ -44,7 +44,8 @@ export const elementKindChecks = (services) => {
 export const tagChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
   return (node, accept) => {
-    const sameKinds = index.allElements(ast.Tag).filter((n) => n.name === node.name).limit(2).count();
+    const tagname = "#" + node.name;
+    const sameKinds = index.allElements(ast.Tag).filter((n) => n.name === tagname).limit(2).count();
     if (sameKinds > 1) {
       accept("error", `Duplicate tag '${node.name}'`, {
         node,

package/dist/validation/view-predicates/custom-element-expr.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../../ast';
+import type { LikeC4Services } from '../../module';
+export declare const customElementExprChecks: (_services: LikeC4Services) => ValidationCheck<ast.CustomElementExpr>;
+//# sourceMappingURL=custom-element-expr.d.ts.map

package/dist/validation/view-predicates/custom-element-expr.js

@@ -0,0 +1,16 @@
+import { ast } from "../../ast.js";
+export const customElementExprChecks = (_services) => {
+  return (el, accept) => {
+    if (ast.isExcludePredicate(el.$container)) {
+      accept("error", 'Invalid inside "exclude"', {
+        node: el
+      });
+    }
+    if (!ast.isElementRef(el.target)) {
+      accept("error", "Invalid target for customization", {
+        node: el,
+        property: "target"
+      });
+    }
+  };
+};

package/dist/validation/view-predicates/incoming.d.ts

@@ -1,5 +1,5 @@
 import type { ValidationCheck } from 'langium';
 import { ast } from '../../ast';
 import type { LikeC4Services } from '../../module';
-export declare const incomingExpressionChecks: (_services: LikeC4Services) => ValidationCheck<ast.IncomingExpression>;
+export declare const incomingExpressionChecks: (_services: LikeC4Services) => ValidationCheck<ast.IncomingExpr>;
 //# sourceMappingURL=incoming.d.ts.map

package/dist/validation/view-predicates/incoming.js

@@ -2,7 +2,7 @@ import { ast } from "../../ast.js";
 import { isNil } from "remeda";
 export const incomingExpressionChecks = (_services) => {
   return (el, accept) => {
-    if (ast.isWildcardExpression(el.target) && ast.isViewRuleExpression(el.$container)) {
+    if (ast.isWildcardExpr(el.to) && ast.isViewRulePredicate(el.$container)) {
       const view = el.$container.$container.$container;
       if (isNil(view.viewOf)) {
         accept("warning", "Predicate is ignored as it concerns all relationships", {

package/dist/validation/view-predicates/index.d.ts

@@ -1,3 +1,4 @@
 export * from './incoming';
 export * from './outgoing';
+export * from './custom-element-expr';
 //# sourceMappingURL=index.d.ts.map

package/dist/validation/view-predicates/index.js

@@ -1,2 +1,3 @@
 export * from "./incoming.js";
 export * from "./outgoing.js";
+export * from "./custom-element-expr.js";

package/dist/validation/view-predicates/outgoing.d.ts

@@ -1,5 +1,5 @@
 import type { ValidationCheck } from 'langium';
 import { ast } from '../../ast';
 import type { LikeC4Services } from '../../module';
-export declare const outgoingExpressionChecks: (_services: LikeC4Services) => ValidationCheck<ast.OutgoingExpression>;
+export declare const outgoingExpressionChecks: (_services: LikeC4Services) => ValidationCheck<ast.OutgoingExpr>;
 //# sourceMappingURL=outgoing.d.ts.map

package/dist/validation/view-predicates/outgoing.js

@@ -2,7 +2,7 @@ import { ast } from "../../ast.js";
 import { isNil } from "remeda";
 export const outgoingExpressionChecks = (_services) => {
   return (el, accept) => {
-    if (ast.isWildcardExpression(el.source) && ast.isViewRuleExpression(el.$container)) {
+    if (ast.isWildcardExpr(el.from)) {
       const view = el.$container.$container.$container;
       if (isNil(view.viewOf)) {
         accept("warning", "Predicate is ignored as it concerns all relationships", {

package/dist/validation/view.js

@@ -7,7 +7,7 @@ export const viewChecks = (services) => {
     if (!el.name) {
       return;
     }
-    const anotherViews = index.allElements(ast.View).filter((n) => n.name === el.name).limit(2).count();
+    const anotherViews = index.allElements(ast.ElementView).filter((n) => n.name === el.name).limit(2).count();
     if (anotherViews > 1) {
       accept("error", `Duplicate view '${el.name}'`, {
         node: el,

package/dist/view-utils/assignNavigateTo.js

@@ -10,6 +10,9 @@ export function assignNavigateTo(views) {
   }
   for (const { id, nodes } of views) {
     for (const node of nodes) {
+      if (node.navigateTo) {
+        continue;
+      }
       const navigateTo = find(allElementViews.get(node.id) ?? [], (v) => v !== id);
       if (navigateTo) {
         node.navigateTo = navigateTo;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "0.46.1",
+  "version": "0.48.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -50,8 +50,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@likec4/core": "0.46.1",
-    "@likec4/graph": "0.46.1",
+    "@likec4/core": "0.48.0",
+    "@likec4/graph": "0.48.0",
     "langium": "^2.1.2",
     "object-hash": "^3.0.0",
     "p-debounce": "^4.0.0",
@@ -59,13 +59,14 @@
     "rambdax": "^9.1.1",
     "remeda": "^1.29.0",
     "strip-indent": "^4.0.0",
+    "type-fest": "^4.8.1",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-protocol": "3.17.5",
     "vscode-uri": "3.0.8"
   },
   "devDependencies": {
     "@types/node": "^20.8.7",
-    "@types/object-hash": "^3.0.5",
+    "@types/object-hash": "^3.0.6",
     "execa": "^8.0.1",
     "langium-cli": "^2.1.0",
     "npm-run-all": "^4.1.5",
@@ -73,7 +74,7 @@
     "unbuild": "^2.0.0",
     "vitest": "^0.34.6"
   },
-  "packageManager": "yarn@4.0.1",
+  "packageManager": "yarn@4.0.2",
   "volta": {
     "extends": "../../package.json"
   }