@rjsf/validator-ajv8 5.11.2 → 5.12.1

package/src/processRawValidationErrors.ts

@@ -0,0 +1,139 @@
+import { ErrorObject } from 'ajv';
+import get from 'lodash/get';
+import {
+  createErrorHandler,
+  CustomValidator,
+  ErrorTransformer,
+  FormContextType,
+  getDefaultFormState,
+  getUiOptions,
+  PROPERTIES_KEY,
+  RJSFSchema,
+  RJSFValidationError,
+  StrictRJSFSchema,
+  toErrorSchema,
+  UiSchema,
+  unwrapErrorHandler,
+  validationDataMerge,
+  ValidatorType,
+} from '@rjsf/utils';
+
+export type RawValidationErrorsType<Result = any> = { errors?: Result[]; validationError?: Error };
+
+/** Transforming the error output from ajv to format used by @rjsf/utils.
+ * At some point, components should be updated to support ajv.
+ *
+ * @param errors - The list of AJV errors to convert to `RJSFValidationErrors`
+ * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
+ */
+export function transformRJSFValidationErrors<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any
+>(errors: ErrorObject[] = [], uiSchema?: UiSchema<T, S, F>): RJSFValidationError[] {
+  return errors.map((e: ErrorObject) => {
+    const { instancePath, keyword, params, schemaPath, parentSchema, ...rest } = e;
+    let { message = '' } = rest;
+    let property = instancePath.replace(/\//g, '.');
+    let stack = `${property} ${message}`.trim();
+
+    if ('missingProperty' in params) {
+      property = property ? `${property}.${params.missingProperty}` : params.missingProperty;
+      const currentProperty: string = params.missingProperty;
+      const uiSchemaTitle = getUiOptions(get(uiSchema, `${property.replace(/^\./, '')}`)).title;
+
+      if (uiSchemaTitle) {
+        message = message.replace(currentProperty, uiSchemaTitle);
+      } else {
+        const parentSchemaTitle = get(parentSchema, [PROPERTIES_KEY, currentProperty, 'title']);
+
+        if (parentSchemaTitle) {
+          message = message.replace(currentProperty, parentSchemaTitle);
+        }
+      }
+
+      stack = message;
+    } else {
+      const uiSchemaTitle = getUiOptions<T, S, F>(get(uiSchema, `${property.replace(/^\./, '')}`)).title;
+
+      if (uiSchemaTitle) {
+        stack = `'${uiSchemaTitle}' ${message}`.trim();
+      } else {
+        const parentSchemaTitle = parentSchema?.title;
+
+        if (parentSchemaTitle) {
+          stack = `'${parentSchemaTitle}' ${message}`.trim();
+        }
+      }
+    }
+
+    // put data in expected format
+    return {
+      name: keyword,
+      property,
+      message,
+      params, // specific to ajv
+      stack,
+      schemaPath,
+    };
+  });
+}
+
+/** 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 AJV validation errors, prior to custom validation and
+ * transform them in what ever way it chooses.
+ *
+ * @param validator - The `ValidatorType` implementation used for the `getDefaultFormState()` call
+ * @param rawErrors - The list of raw `ErrorObject`s to process
+ * @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 AJV validation
+ * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
+ */
+export default function processRawValidationErrors<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any
+>(
+  validator: ValidatorType<T, S, F>,
+  rawErrors: RawValidationErrorsType<ErrorObject>,
+  formData: T | undefined,
+  schema: S,
+  customValidate?: CustomValidator<T, S, F>,
+  transformErrors?: ErrorTransformer<T, S, F>,
+  uiSchema?: UiSchema<T, S, F>
+) {
+  const { validationError: invalidSchemaError } = rawErrors;
+  let errors = transformRJSFValidationErrors<T, S, F>(rawErrors.errors, uiSchema);
+
+  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 };
+  }
+
+  // Include form data with undefined values, which is required for custom validation.
+  const newFormData = getDefaultFormState<T, S, F>(validator, schema, formData, schema, true) as T;
+
+  const errorHandler = customValidate(newFormData, createErrorHandler<T>(newFormData), uiSchema);
+  const userErrorSchema = unwrapErrorHandler<T>(errorHandler);
+  return validationDataMerge<T>({ errors, errorSchema }, userErrorSchema);
+}

package/src/types.ts

@@ -0,0 +1,40 @@
+import Ajv, { Options, ErrorObject } from 'ajv';
+import { FormatsPluginOptions } from 'ajv-formats';
+
+/** The type describing how to customize the AJV6 validator
+ */
+export interface CustomValidatorOptionsType {
+  /** The list of additional meta schemas that the validator can access */
+  additionalMetaSchemas?: ReadonlyArray<object>;
+  /** The set of additional custom formats that the validator will support */
+  customFormats?: {
+    [k: string]: string | RegExp | ((data: string) => boolean);
+  };
+  /** The set of config overrides that will be passed to the AJV validator constructor on top of the defaults */
+  ajvOptionsOverrides?: Options;
+  /** The `ajv-format` options to use when adding formats to `ajv`; pass `false` to disable it */
+  ajvFormatOptions?: FormatsPluginOptions | false;
+  /** The AJV class to construct */
+  AjvClass?: typeof Ajv;
+}
+
+/** The type describing a function that takes a list of Ajv `ErrorObject`s and localizes them
+ */
+export type Localizer = (errors?: null | ErrorObject[]) => void;
+
+/** This is a simplification of the `ValidateFunction` type provided by the AJV validator down to its minimal form so
+ * that the code still works properly with precompiled validator functions generated by the AJV standalone code
+ * compilation but does not rely on any of the internal AJV types which causes Typescript issue for library consumers
+ */
+export interface CompiledValidateFunction {
+  /** The errors produced by the precompiled validator */
+  errors?: null | ErrorObject[];
+  /** This is simplified version of a `ValidateFunction` type definition which describes the interface that our
+   * precompiled validator will call.
+   */
+  (this: Ajv | any, data: any): boolean;
+}
+
+/** The definition of precompiled validator functions
+ */
+export type ValidatorFunctions = { [key: string]: CompiledValidateFunction };

package/src/validator.ts

@@ -0,0 +1,163 @@
+import Ajv, { ErrorObject, ValidateFunction } from 'ajv';
+import {
+  CustomValidator,
+  ErrorSchema,
+  ErrorTransformer,
+  FormContextType,
+  ID_KEY,
+  RJSFSchema,
+  ROOT_SCHEMA_PREFIX,
+  StrictRJSFSchema,
+  toErrorList,
+  UiSchema,
+  ValidationData,
+  ValidatorType,
+  withIdRefPrefix,
+  hashForSchema,
+} from '@rjsf/utils';
+
+import { CustomValidatorOptionsType, Localizer } from './types';
+import createAjvInstance from './createAjvInstance';
+import processRawValidationErrors, { RawValidationErrorsType } from './processRawValidationErrors';
+
+/** `ValidatorType` implementation that uses the AJV 8 validation mechanism.
+ */
+export default class AJV8Validator<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>
+  implements ValidatorType<T, S, F>
+{
+  /** The AJV instance to use for all validations
+   *
+   * @private
+   */
+  private ajv: Ajv;
+
+  /** The Localizer function to use for localizing Ajv errors
+   *
+   * @private
+   */
+  readonly localizer?: Localizer;
+
+  /** Constructs an `AJV8Validator` instance using the `options`
+   *
+   * @param options - The `CustomValidatorOptionsType` options that are used to create the AJV instance
+   * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
+   */
+  constructor(options: CustomValidatorOptionsType, localizer?: Localizer) {
+    const { additionalMetaSchemas, customFormats, ajvOptionsOverrides, ajvFormatOptions, AjvClass } = options;
+    this.ajv = createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides, ajvFormatOptions, AjvClass);
+    this.localizer = localizer;
+  }
+
+  /** Converts an `errorSchema` into a list of `RJSFValidationErrors`
+   *
+   * @param errorSchema - The `ErrorSchema` instance to convert
+   * @param [fieldPath=[]] - The current field path, defaults to [] if not specified
+   * @deprecated - Use the `toErrorList()` function provided by `@rjsf/utils` instead. This function will be removed in
+   *        the next major release.
+   */
+  toErrorList(errorSchema?: ErrorSchema<T>, fieldPath: string[] = []) {
+    return toErrorList(errorSchema, fieldPath);
+  }
+
+  /** 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 schema
+   * @param formData - The form data to validate
+   */
+  rawValidation<Result = any>(schema: S, formData?: T): RawValidationErrorsType<Result> {
+    let compilationError: Error | undefined = undefined;
+    let compiledValidator: ValidateFunction | undefined;
+    if (schema[ID_KEY]) {
+      compiledValidator = this.ajv.getSchema(schema[ID_KEY]);
+    }
+    try {
+      if (compiledValidator === undefined) {
+        compiledValidator = this.ajv.compile(schema);
+      }
+      compiledValidator(formData);
+    } catch (err) {
+      compilationError = err as Error;
+    }
+
+    let errors;
+    if (compiledValidator) {
+      if (typeof this.localizer === 'function') {
+        this.localizer(compiledValidator.errors);
+      }
+      errors = compiledValidator.errors || undefined;
+
+      // Clear errors to prevent persistent errors, see #1104
+      compiledValidator.errors = null;
+    }
+
+    return {
+      errors: errors as unknown as Result[],
+      validationError: compilationError,
+    };
+  }
+
+  /** 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 AJV 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 AJV 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<ErrorObject>(schema, formData);
+    return processRawValidationErrors(this, rawErrors, formData, schema, customValidate, transformErrors, uiSchema);
+  }
+
+  /** Validates data against a schema, returning true if the data is valid, or
+   * false otherwise. If the schema is 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
+   */
+  isValid(schema: S, formData: T | undefined, rootSchema: S) {
+    const rootSchemaId = rootSchema[ID_KEY] ?? ROOT_SCHEMA_PREFIX;
+    try {
+      // add the rootSchema ROOT_SCHEMA_PREFIX as id.
+      // then rewrite the schema ref's to point to the rootSchema
+      // this accounts for the case where schema have references to models
+      // that lives in the rootSchema but not in the schema in question.
+      if (this.ajv.getSchema(rootSchemaId) === undefined) {
+        this.ajv.addSchema(rootSchema, rootSchemaId);
+      }
+      const schemaWithIdRefPrefix = withIdRefPrefix<S>(schema) as S;
+      const schemaId = schemaWithIdRefPrefix[ID_KEY] ?? hashForSchema(schemaWithIdRefPrefix);
+      let compiledValidator: ValidateFunction | undefined;
+      compiledValidator = this.ajv.getSchema(schemaId);
+      if (compiledValidator === undefined) {
+        // Add schema by an explicit ID so it can be fetched later
+        // Fall back to using compile if necessary
+        // https://ajv.js.org/guide/managing-schemas.html#pre-adding-all-schemas-vs-adding-on-demand
+        compiledValidator =
+          this.ajv.addSchema(schemaWithIdRefPrefix, schemaId).getSchema(schemaId) ||
+          this.ajv.compile(schemaWithIdRefPrefix);
+      }
+      const result = compiledValidator(formData);
+      return result as boolean;
+    } catch (e) {
+      console.warn('Error encountered compiling schema:', e);
+      return false;
+    } finally {
+      // TODO: A function should be called if the root schema changes so we don't have to remove and recompile the schema every run.
+      // make sure we remove the rootSchema from the global ajv instance
+      this.ajv.removeSchema(rootSchemaId);
+    }
+  }
+}

package/dist/compileSchemaValidators.cjs.development.js

@@ -1,57 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var fs = require('fs');
-var standaloneCode = require('ajv/dist/standalone');
-var utils = require('@rjsf/utils');
-var createAjvInstance = require('./createAjvInstance-33d73c95.js');
-require('ajv');
-require('ajv-formats');
-require('lodash/isObject');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var standaloneCode__default = /*#__PURE__*/_interopDefaultLegacy(standaloneCode);
-
-/** 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 AJV code compilation see: https://ajv.js.org/standalone.html
- *
- * @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 AJV 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 AJV-based validator.
- */
-function compileSchemaValidators(schema, output, options = {}) {
-  console.log('parsing the schema');
-  const schemaMaps = utils.schemaParser(schema);
-  const schemas = Object.values(schemaMaps);
-  const {
-    additionalMetaSchemas,
-    customFormats,
-    ajvOptionsOverrides = {},
-    ajvFormatOptions,
-    AjvClass
-  } = options;
-  // Allow users to turn off the `lines: true` feature in their own overrides, but NOT the `source: true`
-  const compileOptions = {
-    ...ajvOptionsOverrides,
-    code: {
-      lines: true,
-      ...ajvOptionsOverrides.code,
-      source: true
-    },
-    schemas
-  };
-  const ajv = createAjvInstance.createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);
-  const moduleCode = standaloneCode__default["default"](ajv);
-  console.log(`writing ${output}`);
-  fs__default["default"].writeFileSync(output, moduleCode);
-}
-
-exports["default"] = compileSchemaValidators;
-//# sourceMappingURL=compileSchemaValidators.cjs.development.js.map

package/dist/compileSchemaValidators.cjs.development.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compileSchemaValidators.cjs.development.js","sources":["../src/compileSchemaValidators.ts"],"sourcesContent":["import fs from 'fs';\nimport standaloneCode from 'ajv/dist/standalone';\nimport { RJSFSchema, StrictRJSFSchema, schemaParser } from '@rjsf/utils';\n\nimport createAjvInstance from './createAjvInstance';\nimport { CustomValidatorOptionsType } from './types';\n\n/** The function used to compile a schema into an output file in the form that allows it to be used as a precompiled\n * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,\n * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more\n * information about AJV code compilation see: https://ajv.js.org/standalone.html\n *\n * @param schema - The schema to be compiled into a set of precompiled validators functions\n * @param output - The name of the file into which the precompiled validator functions will be generated\n * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for\n *        compiling the schema. They are the same options that are passed to the `customizeValidator()` function in\n *        order to modify the behavior of the regular AJV-based validator.\n */\nexport default function compileSchemaValidators<S extends StrictRJSFSchema = RJSFSchema>(\n  schema: S,\n  output: string,\n  options: CustomValidatorOptionsType = {}\n) {\n  console.log('parsing the schema');\n  const schemaMaps = schemaParser(schema);\n  const schemas = Object.values(schemaMaps);\n\n  const { additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass } = options;\n  // Allow users to turn off the `lines: true` feature in their own overrides, but NOT the `source: true`\n  const compileOptions = {\n    ...ajvOptionsOverrides,\n    code: { lines: true, ...ajvOptionsOverrides.code, source: true },\n    schemas,\n  };\n  const ajv = createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);\n\n  const moduleCode = standaloneCode(ajv);\n  console.log(`writing ${output}`);\n  fs.writeFileSync(output, moduleCode);\n}\n"],"names":["compileSchemaValidators","schema","output","options","console","log","schemaMaps","schemaParser","schemas","Object","values","additionalMetaSchemas","customFormats","ajvOptionsOverrides","ajvFormatOptions","AjvClass","compileOptions","code","lines","source","ajv","createAjvInstance","moduleCode","standaloneCode","fs","writeFileSync"],"mappings":";;;;;;;;;;;;;;;;;AAOA;;;;;;;;;;AAUG;AACW,SAAUA,uBAAuBA,CAC7CC,MAAS,EACTC,MAAc,EACdC,OAAA,GAAsC,EAAE,EAAA;AAExCC,EAAAA,OAAO,CAACC,GAAG,CAAC,oBAAoB,CAAC,CAAA;AACjC,EAAA,MAAMC,UAAU,GAAGC,kBAAY,CAACN,MAAM,CAAC,CAAA;AACvC,EAAA,MAAMO,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACJ,UAAU,CAAC,CAAA;EAEzC,MAAM;IAAEK,qBAAqB;IAAEC,aAAa;IAAEC,mBAAmB,GAAG,EAAE;IAAEC,gBAAgB;AAAEC,IAAAA,QAAAA;AAAU,GAAA,GAAGZ,OAAO,CAAA;AAC9G;AACA,EAAA,MAAMa,cAAc,GAAG;AACrB,IAAA,GAAGH,mBAAmB;AACtBI,IAAAA,IAAI,EAAE;AAAEC,MAAAA,KAAK,EAAE,IAAI;MAAE,GAAGL,mBAAmB,CAACI,IAAI;AAAEE,MAAAA,MAAM,EAAE,IAAA;KAAM;AAChEX,IAAAA,OAAAA;GACD,CAAA;AACD,EAAA,MAAMY,GAAG,GAAGC,mCAAiB,CAACV,qBAAqB,EAAEC,aAAa,EAAEI,cAAc,EAAEF,gBAAgB,EAAEC,QAAQ,CAAC,CAAA;AAE/G,EAAA,MAAMO,UAAU,GAAGC,kCAAc,CAACH,GAAG,CAAC,CAAA;AACtChB,EAAAA,OAAO,CAACC,GAAG,EAAYH,QAAAA,EAAAA,MAAM,EAAE,CAAC,CAAA;AAChCsB,EAAAA,sBAAE,CAACC,aAAa,CAACvB,MAAM,EAAEoB,UAAU,CAAC,CAAA;AACtC;;;;"}

package/dist/compileSchemaValidators.cjs.production.min.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("fs"),r=require("ajv/dist/standalone"),t=require("@rjsf/utils"),s=require("./createAjvInstance-33d73c95.js");function a(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}require("ajv"),require("ajv-formats"),require("lodash/isObject");var o=a(e),i=a(r);exports.default=function(e,r,a={}){console.log("parsing the schema");const c=t.schemaParser(e),n=Object.values(c),{additionalMetaSchemas:u,customFormats:l,ajvOptionsOverrides:d={},ajvFormatOptions:j,AjvClass:v}=a,f={...d,code:{lines:!0,...d.code,source:!0},schemas:n},m=s.createAjvInstance(u,l,f,j,v),p=i.default(m);console.log(`writing ${r}`),o.default.writeFileSync(r,p)};
-//# sourceMappingURL=compileSchemaValidators.cjs.production.min.js.map

package/dist/compileSchemaValidators.cjs.production.min.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compileSchemaValidators.cjs.production.min.js","sources":["../src/compileSchemaValidators.ts"],"sourcesContent":["import fs from 'fs';\nimport standaloneCode from 'ajv/dist/standalone';\nimport { RJSFSchema, StrictRJSFSchema, schemaParser } from '@rjsf/utils';\n\nimport createAjvInstance from './createAjvInstance';\nimport { CustomValidatorOptionsType } from './types';\n\n/** The function used to compile a schema into an output file in the form that allows it to be used as a precompiled\n * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,\n * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more\n * information about AJV code compilation see: https://ajv.js.org/standalone.html\n *\n * @param schema - The schema to be compiled into a set of precompiled validators functions\n * @param output - The name of the file into which the precompiled validator functions will be generated\n * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for\n *        compiling the schema. They are the same options that are passed to the `customizeValidator()` function in\n *        order to modify the behavior of the regular AJV-based validator.\n */\nexport default function compileSchemaValidators<S extends StrictRJSFSchema = RJSFSchema>(\n  schema: S,\n  output: string,\n  options: CustomValidatorOptionsType = {}\n) {\n  console.log('parsing the schema');\n  const schemaMaps = schemaParser(schema);\n  const schemas = Object.values(schemaMaps);\n\n  const { additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass } = options;\n  // Allow users to turn off the `lines: true` feature in their own overrides, but NOT the `source: true`\n  const compileOptions = {\n    ...ajvOptionsOverrides,\n    code: { lines: true, ...ajvOptionsOverrides.code, source: true },\n    schemas,\n  };\n  const ajv = createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);\n\n  const moduleCode = standaloneCode(ajv);\n  console.log(`writing ${output}`);\n  fs.writeFileSync(output, moduleCode);\n}\n"],"names":["schema","output","options","console","log","schemaMaps","schemaParser","schemas","Object","values","additionalMetaSchemas","customFormats","ajvOptionsOverrides","ajvFormatOptions","AjvClass","compileOptions","code","lines","source","ajv","createAjvInstance","moduleCode","standaloneCode","fs","writeFileSync"],"mappings":"0WAkBc,SACZA,EACAC,EACAC,EAAsC,CAAA,GAEtCC,QAAQC,IAAI,sBACZ,MAAMC,EAAaC,eAAaN,GAC1BO,EAAUC,OAAOC,OAAOJ,IAExBK,sBAAEA,EAAqBC,cAAEA,EAAaC,oBAAEA,EAAsB,CAAE,EAAAC,iBAAEA,EAAgBC,SAAEA,GAAaZ,EAEjGa,EAAiB,IAClBH,EACHI,KAAM,CAAEC,OAAO,KAASL,EAAoBI,KAAME,QAAQ,GAC1DX,WAEIY,EAAMC,EAAAA,kBAAkBV,EAAuBC,EAAeI,EAAgBF,EAAkBC,GAEhGO,EAAaC,UAAeH,GAClChB,QAAQC,eAAeH,KACvBsB,EAAAA,QAAGC,cAAcvB,EAAQoB,EAC3B"}

package/dist/createAjvInstance-33d73c95.js

@@ -1,2 +0,0 @@
-"use strict";var e=require("ajv"),a=require("ajv-formats"),r=require("lodash/isObject"),t=require("@rjsf/utils");function s(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var d=s(e),o=s(a),l=s(r);const u={allErrors:!0,multipleOfPrecision:8,strict:!1,verbose:!0},i=/^(#?([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=/^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;exports.createAjvInstance=function(e,a,r={},s,c=d.default){const b=new c({...u,...r});return s?o.default(b,s):!1!==s&&o.default(b),b.addFormat("data-url",n),b.addFormat("color",i),b.addKeyword(t.ADDITIONAL_PROPERTY_FLAG),b.addKeyword(t.RJSF_ADDITONAL_PROPERTIES_FLAG),Array.isArray(e)&&b.addMetaSchema(e),l.default(a)&&Object.keys(a).forEach((e=>{b.addFormat(e,a[e])})),b};
-//# sourceMappingURL=createAjvInstance-33d73c95.js.map

package/dist/createAjvInstance-33d73c95.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createAjvInstance-33d73c95.js","sources":["../src/createAjvInstance.ts"],"sourcesContent":["import Ajv, { Options } from 'ajv';\nimport addFormats, { FormatsPluginOptions } from 'ajv-formats';\nimport isObject from 'lodash/isObject';\n\nimport { CustomValidatorOptionsType } from './types';\nimport { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITONAL_PROPERTIES_FLAG } from '@rjsf/utils';\n\nexport const AJV_CONFIG: Options = {\n  allErrors: true,\n  multipleOfPrecision: 8,\n  strict: false,\n  verbose: true,\n} as const;\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*\\)))$/;\nexport const DATA_URL_FORMAT_REGEX = /^data:([a-z]+\\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;\n\n/** Creates an Ajv version 8 implementation object with standard support for the 'color` and `data-url` custom formats.\n * If `additionalMetaSchemas` are provided then the Ajv instance is modified to add each of the meta schemas in the\n * list. If `customFormats` are provided then those additional formats are added to the list of supported formats. If\n * `ajvOptionsOverrides` are provided then they are spread on top of the default `AJV_CONFIG` options when constructing\n * the `Ajv` instance. With Ajv v8, the JSON Schema formats are not provided by default, but can be plugged in. By\n * default, all formats from the `ajv-formats` library are added. To disable this capability, set the `ajvFormatOptions`\n * parameter to `false`. Additionally, you can configure the `ajv-formats` by providing a custom set of\n * [format options](https://github.com/ajv-validator/ajv-formats) to the `ajvFormatOptions` parameter.\n *\n * @param [additionalMetaSchemas] - The list of additional meta schemas that the validator can access\n * @param [customFormats] - The set of additional custom formats that the validator will support\n * @param [ajvOptionsOverrides={}] - The set of validator config override options\n * @param [ajvFormatOptions] - The `ajv-format` options to use when adding formats to `ajv`; pass `false` to disable it\n * @param [AjvClass] - The `Ajv` class to use when creating the validator instance\n */\nexport default function createAjvInstance(\n  additionalMetaSchemas?: CustomValidatorOptionsType['additionalMetaSchemas'],\n  customFormats?: CustomValidatorOptionsType['customFormats'],\n  ajvOptionsOverrides: CustomValidatorOptionsType['ajvOptionsOverrides'] = {},\n  ajvFormatOptions?: FormatsPluginOptions | false,\n  AjvClass: typeof Ajv = Ajv\n) {\n  const ajv = new AjvClass({ ...AJV_CONFIG, ...ajvOptionsOverrides });\n  if (ajvFormatOptions) {\n    addFormats(ajv, ajvFormatOptions);\n  } else if (ajvFormatOptions !== false) {\n    addFormats(ajv);\n  }\n\n  // add custom formats\n  ajv.addFormat('data-url', DATA_URL_FORMAT_REGEX);\n  ajv.addFormat('color', COLOR_FORMAT_REGEX);\n\n  // Add RJSF-specific additional properties keywords so Ajv doesn't report errors if strict is enabled.\n  ajv.addKeyword(ADDITIONAL_PROPERTY_FLAG);\n  ajv.addKeyword(RJSF_ADDITONAL_PROPERTIES_FLAG);\n\n  // add more schemas to validate against\n  if (Array.isArray(additionalMetaSchemas)) {\n    ajv.addMetaSchema(additionalMetaSchemas);\n  }\n\n  // add more custom formats to validate against\n  if (isObject(customFormats)) {\n    Object.keys(customFormats).forEach((formatName) => {\n      ajv.addFormat(formatName, customFormats[formatName]);\n    });\n  }\n\n  return ajv;\n}\n"],"names":["AJV_CONFIG","allErrors","multipleOfPrecision","strict","verbose","COLOR_FORMAT_REGEX","DATA_URL_FORMAT_REGEX","additionalMetaSchemas","customFormats","ajvOptionsOverrides","ajvFormatOptions","AjvClass","Ajv","ajv","addFormats","addFormat","addKeyword","ADDITIONAL_PROPERTY_FLAG","RJSF_ADDITONAL_PROPERTIES_FLAG","Array","isArray","addMetaSchema","isObject","Object","keys","forEach","formatName"],"mappings":"kNAOO,MAAMA,EAAsB,CACjCC,WAAW,EACXC,oBAAqB,EACrBC,QAAQ,EACRC,SAAS,GAEEC,EACX,6YACWC,EAAwB,sFAiBb,SACtBC,EACAC,EACAC,EAAyE,CAAA,EACzEC,EACAC,EAAuBC,WAEvB,MAAMC,EAAM,IAAIF,EAAS,IAAKX,KAAeS,IA2B7C,OA1BIC,EACFI,UAAWD,EAAKH,IACc,IAArBA,GACTI,EAAU,QAACD,GAIbA,EAAIE,UAAU,WAAYT,GAC1BO,EAAIE,UAAU,QAASV,GAGvBQ,EAAIG,WAAWC,EAAAA,0BACfJ,EAAIG,WAAWE,EAAAA,gCAGXC,MAAMC,QAAQb,IAChBM,EAAIQ,cAAcd,GAIhBe,EAAAA,QAASd,IACXe,OAAOC,KAAKhB,GAAeiB,SAASC,IAClCb,EAAIE,UAAUW,EAAYlB,EAAckB,GAAY,IAIjDb,CACT"}