pragma-views2/lib/validation-dom.js

import {findParentOfType} from './dom-helper.js';

export class ValidationDom {
    static applyRules(element, rules) {
        // Check if modifyable element and not something like #text or comments.
        if (element.removeAttribute == undefined) {
            return;
        }

        element.removeAttribute("required");
        element.removeAttribute("readonly");
        element.removeAttribute("maxlength");
        element.removeAttribute("pattern"); // pattern=".{0}|.{5,10}"
        element.removeAttribute("max");
        element.removeAttribute("min");

        const keys = Object.keys(rules);

        for (let rule of keys) {
            switch (rule) {
                case "required":
                    rules[rule].value == true ? element.setAttribute("required", rules[rule].value) : element.removeAttribute("required");
                    break;
                case "readOnly":
                    rules[rule].value == true ? element.setAttribute("readonly", rules[rule].value) : element.removeAttribute("readonly");
                    break;
                case "maxLength":
                    element.setAttribute("maxlength", rules[rule].value);
                    break;
                case "minLength":
                    element.setAttribute("pattern", ".{0}|.{" + rules[rule].value + ",}");
                    break;
                case "pattern":
                    element.setAttribute("pattern", rules[rule].value);
                    break;
                case "minimum":
                    element.setAttribute("min", rules[rule].value);
                    break;
                case "maximum":
                    element.setAttribute("max", rules[rule].value);
                    break;
            }
        }
    }

    static applyRulesToUI(element, definition) {
        ValidationDom.applyRules(element, definition.validations);
    }

    static getUIElement(fieldName, dataset) {
        const observer = dataset.observer.getObserver(dataset, fieldName);
        if (observer._callable0 == undefined) {
            return null;
        }

        return observer._callable0.target;
    }

    static updateUI(dataset) {
        if (dataset["__definition"] == undefined) {
            return;
        }

        const fields = dataset["__definition"].fields;

        for (let field of fields) {
            if (field.collection != undefined && dataset[field.name]._data != undefined) {
                for (let item of dataset[field.name]._data) {
                    if (typeof item.updateUI != "undefined") {
                        ValidationDom.updateUI(item);
                    }
                }
            }
            else if (field.dataset != undefined) {
                if (typeof dataset[field.name].updateUI != "undefined") {
                    ValidationDom.updateUI(dataset[field.name]);
                }
            }
            else if (field.validations != undefined) {
                const element = ValidationDom.getUIElement(field.name, dataset);

                if (element != null) {
                    ValidationDom.applyRulesToUI(element, field);
                }
            }
        }
    }

    /**
     * Used to
     * @param element
     */
    static validateInput(element) {
        if (element == null || element == undefined) {
            return;
        }

        if (["INPUT", "TEXTAREA"].indexOf(element.tagName) > -1) {
            const composite = findParentOfType(element, "label-composite");
            if (composite != undefined) {
                composite.shallowValidate();
            }
        }
    }
}