@rjsf/validator-ajv8 5.11.1 → 5.12.0

package/dist/{validator-ajv8.umd.development.js → validator-ajv8.umd.js}

@@ -1,149 +1,87 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@rjsf/utils'), require('ajv'), require('ajv-formats'), require('lodash-es/isObject'), require('lodash-es/get'), require('lodash-es/isEqual')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@rjsf/utils', 'ajv', 'ajv-formats', 'lodash-es/isObject', 'lodash-es/get', 'lodash-es/isEqual'], factory) :
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@rjsf/utils'), require('ajv'), require('ajv-formats'), require('lodash/isObject'), require('lodash/get'), require('lodash/isEqual')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@rjsf/utils', 'ajv', 'ajv-formats', 'lodash/isObject', 'lodash/get', 'lodash/isEqual'], factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/validator-ajv8"] = {}, global.utils, global.Ajv, global.addFormats, global.isObject, global.get, global.isEqual));
 })(this, (function (exports, utils, Ajv, addFormats, isObject, get, isEqual) { 'use strict';
 
-  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-  var Ajv__default = /*#__PURE__*/_interopDefaultLegacy(Ajv);
-  var addFormats__default = /*#__PURE__*/_interopDefaultLegacy(addFormats);
-  var isObject__default = /*#__PURE__*/_interopDefaultLegacy(isObject);
-  var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
-  var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
-
-  const AJV_CONFIG = {
+  // src/validator.ts
+  var AJV_CONFIG = {
     allErrors: true,
     multipleOfPrecision: 8,
     strict: false,
     verbose: true
   };
-  const COLOR_FORMAT_REGEX = /^(#?([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*\)))$/;
-  const DATA_URL_FORMAT_REGEX = /^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;
-  /** Creates an Ajv version 8 implementation object with standard support for the 'color` and `data-url` custom formats.
-   * If `additionalMetaSchemas` are provided then the Ajv instance is modified to add each of the meta schemas in the
-   * list. If `customFormats` are provided then those additional formats are added to the list of supported formats. If
-   * `ajvOptionsOverrides` are provided then they are spread on top of the default `AJV_CONFIG` options when constructing
-   * the `Ajv` instance. With Ajv v8, the JSON Schema formats are not provided by default, but can be plugged in. By
-   * default, all formats from the `ajv-formats` library are added. To disable this capability, set the `ajvFormatOptions`
-   * parameter to `false`. Additionally, you can configure the `ajv-formats` by providing a custom set of
-   * [format options](https://github.com/ajv-validator/ajv-formats) to the `ajvFormatOptions` parameter.
-   *
-   * @param [additionalMetaSchemas] - The list of additional meta schemas that the validator can access
-   * @param [customFormats] - The set of additional custom formats that the validator will support
-   * @param [ajvOptionsOverrides={}] - The set of validator config override options
-   * @param [ajvFormatOptions] - The `ajv-format` options to use when adding formats to `ajv`; pass `false` to disable it
-   * @param [AjvClass] - The `Ajv` class to use when creating the validator instance
-   */
-  function createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass = Ajv__default["default"]) {
-    const ajv = new AjvClass({
-      ...AJV_CONFIG,
-      ...ajvOptionsOverrides
-    });
+  var COLOR_FORMAT_REGEX = /^(#?([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*\)))$/;
+  var DATA_URL_FORMAT_REGEX = /^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;
+  function createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass = Ajv) {
+    const ajv = new AjvClass({ ...AJV_CONFIG, ...ajvOptionsOverrides });
     if (ajvFormatOptions) {
-      addFormats__default["default"](ajv, ajvFormatOptions);
+      addFormats(ajv, ajvFormatOptions);
     } else if (ajvFormatOptions !== false) {
-      addFormats__default["default"](ajv);
+      addFormats(ajv);
     }
-    // add custom formats
-    ajv.addFormat('data-url', DATA_URL_FORMAT_REGEX);
-    ajv.addFormat('color', COLOR_FORMAT_REGEX);
-    // Add RJSF-specific additional properties keywords so Ajv doesn't report errors if strict is enabled.
+    ajv.addFormat("data-url", DATA_URL_FORMAT_REGEX);
+    ajv.addFormat("color", COLOR_FORMAT_REGEX);
     ajv.addKeyword(utils.ADDITIONAL_PROPERTY_FLAG);
     ajv.addKeyword(utils.RJSF_ADDITONAL_PROPERTIES_FLAG);
-    // add more schemas to validate against
     if (Array.isArray(additionalMetaSchemas)) {
       ajv.addMetaSchema(additionalMetaSchemas);
     }
-    // add more custom formats to validate against
-    if (isObject__default["default"](customFormats)) {
-      Object.keys(customFormats).forEach(formatName => {
+    if (isObject(customFormats)) {
+      Object.keys(customFormats).forEach((formatName) => {
         ajv.addFormat(formatName, customFormats[formatName]);
       });
     }
     return ajv;
   }
-
-  /** 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) {
-    return errors.map(e => {
-      const {
-        instancePath,
-        keyword,
-        params,
-        schemaPath,
-        parentSchema,
-        ...rest
-      } = e;
-      let {
-        message = ''
-      } = rest;
-      let property = instancePath.replace(/\//g, '.');
+    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) {
+      if ("missingProperty" in params) {
         property = property ? `${property}.${params.missingProperty}` : params.missingProperty;
         const currentProperty = params.missingProperty;
-        const uiSchemaTitle = utils.getUiOptions(get__default["default"](uiSchema, `${property.replace(/^\./, '')}`)).title;
+        const uiSchemaTitle = utils.getUiOptions(get(uiSchema, `${property.replace(/^\./, "")}`)).title;
         if (uiSchemaTitle) {
           message = message.replace(currentProperty, uiSchemaTitle);
         } else {
-          const parentSchemaTitle = get__default["default"](parentSchema, [utils.PROPERTIES_KEY, currentProperty, 'title']);
+          const parentSchemaTitle = get(parentSchema, [utils.PROPERTIES_KEY, currentProperty, "title"]);
           if (parentSchemaTitle) {
             message = message.replace(currentProperty, parentSchemaTitle);
           }
         }
         stack = message;
       } else {
-        const uiSchemaTitle = utils.getUiOptions(get__default["default"](uiSchema, `${property.replace(/^\./, '')}`)).title;
+        const uiSchemaTitle = utils.getUiOptions(get(uiSchema, `${property.replace(/^\./, "")}`)).title;
         if (uiSchemaTitle) {
           stack = `'${uiSchemaTitle}' ${message}`.trim();
         } else {
-          const parentSchemaTitle = parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.title;
+          const parentSchemaTitle = parentSchema?.title;
           if (parentSchemaTitle) {
             stack = `'${parentSchemaTitle}' ${message}`.trim();
           }
         }
       }
-      // put data in expected format
       return {
         name: keyword,
         property,
         message,
         params,
+        // specific to ajv
         stack,
         schemaPath
       };
     });
   }
-  /** This function processes the `formData` with an optional user contributed `customValidate` function, which receives
-   * the form data and a `errorHandler` function that will be used to add custom validation errors for each field. Also
-   * supports a `transformErrors` function that will take the raw AJV validation errors, prior to custom validation and
-   * transform them in what ever way it chooses.
-   *
-   * @param validator - The `ValidatorType` implementation used for the `getDefaultFormState()` call
-   * @param rawErrors - The list of raw `ErrorObject`s to process
-   * @param formData - The form data to validate
-   * @param schema - The schema against which to validate the form data
-   * @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`
-   */
   function processRawValidationErrors(validator, rawErrors, formData, schema, customValidate, transformErrors, uiSchema) {
-    const {
-      validationError: invalidSchemaError
-    } = rawErrors;
+    const { validationError: invalidSchemaError } = rawErrors;
     let errors = transformRJSFValidationErrors(rawErrors.errors, uiSchema);
     if (invalidSchemaError) {
-      errors = [...errors, {
-        stack: invalidSchemaError.message
-      }];
+      errors = [...errors, { stack: invalidSchemaError.message }];
     }
-    if (typeof transformErrors === 'function') {
+    if (typeof transformErrors === "function") {
       errors = transformErrors(errors, uiSchema);
     }
     let errorSchema = utils.toErrorSchema(errors);
@@ -155,75 +93,51 @@
         }
       };
     }
-    if (typeof customValidate !== 'function') {
-      return {
-        errors,
-        errorSchema
-      };
+    if (typeof customValidate !== "function") {
+      return { errors, errorSchema };
     }
-    // Include form data with undefined values, which is required for custom validation.
     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,
-      errorSchema
-    }, userErrorSchema);
+    return utils.validationDataMerge({ errors, errorSchema }, userErrorSchema);
   }
 
-  /** `ValidatorType` implementation that uses the AJV 8 validation mechanism.
-   */
-  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
+  // src/validator.ts
+  var AJV8Validator = class {
+    /** 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
      */
     constructor(options, localizer) {
-      /** The AJV instance to use for all validations
-       *
-       * @private
-       */
-      this.ajv = void 0;
-      /** The Localizer function to use for localizing Ajv errors
-       *
-       * @private
-       */
-      this.localizer = void 0;
-      const {
-        additionalMetaSchemas,
-        customFormats,
-        ajvOptionsOverrides,
-        ajvFormatOptions,
-        AjvClass
-      } = options;
+      const { additionalMetaSchemas, customFormats, ajvOptionsOverrides, ajvFormatOptions, AjvClass } = options;
       this.ajv = createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides, ajvFormatOptions, AjvClass);
       this.localizer = localizer;
     }
-    /** Converts an `errorSchema` into a list of `RJSFValidationErrors`
-     *
-     * @param errorSchema - The `ErrorSchema` instance to convert
-     * @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.
+    /** Converts an `errorSchema` into a list of `RJSFValidationErrors`
+     *
+     * @param errorSchema - The `ErrorSchema` instance to convert
+     * @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.
      */
     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
-     * by the playground. Returns the `errors` from the validation
-     *
-     * @param schema - The schema against which to validate the form data   * @param schema
-     * @param formData - The form data to validate
+    /** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use
+     * by the playground. Returns the `errors` from the validation
+     *
+     * @param schema - The schema against which to validate the form data   * @param schema
+     * @param formData - The form data to validate
      */
     rawValidation(schema, formData) {
-      let compilationError = undefined;
+      let compilationError = void 0;
       let compiledValidator;
       if (schema[utils.ID_KEY]) {
         compiledValidator = this.ajv.getSchema(schema[utils.ID_KEY]);
       }
       try {
-        if (compiledValidator === undefined) {
+        if (compiledValidator === void 0) {
           compiledValidator = this.ajv.compile(schema);
         }
         compiledValidator(formData);
@@ -232,234 +146,179 @@
       }
       let errors;
       if (compiledValidator) {
-        if (typeof this.localizer === 'function') {
+        if (typeof this.localizer === "function") {
           this.localizer(compiledValidator.errors);
         }
-        errors = compiledValidator.errors || undefined;
-        // Clear errors to prevent persistent errors, see #1104
+        errors = compiledValidator.errors || void 0;
         compiledValidator.errors = null;
       }
       return {
-        errors: errors,
+        errors,
         validationError: compilationError
       };
     }
-    /** This function processes the `formData` with an optional user contributed `customValidate` function, which receives
-     * the form data and a `errorHandler` function that will be used to add custom validation errors for each field. Also
-     * supports a `transformErrors` function that will take the raw AJV validation errors, prior to custom validation and
-     * transform them in what ever way it chooses.
-     *
-     * @param formData - The form data to validate
-     * @param schema - The schema against which to validate the form data
-     * @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`
+    /** This function processes the `formData` with an optional user contributed `customValidate` function, which receives
+     * the form data and a `errorHandler` function that will be used to add custom validation errors for each field. Also
+     * supports a `transformErrors` function that will take the raw AJV validation errors, prior to custom validation and
+     * transform them in what ever way it chooses.
+     *
+     * @param formData - The form data to validate
+     * @param schema - The schema against which to validate the form data
+     * @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`
      */
     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 invalid, then this function will return
-     * false.
-     *
-     * @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
+    /** Validates data against a schema, returning true if the data is valid, or
+     * false otherwise. If the schema is invalid, then this function will return
+     * false.
+     *
+     * @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
      */
     isValid(schema, formData, rootSchema) {
       const rootSchemaId = rootSchema[utils.ID_KEY] ?? utils.ROOT_SCHEMA_PREFIX;
       try {
-        // 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
-        // that lives in the rootSchema but not in the schema in question.
-        if (this.ajv.getSchema(rootSchemaId) === undefined) {
+        if (this.ajv.getSchema(rootSchemaId) === void 0) {
           this.ajv.addSchema(rootSchema, rootSchemaId);
         }
         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
-          // Fall back to using compile if necessary
-          // https://ajv.js.org/guide/managing-schemas.html#pre-adding-all-schemas-vs-adding-on-demand
+        if (compiledValidator === void 0) {
           compiledValidator = this.ajv.addSchema(schemaWithIdRefPrefix, schemaId).getSchema(schemaId) || this.ajv.compile(schemaWithIdRefPrefix);
         }
         const result = compiledValidator(formData);
         return result;
       } catch (e) {
-        console.warn('Error encountered compiling schema:', e);
+        console.warn("Error encountered compiling schema:", e);
         return false;
       } finally {
-        // TODO: A function should be called if the root schema changes so we don't have to remove and recompile the schema every run.
-        // make sure we remove the rootSchema from the global ajv instance
         this.ajv.removeSchema(rootSchemaId);
       }
     }
-  }
+  };
 
-  /** 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
-   * validation.
-   *
-   * @param [options={}] - The `CustomValidatorOptionsType` options that are used to create the `ValidatorType` instance
-   * @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
-   */
+  // src/customizeValidator.ts
   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.
-   */
-  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
-     * @param rootSchema - The root schema that was used with the `compileSchema()` 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
+  var AJV8PrecompiledValidator = class {
+    /** Constructs an `AJV8PrecompiledValidator` instance using the `validateFns` and `rootSchema`
+     *
+     * @param validateFns - The map of the validation functions that are generated by the `schemaCompile()` function
+     * @param rootSchema - The root schema that was used with the `compileSchema()` 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
      */
     constructor(validateFns, rootSchema, localizer) {
-      /** The root schema object used to construct this validator
-       *
-       * @private
-       */
-      this.rootSchema = void 0;
-      /** The root schema resolved top level refs
-       *
-       * @private
-       */
-      this.resolvedRootSchema = void 0;
-      /** The `ValidatorFunctions` map used to construct this validator
-       *
-       * @private
-       */
-      this.validateFns = void 0;
-      /** The main validator function associated with the base schema in the `precompiledValidator`
-       *
-       * @private
-       */
-      this.mainValidator = void 0;
-      /** The Localizer function to use for localizing Ajv errors
-       *
-       * @private
-       */
-      this.localizer = void 0;
       this.rootSchema = rootSchema;
       this.validateFns = validateFns;
       this.localizer = localizer;
       this.mainValidator = this.getValidator(rootSchema);
       this.resolvedRootSchema = utils.retrieveSchema(this, rootSchema, rootSchema);
     }
-    /** Returns the precompiled validator associated with the given `schema` from the map of precompiled validator
-     * functions.
-     *
-     * @param schema - The schema for which a precompiled validator function is desired
-     * @returns - The precompiled validator function associated with this schema
+    /** Returns the precompiled validator associated with the given `schema` from the map of precompiled validator
+     * functions.
+     *
+     * @param schema - The schema for which a precompiled validator function is desired
+     * @returns - The precompiled validator function associated with this schema
      */
     getValidator(schema) {
-      const key = get__default["default"](schema, utils.ID_KEY) || utils.hashForSchema(schema);
+      const key = get(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}"`);
       }
       return validator;
     }
-    /** Converts an `errorSchema` into a list of `RJSFValidationErrors`
-     *
-     * @param errorSchema - The `ErrorSchema` instance to convert
-     * @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.
+    /** Converts an `errorSchema` into a list of `RJSFValidationErrors`
+     *
+     * @param errorSchema - The `ErrorSchema` instance to convert
+     * @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.
      */
     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
-     * by the playground. Returns the `errors` from the validation
-     *
-     * @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
+    /** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use
+     * by the playground. Returns the `errors` from the validation
+     *
+     * @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
      */
     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');
+      if (!isEqual(schema, this.resolvedRootSchema)) {
+        throw new Error(
+          "The schema associated with the precompiled schema differs from the schema provided for validation"
+        );
       }
       this.mainValidator(formData);
-      if (typeof this.localizer === 'function') {
+      if (typeof this.localizer === "function") {
         this.localizer(this.mainValidator.errors);
       }
-      const errors = this.mainValidator.errors || undefined;
-      // Clear errors to prevent persistent errors, see #1104
+      const errors = this.mainValidator.errors || void 0;
       this.mainValidator.errors = null;
-      return {
-        errors: errors
-      };
+      return { errors };
     }
-    /** This function processes the `formData` with an optional user contributed `customValidate` function, which receives
-     * the form data and a `errorHandler` function that will be used to add custom validation errors for each field. Also
-     * supports a `transformErrors` function that will take the raw AJV validation errors, prior to custom validation and
-     * transform them in what ever way it chooses.
-     *
-     * @param formData - The form data to validate
-     * @param schema - The schema against which to validate the form data
-     * @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`
+    /** This function processes the `formData` with an optional user contributed `customValidate` function, which receives
+     * the form data and a `errorHandler` function that will be used to add custom validation errors for each field. Also
+     * supports a `transformErrors` function that will take the raw AJV validation errors, prior to custom validation and
+     * transform them in what ever way it chooses.
+     *
+     * @param formData - The form data to validate
+     * @param schema - The schema against which to validate the form data
+     * @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`
      */
     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
-     * invalid, then this function will return false.
-     *
-     * @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
-     * @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
+    /** Validates data against a schema, returning true if the data is valid, or false otherwise. If the schema is
+     * invalid, then this function will return false.
+     *
+     * @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
+     * @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
      */
     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 (!isEqual(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) {
+      if (get(schema, utils.ID_KEY) === utils.JUNK_OPTION_ID) {
         return false;
       }
       const validator = this.getValidator(schema);
       return validator(formData);
     }
-  }
+  };
 
-  /** 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.
-   *
-   * NOTE: The `validateFns` parameter is an object obtained by importing from a precompiled validation file created via
-   * the `compileSchemaValidators()` function.
-   *
-   * @param validateFns - The map of the validation functions that are created by the `compileSchemaValidators()` function
-   * @param rootSchema - The root schema that was used with the `compileSchemaValidators()` function
-   * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
-   * @returns - The precompiled validator implementation resulting from the set of parameters provided
-   */
+  // src/createPrecompiledValidator.ts
   function createPrecompiledValidator(validateFns, rootSchema, localizer) {
     return new AJV8PrecompiledValidator(validateFns, rootSchema, localizer);
   }
 
-  var index = /*#__PURE__*/customizeValidator();
+  // src/index.ts
+  var src_default = customizeValidator();
 
   exports.createPrecompiledValidator = createPrecompiledValidator;
   exports.customizeValidator = customizeValidator;
-  exports["default"] = index;
+  exports.default = src_default;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-//# sourceMappingURL=validator-ajv8.umd.development.js.map

package/lib/compileSchemaValidators.d.ts

@@ -0,0 +1,16 @@
+import { RJSFSchema, StrictRJSFSchema } from '@rjsf/utils';
+import { CustomValidatorOptionsType } from './types';
+import { compileSchemaValidatorsCode } from './compileSchemaValidatorsCode';
+export { compileSchemaValidatorsCode };
+/** The function used to compile a schema into an output file in the form that allows it to be used as a precompiled
+ * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,
+ * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more
+ * information about AJV code compilation see: https://ajv.js.org/standalone.html
+ *
+ * @param schema - The schema to be compiled into a set of precompiled validators functions
+ * @param output - The name of the file into which the precompiled validator functions will be generated
+ * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for
+ *        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.
+ */
+export default function compileSchemaValidators<S extends StrictRJSFSchema = RJSFSchema>(schema: S, output: string, options?: CustomValidatorOptionsType): void;

package/lib/compileSchemaValidators.js

@@ -0,0 +1,21 @@
+import fs from 'fs';
+import { compileSchemaValidatorsCode } from './compileSchemaValidatorsCode';
+export { compileSchemaValidatorsCode };
+/** The function used to compile a schema into an output file in the form that allows it to be used as a precompiled
+ * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,
+ * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more
+ * information about AJV code compilation see: https://ajv.js.org/standalone.html
+ *
+ * @param schema - The schema to be compiled into a set of precompiled validators functions
+ * @param output - The name of the file into which the precompiled validator functions will be generated
+ * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for
+ *        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.
+ */
+export default function compileSchemaValidators(schema, output, options = {}) {
+    console.log('parsing the schema');
+    const moduleCode = compileSchemaValidatorsCode(schema, options);
+    console.log(`writing ${output}`);
+    fs.writeFileSync(output, moduleCode);
+}
+//# sourceMappingURL=compileSchemaValidators.js.map

package/lib/compileSchemaValidators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileSchemaValidators.js","sourceRoot":"","sources":["../src/compileSchemaValidators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAC;AAGpB,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,OAAO,EAAE,2BAA2B,EAAE,CAAC;AAEvC;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAC7C,MAAS,EACT,MAAc,EACd,UAAsC,EAAE;IAExC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;IAElC,MAAM,UAAU,GAAG,2BAA2B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChE,OAAO,CAAC,GAAG,CAAC,WAAW,MAAM,EAAE,CAAC,CAAC;IACjC,EAAE,CAAC,aAAa,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AACvC,CAAC"}