@rjsf/validator-ajv8 5.10.0 → 5.11.2

package/dist/compileSchemaValidators.cjs.development.js

@@ -2,10 +2,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var createAjvInstance = require('./createAjvInstance-0cd8cfba.js');
 var fs = require('fs');
 var standaloneCode = require('ajv/dist/standalone');
 var utils = require('@rjsf/utils');
+var createAjvInstance = require('./createAjvInstance-33d73c95.js');
 require('ajv');
 require('ajv-formats');
 require('lodash/isObject');
@@ -26,32 +26,30 @@ var standaloneCode__default = /*#__PURE__*/_interopDefaultLegacy(standaloneCode)
  *        compiling the schema. They are the same options that are passed to the `customizeValidator()` function in
  *        order to modify the behavior of the regular AJV-based validator.
  */
-function compileSchemaValidators(schema, output, options) {
-  if (options === void 0) {
-    options = {};
-  }
+function compileSchemaValidators(schema, output, options = {}) {
   console.log('parsing the schema');
-  var schemaMaps = utils.schemaParser(schema);
-  var schemas = Object.values(schemaMaps);
-  var _options = options,
-    additionalMetaSchemas = _options.additionalMetaSchemas,
-    customFormats = _options.customFormats,
-    _options$ajvOptionsOv = _options.ajvOptionsOverrides,
-    ajvOptionsOverrides = _options$ajvOptionsOv === void 0 ? {} : _options$ajvOptionsOv,
-    ajvFormatOptions = _options.ajvFormatOptions,
-    AjvClass = _options.AjvClass;
+  const schemaMaps = utils.schemaParser(schema);
+  const schemas = Object.values(schemaMaps);
+  const {
+    additionalMetaSchemas,
+    customFormats,
+    ajvOptionsOverrides = {},
+    ajvFormatOptions,
+    AjvClass
+  } = options;
   // Allow users to turn off the `lines: true` feature in their own overrides, but NOT the `source: true`
-  var compileOptions = createAjvInstance._extends({}, ajvOptionsOverrides, {
-    code: createAjvInstance._extends({
-      lines: true
-    }, ajvOptionsOverrides.code, {
+  const compileOptions = {
+    ...ajvOptionsOverrides,
+    code: {
+      lines: true,
+      ...ajvOptionsOverrides.code,
       source: true
-    }),
-    schemas: schemas
-  });
-  var ajv = createAjvInstance.createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);
-  var moduleCode = standaloneCode__default["default"](ajv);
-  console.log("writing " + output);
+    },
+    schemas
+  };
+  const ajv = createAjvInstance.createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);
+  const moduleCode = standaloneCode__default["default"](ajv);
+  console.log(`writing ${output}`);
   fs__default["default"].writeFileSync(output, moduleCode);
 }
 

package/dist/compileSchemaValidators.cjs.development.js.map

@@ -1 +1 @@
-{"version":3,"file":"compileSchemaValidators.cjs.development.js","sources":["../src/compileSchemaValidators.ts"],"sourcesContent":["import fs from 'fs';\nimport standaloneCode from 'ajv/dist/standalone';\nimport { RJSFSchema, StrictRJSFSchema, schemaParser } from '@rjsf/utils';\n\nimport createAjvInstance from './createAjvInstance';\nimport { CustomValidatorOptionsType } from './types';\n\n/** The function used to compile a schema into an output file in the form that allows it to be used as a precompiled\n * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,\n * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more\n * information about AJV code compilation see: https://ajv.js.org/standalone.html\n *\n * @param schema - The schema to be compiled into a set of precompiled validators functions\n * @param output - The name of the file into which the precompiled validator functions will be generated\n * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for\n *        compiling the schema. They are the same options that are passed to the `customizeValidator()` function in\n *        order to modify the behavior of the regular AJV-based validator.\n */\nexport default function compileSchemaValidators<S extends StrictRJSFSchema = RJSFSchema>(\n  schema: S,\n  output: string,\n  options: CustomValidatorOptionsType = {}\n) {\n  console.log('parsing the schema');\n  const schemaMaps = schemaParser(schema);\n  const schemas = Object.values(schemaMaps);\n\n  const { additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass } = options;\n  // Allow users to turn off the `lines: true` feature in their own overrides, but NOT the `source: true`\n  const compileOptions = {\n    ...ajvOptionsOverrides,\n    code: { lines: true, ...ajvOptionsOverrides.code, source: true },\n    schemas,\n  };\n  const ajv = createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);\n\n  const moduleCode = standaloneCode(ajv);\n  console.log(`writing ${output}`);\n  fs.writeFileSync(output, moduleCode);\n}\n"],"names":["compileSchemaValidators","schema","output","options","console","log","schemaMaps","schemaParser","schemas","Object","values","_options","additionalMetaSchemas","customFormats","_options$ajvOptionsOv","ajvOptionsOverrides","ajvFormatOptions","AjvClass","compileOptions","_extends","code","lines","source","ajv","createAjvInstance","moduleCode","standaloneCode","fs","writeFileSync"],"mappings":";;;;;;;;;;;;;;;;;AAOA;;;;;;;;;;AAUG;AACW,SAAUA,uBAAuBA,CAC7CC,MAAS,EACTC,MAAc,EACdC,OAAA,EAAwC;AAAA,EAAA,IAAxCA,OAAA,KAAA,KAAA,CAAA,EAAA;IAAAA,OAAA,GAAsC,EAAE,CAAA;AAAA,GAAA;AAExCC,EAAAA,OAAO,CAACC,GAAG,CAAC,oBAAoB,CAAC,CAAA;AACjC,EAAA,IAAMC,UAAU,GAAGC,kBAAY,CAACN,MAAM,CAAC,CAAA;AACvC,EAAA,IAAMO,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACJ,UAAU,CAAC,CAAA;EAEzC,IAAAK,QAAA,GAAuGR,OAAO;IAAtGS,qBAAqB,GAAAD,QAAA,CAArBC,qBAAqB;IAAEC,aAAa,GAAAF,QAAA,CAAbE,aAAa;IAAAC,qBAAA,GAAAH,QAAA,CAAEI,mBAAmB;AAAnBA,IAAAA,mBAAmB,GAAAD,qBAAA,KAAA,KAAA,CAAA,GAAG,EAAE,GAAAA,qBAAA;IAAEE,gBAAgB,GAAAL,QAAA,CAAhBK,gBAAgB;IAAEC,QAAQ,GAAAN,QAAA,CAARM,QAAQ,CAAA;AAClG;AACA,EAAA,IAAMC,cAAc,GAAAC,0BAAA,CAAA,EAAA,EACfJ,mBAAmB,EAAA;AACtBK,IAAAA,IAAI,EAAAD,0BAAA,CAAA;AAAIE,MAAAA,KAAK,EAAE,IAAA;KAASN,EAAAA,mBAAmB,CAACK,IAAI,EAAA;AAAEE,MAAAA,MAAM,EAAE,IAAA;KAAM,CAAA;AAChEd,IAAAA,OAAO,EAAPA,OAAAA;GACD,CAAA,CAAA;AACD,EAAA,IAAMe,GAAG,GAAGC,mCAAiB,CAACZ,qBAAqB,EAAEC,aAAa,EAAEK,cAAc,EAAEF,gBAAgB,EAAEC,QAAQ,CAAC,CAAA;AAE/G,EAAA,IAAMQ,UAAU,GAAGC,kCAAc,CAACH,GAAG,CAAC,CAAA;AACtCnB,EAAAA,OAAO,CAACC,GAAG,CAAYH,UAAAA,GAAAA,MAAQ,CAAC,CAAA;AAChCyB,EAAAA,sBAAE,CAACC,aAAa,CAAC1B,MAAM,EAAEuB,UAAU,CAAC,CAAA;AACtC;;;;"}
+{"version":3,"file":"compileSchemaValidators.cjs.development.js","sources":["../src/compileSchemaValidators.ts"],"sourcesContent":["import fs from 'fs';\nimport standaloneCode from 'ajv/dist/standalone';\nimport { RJSFSchema, StrictRJSFSchema, schemaParser } from '@rjsf/utils';\n\nimport createAjvInstance from './createAjvInstance';\nimport { CustomValidatorOptionsType } from './types';\n\n/** The function used to compile a schema into an output file in the form that allows it to be used as a precompiled\n * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,\n * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more\n * information about AJV code compilation see: https://ajv.js.org/standalone.html\n *\n * @param schema - The schema to be compiled into a set of precompiled validators functions\n * @param output - The name of the file into which the precompiled validator functions will be generated\n * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for\n *        compiling the schema. They are the same options that are passed to the `customizeValidator()` function in\n *        order to modify the behavior of the regular AJV-based validator.\n */\nexport default function compileSchemaValidators<S extends StrictRJSFSchema = RJSFSchema>(\n  schema: S,\n  output: string,\n  options: CustomValidatorOptionsType = {}\n) {\n  console.log('parsing the schema');\n  const schemaMaps = schemaParser(schema);\n  const schemas = Object.values(schemaMaps);\n\n  const { additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass } = options;\n  // Allow users to turn off the `lines: true` feature in their own overrides, but NOT the `source: true`\n  const compileOptions = {\n    ...ajvOptionsOverrides,\n    code: { lines: true, ...ajvOptionsOverrides.code, source: true },\n    schemas,\n  };\n  const ajv = createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);\n\n  const moduleCode = standaloneCode(ajv);\n  console.log(`writing ${output}`);\n  fs.writeFileSync(output, moduleCode);\n}\n"],"names":["compileSchemaValidators","schema","output","options","console","log","schemaMaps","schemaParser","schemas","Object","values","additionalMetaSchemas","customFormats","ajvOptionsOverrides","ajvFormatOptions","AjvClass","compileOptions","code","lines","source","ajv","createAjvInstance","moduleCode","standaloneCode","fs","writeFileSync"],"mappings":";;;;;;;;;;;;;;;;;AAOA;;;;;;;;;;AAUG;AACW,SAAUA,uBAAuBA,CAC7CC,MAAS,EACTC,MAAc,EACdC,OAAA,GAAsC,EAAE,EAAA;AAExCC,EAAAA,OAAO,CAACC,GAAG,CAAC,oBAAoB,CAAC,CAAA;AACjC,EAAA,MAAMC,UAAU,GAAGC,kBAAY,CAACN,MAAM,CAAC,CAAA;AACvC,EAAA,MAAMO,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACJ,UAAU,CAAC,CAAA;EAEzC,MAAM;IAAEK,qBAAqB;IAAEC,aAAa;IAAEC,mBAAmB,GAAG,EAAE;IAAEC,gBAAgB;AAAEC,IAAAA,QAAAA;AAAU,GAAA,GAAGZ,OAAO,CAAA;AAC9G;AACA,EAAA,MAAMa,cAAc,GAAG;AACrB,IAAA,GAAGH,mBAAmB;AACtBI,IAAAA,IAAI,EAAE;AAAEC,MAAAA,KAAK,EAAE,IAAI;MAAE,GAAGL,mBAAmB,CAACI,IAAI;AAAEE,MAAAA,MAAM,EAAE,IAAA;KAAM;AAChEX,IAAAA,OAAAA;GACD,CAAA;AACD,EAAA,MAAMY,GAAG,GAAGC,mCAAiB,CAACV,qBAAqB,EAAEC,aAAa,EAAEI,cAAc,EAAEF,gBAAgB,EAAEC,QAAQ,CAAC,CAAA;AAE/G,EAAA,MAAMO,UAAU,GAAGC,kCAAc,CAACH,GAAG,CAAC,CAAA;AACtChB,EAAAA,OAAO,CAACC,GAAG,EAAYH,QAAAA,EAAAA,MAAM,EAAE,CAAC,CAAA;AAChCsB,EAAAA,sBAAE,CAACC,aAAa,CAACvB,MAAM,EAAEoB,UAAU,CAAC,CAAA;AACtC;;;;"}

package/dist/compileSchemaValidators.cjs.production.min.js

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./createAjvInstance-0cd8cfba.js"),r=require("fs"),t=require("ajv/dist/standalone"),s=require("@rjsf/utils");function a(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}require("ajv"),require("ajv-formats"),require("lodash/isObject");var i=a(r),o=a(t);exports.default=function(r,t,a){void 0===a&&(a={}),console.log("parsing the schema");var c=s.schemaParser(r),n=Object.values(c),u=a.additionalMetaSchemas,d=a.customFormats,l=a.ajvOptionsOverrides,v=void 0===l?{}:l,j=a.ajvFormatOptions,f=a.AjvClass,m=e._extends({},v,{code:e._extends({lines:!0},v.code,{source:!0}),schemas:n}),p=e.createAjvInstance(u,d,m,j,f),q=o.default(p);console.log("writing "+t),i.default.writeFileSync(t,q)};
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("fs"),r=require("ajv/dist/standalone"),t=require("@rjsf/utils"),s=require("./createAjvInstance-33d73c95.js");function a(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}require("ajv"),require("ajv-formats"),require("lodash/isObject");var o=a(e),i=a(r);exports.default=function(e,r,a={}){console.log("parsing the schema");const c=t.schemaParser(e),n=Object.values(c),{additionalMetaSchemas:u,customFormats:l,ajvOptionsOverrides:d={},ajvFormatOptions:j,AjvClass:v}=a,f={...d,code:{lines:!0,...d.code,source:!0},schemas:n},m=s.createAjvInstance(u,l,f,j,v),p=i.default(m);console.log(`writing ${r}`),o.default.writeFileSync(r,p)};
 //# sourceMappingURL=compileSchemaValidators.cjs.production.min.js.map

package/dist/compileSchemaValidators.cjs.production.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"compileSchemaValidators.cjs.production.min.js","sources":["../src/compileSchemaValidators.ts"],"sourcesContent":["import fs from 'fs';\nimport standaloneCode from 'ajv/dist/standalone';\nimport { RJSFSchema, StrictRJSFSchema, schemaParser } from '@rjsf/utils';\n\nimport createAjvInstance from './createAjvInstance';\nimport { CustomValidatorOptionsType } from './types';\n\n/** The function used to compile a schema into an output file in the form that allows it to be used as a precompiled\n * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,\n * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more\n * information about AJV code compilation see: https://ajv.js.org/standalone.html\n *\n * @param schema - The schema to be compiled into a set of precompiled validators functions\n * @param output - The name of the file into which the precompiled validator functions will be generated\n * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for\n *        compiling the schema. They are the same options that are passed to the `customizeValidator()` function in\n *        order to modify the behavior of the regular AJV-based validator.\n */\nexport default function compileSchemaValidators<S extends StrictRJSFSchema = RJSFSchema>(\n  schema: S,\n  output: string,\n  options: CustomValidatorOptionsType = {}\n) {\n  console.log('parsing the schema');\n  const schemaMaps = schemaParser(schema);\n  const schemas = Object.values(schemaMaps);\n\n  const { additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass } = options;\n  // Allow users to turn off the `lines: true` feature in their own overrides, but NOT the `source: true`\n  const compileOptions = {\n    ...ajvOptionsOverrides,\n    code: { lines: true, ...ajvOptionsOverrides.code, source: true },\n    schemas,\n  };\n  const ajv = createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);\n\n  const moduleCode = standaloneCode(ajv);\n  console.log(`writing ${output}`);\n  fs.writeFileSync(output, moduleCode);\n}\n"],"names":["schema","output","options","console","log","schemaMaps","schemaParser","schemas","Object","values","additionalMetaSchemas","customFormats","_options$ajvOptionsOv","ajvOptionsOverrides","ajvFormatOptions","AjvClass","compileOptions","_extends","code","lines","source","ajv","createAjvInstance","moduleCode","standaloneCode","fs","writeFileSync"],"mappings":"0WAkBc,SACZA,EACAC,EACAC,QAAA,IAAAA,IAAAA,EAAsC,CAAA,GAEtCC,QAAQC,IAAI,sBACZ,IAAMC,EAAaC,eAAaN,GAC1BO,EAAUC,OAAOC,OAAOJ,GAEtBK,EAA+FR,EAA/FQ,sBAAuBC,EAAwET,EAAxES,cAAaC,EAA2DV,EAAzDW,oBAAAA,OAAmB,IAAAD,EAAG,CAAE,EAAAA,EAAEE,EAA+BZ,EAA/BY,iBAAkBC,EAAab,EAAba,SAEpFC,EAAcC,EAAAA,SAAA,CAAA,EACfJ,EAAmB,CACtBK,KAAID,EAAAA,SAAA,CAAIE,OAAO,GAASN,EAAoBK,KAAI,CAAEE,QAAQ,IAC1Db,QAAAA,IAEIc,EAAMC,EAAAA,kBAAkBZ,EAAuBC,EAAeK,EAAgBF,EAAkBC,GAEhGQ,EAAaC,UAAeH,GAClClB,QAAQC,IAAeH,WAAAA,GACvBwB,EAAAA,QAAGC,cAAczB,EAAQsB,EAC3B"}
+{"version":3,"file":"compileSchemaValidators.cjs.production.min.js","sources":["../src/compileSchemaValidators.ts"],"sourcesContent":["import fs from 'fs';\nimport standaloneCode from 'ajv/dist/standalone';\nimport { RJSFSchema, StrictRJSFSchema, schemaParser } from '@rjsf/utils';\n\nimport createAjvInstance from './createAjvInstance';\nimport { CustomValidatorOptionsType } from './types';\n\n/** The function used to compile a schema into an output file in the form that allows it to be used as a precompiled\n * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,\n * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more\n * information about AJV code compilation see: https://ajv.js.org/standalone.html\n *\n * @param schema - The schema to be compiled into a set of precompiled validators functions\n * @param output - The name of the file into which the precompiled validator functions will be generated\n * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for\n *        compiling the schema. They are the same options that are passed to the `customizeValidator()` function in\n *        order to modify the behavior of the regular AJV-based validator.\n */\nexport default function compileSchemaValidators<S extends StrictRJSFSchema = RJSFSchema>(\n  schema: S,\n  output: string,\n  options: CustomValidatorOptionsType = {}\n) {\n  console.log('parsing the schema');\n  const schemaMaps = schemaParser(schema);\n  const schemas = Object.values(schemaMaps);\n\n  const { additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass } = options;\n  // Allow users to turn off the `lines: true` feature in their own overrides, but NOT the `source: true`\n  const compileOptions = {\n    ...ajvOptionsOverrides,\n    code: { lines: true, ...ajvOptionsOverrides.code, source: true },\n    schemas,\n  };\n  const ajv = createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);\n\n  const moduleCode = standaloneCode(ajv);\n  console.log(`writing ${output}`);\n  fs.writeFileSync(output, moduleCode);\n}\n"],"names":["schema","output","options","console","log","schemaMaps","schemaParser","schemas","Object","values","additionalMetaSchemas","customFormats","ajvOptionsOverrides","ajvFormatOptions","AjvClass","compileOptions","code","lines","source","ajv","createAjvInstance","moduleCode","standaloneCode","fs","writeFileSync"],"mappings":"0WAkBc,SACZA,EACAC,EACAC,EAAsC,CAAA,GAEtCC,QAAQC,IAAI,sBACZ,MAAMC,EAAaC,eAAaN,GAC1BO,EAAUC,OAAOC,OAAOJ,IAExBK,sBAAEA,EAAqBC,cAAEA,EAAaC,oBAAEA,EAAsB,CAAE,EAAAC,iBAAEA,EAAgBC,SAAEA,GAAaZ,EAEjGa,EAAiB,IAClBH,EACHI,KAAM,CAAEC,OAAO,KAASL,EAAoBI,KAAME,QAAQ,GAC1DX,WAEIY,EAAMC,EAAAA,kBAAkBV,EAAuBC,EAAeI,EAAgBF,EAAkBC,GAEhGO,EAAaC,UAAeH,GAClChB,QAAQC,eAAeH,KACvBsB,EAAAA,QAAGC,cAAcvB,EAAQoB,EAC3B"}

package/dist/createAjvInstance-33d73c95.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("ajv"),a=require("ajv-formats"),r=require("lodash/isObject"),t=require("@rjsf/utils");function s(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var d=s(e),o=s(a),l=s(r);const u={allErrors:!0,multipleOfPrecision:8,strict:!1,verbose:!0},i=/^(#?([0-9A-Fa-f]{3}){1,2}\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\(\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*\))|(rgb\(\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*\)))$/,n=/^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;exports.createAjvInstance=function(e,a,r={},s,c=d.default){const b=new c({...u,...r});return s?o.default(b,s):!1!==s&&o.default(b),b.addFormat("data-url",n),b.addFormat("color",i),b.addKeyword(t.ADDITIONAL_PROPERTY_FLAG),b.addKeyword(t.RJSF_ADDITONAL_PROPERTIES_FLAG),Array.isArray(e)&&b.addMetaSchema(e),l.default(a)&&Object.keys(a).forEach((e=>{b.addFormat(e,a[e])})),b};
+//# sourceMappingURL=createAjvInstance-33d73c95.js.map

package/dist/{createAjvInstance-0cd8cfba.js.map → createAjvInstance-33d73c95.js.map}

@@ -1 +1 @@
-{"version":3,"file":"createAjvInstance-0cd8cfba.js","sources":["../src/createAjvInstance.ts"],"sourcesContent":["import Ajv, { Options } from 'ajv';\nimport addFormats, { FormatsPluginOptions } from 'ajv-formats';\nimport isObject from 'lodash/isObject';\n\nimport { CustomValidatorOptionsType } from './types';\nimport { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITONAL_PROPERTIES_FLAG } from '@rjsf/utils';\n\nexport const AJV_CONFIG: Options = {\n  allErrors: true,\n  multipleOfPrecision: 8,\n  strict: false,\n  verbose: true,\n} as const;\nexport const COLOR_FORMAT_REGEX =\n  /^(#?([0-9A-Fa-f]{3}){1,2}\\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\\(\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*\\))|(rgb\\(\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*\\)))$/;\nexport const DATA_URL_FORMAT_REGEX = /^data:([a-z]+\\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;\n\n/** Creates an Ajv version 8 implementation object with standard support for the 'color` and `data-url` custom formats.\n * If `additionalMetaSchemas` are provided then the Ajv instance is modified to add each of the meta schemas in the\n * list. If `customFormats` are provided then those additional formats are added to the list of supported formats. If\n * `ajvOptionsOverrides` are provided then they are spread on top of the default `AJV_CONFIG` options when constructing\n * the `Ajv` instance. With Ajv v8, the JSON Schema formats are not provided by default, but can be plugged in. By\n * default, all formats from the `ajv-formats` library are added. To disable this capability, set the `ajvFormatOptions`\n * parameter to `false`. Additionally, you can configure the `ajv-formats` by providing a custom set of\n * [format options](https://github.com/ajv-validator/ajv-formats) to the `ajvFormatOptions` parameter.\n *\n * @param [additionalMetaSchemas] - The list of additional meta schemas that the validator can access\n * @param [customFormats] - The set of additional custom formats that the validator will support\n * @param [ajvOptionsOverrides={}] - The set of validator config override options\n * @param [ajvFormatOptions] - The `ajv-format` options to use when adding formats to `ajv`; pass `false` to disable it\n * @param [AjvClass] - The `Ajv` class to use when creating the validator instance\n */\nexport default function createAjvInstance(\n  additionalMetaSchemas?: CustomValidatorOptionsType['additionalMetaSchemas'],\n  customFormats?: CustomValidatorOptionsType['customFormats'],\n  ajvOptionsOverrides: CustomValidatorOptionsType['ajvOptionsOverrides'] = {},\n  ajvFormatOptions?: FormatsPluginOptions | false,\n  AjvClass: typeof Ajv = Ajv\n) {\n  const ajv = new AjvClass({ ...AJV_CONFIG, ...ajvOptionsOverrides });\n  if (ajvFormatOptions) {\n    addFormats(ajv, ajvFormatOptions);\n  } else if (ajvFormatOptions !== false) {\n    addFormats(ajv);\n  }\n\n  // add custom formats\n  ajv.addFormat('data-url', DATA_URL_FORMAT_REGEX);\n  ajv.addFormat('color', COLOR_FORMAT_REGEX);\n\n  // Add RJSF-specific additional properties keywords so Ajv doesn't report errors if strict is enabled.\n  ajv.addKeyword(ADDITIONAL_PROPERTY_FLAG);\n  ajv.addKeyword(RJSF_ADDITONAL_PROPERTIES_FLAG);\n\n  // add more schemas to validate against\n  if (Array.isArray(additionalMetaSchemas)) {\n    ajv.addMetaSchema(additionalMetaSchemas);\n  }\n\n  // add more custom formats to validate against\n  if (isObject(customFormats)) {\n    Object.keys(customFormats).forEach((formatName) => {\n      ajv.addFormat(formatName, customFormats[formatName]);\n    });\n  }\n\n  return ajv;\n}\n"],"names":["AJV_CONFIG","allErrors","multipleOfPrecision","strict","verbose","COLOR_FORMAT_REGEX","DATA_URL_FORMAT_REGEX","additionalMetaSchemas","customFormats","ajvOptionsOverrides","ajvFormatOptions","AjvClass","Ajv","ajv","_extends","addFormats","addFormat","addKeyword","ADDITIONAL_PROPERTY_FLAG","RJSF_ADDITONAL_PROPERTIES_FLAG","Array","isArray","addMetaSchema","isObject","Object","keys","forEach","formatName"],"mappings":"sbAOO,IAAMA,EAAsB,CACjCC,WAAW,EACXC,oBAAqB,EACrBC,QAAQ,EACRC,SAAS,GAEEC,EACX,6YACWC,EAAwB,kRAiBb,SACtBC,EACAC,EACAC,EACAC,EACAC,YAFAF,IAAAA,EAAyE,CAAA,YAEzEE,IAAAA,EAAuBC,EAAAA,SAEvB,IAAMC,EAAM,IAAIF,EAAQG,EAAA,CAAA,EAAMd,EAAeS,IA2B7C,OA1BIC,EACFK,UAAWF,EAAKH,IACc,IAArBA,GACTK,EAAU,QAACF,GAIbA,EAAIG,UAAU,WAAYV,GAC1BO,EAAIG,UAAU,QAASX,GAGvBQ,EAAII,WAAWC,EAAAA,0BACfL,EAAII,WAAWE,EAAAA,gCAGXC,MAAMC,QAAQd,IAChBM,EAAIS,cAAcf,GAIhBgB,EAAAA,QAASf,IACXgB,OAAOC,KAAKjB,GAAekB,SAAQ,SAACC,GAClCd,EAAIG,UAAUW,EAAYnB,EAAcmB,GAC1C,IAGKd,CACT"}
+{"version":3,"file":"createAjvInstance-33d73c95.js","sources":["../src/createAjvInstance.ts"],"sourcesContent":["import Ajv, { Options } from 'ajv';\nimport addFormats, { FormatsPluginOptions } from 'ajv-formats';\nimport isObject from 'lodash/isObject';\n\nimport { CustomValidatorOptionsType } from './types';\nimport { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITONAL_PROPERTIES_FLAG } from '@rjsf/utils';\n\nexport const AJV_CONFIG: Options = {\n  allErrors: true,\n  multipleOfPrecision: 8,\n  strict: false,\n  verbose: true,\n} as const;\nexport const COLOR_FORMAT_REGEX =\n  /^(#?([0-9A-Fa-f]{3}){1,2}\\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\\(\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*\\))|(rgb\\(\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*\\)))$/;\nexport const DATA_URL_FORMAT_REGEX = /^data:([a-z]+\\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;\n\n/** Creates an Ajv version 8 implementation object with standard support for the 'color` and `data-url` custom formats.\n * If `additionalMetaSchemas` are provided then the Ajv instance is modified to add each of the meta schemas in the\n * list. If `customFormats` are provided then those additional formats are added to the list of supported formats. If\n * `ajvOptionsOverrides` are provided then they are spread on top of the default `AJV_CONFIG` options when constructing\n * the `Ajv` instance. With Ajv v8, the JSON Schema formats are not provided by default, but can be plugged in. By\n * default, all formats from the `ajv-formats` library are added. To disable this capability, set the `ajvFormatOptions`\n * parameter to `false`. Additionally, you can configure the `ajv-formats` by providing a custom set of\n * [format options](https://github.com/ajv-validator/ajv-formats) to the `ajvFormatOptions` parameter.\n *\n * @param [additionalMetaSchemas] - The list of additional meta schemas that the validator can access\n * @param [customFormats] - The set of additional custom formats that the validator will support\n * @param [ajvOptionsOverrides={}] - The set of validator config override options\n * @param [ajvFormatOptions] - The `ajv-format` options to use when adding formats to `ajv`; pass `false` to disable it\n * @param [AjvClass] - The `Ajv` class to use when creating the validator instance\n */\nexport default function createAjvInstance(\n  additionalMetaSchemas?: CustomValidatorOptionsType['additionalMetaSchemas'],\n  customFormats?: CustomValidatorOptionsType['customFormats'],\n  ajvOptionsOverrides: CustomValidatorOptionsType['ajvOptionsOverrides'] = {},\n  ajvFormatOptions?: FormatsPluginOptions | false,\n  AjvClass: typeof Ajv = Ajv\n) {\n  const ajv = new AjvClass({ ...AJV_CONFIG, ...ajvOptionsOverrides });\n  if (ajvFormatOptions) {\n    addFormats(ajv, ajvFormatOptions);\n  } else if (ajvFormatOptions !== false) {\n    addFormats(ajv);\n  }\n\n  // add custom formats\n  ajv.addFormat('data-url', DATA_URL_FORMAT_REGEX);\n  ajv.addFormat('color', COLOR_FORMAT_REGEX);\n\n  // Add RJSF-specific additional properties keywords so Ajv doesn't report errors if strict is enabled.\n  ajv.addKeyword(ADDITIONAL_PROPERTY_FLAG);\n  ajv.addKeyword(RJSF_ADDITONAL_PROPERTIES_FLAG);\n\n  // add more schemas to validate against\n  if (Array.isArray(additionalMetaSchemas)) {\n    ajv.addMetaSchema(additionalMetaSchemas);\n  }\n\n  // add more custom formats to validate against\n  if (isObject(customFormats)) {\n    Object.keys(customFormats).forEach((formatName) => {\n      ajv.addFormat(formatName, customFormats[formatName]);\n    });\n  }\n\n  return ajv;\n}\n"],"names":["AJV_CONFIG","allErrors","multipleOfPrecision","strict","verbose","COLOR_FORMAT_REGEX","DATA_URL_FORMAT_REGEX","additionalMetaSchemas","customFormats","ajvOptionsOverrides","ajvFormatOptions","AjvClass","Ajv","ajv","addFormats","addFormat","addKeyword","ADDITIONAL_PROPERTY_FLAG","RJSF_ADDITONAL_PROPERTIES_FLAG","Array","isArray","addMetaSchema","isObject","Object","keys","forEach","formatName"],"mappings":"kNAOO,MAAMA,EAAsB,CACjCC,WAAW,EACXC,oBAAqB,EACrBC,QAAQ,EACRC,SAAS,GAEEC,EACX,6YACWC,EAAwB,sFAiBb,SACtBC,EACAC,EACAC,EAAyE,CAAA,EACzEC,EACAC,EAAuBC,WAEvB,MAAMC,EAAM,IAAIF,EAAS,IAAKX,KAAeS,IA2B7C,OA1BIC,EACFI,UAAWD,EAAKH,IACc,IAArBA,GACTI,EAAU,QAACD,GAIbA,EAAIE,UAAU,WAAYT,GAC1BO,EAAIE,UAAU,QAASV,GAGvBQ,EAAIG,WAAWC,EAAAA,0BACfJ,EAAIG,WAAWE,EAAAA,gCAGXC,MAAMC,QAAQb,IAChBM,EAAIQ,cAAcd,GAIhBe,EAAAA,QAASd,IACXe,OAAOC,KAAKhB,GAAeiB,SAASC,IAClCb,EAAIE,UAAUW,EAAYlB,EAAckB,GAAY,IAIjDb,CACT"}

package/dist/index.cjs.development.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var utils = require('@rjsf/utils');
-var createAjvInstance = require('./createAjvInstance-0cd8cfba.js');
+var createAjvInstance = require('./createAjvInstance-33d73c95.js');
 var get = require('lodash/get');
 var isEqual = require('lodash/isEqual');
 require('ajv');
@@ -15,60 +15,59 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
 var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
 
-var _excluded = ["instancePath", "keyword", "params", "schemaPath", "parentSchema"];
 /** Transforming the error output from ajv to format used by @rjsf/utils.
  * At some point, components should be updated to support ajv.
  *
  * @param errors - The list of AJV errors to convert to `RJSFValidationErrors`
  * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
  */
-function transformRJSFValidationErrors(errors, uiSchema) {
-  if (errors === void 0) {
-    errors = [];
-  }
-  return errors.map(function (e) {
-    var instancePath = e.instancePath,
-      keyword = e.keyword,
-      params = e.params,
-      schemaPath = e.schemaPath,
-      parentSchema = e.parentSchema,
-      rest = createAjvInstance._objectWithoutPropertiesLoose(e, _excluded);
-    var _rest$message = rest.message,
-      message = _rest$message === void 0 ? '' : _rest$message;
-    var property = instancePath.replace(/\//g, '.');
-    var stack = (property + " " + message).trim();
+function transformRJSFValidationErrors(errors = [], uiSchema) {
+  return errors.map(e => {
+    const {
+      instancePath,
+      keyword,
+      params,
+      schemaPath,
+      parentSchema,
+      ...rest
+    } = e;
+    let {
+      message = ''
+    } = rest;
+    let property = instancePath.replace(/\//g, '.');
+    let stack = `${property} ${message}`.trim();
     if ('missingProperty' in params) {
-      property = property ? property + "." + params.missingProperty : params.missingProperty;
-      var currentProperty = params.missingProperty;
-      var uiSchemaTitle = utils.getUiOptions(get__default["default"](uiSchema, "" + property.replace(/^\./, ''))).title;
+      property = property ? `${property}.${params.missingProperty}` : params.missingProperty;
+      const currentProperty = params.missingProperty;
+      const uiSchemaTitle = utils.getUiOptions(get__default["default"](uiSchema, `${property.replace(/^\./, '')}`)).title;
       if (uiSchemaTitle) {
         message = message.replace(currentProperty, uiSchemaTitle);
       } else {
-        var parentSchemaTitle = get__default["default"](parentSchema, [utils.PROPERTIES_KEY, currentProperty, 'title']);
+        const parentSchemaTitle = get__default["default"](parentSchema, [utils.PROPERTIES_KEY, currentProperty, 'title']);
         if (parentSchemaTitle) {
           message = message.replace(currentProperty, parentSchemaTitle);
         }
       }
       stack = message;
     } else {
-      var _uiSchemaTitle = utils.getUiOptions(get__default["default"](uiSchema, "" + property.replace(/^\./, ''))).title;
-      if (_uiSchemaTitle) {
-        stack = ("'" + _uiSchemaTitle + "' " + message).trim();
+      const uiSchemaTitle = utils.getUiOptions(get__default["default"](uiSchema, `${property.replace(/^\./, '')}`)).title;
+      if (uiSchemaTitle) {
+        stack = `'${uiSchemaTitle}' ${message}`.trim();
       } else {
-        var _parentSchemaTitle = parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.title;
-        if (_parentSchemaTitle) {
-          stack = ("'" + _parentSchemaTitle + "' " + message).trim();
+        const parentSchemaTitle = parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.title;
+        if (parentSchemaTitle) {
+          stack = `'${parentSchemaTitle}' ${message}`.trim();
         }
       }
     }
     // put data in expected format
     return {
       name: keyword,
-      property: property,
-      message: message,
-      params: params,
-      stack: stack,
-      schemaPath: schemaPath
+      property,
+      message,
+      params,
+      stack,
+      schemaPath
     };
   });
 }
@@ -86,49 +85,52 @@ function transformRJSFValidationErrors(errors, uiSchema) {
  * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
  */
 function processRawValidationErrors(validator, rawErrors, formData, schema, customValidate, transformErrors, uiSchema) {
-  var invalidSchemaError = rawErrors.validationError;
-  var errors = transformRJSFValidationErrors(rawErrors.errors, uiSchema);
+  const {
+    validationError: invalidSchemaError
+  } = rawErrors;
+  let errors = transformRJSFValidationErrors(rawErrors.errors, uiSchema);
   if (invalidSchemaError) {
-    errors = [].concat(errors, [{
+    errors = [...errors, {
       stack: invalidSchemaError.message
-    }]);
+    }];
   }
   if (typeof transformErrors === 'function') {
     errors = transformErrors(errors, uiSchema);
   }
-  var errorSchema = utils.toErrorSchema(errors);
+  let errorSchema = utils.toErrorSchema(errors);
   if (invalidSchemaError) {
-    errorSchema = createAjvInstance._extends({}, errorSchema, {
+    errorSchema = {
+      ...errorSchema,
       $schema: {
         __errors: [invalidSchemaError.message]
       }
-    });
+    };
   }
   if (typeof customValidate !== 'function') {
     return {
-      errors: errors,
-      errorSchema: errorSchema
+      errors,
+      errorSchema
     };
   }
   // Include form data with undefined values, which is required for custom validation.
-  var newFormData = utils.getDefaultFormState(validator, schema, formData, schema, true);
-  var errorHandler = customValidate(newFormData, utils.createErrorHandler(newFormData), uiSchema);
-  var userErrorSchema = utils.unwrapErrorHandler(errorHandler);
+  const newFormData = utils.getDefaultFormState(validator, schema, formData, schema, true);
+  const errorHandler = customValidate(newFormData, utils.createErrorHandler(newFormData), uiSchema);
+  const userErrorSchema = utils.unwrapErrorHandler(errorHandler);
   return utils.validationDataMerge({
-    errors: errors,
-    errorSchema: errorSchema
+    errors,
+    errorSchema
   }, userErrorSchema);
 }
 
 /** `ValidatorType` implementation that uses the AJV 8 validation mechanism.
  */
-var AJV8Validator = /*#__PURE__*/function () {
+class AJV8Validator {
   /** Constructs an `AJV8Validator` instance using the `options`
    *
    * @param options - The `CustomValidatorOptionsType` options that are used to create the AJV instance
    * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
    */
-  function AJV8Validator(options, localizer) {
+  constructor(options, localizer) {
     /** The AJV instance to use for all validations
      *
      * @private
@@ -139,11 +141,13 @@ var AJV8Validator = /*#__PURE__*/function () {
      * @private
      */
     this.localizer = void 0;
-    var additionalMetaSchemas = options.additionalMetaSchemas,
-      customFormats = options.customFormats,
-      ajvOptionsOverrides = options.ajvOptionsOverrides,
-      ajvFormatOptions = options.ajvFormatOptions,
-      AjvClass = options.AjvClass;
+    const {
+      additionalMetaSchemas,
+      customFormats,
+      ajvOptionsOverrides,
+      ajvFormatOptions,
+      AjvClass
+    } = options;
     this.ajv = createAjvInstance.createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides, ajvFormatOptions, AjvClass);
     this.localizer = localizer;
   }
@@ -154,11 +158,7 @@ var AJV8Validator = /*#__PURE__*/function () {
    * @deprecated - Use the `toErrorList()` function provided by `@rjsf/utils` instead. This function will be removed in
    *        the next major release.
    */
-  var _proto = AJV8Validator.prototype;
-  _proto.toErrorList = function toErrorList(errorSchema, fieldPath) {
-    if (fieldPath === void 0) {
-      fieldPath = [];
-    }
+  toErrorList(errorSchema, fieldPath = []) {
     return utils.toErrorList(errorSchema, fieldPath);
   }
   /** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use
@@ -166,10 +166,10 @@ var AJV8Validator = /*#__PURE__*/function () {
    *
    * @param schema - The schema against which to validate the form data   * @param schema
    * @param formData - The form data to validate
-   */;
-  _proto.rawValidation = function rawValidation(schema, formData) {
-    var compilationError = undefined;
-    var compiledValidator;
+   */
+  rawValidation(schema, formData) {
+    let compilationError = undefined;
+    let compiledValidator;
     if (schema[utils.ID_KEY]) {
       compiledValidator = this.ajv.getSchema(schema[utils.ID_KEY]);
     }
@@ -181,7 +181,7 @@ var AJV8Validator = /*#__PURE__*/function () {
     } catch (err) {
       compilationError = err;
     }
-    var errors;
+    let errors;
     if (compiledValidator) {
       if (typeof this.localizer === 'function') {
         this.localizer(compiledValidator.errors);
@@ -205,9 +205,9 @@ var AJV8Validator = /*#__PURE__*/function () {
    * @param [customValidate] - An optional function that is used to perform custom validation
    * @param [transformErrors] - An optional function that is used to transform errors after AJV validation
    * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
-   */;
-  _proto.validateFormData = function validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
-    var rawErrors = this.rawValidation(schema, formData);
+   */
+  validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
+    const rawErrors = this.rawValidation(schema, formData);
     return processRawValidationErrors(this, rawErrors, formData, schema, customValidate, transformErrors, uiSchema);
   }
   /** Validates data against a schema, returning true if the data is valid, or
@@ -217,12 +217,10 @@ var AJV8Validator = /*#__PURE__*/function () {
    * @param schema - The schema against which to validate the form data
    * @param formData - The form data to validate
    * @param rootSchema - The root schema used to provide $ref resolutions
-   */;
-  _proto.isValid = function isValid(schema, formData, rootSchema) {
-    var _rootSchema$ID_KEY;
-    var rootSchemaId = (_rootSchema$ID_KEY = rootSchema[utils.ID_KEY]) != null ? _rootSchema$ID_KEY : utils.ROOT_SCHEMA_PREFIX;
+   */
+  isValid(schema, formData, rootSchema) {
+    const rootSchemaId = rootSchema[utils.ID_KEY] ?? utils.ROOT_SCHEMA_PREFIX;
     try {
-      var _schemaWithIdRefPrefi;
       // add the rootSchema ROOT_SCHEMA_PREFIX as id.
       // then rewrite the schema ref's to point to the rootSchema
       // this accounts for the case where schema have references to models
@@ -230,9 +228,9 @@ var AJV8Validator = /*#__PURE__*/function () {
       if (this.ajv.getSchema(rootSchemaId) === undefined) {
         this.ajv.addSchema(rootSchema, rootSchemaId);
       }
-      var schemaWithIdRefPrefix = utils.withIdRefPrefix(schema);
-      var schemaId = (_schemaWithIdRefPrefi = schemaWithIdRefPrefix[utils.ID_KEY]) != null ? _schemaWithIdRefPrefi : utils.hashForSchema(schemaWithIdRefPrefix);
-      var compiledValidator;
+      const schemaWithIdRefPrefix = utils.withIdRefPrefix(schema);
+      const schemaId = schemaWithIdRefPrefix[utils.ID_KEY] ?? utils.hashForSchema(schemaWithIdRefPrefix);
+      let compiledValidator;
       compiledValidator = this.ajv.getSchema(schemaId);
       if (compiledValidator === undefined) {
         // Add schema by an explicit ID so it can be fetched later
@@ -240,7 +238,7 @@ var AJV8Validator = /*#__PURE__*/function () {
         // https://ajv.js.org/guide/managing-schemas.html#pre-adding-all-schemas-vs-adding-on-demand
         compiledValidator = this.ajv.addSchema(schemaWithIdRefPrefix, schemaId).getSchema(schemaId) || this.ajv.compile(schemaWithIdRefPrefix);
       }
-      var result = compiledValidator(formData);
+      const result = compiledValidator(formData);
       return result;
     } catch (e) {
       console.warn('Error encountered compiling schema:', e);
@@ -250,9 +248,8 @@ var AJV8Validator = /*#__PURE__*/function () {
       // make sure we remove the rootSchema from the global ajv instance
       this.ajv.removeSchema(rootSchemaId);
     }
-  };
-  return AJV8Validator;
-}();
+  }
+}
 
 /** Creates and returns a customized implementation of the `ValidatorType` with the given customization `options` if
  * provided. If a `localizer` is provided, it is used to translate the messages generated by the underlying AJV
@@ -262,17 +259,14 @@ var AJV8Validator = /*#__PURE__*/function () {
  * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
  * @returns - The custom validator implementation resulting from the set of parameters provided
  */
-function customizeValidator(options, localizer) {
-  if (options === void 0) {
-    options = {};
-  }
+function customizeValidator(options = {}, localizer) {
   return new AJV8Validator(options, localizer);
 }
 
 /** `ValidatorType` implementation that uses an AJV 8 precompiled validator as created by the
  * `compileSchemaValidators()` function provided by the `@rjsf/validator-ajv8` library.
  */
-var AJV8PrecompiledValidator = /*#__PURE__*/function () {
+class AJV8PrecompiledValidator {
   /** Constructs an `AJV8PrecompiledValidator` instance using the `validateFns` and `rootSchema`
    *
    * @param validateFns - The map of the validation functions that are generated by the `schemaCompile()` function
@@ -280,7 +274,7 @@ var AJV8PrecompiledValidator = /*#__PURE__*/function () {
    * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
    * @throws - Error when the base schema of the precompiled validator does not have a matching validator function
    */
-  function AJV8PrecompiledValidator(validateFns, rootSchema, localizer) {
+  constructor(validateFns, rootSchema, localizer) {
     /** The root schema object used to construct this validator
      *
      * @private
@@ -318,12 +312,11 @@ var AJV8PrecompiledValidator = /*#__PURE__*/function () {
    * @param schema - The schema for which a precompiled validator function is desired
    * @returns - The precompiled validator function associated with this schema
    */
-  var _proto = AJV8PrecompiledValidator.prototype;
-  _proto.getValidator = function getValidator(schema) {
-    var key = get__default["default"](schema, utils.ID_KEY) || utils.hashForSchema(schema);
-    var validator = this.validateFns[key];
+  getValidator(schema) {
+    const key = get__default["default"](schema, utils.ID_KEY) || utils.hashForSchema(schema);
+    const validator = this.validateFns[key];
     if (!validator) {
-      throw new Error("No precompiled validator function was found for the given schema for \"" + key + "\"");
+      throw new Error(`No precompiled validator function was found for the given schema for "${key}"`);
     }
     return validator;
   }
@@ -333,11 +326,8 @@ var AJV8PrecompiledValidator = /*#__PURE__*/function () {
    * @param [fieldPath=[]] - The current field path, defaults to [] if not specified
    * @deprecated - Use the `toErrorList()` function provided by `@rjsf/utils` instead. This function will be removed in
    *        the next major release.
-   */;
-  _proto.toErrorList = function toErrorList(errorSchema, fieldPath) {
-    if (fieldPath === void 0) {
-      fieldPath = [];
-    }
+   */
+  toErrorList(errorSchema, fieldPath = []) {
     return utils.toErrorList(errorSchema, fieldPath);
   }
   /** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use
@@ -346,8 +336,8 @@ var AJV8PrecompiledValidator = /*#__PURE__*/function () {
    * @param schema - The schema against which to validate the form data   * @param schema
    * @param formData - The form data to validate
    * @throws - Error when the schema provided does not match the base schema of the precompiled validator
-   */;
-  _proto.rawValidation = function rawValidation(schema, formData) {
+   */
+  rawValidation(schema, formData) {
     if (!isEqual__default["default"](schema, this.resolvedRootSchema)) {
       throw new Error('The schema associated with the precompiled schema differs from the schema provided for validation');
     }
@@ -355,7 +345,7 @@ var AJV8PrecompiledValidator = /*#__PURE__*/function () {
     if (typeof this.localizer === 'function') {
       this.localizer(this.mainValidator.errors);
     }
-    var errors = this.mainValidator.errors || undefined;
+    const errors = this.mainValidator.errors || undefined;
     // Clear errors to prevent persistent errors, see #1104
     this.mainValidator.errors = null;
     return {
@@ -372,9 +362,9 @@ var AJV8PrecompiledValidator = /*#__PURE__*/function () {
    * @param [customValidate] - An optional function that is used to perform custom validation
    * @param [transformErrors] - An optional function that is used to transform errors after AJV validation
    * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
-   */;
-  _proto.validateFormData = function validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
-    var rawErrors = this.rawValidation(schema, formData);
+   */
+  validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
+    const rawErrors = this.rawValidation(schema, formData);
     return processRawValidationErrors(this, rawErrors, formData, schema, customValidate, transformErrors, uiSchema);
   }
   /** Validates data against a schema, returning true if the data is valid, or false otherwise. If the schema is
@@ -386,19 +376,18 @@ var AJV8PrecompiledValidator = /*#__PURE__*/function () {
    * @returns - true if the formData validates against the schema, false otherwise
    * @throws - Error when the schema provided does not match the base schema of the precompiled validator OR if there
    *        isn't a precompiled validator function associated with the schema
-   */;
-  _proto.isValid = function isValid(schema, formData, rootSchema) {
+   */
+  isValid(schema, formData, rootSchema) {
     if (!isEqual__default["default"](rootSchema, this.rootSchema)) {
       throw new Error('The schema associated with the precompiled validator differs from the rootSchema provided for validation');
     }
     if (get__default["default"](schema, utils.ID_KEY) === utils.JUNK_OPTION_ID) {
       return false;
     }
-    var validator = this.getValidator(schema);
+    const validator = this.getValidator(schema);
     return validator(formData);
-  };
-  return AJV8PrecompiledValidator;
-}();
+  }
+}
 
 /** Creates and returns a `ValidatorType` interface that is implemented with a precompiled validator. If a `localizer`
  * is provided, it is used to translate the messages generated by the underlying AJV validation.