@sankhyalabs/sankhyablocks 1.3.31-beta.2 → 1.3.31-beta.20

package/dist/esm/index-e5b61043.js

@@ -0,0 +1,2384 @@
+/**
+ * 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;
+            }
+        });
+    }
+}
+
+var DataType;
+(function (DataType) {
+    DataType["NUMBER"] = "NUMBER";
+    DataType["DATE"] = "DATE";
+    DataType["TEXT"] = "TEXT";
+    DataType["BOOLEAN"] = "BOOLEAN";
+    DataType["OBJECT"] = "OBJECT";
+})(DataType || (DataType = {}));
+const convertType = (dataType, value) => {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (typeof value === "object" && dataType !== DataType.OBJECT && "value" in value) {
+        value = value.value;
+    }
+    switch (dataType) {
+        case DataType.NUMBER:
+            return value === "" || isNaN(value) ? null : Number(value);
+        case DataType.OBJECT:
+            return typeof value === "string" ? JSON.parse(value) : value;
+        case DataType.BOOLEAN:
+            if (typeof value == 'string') {
+                return Boolean(value === 'true');
+            }
+            return Boolean(value);
+        case 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 === DataType.OBJECT) {
+            return JSON.stringify(value);
+        }
+        else if (dataType === 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;
+    }
+}
+var Action;
+(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";
+})(Action || (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 Action.RECORDS_ADDED:
+            case Action.RECORDS_COPIED:
+                return (currentState || []).concat(action.payload);
+            case Action.DATA_SAVED:
+            case 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 Action.RECORDS_REMOVED:
+                const { records, buffered } = action.payload;
+                if (buffered) {
+                    return (currentState || []).concat(records);
+                }
+                return currentState;
+            case Action.EDITION_CANCELED:
+            case 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 Action.DATA_LOADED:
+                return action.payload ? action.payload.records : undefined;
+            case Action.RECORDS_REMOVED:
+                const { records, buffered } = action.payload;
+                if (!buffered) {
+                    return currentState.filter(r => !records.includes(r.__record__id__));
+                }
+                return currentState;
+            case 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 Action.RECORDS_ADDED:
+            case Action.RECORDS_COPIED:
+                return { currentSelection: action.payload.map((r) => r.__record__id__), lastSelection: currentState === null || currentState === void 0 ? void 0 : currentState.currentSelection };
+            case Action.DATA_SAVED:
+                return { currentSelection: updateSavedIds(stateManager, action.payload.records) };
+            case 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 Action.NEXT_SELECTED:
+            case 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 === Action.PREVIOUS_SELECTED ? 0 : Math.min(1, currentRecords.size);
+                    }
+                    else {
+                        index = getItemIndex(currentSelection[0], currentRecords) + (action.type === Action.PREVIOUS_SELECTED ? -1 : 1);
+                    }
+                    if (index < currentRecords.size && index >= 0) {
+                        return { currentSelection: [Array.from(currentRecords.values())[index].__record__id__] };
+                    }
+                }
+                return undefined;
+            case 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 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 Action.CHANGING_DATA:
+                newState = new Map(currentState);
+                Object.entries(action.payload).forEach(([key, value]) => {
+                    newState.set(key, value);
+                });
+                return newState;
+            case Action.WAITING_CHANGE_CANCELED:
+                newState = new Map(currentState);
+                newState.delete(action.payload.fieldName);
+                return newState.size === 0 ? undefined : newState;
+            case Action.DATA_CHANGED:
+                newState = new Map(currentState);
+                Object.entries(action.payload).forEach(([key]) => {
+                    newState.delete(key);
+                });
+                return newState.size === 0 ? undefined : newState;
+            case Action.DATA_SAVED:
+            case 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 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 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 Action.DATA_SAVED:
+            case 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, ChangeOperation.UPDATE));
+            }
+        }
+    });
+    const addedRecords = getAddedRecords(stateManager);
+    if (addedRecords) {
+        addedRecords.forEach(r => {
+            const operation = r.__copy__ ? ChangeOperation.COPY : 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, ChangeOperation.DELETE));
+        });
+    }
+    return result;
+};
+
+class LoadingControlReducerImpl {
+    constructor() {
+        this.sliceName = "loadingControl";
+    }
+    reduce(stateManager, currentState, action) {
+        var _a;
+        switch (action.type) {
+            case Action.LOADING_DATA:
+                return Object.assign(Object.assign({}, currentState), { lastRequest: action.payload });
+            case 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 === 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 Action.DATA_SAVED:
+            case Action.EDITION_CANCELED:
+                stateManager.clearUndo();
+                break;
+            case Action.CHANGE_UNDONE:
+                stateManager.undo();
+                break;
+            case 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(Action.LOADING_DATA, request, executionCtx)) {
+                if (this.dataLoader) {
+                    this.dataLoader(this, request).then(response => {
+                        this.dispatchAction(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(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(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(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(Action.RECORDS_REMOVED, { records: recordIds, cachedRecords, buffered: true }, executionCtx);
+                }
+                else {
+                    if (yield this.dispatchAction(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(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(Action.METADATA_LOADED, md, undefined);
+    }
+    get metadata() {
+        return getMetadata(this._stateManager);
+    }
+    set records(r) {
+        this.dispatchAction(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(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]), executionCtx);
+    }
+    copySelected(executionCtx) {
+        const selectedRecords = this.getSelectedRecords();
+        if (selectedRecords) {
+            this.dispatchAction(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(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined);
+        }
+    }
+    startChange(fieldName, waitingChange) {
+        this.dispatchAction(Action.CHANGING_DATA, { [fieldName]: waitingChange }, undefined);
+    }
+    cancelWaitingChange(fieldName) {
+        this.dispatchAction(Action.WAITING_CHANGE_CANCELED, { fieldName }, undefined);
+    }
+    getSelection() {
+        return getSelection(this._stateManager);
+    }
+    setSelection(selection, executionCtx) {
+        this.dispatchAction(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(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(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(Action.PREVIOUS_SELECTED, undefined, executionCtx);
+        }
+    }
+    cancelEdition(executionCtx) {
+        this.dispatchAction(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(Action.CHANGE_UNDONE, undefined, executionCtx);
+    }
+    redo(executionCtx) {
+        this.dispatchAction(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);
+    }
+}
+var ChangeOperation;
+(function (ChangeOperation) {
+    ChangeOperation["INSERT"] = "INSERT";
+    ChangeOperation["COPY"] = "COPY";
+    ChangeOperation["UPDATE"] = "UPDATE";
+    ChangeOperation["DELETE"] = "DELETE";
+})(ChangeOperation || (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 === ChangeOperation.INSERT;
+    }
+    isCopy() {
+        return this._operation === ChangeOperation.COPY;
+    }
+    isDelete() {
+        return this._operation === ChangeOperation.DELETE;
+    }
+    isUpdate() {
+        return this._operation === ChangeOperation.UPDATE;
+    }
+}
+
+var SortMode;
+(function (SortMode) {
+    SortMode["ASC"] = "ASC";
+    SortMode["DESC"] = "DESC";
+})(SortMode || (SortMode = {}));
+var DependencyType;
+(function (DependencyType) {
+    DependencyType["SEARCHING"] = "SEARCHING";
+    DependencyType["REQUIREMENT"] = "REQUIREMENT";
+    DependencyType["VISIBILITY"] = "REQUIREMENT";
+})(DependencyType || (DependencyType = {}));
+var UserInterface;
+(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";
+})(UserInterface || (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);
+    }
+}
+
+export { Action as A, ChangeOperation as C, DataUnit as D, ErrorException as E, FloatingManager as F, ObjectUtils as O, StringUtils as S, UserInterface as U, WarningException as W, ApplicationContext as a, DataType as b, DateUtils as c, WaitingChangeException as d, DependencyType as e, ErrorTracking as f, ArrayUtils as g, toString as t };