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

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/validation/document-validator.mjs

@@ -0,0 +1,236 @@
+import { findNodeForProperty, findNodeForKeyword } from "../utils/grammar-utils.mjs";
+import { streamAst } from "../utils/ast-utils.mjs";
+import { tokenToRange } from "../utils/cst-utils.mjs";
+import { interruptAndCheck, isOperationCancelled } from "../utils/promise-utils.mjs";
+import { diagnosticData } from "./validation-registry.mjs";
+import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
+class DefaultDocumentValidator {
+  constructor(services) {
+    this.validationRegistry = services.validation.ValidationRegistry;
+    this.metadata = services.LanguageMetaData;
+  }
+  async validateDocument(document, options = {}, cancelToken = cancellationExports.CancellationToken.None) {
+    const parseResult = document.parseResult;
+    const diagnostics = [];
+    await interruptAndCheck(cancelToken);
+    if (!options.categories || options.categories.includes("built-in")) {
+      this.processLexingErrors(parseResult, diagnostics, options);
+      if (options.stopAfterLexingErrors && diagnostics.some((d) => {
+        var _a;
+        return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LexingError;
+      })) {
+        return diagnostics;
+      }
+      this.processParsingErrors(parseResult, diagnostics, options);
+      if (options.stopAfterParsingErrors && diagnostics.some((d) => {
+        var _a;
+        return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.ParsingError;
+      })) {
+        return diagnostics;
+      }
+      this.processLinkingErrors(document, diagnostics, options);
+      if (options.stopAfterLinkingErrors && diagnostics.some((d) => {
+        var _a;
+        return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LinkingError;
+      })) {
+        return diagnostics;
+      }
+    }
+    try {
+      diagnostics.push(...await this.validateAst(parseResult.value, options, cancelToken));
+    } catch (err) {
+      if (isOperationCancelled(err)) {
+        throw err;
+      }
+      console.error("An error occurred during validation:", err);
+    }
+    await interruptAndCheck(cancelToken);
+    return diagnostics;
+  }
+  processLexingErrors(parseResult, diagnostics, _options) {
+    var _a, _b, _c;
+    const lexerDiagnostics = [...parseResult.lexerErrors, ...(_b = (_a = parseResult.lexerReport) === null || _a === void 0 ? void 0 : _a.diagnostics) !== null && _b !== void 0 ? _b : []];
+    for (const lexerDiagnostic of lexerDiagnostics) {
+      const severity = (_c = lexerDiagnostic.severity) !== null && _c !== void 0 ? _c : "error";
+      const diagnostic = {
+        severity: toDiagnosticSeverity(severity),
+        range: {
+          start: {
+            line: lexerDiagnostic.line - 1,
+            character: lexerDiagnostic.column - 1
+          },
+          end: {
+            line: lexerDiagnostic.line - 1,
+            character: lexerDiagnostic.column + lexerDiagnostic.length - 1
+          }
+        },
+        message: lexerDiagnostic.message,
+        data: toDiagnosticData(severity),
+        source: this.getSource()
+      };
+      diagnostics.push(diagnostic);
+    }
+  }
+  processParsingErrors(parseResult, diagnostics, _options) {
+    for (const parserError of parseResult.parserErrors) {
+      let range = void 0;
+      if (isNaN(parserError.token.startOffset)) {
+        if ("previousToken" in parserError) {
+          const token = parserError.previousToken;
+          if (!isNaN(token.startOffset)) {
+            const position = { line: token.endLine - 1, character: token.endColumn };
+            range = { start: position, end: position };
+          } else {
+            const position = { line: 0, character: 0 };
+            range = { start: position, end: position };
+          }
+        }
+      } else {
+        range = tokenToRange(parserError.token);
+      }
+      if (range) {
+        const diagnostic = {
+          severity: toDiagnosticSeverity("error"),
+          range,
+          message: parserError.message,
+          data: diagnosticData(DocumentValidator.ParsingError),
+          source: this.getSource()
+        };
+        diagnostics.push(diagnostic);
+      }
+    }
+  }
+  processLinkingErrors(document, diagnostics, _options) {
+    for (const reference of document.references) {
+      const linkingError = reference.error;
+      if (linkingError) {
+        const info = {
+          node: linkingError.container,
+          property: linkingError.property,
+          index: linkingError.index,
+          data: {
+            code: DocumentValidator.LinkingError,
+            containerType: linkingError.container.$type,
+            property: linkingError.property,
+            refText: linkingError.reference.$refText
+          }
+        };
+        diagnostics.push(this.toDiagnostic("error", linkingError.message, info));
+      }
+    }
+  }
+  async validateAst(rootNode, options, cancelToken = cancellationExports.CancellationToken.None) {
+    const validationItems = [];
+    const acceptor = (severity, message, info) => {
+      validationItems.push(this.toDiagnostic(severity, message, info));
+    };
+    await this.validateAstBefore(rootNode, options, acceptor, cancelToken);
+    await this.validateAstNodes(rootNode, options, acceptor, cancelToken);
+    await this.validateAstAfter(rootNode, options, acceptor, cancelToken);
+    return validationItems;
+  }
+  async validateAstBefore(rootNode, options, acceptor, cancelToken = cancellationExports.CancellationToken.None) {
+    var _a;
+    const checksBefore = this.validationRegistry.checksBefore;
+    for (const checkBefore of checksBefore) {
+      await interruptAndCheck(cancelToken);
+      await checkBefore(rootNode, acceptor, (_a = options.categories) !== null && _a !== void 0 ? _a : [], cancelToken);
+    }
+  }
+  async validateAstNodes(rootNode, options, acceptor, cancelToken = cancellationExports.CancellationToken.None) {
+    await Promise.all(streamAst(rootNode).map(async (node) => {
+      await interruptAndCheck(cancelToken);
+      const checks = this.validationRegistry.getChecks(node.$type, options.categories);
+      for (const check of checks) {
+        await check(node, acceptor, cancelToken);
+      }
+    }));
+  }
+  async validateAstAfter(rootNode, options, acceptor, cancelToken = cancellationExports.CancellationToken.None) {
+    var _a;
+    const checksAfter = this.validationRegistry.checksAfter;
+    for (const checkAfter of checksAfter) {
+      await interruptAndCheck(cancelToken);
+      await checkAfter(rootNode, acceptor, (_a = options.categories) !== null && _a !== void 0 ? _a : [], cancelToken);
+    }
+  }
+  toDiagnostic(severity, message, info) {
+    return {
+      message,
+      range: getDiagnosticRange(info),
+      severity: toDiagnosticSeverity(severity),
+      code: info.code,
+      codeDescription: info.codeDescription,
+      tags: info.tags,
+      relatedInformation: info.relatedInformation,
+      data: info.data,
+      source: this.getSource()
+    };
+  }
+  getSource() {
+    return this.metadata.languageId;
+  }
+}
+function getDiagnosticRange(info) {
+  if (info.range) {
+    return info.range;
+  }
+  let cstNode;
+  if (typeof info.property === "string") {
+    cstNode = findNodeForProperty(info.node.$cstNode, info.property, info.index);
+  } else if (typeof info.keyword === "string") {
+    cstNode = findNodeForKeyword(info.node.$cstNode, info.keyword, info.index);
+  }
+  cstNode !== null && cstNode !== void 0 ? cstNode : cstNode = info.node.$cstNode;
+  if (!cstNode) {
+    return {
+      start: { line: 0, character: 0 },
+      end: { line: 0, character: 0 }
+    };
+  }
+  return cstNode.range;
+}
+function toDiagnosticSeverity(severity) {
+  switch (severity) {
+    case "error":
+      return 1;
+    case "warning":
+      return 2;
+    case "info":
+      return 3;
+    case "hint":
+      return 4;
+    default:
+      throw new Error("Invalid diagnostic severity: " + severity);
+  }
+}
+function toDiagnosticData(severity) {
+  switch (severity) {
+    case "error":
+      return diagnosticData(DocumentValidator.LexingError);
+    case "warning":
+      return diagnosticData(DocumentValidator.LexingWarning);
+    case "info":
+      return diagnosticData(DocumentValidator.LexingInfo);
+    case "hint":
+      return diagnosticData(DocumentValidator.LexingHint);
+    default:
+      throw new Error("Invalid diagnostic severity: " + severity);
+  }
+}
+var DocumentValidator;
+(function(DocumentValidator2) {
+  DocumentValidator2.LexingError = "lexing-error";
+  DocumentValidator2.LexingWarning = "lexing-warning";
+  DocumentValidator2.LexingInfo = "lexing-info";
+  DocumentValidator2.LexingHint = "lexing-hint";
+  DocumentValidator2.ParsingError = "parsing-error";
+  DocumentValidator2.LinkingError = "linking-error";
+})(DocumentValidator || (DocumentValidator = {}));
+export {
+  DefaultDocumentValidator,
+  DocumentValidator,
+  getDiagnosticRange,
+  toDiagnosticData,
+  toDiagnosticSeverity
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/validation/validation-registry.mjs

@@ -0,0 +1,142 @@
+import { MultiMap } from "../utils/collections.mjs";
+import { isOperationCancelled } from "../utils/promise-utils.mjs";
+import { stream } from "../utils/stream.mjs";
+import { assertUnreachable } from "../utils/errors.mjs";
+function diagnosticData(code) {
+  return { code };
+}
+var ValidationCategory;
+(function(ValidationCategory2) {
+  ValidationCategory2.all = ["fast", "slow", "built-in"];
+})(ValidationCategory || (ValidationCategory = {}));
+class ValidationRegistry {
+  constructor(services) {
+    this.entries = new MultiMap();
+    this.entriesBefore = [];
+    this.entriesAfter = [];
+    this.reflection = services.shared.AstReflection;
+  }
+  /**
+   * Register a set of validation checks. Each value in the record can be either a single validation check (i.e. a function)
+   * or an array of validation checks.
+   *
+   * @param checksRecord Set of validation checks to register.
+   * @param category Optional category for the validation checks (defaults to `'fast'`).
+   * @param thisObj Optional object to be used as `this` when calling the validation check functions.
+   */
+  register(checksRecord, thisObj = this, category = "fast") {
+    if (category === "built-in") {
+      throw new Error("The 'built-in' category is reserved for lexer, parser, and linker errors.");
+    }
+    for (const [type, ch] of Object.entries(checksRecord)) {
+      const callbacks = ch;
+      if (Array.isArray(callbacks)) {
+        for (const check of callbacks) {
+          const entry = {
+            check: this.wrapValidationException(check, thisObj),
+            category
+          };
+          this.addEntry(type, entry);
+        }
+      } else if (typeof callbacks === "function") {
+        const entry = {
+          check: this.wrapValidationException(callbacks, thisObj),
+          category
+        };
+        this.addEntry(type, entry);
+      } else {
+        assertUnreachable();
+      }
+    }
+  }
+  wrapValidationException(check, thisObj) {
+    return async (node, accept, cancelToken) => {
+      await this.handleException(() => check.call(thisObj, node, accept, cancelToken), "An error occurred during validation", accept, node);
+    };
+  }
+  async handleException(functionality, messageContext, accept, node) {
+    try {
+      await functionality();
+    } catch (err) {
+      if (isOperationCancelled(err)) {
+        throw err;
+      }
+      console.error(`${messageContext}:`, err);
+      if (err instanceof Error && err.stack) {
+        console.error(err.stack);
+      }
+      const messageDetails = err instanceof Error ? err.message : String(err);
+      accept("error", `${messageContext}: ${messageDetails}`, { node });
+    }
+  }
+  addEntry(type, entry) {
+    if (type === "AstNode") {
+      this.entries.add("AstNode", entry);
+      return;
+    }
+    for (const subtype of this.reflection.getAllSubTypes(type)) {
+      this.entries.add(subtype, entry);
+    }
+  }
+  getChecks(type, categories) {
+    let checks = stream(this.entries.get(type)).concat(this.entries.get("AstNode"));
+    if (categories) {
+      checks = checks.filter((entry) => categories.includes(entry.category));
+    }
+    return checks.map((entry) => entry.check);
+  }
+  /**
+   * Register logic which will be executed once before validating all the nodes of an AST/Langium document.
+   * This helps to prepare or initialize some information which are required or reusable for the following checks on the AstNodes.
+   *
+   * As an example, for validating unique fully-qualified names of nodes in the AST,
+   * here the map for mapping names to nodes could be established.
+   * During the usual checks on the nodes, they are put into this map with their name.
+   *
+   * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
+   * Therefore it is recommended to clear stored information
+   * _before_ validating an AST to validate each AST unaffected from other ASTs
+   * AND _after_ validating the AST to free memory by information which are no longer used.
+   *
+   * @param checkBefore a set-up function which will be called once before actually validating an AST
+   * @param thisObj Optional object to be used as `this` when calling the validation check functions.
+   */
+  registerBeforeDocument(checkBefore, thisObj = this) {
+    this.entriesBefore.push(this.wrapPreparationException(checkBefore, "An error occurred during set-up of the validation", thisObj));
+  }
+  /**
+   * Register logic which will be executed once after validating all the nodes of an AST/Langium document.
+   * This helps to finally evaluate information which are collected during the checks on the AstNodes.
+   *
+   * As an example, for validating unique fully-qualified names of nodes in the AST,
+   * here the map with all the collected nodes and their names is checked
+   * and validation hints are created for all nodes with the same name.
+   *
+   * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
+   * Therefore it is recommended to clear stored information
+   * _before_ validating an AST to validate each AST unaffected from other ASTs
+   * AND _after_ validating the AST to free memory by information which are no longer used.
+   *
+   * @param checkBefore a set-up function which will be called once before actually validating an AST
+   * @param thisObj Optional object to be used as `this` when calling the validation check functions.
+   */
+  registerAfterDocument(checkAfter, thisObj = this) {
+    this.entriesAfter.push(this.wrapPreparationException(checkAfter, "An error occurred during tear-down of the validation", thisObj));
+  }
+  wrapPreparationException(check, messageContext, thisObj) {
+    return async (rootNode, accept, categories, cancelToken) => {
+      await this.handleException(() => check.call(thisObj, rootNode, accept, categories, cancelToken), messageContext, accept, rootNode);
+    };
+  }
+  get checksBefore() {
+    return this.entriesBefore;
+  }
+  get checksAfter() {
+    return this.entriesAfter;
+  }
+}
+export {
+  ValidationCategory,
+  ValidationRegistry,
+  diagnosticData
+};

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

@@ -0,0 +1,75 @@
+import { isLinkingError } from "../syntax-tree.mjs";
+import { streamAst, streamReferences, getDocument } from "../utils/ast-utils.mjs";
+import { toDocumentSegment } from "../utils/cst-utils.mjs";
+import { interruptAndCheck } from "../utils/promise-utils.mjs";
+import { UriUtils } from "../utils/uri-utils.mjs";
+import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
+class DefaultAstNodeDescriptionProvider {
+  constructor(services) {
+    this.astNodeLocator = services.workspace.AstNodeLocator;
+    this.nameProvider = services.references.NameProvider;
+  }
+  createDescription(node, name, document) {
+    const doc = document !== null && document !== void 0 ? document : getDocument(node);
+    name !== null && name !== void 0 ? name : name = this.nameProvider.getName(node);
+    const path = this.astNodeLocator.getAstNodePath(node);
+    if (!name) {
+      throw new Error(`Node at path ${path} has no name.`);
+    }
+    let nameNodeSegment;
+    const nameSegmentGetter = () => {
+      var _a;
+      return nameNodeSegment !== null && nameNodeSegment !== void 0 ? nameNodeSegment : nameNodeSegment = toDocumentSegment((_a = this.nameProvider.getNameNode(node)) !== null && _a !== void 0 ? _a : node.$cstNode);
+    };
+    return {
+      node,
+      name,
+      get nameSegment() {
+        return nameSegmentGetter();
+      },
+      selectionSegment: toDocumentSegment(node.$cstNode),
+      type: node.$type,
+      documentUri: doc.uri,
+      path
+    };
+  }
+}
+class DefaultReferenceDescriptionProvider {
+  constructor(services) {
+    this.nodeLocator = services.workspace.AstNodeLocator;
+  }
+  async createDescriptions(document, cancelToken = cancellationExports.CancellationToken.None) {
+    const descr = [];
+    const rootNode = document.parseResult.value;
+    for (const astNode of streamAst(rootNode)) {
+      await interruptAndCheck(cancelToken);
+      streamReferences(astNode).filter((refInfo) => !isLinkingError(refInfo)).forEach((refInfo) => {
+        const description = this.createDescription(refInfo);
+        if (description) {
+          descr.push(description);
+        }
+      });
+    }
+    return descr;
+  }
+  createDescription(refInfo) {
+    const targetNodeDescr = refInfo.reference.$nodeDescription;
+    const refCstNode = refInfo.reference.$refNode;
+    if (!targetNodeDescr || !refCstNode) {
+      return void 0;
+    }
+    const docUri = getDocument(refInfo.container).uri;
+    return {
+      sourceUri: docUri,
+      sourcePath: this.nodeLocator.getAstNodePath(refInfo.container),
+      targetUri: targetNodeDescr.documentUri,
+      targetPath: targetNodeDescr.path,
+      segment: toDocumentSegment(refCstNode),
+      local: UriUtils.equals(targetNodeDescr.documentUri, docUri)
+    };
+  }
+}
+export {
+  DefaultAstNodeDescriptionProvider,
+  DefaultReferenceDescriptionProvider
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/ast-node-locator.mjs

@@ -0,0 +1,43 @@
+class DefaultAstNodeLocator {
+  constructor() {
+    this.segmentSeparator = "/";
+    this.indexSeparator = "@";
+  }
+  getAstNodePath(node) {
+    if (node.$container) {
+      const containerPath = this.getAstNodePath(node.$container);
+      const newSegment = this.getPathSegment(node);
+      const nodePath = containerPath + this.segmentSeparator + newSegment;
+      return nodePath;
+    }
+    return "";
+  }
+  getPathSegment({ $containerProperty, $containerIndex }) {
+    if (!$containerProperty) {
+      throw new Error("Missing '$containerProperty' in AST node.");
+    }
+    if ($containerIndex !== void 0) {
+      return $containerProperty + this.indexSeparator + $containerIndex;
+    }
+    return $containerProperty;
+  }
+  getAstNode(node, path) {
+    const segments = path.split(this.segmentSeparator);
+    return segments.reduce((previousValue, currentValue) => {
+      if (!previousValue || currentValue.length === 0) {
+        return previousValue;
+      }
+      const propertyIndex = currentValue.indexOf(this.indexSeparator);
+      if (propertyIndex > 0) {
+        const property = currentValue.substring(0, propertyIndex);
+        const arrayIndex = parseInt(currentValue.substring(propertyIndex + 1));
+        const array = previousValue[property];
+        return array === null || array === void 0 ? void 0 : array[arrayIndex];
+      }
+      return previousValue[currentValue];
+    }, node);
+  }
+}
+export {
+  DefaultAstNodeLocator
+};

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

@@ -0,0 +1,81 @@
+import { Deferred } from "../utils/promise-utils.mjs";
+import { e as eventsExports } from "../../../../../../../_virtual/events.mjs";
+class DefaultConfigurationProvider {
+  constructor(services) {
+    this._ready = new Deferred();
+    this.settings = {};
+    this.workspaceConfig = false;
+    this.onConfigurationSectionUpdateEmitter = new eventsExports.Emitter();
+    this.serviceRegistry = services.ServiceRegistry;
+  }
+  get ready() {
+    return this._ready.promise;
+  }
+  initialize(params) {
+    var _a, _b;
+    this.workspaceConfig = (_b = (_a = params.capabilities.workspace) === null || _a === void 0 ? void 0 : _a.configuration) !== null && _b !== void 0 ? _b : false;
+  }
+  async initialized(params) {
+    if (this.workspaceConfig) {
+      if (params.register) {
+        const languages = this.serviceRegistry.all;
+        params.register({
+          // Listen to configuration changes for all languages
+          section: languages.map((lang) => this.toSectionName(lang.LanguageMetaData.languageId))
+        });
+      }
+      if (params.fetchConfiguration) {
+        const configToUpdate = this.serviceRegistry.all.map((lang) => ({
+          // Fetch the configuration changes for all languages
+          section: this.toSectionName(lang.LanguageMetaData.languageId)
+        }));
+        const configs = await params.fetchConfiguration(configToUpdate);
+        configToUpdate.forEach((conf, idx) => {
+          this.updateSectionConfiguration(conf.section, configs[idx]);
+        });
+      }
+    }
+    this._ready.resolve();
+  }
+  /**
+   *  Updates the cached configurations using the `change` notification parameters.
+   *
+   * @param change The parameters of a change configuration notification.
+   * `settings` property of the change object could be expressed as `Record<string, Record<string, any>>`
+   */
+  updateConfiguration(change) {
+    if (!change.settings) {
+      return;
+    }
+    Object.keys(change.settings).forEach((section) => {
+      const configuration = change.settings[section];
+      this.updateSectionConfiguration(section, configuration);
+      this.onConfigurationSectionUpdateEmitter.fire({ section, configuration });
+    });
+  }
+  updateSectionConfiguration(section, configuration) {
+    this.settings[section] = configuration;
+  }
+  /**
+  * Returns a configuration value stored for the given language.
+  *
+  * @param language The language id
+  * @param configuration Configuration name
+  */
+  async getConfiguration(language, configuration) {
+    await this.ready;
+    const sectionName = this.toSectionName(language);
+    if (this.settings[sectionName]) {
+      return this.settings[sectionName][configuration];
+    }
+  }
+  toSectionName(languageId) {
+    return `${languageId}`;
+  }
+  get onConfigurationSectionUpdate() {
+    return this.onConfigurationSectionUpdateEmitter.event;
+  }
+}
+export {
+  DefaultConfigurationProvider
+};