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

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

import { DEFAULT_AUGMENT_SUFFIX } from "@sjsf/form/validators/precompile";
import { createFormErrorsTransformer, createFieldErrorsTransformer, validateAndTransformErrors, validateAndTransformErrorsAsync, } from "../errors.js";
import { CAST_FORM_DATA, NO_FILED_ERRORS } from '../internals.js';
function getValidateFunction({ validateFunctions, augmentSuffix = DEFAULT_AUGMENT_SUFFIX, }, { $id: id, allOf }) {
    if (id === undefined) {
        const firstAllOfItem = allOf?.[0];
        if (typeof firstAllOfItem === "object" &&
            firstAllOfItem.$id !== undefined) {
            id = firstAllOfItem.$id + augmentSuffix;
        }
        else {
            throw new Error("Schema id not found");
        }
    }
    const validate = validateFunctions[id];
    if (validate === undefined) {
        throw new Error(`Validate function with id "${id}" not found`);
    }
    return validate;
}
export function createValidator(options) {
    return {
        isValid(schema, _, formValue) {
            if (typeof schema === "boolean") {
                return schema;
            }
            const validate = getValidateFunction(options, schema);
            try {
                return validate(formValue);
            }
            catch (e) {
                console.warn("Failed to validate", e);
                return false;
            }
        },
    };
}
export function createFormValueValidator(options) {
    const transformErrors = createFormErrorsTransformer(options);
    return {
        validateFormValue(rootSchema, formValue) {
            return validateAndTransformErrors(getValidateFunction(options, rootSchema), formValue, (CAST_FORM_DATA), transformErrors);
        },
    };
}
export function createFieldValueValidator(options) {
    return {
        validateFieldValue(field, fieldValue) {
            return validateAndTransformErrors(getValidateFunction(options, field.schema), fieldValue, NO_FILED_ERRORS, createFieldErrorsTransformer(field));
        },
    };
}
export function createAsyncFormValueValidator(options) {
    const transformErrors = createFormErrorsTransformer(options);
    return {
        validateFormValueAsync(_, rootSchema, formValue) {
            return validateAndTransformErrorsAsync(getValidateFunction(options, rootSchema), formValue, (CAST_FORM_DATA), transformErrors);
        },
    };
}
export function createAsyncFieldValueValidator(options) {
    return {
        validateFieldValueAsync(_, field, fieldValue) {
            return validateAndTransformErrorsAsync(getValidateFunction(options, field.schema), fieldValue, NO_FILED_ERRORS, createFieldErrorsTransformer(field));
        },
    };
}
export function createFormValidatorFactory(vOptions) {
    return (options) => {
        const full = {
            ...vOptions,
            ...options,
        };
        return Object.assign(createValidator(full), createFormValueValidator(full), createFieldValueValidator(full));
    };
}
export function createAsyncFormValidatorFactory(vOptions) {
    return (options) => {
        const full = {
            ...vOptions,
            ...options,
        };
        return Object.assign(createValidator(full), createAsyncFormValueValidator(full), createAsyncFieldValueValidator(full));
    };
}