@likec4/language-server 1.27.3 → 1.28.0

package/dist/config/schema.d.ts

@@ -1,8 +1,8 @@
 import * as v from 'valibot';
 export declare const ProjectConfig: v.ObjectSchema<{
-    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.DescriptionAction<string, "Project name, must be unique in the workspace">]>;
-    readonly contactPerson: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.DescriptionAction<string, "A person who has been involved in creating or maintaining this project">]>, undefined>;
-    readonly exclude: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "List of file patterns to exclude from the project, default is [\"node_modules\"]">]>, undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>, v.DescriptionAction<string, "Project name, must be unique in the workspace">]>;
+    readonly contactPerson: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>, v.DescriptionAction<string, "A person who has been involved in creating or maintaining this project">]>, undefined>;
+    readonly exclude: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "List of file patterns to exclude from the project, default is [\"**/node_modules/**/*\"]">]>, undefined>;
 }, undefined>;
 export type ProjectConfig = v.InferOutput<typeof ProjectConfig>;
 export declare function parseConfigJson(config: string): ProjectConfig;

package/dist/config/schema.js

@@ -1,22 +1,29 @@
 import JSON5 from "json5";
 import * as v from "valibot";
+const nonEmptyString = v.pipe(v.string(), v.nonEmpty());
 export const ProjectConfig = v.object({
   name: v.pipe(
-    v.string(),
-    v.nonEmpty(),
+    nonEmptyString,
+    // TODO: check if this is needed
+    // v.excludes('.', 'Project name cannot contain "."'),
     v.description("Project name, must be unique in the workspace")
   ),
   contactPerson: v.optional(
     v.pipe(
-      v.string(),
-      v.nonEmpty(),
+      nonEmptyString,
       v.description("A person who has been involved in creating or maintaining this project")
     )
   ),
+  // imports: v.optional(
+  //   v.pipe(
+  //     v.record(v.string(), nonEmptyString),
+  //     v.description('Imported projects'),
+  //   ),
+  // ),
   exclude: v.optional(
     v.pipe(
       v.array(v.string()),
-      v.description('List of file patterns to exclude from the project, default is ["node_modules"]')
+      v.description('List of file patterns to exclude from the project, default is ["**/node_modules/**/*"]')
     )
   )
 });

package/dist/documentation/documentation-provider.js

@@ -1,3 +1,4 @@
+import { FqnRef } from "@likec4/core";
 import { AstUtils } from "langium";
 import { ast } from "../ast.js";
 import { logWarnError } from "../logger.js";
@@ -22,7 +23,8 @@ export class LikeC4DocumentationProvider {
       if (ast.isDeployedInstance(node)) {
         const doc = AstUtils.getDocument(node);
         const instance = this.parser.forDocument(doc).parseDeployedInstance(node);
-        const el = this.locator.getParsedElement(instance.element);
+        const [projectId, fqn] = FqnRef.isImportRef(instance.element) ? [instance.element.project, instance.element.model] : [doc.likec4ProjectId, instance.element.model];
+        const el = projectId ? this.locator.getParsedElement(fqn, projectId) : this.locator.getParsedElement(fqn);
         const lines = [instance.id, `_instance of_ ${instance.element}`];
         if (el) {
           lines.push(" ", `**${el.title}**`);

package/dist/formatting/LikeC4Formatter.d.ts

@@ -25,12 +25,10 @@ export declare class LikeC4Formatter extends AbstractFormatter {
     protected formatViewRuleGroup(node: AstNode): void;
     protected formatViewRuleStyle(node: AstNode): void;
     protected formatWhereExpression(node: AstNode): void;
-    protected formatWhereExpressionV2(node: AstNode): void;
     protected formatWhereRelationExpression(node: AstNode): void;
     protected formatWhereElementExpression(node: AstNode): void;
     protected formatIncludeExcludeExpressions(node: AstNode): void;
     protected formatRelationExpression(node: AstNode): void;
-    protected formatDeploymentViewRulePredicateExpressions(node: AstNode): void;
     private findPredicateExpressionRoot;
     private on;
 }

package/dist/formatting/LikeC4Formatter.js

@@ -27,9 +27,7 @@ export class LikeC4Formatter extends AbstractFormatter {
     this.formatViewRuleGlobalStyle(node);
     this.formatViewRuleGlobalPredicate(node);
     this.formatIncludeExcludeExpressions(node);
-    this.formatDeploymentViewRulePredicateExpressions(node);
     this.formatWhereExpression(node);
-    this.formatWhereExpressionV2(node);
     this.formatWhereRelationExpression(node);
     this.formatWhereElementExpression(node);
     this.formatRelationExpression(node);
@@ -61,17 +59,21 @@ export class LikeC4Formatter extends AbstractFormatter {
     });
   }
   formatRelation(node) {
-    this.on(node, ast.isRelation, (n, f) => {
-      const sourceNodes = n?.source?.$cstNode ? [n?.source?.$cstNode] : [];
-      f.cst(sourceNodes).append(FormattingOptions.oneSpace);
-      f.keywords("]->").prepend(FormattingOptions.noSpace);
-      f.keywords("-[").append(FormattingOptions.noSpace);
-      f.nodes(...filter([
-        n.target,
-        n.tags
-      ], isTruthy)).prepend(FormattingOptions.oneSpace);
-      f.properties("title", "technology").prepend(FormattingOptions.oneSpace);
-    });
+    this.on(
+      node,
+      (n) => ast.isRelation(n) || ast.isDeploymentRelation(n),
+      (n, f) => {
+        const sourceNodes = n?.source?.$cstNode ? [n?.source?.$cstNode] : [];
+        f.cst(sourceNodes).append(FormattingOptions.oneSpace);
+        f.keywords("]->").prepend(FormattingOptions.noSpace);
+        f.keywords("-[").append(FormattingOptions.noSpace);
+        f.nodes(...filter([
+          n.target,
+          n.tags
+        ], isTruthy)).prepend(FormattingOptions.oneSpace);
+        f.properties("title", "technology").prepend(FormattingOptions.oneSpace);
+      }
+    );
     this.on(node, ast.isDynamicViewStep, (n, f) => {
       f.keywords("->", "<-").surround(FormattingOptions.oneSpace);
       const kind = f.property("kind");
@@ -80,19 +82,11 @@ export class LikeC4Formatter extends AbstractFormatter {
       f.keywords("-[").prepend(FormattingOptions.oneSpace).append(FormattingOptions.noSpace);
       f.properties("title").prepend(FormattingOptions.oneSpace);
     });
-    this.on(node, ast.isDirectedRelationExpression)?.property("target").prepend(FormattingOptions.oneSpace);
-    this.on(node, ast.isOutgoingRelationExpression, (n, f) => {
-      f.property("from").append(FormattingOptions.oneSpace);
-      f.keywords("]->").prepend(FormattingOptions.noSpace);
-      f.keywords("-[").append(FormattingOptions.noSpace);
-    });
-    this.on(node, ast.isIncomingRelationExpression)?.keywords("->").append(FormattingOptions.oneSpace);
-    this.on(node, ast.isInOutRelationExpression)?.keyword("->").prepend(FormattingOptions.oneSpace);
   }
   removeIndentFromTopLevelStatements(node) {
-    if (ast.isModel(node) || ast.isSpecificationRule(node) || ast.isModelViews(node) || ast.isLikeC4Lib(node) || ast.isGlobals(node) || ast.isModelDeployments(node)) {
+    if (ast.isLikeC4Grammar(node.$container)) {
       const formatter = this.getNodeFormatter(node);
-      formatter.keywords("specification", "model", "views", "likec4lib", "global", "deployments").prepend(FormattingOptions.noIndent);
+      formatter.keywords("specification", "model", "views", "likec4lib", "global", "deployments", "import").prepend(FormattingOptions.noIndent);
     }
   }
   indentContentInBraces(node) {
@@ -222,8 +216,8 @@ export class LikeC4Formatter extends AbstractFormatter {
     }
   }
   formatWithPredicate(node) {
-    const formatter = this.getNodeFormatter(node);
-    if (ast.isElementPredicateWith(node) || ast.isRelationPredicateWith(node)) {
+    if (ast.isFqnExprWith(node) || ast.isRelationExprWith(node)) {
+      const formatter = this.getNodeFormatter(node);
       formatter.keyword("with").prepend(FormattingOptions.oneSpace);
     }
   }
@@ -271,17 +265,11 @@ export class LikeC4Formatter extends AbstractFormatter {
   formatViewRuleStyle(node) {
     this.on(node, ast.isViewRuleStyle)?.keyword("style").append(FormattingOptions.oneSpace);
     this.on(node, ast.isDeploymentViewRuleStyle)?.keyword("style").append(FormattingOptions.oneSpace);
-    this.on(node, ast.isElementExpressionsIterator)?.keyword(",").prepend(FormattingOptions.noSpace).append(FormattingOptions.oneSpace);
+    this.on(node, ast.isExpressions)?.keyword(",").prepend(FormattingOptions.noSpace).append(FormattingOptions.oneSpace);
     this.on(node, ast.isFqnExpressions)?.keyword(",").prepend(FormattingOptions.noSpace).append(FormattingOptions.oneSpace);
   }
   formatWhereExpression(node) {
-    if (ast.isRelationPredicateOrWhere(node) || ast.isElementPredicateOrWhere(node)) {
-      const formatter = this.getNodeFormatter(node);
-      formatter.keyword("where").append(FormattingOptions.oneSpace);
-    }
-  }
-  formatWhereExpressionV2(node) {
-    if (ast.isRelationPredicateOrWhereV2(node) || ast.isElementPredicateOrWhereV2(node)) {
+    if (ast.isRelationExprWhere(node) || ast.isFqnExprWhere(node)) {
       const formatter = this.getNodeFormatter(node);
       formatter.keyword("where").append(FormattingOptions.oneSpace);
     }
@@ -313,13 +301,13 @@ export class LikeC4Formatter extends AbstractFormatter {
     }
   }
   formatIncludeExcludeExpressions(node) {
-    if (ast.isDynamicViewRule(node) || ast.isIncludePredicate(node) || ast.isExcludePredicate(node) || ast.isDeploymentViewRulePredicate(node)) {
+    if (ast.isDynamicViewRule(node) || ast.isViewRulePredicate(node) || ast.isDeploymentViewRulePredicate(node)) {
       const formatter = this.getNodeFormatter(node);
       if (!node.$cstNode || !utils.isMultiline(node.$cstNode)) {
         formatter.keywords("include", "exclude").append(FormattingOptions.oneSpace);
       }
     }
-    if (ast.isDynamicViewPredicateIterator(node) || ast.isPredicates(node) || ast.isPredicates(node)) {
+    if (ast.isExpressions(node)) {
       const formatter = this.getNodeFormatter(node);
       const parent = this.findPredicateExpressionRoot(node);
       const isMultiline = parent?.$cstNode && utils.isMultiline(parent?.$cstNode);
@@ -347,27 +335,10 @@ export class LikeC4Formatter extends AbstractFormatter {
       f.property("target").prepend(FormattingOptions.oneSpace);
     });
   }
-  formatDeploymentViewRulePredicateExpressions(node) {
-    if (ast.isDynamicViewRule(node) || ast.isIncludePredicate(node) || ast.isExcludePredicate(node) || ast.isDeploymentViewRulePredicate(node)) {
-      const formatter = this.getNodeFormatter(node);
-      if (!node.$cstNode || !utils.isMultiline(node.$cstNode)) {
-        formatter.keywords("include", "exclude").append(FormattingOptions.oneSpace);
-      }
-    }
-    if (ast.isDeploymentViewRulePredicateExpression(node)) {
-      const formatter = this.getNodeFormatter(node);
-      const parent = this.findPredicateExpressionRoot(node);
-      const isMultiline = parent?.$cstNode && utils.isMultiline(parent?.$cstNode);
-      if (isMultiline) {
-        formatter.property("value").prepend(FormattingOptions.indent);
-      }
-      formatter.keyword(",").prepend(FormattingOptions.noSpace).append(isMultiline ? FormattingOptions.newLine : FormattingOptions.oneSpace);
-    }
-  }
   findPredicateExpressionRoot(node) {
     let parent = node.$container;
     while (true) {
-      if (!parent || ast.isDynamicViewRule(parent) || ast.isIncludePredicate(parent) || ast.isExcludePredicate(parent) || ast.isDeploymentViewRulePredicate(parent)) {
+      if (!parent || ast.isDynamicViewRule(parent) || ast.isViewRulePredicate(parent) || ast.isDeploymentViewRulePredicate(parent)) {
         return parent;
       }
       parent = parent.$container;