@rjsf/validator-ajv8 5.10.0 → 5.11.1

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

@@ -12,41 +12,14 @@
   var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
   var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
 
-  function _extends() {
-    _extends = Object.assign ? Object.assign.bind() : function (target) {
-      for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) {
-          if (Object.prototype.hasOwnProperty.call(source, key)) {
-            target[key] = source[key];
-          }
-        }
-      }
-      return target;
-    };
-    return _extends.apply(this, arguments);
-  }
-  function _objectWithoutPropertiesLoose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for (i = 0; i < sourceKeys.length; i++) {
-      key = sourceKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      target[key] = source[key];
-    }
-    return target;
-  }
-
-  var AJV_CONFIG = {
+  const AJV_CONFIG = {
     allErrors: true,
     multipleOfPrecision: 8,
     strict: false,
     verbose: true
   };
-  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,(.*)$/;
+  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
@@ -62,14 +35,11 @@
    * @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) {
-    if (ajvOptionsOverrides === void 0) {
-      ajvOptionsOverrides = {};
-    }
-    if (AjvClass === void 0) {
-      AjvClass = Ajv__default["default"];
-    }
-    var ajv = new AjvClass(_extends({}, AJV_CONFIG, ajvOptionsOverrides));
+  function createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass = Ajv__default["default"]) {
+    const ajv = new AjvClass({
+      ...AJV_CONFIG,
+      ...ajvOptionsOverrides
+    });
     if (ajvFormatOptions) {
       addFormats__default["default"](ajv, ajvFormatOptions);
     } else if (ajvFormatOptions !== false) {
@@ -87,67 +57,66 @@
     }
     // add more custom formats to validate against
     if (isObject__default["default"](customFormats)) {
-      Object.keys(customFormats).forEach(function (formatName) {
+      Object.keys(customFormats).forEach(formatName => {
         ajv.addFormat(formatName, customFormats[formatName]);
       });
     }
     return ajv;
   }
 
-  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();
+  function transformRJSFValidationErrors(errors = [], uiSchema) {
+    return errors.map(e => {
+      const {
+        instancePath,
+        keyword,
+        params,
+        schemaPath,
+        parentSchema,
+        ...rest
+      } = e;
+      let {
+        message = ''
+      } = rest;
+      let property = instancePath.replace(/\//g, '.');
+      let stack = `${property} ${message}`.trim();
       if ('missingProperty' in params) {
-        property = property ? property + "." + params.missingProperty : params.missingProperty;
-        var currentProperty = params.missingProperty;
-        var uiSchemaTitle = utils.getUiOptions(get__default["default"](uiSchema, "" + property.replace(/^\./, ''))).title;
+        property = property ? `${property}.${params.missingProperty}` : params.missingProperty;
+        const currentProperty = params.missingProperty;
+        const uiSchemaTitle = utils.getUiOptions(get__default["default"](uiSchema, `${property.replace(/^\./, '')}`)).title;
         if (uiSchemaTitle) {
           message = message.replace(currentProperty, uiSchemaTitle);
         } else {
-          var parentSchemaTitle = get__default["default"](parentSchema, [utils.PROPERTIES_KEY, currentProperty, 'title']);
+          const parentSchemaTitle = get__default["default"](parentSchema, [utils.PROPERTIES_KEY, currentProperty, 'title']);
           if (parentSchemaTitle) {
             message = message.replace(currentProperty, parentSchemaTitle);
           }
         }
         stack = message;
       } else {
-        var _uiSchemaTitle = utils.getUiOptions(get__default["default"](uiSchema, "" + property.replace(/^\./, ''))).title;
-        if (_uiSchemaTitle) {
-          stack = ("'" + _uiSchemaTitle + "' " + message).trim();
+        const uiSchemaTitle = utils.getUiOptions(get__default["default"](uiSchema, `${property.replace(/^\./, '')}`)).title;
+        if (uiSchemaTitle) {
+          stack = `'${uiSchemaTitle}' ${message}`.trim();
         } else {
-          var _parentSchemaTitle = parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.title;
-          if (_parentSchemaTitle) {
-            stack = ("'" + _parentSchemaTitle + "' " + message).trim();
+          const parentSchemaTitle = parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.title;
+          if (parentSchemaTitle) {
+            stack = `'${parentSchemaTitle}' ${message}`.trim();
           }
         }
       }
       // put data in expected format
       return {
         name: keyword,
-        property: property,
-        message: message,
-        params: params,
-        stack: stack,
-        schemaPath: schemaPath
+        property,
+        message,
+        params,
+        stack,
+        schemaPath
       };
     });
   }
@@ -165,49 +134,52 @@
    * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
    */
   function processRawValidationErrors(validator, rawErrors, formData, schema, customValidate, transformErrors, uiSchema) {
-    var invalidSchemaError = rawErrors.validationError;
-    var errors = transformRJSFValidationErrors(rawErrors.errors, uiSchema);
+    const {
+      validationError: invalidSchemaError
+    } = rawErrors;
+    let errors = transformRJSFValidationErrors(rawErrors.errors, uiSchema);
     if (invalidSchemaError) {
-      errors = [].concat(errors, [{
+      errors = [...errors, {
         stack: invalidSchemaError.message
-      }]);
+      }];
     }
     if (typeof transformErrors === 'function') {
       errors = transformErrors(errors, uiSchema);
     }
-    var errorSchema = utils.toErrorSchema(errors);
+    let errorSchema = utils.toErrorSchema(errors);
     if (invalidSchemaError) {
-      errorSchema = _extends({}, errorSchema, {
+      errorSchema = {
+        ...errorSchema,
         $schema: {
           __errors: [invalidSchemaError.message]
         }
-      });
+      };
     }
     if (typeof customValidate !== 'function') {
       return {
-        errors: errors,
-        errorSchema: errorSchema
+        errors,
+        errorSchema
       };
     }
     // Include form data with undefined values, which is required for custom validation.
-    var newFormData = utils.getDefaultFormState(validator, schema, formData, schema, true);
-    var errorHandler = customValidate(newFormData, utils.createErrorHandler(newFormData), uiSchema);
-    var userErrorSchema = utils.unwrapErrorHandler(errorHandler);
+    const newFormData = utils.getDefaultFormState(validator, schema, formData, schema, true);
+    const errorHandler = customValidate(newFormData, utils.createErrorHandler(newFormData), uiSchema);
+    const userErrorSchema = utils.unwrapErrorHandler(errorHandler);
     return utils.validationDataMerge({
-      errors: errors,
-      errorSchema: errorSchema
+      errors,
+      errorSchema
     }, userErrorSchema);
   }
 
   /** `ValidatorType` implementation that uses the AJV 8 validation mechanism.
    */
-  var AJV8Validator = /*#__PURE__*/function () {
+  class AJV8Validator {
     /** Constructs an `AJV8Validator` instance using the `options`
      *
      * @param options - The `CustomValidatorOptionsType` options that are used to create the AJV instance
      * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
      */
-    function AJV8Validator(options, localizer) {
+    constructor(options, localizer) {
       /** The AJV instance to use for all validations
        *
        * @private
@@ -218,11 +190,13 @@
        * @private
        */
       this.localizer = void 0;
-      var additionalMetaSchemas = options.additionalMetaSchemas,
-        customFormats = options.customFormats,
-        ajvOptionsOverrides = options.ajvOptionsOverrides,
-        ajvFormatOptions = options.ajvFormatOptions,
-        AjvClass = options.AjvClass;
+      const {
+        additionalMetaSchemas,
+        customFormats,
+        ajvOptionsOverrides,
+        ajvFormatOptions,
+        AjvClass
+      } = options;
       this.ajv = createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides, ajvFormatOptions, AjvClass);
       this.localizer = localizer;
     }
@@ -233,11 +207,7 @@
      * @deprecated - Use the `toErrorList()` function provided by `@rjsf/utils` instead. This function will be removed in
      *        the next major release.
      */
-    var _proto = AJV8Validator.prototype;
-    _proto.toErrorList = function toErrorList(errorSchema, fieldPath) {
-      if (fieldPath === void 0) {
-        fieldPath = [];
-      }
+    toErrorList(errorSchema, fieldPath = []) {
       return utils.toErrorList(errorSchema, fieldPath);
     }
     /** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use
@@ -245,10 +215,10 @@
      *
      * @param schema - The schema against which to validate the form data   * @param schema
      * @param formData - The form data to validate
-     */;
-    _proto.rawValidation = function rawValidation(schema, formData) {
-      var compilationError = undefined;
-      var compiledValidator;
+     */
+    rawValidation(schema, formData) {
+      let compilationError = undefined;
+      let compiledValidator;
       if (schema[utils.ID_KEY]) {
         compiledValidator = this.ajv.getSchema(schema[utils.ID_KEY]);
       }
@@ -260,7 +230,7 @@
       } catch (err) {
         compilationError = err;
       }
-      var errors;
+      let errors;
       if (compiledValidator) {
         if (typeof this.localizer === 'function') {
           this.localizer(compiledValidator.errors);
@@ -284,9 +254,9 @@
      * @param [customValidate] - An optional function that is used to perform custom validation
      * @param [transformErrors] - An optional function that is used to transform errors after AJV validation
      * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
-     */;
-    _proto.validateFormData = function validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
-      var rawErrors = this.rawValidation(schema, formData);
+     */
+    validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
+      const rawErrors = this.rawValidation(schema, formData);
       return processRawValidationErrors(this, rawErrors, formData, schema, customValidate, transformErrors, uiSchema);
     }
     /** Validates data against a schema, returning true if the data is valid, or
@@ -296,12 +266,10 @@
      * @param schema - The schema against which to validate the form data
      * @param formData - The form data to validate
      * @param rootSchema - The root schema used to provide $ref resolutions
-     */;
-    _proto.isValid = function isValid(schema, formData, rootSchema) {
-      var _rootSchema$ID_KEY;
-      var rootSchemaId = (_rootSchema$ID_KEY = rootSchema[utils.ID_KEY]) != null ? _rootSchema$ID_KEY : utils.ROOT_SCHEMA_PREFIX;
+     */
+    isValid(schema, formData, rootSchema) {
+      const rootSchemaId = rootSchema[utils.ID_KEY] ?? utils.ROOT_SCHEMA_PREFIX;
       try {
-        var _schemaWithIdRefPrefi;
         // add the rootSchema ROOT_SCHEMA_PREFIX as id.
         // then rewrite the schema ref's to point to the rootSchema
         // this accounts for the case where schema have references to models
@@ -309,9 +277,9 @@
         if (this.ajv.getSchema(rootSchemaId) === undefined) {
           this.ajv.addSchema(rootSchema, rootSchemaId);
         }
-        var schemaWithIdRefPrefix = utils.withIdRefPrefix(schema);
-        var schemaId = (_schemaWithIdRefPrefi = schemaWithIdRefPrefix[utils.ID_KEY]) != null ? _schemaWithIdRefPrefi : utils.hashForSchema(schemaWithIdRefPrefix);
-        var compiledValidator;
+        const schemaWithIdRefPrefix = utils.withIdRefPrefix(schema);
+        const schemaId = schemaWithIdRefPrefix[utils.ID_KEY] ?? utils.hashForSchema(schemaWithIdRefPrefix);
+        let compiledValidator;
         compiledValidator = this.ajv.getSchema(schemaId);
         if (compiledValidator === undefined) {
           // Add schema by an explicit ID so it can be fetched later
@@ -319,7 +287,7 @@
           // https://ajv.js.org/guide/managing-schemas.html#pre-adding-all-schemas-vs-adding-on-demand
           compiledValidator = this.ajv.addSchema(schemaWithIdRefPrefix, schemaId).getSchema(schemaId) || this.ajv.compile(schemaWithIdRefPrefix);
         }
-        var result = compiledValidator(formData);
+        const result = compiledValidator(formData);
         return result;
       } catch (e) {
         console.warn('Error encountered compiling schema:', e);
@@ -329,9 +297,8 @@
         // make sure we remove the rootSchema from the global ajv instance
         this.ajv.removeSchema(rootSchemaId);
       }
-    };
-    return AJV8Validator;
-  }();
+    }
+  }
 
   /** Creates and returns a customized implementation of the `ValidatorType` with the given customization `options` if
    * provided. If a `localizer` is provided, it is used to translate the messages generated by the underlying AJV
@@ -341,17 +308,14 @@
    * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
    * @returns - The custom validator implementation resulting from the set of parameters provided
    */
-  function customizeValidator(options, localizer) {
-    if (options === void 0) {
-      options = {};
-    }
+  function customizeValidator(options = {}, localizer) {
     return new AJV8Validator(options, localizer);
   }
 
   /** `ValidatorType` implementation that uses an AJV 8 precompiled validator as created by the
    * `compileSchemaValidators()` function provided by the `@rjsf/validator-ajv8` library.
    */
-  var AJV8PrecompiledValidator = /*#__PURE__*/function () {
+  class AJV8PrecompiledValidator {
     /** Constructs an `AJV8PrecompiledValidator` instance using the `validateFns` and `rootSchema`
      *
      * @param validateFns - The map of the validation functions that are generated by the `schemaCompile()` function
@@ -359,7 +323,7 @@
      * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
      * @throws - Error when the base schema of the precompiled validator does not have a matching validator function
      */
-    function AJV8PrecompiledValidator(validateFns, rootSchema, localizer) {
+    constructor(validateFns, rootSchema, localizer) {
       /** The root schema object used to construct this validator
        *
        * @private
@@ -397,12 +361,11 @@
      * @param schema - The schema for which a precompiled validator function is desired
      * @returns - The precompiled validator function associated with this schema
      */
-    var _proto = AJV8PrecompiledValidator.prototype;
-    _proto.getValidator = function getValidator(schema) {
-      var key = get__default["default"](schema, utils.ID_KEY) || utils.hashForSchema(schema);
-      var validator = this.validateFns[key];
+    getValidator(schema) {
+      const key = get__default["default"](schema, utils.ID_KEY) || utils.hashForSchema(schema);
+      const validator = this.validateFns[key];
       if (!validator) {
-        throw new Error("No precompiled validator function was found for the given schema for \"" + key + "\"");
+        throw new Error(`No precompiled validator function was found for the given schema for "${key}"`);
       }
       return validator;
     }
@@ -412,11 +375,8 @@
      * @param [fieldPath=[]] - The current field path, defaults to [] if not specified
      * @deprecated - Use the `toErrorList()` function provided by `@rjsf/utils` instead. This function will be removed in
      *        the next major release.
-     */;
-    _proto.toErrorList = function toErrorList(errorSchema, fieldPath) {
-      if (fieldPath === void 0) {
-        fieldPath = [];
-      }
+     */
+    toErrorList(errorSchema, fieldPath = []) {
       return utils.toErrorList(errorSchema, fieldPath);
     }
     /** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use
@@ -425,8 +385,8 @@
      * @param schema - The schema against which to validate the form data   * @param schema
      * @param formData - The form data to validate
      * @throws - Error when the schema provided does not match the base schema of the precompiled validator
-     */;
-    _proto.rawValidation = function rawValidation(schema, formData) {
+     */
+    rawValidation(schema, formData) {
       if (!isEqual__default["default"](schema, this.resolvedRootSchema)) {
         throw new Error('The schema associated with the precompiled schema differs from the schema provided for validation');
       }
@@ -434,7 +394,7 @@
       if (typeof this.localizer === 'function') {
         this.localizer(this.mainValidator.errors);
       }
-      var errors = this.mainValidator.errors || undefined;
+      const errors = this.mainValidator.errors || undefined;
       // Clear errors to prevent persistent errors, see #1104
       this.mainValidator.errors = null;
       return {
@@ -451,9 +411,9 @@
      * @param [customValidate] - An optional function that is used to perform custom validation
      * @param [transformErrors] - An optional function that is used to transform errors after AJV validation
      * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
-     */;
-    _proto.validateFormData = function validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
-      var rawErrors = this.rawValidation(schema, formData);
+     */
+    validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
+      const rawErrors = this.rawValidation(schema, formData);
       return processRawValidationErrors(this, rawErrors, formData, schema, customValidate, transformErrors, uiSchema);
     }
     /** Validates data against a schema, returning true if the data is valid, or false otherwise. If the schema is
@@ -465,19 +425,18 @@
      * @returns - true if the formData validates against the schema, false otherwise
      * @throws - Error when the schema provided does not match the base schema of the precompiled validator OR if there
      *        isn't a precompiled validator function associated with the schema
-     */;
-    _proto.isValid = function isValid(schema, formData, rootSchema) {
+     */
+    isValid(schema, formData, rootSchema) {
       if (!isEqual__default["default"](rootSchema, this.rootSchema)) {
         throw new Error('The schema associated with the precompiled validator differs from the rootSchema provided for validation');
       }
       if (get__default["default"](schema, utils.ID_KEY) === utils.JUNK_OPTION_ID) {
         return false;
       }
-      var validator = this.getValidator(schema);
+      const validator = this.getValidator(schema);
       return validator(formData);
-    };
-    return AJV8PrecompiledValidator;
-  }();
+    }
+  }
 
   /** Creates and returns a `ValidatorType` interface that is implemented with a precompiled validator. If a `localizer`
    * is provided, it is used to translate the messages generated by the underlying AJV validation.