@rjsf/validator-ata 6.6.1 → 6.6.2

package/src/processRawValidationErrors.ts

@@ -1,31 +1,33 @@
-import {
-  ANY_OF_KEY,
-  createErrorHandler,
+import type {
   CustomValidator,
   ErrorTransformer,
   FormContextType,
+  RJSFSchema,
+  RJSFValidationError,
+  StrictRJSFSchema,
+  UiSchema,
+  ValidatorType,
+} from '@rjsf/utils';
+import {
+  ANY_OF_KEY,
+  createErrorHandler,
   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> = {
+export interface 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`
@@ -40,7 +42,7 @@ export function filterDuplicateErrors(
   if (suppressDuplicateFiltering === 'all') {
     return errorList;
   }
-  return errorList.reduce((acc: RJSFValidationError[], err: RJSFValidationError) => {
+  return errorList.reduce<RJSFValidationError[]>((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;
@@ -57,7 +59,7 @@ export function filterDuplicateErrors(
       acc.push(err);
     }
     return acc;
-  }, [] as RJSFValidationError[]);
+  }, []);
 }
 
 /** Transforms ata-validator errors into the RJSF-internal `RJSFValidationError`
@@ -91,7 +93,7 @@ export function transformRJSFValidationErrors<
     if (rawPropertyNames.length > 0) {
       rawPropertyNames.forEach((currentProperty) => {
         const path = property ? `${property}.${currentProperty}` : currentProperty;
-        let uiSchemaTitle = getUiOptions(get(uiSchema, `${path.replace(/^\./, '')}`)).title;
+        let uiSchemaTitle = getUiOptions(get(uiSchema, path.replace(/^\./, ''))).title;
         if (uiSchemaTitle === undefined) {
           const uiSchemaPath = schemaPath
             .replace(/\/properties\//g, '/')
@@ -114,7 +116,7 @@ export function transformRJSFValidationErrors<
 
       stack = message;
     } else {
-      const uiSchemaTitle = getUiOptions<T, S, F>(get(uiSchema, `${property.replace(/^\./, '')}`)).title;
+      const uiSchemaTitle = getUiOptions<T, S, F>(get(uiSchema, property.replace(/^\./, ''))).title;
 
       if (uiSchemaTitle) {
         stack = `'${uiSchemaTitle}' ${message}`.trim();
@@ -168,7 +170,7 @@ export default function processRawValidationErrors<
   let errors = transformRJSFValidationErrors<T, S, F>(rawErrors.errors, uiSchema, suppressDuplicateFiltering);
 
   if (invalidSchemaError) {
-    errors = [...errors, { stack: invalidSchemaError!.message }];
+    errors = [...errors, { stack: invalidSchemaError.message }];
   }
   if (typeof transformErrors === 'function') {
     errors = transformErrors(errors, uiSchema);
@@ -180,7 +182,7 @@ export default function processRawValidationErrors<
     errorSchema = {
       ...errorSchema,
       $schema: {
-        __errors: [invalidSchemaError!.message],
+        __errors: [invalidSchemaError.message],
       },
     };
   }

package/src/types.ts

@@ -32,15 +32,13 @@ export interface CustomValidatorOptionsType {
    * Mirrors `ajv.addMetaSchema` / `ajv.addSchema` semantics; ata resolves
    * `$ref` against the registered set.
    */
-  additionalMetaSchemas?: ReadonlyArray<object>;
+  additionalMetaSchemas?: readonly object[];
 
   /** Custom format checkers. Keys are format names referenced from `format`
    * in the schema. Values are validation functions, RegExps, or pre-anchored
    * regex source strings (compiled into a function for ata).
    */
-  customFormats?: {
-    [k: string]: string | RegExp | AtaFormatChecker;
-  };
+  customFormats?: Record<string, string | RegExp | AtaFormatChecker>;
 
   /** Overrides spread on top of the default `ata-validator` options. Use this
    * to flip `coerceTypes`, `removeAdditional`, `verbose`, or `abortEarly`.
@@ -68,4 +66,4 @@ export interface CompiledValidateFunction {
   (data: unknown): boolean;
 }
 
-export type ValidatorFunctions = { [key: string]: CompiledValidateFunction };
+export type ValidatorFunctions = Record<string, CompiledValidateFunction>;

package/src/validator.ts

@@ -1,18 +1,14 @@
-import {
+import type {
   CustomValidator,
-  deepEquals,
   ErrorTransformer,
   FormContextType,
-  hashForSchema,
-  ID_KEY,
   RJSFSchema,
-  ROOT_SCHEMA_PREFIX,
   StrictRJSFSchema,
   UiSchema,
   ValidationData,
   ValidatorType,
-  withIdRefPrefix,
 } from '@rjsf/utils';
+import { deepEquals, hashForSchema, ID_KEY, ROOT_SCHEMA_PREFIX, withIdRefPrefix } from '@rjsf/utils';
 import type { ValidationError, Validator } from 'ata-validator';
 import cloneDeep from 'lodash/cloneDeep';
 
@@ -96,7 +92,7 @@ export default class ATAValidator<
    * a mutated probe changes subsequent answers, so the wrapper has to
    * preserve referential purity that AJV provides by default.
    */
-  private cloneForValidation<D>(data: D): D {
+  private static cloneForValidation<D>(data: D): D {
     if (data === null || typeof data !== 'object') {
       return data;
     }
@@ -141,9 +137,9 @@ export default class ATAValidator<
     let errors: ValidationError[] | undefined;
 
     try {
-      const id = (schema[ID_KEY] as string | undefined) ?? hashForSchema(schema);
+      const id = schema[ID_KEY] ?? hashForSchema(schema);
       const validator = this.getOrBuild(id, schema);
-      const result = validator.validate(this.cloneForValidation(formData));
+      const result = validator.validate(ATAValidator.cloneForValidation(formData));
       errors = result.valid ? undefined : result.errors;
 
       if (errors && typeof this.localizer === 'function') {
@@ -195,7 +191,7 @@ export default class ATAValidator<
     if (this.lastSeenRootSchema === rootSchema && this.hasRegisteredRootSchema) {
       return;
     }
-    const rootSchemaId = (rootSchema[ID_KEY] as string | undefined) ?? ROOT_SCHEMA_PREFIX;
+    const rootSchemaId = rootSchema[ID_KEY] ?? ROOT_SCHEMA_PREFIX;
     // Inject $id into a copy of the rootSchema so ata's schema registry can
     // resolve `<rootSchemaId>#/...` refs produced by `withIdRefPrefix`.
     // The original user-supplied schema is left untouched.
@@ -219,11 +215,11 @@ export default class ATAValidator<
     try {
       this.handleSchemaUpdate(rootSchema);
       const schemaWithIdRefPrefix = withIdRefPrefix<S>(schema) as S;
-      const id = (schemaWithIdRefPrefix[ID_KEY] as string | undefined) ?? hashForSchema(schemaWithIdRefPrefix);
+      const id = schemaWithIdRefPrefix[ID_KEY] ?? hashForSchema(schemaWithIdRefPrefix);
       const validator = this.getOrBuild(id, schemaWithIdRefPrefix);
-      return validator.validate(this.cloneForValidation(formData)).valid;
+      return validator.validate(ATAValidator.cloneForValidation(formData)).valid;
     } catch (e) {
-      // eslint-disable-next-line no-console
+      // oxlint-disable-next-line no-console
       console.warn('Error encountered compiling schema:', e);
       return false;
     }