@hey-api/json-schema-ref-parser 0.0.1

package/dist/lib/dereference.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ref_js_1 = __importDefault(require("./ref.js"));
+const pointer_js_1 = __importDefault(require("./pointer.js"));
+const ono_1 = require("@jsdevtools/ono");
+const url = __importStar(require("./util/url.js"));
+const errors_1 = require("./util/errors");
+exports.default = dereference;
+/**
+ * Crawls the JSON schema, finds all JSON references, and dereferences them.
+ * This method mutates the JSON schema object, replacing JSON references with their resolved value.
+ *
+ * @param parser
+ * @param options
+ */
+function dereference(parser, options) {
+    const start = Date.now();
+    // console.log('Dereferencing $ref pointers in %s', parser.$refs._root$Ref.path);
+    const dereferenced = crawl(parser.schema, parser.$refs._root$Ref.path, "#", new Set(), new Set(), new Map(), parser.$refs, options, start);
+    parser.$refs.circular = dereferenced.circular;
+    parser.schema = dereferenced.value;
+}
+/**
+ * Recursively crawls the given value, and dereferences any JSON references.
+ *
+ * @param obj - The value to crawl. If it's not an object or array, it will be ignored.
+ * @param path - The full path of `obj`, possibly with a JSON Pointer in the hash
+ * @param pathFromRoot - The path of `obj` from the schema root
+ * @param parents - An array of the parent objects that have already been dereferenced
+ * @param processedObjects - An array of all the objects that have already been processed
+ * @param dereferencedCache - An map of all the dereferenced objects
+ * @param $refs
+ * @param options
+ * @param startTime - The time when the dereferencing started
+ * @returns
+ */
+function crawl(obj, path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime) {
+    let dereferenced;
+    const result = {
+        value: obj,
+        circular: false,
+    };
+    if (options && options.timeoutMs) {
+        if (Date.now() - startTime > options.timeoutMs) {
+            throw new errors_1.TimeoutError(options.timeoutMs);
+        }
+    }
+    const derefOptions = (options.dereference || {});
+    const isExcludedPath = derefOptions.excludedPathMatcher || (() => false);
+    if (derefOptions?.circular === "ignore" || !processedObjects.has(obj)) {
+        if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !isExcludedPath(pathFromRoot)) {
+            parents.add(obj);
+            processedObjects.add(obj);
+            if (ref_js_1.default.isAllowed$Ref(obj)) {
+                dereferenced = dereference$Ref(obj, path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime);
+                result.circular = dereferenced.circular;
+                result.value = dereferenced.value;
+            }
+            else {
+                for (const key of Object.keys(obj)) {
+                    const keyPath = pointer_js_1.default.join(path, key);
+                    const keyPathFromRoot = pointer_js_1.default.join(pathFromRoot, key);
+                    if (isExcludedPath(keyPathFromRoot)) {
+                        continue;
+                    }
+                    const value = obj[key];
+                    let circular = false;
+                    if (ref_js_1.default.isAllowed$Ref(value)) {
+                        dereferenced = dereference$Ref(value, keyPath, keyPathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime);
+                        circular = dereferenced.circular;
+                        // Avoid pointless mutations; breaks frozen objects to no profit
+                        if (obj[key] !== dereferenced.value) {
+                            obj[key] = dereferenced.value;
+                            derefOptions?.onDereference?.(value.$ref, obj[key], obj, key);
+                        }
+                    }
+                    else {
+                        if (!parents.has(value)) {
+                            dereferenced = crawl(value, keyPath, keyPathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime);
+                            circular = dereferenced.circular;
+                            // Avoid pointless mutations; breaks frozen objects to no profit
+                            if (obj[key] !== dereferenced.value) {
+                                obj[key] = dereferenced.value;
+                            }
+                        }
+                        else {
+                            circular = foundCircularReference(keyPath, $refs, options);
+                        }
+                    }
+                    // Set the "isCircular" flag if this or any other property is circular
+                    result.circular = result.circular || circular;
+                }
+            }
+            parents.delete(obj);
+        }
+    }
+    return result;
+}
+/**
+ * Dereferences the given JSON Reference, and then crawls the resulting value.
+ *
+ * @param $ref - The JSON Reference to resolve
+ * @param path - The full path of `$ref`, possibly with a JSON Pointer in the hash
+ * @param pathFromRoot - The path of `$ref` from the schema root
+ * @param parents - An array of the parent objects that have already been dereferenced
+ * @param processedObjects - An array of all the objects that have already been dereferenced
+ * @param dereferencedCache - An map of all the dereferenced objects
+ * @param $refs
+ * @param options
+ * @returns
+ */
+function dereference$Ref($ref, path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime) {
+    const $refPath = url.resolve(path, $ref.$ref);
+    const cache = dereferencedCache.get($refPath);
+    if (cache && !cache.circular) {
+        const refKeys = Object.keys($ref);
+        if (refKeys.length > 1) {
+            const extraKeys = {};
+            for (const key of refKeys) {
+                if (key !== "$ref" && !(key in cache.value)) {
+                    // @ts-expect-error TS(7053): Element implicitly has an 'any' type because expre... Remove this comment to see the full error message
+                    extraKeys[key] = $ref[key];
+                }
+            }
+            return {
+                circular: cache.circular,
+                value: Object.assign({}, cache.value, extraKeys),
+            };
+        }
+        return cache;
+    }
+    const pointer = $refs._resolve($refPath, path, options);
+    if (pointer === null) {
+        return {
+            circular: false,
+            value: null,
+        };
+    }
+    // Check for circular references
+    const directCircular = pointer.circular;
+    let circular = directCircular || parents.has(pointer.value);
+    if (circular) {
+        foundCircularReference(path, $refs, options);
+    }
+    // Dereference the JSON reference
+    let dereferencedValue = ref_js_1.default.dereference($ref, pointer.value);
+    // Crawl the dereferenced value (unless it's circular)
+    if (!circular) {
+        // Determine if the dereferenced value is circular
+        const dereferenced = crawl(dereferencedValue, pointer.path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime);
+        circular = dereferenced.circular;
+        dereferencedValue = dereferenced.value;
+    }
+    if (circular && !directCircular && options.dereference?.circular === "ignore") {
+        // The user has chosen to "ignore" circular references, so don't change the value
+        dereferencedValue = $ref;
+    }
+    if (directCircular) {
+        // The pointer is a DIRECT circular reference (i.e. it references itself).
+        // So replace the $ref path with the absolute path from the JSON Schema root
+        dereferencedValue.$ref = pathFromRoot;
+    }
+    const dereferencedObject = {
+        circular,
+        value: dereferencedValue,
+    };
+    // only cache if no extra properties than $ref
+    if (Object.keys($ref).length === 1) {
+        dereferencedCache.set($refPath, dereferencedObject);
+    }
+    return dereferencedObject;
+}
+/**
+ * Called when a circular reference is found.
+ * It sets the {@link $Refs#circular} flag, and throws an error if options.dereference.circular is false.
+ *
+ * @param keyPath - The JSON Reference path of the circular reference
+ * @param $refs
+ * @param options
+ * @returns - always returns true, to indicate that a circular reference was found
+ */
+function foundCircularReference(keyPath, $refs, options) {
+    $refs.circular = true;
+    if (!options.dereference.circular) {
+        throw ono_1.ono.reference(`Circular $ref pointer found at ${keyPath}`);
+    }
+    return true;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,74 @@
+import $Refs from "./refs.js";
+import type { JSONSchema } from "./types/index.js";
+interface ResolvedInput {
+    path: string;
+    schema: string | JSONSchema | Buffer<ArrayBufferLike> | Awaited<JSONSchema> | undefined;
+    type: 'file' | 'json' | 'url';
+}
+export declare const getResolvedInput: ({ pathOrUrlOrSchema, }: {
+    pathOrUrlOrSchema: JSONSchema | string | unknown;
+}) => ResolvedInput;
+/**
+ * This class parses a JSON schema, builds a map of its JSON references and their resolved values,
+ * and provides methods for traversing, manipulating, and dereferencing those references.
+ */
+export declare class $RefParser {
+    /**
+     * The resolved JSON references
+     *
+     * @type {$Refs}
+     * @readonly
+     */
+    $refs: $Refs<JSONSchema>;
+    options: import("./options.js").$RefParserOptions;
+    /**
+     * The parsed (and possibly dereferenced) JSON schema object
+     *
+     * @type {object}
+     * @readonly
+     */
+    schema: JSONSchema | null;
+    /**
+     * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
+     *
+     * This also eliminates the risk of circular references, so the schema can be safely serialized using `JSON.stringify()`.
+     *
+     * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#bundleschema-options-callback
+     *
+     * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
+     */
+    bundle({ arrayBuffer, pathOrUrlOrSchema, resolvedInput, }: {
+        arrayBuffer?: ArrayBuffer;
+        pathOrUrlOrSchema: JSONSchema | string | unknown;
+        resolvedInput?: ResolvedInput;
+    }): Promise<JSONSchema>;
+    /**
+     * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
+     *
+     * The dereference method maintains object reference equality, meaning that all `$ref` pointers that point to the same object will be replaced with references to the same object. Again, this is great for programmatic usage, but it does introduce the risk of circular references, so be careful if you intend to serialize the schema using `JSON.stringify()`. Consider using the bundle method instead, which does not create circular references.
+     *
+     * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
+     *
+     * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
+     */
+    dereference({ pathOrUrlOrSchema, }: {
+        pathOrUrlOrSchema: JSONSchema | string | unknown;
+    }): Promise<JSONSchema>;
+    /**
+     * Parses the given JSON schema.
+     * This method does not resolve any JSON references.
+     * It just reads a single file in JSON or YAML format, and parse it as a JavaScript object.
+     *
+     * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
+     * @returns - The returned promise resolves with the parsed JSON schema object.
+     */
+    parse({ arrayBuffer, pathOrUrlOrSchema, resolvedInput: _resolvedInput, }: {
+        arrayBuffer?: ArrayBuffer;
+        pathOrUrlOrSchema: JSONSchema | string | unknown;
+        resolvedInput?: ResolvedInput;
+    }): Promise<{
+        schema: JSONSchema;
+    }>;
+}
+export { sendRequest } from './resolvers/url.js';
+export type { JSONSchema } from "./types/index.js";

package/dist/lib/index.js

@@ -0,0 +1,208 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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 dereference_js_1 = __importDefault(require("./dereference.js"));
+const url = __importStar(require("./util/url.js"));
+const errors_js_1 = require("./util/errors.js");
+const ono_1 = require("@jsdevtools/ono");
+const options_js_1 = require("./options.js");
+const url_js_1 = require("./resolvers/url.js");
+const file_js_1 = require("./resolvers/file.js");
+const getResolvedInput = ({ pathOrUrlOrSchema, }) => {
+    if (!pathOrUrlOrSchema) {
+        throw (0, ono_1.ono)(`Expected a file path, URL, or object. Got ${pathOrUrlOrSchema}`);
+    }
+    const resolvedInput = {
+        path: typeof pathOrUrlOrSchema === 'string' ? pathOrUrlOrSchema : '',
+        schema: undefined,
+        type: 'url',
+    };
+    // If the path is a filesystem path, then convert it to a URL.
+    // NOTE: According to the JSON Reference spec, these should already be URLs,
+    // but, in practice, many people use local filesystem paths instead.
+    // So we're being generous here and doing the conversion automatically.
+    // This is not intended to be a 100% bulletproof solution.
+    // If it doesn't work for your use-case, then use a URL instead.
+    if (url.isFileSystemPath(resolvedInput.path)) {
+        resolvedInput.path = url.fromFileSystemPath(resolvedInput.path);
+        resolvedInput.type = 'file';
+    }
+    else if (!resolvedInput.path && pathOrUrlOrSchema && typeof pathOrUrlOrSchema === 'object') {
+        if ("$id" in pathOrUrlOrSchema && pathOrUrlOrSchema.$id) {
+            // when schema id has defined an URL should use that hostname to request the references,
+            // instead of using the current page URL
+            const { hostname, protocol } = new URL(pathOrUrlOrSchema.$id);
+            resolvedInput.path = `${protocol}//${hostname}:${protocol === "https:" ? 443 : 80}`;
+            resolvedInput.type = 'url';
+        }
+        else {
+            resolvedInput.schema = pathOrUrlOrSchema;
+            resolvedInput.type = 'json';
+        }
+    }
+    // resolve the absolute path of the schema
+    resolvedInput.path = url.resolve(url.cwd(), resolvedInput.path);
+    return resolvedInput;
+};
+exports.getResolvedInput = getResolvedInput;
+/**
+ * This class parses a JSON schema, builds a map of its JSON references and their resolved values,
+ * and provides methods for traversing, manipulating, and dereferencing those references.
+ */
+class $RefParser {
+    constructor() {
+        /**
+         * The resolved JSON references
+         *
+         * @type {$Refs}
+         * @readonly
+         */
+        this.$refs = new refs_js_1.default();
+        this.options = (0, options_js_1.getJsonSchemaRefParserDefaultOptions)();
+        /**
+         * The parsed (and possibly dereferenced) JSON schema object
+         *
+         * @type {object}
+         * @readonly
+         */
+        this.schema = null;
+    }
+    /**
+     * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
+     *
+     * This also eliminates the risk of circular references, so the schema can be safely serialized using `JSON.stringify()`.
+     *
+     * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#bundleschema-options-callback
+     *
+     * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
+     */
+    async bundle({ arrayBuffer, pathOrUrlOrSchema, resolvedInput, }) {
+        await this.parse({ arrayBuffer, pathOrUrlOrSchema, resolvedInput });
+        await (0, resolve_external_js_1.resolveExternal)(this, this.options);
+        const errors = errors_js_1.JSONParserErrorGroup.getParserErrors(this);
+        if (errors.length > 0) {
+            throw new errors_js_1.JSONParserErrorGroup(this);
+        }
+        (0, bundle_js_1.default)(this, this.options);
+        const errors2 = errors_js_1.JSONParserErrorGroup.getParserErrors(this);
+        if (errors2.length > 0) {
+            throw new errors_js_1.JSONParserErrorGroup(this);
+        }
+        return this.schema;
+    }
+    /**
+     * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
+     *
+     * The dereference method maintains object reference equality, meaning that all `$ref` pointers that point to the same object will be replaced with references to the same object. Again, this is great for programmatic usage, but it does introduce the risk of circular references, so be careful if you intend to serialize the schema using `JSON.stringify()`. Consider using the bundle method instead, which does not create circular references.
+     *
+     * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
+     *
+     * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
+     */
+    async dereference({ pathOrUrlOrSchema, }) {
+        await this.parse({ pathOrUrlOrSchema });
+        await (0, resolve_external_js_1.resolveExternal)(this, this.options);
+        const errors = errors_js_1.JSONParserErrorGroup.getParserErrors(this);
+        if (errors.length > 0) {
+            throw new errors_js_1.JSONParserErrorGroup(this);
+        }
+        (0, dereference_js_1.default)(this, this.options);
+        const errors2 = errors_js_1.JSONParserErrorGroup.getParserErrors(this);
+        if (errors2.length > 0) {
+            throw new errors_js_1.JSONParserErrorGroup(this);
+        }
+        return this.schema;
+    }
+    /**
+     * Parses the given JSON schema.
+     * This method does not resolve any JSON references.
+     * It just reads a single file in JSON or YAML format, and parse it as a JavaScript object.
+     *
+     * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
+     * @returns - The returned promise resolves with the parsed JSON schema object.
+     */
+    async parse({ arrayBuffer, pathOrUrlOrSchema, resolvedInput: _resolvedInput, }) {
+        const resolvedInput = _resolvedInput || (0, exports.getResolvedInput)({ pathOrUrlOrSchema });
+        const { path, type } = resolvedInput;
+        let { schema } = resolvedInput;
+        // reset everything
+        this.schema = null;
+        this.$refs = new refs_js_1.default();
+        if (schema) {
+            // immediately add a new $Ref with the schema object as value
+            const $ref = this.$refs._add(path);
+            $ref.pathType = url.isFileSystemPath(path) ? 'file' : 'http';
+            $ref.value = schema;
+        }
+        else if (type !== 'json') {
+            const file = (0, parse_js_1.newFile)(path);
+            // Add a new $Ref for this file, even though we don't have the value yet.
+            // This ensures that we don't simultaneously read & parse the same file multiple times
+            const $refAdded = this.$refs._add(file.url);
+            $refAdded.pathType = type;
+            try {
+                const resolver = type === 'file' ? file_js_1.fileResolver : url_js_1.urlResolver;
+                await resolver.handler(file, arrayBuffer);
+                const parseResult = await (0, parse_js_1.parseFile)(file, this.options);
+                $refAdded.value = parseResult.result;
+                schema = parseResult.result;
+            }
+            catch (err) {
+                if ((0, errors_js_1.isHandledError)(err)) {
+                    $refAdded.value = err;
+                }
+                throw err;
+            }
+        }
+        if (schema === null || typeof schema !== 'object' || Buffer.isBuffer(schema)) {
+            throw ono_1.ono.syntax(`"${this.$refs._root$Ref.path || schema}" is not a valid JSON Schema`);
+        }
+        this.schema = schema;
+        return {
+            schema,
+        };
+    }
+}
+exports.$RefParser = $RefParser;
+var url_js_2 = require("./resolvers/url.js");
+Object.defineProperty(exports, "sendRequest", { enumerable: true, get: function () { return url_js_2.sendRequest; } });

package/dist/lib/options.d.ts

@@ -0,0 +1,61 @@
+import type { JSONSchemaObject, Plugin } from "./types/index.js";
+export interface DereferenceOptions {
+    /**
+     * Determines whether circular `$ref` pointers are handled.
+     *
+     * If set to `false`, then a `ReferenceError` will be thrown if the schema contains any circular references.
+     *
+     * If set to `"ignore"`, then circular references will simply be ignored. No error will be thrown, but the `$Refs.circular` property will still be set to `true`.
+     */
+    circular?: boolean | "ignore";
+    /**
+     * A function, called for each path, which can return true to stop this path and all
+     * subpaths from being dereferenced further. This is useful in schemas where some
+     * subpaths contain literal $ref keys that should not be dereferenced.
+     */
+    excludedPathMatcher?(path: string): boolean;
+    /**
+     * Callback invoked during dereferencing.
+     *
+     * @argument {string} path - The path being dereferenced (ie. the `$ref` string)
+     * @argument {JSONSchemaObject} value - The JSON-Schema that the `$ref` resolved to
+     * @argument {JSONSchemaObject} parent - The parent of the dereferenced object
+     * @argument {string} parentPropName - The prop name of the parent object whose value was dereferenced
+     */
+    onDereference?(path: string, value: JSONSchemaObject, parent?: JSONSchemaObject, parentPropName?: string): void;
+}
+/**
+ * Options that determine how JSON schemas are parsed, resolved, and dereferenced.
+ *
+ * @param [options] - Overridden options
+ * @class
+ */
+export interface $RefParserOptions {
+    /**
+     * The `dereference` options control how JSON Schema `$Ref` Parser will dereference `$ref` pointers within the JSON schema.
+     */
+    dereference: DereferenceOptions;
+    /**
+     * The `parse` options determine how different types of files will be parsed.
+     *
+     * JSON Schema `$Ref` Parser comes with built-in JSON, YAML, plain-text, and binary parsers, any of which you can configure or disable. You can also add your own custom parsers if you want.
+     */
+    parse: {
+        binary: Plugin;
+        json: Plugin;
+        text: Plugin;
+        yaml: Plugin;
+    };
+    /**
+     * The maximum amount of time (in milliseconds) that JSON Schema $Ref Parser will spend dereferencing a single schema.
+     * It will throw a timeout error if the operation takes longer than this.
+     */
+    timeoutMs?: number;
+}
+export declare const getJsonSchemaRefParserDefaultOptions: () => $RefParserOptions;
+export type Options = $RefParserOptions;
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type ParserOptions = DeepPartial<$RefParserOptions>;
+export {};

package/dist/lib/options.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsonSchemaRefParserDefaultOptions = void 0;
+const json_js_1 = require("./parsers/json.js");
+const yaml_js_1 = require("./parsers/yaml.js");
+const text_js_1 = require("./parsers/text.js");
+const binary_js_1 = require("./parsers/binary.js");
+const getJsonSchemaRefParserDefaultOptions = () => ({
+    /**
+     * Determines the types of JSON references that are allowed.
+     */
+    dereference: {
+        /**
+         * Dereference circular (recursive) JSON references?
+         * If false, then a {@link ReferenceError} will be thrown if a circular reference is found.
+         * If "ignore", then circular references will not be dereferenced.
+         *
+         * @type {boolean|string}
+         */
+        circular: true,
+        /**
+         * A function, called for each path, which can return true to stop this path and all
+         * subpaths from being dereferenced further. This is useful in schemas where some
+         * subpaths contain literal $ref keys that should not be dereferenced.
+         *
+         * @type {function}
+         */
+        excludedPathMatcher: () => false,
+        // @ts-expect-error
+        referenceResolution: "relative",
+    },
+    /**
+     * Determines how different types of files will be parsed.
+     *
+     * You can add additional parsers of your own, replace an existing one with
+     * your own implementation, or disable any parser by setting it to false.
+     */
+    parse: {
+        binary: { ...binary_js_1.binaryParser },
+        json: { ...json_js_1.jsonParser },
+        text: { ...text_js_1.textParser },
+        yaml: { ...yaml_js_1.yamlParser },
+    },
+});
+exports.getJsonSchemaRefParserDefaultOptions = getJsonSchemaRefParserDefaultOptions;

package/dist/lib/parse.d.ts

@@ -0,0 +1,13 @@
+import type { PluginResult } from "./util/plugins.js";
+import type { $RefParserOptions } from "./options.js";
+import type { FileInfo } from "./types/index.js";
+/**
+ * Prepares the file object so we can populate it with data and other values
+ * when it's read and parsed. This "file object" will be passed to all
+ * resolvers and parsers.
+ */
+export declare function newFile(path: string): FileInfo;
+/**
+ * Parses the given file's contents, using the configured parser plugins.
+ */
+export declare const parseFile: (file: FileInfo, options: $RefParserOptions) => Promise<PluginResult>;