@sankhyalabs/sankhyablocks 1.3.31-beta.16 → 1.3.31-beta.18

package/dist/cjs/index-02201bc9.js

@@ -0,0 +1,2397 @@
+'use strict';
+
+/**
+ * Classe com utiliários comuns para Strings.
+ */
+class StringUtils {
+    /**
+     * Verifica se a string está vazia.
+     * Valores null e undefined são considerados como vazio.
+     *
+     * @param value  String para ser validada.
+    */
+    static isEmpty(value) {
+        if (value == undefined || value === null) {
+            return true;
+        }
+        value = value.toString();
+        value = value.trim();
+        if (value.length === 0) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Remove acentos de vogais, substitui Ç por c e retorna a string em caixa alta.
+     *
+     * @param value  String para ser transformada.
+    */
+    static replaceAccentuatedChars(text) {
+        text = text.toUpperCase();
+        text = text.replace(/[À]/, "A");
+        text = text.replace(/[Á]/, "A");
+        text = text.replace(/[Â]/, "A");
+        text = text.replace(/[Ã]/, "A");
+        text = text.replace(/[Ä]/, "A");
+        text = text.replace(/[È]/, "E");
+        text = text.replace(/[É]/, "E");
+        text = text.replace(/[Ê]/, "E");
+        text = text.replace(/[Ë]/, "E");
+        text = text.replace(/[Ì]/, "I");
+        text = text.replace(/[Í]/, "I");
+        text = text.replace(/[Î]/, "I");
+        text = text.replace(/[Ï]/, "I");
+        text = text.replace(/[Ò]/, "O");
+        text = text.replace(/[Ó]/, "O");
+        text = text.replace(/[Ô]/, "O");
+        text = text.replace(/[Ö]/, "O");
+        text = text.replace(/[Ù]/, "U");
+        text = text.replace(/[Ú]/, "U");
+        text = text.replace(/[Û]/, "U");
+        text = text.replace(/[Ü]/, "U");
+        text = text.replace(/[Ç]/, "C");
+        return text.replace(/[^a-z0-9]/gi, "");
+    }
+    /**
+    * Remove acentos de vogais, substitui Ç por c e retorna a string em caixa alta mantendo espaços e símbolos.
+    * @param text String para ser transformada.
+    */
+    static replaceAccentuatedCharsKeepSymbols(text) {
+        return text.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toUpperCase();
+    }
+    /**
+     * Calcula um código hash para uma string.
+     * @param value String que será gerado o hash code.
+    */
+    static hashCode(value) {
+        let hash = 0, i, chr;
+        if (value.length === 0)
+            return hash.toString();
+        for (i = 0; i < value.length; i++) {
+            chr = value.charCodeAt(i);
+            hash = ((hash << 5) - hash) + chr;
+            hash |= 0; // Convert to 32bit integer
+        }
+        return hash.toString();
+    }
+    /**
+     * Converte um valor em string para booleano
+     * @param value Valor a ser convertido
+     * @param defaultValue Será retornado esse caso seja passado valores diferentes do esperado(true, false, "true", "false", "S", "N")
+    */
+    static getBooleanValue(value, defaultValue = false) {
+        if ([true, "true", "S"].includes(value)) {
+            return true;
+        }
+        else if ([false, "false", "N"].includes(value)) {
+            return false;
+        }
+        else {
+            return defaultValue;
+        }
+    }
+    static padStart(str, len, pad = " ") {
+        str = str != undefined ? str : "";
+        while (str.length < len) {
+            str = pad + str;
+        }
+        return str;
+    }
+    static padEnd(str, len, pad = " ") {
+        str = str != undefined ? str : "";
+        while (str.length < len) {
+            str = str + pad;
+        }
+        return str;
+    }
+    /**
+     * Utilitário para determinar a ordem de strings. Geralmente usado no método "sort" de um array.
+     * Retorna um número negativo se o primeiro argumento é menor que o segundo, zero se os dois são iguais
+     * e um número positivo quando o primeiro é maior que o segundo.if they're equal, and a positive value otherwise.
+     * @param a - Primeira string para comparação
+     * @param b - Segunda string para comparação
+     * @returns Um valor maior, menor ou igual a zero para determinar se a ordem precisa ser alterada.
+     */
+    static compare(a, b) {
+        if (a === undefined) {
+            return b === undefined ? 0 : 1;
+        }
+        else if (b === undefined) {
+            return -1;
+        }
+        if (a === null) {
+            return b === null ? 0 : 1;
+        }
+        else if (b === null) {
+            return -1;
+        }
+        return a.localeCompare(b);
+    }
+}
+
+const NUMBERINPUTS_REGEX_SCIENTIFIC_PARTS = /^([+-])?(\d+).?(\d*)[eE]([-+]?\d+)$/;
+/**
+ * `NumberUtils` é uma biblioteca para manipulação de números
+ *
+ * `Métodos`:
+ *
+ * @stringToNumber: converte um número em formato de string em um valor numérico nativo do javascript
+ * @format: arredonda um número em formato de string baseado nos parâmetros "presision" e "prettyPrecision";
+ */
+class NumberUtils {
+}
+/**
+* @stringToNumber: converte um numero em formato de string em numero
+*
+* @param value numero em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico: ######.##)
+*
+* @returns string based number
+*
+* @Exemples
+* @"100,12"     |       100.12
+* @"100.12"     |       100.12
+* @"-100,12"    |       -100.12
+* @"R$100,12"   |       100.12
+* @"-R$100,12"  |       -100.12
+* @"string"     |       NaN
+*/
+NumberUtils.stringToNumber = (value) => {
+    if (value === '' || value === null || value === undefined) {
+        return NaN;
+    }
+    if (value) {
+        value = value.toString();
+        const negative = (value.charAt(0) === '-');
+        if (!NUMBERINPUTS_REGEX_SCIENTIFIC_PARTS.test(value)) {
+            value = value.replace(/[^\d.,]/g, '');
+        }
+        else {
+            value = value.replace(/^-/g, '');
+        }
+        //In case of simple string such as: "@@@@@@@"
+        if (value === '') {
+            return Number(NaN);
+        }
+        const indexV = value.indexOf(',');
+        const indexP = value.indexOf('.');
+        if (indexP > indexV) {
+            value = value.replace(',', '');
+        }
+        else if (indexP < indexV) {
+            value = value.replace(/\./g, '@').replace(',', '.').replace(/@/g, '');
+        }
+        if (negative) {
+            value = '-' + value;
+        }
+    }
+    return Number(value);
+};
+/**
+* @format: converte um numero em formato de string em um numero em formato de string formatado de acordo com os parametros de "precision" e "prettyPrecision"
+*
+* @param value numero em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico<sem separadors de milhares>: ######.##)
+* @param precision (numero de decimais)
+* @param prettyPrecision (numero de zeros nos decimais)
+*
+* @returns numero em formato de string formatado em PT-BR
+*/
+NumberUtils.format = (value, precision, prettyPrecision = NaN) => {
+    if (value === '' || value === undefined || value === "NaN") {
+        return NaN.toString();
+    }
+    const newValue = NumberUtils.stringToNumber(value);
+    if (isNaN(newValue)) {
+        return NaN.toString();
+    }
+    //Validation "precision":
+    // Case1: precision < 0 => does not use precision
+    // Case2: presicion not int => does not use precision
+    if (precision < 0 || Math.abs(Math.round(precision * 1) / 1) !== precision) {
+        //Once stringToNumber returns number format, we need to change to pt-br
+        return NumberUtils.changeFormat(newValue.toString());
+    }
+    //Validation "prettyPrecision"
+    let prettyPrecisionInternal = 0;
+    // Case1: prettyPrecision < 0 => prettyPrecision does not change de format that means: prettyPrecisionInternal = precision;
+    // Case2: prettyPrecision not int => prettyPrecision does not change de format that means: prettyPrecisionInternal = precision;
+    if (isNaN(prettyPrecision) || Math.abs(Math.round(prettyPrecision * 1) / 1) !== prettyPrecision) {
+        prettyPrecisionInternal = precision;
+    }
+    else {
+        prettyPrecisionInternal = prettyPrecision;
+    }
+    let newValueStr;
+    newValueStr = (Math.round(newValue * Math.pow(10, precision)) / Math.pow(10, precision)).toLocaleString('pt-br', { minimumFractionDigits: precision });
+    //prettyPrecision
+    const varSettingPP = precision - prettyPrecisionInternal;
+    if (varSettingPP > 0) {
+        for (let i = 0; i < varSettingPP; i++) {
+            if (newValueStr.substring(newValueStr.length - 1) == "0" && precision > 0) {
+                newValueStr = newValueStr.substring(0, newValueStr.length - 1);
+            }
+        }
+    }
+    //in Case "." or "," in the end of the string
+    if (newValueStr.substring(newValueStr.length - 1) == "." || newValueStr.substring(newValueStr.length - 1) == ",") {
+        newValueStr = newValueStr.substring(0, newValueStr.length - 1);
+    }
+    return newValueStr;
+};
+/**
+* @keepOnlyDecimalSeparator: retira os separadores de milhar de um número em formato de string
+*
+* @param value numero em formato de string a ser convertido
+* @param formatnumber (formatação de ENTRADA e SAÍDA do utilitário: pt-BR="###.###,##" en-US="###,###.##"; Default: "pt-BR")
+*
+* @returns numero em formato de string formatado apenas com separador decimal
+*/
+NumberUtils.keepOnlyDecimalSeparator = (value, formatnumber = 'pt-BR') => {
+    //Formatting formatnumber to be able to get lowercases
+    formatnumber = formatnumber.toUpperCase();
+    //Formatting value following formatnumber parameter
+    //keep only decimal character in order to correct format the string
+    //This transformation is due the "stringtoNumber" method is a general method that tries to convert all formated strings
+    if (formatnumber === 'EN-US') {
+        value = value.replace(/\,/g, '');
+    }
+    else {
+        value = value.replace(/\./g, '');
+    }
+    return value;
+};
+/**
+* @changeFormat: troca o formato do numero string de "PT-BR" para "EN-US" e vice-versa
+*
+* @param value numero em formato de string a ser convertido
+*
+* @returns numero em formato de string formatado de "PT-BR" para "EN-US" e vice-versa
+*/
+NumberUtils.changeFormat = (value) => {
+    //Formatting output following formatnumber
+    return value.replace(/\./g, '_').replace(/\,/g, '.').replace(/\_/g, ',');
+};
+
+/**
+ * `MaskFormatter` é usado para formatar strings. Seu comportamento
+ * é controlado pela formato do atributo `mask` que especifica quais
+ * caracteres são válidos e onde devem estar posicionados, intercalando-os
+ * com eventuais caracteres literais expressados no padrão informado.
+ * Sua implementação é inspirada pela implementação em Java do [MaskFormatter](https://docs.oracle.com/javase/7/docs/api/javax/swing/text/MaskFormatter.html).
+ *
+ * Para o padrão da máscara podem ser usados os seguintes caracteres especiais:
+ *
+ * | Caractere | Comportamento                                                                                               |
+ * |:---------:|-------------------------------------------------------------------------------------------------------------|
+ * | #         | Qualquer número                                                                                             |
+ * | '         | "Escapa" o caractere que vem na sequência. Útil quando desejamos converter um caractere especial em literal.|
+ * | U         | Qualquer letra. Transforma letras maiúsculas em maiúsculas.                                                 |
+ * | L         | Qualquer letra. Transforma letras maiúsculas em minúsculas.                                                 |
+ * | A         | Qualquer letra ou número.                                                                                   |
+ * | ?         | Qualquer letra. Preserva maiúsculas e minúsculas.                                                           |
+ * | *         | Qualquer caractere.                                                                                         |
+ *
+ * Os demais caracteres presentes no padrão serão tratados como literais, isto é,
+ * serão apenas inseridos naquela posição.
+ *
+ * Quando o o valor a ser formatado é menor que a máscara um 'placeHolder'
+ * será inserido em cada posição ausente, completando a formatação.
+ * Por padrão será usado um espaço em branco como 'placeHolder' mas
+ * esse valor pode ser alterado.
+ *
+ * For por exemplo:
+ * '''
+ *    const formatter: MaskFormatter = new MaskFormatter("###-####");
+ *    formatter.placeholder = '_';
+ *    console.log(formatter.format("123"));
+ * '''
+ * resultaria na string '123-____'.
+ *
+ * ##Veja mais alguns exemplos:
+ * |Padrão          |Máscara           |Entrada       |Saída             |
+ * |----------------|------------------|--------------|------------------|
+ * |Telefone        |(##) ####-####    |3432192515    |(34) 3219-2515    |
+ * |CPF             |###.###.###-##    |12345678901   |123.456.789-01    |
+ * |CNPJ            |##.###.###/####-##|12345678901234|12.345.678/9012-34|
+ * |CEP             |##.###-###        |12345678      |12.345-678        |
+ * |PLACA (veículo) |UUU-####          |abc1234       |ABC-1234          |
+ * |Cor RGB         |'#AAAAAA          |00000F0       |#0000F0           |
+ *
+ */
+class MaskFormatter {
+    constructor(mask) {
+        this._mask = '';
+        this._maskChars = new Array();
+        /**
+         * Determina qual caractere será usado dos caracteres não presentes no valor
+         * ou seja, aqueles que o usuário ainda não informou. Por padrão usamos um espaço
+         */
+        this.placeholder = ' ';
+        this.mask = mask;
+    }
+    /**
+     * Setter para mask. Trata-se do padrão que se espera ao formatar o texto.
+     */
+    set mask(mask) {
+        this._mask = mask;
+        this.updateInternalMask();
+    }
+    /**
+     * Getter para mask
+     *
+     * @return A última máscara informada.
+     */
+    get mask() {
+        return this._mask;
+    }
+    /**
+     * Formata a string passada baseada na máscara definda pelo atributo mask.
+     *
+     * @param value Valor a ser formatado
+     * @return O valor processado de acordo com o padrão
+     */
+    format(value) {
+        let result = '';
+        const index = [0];
+        let counter = 0;
+        const maxCounter = this._maskChars.length;
+        while (counter < maxCounter) {
+            result = this._maskChars[counter].append(result, value, index);
+            counter++;
+        }
+        return result;
+    }
+    /**
+     * Preparamos a formatação internamente de acordo com o padrão.
+     */
+    updateInternalMask() {
+        this._maskChars.length = 0;
+        if (this.mask != null) {
+            let counter = 0;
+            const maxCounter = this.mask.length;
+            while (counter < maxCounter) {
+                let maskChar = this.mask.charAt(counter);
+                switch (maskChar) {
+                    case MaskFormatter.DIGIT_KEY:
+                        this._maskChars.push(new MaskFormatter.DigitMaskCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.LITERAL_KEY:
+                        if (++counter < maxCounter) {
+                            maskChar = this.mask.charAt(counter);
+                            this._maskChars.push(new MaskFormatter.LiteralCharacter(this, maskChar));
+                        }
+                        break;
+                    case MaskFormatter.UPPERCASE_KEY:
+                        this._maskChars.push(new MaskFormatter.UpperCaseCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.LOWERCASE_KEY:
+                        this._maskChars.push(new MaskFormatter.LowerCaseCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.ALPHA_NUMERIC_KEY:
+                        this._maskChars.push(new MaskFormatter.AlphaNumericCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.CHARACTER_KEY:
+                        this._maskChars.push(new MaskFormatter.CharCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.ANYTHING_KEY:
+                        this._maskChars.push(new MaskFormatter.MaskCharacter(this, maskChar));
+                        break;
+                    default:
+                        this._maskChars.push(new MaskFormatter.LiteralCharacter(this, maskChar));
+                        break;
+                }
+                counter++;
+            }
+        }
+    }
+}
+MaskFormatter.DIGIT_KEY = "#";
+MaskFormatter.LITERAL_KEY = "'";
+MaskFormatter.UPPERCASE_KEY = "U";
+MaskFormatter.LOWERCASE_KEY = "L";
+MaskFormatter.ALPHA_NUMERIC_KEY = "A";
+MaskFormatter.CHARACTER_KEY = "?";
+MaskFormatter.ANYTHING_KEY = "*";
+//
+// Classes internas usadas para representar a máscara.
+//
+MaskFormatter.MaskCharacter = class {
+    constructor(maskFormatter, type) {
+        this.maskFormatter = maskFormatter;
+        this.type = type;
+    }
+    /**
+     * Cada subclasse deve sobrescrever o retornando true, caso represente
+     * um caractere literal. Por padrão o retorno é false.
+     */
+    isLiteral() {
+        return false;
+    }
+    /**
+     * Returns true if <code>aChar</code> is a valid reprensentation of
+     * the receiver. The default implementation returns true if the
+     * receiver represents a literal character and <code>getChar</code>
+     * == aChar. Otherwise, this will return true is <code>aChar</code>
+     * is contained in the valid characters and not contained
+     * in the invalid characters.
+     */
+    isValidCharacter(aChar) {
+        if (this.isLiteral()) {
+            return (this.getChar(aChar) == aChar);
+        }
+        aChar = this.getChar(aChar);
+        return true;
+    }
+    /**
+     * Returns the character to insert for <code>aChar</code>. The
+     * default implementation returns <code>aChar</code>. Subclasses
+     * that wish to do some sort of mapping, perhaps lower case to upper
+     * case should override this and do the necessary mapping.
+     */
+    getChar(aChar) {
+        return aChar;
+    }
+    /**
+     * Appends the necessary character in <code>formatting</code> at
+     * <code>index</code> to <code>buff</code>.
+     */
+    append(result, formatting, index) {
+        const inString = index[0] < formatting.length;
+        const aChar = inString ? formatting.charAt(index[0]) : '';
+        if (this.isLiteral()) {
+            const literal = this.getChar(aChar);
+            result += literal;
+            if (literal === aChar) {
+                index[0] = index[0] + 1;
+            }
+        }
+        else if (index[0] >= formatting.length) {
+            result += this.maskFormatter.placeholder;
+            index[0] = index[0] + 1;
+        }
+        else if (this.isValidCharacter(aChar)) {
+            result += this.getChar(aChar);
+            index[0] = index[0] + 1;
+        }
+        else {
+            throw new Error(`Valor inválido: "${aChar}". Na posição ${index[0] + 1} espera-se ${this.getFormatMessage()}.`);
+        }
+        return result;
+    }
+    getFormatMessage() {
+        let message;
+        switch (this.type) {
+            case MaskFormatter.UPPERCASE_KEY:
+            case MaskFormatter.LOWERCASE_KEY:
+            case MaskFormatter.CHARACTER_KEY:
+                message = 'uma letra';
+                break;
+            case MaskFormatter.DIGIT_KEY:
+                message = 'um número';
+                break;
+            case MaskFormatter.ALPHA_NUMERIC_KEY:
+                message = 'uma letra ou um número';
+                break;
+            default:
+                message = '';
+        }
+        return message;
+    }
+};
+MaskFormatter.LiteralCharacter = class extends MaskFormatter.MaskCharacter {
+    constructor(maskFormatter, fixedChar) {
+        super(maskFormatter, fixedChar);
+        this._fixedChar = fixedChar;
+    }
+    isLiteral() {
+        return true;
+    }
+    getChar(aChar) {
+        aChar;
+        return this._fixedChar;
+    }
+};
+MaskFormatter.DigitMaskCharacter = class extends MaskFormatter.MaskCharacter {
+    isValidCharacter(aChar) {
+        return (this.isDigit(aChar) && super.isValidCharacter(aChar));
+    }
+    isDigit(char) {
+        return char >= '0' && char <= '9';
+    }
+};
+MaskFormatter.UpperCaseCharacter = class extends MaskFormatter.MaskCharacter {
+    isValidCharacter(aChar) {
+        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+    }
+    getChar(aChar) {
+        return aChar.toUpperCase();
+    }
+};
+MaskFormatter.LowerCaseCharacter = class extends MaskFormatter.MaskCharacter {
+    isValidCharacter(aChar) {
+        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+    }
+    getChar(aChar) {
+        return aChar.toLocaleLowerCase();
+    }
+};
+MaskFormatter.AlphaNumericCharacter = class extends MaskFormatter.MaskCharacter {
+    isValidCharacter(aChar) {
+        //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
+        return (/[a-z0-9]/i.test(aChar)) && super.isValidCharacter(aChar);
+    }
+};
+MaskFormatter.CharCharacter = class extends MaskFormatter.MaskCharacter {
+    isValidCharacter(aChar) {
+        //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
+        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+    }
+};
+
+class FloatingEntry {
+    constructor(parent, content, opts) {
+        try {
+            this.weakRefParent = new WeakRef(parent);
+            this.weakRefContent = new WeakRef(content);
+        }
+        catch (error) {
+            this.strongRefParent = parent;
+            this.strongRefContent = content;
+        }
+        this.options = opts;
+    }
+    get parent() {
+        if (this.weakRefParent) {
+            return this.weakRefParent.deref();
+        }
+        return this.strongRefParent;
+    }
+    get content() {
+        if (this.weakRefContent) {
+            return this.weakRefContent.deref();
+        }
+        return this.strongRefContent;
+    }
+}
+class FloatingManager {
+    static init() {
+        FloatingManager.entries = [];
+        document.addEventListener('mousedown', FloatingManager.handleDocumentEvent);
+        document.addEventListener('keydown', FloatingManager.handleKeyboardEvent);
+        FloatingManager.initialized = true;
+    }
+    static innerClick(container, node) {
+        if (container.contains(node)) {
+            return true;
+        }
+        if (container.shadowRoot && container.shadowRoot.contains(node)) {
+            return true;
+        }
+        return false;
+    }
+    static doClose(id, entry, target, event) {
+        if (!target || entry.options.autoClose) {
+            const parent = entry.parent;
+            const content = entry.content;
+            if (parent && content) {
+                const innerClickFunction = entry.options.innerClickTest ? entry.options.innerClickTest : FloatingManager.innerClick;
+                const backClickFunction = entry.options.backClickListener ? entry.options.backClickListener : () => { };
+                if (!target || !innerClickFunction(content, target, event)) {
+                    content.remove();
+                    delete FloatingManager.entries[id];
+                    backClickFunction();
+                }
+            }
+            else {
+                delete FloatingManager.entries[id];
+            }
+        }
+    }
+    static handleDocumentEvent(event) {
+        FloatingManager.entries.forEach((entry, index) => {
+            FloatingManager.doClose(index, entry, event.composedPath()[0], event);
+        });
+    }
+    static handleKeyboardEvent(event) {
+        if (event.key === 'Escape') {
+            for (let index = FloatingManager.entries.length; index >= 0; index--) {
+                const entry = FloatingManager.entries[index];
+                if (entry) {
+                    FloatingManager.close(index);
+                    break;
+                }
+            }
+        }
+    }
+    static applyStyle(element, propertyName, value) {
+        if (value) {
+            element.style.setProperty(propertyName, value);
+        }
+    }
+    static getFloatIndex(content, parent) {
+        for (let index = 0; index < FloatingManager.entries.length; index++) {
+            const entry = FloatingManager.entries[index];
+            if (entry && content === entry.content && parent === entry.parent) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    static isFloating(id) {
+        return FloatingManager.entries[id] !== undefined;
+    }
+    static float(content, parent, options = { autoClose: true }) {
+        if (!FloatingManager.initialized) {
+            FloatingManager.init();
+        }
+        const alreadyFloatingIndex = FloatingManager.getFloatIndex(content, parent);
+        if (alreadyFloatingIndex > -1) {
+            return alreadyFloatingIndex;
+        }
+        content.style.position = options.isFixed ? 'fixed' : 'absolute';
+        FloatingManager.applyStyle(content, "top", options.top);
+        FloatingManager.applyStyle(content, "left", options.left);
+        FloatingManager.applyStyle(content, "right", options.right);
+        FloatingManager.applyStyle(content, "bottom", options.bottom);
+        parent.appendChild(content);
+        FloatingManager.entries.push(new FloatingEntry(parent, content, options));
+        return FloatingManager.entries.length - 1;
+    }
+    static updateFloatPosition(content, parent, options = { autoClose: true }) {
+        const alreadyFloatingIndex = FloatingManager.getFloatIndex(content, parent);
+        if (alreadyFloatingIndex > -1) {
+            FloatingManager.applyStyle(content, "top", options.top);
+            FloatingManager.applyStyle(content, "left", options.left);
+            FloatingManager.applyStyle(content, "right", options.right);
+            FloatingManager.applyStyle(content, "bottom", options.bottom);
+        }
+    }
+    static close(id) {
+        if (FloatingManager.entries[id]) {
+            FloatingManager.doClose(id, FloatingManager.entries[id], undefined);
+        }
+    }
+}
+
+class DateUtils {
+    static clearTime(date, adjustDayLightSavingTime = true) {
+        const newDate = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
+        return adjustDayLightSavingTime ? DateUtils.adjustDLST(newDate) : newDate;
+    }
+    static strToDate(strValue, adjustDayLightSavingTime = true, monthYearMode = false) {
+        /** monthYearMode é um booleano para usar o formato MM/YYYY.
+         * Quando ativado, é retornado o primeiro dia do mês apenas para construir a data.
+         * Não há necessidade de verificar o horário de verão quando utilizado esse modo. */
+        let parts;
+        if (monthYearMode) {
+            parts = /^(1[0-2]|0[1-9]|[1-9])[^\d]?(\d{2}|\d{4})(?:\s(\d{1,2}):(\d{1,2}):?(\d{0,2}))?$/.exec(strValue);
+        }
+        else {
+            parts = /^(3[01]|[1-2]\d|0[1-9]|[1-9])[^\d]?(1[0-2]|0[1-9]|[1-9])[^\d]?(\d{2}|\d{4})(?:\s(\d{1,2}):(\d{1,2}):?(\d{0,2}))?$/.exec(strValue);
+        }
+        if (!parts) {
+            return undefined;
+        }
+        const day = monthYearMode ? 1 : Number(parts[1]);
+        const month = Number(parts[(monthYearMode ? 1 : 2)]);
+        let year = Number(parts[(monthYearMode ? 2 : 3)]);
+        const hour = Number(parts[(monthYearMode ? 3 : 4)] || 0);
+        const min = Number(parts[(monthYearMode ? 4 : 5)] || 0);
+        const sec = Number(parts[(monthYearMode ? 5 : 6)] || 0);
+        if (year < 100) {
+            year += year < 30 ? 2000 : 1900;
+        }
+        let date = new Date(year, month - 1, day, hour, min, sec, 0);
+        if (adjustDayLightSavingTime === true && !monthYearMode && hour == 0) {
+            date = DateUtils.adjustDLST(date);
+        }
+        return date;
+    }
+    static adjustDLST(date) {
+        //Work around para corrigir o Bug do horário de verão.
+        if (date.getHours() == 23) {
+            return new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1, 1, 0, 0, 0);
+        }
+        return date;
+    }
+}
+
+class ArrayUtils {
+    /**
+     * Filtra um array a partir de um critério textual.
+     *
+     * @param argument - Texto a ser usado no filtro
+     * @param originalArray - Array no formato original
+     * @param alphabeticalSorting - Determina se o resultado deve ser ordenado ou mantido na ordem original. Por padrão ordena.
+     * @param fieldName - Caso o objeto deva ser filtrado por um campo diferente de "label", pode-se usar esse parâmetro
+     * @returns Um array filtrado e ordenado conforme necessidade. Se "argument" for omitido, ou nulo, o array original é retornado.
+     */
+    static applyStringFilter(argument, originalArray, alphabeticalSorting = true, fieldName = "label") {
+        if (!argument) {
+            return originalArray;
+        }
+        const normalizedArgument = ArrayUtils.normalizeSearchString(argument);
+        const filteredArray = originalArray.filter(item => {
+            const itemValue = ArrayUtils.normalizeSearchString(item[fieldName]);
+            return itemValue.includes(normalizedArgument);
+        });
+        return alphabeticalSorting ? filteredArray.sort((a, b) => StringUtils.compare(a[fieldName], b[fieldName])) : filteredArray;
+    }
+    static normalizeSearchString(original) {
+        return StringUtils.replaceAccentuatedCharsKeepSymbols(original.toUpperCase());
+    }
+}
+
+/**
+ * `TimeFormatter` é um utilitário para formatação de strings desformatadas em strings válidas de horários
+ */
+class TimeFormatter {
+    /**
+    * @prepareValue: converts an unformated time string into a formatted time.
+    *
+    * @param value unformated time string to convert
+    *
+    * @returns formatted time string
+    *
+    * @Exemples
+    * @"1012"       |       "10:12"
+    * @"10:12"      |       "10:12:00"
+    * @"100112"     |       "10:01:12"
+    */
+    static prepareValue(value, showSeconds) {
+        if (value && value.length > 0 && value != "NaN") {
+            let validationValue = value.replace(/:/g, "");
+            if (showSeconds) {
+                this._maskFormatter.mask = "##:##:##";
+                if (validationValue.length < 6) {
+                    while (validationValue.length < 6) {
+                        validationValue = "0".concat(validationValue);
+                    }
+                }
+            }
+            else {
+                this._maskFormatter.mask = "##:##";
+                if (validationValue.length < 4) {
+                    while (validationValue.length < 4) {
+                        validationValue = "0".concat(validationValue);
+                    }
+                }
+            }
+            if (this._maskFormatter) {
+                try {
+                    value = this._maskFormatter.format(validationValue);
+                    return value;
+                }
+                catch (e) {
+                    throw new Error(e.message);
+                }
+            }
+        }
+        return '';
+    }
+    /**
+    * @validateTime: validates if an input string has the corect time format.
+    *
+    * @param value input string to validate
+    *
+    * @returns true or false
+    *
+    * @Exemples
+    * @"1012"       |       true
+    * @"14e4"       |       false
+    * @"2624"       |       false
+    */
+    static validateTime(value, showSeconds) {
+        let isValid = true;
+        if (value) {
+            let validationValue = value.replace(/:/g, "");
+            if (showSeconds) {
+                if (!["1", "2", "0"].includes(validationValue[0])) {
+                    isValid = false;
+                }
+                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[2])) {
+                    isValid = false;
+                }
+                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[4])) {
+                    isValid = false;
+                }
+                if (validationValue[0] == "2" && !["0", "1", "2", "3"].includes(validationValue[1])) {
+                    isValid = false;
+                }
+            }
+            else {
+                if (!["1", "2", "0"].includes(validationValue[0])) {
+                    isValid = false;
+                }
+                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[2])) {
+                    isValid = false;
+                }
+                if (validationValue[0] == "2" && !["0", "1", "2", "3"].includes(validationValue[1])) {
+                    isValid = false;
+                }
+            }
+        }
+        else {
+            isValid = false;
+        }
+        return isValid;
+    }
+}
+TimeFormatter._maskFormatter = new MaskFormatter("##:##");
+
+/**
+ * Representa as propriedades necessárias para se executar uma requisição.
+ */
+class RequestMetadata {
+    /**
+     * @param {string} url A URL que deve ser chamada.
+     * @param {Method} method O Método da requisição (GET, PUT, POST ou DELETE).
+     */
+    constructor(url, method, headers) {
+        /** Tempo limite de espera pela resposta */
+        this.timeout = 30000;
+        this.url = url;
+        this.method = method;
+        this.headers = headers || [];
+    }
+}
+/** Representa os verbos HTTP suportados */
+var Method;
+(function (Method) {
+    Method[Method["GET"] = 0] = "GET";
+    Method[Method["PUT"] = 1] = "PUT";
+    Method[Method["POST"] = 2] = "POST";
+    Method[Method["DELETE"] = 3] = "DELETE";
+})(Method || (Method = {}));
+
+/**
+ * Abstração do XMLHttpRequest. Este serviço é responsável por realizar as requisições
+ * ao backend. Todos os métodos são estáticos.
+ */
+class HttpProvider {
+    /**
+     * Faz uma requisição usando o método GET do HTTP para uma URL específica.
+     *
+     * @param {string} url A URL que deve ser chamada.
+     * @param {Array<Header>} headers [Opcional] Cabeçalhos HTTP.
+     * @returns {Promise<Object>} Uma promessa de que a requisição será preenchida.
+     */
+    static get(url, headers) {
+        return this.dispatch(new RequestMetadata(url, Method.GET, headers));
+    }
+    /**
+     * Faz uma requisição usando o método POST do HTTP para uma URL específica.
+     *
+     * @param {string} url A URL que deve ser chamada.
+     * @param {Object} payload Informações a serem enviadas.
+     * @param {Array<Header>} headers [Opcional] Cabeçalhos HTTP.
+     * @returns {Promise<Object>} Uma promessa de que a requisição será preenchida.
+     */
+    static post(url, payload, headers) {
+        return this.dispatch(new RequestMetadata(url, Method.POST, headers), payload);
+    }
+    static dispatch(requestMetadata, payload) {
+        return new Promise((resolve, reject) => {
+            const request = new XMLHttpRequest();
+            request.timeout = requestMetadata.timeout;
+            request.onerror = function handleError() {
+                reject({
+                    status: 404,
+                    statusText: 'Not Found'
+                });
+            };
+            request.ontimeout = function handleTimeout() {
+                reject({
+                    status: 408,
+                    statusText: 'Request Timeout'
+                });
+            };
+            request.onreadystatechange = () => {
+                // While readState isn't done, there's nothing to do...
+                if (request.readyState != 4) {
+                    return;
+                }
+                const status = request.status;
+                // The request has failed so we'll handled by onerror instead
+                if (status === 0) {
+                    return;
+                }
+                const response = {
+                    status,
+                    statusText: request.statusText,
+                };
+                // Anything out of this range is an error, so we just send the status and statusText.
+                if (status >= 200 && status < 300) {
+                    resolve(Object.assign(Object.assign({}, response), { data: request.response, dataAsString: request.responseText }));
+                }
+                else {
+                    reject(response);
+                }
+            };
+            request.open(requestMetadata.method.toString(), requestMetadata.url, true);
+            requestMetadata.headers.map((h) => request.setRequestHeader(h.name, h.value));
+            if (payload != null) {
+                request.send(JSON.stringify(payload));
+            }
+        });
+    }
+}
+
+class SkwHttpProvider {
+    static callService(serviceName, content) {
+        return new Promise((resolve, reject) => {
+            let host = "http://192.168.1.218:8503/mge/";
+            let appName = "ListaTarefa";
+            let module = 'mge';
+            this._counter++;
+            if (serviceName.indexOf("@") > -1) {
+                let s = serviceName.split("@");
+                module = s[0];
+                serviceName = s[1];
+            }
+            let url = `${host}/${module}/service.sbr?serviceName=${serviceName}&counter=${this._counter}&application=${appName}&outputType=json&preventTransform=false`;
+            let requestContent = {
+                serviceName: serviceName,
+                requestBody: content
+            };
+            let headers = new Headers();
+            headers.append("Content-Type", "application/json");
+            //headers.append("Access-Control-Allow-Methods", "GET, POST, OPTIONS, PUT, PATCH, DELETE");
+            //headers.append("Access-Control-Allow-Origin", "Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, Access-Control-Request-Method, Access-Control-Request-Headers");
+            fetch(url, {
+                body: JSON.stringify(requestContent),
+                method: 'POST',
+                headers: headers
+            })
+                .then(res => res.json())
+                .then((data) => {
+                console.log(data);
+            });
+            /*HttpProvider.post(url, requestContent, headers)
+            .then(res => {
+                if (!res.hasOwnProperty('status') ||
+                    res.status == this.STATUS_ERROR ||
+                    res.status == this.STATUS_TIMEOUT) {
+
+                    let statusMessage = res.statusMessage;
+                    
+                    if (!statusMessage) {
+                        statusMessage = 'Erro não identificado.'
+                    }
+                    //TODO: No futuro, exibir mensagens de erro. (MessageUtils.showError)
+                    reject(new Error(statusMessage));
+                }else if (res.status == this.STATUS_CANCELED) {
+                    if (res.statusMessage){
+                        console.warn(res.statusMessage);
+                    }
+                }else{
+                    resolve(res);
+                }
+
+                if (res.status == this.STATUS_INFO) {
+                     //TODO: No futuro, exibir mensagens de erro. (MessageUtils.showAlert)
+                    console.info(res.statusMessage);
+                }
+            })
+            .catch((e)=>{reject(e)});*/
+        });
+    }
+}
+SkwHttpProvider._counter = 0;
+SkwHttpProvider.STATUS_ERROR = 0;
+SkwHttpProvider.STATUS_OK = 1;
+SkwHttpProvider.STATUS_INFO = 2;
+SkwHttpProvider.STATUS_TIMEOUT = 3;
+SkwHttpProvider.STATUS_CANCELED = 4;
+
+var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+class AuthorizedServiceCaller {
+    constructor(serverURL, unauthorizedPath) {
+        this.serverURL = "http://192.168.1.218:8503"; //todo request deve fazer replace de ${serverURL} pelo conteúdo da variável
+        this.unauthorizedPath = "/";
+        this.serverURL = serverURL;
+        this.unauthorizedPath = unauthorizedPath;
+    }
+    requestService(request, callback) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            const token = localStorage.getItem('token');
+            const body = request === null || request === void 0 ? void 0 : request.body;
+            const method = request === null || request === void 0 ? void 0 : request.method;
+            let headers;
+            if (!token) {
+                window.location.pathname = this.unauthorizedPath;
+            }
+            else {
+                headers = {
+                    'Authorization': `${token}`,
+                    'Content-Type': 'application/json',
+                    'Customer-Host': 'http://localhost:8080/sankhyaw'
+                };
+            }
+            const response = yield yield fetch(this.serverURL, {
+                method: method,
+                headers: headers,
+                body: body
+            })
+                .catch(e => {
+                console.log(e);
+            });
+            if (response instanceof Response && response.status === 401) {
+                localStorage.removeItem('token');
+                window.location.pathname = this.unauthorizedPath;
+            }
+            if (callback && response instanceof Response) {
+                callback(response.json().then());
+            }
+            else {
+                return response;
+            }
+        });
+    }
+}
+
+exports.DataType = void 0;
+(function (DataType) {
+    DataType["NUMBER"] = "NUMBER";
+    DataType["DATE"] = "DATE";
+    DataType["TEXT"] = "TEXT";
+    DataType["BOOLEAN"] = "BOOLEAN";
+    DataType["OBJECT"] = "OBJECT";
+})(exports.DataType || (exports.DataType = {}));
+const convertType = (dataType, value) => {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (typeof value === "object" && dataType !== exports.DataType.OBJECT && "value" in value) {
+        value = value.value;
+    }
+    switch (dataType) {
+        case exports.DataType.NUMBER:
+            return value === "" || isNaN(value) ? null : Number(value);
+        case exports.DataType.OBJECT:
+            return typeof value === "string" ? JSON.parse(value) : value;
+        case exports.DataType.BOOLEAN:
+            if (typeof value == 'string') {
+                return Boolean(value === 'true');
+            }
+            return Boolean(value);
+        case exports.DataType.DATE:
+            return new Date(value.toString());
+        default:
+            return value;
+    }
+};
+const toString = (dataType, value) => {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (dataType) {
+        if (dataType === exports.DataType.OBJECT) {
+            return JSON.stringify(value);
+        }
+        else if (dataType === exports.DataType.DATE) {
+            return value.toISOString();
+        }
+        else {
+            return value.toString();
+        }
+    }
+    else {
+        if (typeof value === "string") {
+            return value;
+        }
+        else if (value instanceof Date) {
+            return value.toISOString();
+        }
+        else {
+            try {
+                return JSON.stringify(value);
+            }
+            catch (_a) {
+                value = value.toString();
+            }
+            return value;
+        }
+    }
+};
+
+class DataUnitAction {
+    constructor(type, payload) {
+        this._type = type;
+        this._payload = payload;
+    }
+    get type() {
+        return this._type;
+    }
+    get payload() {
+        return this._payload;
+    }
+}
+exports.Action = void 0;
+(function (Action) {
+    Action["LOADING_METADATA"] = "loadingMetadata";
+    Action["METADATA_LOADED"] = "metadataLoaded";
+    Action["LOADING_DATA"] = "loadingData";
+    Action["DATA_LOADED"] = "dataLoaded";
+    Action["SAVING_DATA"] = "savingData";
+    Action["DATA_SAVED"] = "dataSaved";
+    Action["REMOVING_RECORDS"] = "removingRecords";
+    Action["RECORDS_REMOVED"] = "recordsRemoved";
+    Action["RECORDS_ADDED"] = "recordsAdded";
+    Action["RECORDS_COPIED"] = "recordsCopied";
+    Action["CHANGING_DATA"] = "changingData";
+    Action["WAITING_CHANGE_CANCELED"] = "waitingChangeCanceled";
+    Action["DATA_CHANGED"] = "dataChanged";
+    Action["EDITION_CANCELED"] = "editionCanceled";
+    Action["CHANGE_UNDONE"] = "changeUndone";
+    Action["CHANGE_REDONE"] = "changeRedone";
+    Action["SELECTION_CHANGED"] = "selectionChanged";
+    Action["NEXT_SELECTED"] = "nextSelected";
+    Action["PREVIOUS_SELECTED"] = "previousSelected";
+    Action["STATE_CHANGED"] = "stateChanged";
+})(exports.Action || (exports.Action = {}));
+
+/**
+ * Essa classe representa uma interpretação do padrão de projetos Flux.
+ * No padrão Flux os dados da aplicação são chamados de "estado" e existem
+ * algumas regras para gerenciamento/manipulação desse estado:
+ *
+ *  1 - O estado é imutável.
+ *  2 - Toda modificação de estado é representada por uma "ação".
+ *  3 - Quando "ações" acontecem a "store" cria um novo estado e notifica a todos interessados.
+ *
+ * Nessa interpretação desse design pattern, o StateManager faz o papel da store,
+ * notificando os manipuladores de estado (handlers), que são responsáveis por pedaços
+ * do estado (slices).
+ *
+ * O StateManager mantém dois tipos de estados: "Histórico" e "Não Histórico". No estado
+ * "Histórico", sempre que uma alteração de estado acontece, o estado anterior é guardado em
+ * uma pilha, o que permite que possamos voltar no tempo, desfazendo algumas ações
+ */
+class StateManager {
+    constructor(reducers) {
+        this._past = [];
+        this._future = [];
+        this._present = {};
+        this._nonHist = {};
+        this._histClean = false;
+        this._reducers = reducers;
+    }
+    process(action) {
+        const oldPresent = this._present;
+        let hasHistChange = false;
+        this._histClean = false;
+        this._reducers.forEach(reducer => {
+            const sliceName = reducer.sliceName;
+            const isHistoric = this.isHistoric(sliceName);
+            const oldSlice = this.getSlice(sliceName, isHistoric);
+            const newSlice = reducer.reduce(this, oldSlice, action);
+            if (newSlice !== oldSlice) {
+                this.updateSlice(sliceName, newSlice, isHistoric);
+                hasHistChange || (hasHistChange = isHistoric);
+            }
+        });
+        if (hasHistChange && !this._histClean) {
+            this._past.push(oldPresent);
+            this._future = [];
+            document.dispatchEvent(new CustomEvent("undoableAction", { detail: this }));
+        }
+    }
+    select(sliceName, selector) {
+        const isHistoric = this.isHistoric(sliceName);
+        return selector(this.getSlice(sliceName, isHistoric));
+    }
+    isHistoric(slice) {
+        return slice.startsWith("hist::");
+    }
+    updateSlice(name, slice, isHistoric) {
+        if (isHistoric) {
+            this._present = Object.assign(Object.assign({}, this._present), { [name]: slice });
+            if (slice === undefined) {
+                delete this._present[name];
+            }
+        }
+        else {
+            this._nonHist = Object.assign(Object.assign({}, this._nonHist), { [name]: slice });
+            if (slice === undefined) {
+                delete this._nonHist[name];
+            }
+        }
+    }
+    getSlice(name, isHistoric) {
+        return isHistoric ? this._present[name] : this._nonHist[name];
+    }
+    canUndo() {
+        return this._past.length > 0;
+    }
+    canRedo() {
+        return this._future.length > 0;
+    }
+    undo() {
+        if (this.canUndo()) {
+            this._future.push(this._present);
+            this._present = this._past.pop();
+        }
+    }
+    redo() {
+        if (this.canRedo()) {
+            this._past.push(this._present);
+            this._present = this._future.pop();
+        }
+    }
+    clearUndo() {
+        this._histClean = true;
+        this._past = [];
+        this._future = [];
+    }
+    persist() {
+    }
+}
+
+class ErrorException extends Error {
+    constructor(title, message, errorCode = "") {
+        super(message);
+        this.title = title;
+        this.message = message;
+        this.errorCode = errorCode;
+    }
+}
+
+class WaitingChangeException extends Error {
+    constructor(title, message) {
+        super(message);
+        this.title = title;
+        this.message = message;
+    }
+}
+
+class AddedRecordsReducerImpl {
+    constructor() {
+        this.sliceName = "hist::addedRecords";
+    }
+    reduce(_stateManager, currentState, action) {
+        switch (action.type) {
+            case exports.Action.RECORDS_ADDED:
+            case exports.Action.RECORDS_COPIED:
+                return (currentState || []).concat(action.payload);
+            case exports.Action.DATA_SAVED:
+            case exports.Action.EDITION_CANCELED:
+                return undefined;
+        }
+        return currentState;
+    }
+}
+const AddedRecordsReducer = new AddedRecordsReducerImpl();
+const getAddedRecords = (stateManager) => {
+    return stateManager.select(AddedRecordsReducer.sliceName, (state) => state);
+};
+const prepareAddedRecordId = (stateManager, source) => {
+    let index = (getAddedRecords(stateManager) || []).length;
+    return source.map(item => { return Object.assign(Object.assign({}, item), { __record__id__: "NEW_" + (index++) }); });
+};
+const prepareCopiedRecord = (stateManager, source) => {
+    let index = (getAddedRecords(stateManager) || []).length;
+    return source.map(item => { return Object.assign(Object.assign({}, item), { __record__id__: "NEW_" + (index++), __record__source__id__: item.__record__id__, __copy__: true }); });
+};
+
+class RemovedRecordsReducerImpl {
+    constructor() {
+        this.sliceName = "hist::removedRecords";
+    }
+    reduce(_stateManager, currentState, action) {
+        switch (action.type) {
+            case exports.Action.RECORDS_REMOVED:
+                const { records, buffered } = action.payload;
+                if (buffered) {
+                    return (currentState || []).concat(records);
+                }
+                return currentState;
+            case exports.Action.EDITION_CANCELED:
+            case exports.Action.DATA_SAVED:
+                return undefined;
+        }
+        return currentState;
+    }
+}
+const RemovedRecordsReducer = new RemovedRecordsReducerImpl();
+const getRemovedRecords = (stateManager) => {
+    return stateManager.select(RemovedRecordsReducer.sliceName, (state) => state);
+};
+
+class RecordsReducerImpl {
+    constructor() {
+        this.sliceName = "records";
+    }
+    reduce(stateManager, currentState, action) {
+        switch (action.type) {
+            case exports.Action.DATA_LOADED:
+                return action.payload ? action.payload.records : undefined;
+            case exports.Action.RECORDS_REMOVED:
+                const { records, buffered } = action.payload;
+                if (!buffered) {
+                    return currentState.filter(r => !records.includes(r.__record__id__));
+                }
+                return currentState;
+            case exports.Action.DATA_SAVED:
+                const recordsMap = new Map();
+                const currentRecords = getRecords(stateManager);
+                if (currentRecords) {
+                    const removed = getRemovedRecords(stateManager) || [];
+                    currentRecords.forEach(r => {
+                        if (!removed.includes(r.__record__id__)) {
+                            recordsMap.set(r.__record__id__, r);
+                        }
+                    });
+                }
+                const newRecords = [];
+                const savedRecords = action.payload.records;
+                savedRecords.forEach(sr => {
+                    const recordId = sr.__old__id__ || sr.__record__id__;
+                    const newRecord = Object.assign({}, sr);
+                    delete newRecord["__old__id__"];
+                    if (recordsMap.has(recordId)) {
+                        recordsMap.set(recordId, newRecord);
+                    }
+                    else {
+                        newRecords.push(newRecord);
+                    }
+                });
+                return newRecords.concat(Array.from(recordsMap.values()));
+        }
+        return currentState;
+    }
+}
+const RecordsReducer = new RecordsReducerImpl();
+const getRecords = (stateManager) => {
+    return stateManager.select(RecordsReducer.sliceName, (state) => state);
+};
+
+class CurrentRecordsReducerImpl {
+    constructor() {
+        this.sliceName = "currentRecords";
+    }
+    reduce(stateManager) {
+        let records = getRecords(stateManager);
+        const added = getAddedRecords(stateManager);
+        if (!records && !added) {
+            return undefined;
+        }
+        if (added) {
+            records = (added || []).concat(records || []);
+        }
+        const removedRecords = getRemovedRecords(stateManager);
+        if (removedRecords) {
+            records = records.filter(r => !removedRecords.includes(r.__record__id__));
+        }
+        const changes = getChanges(stateManager);
+        return new Map(records.map(r => {
+            const recordId = r.__record__id__;
+            const record = Object.assign(Object.assign({}, r), changes === null || changes === void 0 ? void 0 : changes.get(recordId));
+            return [recordId, record];
+        }));
+    }
+}
+const CurrentRecordsReducer = new CurrentRecordsReducerImpl();
+const getCurrentRecords = (stateManager) => {
+    return stateManager.select(CurrentRecordsReducer.sliceName, (state) => state);
+};
+const getModifiedRecords = (stateManager) => {
+    const currentRecords = getCurrentRecords(stateManager);
+    if (!currentRecords) {
+        return undefined;
+    }
+    const changes = getChanges(stateManager);
+    const added = getAddedRecords(stateManager);
+    if (!changes && !added) {
+        return undefined;
+    }
+    let modifiedIDs = changes ? Array.from(changes.keys()) : [];
+    if (added) {
+        modifiedIDs = modifiedIDs.concat(added.map(r => r.__record__id__));
+    }
+    return Array.from(currentRecords.values()).filter(r => modifiedIDs.includes(r.__record__id__));
+};
+const getFieldValue = (stateManager, fieldName) => {
+    const selection = getSelection(stateManager);
+    if (selection && selection.length > 0) {
+        const currentRecords = getCurrentRecords(stateManager);
+        if (currentRecords) {
+            const record = currentRecords.get(selection[0]);
+            return record ? record[fieldName] : undefined;
+        }
+    }
+    return undefined;
+};
+
+class SelectionReducerImpl {
+    constructor() {
+        this.sliceName = "hist::selection";
+    }
+    reduce(stateManager, currentState, action) {
+        switch (action.type) {
+            case exports.Action.RECORDS_ADDED:
+            case exports.Action.RECORDS_COPIED:
+                return { currentSelection: action.payload.map((r) => r.__record__id__), lastSelection: currentState === null || currentState === void 0 ? void 0 : currentState.currentSelection };
+            case exports.Action.DATA_SAVED:
+                return { currentSelection: updateSavedIds(stateManager, action.payload.records) };
+            case exports.Action.RECORDS_REMOVED:
+                const removed = action.payload.records;
+                if (currentState && removed) {
+                    const currentSelection = currentState.currentSelection;
+                    const record = currentSelection.filter(recordId => !removed.includes(recordId));
+                    if (record.length === 0) {
+                        const currentRecords = getCurrentRecords(stateManager);
+                        let removedIndex = action.payload.removedIndex.slice(-1)[0];
+                        let currentIndex = 0;
+                        if (removedIndex >= currentRecords.size - 1) {
+                            removedIndex--;
+                        }
+                        else {
+                            removedIndex++;
+                        }
+                        currentRecords.forEach((value, key) => {
+                            if (currentIndex === removedIndex) {
+                                record.push(key);
+                            }
+                            currentIndex++;
+                        });
+                    }
+                    return { currentSelection: record };
+                }
+                return currentState;
+            case exports.Action.NEXT_SELECTED:
+            case exports.Action.PREVIOUS_SELECTED:
+                const currentRecords = getCurrentRecords(stateManager);
+                const currentSelection = currentState === null || currentState === void 0 ? void 0 : currentState.currentSelection;
+                if (currentRecords && currentRecords.size > 0) {
+                    let index;
+                    if (!currentState || currentSelection.length === 0) {
+                        index = action.type === exports.Action.PREVIOUS_SELECTED ? 0 : Math.min(1, currentRecords.size);
+                    }
+                    else {
+                        index = getItemIndex(currentSelection[0], currentRecords) + (action.type === exports.Action.PREVIOUS_SELECTED ? -1 : 1);
+                    }
+                    if (index < currentRecords.size && index >= 0) {
+                        return { currentSelection: [Array.from(currentRecords.values())[index].__record__id__] };
+                    }
+                }
+                return undefined;
+            case exports.Action.SELECTION_CHANGED:
+                const { type, selection: selectionSource } = action.payload;
+                if (selectionSource && type === "index") {
+                    const currentRecords = getCurrentRecords(stateManager);
+                    if (currentRecords) {
+                        const records = Array.from(currentRecords.values());
+                        const selectionById = [];
+                        selectionSource.forEach((i) => {
+                            if (i >= 0 && i < currentRecords.size) {
+                                selectionById.push(records[i].__record__id__);
+                            }
+                        });
+                        return { currentSelection: selectionById };
+                    }
+                }
+                return { currentSelection: selectionSource };
+            case exports.Action.EDITION_CANCELED:
+                if (currentState === null || currentState === void 0 ? void 0 : currentState.lastSelection) {
+                    return { currentSelection: currentState.lastSelection };
+                }
+        }
+        return currentState;
+    }
+}
+const SelectionReducer = new SelectionReducerImpl();
+const getSelection = (stateManager) => {
+    let selection = getCurrentSelection(stateManager);
+    if (!selection || selection.length === 0) {
+        return [];
+    }
+    return selection;
+};
+const hasNext = (stateManager) => {
+    const records = getCurrentRecords(stateManager);
+    if (records) {
+        const selection = getCurrentSelection(stateManager);
+        if (!selection || selection.length === 0) {
+            return records.size > 0;
+        }
+        return records.size > (getItemIndex(selection[0], records) + 1);
+    }
+    return false;
+};
+const hasPrevious = (stateManager) => {
+    const records = getCurrentRecords(stateManager);
+    if (records) {
+        const selection = getCurrentSelection(stateManager);
+        if (!selection || selection.length === 0) {
+            return false;
+        }
+        return getItemIndex(selection[0], records) > 0;
+    }
+    return false;
+};
+function getItemIndex(key, map) {
+    return Array.from(map.keys()).indexOf(key);
+}
+function updateSavedIds(stateManager, savedRecords) {
+    const currentSelection = getSelection(stateManager);
+    if (currentSelection) {
+        const newSelection = [];
+        currentSelection.forEach(id => {
+            const record = savedRecords.find(r => r.__old__id__ === id);
+            if (record) {
+                newSelection.push(record.__record__id__);
+            }
+            else {
+                newSelection.push(id);
+            }
+        });
+        return newSelection;
+    }
+    return currentSelection;
+}
+function getCurrentSelection(stateManager) {
+    var _a;
+    return (_a = stateManager.select(SelectionReducer.sliceName, (state) => state)) === null || _a === void 0 ? void 0 : _a.currentSelection;
+}
+
+class WaitingCheangesReducerImpl {
+    constructor() {
+        this.sliceName = "waitingChanges";
+    }
+    reduce(stateManager, currentState, action) {
+        let newState;
+        switch (action.type) {
+            case exports.Action.CHANGING_DATA:
+                newState = new Map(currentState);
+                Object.entries(action.payload).forEach(([key, value]) => {
+                    newState.set(key, value);
+                });
+                return newState;
+            case exports.Action.WAITING_CHANGE_CANCELED:
+                newState = new Map(currentState);
+                newState.delete(action.payload.fieldName);
+                return newState.size === 0 ? undefined : newState;
+            case exports.Action.DATA_CHANGED:
+                newState = new Map(currentState);
+                Object.entries(action.payload).forEach(([key]) => {
+                    newState.delete(key);
+                });
+                return newState.size === 0 ? undefined : newState;
+            case exports.Action.DATA_SAVED:
+            case exports.Action.EDITION_CANCELED:
+                return undefined;
+        }
+        return currentState;
+    }
+}
+const WaitingChangesReducer = new WaitingCheangesReducerImpl();
+const getWaitingChanges = (stateManager) => {
+    return stateManager.select(WaitingChangesReducer.sliceName, (state) => state);
+};
+const isWaiting = (stateManager, fieldName) => {
+    const allWC = getWaitingChanges(stateManager);
+    return allWC ? allWC.has(fieldName) : false;
+};
+const getBlockingWaitingChanges = (stateManager) => {
+    const allWC = getWaitingChanges(stateManager);
+    if (allWC) {
+        return new Map(Array.from(allWC.entries())
+            .filter(entry => entry[1].blocking)
+            .map(entry => [entry[0], entry[1]]));
+    }
+};
+const getWaitingChangePromisses = (stateManager) => {
+    const allWC = getWaitingChanges(stateManager);
+    if (allWC) {
+        return Array.from(allWC.values())
+            .filter(wc => !wc.blocking)
+            .map(wc => wc.promise);
+    }
+};
+
+class ChangesReducerImpl {
+    constructor() {
+        this.sliceName = "hist::changes";
+    }
+    reduce(stateManager, currentState, action) {
+        switch (action.type) {
+            case exports.Action.RECORDS_COPIED:
+                const records = action.payload;
+                const changes = new Map(getChanges(stateManager));
+                records.forEach(r => {
+                    const rChanges = Object.assign(Object.assign({}, changes.get(r.__record__id__)), r);
+                    delete rChanges.__old__id__;
+                    delete rChanges.__record__id__;
+                    delete rChanges.__parent__record__id__;
+                    delete rChanges.__record__source__id__;
+                    delete rChanges.__copy__;
+                    changes.set(r.__record__id__, rChanges);
+                });
+                return changes;
+            case exports.Action.DATA_CHANGED:
+                const selection = action.payload.records || getSelection(stateManager);
+                if (selection) {
+                    const newState = new Map(currentState);
+                    selection.forEach(recordId => {
+                        const newChanges = Object.assign(Object.assign({}, newState.get(recordId)), action.payload);
+                        delete newChanges.records;
+                        newState.set(recordId, newChanges);
+                    });
+                    return newState;
+                }
+                return currentState;
+            case exports.Action.DATA_SAVED:
+            case exports.Action.EDITION_CANCELED:
+                return undefined;
+        }
+        return currentState;
+    }
+}
+const ChangesReducer = new ChangesReducerImpl();
+const getChanges = (stateManager) => {
+    return stateManager.select(ChangesReducer.sliceName, (state) => state);
+};
+const isDirty = (stateManager) => {
+    if (getAddedRecords(stateManager) !== undefined) {
+        return true;
+    }
+    if (getRemovedRecords(stateManager) !== undefined) {
+        return true;
+    }
+    return hasDirtyRecords(stateManager);
+};
+const hasDirtyRecords = (stateManager) => {
+    if (getWaitingChanges(stateManager) !== undefined) {
+        return true;
+    }
+    return getChanges(stateManager) !== undefined;
+};
+const getChangesToSave = (dataUnit, stateManager) => {
+    const result = [];
+    const changes = getChanges(stateManager);
+    const records = getRecords(stateManager);
+    records === null || records === void 0 ? void 0 : records.forEach(r => {
+        if (changes) {
+            const c = changes.get(r.__record__id__);
+            if (c) {
+                result.push(new Change(dataUnit, r, c, exports.ChangeOperation.UPDATE));
+            }
+        }
+    });
+    const addedRecords = getAddedRecords(stateManager);
+    if (addedRecords) {
+        addedRecords.forEach(r => {
+            const operation = r.__copy__ ? exports.ChangeOperation.COPY : exports.ChangeOperation.INSERT;
+            result.push(new Change(dataUnit, r, changes === null || changes === void 0 ? void 0 : changes.get(r.__record__id__), operation, r.__record__source__id__));
+        });
+    }
+    const removedRecords = getRemovedRecords(stateManager);
+    const recordsById = {};
+    records === null || records === void 0 ? void 0 : records.forEach(r => recordsById[r.__record__id__] = r);
+    if (removedRecords) {
+        removedRecords.forEach(id => {
+            result.push(new Change(dataUnit, recordsById[id], undefined, exports.ChangeOperation.DELETE));
+        });
+    }
+    return result;
+};
+
+class LoadingControlReducerImpl {
+    constructor() {
+        this.sliceName = "loadingControl";
+    }
+    reduce(stateManager, currentState, action) {
+        var _a;
+        switch (action.type) {
+            case exports.Action.LOADING_DATA:
+                return Object.assign(Object.assign({}, currentState), { lastRequest: action.payload });
+            case exports.Action.DATA_LOADED:
+                return Object.assign(Object.assign({}, currentState), { paginationInfo: (_a = action.payload) === null || _a === void 0 ? void 0 : _a.paginationInfo });
+        }
+        return currentState;
+    }
+}
+const LoadingControlReducer = new LoadingControlReducerImpl();
+const getPaginationInfo = (stateManager) => {
+    const state = stateManager.select(LoadingControlReducer.sliceName, (state) => state);
+    return state ? state.paginationInfo : undefined;
+};
+const getCurrentRequest = (stateManager) => {
+    const state = stateManager.select(LoadingControlReducer.sliceName, (state) => state);
+    return state ? state.lastRequest : undefined;
+};
+const getCurrentPage = (stateManager) => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    return paginationInfo ? paginationInfo.currentPage : 0;
+};
+const getLastPage = (stateManager, pageSize) => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    return paginationInfo ? Math.ceil(paginationInfo.total / pageSize) : 0;
+};
+const hasMorePages = (stateManager) => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    if (paginationInfo && paginationInfo.hasMore) {
+        return true;
+    }
+    return false;
+};
+const hasPreviousPages = (stateManager) => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    return paginationInfo ? paginationInfo.currentPage > 0 : false;
+};
+
+class UnitMetadataReducerImpl {
+    constructor() {
+        this.sliceName = "unitMetadata";
+    }
+    reduce(_stateManager, currentState, action) {
+        if (action.type === exports.Action.METADATA_LOADED) {
+            return action.payload;
+        }
+        return currentState;
+    }
+}
+const UnitMetadataReducer = new UnitMetadataReducerImpl();
+const getMetadata = (stateManager) => {
+    return stateManager.select(UnitMetadataReducer.sliceName, (state) => state);
+};
+const getField = (stateManager, fieldName) => {
+    const md = getMetadata(stateManager);
+    return md ? md.fields.find(fmd => fmd.name === fieldName) : undefined;
+};
+
+class HistReducerImpl {
+    constructor() {
+        this.sliceName = "";
+    }
+    reduce(stateManager, _currentState, action) {
+        switch (action.type) {
+            case exports.Action.DATA_SAVED:
+            case exports.Action.EDITION_CANCELED:
+                stateManager.clearUndo();
+                break;
+            case exports.Action.CHANGE_UNDONE:
+                stateManager.undo();
+                break;
+            case exports.Action.CHANGE_REDONE:
+                stateManager.redo();
+                break;
+        }
+    }
+}
+const HistReducer = new HistReducerImpl();
+const canUndo = (stateManager) => {
+    return stateManager.canUndo();
+};
+const canRedo = (stateManager) => {
+    return stateManager.canRedo();
+};
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+class DataUnit {
+    constructor(name) {
+        this._name = name;
+        this._pageSize = 0;
+        this._stateManager = new StateManager([
+            HistReducer,
+            UnitMetadataReducer,
+            LoadingControlReducer,
+            RecordsReducer,
+            RemovedRecordsReducer,
+            AddedRecordsReducer,
+            SelectionReducer,
+            ChangesReducer,
+            WaitingChangesReducer,
+            CurrentRecordsReducer
+        ]);
+        this._observers = [];
+        this._filterProviders = new Map();
+        this._sortingProvider = undefined;
+        this._interceptors = [];
+    }
+    get name() {
+        return this._name;
+    }
+    // Métodos privados
+    validateAndTypeValue(fieldName, newValue) {
+        const descriptor = this.getField(fieldName);
+        return descriptor ? convertType(descriptor.dataType, newValue) : newValue;
+    }
+    getFilters() {
+        let filters = undefined;
+        this._filterProviders.forEach(p => {
+            const f = p.getFilter(this.name);
+            if (f) {
+                filters = (filters || []).concat(f);
+            }
+        });
+        return filters;
+    }
+    getSort() {
+        return this._sortingProvider ? this._sortingProvider.getSort(this._name) : undefined;
+    }
+    getFielterProviderKey(provider) {
+        if (provider.getKey) {
+            return provider.getKey();
+        }
+        return StringUtils.hashCode(provider.getFilter.toString());
+    }
+    executeLoadData(request, executionCtx) {
+        return new Promise((resolve, fail) => __awaiter(this, void 0, void 0, function* () {
+            if (yield this.dispatchAction(exports.Action.LOADING_DATA, request, executionCtx)) {
+                if (this.dataLoader) {
+                    this.dataLoader(this, request).then(response => {
+                        this.dispatchAction(exports.Action.DATA_LOADED, response, executionCtx);
+                        resolve(response);
+                    }).catch(error => {
+                        const { errorCode } = error;
+                        fail(new ErrorException("Problema carregando registros", error, errorCode));
+                    });
+                }
+            }
+        }));
+    }
+    // Loaders
+    loadMetadata(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.dispatchAction(exports.Action.LOADING_METADATA, undefined, executionCtx)) {
+                return new Promise((resolve, fail) => {
+                    if (this.metadataLoader) {
+                        this.metadataLoader(this).then(metadata => {
+                            this.metadata = metadata;
+                            resolve(this.metadata);
+                        }).catch(error => {
+                            const { errorCode } = error;
+                            fail(new ErrorException("Problema carregando metadados", error, errorCode));
+                        });
+                    }
+                });
+            }
+        });
+    }
+    loadData(quickFilter, executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loadDataRequest = {
+                quickFilter,
+                filters: this.getFilters(),
+                sort: this.getSort()
+            };
+            if (this._pageSize > 0) {
+                loadDataRequest.limit = this._pageSize;
+                loadDataRequest.offset = 0;
+            }
+            return this.executeLoadData(loadDataRequest, executionCtx);
+        });
+    }
+    gotoPage(page, executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let request = getCurrentRequest(this._stateManager);
+            if (!request) {
+                request = {
+                    filters: this.getFilters(),
+                    sort: this.getSort()
+                };
+            }
+            if (page >= 0 && page <= getLastPage(this._stateManager, this._pageSize)) {
+                return this.executeLoadData(Object.assign(Object.assign({}, request), { limit: this._pageSize, offset: page * this._pageSize }), executionCtx);
+            }
+        });
+    }
+    nextPage(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.gotoPage(getCurrentPage(this._stateManager) + 1, executionCtx);
+        });
+    }
+    previousPage(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.gotoPage(getCurrentPage(this._stateManager) - 1, executionCtx);
+        });
+    }
+    saveData(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const blockingWaitingChanges = getBlockingWaitingChanges(this._stateManager);
+            if (blockingWaitingChanges && blockingWaitingChanges.size > 0) {
+                const [field, waitingChange] = blockingWaitingChanges.entries().next().value;
+                return Promise.reject(new WaitingChangeException("Aguardando alteração de campo", waitingChange.waitmessage));
+            }
+            else {
+                if (isDirty(this._stateManager)) {
+                    if (yield this.dispatchAction(exports.Action.SAVING_DATA, undefined, executionCtx)) {
+                        const promisses = getWaitingChangePromisses(this._stateManager);
+                        return new Promise((resolve, fail) => {
+                            Promise.all(promisses || []).then(() => {
+                                if (this.saveLoader) {
+                                    const changes = getChangesToSave(this._name, this._stateManager);
+                                    this.saveLoader(this, changes).then(records => {
+                                        this.dispatchAction(exports.Action.DATA_SAVED, { changes, records }, executionCtx);
+                                        resolve();
+                                    }).catch(cause => {
+                                        const { errorCode } = cause;
+                                        fail(new ErrorException("Erro salvando alterações", cause, errorCode));
+                                    });
+                                }
+                                else {
+                                    resolve();
+                                }
+                            });
+                        });
+                    }
+                }
+            }
+            return Promise.resolve();
+        });
+    }
+    removeSelectedRecords(buffered = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const selection = getSelection(this._stateManager);
+            if (selection) {
+                const records = this.getSelectedRecords() || [];
+                return this.removeRecords(selection, records, buffered);
+            }
+            return Promise.resolve(selection);
+        });
+    }
+    removeRecords(recordIds, cachedRecords, buffered = false, executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (recordIds) {
+                if (buffered || !this.removeLoader) {
+                    this.dispatchAction(exports.Action.RECORDS_REMOVED, { records: recordIds, cachedRecords, buffered: true }, executionCtx);
+                }
+                else {
+                    if (yield this.dispatchAction(exports.Action.REMOVING_RECORDS, undefined, executionCtx)) {
+                        return new Promise((resolve, fail) => {
+                            if (this.removeLoader) {
+                                this.removeLoader(this, recordIds).then(removedIds => {
+                                    let currentIndex = 0;
+                                    const removedIndex = [];
+                                    const currentRecords = getCurrentRecords(this._stateManager);
+                                    currentRecords.forEach((value, key) => {
+                                        if (removedIds.includes(key)) {
+                                            removedIndex.push(currentIndex);
+                                        }
+                                        currentIndex++;
+                                    });
+                                    this.dispatchAction(exports.Action.RECORDS_REMOVED, { records: removedIds, cachedRecords, removedIndex, buffered: false }, executionCtx);
+                                    resolve(removedIds);
+                                }).catch(error => {
+                                    const { errorCode } = error;
+                                    fail(new ErrorException("Problema removendo registros", error, errorCode));
+                                });
+                            }
+                        });
+                    }
+                }
+            }
+            return Promise.resolve(recordIds);
+        });
+    }
+    // API
+    valueFromString(fieldName, value) {
+        const descriptor = this.getField(fieldName);
+        return descriptor ? convertType(descriptor.dataType, value) : value;
+    }
+    valueToString(fieldName, value) {
+        const descriptor = this.getField(fieldName);
+        return toString(descriptor === null || descriptor === void 0 ? void 0 : descriptor.dataType, value);
+    }
+    addInterceptor(interceptor) {
+        this._interceptors.push(interceptor);
+    }
+    removeInterceptor(interceptor) {
+        this._interceptors = this._interceptors.filter(i => i !== interceptor);
+    }
+    addFilterProvider(provider) {
+        this._filterProviders.set(this.getFielterProviderKey(provider), provider);
+    }
+    getPaginationInfo() {
+        return getPaginationInfo(this._stateManager);
+    }
+    set sortingProvider(provider) {
+        this._sortingProvider = provider;
+    }
+    set metadata(md) {
+        this.dispatchAction(exports.Action.METADATA_LOADED, md, undefined);
+    }
+    get metadata() {
+        return getMetadata(this._stateManager);
+    }
+    set records(r) {
+        this.dispatchAction(exports.Action.DATA_LOADED, { records: this.records }, undefined);
+    }
+    get records() {
+        const records = getCurrentRecords(this._stateManager);
+        return records ? Array.from(records.values()) : [];
+    }
+    set pageSize(size) {
+        this._pageSize = size;
+    }
+    get pageSize() {
+        return this._pageSize;
+    }
+    getModifiedRecords() {
+        const modified = getModifiedRecords(this._stateManager);
+        return modified || [];
+    }
+    getField(fieldName) {
+        return getField(this._stateManager, fieldName);
+    }
+    addRecord(executionCtx) {
+        this.dispatchAction(exports.Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]), executionCtx);
+    }
+    copySelected(executionCtx) {
+        const selectedRecords = this.getSelectedRecords();
+        if (selectedRecords) {
+            this.dispatchAction(exports.Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords), executionCtx);
+        }
+    }
+    waitingForChange(fieldName) {
+        return isWaiting(this._stateManager, fieldName);
+    }
+    getFieldValue(fieldName) {
+        return getFieldValue(this._stateManager, fieldName);
+    }
+    setFieldValue(fieldName, newValue, records) {
+        const typedValue = this.validateAndTypeValue(fieldName, newValue);
+        const currentValue = this.getFieldValue(fieldName);
+        if (currentValue !== typedValue) {
+            this.dispatchAction(exports.Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined);
+        }
+    }
+    startChange(fieldName, waitingChange) {
+        this.dispatchAction(exports.Action.CHANGING_DATA, { [fieldName]: waitingChange }, undefined);
+    }
+    cancelWaitingChange(fieldName) {
+        this.dispatchAction(exports.Action.WAITING_CHANGE_CANCELED, { fieldName }, undefined);
+    }
+    getSelection() {
+        return getSelection(this._stateManager);
+    }
+    setSelection(selection, executionCtx) {
+        this.dispatchAction(exports.Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx);
+    }
+    selectFirst(executionCtx) {
+        if (this.records.length > 0) {
+            this.setSelectionByIndex([0], executionCtx);
+        }
+    }
+    selectLast(executionCtx) {
+        if (this.records.length > 0) {
+            this.setSelectionByIndex([this.records.length - 1], executionCtx);
+        }
+    }
+    setSelectionByIndex(selection, executionCtx) {
+        this.dispatchAction(exports.Action.SELECTION_CHANGED, { type: "index", selection }, executionCtx);
+    }
+    getSelectedRecords() {
+        const selection = this.getSelection();
+        if (selection) {
+            const currentRecords = this.records;
+            return currentRecords === null || currentRecords === void 0 ? void 0 : currentRecords.filter(r => selection.includes(r.__record__id__));
+        }
+    }
+    nextRecord(executionCtx) {
+        if (!hasNext(this._stateManager)) {
+            if (hasMorePages(this._stateManager)) {
+                this.nextPage({
+                    before: act => {
+                        if (executionCtx && executionCtx.before) {
+                            act = executionCtx.before(act);
+                        }
+                        return act;
+                    },
+                    after: act => {
+                        this.selectFirst(executionCtx);
+                    }
+                });
+            }
+        }
+        else {
+            this.dispatchAction(exports.Action.NEXT_SELECTED, undefined, executionCtx);
+        }
+    }
+    previousRecord(executionCtx) {
+        if (!hasPrevious(this._stateManager)) {
+            if (hasPreviousPages(this._stateManager)) {
+                this.previousPage({
+                    before: act => {
+                        if (executionCtx && executionCtx.before) {
+                            act = executionCtx.before(act);
+                        }
+                        return act;
+                    },
+                    after: act => {
+                        this.selectLast(executionCtx);
+                    }
+                });
+            }
+        }
+        else {
+            this.dispatchAction(exports.Action.PREVIOUS_SELECTED, undefined, executionCtx);
+        }
+    }
+    cancelEdition(executionCtx) {
+        this.dispatchAction(exports.Action.EDITION_CANCELED, undefined, executionCtx);
+    }
+    isDirty() {
+        return isDirty(this._stateManager);
+    }
+    hasDirtyRecords() {
+        return hasDirtyRecords(this._stateManager);
+    }
+    hasNext() {
+        let result = hasNext(this._stateManager);
+        if (!result) {
+            result = hasMorePages(this._stateManager);
+        }
+        return result;
+    }
+    hasPrevious() {
+        let result = hasPrevious(this._stateManager);
+        if (!result) {
+            result = hasPreviousPages(this._stateManager);
+        }
+        return result;
+    }
+    canUndo() {
+        return canUndo(this._stateManager);
+    }
+    canRedo() {
+        return canRedo(this._stateManager);
+    }
+    undo(executionCtx) {
+        this.dispatchAction(exports.Action.CHANGE_UNDONE, undefined, executionCtx);
+    }
+    redo(executionCtx) {
+        this.dispatchAction(exports.Action.CHANGE_REDONE, undefined, executionCtx);
+    }
+    toString() {
+        return this.name;
+    }
+    // Actions / State manager
+    dispatchAction(actionType, payload, executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                let action = new DataUnitAction(actionType, payload);
+                if (executionCtx && executionCtx.before) {
+                    action = executionCtx.before(action);
+                }
+                if (action && this._interceptors && this._interceptors.length > 0) {
+                    action = yield this.intercept(action, this._interceptors.values());
+                }
+                if (action) {
+                    this.doDispatchAction(action);
+                    if (executionCtx && executionCtx.after) {
+                        executionCtx.after(action);
+                    }
+                    resolve(true);
+                }
+                else {
+                    resolve(false);
+                }
+            }));
+        });
+    }
+    intercept(action, interceptors) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                let ite;
+                while (action && !(ite = interceptors.next()).done) {
+                    action = yield ite.value.interceptAction(action);
+                }
+                resolve(action);
+            }));
+        });
+    }
+    doDispatchAction(action) {
+        this._stateManager.process(action);
+        this._observers.forEach(f => {
+            /*
+            if some observer throws exceptions,
+            should be continued
+            */
+            try {
+                f(action);
+            }
+            catch (e) {
+                console.warn("[DataUnit] error while call observer", e);
+            }
+        });
+    }
+    subscribe(observer) {
+        this._observers.push(observer);
+    }
+    unsubscribe(observer) {
+        this._observers = this._observers.filter(f => f !== observer);
+    }
+}
+exports.ChangeOperation = void 0;
+(function (ChangeOperation) {
+    ChangeOperation["INSERT"] = "INSERT";
+    ChangeOperation["COPY"] = "COPY";
+    ChangeOperation["UPDATE"] = "UPDATE";
+    ChangeOperation["DELETE"] = "DELETE";
+})(exports.ChangeOperation || (exports.ChangeOperation = {}));
+class Change {
+    constructor(dataUnit, record, updates, operation, sourceId) {
+        this.dataUnit = dataUnit;
+        this.record = record;
+        this.sourceId = sourceId;
+        this.updatingFields = updates;
+        this._operation = operation;
+    }
+    get operation() {
+        return this._operation.toString();
+    }
+    isInsert() {
+        return this._operation === exports.ChangeOperation.INSERT;
+    }
+    isCopy() {
+        return this._operation === exports.ChangeOperation.COPY;
+    }
+    isDelete() {
+        return this._operation === exports.ChangeOperation.DELETE;
+    }
+    isUpdate() {
+        return this._operation === exports.ChangeOperation.UPDATE;
+    }
+}
+
+var SortMode;
+(function (SortMode) {
+    SortMode["ASC"] = "ASC";
+    SortMode["DESC"] = "DESC";
+})(SortMode || (SortMode = {}));
+exports.DependencyType = void 0;
+(function (DependencyType) {
+    DependencyType["SEARCHING"] = "SEARCHING";
+    DependencyType["REQUIREMENT"] = "REQUIREMENT";
+    DependencyType["VISIBILITY"] = "REQUIREMENT";
+})(exports.DependencyType || (exports.DependencyType = {}));
+exports.UserInterface = void 0;
+(function (UserInterface) {
+    UserInterface["FILE"] = "FILE";
+    UserInterface["IMAGE"] = "IMAGE";
+    UserInterface["DATE"] = "DATE";
+    UserInterface["DATETIME"] = "DATETIME";
+    UserInterface["TIME"] = "TIME";
+    UserInterface["ELAPSEDTIME"] = "ELAPSEDTIME";
+    UserInterface["CHECKBOX"] = "CHECKBOX";
+    UserInterface["SWITCH"] = "SWITCH";
+    UserInterface["OPTIONSELECTOR"] = "OPTIONSELECTOR";
+    UserInterface["DECIMALNUMBER"] = "DECIMALNUMBER";
+    UserInterface["INTEGERNUMBER"] = "INTEGERNUMBER";
+    UserInterface["SEARCH"] = "SEARCH";
+    UserInterface["SHORTTEXT"] = "SHORTTEXT";
+    UserInterface["PASSWORD"] = "PASSWORD";
+    UserInterface["MASKEDTEXT"] = "MASKEDTEXT";
+    UserInterface["LONGTEXT"] = "LONGTEXT";
+    UserInterface["HTML"] = "HTML";
+})(exports.UserInterface || (exports.UserInterface = {}));
+
+class ApplicationContext {
+    static getContextValue(key) {
+        return ApplicationContext.getCtx()[key];
+    }
+    static setContextValue(key, value) {
+        ApplicationContext.getCtx()[key] = value;
+    }
+    static getCtx() {
+        let ctx = window.___snkcore___ctx___;
+        if (!ctx) {
+            ctx = {};
+            window.___snkcore___ctx___ = ctx;
+        }
+        return ctx;
+    }
+}
+
+class ReadyUtil {
+    clean() {
+        this.resolve = undefined;
+        this.promise = undefined;
+    }
+    start() {
+        if (!this.promise)
+            this.promise = new Promise((accept) => {
+                this.resolve = () => accept(true);
+            });
+    }
+    end() {
+        this.resolve && this.resolve();
+    }
+    whenReady() {
+        this.start();
+        return new Promise((accept) => {
+            this.promise.then(() => {
+                accept(true);
+                this.clean();
+            });
+        });
+    }
+}
+
+class ObjectUtils {
+    static copy(data) {
+        return this.stringToObject(this.objectToString(data));
+    }
+    static objectToString(data) {
+        return JSON.stringify(data);
+    }
+    static stringToObject(data) {
+        return JSON.parse(data);
+    }
+}
+
+class WarningException extends Error {
+    constructor(title, message, errorCode = "") {
+        super(message);
+        this.title = title;
+        this.message = message;
+        this.errorCode = errorCode;
+    }
+}
+
+class ErrorTracking {
+    static init() {
+        const rollbar = window.Rollbar;
+        if (rollbar) {
+            rollbar.configure({
+                checkIgnore: function (isUncaught, args, payload) {
+                    return args[1] ? ErrorTracking.isInternalException(args[1]) : false;
+                }
+            });
+        }
+    }
+    static isInternalException(error) {
+        return (error instanceof ErrorException || error instanceof WaitingChangeException || error instanceof WarningException);
+    }
+}
+
+exports.ApplicationContext = ApplicationContext;
+exports.ArrayUtils = ArrayUtils;
+exports.DataUnit = DataUnit;
+exports.DateUtils = DateUtils;
+exports.ErrorException = ErrorException;
+exports.ErrorTracking = ErrorTracking;
+exports.FloatingManager = FloatingManager;
+exports.ObjectUtils = ObjectUtils;
+exports.StringUtils = StringUtils;
+exports.WaitingChangeException = WaitingChangeException;
+exports.WarningException = WarningException;
+exports.toString = toString;