@likec4/language-server 0.37.1 → 0.40.0

package/dist/references/scope-provider.js

@@ -1,129 +1,139 @@
-import { DONE_RESULT, DefaultScopeProvider, EMPTY_STREAM, StreamImpl, StreamScope, getDocument, stream, findNodeForProperty, toDocumentSegment } from 'langium';
-import { ast } from '../ast';
-import { elementRef, isElementRefHead, parentFqnElementRef } from '../elementRef';
-import { logError } from '../logger';
+import {
+  DONE_RESULT,
+  DefaultScopeProvider,
+  EMPTY_STREAM,
+  StreamImpl,
+  StreamScope,
+  getDocument,
+  stream,
+  findNodeForProperty,
+  toDocumentSegment
+} from "langium";
+import { ast } from "../ast.js";
+import { elementRef, isElementRefHead, parentFqnElementRef } from "../elementRef.js";
+import { logError } from "../logger.js";
 function toAstNodeDescription(entry) {
-    const $cstNode = findNodeForProperty(entry.el.$cstNode, 'name');
-    return {
-        documentUri: entry.doc.uri,
-        name: entry.name,
-        ...(entry.el.$cstNode && {
-            selectionSegment: toDocumentSegment(entry.el.$cstNode)
-        }),
-        ...($cstNode && {
-            nameSegment: toDocumentSegment($cstNode)
-        }),
-        path: entry.path,
-        type: ast.Element
-    };
+  const $cstNode = findNodeForProperty(entry.el.$cstNode, "name");
+  return {
+    documentUri: entry.doc.uri,
+    name: entry.name,
+    ...entry.el.$cstNode && {
+      selectionSegment: toDocumentSegment(entry.el.$cstNode)
+    },
+    ...$cstNode && {
+      nameSegment: toDocumentSegment($cstNode)
+    },
+    path: entry.path,
+    type: ast.Element
+  };
 }
 export class LikeC4ScopeProvider extends DefaultScopeProvider {
-    fqnIndex;
-    constructor(services) {
-        super(services);
-        this.fqnIndex = services.likec4.FqnIndex;
-    }
-    directChildrenOf(parent) {
-        return this.fqnIndex.directChildrenOf(parent).map(toAstNodeDescription);
-    }
-    // we need lazy resolving here
-    uniqueDescedants(of) {
-        return new StreamImpl(() => {
-            const element = of();
-            const fqn = element && this.fqnIndex.getFqn(element);
-            if (fqn) {
-                return this.fqnIndex.uniqueDescedants(fqn).map(toAstNodeDescription).iterator();
-            }
-            return null;
-        }, iterator => {
-            if (iterator) {
-                return iterator.next();
-            }
-            return DONE_RESULT;
-        });
-    }
-    scopeElementRef(ref) {
-        const parentNode = ref.$container;
-        if (!ast.isElementRef(parentNode)) {
-            throw new Error('Expected be inside ElementRef');
+  fqnIndex;
+  constructor(services) {
+    super(services);
+    this.fqnIndex = services.likec4.FqnIndex;
+  }
+  directChildrenOf(parent) {
+    return this.fqnIndex.directChildrenOf(parent).map(toAstNodeDescription);
+  }
+  // we need lazy resolving here
+  uniqueDescedants(of) {
+    return new StreamImpl(
+      () => {
+        const element = of();
+        const fqn = element && this.fqnIndex.getFqn(element);
+        if (fqn) {
+          return this.fqnIndex.uniqueDescedants(fqn).map(toAstNodeDescription).iterator();
         }
-        return this.uniqueDescedants(() => parentNode.el.ref);
+        return null;
+      },
+      (iterator) => {
+        if (iterator) {
+          return iterator.next();
+        }
+        return DONE_RESULT;
+      }
+    );
+  }
+  scopeElementRef(ref) {
+    const parentNode = ref.$container;
+    if (!ast.isElementRef(parentNode)) {
+      throw new Error("Expected be inside ElementRef");
     }
-    scopeExtendElement(extend) {
-        return this.uniqueDescedants(() => elementRef(extend.element));
+    return this.uniqueDescedants(() => parentNode.el.ref);
+  }
+  scopeExtendElement(extend) {
+    return this.uniqueDescedants(() => elementRef(extend.element));
+  }
+  scopeElementView({ viewOf, extends: ext }) {
+    if (ext) {
+      return stream([ext]).flatMap((v) => {
+        const view = v.view.ref;
+        return view ? this.scopeElementView(view) : EMPTY_STREAM;
+      });
     }
-    scopeElementView({ viewOf, extends: ext }) {
-        if (ext) {
-            return stream([ext]).flatMap(v => {
-                const view = v.view.ref;
-                return view ? this.scopeElementView(view) : EMPTY_STREAM;
-            });
-        }
-        if (viewOf) {
-            return this.uniqueDescedants(() => elementRef(viewOf));
-        }
-        return EMPTY_STREAM;
+    if (viewOf) {
+      return this.uniqueDescedants(() => elementRef(viewOf));
     }
-    getScope(context) {
-        const referenceType = this.reflection.getReferenceType(context);
-        try {
-            const container = context.container;
-            // const path = this.services.workspace.AstNodeLocator.getAstNodePath(node)
-            if (referenceType === ast.Element) {
-                if (ast.isStrictElementRef(container)) {
-                    if (isElementRefHead(container)) {
-                        return this.getGlobalScope(referenceType);
-                    }
-                    const parent = parentFqnElementRef(container);
-                    return new StreamScope(this.directChildrenOf(parent));
-                }
-                if (ast.isElementRef(container) && !isElementRefHead(container)) {
-                    return new StreamScope(this.scopeElementRef(container));
-                }
-            }
-            return this.computeScope(container, referenceType);
-        }
-        catch (e) {
-            logError(e);
+    return EMPTY_STREAM;
+  }
+  getScope(context) {
+    const referenceType = this.reflection.getReferenceType(context);
+    try {
+      const container = context.container;
+      if (referenceType === ast.Element) {
+        if (ast.isStrictElementRef(container)) {
+          if (isElementRefHead(container)) {
             return this.getGlobalScope(referenceType);
+          }
+          const parent = parentFqnElementRef(container);
+          return new StreamScope(this.directChildrenOf(parent));
         }
-    }
-    computeScope(node, referenceType) {
-        const scopes = [];
-        const doc = getDocument(node);
-        const precomputed = doc.precomputedScopes;
-        const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
-        if (precomputed) {
-            const elements = precomputed.get(node).filter(byReferenceType);
-            if (elements.length > 0) {
-                scopes.push(stream(elements));
-            }
-            let container = node.$container;
-            while (container) {
-                const elements = precomputed.get(container).filter(byReferenceType);
-                if (elements.length > 0) {
-                    scopes.push(stream(elements));
-                }
-                if (referenceType === ast.Element) {
-                    if (ast.isExtendElementBody(container)) {
-                        scopes.push(this.scopeExtendElement(container.$container));
-                    }
-                    if (ast.isElementViewBody(container)) {
-                        scopes.push(this.scopeElementView(container.$container));
-                    }
-                }
-                container = container.$container;
-            }
+        if (ast.isElementRef(container) && !isElementRefHead(container)) {
+          return new StreamScope(this.scopeElementRef(container));
         }
-        return scopes.reduceRight((outerScope, elements) => {
-            return this.createScope(elements, outerScope);
-        }, this.getGlobalScope(referenceType));
+      }
+      return this.computeScope(container, referenceType);
+    } catch (e) {
+      logError(e);
+      return this.getGlobalScope(referenceType);
     }
-    /**
-     * Create a global scope filtered for the given reference type.
-     */
-    getGlobalScope(referenceType) {
-        return new StreamScope(this.indexManager.allElements(referenceType));
+  }
+  computeScope(node, referenceType) {
+    const scopes = [];
+    const doc = getDocument(node);
+    const precomputed = doc.precomputedScopes;
+    const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
+    if (precomputed) {
+      const elements = precomputed.get(node).filter(byReferenceType);
+      if (elements.length > 0) {
+        scopes.push(stream(elements));
+      }
+      let container = node.$container;
+      while (container) {
+        const elements2 = precomputed.get(container).filter(byReferenceType);
+        if (elements2.length > 0) {
+          scopes.push(stream(elements2));
+        }
+        if (referenceType === ast.Element) {
+          if (ast.isExtendElementBody(container)) {
+            scopes.push(this.scopeExtendElement(container.$container));
+          }
+          if (ast.isElementViewBody(container)) {
+            scopes.push(this.scopeElementView(container.$container));
+          }
+        }
+        container = container.$container;
+      }
     }
+    return scopes.reduceRight((outerScope, elements) => {
+      return this.createScope(elements, outerScope);
+    }, this.getGlobalScope(referenceType));
+  }
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  getGlobalScope(referenceType) {
+    return new StreamScope(this.indexManager.allElements(referenceType));
+  }
 }
-//# sourceMappingURL=scope-provider.js.map

package/dist/shared/WorkspaceManager.d.ts

@@ -1,14 +1,12 @@
-import type { LangiumDocument, LangiumDocumentFactory, LangiumSharedServices } from 'langium';
+import type { LangiumDocument } from 'langium';
 import { DefaultWorkspaceManager } from 'langium';
 import type { WorkspaceFolder } from 'vscode-languageserver';
 export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
-    protected readonly documentFactory: LangiumDocumentFactory;
-    constructor(services: LangiumSharedServices);
     /**
      * Load all additional documents that shall be visible in the context of the given workspace
      * folders and add them to the collector. This can be used to include built-in libraries of
      * your language, which can be either loaded from provided files or constructed in memory.
      */
     protected loadAdditionalDocuments(_folders: WorkspaceFolder[], _collector: (document: LangiumDocument) => void): Promise<void>;
+    workspace(): any;
 }
-//# sourceMappingURL=WorkspaceManager.d.ts.map

package/dist/shared/WorkspaceManager.js

@@ -1,18 +1,15 @@
-import { DefaultWorkspaceManager } from 'langium';
+import { nonNullable } from "@likec4/core";
+import { DefaultWorkspaceManager } from "langium";
 export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
-    documentFactory;
-    constructor(services) {
-        super(services);
-        this.documentFactory = services.workspace.LangiumDocumentFactory;
-    }
-    /**
-     * Load all additional documents that shall be visible in the context of the given workspace
-     * folders and add them to the collector. This can be used to include built-in libraries of
-     * your language, which can be either loaded from provided files or constructed in memory.
-     */
-    loadAdditionalDocuments(_folders, _collector) {
-        // collector(this.documentFactory.fromString(builtin.specification.document, URI.parse(builtin.specification.uri)))
-        return Promise.resolve();
-    }
+  /**
+   * Load all additional documents that shall be visible in the context of the given workspace
+   * folders and add them to the collector. This can be used to include built-in libraries of
+   * your language, which can be either loaded from provided files or constructed in memory.
+   */
+  loadAdditionalDocuments(_folders, _collector) {
+    return Promise.resolve();
+  }
+  workspace() {
+    return this.folders && this.folders.length > 0 ? nonNullable(this.folders[0]) : null;
+  }
 }
-//# sourceMappingURL=WorkspaceManager.js.map

package/dist/shared/index.d.ts

@@ -1,2 +1 @@
 export * from './WorkspaceManager';
-//# sourceMappingURL=index.d.ts.map

package/dist/shared/index.js

@@ -1,2 +1 @@
-export * from './WorkspaceManager';
-//# sourceMappingURL=index.js.map
+export * from "./WorkspaceManager.js";

package/dist/test/index.d.ts

@@ -1,2 +1 @@
 export * from './testServices';
-//# sourceMappingURL=index.d.ts.map

package/dist/test/index.js

@@ -1,2 +1 @@
-export * from './testServices';
-//# sourceMappingURL=index.js.map
+export * from "./testServices.js";

package/dist/test/testServices.d.ts

@@ -1,16 +1,15 @@
 import type { LikeC4LangiumDocument } from '../ast';
 export declare function createTestServices(workspace?: string): {
-    services: import("../module").LikeC4Services;
+    services: any;
     parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
     validate: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<{
         document: LikeC4LangiumDocument;
-        diagnostics: import("vscode-languageserver-types").Diagnostic[];
-        errors: string[];
+        diagnostics: any;
+        errors: any;
     }>;
     validateAll: () => Promise<{
-        diagnostics: import("vscode-languageserver-types").Diagnostic[];
-        errors: string[];
+        diagnostics: any;
+        errors: any;
     }>;
-    buildModel: () => Promise<import("@likec4/core").LikeC4Model>;
+    buildModel: () => Promise<any>;
 };
-//# sourceMappingURL=testServices.d.ts.map

package/dist/test/testServices.js

@@ -1,65 +1,68 @@
-import { createLanguageServices } from '../module';
-import { EmptyFileSystem } from 'langium';
-import { URI, Utils } from 'vscode-uri';
-import stripIndent from 'strip-indent';
-export function createTestServices(workspace = 'file:///test/workspace') {
-    const services = createLanguageServices(EmptyFileSystem).likec4;
-    const metaData = services.LanguageMetaData;
-    const langiumDocuments = services.shared.workspace.LangiumDocuments;
-    const documentBuilder = services.shared.workspace.DocumentBuilder;
-    const modelBuilder = services.likec4.ModelBuilder;
-    const workspaceUri = URI.parse(workspace);
-    const initPromise = services.shared.workspace.WorkspaceManager.initializeWorkspace([
-        {
-            name: 'test',
-            uri: workspaceUri.toString()
-        }
-    ]);
-    let documentIndex = 1;
-    const parse = async (input, uri) => {
-        await initPromise;
-        const docUri = Utils.joinPath(workspaceUri, '/src/', uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`);
-        const document = services.shared.workspace.LangiumDocumentFactory.fromString(stripIndent(input), docUri);
-        langiumDocuments.addDocument(document);
-        await documentBuilder.build([document], { validation: false });
-        return document;
-    };
-    const validate = async (input, uri) => {
-        await initPromise;
-        const document = typeof input === 'string' ? await parse(input, uri) : input;
-        await documentBuilder.build([document], { validation: true });
-        const diagnostics = document.diagnostics ?? [];
-        const errors = diagnostics.map(d => d.message);
-        return {
-            document,
-            diagnostics,
-            errors
-        };
-    };
-    const validateAll = async () => {
-        await initPromise;
-        const docs = langiumDocuments.all.toArray();
-        await documentBuilder.build(docs, { validation: true });
-        const diagnostics = docs.flatMap(doc => doc.diagnostics ?? []);
-        const errors = diagnostics.map(d => d.message);
-        return {
-            diagnostics,
-            errors
-        };
-    };
-    const buildModel = async () => {
-        await validateAll();
-        const model = modelBuilder.buildModel();
-        if (!model)
-            throw new Error('No model found');
-        return model;
+import { createLanguageServices } from "../module.js";
+import { EmptyFileSystem } from "langium";
+import { URI, Utils } from "vscode-uri";
+import stripIndent from "strip-indent";
+export function createTestServices(workspace = "file:///test/workspace") {
+  const services = createLanguageServices(EmptyFileSystem).likec4;
+  const metaData = services.LanguageMetaData;
+  const langiumDocuments = services.shared.workspace.LangiumDocuments;
+  const documentBuilder = services.shared.workspace.DocumentBuilder;
+  const modelBuilder = services.likec4.ModelBuilder;
+  const workspaceUri = URI.parse(workspace);
+  const workspaceFolder = {
+    name: "test",
+    uri: workspaceUri.toString()
+  };
+  const initPromise = services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
+  void initPromise.finally(() => {
+    Object.assign(services.shared.workspace.WorkspaceManager, {
+      folders: [workspaceFolder]
+    });
+  });
+  let documentIndex = 1;
+  const parse = async (input, uri) => {
+    await initPromise;
+    const docUri = Utils.resolvePath(workspaceUri, "./src/", uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`);
+    const document = services.shared.workspace.LangiumDocumentFactory.fromString(stripIndent(input), docUri);
+    langiumDocuments.addDocument(document);
+    await documentBuilder.build([document], { validation: false });
+    return document;
+  };
+  const validate = async (input, uri) => {
+    await initPromise;
+    const document = typeof input === "string" ? await parse(input, uri) : input;
+    await documentBuilder.build([document], { validation: true });
+    const diagnostics = document.diagnostics ?? [];
+    const errors = diagnostics.map((d) => d.message);
+    return {
+      document,
+      diagnostics,
+      errors
     };
+  };
+  const validateAll = async () => {
+    await initPromise;
+    const docs = langiumDocuments.all.toArray();
+    await documentBuilder.build(docs, { validation: true });
+    const diagnostics = docs.flatMap((doc) => doc.diagnostics ?? []);
+    const errors = diagnostics.map((d) => d.message);
     return {
-        services,
-        parse,
-        validate,
-        validateAll,
-        buildModel
+      diagnostics,
+      errors
     };
+  };
+  const buildModel = async () => {
+    await validateAll();
+    const model = modelBuilder.buildModel();
+    if (!model)
+      throw new Error("No model found");
+    return model;
+  };
+  return {
+    services,
+    parse,
+    validate,
+    validateAll,
+    buildModel
+  };
 }
-//# sourceMappingURL=testServices.js.map

package/dist/utils.d.ts

@@ -1,3 +1,3 @@
 import type { LangiumDocument } from 'langium';
 export declare const printDocs: (docs: LangiumDocument[]) => string;
-//# sourceMappingURL=utils.d.ts.map
+export declare function queueMicrotask(cb: () => void): Promise<void>;

package/dist/utils.js

@@ -1,3 +1,4 @@
-import { Utils } from 'vscode-uri';
-export const printDocs = (docs) => docs.map(d => '  - ' + Utils.basename(d.uri)).join('\n');
-//# sourceMappingURL=utils.js.map
+export const printDocs = (docs) => docs.map((d) => "  - " + d.uri.path).join("\n");
+export function queueMicrotask(cb) {
+  return Promise.resolve().then(cb);
+}

package/dist/validation/element.d.ts

@@ -1,5 +1,3 @@
-import { type ValidationCheck } from 'langium';
 import type { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const elementChecks: (services: LikeC4Services) => ValidationCheck<ast.Element>;
-//# sourceMappingURL=element.d.ts.map

package/dist/validation/element.js

@@ -1,41 +1,30 @@
-import { getDocument } from 'langium';
+import { getDocument } from "langium";
 export const elementChecks = (services) => {
-    const fqnIndex = services.likec4.FqnIndex;
-    return (el, accept) => {
-        const fqn = fqnIndex.getFqn(el);
-        if (!fqn) {
-            accept('error', 'Not indexed element', {
-                node: el,
-                property: 'name'
-            });
-            return;
-        }
-        const withSameFqn = fqnIndex
-            .byFqn(fqn)
-            .filter(v => v.el !== el)
-            .head();
-        if (withSameFqn) {
-            accept('error', `Duplicate element name ${el.name !== fqn ? el.name + ' (' + fqn + ')' : el.name}`, {
-                node: el,
-                property: 'name',
-                relatedInformation: [
-                    {
-                        location: {
-                            range: withSameFqn.el.$cstNode.range,
-                            uri: getDocument(withSameFqn.el).uri.toString()
-                        },
-                        message: `Already defined here`
-                    }
-                ]
-            });
-        }
-        // for (let i = 3; i < el.props.length; i++) {
-        //   accept('error', `Too many properties, max 3 allowed`, {
-        //     node: el,
-        //     property: 'props',
-        //     index: i
-        //   })
-        // }
-    };
+  const fqnIndex = services.likec4.FqnIndex;
+  return (el, accept) => {
+    const fqn = fqnIndex.getFqn(el);
+    if (!fqn) {
+      accept("error", "Not indexed element", {
+        node: el,
+        property: "name"
+      });
+      return;
+    }
+    const withSameFqn = fqnIndex.byFqn(fqn).filter((v) => v.el !== el).head();
+    if (withSameFqn) {
+      accept("error", `Duplicate element name ${el.name !== fqn ? el.name + " (" + fqn + ")" : el.name}`, {
+        node: el,
+        property: "name",
+        relatedInformation: [
+          {
+            location: {
+              range: withSameFqn.el.$cstNode.range,
+              uri: getDocument(withSameFqn.el).uri.toString()
+            },
+            message: `Already defined here`
+          }
+        ]
+      });
+    }
+  };
 };
-//# sourceMappingURL=element.js.map

package/dist/validation/index.d.ts

@@ -1,3 +1,2 @@
 import type { LikeC4Services } from '../module';
 export declare function registerValidationChecks(services: LikeC4Services): void;
-//# sourceMappingURL=index.d.ts.map