@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/references/name-provider.mjs

@@ -0,0 +1,19 @@
+import { findNodeForProperty } from "../utils/grammar-utils.mjs";
+function isNamed(node) {
+  return typeof node.name === "string";
+}
+class DefaultNameProvider {
+  getName(node) {
+    if (isNamed(node)) {
+      return node.name;
+    }
+    return void 0;
+  }
+  getNameNode(node) {
+    return findNodeForProperty(node.$cstNode, "name");
+  }
+}
+export {
+  DefaultNameProvider,
+  isNamed
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/references.mjs

@@ -0,0 +1,80 @@
+import { findAssignment } from "../utils/grammar-utils.mjs";
+import { isReference } from "../syntax-tree.mjs";
+import { getDocument } from "../utils/ast-utils.mjs";
+import { isChildNode, toDocumentSegment } from "../utils/cst-utils.mjs";
+import { stream } from "../utils/stream.mjs";
+import { UriUtils } from "../utils/uri-utils.mjs";
+class DefaultReferences {
+  constructor(services) {
+    this.nameProvider = services.references.NameProvider;
+    this.index = services.shared.workspace.IndexManager;
+    this.nodeLocator = services.workspace.AstNodeLocator;
+  }
+  findDeclaration(sourceCstNode) {
+    if (sourceCstNode) {
+      const assignment = findAssignment(sourceCstNode);
+      const nodeElem = sourceCstNode.astNode;
+      if (assignment && nodeElem) {
+        const reference = nodeElem[assignment.feature];
+        if (isReference(reference)) {
+          return reference.ref;
+        } else if (Array.isArray(reference)) {
+          for (const ref of reference) {
+            if (isReference(ref) && ref.$refNode && ref.$refNode.offset <= sourceCstNode.offset && ref.$refNode.end >= sourceCstNode.end) {
+              return ref.ref;
+            }
+          }
+        }
+      }
+      if (nodeElem) {
+        const nameNode = this.nameProvider.getNameNode(nodeElem);
+        if (nameNode && (nameNode === sourceCstNode || isChildNode(sourceCstNode, nameNode))) {
+          return nodeElem;
+        }
+      }
+    }
+    return void 0;
+  }
+  findDeclarationNode(sourceCstNode) {
+    const astNode = this.findDeclaration(sourceCstNode);
+    if (astNode === null || astNode === void 0 ? void 0 : astNode.$cstNode) {
+      const targetNode = this.nameProvider.getNameNode(astNode);
+      return targetNode !== null && targetNode !== void 0 ? targetNode : astNode.$cstNode;
+    }
+    return void 0;
+  }
+  findReferences(targetNode, options) {
+    const refs = [];
+    if (options.includeDeclaration) {
+      const ref = this.getReferenceToSelf(targetNode);
+      if (ref) {
+        refs.push(ref);
+      }
+    }
+    let indexReferences = this.index.findAllReferences(targetNode, this.nodeLocator.getAstNodePath(targetNode));
+    if (options.documentUri) {
+      indexReferences = indexReferences.filter((ref) => UriUtils.equals(ref.sourceUri, options.documentUri));
+    }
+    refs.push(...indexReferences);
+    return stream(refs);
+  }
+  getReferenceToSelf(targetNode) {
+    const nameNode = this.nameProvider.getNameNode(targetNode);
+    if (nameNode) {
+      const doc = getDocument(targetNode);
+      const path = this.nodeLocator.getAstNodePath(targetNode);
+      return {
+        sourceUri: doc.uri,
+        sourcePath: path,
+        targetUri: doc.uri,
+        targetPath: path,
+        segment: toDocumentSegment(nameNode),
+        local: true
+      };
+    }
+    return void 0;
+  }
+}
+export {
+  DefaultReferences
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/scope-computation.mjs

@@ -0,0 +1,70 @@
+import { streamContents, streamAllContents } from "../utils/ast-utils.mjs";
+import { MultiMap } from "../utils/collections.mjs";
+import { interruptAndCheck } from "../utils/promise-utils.mjs";
+import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
+class DefaultScopeComputation {
+  constructor(services) {
+    this.nameProvider = services.references.NameProvider;
+    this.descriptions = services.workspace.AstNodeDescriptionProvider;
+  }
+  async computeExports(document, cancelToken = cancellationExports.CancellationToken.None) {
+    return this.computeExportsForNode(document.parseResult.value, document, void 0, cancelToken);
+  }
+  /**
+   * Creates {@link AstNodeDescription AstNodeDescriptions} for the given {@link AstNode parentNode} and its children.
+   * The list of children to be considered is determined by the function parameter {@link children}.
+   * By default only the direct children of {@link parentNode} are visited, nested nodes are not exported.
+   *
+   * @param parentNode AST node to be exported, i.e., of which an {@link AstNodeDescription} shall be added to the returned list.
+   * @param document The document containing the AST node to be exported.
+   * @param children A function called with {@link parentNode} as single argument and returning an {@link Iterable} supplying the children to be visited, which must be directly or transitively contained in {@link parentNode}.
+   * @param cancelToken Indicates when to cancel the current operation.
+   * @throws `OperationCancelled` if a user action occurs during execution.
+   * @returns A list of {@link AstNodeDescription AstNodeDescriptions} to be published to index.
+   */
+  async computeExportsForNode(parentNode, document, children = streamContents, cancelToken = cancellationExports.CancellationToken.None) {
+    const exports = [];
+    this.exportNode(parentNode, exports, document);
+    for (const node of children(parentNode)) {
+      await interruptAndCheck(cancelToken);
+      this.exportNode(node, exports, document);
+    }
+    return exports;
+  }
+  /**
+   * Add a single node to the list of exports if it has a name. Override this method to change how
+   * symbols are exported, e.g. by modifying their exported name.
+   */
+  exportNode(node, exports, document) {
+    const name = this.nameProvider.getName(node);
+    if (name) {
+      exports.push(this.descriptions.createDescription(node, name, document));
+    }
+  }
+  async computeLocalScopes(document, cancelToken = cancellationExports.CancellationToken.None) {
+    const rootNode = document.parseResult.value;
+    const scopes = new MultiMap();
+    for (const node of streamAllContents(rootNode)) {
+      await interruptAndCheck(cancelToken);
+      this.processNode(node, document, scopes);
+    }
+    return scopes;
+  }
+  /**
+   * Process a single node during scopes computation. The default implementation makes the node visible
+   * in the subtree of its container (if the node has a name). Override this method to change this,
+   * e.g. by increasing the visibility to a higher level in the AST.
+   */
+  processNode(node, document, scopes) {
+    const container = node.$container;
+    if (container) {
+      const name = this.nameProvider.getName(node);
+      if (name) {
+        scopes.add(container, this.descriptions.createDescription(node, name, document));
+      }
+    }
+  }
+}
+export {
+  DefaultScopeComputation
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/scope-provider.mjs

@@ -0,0 +1,62 @@
+import { StreamScope, MapScope } from "./scope.mjs";
+import { getDocument } from "../utils/ast-utils.mjs";
+import { stream } from "../utils/stream.mjs";
+import { WorkspaceCache } from "../utils/caching.mjs";
+class DefaultScopeProvider {
+  constructor(services) {
+    this.reflection = services.shared.AstReflection;
+    this.nameProvider = services.references.NameProvider;
+    this.descriptions = services.workspace.AstNodeDescriptionProvider;
+    this.indexManager = services.shared.workspace.IndexManager;
+    this.globalScopeCache = new WorkspaceCache(services.shared);
+  }
+  getScope(context) {
+    const scopes = [];
+    const referenceType = this.reflection.getReferenceType(context);
+    const precomputed = getDocument(context.container).precomputedScopes;
+    if (precomputed) {
+      let currentNode = context.container;
+      do {
+        const allDescriptions = precomputed.get(currentNode);
+        if (allDescriptions.length > 0) {
+          scopes.push(stream(allDescriptions).filter((desc) => this.reflection.isSubtype(desc.type, referenceType)));
+        }
+        currentNode = currentNode.$container;
+      } while (currentNode);
+    }
+    let result = this.getGlobalScope(referenceType, context);
+    for (let i = scopes.length - 1; i >= 0; i--) {
+      result = this.createScope(scopes[i], result);
+    }
+    return result;
+  }
+  /**
+   * Create a scope for the given collection of AST node descriptions.
+   */
+  createScope(elements, outerScope, options) {
+    return new StreamScope(stream(elements), outerScope, options);
+  }
+  /**
+   * Create a scope for the given collection of AST nodes, which need to be transformed into respective
+   * descriptions first. This is done using the `NameProvider` and `AstNodeDescriptionProvider` services.
+   */
+  createScopeForNodes(elements, outerScope, options) {
+    const s = stream(elements).map((e) => {
+      const name = this.nameProvider.getName(e);
+      if (name) {
+        return this.descriptions.createDescription(e, name);
+      }
+      return void 0;
+    }).nonNullable();
+    return new StreamScope(s, outerScope, options);
+  }
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  getGlobalScope(referenceType, _context) {
+    return this.globalScopeCache.get(referenceType, () => new MapScope(this.indexManager.allElements(referenceType)));
+  }
+}
+export {
+  DefaultScopeProvider
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/scope.mjs

@@ -0,0 +1,60 @@
+import { stream } from "../utils/stream.mjs";
+class StreamScope {
+  constructor(elements, outerScope, options) {
+    var _a;
+    this.elements = elements;
+    this.outerScope = outerScope;
+    this.caseInsensitive = (_a = options === null || options === void 0 ? void 0 : options.caseInsensitive) !== null && _a !== void 0 ? _a : false;
+  }
+  getAllElements() {
+    if (this.outerScope) {
+      return this.elements.concat(this.outerScope.getAllElements());
+    } else {
+      return this.elements;
+    }
+  }
+  getElement(name) {
+    const local = this.caseInsensitive ? this.elements.find((e) => e.name.toLowerCase() === name.toLowerCase()) : this.elements.find((e) => e.name === name);
+    if (local) {
+      return local;
+    }
+    if (this.outerScope) {
+      return this.outerScope.getElement(name);
+    }
+    return void 0;
+  }
+}
+class MapScope {
+  constructor(elements, outerScope, options) {
+    var _a;
+    this.elements = /* @__PURE__ */ new Map();
+    this.caseInsensitive = (_a = options === null || options === void 0 ? void 0 : options.caseInsensitive) !== null && _a !== void 0 ? _a : false;
+    for (const element of elements) {
+      const name = this.caseInsensitive ? element.name.toLowerCase() : element.name;
+      this.elements.set(name, element);
+    }
+    this.outerScope = outerScope;
+  }
+  getElement(name) {
+    const localName = this.caseInsensitive ? name.toLowerCase() : name;
+    const local = this.elements.get(localName);
+    if (local) {
+      return local;
+    }
+    if (this.outerScope) {
+      return this.outerScope.getElement(name);
+    }
+    return void 0;
+  }
+  getAllElements() {
+    let elementStream = stream(this.elements.values());
+    if (this.outerScope) {
+      elementStream = elementStream.concat(this.outerScope.getAllElements());
+    }
+    return elementStream;
+  }
+}
+export {
+  MapScope,
+  StreamScope
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/serializer/hydrator.mjs

@@ -0,0 +1,256 @@
+import { RootCstNodeImpl, CompositeCstNodeImpl, LeafCstNodeImpl } from "../parser/cst-node-builder.mjs";
+import { isAbstractElement } from "../languages/generated/ast.mjs";
+import { isAstNode, isReference, isRootCstNode, isCompositeCstNode, isLeafCstNode } from "../syntax-tree.mjs";
+import { streamAst } from "../utils/ast-utils.mjs";
+import { BiMap } from "../utils/collections.mjs";
+import { streamCst } from "../utils/cst-utils.mjs";
+class DefaultHydrator {
+  constructor(services) {
+    this.grammarElementIdMap = new BiMap();
+    this.tokenTypeIdMap = new BiMap();
+    this.grammar = services.Grammar;
+    this.lexer = services.parser.Lexer;
+    this.linker = services.references.Linker;
+  }
+  dehydrate(result) {
+    return {
+      lexerErrors: result.lexerErrors,
+      lexerReport: result.lexerReport ? this.dehydrateLexerReport(result.lexerReport) : void 0,
+      // We need to create shallow copies of the errors
+      // The original errors inherit from the `Error` class, which is not transferable across worker threads
+      parserErrors: result.parserErrors.map((e) => Object.assign(Object.assign({}, e), { message: e.message })),
+      value: this.dehydrateAstNode(result.value, this.createDehyrationContext(result.value))
+    };
+  }
+  dehydrateLexerReport(lexerReport) {
+    return lexerReport;
+  }
+  createDehyrationContext(node) {
+    const astNodes = /* @__PURE__ */ new Map();
+    const cstNodes = /* @__PURE__ */ new Map();
+    for (const astNode of streamAst(node)) {
+      astNodes.set(astNode, {});
+    }
+    if (node.$cstNode) {
+      for (const cstNode of streamCst(node.$cstNode)) {
+        cstNodes.set(cstNode, {});
+      }
+    }
+    return {
+      astNodes,
+      cstNodes
+    };
+  }
+  dehydrateAstNode(node, context) {
+    const obj = context.astNodes.get(node);
+    obj.$type = node.$type;
+    obj.$containerIndex = node.$containerIndex;
+    obj.$containerProperty = node.$containerProperty;
+    if (node.$cstNode !== void 0) {
+      obj.$cstNode = this.dehydrateCstNode(node.$cstNode, context);
+    }
+    for (const [name, value] of Object.entries(node)) {
+      if (name.startsWith("$")) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        const arr = [];
+        obj[name] = arr;
+        for (const item of value) {
+          if (isAstNode(item)) {
+            arr.push(this.dehydrateAstNode(item, context));
+          } else if (isReference(item)) {
+            arr.push(this.dehydrateReference(item, context));
+          } else {
+            arr.push(item);
+          }
+        }
+      } else if (isAstNode(value)) {
+        obj[name] = this.dehydrateAstNode(value, context);
+      } else if (isReference(value)) {
+        obj[name] = this.dehydrateReference(value, context);
+      } else if (value !== void 0) {
+        obj[name] = value;
+      }
+    }
+    return obj;
+  }
+  dehydrateReference(reference, context) {
+    const obj = {};
+    obj.$refText = reference.$refText;
+    if (reference.$refNode) {
+      obj.$refNode = context.cstNodes.get(reference.$refNode);
+    }
+    return obj;
+  }
+  dehydrateCstNode(node, context) {
+    const cstNode = context.cstNodes.get(node);
+    if (isRootCstNode(node)) {
+      cstNode.fullText = node.fullText;
+    } else {
+      cstNode.grammarSource = this.getGrammarElementId(node.grammarSource);
+    }
+    cstNode.hidden = node.hidden;
+    cstNode.astNode = context.astNodes.get(node.astNode);
+    if (isCompositeCstNode(node)) {
+      cstNode.content = node.content.map((child) => this.dehydrateCstNode(child, context));
+    } else if (isLeafCstNode(node)) {
+      cstNode.tokenType = node.tokenType.name;
+      cstNode.offset = node.offset;
+      cstNode.length = node.length;
+      cstNode.startLine = node.range.start.line;
+      cstNode.startColumn = node.range.start.character;
+      cstNode.endLine = node.range.end.line;
+      cstNode.endColumn = node.range.end.character;
+    }
+    return cstNode;
+  }
+  hydrate(result) {
+    const node = result.value;
+    const context = this.createHydrationContext(node);
+    if ("$cstNode" in node) {
+      this.hydrateCstNode(node.$cstNode, context);
+    }
+    return {
+      lexerErrors: result.lexerErrors,
+      lexerReport: result.lexerReport,
+      parserErrors: result.parserErrors,
+      value: this.hydrateAstNode(node, context)
+    };
+  }
+  createHydrationContext(node) {
+    const astNodes = /* @__PURE__ */ new Map();
+    const cstNodes = /* @__PURE__ */ new Map();
+    for (const astNode of streamAst(node)) {
+      astNodes.set(astNode, {});
+    }
+    let root;
+    if (node.$cstNode) {
+      for (const cstNode of streamCst(node.$cstNode)) {
+        let cst;
+        if ("fullText" in cstNode) {
+          cst = new RootCstNodeImpl(cstNode.fullText);
+          root = cst;
+        } else if ("content" in cstNode) {
+          cst = new CompositeCstNodeImpl();
+        } else if ("tokenType" in cstNode) {
+          cst = this.hydrateCstLeafNode(cstNode);
+        }
+        if (cst) {
+          cstNodes.set(cstNode, cst);
+          cst.root = root;
+        }
+      }
+    }
+    return {
+      astNodes,
+      cstNodes
+    };
+  }
+  hydrateAstNode(node, context) {
+    const astNode = context.astNodes.get(node);
+    astNode.$type = node.$type;
+    astNode.$containerIndex = node.$containerIndex;
+    astNode.$containerProperty = node.$containerProperty;
+    if (node.$cstNode) {
+      astNode.$cstNode = context.cstNodes.get(node.$cstNode);
+    }
+    for (const [name, value] of Object.entries(node)) {
+      if (name.startsWith("$")) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        const arr = [];
+        astNode[name] = arr;
+        for (const item of value) {
+          if (isAstNode(item)) {
+            arr.push(this.setParent(this.hydrateAstNode(item, context), astNode));
+          } else if (isReference(item)) {
+            arr.push(this.hydrateReference(item, astNode, name, context));
+          } else {
+            arr.push(item);
+          }
+        }
+      } else if (isAstNode(value)) {
+        astNode[name] = this.setParent(this.hydrateAstNode(value, context), astNode);
+      } else if (isReference(value)) {
+        astNode[name] = this.hydrateReference(value, astNode, name, context);
+      } else if (value !== void 0) {
+        astNode[name] = value;
+      }
+    }
+    return astNode;
+  }
+  setParent(node, parent) {
+    node.$container = parent;
+    return node;
+  }
+  hydrateReference(reference, node, name, context) {
+    return this.linker.buildReference(node, name, context.cstNodes.get(reference.$refNode), reference.$refText);
+  }
+  hydrateCstNode(cstNode, context, num = 0) {
+    const cstNodeObj = context.cstNodes.get(cstNode);
+    if (typeof cstNode.grammarSource === "number") {
+      cstNodeObj.grammarSource = this.getGrammarElement(cstNode.grammarSource);
+    }
+    cstNodeObj.astNode = context.astNodes.get(cstNode.astNode);
+    if (isCompositeCstNode(cstNodeObj)) {
+      for (const child of cstNode.content) {
+        const hydrated = this.hydrateCstNode(child, context, num++);
+        cstNodeObj.content.push(hydrated);
+      }
+    }
+    return cstNodeObj;
+  }
+  hydrateCstLeafNode(cstNode) {
+    const tokenType = this.getTokenType(cstNode.tokenType);
+    const offset = cstNode.offset;
+    const length = cstNode.length;
+    const startLine = cstNode.startLine;
+    const startColumn = cstNode.startColumn;
+    const endLine = cstNode.endLine;
+    const endColumn = cstNode.endColumn;
+    const hidden = cstNode.hidden;
+    const node = new LeafCstNodeImpl(offset, length, {
+      start: {
+        line: startLine,
+        character: startColumn
+      },
+      end: {
+        line: endLine,
+        character: endColumn
+      }
+    }, tokenType, hidden);
+    return node;
+  }
+  getTokenType(name) {
+    return this.lexer.definition[name];
+  }
+  getGrammarElementId(node) {
+    if (!node) {
+      return void 0;
+    }
+    if (this.grammarElementIdMap.size === 0) {
+      this.createGrammarElementIdMap();
+    }
+    return this.grammarElementIdMap.get(node);
+  }
+  getGrammarElement(id) {
+    if (this.grammarElementIdMap.size === 0) {
+      this.createGrammarElementIdMap();
+    }
+    const element = this.grammarElementIdMap.getKey(id);
+    return element;
+  }
+  createGrammarElementIdMap() {
+    let id = 0;
+    for (const element of streamAst(this.grammar)) {
+      if (isAbstractElement(element)) {
+        this.grammarElementIdMap.set(element, id++);
+      }
+    }
+  }
+}
+export {
+  DefaultHydrator
+};