@likec4/language-server 1.18.0 → 1.19.1

package/dist/browser.js

@@ -0,0 +1,13 @@
+import { startLanguageServer as startLanguim } from "langium/lsp";
+import { BrowserMessageReader, BrowserMessageWriter, createConnection } from "vscode-languageserver/browser";
+import { createLanguageServices } from "./module.js";
+export { logger as lspLogger, setLogLevel } from "./logger.js";
+export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from "./module.js";
+export function startLanguageServer() {
+  const messageReader = new BrowserMessageReader(self);
+  const messageWriter = new BrowserMessageWriter(self);
+  const connection = createConnection(messageReader, messageWriter);
+  const services = createLanguageServices({ connection });
+  startLanguim(services.shared);
+  return services;
+}

package/dist/documentation/documentation-provider.d.ts

@@ -0,0 +1,8 @@
+import { type AstNode, type DocumentationProvider } from 'langium';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4DocumentationProvider implements DocumentationProvider {
+    private parser;
+    private locator;
+    constructor(services: LikeC4Services);
+    getDocumentation(node: AstNode): string | undefined;
+}

package/dist/documentation/documentation-provider.js

@@ -0,0 +1,46 @@
+import { AstUtils } from "langium";
+import { ast } from "../ast.js";
+import { logWarnError } from "../logger.js";
+export class LikeC4DocumentationProvider {
+  parser;
+  locator;
+  constructor(services) {
+    this.parser = services.likec4.ModelParser;
+    this.locator = services.likec4.ModelLocator;
+  }
+  getDocumentation(node) {
+    try {
+      if (ast.isDeploymentNode(node)) {
+        const doc = AstUtils.getDocument(node);
+        const el = this.parser.forDocument(doc).parseDeploymentNode(node);
+        const lines = [el.id];
+        if (el.title !== node.name) {
+          lines.push(" ", `**${el.title}**`);
+        }
+        return lines.join("  \n");
+      }
+      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 lines = [instance.id, `_instance of_ ${instance.element}`];
+        if (el) {
+          lines.push(" ", `**${el.title}**`);
+        }
+        return lines.join("  \n");
+      }
+      if (ast.isElement(node)) {
+        const doc = AstUtils.getDocument(node);
+        const el = this.parser.forDocument(doc).parseElement(node);
+        if (!el) {
+          return;
+        }
+        const lines = [el.id, " ", `**${el.title}**`];
+        return lines.join("  \n");
+      }
+    } catch (e) {
+      logWarnError(e);
+    }
+    return;
+  }
+}

package/dist/documentation/index.d.ts

@@ -0,0 +1 @@
+export { LikeC4DocumentationProvider } from './documentation-provider';

package/dist/documentation/index.js

@@ -0,0 +1 @@
+export { LikeC4DocumentationProvider } from "./documentation-provider.js";

package/dist/formatting/LikeC4Formatter.d.ts

@@ -0,0 +1,27 @@
+import { type AstNode } from 'langium';
+import { AbstractFormatter } from 'langium/lsp';
+export declare class LikeC4Formatter extends AbstractFormatter {
+    protected format(node: AstNode): void;
+    protected formatTags(node: AstNode): void;
+    protected formatRelation(node: AstNode): void;
+    protected removeIndentFromTopLevelStatements(node: AstNode): void;
+    protected indentContentInBraces(node: AstNode): void;
+    protected appendKeywordsWithSpace(node: AstNode): void;
+    protected formatView(node: AstNode): void;
+    protected formatLeafProperty(node: AstNode): void;
+    protected formatLinkProperty(node: AstNode): void;
+    protected formatNavigateToProperty(node: AstNode): void;
+    protected formatAutolayoutProperty(node: AstNode): void;
+    protected formatMetadataProperty(node: AstNode): void;
+    protected formatElementDeclaration(node: AstNode): void;
+    protected formatGlobals(node: AstNode): void;
+    protected formatSpecificationRule(node: AstNode): void;
+    protected formatWithPredicate(node: AstNode): void;
+    protected formatViewRuleGlobalStyle(node: AstNode): void;
+    protected formatViewRuleGroup(node: AstNode): void;
+    protected formatViewRuleStyle(node: AstNode): void;
+    protected formatWhereExpression(node: AstNode): void;
+    protected formatIncludeExcludeExpressions(node: AstNode): void;
+    private findPredicateExpressionRoot;
+    private on;
+}

package/dist/formatting/LikeC4Formatter.js

@@ -0,0 +1,261 @@
+import { GrammarUtils } from "langium";
+import { AbstractFormatter, Formatting } from "langium/lsp";
+import { filter, isTruthy } from "remeda";
+import * as ast from "../generated/ast.js";
+import * as utils from "./utils.js";
+const FormattingOptions = {
+  newLine: Formatting.newLine({ allowMore: true }),
+  oneSpace: Formatting.oneSpace(),
+  noSpace: Formatting.noSpace(),
+  indent: Formatting.indent({ allowMore: true }),
+  noIndent: Formatting.noIndent()
+};
+export class LikeC4Formatter extends AbstractFormatter {
+  format(node) {
+    this.removeIndentFromTopLevelStatements(node);
+    this.indentContentInBraces(node);
+    this.formatSpecificationRule(node);
+    this.formatGlobals(node);
+    this.formatElementDeclaration(node);
+    this.formatRelation(node);
+    this.formatMetadataProperty(node);
+    this.formatView(node);
+    this.formatViewRuleGroup(node);
+    this.formatViewRuleGlobalStyle(node);
+    this.formatIncludeExcludeExpressions(node);
+    this.formatWhereExpression(node);
+    this.formatAutolayoutProperty(node);
+    this.formatWithPredicate(node);
+    this.formatViewRuleStyle(node);
+    this.formatLeafProperty(node);
+    this.formatLinkProperty(node);
+    this.formatNavigateToProperty(node);
+    this.formatTags(node);
+  }
+  formatTags(node) {
+    this.on(node, ast.isTags, (n, f) => {
+      f.cst(GrammarUtils.findNodesForProperty(n.$cstNode, "values").slice(1)).prepend(FormattingOptions.oneSpace);
+      f.keywords(",").prepend(FormattingOptions.noSpace).append(FormattingOptions.oneSpace);
+    });
+  }
+  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, ast.isDynamicViewStep, (n, f) => {
+      f.keywords("->", "<-").surround(FormattingOptions.oneSpace);
+      const kind = f.property("kind");
+      kind.nodes[0]?.text.startsWith(".") && kind.surround(FormattingOptions.oneSpace);
+      f.keywords("]->").prepend(FormattingOptions.noSpace).append(FormattingOptions.oneSpace);
+      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)) {
+      const formatter = this.getNodeFormatter(node);
+      formatter.keywords("specification", "model", "views", "likec4lib", "global").prepend(FormattingOptions.noIndent);
+    }
+  }
+  indentContentInBraces(node) {
+    if (ast.isLikeC4Lib(node) || ast.isSpecificationRule(node) || ast.isSpecificationElementKind(node) || ast.isSpecificationRelationshipKind(node) || ast.isGlobals(node) || ast.isGlobalStyle(node) || ast.isGlobalStyleGroup(node) || ast.isModel(node) || ast.isElementBody(node) || ast.isExtendElementBody(node) || ast.isRelationBody(node) || ast.isRelationStyleProperty(node) || ast.isMetadataBody(node) || ast.isModelViews(node) || ast.isElementViewBody(node) || ast.isDynamicViewBody(node) || ast.isViewRuleStyle(node) || ast.isViewRuleGroup(node) || ast.isCustomElementProperties(node) || ast.isCustomRelationProperties(node) || ast.isElementStyleProperty(node) || ast.isDynamicViewParallelSteps(node)) {
+      const formatter = this.getNodeFormatter(node);
+      const openBrace = formatter.keywords("{");
+      const closeBrace = formatter.keywords("}");
+      const interiorNodes = formatter.interior(openBrace, closeBrace);
+      let perviousNode = null;
+      for (const interiorNode of interiorNodes.nodes) {
+        if (!perviousNode || !utils.areOverlap(perviousNode, interiorNode)) {
+          formatter.cst([interiorNode]).prepend(FormattingOptions.indent);
+        }
+        perviousNode = interiorNode;
+      }
+      openBrace.prepend(FormattingOptions.noIndent).prepend(FormattingOptions.oneSpace);
+      closeBrace.prepend(FormattingOptions.noIndent).prepend(Formatting.newLine({ allowMore: true }));
+    }
+  }
+  appendKeywordsWithSpace(node) {
+    this.on(node, ast.isElementKind)?.keywords("element").append(FormattingOptions.oneSpace);
+  }
+  formatView(node) {
+    this.on(node, ast.isElementView, (n, f) => {
+      if (n.extends || n.viewOf || n.name) {
+        f.keywords("view").append(FormattingOptions.oneSpace);
+      }
+      f.keywords("of", "extends").surround(FormattingOptions.oneSpace);
+    });
+    this.on(node, ast.isDynamicView)?.keywords("dynamic", "view").append(FormattingOptions.oneSpace);
+  }
+  formatLeafProperty(node) {
+    if (ast.isElementStringProperty(node) || ast.isRelationStringProperty(node) || ast.isViewStringProperty(node) || ast.isNotationProperty(node) || ast.isSpecificationElementStringProperty(node) || ast.isSpecificationRelationshipStringProperty(node) || ast.isColorProperty(node) || ast.isLineProperty(node) || ast.isArrowProperty(node) || ast.isIconProperty(node) || ast.isShapeProperty(node) || ast.isBorderProperty(node) || ast.isOpacityProperty(node)) {
+      const formatter = this.getNodeFormatter(node);
+      const colon = formatter.keyword(":");
+      const propertyName = formatter.keywords(
+        "title",
+        "description",
+        "technology",
+        "notation",
+        "color",
+        "line",
+        "head",
+        "tail",
+        "icon",
+        "shape",
+        "border",
+        "opacity"
+      );
+      if (colon.nodes.length === 0) {
+        propertyName.append(FormattingOptions.oneSpace);
+      } else {
+        colon.prepend(FormattingOptions.noSpace).append(FormattingOptions.oneSpace);
+      }
+      formatter.keyword(";").prepend(FormattingOptions.noSpace).append(FormattingOptions.newLine);
+    }
+  }
+  formatLinkProperty(node) {
+    this.on(node, ast.isLinkProperty, (n, f) => {
+      f.keyword("link").append(FormattingOptions.oneSpace);
+      f.property("value").append(FormattingOptions.oneSpace);
+      f.keyword(":").prepend(FormattingOptions.noSpace).append(FormattingOptions.oneSpace);
+      f.keyword(";").prepend(FormattingOptions.noSpace).append(FormattingOptions.newLine);
+    });
+  }
+  formatNavigateToProperty(node) {
+    this.on(node, ast.isNavigateToProperty)?.property("key").append(FormattingOptions.oneSpace);
+  }
+  formatAutolayoutProperty(node) {
+    this.on(node, ast.isViewRuleAutoLayout, (n, f) => {
+      f.keyword("autoLayout").append(FormattingOptions.oneSpace);
+      f.property("rankSep").prepend(FormattingOptions.oneSpace);
+      f.property("nodeSep").prepend(FormattingOptions.oneSpace);
+    });
+  }
+  formatMetadataProperty(node) {
+    this.on(node, ast.isMetadataAttribute, (n, f) => {
+      f.property("key").append(FormattingOptions.oneSpace);
+      f.keyword(":").prepend(FormattingOptions.noSpace).append(FormattingOptions.oneSpace);
+      f.keyword(";").prepend(FormattingOptions.noSpace).append(FormattingOptions.newLine);
+    });
+  }
+  formatElementDeclaration(node) {
+    this.on(node, ast.isElement, (n, f) => {
+      const kind = GrammarUtils.findNodeForProperty(n.$cstNode, "kind");
+      const name = GrammarUtils.findNodeForProperty(n.$cstNode, "name");
+      if (name && kind) {
+        if (utils.compareRanges(name, kind) > 0) {
+          f.cst([kind]).append(FormattingOptions.oneSpace);
+        } else {
+          f.cst([name]).append(FormattingOptions.oneSpace);
+          f.cst([kind]).prepend(FormattingOptions.oneSpace);
+        }
+      }
+      f.properties("props").prepend(FormattingOptions.oneSpace);
+    });
+  }
+  formatGlobals(node) {
+    this.on(node, ast.isGlobalStyle, (n, f) => {
+      f.keyword("style").append(FormattingOptions.oneSpace);
+      f.property("id").append(FormattingOptions.oneSpace);
+    });
+    this.on(node, ast.isGlobalStyleGroup, (n, f) => {
+      f.keyword("styleGroup").append(FormattingOptions.oneSpace);
+    });
+  }
+  formatSpecificationRule(node) {
+    if (ast.isSpecificationElementKind(node) || ast.isSpecificationRelationshipKind(node) || ast.isSpecificationTag(node)) {
+      const formatter = this.getNodeFormatter(node);
+      formatter.keywords("element", "relationship", "tag").append(FormattingOptions.oneSpace);
+    }
+    if (ast.isSpecificationColor(node)) {
+      const formatter = this.getNodeFormatter(node);
+      formatter.keyword("color").append(FormattingOptions.oneSpace);
+      formatter.property("name").append(FormattingOptions.oneSpace);
+    }
+  }
+  formatWithPredicate(node) {
+    const formatter = this.getNodeFormatter(node);
+    if (ast.isElementPredicateWith(node) || ast.isRelationPredicateWith(node)) {
+      formatter.keyword("with").prepend(FormattingOptions.oneSpace);
+    }
+  }
+  formatViewRuleGlobalStyle(node) {
+    this.on(node, ast.isViewRuleGlobalStyle, (n, f) => {
+      f.keywords("global", "style").append(FormattingOptions.oneSpace);
+    });
+  }
+  formatViewRuleGroup(node) {
+    this.on(node, ast.isViewRuleGroup, (n, f) => {
+      f.keyword("group").append(FormattingOptions.oneSpace);
+    });
+  }
+  formatViewRuleStyle(node) {
+    this.on(node, ast.isViewRuleStyle)?.keyword("style").append(FormattingOptions.oneSpace);
+    this.on(node, ast.isElementExpressionsIterator)?.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);
+    }
+    if (ast.isWhereRelationExpression(node) || ast.isWhereElementExpression(node)) {
+      const formatter = this.getNodeFormatter(node);
+      formatter.property("operator").surround(FormattingOptions.oneSpace);
+    }
+    if (ast.isWhereElementNegation(node) || ast.isWhereRelationNegation(node)) {
+      const formatter = this.getNodeFormatter(node);
+      formatter.keyword("not").append(FormattingOptions.oneSpace);
+    }
+    if (ast.isWhereElement(node) || ast.isWhereElementTag(node) || ast.isWhereElementKind(node) || ast.isWhereRelation(node) || ast.isWhereRelationTag(node) || ast.isWhereRelationKind(node)) {
+      const formatter = this.getNodeFormatter(node);
+      formatter.property("operator").surround(FormattingOptions.oneSpace);
+      formatter.property("not").surround(FormattingOptions.oneSpace);
+    }
+  }
+  formatIncludeExcludeExpressions(node) {
+    if (ast.isDynamicViewRule(node) || ast.isIncludePredicate(node) || ast.isExcludePredicate(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)) {
+      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)) {
+        return parent;
+      }
+      parent = parent.$container;
+    }
+  }
+  on(node, predicate, format) {
+    const formatter = predicate(node) ? this.getNodeFormatter(node) : void 0;
+    format && formatter && format(node, formatter);
+    return formatter;
+  }
+}

package/dist/formatting/utils.d.ts

@@ -0,0 +1,6 @@
+import type { CstNode } from "langium";
+import type { Position, Range } from "vscode-languageserver-types";
+export declare function areOverlap(a: CstNode, b: CstNode): boolean;
+export declare function compareRanges(a: CstNode, b: CstNode): number;
+export declare function isInRagne(range: Range, pos: Position): boolean;
+export declare function isMultiline(node: CstNode): boolean;

package/dist/formatting/utils.js

@@ -0,0 +1,15 @@
+export function areOverlap(a, b) {
+  ;
+  [a, b] = compareRanges(a, b) > 0 ? [b, a] : [a, b];
+  return isInRagne(a.range, b.range.start);
+}
+export function compareRanges(a, b) {
+  const lineDiff = a.range.start.line - b.range.start.line;
+  return lineDiff !== 0 ? lineDiff : a.range.start.character - b.range.start.character;
+}
+export function isInRagne(range, pos) {
+  return !(pos.line < range.start.line || pos.line > range.end.line || pos.line == range.start.line && pos.character < range.start.character || pos.line == range.end.line && pos.character > range.end.character);
+}
+export function isMultiline(node) {
+  return node.range.start.line != node.range.end.line;
+}