@hey-api/json-schema-ref-parser 1.0.4 → 1.0.5

package/dist/lib/__tests__/bundle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/bundle.test.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const vitest_1 = require("vitest");
+const __1 = require("..");
+(0, vitest_1.describe)('bundle', () => {
+    (0, vitest_1.it)('handles circular reference with description', async () => {
+        const refParser = new __1.$RefParser();
+        const pathOrUrlOrSchema = node_path_1.default.resolve('lib', '__tests__', 'spec', 'circular-ref-with-description.json');
+        const schema = await refParser.bundle({ pathOrUrlOrSchema });
+        (0, vitest_1.expect)(schema).not.toBeUndefined();
+    });
+});

package/dist/lib/bundle.d.ts

@@ -2,17 +2,17 @@ import type { ParserOptions } from "./options.js";
 import type { $RefParser } from "./index";
 export interface InventoryEntry {
     $ref: any;
-    parent: any;
-    key: any;
-    pathFromRoot: any;
-    depth: any;
-    file: any;
-    hash: any;
-    value: any;
     circular: any;
+    depth: any;
     extended: any;
     external: any;
+    file: any;
+    hash: any;
     indirections: any;
+    key: any;
+    parent: any;
+    pathFromRoot: any;
+    value: any;
 }
 /**
  * Bundles all external JSON references into the main JSON schema, thus resulting in a schema that
@@ -22,5 +22,4 @@ export interface InventoryEntry {
  * @param parser
  * @param options
  */
-declare function bundle(parser: $RefParser, options: ParserOptions): void;
-export default bundle;
+export declare const bundle: (parser: $RefParser, options: ParserOptions) => void;

package/dist/lib/bundle.js

@@ -36,90 +36,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundle = void 0;
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
 const ref_js_1 = __importDefault(require("./ref.js"));
 const pointer_js_1 = __importDefault(require("./pointer.js"));
 const url = __importStar(require("./util/url.js"));
 /**
- * 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(parser, options) {
-    // 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 = [];
-    crawl(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
+ * TODO
  */
-function crawl(parent, key, path, pathFromRoot, indirections, inventory, $refs, options) {
-    const obj = key === null ? parent : parent[key];
-    if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
-        if (ref_js_1.default.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;
-                }
-            });
-            for (const key of keys) {
-                const keyPath = pointer_js_1.default.join(path, key);
-                const keyPathFromRoot = pointer_js_1.default.join(pathFromRoot, key);
-                const value = obj[key];
-                if (ref_js_1.default.isAllowed$Ref(value)) {
-                    inventory$Ref(obj, key, path, keyPathFromRoot, indirections, inventory, $refs, options);
-                }
-                else {
-                    crawl(obj, key, keyPath, keyPathFromRoot, indirections, inventory, $refs, options);
+const findInInventory = (inventory, $refParent, $refKey) => {
+    for (const entry of inventory) {
+        if (entry) {
+            if ((0, isEqual_1.default)(entry.parent, $refParent)) {
+                if (entry.key === $refKey) {
+                    return entry;
                 }
             }
         }
     }
-}
+    return undefined;
+};
 /**
  * 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($refParent, $refKey, path, pathFromRoot, indirections, inventory, $refs, options) {
+const inventory$Ref = ({ $refKey, $refParent, $refs, indirections, inventory, options, path, pathFromRoot, }) => {
     const $ref = $refKey === null ? $refParent : $refParent[$refKey];
     const $refPath = url.resolve(path, $ref.$ref);
     const pointer = $refs._resolve($refPath, pathFromRoot, options);
@@ -145,23 +86,101 @@ function inventory$Ref($refParent, $refKey, path, pathFromRoot, indirections, in
     }
     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)
+        depth, // How far from the JSON Schema root is this $ref pointer?
         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?
+        file, // The file that the $ref pointer resolves to
+        hash, // The hash within `file` that the $ref pointer resolves to
         indirections, // The number of indirect references that were traversed to resolve the value
+        key: $refKey, // The key in `parent` that is the $ref pointer
+        parent: $refParent, // The object that contains this $ref pointer
+        pathFromRoot, // The path to the $ref pointer, from the JSON Schema root
+        value: pointer.value, // The resolved value of the $ref pointer
     });
     // Recursively crawl the resolved value
     if (!existingEntry || external) {
-        crawl(pointer.value, null, pointer.path, pathFromRoot, indirections + 1, inventory, $refs, options);
+        crawl({
+            parent: pointer.value,
+            key: null,
+            path: pointer.path,
+            pathFromRoot,
+            indirections: indirections + 1,
+            inventory,
+            $refs,
+            options,
+        });
     }
-}
+};
+/**
+ * Recursively crawls the given value, and inventories all JSON references.
+ */
+const crawl = ({ $refs, indirections, inventory, key, options, parent, path, pathFromRoot, }) => {
+    const obj = key === null ? parent : parent[key];
+    if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
+        if (ref_js_1.default.isAllowed$Ref(obj)) {
+            inventory$Ref({
+                $refParent: parent,
+                $refKey: 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 "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;
+                }
+            });
+            for (const key of keys) {
+                const keyPath = pointer_js_1.default.join(path, key);
+                const keyPathFromRoot = pointer_js_1.default.join(pathFromRoot, key);
+                const value = obj[key];
+                if (ref_js_1.default.isAllowed$Ref(value)) {
+                    inventory$Ref({
+                        $refParent: obj,
+                        $refKey: key,
+                        path,
+                        pathFromRoot: keyPathFromRoot,
+                        indirections,
+                        inventory,
+                        $refs,
+                        options,
+                    });
+                }
+                else {
+                    crawl({
+                        parent: obj,
+                        key,
+                        path: keyPath,
+                        pathFromRoot: keyPathFromRoot,
+                        indirections,
+                        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
@@ -275,19 +294,33 @@ function remap(inventory) {
     //   }
     // }
 }
-/**
- * TODO
- */
-function findInInventory(inventory, $refParent, $refKey) {
-    for (const existingEntry of inventory) {
-        if (existingEntry && existingEntry.parent === $refParent && existingEntry.key === $refKey) {
-            return existingEntry;
-        }
-    }
-    return undefined;
-}
 function removeFromInventory(inventory, entry) {
     const index = inventory.indexOf(entry);
     inventory.splice(index, 1);
 }
-exports.default = bundle;
+/**
+ * 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
+ */
+const bundle = (parser, options) => {
+    // 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 = [];
+    crawl({
+        parent: parser,
+        key: 'schema',
+        path: parser.$refs._root$Ref.path + "#",
+        pathFromRoot: "#",
+        indirections: 0,
+        inventory,
+        $refs: parser.$refs,
+        options,
+    });
+    // Remap all $ref pointers
+    remap(inventory);
+};
+exports.bundle = bundle;

package/dist/lib/index.js

@@ -40,7 +40,7 @@ exports.sendRequest = exports.$RefParser = exports.getResolvedInput = void 0;
 const refs_js_1 = __importDefault(require("./refs.js"));
 const parse_js_1 = require("./parse.js");
 const resolve_external_js_1 = require("./resolve-external.js");
-const bundle_js_1 = __importDefault(require("./bundle.js"));
+const bundle_js_1 = require("./bundle.js");
 const dereference_js_1 = __importDefault(require("./dereference.js"));
 const url = __importStar(require("./util/url.js"));
 const errors_js_1 = require("./util/errors.js");
@@ -130,7 +130,7 @@ class $RefParser {
         if (errors.length > 0) {
             throw new errors_js_1.JSONParserErrorGroup(this);
         }
-        (0, bundle_js_1.default)(this, this.options);
+        (0, bundle_js_1.bundle)(this, this.options);
         const errors2 = errors_js_1.JSONParserErrorGroup.getParserErrors(this);
         if (errors2.length > 0) {
             throw new errors_js_1.JSONParserErrorGroup(this);

package/lib/__tests__/bundle.test.ts

@@ -0,0 +1,14 @@
+import path from 'node:path';
+
+import { describe, expect, it } from 'vitest';
+
+import { $RefParser } from '..';
+
+describe('bundle', () => {
+  it('handles circular reference with description', async () => {
+    const refParser = new $RefParser();
+    const pathOrUrlOrSchema = path.resolve('lib', '__tests__', 'spec', 'circular-ref-with-description.json');
+    const schema = await refParser.bundle({ pathOrUrlOrSchema });
+    expect(schema).not.toBeUndefined();
+  });
+});

package/lib/__tests__/spec/circular-ref-with-description.json

@@ -0,0 +1,11 @@
+{
+  "schemas": {
+    "Foo": {
+      "$ref": "#/schemas/Bar"
+    },
+    "Bar": {
+      "description": "ok",
+      "$ref": "#/schemas/Foo"
+    }
+  }
+}

package/lib/bundle.ts

@@ -1,3 +1,5 @@
+import isEqual from "lodash/isEqual";
+
 import $Ref from "./ref.js";
 import type { ParserOptions } from "./options.js";
 import Pointer from "./pointer.js";
@@ -8,123 +10,76 @@ import type { JSONSchema } from "./types/index.js";
 
 export interface InventoryEntry {
   $ref: any;
-  parent: any;
-  key: any;
-  pathFromRoot: any;
-  depth: any;
-  file: any;
-  hash: any;
-  value: any;
   circular: any;
+  depth: any;
   extended: any;
   external: any;
+  file: any;
+  hash: 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(
-  parser: $RefParser,
-  options: ParserOptions,
-) {
-  // 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<JSONSchema>(parser, "schema", parser.$refs._root$Ref.path + "#", "#", 0, inventory, parser.$refs, options);
-
-  // Remap all $ref pointers
-  remap(inventory);
+  key: any;
+  parent: any;
+  pathFromRoot: any;
+  value: any;
 }
 
 /**
- * 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
+ * TODO
  */
-function crawl<S extends object = JSONSchema>(
-  parent: object | $RefParser,
-  key: string | null,
-  path: string,
-  pathFromRoot: string,
-  indirections: number,
-  inventory: InventoryEntry[],
-  $refs: $Refs<S>,
-  options: ParserOptions,
-) {
-  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);
+const findInInventory = (inventory: Array<InventoryEntry>, $refParent: any, $refKey: any) => {
+  for (const entry of inventory) {
+    if (entry) {
+      if (isEqual(entry.parent, $refParent)) {
+        if (entry.key === $refKey) {
+          return entry;
         }
       }
     }
   }
-}
+  return undefined;
+};
 
 /**
  * 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>(
-  $refParent: any,
-  $refKey: string | null,
-  path: string,
-  pathFromRoot: string,
-  indirections: number,
-  inventory: InventoryEntry[],
-  $refs: $Refs<S>,
-  options: ParserOptions,
-) {
+const inventory$Ref = <S extends object = JSONSchema>({
+  $refKey,
+  $refParent,
+  $refs,
+  indirections,
+  inventory,
+  options,
+  path,
+  pathFromRoot,
+}: {
+  /**
+   * The key in `$refParent` that is a JSON Reference
+   */
+  $refKey: string | null;
+  /**
+   * The object that contains a JSON Reference as one of its keys
+   */
+  $refParent: any;
+  $refs: $Refs<S>;
+  /**
+   * unknown
+   */
+  indirections: number;
+  /**
+   * An array of already-inventoried $ref pointers
+   */
+  inventory: Array<InventoryEntry>;
+  options: ParserOptions;
+  /**
+   * The full path of the JSON Reference at `$refKey`, possibly with a JSON Pointer in the hash
+   */
+  path: string;
+  /**
+   * The path of the JSON Reference at `$refKey`, from the schema root
+   */
+  pathFromRoot: string;
+}) => {
   const $ref = $refKey === null ? $refParent : $refParent[$refKey];
   const $refPath = url.resolve(path, $ref.$ref);
   const pointer = $refs._resolve($refPath, pathFromRoot, options);
@@ -151,24 +106,135 @@ function inventory$Ref<S extends object = JSONSchema>(
 
   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)
+    depth, // How far from the JSON Schema root is this $ref pointer?
     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?
+    file, // The file that the $ref pointer resolves to
+    hash, // The hash within `file` that the $ref pointer resolves to
     indirections, // The number of indirect references that were traversed to resolve the value
+    key: $refKey, // The key in `parent` that is the $ref pointer
+    parent: $refParent, // The object that contains this $ref pointer
+    pathFromRoot, // The path to the $ref pointer, from the JSON Schema root
+    value: pointer.value, // The resolved value of the $ref pointer
   });
 
   // Recursively crawl the resolved value
   if (!existingEntry || external) {
-    crawl(pointer.value, null, pointer.path, pathFromRoot, indirections + 1, inventory, $refs, options);
+    crawl({
+      parent: pointer.value,
+      key: null,
+      path: pointer.path,
+      pathFromRoot,
+      indirections: indirections + 1,
+      inventory,
+      $refs,
+      options,
+    });
   }
-}
+};
+
+/**
+ * Recursively crawls the given value, and inventories all JSON references.
+ */
+const crawl = <S extends object = JSONSchema>({
+  $refs,
+  indirections,
+  inventory,
+  key,
+  options,
+  parent,
+  path,
+  pathFromRoot,
+}: {
+  $refs: $Refs<S>;
+  indirections: number;
+  /**
+   * An array of already-inventoried $ref pointers
+   */
+  inventory: Array<InventoryEntry>;
+  /**
+   * The property key of `parent` to be crawled
+   */
+  key: string | null;
+  options: ParserOptions;
+  /**
+   * The object containing the value to crawl. If the value is not an object or array, it will be ignored.
+   */
+  parent: object | $RefParser;
+  /**
+   * The full path of the property being crawled, possibly with a JSON Pointer in the hash
+   */
+  path: string;
+  /**
+   * The path of the property being crawled, from the schema root
+   */
+  pathFromRoot: string;
+}) => {
+  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({
+        $refParent: parent,
+        $refKey: 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 "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({
+            $refParent: obj,
+            $refKey: key,
+            path,
+            pathFromRoot: keyPathFromRoot,
+            indirections,
+            inventory,
+            $refs,
+            options,
+          });
+        } else {
+          crawl({
+            parent: obj,
+            key,
+            path: keyPath,
+            pathFromRoot: keyPathFromRoot,
+            indirections,
+            inventory,
+            $refs,
+            options,
+          });
+        }
+      }
+    }
+  }
+};
 
 /**
  * Re-maps every $ref pointer, so that they're all relative to the root of the JSON Schema.
@@ -280,20 +346,38 @@ function remap(inventory: InventoryEntry[]) {
   // }
 }
 
-/**
- * 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;
+
+/**
+ * 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
+ */
+export const bundle = (
+  parser: $RefParser,
+  options: ParserOptions,
+) => {
+  // 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<JSONSchema>({
+    parent: parser,
+    key: 'schema',
+    path: parser.$refs._root$Ref.path + "#",
+    pathFromRoot: "#",
+    indirections: 0,
+    inventory,
+    $refs: parser.$refs,
+    options,
+  });
+
+  // Remap all $ref pointers
+  remap(inventory);
+};

package/lib/index.ts

@@ -1,7 +1,7 @@
 import $Refs from "./refs.js";
 import { newFile, parseFile } from "./parse.js";
 import { resolveExternal } from "./resolve-external.js";
-import _bundle from "./bundle.js";
+import { bundle as _bundle } from "./bundle.js";
 import _dereference from "./dereference.js";
 import * as url from "./util/url.js";
 import { isHandledError, JSONParserErrorGroup } from "./util/errors.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hey-api/json-schema-ref-parser",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
   "homepage": "https://heyapi.dev/",
   "repository": {
@@ -57,6 +57,7 @@
     "@eslint/js": "^9.16.0",
     "@types/eslint": "9.6.1",
     "@types/js-yaml": "^4.0.9",
+    "@types/lodash": "^4",
     "@types/node": "^22",
     "@typescript-eslint/eslint-plugin": "^8.17.0",
     "@typescript-eslint/parser": "^8.17.0",
@@ -80,7 +81,8 @@
   "dependencies": {
     "@jsdevtools/ono": "^7.1.3",
     "@types/json-schema": "^7.0.15",
-    "js-yaml": "^4.1.0"
+    "js-yaml": "^4.1.0",
+    "lodash": "^4.17.21"
   },
   "release": {
     "branches": [