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

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

@@ -0,0 +1,202 @@
+import { URI } from "../../../../../vscode-uri@3.0.8/node_modules/vscode-uri/lib/esm/index.mjs";
+import { isReference, isAstNode } from "../syntax-tree.mjs";
+import { getDocument } from "../utils/ast-utils.mjs";
+import { findNodesForProperty } from "../utils/grammar-utils.mjs";
+function isAstNodeWithComment(node) {
+  return typeof node.$comment === "string";
+}
+function isIntermediateReference(obj) {
+  return typeof obj === "object" && !!obj && ("$ref" in obj || "$error" in obj);
+}
+class DefaultJsonSerializer {
+  constructor(services) {
+    this.ignoreProperties = /* @__PURE__ */ new Set(["$container", "$containerProperty", "$containerIndex", "$document", "$cstNode"]);
+    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+    this.astNodeLocator = services.workspace.AstNodeLocator;
+    this.nameProvider = services.references.NameProvider;
+    this.commentProvider = services.documentation.CommentProvider;
+  }
+  serialize(node, options) {
+    const serializeOptions = options !== null && options !== void 0 ? options : {};
+    const specificReplacer = options === null || options === void 0 ? void 0 : options.replacer;
+    const defaultReplacer = (key, value) => this.replacer(key, value, serializeOptions);
+    const replacer = specificReplacer ? (key, value) => specificReplacer(key, value, defaultReplacer) : defaultReplacer;
+    try {
+      this.currentDocument = getDocument(node);
+      return JSON.stringify(node, replacer, options === null || options === void 0 ? void 0 : options.space);
+    } finally {
+      this.currentDocument = void 0;
+    }
+  }
+  deserialize(content, options) {
+    const deserializeOptions = options !== null && options !== void 0 ? options : {};
+    const root = JSON.parse(content);
+    this.linkNode(root, root, deserializeOptions);
+    return root;
+  }
+  replacer(key, value, { refText, sourceText, textRegions, comments, uriConverter }) {
+    var _a, _b, _c, _d;
+    if (this.ignoreProperties.has(key)) {
+      return void 0;
+    } else if (isReference(value)) {
+      const refValue = value.ref;
+      const $refText = refText ? value.$refText : void 0;
+      if (refValue) {
+        const targetDocument = getDocument(refValue);
+        let targetUri = "";
+        if (this.currentDocument && this.currentDocument !== targetDocument) {
+          if (uriConverter) {
+            targetUri = uriConverter(targetDocument.uri, value);
+          } else {
+            targetUri = targetDocument.uri.toString();
+          }
+        }
+        const targetPath = this.astNodeLocator.getAstNodePath(refValue);
+        return {
+          $ref: `${targetUri}#${targetPath}`,
+          $refText
+        };
+      } else {
+        return {
+          $error: (_b = (_a = value.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : "Could not resolve reference",
+          $refText
+        };
+      }
+    } else if (isAstNode(value)) {
+      let astNode = void 0;
+      if (textRegions) {
+        astNode = this.addAstNodeRegionWithAssignmentsTo(Object.assign({}, value));
+        if ((!key || value.$document) && (astNode === null || astNode === void 0 ? void 0 : astNode.$textRegion)) {
+          astNode.$textRegion.documentURI = (_c = this.currentDocument) === null || _c === void 0 ? void 0 : _c.uri.toString();
+        }
+      }
+      if (sourceText && !key) {
+        astNode !== null && astNode !== void 0 ? astNode : astNode = Object.assign({}, value);
+        astNode.$sourceText = (_d = value.$cstNode) === null || _d === void 0 ? void 0 : _d.text;
+      }
+      if (comments) {
+        astNode !== null && astNode !== void 0 ? astNode : astNode = Object.assign({}, value);
+        const comment = this.commentProvider.getComment(value);
+        if (comment) {
+          astNode.$comment = comment.replace(/\r/g, "");
+        }
+      }
+      return astNode !== null && astNode !== void 0 ? astNode : value;
+    } else {
+      return value;
+    }
+  }
+  addAstNodeRegionWithAssignmentsTo(node) {
+    const createDocumentSegment = (cstNode) => ({
+      offset: cstNode.offset,
+      end: cstNode.end,
+      length: cstNode.length,
+      range: cstNode.range
+    });
+    if (node.$cstNode) {
+      const textRegion = node.$textRegion = createDocumentSegment(node.$cstNode);
+      const assignments = textRegion.assignments = {};
+      Object.keys(node).filter((key) => !key.startsWith("$")).forEach((key) => {
+        const propertyAssignments = findNodesForProperty(node.$cstNode, key).map(createDocumentSegment);
+        if (propertyAssignments.length !== 0) {
+          assignments[key] = propertyAssignments;
+        }
+      });
+      return node;
+    }
+    return void 0;
+  }
+  linkNode(node, root, options, container, containerProperty, containerIndex) {
+    for (const [propertyName, item] of Object.entries(node)) {
+      if (Array.isArray(item)) {
+        for (let index = 0; index < item.length; index++) {
+          const element = item[index];
+          if (isIntermediateReference(element)) {
+            item[index] = this.reviveReference(node, propertyName, root, element, options);
+          } else if (isAstNode(element)) {
+            this.linkNode(element, root, options, node, propertyName, index);
+          }
+        }
+      } else if (isIntermediateReference(item)) {
+        node[propertyName] = this.reviveReference(node, propertyName, root, item, options);
+      } else if (isAstNode(item)) {
+        this.linkNode(item, root, options, node, propertyName);
+      }
+    }
+    const mutable = node;
+    mutable.$container = container;
+    mutable.$containerProperty = containerProperty;
+    mutable.$containerIndex = containerIndex;
+  }
+  reviveReference(container, property, root, reference, options) {
+    let refText = reference.$refText;
+    let error = reference.$error;
+    if (reference.$ref) {
+      const ref = this.getRefNode(root, reference.$ref, options.uriConverter);
+      if (isAstNode(ref)) {
+        if (!refText) {
+          refText = this.nameProvider.getName(ref);
+        }
+        return {
+          $refText: refText !== null && refText !== void 0 ? refText : "",
+          ref
+        };
+      } else {
+        error = ref;
+      }
+    }
+    if (error) {
+      const ref = {
+        $refText: refText !== null && refText !== void 0 ? refText : ""
+      };
+      ref.error = {
+        container,
+        property,
+        message: error,
+        reference: ref
+      };
+      return ref;
+    } else {
+      return void 0;
+    }
+  }
+  getRefNode(root, uri, uriConverter) {
+    try {
+      const fragmentIndex = uri.indexOf("#");
+      if (fragmentIndex === 0) {
+        const node2 = this.astNodeLocator.getAstNode(root, uri.substring(1));
+        if (!node2) {
+          return "Could not resolve path: " + uri;
+        }
+        return node2;
+      }
+      if (fragmentIndex < 0) {
+        const documentUri2 = uriConverter ? uriConverter(uri) : URI.parse(uri);
+        const document2 = this.langiumDocuments.getDocument(documentUri2);
+        if (!document2) {
+          return "Could not find document for URI: " + uri;
+        }
+        return document2.parseResult.value;
+      }
+      const documentUri = uriConverter ? uriConverter(uri.substring(0, fragmentIndex)) : URI.parse(uri.substring(0, fragmentIndex));
+      const document = this.langiumDocuments.getDocument(documentUri);
+      if (!document) {
+        return "Could not find document for URI: " + uri;
+      }
+      if (fragmentIndex === uri.length - 1) {
+        return document.parseResult.value;
+      }
+      const node = this.astNodeLocator.getAstNode(document.parseResult.value, uri.substring(fragmentIndex + 1));
+      if (!node) {
+        return "Could not resolve URI: " + uri;
+      }
+      return node;
+    } catch (err) {
+      return String(err);
+    }
+  }
+}
+export {
+  DefaultJsonSerializer,
+  isAstNodeWithComment
+};

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

@@ -0,0 +1,69 @@
+import { UriUtils } from "./utils/uri-utils.mjs";
+class DefaultServiceRegistry {
+  /**
+   * @deprecated Use the new `fileExtensionMap` (or `languageIdMap`) property instead.
+   */
+  get map() {
+    return this.fileExtensionMap;
+  }
+  constructor(services) {
+    this.languageIdMap = /* @__PURE__ */ new Map();
+    this.fileExtensionMap = /* @__PURE__ */ new Map();
+    this.textDocuments = services === null || services === void 0 ? void 0 : services.workspace.TextDocuments;
+  }
+  register(language) {
+    const data = language.LanguageMetaData;
+    for (const ext of data.fileExtensions) {
+      if (this.fileExtensionMap.has(ext)) {
+        console.warn(`The file extension ${ext} is used by multiple languages. It is now assigned to '${data.languageId}'.`);
+      }
+      this.fileExtensionMap.set(ext, language);
+    }
+    this.languageIdMap.set(data.languageId, language);
+    if (this.languageIdMap.size === 1) {
+      this.singleton = language;
+    } else {
+      this.singleton = void 0;
+    }
+  }
+  getServices(uri) {
+    var _a, _b;
+    if (this.singleton !== void 0) {
+      return this.singleton;
+    }
+    if (this.languageIdMap.size === 0) {
+      throw new Error("The service registry is empty. Use `register` to register the services of a language.");
+    }
+    const languageId = (_b = (_a = this.textDocuments) === null || _a === void 0 ? void 0 : _a.get(uri)) === null || _b === void 0 ? void 0 : _b.languageId;
+    if (languageId !== void 0) {
+      const services2 = this.languageIdMap.get(languageId);
+      if (services2) {
+        return services2;
+      }
+    }
+    const ext = UriUtils.extname(uri);
+    const services = this.fileExtensionMap.get(ext);
+    if (!services) {
+      if (languageId) {
+        throw new Error(`The service registry contains no services for the extension '${ext}' for language '${languageId}'.`);
+      } else {
+        throw new Error(`The service registry contains no services for the extension '${ext}'.`);
+      }
+    }
+    return services;
+  }
+  hasServices(uri) {
+    try {
+      this.getServices(uri);
+      return true;
+    } catch (_a) {
+      return false;
+    }
+  }
+  get all() {
+    return Array.from(this.languageIdMap.values());
+  }
+}
+export {
+  DefaultServiceRegistry
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/syntax-tree.mjs

@@ -0,0 +1,73 @@
+function isAstNode(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.$type === "string";
+}
+function isReference(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.$refText === "string";
+}
+function isAstNodeDescription(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.name === "string" && typeof obj.type === "string" && typeof obj.path === "string";
+}
+function isLinkingError(obj) {
+  return typeof obj === "object" && obj !== null && isAstNode(obj.container) && isReference(obj.reference) && typeof obj.message === "string";
+}
+class AbstractAstReflection {
+  constructor() {
+    this.subtypes = {};
+    this.allSubtypes = {};
+  }
+  isInstance(node, type) {
+    return isAstNode(node) && this.isSubtype(node.$type, type);
+  }
+  isSubtype(subtype, supertype) {
+    if (subtype === supertype) {
+      return true;
+    }
+    let nested = this.subtypes[subtype];
+    if (!nested) {
+      nested = this.subtypes[subtype] = {};
+    }
+    const existing = nested[supertype];
+    if (existing !== void 0) {
+      return existing;
+    } else {
+      const result = this.computeIsSubtype(subtype, supertype);
+      nested[supertype] = result;
+      return result;
+    }
+  }
+  getAllSubTypes(type) {
+    const existing = this.allSubtypes[type];
+    if (existing) {
+      return existing;
+    } else {
+      const allTypes = this.getAllTypes();
+      const types = [];
+      for (const possibleSubType of allTypes) {
+        if (this.isSubtype(possibleSubType, type)) {
+          types.push(possibleSubType);
+        }
+      }
+      this.allSubtypes[type] = types;
+      return types;
+    }
+  }
+}
+function isCompositeCstNode(node) {
+  return typeof node === "object" && node !== null && Array.isArray(node.content);
+}
+function isLeafCstNode(node) {
+  return typeof node === "object" && node !== null && typeof node.tokenType === "object";
+}
+function isRootCstNode(node) {
+  return isCompositeCstNode(node) && typeof node.fullText === "string";
+}
+export {
+  AbstractAstReflection,
+  isAstNode,
+  isAstNodeDescription,
+  isCompositeCstNode,
+  isLeafCstNode,
+  isLinkingError,
+  isReference,
+  isRootCstNode
+};

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

@@ -0,0 +1,159 @@
+import { isAstNode, isReference } from "../syntax-tree.mjs";
+import { TreeStreamImpl, StreamImpl, DONE_RESULT } from "./stream.mjs";
+import { inRange } from "./cst-utils.mjs";
+function linkContentToContainer(node) {
+  for (const [name, value] of Object.entries(node)) {
+    if (!name.startsWith("$")) {
+      if (Array.isArray(value)) {
+        value.forEach((item, index) => {
+          if (isAstNode(item)) {
+            item.$container = node;
+            item.$containerProperty = name;
+            item.$containerIndex = index;
+          }
+        });
+      } else if (isAstNode(value)) {
+        value.$container = node;
+        value.$containerProperty = name;
+      }
+    }
+  }
+}
+function getContainerOfType(node, typePredicate) {
+  let item = node;
+  while (item) {
+    if (typePredicate(item)) {
+      return item;
+    }
+    item = item.$container;
+  }
+  return void 0;
+}
+function getDocument(node) {
+  const rootNode = findRootNode(node);
+  const result = rootNode.$document;
+  if (!result) {
+    throw new Error("AST node has no document.");
+  }
+  return result;
+}
+function findRootNode(node) {
+  while (node.$container) {
+    node = node.$container;
+  }
+  return node;
+}
+function streamContents(node, options) {
+  if (!node) {
+    throw new Error("Node must be an AstNode.");
+  }
+  const range = options === null || options === void 0 ? void 0 : options.range;
+  return new StreamImpl(() => ({
+    keys: Object.keys(node),
+    keyIndex: 0,
+    arrayIndex: 0
+  }), (state) => {
+    while (state.keyIndex < state.keys.length) {
+      const property = state.keys[state.keyIndex];
+      if (!property.startsWith("$")) {
+        const value = node[property];
+        if (isAstNode(value)) {
+          state.keyIndex++;
+          if (isAstNodeInRange(value, range)) {
+            return { done: false, value };
+          }
+        } else if (Array.isArray(value)) {
+          while (state.arrayIndex < value.length) {
+            const index = state.arrayIndex++;
+            const element = value[index];
+            if (isAstNode(element) && isAstNodeInRange(element, range)) {
+              return { done: false, value: element };
+            }
+          }
+          state.arrayIndex = 0;
+        }
+      }
+      state.keyIndex++;
+    }
+    return DONE_RESULT;
+  });
+}
+function streamAllContents(root, options) {
+  if (!root) {
+    throw new Error("Root node must be an AstNode.");
+  }
+  return new TreeStreamImpl(root, (node) => streamContents(node, options));
+}
+function streamAst(root, options) {
+  if (!root) {
+    throw new Error("Root node must be an AstNode.");
+  }
+  return new TreeStreamImpl(root, (node) => streamContents(node, options), { includeRoot: true });
+}
+function isAstNodeInRange(astNode, range) {
+  var _a;
+  if (!range) {
+    return true;
+  }
+  const nodeRange = (_a = astNode.$cstNode) === null || _a === void 0 ? void 0 : _a.range;
+  if (!nodeRange) {
+    return false;
+  }
+  return inRange(nodeRange, range);
+}
+function streamReferences(node) {
+  return new StreamImpl(() => ({
+    keys: Object.keys(node),
+    keyIndex: 0,
+    arrayIndex: 0
+  }), (state) => {
+    while (state.keyIndex < state.keys.length) {
+      const property = state.keys[state.keyIndex];
+      if (!property.startsWith("$")) {
+        const value = node[property];
+        if (isReference(value)) {
+          state.keyIndex++;
+          return { done: false, value: { reference: value, container: node, property } };
+        } else if (Array.isArray(value)) {
+          while (state.arrayIndex < value.length) {
+            const index = state.arrayIndex++;
+            const element = value[index];
+            if (isReference(element)) {
+              return { done: false, value: { reference: element, container: node, property, index } };
+            }
+          }
+          state.arrayIndex = 0;
+        }
+      }
+      state.keyIndex++;
+    }
+    return DONE_RESULT;
+  });
+}
+function assignMandatoryProperties(reflection, node) {
+  const typeMetaData = reflection.getTypeMetaData(node.$type);
+  const genericNode = node;
+  for (const property of typeMetaData.properties) {
+    if (property.defaultValue !== void 0 && genericNode[property.name] === void 0) {
+      genericNode[property.name] = copyDefaultValue(property.defaultValue);
+    }
+  }
+}
+function copyDefaultValue(propertyType) {
+  if (Array.isArray(propertyType)) {
+    return [...propertyType.map(copyDefaultValue)];
+  } else {
+    return propertyType;
+  }
+}
+export {
+  assignMandatoryProperties,
+  findRootNode,
+  getContainerOfType,
+  getDocument,
+  linkContentToContainer,
+  streamAllContents,
+  streamAst,
+  streamContents,
+  streamReferences
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/caching.mjs

@@ -0,0 +1,137 @@
+class DisposableCache {
+  constructor() {
+    this.toDispose = [];
+    this.isDisposed = false;
+  }
+  onDispose(disposable) {
+    this.toDispose.push(disposable);
+  }
+  dispose() {
+    this.throwIfDisposed();
+    this.clear();
+    this.isDisposed = true;
+    this.toDispose.forEach((disposable) => disposable.dispose());
+  }
+  throwIfDisposed() {
+    if (this.isDisposed) {
+      throw new Error("This cache has already been disposed");
+    }
+  }
+}
+class SimpleCache extends DisposableCache {
+  constructor() {
+    super(...arguments);
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  has(key) {
+    this.throwIfDisposed();
+    return this.cache.has(key);
+  }
+  set(key, value) {
+    this.throwIfDisposed();
+    this.cache.set(key, value);
+  }
+  get(key, provider) {
+    this.throwIfDisposed();
+    if (this.cache.has(key)) {
+      return this.cache.get(key);
+    } else if (provider) {
+      const value = provider();
+      this.cache.set(key, value);
+      return value;
+    } else {
+      return void 0;
+    }
+  }
+  delete(key) {
+    this.throwIfDisposed();
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.throwIfDisposed();
+    this.cache.clear();
+  }
+}
+class ContextCache extends DisposableCache {
+  constructor(converter) {
+    super();
+    this.cache = /* @__PURE__ */ new Map();
+    this.converter = converter !== null && converter !== void 0 ? converter : (value) => value;
+  }
+  has(contextKey, key) {
+    this.throwIfDisposed();
+    return this.cacheForContext(contextKey).has(key);
+  }
+  set(contextKey, key, value) {
+    this.throwIfDisposed();
+    this.cacheForContext(contextKey).set(key, value);
+  }
+  get(contextKey, key, provider) {
+    this.throwIfDisposed();
+    const contextCache = this.cacheForContext(contextKey);
+    if (contextCache.has(key)) {
+      return contextCache.get(key);
+    } else if (provider) {
+      const value = provider();
+      contextCache.set(key, value);
+      return value;
+    } else {
+      return void 0;
+    }
+  }
+  delete(contextKey, key) {
+    this.throwIfDisposed();
+    return this.cacheForContext(contextKey).delete(key);
+  }
+  clear(contextKey) {
+    this.throwIfDisposed();
+    if (contextKey) {
+      const mapKey = this.converter(contextKey);
+      this.cache.delete(mapKey);
+    } else {
+      this.cache.clear();
+    }
+  }
+  cacheForContext(contextKey) {
+    const mapKey = this.converter(contextKey);
+    let documentCache = this.cache.get(mapKey);
+    if (!documentCache) {
+      documentCache = /* @__PURE__ */ new Map();
+      this.cache.set(mapKey, documentCache);
+    }
+    return documentCache;
+  }
+}
+class WorkspaceCache extends SimpleCache {
+  /**
+   * Creates a new workspace cache.
+   *
+   * @param sharedServices Service container instance to hook into document lifecycle events.
+   * @param state Optional document state on which the cache should evict.
+   * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.
+   * *Deleted* documents are considered in both cases.
+   */
+  constructor(sharedServices, state) {
+    super();
+    if (state) {
+      this.toDispose.push(sharedServices.workspace.DocumentBuilder.onBuildPhase(state, () => {
+        this.clear();
+      }));
+      this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {
+        if (deleted.length > 0) {
+          this.clear();
+        }
+      }));
+    } else {
+      this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate(() => {
+        this.clear();
+      }));
+    }
+  }
+}
+export {
+  ContextCache,
+  DisposableCache,
+  SimpleCache,
+  WorkspaceCache
+};