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",
+    );
+  });
+
+});