@apidevtools/json-schema-ref-parser 11.7.2 → 11.8.2

package/cjs/pointer.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _refJs = /*#__PURE__*/ _interopRequireDefault(require("./ref.js"));
+var _urlJs = /*#__PURE__*/ _interopRequireWildcard(require("./util/url.js"));
+var _errorsJs = require("./util/errors.js");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _default = Pointer;
+var slashes = /\//g;
+var tildes = /~/g;
+var escapedSlash = /~1/g;
+var escapedTilde = /~0/g;
+/**
+ * This class represents a single JSON pointer and its resolved value.
+ *
+ * @param {$Ref} $ref
+ * @param {string} path
+ * @param {string} [friendlyPath] - The original user-specified path (used for error messages)
+ * @constructor
+ */ function Pointer($ref, path, friendlyPath) {
+    /**
+   * The {@link $Ref} object that contains this {@link Pointer} object.
+   * @type {$Ref}
+   */ this.$ref = $ref;
+    /**
+   * 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.
+   * @type {string}
+   */ this.path = path;
+    /**
+   * The original path or URL, used for error messages.
+   * @type {string}
+   */ this.originalPath = friendlyPath || path;
+    /**
+   * The value of the JSON pointer.
+   * Can be any JSON type, not just objects. Unknown file types are represented as Buffers (byte arrays).
+   * @type {?*}
+   */ this.value = undefined;
+    /**
+   * Indicates whether the pointer references itself.
+   * @type {boolean}
+   */ this.circular = false;
+    /**
+   * The number of indirect references that were traversed to resolve the value.
+   * Resolving a single pointer may require resolving multiple $Refs.
+   * @type {number}
+   */ this.indirections = 0;
+}
+/**
+ * Resolves the value of a nested property within the given object.
+ *
+ * @param {*} obj - The object that will be crawled
+ * @param {$RefParserOptions} options
+ * @param {string} pathFromRoot - the path of place that initiated resolving
+ *
+ * @returns {Pointer}
+ * Returns a JSON pointer whose {@link Pointer#value} is the resolved value.
+ * If resolving this value required resolving other JSON references, then
+ * the {@link Pointer#$ref} and {@link Pointer#path} will reflect the resolution path
+ * of the resolved value.
+ */ Pointer.prototype.resolve = function(obj, options, pathFromRoot) {
+    var tokens = Pointer.parse(this.path, this.originalPath);
+    // Crawl the object, one token at a time
+    this.value = unwrapOrThrow(obj);
+    for(var i = 0; i < tokens.length; i++){
+        if (resolveIf$Ref(this, options)) {
+            // The $ref path has changed, so append the remaining tokens to the path
+            this.path = Pointer.join(this.path, tokens.slice(i));
+        }
+        if (typeof this.value === "object" && this.value !== null && "$ref" in this.value) {
+            return this;
+        }
+        var token = tokens[i];
+        if (this.value[token] === undefined || this.value[token] === null) {
+            this.value = null;
+            throw new _errorsJs.MissingPointerError(token, decodeURI(this.originalPath));
+        } else {
+            this.value = this.value[token];
+        }
+    }
+    // Resolve the final value
+    if (!this.value || this.value.$ref && _urlJs.resolve(this.path, this.value.$ref) !== pathFromRoot) {
+        resolveIf$Ref(this, options);
+    }
+    return this;
+};
+/**
+ * Sets the value of a nested property within the given object.
+ *
+ * @param {*} obj - The object that will be crawled
+ * @param {*} value - the value to assign
+ * @param {$RefParserOptions} options
+ *
+ * @returns {*}
+ * Returns the modified object, or an entirely new object if the entire object is overwritten.
+ */ Pointer.prototype.set = function(obj, value, options) {
+    var tokens = Pointer.parse(this.path);
+    var token;
+    if (tokens.length === 0) {
+        // There are no tokens, replace the entire object with the new value
+        this.value = value;
+        return value;
+    }
+    // Crawl the object, one token at a time
+    this.value = unwrapOrThrow(obj);
+    for(var i = 0; i < tokens.length - 1; i++){
+        resolveIf$Ref(this, options);
+        token = tokens[i];
+        if (this.value && this.value[token] !== undefined) {
+            // The token exists
+            this.value = this.value[token];
+        } else {
+            // The token doesn't exist, so create it
+            this.value = setValue(this, token, {});
+        }
+    }
+    // Set the value of the final token
+    resolveIf$Ref(this, options);
+    token = tokens[tokens.length - 1];
+    setValue(this, token, value);
+    // Return the updated object
+    return obj;
+};
+/**
+ * Parses a JSON pointer (or a path containing a JSON pointer in the hash)
+ * and returns an array of the pointer's tokens.
+ * (e.g. "schema.json#/definitions/person/name" => ["definitions", "person", "name"])
+ *
+ * The pointer is parsed according to RFC 6901
+ * {@link https://tools.ietf.org/html/rfc6901#section-3}
+ *
+ * @param {string} path
+ * @param {string} [originalPath]
+ * @returns {string[]}
+ */ Pointer.parse = function(path, originalPath) {
+    // Get the JSON pointer from the path's hash
+    var pointer = _urlJs.getHash(path).substr(1);
+    // If there's no pointer, then there are no tokens,
+    // so return an empty array
+    if (!pointer) {
+        return [];
+    }
+    // Split into an array
+    pointer = pointer.split("/");
+    // Decode each part, according to RFC 6901
+    for(var i = 0; i < pointer.length; i++){
+        pointer[i] = decodeURIComponent(pointer[i].replace(escapedSlash, "/").replace(escapedTilde, "~"));
+    }
+    if (pointer[0] !== "") {
+        throw new _errorsJs.InvalidPointerError(pointer, originalPath === undefined ? path : originalPath);
+    }
+    return pointer.slice(1);
+};
+/**
+ * Creates a JSON pointer path, by joining one or more tokens to a base path.
+ *
+ * @param {string} base - The base path (e.g. "schema.json#/definitions/person")
+ * @param {string|string[]} tokens - The token(s) to append (e.g. ["name", "first"])
+ * @returns {string}
+ */ Pointer.join = function(base, tokens) {
+    // Ensure that the base path contains a hash
+    if (base.indexOf("#") === -1) {
+        base += "#";
+    }
+    // Append each token to the base path
+    tokens = Array.isArray(tokens) ? tokens : [
+        tokens
+    ];
+    for(var i = 0; i < tokens.length; i++){
+        var token = tokens[i];
+        // Encode the token, according to RFC 6901
+        base += "/" + encodeURIComponent(token.replace(tildes, "~0").replace(slashes, "~1"));
+    }
+    return base;
+};
+/**
+ * If the given pointer's {@link Pointer#value} is a JSON reference,
+ * then the reference is resolved and {@link Pointer#value} is replaced with the resolved value.
+ * In addition, {@link Pointer#path} and {@link Pointer#$ref} are updated to reflect the
+ * resolution path of the new value.
+ *
+ * @param {Pointer} pointer
+ * @param {$RefParserOptions} options
+ * @returns {boolean} - Returns `true` if the resolution path changed
+ */ function resolveIf$Ref(pointer, options) {
+    // Is the value a JSON reference? (and allowed?)
+    if (_refJs.default.isAllowed$Ref(pointer.value, options)) {
+        var $refPath = _urlJs.resolve(pointer.path, pointer.value.$ref);
+        if ($refPath === pointer.path) {
+            // The value is a reference to itself, so there's nothing to do.
+            pointer.circular = true;
+        } else {
+            var resolved = pointer.$ref.$refs._resolve($refPath, pointer.path, options);
+            if (resolved === null) {
+                return false;
+            }
+            pointer.indirections += resolved.indirections + 1;
+            if (_refJs.default.isExtended$Ref(pointer.value)) {
+                // This JSON reference "extends" the resolved value, rather than simply pointing to it.
+                // So the resolved path does NOT change.  Just the value does.
+                pointer.value = _refJs.default.dereference(pointer.value, resolved.value);
+                return false;
+            } else {
+                // Resolve the reference
+                pointer.$ref = resolved.$ref;
+                pointer.path = resolved.path;
+                pointer.value = resolved.value;
+            }
+            return true;
+        }
+    }
+}
+/**
+ * Sets the specified token value of the {@link Pointer#value}.
+ *
+ * The token is evaluated according to RFC 6901.
+ * {@link https://tools.ietf.org/html/rfc6901#section-4}
+ *
+ * @param {Pointer} pointer - The JSON Pointer whose value will be modified
+ * @param {string} token - A JSON Pointer token that indicates how to modify `obj`
+ * @param {*} value - The value to assign
+ * @returns {*} - Returns the assigned value
+ */ function setValue(pointer, token, value) {
+    if (pointer.value && typeof pointer.value === "object") {
+        if (token === "-" && Array.isArray(pointer.value)) {
+            pointer.value.push(value);
+        } else {
+            pointer.value[token] = value;
+        }
+    } else {
+        throw new _errorsJs.JSONParserError('Error assigning $ref pointer "'.concat(pointer.path, '". \nCannot set "').concat(token, '" of a non-object.'));
+    }
+    return value;
+}
+function unwrapOrThrow(value) {
+    if ((0, _errorsJs.isHandledError)(value)) {
+        throw value;
+    }
+    return value;
+}

package/cjs/ref.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _pointerJs = /*#__PURE__*/ _interopRequireDefault(require("./pointer.js"));
+var _errorsJs = require("./util/errors.js");
+var _urlJs = require("./util/url.js");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+var _default = $Ref;
+/**
+ * This class represents a single JSON reference and its resolved value.
+ *
+ * @class
+ */ function $Ref() {
+    /**
+   * The file path or URL of the referenced file.
+   * This path is relative to the path of the main JSON schema file.
+   *
+   * This path does NOT contain document fragments (JSON pointers). It always references an ENTIRE file.
+   * Use methods such as {@link $Ref#get}, {@link $Ref#resolve}, and {@link $Ref#exists} to get
+   * specific JSON pointers within the file.
+   *
+   * @type {string}
+   */ this.path = undefined;
+    /**
+   * The resolved value of the JSON reference.
+   * Can be any JSON type, not just objects. Unknown file types are represented as Buffers (byte arrays).
+   *
+   * @type {?*}
+   */ this.value = undefined;
+    /**
+   * The {@link $Refs} object that contains this {@link $Ref} object.
+   *
+   * @type {$Refs}
+   */ this.$refs = undefined;
+    /**
+   * Indicates the type of {@link $Ref#path} (e.g. "file", "http", etc.)
+   *
+   * @type {?string}
+   */ this.pathType = undefined;
+    /**
+   * List of all errors. Undefined if no errors.
+   *
+   * @type {Array<JSONParserError | ResolverError | ParserError | MissingPointerError>}
+   */ this.errors = undefined;
+}
+/**
+ * Pushes an error to errors array.
+ *
+ * @param {Array<JSONParserError | JSONParserErrorGroup>} err - The error to be pushed
+ * @returns {void}
+ */ $Ref.prototype.addError = function(err) {
+    if (this.errors === undefined) {
+        this.errors = [];
+    }
+    var existingErrors = this.errors.map(function(param) {
+        var footprint = param.footprint;
+        return footprint;
+    });
+    // the path has been almost certainly set at this point,
+    // but just in case something went wrong, normalizeError injects path if necessary
+    // moreover, certain errors might point at the same spot, so filter them out to reduce noise
+    if (Array.isArray(err.errors)) {
+        var _this_errors;
+        (_this_errors = this.errors).push.apply(_this_errors, _toConsumableArray(err.errors.map(_errorsJs.normalizeError).filter(function(param) {
+            var footprint = param.footprint;
+            return !existingErrors.includes(footprint);
+        })));
+    } else if (!existingErrors.includes(err.footprint)) {
+        this.errors.push((0, _errorsJs.normalizeError)(err));
+    }
+};
+/**
+ * Determines whether the given JSON reference exists within this {@link $Ref#value}.
+ *
+ * @param {string} path - The full path being resolved, optionally with a JSON pointer in the hash
+ * @param {$RefParserOptions} options
+ * @returns {boolean}
+ */ $Ref.prototype.exists = function(path, options) {
+    try {
+        this.resolve(path, options);
+        return true;
+    } catch (e) {
+        return false;
+    }
+};
+/**
+ * Resolves the given JSON reference within this {@link $Ref#value} and returns the resolved value.
+ *
+ * @param {string} path - The full path being resolved, optionally with a JSON pointer in the hash
+ * @param {$RefParserOptions} options
+ * @returns {*} - Returns the resolved value
+ */ $Ref.prototype.get = function(path, options) {
+    return this.resolve(path, options).value;
+};
+/**
+ * Resolves the given JSON reference within this {@link $Ref#value}.
+ *
+ * @param {string} path - The full path being resolved, optionally with a JSON pointer in the hash
+ * @param {$RefParserOptions} options
+ * @param {string} friendlyPath - The original user-specified path (used for error messages)
+ *  @param {string} pathFromRoot - The path of `obj` from the schema root
+ * @returns {Pointer | null}
+ */ $Ref.prototype.resolve = function(path, options, friendlyPath, pathFromRoot) {
+    var pointer = new _pointerJs.default(this, path, friendlyPath);
+    try {
+        return pointer.resolve(this.value, options, pathFromRoot);
+    } catch (err) {
+        if (!options || !options.continueOnError || !(0, _errorsJs.isHandledError)(err)) {
+            throw err;
+        }
+        if (err.path === null) {
+            err.path = (0, _urlJs.safePointerToPath)((0, _urlJs.getHash)(pathFromRoot));
+        }
+        if (_instanceof(err, _errorsJs.InvalidPointerError)) {
+            // this is a special case - InvalidPointerError is thrown when dereferencing external file,
+            // but the issue is caused by the source file that referenced the file that undergoes dereferencing
+            err.source = decodeURI((0, _urlJs.stripHash)(pathFromRoot));
+        }
+        this.addError(err);
+        return 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.
+ *
+ * @param {string} path - The full path of the property to set, optionally with a JSON pointer in the hash
+ * @param {*} value - The value to assign
+ */ $Ref.prototype.set = function(path, value) {
+    var pointer = new _pointerJs.default(this, path);
+    this.value = pointer.set(this.value, value);
+};
+/**
+ * Determines whether the given value is a JSON reference.
+ *
+ * @param {*} value - The value to inspect
+ * @returns {boolean}
+ */ $Ref.is$Ref = function(value) {
+    return value && typeof value === "object" && typeof value.$ref === "string" && value.$ref.length > 0;
+};
+/**
+ * Determines whether the given value is an external JSON reference.
+ *
+ * @param {*} value - The value to inspect
+ * @returns {boolean}
+ */ $Ref.isExternal$Ref = function(value) {
+    return $Ref.is$Ref(value) && value.$ref[0] !== "#";
+};
+/**
+ * Determines whether the given value is a JSON reference, and whether it is allowed by the options.
+ * For example, if it references an external file, then options.resolve.external must be true.
+ *
+ * @param {*} value - The value to inspect
+ * @param {$RefParserOptions} options
+ * @returns {boolean}
+ */ $Ref.isAllowed$Ref = function(value, options) {
+    if ($Ref.is$Ref(value)) {
+        if (value.$ref.substr(0, 2) === "#/" || value.$ref === "#") {
+            // It's a JSON Pointer reference, which is always allowed
+            return true;
+        } else if (value.$ref[0] !== "#" && (!options || options.resolve.external)) {
+            // It's an external reference, which is allowed by the options
+            return true;
+        }
+    }
+};
+/**
+ * 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
+ * an existing value, this $ref actually creates a NEW value that is a shallow copy of the resolved
+ * value, plus the extra properties.
+ *
+ * @example:
+ *  {
+ *    person: {
+ *      properties: {
+ *        firstName: { type: string }
+ *        lastName: { type: string }
+ *      }
+ *    }
+ *    employee: {
+ *      properties: {
+ *        $ref: #/person/properties
+ *        salary: { type: number }
+ *      }
+ *    }
+ *  }
+ *
+ *  In this example, "employee" is an extended $ref, since it extends "person" with an additional
+ *  property (salary).  The result is a NEW value that looks like this:
+ *
+ *  {
+ *    properties: {
+ *      firstName: { type: string }
+ *      lastName: { type: string }
+ *      salary: { type: number }
+ *    }
+ *  }
+ *
+ * @param {*} value - The value to inspect
+ * @returns {boolean}
+ */ $Ref.isExtended$Ref = function(value) {
+    return $Ref.is$Ref(value) && Object.keys(value).length > 1;
+};
+/**
+ * Returns the resolved value of a JSON Reference.
+ * If necessary, the resolved value is merged with the JSON Reference to create a new object
+ *
+ * @example:
+ *  {
+ *    person: {
+ *      properties: {
+ *        firstName: { type: string }
+ *        lastName: { type: string }
+ *      }
+ *    }
+ *    employee: {
+ *      properties: {
+ *        $ref: #/person/properties
+ *        salary: { type: number }
+ *      }
+ *    }
+ *  }
+ *
+ *  When "person" and "employee" are merged, you end up with the following object:
+ *
+ *  {
+ *    properties: {
+ *      firstName: { type: string }
+ *      lastName: { type: string }
+ *      salary: { type: number }
+ *    }
+ *  }
+ *
+ * @param {object} $ref - The JSON reference object (the one with the "$ref" property)
+ * @param {*} resolvedValue - The resolved value, which can be any type
+ * @returns {*} - Returns the dereferenced value
+ */ $Ref.dereference = function($ref, resolvedValue) {
+    if (resolvedValue && typeof resolvedValue === "object" && $Ref.isExtended$Ref($ref)) {
+        var merged = {};
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = Object.keys($ref)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var key = _step.value;
+                if (key !== "$ref") {
+                    merged[key] = $ref[key];
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = Object.keys(resolvedValue)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var key1 = _step1.value;
+                if (!(key1 in merged)) {
+                    merged[key1] = resolvedValue[key1];
+                }
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
+            }
+        }
+        return merged;
+    } else {
+        // Completely replace the original reference with the resolved value
+        return resolvedValue;
+    }
+};