@likec4/language-server 1.25.1 → 1.26.0

package/dist/module.js

@@ -15,6 +15,7 @@ import {
   LikeC4GeneratedModule,
   LikeC4GeneratedSharedModule
 } from "./generated/module.js";
+import { DefaultLikeC4LanguageServices } from "./LikeC4LanguageServices.js";
 import { logger } from "./logger.js";
 import {
   LikeC4CodeLensProvider,
@@ -26,9 +27,9 @@ import {
   LikeC4SemanticTokenProvider
 } from "./lsp/index.js";
 import {
+  DefaultLikeC4ModelBuilder,
   DeploymentsIndex,
   FqnIndex,
-  LikeC4ModelBuilder,
   LikeC4ModelLocator,
   LikeC4ModelParser
 } from "./model/index.js";
@@ -40,18 +41,27 @@ import {
 } from "./references/index.js";
 import { Rpc } from "./Rpc.js";
 import {
-  LikeC4WorkspaceManager,
   NodeKindProvider,
   WorkspaceSymbolProvider
 } from "./shared/index.js";
 import { registerValidationChecks } from "./validation/index.js";
-import { LikeC4Views } from "./views/index.js";
+import { DefaultLikeC4Views } from "./views/index.js";
+import {
+  AstNodeDescriptionProvider,
+  IndexManager,
+  LangiumDocuments,
+  LikeC4WorkspaceManager,
+  ProjectsManager
+} from "./workspace/index.js";
 const LikeC4SharedModule = {
   lsp: {
     NodeKindProvider: (services) => new NodeKindProvider(services),
     WorkspaceSymbolProvider: (services) => new WorkspaceSymbolProvider(services)
   },
   workspace: {
+    IndexManager: (services) => new IndexManager(services),
+    LangiumDocuments: (services) => new LangiumDocuments(services),
+    ProjectsManager: (services) => new ProjectsManager(services),
     WorkspaceManager: (services) => new LikeC4WorkspaceManager(services)
   }
 };
@@ -65,16 +75,17 @@ export const LikeC4Module = {
   ValidatedWorkspaceCache: (services) => new WorkspaceCache(services.shared, DocumentState.Validated),
   Rpc: bind(Rpc),
   likec4: {
+    LanguageServices: bind(DefaultLikeC4LanguageServices),
     Layouter: (_services) => {
       logger.debug("Creating GraphvizLayouter with GraphvizWasmAdapter");
       return new GraphvizLayouter(new GraphvizWasmAdapter());
     },
-    Views: bind(LikeC4Views),
+    Views: bind(DefaultLikeC4Views),
     DeploymentsIndex: bind(DeploymentsIndex),
     ModelChanges: bind(LikeC4ModelChanges),
     FqnIndex: bind(FqnIndex),
     ModelParser: bind(LikeC4ModelParser),
-    ModelBuilder: bind(LikeC4ModelBuilder),
+    ModelBuilder: bind(DefaultLikeC4ModelBuilder),
     ModelLocator: bind(LikeC4ModelLocator)
   },
   lsp: {
@@ -88,6 +99,9 @@ export const LikeC4Module = {
     DocumentLinkProvider: bind(LikeC4DocumentLinkProvider),
     Formatter: bind(LikeC4Formatter)
   },
+  workspace: {
+    AstNodeDescriptionProvider: bind(AstNodeDescriptionProvider)
+  },
   references: {
     NameProvider: bind(LikeC4NameProvider),
     ScopeComputation: bind(LikeC4ScopeComputation),

package/dist/protocol.d.ts

@@ -1,41 +1,79 @@
-import type { ComputedLikeC4Model, ComputedView, DiagramView, Fqn, LayoutedLikeC4Model, RelationId, ViewChange, ViewId } from '@likec4/core';
+import type { ComputedLikeC4ModelData, ComputedView, DiagramView, Fqn, LayoutedLikeC4ModelData, NonEmptyArray, ProjectId, RelationId, ViewChange, ViewId } from '@likec4/core';
 import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc';
 import type { DiagnosticSeverity, DocumentUri, Location, Position } from 'vscode-languageserver-types';
-export declare const onDidChangeModel: NotificationType<string>;
-export type OnDidChangeModelNotification = typeof onDidChangeModel;
+export declare namespace DidChangeModelNotification {
+    const type: NotificationType<string>;
+    type Type = typeof type;
+}
+/**
+ * Request to fetch the computed model data
+ * If LSP has multiple projects, the projectId is required.
+ * otherwise throws an error.
+ */
 export declare namespace FetchComputedModel {
     type Params = {
+        projectId?: string | undefined;
         cleanCaches?: boolean | undefined;
     };
     type Res = {
-        model: ComputedLikeC4Model | null;
+        model: ComputedLikeC4ModelData | null;
     };
-    const Req: RequestType<Params, Res, void>;
-    type Req = typeof Req;
+    const req: RequestType<Params, Res, void>;
+    type Req = typeof req;
+}
+/**
+ * Request to fetch all views of all projects
+ */
+export declare namespace FetchViewsFromAllProjects {
+    type Res = {
+        views: Array<{
+            id: ViewId;
+            title: string;
+            projectId: ProjectId;
+        }>;
+    };
+    const req: RequestType0<Res, void>;
+    type Req = typeof req;
 }
+/**
+ * Request to compute a view.
+ * If LSP has multiple projects, the projectId is required.
+ * otherwise throws an error.
+ */
 export declare namespace ComputeView {
     type Params = {
         viewId: ViewId;
+        projectId?: string;
     };
     type Result = {
         view: ComputedView | null;
     };
-    const Req: RequestType<Params, Result, void>;
-    type Req = typeof Req;
+    const req: RequestType<Params, Result, void>;
+    type Req = typeof req;
 }
+/**
+ * Request to fetch the layouted model data
+ * If LSP has multiple projects, the projectId is required.
+ * otherwise throws an error.
+ */
 export declare namespace FetchLayoutedModel {
+    type Params = {
+        projectId?: string | undefined;
+    };
     type Res = {
-        model: LayoutedLikeC4Model | null;
+        model: LayoutedLikeC4ModelData | null;
     };
-    const Req: RequestType0<Res, void>;
-    type Req = typeof Req;
+    const req: RequestType<Params, Res, void>;
+    type Req = typeof req;
 }
 /**
  * Request to layout a view.
+ * If LSP has multiple projects, the projectId is required.
  */
 export declare namespace LayoutView {
     type Params = {
         viewId: ViewId;
+        projectId?: string | undefined;
     };
     type Res = {
         result: {
@@ -43,14 +81,17 @@ export declare namespace LayoutView {
             diagram: DiagramView;
         } | null;
     };
-    const Req: RequestType<Params, Res, void>;
-    type Req = typeof Req;
+    const req: RequestType<Params, Res, void>;
+    type Req = typeof req;
 }
 /**
- * Request to layout all existing views.
+ * Request to validate all views
+ * If projects ID is provided, it will validate only the views of that project.
  */
 export declare namespace ValidateLayout {
-    type Params = never;
+    type Params = {
+        projectId?: string;
+    };
     type Res = {
         result: {
             uri: string;
@@ -63,9 +104,22 @@ export declare namespace ValidateLayout {
             };
         }[] | null;
     };
-    const Req: RequestType0<Res, void>;
+    const Req: RequestType<Params, Res, void>;
     type Req = typeof Req;
 }
+/**
+ * Request to build documents.
+ */
+export declare namespace FetchProjects {
+    type Params = never;
+    type Res = {
+        projects: {
+            [projectId: ProjectId]: NonEmptyArray<DocumentUri>;
+        };
+    };
+    const req: RequestType0<Res, void>;
+    type Req = typeof req;
+}
 /**
  * Request to build documents.
  */
@@ -78,29 +132,57 @@ export declare namespace BuildDocuments {
 }
 /**
  * Request to locate an element, relation, deployment or view.
+ * If LSP has multiple projects, the projectId is required.
  */
 export declare namespace Locate {
     type Params = {
         element: Fqn;
+        projectId?: string | undefined;
         property?: string;
     } | {
+        projectId?: string | undefined;
         relation: RelationId;
     } | {
         deployment: Fqn;
+        projectId?: string | undefined;
         property?: string;
     } | {
         view: ViewId;
+        projectId?: string | undefined;
     };
     type Res = Location | null;
     const Req: RequestType<Params, Res, void>;
     type Req = typeof Req;
 }
+/**
+ * Request to change the view
+ * If LSP has multiple projects, the projectId is required.
+ */
 export declare namespace ChangeView {
     type Params = {
         viewId: ViewId;
         change: ViewChange;
+        projectId?: string | undefined;
     };
     type Res = Location | null;
     const Req: RequestType<Params, Res, void>;
     type Req = typeof Req;
 }
+/**
+ * Request to fetch telemetry metrics
+ */
+export declare namespace FetchTelemetryMetrics {
+    type Res = {
+        metrics: null | {
+            elementKinds: number;
+            relationshipKinds: number;
+            tags: number;
+            elements: number;
+            relationships: number;
+            views: number;
+            projects: number;
+        };
+    };
+    const req: RequestType0<Res, void>;
+    type Req = typeof req;
+}

package/dist/protocol.js

@@ -1,25 +1,36 @@
 import { NotificationType, RequestType, RequestType0 } from "vscode-jsonrpc";
-export const onDidChangeModel = new NotificationType("likec4/onDidChangeModel");
+export var DidChangeModelNotification;
+((DidChangeModelNotification2) => {
+  DidChangeModelNotification2.type = new NotificationType("likec4/onDidChangeModel");
+})(DidChangeModelNotification || (DidChangeModelNotification = {}));
 export var FetchComputedModel;
 ((FetchComputedModel2) => {
-  FetchComputedModel2.Req = new RequestType("likec4/fetchComputedModel");
+  FetchComputedModel2.req = new RequestType("likec4/fetchComputedModel");
 })(FetchComputedModel || (FetchComputedModel = {}));
+export var FetchViewsFromAllProjects;
+((FetchViewsFromAllProjects2) => {
+  FetchViewsFromAllProjects2.req = new RequestType0("likec4/fetchViewsFromAllProjects");
+})(FetchViewsFromAllProjects || (FetchViewsFromAllProjects = {}));
 export var ComputeView;
 ((ComputeView2) => {
-  ComputeView2.Req = new RequestType("likec4/computeView");
+  ComputeView2.req = new RequestType("likec4/computeView");
 })(ComputeView || (ComputeView = {}));
 export var FetchLayoutedModel;
 ((FetchLayoutedModel2) => {
-  FetchLayoutedModel2.Req = new RequestType0("likec4/fetchLayoutedModel");
+  FetchLayoutedModel2.req = new RequestType("likec4/fetchLayoutedModel");
 })(FetchLayoutedModel || (FetchLayoutedModel = {}));
 export var LayoutView;
 ((LayoutView2) => {
-  LayoutView2.Req = new RequestType("likec4/layout-view");
+  LayoutView2.req = new RequestType("likec4/layout-view");
 })(LayoutView || (LayoutView = {}));
 export var ValidateLayout;
 ((ValidateLayout2) => {
-  ValidateLayout2.Req = new RequestType0("likec4/validate-layout");
+  ValidateLayout2.Req = new RequestType("likec4/validate-layout");
 })(ValidateLayout || (ValidateLayout = {}));
+export var FetchProjects;
+((FetchProjects2) => {
+  FetchProjects2.req = new RequestType0("likec4/fetch-projects");
+})(FetchProjects || (FetchProjects = {}));
 export var BuildDocuments;
 ((BuildDocuments2) => {
   BuildDocuments2.Req = new RequestType("likec4/build");
@@ -32,3 +43,7 @@ export var ChangeView;
 ((ChangeView2) => {
   ChangeView2.Req = new RequestType("likec4/change-view");
 })(ChangeView || (ChangeView = {}));
+export var FetchTelemetryMetrics;
+((FetchTelemetryMetrics2) => {
+  FetchTelemetryMetrics2.req = new RequestType0("likec4/metrics");
+})(FetchTelemetryMetrics || (FetchTelemetryMetrics = {}));

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

@@ -1,18 +1,23 @@
-import { type ReferenceInfo, type Scope, DefaultScopeProvider } from 'langium';
+import { type ProjectId } from '@likec4/core';
+import { type AstNodeDescription, type ReferenceInfo, type Scope, type Stream, DefaultScopeProvider } from 'langium';
 import { ast } from '../ast';
+import type { DeploymentsIndex, FqnIndex } from '../model';
 import type { LikeC4Services } from '../module';
+import type { IndexManager } from '../workspace';
 export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
-    private deploymentsIndex;
-    private fqnIndex;
+    protected deploymentsIndex: DeploymentsIndex;
+    protected fqnIndex: FqnIndex;
+    protected readonly indexManager: IndexManager;
     constructor(services: LikeC4Services);
-    private uniqueDescedants;
     getScope(context: ReferenceInfo): Scope;
-    private getScopeElementRef;
-    private getScopeExtendElement;
-    private getScopeElementView;
-    private getScopeForStrictFqnRef;
-    private getScopeExtendDeployment;
-    protected getScopeForFqnRef(container: ast.FqnRef, context: ReferenceInfo): any;
+    protected genUniqueDescedants(of: () => ast.Element | ast.DeploymentNode | undefined): Generator<Stream<import("../ast").AstNodeDescriptionWithFqn>, void, any>;
+    protected streamScopeElementRef(ref: ast.ElementRef): Stream<AstNodeDescription>;
+    protected streamScopeExtendElement({ element }: ast.ExtendElement): Stream<AstNodeDescription>;
+    protected streamScopeElementView({ viewOf, extends: ext }: ast.ElementView): Stream<AstNodeDescription>;
+    protected getScopeForStrictFqnRef(projectId: ProjectId, container: ast.StrictFqnRef, context: ReferenceInfo): any;
+    protected streamScopeExtendDeployment({ deploymentNode }: ast.ExtendDeployment): Stream<AstNodeDescription>;
+    protected streamForFqnRef(projectId: ProjectId, container: ast.FqnRef, context: ReferenceInfo): Stream<AstNodeDescription>;
+    protected genScopeForFqnRef(projectId: ProjectId, container: ast.FqnRef, context: ReferenceInfo): Generator<any, void, any>;
     /**
      * Computes the scope for a given reference context.
      *
@@ -24,5 +29,13 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
      * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
      * Finally, it combines the collected scopes with the global scope to produce the final scope.
      */
-    protected computeScope(context: ReferenceInfo, referenceType?: any): any;
+    protected computeScope(projectId: ProjectId, context: ReferenceInfo, referenceType?: any): Generator<any, void, any>;
+    /**
+     * Create a global scope filtered for the given reference type.
+     */
+    protected getProjectScope(projectId: ProjectId, referenceType: string, context: ReferenceInfo): Scope;
+    /**
+     * Create a global scope filtered for the given reference type.
+     */
+    protected getGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
 }

package/dist/references/scope-provider.js

@@ -12,64 +12,45 @@ import {
 } from "langium";
 import { ast } from "../ast.js";
 import { logWarnError } from "../logger.js";
+import { projectIdFrom } from "../utils/index.js";
 import { elementRef, readStrictFqn } from "../utils/elementRef.js";
 const { getDocument } = AstUtils;
 export class LikeC4ScopeProvider extends DefaultScopeProvider {
   deploymentsIndex;
   fqnIndex;
+  indexManager;
   constructor(services) {
     super(services);
+    this.indexManager = services.shared.workspace.IndexManager;
     this.fqnIndex = services.likec4.FqnIndex;
     this.deploymentsIndex = services.likec4.DeploymentsIndex;
   }
-  // we need lazy resolving here
-  uniqueDescedants(of) {
-    return new StreamImpl(
-      () => {
-        const element = of();
-        if (element && ast.isElement(element)) {
-          const fqn = this.fqnIndex.getFqn(element);
-          return this.fqnIndex.uniqueDescedants(fqn).iterator();
-        }
-        if (element && ast.isDeploymentNode(element)) {
-          const fqn = this.deploymentsIndex.getFqn(element);
-          return this.deploymentsIndex.uniqueDescedants(fqn).iterator();
-        }
-        return null;
-      },
-      (iterator) => {
-        if (iterator) {
-          return iterator.next();
-        }
-        return DONE_RESULT;
-      }
-    );
-  }
   getScope(context) {
     try {
+      const projectId = projectIdFrom(context.container);
       const referenceType = this.reflection.getReferenceType(context);
       try {
         const container = context.container;
         if (ast.isFqnRef(container)) {
-          return this.getScopeForFqnRef(container, context);
+          return new StreamScope(this.streamForFqnRef(projectId, container, context));
         }
         if (ast.isStrictFqnRef(container)) {
-          return this.getScopeForStrictFqnRef(container, context);
+          return this.getScopeForStrictFqnRef(projectId, container, context);
         }
         if (referenceType !== ast.Element) {
-          return this.getGlobalScope(referenceType, context);
+          return this.getProjectScope(projectId, referenceType, context);
         }
         if (ast.isStrictFqnElementRef(container) && context.property === "el") {
           const parent = container.parent;
           if (!parent) {
-            return this.getGlobalScope(referenceType, context);
+            return this.getProjectScope(projectId, referenceType, context);
           }
-          return new StreamScope(this.fqnIndex.directChildrenOf(readStrictFqn(parent)));
+          return new StreamScope(this.fqnIndex.directChildrenOf(projectId, readStrictFqn(parent)));
         }
         if (ast.isElementRef(container) && context.property === "el") {
           const parent = container.parent;
           if (parent) {
-            return new StreamScope(this.getScopeElementRef(parent));
+            return new StreamScope(this.streamScopeElementRef(parent));
           }
           if (context.reference.$refText === "this" || context.reference.$refText === "it") {
             const closestElement = AstUtils.getContainerOfType(container, ast.isElement);
@@ -82,78 +63,93 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
             }
           }
         }
-        return this.computeScope(context);
+        return new StreamScope(stream(this.computeScope(projectId, context)));
       } catch (e) {
         logWarnError(e);
-        return this.getGlobalScope(referenceType, context);
+        return this.getProjectScope(projectId, referenceType, context);
       }
     } catch (e) {
       logWarnError(e);
       return EMPTY_SCOPE;
     }
   }
-  getScopeElementRef(ref) {
-    return this.uniqueDescedants(() => ref.el.ref);
+  // we need lazy resolving here
+  *genUniqueDescedants(of) {
+    const element = of();
+    if (!element) {
+      return;
+    }
+    const projectId = projectIdFrom(element);
+    if (ast.isElement(element)) {
+      const fqn = this.fqnIndex.getFqn(element);
+      yield* this.fqnIndex.uniqueDescedants(projectId, fqn);
+      return;
+    }
+    if (ast.isDeploymentNode(element)) {
+      const fqn = this.deploymentsIndex.getFqn(element);
+      yield* this.deploymentsIndex.uniqueDescedants(projectId, fqn);
+    }
   }
-  getScopeExtendElement({ element }) {
-    return stream([element.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(element)));
+  streamScopeElementRef(ref) {
+    return stream(this.genUniqueDescedants(() => ref.el.ref));
   }
-  getScopeElementView({ viewOf, extends: ext }) {
+  streamScopeExtendElement({ element }) {
+    return stream([element.el.$nodeDescription]).nonNullable().concat(this.genUniqueDescedants(() => elementRef(element)));
+  }
+  streamScopeElementView({ viewOf, extends: ext }) {
     if (viewOf) {
-      return stream([viewOf.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(viewOf)));
+      return stream([viewOf.el.$nodeDescription]).nonNullable().concat(this.genUniqueDescedants(() => elementRef(viewOf)));
     }
     if (ext) {
       return stream([ext]).flatMap((v) => {
         const view = v.view.ref;
-        return view ? this.getScopeElementView(view) : EMPTY_STREAM;
+        return view ? this.streamScopeElementView(view) : EMPTY_STREAM;
       });
     }
     return EMPTY_STREAM;
   }
-  getScopeForStrictFqnRef(container, context) {
+  getScopeForStrictFqnRef(projectId, container, context) {
     const parent = container.parent;
     if (!parent) {
-      return this.getGlobalScope(ast.DeploymentNode, context);
+      return this.getProjectScope(projectId, ast.DeploymentNode, context);
     }
     return new StreamScope(
-      this.deploymentsIndex.directChildrenOf(readStrictFqn(parent)).filter((desc) => this.reflection.isSubtype(desc.type, ast.DeploymentNode))
+      this.deploymentsIndex.directChildrenOf(projectId, readStrictFqn(parent)).filter((desc) => this.reflection.isSubtype(desc.type, ast.DeploymentNode))
     );
   }
-  getScopeExtendDeployment({ deploymentNode }) {
-    return stream([deploymentNode.value.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => {
+  streamScopeExtendDeployment({ deploymentNode }) {
+    return stream([deploymentNode.value.$nodeDescription]).nonNullable().concat(this.genUniqueDescedants(() => {
       const target = deploymentNode.value.ref;
       return target && ast.isDeploymentNode(target) ? target : void 0;
     }));
   }
-  getScopeForFqnRef(container, context) {
+  streamForFqnRef(projectId, container, context) {
     const parent = container.parent;
     if (!parent) {
-      return this.createScope(
-        // First preference for deployment nodes
-        this.computeScope(context, ast.DeploymentNode).getAllElements(),
-        this.createScope(
-          // Second preference for deployed instances
-          this.computeScope(context, ast.DeployedInstance).getAllElements(),
-          // Third preference for elements if we are in deployment view
-          AstUtils.hasContainerOfType(container, ast.isDeploymentView) ? this.computeScope(context, ast.Element) : EMPTY_SCOPE
-        )
-      );
+      return stream(this.genScopeForFqnRef(projectId, container, context));
     }
     const parentRef = parent.value.ref;
     if (!parentRef) {
-      return EMPTY_SCOPE;
+      return EMPTY_STREAM;
     }
     if (ast.isDeploymentNode(parentRef)) {
-      return new StreamScope(this.uniqueDescedants(() => parentRef));
+      return stream(this.genUniqueDescedants(() => parentRef));
     }
     if (ast.isDeployedInstance(parentRef)) {
-      return new StreamScope(this.getScopeElementRef(parentRef.element));
+      return stream(this.streamScopeElementRef(parentRef.element));
     }
     if (ast.isElement(parentRef)) {
-      return new StreamScope(this.uniqueDescedants(() => parentRef));
+      return stream(this.genUniqueDescedants(() => parentRef));
     }
     return nonexhaustive(parentRef);
   }
+  *genScopeForFqnRef(projectId, container, context) {
+    yield* this.computeScope(projectId, context, ast.DeploymentNode);
+    yield* this.computeScope(projectId, context, ast.DeployedInstance);
+    if (AstUtils.hasContainerOfType(container, ast.isDeploymentView)) {
+      yield* this.computeScope(projectId, context, ast.Element);
+    }
+  }
   /**
    * Computes the scope for a given reference context.
    *
@@ -165,35 +161,68 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
    * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
    * Finally, it combines the collected scopes with the global scope to produce the final scope.
    */
-  computeScope(context, referenceType = this.reflection.getReferenceType(context)) {
+  *computeScope(projectId, context, referenceType = this.reflection.getReferenceType(context)) {
     const isElementReference = this.reflection.isSubtype(referenceType, ast.Element);
     const isDeploymentReference = this.reflection.isSubtype(referenceType, ast.DeploymentElement);
-    const scopes = [];
     const doc = getDocument(context.container);
     const precomputed = doc.precomputedScopes;
     if (!precomputed) {
-      return this.getGlobalScope(referenceType, context);
+      yield* this.getProjectScope(projectId, referenceType, context).getAllElements();
+      return;
     }
     const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
     let container = context.container;
     while (container) {
       const elements = precomputed.get(container).filter(byReferenceType);
       if (elements.length > 0) {
-        scopes.push(stream(elements));
+        yield* elements;
       }
       if (isDeploymentReference && ast.isExtendDeploymentBody(container)) {
-        scopes.push(this.getScopeExtendDeployment(container.$container));
+        yield* this.streamScopeExtendDeployment(container.$container);
       }
       if (isElementReference && ast.isExtendElementBody(container)) {
-        scopes.push(this.getScopeExtendElement(container.$container));
+        yield* this.streamScopeExtendElement(container.$container);
       }
       if (isElementReference && ast.isElementViewBody(container)) {
-        scopes.push(this.getScopeElementView(container.$container));
+        yield* this.streamScopeElementView(container.$container);
       }
       container = container.$container;
     }
-    return scopes.reduceRight((outerScope, elements) => {
-      return this.createScope(elements, outerScope);
-    }, this.getGlobalScope(referenceType, context));
+    yield* this.getProjectScope(projectId, referenceType, context).getAllElements();
   }
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  getProjectScope(projectId, referenceType, context) {
+    if (referenceType === ast.LibIcon) {
+      return super.getGlobalScope(referenceType, context);
+    }
+    return this.globalScopeCache.get(
+      `${projectId}::${referenceType}`,
+      () => new MapScope(this.indexManager.projectElements(projectId, referenceType))
+    );
+  }
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  getGlobalScope(referenceType, context) {
+    if (referenceType === ast.LibIcon) {
+      return super.getGlobalScope(referenceType, context);
+    }
+    const projectId = projectIdFrom(context.container);
+    return this.getProjectScope(projectId, referenceType, context);
+  }
+}
+function lazyStream(fn) {
+  return new StreamImpl(
+    () => {
+      return fn().iterator();
+    },
+    (iterator) => {
+      if (iterator) {
+        return iterator.next();
+      }
+      return DONE_RESULT;
+    }
+  );
 }

package/dist/shared/index.d.ts

@@ -1,3 +1,2 @@
 export * from './NodeKindProvider';
-export * from './WorkspaceManager';
 export * from './WorkspaceSymbolProvider';

package/dist/shared/index.js

@@ -1,3 +1,2 @@
 export * from "./NodeKindProvider.js";
-export * from "./WorkspaceManager.js";
 export * from "./WorkspaceSymbolProvider.js";