@apidevtools/json-schema-ref-parser 10.0.1 → 11.0.0

package/lib/util/{plugins.js → plugins.ts}

@@ -1,48 +1,53 @@
+import type { FileInfo } 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.
  *
- * @param  {object} plugins - A map of plugin objects
- * @return {object[]}
+ * @returns
  */
-export function all (plugins) {
+export function all(plugins: $RefParserOptions["resolve"]): Plugin[] {
   return Object.keys(plugins)
     .filter((key) => {
       return typeof plugins[key] === "object";
     })
     .map((key) => {
-      plugins[key].name = key;
-      return plugins[key];
+      (plugins[key] as ResolverOptions)!.name = key;
+      return plugins[key] as Plugin;
     });
 }
 
 /**
  * Filters the given plugins, returning only the ones return `true` for the given method.
- *
- * @param  {object[]} plugins - An array of plugin objects
- * @param  {string}   method  - The name of the filter method to invoke for each plugin
- * @param  {object}   file    - A file info object, which will be passed to each method
- * @return {object[]}
  */
-export function filter (plugins, method, file) {
-  return plugins
-    .filter((plugin) => {
-      return !!getResult(plugin, method, file);
-    });
+export function filter(plugins: Plugin[], method: any, file: any) {
+  return plugins.filter((plugin: Plugin) => {
+    return !!getResult(plugin, method, file);
+  });
 }
 
 /**
  * Sorts the given plugins, in place, by their `order` property.
- *
- * @param {object[]} plugins - An array of plugin objects
- * @returns {object[]}
  */
-export function sort (plugins) {
-  for (let plugin of plugins) {
+export function sort(plugins: Plugin[]) {
+  for (const plugin of plugins) {
     plugin.order = plugin.order || Number.MAX_SAFE_INTEGER;
   }
 
-  return plugins.sort((a, b) => { return a.order - b.order; });
+  return plugins.sort((a: any, b: any) => {
+    return a.order - b.order;
+  });
+}
+
+export interface PluginResult {
+  plugin: Plugin;
+  result?: string | Buffer | JSONSchema;
+  error?: any;
 }
 
 /**
@@ -52,19 +57,21 @@ export function sort (plugins) {
  * is immediately returned and no further plugins are called.
  * 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.
- *
- * @param {object[]}  plugins - An array of plugin objects
- * @param {string}    method  - The name of the method to invoke for each plugin
- * @param {object}    file    - A file info object, which will be passed to each method
- * @returns {Promise}
  */
-export function run (plugins, method, file, $refs) {
-  let plugin, lastError, index = 0;
+export async function run(
+  plugins: Plugin[],
+  method: keyof Plugin | keyof ResolverOptions,
+  file: FileInfo,
+  $refs: $Refs,
+) {
+  let plugin: Plugin;
+  let lastError: PluginResult;
+  let index = 0;
 
-  return new Promise(((resolve, reject) => {
+  return new Promise<PluginResult>((resolve, reject) => {
     runNextPlugin();
 
-    function runNextPlugin () {
+    function runNextPlugin() {
       plugin = plugins[index++];
       if (!plugin) {
         // There are no more functions, so re-throw the last error
@@ -73,42 +80,38 @@ export function run (plugins, method, file, $refs) {
 
       try {
         // console.log('  %s', plugin.name);
-        let result = getResult(plugin, method, file, callback, $refs);
+        const result = getResult(plugin, method, file, callback, $refs);
         if (result && typeof result.then === "function") {
           // A promise was returned
           result.then(onSuccess, onError);
-        }
-        else if (result !== undefined) {
+        } else if (result !== undefined) {
           // A synchronous result was returned
           onSuccess(result);
-        }
-        else if (index === plugins.length) {
+        } else if (index === plugins.length) {
           throw new Error("No promise has been returned or callback has been called.");
         }
-      }
-      catch (e) {
+      } catch (e) {
         onError(e);
       }
     }
 
-    function callback (err, result) {
+    function callback(err: PluginResult["error"], result: PluginResult["result"]) {
       if (err) {
         onError(err);
-      }
-      else {
+      } else {
         onSuccess(result);
       }
     }
 
-    function onSuccess (result) {
+    function onSuccess(result: PluginResult["result"]) {
       // console.log('    success');
       resolve({
         plugin,
-        result
+        result,
       });
     }
 
-    function onError (error) {
+    function onError(error: PluginResult["error"]) {
       // console.log('    %s', err.message || err);
       lastError = {
         plugin,
@@ -116,23 +119,23 @@ export function run (plugins, method, file, $refs) {
       };
       runNextPlugin();
     }
-  }));
+  });
 }
 
 /**
  * Returns the value of the given property.
  * If the property is a function, then the result of the function is returned.
  * If the value is a RegExp, then it will be tested against the file URL.
- * If the value is an aray, then it will be compared against the file extension.
- *
- * @param   {object}   obj        - The object whose property/method is called
- * @param   {string}   prop       - The name of the property/method to invoke
- * @param   {object}   file       - A file info object, which will be passed to the method
- * @param   {function} [callback] - A callback function, which will be passed to the method
- * @returns {*}
+ * If the value is an array, then it will be compared against the file extension.
  */
-function getResult (obj, prop, file, callback, $refs) {
-  let value = obj[prop];
+function getResult(
+  obj: Plugin,
+  prop: keyof Plugin | keyof ResolverOptions,
+  file: FileInfo,
+  callback?: (err?: Error, result?: any) => void,
+  $refs?: any,
+) {
+  const value = obj[prop as keyof typeof obj] as unknown;
 
   if (typeof value === "function") {
     return value.apply(obj, [file, callback, $refs]);
@@ -144,11 +147,9 @@ function getResult (obj, prop, file, callback, $refs) {
     // files by RegExp or by file extension.
     if (value instanceof RegExp) {
       return value.test(file.url);
-    }
-    else if (typeof value === "string") {
+    } else if (typeof value === "string") {
       return value === file.extension;
-    }
-    else if (Array.isArray(value)) {
+    } else if (Array.isArray(value)) {
       return value.indexOf(file.extension) !== -1;
     }
   }

package/lib/util/{url.js → url.ts}

@@ -1,38 +1,33 @@
-import projectDir from "./projectDir.cjs";
+import convertPathToPosix from "./convert-path-to-posix";
+import path, { win32 } from "path";
 
-let isWindows = /^win/.test(globalThis.process ? globalThis.process.platform : undefined),
-    forwardSlashPattern = /\//g,
-    protocolPattern = /^(\w{2,}):\/\//i,
-    jsonPointerSlash = /~1/g,
-    jsonPointerTilde = /~0/g;
+const forwardSlashPattern = /\//g;
+const protocolPattern = /^(\w{2,}):\/\//i;
+const jsonPointerSlash = /~1/g;
+const jsonPointerTilde = /~0/g;
 
+import { join } from "path";
+import { isWindows } from "./is-windows";
+
+const projectDir = join(__dirname, "..", "..");
 // RegExp patterns to URL-encode special characters in local filesystem paths
-let urlEncodePatterns = [
-  /\?/g, "%3F",
-  /\#/g, "%23",
-];
+const urlEncodePatterns = [/\?/g, "%3F", /#/g, "%23"];
 
 // RegExp patterns to URL-decode special characters for local filesystem paths
-let urlDecodePatterns = [
-  /\%23/g, "#",
-  /\%24/g, "$",
-  /\%26/g, "&",
-  /\%2C/g, ",",
-  /\%40/g, "@"
-];
+const urlDecodePatterns = [/%23/g, "#", /%24/g, "$", /%26/g, "&", /%2C/g, ",", /%40/g, "@"];
 
-export const parse = (u) => new URL(u);
+export const parse = (u: any) => new URL(u);
 
 /**
  * Returns resolved target URL relative to a base URL in a manner similar to that of a Web browser resolving an anchor tag HREF.
  *
- * @return {string}
+ * @returns
  */
-export function resolve (from, to) {
-  let resolvedUrl = new URL(to, new URL(from, "resolve://"));
+export function resolve(from: any, to: any) {
+  const resolvedUrl = new URL(to, new URL(from, "resolve://"));
   if (resolvedUrl.protocol === "resolve:") {
     // `from` is a relative URL.
-    let { pathname, search, hash } = resolvedUrl;
+    const { pathname, search, hash } = resolvedUrl;
     return pathname + search + hash;
   }
   return resolvedUrl.toString();
@@ -41,20 +36,19 @@ export function resolve (from, to) {
 /**
  * Returns the current working directory (in Node) or the current page URL (in browsers).
  *
- * @returns {string}
+ * @returns
  */
-export function cwd () {
+export function cwd() {
   if (typeof window !== "undefined") {
     return location.href;
   }
 
-  let path = process.cwd();
+  const path = process.cwd();
 
-  let lastChar = path.slice(-1);
+  const lastChar = path.slice(-1);
   if (lastChar === "/" || lastChar === "\\") {
     return path;
-  }
-  else {
+  } else {
     return path + "/";
   }
 }
@@ -62,11 +56,11 @@ export function cwd () {
 /**
  * Returns the protocol of the given URL, or `undefined` if it has no protocol.
  *
- * @param   {string} path
- * @returns {?string}
+ * @param path
+ * @returns
  */
-export function getProtocol (path) {
-  let match = protocolPattern.exec(path);
+export function getProtocol(path: string | undefined) {
+  const match = protocolPattern.exec(path || "");
   if (match) {
     return match[1].toLowerCase();
   }
@@ -76,11 +70,11 @@ export function getProtocol (path) {
  * Returns the lowercased file extension of the given URL,
  * or an empty string if it has no extension.
  *
- * @param   {string} path
- * @returns {string}
+ * @param path
+ * @returns
  */
-export function getExtension (path) {
-  let lastDot = path.lastIndexOf(".");
+export function getExtension(path: any) {
+  const lastDot = path.lastIndexOf(".");
   if (lastDot >= 0) {
     return stripQuery(path.substr(lastDot).toLowerCase());
   }
@@ -90,11 +84,11 @@ export function getExtension (path) {
 /**
  * Removes the query, if any, from the given path.
  *
- * @param   {string} path
- * @returns {string}
+ * @param path
+ * @returns
  */
-export function stripQuery (path) {
-  let queryIndex = path.indexOf("?");
+export function stripQuery(path: any) {
+  const queryIndex = path.indexOf("?");
   if (queryIndex >= 0) {
     path = path.substr(0, queryIndex);
   }
@@ -105,11 +99,11 @@ export function stripQuery (path) {
  * Returns the hash (URL fragment), of the given path.
  * If there is no hash, then the root hash ("#") is returned.
  *
- * @param   {string} path
- * @returns {string}
+ * @param path
+ * @returns
  */
-export function getHash (path) {
-  let hashIndex = path.indexOf("#");
+export function getHash(path: any) {
+  const hashIndex = path.indexOf("#");
   if (hashIndex >= 0) {
     return path.substr(hashIndex);
   }
@@ -119,11 +113,11 @@ export function getHash (path) {
 /**
  * Removes the hash (URL fragment), if any, from the given path.
  *
- * @param   {string} path
- * @returns {string}
+ * @param path
+ * @returns
  */
-export function stripHash (path) {
-  let hashIndex = path.indexOf("#");
+export function stripHash(path: any) {
+  const hashIndex = path.indexOf("#");
   if (hashIndex >= 0) {
     path = path.substr(0, hashIndex);
   }
@@ -133,19 +127,17 @@ export function stripHash (path) {
 /**
  * Determines whether the given path is an HTTP(S) URL.
  *
- * @param   {string} path
- * @returns {boolean}
+ * @param path
+ * @returns
  */
-export function isHttp (path) {
-  let protocol = getProtocol(path);
+export function isHttp(path: any) {
+  const protocol = getProtocol(path);
   if (protocol === "http" || protocol === "https") {
     return true;
-  }
-  else if (protocol === undefined) {
+  } else if (protocol === undefined) {
     // There is no protocol.  If we're running in a browser, then assume it's HTTP.
     return typeof window !== "undefined";
-  }
-  else {
+  } else {
     // It's some other protocol, such as "ftp://", "mongodb://", etc.
     return false;
   }
@@ -155,17 +147,18 @@ export function isHttp (path) {
  * Determines whether the given path is a filesystem path.
  * This includes "file://" URLs.
  *
- * @param   {string} path
- * @returns {boolean}
+ * @param path
+ * @returns
  */
-export function isFileSystemPath (path) {
-  if (process.browser) {
+export function isFileSystemPath(path: string | undefined) {
+  // @ts-ignore
+  if (typeof window !== "undefined" || process.browser) {
     // We're running in a browser, so assume that all paths are URLs.
     // This way, even relative paths will be treated as URLs rather than as filesystem paths
     return false;
   }
 
-  let protocol = getProtocol(path);
+  const protocol = getProtocol(path);
   return protocol === undefined || protocol === "file";
 }
 
@@ -182,21 +175,24 @@ export function isFileSystemPath (path) {
  *    C:\\My Documents\\File (1).json   ==>   C:/My%20Documents/File%20(1).json
  *    file://Project #42/file.json      ==>   file://Project%20%2342/file.json
  *
- * @param {string} path
- * @returns {string}
+ * @param path
+ * @returns
  */
-export function fromFileSystemPath (path) {
+export function fromFileSystemPath(path: any) {
   // Step 1: On Windows, replace backslashes with forward slashes,
   // rather than encoding them as "%5C"
-  if (isWindows) {
-    const hasProjectDir = path.toUpperCase().includes(projectDir.replace(/\\/g, "\\").toUpperCase());
-    const hasProjectUri = path.toUpperCase().includes(projectDir.replace(/\\/g, "/").toUpperCase());
-    if (hasProjectDir || hasProjectUri) {
-      path = path.replace(/\\/g, "/");
-    }
-    else {
-      path = `${projectDir}/${path}`.replace(/\\/g, "/");
+  if (isWindows()) {
+    const upperPath = path.toUpperCase();
+    const projectDirPosixPath = convertPathToPosix(projectDir);
+    const posixUpper = projectDirPosixPath.toUpperCase();
+    const hasProjectDir = upperPath.includes(posixUpper);
+    const hasProjectUri = upperPath.includes(posixUpper);
+    const isAbsolutePath = win32.isAbsolute(path);
+
+    if (!(hasProjectDir || hasProjectUri || isAbsolutePath)) {
+      path = join(projectDir, path);
     }
+    path = convertPathToPosix(path);
   }
 
   // Step 2: `encodeURI` will take care of MOST characters
@@ -214,20 +210,16 @@ export function fromFileSystemPath (path) {
 
 /**
  * Converts a URL to a local filesystem path.
- *
- * @param {string}  path
- * @param {boolean} [keepFileProtocol] - If true, then "file://" will NOT be stripped
- * @returns {string}
  */
-export function toFileSystemPath (path, keepFileProtocol) {
+export function toFileSystemPath(path: string | undefined, keepFileProtocol?: boolean): string {
   // Step 1: `decodeURI` will decode characters such as Cyrillic characters, spaces, etc.
-  path = decodeURI(path);
+  path = decodeURI(path!);
 
   // Step 2: Manually decode characters that are not decoded by `decodeURI`.
   // This includes characters such as "#" and "?", which have special meaning in URLs,
   // but are just normal characters in a filesystem path.
   for (let i = 0; i < urlDecodePatterns.length; i += 2) {
-    path = path.replace(urlDecodePatterns[i], urlDecodePatterns[i + 1]);
+    path = path.replace(urlDecodePatterns[i], urlDecodePatterns[i + 1] as string);
   }
 
   // Step 3: If it's a "file://" URL, then format it consistently
@@ -238,25 +230,24 @@ export function toFileSystemPath (path, keepFileProtocol) {
     path = path[7] === "/" ? path.substr(8) : path.substr(7);
 
     // insert a colon (":") after the drive letter on Windows
-    if (isWindows && path[1] === "/") {
+    if (isWindows() && path[1] === "/") {
       path = path[0] + ":" + path.substr(1);
     }
 
     if (keepFileProtocol) {
       // Return the consistently-formatted "file://" URL
       path = "file:///" + path;
-    }
-    else {
+    } else {
       // Convert the "file://" URL to a local filesystem path.
       // On Windows, it will start with something like "C:/".
       // On Posix, it will start with "/"
       isFileUrl = false;
-      path = isWindows ? path : "/" + path;
+      path = isWindows() ? path : "/" + path;
     }
   }
 
   // Step 4: Normalize Windows paths (unless it's a "file://" URL)
-  if (isWindows && !isFileUrl) {
+  if (isWindows() && !isFileUrl) {
     // Replace forward slashes with backslashes
     path = path.replace(forwardSlashPattern, "\\");
 
@@ -272,10 +263,10 @@ export function toFileSystemPath (path, keepFileProtocol) {
 /**
  * Converts a $ref pointer to a valid JSON Path.
  *
- * @param {string}  pointer
- * @returns {Array<number | string>}
+ * @param pointer
+ * @returns
  */
-export function safePointerToPath (pointer) {
+export function safePointerToPath(pointer: any) {
   if (pointer.length <= 1 || pointer[0] !== "#" || pointer[1] !== "/") {
     return [];
   }
@@ -283,9 +274,19 @@ export function safePointerToPath (pointer) {
   return pointer
     .slice(2)
     .split("/")
-    .map((value) => {
-      return decodeURIComponent(value)
-        .replace(jsonPointerSlash, "/")
-        .replace(jsonPointerTilde, "~");
+    .map((value: any) => {
+      return decodeURIComponent(value).replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~");
     });
 }
+
+export function relative(from: string | undefined, to: string | undefined) {
+  if (!isFileSystemPath(from) || !isFileSystemPath(to)) {
+    return resolve(from, to);
+  }
+
+  const fromDir = path.dirname(stripHash(from));
+  const toPath = stripHash(to);
+
+  const result = path.relative(fromDir, toPath);
+  return result + getHash(to);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apidevtools/json-schema-ref-parser",
-  "version": "10.0.1",
+  "version": "11.0.0",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
   "keywords": [
     "json",
@@ -28,6 +28,10 @@
     {
       "name": "Jakub Rożek",
       "email": "jakub@stoplight.io"
+    },
+    {
+      "name": "JonLuca DeCaro",
+      "email": "apis@jonlu.ca"
     }
   ],
   "homepage": "https://apitools.dev/json-schema-ref-parser/",
@@ -37,67 +41,61 @@
   },
   "license": "MIT",
   "funding": "https://github.com/sponsors/philsturgeon",
-  "main": "lib/index.js",
-  "typings": "lib/index.d.ts",
-  "exports": {
-    "types": "./lib/index.d.ts",
-    "require": "./cjs/index.js",
-    "default": "./lib/index.js"
-  },
+  "types": "dist/lib/index.d.ts",
+  "main": "dist/lib/index.js",
   "browser": {
     "fs": false
   },
   "engines": {
-    "node": ">= 17"
+    "node": ">= 16"
   },
   "files": [
     "lib",
+    "dist",
     "cjs"
   ],
-  "type": "module",
   "scripts": {
-    "build": "swc ./lib/*.js -d ./cjs && swc ./lib/**/*.js -d ./cjs && copyfiles ./lib/**/*.cjs -u 1 ./cjs && node ./scripts/writeCJSPackageJSON.cjs",
-    "clean": "shx rm -rf coverage cjs",
-    "lint": "eslint lib test/fixtures test/specs",
-    "test": "npm run test:node && npm run test:typescript && npm run test:browser && npm run lint",
-    "test:node": "mocha",
-    "test:browser": "cross-env NODE_OPTIONS=--openssl-legacy-provider karma start karma.conf.cjs --single-run",
-    "test:typescript": "tsc --noEmit --strict --lib esnext,dom test/specs/typescript-definition.spec.ts",
-    "coverage": "npm run coverage:node && npm run coverage:browser",
-    "coverage:node": "c8 node_modules/mocha/bin/mocha",
-    "coverage:browser": "npm run test:browser -- --coverage",
-    "upgrade": "npm-check -u && npm audit fix"
+    "prepublishOnly": "yarn build",
+    "lint": "eslint lib",
+    "build": "rm -fr dist/* && tsc",
+    "typecheck": "tsc --noEmit",
+    "prettier": "prettier --write \"**/*.+(js|jsx|ts|tsx|har||json|css|md)\"",
+    "test": "vitest --coverage",
+    "test:node": "yarn test",
+    "test:browser": "cross-env BROWSER=\"true\" yarn test",
+    "test:update": "vitest -u",
+    "test:watch": "vitest -w"
   },
   "devDependencies": {
-    "@babel/polyfill": "^7.12.1",
-    "@chiragrupani/karma-chromium-edge-launcher": "^2.2.2",
-    "@jsdevtools/eslint-config": "^1.0.7",
-    "@jsdevtools/host-environment": "^2.1.2",
-    "@jsdevtools/karma-config": "^3.1.7",
-    "@swc/cli": "^0.1.59",
-    "@swc/core": "^1.3.25",
-    "@types/node": "^14.14.21",
-    "c8": "^7.12.0",
-    "chai": "^4.2.0",
-    "chai-subset": "^1.6.0",
-    "chokidar": "^3.5.3",
-    "copyfiles": "^2.4.1",
+    "@types/eslint": "8.44.2",
+    "@types/js-yaml": "^4.0.6",
+    "@types/node": "^20.6.2",
+    "@typescript-eslint/eslint-plugin": "^6.7.2",
+    "@typescript-eslint/eslint-plugin-tslint": "^6.7.2",
+    "@typescript-eslint/parser": "^6.7.2",
+    "@vitest/coverage-v8": "^0.34.4",
+    "abortcontroller-polyfill": "^1.7.5",
     "cross-env": "^7.0.3",
-    "eslint": "^7.18.0",
-    "isomorphic-fetch": "^3.0.0",
-    "karma": "^5.0.2",
-    "karma-cli": "^2.0.0",
-    "mocha": "^8.2.1",
-    "node-abort-controller": "^3.0.1",
-    "npm-check": "^5.9.0",
-    "shx": "^0.3.2",
-    "typescript": "^4.0.5"
+    "eslint": "^8.49.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-prettier": "^5.0.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-unused-imports": "^3.0.0",
+    "jsdom": "^22.1.0",
+    "lint-staged": "^14.0.1",
+    "node-fetch": "^3.3.2",
+    "prettier": "^3.0.3",
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.4"
   },
   "dependencies": {
     "@jsdevtools/ono": "^7.1.3",
-    "@types/json-schema": "^7.0.6",
-    "call-me-maybe": "^1.0.1",
-    "js-yaml": "^4.1.0"
+    "@types/json-schema": "^7.0.13",
+    "@types/lodash.clonedeep": "^4.5.7",
+    "js-yaml": "^4.1.0",
+    "lodash.clonedeep": "^4.5.0"
   },
   "release": {
     "branches": [