@rjsf/validator-ata 6.6.1

package/src/compileSchemaValidators.ts

@@ -0,0 +1,30 @@
+import { RJSFSchema, StrictRJSFSchema } from '@rjsf/utils';
+import fs from 'fs';
+
+import { compileSchemaValidatorsCode } from './compileSchemaValidatorsCode';
+import { CustomValidatorOptionsType } from './types';
+
+export { compileSchemaValidatorsCode };
+
+/** The function used to compile a schema into an output file in the form that allows it to be used as a precompiled
+ * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,
+ * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more
+ * information about ata standalone compilation see the ata-validator documentation.
+ *
+ * @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 ata 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 ata-based validator.
+ */
+export default function compileSchemaValidators<S extends StrictRJSFSchema = RJSFSchema>(
+  schema: S,
+  output: string,
+  options: CustomValidatorOptionsType = {},
+) {
+  console.log('parsing the schema');
+
+  const moduleCode = compileSchemaValidatorsCode(schema, options);
+  console.log(`writing ${output}`);
+  fs.writeFileSync(output, moduleCode);
+}

package/src/compileSchemaValidatorsCode.ts

@@ -0,0 +1,92 @@
+import { RJSFSchema, StrictRJSFSchema, schemaParser } from '@rjsf/utils';
+import { Validator } from 'ata-validator';
+
+import { COLOR_FORMAT_REGEX, DATA_URL_FORMAT_REGEX } from './createAtaInstance';
+import { CustomValidatorOptionsType } from './types';
+
+/** Compiles a schema into a precompiled validator module. ata's
+ * `bundleStandalone` emits `module.exports = [fn, ...]`, one validator per
+ * schema in order, where each `fn(data)` returns `{ valid, errors }`. This wraps
+ * that array into the `{ [id]: (data) => boolean }`-with-`errors` map that
+ * `createPrecompiledValidator` consumes, keyed the same way `schemaParser` keys
+ * the schemas so the precompiled validator can look each one up.
+ *
+ * @param schema - The schema to compile
+ * @param [options={}] - The `CustomValidatorOptionsType` used to build the validator
+ */
+export function compileSchemaValidatorsCode<S extends StrictRJSFSchema = RJSFSchema>(
+  schema: S,
+  options: CustomValidatorOptionsType = {},
+) {
+  const schemaMaps = schemaParser(schema);
+  const keys = Object.keys(schemaMaps);
+  const schemas = Object.values(schemaMaps);
+
+  const { customFormats, ataOptionsOverrides = {} } = options;
+
+  // Format checkers are serialized into the standalone module via Function#toString,
+  // so they must carry no closure references or build-time instrumentation (a plain
+  // arrow over the source file picks up coverage counters). Building each from its
+  // regex via `new Function` produces a function whose source is exactly its body.
+  const regexFormats: Record<string, RegExp> = {
+    color: COLOR_FORMAT_REGEX,
+    'data-url': DATA_URL_FORMAT_REGEX,
+  };
+  if (customFormats) {
+    for (const [name, check] of Object.entries(customFormats)) {
+      if (typeof check === 'function') {
+        // A function checker would be serialized via toString, which is unsafe in a
+        // precompiled bundle: transpilers, minifiers, and coverage tools rewrite the
+        // body and leave references that do not exist in the generated module. Only
+        // RegExp/string patterns can be embedded reliably here.
+        throw new Error(
+          `@rjsf/validator-ata: custom format "${name}" is a function, which is not supported by the precompiled validator; provide a RegExp or string pattern instead`,
+        );
+      }
+      regexFormats[name] = typeof check === 'string' ? new RegExp(check) : check;
+    }
+  }
+  const formats: Record<string, (value: string) => boolean> = {};
+  for (const [name, re] of Object.entries(regexFormats)) {
+    // `new Function` rather than a fat-arrow on purpose: ata serializes these format
+    // checkers into the standalone bundle via Function#toString. A fat-arrow would
+    // close over `re` and emit `re.test(value)`, leaving `re` undefined in the
+    // generated module. Building it from a string inlines the regex literal into the
+    // body, so the bundled output stays self-contained.
+    // eslint-disable-next-line no-new-func
+    formats[name] = new Function('value', `return ${re.toString()}.test(value)`) as (value: string) => boolean;
+  }
+
+  const bundle = Validator.bundleStandalone(schemas, {
+    format: 'cjs',
+    verbose: ataOptionsOverrides.verbose !== false,
+    formats,
+  });
+
+  const entries = keys
+    .map((key, index) => `  ${JSON.stringify(key)}: wrap(validators[${index}], ${JSON.stringify(key)}),`)
+    .join('\n');
+
+  return [
+    'const validators = (function () {',
+    '  const module = { exports: {} };',
+    bundle,
+    '  return module.exports;',
+    '})();',
+    'function wrap(fn, key) {',
+    '  function validate(data) {',
+    "    if (typeof fn !== 'function') {",
+    "      throw new Error('@rjsf/validator-ata: schema \"' + key + '\" was not compiled to a standalone validator');",
+    '    }',
+    '    const result = fn(data);',
+    '    validate.errors = result.valid ? null : result.errors;',
+    '    return result.valid;',
+    '  }',
+    '  return validate;',
+    '}',
+    'module.exports = {',
+    entries,
+    '};',
+    '',
+  ].join('\n');
+}

package/src/createAtaInstance.ts

@@ -0,0 +1,81 @@
+import { Validator, type ValidatorOptions } from 'ata-validator';
+import isObject from 'lodash/isObject';
+
+import type { AtaFormatChecker, CustomValidatorOptionsType } from './types';
+
+/** Default options applied to every ata `Validator` constructed for RJSF.
+ * `verbose: true` keeps `parentSchema` available on errors, which the RJSF
+ * error transformer uses to recover field titles. The remainder match
+ * `@rjsf/validator-ajv8`'s defaults (`allErrors`-equivalent behavior is
+ * ata's default).
+ */
+export const ATA_CONFIG: ValidatorOptions = {
+  verbose: true,
+} as const;
+
+/** Color names + hex + `rgb()` regex source. Mirrors the pattern shipped by
+ * `@rjsf/validator-ajv8` so RJSF schemas using `format: 'color'` keep
+ * working when swapped to validator-ata.
+ */
+export 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*\)))$/;
+
+/** RFC 2397 data URL with required mime type and base64 marker, matching
+ * the shape used by `@rjsf/validator-ajv8`.
+ */
+export const DATA_URL_FORMAT_REGEX = /^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;
+
+/** Coerces the user-supplied custom format value into the `(value: string)
+ * => boolean` shape expected by ata. Strings are treated as RegExp source
+ * (anchored at both ends if not already), RegExps are converted to a `.test`
+ * call, functions pass through.
+ */
+function asFormatChecker(spec: string | RegExp | AtaFormatChecker): AtaFormatChecker {
+  if (typeof spec === 'function') {
+    return spec;
+  }
+  const re = spec instanceof RegExp ? spec : new RegExp(spec);
+  return (value: string) => re.test(value);
+}
+
+/** Builds a fresh `ata-validator` `Validator` for a given schema with all
+ * RJSF-aware defaults and user customizations applied.
+ *
+ * The factory exists so that the validator class can construct one
+ * `Validator` per schema-id (ata is schema-bound, unlike AJV's single
+ * instance with a schema registry) while keeping the option translation
+ * in one place.
+ */
+export default function createAtaInstance(schema: object, options: CustomValidatorOptionsType = {}): Validator {
+  const { customFormats, ataOptionsOverrides, additionalMetaSchemas, extenderFn } = options;
+
+  const formats: Record<string, AtaFormatChecker> = {
+    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: 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;
+}

package/src/createPrecompiledValidator.ts

@@ -0,0 +1,29 @@
+import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '@rjsf/utils';
+
+import ATAPrecompiledValidator from './precompiledValidator';
+import { Localizer, SuppressDuplicateFilteringType, ValidatorFunctions } from './types';
+
+/** 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 ata 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 ata `ValidationError`s
+ * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`
+ * @returns - The precompiled validator implementation resulting from the set of parameters provided
+ */
+export default function createPrecompiledValidator<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(
+  validateFns: ValidatorFunctions,
+  rootSchema: S,
+  localizer?: Localizer,
+  suppressDuplicateFiltering?: SuppressDuplicateFilteringType,
+): ValidatorType<T, S, F> {
+  return new ATAPrecompiledValidator<T, S, F>(validateFns, rootSchema, localizer, suppressDuplicateFiltering);
+}

package/src/customizeValidator.ts

@@ -0,0 +1,16 @@
+import { FormContextType, RJSFSchema, StrictRJSFSchema } from '@rjsf/utils';
+
+import type { CustomValidatorOptionsType, Localizer } from './types';
+import ATAValidator from './validator';
+
+/** Build an `ATAValidator` instance, optionally customized with format
+ * checkers, validator overrides, an extender hook, or a localizer. Mirrors
+ * `@rjsf/validator-ajv8`'s `customizeValidator`.
+ */
+export default function customizeValidator<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(options: CustomValidatorOptionsType = {}, localizer?: Localizer) {
+  return new ATAValidator<T, S, F>(options, localizer);
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+import createPrecompiledValidator from './createPrecompiledValidator';
+import customizeValidator from './customizeValidator';
+
+export { customizeValidator, createPrecompiledValidator };
+export { default as ATAValidator } from './validator';
+export * from './types';
+
+export default customizeValidator();

package/src/precompiledValidator.ts

@@ -0,0 +1,188 @@
+import {
+  CustomValidator,
+  deepEquals,
+  ErrorTransformer,
+  FormContextType,
+  hashForSchema,
+  ID_KEY,
+  JUNK_OPTION_ID,
+  retrieveSchema,
+  RJSFSchema,
+  StrictRJSFSchema,
+  UiSchema,
+  ValidationData,
+  ValidatorType,
+} from '@rjsf/utils';
+import type { ValidationError } from 'ata-validator';
+import get from 'lodash/get';
+
+import processRawValidationErrors, { RawValidationErrorsType } from './processRawValidationErrors';
+import { CompiledValidateFunction, Localizer, SuppressDuplicateFilteringType, ValidatorFunctions } from './types';
+
+/** `ValidatorType` implementation that uses an ata precompiled validator as created by the
+ * `compileSchemaValidators()` function provided by the `@rjsf/validator-ata` library.
+ */
+export default class ATAPrecompiledValidator<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+> implements ValidatorType<T, S, F> {
+  /** The root schema object used to construct this validator
+   *
+   * @private
+   */
+  readonly rootSchema: S;
+
+  /** The `ValidatorFunctions` map used to construct this validator
+   *
+   * @private
+   */
+  readonly validateFns: ValidatorFunctions;
+
+  /** The main validator function associated with the base schema in the `precompiledValidator`
+   *
+   * @private
+   */
+  readonly mainValidator: CompiledValidateFunction;
+
+  /** The Localizer function to use for localizing ata errors
+   *
+   * @private
+   */
+  readonly localizer?: Localizer;
+
+  /** Controls which duplicate error filtering is suppressed; see `filterDuplicateErrors`
+   *
+   * @private
+   */
+  readonly suppressDuplicateFiltering?: SuppressDuplicateFilteringType;
+
+  /** 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: ValidatorFunctions,
+    rootSchema: S,
+    localizer?: Localizer,
+    suppressDuplicateFiltering?: SuppressDuplicateFilteringType,
+  ) {
+    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: S) {
+    const key = get(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: S, formData?: T) {
+    if (!deepEquals(schema, this.rootSchema)) {
+      // Resolve the root schema with the passed in form data since that may affect the resolution
+      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<Result = any>(schema: S, formData?: T): RawValidationErrorsType<Result> {
+    this.ensureSameRootSchema(schema, formData);
+    this.mainValidator(formData);
+
+    if (typeof this.localizer === 'function') {
+      this.localizer(this.mainValidator.errors);
+    }
+    const errors = this.mainValidator.errors || undefined;
+
+    // Clear errors to prevent persistent errors, see #1104
+    this.mainValidator.errors = null;
+
+    return { errors: errors as unknown as Result[] };
+  }
+
+  /** 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: T | undefined,
+    schema: S,
+    customValidate?: CustomValidator<T, S, F>,
+    transformErrors?: ErrorTransformer<T, S, F>,
+    uiSchema?: UiSchema<T, S, F>,
+  ): ValidationData<T> {
+    const rawErrors = this.rawValidation<ValidationError>(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: S, formData: T | undefined, rootSchema: S) {
+    this.ensureSameRootSchema(rootSchema, formData);
+    if (get(schema, ID_KEY) === JUNK_OPTION_ID) {
+      return false;
+    }
+    const validator = this.getValidator(schema);
+    return validator(formData);
+  }
+}

package/src/processRawValidationErrors.ts

@@ -0,0 +1,197 @@
+import {
+  ANY_OF_KEY,
+  createErrorHandler,
+  CustomValidator,
+  ErrorTransformer,
+  FormContextType,
+  getDefaultFormState,
+  getUiOptions,
+  ONE_OF_KEY,
+  PROPERTIES_KEY,
+  RJSFSchema,
+  RJSFValidationError,
+  StrictRJSFSchema,
+  toErrorSchema,
+  UiSchema,
+  unwrapErrorHandler,
+  validationDataMerge,
+  ValidatorType,
+} from '@rjsf/utils';
+import type { ValidationError } from 'ata-validator';
+import get from 'lodash/get';
+
+import type { SuppressDuplicateFilteringType } from './types';
+
+export type RawValidationErrorsType<Result = any> = {
+  errors?: Result[];
+  validationError?: Error;
+};
+
+/** Filters duplicate errors from `anyOf`/`oneOf` schema paths according to
+ * the `suppressDuplicateFiltering` flag. Mirrors the `@rjsf/validator-ajv8`
+ * implementation: under any non-`'all'` setting, duplicate messages that
+ * share a common prefix before the `/anyOf/` or `/oneOf/` segment are
+ * collapsed into a single entry.
+ */
+export function filterDuplicateErrors(
+  errorList: RJSFValidationError[],
+  suppressDuplicateFiltering: SuppressDuplicateFilteringType = 'none',
+): RJSFValidationError[] {
+  if (suppressDuplicateFiltering === 'all') {
+    return errorList;
+  }
+  return errorList.reduce((acc: RJSFValidationError[], err: RJSFValidationError) => {
+    const { message, schemaPath } = err;
+    const anyOfIndex = suppressDuplicateFiltering !== 'anyOf' ? schemaPath?.indexOf(`/${ANY_OF_KEY}/`) : undefined;
+    const oneOfIndex = suppressDuplicateFiltering !== 'oneOf' ? schemaPath?.indexOf(`/${ONE_OF_KEY}/`) : undefined;
+    let schemaPrefix: string | undefined;
+    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: RJSFValidationError) => e.message === message && e.schemaPath?.startsWith(schemaPrefix))
+      : undefined;
+    if (!dup) {
+      acc.push(err);
+    }
+    return acc;
+  }, [] as RJSFValidationError[]);
+}
+
+/** Transforms ata-validator errors into the RJSF-internal `RJSFValidationError`
+ * shape. ata's error objects already use the same field names AJV does
+ * (`instancePath`, `keyword`, `params`, `schemaPath`, `parentSchema`,
+ * `message`), so the conversion is structural only.
+ */
+export function transformRJSFValidationErrors<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(
+  errors: ValidationError[] = [],
+  uiSchema?: UiSchema<T, S, F>,
+  suppressDuplicateFiltering?: SuppressDuplicateFilteringType,
+): RJSFValidationError[] {
+  const errorList = errors.map((e: ValidationError) => {
+    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 as Record<string, any>;
+    const rawPropertyNames: string[] = [
+      ...((p?.deps as string | undefined)?.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 === undefined) {
+          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<T, S, F>(get(uiSchema, `${property.replace(/^\./, '')}`)).title;
+
+      if (uiSchemaTitle) {
+        stack = `'${uiSchemaTitle}' ${message}`.trim();
+        uiTitle = uiSchemaTitle;
+      } else {
+        const parentSchemaTitle = (parentSchema as { title?: string } | undefined)?.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);
+}
+
+/** Processes raw ata validation errors into the `ValidationData<T>` shape
+ * RJSF consumes. Mirrors the AJV-validator's `processRawValidationErrors`,
+ * including the optional `customValidate` and `transformErrors` hooks.
+ */
+export default function processRawValidationErrors<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(
+  validator: ValidatorType<T, S, F>,
+  rawErrors: RawValidationErrorsType<ValidationError>,
+  formData: T | undefined,
+  schema: S,
+  customValidate?: CustomValidator<T, S, F>,
+  transformErrors?: ErrorTransformer<T, S, F>,
+  uiSchema?: UiSchema<T, S, F>,
+  suppressDuplicateFiltering?: SuppressDuplicateFilteringType,
+) {
+  const { validationError: invalidSchemaError } = rawErrors;
+  let errors = transformRJSFValidationErrors<T, S, F>(rawErrors.errors, uiSchema, suppressDuplicateFiltering);
+
+  if (invalidSchemaError) {
+    errors = [...errors, { stack: invalidSchemaError!.message }];
+  }
+  if (typeof transformErrors === 'function') {
+    errors = transformErrors(errors, uiSchema);
+  }
+
+  let errorSchema = toErrorSchema<T>(errors);
+
+  if (invalidSchemaError) {
+    errorSchema = {
+      ...errorSchema,
+      $schema: {
+        __errors: [invalidSchemaError!.message],
+      },
+    };
+  }
+
+  if (typeof customValidate !== 'function') {
+    return { errors, errorSchema };
+  }
+
+  const newFormData = getDefaultFormState<T, S, F>(validator, schema, formData, schema, true) as T;
+
+  const errorHandler = customValidate(newFormData, createErrorHandler<T>(newFormData), uiSchema, errorSchema);
+  const userErrorSchema = unwrapErrorHandler<T>(errorHandler);
+  return validationDataMerge<T>({ errors, errorSchema }, userErrorSchema);
+}

package/src/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["./"],
+  "compilerOptions": {
+    "rootDir": "./",
+    "outDir": "../lib",
+    "jsx": "react-jsx",
+    "types": ["node"]
+  },
+  "references": [
+    {
+      "path": "../../utils"
+    }
+  ]
+}