@scalar/openapi-parser 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @scalar/openapi-parser
 
+## 0.14.0
+
+### Minor Changes
+
+- ee3eb77: feat(openapi-parser): bundle openapi documents
+
 ## 0.13.0
 
 ### Minor Changes

package/README.md

@@ -55,6 +55,140 @@ const specification = `{
 const { schema, errors } = await dereference(specification)
 ```
 
+### Bundle external references
+
+The OpenAPI specification allows to point to external files (URLs or files). But sometimes, you just want to combine all files into one.
+
+#### Plugins
+
+##### fetchUrls
+This plugins handles all external urls. It works for both node.js and browser environment
+
+```ts
+import { bundle, fetchUrls } from '@scalar/openapi-parser'
+
+const document = {
+  openapi: '3.1.0',
+  info: { title: 'Bundled API', version: '1.0.0' },
+  paths: {},
+  components: {
+    schemas: {
+      User: { $ref: 'https://example.com/user-schema.json#' }
+    }
+  }
+}
+
+// This will bundle all external documents and turn all references from external into internal
+await bundle(document, {
+  plugins: [fetchUrls()],
+  treeShake: true  // <------  This flag will try to remove any unused part of the external document
+})
+
+console.log(document)
+```
+
+###### Limiting the number of concurrent requests
+
+```ts
+await bundle(document, {
+  plugins: [
+    fetchUrls({
+      limit: 10, // it should run at most 10 requests at the same time
+    }),
+  ],
+  treeShake: false
+})
+
+```
+
+###### Custom headers
+To pass custom headers to requests for specific domains you can configure the fetch plugin like the example
+
+```ts
+await bundle(
+  document,
+  {
+    plugins: [
+      fetchUrls({
+        // Pass custom headers
+        // The header will only be attached to the list of domains
+        headers: [
+          {
+            domains: ['example.com'],
+            headers: {
+              'Authorization': 'Bearer <TOKEN>'
+            }
+          }
+        ]
+      }),
+      readFiles(),
+    ],
+    treeShake: false
+  },
+)
+```
+
+###### Bundle from remote url
+
+```ts
+const result = await bundle(
+  'https://example.com/openapi.json',
+  {
+    plugins: [
+      fetchUrls(),
+    ],
+    treeShake: false
+  },
+)
+
+// Bundled document
+console.log(result)
+```
+
+##### readFiles
+This plugins handles local files. Only works on node.js environment
+
+```ts
+import { bundle, readFiles } from '@scalar/openapi-parser'
+
+const document = {
+  openapi: '3.1.0',
+  info: { title: 'Bundled API', version: '1.0.0' },
+  paths: {},
+  components: {
+    schemas: {
+      User: { $ref: './user-schema.json#' }
+    }
+  }
+}
+
+// This will bundle all external documents and turn all references from external into internal
+await bundle(document, {
+  plugins: [readFiles()],
+  treeShake: false
+})
+
+console.log(document)
+```
+
+###### Bundle from local file
+You can pass the file path directly but make sure to have the correct plugins to handle reading from the local files
+
+```ts
+const result = await bundle(
+  './input.json',
+  {
+    plugins: [
+      readFiles(),
+    ],
+    treeShake: false
+  },
+)
+
+// Bundled document
+console.log(result)
+```
+
 ### Track references
 
 The `dereference` function accepts an `onDereference` callback option that gets called whenever a reference is resolved. This can be useful for tracking which schemas are being dereferenced:

package/dist/index.d.ts

@@ -14,5 +14,6 @@ export { upgrade } from './utils/upgrade.js';
 export { upgradeFromThreeToThreeOne } from './utils/upgrade-from-three-to-three-one.js';
 export { upgradeFromTwoToThree } from './utils/upgrade-from-two-to-three.js';
 export { validate } from './utils/validate.js';
+export { bundle, fetchUrls, readFiles } from './utils/bundle/index.js';
 export type { LoadResult, Filesystem, AnyObject, ErrorObject } from './types/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AACrD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAA;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAA;AACpF,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAA;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AACrD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAA;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAA;AACpF,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAA;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC7D,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -14,14 +14,18 @@ import { upgrade } from "./utils/upgrade.js";
 import { upgradeFromThreeToThreeOne } from "./utils/upgrade-from-three-to-three-one.js";
 import { upgradeFromTwoToThree } from "./utils/upgrade-from-two-to-three.js";
 import { validate } from "./utils/validate.js";
+import { bundle, fetchUrls, readFiles } from "./utils/bundle/index.js";
 export {
+  bundle,
   dereference,
   escapeJsonPointer,
+  fetchUrls,
   filter,
   isJson,
   isYaml,
   load,
   normalize,
+  readFiles,
   sanitize,
   toJson,
   toYaml,

package/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "sourcesContent": ["export { dereference } from './utils/dereference'\nexport { escapeJsonPointer } from './utils/escape-json-pointer'\nexport { filter } from './utils/filter'\nexport { isJson } from './utils/is-json'\nexport { isYaml } from './utils/is-yaml'\nexport { load } from './utils/load'\nexport { normalize } from './utils/normalize'\nexport { sanitize } from './utils/transform/sanitize'\nexport { toJson } from './utils/to-json'\nexport { toYaml } from './utils/to-yaml'\nexport { traverse } from './utils/traverse'\nexport { unescapeJsonPointer } from './utils/unescape-json-pointer'\nexport { upgrade } from './utils/upgrade'\nexport { upgradeFromThreeToThreeOne } from './utils/upgrade-from-three-to-three-one'\nexport { upgradeFromTwoToThree } from './utils/upgrade-from-two-to-three'\nexport { validate } from './utils/validate'\nexport type { LoadResult, Filesystem, AnyObject, ErrorObject } from './types'\n"],
-  "mappings": "AAAA,SAAS,mBAAmB;AAC5B,SAAS,yBAAyB;AAClC,SAAS,cAAc;AACvB,SAAS,cAAc;AACvB,SAAS,cAAc;AACvB,SAAS,YAAY;AACrB,SAAS,iBAAiB;AAC1B,SAAS,gBAAgB;AACzB,SAAS,cAAc;AACvB,SAAS,cAAc;AACvB,SAAS,gBAAgB;AACzB,SAAS,2BAA2B;AACpC,SAAS,eAAe;AACxB,SAAS,kCAAkC;AAC3C,SAAS,6BAA6B;AACtC,SAAS,gBAAgB;",
+  "sourcesContent": ["export { dereference } from './utils/dereference'\nexport { escapeJsonPointer } from './utils/escape-json-pointer'\nexport { filter } from './utils/filter'\nexport { isJson } from './utils/is-json'\nexport { isYaml } from './utils/is-yaml'\nexport { load } from './utils/load'\nexport { normalize } from './utils/normalize'\nexport { sanitize } from './utils/transform/sanitize'\nexport { toJson } from './utils/to-json'\nexport { toYaml } from './utils/to-yaml'\nexport { traverse } from './utils/traverse'\nexport { unescapeJsonPointer } from './utils/unescape-json-pointer'\nexport { upgrade } from './utils/upgrade'\nexport { upgradeFromThreeToThreeOne } from './utils/upgrade-from-three-to-three-one'\nexport { upgradeFromTwoToThree } from './utils/upgrade-from-two-to-three'\nexport { validate } from './utils/validate'\nexport { bundle, fetchUrls, readFiles } from './utils/bundle'\nexport type { LoadResult, Filesystem, AnyObject, ErrorObject } from './types'\n"],
+  "mappings": "AAAA,SAAS,mBAAmB;AAC5B,SAAS,yBAAyB;AAClC,SAAS,cAAc;AACvB,SAAS,cAAc;AACvB,SAAS,cAAc;AACvB,SAAS,YAAY;AACrB,SAAS,iBAAiB;AAC1B,SAAS,gBAAgB;AACzB,SAAS,cAAc;AACvB,SAAS,cAAc;AACvB,SAAS,gBAAgB;AACzB,SAAS,2BAA2B;AACpC,SAAS,eAAe;AACxB,SAAS,kCAAkC;AAC3C,SAAS,6BAA6B;AACtC,SAAS,gBAAgB;AACzB,SAAS,QAAQ,WAAW,iBAAiB;",
   "names": []
 }

package/dist/types/index.d.ts

@@ -5,6 +5,7 @@ import type { ERRORS, OpenApiVersion } from '../configuration/index.js';
  */
 export type Merge<A, B> = A & Omit<B, keyof A>;
 export type AnyObject = Record<string, any>;
+export type UnknownObject = Record<string, unknown>;
 /**
  * JSON, YAML or object representation of an OpenAPI API definition
  */

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/dist/utils/bundle/bundle.d.ts

@@ -0,0 +1,193 @@
+import type { UnknownObject } from '../../types/index.js';
+/**
+ * Checks if a string is a remote URL (starts with http:// or https://)
+ * @param value - The URL string to check
+ * @returns true if the string is a remote URL, false otherwise
+ * @example
+ * ```ts
+ * isRemoteUrl('https://example.com/schema.json') // true
+ * isRemoteUrl('http://api.example.com/schemas/user.json') // true
+ * isRemoteUrl('#/components/schemas/User') // false
+ * isRemoteUrl('./local-schema.json') // false
+ * ```
+ */
+export declare function isRemoteUrl(value: string): boolean;
+/**
+ * Checks if a string is a local reference (starts with #)
+ * @param value - The reference string to check
+ * @returns true if the string is a local reference, false otherwise
+ * @example
+ * ```ts
+ * isLocalRef('#/components/schemas/User') // true
+ * isLocalRef('https://example.com/schema.json') // false
+ * isLocalRef('./local-schema.json') // false
+ * ```
+ */
+export declare function isLocalRef(value: string): boolean;
+export type ResolveResult = {
+    ok: true;
+    data: unknown;
+} | {
+    ok: false;
+};
+/**
+ * Retrieves a nested value from an object using an array of property segments.
+ * @param target - The target object to traverse
+ * @param segments - Array of property names representing the path to the desired value
+ * @returns The value at the specified path, or undefined if the path doesn't exist
+ * @example
+ * const obj = { foo: { bar: { baz: 42 } } };
+ * getNestedValue(obj, ['foo', 'bar', 'baz']); // returns 42
+ */
+export declare function getNestedValue(target: Record<string, any>, segments: string[]): any;
+/**
+ * Sets a value at a specified path in an object, creating intermediate objects/arrays as needed.
+ * This function traverses the object structure and creates any missing intermediate objects
+ * or arrays based on the path segments. If the next segment is a numeric string, it creates
+ * an array instead of an object.
+ *
+ * @param obj - The target object to set the value in
+ * @param path - The JSON pointer path where the value should be set
+ * @param value - The value to set at the specified path
+ * @throws {Error} If attempting to set a value at the root path ('')
+ *
+ * @example
+ * const obj = {}
+ * setValueAtPath(obj, '/foo/bar/0', 'value')
+ * // Result:
+ * // {
+ * //   foo: {
+ * //     bar: ['value']
+ * //   }
+ * // }
+ *
+ * @example
+ * const obj = { existing: { path: 'old' } }
+ * setValueAtPath(obj, '/existing/path', 'new')
+ * // Result:
+ * // {
+ * //   existing: {
+ * //     path: 'new'
+ * //   }
+ * // }
+ */
+export declare function setValueAtPath(obj: any, path: string, value: any): void;
+/**
+ * Prefixes an internal JSON reference with a given path prefix.
+ * Takes a local reference (starting with #) and prepends the provided prefix segments.
+ *
+ * @param input - The internal reference string to prefix (must start with #)
+ * @param prefix - Array of path segments to prepend to the reference
+ * @returns The prefixed reference string
+ * @throws Error if input is not a local reference
+ * @example
+ * prefixInternalRef('#/components/schemas/User', ['definitions'])
+ * // Returns: '#/definitions/components/schemas/User'
+ */
+export declare function prefixInternalRef(input: string, prefix: string[]): string;
+/**
+ * Updates internal references in an object by adding a prefix to their paths.
+ * Recursively traverses the input object and modifies any local $ref references
+ * by prepending the given prefix to their paths. This is used when embedding external
+ * documents to maintain correct reference paths relative to the main document.
+ *
+ * @param input - The object to update references in
+ * @param prefix - Array of path segments to prepend to internal reference paths
+ * @returns void
+ * @example
+ * ```ts
+ * const input = {
+ *   foo: {
+ *     $ref: '#/components/schemas/User'
+ *   }
+ * }
+ * prefixInternalRefRecursive(input, ['definitions'])
+ * // Result:
+ * // {
+ * //   foo: {
+ * //     $ref: '#/definitions/components/schemas/User'
+ * //   }
+ * // }
+ * ```
+ */
+export declare function prefixInternalRefRecursive(input: unknown, prefix: string[]): string;
+/**
+ * Generates a short SHA-1 hash from a string value.
+ * This function is used to create unique identifiers for external references
+ * while keeping the hash length manageable. It uses the Web Crypto API to
+ * generate a SHA-1 hash and returns the first 7 characters of the hex string.
+ *
+ * @param value - The string to hash
+ * @returns A 7-character hexadecimal hash
+ * @example
+ * // Returns "a1b2c3d"
+ * getHash("https://example.com/schema.json")
+ */
+export declare function getHash(value: string): Promise<string>;
+/**
+ * Represents a plugin that handles resolving references from external sources.
+ * Plugins are responsible for fetching and processing data from different sources
+ * like URLs or the filesystem. Each plugin must implement validation to determine
+ * if it can handle a specific reference, and an execution function to perform
+ * the actual resolution.
+ *
+ * @property validate - Determines if this plugin can handle the given reference
+ * @property exec - Fetches and processes the reference, returning the resolved data
+ */
+export type Plugin = {
+    validate: (value: string) => boolean;
+    exec: (value: string) => Promise<ResolveResult>;
+};
+type Config = {
+    plugins: Plugin[];
+    root?: UnknownObject;
+    cache?: Map<string, Promise<ResolveResult>>;
+    treeShake: boolean;
+    urlMap?: boolean;
+};
+/**
+ * Bundles an OpenAPI specification by resolving all external references.
+ * This function traverses the input object recursively and embeds external $ref
+ * references into an x-ext section. External references can be URLs or local files.
+ * The original $refs are updated to point to their embedded content in the x-ext section.
+ * If the input is an object, it will be modified in place by adding an x-ext
+ * property to store resolved external references.
+ *
+ * @param input - The OpenAPI specification object or string to bundle. If a string is provided,
+ *                it should be a URL or file path that points to an OpenAPI specification.
+ *                The string will be resolved using the provided plugins before bundling.
+ * @param config - Configuration object containing plugins for resolving references
+ * @returns A promise that resolves to the bundled specification with all references embedded
+ * @example
+ * // Example with object input
+ * const spec = {
+ *   paths: {
+ *     '/users': {
+ *       $ref: 'https://example.com/schemas/users.yaml'
+ *     }
+ *   }
+ * }
+ *
+ * const bundled = await bundle(spec, { plugins: [fetchUrls()] })
+ * // Result:
+ * // {
+ * //   paths: {
+ * //     '/users': {
+ * //       $ref: '#/x-ext/https~1~1example.com~1schemas~1users.yaml'
+ * //     }
+ * //   },
+ * //   'x-ext': {
+ * //     'https~1~1example.com~1schemas~1users.yaml': {
+ * //       // Resolved content from users.yaml
+ * //     }
+ * //   }
+ * // }
+ *
+ * // Example with URL input
+ * const bundledFromUrl = await bundle('https://example.com/openapi.yaml', { plugins: [fetchUrls()] })
+ * // The function will first fetch the OpenAPI spec from the URL,
+ * // then bundle all its external references into the x-ext section
+ */
+export declare function bundle(input: UnknownObject | string, config: Config): Promise<unknown>;
+export {};
+//# sourceMappingURL=bundle.d.ts.map

package/dist/utils/bundle/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../src/utils/bundle/bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAM5C;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,CAAA;AA2BvE;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAO7E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAyBvE;AAiCD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAMhE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAgB1E;AAqFD;;;;;;;;;;;GAWG;AACH,wBAAsB,OAAO,CAAC,KAAK,EAAE,MAAM,mBAa1C;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,MAAM,GAAG;IAEnB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;IAEpC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAA;CAChD,CAAA;AAED,KAAK,MAAM,GAAG;IAEZ,OAAO,EAAE,MAAM,EAAE,CAAA;IAGjB,IAAI,CAAC,EAAE,aAAa,CAAA;IAEpB,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC,CAAA;IAE3C,SAAS,EAAE,OAAO,CAAA;IAElB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,EAAE,MAAM,EAAE,MAAM,oBA2IzE"}

package/dist/utils/bundle/bundle.js

@@ -0,0 +1,197 @@
+import { escapeJsonPointer } from "../../utils/escape-json-pointer.js";
+import path from "../../polyfills/path.js";
+import { getSegmentsFromPath } from "../../utils/get-segments-from-path.js";
+import { isObject } from "../../utils/is-object.js";
+function isRemoteUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+function isLocalRef(value) {
+  return value.startsWith("#");
+}
+async function resolveContents(value, plugins) {
+  const plugin = plugins.find((p) => p.validate(value));
+  if (plugin) {
+    return plugin.exec(value);
+  }
+  return {
+    ok: false
+  };
+}
+function getNestedValue(target, segments) {
+  return segments.reduce((acc, key) => {
+    if (acc === void 0) {
+      return void 0;
+    }
+    return acc[key];
+  }, target);
+}
+function setValueAtPath(obj, path2, value) {
+  if (path2 === "") {
+    throw new Error("Cannot set value at root ('') pointer");
+  }
+  const parts = getSegmentsFromPath(path2);
+  let current = obj;
+  for (let i = 0; i < parts.length; i++) {
+    const key = parts[i];
+    const isLast = i === parts.length - 1;
+    const nextKey = parts[i + 1];
+    const shouldBeArray = /^\d+$/.test(nextKey ?? "");
+    if (isLast) {
+      current[key] = value;
+    } else {
+      if (!(key in current) || typeof current[key] !== "object") {
+        current[key] = shouldBeArray ? [] : {};
+      }
+      current = current[key];
+    }
+  }
+}
+function resolveReferencePath(base, relativePath) {
+  if (isRemoteUrl(relativePath)) {
+    return relativePath;
+  }
+  if (isRemoteUrl(base)) {
+    const url = new URL(base);
+    const mergedPath = path.join(path.dirname(url.pathname), relativePath);
+    return new URL(mergedPath, base).toString();
+  }
+  return path.join(path.dirname(base), relativePath);
+}
+function prefixInternalRef(input, prefix) {
+  if (!isLocalRef(input)) {
+    throw "Please provide an internal ref";
+  }
+  return `#/${prefix.map(escapeJsonPointer).join("/")}${input.substring(1)}`;
+}
+function prefixInternalRefRecursive(input, prefix) {
+  if (!isObject(input)) {
+    return;
+  }
+  Object.values(input).forEach((el) => prefixInternalRefRecursive(el, prefix));
+  if (typeof input === "object" && "$ref" in input && typeof input["$ref"] === "string") {
+    const ref = input["$ref"];
+    if (!isLocalRef(ref)) {
+      return;
+    }
+    return input["$ref"] = prefixInternalRef(ref, prefix);
+  }
+}
+const resolveAndCopyReferences = (targetDocument, sourceDocument, referencePath, externalRefsKey, documentKey, processedNodes = /* @__PURE__ */ new Set()) => {
+  const referencedValue = getNestedValue(sourceDocument, getSegmentsFromPath(referencePath));
+  if (processedNodes.has(referencedValue)) {
+    return;
+  }
+  processedNodes.add(referencedValue);
+  setValueAtPath(targetDocument, referencePath, referencedValue);
+  const traverse = (node) => {
+    if (!node || typeof node !== "object") {
+      return;
+    }
+    if ("$ref" in node && typeof node["$ref"] === "string") {
+      if (node["$ref"].startsWith(`#/${externalRefsKey}/${escapeJsonPointer(documentKey)}`)) {
+        resolveAndCopyReferences(
+          targetDocument,
+          sourceDocument,
+          node["$ref"].substring(1),
+          documentKey,
+          externalRefsKey,
+          processedNodes
+        );
+      }
+    }
+    for (const value of Object.values(node)) {
+      traverse(value);
+    }
+  };
+  traverse(referencedValue);
+};
+async function getHash(value) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hashBuffer = await crypto.subtle.digest("SHA-1", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex.slice(0, 7);
+}
+async function bundle(input, config) {
+  const cache = config.cache ?? /* @__PURE__ */ new Map();
+  const resolveInput = async () => {
+    if (typeof input !== "string") {
+      return input;
+    }
+    const result = await resolveContents(input, config.plugins);
+    if (result.ok) {
+      return result.data;
+    }
+    throw "Please provide a valid string value or pass a loader to process the input";
+  };
+  const rawSpecification = await resolveInput();
+  const documentRoot = config.root ?? rawSpecification;
+  const EXTERNAL_KEY = "x-ext";
+  const EXTERNAL_URL_MAPPING = "x-ext-urls";
+  const bundler = async (root, origin = typeof input === "string" ? input : "") => {
+    if (!isObject(root) && !Array.isArray(root)) {
+      return;
+    }
+    if (typeof root === "object" && "$ref" in root && typeof root["$ref"] === "string") {
+      const ref = root["$ref"];
+      if (isLocalRef(ref)) {
+        return;
+      }
+      const [prefix, path2 = ""] = ref.split("#", 2);
+      const resolvedPath = resolveReferencePath(origin, prefix);
+      const hashPath = await getHash(resolvedPath);
+      const seen = cache.has(resolvedPath);
+      if (!seen) {
+        cache.set(resolvedPath, resolveContents(resolvedPath, config.plugins));
+      }
+      const result = await cache.get(resolvedPath);
+      if (result.ok) {
+        if (!seen) {
+          prefixInternalRefRecursive(result.data, [EXTERNAL_KEY, hashPath]);
+          await bundler(result.data, resolvedPath);
+          if (config.urlMap) {
+            setValueAtPath(documentRoot, `/${EXTERNAL_URL_MAPPING}/${escapeJsonPointer(resolvedPath)}`, hashPath);
+          }
+        }
+        if (config.treeShake === true) {
+          resolveAndCopyReferences(
+            documentRoot,
+            { [EXTERNAL_KEY]: { [hashPath]: result.data } },
+            prefixInternalRef(`#${path2}`, [EXTERNAL_KEY, hashPath]).substring(1),
+            EXTERNAL_KEY,
+            hashPath
+          );
+        } else if (!seen) {
+          setValueAtPath(documentRoot, `/${EXTERNAL_KEY}/${hashPath}`, result.data);
+        }
+        root.$ref = prefixInternalRef(`#${path2}`, [EXTERNAL_KEY, hashPath]);
+        return;
+      }
+      return console.warn(
+        `Failed to resolve external reference "${prefix}". The reference may be invalid, inaccessible, or missing a loader for this type of reference.`
+      );
+    }
+    await Promise.all(
+      Object.entries(root).map(async ([key, value]) => {
+        if (key === EXTERNAL_KEY) {
+          return;
+        }
+        await bundler(value, origin);
+      })
+    );
+  };
+  await bundler(rawSpecification);
+  return rawSpecification;
+}
+export {
+  bundle,
+  getHash,
+  getNestedValue,
+  isLocalRef,
+  isRemoteUrl,
+  prefixInternalRef,
+  prefixInternalRefRecursive,
+  setValueAtPath
+};
+//# sourceMappingURL=bundle.js.map

package/dist/utils/bundle/bundle.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/bundle/bundle.ts"],
+  "sourcesContent": ["import type { UnknownObject } from '@/types'\nimport { escapeJsonPointer } from '@/utils/escape-json-pointer'\nimport path from '@/polyfills/path'\nimport { getSegmentsFromPath } from '@/utils/get-segments-from-path'\nimport { isObject } from '@/utils/is-object'\n\n/**\n * Checks if a string is a remote URL (starts with http:// or https://)\n * @param value - The URL string to check\n * @returns true if the string is a remote URL, false otherwise\n * @example\n * ```ts\n * isRemoteUrl('https://example.com/schema.json') // true\n * isRemoteUrl('http://api.example.com/schemas/user.json') // true\n * isRemoteUrl('#/components/schemas/User') // false\n * isRemoteUrl('./local-schema.json') // false\n * ```\n */\nexport function isRemoteUrl(value: string): boolean {\n  return value.startsWith('http://') || value.startsWith('https://')\n}\n\n/**\n * Checks if a string is a local reference (starts with #)\n * @param value - The reference string to check\n * @returns true if the string is a local reference, false otherwise\n * @example\n * ```ts\n * isLocalRef('#/components/schemas/User') // true\n * isLocalRef('https://example.com/schema.json') // false\n * isLocalRef('./local-schema.json') // false\n * ```\n */\nexport function isLocalRef(value: string): boolean {\n  return value.startsWith('#')\n}\n\nexport type ResolveResult = { ok: true; data: unknown } | { ok: false }\n\n/**\n * Resolves a string by finding and executing the appropriate plugin.\n * @param value - The string to resolve (URL, file path, etc)\n * @param plugins - Array of plugins that can handle different types of strings\n * @returns A promise that resolves to either the content or an error result\n * @example\n * // Using a URL plugin\n * await resolveContents('https://example.com/schema.json', [urlPlugin])\n * // Using a file plugin\n * await resolveContents('./schemas/user.json', [filePlugin])\n * // No matching plugin returns { ok: false }\n * await resolveContents('#/components/schemas/User', [urlPlugin, filePlugin])\n */\nasync function resolveContents(value: string, plugins: Plugin[]): Promise<ResolveResult> {\n  const plugin = plugins.find((p) => p.validate(value))\n\n  if (plugin) {\n    return plugin.exec(value)\n  }\n\n  return {\n    ok: false,\n  }\n}\n\n/**\n * Retrieves a nested value from an object using an array of property segments.\n * @param target - The target object to traverse\n * @param segments - Array of property names representing the path to the desired value\n * @returns The value at the specified path, or undefined if the path doesn't exist\n * @example\n * const obj = { foo: { bar: { baz: 42 } } };\n * getNestedValue(obj, ['foo', 'bar', 'baz']); // returns 42\n */\nexport function getNestedValue(target: Record<string, any>, segments: string[]) {\n  return segments.reduce<any>((acc, key) => {\n    if (acc === undefined) {\n      return undefined\n    }\n    return acc[key]\n  }, target)\n}\n\n/**\n * Sets a value at a specified path in an object, creating intermediate objects/arrays as needed.\n * This function traverses the object structure and creates any missing intermediate objects\n * or arrays based on the path segments. If the next segment is a numeric string, it creates\n * an array instead of an object.\n *\n * @param obj - The target object to set the value in\n * @param path - The JSON pointer path where the value should be set\n * @param value - The value to set at the specified path\n * @throws {Error} If attempting to set a value at the root path ('')\n *\n * @example\n * const obj = {}\n * setValueAtPath(obj, '/foo/bar/0', 'value')\n * // Result:\n * // {\n * //   foo: {\n * //     bar: ['value']\n * //   }\n * // }\n *\n * @example\n * const obj = { existing: { path: 'old' } }\n * setValueAtPath(obj, '/existing/path', 'new')\n * // Result:\n * // {\n * //   existing: {\n * //     path: 'new'\n * //   }\n * // }\n */\nexport function setValueAtPath(obj: any, path: string, value: any): void {\n  if (path === '') {\n    throw new Error(\"Cannot set value at root ('') pointer\")\n  }\n\n  const parts = getSegmentsFromPath(path)\n\n  let current = obj\n\n  for (let i = 0; i < parts.length; i++) {\n    const key = parts[i]\n    const isLast = i === parts.length - 1\n\n    const nextKey = parts[i + 1]\n    const shouldBeArray = /^\\d+$/.test(nextKey ?? '')\n\n    if (isLast) {\n      current[key] = value\n    } else {\n      if (!(key in current) || typeof current[key] !== 'object') {\n        current[key] = shouldBeArray ? [] : {}\n      }\n      current = current[key]\n    }\n  }\n}\n\n/**\n * Resolves a reference path by combining a base path with a relative path.\n * Handles both remote URLs and local file paths.\n *\n * @param base - The base path (can be a URL or local file path)\n * @param relativePath - The relative path to resolve against the base\n * @returns The resolved absolute path\n * @example\n * // Resolve remote URL\n * resolveReferencePath('https://example.com/api/schema.json', 'user.json')\n * // Returns: 'https://example.com/api/user.json'\n *\n * // Resolve local path\n * resolveReferencePath('/path/to/schema.json', 'user.json')\n * // Returns: '/path/to/user.json'\n */\nfunction resolveReferencePath(base: string, relativePath: string) {\n  if (isRemoteUrl(relativePath)) {\n    return relativePath\n  }\n\n  if (isRemoteUrl(base)) {\n    const url = new URL(base)\n\n    const mergedPath = path.join(path.dirname(url.pathname), relativePath)\n    return new URL(mergedPath, base).toString()\n  }\n\n  return path.join(path.dirname(base), relativePath)\n}\n\n/**\n * Prefixes an internal JSON reference with a given path prefix.\n * Takes a local reference (starting with #) and prepends the provided prefix segments.\n *\n * @param input - The internal reference string to prefix (must start with #)\n * @param prefix - Array of path segments to prepend to the reference\n * @returns The prefixed reference string\n * @throws Error if input is not a local reference\n * @example\n * prefixInternalRef('#/components/schemas/User', ['definitions'])\n * // Returns: '#/definitions/components/schemas/User'\n */\nexport function prefixInternalRef(input: string, prefix: string[]) {\n  if (!isLocalRef(input)) {\n    throw 'Please provide an internal ref'\n  }\n\n  return `#/${prefix.map(escapeJsonPointer).join('/')}${input.substring(1)}`\n}\n\n/**\n * Updates internal references in an object by adding a prefix to their paths.\n * Recursively traverses the input object and modifies any local $ref references\n * by prepending the given prefix to their paths. This is used when embedding external\n * documents to maintain correct reference paths relative to the main document.\n *\n * @param input - The object to update references in\n * @param prefix - Array of path segments to prepend to internal reference paths\n * @returns void\n * @example\n * ```ts\n * const input = {\n *   foo: {\n *     $ref: '#/components/schemas/User'\n *   }\n * }\n * prefixInternalRefRecursive(input, ['definitions'])\n * // Result:\n * // {\n * //   foo: {\n * //     $ref: '#/definitions/components/schemas/User'\n * //   }\n * // }\n * ```\n */\nexport function prefixInternalRefRecursive(input: unknown, prefix: string[]) {\n  if (!isObject(input)) {\n    return\n  }\n\n  Object.values(input).forEach((el) => prefixInternalRefRecursive(el, prefix))\n\n  if (typeof input === 'object' && '$ref' in input && typeof input['$ref'] === 'string') {\n    const ref = input['$ref']\n\n    if (!isLocalRef(ref)) {\n      return\n    }\n\n    return (input['$ref'] = prefixInternalRef(ref, prefix))\n  }\n}\n\n/**\n * Resolves and copies referenced values from a source document to a target document.\n * This function traverses the document and copies referenced values to the target document,\n * while tracking processed references to avoid duplicates. It only processes references\n * that belong to the same external document.\n *\n * @param targetDocument - The document to copy referenced values to\n * @param sourceDocument - The source document containing the references\n * @param referencePath - The JSON pointer path to the reference\n * @param externalRefsKey - The key used for external references (e.g. 'x-ext')\n * @param documentKey - The key identifying the external document\n * @param processedNodes - Set of already processed nodes to prevent duplicates\n * @example\n * ```ts\n * const source = {\n *   components: {\n *     schemas: {\n *       User: {\n *         $ref: '#/x-ext/users~1schema/definitions/Person'\n *       }\n *     }\n *   }\n * }\n *\n * const target = {}\n * resolveAndCopyReferences(\n *   target,\n *   source,\n *   '/components/schemas/User',\n *   'x-ext',\n *   'users/schema'\n * )\n * // Result: target will contain the User schema with resolved references\n * ```\n */\nconst resolveAndCopyReferences = (\n  targetDocument: unknown,\n  sourceDocument: unknown,\n  referencePath: string,\n  externalRefsKey: string,\n  documentKey: string,\n  processedNodes = new Set(),\n) => {\n  const referencedValue = getNestedValue(sourceDocument, getSegmentsFromPath(referencePath))\n\n  if (processedNodes.has(referencedValue)) {\n    return\n  }\n  processedNodes.add(referencedValue)\n\n  setValueAtPath(targetDocument, referencePath, referencedValue)\n\n  // Do the same for each local ref\n  const traverse = (node: unknown) => {\n    if (!node || typeof node !== 'object') {\n      return\n    }\n\n    if ('$ref' in node && typeof node['$ref'] === 'string') {\n      // We only process references from the same external document because:\n      // 1. Other documents will be handled in separate recursive branches\n      // 2. The source document only contains the current document's content\n      // This prevents undefined behavior and maintains proper document boundaries\n      if (node['$ref'].startsWith(`#/${externalRefsKey}/${escapeJsonPointer(documentKey)}`)) {\n        resolveAndCopyReferences(\n          targetDocument,\n          sourceDocument,\n          node['$ref'].substring(1),\n          documentKey,\n          externalRefsKey,\n          processedNodes,\n        )\n      }\n    }\n\n    for (const value of Object.values(node)) {\n      traverse(value)\n    }\n  }\n\n  traverse(referencedValue)\n}\n\n/**\n * Generates a short SHA-1 hash from a string value.\n * This function is used to create unique identifiers for external references\n * while keeping the hash length manageable. It uses the Web Crypto API to\n * generate a SHA-1 hash and returns the first 7 characters of the hex string.\n *\n * @param value - The string to hash\n * @returns A 7-character hexadecimal hash\n * @example\n * // Returns \"a1b2c3d\"\n * getHash(\"https://example.com/schema.json\")\n */\nexport async function getHash(value: string) {\n  // Convert string to ArrayBuffer\n  const encoder = new TextEncoder()\n  const data = encoder.encode(value)\n\n  // Hash the data\n  const hashBuffer = await crypto.subtle.digest('SHA-1', data)\n\n  // Convert buffer to hex string\n  const hashArray = Array.from(new Uint8Array(hashBuffer))\n  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')\n\n  return hashHex.slice(0, 7)\n}\n\n/**\n * Represents a plugin that handles resolving references from external sources.\n * Plugins are responsible for fetching and processing data from different sources\n * like URLs or the filesystem. Each plugin must implement validation to determine\n * if it can handle a specific reference, and an execution function to perform\n * the actual resolution.\n *\n * @property validate - Determines if this plugin can handle the given reference\n * @property exec - Fetches and processes the reference, returning the resolved data\n */\nexport type Plugin = {\n  // Determines if this plugin can handle the given reference value\n  validate: (value: string) => boolean\n  // Fetches and processes the reference, returning the resolved data\n  exec: (value: string) => Promise<ResolveResult>\n}\n\ntype Config = {\n  // Array of plugins that handle resolving references from different sources (URLs, files, etc.)\n  plugins: Plugin[]\n  // Optional root object that serves as the base document when bundling a subpart of the document\n  // This allows resolving references relative to the root document's location\n  root?: UnknownObject\n  // Optional cache to store promises of resolved references to avoid duplicate fetches/reads\n  cache?: Map<string, Promise<ResolveResult>>\n  // Enable tree shaking, which removes unused references from the final bundle\n  treeShake: boolean\n  // Optional flag to generate a URL map that tracks the original source URLs of bundled references\n  urlMap?: boolean\n}\n\n/**\n * Bundles an OpenAPI specification by resolving all external references.\n * This function traverses the input object recursively and embeds external $ref\n * references into an x-ext section. External references can be URLs or local files.\n * The original $refs are updated to point to their embedded content in the x-ext section.\n * If the input is an object, it will be modified in place by adding an x-ext\n * property to store resolved external references.\n *\n * @param input - The OpenAPI specification object or string to bundle. If a string is provided,\n *                it should be a URL or file path that points to an OpenAPI specification.\n *                The string will be resolved using the provided plugins before bundling.\n * @param config - Configuration object containing plugins for resolving references\n * @returns A promise that resolves to the bundled specification with all references embedded\n * @example\n * // Example with object input\n * const spec = {\n *   paths: {\n *     '/users': {\n *       $ref: 'https://example.com/schemas/users.yaml'\n *     }\n *   }\n * }\n *\n * const bundled = await bundle(spec, { plugins: [fetchUrls()] })\n * // Result:\n * // {\n * //   paths: {\n * //     '/users': {\n * //       $ref: '#/x-ext/https~1~1example.com~1schemas~1users.yaml'\n * //     }\n * //   },\n * //   'x-ext': {\n * //     'https~1~1example.com~1schemas~1users.yaml': {\n * //       // Resolved content from users.yaml\n * //     }\n * //   }\n * // }\n *\n * // Example with URL input\n * const bundledFromUrl = await bundle('https://example.com/openapi.yaml', { plugins: [fetchUrls()] })\n * // The function will first fetch the OpenAPI spec from the URL,\n * // then bundle all its external references into the x-ext section\n */\nexport async function bundle(input: UnknownObject | string, config: Config) {\n  // Cache for storing promises of resolved external references (URLs and local files)\n  // to avoid duplicate fetches/reads of the same resource\n  const cache = config.cache ?? new Map<string, Promise<ResolveResult>>()\n\n  /**\n   * Resolves the input value by either returning it directly if it's not a string,\n   * or attempting to resolve it using the provided plugins if it is a string.\n   * @returns The resolved input data or throws an error if resolution fails\n   */\n  const resolveInput = async () => {\n    if (typeof input !== 'string') {\n      return input\n    }\n    const result = await resolveContents(input, config.plugins)\n\n    if (result.ok) {\n      return result.data\n    }\n\n    throw 'Please provide a valid string value or pass a loader to process the input'\n  }\n\n  const rawSpecification = await resolveInput()\n\n  // Document root used to write all external documents\n  // We need this when we want to do a partial bundle of a document\n  const documentRoot = config.root ?? rawSpecification\n\n  // Custom OpenAPI extension key used to store external references\n  // This key will contain all bundled external documents\n  const EXTERNAL_KEY = 'x-ext'\n\n  // Custom OpenAPI extension key used to maintain a mapping between\n  // original URLs and their corresponding hashed keys in x-ext\n  const EXTERNAL_URL_MAPPING = 'x-ext-urls'\n\n  const bundler = async (root: any, origin: string = typeof input === 'string' ? input : '') => {\n    if (!isObject(root) && !Array.isArray(root)) {\n      return\n    }\n\n    if (typeof root === 'object' && '$ref' in root && typeof root['$ref'] === 'string') {\n      const ref = root['$ref']\n\n      if (isLocalRef(ref)) {\n        return\n      }\n\n      const [prefix, path = ''] = ref.split('#', 2)\n\n      // Combine the current origin with the new path to resolve relative references\n      // correctly within the context of the external file being processed\n      const resolvedPath = resolveReferencePath(origin, prefix)\n      const hashPath = await getHash(resolvedPath)\n\n      const seen = cache.has(resolvedPath)\n\n      if (!seen) {\n        cache.set(resolvedPath, resolveContents(resolvedPath, config.plugins))\n      }\n\n      // Resolve the remote document\n      const result = await cache.get(resolvedPath)\n\n      if (result.ok) {\n        // Process the result only once to avoid duplicate processing and prevent multiple prefixing\n        // of internal references, which would corrupt the reference paths\n        if (!seen) {\n          // Update internal references in the resolved document to use the correct base path.\n          // When we embed external documents, their internal references need to be updated to\n          // maintain the correct path context relative to the main document. This is crucial\n          // because internal references in the external document are relative to its original\n          // location, but when embedded, they need to be relative to their new location in\n          // the main document's x-ext section. Without this update, internal references\n          // would point to incorrect locations and break the document structure.\n          prefixInternalRefRecursive(result.data, [EXTERNAL_KEY, hashPath])\n\n          // Recursively process the resolved content\n          // to handle any nested references it may contain. We pass the resolvedPath as the new origin\n          // to ensure any relative references within this content are resolved correctly relative to\n          // their new location in the bundled document.\n          await bundler(result.data, resolvedPath)\n\n          // Store the mapping between original URLs and their hashed keys in x-ext-urls\n          // This allows tracking which external URLs were bundled and their corresponding locations\n          if (config.urlMap) {\n            setValueAtPath(documentRoot, `/${EXTERNAL_URL_MAPPING}/${escapeJsonPointer(resolvedPath)}`, hashPath)\n          }\n        }\n\n        if (config.treeShake === true) {\n          // Store only the subtree that is actually used\n          // This optimizes the bundle size by only including the parts of the external document\n          // that are referenced, rather than the entire document\n          resolveAndCopyReferences(\n            documentRoot,\n            { [EXTERNAL_KEY]: { [hashPath]: result.data } },\n            prefixInternalRef(`#${path}`, [EXTERNAL_KEY, hashPath]).substring(1),\n            EXTERNAL_KEY,\n            hashPath,\n          )\n        } else if (!seen) {\n          // Store the external document in the main document's x-ext key\n          // When tree shaking is disabled, we include the entire external document\n          // This preserves all content and is faster since we don't need to analyze and copy\n          // specific parts. This approach is ideal when storing the result in memory\n          // as it avoids the overhead of tree shaking operations\n          setValueAtPath(documentRoot, `/${EXTERNAL_KEY}/${hashPath}`, result.data)\n        }\n\n        // Update the $ref to point to the embedded document in x-ext\n        // This is necessary because we need to maintain the correct path context\n        // for the embedded document while preserving its internal structure\n        root.$ref = prefixInternalRef(`#${path}`, [EXTERNAL_KEY, hashPath])\n        return\n      }\n\n      return console.warn(\n        `Failed to resolve external reference \"${prefix}\". The reference may be invalid, inaccessible, or missing a loader for this type of reference.`,\n      )\n    }\n\n    // Recursively process all child objects to handle nested references\n    // This ensures we catch and resolve any $refs that exist deeper in the object tree\n    // We skip EXTERNAL_KEY to avoid processing already bundled content\n    await Promise.all(\n      Object.entries(root).map(async ([key, value]) => {\n        if (key === EXTERNAL_KEY) {\n          return\n        }\n\n        await bundler(value, origin)\n      }),\n    )\n  }\n\n  await bundler(rawSpecification)\n  return rawSpecification\n}\n"],
+  "mappings": "AACA,SAAS,yBAAyB;AAClC,OAAO,UAAU;AACjB,SAAS,2BAA2B;AACpC,SAAS,gBAAgB;AAclB,SAAS,YAAY,OAAwB;AAClD,SAAO,MAAM,WAAW,SAAS,KAAK,MAAM,WAAW,UAAU;AACnE;AAaO,SAAS,WAAW,OAAwB;AACjD,SAAO,MAAM,WAAW,GAAG;AAC7B;AAiBA,eAAe,gBAAgB,OAAe,SAA2C;AACvF,QAAM,SAAS,QAAQ,KAAK,CAAC,MAAM,EAAE,SAAS,KAAK,CAAC;AAEpD,MAAI,QAAQ;AACV,WAAO,OAAO,KAAK,KAAK;AAAA,EAC1B;AAEA,SAAO;AAAA,IACL,IAAI;AAAA,EACN;AACF;AAWO,SAAS,eAAe,QAA6B,UAAoB;AAC9E,SAAO,SAAS,OAAY,CAAC,KAAK,QAAQ;AACxC,QAAI,QAAQ,QAAW;AACrB,aAAO;AAAA,IACT;AACA,WAAO,IAAI,GAAG;AAAA,EAChB,GAAG,MAAM;AACX;AAiCO,SAAS,eAAe,KAAUA,OAAc,OAAkB;AACvE,MAAIA,UAAS,IAAI;AACf,UAAM,IAAI,MAAM,uCAAuC;AAAA,EACzD;AAEA,QAAM,QAAQ,oBAAoBA,KAAI;AAEtC,MAAI,UAAU;AAEd,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,UAAM,MAAM,MAAM,CAAC;AACnB,UAAM,SAAS,MAAM,MAAM,SAAS;AAEpC,UAAM,UAAU,MAAM,IAAI,CAAC;AAC3B,UAAM,gBAAgB,QAAQ,KAAK,WAAW,EAAE;AAEhD,QAAI,QAAQ;AACV,cAAQ,GAAG,IAAI;AAAA,IACjB,OAAO;AACL,UAAI,EAAE,OAAO,YAAY,OAAO,QAAQ,GAAG,MAAM,UAAU;AACzD,gBAAQ,GAAG,IAAI,gBAAgB,CAAC,IAAI,CAAC;AAAA,MACvC;AACA,gBAAU,QAAQ,GAAG;AAAA,IACvB;AAAA,EACF;AACF;AAkBA,SAAS,qBAAqB,MAAc,cAAsB;AAChE,MAAI,YAAY,YAAY,GAAG;AAC7B,WAAO;AAAA,EACT;AAEA,MAAI,YAAY,IAAI,GAAG;AACrB,UAAM,MAAM,IAAI,IAAI,IAAI;AAExB,UAAM,aAAa,KAAK,KAAK,KAAK,QAAQ,IAAI,QAAQ,GAAG,YAAY;AACrE,WAAO,IAAI,IAAI,YAAY,IAAI,EAAE,SAAS;AAAA,EAC5C;AAEA,SAAO,KAAK,KAAK,KAAK,QAAQ,IAAI,GAAG,YAAY;AACnD;AAcO,SAAS,kBAAkB,OAAe,QAAkB;AACjE,MAAI,CAAC,WAAW,KAAK,GAAG;AACtB,UAAM;AAAA,EACR;AAEA,SAAO,KAAK,OAAO,IAAI,iBAAiB,EAAE,KAAK,GAAG,CAAC,GAAG,MAAM,UAAU,CAAC,CAAC;AAC1E;AA2BO,SAAS,2BAA2B,OAAgB,QAAkB;AAC3E,MAAI,CAAC,SAAS,KAAK,GAAG;AACpB;AAAA,EACF;AAEA,SAAO,OAAO,KAAK,EAAE,QAAQ,CAAC,OAAO,2BAA2B,IAAI,MAAM,CAAC;AAE3E,MAAI,OAAO,UAAU,YAAY,UAAU,SAAS,OAAO,MAAM,MAAM,MAAM,UAAU;AACrF,UAAM,MAAM,MAAM,MAAM;AAExB,QAAI,CAAC,WAAW,GAAG,GAAG;AACpB;AAAA,IACF;AAEA,WAAQ,MAAM,MAAM,IAAI,kBAAkB,KAAK,MAAM;AAAA,EACvD;AACF;AAqCA,MAAM,2BAA2B,CAC/B,gBACA,gBACA,eACA,iBACA,aACA,iBAAiB,oBAAI,IAAI,MACtB;AACH,QAAM,kBAAkB,eAAe,gBAAgB,oBAAoB,aAAa,CAAC;AAEzF,MAAI,eAAe,IAAI,eAAe,GAAG;AACvC;AAAA,EACF;AACA,iBAAe,IAAI,eAAe;AAElC,iBAAe,gBAAgB,eAAe,eAAe;AAG7D,QAAM,WAAW,CAAC,SAAkB;AAClC,QAAI,CAAC,QAAQ,OAAO,SAAS,UAAU;AACrC;AAAA,IACF;AAEA,QAAI,UAAU,QAAQ,OAAO,KAAK,MAAM,MAAM,UAAU;AAKtD,UAAI,KAAK,MAAM,EAAE,WAAW,KAAK,eAAe,IAAI,kBAAkB,WAAW,CAAC,EAAE,GAAG;AACrF;AAAA,UACE;AAAA,UACA;AAAA,UACA,KAAK,MAAM,EAAE,UAAU,CAAC;AAAA,UACxB;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,eAAW,SAAS,OAAO,OAAO,IAAI,GAAG;AACvC,eAAS,KAAK;AAAA,IAChB;AAAA,EACF;AAEA,WAAS,eAAe;AAC1B;AAcA,eAAsB,QAAQ,OAAe;AAE3C,QAAM,UAAU,IAAI,YAAY;AAChC,QAAM,OAAO,QAAQ,OAAO,KAAK;AAGjC,QAAM,aAAa,MAAM,OAAO,OAAO,OAAO,SAAS,IAAI;AAG3D,QAAM,YAAY,MAAM,KAAK,IAAI,WAAW,UAAU,CAAC;AACvD,QAAM,UAAU,UAAU,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAE7E,SAAO,QAAQ,MAAM,GAAG,CAAC;AAC3B;AA4EA,eAAsB,OAAO,OAA+B,QAAgB;AAG1E,QAAM,QAAQ,OAAO,SAAS,oBAAI,IAAoC;AAOtE,QAAM,eAAe,YAAY;AAC/B,QAAI,OAAO,UAAU,UAAU;AAC7B,aAAO;AAAA,IACT;AACA,UAAM,SAAS,MAAM,gBAAgB,OAAO,OAAO,OAAO;AAE1D,QAAI,OAAO,IAAI;AACb,aAAO,OAAO;AAAA,IAChB;AAEA,UAAM;AAAA,EACR;AAEA,QAAM,mBAAmB,MAAM,aAAa;AAI5C,QAAM,eAAe,OAAO,QAAQ;AAIpC,QAAM,eAAe;AAIrB,QAAM,uBAAuB;AAE7B,QAAM,UAAU,OAAO,MAAW,SAAiB,OAAO,UAAU,WAAW,QAAQ,OAAO;AAC5F,QAAI,CAAC,SAAS,IAAI,KAAK,CAAC,MAAM,QAAQ,IAAI,GAAG;AAC3C;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,YAAY,UAAU,QAAQ,OAAO,KAAK,MAAM,MAAM,UAAU;AAClF,YAAM,MAAM,KAAK,MAAM;AAEvB,UAAI,WAAW,GAAG,GAAG;AACnB;AAAA,MACF;AAEA,YAAM,CAAC,QAAQA,QAAO,EAAE,IAAI,IAAI,MAAM,KAAK,CAAC;AAI5C,YAAM,eAAe,qBAAqB,QAAQ,MAAM;AACxD,YAAM,WAAW,MAAM,QAAQ,YAAY;AAE3C,YAAM,OAAO,MAAM,IAAI,YAAY;AAEnC,UAAI,CAAC,MAAM;AACT,cAAM,IAAI,cAAc,gBAAgB,cAAc,OAAO,OAAO,CAAC;AAAA,MACvE;AAGA,YAAM,SAAS,MAAM,MAAM,IAAI,YAAY;AAE3C,UAAI,OAAO,IAAI;AAGb,YAAI,CAAC,MAAM;AAQT,qCAA2B,OAAO,MAAM,CAAC,cAAc,QAAQ,CAAC;AAMhE,gBAAM,QAAQ,OAAO,MAAM,YAAY;AAIvC,cAAI,OAAO,QAAQ;AACjB,2BAAe,cAAc,IAAI,oBAAoB,IAAI,kBAAkB,YAAY,CAAC,IAAI,QAAQ;AAAA,UACtG;AAAA,QACF;AAEA,YAAI,OAAO,cAAc,MAAM;AAI7B;AAAA,YACE;AAAA,YACA,EAAE,CAAC,YAAY,GAAG,EAAE,CAAC,QAAQ,GAAG,OAAO,KAAK,EAAE;AAAA,YAC9C,kBAAkB,IAAIA,KAAI,IAAI,CAAC,cAAc,QAAQ,CAAC,EAAE,UAAU,CAAC;AAAA,YACnE;AAAA,YACA;AAAA,UACF;AAAA,QACF,WAAW,CAAC,MAAM;AAMhB,yBAAe,cAAc,IAAI,YAAY,IAAI,QAAQ,IAAI,OAAO,IAAI;AAAA,QAC1E;AAKA,aAAK,OAAO,kBAAkB,IAAIA,KAAI,IAAI,CAAC,cAAc,QAAQ,CAAC;AAClE;AAAA,MACF;AAEA,aAAO,QAAQ;AAAA,QACb,yCAAyC,MAAM;AAAA,MACjD;AAAA,IACF;AAKA,UAAM,QAAQ;AAAA,MACZ,OAAO,QAAQ,IAAI,EAAE,IAAI,OAAO,CAAC,KAAK,KAAK,MAAM;AAC/C,YAAI,QAAQ,cAAc;AACxB;AAAA,QACF;AAEA,cAAM,QAAQ,OAAO,MAAM;AAAA,MAC7B,CAAC;AAAA,IACH;AAAA,EACF;AAEA,QAAM,QAAQ,gBAAgB;AAC9B,SAAO;AACT;",
+  "names": ["path"]
+}

package/dist/utils/bundle/create-limiter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates a function that limits the number of concurrent executions of async functions.
+ *
+ * @param maxConcurrent - Maximum number of concurrent executions allowed
+ * @returns A function that wraps async functions to limit their concurrent execution
+ *
+ * @example
+ * ```ts
+ * const limiter = createLimiter(2) // Allow max 2 concurrent executions
+ *
+ * // These will run with max 2 at a time
+ * const results = await Promise.all([
+ *   limiter(() => fetch('/api/1')),
+ *   limiter(() => fetch('/api/2')),
+ *   limiter(() => fetch('/api/3')),
+ *   limiter(() => fetch('/api/4'))
+ * ])
+ * ```
+ */
+export declare function createLimiter(maxConcurrent: number): <T>(fn: () => Promise<T>) => Promise<T>;
+//# sourceMappingURL=create-limiter.d.ts.map

package/dist/utils/bundle/create-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-limiter.d.ts","sourceRoot":"","sources":["../../../src/utils/bundle/create-limiter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,IAgB9B,CAAC,MAAM,MAAM,OAAO,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,CAAC,CAgBxD"}

package/dist/utils/bundle/create-limiter.js

@@ -0,0 +1,31 @@
+function createLimiter(maxConcurrent) {
+  let activeCount = 0;
+  const queue = [];
+  const next = () => {
+    if (queue.length === 0 || activeCount >= maxConcurrent) {
+      return;
+    }
+    const resolve = queue.shift();
+    if (resolve) {
+      resolve();
+    }
+  };
+  const run = async (fn) => {
+    if (activeCount >= maxConcurrent) {
+      await new Promise((resolve) => queue.push(resolve));
+    }
+    activeCount++;
+    try {
+      const result = await fn();
+      return result;
+    } finally {
+      activeCount--;
+      next();
+    }
+  };
+  return run;
+}
+export {
+  createLimiter
+};
+//# sourceMappingURL=create-limiter.js.map

package/dist/utils/bundle/create-limiter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/bundle/create-limiter.ts"],
+  "sourcesContent": ["/**\n * Creates a function that limits the number of concurrent executions of async functions.\n *\n * @param maxConcurrent - Maximum number of concurrent executions allowed\n * @returns A function that wraps async functions to limit their concurrent execution\n *\n * @example\n * ```ts\n * const limiter = createLimiter(2) // Allow max 2 concurrent executions\n *\n * // These will run with max 2 at a time\n * const results = await Promise.all([\n *   limiter(() => fetch('/api/1')),\n *   limiter(() => fetch('/api/2')),\n *   limiter(() => fetch('/api/3')),\n *   limiter(() => fetch('/api/4'))\n * ])\n * ```\n */\nexport function createLimiter(maxConcurrent: number) {\n  let activeCount = 0\n  const queue: (() => void)[] = []\n\n  const next = () => {\n    if (queue.length === 0 || activeCount >= maxConcurrent) {\n      return\n    }\n\n    const resolve = queue.shift()\n\n    if (resolve) {\n      resolve()\n    }\n  }\n\n  const run = async <T>(fn: () => Promise<T>): Promise<T> => {\n    if (activeCount >= maxConcurrent) {\n      await new Promise<void>((resolve) => queue.push(resolve))\n    }\n\n    activeCount++\n    try {\n      const result = await fn()\n      return result\n    } finally {\n      activeCount--\n      next()\n    }\n  }\n\n  return run\n}\n"],
+  "mappings": "AAmBO,SAAS,cAAc,eAAuB;AACnD,MAAI,cAAc;AAClB,QAAM,QAAwB,CAAC;AAE/B,QAAM,OAAO,MAAM;AACjB,QAAI,MAAM,WAAW,KAAK,eAAe,eAAe;AACtD;AAAA,IACF;AAEA,UAAM,UAAU,MAAM,MAAM;AAE5B,QAAI,SAAS;AACX,cAAQ;AAAA,IACV;AAAA,EACF;AAEA,QAAM,MAAM,OAAU,OAAqC;AACzD,QAAI,eAAe,eAAe;AAChC,YAAM,IAAI,QAAc,CAAC,YAAY,MAAM,KAAK,OAAO,CAAC;AAAA,IAC1D;AAEA;AACA,QAAI;AACF,YAAM,SAAS,MAAM,GAAG;AACxB,aAAO;AAAA,IACT,UAAE;AACA;AACA,WAAK;AAAA,IACP;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/utils/bundle/index.d.ts

@@ -0,0 +1,4 @@
+export { bundle } from './bundle.js';
+export { fetchUrls } from './plugins/fetch-urls.js';
+export { readFiles } from './plugins/read-files.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/bundle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/bundle/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/utils/bundle/index.js

@@ -0,0 +1,9 @@
+import { bundle } from "./bundle.js";
+import { fetchUrls } from "./plugins/fetch-urls.js";
+import { readFiles } from "./plugins/read-files.js";
+export {
+  bundle,
+  fetchUrls,
+  readFiles
+};
+//# sourceMappingURL=index.js.map

package/dist/utils/bundle/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/bundle/index.ts"],
+  "sourcesContent": ["// biome-ignore lint/performance/noBarrelFile: This is the interface we expose for the bundler\nexport { bundle } from './bundle'\nexport { fetchUrls } from './plugins/fetch-urls'\nexport { readFiles } from './plugins/read-files'\n"],
+  "mappings": "AACA,SAAS,cAAc;AACvB,SAAS,iBAAiB;AAC1B,SAAS,iBAAiB;",
+  "names": []
+}

package/dist/utils/bundle/plugins/fetch-urls.d.ts

@@ -0,0 +1,38 @@
+import { type Plugin, type ResolveResult } from '../../../utils/bundle/bundle.js';
+type FetchConfig = Partial<{
+    headers: {
+        headers: HeadersInit;
+        domains: string[];
+    }[];
+}>;
+/**
+ * Fetches and normalizes data from a remote URL
+ * @param url - The URL to fetch data from
+ * @returns A promise that resolves to either the normalized data or an error result
+ * @example
+ * ```ts
+ * const result = await fetchUrl('https://api.example.com/data.json')
+ * if (result.ok) {
+ *   console.log(result.data) // The normalized data
+ * } else {
+ *   console.log('Failed to fetch data')
+ * }
+ * ```
+ */
+export declare function fetchUrl(url: string, limiter: <T>(fn: () => Promise<T>) => Promise<T>, config?: FetchConfig): Promise<ResolveResult>;
+/**
+ * Creates a plugin for handling remote URL references.
+ * This plugin validates and fetches data from HTTP/HTTPS URLs.
+ *
+ * @returns A plugin object with validate and exec functions
+ * @example
+ * const urlPlugin = fetchUrls()
+ * if (urlPlugin.validate('https://example.com/schema.json')) {
+ *   const result = await urlPlugin.exec('https://example.com/schema.json')
+ * }
+ */
+export declare function fetchUrls(config?: FetchConfig & Partial<{
+    limit: number | null;
+}>): Plugin;
+export {};
+//# sourceMappingURL=fetch-urls.d.ts.map

package/dist/utils/bundle/plugins/fetch-urls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-urls.d.ts","sourceRoot":"","sources":["../../../../src/utils/bundle/plugins/fetch-urls.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAGpF,KAAK,WAAW,GAAG,OAAO,CAAC;IACzB,OAAO,EAAE;QAAE,OAAO,EAAE,WAAW,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAA;CACvD,CAAC,CAAA;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,QAAQ,CAC5B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAChD,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,aAAa,CAAC,CA8BxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,GAAG,MAAM,CAQ1F"}

package/dist/utils/bundle/plugins/fetch-urls.js

@@ -0,0 +1,40 @@
+import { normalize } from "../../../utils/normalize.js";
+import { isRemoteUrl } from "../../../utils/bundle/bundle.js";
+import { createLimiter } from "../../../utils/bundle/create-limiter.js";
+async function fetchUrl(url, limiter, config) {
+  try {
+    const domain = new URL(url).host;
+    const headers = config?.headers?.find((a) => a.domains.find((d) => d === domain) !== void 0)?.headers;
+    const result = await limiter(
+      () => fetch(url, {
+        headers
+      })
+    );
+    if (result.ok) {
+      const body = await result.text();
+      return {
+        ok: true,
+        data: normalize(body)
+      };
+    }
+    return {
+      ok: false
+    };
+  } catch {
+    return {
+      ok: false
+    };
+  }
+}
+function fetchUrls(config) {
+  const limiter = config?.limit ? createLimiter(config.limit) : (fn) => fn();
+  return {
+    validate: (value) => isRemoteUrl(value),
+    exec: (value) => fetchUrl(value, limiter, config)
+  };
+}
+export {
+  fetchUrl,
+  fetchUrls
+};
+//# sourceMappingURL=fetch-urls.js.map

package/dist/utils/bundle/plugins/fetch-urls.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/utils/bundle/plugins/fetch-urls.ts"],
+  "sourcesContent": ["import { normalize } from '@/utils/normalize'\nimport { isRemoteUrl, type Plugin, type ResolveResult } from '@/utils/bundle/bundle'\nimport { createLimiter } from '@/utils/bundle/create-limiter'\n\ntype FetchConfig = Partial<{\n  headers: { headers: HeadersInit; domains: string[] }[]\n}>\n\n/**\n * Fetches and normalizes data from a remote URL\n * @param url - The URL to fetch data from\n * @returns A promise that resolves to either the normalized data or an error result\n * @example\n * ```ts\n * const result = await fetchUrl('https://api.example.com/data.json')\n * if (result.ok) {\n *   console.log(result.data) // The normalized data\n * } else {\n *   console.log('Failed to fetch data')\n * }\n * ```\n */\nexport async function fetchUrl(\n  url: string,\n  limiter: <T>(fn: () => Promise<T>) => Promise<T>,\n  config?: FetchConfig,\n): Promise<ResolveResult> {\n  try {\n    const domain = new URL(url).host\n\n    // Get the headers that match the domain\n    const headers = config?.headers?.find((a) => a.domains.find((d) => d === domain) !== undefined)?.headers\n\n    const result = await limiter(() =>\n      fetch(url, {\n        headers,\n      }),\n    )\n\n    if (result.ok) {\n      const body = await result.text()\n\n      return {\n        ok: true,\n        data: normalize(body),\n      }\n    }\n\n    return {\n      ok: false,\n    }\n  } catch {\n    return {\n      ok: false,\n    }\n  }\n}\n\n/**\n * Creates a plugin for handling remote URL references.\n * This plugin validates and fetches data from HTTP/HTTPS URLs.\n *\n * @returns A plugin object with validate and exec functions\n * @example\n * const urlPlugin = fetchUrls()\n * if (urlPlugin.validate('https://example.com/schema.json')) {\n *   const result = await urlPlugin.exec('https://example.com/schema.json')\n * }\n */\nexport function fetchUrls(config?: FetchConfig & Partial<{ limit: number | null }>): Plugin {\n  // If there is a limit specified we limit the number of concurrent calls\n  const limiter = config?.limit ? createLimiter(config.limit) : <T>(fn: () => Promise<T>) => fn()\n\n  return {\n    validate: (value) => isRemoteUrl(value),\n    exec: (value) => fetchUrl(value, limiter, config),\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,iBAAiB;AAC1B,SAAS,mBAAoD;AAC7D,SAAS,qBAAqB;AAoB9B,eAAsB,SACpB,KACA,SACA,QACwB;AACxB,MAAI;AACF,UAAM,SAAS,IAAI,IAAI,GAAG,EAAE;AAG5B,UAAM,UAAU,QAAQ,SAAS,KAAK,CAAC,MAAM,EAAE,QAAQ,KAAK,CAAC,MAAM,MAAM,MAAM,MAAM,MAAS,GAAG;AAEjG,UAAM,SAAS,MAAM;AAAA,MAAQ,MAC3B,MAAM,KAAK;AAAA,QACT;AAAA,MACF,CAAC;AAAA,IACH;AAEA,QAAI,OAAO,IAAI;AACb,YAAM,OAAO,MAAM,OAAO,KAAK;AAE/B,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,MAAM,UAAU,IAAI;AAAA,MACtB;AAAA,IACF;AAEA,WAAO;AAAA,MACL,IAAI;AAAA,IACN;AAAA,EACF,QAAQ;AACN,WAAO;AAAA,MACL,IAAI;AAAA,IACN;AAAA,EACF;AACF;AAaO,SAAS,UAAU,QAAkE;AAE1F,QAAM,UAAU,QAAQ,QAAQ,cAAc,OAAO,KAAK,IAAI,CAAI,OAAyB,GAAG;AAE9F,SAAO;AAAA,IACL,UAAU,CAAC,UAAU,YAAY,KAAK;AAAA,IACtC,MAAM,CAAC,UAAU,SAAS,OAAO,SAAS,MAAM;AAAA,EAClD;AACF;",
+  "names": []
+}

package/dist/utils/bundle/plugins/read-files.d.ts

@@ -0,0 +1,29 @@
+import { type Plugin, type ResolveResult } from '../../../utils/bundle/bundle.js';
+/**
+ * Reads and normalizes data from a local file
+ * @param path - The file path to read from
+ * @returns A promise that resolves to either the normalized data or an error result
+ * @example
+ * ```ts
+ * const result = await readFile('./schemas/user.json')
+ * if (result.ok) {
+ *   console.log(result.data) // The normalized data
+ * } else {
+ *   console.log('Failed to read file')
+ * }
+ * ```
+ */
+export declare function readFile(path: string): Promise<ResolveResult>;
+/**
+ * Creates a plugin for handling local file references.
+ * This plugin validates and reads data from local filesystem paths.
+ *
+ * @returns A plugin object with validate and exec functions
+ * @example
+ * const filePlugin = readFiles()
+ * if (filePlugin.validate('./local-schema.json')) {
+ *   const result = await filePlugin.exec('./local-schema.json')
+ * }
+ */
+export declare function readFiles(): Plugin;
+//# sourceMappingURL=read-files.d.ts.map

package/dist/utils/bundle/plugins/read-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-files.d.ts","sourceRoot":"","sources":["../../../../src/utils/bundle/plugins/read-files.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAIpF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAiBnE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAKlC"}

package/dist/utils/bundle/plugins/read-files.js

@@ -0,0 +1,30 @@
+import { normalize } from "../../../utils/normalize.js";
+import { isRemoteUrl } from "../../../utils/bundle/bundle.js";
+const fs = typeof window === "undefined" ? await import("node:fs/promises") : void 0;
+async function readFile(path) {
+  if (fs === void 0) {
+    throw "Can not use readFiles plugin outside of a node environment";
+  }
+  try {
+    const fileContents = await fs.readFile(path, { encoding: "utf-8" });
+    return {
+      ok: true,
+      data: normalize(fileContents)
+    };
+  } catch {
+    return {
+      ok: false
+    };
+  }
+}
+function readFiles() {
+  return {
+    validate: (value) => !isRemoteUrl(value),
+    exec: (value) => readFile(value)
+  };
+}
+export {
+  readFile,
+  readFiles
+};
+//# sourceMappingURL=read-files.js.map

package/dist/utils/bundle/plugins/read-files.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/utils/bundle/plugins/read-files.ts"],
+  "sourcesContent": ["import { normalize } from '@/utils/normalize'\nimport { isRemoteUrl, type Plugin, type ResolveResult } from '@/utils/bundle/bundle'\n\nconst fs = typeof window === 'undefined' ? await import('node:fs/promises') : undefined\n\n/**\n * Reads and normalizes data from a local file\n * @param path - The file path to read from\n * @returns A promise that resolves to either the normalized data or an error result\n * @example\n * ```ts\n * const result = await readFile('./schemas/user.json')\n * if (result.ok) {\n *   console.log(result.data) // The normalized data\n * } else {\n *   console.log('Failed to read file')\n * }\n * ```\n */\nexport async function readFile(path: string): Promise<ResolveResult> {\n  if (fs === undefined) {\n    throw 'Can not use readFiles plugin outside of a node environment'\n  }\n\n  try {\n    const fileContents = await fs.readFile(path, { encoding: 'utf-8' })\n\n    return {\n      ok: true,\n      data: normalize(fileContents),\n    }\n  } catch {\n    return {\n      ok: false,\n    }\n  }\n}\n\n/**\n * Creates a plugin for handling local file references.\n * This plugin validates and reads data from local filesystem paths.\n *\n * @returns A plugin object with validate and exec functions\n * @example\n * const filePlugin = readFiles()\n * if (filePlugin.validate('./local-schema.json')) {\n *   const result = await filePlugin.exec('./local-schema.json')\n * }\n */\nexport function readFiles(): Plugin {\n  return {\n    validate: (value) => !isRemoteUrl(value),\n    exec: (value) => readFile(value),\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,iBAAiB;AAC1B,SAAS,mBAAoD;AAE7D,MAAM,KAAK,OAAO,WAAW,cAAc,MAAM,OAAO,kBAAkB,IAAI;AAgB9E,eAAsB,SAAS,MAAsC;AACnE,MAAI,OAAO,QAAW;AACpB,UAAM;AAAA,EACR;AAEA,MAAI;AACF,UAAM,eAAe,MAAM,GAAG,SAAS,MAAM,EAAE,UAAU,QAAQ,CAAC;AAElE,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,MAAM,UAAU,YAAY;AAAA,IAC9B;AAAA,EACF,QAAQ;AACN,WAAO;AAAA,MACL,IAAI;AAAA,IACN;AAAA,EACF;AACF;AAaO,SAAS,YAAoB;AAClC,SAAO;AAAA,IACL,UAAU,CAAC,UAAU,CAAC,YAAY,KAAK;AAAA,IACvC,MAAM,CAAC,UAAU,SAAS,KAAK;AAAA,EACjC;AACF;",
+  "names": []
+}

package/dist/utils/normalize.js

@@ -12,8 +12,8 @@ function normalize(content) {
       return JSON.parse(content);
     } catch (_error) {
       const hasColon = /^[^:]+:/.test(content);
-      const isMultiLine = content.includes("\n");
-      if (!hasColon || !isMultiLine) {
+      const isJson = content.slice(0, 50).trimStart().startsWith("{");
+      if (!hasColon || isJson) {
         return void 0;
       }
       return parse(content, {

package/dist/utils/normalize.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/utils/normalize.ts"],
-  "sourcesContent": ["import type { UnknownObject } from '@scalar/types/utils'\nimport { parse } from 'yaml'\n\nimport type { Filesystem } from '@/types/index'\nimport { isFilesystem } from './is-filesystem'\n\n/**\n * Normalize the OpenAPI document (YAML, JSON, object) to a JavaScript object.\n *\n * Doesn\u2019t modify the object if it\u2019s a `Filesystem` (multiple files) already.\n */\nexport function normalize(content: string | UnknownObject | Filesystem): UnknownObject | Filesystem {\n  if (content === null) {\n    return undefined\n  }\n\n  if (typeof content === 'string') {\n    if (content.trim() === '') {\n      return undefined\n    }\n\n    try {\n      return JSON.parse(content)\n    } catch (_error) {\n      // Does it look like YAML?\n      const hasColon = /^[^:]+:/.test(content)\n      const isMultiLine = content.includes('\\n')\n\n      if (!hasColon || !isMultiLine) {\n        return undefined\n      }\n\n      return parse(content, {\n        maxAliasCount: 10000,\n      })\n    }\n  }\n\n  if (isFilesystem(content)) {\n    return content\n  }\n\n  return content\n}\n"],
-  "mappings": "AACA,SAAS,aAAa;AAGtB,SAAS,oBAAoB;AAOtB,SAAS,UAAU,SAA0E;AAClG,MAAI,YAAY,MAAM;AACpB,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,YAAY,UAAU;AAC/B,QAAI,QAAQ,KAAK,MAAM,IAAI;AACzB,aAAO;AAAA,IACT;AAEA,QAAI;AACF,aAAO,KAAK,MAAM,OAAO;AAAA,IAC3B,SAAS,QAAQ;AAEf,YAAM,WAAW,UAAU,KAAK,OAAO;AACvC,YAAM,cAAc,QAAQ,SAAS,IAAI;AAEzC,UAAI,CAAC,YAAY,CAAC,aAAa;AAC7B,eAAO;AAAA,MACT;AAEA,aAAO,MAAM,SAAS;AAAA,QACpB,eAAe;AAAA,MACjB,CAAC;AAAA,IACH;AAAA,EACF;AAEA,MAAI,aAAa,OAAO,GAAG;AACzB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
+  "sourcesContent": ["import type { UnknownObject } from '@scalar/types/utils'\nimport { parse } from 'yaml'\n\nimport type { Filesystem } from '@/types/index'\nimport { isFilesystem } from './is-filesystem'\n\n/**\n * Normalize the OpenAPI document (YAML, JSON, object) to a JavaScript object.\n *\n * Doesn\u2019t modify the object if it\u2019s a `Filesystem` (multiple files) already.\n */\nexport function normalize(content: string | UnknownObject | Filesystem): UnknownObject | Filesystem {\n  if (content === null) {\n    return undefined\n  }\n\n  if (typeof content === 'string') {\n    if (content.trim() === '') {\n      return undefined\n    }\n\n    try {\n      return JSON.parse(content)\n    } catch (_error) {\n      // Does it look like YAML?\n      const hasColon = /^[^:]+:/.test(content)\n      const isJson = content.slice(0, 50).trimStart().startsWith('{')\n\n      if (!hasColon || isJson) {\n        return undefined\n      }\n\n      return parse(content, {\n        maxAliasCount: 10000,\n      })\n    }\n  }\n\n  if (isFilesystem(content)) {\n    return content\n  }\n\n  return content\n}\n"],
+  "mappings": "AACA,SAAS,aAAa;AAGtB,SAAS,oBAAoB;AAOtB,SAAS,UAAU,SAA0E;AAClG,MAAI,YAAY,MAAM;AACpB,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,YAAY,UAAU;AAC/B,QAAI,QAAQ,KAAK,MAAM,IAAI;AACzB,aAAO;AAAA,IACT;AAEA,QAAI;AACF,aAAO,KAAK,MAAM,OAAO;AAAA,IAC3B,SAAS,QAAQ;AAEf,YAAM,WAAW,UAAU,KAAK,OAAO;AACvC,YAAM,SAAS,QAAQ,MAAM,GAAG,EAAE,EAAE,UAAU,EAAE,WAAW,GAAG;AAE9D,UAAI,CAAC,YAAY,QAAQ;AACvB,eAAO;AAAA,MACT;AAEA,aAAO,MAAM,SAAS;AAAA,QACpB,eAAe;AAAA,MACjB,CAAC;AAAA,IACH;AAAA,EACF;AAEA,MAAI,aAAa,OAAO,GAAG;AACzB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
   "names": []
 }

package/package.json

@@ -17,7 +17,7 @@
     "parser",
     "typescript"
   ],
-  "version": "0.13.0",
+  "version": "0.14.0",
   "engines": {
     "node": ">=20"
   },
@@ -58,14 +58,14 @@
   "devDependencies": {
     "@apidevtools/swagger-parser": "^10.1.0",
     "@types/node": "^20.17.10",
-    "glob": "^10.3.10",
+    "fastify": "^4.26.2",
     "json-to-ast": "^2.1.0",
     "just-diff": "^6.0.2",
     "tinybench": "^2.8.0",
     "vite": "5.4.19",
     "@scalar/openapi-types": "0.3.1",
-    "@scalar/build-tooling": "0.2.1",
-    "@scalar/types": "0.2.1"
+    "@scalar/types": "0.2.1",
+    "@scalar/build-tooling": "0.2.1"
   },
   "scripts": {
     "build": "scalar-build-esbuild",
@@ -74,7 +74,7 @@
     "lint:fix": "eslint .  --fix",
     "test": "NODE_OPTIONS=--max_old_space_size=8192 vitest",
     "test:prepare": "vite-node scripts/load-files.ts",
-    "test:unit": "vite-node scripts/load-files.ts && vitest",
+    "test:unit": "vitest",
     "types:build": "scalar-types-build",
     "types:check": "scalar-types-check"
   }