@sjsf/ajv8-validator/dist/precompile/validator.js

The ajv-8 based validator for svelte-jsonschema-form

import { fromValidators } from "@sjsf/form/validators/precompile";
import { createFormErrorsTransformer, createFieldErrorsTransformer, validateAndTransformErrors, validateAndTransformErrorsAsync, } from "../errors.js";
import { CAST_FORM_DATA, NO_FILED_ERRORS, } from "../internals.js";
// TODO: Remove in v4
function createRetriever(options) {
    return "validateFunctions" in options
        ? (options.validatorRetriever ??
            fromValidators(options.validateFunctions, options.augmentSuffix
                ? {
                    idAugmentations: {
                        combination: (id) => id + options.augmentSuffix,
                    },
                }
                : undefined))
        : options.validatorRetriever;
}
export function createValidator(options) {
    const getValidateFunction = createRetriever(options);
    return {
        isValid(schema, _, formValue) {
            if (typeof schema === "boolean") {
                return schema;
            }
            const validate = getValidateFunction(schema);
            try {
                return validate(formValue);
            }
            catch (e) {
                console.warn("Failed to validate", e);
                return false;
            }
        },
    };
}
export function createFormValueValidator(options) {
    const getValidateFunction = createRetriever(options);
    const transformErrors = createFormErrorsTransformer(options);
    return {
        validateFormValue(rootSchema, formValue) {
            return validateAndTransformErrors(getValidateFunction(rootSchema), formValue, (CAST_FORM_DATA), transformErrors);
        },
    };
}
export function createFieldValueValidator(options) {
    const getValidateFunction = createRetriever(options);
    return {
        validateFieldValue(field, fieldValue) {
            return validateAndTransformErrors(getValidateFunction(field.schema), fieldValue, NO_FILED_ERRORS, createFieldErrorsTransformer(field));
        },
    };
}
export function createAsyncFormValueValidator(options) {
    const getValidateFunction = createRetriever(options);
    const transformErrors = createFormErrorsTransformer(options);
    return {
        validateFormValueAsync(_, rootSchema, formValue) {
            return validateAndTransformErrorsAsync(getValidateFunction(rootSchema), formValue, (CAST_FORM_DATA), transformErrors);
        },
    };
}
export function createAsyncFieldValueValidator(options) {
    const getValidateFunction = createRetriever(options);
    return {
        validateFieldValueAsync(_, field, fieldValue) {
            return validateAndTransformErrorsAsync(getValidateFunction(field.schema), fieldValue, NO_FILED_ERRORS, createFieldErrorsTransformer(field));
        },
    };
}
export function createFormValidatorFactory(vOptions) {
    return (options) => {
        const full = {
            ...options,
            ...vOptions,
            validatorRetriever: vOptions.validatorRetriever ?? createRetriever(vOptions),
        };
        return Object.assign(createValidator(full), createFormValueValidator(full), createFieldValueValidator(full));
    };
}
export function createAsyncFormValidatorFactory(vOptions) {
    return (options) => {
        const full = {
            ...options,
            ...vOptions,
            validatorRetriever: vOptions.validatorRetriever ?? createRetriever(vOptions),
        };
        return Object.assign(createValidator(full), createAsyncFormValueValidator(full), createAsyncFieldValueValidator(full));
    };
}