@likec4/language-server 0.37.0 → 0.40.0

package/dist/module.js

@@ -1,69 +1,78 @@
-import { EmptyFileSystem, createDefaultModule, createDefaultSharedModule, inject } from 'langium';
-import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module';
-import { LikeC4CodeLensProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
-import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
-import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
-import { registerProtocolHandlers } from './registerProtocolHandlers';
-import { LikeC4WorkspaceManager } from './shared';
-import { registerValidationChecks } from './validation';
-import { logger } from './logger';
-import { serializeError } from '@likec4/core';
+import {
+  WorkspaceCache
+} from "langium";
+import { EmptyFileSystem, createDefaultModule, createDefaultSharedModule, inject } from "langium";
+import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from "./generated/module.js";
+import {
+  LikeC4CodeLensProvider,
+  LikeC4DocumentLinkProvider,
+  LikeC4DocumentSymbolProvider,
+  LikeC4HoverProvider,
+  LikeC4SemanticTokenProvider
+} from "./lsp/index.js";
+import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from "./model/index.js";
+import { LikeC4ScopeComputation, LikeC4ScopeProvider } from "./references/index.js";
+import { Rpc } from "./Rpc.js";
+import { LikeC4WorkspaceManager } from "./shared/index.js";
+import { registerValidationChecks } from "./validation/index.js";
+import { logger } from "./logger.js";
+import { serializeError } from "@likec4/core";
 function bind(Type) {
-    return (services) => new Type(services);
+  return (services) => new Type(services);
 }
 export const LikeC4Module = {
-    likec4: {
-        FqnIndex: bind(FqnIndex),
-        ModelParser: bind(LikeC4ModelParser),
-        ModelBuilder: bind(LikeC4ModelBuilder),
-        ModelLocator: bind(LikeC4ModelLocator)
-    },
-    lsp: {
-        DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
-        SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
-        HoverProvider: bind(LikeC4HoverProvider),
-        CodeLensProvider: bind(LikeC4CodeLensProvider),
-        DocumentLinkProvider: bind(LikeC4DocumentLinkProvider)
-    },
-    //
-    //   // Formatter: bind(LikeC4Formatter),
-    //
-    // },
-    references: {
-        ScopeComputation: bind(LikeC4ScopeComputation),
-        ScopeProvider: bind(LikeC4ScopeProvider)
-    }
+  WorkspaceCache: (services) => new WorkspaceCache(services.shared),
+  Rpc: bind(Rpc),
+  likec4: {
+    FqnIndex: bind(FqnIndex),
+    ModelParser: bind(LikeC4ModelParser),
+    ModelBuilder: bind(LikeC4ModelBuilder),
+    ModelLocator: bind(LikeC4ModelLocator)
+  },
+  lsp: {
+    DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
+    SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
+    HoverProvider: bind(LikeC4HoverProvider),
+    CodeLensProvider: bind(LikeC4CodeLensProvider),
+    DocumentLinkProvider: bind(LikeC4DocumentLinkProvider)
+  },
+  references: {
+    ScopeComputation: bind(LikeC4ScopeComputation),
+    ScopeProvider: bind(LikeC4ScopeProvider)
+  }
 };
 const LikeC4SharedModule = {
-    workspace: {
-        WorkspaceManager: services => new LikeC4WorkspaceManager(services)
-    }
+  workspace: {
+    WorkspaceManager: (services) => new LikeC4WorkspaceManager(services)
+  }
 };
 export function createLanguageServices(context) {
-    const connection = context?.connection;
-    if (connection) {
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        const original = logger.error.bind(logger);
-        logger.error = (arg) => {
-            if (typeof arg === 'string') {
-                original(arg);
-                connection.telemetry.logEvent({ eventName: 'error', error: arg });
-                return;
-            }
-            const { message, error } = serializeError(arg);
-            original(error);
-            connection.telemetry.logEvent({ eventName: 'error', error: message });
-        };
-    }
-    const moduleContext = {
-        ...EmptyFileSystem,
-        ...context
+  const connection = context?.connection;
+  if (connection) {
+    const original = logger.error.bind(logger);
+    logger.error = (arg) => {
+      if (typeof arg === "string") {
+        original(arg);
+        connection.telemetry.logEvent({ eventName: "error", error: arg });
+        return;
+      }
+      const { message, error } = serializeError(arg);
+      original(error);
+      connection.telemetry.logEvent({ eventName: "error", error: message });
     };
-    const shared = inject(createDefaultSharedModule(moduleContext), LikeC4GeneratedSharedModule, LikeC4SharedModule);
-    const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
-    shared.ServiceRegistry.register(likec4);
-    registerValidationChecks(likec4);
-    registerProtocolHandlers(likec4);
-    return { shared, likec4 };
+  }
+  const moduleContext = {
+    ...EmptyFileSystem,
+    ...context
+  };
+  const shared = inject(
+    createDefaultSharedModule(moduleContext),
+    LikeC4GeneratedSharedModule,
+    LikeC4SharedModule
+  );
+  const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
+  shared.ServiceRegistry.register(likec4);
+  registerValidationChecks(likec4);
+  likec4.Rpc.init();
+  return { shared, likec4 };
 }
-//# sourceMappingURL=module.js.map

package/dist/protocol.d.ts

@@ -1,9 +1,25 @@
 import type { ComputedView, Fqn, LikeC4Model, LikeC4RawModel, RelationID, ViewID } from '@likec4/core';
 import type { DocumentUri, Location } from 'vscode-languageserver-protocol';
 import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver-protocol';
+export declare const onDidChangeModel: NotificationType<string>;
+export declare const fetchRawModel: RequestType0<{
+    rawmodel: LikeC4RawModel | null;
+}, void>;
+export declare const fetchModel: RequestType0<{
+    model: LikeC4Model | null;
+}, void>;
+export declare const computeView: RequestType<{
+    viewId: ViewID;
+}, {
+    view: ComputedView | null;
+}, void>;
+export declare const rebuild: RequestType0<{
+    docs: DocumentUri[];
+}, void>;
 interface BuildDocumentsParams {
     docs: DocumentUri[];
 }
+export declare const buildDocuments: RequestType<BuildDocumentsParams, void, void>;
 export type LocateParams = {
     element: Fqn;
     property?: string;
@@ -13,24 +29,4 @@ export type LocateParams = {
     view: ViewID;
 };
 export declare const locate: RequestType<LocateParams, Location | null, void>;
-export declare const Rpc: {
-    readonly onDidChangeModel: NotificationType<string>;
-    readonly fetchModel: RequestType0<{
-        model: LikeC4Model | null;
-    }, void>;
-    readonly fetchRawModel: RequestType0<{
-        rawmodel: LikeC4RawModel | null;
-    }, void>;
-    readonly computeView: RequestType<{
-        viewId: ViewID;
-    }, {
-        view: ComputedView | null;
-    }, void>;
-    readonly rebuild: RequestType0<{
-        docs: DocumentUri[];
-    }, void>;
-    readonly buildDocuments: RequestType<BuildDocumentsParams, void, void>;
-    readonly locate: RequestType<LocateParams, Location | null, void>;
-};
 export {};
-//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.js

@@ -1,22 +1,14 @@
-import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver-protocol';
-//#region From server
-const onDidChangeModel = new NotificationType('likec4/onDidChangeModel');
-//#endregion
-//#region To server
-const fetchRawModel = new RequestType0('likec4/fetchRaw');
-const fetchModel = new RequestType0('likec4/fetchModel');
-const computeView = new RequestType('likec4/computeView');
-const rebuild = new RequestType0('likec4/rebuildModel');
-const buildDocuments = new RequestType('likec4/buildDocuments');
-export const locate = new RequestType('likec4/locate');
-//#endregion
-export const Rpc = {
-    onDidChangeModel,
-    fetchModel,
-    fetchRawModel,
-    computeView,
-    rebuild,
-    buildDocuments,
-    locate
-};
-//# sourceMappingURL=protocol.js.map
+import { NotificationType, RequestType, RequestType0 } from "vscode-languageserver-protocol";
+export const onDidChangeModel = new NotificationType("likec4/onDidChangeModel");
+export const fetchRawModel = new RequestType0(
+  "likec4/fetchRaw"
+);
+export const fetchModel = new RequestType0("likec4/fetchModel");
+export const computeView = new RequestType(
+  "likec4/computeView"
+);
+export const rebuild = new RequestType0("likec4/rebuildModel");
+export const buildDocuments = new RequestType(
+  "likec4/buildDocuments"
+);
+export const locate = new RequestType("likec4/locate");

package/dist/references/index.d.ts

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

package/dist/references/index.js

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

package/dist/references/scope-computation.d.ts

@@ -1,11 +1,10 @@
-import { DefaultScopeComputation, MultiMap, type AstNodeDescription, type PrecomputedScopes } from 'langium';
+import { DefaultScopeComputation, type AstNodeDescription, type PrecomputedScopes } from 'langium';
 import type { CancellationToken } from 'vscode-languageserver';
 import { ast, type LikeC4LangiumDocument } from '../ast';
 type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
 export declare class LikeC4ScopeComputation extends DefaultScopeComputation {
     computeExports(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<AstNodeDescription[]>;
     computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<PrecomputedScopes>;
-    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): MultiMap<string, AstNodeDescription>;
+    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): any;
 }
 export {};
-//# sourceMappingURL=scope-computation.d.ts.map

package/dist/references/scope-computation.js

@@ -1,80 +1,78 @@
-import { DefaultScopeComputation, MultiMap } from 'langium';
-import { isEmpty } from 'remeda';
-import { ast } from '../ast';
+import {
+  DefaultScopeComputation,
+  MultiMap
+} from "langium";
+import { isEmpty } from "remeda";
+import { ast } from "../ast.js";
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
-    computeExports(document, _cancelToken) {
-        const { specification, model, views } = document.parseResult.value;
-        const docExports = [];
-        if (specification) {
-            for (const spec of specification.elements) {
-                if (spec.kind && !isEmpty(spec.kind.name)) {
-                    docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
-                }
-            }
-            for (const spec of specification.tags) {
-                if (spec.tag && !isEmpty(spec.tag.name)) {
-                    docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
-                    docExports.push(this.descriptions.createDescription(spec.tag, '#' + spec.tag.name, document));
-                }
-            }
+  computeExports(document, _cancelToken) {
+    const { specification, model, views } = document.parseResult.value;
+    const docExports = [];
+    if (specification) {
+      for (const spec of specification.elements) {
+        if (spec.kind && !isEmpty(spec.kind.name)) {
+          docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
         }
-        // Only root model elements are exported
-        if (model && model.elements.length > 0) {
-            for (const elAst of model.elements) {
-                if (ast.isElement(elAst) && !isEmpty(elAst.name)) {
-                    docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
-                }
-            }
+      }
+      for (const spec of specification.tags) {
+        if (spec.tag && !isEmpty(spec.tag.name)) {
+          docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
+          docExports.push(this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document));
         }
-        if (views && views.views.length > 0) {
-            for (const viewAst of views.views) {
-                if (viewAst.name && !isEmpty(viewAst.name)) {
-                    docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
-                }
-            }
-        }
-        return Promise.resolve(docExports);
+      }
     }
-    async computeLocalScopes(document, _cancelToken) {
-        const root = document.parseResult.value;
-        const scopes = new MultiMap();
-        if (root.model) {
-            const nested = this.processContainer(root.model, scopes, document);
-            scopes.addAll(root, nested.values());
+    if (model && model.elements.length > 0) {
+      for (const elAst of model.elements) {
+        if (ast.isElement(elAst) && !isEmpty(elAst.name)) {
+          docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
         }
-        return Promise.resolve(scopes);
+      }
     }
-    processContainer(container, scopes, document) {
-        const localScope = new MultiMap();
-        const nestedScopes = new MultiMap();
-        for (const el of container.elements) {
-            if (ast.isRelation(el)) {
-                continue;
-            }
-            let subcontainer;
-            if (ast.isElement(el) && !isEmpty(el.name)) {
-                localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
-                subcontainer = el.body;
-            }
-            else if (ast.isExtendElement(el)) {
-                subcontainer = el.body;
-            }
-            if (subcontainer && subcontainer.elements.length > 0) {
-                const nested = this.processContainer(subcontainer, scopes, document);
-                for (const [nestedName, desc] of nested) {
-                    nestedScopes.add(nestedName, desc);
-                }
-            }
+    if (views && views.views.length > 0) {
+      for (const viewAst of views.views) {
+        if (viewAst.name && !isEmpty(viewAst.name)) {
+          docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
         }
-        for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
-            // If name is unique for current scope
-            if (!localScope.has(name) && descriptions.length === 1) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                localScope.add(name, descriptions[0]);
-            }
+      }
+    }
+    return Promise.resolve(docExports);
+  }
+  async computeLocalScopes(document, _cancelToken) {
+    const root = document.parseResult.value;
+    const scopes = new MultiMap();
+    if (root.model) {
+      const nested = this.processContainer(root.model, scopes, document);
+      scopes.addAll(root, nested.values());
+    }
+    return Promise.resolve(scopes);
+  }
+  processContainer(container, scopes, document) {
+    const localScope = new MultiMap();
+    const nestedScopes = new MultiMap();
+    for (const el of container.elements) {
+      if (ast.isRelation(el)) {
+        continue;
+      }
+      let subcontainer;
+      if (ast.isElement(el) && !isEmpty(el.name)) {
+        localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
+        subcontainer = el.body;
+      } else if (ast.isExtendElement(el)) {
+        subcontainer = el.body;
+      }
+      if (subcontainer && subcontainer.elements.length > 0) {
+        const nested = this.processContainer(subcontainer, scopes, document);
+        for (const [nestedName, desc] of nested) {
+          nestedScopes.add(nestedName, desc);
         }
-        scopes.addAll(container, localScope.values());
-        return localScope;
+      }
+    }
+    for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
+      if (!localScope.has(name) && descriptions.length === 1) {
+        localScope.add(name, descriptions[0]);
+      }
     }
+    scopes.addAll(container, localScope.values());
+    return localScope;
+  }
 }
-//# sourceMappingURL=scope-computation.js.map

package/dist/references/scope-provider.d.ts

@@ -10,10 +10,9 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
     private scopeExtendElement;
     private scopeElementView;
     getScope(context: ReferenceInfo): Scope;
-    protected computeScope(node: AstNode, referenceType: string): Scope;
+    protected computeScope(node: AstNode, referenceType: string): Stream<AstNodeDescription>;
     /**
      * Create a global scope filtered for the given reference type.
      */
     protected getGlobalScope(referenceType: string): Scope;
 }
-//# sourceMappingURL=scope-provider.d.ts.map