@likec4/language-server 0.37.1 → 0.40.0

package/dist/lsp/HoverProvider.js

@@ -1,55 +1,42 @@
-import { AstNodeHoverProvider } from 'langium';
-import stripIndent from 'strip-indent';
-import { ast } from '../ast';
+import { AstNodeHoverProvider } from "langium";
+import stripIndent from "strip-indent";
+import { ast } from "../ast.js";
 export class LikeC4HoverProvider extends AstNodeHoverProvider {
-    locator;
-    constructor(services) {
-        super(services);
-        this.locator = services.likec4.ModelLocator;
-    }
-    getAstNodeHoverContent(node) {
-        if (ast.isTag(node)) {
-            return {
-                contents: {
-                    kind: 'markdown',
-                    value: stripIndent(`
+  locator;
+  constructor(services) {
+    super(services);
+    this.locator = services.likec4.ModelLocator;
+  }
+  getAstNodeHoverContent(node) {
+    if (ast.isTag(node)) {
+      return {
+        contents: {
+          kind: "markdown",
+          value: stripIndent(`
             tag: \`${node.name}\`
           `)
-                }
-            };
-        }
-        // if (ast.isElementKind(node)) {
-        //   const spec = this.specIndex.get(node.name as ElementKind)
-        //   return {
-        //     contents: {
-        //       kind: 'markdown',
-        //       value: stripIndent(`
-        //         kind: **${spec.id}**
-        //         shape: ${spec.style.shape}
-        //       `)
-        //     }
-        //   }
-        // }
-        if (ast.isElement(node)) {
-            const el = this.locator.getParsedElement(node);
-            if (!el) {
-                return;
-            }
-            const lines = [el.id, `${el.kind}: **${el.title}**`];
-            if (el.tags && el.tags.length > 0) {
-                lines.push('  \n', el.tags.map(t => '#' + t).join(', '));
-            }
-            if (el.description) {
-                lines.push('  \n', el.description);
-            }
-            return {
-                contents: {
-                    kind: 'markdown',
-                    value: lines.join('  \n')
-                }
-            };
         }
+      };
+    }
+    if (ast.isElement(node)) {
+      const el = this.locator.getParsedElement(node);
+      if (!el) {
         return;
+      }
+      const lines = [el.id, `${el.kind}: **${el.title}**`];
+      if (el.tags && el.tags.length > 0) {
+        lines.push("  \n", el.tags.map((t) => "#" + t).join(", "));
+      }
+      if (el.description) {
+        lines.push("  \n", el.description);
+      }
+      return {
+        contents: {
+          kind: "markdown",
+          value: lines.join("  \n")
+        }
+      };
     }
+    return;
+  }
 }
-//# sourceMappingURL=HoverProvider.js.map

package/dist/lsp/SemanticTokenProvider.d.ts

@@ -4,4 +4,3 @@ export declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenPr
     private highlightAstElement;
     private highlightView;
 }
-//# sourceMappingURL=SemanticTokenProvider.d.ts.map

package/dist/lsp/SemanticTokenProvider.js

@@ -1,210 +1,162 @@
-import { AbstractSemanticTokenProvider } from 'langium';
-import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-protocol';
-import { ast } from '../ast';
-import { isElementRefHead } from '../elementRef';
+import { AbstractSemanticTokenProvider } from "langium";
+import { SemanticTokenModifiers, SemanticTokenTypes } from "vscode-languageserver-protocol";
+import { ast } from "../ast.js";
+import { isElementRefHead } from "../elementRef.js";
 export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
-    highlightElement(node, acceptor) {
-        const keyword = (keyword, _index) => acceptor({
-            node,
-            keyword,
-            type: SemanticTokenTypes.keyword,
-            modifier: [SemanticTokenModifiers.defaultLibrary]
-        });
-        if ('arr' in node) {
-            acceptor({
-                node,
-                property: 'arr',
-                type: SemanticTokenTypes.keyword,
-                modifier: [SemanticTokenModifiers.defaultLibrary]
-            });
-        }
-        if (ast.isElementRef(node) || ast.isStrictElementRef(node)) {
-            acceptor({
-                node,
-                property: 'el',
-                type: isElementRefHead(node) ? SemanticTokenTypes.variable : SemanticTokenTypes.property
-            });
-            return;
-        }
-        if (ast.isElementViewRef(node)) {
-            acceptor({
-                node,
-                property: 'view',
-                type: SemanticTokenTypes.variable
-            });
-            return;
-        }
-        if (ast.isWildcardExpression(node)) {
-            acceptor({
-                node,
-                property: 'isWildcard',
-                type: SemanticTokenTypes.variable
-            });
-            return;
-        }
-        // if (
-        //   ast.isRelation(node) ||
-        //   ast.isRelationExpression(node) ||
-        //   ast.isIncomingExpression(node) ||
-        //   ast.isInOutExpression(node) ||
-        //   ast.isOutgoingExpression(node)
-        // ) {
-        //   acceptor({
-        //     node,
-        //     property: 'arr',
-        //     type: SemanticTokenTypes.keyword,
-        //     modifier: [SemanticTokenModifiers.defaultLibrary]
-        //   })
-        // }
-        if (ast.isElementKindExpression(node) || ast.isElementTagExpression(node)) {
-            keyword('element');
-            if (ast.isElementKindExpression(node)) {
-                keyword('kind');
-                acceptor({
-                    node,
-                    property: 'kind',
-                    type: SemanticTokenTypes.type,
-                    modifier: [SemanticTokenModifiers.definition]
-                });
-                return;
-            }
-            if (ast.isElementTagExpression(node)) {
-                keyword('tag');
-                acceptor({
-                    node,
-                    property: 'tag',
-                    type: SemanticTokenTypes.type,
-                    modifier: [SemanticTokenModifiers.definition]
-                });
-                return;
-            }
-        }
-        if (ast.isRelation(node)) {
-            if ('title' in node) {
-                acceptor({
-                    node,
-                    property: 'title',
-                    type: SemanticTokenTypes.string
-                });
-            }
-            return;
-        }
-        if (ast.isElementKind(node)) {
-            acceptor({
-                node,
-                property: 'name',
-                type: SemanticTokenTypes.type,
-                modifier: [SemanticTokenModifiers.definition]
-            });
-            return;
-        }
-        if (ast.isTags(node)) {
-            acceptor({
-                node,
-                property: 'value',
-                type: SemanticTokenTypes.type,
-                modifier: [SemanticTokenModifiers.definition]
-            });
-            return;
-        }
-        if (ast.isTag(node)) {
-            acceptor({
-                node,
-                property: 'name',
-                type: SemanticTokenTypes.type,
-                modifier: [SemanticTokenModifiers.definition]
-            });
-            return;
-        }
-        if (ast.isColorProperty(node) || ast.isShapeProperty(node)) {
-            acceptor({
-                node,
-                property: 'key',
-                type: SemanticTokenTypes.keyword
-            });
-            acceptor({
-                node,
-                property: 'value',
-                type: SemanticTokenTypes.enum
-            });
-            return;
-        }
-        if (ast.isLinkProperty(node) || ast.isIconProperty(node)) {
-            acceptor({
-                node,
-                property: 'key',
-                type: SemanticTokenTypes.keyword
-            });
-            acceptor({
-                node,
-                property: 'value',
-                type: SemanticTokenTypes.string
-            });
-            return;
-        }
-        // ViewProperty | ElementStringProperty | RelationStringProperty | LinkProperty
-        // if (
-        //   ast.isViewProperty(node) ||
-        //   ast.isElementStringProperty(node) ||
-        //   ast.isRelationStringProperty(node) ||
-        //   ast.isLinkProperty(node) ||
-        //   ast.isIconProperty(node)
-        // ) {
-        //   acceptor({
-        //     node,
-        //     property: 'key',
-        //     type: SemanticTokenTypes.keyword
-        //     // type: SemanticTokenTypes.property,
-        //     // modifier: [
-        //     //   SemanticTokenModifiers.readonly,
-        //     //   SemanticTokenModifiers.declaration
-        //     // ]
-        //   })
-        //   acceptor({
-        //     node,
-        //     property: 'value',
-        //     type: SemanticTokenTypes.string
-        //   })
-        //   return
-        // }
-        // if (ast.isModel(node)) {
-        //   keyword('model')
-        //   return
-        // }
-        // if (ast.isModelViews(node)) {
-        //   keyword('views')
-        //   return
-        // }
-        if (ast.isElement(node)) {
-            return this.highlightAstElement(node, acceptor);
-        }
-        if (ast.isView(node)) {
-            return this.highlightView(node, acceptor);
-        }
+  highlightElement(node, acceptor) {
+    const keyword = (keyword2, _index) => acceptor({
+      node,
+      keyword: keyword2,
+      type: SemanticTokenTypes.keyword,
+      modifier: [SemanticTokenModifiers.defaultLibrary]
+    });
+    if ("arr" in node) {
+      acceptor({
+        node,
+        property: "arr",
+        type: SemanticTokenTypes.keyword,
+        modifier: [SemanticTokenModifiers.defaultLibrary]
+      });
+    }
+    if (ast.isElementRef(node) || ast.isStrictElementRef(node)) {
+      acceptor({
+        node,
+        property: "el",
+        type: isElementRefHead(node) ? SemanticTokenTypes.variable : SemanticTokenTypes.property
+      });
+      return;
+    }
+    if (ast.isElementViewRef(node)) {
+      acceptor({
+        node,
+        property: "view",
+        type: SemanticTokenTypes.variable
+      });
+      return;
+    }
+    if (ast.isWildcardExpression(node)) {
+      acceptor({
+        node,
+        property: "isWildcard",
+        type: SemanticTokenTypes.variable
+      });
+      return;
     }
-    highlightAstElement(node, acceptor) {
+    if (ast.isElementKindExpression(node) || ast.isElementTagExpression(node)) {
+      keyword("element");
+      if (ast.isElementKindExpression(node)) {
+        keyword("kind");
         acceptor({
-            node,
-            property: 'name',
-            type: SemanticTokenTypes.variable,
-            modifier: [SemanticTokenModifiers.declaration]
+          node,
+          property: "kind",
+          type: SemanticTokenTypes.type,
+          modifier: [SemanticTokenModifiers.definition]
         });
+        return;
+      }
+      if (ast.isElementTagExpression(node)) {
+        keyword("tag");
+        acceptor({
+          node,
+          property: "tag",
+          type: SemanticTokenTypes.type,
+          modifier: [SemanticTokenModifiers.definition]
+        });
+        return;
+      }
+    }
+    if (ast.isRelation(node)) {
+      if ("title" in node) {
         acceptor({
-            node,
-            property: 'kind',
-            type: SemanticTokenTypes.keyword,
-            modifier: []
+          node,
+          property: "title",
+          type: SemanticTokenTypes.string
         });
+      }
+      return;
+    }
+    if (ast.isElementKind(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.type,
+        modifier: [SemanticTokenModifiers.definition]
+      });
+      return;
+    }
+    if (ast.isTags(node)) {
+      acceptor({
+        node,
+        property: "value",
+        type: SemanticTokenTypes.type,
+        modifier: [SemanticTokenModifiers.definition]
+      });
+      return;
+    }
+    if (ast.isTag(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.type,
+        modifier: [SemanticTokenModifiers.definition]
+      });
+      return;
+    }
+    if (ast.isColorProperty(node) || ast.isShapeProperty(node)) {
+      acceptor({
+        node,
+        property: "key",
+        type: SemanticTokenTypes.keyword
+      });
+      acceptor({
+        node,
+        property: "value",
+        type: SemanticTokenTypes.enum
+      });
+      return;
+    }
+    if (ast.isLinkProperty(node) || ast.isIconProperty(node)) {
+      acceptor({
+        node,
+        property: "key",
+        type: SemanticTokenTypes.keyword
+      });
+      acceptor({
+        node,
+        property: "value",
+        type: SemanticTokenTypes.string
+      });
+      return;
+    }
+    if (ast.isElement(node)) {
+      return this.highlightAstElement(node, acceptor);
+    }
+    if (ast.isView(node)) {
+      return this.highlightView(node, acceptor);
     }
-    highlightView(node, acceptor) {
-        if (node.name) {
-            acceptor({
-                node,
-                property: 'name',
-                type: SemanticTokenTypes.variable,
-                modifier: [SemanticTokenModifiers.declaration]
-            });
-        }
+  }
+  highlightAstElement(node, acceptor) {
+    acceptor({
+      node,
+      property: "name",
+      type: SemanticTokenTypes.variable,
+      modifier: [SemanticTokenModifiers.declaration]
+    });
+    acceptor({
+      node,
+      property: "kind",
+      type: SemanticTokenTypes.keyword,
+      modifier: []
+    });
+  }
+  highlightView(node, acceptor) {
+    if (node.name) {
+      acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.variable,
+        modifier: [SemanticTokenModifiers.declaration]
+      });
     }
+  }
 }
-//# sourceMappingURL=SemanticTokenProvider.js.map

package/dist/lsp/index.d.ts

@@ -3,4 +3,3 @@ export * from './DocumentLinkProvider';
 export * from './DocumentSymbolProvider';
 export * from './HoverProvider';
 export * from './SemanticTokenProvider';
-//# sourceMappingURL=index.d.ts.map

package/dist/lsp/index.js

@@ -1,6 +1,5 @@
-export * from './CodeLensProvider';
-export * from './DocumentLinkProvider';
-export * from './DocumentSymbolProvider';
-export * from './HoverProvider';
-export * from './SemanticTokenProvider';
-//# sourceMappingURL=index.js.map
+export * from "./CodeLensProvider.js";
+export * from "./DocumentLinkProvider.js";
+export * from "./DocumentSymbolProvider.js";
+export * from "./HoverProvider.js";
+export * from "./SemanticTokenProvider.js";

package/dist/model/fqn-computation.d.ts

@@ -1,4 +1,3 @@
 import { type LikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare function computeDocumentFqn(document: LikeC4LangiumDocument, services: LikeC4Services): void;
-//# sourceMappingURL=fqn-computation.d.ts.map

package/dist/model/fqn-computation.js

@@ -1,44 +1,43 @@
-import { AsFqn, nonexhaustive } from '@likec4/core';
-import { MultiMap } from 'langium';
-import { isEmpty, isNil } from 'remeda';
-import { ElementOps, ast } from '../ast';
-import { fqnElementRef } from '../elementRef';
+import { AsFqn, nonexhaustive } from "@likec4/core";
+import { MultiMap } from "langium";
+import { isEmpty, isNil } from "remeda";
+import { ElementOps, ast } from "../ast.js";
+import { fqnElementRef } from "../elementRef.js";
 export function computeDocumentFqn(document, services) {
-    const c4fqns = (document.c4fqns = new MultiMap());
-    const { model } = document.parseResult.value;
-    if (!model?.elements) {
-        return;
+  const c4fqns = document.c4fqns = new MultiMap();
+  const { model } = document.parseResult.value;
+  if (!model?.elements) {
+    return;
+  }
+  const locator = services.workspace.AstNodeLocator;
+  const traverseStack = model.elements.map((el) => [el, null]);
+  let pair;
+  while (pair = traverseStack.shift()) {
+    const [el, parent] = pair;
+    if (ast.isRelation(el)) {
+      continue;
     }
-    const locator = services.workspace.AstNodeLocator;
-    const traverseStack = model.elements.map(el => [el, null]);
-    let pair;
-    while ((pair = traverseStack.shift())) {
-        const [el, parent] = pair;
-        if (ast.isRelation(el)) {
-            continue;
-        }
-        if (ast.isExtendElement(el)) {
-            if (!isNil(el.body) && !isEmpty(el.body.elements)) {
-                const fqn = fqnElementRef(el.element);
-                el.body.elements.forEach(child => traverseStack.push([child, fqn]));
-            }
-            continue;
-        }
-        if (ast.isElement(el)) {
-            const fqn = AsFqn(el.name, parent);
-            const path = locator.getAstNodePath(el);
-            c4fqns.add(fqn, {
-                el: new WeakRef(el),
-                path,
-                name: el.name
-            });
-            ElementOps.writeId(el, fqn);
-            if (!isNil(el.body) && !isEmpty(el.body.elements)) {
-                el.body.elements.forEach(child => traverseStack.push([child, fqn]));
-            }
-            continue;
-        }
-        nonexhaustive(el);
+    if (ast.isExtendElement(el)) {
+      if (!isNil(el.body) && !isEmpty(el.body.elements)) {
+        const fqn = fqnElementRef(el.element);
+        el.body.elements.forEach((child) => traverseStack.push([child, fqn]));
+      }
+      continue;
     }
+    if (ast.isElement(el)) {
+      const fqn = AsFqn(el.name, parent);
+      const path = locator.getAstNodePath(el);
+      c4fqns.add(fqn, {
+        el: new WeakRef(el),
+        path,
+        name: el.name
+      });
+      ElementOps.writeId(el, fqn);
+      if (!isNil(el.body) && !isEmpty(el.body.elements)) {
+        el.body.elements.forEach((child) => traverseStack.push([child, fqn]));
+      }
+      continue;
+    }
+    nonexhaustive(el);
+  }
 }
-//# sourceMappingURL=fqn-computation.js.map

package/dist/model/fqn-index.d.ts

@@ -27,4 +27,3 @@ export declare class FqnIndex {
      */
     uniqueDescedants(parent: Fqn): Stream<FqnIndexEntry>;
 }
-//# sourceMappingURL=fqn-index.d.ts.map