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

package/lib/refs.js

@@ -1,196 +0,0 @@
-import { ono } from "@jsdevtools/ono";
-import $Ref from "./ref.js";
-import * as url from "./util/url.js";
-
-const isWindows = /^win/.test(globalThis.process ? globalThis.process.platform : undefined);
-const getPathFromOs = filePath => isWindows ? filePath.replace(/\\/g, "/") : filePath;
-
-/**
- * This class is a map of JSON references and their resolved values.
- */
-export default function $Refs () {
-  /**
-   * Indicates whether the schema contains any circular references.
-   *
-   * @type {boolean}
-   */
-  this.circular = false;
-
-  /**
-   * A map of paths/urls to {@link $Ref} objects
-   *
-   * @type {object}
-   * @protected
-   */
-  this._$refs = {};
-
-  /**
-   * The {@link $Ref} object that is the root of the JSON schema.
-   *
-   * @type {$Ref}
-   * @protected
-   */
-  this._root$Ref = null;
-}
-
-/**
- * Returns the paths of all the files/URLs that are referenced by the JSON schema,
- * including the schema itself.
- *
- * @param {...string|string[]} [types] - Only return paths of the given types ("file", "http", etc.)
- * @returns {string[]}
- */
-$Refs.prototype.paths = function (types) {    // eslint-disable-line no-unused-vars
-  let paths = getPaths(this._$refs, arguments);
-  return paths.map((path) => {
-    return getPathFromOs(path.decoded);
-  });
-};
-
-/**
- * Returns the map of JSON references and their resolved values.
- *
- * @param {...string|string[]} [types] - Only return references of the given types ("file", "http", etc.)
- * @returns {object}
- */
-$Refs.prototype.values = function (types) {   // eslint-disable-line no-unused-vars
-  let $refs = this._$refs;
-  let paths = getPaths($refs, arguments);
-  return paths.reduce((obj, path) => {
-    obj[getPathFromOs(path.decoded)] = $refs[path.encoded].value;
-    return obj;
-  }, {});
-};
-
-/**
- * Returns a POJO (plain old JavaScript object) for serialization as JSON.
- *
- * @returns {object}
- */
-$Refs.prototype.toJSON = $Refs.prototype.values;
-
-/**
- * Determines whether the given JSON reference exists.
- *
- * @param {string} path - The path being resolved, optionally with a JSON pointer in the hash
- * @param {$RefParserOptions} [options]
- * @returns {boolean}
- */
-$Refs.prototype.exists = function (path, options) {
-  try {
-    this._resolve(path, "", options);
-    return true;
-  }
-  catch (e) {
-    return false;
-  }
-};
-
-/**
- * Resolves the given JSON reference and returns the resolved value.
- *
- * @param {string} path - The path being resolved, with a JSON pointer in the hash
- * @param {$RefParserOptions} [options]
- * @returns {*} - Returns the resolved value
- */
-$Refs.prototype.get = function (path, options) {
-  return this._resolve(path, "", options).value;
-};
-
-/**
- * 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.
- *
- * @param {string} path - The path of the property to set, optionally with a JSON pointer in the hash
- * @param {*} value - The value to assign
- */
-$Refs.prototype.set = function (path, value) {
-  let absPath = url.resolve(this._root$Ref.path, path);
-  let withoutHash = url.stripHash(absPath);
-  let $ref = this._$refs[withoutHash];
-
-  if (!$ref) {
-    throw ono(`Error resolving $ref pointer "${path}". \n"${withoutHash}" not found.`);
-  }
-
-  $ref.set(absPath, value);
-};
-
-/**
- * Creates a new {@link $Ref} object and adds it to this {@link $Refs} object.
- *
- * @param {string} path  - The file path or URL of the referenced file
- */
-$Refs.prototype._add = function (path) {
-  let withoutHash = url.stripHash(path);
-
-  let $ref = new $Ref();
-  $ref.path = withoutHash;
-  $ref.$refs = this;
-
-  this._$refs[withoutHash] = $ref;
-  this._root$Ref = this._root$Ref || $ref;
-
-  return $ref;
-};
-
-/**
- * Resolves the given JSON reference.
- *
- * @param {string} path - The path being resolved, optionally with a JSON pointer in the hash
- * @param {string} pathFromRoot - The path of `obj` from the schema root
- * @param {$RefParserOptions} [options]
- * @returns {Pointer}
- * @protected
- */
-$Refs.prototype._resolve = function (path, pathFromRoot, options) {
-  let absPath = url.resolve(this._root$Ref.path, path);
-  let withoutHash = url.stripHash(absPath);
-  let $ref = this._$refs[withoutHash];
-
-  if (!$ref) {
-    throw ono(`Error resolving $ref pointer "${path}". \n"${withoutHash}" not found.`);
-  }
-
-  return $ref.resolve(absPath, options, path, pathFromRoot);
-};
-
-/**
- * Returns the specified {@link $Ref} object, or undefined.
- *
- * @param {string} path - The path being resolved, optionally with a JSON pointer in the hash
- * @returns {$Ref|undefined}
- * @protected
- */
-$Refs.prototype._get$Ref = function (path) {
-  path = url.resolve(this._root$Ref.path, path);
-  let withoutHash = url.stripHash(path);
-  return this._$refs[withoutHash];
-};
-
-/**
- * Returns the encoded and decoded paths keys of the given object.
- *
- * @param {object} $refs - The object whose keys are URL-encoded paths
- * @param {...string|string[]} [types] - Only return paths of the given types ("file", "http", etc.)
- * @returns {object[]}
- */
-function getPaths ($refs, types) {
-  let paths = Object.keys($refs);
-
-  // Filter the paths by type
-  types = Array.isArray(types[0]) ? types[0] : Array.prototype.slice.call(types);
-  if (types.length > 0 && types[0]) {
-    paths = paths.filter((key) => {
-      return types.indexOf($refs[key].pathType) !== -1;
-    });
-  }
-
-  // Decode local filesystem paths
-  return paths.map((path) => {
-    return {
-      encoded: path,
-      decoded: $refs[path].pathType === "file" ? url.toFileSystemPath(path, true) : path
-    };
-  });
-}

package/lib/resolvers/file.js

@@ -1,63 +0,0 @@
-import fs from "fs";
-import { ono } from "@jsdevtools/ono";
-import * as url from "../util/url.js";
-import { ResolverError } from "../util/errors.js";
-
-export default {
-  /**
-   * The order that this resolver will run, in relation to other resolvers.
-   *
-   * @type {number}
-   */
-  order: 100,
-
-  /**
-   * Determines whether this resolver can read a given file reference.
-   * Resolvers that return true will be tried, in order, until one successfully resolves the file.
-   * Resolvers that return false will not be given a chance to resolve the file.
-   *
-   * @param {object} file           - An object containing information about the referenced file
-   * @param {string} file.url       - The full URL of the referenced file
-   * @param {string} file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
-   * @returns {boolean}
-   */
-  canRead (file) {
-    return url.isFileSystemPath(file.url);
-  },
-
-  /**
-   * Reads the given file and returns its raw contents as a Buffer.
-   *
-   * @param {object} file           - An object containing information about the referenced file
-   * @param {string} file.url       - The full URL of the referenced file
-   * @param {string} file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
-   * @returns {Promise<Buffer>}
-   */
-  read (file) {
-    return new Promise(((resolve, reject) => {
-      let path;
-      try {
-        path = url.toFileSystemPath(file.url);
-      }
-      catch (err) {
-        reject(new ResolverError(ono.uri(err, `Malformed URI: ${file.url}`), file.url));
-      }
-
-      // console.log('Opening file: %s', path);
-
-      try {
-        fs.readFile(path, (err, data) => {
-          if (err) {
-            reject(new ResolverError(ono(err, `Error opening file "${path}"`), path));
-          }
-          else {
-            resolve(data);
-          }
-        });
-      }
-      catch (err) {
-        reject(new ResolverError(ono(err, `Error opening file "${path}"`), path));
-      }
-    }));
-  }
-};

package/lib/resolvers/http.js

@@ -1,155 +0,0 @@
-import { ono } from "@jsdevtools/ono";
-import * as url from "../util/url.js";
-import { ResolverError } from "../util/errors.js";
-
-export default {
-  /**
-   * The order that this resolver will run, in relation to other resolvers.
-   *
-   * @type {number}
-   */
-  order: 200,
-
-  /**
-   * HTTP headers to send when downloading files.
-   *
-   * @example:
-   * {
-   *   "User-Agent": "JSON Schema $Ref Parser",
-   *   Accept: "application/json"
-   * }
-   *
-   * @type {object}
-   */
-  headers: null,
-
-  /**
-   * HTTP request timeout (in milliseconds).
-   *
-   * @type {number}
-   */
-  timeout: 5000, // 5 seconds
-
-  /**
-   * The maximum number of HTTP redirects to follow.
-   * To disable automatic following of redirects, set this to zero.
-   *
-   * @type {number}
-   */
-  redirects: 5,
-
-  /**
-   * The `withCredentials` option of XMLHttpRequest.
-   * Set this to `true` if you're downloading files from a CORS-enabled server that requires authentication
-   *
-   * @type {boolean}
-   */
-  withCredentials: false,
-
-  /**
-   * Determines whether this resolver can read a given file reference.
-   * Resolvers that return true will be tried in order, until one successfully resolves the file.
-   * Resolvers that return false will not be given a chance to resolve the file.
-   *
-   * @param {object} file           - An object containing information about the referenced file
-   * @param {string} file.url       - The full URL of the referenced file
-   * @param {string} file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
-   * @returns {boolean}
-   */
-  canRead (file) {
-    return url.isHttp(file.url);
-  },
-
-  /**
-   * Reads the given URL and returns its raw contents as a Buffer.
-   *
-   * @param {object} file           - An object containing information about the referenced file
-   * @param {string} file.url       - The full URL of the referenced file
-   * @param {string} file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
-   * @returns {Promise<Buffer>}
-   */
-  read (file) {
-    let u = url.parse(file.url);
-
-    if (typeof window !== "undefined" && !u.protocol) {
-      // Use the protocol of the current page
-      u.protocol = url.parse(location.href).protocol;
-    }
-
-    return download(u, this);
-  }
-};
-
-/**
- * Downloads the given file.
- *
- * @param {Url|string} u        - The url to download (can be a parsed {@link Url} object)
- * @param {object} httpOptions  - The `options.resolve.http` object
- * @param {number} [redirects]  - The redirect URLs that have already been followed
- *
- * @returns {Promise<Buffer>}
- * The promise resolves with the raw downloaded data, or rejects if there is an HTTP error.
- */
-function download (u, httpOptions, redirects) {
-  u = url.parse(u);
-  redirects = redirects || [];
-  redirects.push(u.href);
-
-  return get(u, httpOptions)
-    .then((res) => {
-      if (res.status >= 400) {
-        throw ono({ status: res.statusCode }, `HTTP ERROR ${res.status}`);
-      }
-      else if (res.status >= 300) {
-        if (redirects.length > httpOptions.redirects) {
-          throw new ResolverError(ono({ status: res.status },
-            `Error downloading ${redirects[0]}. \nToo many redirects: \n  ${redirects.join(" \n  ")}`));
-        }
-        else if (!res.headers.location) {
-          throw ono({ status: res.status }, `HTTP ${res.status} redirect with no location header`);
-        }
-        else {
-          // console.log('HTTP %d redirect %s -> %s', res.status, u.href, res.headers.location);
-          let redirectTo = url.resolve(u, res.headers.location);
-          return download(redirectTo, httpOptions, redirects);
-        }
-      }
-      else {
-        return res.body ? res.arrayBuffer().then(buf => Buffer.from(buf)) : Buffer.alloc(0);
-      }
-    })
-    .catch((err) => {
-      throw new ResolverError(ono(err, `Error downloading ${u.href}`), u.href);
-    });
-}
-
-/**
- * Sends an HTTP GET request.
- *
- * @param {Url} u - A parsed {@link Url} object
- * @param {object} httpOptions - The `options.resolve.http` object
- *
- * @returns {Promise<Response>}
- * The promise resolves with the HTTP Response object.
- */
-function get (u, httpOptions) {
-  let controller;
-  let timeoutId;
-  if (httpOptions.timeout) {
-    controller = new AbortController();
-    timeoutId = setTimeout(() => controller.abort(), httpOptions.timeout);
-  }
-
-  return fetch(u, {
-    method: "GET",
-    headers: httpOptions.headers || {},
-    credentials: httpOptions.withCredentials ? "include" : "same-origin",
-    signal: controller ? controller.signal : null,
-  }).then(response => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-
-    return response;
-  });
-}

package/lib/util/errors.js

@@ -1,134 +0,0 @@
-import { Ono } from "@jsdevtools/ono";
-
-import { stripHash, toFileSystemPath } from "./url.js";
-
-export const JSONParserError = class JSONParserError extends Error {
-  constructor (message, source) {
-    super();
-
-    this.code = "EUNKNOWN";
-    this.message = message;
-    this.source = source;
-    this.path = null;
-
-    Ono.extend(this);
-  }
-
-  get footprint () {
-    return `${this.path}+${this.source}+${this.code}+${this.message}`;
-  }
-};
-
-setErrorName(JSONParserError);
-
-export const JSONParserErrorGroup = class JSONParserErrorGroup extends Error {
-  constructor (parser) {
-    super();
-
-    this.files = parser;
-    this.message = `${this.errors.length} error${this.errors.length > 1 ? "s" : ""} occurred while reading '${toFileSystemPath(parser.$refs._root$Ref.path)}'`;
-
-    Ono.extend(this);
-  }
-
-  static getParserErrors (parser) {
-    const errors = [];
-
-    for (const $ref of Object.values(parser.$refs._$refs)) {
-      if ($ref.errors) {
-        errors.push(...$ref.errors);
-      }
-    }
-
-    return errors;
-  }
-
-  get errors () {
-    return JSONParserErrorGroup.getParserErrors(this.files);
-  }
-};
-
-setErrorName(JSONParserErrorGroup);
-
-export const ParserError = class ParserError extends JSONParserError {
-  constructor (message, source) {
-    super(`Error parsing ${source}: ${message}`, source);
-
-    this.code = "EPARSER";
-  }
-};
-
-setErrorName(ParserError);
-
-export const UnmatchedParserError = class UnmatchedParserError extends JSONParserError {
-  constructor (source) {
-    super(`Could not find parser for "${source}"`, source);
-
-    this.code = "EUNMATCHEDPARSER";
-  }
-};
-
-setErrorName(UnmatchedParserError);
-
-export const ResolverError = class ResolverError extends JSONParserError {
-  constructor (ex, source) {
-    super(ex.message || `Error reading file "${source}"`, source);
-
-    this.code = "ERESOLVER";
-
-    if ("code" in ex) {
-      this.ioErrorCode = String(ex.code);
-    }
-  }
-};
-
-setErrorName(ResolverError);
-
-export const UnmatchedResolverError = class UnmatchedResolverError extends JSONParserError {
-  constructor (source) {
-    super(`Could not find resolver for "${source}"`, source);
-
-    this.code = "EUNMATCHEDRESOLVER";
-  }
-};
-
-setErrorName(UnmatchedResolverError);
-
-export const MissingPointerError = class MissingPointerError extends JSONParserError {
-  constructor (token, path) {
-    super(`Token "${token}" does not exist.`, stripHash(path));
-
-    this.code = "EMISSINGPOINTER";
-  }
-};
-
-setErrorName(MissingPointerError);
-
-export const InvalidPointerError = class InvalidPointerError extends JSONParserError {
-  constructor (pointer, path) {
-    super(`Invalid $ref pointer "${pointer}". Pointers must begin with "#/"`, stripHash(path));
-
-    this.code = "EINVALIDPOINTER";
-  }
-};
-
-setErrorName(InvalidPointerError);
-
-function setErrorName (err) {
-  Object.defineProperty(err.prototype, "name", {
-    value: err.name,
-    enumerable: true,
-  });
-}
-
-export function isHandledError (err) {
-  return err instanceof JSONParserError || err instanceof JSONParserErrorGroup;
-}
-
-export function normalizeError (err) {
-  if (err.path === null) {
-    err.path = [];
-  }
-
-  return err;
-}

package/lib/util/projectDir.cjs

@@ -1,6 +0,0 @@
-const nodePath = require("path");
-
-// Webpack 4 (used by browser tests) can't transpile import.meta.url
-// So export the project directory using __dirname from a .cjs module
-const projectDir = nodePath.resolve(__dirname, "..", "..");
-module.exports = projectDir