@elmethis/core 1.0.0-alpha.149 → 1.0.0-alpha.150

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

@@ -1,236 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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
-};