mapInputUpdate.js

{
    class AcceptMap {
        constructor(values) {
            if (typeof values === 'string') {
                values = values.trim().split(/\s+/);
            }
            values.forEach(value => this[value] = true);
        }
    }
    class RejectMap {
        constructor(values) {
            if (typeof values === 'string') {
                values = values.trim().split(/\s+/);
            }
            values.forEach(value => this[value] = true);
        }
    }
    const check = (value, condition) => {
        if (condition instanceof AcceptMap) {
            return value in condition;
        }
        if (condition instanceof RejectMap) {
            return !(value in condition);
        }
        if (condition instanceof Object) {
            return !!condition[value];
        }
        return value == condition;
    };

    // Amarra a configuração de alguns elementos ao valor de uma input após determinado evento
    // selector: Selector do campo
    // affected: Objeto onde o nome de cada atributo indica um selector dos elementos afetados e o
    // valor do atributo indica a condição aplicada a estes elementos.
    // Se a condição for um objeto, cada nome de atributo deste objeto será um possível valor
    // consiedrado para a input, o valor do atributo deve ser um boolean que indica se este valor é
    // aceito ou não.
    // Se a condição não for um objeto, quando o valor da input for igual ao valor desta condição
    // então a condição será considerada aceita
    // event: evento que verifica as condições e atualiza os elementos
    // effect: Função de atualização aplicada. Receberá dois argumentos, os elementos em questão e
    // um boolean indicando se a condição foi aceita
    // default_value: Valor considerado enquanto a input estiver vazia
    // dynamic: Indica se a busca pelos selectors dos elementos afetados deve ser feita a toda
    // atualização ou apenas no momento da chamada desta função
    const mapInputUpdate = ({selector, affected, event, effect, default_value, dynamic=false}) => {
        const input = $(selector);
        const type = input.attr('type');
        const map = {};
        if (!dynamic) {
            for (let selector in affected) {
                map[selector] = $(selector);
            }
        }
        const update = () => {
            const value = (type==='radio'?input.filter(':checked'):input).val() || default_value;
            for (let selector in affected) {
                const condition = affected[selector];
                effect(dynamic? $(selector): map[selector], check(value, condition));
            }
        };
        input.bind(event, update);
        update();
        return update;
    };

    // Amarra a visibilidade de elementos ao valor de uma input
    // #Parâemtros
    // * name: Valor do atributo 'name' da input;
    // * object: Para cada atributo deste objeto o nome representará um selector e o valor será a
    // condição para que este objeto seja visível. Caso o valor (condição) seja um objeto usará este
    // objeto como um mapa de condições onde cada chave é um possível valor da input e o valor
    // indica se ele ficará visível nesta condição. Se o valor do atributo não for um objeto então o
    // valor da input deverá ser igual a este valor para que os elementos do selector fiquem
    // visíveis Retorna o método que atualiza a visibilidade dos elementos
    // * def (opcional): Valor default, caso a input ainda não tenha um valor, o valor de def será
    // considerado como o valor da input
    const bindInputVisibility = (name, affected, default_value) => mapInputUpdate({
        selector: `[name="${ name }"]`,
        affected, default_value,
        event: 'change',
        effect: (target, accepted) => accepted? target.show(): target.hide(),
    });

    window.mapInputUpdate = mapInputUpdate;
    window.bindInputVisibility = bindInputVisibility;
    window.MapValue = {
        accept: values => new AcceptMap(values),
        reject: values => new RejectMap(values),
    };
}