@likec4/language-server 1.1.1 → 1.2.0

package/dist/references/scope-computation.js

@@ -6,52 +6,55 @@ import { isTruthy } from "remeda";
 import { ast } from "../ast.js";
 import { logError } from "../logger.js";
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
-  computeExports(document, _cancelToken) {
-    return new Promise((resolve) => {
-      const docExports = [];
+  async computeExports(document, _cancelToken) {
+    const docExports = [];
+    try {
       const { specifications, models, views } = document.parseResult.value;
-      try {
-        for (const spec of specifications.flatMap((s) => [...s.elements, ...s.relationships])) {
+      for (const spec of specifications.flatMap((s) => [
+        ...s.elements,
+        ...s.relationships,
+        ...s.tags
+      ])) {
+        try {
+          if (ast.isSpecificationTag(spec)) {
+            if (spec.tag && isTruthy(spec.tag.name)) {
+              docExports.push(
+                this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document)
+              );
+            }
+            continue;
+          }
           if (spec.kind && isTruthy(spec.kind.name)) {
             docExports.push(
               this.descriptions.createDescription(spec.kind, spec.kind.name, document)
             );
           }
+        } catch (e) {
+          logError(e);
         }
-      } catch (e) {
-        logError(e);
-      }
-      try {
-        for (const spec of specifications.flatMap((s) => s.tags)) {
-          if (spec.tag && isTruthy(spec.tag.name)) {
-            docExports.push(
-              this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document)
-            );
-          }
-        }
-      } catch (e) {
-        logError(e);
       }
-      try {
-        for (const elAst of models.flatMap((m) => m.elements)) {
+      for (const elAst of models.flatMap((m) => m.elements)) {
+        try {
           if (ast.isElement(elAst) && isTruthy(elAst.name)) {
             docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
           }
+        } catch (e) {
+          logError(e);
         }
-      } catch (e) {
-        logError(e);
       }
-      try {
-        for (const viewAst of views.flatMap((v) => v.views)) {
+      for (const viewAst of views.flatMap((v) => v.views)) {
+        try {
           if (isTruthy(viewAst.name)) {
             docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
           }
+        } catch (e) {
+          logError(e);
         }
-      } catch (e) {
-        logError(e);
       }
-      resolve(docExports);
-    });
+    } catch (e) {
+      logError(e);
+    }
+    return docExports;
   }
   computeLocalScopes(document, _cancelToken) {
     return new Promise((resolve) => {

package/dist/shared/NodeKindProvider.js

@@ -17,7 +17,7 @@ export class NodeKindProvider {
       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)): {
+      case (ast.isLikeC4View(node) || hasType(ast.LikeC4View)): {
         return SymbolKind.Class;
       }
       case (ast.isTag(node) || hasType(ast.Tag) || (ast.isSpecificationTag(node) || hasType(ast.SpecificationTag))): {
@@ -43,6 +43,8 @@ export class NodeKindProvider {
         return CompletionItemKind.Module;
       case SymbolKind.Class:
         return CompletionItemKind.Class;
+      case SymbolKind.Enum:
+        return CompletionItemKind.Enum;
       case SymbolKind.EnumMember:
         return CompletionItemKind.EnumMember;
       case SymbolKind.TypeParameter:
@@ -52,7 +54,7 @@ export class NodeKindProvider {
       case SymbolKind.Event:
         return CompletionItemKind.Event;
       default:
-        return CompletionItemKind.Keyword;
+        return CompletionItemKind.Reference;
     }
   }
 }

package/dist/validation/dynamic-view-rule.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const dynamicViewRulePredicate: (_services: LikeC4Services) => ValidationCheck<ast.DynamicViewRulePredicate>;
+//# sourceMappingURL=dynamic-view-rule.d.ts.map

package/dist/validation/dynamic-view-rule.js

@@ -0,0 +1,32 @@
+import { nonexhaustive } from "@likec4/core";
+import { ast } from "../ast.js";
+import { logError } from "../logger.js";
+export const dynamicViewRulePredicate = (_services) => {
+  return (el, accept) => {
+    try {
+      for (const expr of el.expressions) {
+        switch (true) {
+          case ast.isElementRef(expr):
+          case ast.isDescedantsExpr(expr):
+          case ast.isCustomElementExpr(expr):
+          case ast.isExpandElementExpr(expr):
+            return;
+          case ast.isRelationExpr(expr):
+          case ast.isInOutExpr(expr):
+          case ast.isIncomingExpr(expr):
+          case ast.isOutgoingExpr(expr):
+          case ast.isElementKindExpr(expr):
+          case ast.isElementTagExpr(expr):
+          case ast.isWildcardExpr(expr):
+            return accept("warning", `Expression is not supported by dynamic views`, {
+              node: expr
+            });
+          default:
+            nonexhaustive(expr);
+        }
+      }
+    } catch (e) {
+      logError(e);
+    }
+  };
+};

package/dist/validation/dynamic-view-step.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const dynamicViewStep: (services: LikeC4Services) => ValidationCheck<ast.DynamicViewStep>;
+//# sourceMappingURL=dynamic-view-step.d.ts.map

package/dist/validation/dynamic-view-step.js

@@ -0,0 +1,33 @@
+import { isAncestor } from "@likec4/core";
+import { elementRef } from "../elementRef.js";
+import { logError } from "../logger.js";
+export const dynamicViewStep = (services) => {
+  const fqnIndex = services.likec4.FqnIndex;
+  return (el, accept) => {
+    try {
+      const sourceEl = elementRef(el.source);
+      const source = sourceEl && fqnIndex.getFqn(sourceEl);
+      if (!source) {
+        accept("error", "Source not found (not parsed/indexed yet)", {
+          node: el,
+          property: "source"
+        });
+      }
+      const targetEl = elementRef(el.target);
+      const target = targetEl && fqnIndex.getFqn(targetEl);
+      if (!target) {
+        accept("error", "Target not found (not parsed/indexed yet)", {
+          node: el,
+          property: "target"
+        });
+      }
+      if (source && target && (isAncestor(source, target) || isAncestor(target, source))) {
+        accept("error", "Invalid parent-child relationship", {
+          node: el
+        });
+      }
+    } catch (e) {
+      logError(e);
+    }
+  };
+};

package/dist/validation/index.js

@@ -1,4 +1,6 @@
 import { logger } from "../logger.js";
+import { dynamicViewRulePredicate } from "./dynamic-view-rule.js";
+import { dynamicViewStep } from "./dynamic-view-step.js";
 import { elementChecks } from "./element.js";
 import { opacityPropertyRuleChecks } from "./property-checks.js";
 import { relationChecks } from "./relation.js";
@@ -25,11 +27,13 @@ export function registerValidationChecks(services) {
     SpecificationRule: specificationRuleChecks(services),
     Model: modelRuleChecks(services),
     ModelViews: modelViewsChecks(services),
-    ElementView: viewChecks(services),
+    DynamicViewStep: dynamicViewStep(services),
+    LikeC4View: viewChecks(services),
     Element: elementChecks(services),
     ElementKind: elementKindChecks(services),
     Relation: relationChecks(services),
     Tag: tagChecks(services),
+    DynamicViewRulePredicate: dynamicViewRulePredicate(services),
     CustomElementExpr: customElementExprChecks(services),
     ExpandElementExpr: expandElementExprChecks(services),
     RelationshipKind: relationshipChecks(services),

package/dist/validation/view-predicates/expanded-element.js

@@ -4,6 +4,7 @@ export const expandElementExprChecks = (_services) => {
   return (el, accept) => {
     switch (true) {
       case ast.isIncludePredicate(el.$container):
+      case ast.isDynamicViewRulePredicate(el.$container):
       case ast.isViewRuleStyle(el.$container):
         return;
       case ast.isCustomElementExpr(el.$container):

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

@@ -1,10 +1,10 @@
-import { isNil } from "remeda";
+import { isNullish } from "remeda";
 import { ast } from "../../ast.js";
 export const outgoingExpressionChecks = (_services) => {
   return (el, accept) => {
     if (ast.isWildcardExpr(el.from)) {
       const view = el.$container.$container.$container;
-      if (isNil(view.viewOf)) {
+      if (view.$type === "ElementView" && isNullish(view.viewOf)) {
         accept("warning", "Predicate is ignored as it concerns all relationships", {
           node: el
         });

package/dist/validation/view.d.ts

@@ -1,5 +1,5 @@
 import type { ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
-export declare const viewChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementView>;
+export declare const viewChecks: (services: LikeC4Services) => ValidationCheck<ast.LikeC4View>;
 //# sourceMappingURL=view.d.ts.map

package/dist/validation/view.js

@@ -2,12 +2,10 @@ import { ast } from "../ast.js";
 export const viewChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
   return (el, accept) => {
-    if (el.extends) {
-    }
     if (!el.name) {
       return;
     }
-    const anotherViews = index.allElements(ast.ElementView).filter((n) => n.name === el.name).limit(2).count();
+    const anotherViews = index.allElements(ast.LikeC4View).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.d.ts

@@ -1,3 +1,3 @@
-import type { ComputedView } from '@likec4/core';
+import { type ComputedView } from '@likec4/core';
 export declare function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R;
 //# sourceMappingURL=assignNavigateTo.d.ts.map

package/dist/view-utils/assignNavigateTo.js

@@ -1,8 +1,9 @@
+import { isComputedElementView } from "@likec4/core";
 import { find } from "remeda";
 export function assignNavigateTo(views) {
   const allElementViews = /* @__PURE__ */ new Map();
   for (const v of views) {
-    if (v.viewOf && !v.extends) {
+    if (isComputedElementView(v) && v.viewOf && !v.extends) {
       const viewsOf = allElementViews.get(v.viewOf) ?? [];
       viewsOf.push(v.id);
       allElementViews.set(v.viewOf, viewsOf);

package/dist/view-utils/resolve-extended-views.d.ts

@@ -1,7 +1,7 @@
-import { type ElementView } from '@likec4/core';
+import { type View } from '@likec4/core';
 /**
  * Resolve rules of extended views
  * (Removes invalid views)
  */
-export declare function resolveRulesExtendedViews<V extends Record<any, ElementView>>(unresolvedViews: V): V;
+export declare function resolveRulesExtendedViews<V extends Record<any, View>>(unresolvedViews: V): V;
 //# sourceMappingURL=resolve-extended-views.d.ts.map

package/dist/view-utils/resolve-relative-paths.d.ts

@@ -1,3 +1,3 @@
-import type { ElementView } from '@likec4/core';
-export declare function resolveRelativePaths(views: ElementView[]): ElementView[];
+import type { View } from '@likec4/core';
+export declare function resolveRelativePaths(views: View[]): View[];
 //# sourceMappingURL=resolve-relative-paths.d.ts.map

package/dist/view-utils/resolve-relative-paths.js

@@ -1,10 +1,9 @@
 import { invariant } from "@likec4/core";
-import { uniq, zip } from "rambdax";
-import { hasAtLeast } from "remeda";
+import { hasAtLeast, unique, zip } from "remeda";
 function commonAncestorPath(views, sep = "/") {
   if (views.length <= 1)
     return "";
-  const uniqURIs = uniq(views.flatMap(({ docUri }) => docUri ? [docUri] : []));
+  const uniqURIs = unique(views.flatMap(({ docUri }) => docUri ? [docUri] : []));
   if (uniqURIs.length === 0)
     return "";
   if (uniqURIs.length === 1) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -61,7 +61,7 @@
     }
   },
   "scripts": {
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc -b",
     "watch:langium": "langium generate --watch",
     "watch:ts": "tsc --watch",
     "generate": "langium generate",
@@ -74,8 +74,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@likec4/core": "1.1.1",
-    "@likec4/graph": "1.1.1",
+    "@likec4/core": "1.2.0",
+    "@likec4/graph": "1.2.0",
     "@total-typescript/ts-reset": "^0.5.1",
     "fast-equals": "^5.0.1",
     "langium": "^3.0.0",
@@ -92,7 +92,7 @@
     "vscode-uri": "3.0.8"
   },
   "devDependencies": {
-    "@types/node": "^20.12.7",
+    "@types/node": "^20.13.0",
     "@types/object-hash": "^3.0.6",
     "@types/string-hash": "^1",
     "execa": "^9.1.0",
@@ -102,5 +102,5 @@
     "unbuild": "^2.0.0",
     "vitest": "~1.5.2"
   },
-  "packageManager": "yarn@4.2.2"
+  "packageManager": "yarn@4.3.0"
 }