@apidevtools/json-schema-ref-parser 11.4.2 → 11.5.1

package/dist/lib/parse.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
 import type $Refs from "./refs.js";
 import type { Options } from "./options.js";
-export default parse;
+import type { JSONSchema } from "./types/index.js";
 /**
  * Reads and parses the specified file path or URL.
  */
-declare function parse(path: string, $refs: $Refs, options: Options): Promise<string | import("./types/index.js").JSONSchema | Buffer | undefined>;
+declare function parse<S extends JSONSchema = JSONSchema, O extends Options = Options>(path: string, $refs: $Refs<S>, options: O): Promise<string | Buffer | S | undefined>;
+export default parse;

package/dist/lib/parse.js

@@ -27,7 +27,6 @@ const ono_1 = require("@jsdevtools/ono");
 const url = __importStar(require("./util/url.js"));
 const plugins = __importStar(require("./util/plugins.js"));
 const errors_js_1 = require("./util/errors.js");
-exports.default = parse;
 /**
  * Reads and parses the specified file path or URL.
  */
@@ -72,7 +71,7 @@ async function parse(path, $refs, options) {
  * @param file.url       - The full URL of the referenced file
  * @param file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
  * @param options
- *
+ * @param $refs
  * @returns
  * The promise resolves with the raw file contents and the resolver that was used.
  */
@@ -113,6 +112,7 @@ async function readFile(file, options, $refs) {
  * @param file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
  * @param file.data      - The file contents. This will be whatever data type was returned by the resolver
  * @param options
+ * @param $refs
  *
  * @returns
  * The promise resolves with the parsed file contents and the parser that was used.
@@ -166,3 +166,4 @@ function isEmpty(value) {
         (typeof value === "string" && value.trim().length === 0) ||
         (Buffer.isBuffer(value) && value.length === 0));
 }
+exports.default = parse;

package/dist/lib/pointer.d.ts

@@ -1,5 +1,6 @@
 import type $RefParserOptions from "./options.js";
 import $Ref from "./ref.js";
+import type { JSONSchema } from "./types";
 /**
  * This class represents a single JSON pointer and its resolved value.
  *
@@ -8,11 +9,11 @@ import $Ref from "./ref.js";
  * @param [friendlyPath] - The original user-specified path (used for error messages)
  * @class
  */
-declare class Pointer {
+declare class Pointer<S extends JSONSchema = JSONSchema> {
     /**
      * The {@link $Ref} object that contains this {@link Pointer} object.
      */
-    $ref: $Ref;
+    $ref: $Ref<S>;
     /**
      * The file path or URL, containing the JSON pointer in the hash.
      * This path is relative to the path of the main JSON schema file.
@@ -36,7 +37,7 @@ declare class Pointer {
      * Resolving a single pointer may require resolving multiple $Refs.
      */
     indirections: number;
-    constructor($ref: $Ref, path: string, friendlyPath?: string);
+    constructor($ref: $Ref<S>, path: string, friendlyPath?: string);
     /**
      * Resolves the value of a nested property within the given object.
      *
@@ -50,7 +51,7 @@ declare class Pointer {
      * the {@link Pointer#$ref} and {@link Pointer#path} will reflect the resolution path
      * of the resolved value.
      */
-    resolve(obj: any, options?: $RefParserOptions, pathFromRoot?: string): this;
+    resolve(obj: any, options?: $RefParserOptions<S>, pathFromRoot?: string): this;
     /**
      * Sets the value of a nested property within the given object.
      *
@@ -61,7 +62,7 @@ declare class Pointer {
      * @returns
      * Returns the modified object, or an entirely new object if the entire object is overwritten.
      */
-    set(obj: any, value: any, options?: $RefParserOptions): any;
+    set(obj: any, value: any, options?: $RefParserOptions<S>): any;
     /**
      * Parses a JSON pointer (or a path containing a JSON pointer in the hash)
      * and returns an array of the pointer's tokens.

package/dist/lib/ref.d.ts

@@ -2,6 +2,7 @@ import Pointer from "./pointer.js";
 import type { JSONParserError, MissingPointerError, ParserError, ResolverError } from "./util/errors.js";
 import type $Refs from "./refs.js";
 import type $RefParserOptions from "./options.js";
+import type { ParserOptions } from "./options.js";
 import type { JSONSchema } from "./types";
 export type $RefError = JSONParserError | ResolverError | ParserError | MissingPointerError;
 /**
@@ -9,7 +10,7 @@ export type $RefError = JSONParserError | ResolverError | ParserError | MissingP
  *
  * @class
  */
-declare class $Ref {
+declare class $Ref<S extends JSONSchema = JSONSchema> {
     /**
      * The file path or URL of the referenced file.
      * This path is relative to the path of the main JSON schema file.
@@ -33,7 +34,7 @@ declare class $Ref {
      *
      * @type {$Refs}
      */
-    $refs: $Refs;
+    $refs: $Refs<S>;
     /**
      * Indicates the type of {@link $Ref#path} (e.g. "file", "http", etc.)
      */
@@ -42,7 +43,7 @@ declare class $Ref {
      * List of all errors. Undefined if no errors.
      */
     errors: Array<$RefError>;
-    constructor($refs: $Refs);
+    constructor($refs: $Refs<S>);
     /**
      * Pushes an error to errors array.
      *
@@ -57,7 +58,7 @@ declare class $Ref {
      * @param options
      * @returns
      */
-    exists(path: string, options?: $RefParserOptions): boolean;
+    exists(path: string, options?: $RefParserOptions<S>): boolean;
     /**
      * Resolves the given JSON reference within this {@link $Ref#value} and returns the resolved value.
      *
@@ -65,7 +66,7 @@ declare class $Ref {
      * @param options
      * @returns - Returns the resolved value
      */
-    get(path: any, options: $RefParserOptions): any;
+    get(path: string, options?: $RefParserOptions<S>): any;
     /**
      * Resolves the given JSON reference within this {@link $Ref#value}.
      *
@@ -75,7 +76,7 @@ declare class $Ref {
      * @param pathFromRoot - The path of `obj` from the schema root
      * @returns
      */
-    resolve(path: any, options?: $RefParserOptions, friendlyPath?: string, pathFromRoot?: string): Pointer | null;
+    resolve(path: string, options?: $RefParserOptions<S>, friendlyPath?: string, pathFromRoot?: string): Pointer<S> | null;
     /**
      * Sets the value of a nested property within this {@link $Ref#value}.
      * If the property, or any of its parents don't exist, they will be created.
@@ -109,7 +110,7 @@ declare class $Ref {
      * @param options
      * @returns
      */
-    static isAllowed$Ref(value: unknown, options?: $RefParserOptions): true | undefined;
+    static isAllowed$Ref(value: unknown, options?: ParserOptions): true | undefined;
     /**
      * Determines whether the given value is a JSON reference that "extends" its resolved value.
      * That is, it has extra properties (in addition to "$ref"), so rather than simply pointing to
@@ -176,6 +177,6 @@ declare class $Ref {
      * @param resolvedValue - The resolved value, which can be any type
      * @returns - Returns the dereferenced value
      */
-    static dereference($ref: $Ref, resolvedValue: JSONSchema): JSONSchema;
+    static dereference<S extends JSONSchema = JSONSchema>($ref: $Ref<S>, resolvedValue: S): S;
 }
 export default $Ref;

package/dist/lib/ref.js

@@ -142,7 +142,7 @@ class $Ref {
                 // It's a JSON Pointer reference, which is always allowed
                 return true;
             }
-            else if (value.$ref[0] !== "#" && (!options || options.resolve.external)) {
+            else if (value.$ref[0] !== "#" && (!options || options.resolve?.external)) {
                 // It's an external reference, which is allowed by the options
                 return true;
             }

package/dist/lib/refs.d.ts

@@ -1,9 +1,9 @@
 import $Ref from "./ref.js";
 import type { JSONSchema4Type, JSONSchema6Type, JSONSchema7Type } from "json-schema";
-import type { JSONSchema } from "./types/index.js";
 import type $RefParserOptions from "./options.js";
-interface $RefsMap {
-    [url: string]: $Ref;
+import type { JSONSchema } from "./types";
+interface $RefsMap<S extends JSONSchema = JSONSchema> {
+    [url: string]: $Ref<S>;
 }
 /**
  * When you call the resolve method, the value that gets passed to the callback function (or Promise) is a $Refs object. This same object is accessible via the parser.$refs property of $RefParser objects.
@@ -12,7 +12,7 @@ interface $RefsMap {
  *
  * See https://apitools.dev/json-schema-ref-parser/docs/refs.html
  */
-export default class $Refs {
+export default class $Refs<S extends JSONSchema = JSONSchema> {
     /**
      * This property is true if the schema contains any circular references. You may want to check this property before serializing the dereferenced schema as JSON, since JSON.stringify() does not support circular references by default.
      *
@@ -34,7 +34,7 @@ export default class $Refs {
      *
      * @param types (optional) Optionally only return values from certain locations ("file", "http", etc.)
      */
-    values(...types: string[]): JSONSchema;
+    values(...types: string[]): S;
     /**
      * Returns `true` if the given path exists in the schema; otherwise, returns `false`
      *
@@ -57,14 +57,14 @@ export default class $Refs {
      * @param [options]
      * @returns - Returns the resolved value
      */
-    get(path: string, options?: $RefParserOptions): JSONSchema4Type | JSONSchema6Type | JSONSchema7Type;
+    get(path: string, options?: $RefParserOptions<S>): JSONSchema4Type | JSONSchema6Type | JSONSchema7Type;
     /**
      * Sets the value at the given path in the schema. If the property, or any of its parents, don't exist, they will be created.
      *
-     * @param $ref The JSON Reference path, optionally with a JSON Pointer in the hash
+     * @param path The JSON Reference path, optionally with a JSON Pointer in the hash
      * @param value The value to assign. Can be anything (object, string, number, etc.)
      */
-    set(path: any, value: JSONSchema4Type | JSONSchema6Type | JSONSchema7Type): void;
+    set(path: string, value: JSONSchema4Type | JSONSchema6Type | JSONSchema7Type): void;
     /**
      * Returns the specified {@link $Ref} object, or undefined.
      *
@@ -72,13 +72,13 @@ export default class $Refs {
      * @returns
      * @protected
      */
-    _get$Ref(path: any): $Ref;
+    _get$Ref(path: any): $Ref<S>;
     /**
      * Creates a new {@link $Ref} object and adds it to this {@link $Refs} object.
      *
      * @param path  - The file path or URL of the referenced file
      */
-    _add(path: string): $Ref;
+    _add(path: string): $Ref<S>;
     /**
      * Resolves the given JSON reference.
      *
@@ -88,21 +88,21 @@ export default class $Refs {
      * @returns
      * @protected
      */
-    _resolve(path: string, pathFromRoot: string, options?: any): import("./pointer.js").default | null;
+    _resolve(path: string, pathFromRoot: string, options?: any): import("./pointer.js").default<S> | null;
     /**
      * A map of paths/urls to {@link $Ref} objects
      *
      * @type {object}
      * @protected
      */
-    _$refs: $RefsMap;
+    _$refs: $RefsMap<S>;
     /**
      * The {@link $Ref} object that is the root of the JSON schema.
      *
      * @type {$Ref}
      * @protected
      */
-    _root$Ref: $Ref;
+    _root$Ref: $Ref<S>;
     constructor();
     /**
      * Returns the paths of all the files/URLs that are referenced by the JSON schema,
@@ -122,6 +122,6 @@ export default class $Refs {
      *
      * @returns {object}
      */
-    toJSON: (...types: string[]) => JSONSchema;
+    toJSON: (...types: string[]) => S;
 }
 export {};

package/dist/lib/refs.js

@@ -102,7 +102,7 @@ class $Refs {
     /**
      * Sets the value at the given path in the schema. If the property, or any of its parents, don't exist, they will be created.
      *
-     * @param $ref The JSON Reference path, optionally with a JSON Pointer in the hash
+     * @param path The JSON Reference path, optionally with a JSON Pointer in the hash
      * @param value The value to assign. Can be anything (object, string, number, etc.)
      */
     set(path, value) {

package/dist/lib/resolve-external.d.ts

@@ -1,6 +1,6 @@
-import type { Options } from "./options.js";
+import type { Options, ParserOptions } from "./options.js";
+import type { JSONSchema } from "./types/index.js";
 import type $RefParser from "./index.js";
-export default resolveExternal;
 /**
  * Crawls the JSON schema, finds all external JSON references, and resolves their values.
  * This method does not mutate the JSON schema. The resolved values are added to {@link $RefParser#$refs}.
@@ -11,4 +11,5 @@ export default resolveExternal;
  * The promise resolves once all JSON references in the schema have been resolved,
  * including nested references that are contained in externally-referenced files.
  */
-declare function resolveExternal(parser: $RefParser, options: Options): Promise<void> | Promise<any[]>;
+declare function resolveExternal<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(parser: $RefParser<S, O>, options: Options): Promise<void> | Promise<any[]>;
+export default resolveExternal;

package/dist/lib/resolve-external.js

@@ -31,7 +31,6 @@ const pointer_js_1 = __importDefault(require("./pointer.js"));
 const parse_js_1 = __importDefault(require("./parse.js"));
 const url = __importStar(require("./util/url.js"));
 const errors_js_1 = require("./util/errors.js");
-exports.default = resolveExternal;
 /**
  * Crawls the JSON schema, finds all external JSON references, and resolves their values.
  * This method does not mutate the JSON schema. The resolved values are added to {@link $RefParser#$refs}.
@@ -107,10 +106,10 @@ async function resolve$Ref($ref, path, $refs, options) {
     const withoutHash = url.stripHash(resolvedPath);
     // $ref.$ref = url.relative($refs._root$Ref.path, resolvedPath);
     // Do we already have this $ref?
-    $ref = $refs._$refs[withoutHash];
-    if ($ref) {
+    const ref = $refs._$refs[withoutHash];
+    if (ref) {
         // We've already parsed this $ref, so use the existing value
-        return Promise.resolve($ref.value);
+        return Promise.resolve(ref.value);
     }
     // Parse the $referenced file/url
     try {
@@ -131,3 +130,4 @@ async function resolve$Ref($ref, path, $refs, options) {
         return [];
     }
 }
+exports.default = resolveExternal;

package/dist/lib/resolvers/file.d.ts

@@ -1,3 +1,3 @@
-import type { ResolverOptions } from "../types/index.js";
-declare const _default: ResolverOptions;
+import type { JSONSchema, ResolverOptions } from "../types/index.js";
+declare const _default: ResolverOptions<JSONSchema>;
 export default _default;

package/dist/lib/resolvers/http.d.ts

@@ -1,3 +1,3 @@
-import type { HTTPResolverOptions } from "../types/index.js";
-declare const _default: HTTPResolverOptions;
+import type { HTTPResolverOptions, JSONSchema } from "../types/index.js";
+declare const _default: HTTPResolverOptions<JSONSchema>;
 export default _default;

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

@@ -3,12 +3,12 @@ import type { JSONSchema4, JSONSchema4Object, JSONSchema6, JSONSchema6Object, JS
 import type $Refs from "../refs.js";
 export type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
 export type JSONSchemaObject = JSONSchema4Object | JSONSchema6Object | JSONSchema7Object;
-export type SchemaCallback = (err: Error | null, schema?: JSONSchema | object | null) => any;
-export type $RefsCallback = (err: Error | null, $refs?: $Refs) => any;
+export type SchemaCallback<S extends JSONSchema = JSONSchema> = (err: Error | null, schema?: S | object | null) => any;
+export type $RefsCallback<S extends JSONSchema = JSONSchema> = (err: Error | null, $refs?: $Refs<S>) => any;
 /**
  * See https://apitools.dev/json-schema-ref-parser/docs/options.html
  */
-export interface HTTPResolverOptions extends Partial<ResolverOptions> {
+export interface HTTPResolverOptions<S extends JSONSchema = JSONSchema> extends Partial<ResolverOptions<S>> {
     /**
      * You can specify any HTTP headers that should be sent when downloading files. For example, some servers may require you to set the `Accept` or `Referrer` header.
      */
@@ -31,7 +31,7 @@ export interface HTTPResolverOptions extends Partial<ResolverOptions> {
  *
  * See https://apitools.dev/json-schema-ref-parser/docs/plugins/resolvers.html
  */
-export interface ResolverOptions {
+export interface ResolverOptions<S extends JSONSchema = JSONSchema> {
     name?: string;
     /**
      * All resolvers have an order property, even the built-in resolvers. If you don't specify an order property, then your resolver will run last. Specifying `order: 1`, like we did in this example, will make your resolver run first. Or you can squeeze your resolver in-between some of the built-in resolvers. For example, `order: 101` would make it run after the file resolver, but before the HTTP resolver. You can see the order of all the built-in resolvers by looking at their source code.
@@ -48,7 +48,7 @@ export interface ResolverOptions {
      *
      * Unlike the `canRead` function, the `read` method can also be asynchronous. This might be important if your resolver needs to read data from a database or some other external source. You can return your asynchronous value using either an ES6 Promise or a Node.js-style error-first callback. Of course, if your resolver has the ability to return its data synchronously, then that's fine too. Here are examples of all three approaches:
      */
-    read: string | object | ((file: FileInfo, callback?: (error: Error | null, data: string | null) => any) => string | Buffer | JSONSchema | Promise<string | Buffer | JSONSchema>);
+    read: string | object | ((file: FileInfo, callback?: (error: Error | null, data: string | null) => any) => string | Buffer | S | Promise<string | Buffer | S>);
 }
 export interface Plugin {
     name?: string;

package/dist/lib/util/errors.d.ts

@@ -1,4 +1,6 @@
 import type $RefParser from "../index.js";
+import type { ParserOptions } from "../index.js";
+import type { JSONSchema } from "../index.js";
 export type JSONParserErrorType = "EUNKNOWN" | "EPARSER" | "EUNMATCHEDPARSER" | "ERESOLVER" | "EUNMATCHEDRESOLVER" | "EMISSINGPOINTER" | "EINVALIDPOINTER";
 export declare class JSONParserError extends Error {
     readonly name: string;
@@ -9,10 +11,10 @@ export declare class JSONParserError extends Error {
     constructor(message: string, source?: string);
     get footprint(): string;
 }
-export declare class JSONParserErrorGroup extends Error {
-    files: $RefParser;
-    constructor(parser: $RefParser);
-    static getParserErrors(parser: any): JSONParserError[];
+export declare class JSONParserErrorGroup<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions> extends Error {
+    files: $RefParser<S, O>;
+    constructor(parser: $RefParser<S, O>);
+    static getParserErrors<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(parser: $RefParser<S, O>): JSONParserError[];
     get errors(): Array<JSONParserError | InvalidPointerError | ResolverError | ParserError | MissingPointerError | UnmatchedParserError | UnmatchedResolverError>;
 }
 export declare class ParserError extends JSONParserError {

package/dist/lib/util/plugins.d.ts

@@ -1,17 +1,16 @@
 /// <reference types="node" />
-import type { FileInfo } from "../types/index.js";
+import type { FileInfo, JSONSchema } from "../types/index.js";
 import type $RefParserOptions from "../options.js";
 import type { ResolverOptions } from "../types/index.js";
 import type $Refs from "../refs.js";
 import type { Plugin } from "../types/index.js";
-import type { JSONSchema } from "../types/index.js";
 /**
  * Returns the given plugins as an array, rather than an object map.
  * All other methods in this module expect an array of plugins rather than an object map.
  *
  * @returns
  */
-export declare function all(plugins: $RefParserOptions["resolve"]): Plugin[];
+export declare function all<S extends JSONSchema = JSONSchema>(plugins: $RefParserOptions<S>["resolve"]): Plugin[];
 /**
  * Filters the given plugins, returning only the ones return `true` for the given method.
  */
@@ -20,9 +19,9 @@ export declare function filter(plugins: Plugin[], method: any, file: any): Plugi
  * Sorts the given plugins, in place, by their `order` property.
  */
 export declare function sort(plugins: Plugin[]): Plugin[];
-export interface PluginResult {
+export interface PluginResult<S extends JSONSchema = JSONSchema> {
     plugin: Plugin;
-    result?: string | Buffer | JSONSchema;
+    result?: string | Buffer | S;
     error?: any;
 }
 /**
@@ -33,4 +32,4 @@ export interface PluginResult {
  * If the promise rejects, or the callback is called with an error, then the next plugin is called.
  * If ALL plugins fail, then the last error is thrown.
  */
-export declare function run(plugins: Plugin[], method: keyof Plugin | keyof ResolverOptions, file: FileInfo, $refs: $Refs): Promise<PluginResult>;
+export declare function run<S extends JSONSchema = JSONSchema>(plugins: Plugin[], method: keyof Plugin | keyof ResolverOptions<S>, file: FileInfo, $refs: $Refs<S>): Promise<PluginResult<S>>;

package/lib/bundle.ts

@@ -1,10 +1,10 @@
 import $Ref from "./ref.js";
 import Pointer from "./pointer.js";
 import * as url from "./util/url.js";
-import type $RefParserOptions from "./options.js";
 import type $Refs from "./refs.js";
-
-export default bundle;
+import type $RefParser from "./index";
+import type { ParserOptions } from "./index";
+import type { JSONSchema } from "./index";
 
 /**
  * Bundles all external JSON references into the main JSON schema, thus resulting in a schema that
@@ -14,12 +14,15 @@ export default bundle;
  * @param parser
  * @param options
  */
-function bundle(parser: any, options: any) {
+function bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
+  parser: $RefParser<S, O>,
+  options: O,
+) {
   // console.log('Bundling $ref pointers in %s', parser.$refs._root$Ref.path);
 
   // Build an inventory of all $ref pointers in the JSON Schema
   const inventory: any = [];
-  crawl(parser, "schema", parser.$refs._root$Ref.path + "#", "#", 0, inventory, parser.$refs, options);
+  crawl<S, O>(parser, "schema", parser.$refs._root$Ref.path + "#", "#", 0, inventory, parser.$refs, options);
 
   // Remap all $ref pointers
   remap(inventory);
@@ -32,19 +35,20 @@ function bundle(parser: any, options: any) {
  * @param key - The property key of `parent` to be crawled
  * @param path - The full path of the property being crawled, possibly with a JSON Pointer in the hash
  * @param pathFromRoot - The path of the property being crawled, from the schema root
+ * @param indirections
  * @param inventory - An array of already-inventoried $ref pointers
  * @param $refs
  * @param options
  */
-function crawl(
+function crawl<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
   parent: any,
-  key: any,
-  path: any,
-  pathFromRoot: any,
-  indirections: any,
-  inventory: any,
-  $refs: any,
-  options: any,
+  key: string | null,
+  path: string,
+  pathFromRoot: string,
+  indirections: number,
+  inventory: unknown[],
+  $refs: $Refs<S>,
+  options: O,
 ) {
   const obj = key === null ? parent : parent[key];
 
@@ -98,15 +102,15 @@ function crawl(
  * @param $refs
  * @param options
  */
-function inventory$Ref(
+function inventory$Ref<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
   $refParent: any,
   $refKey: any,
   path: string,
   pathFromRoot: any,
   indirections: any,
   inventory: any,
-  $refs: $Refs,
-  options: $RefParserOptions,
+  $refs: $Refs<S>,
+  options: O,
 ) {
   const $ref = $refKey === null ? $refParent : $refParent[$refKey];
   const $refPath = url.resolve(path, $ref.$ref);
@@ -248,9 +252,8 @@ function remap(inventory: any) {
  * TODO
  */
 function findInInventory(inventory: any, $refParent: any, $refKey: any) {
-  for (let i = 0; i < inventory.length; i++) {
-    const existingEntry = inventory[i];
-    if (existingEntry.parent === $refParent && existingEntry.key === $refKey) {
+  for (const existingEntry of inventory) {
+    if (existingEntry && existingEntry.parent === $refParent && existingEntry.key === $refKey) {
       return existingEntry;
     }
   }
@@ -260,3 +263,4 @@ function removeFromInventory(inventory: any, entry: any) {
   const index = inventory.indexOf(entry);
   inventory.splice(index, 1);
 }
+export default bundle;

package/lib/dereference.ts

@@ -3,7 +3,9 @@ import Pointer from "./pointer.js";
 import { ono } from "@jsdevtools/ono";
 import * as url from "./util/url.js";
 import type $Refs from "./refs.js";
-import type $RefParserOptions from "./options.js";
+import type { DereferenceOptions, ParserOptions } from "./options.js";
+import type { JSONSchema } from "./types";
+import type $RefParser from "./index";
 
 export default dereference;
 
@@ -14,11 +16,14 @@ export default dereference;
  * @param parser
  * @param options
  */
-function dereference(parser: any, options: any) {
+function dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
+  parser: $RefParser<S, O>,
+  options: O,
+) {
   // console.log('Dereferencing $ref pointers in %s', parser.$refs._root$Ref.path);
-  const dereferenced = crawl(
+  const dereferenced = crawl<S, O>(
     parser.schema,
-    parser.$refs._root$Ref.path,
+    parser.$refs._root$Ref.path!,
     "#",
     new Set(),
     new Set(),
@@ -43,15 +48,15 @@ function dereference(parser: any, options: any) {
  * @param options
  * @returns
  */
-function crawl(
+function crawl<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
   obj: any,
   path: string,
   pathFromRoot: string,
   parents: Set<any>,
   processedObjects: Set<any>,
   dereferencedCache: any,
-  $refs: $Refs,
-  options: $RefParserOptions,
+  $refs: $Refs<S>,
+  options: O,
 ) {
   let dereferenced;
   const result = {
@@ -59,9 +64,10 @@ function crawl(
     circular: false,
   };
 
-  const isExcludedPath = options.dereference.excludedPathMatcher || (() => false);
+  const derefOptions = (options.dereference || {}) as DereferenceOptions;
+  const isExcludedPath = derefOptions.excludedPathMatcher || (() => false);
 
-  if (options.dereference.circular === "ignore" || !processedObjects.has(obj)) {
+  if (derefOptions?.circular === "ignore" || !processedObjects.has(obj)) {
     if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !isExcludedPath(pathFromRoot)) {
       parents.add(obj);
       processedObjects.add(obj);
@@ -106,9 +112,7 @@ function crawl(
             // Avoid pointless mutations; breaks frozen objects to no profit
             if (obj[key] !== dereferenced.value) {
               obj[key] = dereferenced.value;
-              if (options.dereference.onDereference) {
-                options.dereference.onDereference(value.$ref, obj[key], obj, key);
-              }
+              derefOptions?.onDereference?.(value.$ref, obj[key], obj, key);
             }
           } else {
             if (!parents.has(value)) {
@@ -157,18 +161,18 @@ function crawl(
  * @param options
  * @returns
  */
-function dereference$Ref(
+function dereference$Ref<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
   $ref: any,
   path: string,
   pathFromRoot: string,
   parents: Set<any>,
   processedObjects: any,
   dereferencedCache: any,
-  $refs: $Refs,
-  options: $RefParserOptions,
+  $refs: $Refs<S>,
+  options: O,
 ) {
   const isExternalRef = $Ref.isExternal$Ref($ref);
-  const shouldResolveOnCwd = isExternalRef && options?.dereference.externalReferenceResolution === "root";
+  const shouldResolveOnCwd = isExternalRef && options?.dereference?.externalReferenceResolution === "root";
   const $refPath = url.resolve(shouldResolveOnCwd ? url.cwd() : path, $ref.$ref);
 
   const cache = dereferencedCache.get($refPath);
@@ -225,7 +229,7 @@ function dereference$Ref(
     dereferencedValue = dereferenced.value;
   }
 
-  if (circular && !directCircular && options.dereference.circular === "ignore") {
+  if (circular && !directCircular && options.dereference?.circular === "ignore") {
     // The user has chosen to "ignore" circular references, so don't change the value
     dereferencedValue = $ref;
   }