@nocobase/plugin-mcp-server 2.1.0-alpha.19 → 2.1.0-alpha.20

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/url.js

@@ -1,319 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = void 0;
-exports.resolve = resolve;
-exports.cwd = cwd;
-exports.getProtocol = getProtocol;
-exports.getExtension = getExtension;
-exports.stripQuery = stripQuery;
-exports.getHash = getHash;
-exports.stripHash = stripHash;
-exports.isHttp = isHttp;
-exports.isFileSystemPath = isFileSystemPath;
-exports.fromFileSystemPath = fromFileSystemPath;
-exports.toFileSystemPath = toFileSystemPath;
-exports.safePointerToPath = safePointerToPath;
-exports.relative = relative;
-const convert_path_to_posix_1 = __importDefault(require("./convert-path-to-posix"));
-const path_1 = __importStar(require("path"));
-const forwardSlashPattern = /\//g;
-const protocolPattern = /^(\w{2,}):\/\//i;
-const jsonPointerSlash = /~1/g;
-const jsonPointerTilde = /~0/g;
-const path_2 = require("path");
-const is_windows_1 = require("./is-windows");
-// RegExp patterns to URL-encode special characters in local filesystem paths
-const urlEncodePatterns = [
-    [/\?/g, "%3F"],
-    [/#/g, "%23"],
-];
-// RegExp patterns to URL-decode special characters for local filesystem paths
-const urlDecodePatterns = [/%23/g, "#", /%24/g, "$", /%26/g, "&", /%2C/g, ",", /%40/g, "@"];
-const parse = (u) => new URL(u);
-exports.parse = parse;
-/**
- * Returns resolved target URL relative to a base URL in a manner similar to that of a Web browser resolving an anchor tag HREF.
- *
- * @returns
- */
-function resolve(from, to) {
-    const fromUrl = new URL((0, convert_path_to_posix_1.default)(from), "resolve://");
-    const resolvedUrl = new URL((0, convert_path_to_posix_1.default)(to), fromUrl);
-    const endSpaces = to.match(/(\s*)$/)?.[1] || "";
-    if (resolvedUrl.protocol === "resolve:") {
-        // `from` is a relative URL.
-        const { pathname, search, hash } = resolvedUrl;
-        return pathname + search + hash + endSpaces;
-    }
-    return resolvedUrl.toString() + endSpaces;
-}
-/**
- * Returns the current working directory (in Node) or the current page URL (in browsers).
- *
- * @returns
- */
-function cwd() {
-    if (typeof window !== "undefined") {
-        return location.href;
-    }
-    const path = process.cwd();
-    const lastChar = path.slice(-1);
-    if (lastChar === "/" || lastChar === "\\") {
-        return path;
-    }
-    else {
-        return path + "/";
-    }
-}
-/**
- * Returns the protocol of the given URL, or `undefined` if it has no protocol.
- *
- * @param path
- * @returns
- */
-function getProtocol(path) {
-    const match = protocolPattern.exec(path || "");
-    if (match) {
-        return match[1].toLowerCase();
-    }
-    return undefined;
-}
-/**
- * Returns the lowercased file extension of the given URL,
- * or an empty string if it has no extension.
- *
- * @param path
- * @returns
- */
-function getExtension(path) {
-    const lastDot = path.lastIndexOf(".");
-    if (lastDot >= 0) {
-        return stripQuery(path.substr(lastDot).toLowerCase());
-    }
-    return "";
-}
-/**
- * Removes the query, if any, from the given path.
- *
- * @param path
- * @returns
- */
-function stripQuery(path) {
-    const queryIndex = path.indexOf("?");
-    if (queryIndex >= 0) {
-        path = path.substr(0, queryIndex);
-    }
-    return path;
-}
-/**
- * Returns the hash (URL fragment), of the given path.
- * If there is no hash, then the root hash ("#") is returned.
- *
- * @param path
- * @returns
- */
-function getHash(path) {
-    if (!path) {
-        return "#";
-    }
-    const hashIndex = path.indexOf("#");
-    if (hashIndex >= 0) {
-        return path.substring(hashIndex);
-    }
-    return "#";
-}
-/**
- * Removes the hash (URL fragment), if any, from the given path.
- *
- * @param path
- * @returns
- */
-function stripHash(path) {
-    if (!path) {
-        return "";
-    }
-    const hashIndex = path.indexOf("#");
-    if (hashIndex >= 0) {
-        path = path.substring(0, hashIndex);
-    }
-    return path;
-}
-/**
- * Determines whether the given path is an HTTP(S) URL.
- *
- * @param path
- * @returns
- */
-function isHttp(path) {
-    const protocol = getProtocol(path);
-    if (protocol === "http" || protocol === "https") {
-        return true;
-    }
-    else if (protocol === undefined) {
-        // There is no protocol.  If we're running in a browser, then assume it's HTTP.
-        return typeof window !== "undefined";
-    }
-    else {
-        // It's some other protocol, such as "ftp://", "mongodb://", etc.
-        return false;
-    }
-}
-/**
- * Determines whether the given path is a filesystem path.
- * This includes "file://" URLs.
- *
- * @param path
- * @returns
- */
-function isFileSystemPath(path) {
-    // @ts-ignore
-    if (typeof window !== "undefined" || (typeof process !== "undefined" && process.browser)) {
-        // We're running in a browser, so assume that all paths are URLs.
-        // This way, even relative paths will be treated as URLs rather than as filesystem paths
-        return false;
-    }
-    const protocol = getProtocol(path);
-    return protocol === undefined || protocol === "file";
-}
-/**
- * Converts a filesystem path to a properly-encoded URL.
- *
- * This is intended to handle situations where JSON Schema $Ref Parser is called
- * with a filesystem path that contains characters which are not allowed in URLs.
- *
- * @example
- * The following filesystem paths would be converted to the following URLs:
- *
- *    <"!@#$%^&*+=?'>.json              ==>   %3C%22!@%23$%25%5E&*+=%3F\'%3E.json
- *    C:\\My Documents\\File (1).json   ==>   C:/My%20Documents/File%20(1).json
- *    file://Project #42/file.json      ==>   file://Project%20%2342/file.json
- *
- * @param path
- * @returns
- */
-function fromFileSystemPath(path) {
-    // Step 1: On Windows, replace backslashes with forward slashes,
-    // rather than encoding them as "%5C"
-    if ((0, is_windows_1.isWindows)()) {
-        const projectDir = cwd();
-        const upperPath = path.toUpperCase();
-        const projectDirPosixPath = (0, convert_path_to_posix_1.default)(projectDir);
-        const posixUpper = projectDirPosixPath.toUpperCase();
-        const hasProjectDir = upperPath.includes(posixUpper);
-        const hasProjectUri = upperPath.includes(posixUpper);
-        const isAbsolutePath = path_1.win32?.isAbsolute(path) ||
-            path.startsWith("http://") ||
-            path.startsWith("https://") ||
-            path.startsWith("file://");
-        if (!(hasProjectDir || hasProjectUri || isAbsolutePath) && !projectDir.startsWith("http")) {
-            path = (0, path_2.join)(projectDir, path);
-        }
-        path = (0, convert_path_to_posix_1.default)(path);
-    }
-    // Step 2: `encodeURI` will take care of MOST characters
-    path = encodeURI(path);
-    // Step 3: Manually encode characters that are not encoded by `encodeURI`.
-    // This includes characters such as "#" and "?", which have special meaning in URLs,
-    // but are just normal characters in a filesystem path.
-    for (const pattern of urlEncodePatterns) {
-        path = path.replace(pattern[0], pattern[1]);
-    }
-    return path;
-}
-/**
- * Converts a URL to a local filesystem path.
- */
-function toFileSystemPath(path, keepFileProtocol) {
-    // Step 1: `decodeURI` will decode characters such as Cyrillic characters, spaces, etc.
-    path = decodeURI(path);
-    // Step 2: Manually decode characters that are not decoded by `decodeURI`.
-    // This includes characters such as "#" and "?", which have special meaning in URLs,
-    // but are just normal characters in a filesystem path.
-    for (let i = 0; i < urlDecodePatterns.length; i += 2) {
-        path = path.replace(urlDecodePatterns[i], urlDecodePatterns[i + 1]);
-    }
-    // Step 3: If it's a "file://" URL, then format it consistently
-    // or convert it to a local filesystem path
-    let isFileUrl = path.substr(0, 7).toLowerCase() === "file://";
-    if (isFileUrl) {
-        // Strip-off the protocol, and the initial "/", if there is one
-        path = path[7] === "/" ? path.substr(8) : path.substr(7);
-        // insert a colon (":") after the drive letter on Windows
-        if ((0, is_windows_1.isWindows)() && path[1] === "/") {
-            path = path[0] + ":" + path.substr(1);
-        }
-        if (keepFileProtocol) {
-            // Return the consistently-formatted "file://" URL
-            path = "file:///" + path;
-        }
-        else {
-            // Convert the "file://" URL to a local filesystem path.
-            // On Windows, it will start with something like "C:/".
-            // On Posix, it will start with "/"
-            isFileUrl = false;
-            path = (0, is_windows_1.isWindows)() ? path : "/" + path;
-        }
-    }
-    // Step 4: Normalize Windows paths (unless it's a "file://" URL)
-    if ((0, is_windows_1.isWindows)() && !isFileUrl) {
-        // Replace forward slashes with backslashes
-        path = path.replace(forwardSlashPattern, "\\");
-        // Capitalize the drive letter
-        if (path.substr(1, 2) === ":\\") {
-            path = path[0].toUpperCase() + path.substr(1);
-        }
-    }
-    return path;
-}
-/**
- * Converts a $ref pointer to a valid JSON Path.
- *
- * @param pointer
- * @returns
- */
-function safePointerToPath(pointer) {
-    if (pointer.length <= 1 || pointer[0] !== "#" || pointer[1] !== "/") {
-        return [];
-    }
-    return pointer
-        .slice(2)
-        .split("/")
-        .map((value) => {
-        return decodeURIComponent(value).replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~");
-    });
-}
-function relative(from, to) {
-    if (!isFileSystemPath(from) || !isFileSystemPath(to)) {
-        return resolve(from, to);
-    }
-    const fromDir = path_1.default.dirname(stripHash(from));
-    const toPath = stripHash(to);
-    const result = path_1.default.relative(fromDir, toPath);
-    return result + getHash(to);
-}

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/dist/vite.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/dist/vite.config.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const config_1 = require("vitest/config");
-const isBrowser = process.env.BROWSER === "true";
-exports.default = (0, config_1.defineConfig)({
-    test: {
-        environment: isBrowser ? "jsdom" : "node",
-        dir: "test",
-        exclude: ["**/__IGNORED__/**"],
-        watch: false,
-        globalSetup: isBrowser ? ["./test/fixtures/server.ts"] : undefined,
-        testTimeout: 5000,
-        globals: true,
-        passWithNoTests: true,
-        reporters: ["verbose"],
-        coverage: { reporter: ["lcov", "html", "text"] },
-    },
-});

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/lib/bundle.ts

@@ -1,299 +0,0 @@
-import $Ref from "./ref.js";
-import Pointer from "./pointer.js";
-import * as url from "./util/url.js";
-import type $Refs from "./refs.js";
-import type $RefParser from "./index";
-import type { ParserOptions } from "./index";
-import type { JSONSchema } from "./index";
-
-export interface InventoryEntry {
-  $ref: any;
-  parent: any;
-  key: any;
-  pathFromRoot: any;
-  depth: any;
-  file: any;
-  hash: any;
-  value: any;
-  circular: any;
-  extended: any;
-  external: any;
-  indirections: any;
-}
-/**
- * Bundles all external JSON references into the main JSON schema, thus resulting in a schema that
- * only has *internal* references, not any *external* references.
- * This method mutates the JSON schema object, adding new references and re-mapping existing ones.
- *
- * @param parser
- * @param options
- */
-function bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
-  parser: $RefParser<S, O>,
-  options: O,
-) {
-  // console.log('Bundling $ref pointers in %s', parser.$refs._root$Ref.path);
-
-  // Build an inventory of all $ref pointers in the JSON Schema
-  const inventory: InventoryEntry[] = [];
-  crawl<S, O>(parser, "schema", parser.$refs._root$Ref.path + "#", "#", 0, inventory, parser.$refs, options);
-
-  // Remap all $ref pointers
-  remap(inventory);
-}
-
-/**
- * Recursively crawls the given value, and inventories all JSON references.
- *
- * @param parent - The object containing the value to crawl. If the value is not an object or array, it will be ignored.
- * @param key - The property key of `parent` to be crawled
- * @param path - The full path of the property being crawled, possibly with a JSON Pointer in the hash
- * @param pathFromRoot - The path of the property being crawled, from the schema root
- * @param indirections
- * @param inventory - An array of already-inventoried $ref pointers
- * @param $refs
- * @param options
- */
-function crawl<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
-  parent: object | $RefParser<S, O>,
-  key: string | null,
-  path: string,
-  pathFromRoot: string,
-  indirections: number,
-  inventory: InventoryEntry[],
-  $refs: $Refs<S, O>,
-  options: O,
-) {
-  const obj = key === null ? parent : parent[key as keyof typeof parent];
-
-  if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
-    if ($Ref.isAllowed$Ref(obj)) {
-      inventory$Ref(parent, key, path, pathFromRoot, indirections, inventory, $refs, options);
-    } else {
-      // Crawl the object in a specific order that's optimized for bundling.
-      // This is important because it determines how `pathFromRoot` gets built,
-      // which later determines which keys get dereferenced and which ones get remapped
-      const keys = Object.keys(obj).sort((a, b) => {
-        // Most people will expect references to be bundled into the the "definitions" property,
-        // so we always crawl that property first, if it exists.
-        if (a === "definitions") {
-          return -1;
-        } else if (b === "definitions") {
-          return 1;
-        } else {
-          // Otherwise, crawl the keys based on their length.
-          // This produces the shortest possible bundled references
-          return a.length - b.length;
-        }
-      }) as (keyof typeof obj)[];
-
-      for (const key of keys) {
-        const keyPath = Pointer.join(path, key);
-        const keyPathFromRoot = Pointer.join(pathFromRoot, key);
-        const value = obj[key];
-
-        if ($Ref.isAllowed$Ref(value)) {
-          inventory$Ref(obj, key, path, keyPathFromRoot, indirections, inventory, $refs, options);
-        } else {
-          crawl(obj, key, keyPath, keyPathFromRoot, indirections, inventory, $refs, options);
-        }
-      }
-    }
-  }
-}
-
-/**
- * Inventories the given JSON Reference (i.e. records detailed information about it so we can
- * optimize all $refs in the schema), and then crawls the resolved value.
- *
- * @param $refParent - The object that contains a JSON Reference as one of its keys
- * @param $refKey - The key in `$refParent` that is a JSON Reference
- * @param path - The full path of the JSON Reference at `$refKey`, possibly with a JSON Pointer in the hash
- * @param indirections - unknown
- * @param pathFromRoot - The path of the JSON Reference at `$refKey`, from the schema root
- * @param inventory - An array of already-inventoried $ref pointers
- * @param $refs
- * @param options
- */
-function inventory$Ref<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
-  $refParent: any,
-  $refKey: string | null,
-  path: string,
-  pathFromRoot: string,
-  indirections: number,
-  inventory: InventoryEntry[],
-  $refs: $Refs<S, O>,
-  options: O,
-) {
-  const $ref = $refKey === null ? $refParent : $refParent[$refKey];
-  const $refPath = url.resolve(path, $ref.$ref);
-  const pointer = $refs._resolve($refPath, pathFromRoot, options);
-  if (pointer === null) {
-    return;
-  }
-  const parsed = Pointer.parse(pathFromRoot);
-  const depth = parsed.length;
-  const file = url.stripHash(pointer.path);
-  const hash = url.getHash(pointer.path);
-  const external = file !== $refs._root$Ref.path;
-  const extended = $Ref.isExtended$Ref($ref);
-  indirections += pointer.indirections;
-
-  const existingEntry = findInInventory(inventory, $refParent, $refKey);
-  if (existingEntry) {
-    // This $Ref has already been inventoried, so we don't need to process it again
-    if (depth < existingEntry.depth || indirections < existingEntry.indirections) {
-      removeFromInventory(inventory, existingEntry);
-    } else {
-      return;
-    }
-  }
-
-  inventory.push({
-    $ref, // The JSON Reference (e.g. {$ref: string})
-    parent: $refParent, // The object that contains this $ref pointer
-    key: $refKey, // The key in `parent` that is the $ref pointer
-    pathFromRoot, // The path to the $ref pointer, from the JSON Schema root
-    depth, // How far from the JSON Schema root is this $ref pointer?
-    file, // The file that the $ref pointer resolves to
-    hash, // The hash within `file` that the $ref pointer resolves to
-    value: pointer.value, // The resolved value of the $ref pointer
-    circular: pointer.circular, // Is this $ref pointer DIRECTLY circular? (i.e. it references itself)
-    extended, // Does this $ref extend its resolved value? (i.e. it has extra properties, in addition to "$ref")
-    external, // Does this $ref pointer point to a file other than the main JSON Schema file?
-    indirections, // The number of indirect references that were traversed to resolve the value
-  });
-
-  // Recursively crawl the resolved value
-  if (!existingEntry || external) {
-    crawl(pointer.value, null, pointer.path, pathFromRoot, indirections + 1, inventory, $refs, options);
-  }
-}
-
-/**
- * Re-maps every $ref pointer, so that they're all relative to the root of the JSON Schema.
- * Each referenced value is dereferenced EXACTLY ONCE.  All subsequent references to the same
- * value are re-mapped to point to the first reference.
- *
- * @example: {
- *    first: { $ref: somefile.json#/some/part },
- *    second: { $ref: somefile.json#/another/part },
- *    third: { $ref: somefile.json },
- *    fourth: { $ref: somefile.json#/some/part/sub/part }
- *  }
- *
- * In this example, there are four references to the same file, but since the third reference points
- * to the ENTIRE file, that's the only one we need to dereference.  The other three can just be
- * remapped to point inside the third one.
- *
- * On the other hand, if the third reference DIDN'T exist, then the first and second would both need
- * to be dereferenced, since they point to different parts of the file. The fourth reference does NOT
- * need to be dereferenced, because it can be remapped to point inside the first one.
- *
- * @param inventory
- */
-function remap(inventory: InventoryEntry[]) {
-  // Group & sort all the $ref pointers, so they're in the order that we need to dereference/remap them
-  inventory.sort((a: InventoryEntry, b: InventoryEntry) => {
-    if (a.file !== b.file) {
-      // Group all the $refs that point to the same file
-      return a.file < b.file ? -1 : +1;
-    } else if (a.hash !== b.hash) {
-      // Group all the $refs that point to the same part of the file
-      return a.hash < b.hash ? -1 : +1;
-    } else if (a.circular !== b.circular) {
-      // If the $ref points to itself, then sort it higher than other $refs that point to this $ref
-      return a.circular ? -1 : +1;
-    } else if (a.extended !== b.extended) {
-      // If the $ref extends the resolved value, then sort it lower than other $refs that don't extend the value
-      return a.extended ? +1 : -1;
-    } else if (a.indirections !== b.indirections) {
-      // Sort direct references higher than indirect references
-      return a.indirections - b.indirections;
-    } else if (a.depth !== b.depth) {
-      // Sort $refs by how close they are to the JSON Schema root
-      return a.depth - b.depth;
-    } else {
-      // Determine how far each $ref is from the "definitions" property.
-      // Most people will expect references to be bundled into the the "definitions" property if possible.
-      const aDefinitionsIndex = a.pathFromRoot.lastIndexOf("/definitions");
-      const bDefinitionsIndex = b.pathFromRoot.lastIndexOf("/definitions");
-
-      if (aDefinitionsIndex !== bDefinitionsIndex) {
-        // Give higher priority to the $ref that's closer to the "definitions" property
-        return bDefinitionsIndex - aDefinitionsIndex;
-      } else {
-        // All else is equal, so use the shorter path, which will produce the shortest possible reference
-        return a.pathFromRoot.length - b.pathFromRoot.length;
-      }
-    }
-  });
-
-  let file, hash, pathFromRoot;
-  for (const entry of inventory) {
-    // console.log('Re-mapping $ref pointer "%s" at %s', entry.$ref.$ref, entry.pathFromRoot);
-
-    if (!entry.external) {
-      // This $ref already resolves to the main JSON Schema file
-      entry.$ref.$ref = entry.hash;
-    } else if (entry.file === file && entry.hash === hash) {
-      // This $ref points to the same value as the prevous $ref, so remap it to the same path
-      entry.$ref.$ref = pathFromRoot;
-    } else if (entry.file === file && entry.hash.indexOf(hash + "/") === 0) {
-      // This $ref points to a sub-value of the prevous $ref, so remap it beneath that path
-      entry.$ref.$ref = Pointer.join(pathFromRoot, Pointer.parse(entry.hash.replace(hash, "#")));
-    } else {
-      // We've moved to a new file or new hash
-      file = entry.file;
-      hash = entry.hash;
-      pathFromRoot = entry.pathFromRoot;
-
-      // This is the first $ref to point to this value, so dereference the value.
-      // Any other $refs that point to the same value will point to this $ref instead
-      entry.$ref = entry.parent[entry.key] = $Ref.dereference(entry.$ref, entry.value);
-
-      if (entry.circular) {
-        // This $ref points to itself
-        entry.$ref.$ref = entry.pathFromRoot;
-      }
-    }
-  }
-
-  // we want to ensure that any $refs that point to another $ref are remapped to point to the final value
-  // let hadChange = true;
-  // while (hadChange) {
-  //   hadChange = false;
-  //   for (const entry of inventory) {
-  //     if (entry.$ref && typeof entry.$ref === "object" && "$ref" in entry.$ref) {
-  //       const resolved = inventory.find((e: InventoryEntry) => e.pathFromRoot === entry.$ref.$ref);
-  //       if (resolved) {
-  //         const resolvedPointsToAnotherRef =
-  //           resolved.$ref && typeof resolved.$ref === "object" && "$ref" in resolved.$ref;
-  //         if (resolvedPointsToAnotherRef && entry.$ref.$ref !== resolved.$ref.$ref) {
-  //           // console.log('Re-mapping $ref pointer "%s" at %s', entry.$ref.$ref, entry.pathFromRoot);
-  //           entry.$ref.$ref = resolved.$ref.$ref;
-  //           hadChange = true;
-  //         }
-  //       }
-  //     }
-  //   }
-  // }
-}
-
-/**
- * TODO
- */
-function findInInventory(inventory: InventoryEntry[], $refParent: any, $refKey: any) {
-  for (const existingEntry of inventory) {
-    if (existingEntry && existingEntry.parent === $refParent && existingEntry.key === $refKey) {
-      return existingEntry;
-    }
-  }
-  return undefined;
-}
-
-function removeFromInventory(inventory: InventoryEntry[], entry: any) {
-  const index = inventory.indexOf(entry);
-  inventory.splice(index, 1);
-}
-export default bundle;