@likec4/language-server 1.43.0 → 1.44.0

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);
-  }
-}

package/dist/lsp/HoverProvider.mjs

@@ -1,104 +0,0 @@
-import { FqnRef, preferSummary } from "@likec4/core";
-import { AstUtils } from "langium";
-import { AstNodeHoverProvider } from "langium/lsp";
-import { ast } from "../ast.mjs";
-export class LikeC4HoverProvider extends AstNodeHoverProvider {
-  parser;
-  locator;
-  constructor(services) {
-    super(services);
-    this.parser = services.likec4.ModelParser;
-    this.locator = services.likec4.ModelLocator;
-  }
-  getAstNodeHoverContent(node) {
-    if (ast.isTag(node)) {
-      return {
-        contents: {
-          kind: "markdown",
-          value: "tag `" + node.name + "`"
-        }
-      };
-    }
-    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}`);
-      }
-      lines.push("deployment node `" + el.kind + "` ");
-      const summary = preferSummary(el);
-      if (summary) {
-        lines.push("", summary.md ?? summary.txt);
-      }
-      return {
-        contents: {
-          kind: "markdown",
-          value: lines.join("\n")
-        }
-      };
-    }
-    if (ast.isDeployedInstance(node)) {
-      const doc = AstUtils.getDocument(node);
-      const instance = this.parser.forDocument(doc).parseDeployedInstance(node);
-      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 \`${FqnRef.flatten(instance.element)}\``];
-      if (el) {
-        lines.push(`### ${el.title}`, "element kind `" + el.kind + "` ");
-      }
-      return {
-        contents: {
-          kind: "markdown",
-          value: lines.join("\n")
-        }
-      };
-    }
-    if (ast.isElementKind(node)) {
-      return {
-        contents: {
-          kind: "markdown",
-          value: "element kind `" + node.name + "`"
-        }
-      };
-    }
-    if (ast.isDeploymentNodeKind(node)) {
-      return {
-        contents: {
-          kind: "markdown",
-          value: "deployment node `" + node.name + "`"
-        }
-      };
-    }
-    if (ast.isRelationshipKind(node)) {
-      return {
-        contents: {
-          kind: "markdown",
-          value: "relationship kind `" + node.name + "`"
-        }
-      };
-    }
-    if (ast.isElement(node)) {
-      const el = this.locator.getParsedElement(node);
-      if (!el) {
-        return;
-      }
-      const lines = [
-        el.id,
-        `### ${el.title}`,
-        "element kind `" + el.kind + "` "
-      ];
-      const summary = preferSummary(el);
-      if (summary) {
-        lines.push("", summary.md ?? summary.txt);
-      }
-      return {
-        contents: {
-          kind: "markdown",
-          value: lines.join("\n")
-        }
-      };
-    }
-    return;
-  }
-}

package/dist/lsp/RenameProvider.mjs

@@ -1,6 +0,0 @@
-import { DefaultRenameProvider } from "langium/lsp";
-export class LikeC4RenameProvider extends DefaultRenameProvider {
-  constructor(services) {
-    super(services);
-  }
-}

package/dist/lsp/SemanticTokenProvider.mjs

@@ -1,276 +0,0 @@
-import { invariant, isAnyOf, nonNullable } from "@likec4/core/utils";
-import {
-  AbstractSemanticTokenProvider
-} from "langium/lsp";
-import { isTruthy } from "remeda";
-import { SemanticTokenModifiers, SemanticTokenTypes } from "vscode-languageserver-types";
-import { ast } from "../ast.mjs";
-import { logger } from "../logger.mjs";
-const SemanticTypes = { ...SemanticTokenTypes };
-const SemanticModifiers = { ...SemanticTokenModifiers };
-function createSemanticTypeMethods(applyHighlight) {
-  const modifier = [];
-  const self = new Proxy({}, {
-    get(_, prop) {
-      if (prop === "modifier") {
-        return (mod) => {
-          modifier.push(mod);
-          return self;
-        };
-      }
-      if (prop in SemanticModifiers) {
-        modifier.push(SemanticModifiers[prop]);
-        return self;
-      }
-      if (prop in SemanticTypes) {
-        return () => applyHighlight(SemanticTypes[prop], modifier);
-      }
-      throw new Error(`Unknown semantic token type or modifier: ${prop}`);
-    }
-  });
-  return self;
-}
-const PRUNE = "Stop Highlighting";
-const stopHighlight = () => {
-  throw PRUNE;
-};
-export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
-  rules = [];
-  constructor(services) {
-    super(services);
-    this.initRules();
-  }
-  initRules() {
-    this.rules = [];
-    const when = (predicate, highlightFn) => {
-      const rule = { predicate, highlightFn };
-      this.rules.push(rule);
-    };
-    when(ast.isRelationshipKind, (mark) => {
-      mark.property("name").function();
-    });
-    when(isAnyOf(ast.isRelation, ast.isOutgoingRelationExpr, ast.isDeploymentRelation), (mark) => {
-      mark.property("kind").function();
-    });
-    when(ast.isLibIcon, (mark) => {
-      mark.property("name").definition.function();
-      stopHighlight();
-    });
-    when(isAnyOf(ast.isNavigateToProperty, ast.isRelationNavigateToProperty), (mark) => {
-      mark.property("value").readonly.definition.interface();
-      stopHighlight();
-    });
-    when(isAnyOf(ast.isFqnRefExpr, ast.isWildcardExpression), (mark) => {
-      mark.cst().readonly.definition.variable();
-      stopHighlight();
-    });
-    when(ast.isTagRef, (mark) => {
-      mark.cst().type();
-      stopHighlight();
-    });
-    when(ast.isRelationKindDotRef, (mark) => {
-      mark.cst().function();
-      stopHighlight();
-    });
-    when(ast.isWhereRelationKind, (mark) => {
-      if (isTruthy(mark.node.value)) {
-        mark.property("value").function();
-      }
-    });
-    when(isAnyOf(ast.isWhereElement, ast.isWhereRelation), (mark) => {
-      if (isTruthy(mark.node.value)) {
-        mark.property("value").readonly.definition.type();
-      }
-    });
-    when(isAnyOf(ast.isWhereRelationParticipantKind, ast.isWhereRelationParticipantTag), (mark) => {
-      mark.property("participant").keyword();
-    });
-    when(ast.isElementKindExpression, (mark) => {
-      if (isTruthy(mark.node.kind)) {
-        mark.property("kind").definition.type();
-      }
-    });
-    when(isAnyOf(ast.isGlobalStyleGroup, ast.isGlobalStyle), (mark) => {
-      mark.property("id").readonly.definition.variable();
-    });
-    when(ast.isViewRuleGlobalStyle, (mark) => {
-      mark.property("style").readonly.definition.variable();
-    });
-    when(isAnyOf(ast.isGlobalPredicateGroup, ast.isGlobalDynamicPredicateGroup), (mark) => {
-      mark.property("name").readonly.definition.variable();
-    });
-    when(ast.isViewRuleGlobalPredicateRef, (mark) => {
-      mark.property("predicate").readonly.definition.variable();
-    });
-    when(ast.isElementTagExpression, (mark) => {
-      if (isTruthy(mark.node.tag)) {
-        mark.property("tag").definition.type();
-      }
-    });
-    when(isAnyOf(ast.isFqnRef, ast.isStrictFqnRef), (mark) => {
-      mark.property("value").readonly.definition.variable();
-      if (!mark.node.parent) {
-        stopHighlight();
-      }
-    });
-    when(ast.isStrictFqnElementRef, (mark) => {
-      mark.property("el").readonly.definition.variable();
-      if (!mark.node.parent) {
-        stopHighlight();
-      }
-    });
-    when(ast.isSpecificationColor, (mark) => {
-      mark.keyword("color").keyword();
-      mark.property("name").readonly.declaration.type();
-    });
-    when(ast.isSpecificationTag, (mark) => {
-      if (isTruthy(mark.node.color)) {
-        mark.keyword("color").property();
-      }
-    });
-    when(
-      isAnyOf(
-        ast.isSpecificationElementKind,
-        ast.isSpecificationRelationshipKind,
-        ast.isSpecificationDeploymentNodeKind
-      ),
-      (mark) => {
-        mark.property("kind").readonly.declaration.type();
-      }
-    );
-    when(ast.isTag, (mark) => {
-      mark.property("name").definition.type();
-    });
-    when(ast.isOpacityProperty, (mark) => {
-      mark.property("value").number();
-    });
-    when(ast.isIconProperty, (mark) => {
-      if (mark.node.libicon || mark.node.value === "none") {
-        mark.property(mark.node.libicon ? "libicon" : "value").defaultLibrary.enum();
-        return;
-      }
-      mark.property("value").string();
-    });
-    when(ast.isLinkProperty, (mark) => {
-      if (isTruthy(mark.node.value)) {
-        mark.property("value").string();
-      }
-    });
-    when(ast.isColorProperty, (mark) => {
-      if (isTruthy(mark.node.customColor)) {
-        mark.property("customColor").enum();
-      }
-      if (isTruthy(mark.node.themeColor)) {
-        mark.property("themeColor").enum();
-      }
-    });
-    when(
-      isAnyOf(
-        ast.isShapeProperty,
-        ast.isArrowProperty,
-        ast.isLineProperty,
-        ast.isBorderProperty,
-        ast.isSizeProperty,
-        ast.isDynamicViewDisplayVariantProperty
-      ),
-      (mark) => {
-        if (isTruthy(mark.node.value)) {
-          mark.property("value").enum();
-        }
-      }
-    );
-  }
-  highlightElement(node, acceptor) {
-    try {
-      if (isAnyOf(ast.isElement, ast.isDeploymentNode, ast.isDeployedInstance)(node)) {
-        return this.highlightNameAndKind(node);
-      }
-      if (ast.isLikeC4View(node)) {
-        return this.highlightView(node);
-      }
-      if (ast.isAnyProperty(node) && !isAnyOf(
-        ast.isMetadataProperty,
-        ast.isElementStyleProperty,
-        ast.isRelationStyleProperty
-      )(node)) {
-        invariant(node.key);
-        acceptor({
-          node,
-          property: "key",
-          type: SemanticTokenTypes.property
-        });
-      }
-      for (const { predicate, highlightFn } of this.rules) {
-        if (predicate(node)) {
-          highlightFn(this.mark(node));
-          break;
-        }
-      }
-    } catch (error) {
-      if (error === PRUNE) {
-        return "prune";
-      }
-      logger.warn(`Error highlighting node of type ${node._type}`, { error });
-    }
-  }
-  highlightNameAndKind(node) {
-    const mark = this.mark(node);
-    mark.property("name").declaration.readonly.variable();
-    if (!ast.isDeployedInstance(node)) {
-      this.mark(node).property("kind").keyword();
-    }
-    if (ast.isElement(node)) {
-      if (node.props.length > 0) {
-        this.mark(node).property("props").string();
-      }
-      return;
-    }
-    if (node.title) {
-      this.mark(node).property("title").string();
-    }
-  }
-  highlightView(node) {
-    if (node.name) {
-      const mark = this.mark(node);
-      mark.property("name").modifier("local").declaration.readonly.interface();
-    }
-  }
-  mark(node) {
-    const cst = (cstNode) => {
-      return createSemanticTypeMethods(
-        (type, modifier) => this.highlightToken({
-          range: nonNullable(cstNode ?? node.$cstNode, "AST node has no CST node").range,
-          type,
-          modifier
-        })
-      );
-    };
-    const keyword = (keyword2) => {
-      return createSemanticTypeMethods(
-        (type, modifier) => this.highlightKeyword({
-          node,
-          keyword: keyword2,
-          type,
-          modifier
-        })
-      );
-    };
-    const property = (property2, index) => {
-      return createSemanticTypeMethods(
-        (type, modifier) => this.highlightProperty({
-          node,
-          property: property2,
-          type,
-          modifier,
-          ...index !== void 0 ? { index } : {}
-        })
-      );
-    };
-    return {
-      node,
-      cst,
-      keyword,
-      property
-    };
-  }
-}

package/dist/lsp/index.mjs

@@ -1,7 +0,0 @@
-export * from "./CodeLensProvider.mjs";
-export * from "./CompletionProvider.mjs";
-export * from "./DocumentHighlightProvider.mjs";
-export * from "./DocumentLinkProvider.mjs";
-export * from "./DocumentSymbolProvider.mjs";
-export * from "./HoverProvider.mjs";
-export * from "./SemanticTokenProvider.mjs";