@apidevtools/json-schema-ref-parser 9.1.0 → 10.0.0

package/cjs/util/plugins.js

@@ -0,0 +1,159 @@
+/**
+ * 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[]}
+ */ "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, {
+    all: function() {
+        return all;
+    },
+    filter: function() {
+        return filter;
+    },
+    sort: function() {
+        return sort;
+    },
+    run: function() {
+        return run;
+    }
+});
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function all(plugins) {
+    return Object.keys(plugins).filter(function(key) {
+        return typeof plugins[key] === "object";
+    }).map(function(key) {
+        plugins[key].name = key;
+        return plugins[key];
+    });
+}
+function filter(plugins, method, file) {
+    return plugins.filter(function(plugin) {
+        return !!getResult(plugin, method, file);
+    });
+}
+function sort(plugins) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = plugins[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var plugin = _step.value;
+            plugin.order = plugin.order || Number.MAX_SAFE_INTEGER;
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return plugins.sort(function(a, b) {
+        return a.order - b.order;
+    });
+}
+function run(plugins, method, file, $refs) {
+    var plugin, lastError, index = 0;
+    return new Promise(function(resolve, reject) {
+        var runNextPlugin = function runNextPlugin() {
+            plugin = plugins[index++];
+            if (!plugin) {
+                // There are no more functions, so re-throw the last error
+                return reject(lastError);
+            }
+            try {
+                // console.log('  %s', plugin.name);
+                var 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) {
+                    // A synchronous result was returned
+                    onSuccess(result);
+                } else if (index === plugins.length) {
+                    throw new Error("No promise has been returned or callback has been called.");
+                }
+            } catch (e) {
+                onError(e);
+            }
+        };
+        var callback = function callback(err, result) {
+            if (err) {
+                onError(err);
+            } else {
+                onSuccess(result);
+            }
+        };
+        var onSuccess = function onSuccess(result) {
+            // console.log('    success');
+            resolve({
+                plugin: plugin,
+                result: result
+            });
+        };
+        var onError = function onError(error) {
+            // console.log('    %s', err.message || err);
+            lastError = {
+                plugin: plugin,
+                error: error
+            };
+            runNextPlugin();
+        };
+        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 {*}
+ */ function getResult(obj, prop, file, callback, $refs) {
+    var value = obj[prop];
+    if (typeof value === "function") {
+        return value.apply(obj, [
+            file,
+            callback,
+            $refs
+        ]);
+    }
+    if (!callback) {
+        // The synchronous plugin functions (canParse and canRead)
+        // allow a "shorthand" syntax, where the user can match
+        // files by RegExp or by file extension.
+        if (_instanceof(value, RegExp)) {
+            return value.test(file.url);
+        } else if (typeof value === "string") {
+            return value === file.extension;
+        } else if (Array.isArray(value)) {
+            return value.indexOf(file.extension) !== -1;
+        }
+    }
+    return value;
+}

package/cjs/util/projectDir.cjs

@@ -0,0 +1,6 @@
+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

package/cjs/util/url.js

@@ -0,0 +1,228 @@
+"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, {
+    parse: function() {
+        return parse;
+    },
+    resolve: function() {
+        return resolve;
+    },
+    cwd: function() {
+        return cwd;
+    },
+    getProtocol: function() {
+        return getProtocol;
+    },
+    getExtension: function() {
+        return getExtension;
+    },
+    stripQuery: function() {
+        return stripQuery;
+    },
+    getHash: function() {
+        return getHash;
+    },
+    stripHash: function() {
+        return stripHash;
+    },
+    isHttp: function() {
+        return isHttp;
+    },
+    isFileSystemPath: function() {
+        return isFileSystemPath;
+    },
+    fromFileSystemPath: function() {
+        return fromFileSystemPath;
+    },
+    toFileSystemPath: function() {
+        return toFileSystemPath;
+    },
+    safePointerToPath: function() {
+        return safePointerToPath;
+    }
+});
+var _projectDirCjs = /*#__PURE__*/ _interopRequireDefault(require("./projectDir.cjs"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var isWindows = /^win/.test(globalThis.process ? globalThis.process.platform : undefined), forwardSlashPattern = /\//g, protocolPattern = /^(\w{2,}):\/\//i, jsonPointerSlash = /~1/g, jsonPointerTilde = /~0/g;
+// RegExp patterns to URL-encode special characters in local filesystem paths
+var urlEncodePatterns = [
+    /\?/g,
+    "%3F",
+    /\#/g,
+    "%23"
+];
+// RegExp patterns to URL-decode special characters for local filesystem paths
+var urlDecodePatterns = [
+    /\%23/g,
+    "#",
+    /\%24/g,
+    "$",
+    /\%26/g,
+    "&",
+    /\%2C/g,
+    ",",
+    /\%40/g,
+    "@"
+];
+var parse = function(u) {
+    return new URL(u);
+};
+function resolve(from, to) {
+    var resolvedUrl = new URL(to, new URL(from, "resolve://"));
+    if (resolvedUrl.protocol === "resolve:") {
+        // `from` is a relative URL.
+        var pathname = resolvedUrl.pathname, search = resolvedUrl.search, hash = resolvedUrl.hash;
+        return pathname + search + hash;
+    }
+    return resolvedUrl.toString();
+}
+function cwd() {
+    if (typeof window !== "undefined") {
+        return location.href;
+    }
+    var path = process.cwd();
+    var lastChar = path.slice(-1);
+    if (lastChar === "/" || lastChar === "\\") {
+        return path;
+    } else {
+        return path + "/";
+    }
+}
+function getProtocol(path) {
+    var match = protocolPattern.exec(path);
+    if (match) {
+        return match[1].toLowerCase();
+    }
+}
+function getExtension(path) {
+    var lastDot = path.lastIndexOf(".");
+    if (lastDot >= 0) {
+        return stripQuery(path.substr(lastDot).toLowerCase());
+    }
+    return "";
+}
+function stripQuery(path) {
+    var queryIndex = path.indexOf("?");
+    if (queryIndex >= 0) {
+        path = path.substr(0, queryIndex);
+    }
+    return path;
+}
+function getHash(path) {
+    var hashIndex = path.indexOf("#");
+    if (hashIndex >= 0) {
+        return path.substr(hashIndex);
+    }
+    return "#";
+}
+function stripHash(path) {
+    var hashIndex = path.indexOf("#");
+    if (hashIndex >= 0) {
+        path = path.substr(0, hashIndex);
+    }
+    return path;
+}
+function isHttp(path) {
+    var protocol = getProtocol(path);
+    if (protocol === "http" || protocol === "https") {
+        return true;
+    } 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 {
+        // It's some other protocol, such as "ftp://", "mongodb://", etc.
+        return false;
+    }
+}
+function isFileSystemPath(path) {
+    if (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;
+    }
+    var protocol = getProtocol(path);
+    return protocol === undefined || protocol === "file";
+}
+function fromFileSystemPath(path) {
+    // Step 1: On Windows, replace backslashes with forward slashes,
+    // rather than encoding them as "%5C"
+    if (isWindows) {
+        var hasProjectDir = path.toUpperCase().includes(_projectDirCjs.default.replace(/\\/g, "\\").toUpperCase());
+        var hasProjectUri = path.toUpperCase().includes(_projectDirCjs.default.replace(/\\/g, "/").toUpperCase());
+        if (hasProjectDir || hasProjectUri) {
+            path = path.replace(/\\/g, "/");
+        } else {
+            path = "".concat(_projectDirCjs.default, "/").concat(path).replace(/\\/g, "/");
+        }
+    }
+    // Step 2: `encodeURI` will take care of MOST characters
+    path = encodeURI(path);
+    // Step 3: Manually encode characters that are not encoded by `encodeURI`.
+    // This includes characters such as "#" and "?", which have special meaning in URLs,
+    // but are just normal characters in a filesystem path.
+    for(var i = 0; i < urlEncodePatterns.length; i += 2){
+        path = path.replace(urlEncodePatterns[i], urlEncodePatterns[i + 1]);
+    }
+    return path;
+}
+function toFileSystemPath(path, keepFileProtocol) {
+    // Step 1: `decodeURI` will decode characters such as Cyrillic characters, spaces, etc.
+    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(var i = 0; i < urlDecodePatterns.length; i += 2){
+        path = path.replace(urlDecodePatterns[i], urlDecodePatterns[i + 1]);
+    }
+    // Step 3: If it's a "file://" URL, then format it consistently
+    // or convert it to a local filesystem path
+    var isFileUrl = path.substr(0, 7).toLowerCase() === "file://";
+    if (isFileUrl) {
+        // Strip-off the protocol, and the initial "/", if there is one
+        path = path[7] === "/" ? path.substr(8) : path.substr(7);
+        // insert a colon (":") after the drive letter on Windows
+        if (isWindows && path[1] === "/") {
+            path = path[0] + ":" + path.substr(1);
+        }
+        if (keepFileProtocol) {
+            // Return the consistently-formatted "file://" URL
+            path = "file:///" + path;
+        } 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;
+        }
+    }
+    // Step 4: Normalize Windows paths (unless it's a "file://" URL)
+    if (isWindows && !isFileUrl) {
+        // Replace forward slashes with backslashes
+        path = path.replace(forwardSlashPattern, "\\");
+        // Capitalize the drive letter
+        if (path.substr(1, 2) === ":\\") {
+            path = path[0].toUpperCase() + path.substr(1);
+        }
+    }
+    return path;
+}
+function safePointerToPath(pointer) {
+    if (pointer.length <= 1 || pointer[0] !== "#" || pointer[1] !== "/") {
+        return [];
+    }
+    return pointer.slice(2).split("/").map(function(value) {
+        return decodeURIComponent(value).replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~");
+    });
+}

package/lib/bundle.js

@@ -1,10 +1,8 @@
-"use strict";
+import $Ref from "./ref.js";
+import Pointer from "./pointer.js";
+import * as url from "./util/url.js";
 
-const $Ref = require("./ref");
-const Pointer = require("./pointer");
-const url = require("./util/url");
-
-module.exports = bundle;
+export default bundle;
 
 /**
  * Bundles all external JSON references into the main JSON schema, thus resulting in a schema that
@@ -135,7 +133,7 @@ function inventory$Ref ($refParent, $refKey, path, pathFromRoot, indirections, i
   });
 
   // Recursively crawl the resolved value
-  if (!existingEntry) {
+  if (!existingEntry || external) {
     crawl(pointer.value, null, pointer.path, pathFromRoot, indirections + 1, inventory, $refs, options);
   }
 }

package/lib/dereference.js

@@ -1,11 +1,9 @@
-"use strict";
+import $Ref from "./ref.js";
+import Pointer from "./pointer.js";
+import { ono } from "@jsdevtools/ono";
+import * as url from "./util/url.js";
 
-const $Ref = require("./ref");
-const Pointer = require("./pointer");
-const { ono } = require("@jsdevtools/ono");
-const url = require("./util/url");
-
-module.exports = dereference;
+export default dereference;
 
 /**
  * Crawls the JSON schema, finds all JSON references, and dereferences them.
@@ -71,6 +69,9 @@ function crawl (obj, path, pathFromRoot, parents, processedObjects, dereferenced
             // 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]);
+              }
             }
           }
           else {

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { JSONSchema4, JSONSchema4Type, JSONSchema6, JSONSchema6Type, JSONSchema7, JSONSchema7Type } from "json-schema";
+import { JSONSchema4, JSONSchema4Object, JSONSchema4Type, JSONSchema6, JSONSchema6Object, JSONSchema6Type, JSONSchema7, JSONSchema7Object, JSONSchema7Type } from "json-schema";
 
 export = $RefParser;
 
@@ -174,6 +174,7 @@ declare class $RefParser {
 declare namespace $RefParser {
 
   export type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
+  export type JSONSchemaObject = JSONSchema4Object | JSONSchema6Object | JSONSchema7Object;
   export type SchemaCallback = (err: Error | null, schema?: JSONSchema) => any;
   export type $RefsCallback = (err: Error | null, $refs?: $Refs) => any;
 
@@ -238,6 +239,14 @@ declare namespace $RefParser {
        * subpaths contain literal $ref keys that should not be dereferenced.
        */
       excludedPathMatcher?(path: string): boolean;
+
+      /**
+       * Callback invoked during dereferencing.
+       *
+       * @argument {string} path The path being dereferenced (ie. the `$ref` string).
+       * @argument {JSONSchemaObject} object The JSON-Schema that the `$ref` resolved to.
+       */
+      onDereference(path: string, value: JSONSchemaObject): void;
     };
   }
 

package/lib/index.js

@@ -1,26 +1,23 @@
 /* eslint-disable no-unused-vars */
-"use strict";
+import $Refs from "./refs.js";
+import _parse from "./parse.js";
+import normalizeArgs from "./normalize-args.js";
+import resolveExternal from "./resolve-external.js";
+import _bundle from "./bundle.js";
+import _dereference from "./dereference.js";
+import * as url from "./util/url.js";
+import { JSONParserError, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError, JSONParserErrorGroup } from "./util/errors.js";
+import maybe from "call-me-maybe";
+import { ono } from "@jsdevtools/ono";
 
-const $Refs = require("./refs");
-const _parse = require("./parse");
-const normalizeArgs = require("./normalize-args");
-const resolveExternal = require("./resolve-external");
-const _bundle = require("./bundle");
-const _dereference = require("./dereference");
-const url = require("./util/url");
-const { JSONParserError, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError, JSONParserErrorGroup } = require("./util/errors");
-const maybe = require("call-me-maybe");
-const { ono } = require("@jsdevtools/ono");
-
-module.exports = $RefParser;
-module.exports.default = $RefParser;
-module.exports.JSONParserError = JSONParserError;
-module.exports.InvalidPointerError = InvalidPointerError;
-module.exports.MissingPointerError = MissingPointerError;
-module.exports.ResolverError = ResolverError;
-module.exports.ParserError = ParserError;
-module.exports.UnmatchedParserError = UnmatchedParserError;
-module.exports.UnmatchedResolverError = UnmatchedResolverError;
+export default $RefParser;
+export { JSONParserError };
+export { InvalidPointerError };
+export { MissingPointerError };
+export { ResolverError };
+export { ParserError };
+export { UnmatchedParserError };
+export { UnmatchedResolverError };
 
 /**
  * This class parses a JSON schema, builds a map of its JSON references and their resolved values,
@@ -281,3 +278,13 @@ function finalize (parser) {
     throw new JSONParserErrorGroup(parser);
   }
 }
+
+export const parse = $RefParser.parse.bind($RefParser);
+export const resolve = $RefParser.resolve.bind($RefParser);
+export const bundle = $RefParser.bundle.bind($RefParser);
+export const dereference = $RefParser.dereference.bind($RefParser);
+
+// CommonJS default export hack
+if (typeof module === "object" && typeof module.exports === "object") {
+  module.exports = Object.assign(module.exports.default, module.exports);
+}

package/lib/normalize-args.js

@@ -1,8 +1,6 @@
-"use strict";
+import Options from "./options.js";
 
-const Options = require("./options");
-
-module.exports = normalizeArgs;
+export default normalizeArgs;
 
 /**
  * Normalizes the given arguments, accounting for optional args.

package/lib/options.js

@@ -1,14 +1,12 @@
 /* eslint lines-around-comment: [2, {beforeBlockComment: false}] */
-"use strict";
+import jsonParser from "./parsers/json.js";
+import yamlParser from "./parsers/yaml.js";
+import textParser from "./parsers/text.js";
+import binaryParser from "./parsers/binary.js";
+import fileResolver from "./resolvers/file.js";
+import httpResolver from "./resolvers/http.js";
 
-const jsonParser = require("./parsers/json");
-const yamlParser = require("./parsers/yaml");
-const textParser = require("./parsers/text");
-const binaryParser = require("./parsers/binary");
-const fileResolver = require("./resolvers/file");
-const httpResolver = require("./resolvers/http");
-
-module.exports = $RefParserOptions;
+export default $RefParserOptions;
 
 /**
  * Options that determine how JSON schemas are parsed, resolved, and dereferenced.

package/lib/parse.js

@@ -1,11 +1,9 @@
-"use strict";
+import { ono } from "@jsdevtools/ono";
+import * as url from "./util/url.js";
+import * as plugins from "./util/plugins.js";
+import { ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError } from "./util/errors.js";
 
-const { ono } = require("@jsdevtools/ono");
-const url = require("./util/url");
-const plugins = require("./util/plugins");
-const { ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError } = require("./util/errors");
-
-module.exports = parse;
+export default parse;
 
 /**
  * Reads and parses the specified file path or URL.

package/lib/parsers/binary.js

@@ -1,8 +1,6 @@
-"use strict";
-
 let BINARY_REGEXP = /\.(jpeg|jpg|gif|png|bmp|ico)$/i;
 
-module.exports = {
+export default {
   /**
    * The order that this parser will run, in relation to other parsers.
    *

package/lib/parsers/json.js

@@ -1,8 +1,6 @@
-"use strict";
+import { ParserError } from "../util/errors.js";
 
-const { ParserError } = require("../util/errors");
-
-module.exports = {
+export default {
   /**
    * The order that this parser will run, in relation to other parsers.
    *

package/lib/parsers/text.js

@@ -1,10 +1,8 @@
-"use strict";
-
-const { ParserError } = require("../util/errors");
+import { ParserError } from "../util/errors.js";
 
 let TEXT_REGEXP = /\.(txt|htm|html|md|xml|js|min|map|css|scss|less|svg)$/i;
 
-module.exports = {
+export default {
   /**
    * The order that this parser will run, in relation to other parsers.
    *

package/lib/parsers/yaml.js

@@ -1,10 +1,8 @@
-"use strict";
+import { ParserError } from "../util/errors.js";
+import yaml from "js-yaml";
+import { JSON_SCHEMA } from "js-yaml";
 
-const { ParserError } = require("../util/errors");
-const yaml = require("js-yaml");
-const { JSON_SCHEMA } = require("js-yaml");
-
-module.exports = {
+export default {
   /**
    * The order that this parser will run, in relation to other parsers.
    *

package/lib/pointer.js

@@ -1,10 +1,8 @@
-"use strict";
+export default Pointer;
 
-module.exports = Pointer;
-
-const $Ref = require("./ref");
-const url = require("./util/url");
-const { JSONParserError, InvalidPointerError, MissingPointerError, isHandledError } = require("./util/errors");
+import $Ref from "./ref.js";
+import * as url from "./util/url.js";
+import { JSONParserError, InvalidPointerError, MissingPointerError, isHandledError } from "./util/errors.js";
 const slashes = /\//g;
 const tildes = /~/g;
 const escapedSlash = /~1/g;

package/lib/ref.js

@@ -1,10 +1,8 @@
-"use strict";
+export default $Ref;
 
-module.exports = $Ref;
-
-const Pointer = require("./pointer");
-const { InvalidPointerError, isHandledError, normalizeError } = require("./util/errors");
-const { safePointerToPath, stripHash, getHash } = require("./util/url");
+import Pointer from "./pointer.js";
+import { InvalidPointerError, isHandledError, normalizeError } from "./util/errors.js";
+import { safePointerToPath, stripHash, getHash } from "./util/url.js";
 
 /**
  * This class represents a single JSON reference and its resolved value.