Added named and default CJS and ESM exports

Also added tests to verify exports

Author: JamesMessinger

lib/index.js

@@ -1,18 +1,18 @@
 "use strict";
 
-const Options = require("./options");
 const $Refs = require("./refs");
-const parse = require("./parse");
+const _parse = require("./parse");
 const normalizeArgs = require("./normalize-args");
 const resolveExternal = require("./resolve-external");
-const bundle = require("./bundle");
-const dereference = require("./dereference");
+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;
@@ -56,7 +56,7 @@ function $RefParser () {
  * @param {function} [callback] - An error-first callback. The second parameter is the parsed JSON schema object.
  * @returns {Promise} - The returned promise resolves with the parsed JSON schema object.
  */
-$RefParser.parse = function (path, schema, options, callback) {
+$RefParser.parse = function parse (path, schema, options, callback) {
  let Class = this; // eslint-disable-line consistent-this
  let instance = new Class();
  return instance.parse.apply(instance, arguments);
@@ -73,7 +73,7 @@ $RefParser.parse = function (path, schema, options, callback) {
  * @param {function} [callback] - An error-first callback. The second parameter is the parsed JSON schema object.
  * @returns {Promise} - The returned promise resolves with the parsed JSON schema object.
  */
-$RefParser.prototype.parse = async function (path, schema, options, callback) {
+$RefParser.prototype.parse = async function parse (path, schema, options, callback) {
  let args = normalizeArgs(arguments);
  let promise;
 
@@ -111,7 +111,7 @@ $RefParser.prototype.parse = async function (path, schema, options, callback) {
  }
  else {
  // Parse the schema file/url
- promise = parse(args.path, this.$refs, args.options);
+ promise = _parse(args.path, this.$refs, args.options);
  }
 
  let me = this;
@@ -156,7 +156,7 @@ $RefParser.prototype.parse = async function (path, schema, options, callback) {
  * @returns {Promise}
  * The returned promise resolves with a {@link $Refs} object containing the resolved JSON references
  */
-$RefParser.resolve = function (path, schema, options, callback) {
+$RefParser.resolve = function resolve (path, schema, options, callback) {
  let Class = this; // eslint-disable-line consistent-this
  let instance = new Class();
  return instance.resolve.apply(instance, arguments);
@@ -175,7 +175,7 @@ $RefParser.resolve = function (path, schema, options, callback) {
  * @returns {Promise}
  * The returned promise resolves with a {@link $Refs} object containing the resolved JSON references
  */
-$RefParser.prototype.resolve = async function (path, schema, options, callback) {
+$RefParser.prototype.resolve = async function resolve (path, schema, options, callback) {
  let me = this;
  let args = normalizeArgs(arguments);
 
@@ -201,7 +201,7 @@ $RefParser.prototype.resolve = async function (path, schema, options, callback)
  * @param {function} [callback] - An error-first callback. The second parameter is the bundled JSON schema object
  * @returns {Promise} - The returned promise resolves with the bundled JSON schema object.
  */
-$RefParser.bundle = function (path, schema, options, callback) {
+$RefParser.bundle = function bundle (path, schema, options, callback) {
  let Class = this; // eslint-disable-line consistent-this
  let instance = new Class();
  return instance.bundle.apply(instance, arguments);
@@ -218,13 +218,13 @@ $RefParser.bundle = function (path, schema, options, callback) {
  * @param {function} [callback] - An error-first callback. The second parameter is the bundled JSON schema object
  * @returns {Promise} - The returned promise resolves with the bundled JSON schema object.
  */
-$RefParser.prototype.bundle = async function (path, schema, options, callback) {
+$RefParser.prototype.bundle = async function bundle (path, schema, options, callback) {
  let me = this;
  let args = normalizeArgs(arguments);
 
  try {
  await this.resolve(args.path, args.schema, args.options);
- bundle(me, args.options);
+ _bundle(me, args.options);
  finalize(me);
  return maybe(args.callback, Promise.resolve(me.schema));
  }
@@ -243,7 +243,7 @@ $RefParser.prototype.bundle = async function (path, schema, options, callback) {
  * @param {function} [callback] - An error-first callback. The second parameter is the dereferenced JSON schema object
  * @returns {Promise} - The returned promise resolves with the dereferenced JSON schema object.
  */
-$RefParser.dereference = function (path, schema, options, callback) {
+$RefParser.dereference = function dereference (path, schema, options, callback) {
  let Class = this; // eslint-disable-line consistent-this
  let instance = new Class();
  return instance.dereference.apply(instance, arguments);
@@ -259,13 +259,13 @@ $RefParser.dereference = function (path, schema, options, callback) {
  * @param {function} [callback] - An error-first callback. The second parameter is the dereferenced JSON schema object
  * @returns {Promise} - The returned promise resolves with the dereferenced JSON schema object.
  */
-$RefParser.prototype.dereference = async function (path, schema, options, callback) {
+$RefParser.prototype.dereference = async function dereference (path, schema, options, callback) {
  let me = this;
  let args = normalizeArgs(arguments);
 
  try {
  await this.resolve(args.path, args.schema, args.options);
- dereference(me, args.options);
+ _dereference(me, args.options);
  finalize(me);
  return maybe(args.callback, Promise.resolve(me.schema));
  }

test/specs/exports.spec.js

@@ -0,0 +1,91 @@
+"use strict";
+
+const { expect } = require("chai");
+const commonJSExport = require("../../");
+const { default: defaultExport } = require("../../");
+const {
+ JSONParserError,
+ InvalidPointerError,
+ MissingPointerError,
+ ResolverError,
+ ParserError,
+ UnmatchedParserError,
+ UnmatchedResolverError,
+} = require("../../");
+
+describe("json-schema-ref-parser package exports", () => {
+
+ function is$RefParser (parser) {
+ expect(parser).to.be.a("function").with.property("name", "$RefParser");
+ expect(parser.parse).to.be.a("function").with.property("name", "parse");
+ expect(parser.prototype.parse).to.be.a("function").with.property("name", "parse");
+ expect(parser.resolve).to.be.a("function").with.property("name", "resolve");
+ expect(parser.prototype.resolve).to.be.a("function").with.property("name", "resolve");
+ expect(parser.dereference).to.be.a("function").with.property("name", "dereference");
+ expect(parser.prototype.dereference).to.be.a("function").with.property("name", "dereference");
+ expect(parser.bundle).to.be.a("function").with.property("name", "bundle");
+ expect(parser.prototype.bundle).to.be.a("function").with.property("name", "bundle");
+ return true;
+ }
+
+ it("should export the $RefParser class as the default CommonJS export", async () => {
+ expect(commonJSExport).to.satisfy(is$RefParser);
+ });
+
+ it("should export the $RefParser class as the default ESM export", async () => {
+ expect(defaultExport).to.satisfy(is$RefParser);
+ });
+
+ it("should export the JSONParserError class as a named ESM export", async () => {
+ expect(JSONParserError).to.be.a("function");
+ expect(JSONParserError.name).to.equal("JSONParserError");
+ });
+
+ it("should export the InvalidPointerError class as a named ESM export", async () => {
+ expect(InvalidPointerError).to.be.a("function");
+ expect(InvalidPointerError.name).to.equal("InvalidPointerError");
+ });
+
+ it("should export the MissingPointerError class as a named ESM export", async () => {
+ expect(MissingPointerError).to.be.a("function");
+ expect(MissingPointerError.name).to.equal("MissingPointerError");
+ });
+
+ it("should export the ResolverError class as a named ESM export", async () => {
+ expect(ResolverError).to.be.a("function");
+ expect(ResolverError.name).to.equal("ResolverError");
+ });
+
+ it("should export the ParserError class as a named ESM export", async () => {
+ expect(ParserError).to.be.a("function");
+ expect(ParserError.name).to.equal("ParserError");
+ });
+
+ it("should export the UnmatchedParserError class as a named ESM export", async () => {
+ expect(UnmatchedParserError).to.be.a("function");
+ expect(UnmatchedParserError.name).to.equal("UnmatchedParserError");
+ });
+
+ it("should export the UnmatchedResolverError class as a named ESM export", async () => {
+ expect(UnmatchedResolverError).to.be.a("function");
+ expect(UnmatchedResolverError.name).to.equal("UnmatchedResolverError");
+ });
+
+ it("should not export anything else", async () => {
+ expect(commonJSExport).to.have.same.keys(
+ "default",
+ "parse",
+ "resolve",
+ "dereference",
+ "bundle",
+ "JSONParserError",
+ "InvalidPointerError",
+ "MissingPointerError",
+ "ResolverError",
+ "ParserError",
+ "UnmatchedParserError",
+ "UnmatchedResolverError",
+ );
+ });
+
+});