@elmethis/core 1.0.0-alpha.147 → 1.0.0-alpha.148

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/document-builder.mjs

@@ -0,0 +1,328 @@
+import { Disposable } from "../utils/disposable.mjs";
+import { MultiMap } from "../utils/collections.mjs";
+import { interruptAndCheck, OperationCancelled, isOperationCancelled } from "../utils/promise-utils.mjs";
+import { stream } from "../utils/stream.mjs";
+import { ValidationCategory } from "../validation/validation-registry.mjs";
+import { DocumentState } from "./documents.mjs";
+import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
+class DefaultDocumentBuilder {
+  constructor(services) {
+    this.updateBuildOptions = {
+      // Default: run only the built-in validation checks and those in the _fast_ category (includes those without category)
+      validation: {
+        categories: ["built-in", "fast"]
+      }
+    };
+    this.updateListeners = [];
+    this.buildPhaseListeners = new MultiMap();
+    this.documentPhaseListeners = new MultiMap();
+    this.buildState = /* @__PURE__ */ new Map();
+    this.documentBuildWaiters = /* @__PURE__ */ new Map();
+    this.currentState = DocumentState.Changed;
+    this.langiumDocuments = services.workspace.LangiumDocuments;
+    this.langiumDocumentFactory = services.workspace.LangiumDocumentFactory;
+    this.textDocuments = services.workspace.TextDocuments;
+    this.indexManager = services.workspace.IndexManager;
+    this.serviceRegistry = services.ServiceRegistry;
+  }
+  async build(documents, options = {}, cancelToken = cancellationExports.CancellationToken.None) {
+    var _a, _b;
+    for (const document of documents) {
+      const key = document.uri.toString();
+      if (document.state === DocumentState.Validated) {
+        if (typeof options.validation === "boolean" && options.validation) {
+          document.state = DocumentState.IndexedReferences;
+          document.diagnostics = void 0;
+          this.buildState.delete(key);
+        } else if (typeof options.validation === "object") {
+          const buildState = this.buildState.get(key);
+          const previousCategories = (_a = buildState === null || buildState === void 0 ? void 0 : buildState.result) === null || _a === void 0 ? void 0 : _a.validationChecks;
+          if (previousCategories) {
+            const newCategories = (_b = options.validation.categories) !== null && _b !== void 0 ? _b : ValidationCategory.all;
+            const categories = newCategories.filter((c) => !previousCategories.includes(c));
+            if (categories.length > 0) {
+              this.buildState.set(key, {
+                completed: false,
+                options: {
+                  validation: Object.assign(Object.assign({}, options.validation), { categories })
+                },
+                result: buildState.result
+              });
+              document.state = DocumentState.IndexedReferences;
+            }
+          }
+        }
+      } else {
+        this.buildState.delete(key);
+      }
+    }
+    this.currentState = DocumentState.Changed;
+    await this.emitUpdate(documents.map((e) => e.uri), []);
+    await this.buildDocuments(documents, options, cancelToken);
+  }
+  async update(changed, deleted, cancelToken = cancellationExports.CancellationToken.None) {
+    this.currentState = DocumentState.Changed;
+    for (const deletedUri of deleted) {
+      this.langiumDocuments.deleteDocument(deletedUri);
+      this.buildState.delete(deletedUri.toString());
+      this.indexManager.remove(deletedUri);
+    }
+    for (const changedUri of changed) {
+      const invalidated = this.langiumDocuments.invalidateDocument(changedUri);
+      if (!invalidated) {
+        const newDocument = this.langiumDocumentFactory.fromModel({ $type: "INVALID" }, changedUri);
+        newDocument.state = DocumentState.Changed;
+        this.langiumDocuments.addDocument(newDocument);
+      }
+      this.buildState.delete(changedUri.toString());
+    }
+    const allChangedUris = stream(changed).concat(deleted).map((uri) => uri.toString()).toSet();
+    this.langiumDocuments.all.filter((doc) => !allChangedUris.has(doc.uri.toString()) && this.shouldRelink(doc, allChangedUris)).forEach((doc) => {
+      const linker = this.serviceRegistry.getServices(doc.uri).references.Linker;
+      linker.unlink(doc);
+      doc.state = Math.min(doc.state, DocumentState.ComputedScopes);
+      doc.diagnostics = void 0;
+    });
+    await this.emitUpdate(changed, deleted);
+    await interruptAndCheck(cancelToken);
+    const rebuildDocuments = this.sortDocuments(this.langiumDocuments.all.filter((doc) => {
+      var _a;
+      return doc.state < DocumentState.Linked || !((_a = this.buildState.get(doc.uri.toString())) === null || _a === void 0 ? void 0 : _a.completed);
+    }).toArray());
+    await this.buildDocuments(rebuildDocuments, this.updateBuildOptions, cancelToken);
+  }
+  async emitUpdate(changed, deleted) {
+    await Promise.all(this.updateListeners.map((listener) => listener(changed, deleted)));
+  }
+  /**
+   * Sort the given documents by priority. By default, documents with an open text document are prioritized.
+   * This is useful to ensure that visible documents show their diagnostics before all other documents.
+   *
+   * This improves the responsiveness in large workspaces as users usually don't care about diagnostics
+   * in files that are currently not opened in the editor.
+   */
+  sortDocuments(documents) {
+    let left = 0;
+    let right = documents.length - 1;
+    while (left < right) {
+      while (left < documents.length && this.hasTextDocument(documents[left])) {
+        left++;
+      }
+      while (right >= 0 && !this.hasTextDocument(documents[right])) {
+        right--;
+      }
+      if (left < right) {
+        [documents[left], documents[right]] = [documents[right], documents[left]];
+      }
+    }
+    return documents;
+  }
+  hasTextDocument(doc) {
+    var _a;
+    return Boolean((_a = this.textDocuments) === null || _a === void 0 ? void 0 : _a.get(doc.uri));
+  }
+  /**
+   * Check whether the given document should be relinked after changes were found in the given URIs.
+   */
+  shouldRelink(document, changedUris) {
+    if (document.references.some((ref) => ref.error !== void 0)) {
+      return true;
+    }
+    return this.indexManager.isAffected(document, changedUris);
+  }
+  onUpdate(callback) {
+    this.updateListeners.push(callback);
+    return Disposable.create(() => {
+      const index = this.updateListeners.indexOf(callback);
+      if (index >= 0) {
+        this.updateListeners.splice(index, 1);
+      }
+    });
+  }
+  /**
+   * Build the given documents by stepping through all build phases. If a document's state indicates
+   * that a certain build phase is already done, the phase is skipped for that document.
+   *
+   * @param documents The documents to build.
+   * @param options the {@link BuildOptions} to use.
+   * @param cancelToken A cancellation token that can be used to cancel the build.
+   * @returns A promise that resolves when the build is done.
+   */
+  async buildDocuments(documents, options, cancelToken) {
+    this.prepareBuild(documents, options);
+    await this.runCancelable(documents, DocumentState.Parsed, cancelToken, (doc) => this.langiumDocumentFactory.update(doc, cancelToken));
+    await this.runCancelable(documents, DocumentState.IndexedContent, cancelToken, (doc) => this.indexManager.updateContent(doc, cancelToken));
+    await this.runCancelable(documents, DocumentState.ComputedScopes, cancelToken, async (doc) => {
+      const scopeComputation = this.serviceRegistry.getServices(doc.uri).references.ScopeComputation;
+      doc.precomputedScopes = await scopeComputation.computeLocalScopes(doc, cancelToken);
+    });
+    await this.runCancelable(documents, DocumentState.Linked, cancelToken, (doc) => {
+      const linker = this.serviceRegistry.getServices(doc.uri).references.Linker;
+      return linker.link(doc, cancelToken);
+    });
+    await this.runCancelable(documents, DocumentState.IndexedReferences, cancelToken, (doc) => this.indexManager.updateReferences(doc, cancelToken));
+    const toBeValidated = documents.filter((doc) => this.shouldValidate(doc));
+    await this.runCancelable(toBeValidated, DocumentState.Validated, cancelToken, (doc) => this.validate(doc, cancelToken));
+    for (const doc of documents) {
+      const state = this.buildState.get(doc.uri.toString());
+      if (state) {
+        state.completed = true;
+      }
+    }
+  }
+  /**
+   * Runs prior to beginning the build process to update the {@link DocumentBuildState} for each document
+   *
+   * @param documents collection of documents to be built
+   * @param options the {@link BuildOptions} to use
+   */
+  prepareBuild(documents, options) {
+    for (const doc of documents) {
+      const key = doc.uri.toString();
+      const state = this.buildState.get(key);
+      if (!state || state.completed) {
+        this.buildState.set(key, {
+          completed: false,
+          options,
+          result: state === null || state === void 0 ? void 0 : state.result
+        });
+      }
+    }
+  }
+  /**
+   * Runs a cancelable operation on a set of documents to bring them to a specified {@link DocumentState}.
+   *
+   * @param documents The array of documents to process.
+   * @param targetState The target {@link DocumentState} to bring the documents to.
+   * @param cancelToken A token that can be used to cancel the operation.
+   * @param callback A function to be called for each document.
+   * @returns A promise that resolves when all documents have been processed or the operation is canceled.
+   * @throws Will throw `OperationCancelled` if the operation is canceled via a `CancellationToken`.
+   */
+  async runCancelable(documents, targetState, cancelToken, callback) {
+    const filtered = documents.filter((doc) => doc.state < targetState);
+    for (const document of filtered) {
+      await interruptAndCheck(cancelToken);
+      await callback(document);
+      document.state = targetState;
+      await this.notifyDocumentPhase(document, targetState, cancelToken);
+    }
+    const targetStateDocs = documents.filter((doc) => doc.state === targetState);
+    await this.notifyBuildPhase(targetStateDocs, targetState, cancelToken);
+    this.currentState = targetState;
+  }
+  onBuildPhase(targetState, callback) {
+    this.buildPhaseListeners.add(targetState, callback);
+    return Disposable.create(() => {
+      this.buildPhaseListeners.delete(targetState, callback);
+    });
+  }
+  onDocumentPhase(targetState, callback) {
+    this.documentPhaseListeners.add(targetState, callback);
+    return Disposable.create(() => {
+      this.documentPhaseListeners.delete(targetState, callback);
+    });
+  }
+  waitUntil(state, uriOrToken, cancelToken) {
+    let uri = void 0;
+    if (uriOrToken && "path" in uriOrToken) {
+      uri = uriOrToken;
+    } else {
+      cancelToken = uriOrToken;
+    }
+    cancelToken !== null && cancelToken !== void 0 ? cancelToken : cancelToken = cancellationExports.CancellationToken.None;
+    if (uri) {
+      const document = this.langiumDocuments.getDocument(uri);
+      if (document && document.state > state) {
+        return Promise.resolve(uri);
+      }
+    }
+    if (this.currentState >= state) {
+      return Promise.resolve(void 0);
+    } else if (cancelToken.isCancellationRequested) {
+      return Promise.reject(OperationCancelled);
+    }
+    return new Promise((resolve, reject) => {
+      const buildDisposable = this.onBuildPhase(state, () => {
+        buildDisposable.dispose();
+        cancelDisposable.dispose();
+        if (uri) {
+          const document = this.langiumDocuments.getDocument(uri);
+          resolve(document === null || document === void 0 ? void 0 : document.uri);
+        } else {
+          resolve(void 0);
+        }
+      });
+      const cancelDisposable = cancelToken.onCancellationRequested(() => {
+        buildDisposable.dispose();
+        cancelDisposable.dispose();
+        reject(OperationCancelled);
+      });
+    });
+  }
+  async notifyDocumentPhase(document, state, cancelToken) {
+    const listeners = this.documentPhaseListeners.get(state);
+    const listenersCopy = listeners.slice();
+    for (const listener of listenersCopy) {
+      try {
+        await listener(document, cancelToken);
+      } catch (err) {
+        if (!isOperationCancelled(err)) {
+          throw err;
+        }
+      }
+    }
+  }
+  async notifyBuildPhase(documents, state, cancelToken) {
+    if (documents.length === 0) {
+      return;
+    }
+    const listeners = this.buildPhaseListeners.get(state);
+    const listenersCopy = listeners.slice();
+    for (const listener of listenersCopy) {
+      await interruptAndCheck(cancelToken);
+      await listener(documents, cancelToken);
+    }
+  }
+  /**
+   * Determine whether the given document should be validated during a build. The default
+   * implementation checks the `validation` property of the build options. If it's set to `true`
+   * or a `ValidationOptions` object, the document is included in the validation phase.
+   */
+  shouldValidate(document) {
+    return Boolean(this.getBuildOptions(document).validation);
+  }
+  /**
+   * Run validation checks on the given document and store the resulting diagnostics in the document.
+   * If the document already contains diagnostics, the new ones are added to the list.
+   */
+  async validate(document, cancelToken) {
+    var _a, _b;
+    const validator = this.serviceRegistry.getServices(document.uri).validation.DocumentValidator;
+    const validationSetting = this.getBuildOptions(document).validation;
+    const options = typeof validationSetting === "object" ? validationSetting : void 0;
+    const diagnostics = await validator.validateDocument(document, options, cancelToken);
+    if (document.diagnostics) {
+      document.diagnostics.push(...diagnostics);
+    } else {
+      document.diagnostics = diagnostics;
+    }
+    const state = this.buildState.get(document.uri.toString());
+    if (state) {
+      (_a = state.result) !== null && _a !== void 0 ? _a : state.result = {};
+      const newCategories = (_b = options === null || options === void 0 ? void 0 : options.categories) !== null && _b !== void 0 ? _b : ValidationCategory.all;
+      if (state.result.validationChecks) {
+        state.result.validationChecks.push(...newCategories);
+      } else {
+        state.result.validationChecks = [...newCategories];
+      }
+    }
+  }
+  getBuildOptions(document) {
+    var _a, _b;
+    return (_b = (_a = this.buildState.get(document.uri.toString())) === null || _a === void 0 ? void 0 : _a.options) !== null && _b !== void 0 ? _b : {};
+  }
+}
+export {
+  DefaultDocumentBuilder
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/documents.mjs

@@ -0,0 +1,210 @@
+import { TextDocument } from "../../../../../vscode-languageserver-textdocument@1.0.12/node_modules/vscode-languageserver-textdocument/lib/esm/main.mjs";
+import { stream } from "../utils/stream.mjs";
+import "../utils/uri-utils.mjs";
+import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
+import { URI } from "../../../../../vscode-uri@3.0.8/node_modules/vscode-uri/lib/esm/index.mjs";
+var DocumentState;
+(function(DocumentState2) {
+  DocumentState2[DocumentState2["Changed"] = 0] = "Changed";
+  DocumentState2[DocumentState2["Parsed"] = 1] = "Parsed";
+  DocumentState2[DocumentState2["IndexedContent"] = 2] = "IndexedContent";
+  DocumentState2[DocumentState2["ComputedScopes"] = 3] = "ComputedScopes";
+  DocumentState2[DocumentState2["Linked"] = 4] = "Linked";
+  DocumentState2[DocumentState2["IndexedReferences"] = 5] = "IndexedReferences";
+  DocumentState2[DocumentState2["Validated"] = 6] = "Validated";
+})(DocumentState || (DocumentState = {}));
+class DefaultLangiumDocumentFactory {
+  constructor(services) {
+    this.serviceRegistry = services.ServiceRegistry;
+    this.textDocuments = services.workspace.TextDocuments;
+    this.fileSystemProvider = services.workspace.FileSystemProvider;
+  }
+  async fromUri(uri, cancellationToken = cancellationExports.CancellationToken.None) {
+    const content = await this.fileSystemProvider.readFile(uri);
+    return this.createAsync(uri, content, cancellationToken);
+  }
+  fromTextDocument(textDocument, uri, token) {
+    uri = uri !== null && uri !== void 0 ? uri : URI.parse(textDocument.uri);
+    if (cancellationExports.CancellationToken.is(token)) {
+      return this.createAsync(uri, textDocument, token);
+    } else {
+      return this.create(uri, textDocument, token);
+    }
+  }
+  fromString(text, uri, token) {
+    if (cancellationExports.CancellationToken.is(token)) {
+      return this.createAsync(uri, text, token);
+    } else {
+      return this.create(uri, text, token);
+    }
+  }
+  fromModel(model, uri) {
+    return this.create(uri, { $model: model });
+  }
+  create(uri, content, options) {
+    if (typeof content === "string") {
+      const parseResult = this.parse(uri, content, options);
+      return this.createLangiumDocument(parseResult, uri, void 0, content);
+    } else if ("$model" in content) {
+      const parseResult = { value: content.$model, parserErrors: [], lexerErrors: [] };
+      return this.createLangiumDocument(parseResult, uri);
+    } else {
+      const parseResult = this.parse(uri, content.getText(), options);
+      return this.createLangiumDocument(parseResult, uri, content);
+    }
+  }
+  async createAsync(uri, content, cancelToken) {
+    if (typeof content === "string") {
+      const parseResult = await this.parseAsync(uri, content, cancelToken);
+      return this.createLangiumDocument(parseResult, uri, void 0, content);
+    } else {
+      const parseResult = await this.parseAsync(uri, content.getText(), cancelToken);
+      return this.createLangiumDocument(parseResult, uri, content);
+    }
+  }
+  /**
+   * Create a LangiumDocument from a given parse result.
+   *
+   * A TextDocument is created on demand if it is not provided as argument here. Usually this
+   * should not be necessary because the main purpose of the TextDocument is to convert between
+   * text ranges and offsets, which is done solely in LSP request handling.
+   *
+   * With the introduction of {@link update} below this method is supposed to be mainly called
+   * during workspace initialization and on addition/recognition of new files, while changes in
+   * existing documents are processed via {@link update}.
+   */
+  createLangiumDocument(parseResult, uri, textDocument, text) {
+    let document;
+    if (textDocument) {
+      document = {
+        parseResult,
+        uri,
+        state: DocumentState.Parsed,
+        references: [],
+        textDocument
+      };
+    } else {
+      const textDocumentGetter = this.createTextDocumentGetter(uri, text);
+      document = {
+        parseResult,
+        uri,
+        state: DocumentState.Parsed,
+        references: [],
+        get textDocument() {
+          return textDocumentGetter();
+        }
+      };
+    }
+    parseResult.value.$document = document;
+    return document;
+  }
+  async update(document, cancellationToken) {
+    var _a, _b;
+    const oldText = (_a = document.parseResult.value.$cstNode) === null || _a === void 0 ? void 0 : _a.root.fullText;
+    const textDocument = (_b = this.textDocuments) === null || _b === void 0 ? void 0 : _b.get(document.uri.toString());
+    const text = textDocument ? textDocument.getText() : await this.fileSystemProvider.readFile(document.uri);
+    if (textDocument) {
+      Object.defineProperty(document, "textDocument", {
+        value: textDocument
+      });
+    } else {
+      const textDocumentGetter = this.createTextDocumentGetter(document.uri, text);
+      Object.defineProperty(document, "textDocument", {
+        get: textDocumentGetter
+      });
+    }
+    if (oldText !== text) {
+      document.parseResult = await this.parseAsync(document.uri, text, cancellationToken);
+      document.parseResult.value.$document = document;
+    }
+    document.state = DocumentState.Parsed;
+    return document;
+  }
+  parse(uri, text, options) {
+    const services = this.serviceRegistry.getServices(uri);
+    return services.parser.LangiumParser.parse(text, options);
+  }
+  parseAsync(uri, text, cancellationToken) {
+    const services = this.serviceRegistry.getServices(uri);
+    return services.parser.AsyncParser.parse(text, cancellationToken);
+  }
+  createTextDocumentGetter(uri, text) {
+    const serviceRegistry = this.serviceRegistry;
+    let textDoc = void 0;
+    return () => {
+      return textDoc !== null && textDoc !== void 0 ? textDoc : textDoc = TextDocument.create(uri.toString(), serviceRegistry.getServices(uri).LanguageMetaData.languageId, 0, text !== null && text !== void 0 ? text : "");
+    };
+  }
+}
+class DefaultLangiumDocuments {
+  constructor(services) {
+    this.documentMap = /* @__PURE__ */ new Map();
+    this.langiumDocumentFactory = services.workspace.LangiumDocumentFactory;
+    this.serviceRegistry = services.ServiceRegistry;
+  }
+  get all() {
+    return stream(this.documentMap.values());
+  }
+  addDocument(document) {
+    const uriString = document.uri.toString();
+    if (this.documentMap.has(uriString)) {
+      throw new Error(`A document with the URI '${uriString}' is already present.`);
+    }
+    this.documentMap.set(uriString, document);
+  }
+  getDocument(uri) {
+    const uriString = uri.toString();
+    return this.documentMap.get(uriString);
+  }
+  async getOrCreateDocument(uri, cancellationToken) {
+    let document = this.getDocument(uri);
+    if (document) {
+      return document;
+    }
+    document = await this.langiumDocumentFactory.fromUri(uri, cancellationToken);
+    this.addDocument(document);
+    return document;
+  }
+  createDocument(uri, text, cancellationToken) {
+    if (cancellationToken) {
+      return this.langiumDocumentFactory.fromString(text, uri, cancellationToken).then((document) => {
+        this.addDocument(document);
+        return document;
+      });
+    } else {
+      const document = this.langiumDocumentFactory.fromString(text, uri);
+      this.addDocument(document);
+      return document;
+    }
+  }
+  hasDocument(uri) {
+    return this.documentMap.has(uri.toString());
+  }
+  invalidateDocument(uri) {
+    const uriString = uri.toString();
+    const langiumDoc = this.documentMap.get(uriString);
+    if (langiumDoc) {
+      const linker = this.serviceRegistry.getServices(uri).references.Linker;
+      linker.unlink(langiumDoc);
+      langiumDoc.state = DocumentState.Changed;
+      langiumDoc.precomputedScopes = void 0;
+      langiumDoc.diagnostics = void 0;
+    }
+    return langiumDoc;
+  }
+  deleteDocument(uri) {
+    const uriString = uri.toString();
+    const langiumDoc = this.documentMap.get(uriString);
+    if (langiumDoc) {
+      langiumDoc.state = DocumentState.Changed;
+      this.documentMap.delete(uriString);
+    }
+    return langiumDoc;
+  }
+}
+export {
+  DefaultLangiumDocumentFactory,
+  DefaultLangiumDocuments,
+  DocumentState,
+  TextDocument
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/file-system-provider.mjs

@@ -0,0 +1,15 @@
+class EmptyFileSystemProvider {
+  readFile() {
+    throw new Error("No file system is available.");
+  }
+  async readDirectory() {
+    return [];
+  }
+}
+const EmptyFileSystem = {
+  fileSystemProvider: () => new EmptyFileSystemProvider()
+};
+export {
+  EmptyFileSystem,
+  EmptyFileSystemProvider
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/index-manager.mjs

@@ -0,0 +1,74 @@
+import { getDocument } from "../utils/ast-utils.mjs";
+import { ContextCache } from "../utils/caching.mjs";
+import { stream } from "../utils/stream.mjs";
+import { UriUtils } from "../utils/uri-utils.mjs";
+import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
+class DefaultIndexManager {
+  constructor(services) {
+    this.symbolIndex = /* @__PURE__ */ new Map();
+    this.symbolByTypeIndex = new ContextCache();
+    this.referenceIndex = /* @__PURE__ */ new Map();
+    this.documents = services.workspace.LangiumDocuments;
+    this.serviceRegistry = services.ServiceRegistry;
+    this.astReflection = services.AstReflection;
+  }
+  findAllReferences(targetNode, astNodePath) {
+    const targetDocUri = getDocument(targetNode).uri;
+    const result = [];
+    this.referenceIndex.forEach((docRefs) => {
+      docRefs.forEach((refDescr) => {
+        if (UriUtils.equals(refDescr.targetUri, targetDocUri) && refDescr.targetPath === astNodePath) {
+          result.push(refDescr);
+        }
+      });
+    });
+    return stream(result);
+  }
+  allElements(nodeType, uris) {
+    let documentUris = stream(this.symbolIndex.keys());
+    if (uris) {
+      documentUris = documentUris.filter((uri) => !uris || uris.has(uri));
+    }
+    return documentUris.map((uri) => this.getFileDescriptions(uri, nodeType)).flat();
+  }
+  getFileDescriptions(uri, nodeType) {
+    var _a;
+    if (!nodeType) {
+      return (_a = this.symbolIndex.get(uri)) !== null && _a !== void 0 ? _a : [];
+    }
+    const descriptions = this.symbolByTypeIndex.get(uri, nodeType, () => {
+      var _a2;
+      const allFileDescriptions = (_a2 = this.symbolIndex.get(uri)) !== null && _a2 !== void 0 ? _a2 : [];
+      return allFileDescriptions.filter((e) => this.astReflection.isSubtype(e.type, nodeType));
+    });
+    return descriptions;
+  }
+  remove(uri) {
+    const uriString = uri.toString();
+    this.symbolIndex.delete(uriString);
+    this.symbolByTypeIndex.clear(uriString);
+    this.referenceIndex.delete(uriString);
+  }
+  async updateContent(document, cancelToken = cancellationExports.CancellationToken.None) {
+    const services = this.serviceRegistry.getServices(document.uri);
+    const exports = await services.references.ScopeComputation.computeExports(document, cancelToken);
+    const uri = document.uri.toString();
+    this.symbolIndex.set(uri, exports);
+    this.symbolByTypeIndex.clear(uri);
+  }
+  async updateReferences(document, cancelToken = cancellationExports.CancellationToken.None) {
+    const services = this.serviceRegistry.getServices(document.uri);
+    const indexData = await services.workspace.ReferenceDescriptionProvider.createDescriptions(document, cancelToken);
+    this.referenceIndex.set(document.uri.toString(), indexData);
+  }
+  isAffected(document, changedUris) {
+    const references = this.referenceIndex.get(document.uri.toString());
+    if (!references) {
+      return false;
+    }
+    return references.some((ref) => !ref.local && changedUris.has(ref.targetUri.toString()));
+  }
+}
+export {
+  DefaultIndexManager
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/workspace-lock.mjs

@@ -0,0 +1,64 @@
+import { startCancelableOperation, Deferred, isOperationCancelled } from "../utils/promise-utils.mjs";
+import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
+class DefaultWorkspaceLock {
+  constructor() {
+    this.previousTokenSource = new cancellationExports.CancellationTokenSource();
+    this.writeQueue = [];
+    this.readQueue = [];
+    this.done = true;
+  }
+  write(action) {
+    this.cancelWrite();
+    const tokenSource = startCancelableOperation();
+    this.previousTokenSource = tokenSource;
+    return this.enqueue(this.writeQueue, action, tokenSource.token);
+  }
+  read(action) {
+    return this.enqueue(this.readQueue, action);
+  }
+  enqueue(queue, action, cancellationToken = cancellationExports.CancellationToken.None) {
+    const deferred = new Deferred();
+    const entry = {
+      action,
+      deferred,
+      cancellationToken
+    };
+    queue.push(entry);
+    this.performNextOperation();
+    return deferred.promise;
+  }
+  async performNextOperation() {
+    if (!this.done) {
+      return;
+    }
+    const entries = [];
+    if (this.writeQueue.length > 0) {
+      entries.push(this.writeQueue.shift());
+    } else if (this.readQueue.length > 0) {
+      entries.push(...this.readQueue.splice(0, this.readQueue.length));
+    } else {
+      return;
+    }
+    this.done = false;
+    await Promise.all(entries.map(async ({ action, deferred, cancellationToken }) => {
+      try {
+        const result = await Promise.resolve().then(() => action(cancellationToken));
+        deferred.resolve(result);
+      } catch (err) {
+        if (isOperationCancelled(err)) {
+          deferred.resolve(void 0);
+        } else {
+          deferred.reject(err);
+        }
+      }
+    }));
+    this.done = true;
+    this.performNextOperation();
+  }
+  cancelWrite() {
+    this.previousTokenSource.cancel();
+  }
+}
+export {
+  DefaultWorkspaceLock
+};