@rjsf/validator-ata 6.6.1

package/dist/validator-ata.umd.js

@@ -0,0 +1,422 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@rjsf/utils'), require('lodash/get'), require('lodash/cloneDeep'), require('ata-validator'), require('lodash/isObject')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@rjsf/utils', 'lodash/get', 'lodash/cloneDeep', 'ata-validator', 'lodash/isObject'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/validator-ata"] = {}, global.utils, global.get, global.cloneDeep, global.ataValidator, global.isObject));
+})(this, (function (exports, utils, get, cloneDeep, ataValidator, isObject) { 'use strict';
+
+  // src/precompiledValidator.ts
+  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(`/${utils.ANY_OF_KEY}/`) : void 0;
+      const oneOfIndex = suppressDuplicateFiltering !== "oneOf" ? schemaPath?.indexOf(`/${utils.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 = utils.getUiOptions(get(uiSchema, `${path.replace(/^\./, "")}`)).title;
+          if (uiSchemaTitle === void 0) {
+            const uiSchemaPath = schemaPath.replace(/\/properties\//g, "/").split("/").slice(1, -1).concat([currentProperty]);
+            uiSchemaTitle = utils.getUiOptions(get(uiSchema, uiSchemaPath)).title;
+          }
+          if (uiSchemaTitle) {
+            message = message.replace(`'${currentProperty}'`, `'${uiSchemaTitle}'`);
+            uiTitle = uiSchemaTitle;
+          } else {
+            const parentSchemaTitle = get(parentSchema, [utils.PROPERTIES_KEY, currentProperty, "title"]);
+            if (parentSchemaTitle) {
+              message = message.replace(`'${currentProperty}'`, `'${parentSchemaTitle}'`);
+              uiTitle = parentSchemaTitle;
+            }
+          }
+        });
+        stack = message;
+      } else {
+        const uiSchemaTitle = utils.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 = utils.toErrorSchema(errors);
+    if (invalidSchemaError) {
+      errorSchema = {
+        ...errorSchema,
+        $schema: {
+          __errors: [invalidSchemaError.message]
+        }
+      };
+    }
+    if (typeof customValidate !== "function") {
+      return { errors, errorSchema };
+    }
+    const newFormData = utils.getDefaultFormState(validator, schema, formData, schema, true);
+    const errorHandler = customValidate(newFormData, utils.createErrorHandler(newFormData), uiSchema, errorSchema);
+    const userErrorSchema = utils.unwrapErrorHandler(errorHandler);
+    return utils.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 = get(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}"`);
+      }
+      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 (!utils.deepEquals(schema, this.rootSchema)) {
+        const resolvedRootSchema = utils.retrieveSchema(this, this.rootSchema, this.rootSchema, formData);
+        if (!utils.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 (get(schema, utils.ID_KEY) === utils.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);
+  }
+  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 ataValidator.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 && utils.deepEquals(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[utils.ID_KEY] ?? utils.hashForSchema(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[utils.ID_KEY] ?? utils.ROOT_SCHEMA_PREFIX;
+      const rootWithId = rootSchema[utils.ID_KEY] === rootSchemaId ? rootSchema : { ...rootSchema, [utils.ID_KEY]: rootSchemaId };
+      this.cachedRootSchema = rootWithId;
+      const cached = this.validators.get(rootSchemaId);
+      if (!cached || !utils.deepEquals(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 = utils.withIdRefPrefix(schema);
+        const id = schemaWithIdRefPrefix[utils.ID_KEY] ?? utils.hashForSchema(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();
+
+  exports.ATAValidator = ATAValidator;
+  exports.createPrecompiledValidator = createPrecompiledValidator;
+  exports.customizeValidator = customizeValidator;
+  exports.default = index_default;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));

package/lib/compileSchemaValidators.d.ts

@@ -0,0 +1,16 @@
+import { RJSFSchema, StrictRJSFSchema } from '@rjsf/utils';
+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): void;

package/lib/compileSchemaValidators.js

@@ -0,0 +1,21 @@
+import fs from 'fs';
+import { compileSchemaValidatorsCode } from './compileSchemaValidatorsCode';
+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(schema, output, options = {}) {
+    console.log('parsing the schema');
+    const moduleCode = compileSchemaValidatorsCode(schema, options);
+    console.log(`writing ${output}`);
+    fs.writeFileSync(output, moduleCode);
+}
+//# sourceMappingURL=compileSchemaValidators.js.map

package/lib/compileSchemaValidators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileSchemaValidators.js","sourceRoot":"","sources":["../src/compileSchemaValidators.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,IAAI,CAAC;AAEpB,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAG5E,OAAO,EAAE,2BAA2B,EAAE,CAAC;AAEvC;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAC7C,MAAS,EACT,MAAc,EACd,UAAsC,EAAE;IAExC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;IAElC,MAAM,UAAU,GAAG,2BAA2B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChE,OAAO,CAAC,GAAG,CAAC,WAAW,MAAM,EAAE,CAAC,CAAC;IACjC,EAAE,CAAC,aAAa,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AACvC,CAAC"}

package/lib/compileSchemaValidatorsCode.d.ts

@@ -0,0 +1,13 @@
+import { RJSFSchema, StrictRJSFSchema } from '@rjsf/utils';
+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 declare function compileSchemaValidatorsCode<S extends StrictRJSFSchema = RJSFSchema>(schema: S, options?: CustomValidatorOptionsType): string;

package/lib/compileSchemaValidatorsCode.js

@@ -0,0 +1,80 @@
+import { schemaParser } from '@rjsf/utils';
+import { Validator } from 'ata-validator';
+import { COLOR_FORMAT_REGEX, DATA_URL_FORMAT_REGEX } from './createAtaInstance';
+/** 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(schema, options = {}) {
+    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 = {
+        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 = {};
+    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)`);
+    }
+    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');
+}
+//# sourceMappingURL=compileSchemaValidatorsCode.js.map

package/lib/compileSchemaValidatorsCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileSchemaValidatorsCode.js","sourceRoot":"","sources":["../src/compileSchemaValidatorsCode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,YAAY,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAGhF;;;;;;;;;GASG;AACH,MAAM,UAAU,2BAA2B,CACzC,MAAS,EACT,UAAsC,EAAE;IAExC,MAAM,UAAU,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IACxC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACrC,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAE1C,MAAM,EAAE,aAAa,EAAE,mBAAmB,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC;IAE5D,mFAAmF;IACnF,kFAAkF;IAClF,iFAAiF;IACjF,iFAAiF;IACjF,MAAM,YAAY,GAA2B;QAC3C,KAAK,EAAE,kBAAkB;QACzB,UAAU,EAAE,qBAAqB;KAClC,CAAC;IACF,IAAI,aAAa,EAAE,CAAC;QAClB,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC;YAC1D,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;gBAChC,4EAA4E;gBAC5E,6EAA6E;gBAC7E,4EAA4E;gBAC5E,wDAAwD;gBACxD,MAAM,IAAI,KAAK,CACb,uCAAuC,IAAI,kHAAkH,CAC9J,CAAC;YACJ,CAAC;YACD,YAAY,CAAC,IAAI,CAAC,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAC7E,CAAC;IACH,CAAC;IACD,MAAM,OAAO,GAA+C,EAAE,CAAC;IAC/D,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;QACtD,iFAAiF;QACjF,+EAA+E;QAC/E,2EAA2E;QAC3E,iFAAiF;QACjF,oDAAoD;QACpD,uCAAuC;QACvC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC,QAAQ,EAAE,cAAc,CAA+B,CAAC;IAC7G,CAAC;IAED,MAAM,MAAM,GAAG,SAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE;QACjD,MAAM,EAAE,KAAK;QACb,OAAO,EAAE,mBAAmB,CAAC,OAAO,KAAK,KAAK;QAC9C,OAAO;KACR,CAAC,CAAC;IAEH,MAAM,OAAO,GAAG,IAAI;SACjB,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,qBAAqB,KAAK,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC;SACpG,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,OAAO;QACL,mCAAmC;QACnC,mCAAmC;QACnC,MAAM;QACN,0BAA0B;QAC1B,OAAO;QACP,0BAA0B;QAC1B,6BAA6B;QAC7B,qCAAqC;QACrC,kHAAkH;QAClH,OAAO;QACP,8BAA8B;QAC9B,4DAA4D;QAC5D,0BAA0B;QAC1B,KAAK;QACL,oBAAoB;QACpB,GAAG;QACH,oBAAoB;QACpB,OAAO;QACP,IAAI;QACJ,EAAE;KACH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/lib/createAtaInstance.d.ts

@@ -0,0 +1,27 @@
+import { Validator, type ValidatorOptions } from 'ata-validator';
+import type { 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 declare const ATA_CONFIG: ValidatorOptions;
+/** 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 declare const COLOR_FORMAT_REGEX: RegExp;
+/** RFC 2397 data URL with required mime type and base64 marker, matching
+ * the shape used by `@rjsf/validator-ajv8`.
+ */
+export declare const DATA_URL_FORMAT_REGEX: RegExp;
+/** 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;

package/lib/createAtaInstance.js

@@ -0,0 +1,68 @@
+import { Validator } from 'ata-validator';
+import isObject from 'lodash/isObject';
+/** 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 = {
+    verbose: true,
+};
+/** 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) {
+    if (typeof spec === 'function') {
+        return spec;
+    }
+    const re = spec instanceof RegExp ? spec : new RegExp(spec);
+    return (value) => 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, 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;
+}
+//# sourceMappingURL=createAtaInstance.js.map

package/lib/createAtaInstance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAtaInstance.js","sourceRoot":"","sources":["../src/createAtaInstance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAyB,MAAM,eAAe,CAAC;AACjE,OAAO,QAAQ,MAAM,iBAAiB,CAAC;AAIvC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAqB;IAC1C,OAAO,EAAE,IAAI;CACL,CAAC;AAEX;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAC7B,4YAA4Y,CAAC;AAE/Y;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,2DAA2D,CAAC;AAEjG;;;;GAIG;AACH,SAAS,eAAe,CAAC,IAAwC;IAC/D,IAAI,OAAO,IAAI,KAAK,UAAU,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,EAAE,GAAG,IAAI,YAAY,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC;IAC5D,OAAO,CAAC,KAAa,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,MAAc,EAAE,UAAsC,EAAE;IAChG,MAAM,EAAE,aAAa,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IAE1F,MAAM,OAAO,GAAqC;QAChD,KAAK,EAAE,eAAe,CAAC,kBAAkB,CAAC;QAC1C,UAAU,EAAE,eAAe,CAAC,qBAAqB,CAAC;KACnD,CAAC;IACF,IAAI,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;QAC5B,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,aAAc,CAAC,EAAE,CAAC;YAC1D,OAAO,CAAC,IAAI,CAAC,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAED,MAAM,gBAAgB,GAAqB;QACzC,GAAG,UAAU;QACb,GAAG,mBAAmB;QACtB,OAAO;KACR,CAAC;IAEF,IAAI,SAAS,GAAG,IAAI,SAAS,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAExD,IAAI,KAAK,CAAC,OAAO,CAAC,qBAAqB,CAAC,EAAE,CAAC;QACzC,KAAK,MAAM,IAAI,IAAI,qBAAqB,EAAE,CAAC;YACzC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAED,IAAI,OAAO,UAAU,KAAK,UAAU,EAAE,CAAC;QACrC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC"}