@likec4/language-server 1.42.1 → 1.44.0

package/dist/logger.mjs

@@ -1,82 +0,0 @@
-import { nonexhaustive } from "@likec4/core/utils";
-import {
-  errorFromLogRecord,
-  getMessageOnlyFormatter,
-  getTextFormatter,
-  loggable,
-  logger as root
-} from "@likec4/log";
-export const logger = root.getChild("server");
-export {
-  logger as serverLogger
-};
-export function logError(err) {
-  logger.error(loggable(err));
-}
-export function logWarnError(err) {
-  logger.warn(loggable(err));
-}
-export function getLspConnectionSink(connection, props) {
-  const format = props?.formatter ?? getTextFormatter({
-    format: ({ category, message }) => {
-      return `${category} ${message}`;
-    }
-  });
-  return (logObj) => {
-    try {
-      switch (logObj.level) {
-        case "trace":
-        case "debug":
-          connection.console.debug(format(logObj));
-          break;
-        case "info":
-          connection.console.info(format(logObj));
-          break;
-        case "warning":
-          connection.console.warn(format(logObj));
-          break;
-        case "error":
-        case "fatal": {
-          connection.console.error(format(logObj));
-          break;
-        }
-        default:
-          nonexhaustive(logObj.level);
-      }
-    } catch (e) {
-      console.error("Error while logging to LSP connection:", e);
-    }
-  };
-}
-export function getTelemetrySink(connection) {
-  const messageOnly = getMessageOnlyFormatter();
-  return (logObj) => {
-    try {
-      switch (logObj.level) {
-        case "error":
-        case "fatal": {
-          const err = errorFromLogRecord(logObj);
-          if (err) {
-            connection.telemetry.logEvent({
-              eventName: "error",
-              message: `${err.name}: ${err.message}`,
-              category: logObj.category.join("."),
-              ...err.stack && {
-                stack: err.stack
-              }
-            });
-          } else {
-            connection.telemetry.logEvent({
-              eventName: "error",
-              message: messageOnly(logObj),
-              category: logObj.category.join(".")
-            });
-          }
-          break;
-        }
-      }
-    } catch (e) {
-      console.error("Error while logging to LSP connection:", e);
-    }
-  };
-}

package/dist/lsp/CodeLensProvider.mjs

@@ -1,42 +0,0 @@
-import { DocumentState } from "langium";
-import { isLikeC4LangiumDocument, ViewOps } from "../ast.mjs";
-import { logger } from "../logger.mjs";
-import { projectIdFrom } from "../utils/index.mjs";
-export class LikeC4CodeLensProvider {
-  constructor(services) {
-    this.services = services;
-  }
-  async provideCodeLens(doc, _params, cancelToken) {
-    if (!isLikeC4LangiumDocument(doc)) {
-      return;
-    }
-    if (doc.state <= DocumentState.Linked) {
-      logger.debug(`Waiting for document ${doc.uri.path} to be Linked`);
-      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Linked, doc.uri, cancelToken);
-      logger.debug(`Document is linked`);
-    }
-    const views = doc.parseResult.value.views.flatMap((v) => v.views);
-    return views.flatMap((ast) => {
-      const viewId = ViewOps.readId(ast);
-      const range = ast.$cstNode?.range;
-      if (!range || !viewId) {
-        return [];
-      }
-      const projectId = projectIdFrom(ast);
-      return {
-        range: {
-          start: range.start,
-          end: {
-            line: range.start.line,
-            character: range.start.character + 4
-          }
-        },
-        command: {
-          command: "likec4.open-preview",
-          arguments: [viewId, projectId],
-          title: "open preview"
-        }
-      };
-    });
-  }
-}

package/dist/lsp/CompletionProvider.mjs

@@ -1,208 +0,0 @@
-import { ThemeColors } from "@likec4/core/styles";
-import { AstUtils } from "langium";
-import {
-  DefaultCompletionProvider
-} from "langium/lsp";
-import { anyPass } from "remeda";
-import { CompletionItemKind, InsertTextFormat } from "vscode-languageserver-types";
-import { ast } from "../ast.mjs";
-const STYLE_FIELDS = [
-  "color",
-  "shape",
-  "icon",
-  "border",
-  "opacity",
-  "multiple",
-  "size",
-  "textSize"
-].join(",");
-export class LikeC4CompletionProvider extends DefaultCompletionProvider {
-  constructor(services) {
-    super(services);
-    this.services = services;
-  }
-  completionOptions = {
-    triggerCharacters: [".", "#"]
-  };
-  completionForKeyword(context, keyword, acceptor) {
-    if (!this.filterKeyword(context, keyword)) {
-      return;
-    }
-    switch (true) {
-      case keyword.value === "import":
-        acceptor(context, {
-          label: keyword.value,
-          kind: CompletionItemKind.Snippet,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} { $0 } from '\${1|${this.services.shared.workspace.ProjectsManager.all.join(",")}|}'`
-        });
-        break;
-      case (keyword.value === "deployment" && AstUtils.hasContainerOfType(context.node, ast.isModelViews)):
-        acceptor(context, {
-          label: keyword.value,
-          detail: `Insert deployment view`,
-          kind: CompletionItemKind.Class,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: [
-            "deployment view ${1:view_${TM_FILENAME_BASE}_${CURRENT_SECOND}} {",
-            "	title '${2:Untitled}'",
-            "	",
-            "	include $0",
-            "}"
-          ].join("\n")
-        });
-        break;
-      case ["title", "description", "technology", "link"].includes(keyword.value):
-        acceptor(context, {
-          label: keyword.value,
-          detail: `Insert ${keyword.value} property`,
-          kind: CompletionItemKind.Property,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} '\${0}'`
-        });
-        break;
-      case keyword.value === "color":
-        acceptor(context, {
-          label: keyword.value,
-          kind: CompletionItemKind.Property,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} \${1|${ThemeColors.join(",")}|}$0`
-        });
-        break;
-      case keyword.value === "opacity":
-        acceptor(context, {
-          label: keyword.value,
-          kind: CompletionItemKind.Property,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} \${0:100}%`
-        });
-        break;
-      case ["views", "specification", "model", "deployment", "with"].includes(keyword.value):
-        acceptor(context, {
-          label: keyword.value,
-          detail: `Insert ${keyword.value} block`,
-          kind: CompletionItemKind.Module,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} {
-	$0
-}`
-        });
-        break;
-      case keyword.value === "group":
-        acceptor(context, {
-          label: keyword.value,
-          detail: `Insert group block`,
-          kind: CompletionItemKind.Module,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: [
-            "group '${1:Title}' {",
-            "	$0",
-            "}"
-          ].join("\n")
-        });
-        break;
-      case ["par", "parallel"].includes(keyword.value):
-        acceptor(context, {
-          label: keyword.value,
-          detail: `Insert block of parallel steps`,
-          kind: CompletionItemKind.Module,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: [
-            `${keyword.value} {`,
-            "	$0",
-            "}"
-          ].join("\n")
-        });
-        break;
-      case (keyword.value === "dynamic" && AstUtils.hasContainerOfType(context.node, ast.isModelViews)):
-        acceptor(context, {
-          label: keyword.value,
-          detail: `Insert dynamic view`,
-          kind: CompletionItemKind.Class,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: [
-            "dynamic view ${1:view_${TM_FILENAME_BASE}_${CURRENT_SECOND}} {",
-            "	title '${2:Untitled}'",
-            "	",
-            "	$0",
-            "}"
-          ].join("\n")
-        });
-        break;
-      case (keyword.value === "style" && context.node && AstUtils.hasContainerOfType(context.node, ast.isGlobalStyle)):
-        acceptor(context, {
-          label: keyword.value,
-          detail: `Insert ${keyword.value} block`,
-          kind: CompletionItemKind.Module,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} \${1:name} \${2:*} {
-	\${3|${STYLE_FIELDS}|} $0
-}`
-        });
-        break;
-      case (keyword.value === "style" && context.node && AstUtils.hasContainerOfType(context.node, anyPass([ast.isModelViews, ast.isGlobalStyleGroup]))):
-        acceptor(context, {
-          label: keyword.value,
-          detail: `Insert ${keyword.value} block`,
-          kind: CompletionItemKind.Module,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} \${1:*} {
-	\${2|${STYLE_FIELDS}|} $0
-}`
-        });
-        break;
-      case keyword.value === "style":
-        acceptor(context, {
-          label: keyword.value,
-          detail: `Insert ${keyword.value} block`,
-          kind: CompletionItemKind.Module,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} {
-	\${1|${STYLE_FIELDS}|} $0
-}`
-        });
-        break;
-      case keyword.value === "extend":
-        acceptor(context, {
-          label: keyword.value,
-          detail: `Extend another view`,
-          kind: CompletionItemKind.Class,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: "extend $1 {\n	$0\n}"
-        });
-        break;
-      case keyword.value === "autoLayout":
-        acceptor(context, {
-          label: keyword.value,
-          kind: CompletionItemKind.Property,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: "autoLayout ${1|TopBottom,BottomTop,LeftRight,RightLeft|}$0"
-        });
-        break;
-      case keyword.value === "mode":
-        acceptor(context, {
-          label: keyword.value,
-          kind: CompletionItemKind.Property,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: "mode ${1|sequence,diagram|}$0"
-        });
-        break;
-      case ["include", "exclude"].includes(keyword.value):
-        acceptor(context, {
-          label: keyword.value,
-          kind: CompletionItemKind.Operator,
-          detail: `Insert ${keyword.value} predicate`,
-          insertTextFormat: InsertTextFormat.PlainText,
-          insertText: `${keyword.value} `
-        });
-        break;
-      default:
-        acceptor(context, {
-          label: keyword.value,
-          kind: this.getKeywordCompletionItemKind(keyword),
-          detail: "Keyword",
-          sortText: "1"
-        });
-    }
-  }
-}

package/dist/lsp/DocumentHighlightProvider.mjs

@@ -1,10 +0,0 @@
-import { DefaultDocumentHighlightProvider } from "langium/lsp";
-import { DocumentHighlight, DocumentHighlightKind } from "vscode-languageserver";
-export class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
-  /**
-   * Override this method to determine the highlight kind of the given reference.
-   */
-  createDocumentHighlight(reference) {
-    return DocumentHighlight.create(reference.segment.range, DocumentHighlightKind.Read);
-  }
-}

package/dist/lsp/DocumentLinkProvider.mjs

@@ -1,53 +0,0 @@
-import { AstUtils, GrammarUtils } from "langium";
-import { hasLeadingSlash, hasProtocol, isRelative, joinRelativeURL, withoutBase, withoutLeadingSlash } from "ufo";
-import { ast, isLikeC4LangiumDocument } from "../ast.mjs";
-import { logWarnError } from "../logger.mjs";
-export class LikeC4DocumentLinkProvider {
-  constructor(services) {
-    this.services = services;
-  }
-  async getDocumentLinks(doc, _params, _cancelToken) {
-    if (!isLikeC4LangiumDocument(doc) || this.services.likec4.LanguageServices.isExcluded(doc)) {
-      return [];
-    }
-    return AstUtils.streamAllContents(doc.parseResult.value).filter(ast.isLinkProperty).map((n) => {
-      try {
-        const range = GrammarUtils.findNodeForProperty(n.$cstNode, "value")?.range;
-        const target = range && this.resolveLink(doc, n.value);
-        if (target && hasProtocol(target)) {
-          return {
-            range,
-            target
-          };
-        }
-      } catch (e) {
-        logWarnError(e);
-      }
-      return null;
-    }).nonNullable().toArray();
-  }
-  resolveLink(doc, link) {
-    if (hasProtocol(link) || hasLeadingSlash(link)) {
-      return link;
-    }
-    if (isRelative(link)) {
-      return joinRelativeURL(doc.uri.toString(), "../", link);
-    }
-    const base = this.services.shared.workspace.ProjectsManager.getProject(doc).folderUri;
-    return joinRelativeURL(base.toString(), link);
-  }
-  relativeLink(doc, link) {
-    if (hasLeadingSlash(link)) {
-      return withoutLeadingSlash(link);
-    }
-    if (isRelative(link)) {
-      const base = this.services.shared.workspace.ProjectsManager.getProject(doc).folderUri.toString();
-      const docURL = new URL(doc.uri.toString());
-      const linkURL = new URL(link, docURL).toString();
-      return withoutLeadingSlash(
-        withoutBase(linkURL, base)
-      );
-    }
-    return null;
-  }
-}

package/dist/lsp/DocumentSymbolProvider.mjs

@@ -1,287 +0,0 @@
-import { nonexhaustive } from "@likec4/core";
-import { AstUtils, DocumentState, GrammarUtils } from "langium";
-import { filter, isEmpty, isTruthy, map, pipe } from "remeda";
-import { SymbolKind } from "vscode-languageserver-types";
-import { ast, isLikeC4LangiumDocument } from "../ast.mjs";
-import { logger as rootLogger, logWarnError } from "../logger.mjs";
-import { readStrictFqn } from "../utils/elementRef.mjs";
-const logger = rootLogger.getChild("DocumentSymbolProvider");
-export class LikeC4DocumentSymbolProvider {
-  constructor(services) {
-    this.services = services;
-    this.nodeKindProvider = services.shared.lsp.NodeKindProvider;
-    this.parser = services.likec4.ModelParser;
-    this.locator = services.likec4.ModelLocator;
-    this.nameProvider = services.references.NameProvider;
-  }
-  nodeKindProvider;
-  nameProvider;
-  parser;
-  locator;
-  async getSymbols(doc, _params, cancelToken) {
-    if (!isLikeC4LangiumDocument(doc) || this.services.likec4.LanguageServices.isExcluded(doc)) {
-      return [];
-    }
-    if (doc.state <= DocumentState.Linked) {
-      logger.debug(`Waiting for document ${doc.uri.path} to be Linked`);
-      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Linked, doc.uri, cancelToken);
-      logger.debug(`document is Linked`);
-    }
-    const {
-      parseResult: {
-        value: { specifications, models, deployments, views, likec4lib }
-      }
-    } = doc;
-    return [
-      ...likec4lib.map((l) => () => this.getLikec4LibSymbol(l)),
-      ...specifications.map((s) => () => this.getSpecSymbol(s)),
-      ...models.map((s) => () => this.getModelSymbol(s)),
-      ...deployments.map((s) => () => this.getDeploymentModelSymbol(s)),
-      ...views.map((s) => () => this.getModelViewsSymbol(s))
-    ].flatMap((fn) => {
-      try {
-        return fn() ?? [];
-      } catch (e) {
-        logWarnError(e);
-        return [];
-      }
-    });
-  }
-  getLikec4LibSymbol(astLib) {
-    const cstModel = astLib?.$cstNode;
-    if (!cstModel) return [];
-    const children = astLib.icons.map((i) => this.getLibIconSymbol(i)).filter(isTruthy);
-    if (children.length === 0) return [];
-    return [
-      {
-        kind: SymbolKind.Namespace,
-        name: "icons",
-        range: cstModel.range,
-        selectionRange: GrammarUtils.findNodeForKeyword(cstModel, "icons")?.range ?? cstModel.range,
-        children
-      }
-    ];
-  }
-  getSpecSymbol(astSpec) {
-    const cstModel = astSpec?.$cstNode;
-    if (!cstModel) return [];
-    const specKeywordNode = GrammarUtils.findNodeForProperty(cstModel, "name");
-    if (!specKeywordNode) return [];
-    const specSymbols = pipe(
-      [...astSpec.elements, ...astSpec.tags, ...astSpec.relationships],
-      map((nd) => {
-        try {
-          if (ast.isSpecificationElementKind(nd) || ast.isSpecificationRelationshipKind(nd) || ast.isSpecificationDeploymentNodeKind(nd)) {
-            return this.getKindSymbol(nd);
-          }
-          if (ast.isSpecificationTag(nd)) {
-            return this.getTagSymbol(nd);
-          }
-        } catch (e) {
-          logWarnError(e);
-          return null;
-        }
-        nonexhaustive(nd);
-      }),
-      filter(isTruthy)
-    );
-    if (specSymbols.length === 0) return [];
-    return [
-      {
-        kind: SymbolKind.Namespace,
-        name: astSpec.name,
-        range: cstModel.range,
-        selectionRange: specKeywordNode.range,
-        children: specSymbols
-      }
-    ];
-  }
-  getModelSymbol(astModel) {
-    const cstModel = astModel.$cstNode;
-    if (!cstModel) return [];
-    const nameNode = GrammarUtils.findNodeForProperty(cstModel, "name");
-    if (!nameNode) return [];
-    return [
-      {
-        kind: this.symbolKind(astModel),
-        name: astModel.name,
-        range: cstModel.range,
-        selectionRange: nameNode.range,
-        children: astModel.elements.flatMap((e) => this.getElementsSymbol(e))
-      }
-    ];
-  }
-  getDeploymentModelSymbol(astModel) {
-    const cstModel = astModel.$cstNode;
-    if (!cstModel) return [];
-    const nameNode = GrammarUtils.findNodeForProperty(cstModel, "name");
-    if (!nameNode) return [];
-    return [
-      {
-        kind: this.symbolKind(astModel),
-        name: astModel.name,
-        range: cstModel.range,
-        selectionRange: nameNode.range,
-        children: astModel.elements.flatMap((e) => this.getDeploymentElementSymbol(e))
-      }
-    ];
-  }
-  getElementsSymbol(el) {
-    try {
-      if (ast.isExtendElement(el)) {
-        return this.getExtendElementSymbol(el);
-      }
-      if (ast.isElement(el)) {
-        return this.getElementSymbol(el);
-      }
-    } catch (e) {
-      logWarnError(e);
-    }
-    return [];
-  }
-  getExtendElementSymbol(astElement) {
-    const cst = astElement.$cstNode;
-    const nameNode = astElement.element.$cstNode;
-    const body = astElement.body;
-    if (!cst || !nameNode) return [];
-    return [
-      {
-        kind: this.symbolKind(astElement),
-        name: readStrictFqn(astElement.element),
-        range: cst.range,
-        selectionRange: nameNode.range,
-        children: body.elements.flatMap((e) => this.getElementsSymbol(e))
-      }
-    ];
-  }
-  getElementSymbol(astElement) {
-    const cst = astElement.$cstNode;
-    const nameNode = GrammarUtils.findNodeForProperty(cst, "name");
-    if (!nameNode || !cst) return [];
-    const name = astElement.name;
-    const kind = astElement.kind.$refText;
-    const detail = kind;
-    return [
-      {
-        kind: this.symbolKind(astElement),
-        name,
-        range: cst.range,
-        selectionRange: nameNode.range,
-        detail,
-        children: astElement.body?.elements.flatMap((e) => this.getElementsSymbol(e)) ?? []
-      }
-    ];
-  }
-  getModelViewsSymbol(astViews) {
-    const cst = astViews.$cstNode;
-    const nameNode = GrammarUtils.findNodeForProperty(cst, "name");
-    if (!nameNode || !cst) return [];
-    return [
-      {
-        kind: this.symbolKind(astViews),
-        name: astViews.name,
-        range: cst.range,
-        selectionRange: nameNode.range,
-        children: astViews.views.flatMap((e) => this.getViewSymbol(e))
-      }
-    ];
-  }
-  getKindSymbol(astKind) {
-    if (!astKind.$cstNode || !astKind.kind.$cstNode || isEmpty(astKind.kind.name)) return null;
-    return {
-      kind: this.symbolKind(astKind),
-      name: astKind.kind.name,
-      range: astKind.$cstNode.range,
-      selectionRange: astKind.kind.$cstNode.range
-    };
-  }
-  getTagSymbol(astTag) {
-    if (!astTag.$cstNode || !astTag.tag.$cstNode || isEmpty(astTag.tag.name)) return null;
-    return {
-      kind: this.symbolKind(astTag),
-      name: "#" + astTag.tag.name,
-      range: astTag.$cstNode.range,
-      selectionRange: astTag.tag.$cstNode.range
-    };
-  }
-  getLibIconSymbol(astTag) {
-    if (!astTag.$cstNode || isEmpty(astTag.name)) return null;
-    return {
-      kind: this.symbolKind(astTag),
-      name: astTag.name,
-      range: astTag.$cstNode.range,
-      selectionRange: astTag.$cstNode.range
-    };
-  }
-  getViewSymbol(astView) {
-    const cst = astView?.$cstNode;
-    if (!cst) return [];
-    const nameNode = astView.name ? GrammarUtils.findNodeForProperty(cst, "name") : null;
-    if (!nameNode) return [];
-    return [
-      {
-        kind: this.symbolKind(astView),
-        name: nameNode.text,
-        range: cst.range,
-        selectionRange: nameNode.range,
-        children: []
-      }
-    ];
-  }
-  getDeploymentElementSymbol(el) {
-    try {
-      if (ast.isDeploymentNode(el)) {
-        return this.getDeploymentNodeSymbol(el);
-      }
-      if (ast.isDeployedInstance(el)) {
-        return this.getDeployedInstanceSymbol(el);
-      }
-      if (ast.isExtendDeployment(el)) {
-        return [];
-      }
-    } catch (e) {
-      logWarnError(e);
-    }
-    return [];
-  }
-  getDeploymentNodeSymbol(astElement) {
-    const cst = astElement.$cstNode;
-    const nameNode = this.nameProvider.getNameNode(astElement);
-    if (!nameNode || !cst) return [];
-    const name = this.nameProvider.getNameStrict(astElement);
-    const kind = astElement.kind.$refText;
-    const detail = kind;
-    return [
-      {
-        kind: this.symbolKind(astElement),
-        name,
-        range: cst.range,
-        selectionRange: nameNode.range,
-        detail,
-        children: astElement.body?.elements.flatMap((e) => this.getDeploymentElementSymbol(e)) ?? []
-      }
-    ];
-  }
-  getDeployedInstanceSymbol(astElement) {
-    const cst = astElement.$cstNode;
-    const nameNode = this.nameProvider.getNameNode(astElement);
-    if (!nameNode || !cst) return [];
-    const doc = AstUtils.getDocument(astElement);
-    const instance = this.parser.forDocument(doc).parseDeployedInstance(astElement);
-    const name = this.nameProvider.getNameStrict(astElement);
-    const detail = "instance of " + instance.element.model;
-    return [
-      {
-        kind: this.symbolKind(astElement),
-        name,
-        range: cst.range,
-        selectionRange: nameNode.range,
-        detail,
-        children: []
-      }
-    ];
-  }
-  symbolKind(node) {
-    return this.nodeKindProvider.getSymbolKind(node);
-  }
-}