@sankhyalabs/sankhyablocks 1.1.23 → 1.1.24

package/dist/cjs/snk-application.cjs.entry.js

@@ -2,1223 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const index = require('./index-20a7d705.js');
-
-/**
- * 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, '');
-    }
-}
-
-/**
- * `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) {
-        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 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;
-        }
-        var day = monthYearMode ? 1 : Number(parts[1]);
-        var month = Number(parts[(monthYearMode ? 1 : 2)]);
-        var year = Number(parts[(monthYearMode ? 2 : 3)]);
-        var hour = Number(parts[(monthYearMode ? 3 : 4)] || 0);
-        var min = Number(parts[(monthYearMode ? 4 : 5)] || 0);
-        var 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;
-    }
-}
-
-new MaskFormatter("##:##");
-
-/**
- * Representa as propriedades necessárias para se executar uma requisição.
- */
-/** 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 = {}));
-
-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;
-    }
-    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:
-            return Boolean(value);
-        case DataType.DATE:
-            return new Date(value.toString());
-        default:
-            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["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 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();
-};
-
-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 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;
-            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 savedRecords = action.payload.records;
-                savedRecords.forEach(sr => {
-                    const recordId = sr.__old__id__ || sr.__record__id__;
-                    const newRecord = Object.assign({}, sr);
-                    delete newRecord["__old__id__"];
-                    recordsMap.set(recordId, newRecord);
-                });
-                return Array.from(recordsMap.values());
-        }
-        return currentState;
-    }
-}
-const RecordsReducer = new RecordsReducerImpl();
-const getRecords = (stateManager) => {
-    return stateManager.select(RecordsReducer.sliceName, (state) => state);
-};
-
-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++) }); });
-};
-
-class ChangesReducerImpl {
-    constructor() {
-        this.sliceName = "hist::changes";
-    }
-    reduce(stateManager, currentState, action) {
-        switch (action.type) {
-            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 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 => {
-            result.push(new Change(dataUnit, r, changes === null || changes === void 0 ? void 0 : changes.get(r.__record__id__), ChangeOperation.INSERT));
-        });
-    }
-    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 CurrentRecordsReducerImpl {
-    constructor() {
-        this.sliceName = "currentRecords";
-    }
-    reduce(stateManager, _currentState, _action) {
-        let records = getRecords(stateManager);
-        const added = getAddedRecords(stateManager);
-        if (!records && !added) {
-            return undefined;
-        }
-        if (added) {
-            records = (records || []).concat(added);
-        }
-        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 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 action.payload.map((r) => r.__record__id__);
-            case Action.DATA_SAVED:
-                return updateSavedIds(stateManager, action.payload.records);
-            case Action.RECORDS_REMOVED:
-                const removed = action.payload.records;
-                if (currentState && removed) {
-                    return currentState.filter(recordId => !removed.includes(recordId));
-                }
-                return currentState;
-            case Action.NEXT_SELECTED:
-            case Action.PREVIOUS_SELECTED:
-                const currentRecords = getCurrentRecords(stateManager);
-                if (currentRecords && currentRecords.size > 0) {
-                    let index;
-                    if (!currentState || currentState.length === 0) {
-                        index = action.type === Action.PREVIOUS_SELECTED ? 0 : Math.min(1, currentRecords.size);
-                    }
-                    else {
-                        index = getItemIndex(currentState[0], currentRecords) + (action.type === Action.PREVIOUS_SELECTED ? -1 : 1);
-                    }
-                    if (index < currentRecords.size && index >= 0) {
-                        return [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 selectionById;
-                    }
-                }
-                return selectionSource;
-        }
-        return currentState;
-    }
-}
-const SelectionReducer = new SelectionReducerImpl();
-const getSelection = (stateManager) => {
-    let selection = stateManager.select(SelectionReducer.sliceName, (state) => state);
-    const currentRecords = Array.from((getCurrentRecords(stateManager) || new Map()).keys());
-    if (selection) {
-        selection = selection.filter(id => currentRecords.includes(id));
-    }
-    if (!selection || selection.length === 0) {
-        if (currentRecords && currentRecords.length > 0) {
-            return [currentRecords[0]];
-        }
-    }
-    return selection;
-};
-const hasNext = (stateManager) => {
-    const records = getCurrentRecords(stateManager);
-    if (records) {
-        const selection = stateManager.select(SelectionReducer.sliceName, (state) => state);
-        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 = stateManager.select(SelectionReducer.sliceName, (state) => state);
-        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;
-}
-
-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._stateManager = new StateManager([
-            HistReducer,
-            UnitMetadataReducer,
-            RecordsReducer,
-            RemovedRecordsReducer,
-            AddedRecordsReducer,
-            SelectionReducer,
-            ChangesReducer,
-            CurrentRecordsReducer
-        ]);
-        this._observers = [];
-        this._filterProviders = [];
-        this._sortingProvider = undefined;
-        this._interceptors = [];
-    }
-    get name() {
-        return this._name;
-    }
-    // Métodos privados
-    validateAndTypeValue(fieldName, newValue) {
-        //FIXME: Validações devem ser feitas aqui
-        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;
-    }
-    // Loaders
-    loadMetadata() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.dispatchAction(Action.LOADING_METADATA);
-            return new Promise((resolve, fail) => {
-                if (this.metadataLoader) {
-                    this.metadataLoader(this).then(metadata => {
-                        this.metadata = metadata;
-                        resolve(this.metadata);
-                    }).catch(error => fail(error));
-                }
-            });
-        });
-    }
-    loadData() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.dispatchAction(Action.LOADING_DATA);
-            return new Promise((resolve, fail) => {
-                if (this.dataLoader) {
-                    const sort = this.getSort();
-                    const filters = this.getFilters();
-                    this.dataLoader(this, sort, filters).then(records => {
-                        this.records = records;
-                        resolve(this.records);
-                    }).catch(error => fail(error));
-                }
-            });
-        });
-    }
-    saveData() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const changes = getChangesToSave(this._name, this._stateManager);
-            if (changes.length > 0) {
-                this.dispatchAction(Action.SAVING_DATA);
-                return new Promise((resolve, fail) => {
-                    if (this.saveLoader) {
-                        this.saveLoader(this, changes).then(records => this.dispatchAction(Action.DATA_SAVED, { changes, records })).catch(error => fail(error));
-                    }
-                });
-            }
-            return Promise.resolve();
-        });
-    }
-    removeSelectedRecords(buffered = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const selection = getSelection(this._stateManager);
-            if (selection) {
-                return this.removeRecords(selection, buffered);
-            }
-            return Promise.resolve(selection);
-        });
-    }
-    removeRecords(records, buffered = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (records) {
-                if (buffered || !this.removeLoader) {
-                    this.dispatchAction(Action.RECORDS_REMOVED, { records, buffered: true });
-                }
-                else {
-                    this.dispatchAction(Action.REMOVING_RECORDS);
-                    return new Promise((resolve, fail) => {
-                        if (this.removeLoader) {
-                            this.removeLoader(this, records).then(records => {
-                                this.dispatchAction(Action.RECORDS_REMOVED, { records, buffered: false });
-                                resolve(records);
-                            }).catch(error => fail(error));
-                        }
-                    });
-                }
-            }
-            return Promise.resolve(records);
-        });
-    }
-    // API
-    valueFromString(fieldName, value) {
-        const descriptor = this.getField(fieldName);
-        return descriptor ? convertType(descriptor.dataType, value) : value;
-    }
-    addInterceptor(interceptor) {
-        this._interceptors.push(interceptor);
-    }
-    addFilterProvider(provider) {
-        this._filterProviders.push(provider);
-    }
-    set sortingProvider(provider) {
-        this._sortingProvider = provider;
-    }
-    set metadata(md) {
-        this.dispatchAction(Action.METADATA_LOADED, md);
-    }
-    get metadata() {
-        return getMetadata(this._stateManager);
-    }
-    set records(r) {
-        this.dispatchAction(Action.DATA_LOADED, r);
-    }
-    get records() {
-        const records = getCurrentRecords(this._stateManager);
-        return records ? Array.from(records.values()) : [];
-    }
-    getField(fieldName) {
-        return getField(this._stateManager, fieldName);
-    }
-    addRecord() {
-        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]));
-    }
-    copySelected() {
-        const selectedRecords = this.getSelectedRecords();
-        if (selectedRecords) {
-            this.dispatchAction(Action.RECORDS_COPIED, prepareAddedRecordId(this._stateManager, selectedRecords));
-        }
-    }
-    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 });
-        }
-    }
-    getSelection() {
-        return getSelection(this._stateManager);
-    }
-    setSelection(selection) {
-        this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection });
-    }
-    setSelectionByIndex(selection) {
-        this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection });
-    }
-    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() {
-        this.dispatchAction(Action.NEXT_SELECTED);
-    }
-    previousRecord() {
-        this.dispatchAction(Action.PREVIOUS_SELECTED);
-    }
-    cancelEdition() {
-        this.dispatchAction(Action.EDITION_CANCELED);
-    }
-    isDirty() {
-        return isDirty(this._stateManager);
-    }
-    hasNext() {
-        return hasNext(this._stateManager);
-    }
-    hasPrevious() {
-        return hasPrevious(this._stateManager);
-    }
-    canUndo() {
-        return canUndo(this._stateManager);
-    }
-    canRedo() {
-        return canRedo(this._stateManager);
-    }
-    undo() {
-        this.dispatchAction(Action.CHANGE_UNDONE);
-    }
-    redo() {
-        this.dispatchAction(Action.CHANGE_REDONE);
-    }
-    toString() {
-        return this.name;
-    }
-    // Actions / State manager
-    dispatchAction(actionType, payload) {
-        var _a;
-        let action = new DataUnitAction(actionType, payload);
-        (_a = this._interceptors) === null || _a === void 0 ? void 0 : _a.forEach(interceptor => {
-            if (action) {
-                action = interceptor.interceptAction(action);
-            }
-        });
-        if (action) {
-            this._stateManager.process(action);
-            this._observers.forEach(f => f(action));
-        }
-    }
-    subscribe(observer) {
-        this._observers.push(observer);
-    }
-    unsubscribe(observer) {
-        this._observers = this._observers.filter(f => f !== observer);
-    }
-}
-var ChangeOperation;
-(function (ChangeOperation) {
-    ChangeOperation["INSERT"] = "INSERT";
-    ChangeOperation["UPDATE"] = "UPDATE";
-    ChangeOperation["DELETE"] = "DELETE";
-})(ChangeOperation || (ChangeOperation = {}));
-class Change {
-    constructor(dataUnit, record, updates, operation) {
-        this.dataUnit = dataUnit;
-        this.record = record;
-        this.updatingFields = updates;
-        this._operation = operation;
-    }
-    get operation() {
-        return this._operation.toString();
-    }
-    isInsert() {
-        return this._operation === ChangeOperation.INSERT;
-    }
-    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;
-    }
-}
+const index = require('./index-4720dab8.js');
+const core = require('@sankhyalabs/core');
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -6884,6 +5669,280 @@ exports.ClientError = ClientError;
 //# sourceMappingURL=types.js.map
 });
 
+var graphqlWs = createCommonjsModule(function (module, exports) {
+var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (commonjsGlobal && commonjsGlobal.__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());
+    });
+};
+var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLWebSocketClient = void 0;
+
+
+var CONNECTION_INIT = 'connection_init';
+var CONNECTION_ACK = 'connection_ack';
+var PING = 'ping';
+var PONG = 'pong';
+var SUBSCRIBE = 'subscribe';
+var NEXT = 'next';
+var ERROR = 'error';
+var COMPLETE = 'complete';
+var GraphQLWebSocketMessage = /** @class */ (function () {
+    function GraphQLWebSocketMessage(type, payload, id) {
+        this._type = type;
+        this._payload = payload;
+        this._id = id;
+    }
+    Object.defineProperty(GraphQLWebSocketMessage.prototype, "type", {
+        get: function () { return this._type; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GraphQLWebSocketMessage.prototype, "id", {
+        get: function () { return this._id; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GraphQLWebSocketMessage.prototype, "payload", {
+        get: function () { return this._payload; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GraphQLWebSocketMessage.prototype, "text", {
+        get: function () {
+            var result = { type: this.type };
+            if (this.id != null && this.id != undefined)
+                result.id = this.id;
+            if (this.payload != null && this.payload != undefined)
+                result.payload = this.payload;
+            return JSON.stringify(result);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GraphQLWebSocketMessage.parse = function (data, f) {
+        var _a = JSON.parse(data), type = _a.type, payload = _a.payload, id = _a.id;
+        return new GraphQLWebSocketMessage(type, f(payload), id);
+    };
+    return GraphQLWebSocketMessage;
+}());
+var GraphQLWebSocketClient = /** @class */ (function () {
+    function GraphQLWebSocketClient(socket, _a) {
+        var _this = this;
+        var onInit = _a.onInit, onAcknowledged = _a.onAcknowledged, onPing = _a.onPing, onPong = _a.onPong;
+        this.socketState = { acknowledged: false, lastRequestId: 0, subscriptions: {} };
+        this.socket = socket;
+        socket.onopen = function (e) { return __awaiter(_this, void 0, void 0, function () {
+            var _a, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        this.socketState.acknowledged = false;
+                        this.socketState.subscriptions = {};
+                        _b = (_a = socket).send;
+                        _c = ConnectionInit;
+                        if (!onInit) return [3 /*break*/, 2];
+                        return [4 /*yield*/, onInit()];
+                    case 1:
+                        _d = _e.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _d = null;
+                        _e.label = 3;
+                    case 3:
+                        _b.apply(_a, [_c.apply(void 0, [_d]).text]);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        socket.onclose = function (e) {
+            _this.socketState.acknowledged = false;
+            _this.socketState.subscriptions = {};
+        };
+        socket.onerror = function (e) {
+            console.error(e);
+        };
+        socket.onmessage = function (e) {
+            try {
+                var message = parseMessage(e.data);
+                switch (message.type) {
+                    case CONNECTION_ACK: {
+                        if (_this.socketState.acknowledged) {
+                            console.warn("Duplicate CONNECTION_ACK message ignored");
+                        }
+                        else {
+                            _this.socketState.acknowledged = true;
+                            if (onAcknowledged)
+                                onAcknowledged(message.payload);
+                        }
+                        return;
+                    }
+                    case PING: {
+                        if (onPing)
+                            onPing(message.payload).then(function (r) { return socket.send(Pong(r).text); });
+                        else
+                            socket.send(Pong(null).text);
+                        return;
+                    }
+                    case PONG: {
+                        if (onPong)
+                            onPong(message.payload);
+                        return;
+                    }
+                }
+                if (!_this.socketState.acknowledged) {
+                    // Web-socket connection not acknowledged
+                    return;
+                }
+                if (message.id === undefined || message.id === null || !_this.socketState.subscriptions[message.id]) {
+                    // No subscription identifer or subscription indentifier is not found
+                    return;
+                }
+                var _a = _this.socketState.subscriptions[message.id], query = _a.query, variables = _a.variables, subscriber = _a.subscriber;
+                switch (message.type) {
+                    case NEXT: {
+                        if (!message.payload.errors && message.payload.data) {
+                            subscriber.next && subscriber.next(message.payload.data);
+                        }
+                        if (message.payload.errors) {
+                            subscriber.error && subscriber.error(new types.ClientError(__assign(__assign({}, message.payload), { status: 200 }), { query: query, variables: variables }));
+                        }
+                        return;
+                    }
+                    case ERROR: {
+                        subscriber.error && subscriber.error(new types.ClientError({ errors: message.payload, status: 200 }, { query: query, variables: variables }));
+                        return;
+                    }
+                    case COMPLETE: {
+                        subscriber.complete && subscriber.complete();
+                        delete _this.socketState.subscriptions[message.id];
+                        return;
+                    }
+                }
+            }
+            catch (e) {
+                // Unexpected errors while handling graphql-ws message
+                console.error(e);
+                socket.close(1006);
+            }
+            socket.close(4400, "Unknown graphql-ws message.");
+        };
+    }
+    GraphQLWebSocketClient.prototype.makeSubscribe = function (query, operationName, variables, subscriber) {
+        var _this = this;
+        var subscriptionId = (this.socketState.lastRequestId++).toString();
+        this.socketState.subscriptions[subscriptionId] = { query: query, variables: variables, subscriber: subscriber };
+        this.socket.send(Subscribe(subscriptionId, { query: query, operationName: operationName, variables: variables }).text);
+        return function () {
+            _this.socket.send(Complete(subscriptionId).text);
+            delete _this.socketState.subscriptions[subscriptionId];
+        };
+    };
+    GraphQLWebSocketClient.prototype.rawRequest = function (query, variables) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var result;
+            _this.rawSubscribe(query, {
+                next: function (data, extensions) { return (result = { data: data, extensions: extensions }); },
+                error: reject,
+                complete: function () { return resolve(result); },
+            }, variables);
+        });
+    };
+    GraphQLWebSocketClient.prototype.request = function (document, variables) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var result;
+            _this.subscribe(document, {
+                next: function (data) { return (result = data); },
+                error: reject,
+                complete: function () { return resolve(result); },
+            }, variables);
+        });
+    };
+    GraphQLWebSocketClient.prototype.subscribe = function (document, subscriber, variables) {
+        var _a = dist.resolveRequestDocument(document), query = _a.query, operationName = _a.operationName;
+        return this.makeSubscribe(query, operationName, variables, subscriber);
+    };
+    GraphQLWebSocketClient.prototype.rawSubscribe = function (query, subscriber, variables) {
+        return this.makeSubscribe(query, undefined, variables, subscriber);
+    };
+    GraphQLWebSocketClient.prototype.ping = function (payload) {
+        this.socket.send(Ping(payload).text);
+    };
+    GraphQLWebSocketClient.prototype.close = function () {
+        this.socket.close(1000);
+    };
+    GraphQLWebSocketClient.PROTOCOL = "graphql-transport-ws";
+    return GraphQLWebSocketClient;
+}());
+exports.GraphQLWebSocketClient = GraphQLWebSocketClient;
+// Helper functions
+function parseMessage(data, f) {
+    if (f === void 0) { f = function (a) { return a; }; }
+    var m = GraphQLWebSocketMessage.parse(data, f);
+    return m;
+}
+function ConnectionInit(payload) {
+    return new GraphQLWebSocketMessage(CONNECTION_INIT, payload);
+}
+function Ping(payload) {
+    return new GraphQLWebSocketMessage(PING, payload, undefined);
+}
+function Pong(payload) {
+    return new GraphQLWebSocketMessage(PONG, payload, undefined);
+}
+function Subscribe(id, payload) {
+    return new GraphQLWebSocketMessage(SUBSCRIBE, payload, id);
+}
+function Complete(id) {
+    return new GraphQLWebSocketMessage(COMPLETE, undefined, id);
+}
+//# sourceMappingURL=graphql-ws.js.map
+});
+
 var dist = createCommonjsModule(function (module, exports) {
 var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
     __assign = Object.assign || function(t) {
@@ -6966,7 +6025,7 @@ var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || func
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gql = exports.batchRequests = exports.request = exports.rawRequest = exports.GraphQLClient = exports.ClientError = void 0;
+exports.GraphQLWebSocketClient = exports.gql = exports.resolveRequestDocument = exports.batchRequests = exports.request = exports.rawRequest = exports.GraphQLClient = exports.ClientError = void 0;
 var cross_fetch_1 = __importStar(browserPonyfill), CrossFetch = cross_fetch_1;
 
 
@@ -7100,7 +6159,7 @@ var GraphQLClient = /** @class */ (function () {
                         url: url,
                         query: rawRequestOptions.query,
                         variables: rawRequestOptions.variables,
-                        headers: __assign(__assign({}, resolveHeaders(headers)), resolveHeaders(rawRequestOptions.requestHeaders)),
+                        headers: __assign(__assign({}, resolveHeaders(callOrIdentity(headers))), resolveHeaders(rawRequestOptions.requestHeaders)),
                         operationName: operationName,
                         fetch: fetch,
                         method: method,
@@ -7126,7 +6185,7 @@ var GraphQLClient = /** @class */ (function () {
                                 url: url,
                                 query: query,
                                 variables: requestOptions.variables,
-                                headers: __assign(__assign({}, resolveHeaders(headers)), resolveHeaders(requestOptions.requestHeaders)),
+                                headers: __assign(__assign({}, resolveHeaders(callOrIdentity(headers))), resolveHeaders(requestOptions.requestHeaders)),
                                 operationName: operationName,
                                 fetch: fetch,
                                 method: method,
@@ -7163,7 +6222,7 @@ var GraphQLClient = /** @class */ (function () {
                                 url: url,
                                 query: queries,
                                 variables: variables,
-                                headers: __assign(__assign({}, resolveHeaders(headers)), resolveHeaders(batchRequestOptions.requestHeaders)),
+                                headers: __assign(__assign({}, resolveHeaders(callOrIdentity(headers))), resolveHeaders(batchRequestOptions.requestHeaders)),
                                 operationName: undefined,
                                 fetch: fetch,
                                 method: method,
@@ -7209,7 +6268,7 @@ exports.GraphQLClient = GraphQLClient;
 function makeRequest(_a) {
     var url = _a.url, query = _a.query, variables = _a.variables, headers = _a.headers, operationName = _a.operationName, fetch = _a.fetch, _b = _a.method, method = _b === void 0 ? 'POST' : _b, fetchOptions = _a.fetchOptions;
     return __awaiter(this, void 0, void 0, function () {
-        var fetcher, isBathchingQuery, response, result, successfullyReceivedData, headers_1, status_1, errorResult;
+        var fetcher, isBathchingQuery, response, result, successfullyReceivedData, successfullyPassedErrorPolicy, headers_1, status_1, rest, data, errorResult;
         return __generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
@@ -7233,9 +6292,12 @@ function makeRequest(_a) {
                         var data = _a.data;
                         return !data;
                     }) : !!result.data;
-                    if (response.ok && !result.errors && successfullyReceivedData) {
+                    successfullyPassedErrorPolicy = !result.errors || fetchOptions.errorPolicy === 'all' || fetchOptions.errorPolicy === 'ignore';
+                    if (response.ok && successfullyPassedErrorPolicy && successfullyReceivedData) {
                         headers_1 = response.headers, status_1 = response.status;
-                        return [2 /*return*/, __assign(__assign({}, (isBathchingQuery ? { data: result } : result)), { headers: headers_1, status: status_1 })];
+                        rest = __rest(result, ["errors"]);
+                        data = fetchOptions.errorPolicy === 'ignore' ? rest : result;
+                        return [2 /*return*/, __assign(__assign({}, (isBathchingQuery ? { data: data } : data)), { headers: headers_1, status: status_1 })];
                     }
                     else {
                         errorResult = typeof result === 'string' ? { error: result } : result;
@@ -7330,6 +6392,10 @@ function resolveRequestDocument(document) {
     var operationName = extractOperationName(document);
     return { query: printer.print(document), operationName: operationName };
 }
+exports.resolveRequestDocument = resolveRequestDocument;
+function callOrIdentity(value) {
+    return typeof value === 'function' ? value() : value;
+}
 /**
  * Convenience passthrough template tag to get the benefits of tooling for the gql template tag. This does not actually parse the input into a GraphQL DocumentNode like graphql-tag package does. It just returns the string with any variables given interpolated. Can save you a bit of performance and having to install another package.
  *
@@ -7361,6 +6427,8 @@ function HeadersInstanceToPlainObject(headers) {
     });
     return o;
 }
+
+Object.defineProperty(exports, "GraphQLWebSocketClient", { enumerable: true, get: function () { return graphqlWs.GraphQLWebSocketClient; } });
 //# sourceMappingURL=index.js.map
 });
 
@@ -7580,7 +6648,7 @@ class DataUnitFetcher {
           }`);
   }
   getDataUnit(entityName, resourceID) {
-    const dataUnit = new DataUnit(`dd://${entityName}/${resourceID}`);
+    const dataUnit = new core.DataUnit(`dd://${entityName}/${resourceID}`);
     dataUnit.metadataLoader = (dataUnit) => this.loadMetadata(dataUnit);
     dataUnit.dataLoader = (dataUnit, sort, filters) => this.loadData(dataUnit, sort, filters);
     dataUnit.saveLoader = (dataUnit, changes) => this.saveData(dataUnit, changes);
@@ -7690,7 +6758,7 @@ class DataUnitFetcher {
   }
   removeRecords(dataUnit, recordIds) {
     const changes = recordIds.map((recordId) => {
-      return { dataUnit: dataUnit.name, operation: ChangeOperation.DELETE, recordId };
+      return { dataUnit: dataUnit.name, operation: core.ChangeOperation.DELETE, recordId };
     });
     return new Promise((resolve, reject) => {
       HttpFetcher.get()
@@ -7778,7 +6846,7 @@ class ParametersFetcher {
   }
   async asDate(name, resourceID) {
     const paramArr = await this.getParam(name, resourceID);
-    return DateUtils.strToDate(this.getValue(paramArr));
+    return core.DateUtils.strToDate(this.getValue(paramArr));
   }
   async getBatchParams(names, resourceID) {
     const paramArr = await this.getParam(names.join(","), resourceID);
@@ -7791,7 +6859,7 @@ class ParametersFetcher {
     if (Array.isArray(obj) && obj.length > 0) {
       obj = obj[0];
     }
-    if (StringUtils.isEmpty(obj.resource))
+    if (core.StringUtils.isEmpty(obj.resource))
       return "";
     return obj.resource;
   }
@@ -7817,17 +6885,21 @@ class ApplicationUtils {
   static async confirm(title, message, icon = null, critical = false) {
     return ApplicationUtils.showDialog(title, message, icon, true, critical);
   }
-  static async info(message) {
+  static async info(message, options = ApplicationUtils.defaultMessageOptions) {
     let toast = document.querySelector("ez-toast");
     if (!toast) {
       toast = document.createElement("ez-toast");
       window.document.body.appendChild(toast);
     }
+    toast.canClose = options.canClose;
     toast.message = message;
     toast.fadeTime = 4000;
     toast.show();
   }
-}
+}
+ApplicationUtils.defaultMessageOptions = {
+  canClose: true
+};
 
 class ResourceFetcher {
   constructor() {
@@ -7986,8 +7058,8 @@ const SnkApplication = class {
   async confirm(title, message, icon, critical) {
     return ApplicationUtils.confirm(title, message, icon, critical);
   }
-  async info(message) {
-    return ApplicationUtils.info(message);
+  async info(message, options = undefined) {
+    return ApplicationUtils.info(message, options);
   }
   async loadFormConfig(name) {
     return this.formConfigFetcher.loadFormConfig(name, this.resourceID);
@@ -8011,7 +7083,7 @@ const SnkApplication = class {
     return this._formConfigFetcher;
   }
   componentWillLoad() {
-    ApplicationContext.setContextValue("__EZUI__SEARCH__OPTION__LOADER__", pesquisaLoadOptions);
+    core.ApplicationContext.setContextValue("__EZUI__SEARCH__OPTION__LOADER__", pesquisaLoadOptions);
   }
   componentDidLoad() {
     this.applicationLoading.emit(true);