@rjsf/validator-ajv8 5.6.0 → 5.7.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as _rjsf_utils from '@rjsf/utils';
 import { StrictRJSFSchema, RJSFSchema, FormContextType, ValidatorType } from '@rjsf/utils';
-import Ajv, { Options, ErrorObject } from 'ajv';
+import Ajv, { Options, ErrorObject, ValidateFunction } from 'ajv';
 import { FormatsPluginOptions } from 'ajv-formats';
+import { DataValidationCxt } from 'ajv/lib/types';
 
 /** The type describing how to customize the AJV6 validator
  */
@@ -21,16 +22,58 @@ interface CustomValidatorOptionsType {
 }
 /** The type describing a function that takes a list of Ajv `ErrorObject`s and localizes them
  */
-type Localizer = (errors?: null | ErrorObject[]) => void;
+type Localizer = (errors?: null | ErrorObject[]) => void;
+/** Extend ValidateFunction to Omit its two required properties, `schema` and `schemaEnv` that are not produced by the
+ * AJV schema standalone compilation code
+ */
+interface CompiledValidateFunction<T = any> extends Omit<ValidateFunction<T>, 'schema' | 'schemaEnv'> {
+    /** This is almost an exact copy from the `ValidateFunction` type definition from which it extends because it seems to
+     * get lost as part of the Omit<> and this one simply returns boolean rather than `data is T`.
+     */
+    (this: Ajv | any, data: any, dataCxt?: DataValidationCxt): boolean;
+}
+/** The definition of precompiled validator functions
+ */
+type ValidatorFunctions<T = any> = {
+    [key: string]: CompiledValidateFunction<T>;
+};
 
 /** Creates and returns a customized implementation of the `ValidatorType` with the given customization `options` if
- * provided.
+ * 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
  */
 declare function customizeValidator<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(options?: CustomValidatorOptionsType, localizer?: Localizer): ValidatorType<T, S, F>;
 
+/** 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.
+ */
+declare function compileSchemaValidators<S extends StrictRJSFSchema = RJSFSchema>(schema: S, output: string, options?: CustomValidatorOptionsType): void;
+
+/** 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
+ */
+declare function createPrecompiledValidator<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validateFns: ValidatorFunctions<T>, rootSchema: S, localizer?: Localizer): ValidatorType<T, S, F>;
+
 declare const _default: _rjsf_utils.ValidatorType<any, _rjsf_utils.RJSFSchema, any>;
 
-export { CustomValidatorOptionsType, Localizer, customizeValidator, _default as default };
+export { CompiledValidateFunction, CustomValidatorOptionsType, Localizer, ValidatorFunctions, compileSchemaValidators, createPrecompiledValidator, customizeValidator, _default as default };

package/dist/validator-ajv8.cjs.development.js

@@ -2,18 +2,24 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var get = require('lodash/get');
 var utils = require('@rjsf/utils');
 var Ajv = require('ajv');
 var addFormats = require('ajv-formats');
 var isObject = require('lodash/isObject');
+var get = require('lodash/get');
+var fs = require('fs');
+var standaloneCode = require('ajv/dist/standalone');
+var isEqual = require('lodash/isEqual');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
 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 fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var standaloneCode__default = /*#__PURE__*/_interopDefaultLegacy(standaloneCode);
+var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
 
 function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
@@ -98,6 +104,110 @@ function createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverr
 }
 
 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 = _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();
+    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;
+      if (uiSchemaTitle) {
+        message = message.replace(currentProperty, uiSchemaTitle);
+      } else {
+        var 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();
+      } else {
+        var _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
+    };
+  });
+}
+/** 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) {
+  var invalidSchemaError = rawErrors.validationError;
+  var errors = transformRJSFValidationErrors(rawErrors.errors, uiSchema);
+  if (invalidSchemaError) {
+    errors = [].concat(errors, [{
+      stack: invalidSchemaError.message
+    }]);
+  }
+  if (typeof transformErrors === 'function') {
+    errors = transformErrors(errors, uiSchema);
+  }
+  var errorSchema = utils.toErrorSchema(errors);
+  if (invalidSchemaError) {
+    errorSchema = _extends({}, errorSchema, {
+      $schema: {
+        __errors: [invalidSchemaError.message]
+      }
+    });
+  }
+  if (typeof customValidate !== 'function') {
+    return {
+      errors: errors,
+      errorSchema: 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);
+  return utils.validationDataMerge({
+    errors: errors,
+    errorSchema: errorSchema
+  }, userErrorSchema);
+}
+
 /** `ValidatorType` implementation that uses the AJV 8 validation mechanism.
  */
 var AJV8Validator = /*#__PURE__*/function () {
@@ -139,63 +249,6 @@ var AJV8Validator = /*#__PURE__*/function () {
     }
     return utils.toErrorList(errorSchema, fieldPath);
   }
-  /** 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`
-   * @protected
-   */;
-  _proto.transformRJSFValidationErrors = 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 = _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();
-      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;
-        if (uiSchemaTitle) {
-          message = message.replace(currentProperty, uiSchemaTitle);
-        } else {
-          var 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();
-        } else {
-          var _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
-      };
-    });
-  }
   /** 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
    *
@@ -205,8 +258,8 @@ var AJV8Validator = /*#__PURE__*/function () {
   _proto.rawValidation = function rawValidation(schema, formData) {
     var compilationError = undefined;
     var compiledValidator;
-    if (schema['$id']) {
-      compiledValidator = this.ajv.getSchema(schema['$id']);
+    if (schema[utils.ID_KEY]) {
+      compiledValidator = this.ajv.getSchema(schema[utils.ID_KEY]);
     }
     try {
       if (compiledValidator === undefined) {
@@ -243,38 +296,7 @@ var AJV8Validator = /*#__PURE__*/function () {
    */;
   _proto.validateFormData = function validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
     var rawErrors = this.rawValidation(schema, formData);
-    var invalidSchemaError = rawErrors.validationError;
-    var errors = this.transformRJSFValidationErrors(rawErrors.errors, uiSchema);
-    if (invalidSchemaError) {
-      errors = [].concat(errors, [{
-        stack: invalidSchemaError.message
-      }]);
-    }
-    if (typeof transformErrors === 'function') {
-      errors = transformErrors(errors, uiSchema);
-    }
-    var errorSchema = utils.toErrorSchema(errors);
-    if (invalidSchemaError) {
-      errorSchema = _extends({}, errorSchema, {
-        $schema: {
-          __errors: [invalidSchemaError.message]
-        }
-      });
-    }
-    if (typeof customValidate !== 'function') {
-      return {
-        errors: errors,
-        errorSchema: errorSchema
-      };
-    }
-    // Include form data with undefined values, which is required for custom validation.
-    var newFormData = utils.getDefaultFormState(this, schema, formData, schema, true);
-    var errorHandler = customValidate(newFormData, utils.createErrorHandler(newFormData), uiSchema);
-    var userErrorSchema = utils.unwrapErrorHandler(errorHandler);
-    return utils.validationDataMerge({
-      errors: errors,
-      errorSchema: errorSchema
-    }, userErrorSchema);
+    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
@@ -285,8 +307,8 @@ var AJV8Validator = /*#__PURE__*/function () {
    * @param rootSchema - The root schema used to provide $ref resolutions
    */;
   _proto.isValid = function isValid(schema, formData, rootSchema) {
-    var _rootSchema$$id;
-    var rootSchemaId = (_rootSchema$$id = rootSchema['$id']) != null ? _rootSchema$$id : utils.ROOT_SCHEMA_PREFIX;
+    var _rootSchema$ID_KEY;
+    var rootSchemaId = (_rootSchema$ID_KEY = rootSchema[utils.ID_KEY]) != null ? _rootSchema$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
@@ -297,8 +319,8 @@ var AJV8Validator = /*#__PURE__*/function () {
       }
       var schemaWithIdRefPrefix = utils.withIdRefPrefix(schema);
       var compiledValidator;
-      if (schemaWithIdRefPrefix['$id']) {
-        compiledValidator = this.ajv.getSchema(schemaWithIdRefPrefix['$id']);
+      if (schemaWithIdRefPrefix[utils.ID_KEY]) {
+        compiledValidator = this.ajv.getSchema(schemaWithIdRefPrefix[utils.ID_KEY]);
       }
       if (compiledValidator === undefined) {
         compiledValidator = this.ajv.compile(schemaWithIdRefPrefix);
@@ -318,10 +340,12 @@ var AJV8Validator = /*#__PURE__*/function () {
 }();
 
 /** Creates and returns a customized implementation of the `ValidatorType` with the given customization `options` if
- * provided.
+ * 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
  */
 function customizeValidator(options, localizer) {
   if (options === void 0) {
@@ -330,8 +354,187 @@ function customizeValidator(options, localizer) {
   return new AJV8Validator(options, localizer);
 }
 
+/** 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.
+ */
+function compileSchemaValidators(schema, output, options) {
+  if (options === void 0) {
+    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;
+  // Allow users to turn off the `lines: true` feature in their own overrides, but NOT the `source: true`
+  var compileOptions = _extends({}, ajvOptionsOverrides, {
+    code: _extends({
+      lines: true
+    }, ajvOptionsOverrides.code, {
+      source: true
+    }),
+    schemas: schemas
+  });
+  var ajv = createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);
+  var moduleCode = standaloneCode__default["default"](ajv);
+  console.log("writing " + output);
+  fs__default["default"].writeFileSync(output, moduleCode);
+}
+
+/** `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 () {
+  /** 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
+   */
+  function AJV8PrecompiledValidator(validateFns, rootSchema, localizer) {
+    /** The root schema object used to construct this validator
+     *
+     * @private
+     */
+    this.rootSchema = 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);
+  }
+  /** 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
+   */
+  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];
+    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.
+   */;
+  _proto.toErrorList = function toErrorList(errorSchema, fieldPath) {
+    if (fieldPath === void 0) {
+      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
+   */;
+  _proto.rawValidation = function rawValidation(schema, formData) {
+    if (!isEqual__default["default"](schema, this.rootSchema)) {
+      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') {
+      this.localizer(this.mainValidator.errors);
+    }
+    var errors = this.mainValidator.errors || undefined;
+    // Clear errors to prevent persistent errors, see #1104
+    this.mainValidator.errors = null;
+    return {
+      errors: 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`
+   */;
+  _proto.validateFormData = function validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
+    var 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
+   */;
+  _proto.isValid = function 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');
+    }
+    var 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.
+ *
+ * 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
+ */
+function createPrecompiledValidator(validateFns, rootSchema, localizer) {
+  return new AJV8PrecompiledValidator(validateFns, rootSchema, localizer);
+}
+
 var index = /*#__PURE__*/customizeValidator();
 
+exports.compileSchemaValidators = compileSchemaValidators;
+exports.createPrecompiledValidator = createPrecompiledValidator;
 exports.customizeValidator = customizeValidator;
 exports["default"] = index;
 //# sourceMappingURL=validator-ajv8.cjs.development.js.map