@rjsf/validator-ata 6.6.1

package/dist/validator-ata.esm.js

@@ -0,0 +1,450 @@
+// src/precompiledValidator.ts
+import {
+  deepEquals,
+  hashForSchema,
+  ID_KEY,
+  JUNK_OPTION_ID,
+  retrieveSchema
+} from "@rjsf/utils";
+import get2 from "lodash/get";
+
+// src/processRawValidationErrors.ts
+import {
+  ANY_OF_KEY,
+  createErrorHandler,
+  getDefaultFormState,
+  getUiOptions,
+  ONE_OF_KEY,
+  PROPERTIES_KEY,
+  toErrorSchema,
+  unwrapErrorHandler,
+  validationDataMerge
+} from "@rjsf/utils";
+import get from "lodash/get";
+function filterDuplicateErrors(errorList, suppressDuplicateFiltering = "none") {
+  if (suppressDuplicateFiltering === "all") {
+    return errorList;
+  }
+  return errorList.reduce((acc, err) => {
+    const { message, schemaPath } = err;
+    const anyOfIndex = suppressDuplicateFiltering !== "anyOf" ? schemaPath?.indexOf(`/${ANY_OF_KEY}/`) : void 0;
+    const oneOfIndex = suppressDuplicateFiltering !== "oneOf" ? schemaPath?.indexOf(`/${ONE_OF_KEY}/`) : void 0;
+    let schemaPrefix;
+    if (anyOfIndex && anyOfIndex >= 0) {
+      schemaPrefix = schemaPath?.substring(0, anyOfIndex);
+    } else if (oneOfIndex && oneOfIndex >= 0) {
+      schemaPrefix = schemaPath?.substring(0, oneOfIndex);
+    }
+    const dup = schemaPrefix ? acc.find((e) => e.message === message && e.schemaPath?.startsWith(schemaPrefix)) : void 0;
+    if (!dup) {
+      acc.push(err);
+    }
+    return acc;
+  }, []);
+}
+function transformRJSFValidationErrors(errors = [], uiSchema, suppressDuplicateFiltering) {
+  const errorList = errors.map((e) => {
+    const { instancePath, keyword, params, schemaPath, parentSchema } = e;
+    let { message = "" } = e;
+    let property = instancePath.replace(/\//g, ".");
+    let stack = `${property} ${message}`.trim();
+    let uiTitle = "";
+    const p = params;
+    const rawPropertyNames = [
+      ...p?.deps?.split(", ") || [],
+      p?.missingProperty,
+      p?.property
+    ].filter((item) => Boolean(item));
+    if (rawPropertyNames.length > 0) {
+      rawPropertyNames.forEach((currentProperty) => {
+        const path = property ? `${property}.${currentProperty}` : currentProperty;
+        let uiSchemaTitle = getUiOptions(get(uiSchema, `${path.replace(/^\./, "")}`)).title;
+        if (uiSchemaTitle === void 0) {
+          const uiSchemaPath = schemaPath.replace(/\/properties\//g, "/").split("/").slice(1, -1).concat([currentProperty]);
+          uiSchemaTitle = getUiOptions(get(uiSchema, uiSchemaPath)).title;
+        }
+        if (uiSchemaTitle) {
+          message = message.replace(`'${currentProperty}'`, `'${uiSchemaTitle}'`);
+          uiTitle = uiSchemaTitle;
+        } else {
+          const parentSchemaTitle = get(parentSchema, [PROPERTIES_KEY, currentProperty, "title"]);
+          if (parentSchemaTitle) {
+            message = message.replace(`'${currentProperty}'`, `'${parentSchemaTitle}'`);
+            uiTitle = parentSchemaTitle;
+          }
+        }
+      });
+      stack = message;
+    } else {
+      const uiSchemaTitle = getUiOptions(get(uiSchema, `${property.replace(/^\./, "")}`)).title;
+      if (uiSchemaTitle) {
+        stack = `'${uiSchemaTitle}' ${message}`.trim();
+        uiTitle = uiSchemaTitle;
+      } else {
+        const parentSchemaTitle = parentSchema?.title;
+        if (parentSchemaTitle) {
+          stack = `'${parentSchemaTitle}' ${message}`.trim();
+          uiTitle = parentSchemaTitle;
+        }
+      }
+    }
+    if (p && "missingProperty" in p) {
+      property = property ? `${property}.${p.missingProperty}` : p.missingProperty;
+    }
+    return {
+      name: keyword,
+      property,
+      message,
+      params,
+      stack,
+      schemaPath,
+      title: uiTitle
+    };
+  });
+  return filterDuplicateErrors(errorList, suppressDuplicateFiltering);
+}
+function processRawValidationErrors(validator, rawErrors, formData, schema, customValidate, transformErrors, uiSchema, suppressDuplicateFiltering) {
+  const { validationError: invalidSchemaError } = rawErrors;
+  let errors = transformRJSFValidationErrors(rawErrors.errors, uiSchema, suppressDuplicateFiltering);
+  if (invalidSchemaError) {
+    errors = [...errors, { stack: invalidSchemaError.message }];
+  }
+  if (typeof transformErrors === "function") {
+    errors = transformErrors(errors, uiSchema);
+  }
+  let errorSchema = toErrorSchema(errors);
+  if (invalidSchemaError) {
+    errorSchema = {
+      ...errorSchema,
+      $schema: {
+        __errors: [invalidSchemaError.message]
+      }
+    };
+  }
+  if (typeof customValidate !== "function") {
+    return { errors, errorSchema };
+  }
+  const newFormData = getDefaultFormState(validator, schema, formData, schema, true);
+  const errorHandler = customValidate(newFormData, createErrorHandler(newFormData), uiSchema, errorSchema);
+  const userErrorSchema = unwrapErrorHandler(errorHandler);
+  return validationDataMerge({ errors, errorSchema }, userErrorSchema);
+}
+
+// src/precompiledValidator.ts
+var ATAPrecompiledValidator = class {
+  /** Constructs an `ATAPrecompiledValidator` 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 ata `ValidationError`s
+   * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`
+   * @throws - Error when the base schema of the precompiled validator does not have a matching validator function
+   */
+  constructor(validateFns, rootSchema, localizer, suppressDuplicateFiltering) {
+    this.rootSchema = rootSchema;
+    this.validateFns = validateFns;
+    this.localizer = localizer;
+    this.suppressDuplicateFiltering = suppressDuplicateFiltering;
+    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
+   */
+  getValidator(schema) {
+    const key = get2(schema, ID_KEY) || 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;
+  }
+  /** Ensures that the validator is using the same schema as the root schema used to construct the precompiled
+   * validator. It first compares the given `schema` against the root schema and if they aren't the same, then it
+   * checks against the resolved root schema, on the chance that a resolved version of the root schema was passed in
+   * instead of the raw root schema.
+   *
+   * @param schema - The schema against which to validate the form data
+   * @param [formData] - The form data to validate if any
+   */
+  ensureSameRootSchema(schema, formData) {
+    if (!deepEquals(schema, this.rootSchema)) {
+      const resolvedRootSchema = retrieveSchema(this, this.rootSchema, this.rootSchema, formData);
+      if (!deepEquals(schema, resolvedRootSchema)) {
+        throw new Error(
+          "The schema associated with the precompiled validator differs from the rootSchema provided for validation"
+        );
+      }
+    }
+    return true;
+  }
+  /** 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 [formData] - The form data to validate, if any
+   * @throws - Error when the schema provided does not match the base schema of the precompiled validator
+   */
+  rawValidation(schema, formData) {
+    this.ensureSameRootSchema(schema, formData);
+    this.mainValidator(formData);
+    if (typeof this.localizer === "function") {
+      this.localizer(this.mainValidator.errors);
+    }
+    const errors = this.mainValidator.errors || void 0;
+    this.mainValidator.errors = null;
+    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 ata 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 ata 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,
+      this.suppressDuplicateFiltering
+    );
+  }
+  /** 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) {
+    this.ensureSameRootSchema(rootSchema, formData);
+    if (get2(schema, ID_KEY) === JUNK_OPTION_ID) {
+      return false;
+    }
+    const validator = this.getValidator(schema);
+    return validator(formData);
+  }
+};
+
+// src/createPrecompiledValidator.ts
+function createPrecompiledValidator(validateFns, rootSchema, localizer, suppressDuplicateFiltering) {
+  return new ATAPrecompiledValidator(validateFns, rootSchema, localizer, suppressDuplicateFiltering);
+}
+
+// src/validator.ts
+import {
+  deepEquals as deepEquals2,
+  hashForSchema as hashForSchema2,
+  ID_KEY as ID_KEY2,
+  ROOT_SCHEMA_PREFIX,
+  withIdRefPrefix
+} from "@rjsf/utils";
+import cloneDeep from "lodash/cloneDeep";
+
+// src/createAtaInstance.ts
+import { Validator } from "ata-validator";
+import isObject from "lodash/isObject";
+var ATA_CONFIG = {
+  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,(.*)$/;
+function asFormatChecker(spec) {
+  if (typeof spec === "function") {
+    return spec;
+  }
+  const re = spec instanceof RegExp ? spec : new RegExp(spec);
+  return (value) => re.test(value);
+}
+function createAtaInstance(schema, options = {}) {
+  const { customFormats, ataOptionsOverrides, additionalMetaSchemas, extenderFn } = options;
+  const formats = {
+    color: asFormatChecker(COLOR_FORMAT_REGEX),
+    "data-url": asFormatChecker(DATA_URL_FORMAT_REGEX)
+  };
+  if (isObject(customFormats)) {
+    for (const [name, spec] of Object.entries(customFormats)) {
+      formats[name] = asFormatChecker(spec);
+    }
+  }
+  const validatorOptions = {
+    ...ATA_CONFIG,
+    ...ataOptionsOverrides,
+    formats
+  };
+  let validator = new Validator(schema, validatorOptions);
+  if (Array.isArray(additionalMetaSchemas)) {
+    for (const meta of additionalMetaSchemas) {
+      validator.addSchema(meta);
+    }
+  }
+  if (typeof extenderFn === "function") {
+    validator = extenderFn(validator);
+  }
+  return validator;
+}
+
+// src/validator.ts
+var ATAValidator = class {
+  constructor(options, localizer) {
+    /** Per-schema-id cache of constructed ata `Validator` instances. AJV uses a
+     * single instance with a schema registry; ata is schema-bound, so we
+     * maintain the registry ourselves.
+     */
+    this.validators = /* @__PURE__ */ new Map();
+    /** True once a `rootSchema` has been registered in this lifecycle. */
+    this.hasRegisteredRootSchema = false;
+    this.options = options;
+    this.localizer = localizer;
+    this.suppressDuplicateFiltering = options.suppressDuplicateFiltering;
+  }
+  /** Resets the cached validators and root-schema bookkeeping. Mirrors
+   * `AJV8Validator#reset` so RJSF's test harness can flush state between runs.
+   */
+  reset() {
+    this.validators.clear();
+    this.lastSeenRootSchema = void 0;
+    this.hasRegisteredRootSchema = false;
+  }
+  /** Returns a structural copy of `formData` so ata's default-applier
+   * (which writes `default` values into the input object during validation)
+   * doesn't leak a mutation back to the caller. RJSF probes the same data
+   * through `isValid` repeatedly while resolving oneOf/anyOf options, and
+   * a mutated probe changes subsequent answers, so the wrapper has to
+   * preserve referential purity that AJV provides by default.
+   */
+  cloneForValidation(data) {
+    if (data === null || typeof data !== "object") {
+      return data;
+    }
+    if (typeof globalThis.structuredClone === "function") {
+      return globalThis.structuredClone(data);
+    }
+    return cloneDeep(data);
+  }
+  /** Returns the cached ata `Validator` for the given id, or builds and
+   * caches a new one. When a rootSchema has been registered via
+   * `handleSchemaUpdate`, it is supplied as a sibling schema so `$ref` to
+   * the root resolves regardless of which sub-schema is being validated.
+   */
+  getOrBuild(id, schema) {
+    const existing = this.validators.get(id);
+    if (existing && deepEquals2(existing.schema, schema)) {
+      return existing.validator;
+    }
+    const siblingRoots = this.cachedRootSchema && this.cachedRootSchema !== schema ? [this.cachedRootSchema] : [];
+    const optionsWithSchemas = {
+      ...this.options,
+      ataOptionsOverrides: {
+        ...this.options.ataOptionsOverrides || {},
+        ...siblingRoots.length ? { schemas: siblingRoots } : {}
+      }
+    };
+    const validator = createAtaInstance(schema, optionsWithSchemas);
+    this.validators.set(id, { validator, schema });
+    return validator;
+  }
+  /** Runs raw validation against the given schema. Equivalent to
+   * `AJV8Validator#rawValidation`: returns ata's error array (already in
+   * AJV-compatible shape) plus any compilation error encountered.
+   */
+  rawValidation(schema, formData) {
+    let compilationError;
+    let errors;
+    try {
+      const id = schema[ID_KEY2] ?? hashForSchema2(schema);
+      const validator = this.getOrBuild(id, schema);
+      const result = validator.validate(this.cloneForValidation(formData));
+      errors = result.valid ? void 0 : result.errors;
+      if (errors && typeof this.localizer === "function") {
+        this.localizer(errors);
+      }
+    } catch (err) {
+      compilationError = err;
+    }
+    return {
+      errors,
+      validationError: compilationError
+    };
+  }
+  /** Validates `formData` and returns RJSF's `ValidationData<T>`. See
+   * `processRawValidationErrors` for the shape of the post-processing
+   * pipeline (custom validation, transform hook, ui-title resolution).
+   */
+  validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
+    const rawErrors = this.rawValidation(schema, formData);
+    return processRawValidationErrors(
+      this,
+      rawErrors,
+      formData,
+      schema,
+      customValidate,
+      transformErrors,
+      uiSchema,
+      this.suppressDuplicateFiltering
+    );
+  }
+  /** Registers (or refreshes) the rootSchema in the per-schema registry so
+   * subsequent `$ref`-resolving validators can see it. Mirrors AJV's
+   * `addSchema(rootSchema, rootSchemaId)` flow.
+   */
+  handleSchemaUpdate(rootSchema) {
+    if (this.lastSeenRootSchema === rootSchema && this.hasRegisteredRootSchema) {
+      return;
+    }
+    const rootSchemaId = rootSchema[ID_KEY2] ?? ROOT_SCHEMA_PREFIX;
+    const rootWithId = rootSchema[ID_KEY2] === rootSchemaId ? rootSchema : { ...rootSchema, [ID_KEY2]: rootSchemaId };
+    this.cachedRootSchema = rootWithId;
+    const cached = this.validators.get(rootSchemaId);
+    if (!cached || !deepEquals2(cached.schema, rootWithId)) {
+      this.getOrBuild(rootSchemaId, rootWithId);
+    }
+    this.lastSeenRootSchema = rootSchema;
+    this.hasRegisteredRootSchema = true;
+  }
+  /** Boolean validation entrypoint. Returns false on validation failure or
+   * compilation error. Mirrors `AJV8Validator#isValid` semantics.
+   */
+  isValid(schema, formData, rootSchema) {
+    try {
+      this.handleSchemaUpdate(rootSchema);
+      const schemaWithIdRefPrefix = withIdRefPrefix(schema);
+      const id = schemaWithIdRefPrefix[ID_KEY2] ?? hashForSchema2(schemaWithIdRefPrefix);
+      const validator = this.getOrBuild(id, schemaWithIdRefPrefix);
+      return validator.validate(this.cloneForValidation(formData)).valid;
+    } catch (e) {
+      console.warn("Error encountered compiling schema:", e);
+      return false;
+    }
+  }
+};
+
+// src/customizeValidator.ts
+function customizeValidator(options = {}, localizer) {
+  return new ATAValidator(options, localizer);
+}
+
+// src/index.ts
+var index_default = customizeValidator();
+export {
+  ATAValidator,
+  createPrecompiledValidator,
+  customizeValidator,
+  index_default as default
+};
+//# sourceMappingURL=validator-ata.esm.js.map

package/dist/validator-ata.esm.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/precompiledValidator.ts", "../src/processRawValidationErrors.ts", "../src/createPrecompiledValidator.ts", "../src/validator.ts", "../src/createAtaInstance.ts", "../src/customizeValidator.ts", "../src/index.ts"],
+  "sourcesContent": ["import {\n  CustomValidator,\n  deepEquals,\n  ErrorTransformer,\n  FormContextType,\n  hashForSchema,\n  ID_KEY,\n  JUNK_OPTION_ID,\n  retrieveSchema,\n  RJSFSchema,\n  StrictRJSFSchema,\n  UiSchema,\n  ValidationData,\n  ValidatorType,\n} from '@rjsf/utils';\nimport type { ValidationError } from 'ata-validator';\nimport get from 'lodash/get';\n\nimport processRawValidationErrors, { RawValidationErrorsType } from './processRawValidationErrors';\nimport { CompiledValidateFunction, Localizer, SuppressDuplicateFilteringType, ValidatorFunctions } from './types';\n\n/** `ValidatorType` implementation that uses an ata precompiled validator as created by the\n * `compileSchemaValidators()` function provided by the `@rjsf/validator-ata` library.\n */\nexport default class ATAPrecompiledValidator<\n  T = any,\n  S extends StrictRJSFSchema = RJSFSchema,\n  F extends FormContextType = any,\n> implements ValidatorType<T, S, F> {\n  /** The root schema object used to construct this validator\n   *\n   * @private\n   */\n  readonly rootSchema: S;\n\n  /** The `ValidatorFunctions` map used to construct this validator\n   *\n   * @private\n   */\n  readonly validateFns: ValidatorFunctions;\n\n  /** The main validator function associated with the base schema in the `precompiledValidator`\n   *\n   * @private\n   */\n  readonly mainValidator: CompiledValidateFunction;\n\n  /** The Localizer function to use for localizing ata errors\n   *\n   * @private\n   */\n  readonly localizer?: Localizer;\n\n  /** Controls which duplicate error filtering is suppressed; see `filterDuplicateErrors`\n   *\n   * @private\n   */\n  readonly suppressDuplicateFiltering?: SuppressDuplicateFilteringType;\n\n  /** Constructs an `ATAPrecompiledValidator` instance using the `validateFns` and `rootSchema`\n   *\n   * @param validateFns - The map of the validation functions that are generated by the `schemaCompile()` function\n   * @param rootSchema - The root schema that was used with the `compileSchema()` function\n   * @param [localizer] - If provided, is used to localize a list of ata `ValidationError`s\n   * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`\n   * @throws - Error when the base schema of the precompiled validator does not have a matching validator function\n   */\n  constructor(\n    validateFns: ValidatorFunctions,\n    rootSchema: S,\n    localizer?: Localizer,\n    suppressDuplicateFiltering?: SuppressDuplicateFilteringType,\n  ) {\n    this.rootSchema = rootSchema;\n    this.validateFns = validateFns;\n    this.localizer = localizer;\n    this.suppressDuplicateFiltering = suppressDuplicateFiltering;\n    this.mainValidator = this.getValidator(rootSchema);\n  }\n\n  /** Returns the precompiled validator associated with the given `schema` from the map of precompiled validator\n   * functions.\n   *\n   * @param schema - The schema for which a precompiled validator function is desired\n   * @returns - The precompiled validator function associated with this schema\n   */\n  getValidator(schema: S) {\n    const key = get(schema, ID_KEY) || hashForSchema(schema);\n    const validator = this.validateFns[key];\n    if (!validator) {\n      throw new Error(`No precompiled validator function was found for the given schema for \"${key}\"`);\n    }\n    return validator;\n  }\n\n  /** Ensures that the validator is using the same schema as the root schema used to construct the precompiled\n   * validator. It first compares the given `schema` against the root schema and if they aren't the same, then it\n   * checks against the resolved root schema, on the chance that a resolved version of the root schema was passed in\n   * instead of the raw root schema.\n   *\n   * @param schema - The schema against which to validate the form data\n   * @param [formData] - The form data to validate if any\n   */\n  ensureSameRootSchema(schema: S, formData?: T) {\n    if (!deepEquals(schema, this.rootSchema)) {\n      // Resolve the root schema with the passed in form data since that may affect the resolution\n      const resolvedRootSchema = retrieveSchema(this, this.rootSchema, this.rootSchema, formData);\n      if (!deepEquals(schema, resolvedRootSchema)) {\n        throw new Error(\n          'The schema associated with the precompiled validator differs from the rootSchema provided for validation',\n        );\n      }\n    }\n    return true;\n  }\n\n  /** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use\n   * by the playground. Returns the `errors` from the validation\n   *\n   * @param schema - The schema against which to validate the form data\n   * @param [formData] - The form data to validate, if any\n   * @throws - Error when the schema provided does not match the base schema of the precompiled validator\n   */\n  rawValidation<Result = any>(schema: S, formData?: T): RawValidationErrorsType<Result> {\n    this.ensureSameRootSchema(schema, formData);\n    this.mainValidator(formData);\n\n    if (typeof this.localizer === 'function') {\n      this.localizer(this.mainValidator.errors);\n    }\n    const errors = this.mainValidator.errors || undefined;\n\n    // Clear errors to prevent persistent errors, see #1104\n    this.mainValidator.errors = null;\n\n    return { errors: errors as unknown as Result[] };\n  }\n\n  /** This function processes the `formData` with an optional user contributed `customValidate` function, which receives\n   * the form data and a `errorHandler` function that will be used to add custom validation errors for each field. Also\n   * supports a `transformErrors` function that will take the raw ata validation errors, prior to custom validation and\n   * transform them in what ever way it chooses.\n   *\n   * @param formData - The form data to validate\n   * @param schema - The schema against which to validate the form data\n   * @param [customValidate] - An optional function that is used to perform custom validation\n   * @param [transformErrors] - An optional function that is used to transform errors after ata validation\n   * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`\n   */\n  validateFormData(\n    formData: T | undefined,\n    schema: S,\n    customValidate?: CustomValidator<T, S, F>,\n    transformErrors?: ErrorTransformer<T, S, F>,\n    uiSchema?: UiSchema<T, S, F>,\n  ): ValidationData<T> {\n    const rawErrors = this.rawValidation<ValidationError>(schema, formData);\n    return processRawValidationErrors(\n      this,\n      rawErrors,\n      formData,\n      schema,\n      customValidate,\n      transformErrors,\n      uiSchema,\n      this.suppressDuplicateFiltering,\n    );\n  }\n\n  /** Validates data against a schema, returning true if the data is valid, or false otherwise. If the schema is\n   * invalid, then this function will return false.\n   *\n   * @param schema - The schema against which to validate the form data\n   * @param formData - The form data to validate\n   * @param rootSchema - The root schema used to provide $ref resolutions\n   * @returns - true if the formData validates against the schema, false otherwise\n   * @throws - Error when the schema provided does not match the base schema of the precompiled validator OR if there\n   *        isn't a precompiled validator function associated with the schema\n   */\n  isValid(schema: S, formData: T | undefined, rootSchema: S) {\n    this.ensureSameRootSchema(rootSchema, formData);\n    if (get(schema, ID_KEY) === JUNK_OPTION_ID) {\n      return false;\n    }\n    const validator = this.getValidator(schema);\n    return validator(formData);\n  }\n}\n", "import {\n  ANY_OF_KEY,\n  createErrorHandler,\n  CustomValidator,\n  ErrorTransformer,\n  FormContextType,\n  getDefaultFormState,\n  getUiOptions,\n  ONE_OF_KEY,\n  PROPERTIES_KEY,\n  RJSFSchema,\n  RJSFValidationError,\n  StrictRJSFSchema,\n  toErrorSchema,\n  UiSchema,\n  unwrapErrorHandler,\n  validationDataMerge,\n  ValidatorType,\n} from '@rjsf/utils';\nimport type { ValidationError } from 'ata-validator';\nimport get from 'lodash/get';\n\nimport type { SuppressDuplicateFilteringType } from './types';\n\nexport type RawValidationErrorsType<Result = any> = {\n  errors?: Result[];\n  validationError?: Error;\n};\n\n/** Filters duplicate errors from `anyOf`/`oneOf` schema paths according to\n * the `suppressDuplicateFiltering` flag. Mirrors the `@rjsf/validator-ajv8`\n * implementation: under any non-`'all'` setting, duplicate messages that\n * share a common prefix before the `/anyOf/` or `/oneOf/` segment are\n * collapsed into a single entry.\n */\nexport function filterDuplicateErrors(\n  errorList: RJSFValidationError[],\n  suppressDuplicateFiltering: SuppressDuplicateFilteringType = 'none',\n): RJSFValidationError[] {\n  if (suppressDuplicateFiltering === 'all') {\n    return errorList;\n  }\n  return errorList.reduce((acc: RJSFValidationError[], err: RJSFValidationError) => {\n    const { message, schemaPath } = err;\n    const anyOfIndex = suppressDuplicateFiltering !== 'anyOf' ? schemaPath?.indexOf(`/${ANY_OF_KEY}/`) : undefined;\n    const oneOfIndex = suppressDuplicateFiltering !== 'oneOf' ? schemaPath?.indexOf(`/${ONE_OF_KEY}/`) : undefined;\n    let schemaPrefix: string | undefined;\n    if (anyOfIndex && anyOfIndex >= 0) {\n      schemaPrefix = schemaPath?.substring(0, anyOfIndex);\n    } else if (oneOfIndex && oneOfIndex >= 0) {\n      schemaPrefix = schemaPath?.substring(0, oneOfIndex);\n    }\n    const dup = schemaPrefix\n      ? acc.find((e: RJSFValidationError) => e.message === message && e.schemaPath?.startsWith(schemaPrefix))\n      : undefined;\n    if (!dup) {\n      acc.push(err);\n    }\n    return acc;\n  }, [] as RJSFValidationError[]);\n}\n\n/** Transforms ata-validator errors into the RJSF-internal `RJSFValidationError`\n * shape. ata's error objects already use the same field names AJV does\n * (`instancePath`, `keyword`, `params`, `schemaPath`, `parentSchema`,\n * `message`), so the conversion is structural only.\n */\nexport function transformRJSFValidationErrors<\n  T = any,\n  S extends StrictRJSFSchema = RJSFSchema,\n  F extends FormContextType = any,\n>(\n  errors: ValidationError[] = [],\n  uiSchema?: UiSchema<T, S, F>,\n  suppressDuplicateFiltering?: SuppressDuplicateFilteringType,\n): RJSFValidationError[] {\n  const errorList = errors.map((e: ValidationError) => {\n    const { instancePath, keyword, params, schemaPath, parentSchema } = e;\n    let { message = '' } = e;\n    let property = instancePath.replace(/\\//g, '.');\n    let stack = `${property} ${message}`.trim();\n    let uiTitle = '';\n\n    const p = params as Record<string, any>;\n    const rawPropertyNames: string[] = [\n      ...((p?.deps as string | undefined)?.split(', ') || []),\n      p?.missingProperty,\n      p?.property,\n    ].filter((item) => Boolean(item));\n\n    if (rawPropertyNames.length > 0) {\n      rawPropertyNames.forEach((currentProperty) => {\n        const path = property ? `${property}.${currentProperty}` : currentProperty;\n        let uiSchemaTitle = getUiOptions(get(uiSchema, `${path.replace(/^\\./, '')}`)).title;\n        if (uiSchemaTitle === undefined) {\n          const uiSchemaPath = schemaPath\n            .replace(/\\/properties\\//g, '/')\n            .split('/')\n            .slice(1, -1)\n            .concat([currentProperty]);\n          uiSchemaTitle = getUiOptions(get(uiSchema, uiSchemaPath)).title;\n        }\n        if (uiSchemaTitle) {\n          message = message.replace(`'${currentProperty}'`, `'${uiSchemaTitle}'`);\n          uiTitle = uiSchemaTitle;\n        } else {\n          const parentSchemaTitle = get(parentSchema, [PROPERTIES_KEY, currentProperty, 'title']);\n          if (parentSchemaTitle) {\n            message = message.replace(`'${currentProperty}'`, `'${parentSchemaTitle}'`);\n            uiTitle = parentSchemaTitle;\n          }\n        }\n      });\n\n      stack = message;\n    } else {\n      const uiSchemaTitle = getUiOptions<T, S, F>(get(uiSchema, `${property.replace(/^\\./, '')}`)).title;\n\n      if (uiSchemaTitle) {\n        stack = `'${uiSchemaTitle}' ${message}`.trim();\n        uiTitle = uiSchemaTitle;\n      } else {\n        const parentSchemaTitle = (parentSchema as { title?: string } | undefined)?.title;\n\n        if (parentSchemaTitle) {\n          stack = `'${parentSchemaTitle}' ${message}`.trim();\n          uiTitle = parentSchemaTitle;\n        }\n      }\n    }\n\n    if (p && 'missingProperty' in p) {\n      property = property ? `${property}.${p.missingProperty}` : p.missingProperty;\n    }\n\n    return {\n      name: keyword,\n      property,\n      message,\n      params,\n      stack,\n      schemaPath,\n      title: uiTitle,\n    };\n  });\n  return filterDuplicateErrors(errorList, suppressDuplicateFiltering);\n}\n\n/** Processes raw ata validation errors into the `ValidationData<T>` shape\n * RJSF consumes. Mirrors the AJV-validator's `processRawValidationErrors`,\n * including the optional `customValidate` and `transformErrors` hooks.\n */\nexport default function processRawValidationErrors<\n  T = any,\n  S extends StrictRJSFSchema = RJSFSchema,\n  F extends FormContextType = any,\n>(\n  validator: ValidatorType<T, S, F>,\n  rawErrors: RawValidationErrorsType<ValidationError>,\n  formData: T | undefined,\n  schema: S,\n  customValidate?: CustomValidator<T, S, F>,\n  transformErrors?: ErrorTransformer<T, S, F>,\n  uiSchema?: UiSchema<T, S, F>,\n  suppressDuplicateFiltering?: SuppressDuplicateFilteringType,\n) {\n  const { validationError: invalidSchemaError } = rawErrors;\n  let errors = transformRJSFValidationErrors<T, S, F>(rawErrors.errors, uiSchema, suppressDuplicateFiltering);\n\n  if (invalidSchemaError) {\n    errors = [...errors, { stack: invalidSchemaError!.message }];\n  }\n  if (typeof transformErrors === 'function') {\n    errors = transformErrors(errors, uiSchema);\n  }\n\n  let errorSchema = toErrorSchema<T>(errors);\n\n  if (invalidSchemaError) {\n    errorSchema = {\n      ...errorSchema,\n      $schema: {\n        __errors: [invalidSchemaError!.message],\n      },\n    };\n  }\n\n  if (typeof customValidate !== 'function') {\n    return { errors, errorSchema };\n  }\n\n  const newFormData = getDefaultFormState<T, S, F>(validator, schema, formData, schema, true) as T;\n\n  const errorHandler = customValidate(newFormData, createErrorHandler<T>(newFormData), uiSchema, errorSchema);\n  const userErrorSchema = unwrapErrorHandler<T>(errorHandler);\n  return validationDataMerge<T>({ errors, errorSchema }, userErrorSchema);\n}\n", "import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '@rjsf/utils';\n\nimport ATAPrecompiledValidator from './precompiledValidator';\nimport { Localizer, SuppressDuplicateFilteringType, ValidatorFunctions } from './types';\n\n/** Creates and returns a `ValidatorType` interface that is implemented with a precompiled validator. If a `localizer`\n * is provided, it is used to translate the messages generated by the underlying ata validation.\n *\n * NOTE: The `validateFns` parameter is an object obtained by importing from a precompiled validation file created via\n * the `compileSchemaValidators()` function.\n *\n * @param validateFns - The map of the validation functions that are created by the `compileSchemaValidators()` function\n * @param rootSchema - The root schema that was used with the `compileSchemaValidators()` function\n * @param [localizer] - If provided, is used to localize a list of ata `ValidationError`s\n * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`\n * @returns - The precompiled validator implementation resulting from the set of parameters provided\n */\nexport default function createPrecompiledValidator<\n  T = any,\n  S extends StrictRJSFSchema = RJSFSchema,\n  F extends FormContextType = any,\n>(\n  validateFns: ValidatorFunctions,\n  rootSchema: S,\n  localizer?: Localizer,\n  suppressDuplicateFiltering?: SuppressDuplicateFilteringType,\n): ValidatorType<T, S, F> {\n  return new ATAPrecompiledValidator<T, S, F>(validateFns, rootSchema, localizer, suppressDuplicateFiltering);\n}\n", "import {\n  CustomValidator,\n  deepEquals,\n  ErrorTransformer,\n  FormContextType,\n  hashForSchema,\n  ID_KEY,\n  RJSFSchema,\n  ROOT_SCHEMA_PREFIX,\n  StrictRJSFSchema,\n  UiSchema,\n  ValidationData,\n  ValidatorType,\n  withIdRefPrefix,\n} from '@rjsf/utils';\nimport type { ValidationError, Validator } from 'ata-validator';\nimport cloneDeep from 'lodash/cloneDeep';\n\nimport createAtaInstance from './createAtaInstance';\nimport processRawValidationErrors, { type RawValidationErrorsType } from './processRawValidationErrors';\nimport type { CustomValidatorOptionsType, Localizer, SuppressDuplicateFilteringType } from './types';\n\n/** `ValidatorType` implementation backed by `ata-validator`.\n *\n * ata is schema-bound (one `Validator` per schema) rather than instance-with-\n * registry like AJV, so this class maintains its own per-schema-id cache and\n * registers cross-schema dependencies through ata's `addSchema` so `$ref`\n * still resolves between schemas RJSF passes in.\n */\nexport default class ATAValidator<\n  T = any,\n  S extends StrictRJSFSchema = RJSFSchema,\n  F extends FormContextType = any,\n> implements ValidatorType<T, S, F> {\n  /** Stable copy of the constructor options, used when (re)building per-schema\n   * `Validator` instances on demand.\n   *\n   * @private\n   */\n  readonly options: CustomValidatorOptionsType;\n\n  /** The Localizer function applied to ata errors before they are returned.\n   *\n   * @private\n   */\n  readonly localizer?: Localizer;\n\n  /** Controls which duplicate error filtering is suppressed; see\n   * `processRawValidationErrors#filterDuplicateErrors`.\n   *\n   * @private\n   */\n  readonly suppressDuplicateFiltering?: SuppressDuplicateFilteringType;\n\n  /** Per-schema-id cache of constructed ata `Validator` instances. AJV uses a\n   * single instance with a schema registry; ata is schema-bound, so we\n   * maintain the registry ourselves.\n   */\n  private readonly validators = new Map<string, { validator: Validator; schema: object }>();\n\n  /** Most recent `rootSchema` reference seen by `handleSchemaUpdate`, used as\n   * a fast-path to skip a deep-equality check when the same root is passed\n   * back-to-back.\n   */\n  private lastSeenRootSchema?: S;\n\n  /** True once a `rootSchema` has been registered in this lifecycle. */\n  private hasRegisteredRootSchema = false;\n\n  constructor(options: CustomValidatorOptionsType, localizer?: Localizer) {\n    this.options = options;\n    this.localizer = localizer;\n    this.suppressDuplicateFiltering = options.suppressDuplicateFiltering;\n  }\n\n  /** Resets the cached validators and root-schema bookkeeping. Mirrors\n   * `AJV8Validator#reset` so RJSF's test harness can flush state between runs.\n   */\n  reset() {\n    this.validators.clear();\n    this.lastSeenRootSchema = undefined;\n    this.hasRegisteredRootSchema = false;\n  }\n\n  /** The most recently registered rootSchema, kept so we can pass it to ata's\n   * `schemas` constructor option when building validators for sub-schemas.\n   * This is how `$ref` to root-level definitions resolves under ata's\n   * per-schema model (vs AJV's single-instance registry).\n   */\n  private cachedRootSchema?: object;\n\n  /** Returns a structural copy of `formData` so ata's default-applier\n   * (which writes `default` values into the input object during validation)\n   * doesn't leak a mutation back to the caller. RJSF probes the same data\n   * through `isValid` repeatedly while resolving oneOf/anyOf options, and\n   * a mutated probe changes subsequent answers, so the wrapper has to\n   * preserve referential purity that AJV provides by default.\n   */\n  private cloneForValidation<D>(data: D): D {\n    if (data === null || typeof data !== 'object') {\n      return data;\n    }\n    if (typeof globalThis.structuredClone === 'function') {\n      return globalThis.structuredClone(data);\n    }\n    return cloneDeep(data);\n  }\n\n  /** Returns the cached ata `Validator` for the given id, or builds and\n   * caches a new one. When a rootSchema has been registered via\n   * `handleSchemaUpdate`, it is supplied as a sibling schema so `$ref` to\n   * the root resolves regardless of which sub-schema is being validated.\n   */\n  private getOrBuild(id: string, schema: object): Validator {\n    const existing = this.validators.get(id);\n    if (existing && deepEquals(existing.schema, schema)) {\n      return existing.validator;\n    }\n    // Pass the rootSchema as a sibling so `$ref` to its definitions resolves.\n    // Skip when the schema itself is the root, otherwise ata sees a\n    // self-referential addition.\n    const siblingRoots = this.cachedRootSchema && this.cachedRootSchema !== schema ? [this.cachedRootSchema] : [];\n    const optionsWithSchemas = {\n      ...this.options,\n      ataOptionsOverrides: {\n        ...(this.options.ataOptionsOverrides || {}),\n        ...(siblingRoots.length ? { schemas: siblingRoots } : {}),\n      },\n    };\n    const validator = createAtaInstance(schema, optionsWithSchemas);\n    this.validators.set(id, { validator, schema });\n    return validator;\n  }\n\n  /** Runs raw validation against the given schema. Equivalent to\n   * `AJV8Validator#rawValidation`: returns ata's error array (already in\n   * AJV-compatible shape) plus any compilation error encountered.\n   */\n  rawValidation<Result = any>(schema: S, formData?: T): RawValidationErrorsType<Result> {\n    let compilationError: Error | undefined;\n    let errors: ValidationError[] | undefined;\n\n    try {\n      const id = (schema[ID_KEY] as string | undefined) ?? hashForSchema(schema);\n      const validator = this.getOrBuild(id, schema);\n      const result = validator.validate(this.cloneForValidation(formData));\n      errors = result.valid ? undefined : result.errors;\n\n      if (errors && typeof this.localizer === 'function') {\n        // ata freezes `error.params`, so the AJV-validator's pre-quote dance\n        // (used to coax `ajv-i18n` into producing quoted property names)\n        // can't be applied verbatim. The hook is invoked with the raw\n        // ata errors; localizers that mutate `message` in place still work.\n        this.localizer(errors);\n      }\n    } catch (err) {\n      compilationError = err as Error;\n    }\n\n    return {\n      errors: errors as unknown as Result[] | undefined,\n      validationError: compilationError,\n    };\n  }\n\n  /** Validates `formData` and returns RJSF's `ValidationData<T>`. See\n   * `processRawValidationErrors` for the shape of the post-processing\n   * pipeline (custom validation, transform hook, ui-title resolution).\n   */\n  validateFormData(\n    formData: T | undefined,\n    schema: S,\n    customValidate?: CustomValidator<T, S, F>,\n    transformErrors?: ErrorTransformer<T, S, F>,\n    uiSchema?: UiSchema<T, S, F>,\n  ): ValidationData<T> {\n    const rawErrors = this.rawValidation<ValidationError>(schema, formData);\n    return processRawValidationErrors(\n      this,\n      rawErrors,\n      formData,\n      schema,\n      customValidate,\n      transformErrors,\n      uiSchema,\n      this.suppressDuplicateFiltering,\n    );\n  }\n\n  /** Registers (or refreshes) the rootSchema in the per-schema registry so\n   * subsequent `$ref`-resolving validators can see it. Mirrors AJV's\n   * `addSchema(rootSchema, rootSchemaId)` flow.\n   */\n  handleSchemaUpdate(rootSchema: S): void {\n    if (this.lastSeenRootSchema === rootSchema && this.hasRegisteredRootSchema) {\n      return;\n    }\n    const rootSchemaId = (rootSchema[ID_KEY] as string | undefined) ?? ROOT_SCHEMA_PREFIX;\n    // Inject $id into a copy of the rootSchema so ata's schema registry can\n    // resolve `<rootSchemaId>#/...` refs produced by `withIdRefPrefix`.\n    // The original user-supplied schema is left untouched.\n    const rootWithId =\n      rootSchema[ID_KEY] === rootSchemaId\n        ? (rootSchema as object)\n        : { ...(rootSchema as object), [ID_KEY]: rootSchemaId };\n    this.cachedRootSchema = rootWithId;\n    const cached = this.validators.get(rootSchemaId);\n    if (!cached || !deepEquals(cached.schema, rootWithId)) {\n      this.getOrBuild(rootSchemaId, rootWithId);\n    }\n    this.lastSeenRootSchema = rootSchema;\n    this.hasRegisteredRootSchema = true;\n  }\n\n  /** Boolean validation entrypoint. Returns false on validation failure or\n   * compilation error. Mirrors `AJV8Validator#isValid` semantics.\n   */\n  isValid(schema: S, formData: T | undefined, rootSchema: S) {\n    try {\n      this.handleSchemaUpdate(rootSchema);\n      const schemaWithIdRefPrefix = withIdRefPrefix<S>(schema) as S;\n      const id = (schemaWithIdRefPrefix[ID_KEY] as string | undefined) ?? hashForSchema(schemaWithIdRefPrefix);\n      const validator = this.getOrBuild(id, schemaWithIdRefPrefix);\n      return validator.validate(this.cloneForValidation(formData)).valid;\n    } catch (e) {\n      // eslint-disable-next-line no-console\n      console.warn('Error encountered compiling schema:', e);\n      return false;\n    }\n  }\n}\n", "import { Validator, type ValidatorOptions } from 'ata-validator';\nimport isObject from 'lodash/isObject';\n\nimport type { AtaFormatChecker, CustomValidatorOptionsType } from './types';\n\n/** Default options applied to every ata `Validator` constructed for RJSF.\n * `verbose: true` keeps `parentSchema` available on errors, which the RJSF\n * error transformer uses to recover field titles. The remainder match\n * `@rjsf/validator-ajv8`'s defaults (`allErrors`-equivalent behavior is\n * ata's default).\n */\nexport const ATA_CONFIG: ValidatorOptions = {\n  verbose: true,\n} as const;\n\n/** Color names + hex + `rgb()` regex source. Mirrors the pattern shipped by\n * `@rjsf/validator-ajv8` so RJSF schemas using `format: 'color'` keep\n * working when swapped to validator-ata.\n */\nexport const COLOR_FORMAT_REGEX =\n  /^(#?([0-9A-Fa-f]{3}){1,2}\\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\\(\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*\\))|(rgb\\(\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*\\)))$/;\n\n/** RFC 2397 data URL with required mime type and base64 marker, matching\n * the shape used by `@rjsf/validator-ajv8`.\n */\nexport const DATA_URL_FORMAT_REGEX = /^data:([a-z]+\\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;\n\n/** Coerces the user-supplied custom format value into the `(value: string)\n * => boolean` shape expected by ata. Strings are treated as RegExp source\n * (anchored at both ends if not already), RegExps are converted to a `.test`\n * call, functions pass through.\n */\nfunction asFormatChecker(spec: string | RegExp | AtaFormatChecker): AtaFormatChecker {\n  if (typeof spec === 'function') {\n    return spec;\n  }\n  const re = spec instanceof RegExp ? spec : new RegExp(spec);\n  return (value: string) => re.test(value);\n}\n\n/** Builds a fresh `ata-validator` `Validator` for a given schema with all\n * RJSF-aware defaults and user customizations applied.\n *\n * The factory exists so that the validator class can construct one\n * `Validator` per schema-id (ata is schema-bound, unlike AJV's single\n * instance with a schema registry) while keeping the option translation\n * in one place.\n */\nexport default function createAtaInstance(schema: object, options: CustomValidatorOptionsType = {}): Validator {\n  const { customFormats, ataOptionsOverrides, additionalMetaSchemas, extenderFn } = options;\n\n  const formats: Record<string, AtaFormatChecker> = {\n    color: asFormatChecker(COLOR_FORMAT_REGEX),\n    'data-url': asFormatChecker(DATA_URL_FORMAT_REGEX),\n  };\n  if (isObject(customFormats)) {\n    for (const [name, spec] of Object.entries(customFormats!)) {\n      formats[name] = asFormatChecker(spec);\n    }\n  }\n\n  const validatorOptions: ValidatorOptions = {\n    ...ATA_CONFIG,\n    ...ataOptionsOverrides,\n    formats,\n  };\n\n  let validator = new Validator(schema, validatorOptions);\n\n  if (Array.isArray(additionalMetaSchemas)) {\n    for (const meta of additionalMetaSchemas) {\n      validator.addSchema(meta);\n    }\n  }\n\n  if (typeof extenderFn === 'function') {\n    validator = extenderFn(validator);\n  }\n\n  return validator;\n}\n", "import { FormContextType, RJSFSchema, StrictRJSFSchema } from '@rjsf/utils';\n\nimport type { CustomValidatorOptionsType, Localizer } from './types';\nimport ATAValidator from './validator';\n\n/** Build an `ATAValidator` instance, optionally customized with format\n * checkers, validator overrides, an extender hook, or a localizer. Mirrors\n * `@rjsf/validator-ajv8`'s `customizeValidator`.\n */\nexport default function customizeValidator<\n  T = any,\n  S extends StrictRJSFSchema = RJSFSchema,\n  F extends FormContextType = any,\n>(options: CustomValidatorOptionsType = {}, localizer?: Localizer) {\n  return new ATAValidator<T, S, F>(options, localizer);\n}\n", "import createPrecompiledValidator from './createPrecompiledValidator';\nimport customizeValidator from './customizeValidator';\n\nexport { customizeValidator, createPrecompiledValidator };\nexport { default as ATAValidator } from './validator';\nexport * from './types';\n\nexport default customizeValidator();\n"],
+  "mappings": "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",
+  "names": ["get", "get", "deepEquals", "hashForSchema", "ID_KEY", "deepEquals", "ID_KEY", "hashForSchema"]
+}