@adaptabletools/adaptable/src/AdaptableState/Common/AdaptableForm.js

Powerful AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements

export function isAdaptableFormFieldGroup(entry) {
    return !!entry && !Array.isArray(entry) && entry.kind === 'group';
}
export function flattenAdaptableFormFields(formDef) {
    const out = [];
    for (const entry of formDef?.fields ?? []) {
        if (Array.isArray(entry)) {
            out.push(...entry);
        }
        else if (isAdaptableFormFieldGroup(entry)) {
            for (const inner of entry.fields) {
                if (Array.isArray(inner)) {
                    out.push(...inner);
                }
                else {
                    out.push(inner);
                }
            }
        }
        else {
            out.push(entry);
        }
    }
    return out;
}
export function shouldClearSelectToDefault(field) {
    if (field.fieldType !== 'select' || field.multi) {
        return false;
    }
    if (field.clearToDefault === false) {
        return false;
    }
    if (field.clearToDefault === true) {
        return true;
    }
    return (field.defaultValue !== undefined && field.defaultValue !== null && field.defaultValue !== '');
}
export function resolveSelectValueAfterClear(field, newValue) {
    if (field.fieldType !== 'select' || field.multi) {
        return newValue;
    }
    const isEmpty = newValue === null || newValue === undefined || newValue === '';
    if (!isEmpty || !shouldClearSelectToDefault(field)) {
        return newValue;
    }
    return field.defaultValue;
}
export function resolveSelectPlaceholder(field, options) {
    if (field.placeholder) {
        return field.placeholder;
    }
    if (field.defaultValue === undefined || field.defaultValue === null || field.defaultValue === '') {
        return undefined;
    }
    return options.find((option) => option.value === field.defaultValue)?.label;
}
export function getDefaultAdaptableFormData(formDef) {
    return flattenAdaptableFormFields(formDef).reduce((data, field) => {
        if (field.fieldType === 'select' && field.multi) {
            data[field.name] = Array.isArray(field.defaultValue)
                ? field.defaultValue
                : field.defaultValue == null || field.defaultValue === ''
                    ? []
                    : [field.defaultValue];
        }
        else {
            data[field.name] = field.defaultValue ?? '';
        }
        return data;
    }, {});
}
export function resolveAdaptableFormFieldOptionsSync(field, formData, context) {
    const opts = field.options;
    if (!opts)
        return [];
    if (Array.isArray(opts))
        return opts;
    const result = opts(formData, context);
    if (result instanceof Promise)
        return undefined;
    return result;
}
export function isAdaptableFormFieldHidden(field, formData, context) {
    if (typeof field.hidden === 'function') {
        return !!field.hidden(formData, context);
    }
    return !!field.hidden;
}
export function isAdaptableFormFieldGroupHidden(group, formData, context) {
    if (typeof group.hidden === 'function') {
        return !!group.hidden(formData, context);
    }
    return !!group.hidden;
}
export function isAdaptableFormFieldDisabled(field, formData, context) {
    if (typeof field.disabled === 'function') {
        return !!field.disabled(formData, context);
    }
    return !!field.disabled;
}
export function validateAdaptableForm(formDef, formData, context) {
    const errors = {};
    for (const entry of formDef?.fields ?? []) {
        if (isAdaptableFormFieldGroup(entry)) {
            if (isAdaptableFormFieldGroupHidden(entry, formData, context)) {
                continue;
            }
            const innerFlat = entry.fields.flatMap((f) => (Array.isArray(f) ? f : [f]));
            for (const field of innerFlat) {
                validateOne(field, formData, context, errors);
            }
        }
        else if (Array.isArray(entry)) {
            for (const field of entry) {
                validateOne(field, formData, context, errors);
            }
        }
        else {
            validateOne(entry, formData, context, errors);
        }
    }
    return errors;
}
function validateOne(field, formData, context, errors) {
    if (isAdaptableFormFieldHidden(field, formData, context)) {
        return;
    }
    const error = validateAdaptableFormField(field, formData, context);
    if (error) {
        errors[field.name] = error;
    }
}
function validateAdaptableFormField(field, formData, context) {
    const value = formData[field.name];
    if (field.fieldType === 'textOutput') {
        return null;
    }
    if (field.required) {
        const isEmpty = value == null ||
            value === '' ||
            (field.fieldType === 'checkbox' && value === false) ||
            (field.fieldType === 'select' && field.multi && Array.isArray(value) && value.length === 0);
        if (isEmpty) {
            return `${field.label} is required`;
        }
    }
    const isProvided = value != null && value !== '';
    if (isProvided) {
        if (field.fieldType === 'number' || field.fieldType === 'slider') {
            const numValue = Number(value);
            if (!Number.isNaN(numValue)) {
                if (typeof field.min === 'number' && numValue < field.min) {
                    return `${field.label} must be at least ${field.min}`;
                }
                if (typeof field.max === 'number' && numValue > field.max) {
                    return `${field.label} must be at most ${field.max}`;
                }
            }
        }
        if (field.fieldType === 'date' ||
            field.fieldType === 'time' ||
            field.fieldType === 'datetime') {
            if (typeof field.min === 'string' && value < field.min) {
                return `${field.label} must be on or after ${field.min}`;
            }
            if (typeof field.max === 'string' && value > field.max) {
                return `${field.label} must be on or before ${field.max}`;
            }
        }
        if (field.fieldType === 'text' || field.fieldType === 'textarea') {
            const strValue = String(value);
            if (typeof field.minLength === 'number' && strValue.length < field.minLength) {
                return `${field.label} must be at least ${field.minLength} characters`;
            }
            if (typeof field.maxLength === 'number' && strValue.length > field.maxLength) {
                return `${field.label} must be at most ${field.maxLength} characters`;
            }
            if (field.fieldType === 'text' && field.pattern) {
                try {
                    const re = new RegExp(field.pattern);
                    if (!re.test(strValue)) {
                        return `${field.label} is not in the expected format`;
                    }
                }
                catch {
                }
            }
        }
    }
    if (field.validate) {
        const customError = field.validate(value, formData, context);
        if (customError) {
            return customError;
        }
    }
    return null;
}