@sankhyalabs/ezui 1.1.4 → 1.1.5

package/dist/esm/DataUnit-ac4cc054.js

@@ -0,0 +1,375 @@
+function changeFieldValue(dataUnit, recordId, fieldName, value) {
+  return {
+    type: 'FORM/CHANGEFIELD',
+    payload: { dataUnit, recordId, fieldName, value }
+  };
+}
+function changeTab(formId, index) {
+  return {
+    type: 'FORM/CHANGETAB',
+    payload: { formId, index }
+  };
+}
+function clearEdition(dataUnit, recordsLimit) {
+  return {
+    type: 'FORM/CLEAREDITION',
+    payload: {
+      dataUnit,
+      recordsLimit
+    }
+  };
+}
+function collapseExpandGroup(collapseId, collapsed) {
+  return {
+    type: 'FORM/COLLAPSEGROUP',
+    payload: { collapseId, collapsed }
+  };
+}
+function previousRecord(dataUnit) {
+  return {
+    type: 'FORM/NAVIGATE',
+    payload: {
+      dataUnit,
+      limit: 0,
+      backward: true
+    }
+  };
+}
+function nextRecord(dataUnit, limit) {
+  return {
+    type: 'FORM/NAVIGATE',
+    payload: {
+      dataUnit,
+      limit,
+      backward: false
+    }
+  };
+}
+function insertRecord(dataUnit, insertionIndex) {
+  return {
+    type: 'FORM/INSERT',
+    payload: {
+      dataUnit,
+      insertionIndex
+    }
+  };
+}
+function formLoad() {
+  return {
+    type: 'FORM/LOAD'
+  };
+}
+function dataLoading(dataUnit) {
+  return {
+    type: 'FORM/DATALOADING',
+    payload: {
+      dataUnit
+    }
+  };
+}
+function savingChanges(dataUnit) {
+  return {
+    type: 'FORM/SAVINGCHANGES',
+    payload: {
+      dataUnit
+    }
+  };
+}
+function dataLoaded(dataUnit) {
+  return {
+    type: 'FORM/DATALOADED',
+    payload: {
+      dataUnit
+    }
+  };
+}
+function changesSaved(dataUnit) {
+  return {
+    type: 'FORM/CHANGESSAVED',
+    payload: {
+      dataUnit
+    }
+  };
+}
+function removingRecord(dataUnit) {
+  return {
+    type: 'FORM/REMOVINGRECORD',
+    payload: {
+      dataUnit
+    }
+  };
+}
+function recordRemoved(dataUnit) {
+  return {
+    type: 'FORM/RECORDREMOVED',
+    payload: {
+      dataUnit
+    }
+  };
+}
+function invalidField(tabController, tabIndex, dataUnit, recordIndex, recordId, fieldName, errorMessage) {
+  return {
+    type: 'FORM/INVALIDFIELD',
+    payload: {
+      tabController,
+      tabIndex,
+      dataUnit,
+      recordId,
+      recordIndex,
+      fieldName,
+      errorMessage
+    }
+  };
+}
+function showHideNavigationButtons(buttonName, status) {
+  return {
+    type: 'FORM/SHOWHIDENAVBTN',
+    payload: {
+      buttonName,
+      status
+    }
+  };
+}
+
+//histórico
+const selectCurrentTab = (state, formName) => {
+  const data = state.hist.present.currentTabIndex;
+  return data[formName] || 0;
+};
+const selectIsCollapsedFieldSet = (state, fieldSetName) => {
+  const data = state.hist.present.collapsedGroups;
+  return data[fieldSetName];
+};
+const selectRecordChanges = (state, dataUnit, recordId) => {
+  const data = selectDataUnitChanges(state, dataUnit);
+  return data ? data[recordId] : undefined;
+};
+const selectDataUnitChanges = (state, dataUnit) => {
+  const data = state.hist.present.changes;
+  return data[dataUnit];
+};
+const selectCurrentRecordIndex = (state, dataUnit) => {
+  const data = state.hist.present.currentRecordIndex;
+  return data[dataUnit] || 0;
+};
+const selectNewRecordIndex = (state, dataUnit) => {
+  const data = state.hist.present.newRecordIndex;
+  return data[dataUnit] || 0;
+};
+//não histórico
+const selectLoadingData = (state, dataUnit) => {
+  const data = state.nonhist.dataLoading;
+  return data[dataUnit];
+};
+const selectErrorMessage = (state, dataUnit, recordId, fieldName) => {
+  const data = state.nonhist.invalidFields;
+  const dataUnitMessages = data[dataUnit] || {};
+  const recordMessages = dataUnitMessages[recordId] || {};
+  return recordMessages[fieldName] || "";
+};
+const selectVisibleButtons = state => state.nonhist.visibleButtons;
+
+class DataUnit {
+  constructor(name, unitLabel, cardinality = '1') {
+    this.name = name;
+    this.unitLabel = unitLabel;
+    this.cardinality = cardinality;
+  }
+  set store(store) {
+    this._store = store;
+  }
+  isLoading() {
+    return selectLoadingData(this._store.getState(), this.name);
+  }
+  hasChanges() {
+    const state = this._store.getState();
+    return selectDataUnitChanges(state, this.name) !== undefined || selectNewRecordIndex(state, this.name) > 0;
+  }
+  hasNext() {
+    return selectCurrentRecordIndex(this._store.getState(), this.name) < (this.records.length - 1);
+  }
+  hasPrevious() {
+    return selectCurrentRecordIndex(this._store.getState(), this.name) > 0;
+  }
+  hasCurrentRecord() {
+    return this.getCurrentRecord() != undefined;
+  }
+  previous() {
+    this._store.dispatch(previousRecord(this.name));
+  }
+  next() {
+    this._store.dispatch(nextRecord(this.name, this.records.length));
+  }
+  getValue(fieldName) {
+    const currentRecord = this.getCurrentRecord();
+    if (!currentRecord) {
+      return undefined;
+    }
+    const changes = this.getRecordChanges(currentRecord);
+    return changes && changes[fieldName] !== undefined ? changes[fieldName] : currentRecord[fieldName] || null;
+  }
+  getErrorMessage(fieldName) {
+    const currentRecord = this.getCurrentRecord();
+    return selectErrorMessage(this._store.getState(), this.name, currentRecord === null || currentRecord === void 0 ? void 0 : currentRecord.record__id, fieldName);
+  }
+  changeValue(fieldName, newValue) {
+    if (this.records.length == 0) {
+      this.insert();
+    }
+    if (this._changeDeboucing) {
+      window.clearTimeout(this._changeDeboucing);
+    }
+    this._changeDeboucing = window.setTimeout(() => {
+      const currentRecord = this.getCurrentRecord();
+      this._store.dispatch(changeFieldValue(this.name, currentRecord.record__id, fieldName, newValue));
+    }, 100);
+  }
+  cancel() {
+    this.records = this.records.filter(r => !r.record__id.startsWith('NEW_'));
+    this._store.dispatch(clearEdition(this.name, this.records.length - 1));
+  }
+  insert() {
+    const insertionIndex = this.records.length;
+    const newRecordIndex = selectNewRecordIndex(this._store.getState(), this.name);
+    this.records.push({ record__id: 'NEW_' + (newRecordIndex + 1) });
+    this._store.dispatch(insertRecord(this.name, insertionIndex));
+  }
+  getChangesToSave() {
+    const duChanges = selectDataUnitChanges(this._store.getState(), this.name);
+    const changesByRecord = Object.keys(duChanges).map(record__id => {
+      const record = { record__id };
+      const recordChanges = duChanges[record__id];
+      Object.keys(recordChanges).forEach(fieldName => { record[fieldName] = recordChanges[fieldName]; });
+      return record;
+    });
+    return [{
+        dataUnit: this.name,
+        records: changesByRecord
+      }];
+  }
+  save() {
+    if (!this.validateRecords()) {
+      return;
+    }
+    this._store.dispatch(savingChanges(this.name));
+    let saveResult;
+    if (this.saveExecutor) {
+      saveResult = this.saveExecutor(this.getChangesToSave());
+    }
+    if (saveResult instanceof Promise) {
+      saveResult.then(r => this.processSaveResult(r));
+    }
+    else {
+      this.processSaveResult(saveResult);
+    }
+  }
+  load() {
+    this._store.dispatch(dataLoading(this.name));
+    let result;
+    if (this.loadExecutor) {
+      result = this.loadExecutor({ dataUnit: this.name });
+    }
+    if (result instanceof Promise) {
+      result.then(r => this.processLoadResult(r));
+    }
+    else {
+      this.processLoadResult(result);
+    }
+  }
+  remove() {
+    const currentIndex = selectCurrentRecordIndex(this._store.getState(), this.name);
+    this._store.dispatch(removingRecord(this.name));
+    let removeResult;
+    if (this.removeExecutor) {
+      const record = this.getCurrentRecord();
+      removeResult = this.removeExecutor({ dataUnit: this.name, recordId: record.record__id, record });
+    }
+    else {
+      removeResult = true;
+    }
+    if (removeResult) {
+      if (removeResult instanceof Promise) {
+        removeResult.then(r => this.processRemoveResult(r, currentIndex));
+      }
+      else {
+        this.processRemoveResult(removeResult, currentIndex);
+      }
+    }
+  }
+  processSaveResult(result) {
+    if (result) {
+      if (result instanceof Array) {
+        result.forEach(item => this.processSaveResult(item));
+      }
+      else {
+        if (result.dataUnit === this.name) {
+          result.records.forEach(savedRecord => {
+            let rID = savedRecord.oldRecord__id;
+            delete savedRecord.oldRecord__id;
+            if (rID === undefined) {
+              rID = savedRecord.record__id;
+            }
+            this.records.forEach((r, index) => {
+              if (r.record__id === rID) {
+                this.records[index] = Object.assign(r, savedRecord);
+              }
+            });
+          });
+        }
+      }
+    }
+    this._store.dispatch(clearEdition(this.name, this.records.length - 1));
+    this._store.dispatch(changesSaved(this.name));
+  }
+  processLoadResult(records) {
+    this.records = records;
+    this._store.dispatch(clearEdition(this.name, this.records.length - 1));
+    this._store.dispatch(dataLoaded(this.name));
+  }
+  processRemoveResult(removed, recordIndex) {
+    if (removed) {
+      this.records.splice(recordIndex, 1);
+      this._store.dispatch(clearEdition(this.name, this.records.length - 1));
+    }
+    this._store.dispatch(recordRemoved(this.name));
+  }
+  set records(records) {
+    this._records = records;
+  }
+  get records() {
+    if (!this._records) {
+      this._records = [];
+    }
+    return this._records;
+  }
+  getCurrentRecord() {
+    const currentIndex = selectCurrentRecordIndex(this._store.getState(), this.name);
+    return this.records[currentIndex];
+  }
+  getRecordChanges(currentRecord = undefined) {
+    if (currentRecord === undefined) {
+      currentRecord = this.getCurrentRecord();
+    }
+    return currentRecord ? selectRecordChanges(this._store.getState(), this.name, currentRecord.record__id) : undefined;
+  }
+  validateRecords() {
+    if (!this.recordsValidator) {
+      return true;
+    }
+    const duChanges = selectDataUnitChanges(this._store.getState(), this.name);
+    const recordsToValidate = [];
+    this.records.forEach((record, i) => {
+      const changes = duChanges[record.record__id];
+      if (changes) {
+        recordsToValidate.push(Object.assign(Object.assign(Object.assign({}, record), changes), { record__index: i, record__changedfields: Object.keys(changes) }));
+      }
+    });
+    const result = this.recordsValidator.validateRecords(this, recordsToValidate);
+    if (result.message) {
+      alert(result.message);
+    }
+    return result.isValid;
+  }
+}
+
+export { DataUnit as D, selectCurrentTab as a, selectVisibleButtons as b, collapseExpandGroup as c, changeTab as d, showHideNavigationButtons as e, formLoad as f, invalidField as i, selectIsCollapsedFieldSet as s };

package/dist/esm/RequestMetadata-c265c9d5.js

@@ -0,0 +1,527 @@
+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();
+        var 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);
+        }
+        var indexV = value.indexOf(',');
+        var 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();
+    }
+    let newValue = NumberUtils.stringToNumber(value);
+    if (newValue === NaN) {
+        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 (prettyPrecision === NaN || 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) {
+        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));
+    }
+};
+
+/**
+ * `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.
+ */
+/** 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 = {}));
+
+export { MaskFormatter as M, NumberUtils as N, TimeFormatter as T };