@sankhyalabs/core 1.0.40 → 1.0.42

package/src/utils/MaskFormatter.ts

@@ -1,323 +1,323 @@
-/**
- * `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           |
- *
- */
-export class MaskFormatter {
-
-    private static DIGIT_KEY: string = "#";
-    private static LITERAL_KEY: string = "'";
-    private static UPPERCASE_KEY: string = "U";
-    private static LOWERCASE_KEY: string = "L";
-    private static ALPHA_NUMERIC_KEY: string = "A";
-    private static CHARACTER_KEY: string = "?";
-    private static ANYTHING_KEY: string = "*";
-
-    private _mask: string = '';
-    private _maskChars: Array<MaskFormatter.MaskCharacter> = new Array<MaskFormatter.MaskCharacter>();
-
-    /**
-     * 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
-     */
-    public placeholder: string = ' ';
-
-    /**
-     * Setter para mask. Trata-se do padrão que se espera ao formatar o texto.
-     */
-    public set mask(mask: string) {
-        this._mask = mask;
-        this.updateInternalMask();
-    }
-
-    /**
-     * Getter para mask
-     *
-     * @return A última máscara informada.
-     */
-    public get mask(): string {
-        return this._mask;
-    }
-
-    constructor(mask: string) {
-        this.mask = 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
-     */
-    public format(value: string): string {
-        let result: string = '';
-        const index: Array<number> = [0];
-
-        let counter: number = 0;
-        const maxCounter: number = 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.
-     */
-    private updateInternalMask(): void {
-
-        this._maskChars.length = 0;
-
-        if (this.mask != null) {
-            let counter: number = 0;
-            const maxCounter: number = this.mask.length;
-            while (counter < maxCounter) {
-
-                let maskChar: string = 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++;
-            }
-        }
-    }
-
-    //
-    // Classes internas usadas para representar a máscara.
-    //
-    public static MaskCharacter = class {
-
-        public maskFormatter: MaskFormatter;
-        public type: string;
-
-        constructor(maskFormatter: MaskFormatter, type: string) {
-            this.maskFormatter = maskFormatter;
-            this.type = type;
-        }
-        /**
-         * Cada subclasse deve sobrescrever o retornando true, caso represente
-         * um caractere literal. Por padrão o retorno é false.
-         */
-        public isLiteral(): boolean {
-            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.
-         */
-        public isValidCharacter(aChar: string): boolean {
-            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.
-         */
-        public getChar(aChar: string): string {
-            return aChar;
-        }
-
-        /**
-         * Appends the necessary character in <code>formatting</code> at
-         * <code>index</code> to <code>buff</code>.
-         */
-        public append(result: string, formatting: string, index: Array<number>): string {
-
-            const inString: boolean = index[0] < formatting.length;
-            const aChar: string = inString ? formatting.charAt(index[0]) : '';
-
-            if (this.isLiteral()) {
-                const literal: string = 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;
-        }
-
-        public getFormatMessage(): string{
-            let message: string;
-            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;
-        }
-    }
-
-    private static LiteralCharacter = class extends MaskFormatter.MaskCharacter {
-
-        private _fixedChar: string;
-
-        constructor(maskFormatter: MaskFormatter, fixedChar: string) {
-            super(maskFormatter, fixedChar);
-            this._fixedChar = fixedChar;
-        }
-
-        public isLiteral(): boolean {
-            return true;
-        }
-
-        public getChar(aChar: string): string {
-            aChar;
-            return this._fixedChar;
-        }
-    }
-
-    private static DigitMaskCharacter = class extends MaskFormatter.MaskCharacter {
-
-        public isValidCharacter(aChar: string): boolean {
-            return (this.isDigit(aChar) && super.isValidCharacter(aChar));
-        }
-
-        private isDigit(char: string): boolean {
-            return char >= '0' && char <= '9'
-        }
-    }
-
-    private static UpperCaseCharacter = class extends MaskFormatter.MaskCharacter {
-        public isValidCharacter(aChar: string): boolean {
-            return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
-        }
-
-        public getChar(aChar: string): string {
-            return aChar.toUpperCase();
-        }
-    }
-
-    private static LowerCaseCharacter = class extends MaskFormatter.MaskCharacter {
-
-        public isValidCharacter(aChar: string): boolean {
-            return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
-        }
-
-        public getChar(aChar: string): string {
-            return aChar.toLocaleLowerCase();
-        }
-    }
-
-    private static AlphaNumericCharacter = class extends MaskFormatter.MaskCharacter {
-
-        public isValidCharacter(aChar: string): boolean {
-            //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
-            return (/[a-z0-9]/i.test(aChar)) && super.isValidCharacter(aChar);
-        }
-    }
-
-    private static CharCharacter = class extends MaskFormatter.MaskCharacter {
-        public isValidCharacter(aChar: string): boolean {
-            //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
-            return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
-        }
-
-    }
-
-}
-
-export namespace MaskFormatter {
-    export type MaskCharacter = InstanceType<typeof MaskFormatter.MaskCharacter>;
+/**
+ * `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           |
+ *
+ */
+export class MaskFormatter {
+
+    private static DIGIT_KEY: string = "#";
+    private static LITERAL_KEY: string = "'";
+    private static UPPERCASE_KEY: string = "U";
+    private static LOWERCASE_KEY: string = "L";
+    private static ALPHA_NUMERIC_KEY: string = "A";
+    private static CHARACTER_KEY: string = "?";
+    private static ANYTHING_KEY: string = "*";
+
+    private _mask: string = '';
+    private _maskChars: Array<MaskFormatter.MaskCharacter> = new Array<MaskFormatter.MaskCharacter>();
+
+    /**
+     * 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
+     */
+    public placeholder: string = ' ';
+
+    /**
+     * Setter para mask. Trata-se do padrão que se espera ao formatar o texto.
+     */
+    public set mask(mask: string) {
+        this._mask = mask;
+        this.updateInternalMask();
+    }
+
+    /**
+     * Getter para mask
+     *
+     * @return A última máscara informada.
+     */
+    public get mask(): string {
+        return this._mask;
+    }
+
+    constructor(mask: string) {
+        this.mask = 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
+     */
+    public format(value: string): string {
+        let result: string = '';
+        const index: Array<number> = [0];
+
+        let counter: number = 0;
+        const maxCounter: number = 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.
+     */
+    private updateInternalMask(): void {
+
+        this._maskChars.length = 0;
+
+        if (this.mask != null) {
+            let counter: number = 0;
+            const maxCounter: number = this.mask.length;
+            while (counter < maxCounter) {
+
+                let maskChar: string = 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++;
+            }
+        }
+    }
+
+    //
+    // Classes internas usadas para representar a máscara.
+    //
+    public static MaskCharacter = class {
+
+        public maskFormatter: MaskFormatter;
+        public type: string;
+
+        constructor(maskFormatter: MaskFormatter, type: string) {
+            this.maskFormatter = maskFormatter;
+            this.type = type;
+        }
+        /**
+         * Cada subclasse deve sobrescrever o retornando true, caso represente
+         * um caractere literal. Por padrão o retorno é false.
+         */
+        public isLiteral(): boolean {
+            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.
+         */
+        public isValidCharacter(aChar: string): boolean {
+            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.
+         */
+        public getChar(aChar: string): string {
+            return aChar;
+        }
+
+        /**
+         * Appends the necessary character in <code>formatting</code> at
+         * <code>index</code> to <code>buff</code>.
+         */
+        public append(result: string, formatting: string, index: Array<number>): string {
+
+            const inString: boolean = index[0] < formatting.length;
+            const aChar: string = inString ? formatting.charAt(index[0]) : '';
+
+            if (this.isLiteral()) {
+                const literal: string = 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;
+        }
+
+        public getFormatMessage(): string{
+            let message: string;
+            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;
+        }
+    }
+
+    private static LiteralCharacter = class extends MaskFormatter.MaskCharacter {
+
+        private _fixedChar: string;
+
+        constructor(maskFormatter: MaskFormatter, fixedChar: string) {
+            super(maskFormatter, fixedChar);
+            this._fixedChar = fixedChar;
+        }
+
+        public isLiteral(): boolean {
+            return true;
+        }
+
+        public getChar(aChar: string): string {
+            aChar;
+            return this._fixedChar;
+        }
+    }
+
+    private static DigitMaskCharacter = class extends MaskFormatter.MaskCharacter {
+
+        public isValidCharacter(aChar: string): boolean {
+            return (this.isDigit(aChar) && super.isValidCharacter(aChar));
+        }
+
+        private isDigit(char: string): boolean {
+            return char >= '0' && char <= '9'
+        }
+    }
+
+    private static UpperCaseCharacter = class extends MaskFormatter.MaskCharacter {
+        public isValidCharacter(aChar: string): boolean {
+            return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+        }
+
+        public getChar(aChar: string): string {
+            return aChar.toUpperCase();
+        }
+    }
+
+    private static LowerCaseCharacter = class extends MaskFormatter.MaskCharacter {
+
+        public isValidCharacter(aChar: string): boolean {
+            return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+        }
+
+        public getChar(aChar: string): string {
+            return aChar.toLocaleLowerCase();
+        }
+    }
+
+    private static AlphaNumericCharacter = class extends MaskFormatter.MaskCharacter {
+
+        public isValidCharacter(aChar: string): boolean {
+            //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
+            return (/[a-z0-9]/i.test(aChar)) && super.isValidCharacter(aChar);
+        }
+    }
+
+    private static CharCharacter = class extends MaskFormatter.MaskCharacter {
+        public isValidCharacter(aChar: string): boolean {
+            //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
+            return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+        }
+
+    }
+
+}
+
+export namespace MaskFormatter {
+    export type MaskCharacter = InstanceType<typeof MaskFormatter.MaskCharacter>;
 }