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

package/cjs/resolvers/http.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _ono = require("@jsdevtools/ono");
+var _urlJs = /*#__PURE__*/ _interopRequireWildcard(require("../util/url.js"));
+var _errorsJs = require("../util/errors.js");
+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 = {
+    /**
+   * 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,
+    /**
+   * 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: function canRead(file) {
+        return _urlJs.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: function read(file) {
+        var u = _urlJs.parse(file.url);
+        if (typeof window !== "undefined" && !u.protocol) {
+            // Use the protocol of the current page
+            u.protocol = _urlJs.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 = _urlJs.parse(u);
+    redirects = redirects || [];
+    redirects.push(u.href);
+    return get(u, httpOptions).then(function(res) {
+        if (res.status >= 400) {
+            throw (0, _ono.ono)({
+                status: res.statusCode
+            }, "HTTP ERROR ".concat(res.status));
+        } else if (res.status >= 300) {
+            if (redirects.length > httpOptions.redirects) {
+                throw new _errorsJs.ResolverError((0, _ono.ono)({
+                    status: res.status
+                }, "Error downloading ".concat(redirects[0], ". \nToo many redirects: \n  ").concat(redirects.join(" \n  "))));
+            } else if (!res.headers.location) {
+                throw (0, _ono.ono)({
+                    status: res.status
+                }, "HTTP ".concat(res.status, " redirect with no location header"));
+            } else {
+                // console.log('HTTP %d redirect %s -> %s', res.status, u.href, res.headers.location);
+                var redirectTo = _urlJs.resolve(u, res.headers.location);
+                return download(redirectTo, httpOptions, redirects);
+            }
+        } else {
+            return res.body ? res.arrayBuffer().then(function(buf) {
+                return Buffer.from(buf);
+            }) : Buffer.alloc(0);
+        }
+    }).catch(function(err) {
+        throw new _errorsJs.ResolverError((0, _ono.ono)(err, "Error downloading ".concat(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) {
+    var controller;
+    var timeoutId;
+    if (httpOptions.timeout) {
+        controller = new AbortController();
+        timeoutId = setTimeout(function() {
+            return controller.abort();
+        }, httpOptions.timeout);
+    }
+    return fetch(u, {
+        method: "GET",
+        headers: httpOptions.headers || {},
+        credentials: httpOptions.withCredentials ? "include" : "same-origin",
+        signal: controller ? controller.signal : null
+    }).then(function(response) {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        return response;
+    });
+}

package/cjs/util/errors.js

@@ -0,0 +1,401 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    JSONParserError: function() {
+        return JSONParserError;
+    },
+    JSONParserErrorGroup: function() {
+        return JSONParserErrorGroup;
+    },
+    ParserError: function() {
+        return ParserError;
+    },
+    UnmatchedParserError: function() {
+        return UnmatchedParserError;
+    },
+    ResolverError: function() {
+        return ResolverError;
+    },
+    UnmatchedResolverError: function() {
+        return UnmatchedResolverError;
+    },
+    MissingPointerError: function() {
+        return MissingPointerError;
+    },
+    InvalidPointerError: function() {
+        return InvalidPointerError;
+    },
+    isHandledError: function() {
+        return isHandledError;
+    },
+    normalizeError: function() {
+        return normalizeError;
+    }
+});
+var _ono = require("@jsdevtools/ono");
+var _urlJs = require("./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 _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _construct(Parent, args, Class) {
+    if (isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function _construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _setPrototypeOf(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+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 _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+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);
+}
+function _wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrapNativeSuper = function _wrapNativeSuper(Class) {
+        if (Class === null || !_isNativeFunction(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _setPrototypeOf(Wrapper, Class);
+    };
+    return _wrapNativeSuper(Class);
+}
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+var JSONParserError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(JSONParserError, Error1);
+    var _super = _createSuper(JSONParserError);
+    function JSONParserError(message, source) {
+        _classCallCheck(this, JSONParserError);
+        var _this;
+        _this = _super.call(this);
+        _this.code = "EUNKNOWN";
+        _this.message = message;
+        _this.source = source;
+        _this.path = null;
+        _ono.Ono.extend(_assertThisInitialized(_this));
+        return _this;
+    }
+    _createClass(JSONParserError, [
+        {
+            key: "footprint",
+            get: function get() {
+                return "".concat(this.path, "+").concat(this.source, "+").concat(this.code, "+").concat(this.message);
+            }
+        }
+    ]);
+    return JSONParserError;
+}(_wrapNativeSuper(Error));
+setErrorName(JSONParserError);
+var JSONParserErrorGroup = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(JSONParserErrorGroup, Error1);
+    var _super = _createSuper(JSONParserErrorGroup);
+    function JSONParserErrorGroup(parser) {
+        _classCallCheck(this, JSONParserErrorGroup);
+        var _this;
+        _this = _super.call(this);
+        _this.files = parser;
+        _this.message = "".concat(_this.errors.length, " error").concat(_this.errors.length > 1 ? "s" : "", " occurred while reading '").concat((0, _urlJs.toFileSystemPath)(parser.$refs._root$Ref.path), "'");
+        _ono.Ono.extend(_assertThisInitialized(_this));
+        return _this;
+    }
+    _createClass(JSONParserErrorGroup, [
+        {
+            key: "errors",
+            get: function get() {
+                return JSONParserErrorGroup.getParserErrors(this.files);
+            }
+        }
+    ], [
+        {
+            key: "getParserErrors",
+            value: function getParserErrors(parser) {
+                var errors = [];
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = Object.values(parser.$refs._$refs)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var $ref = _step.value;
+                        if ($ref.errors) {
+                            var _errors;
+                            (_errors = errors).push.apply(_errors, _toConsumableArray($ref.errors));
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return errors;
+            }
+        }
+    ]);
+    return JSONParserErrorGroup;
+}(_wrapNativeSuper(Error));
+setErrorName(JSONParserErrorGroup);
+var ParserError = /*#__PURE__*/ function(JSONParserError) {
+    "use strict";
+    _inherits(ParserError, JSONParserError);
+    var _super = _createSuper(ParserError);
+    function ParserError(message, source) {
+        _classCallCheck(this, ParserError);
+        var _this;
+        _this = _super.call(this, "Error parsing ".concat(source, ": ").concat(message), source);
+        _this.code = "EPARSER";
+        return _this;
+    }
+    return ParserError;
+}(JSONParserError);
+setErrorName(ParserError);
+var UnmatchedParserError = /*#__PURE__*/ function(JSONParserError) {
+    "use strict";
+    _inherits(UnmatchedParserError, JSONParserError);
+    var _super = _createSuper(UnmatchedParserError);
+    function UnmatchedParserError(source) {
+        _classCallCheck(this, UnmatchedParserError);
+        var _this;
+        _this = _super.call(this, 'Could not find parser for "'.concat(source, '"'), source);
+        _this.code = "EUNMATCHEDPARSER";
+        return _this;
+    }
+    return UnmatchedParserError;
+}(JSONParserError);
+setErrorName(UnmatchedParserError);
+var ResolverError = /*#__PURE__*/ function(JSONParserError) {
+    "use strict";
+    _inherits(ResolverError, JSONParserError);
+    var _super = _createSuper(ResolverError);
+    function ResolverError(ex, source) {
+        _classCallCheck(this, ResolverError);
+        var _this;
+        _this = _super.call(this, ex.message || 'Error reading file "'.concat(source, '"'), source);
+        _this.code = "ERESOLVER";
+        if ("code" in ex) {
+            _this.ioErrorCode = String(ex.code);
+        }
+        return _this;
+    }
+    return ResolverError;
+}(JSONParserError);
+setErrorName(ResolverError);
+var UnmatchedResolverError = /*#__PURE__*/ function(JSONParserError) {
+    "use strict";
+    _inherits(UnmatchedResolverError, JSONParserError);
+    var _super = _createSuper(UnmatchedResolverError);
+    function UnmatchedResolverError(source) {
+        _classCallCheck(this, UnmatchedResolverError);
+        var _this;
+        _this = _super.call(this, 'Could not find resolver for "'.concat(source, '"'), source);
+        _this.code = "EUNMATCHEDRESOLVER";
+        return _this;
+    }
+    return UnmatchedResolverError;
+}(JSONParserError);
+setErrorName(UnmatchedResolverError);
+var MissingPointerError = /*#__PURE__*/ function(JSONParserError) {
+    "use strict";
+    _inherits(MissingPointerError, JSONParserError);
+    var _super = _createSuper(MissingPointerError);
+    function MissingPointerError(token, path) {
+        _classCallCheck(this, MissingPointerError);
+        var _this;
+        _this = _super.call(this, 'Token "'.concat(token, '" does not exist.'), (0, _urlJs.stripHash)(path));
+        _this.code = "EMISSINGPOINTER";
+        return _this;
+    }
+    return MissingPointerError;
+}(JSONParserError);
+setErrorName(MissingPointerError);
+var InvalidPointerError = /*#__PURE__*/ function(JSONParserError) {
+    "use strict";
+    _inherits(InvalidPointerError, JSONParserError);
+    var _super = _createSuper(InvalidPointerError);
+    function InvalidPointerError(pointer, path) {
+        _classCallCheck(this, InvalidPointerError);
+        var _this;
+        _this = _super.call(this, 'Invalid $ref pointer "'.concat(pointer, '". Pointers must begin with "#/"'), (0, _urlJs.stripHash)(path));
+        _this.code = "EINVALIDPOINTER";
+        return _this;
+    }
+    return InvalidPointerError;
+}(JSONParserError);
+setErrorName(InvalidPointerError);
+function setErrorName(err) {
+    Object.defineProperty(err.prototype, "name", {
+        value: err.name,
+        enumerable: true
+    });
+}
+function isHandledError(err) {
+    return _instanceof(err, JSONParserError) || _instanceof(err, JSONParserErrorGroup);
+}
+function normalizeError(err) {
+    if (err.path === null) {
+        err.path = [];
+    }
+    return err;
+}