@rjsf/validator-ajv8 5.11.1 → 5.12.0

package/dist/validator-ajv8.esm.js

@@ -1,142 +1,106 @@
-import { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITONAL_PROPERTIES_FLAG, toErrorSchema, getDefaultFormState, createErrorHandler, unwrapErrorHandler, validationDataMerge, getUiOptions, PROPERTIES_KEY, toErrorList, ID_KEY, withIdRefPrefix, hashForSchema, ROOT_SCHEMA_PREFIX, retrieveSchema, JUNK_OPTION_ID } from '@rjsf/utils';
-import Ajv from 'ajv';
-import addFormats from 'ajv-formats';
-import isObject from 'lodash-es/isObject';
-import get from 'lodash-es/get';
-import isEqual from 'lodash-es/isEqual';
+// src/validator.ts
+import {
+  ID_KEY,
+  ROOT_SCHEMA_PREFIX,
+  toErrorList,
+  withIdRefPrefix,
+  hashForSchema
+} from "@rjsf/utils";
 
-const AJV_CONFIG = {
+// src/createAjvInstance.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import isObject from "lodash/isObject";
+import { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITONAL_PROPERTIES_FLAG } from "@rjsf/utils";
+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
- */
+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
-  });
+  const ajv = new AjvClass({ ...AJV_CONFIG, ...ajvOptionsOverrides });
   if (ajvFormatOptions) {
     addFormats(ajv, ajvFormatOptions);
   } else if (ajvFormatOptions !== false) {
     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(ADDITIONAL_PROPERTY_FLAG);
   ajv.addKeyword(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(customFormats)) {
-    Object.keys(customFormats).forEach(formatName => {
+    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`
- */
+// src/processRawValidationErrors.ts
+import get from "lodash/get";
+import {
+  createErrorHandler,
+  getDefaultFormState,
+  getUiOptions,
+  PROPERTIES_KEY,
+  toErrorSchema,
+  unwrapErrorHandler,
+  validationDataMerge
+} from "@rjsf/utils";
 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 = getUiOptions(get(uiSchema, `${property.replace(/^\./, '')}`)).title;
+      const uiSchemaTitle = getUiOptions(get(uiSchema, `${property.replace(/^\./, "")}`)).title;
       if (uiSchemaTitle) {
         message = message.replace(currentProperty, uiSchemaTitle);
       } else {
-        const parentSchemaTitle = get(parentSchema, [PROPERTIES_KEY, currentProperty, 'title']);
+        const parentSchemaTitle = get(parentSchema, [PROPERTIES_KEY, currentProperty, "title"]);
         if (parentSchemaTitle) {
           message = message.replace(currentProperty, parentSchemaTitle);
         }
       }
       stack = message;
     } else {
-      const uiSchemaTitle = getUiOptions(get(uiSchema, `${property.replace(/^\./, '')}`)).title;
+      const uiSchemaTitle = 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 = toErrorSchema(errors);
@@ -148,75 +112,51 @@ function processRawValidationErrors(validator, rawErrors, formData, schema, cust
       }
     };
   }
-  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 = getDefaultFormState(validator, schema, formData, schema, true);
   const errorHandler = customValidate(newFormData, createErrorHandler(newFormData), uiSchema);
   const userErrorSchema = unwrapErrorHandler(errorHandler);
-  return validationDataMerge({
-    errors,
-    errorSchema
-  }, userErrorSchema);
+  return 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 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[ID_KEY]) {
       compiledValidator = this.ajv.getSchema(schema[ID_KEY]);
     }
     try {
-      if (compiledValidator === undefined) {
+      if (compiledValidator === void 0) {
         compiledValidator = this.ajv.compile(schema);
       }
       compiledValidator(formData);
@@ -225,228 +165,188 @@ class AJV8Validator {
     }
     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[ID_KEY] ?? 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 = withIdRefPrefix(schema);
       const schemaId = schemaWithIdRefPrefix[ID_KEY] ?? 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
+// src/precompiledValidator.ts
+import get2 from "lodash/get";
+import isEqual from "lodash/isEqual";
+import {
+  hashForSchema as hashForSchema2,
+  ID_KEY as ID_KEY2,
+  JUNK_OPTION_ID,
+  toErrorList as toErrorList2,
+  retrieveSchema
+} from "@rjsf/utils";
+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 = 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(schema, ID_KEY) || hashForSchema(schema);
+    const key = get2(schema, ID_KEY2) || hashForSchema2(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 toErrorList(errorSchema, fieldPath);
+    return toErrorList2(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(schema, this.resolvedRootSchema)) {
-      throw new Error('The schema associated with the precompiled schema differs from the schema provided for validation');
+      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(rootSchema, this.rootSchema)) {
-      throw new Error('The schema associated with the precompiled validator differs from the rootSchema provided for validation');
+      throw new Error(
+        "The schema associated with the precompiled validator differs from the rootSchema provided for validation"
+      );
     }
-    if (get(schema, ID_KEY) === JUNK_OPTION_ID) {
+    if (get2(schema, ID_KEY2) === 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();
-
-export { createPrecompiledValidator, customizeValidator, index as default };
+// src/index.ts
+var src_default = customizeValidator();
+export {
+  createPrecompiledValidator,
+  customizeValidator,
+  src_default as default
+};
 //# sourceMappingURL=validator-ajv8.esm.js.map