13331632524

Committed 14 Feb 2025 02:51PM CUT coverage: 22.015% (-69.6%) from 91.622%

Build # 13331632524

Build Type

Pull #15372

github

Committed by

web-flow

Commit Message

Merge d52d57714 into bcb78ae0a

Pull Request Pull Request #15372: chore(*): test ci passing

Run Details

1990 of 15592 branches covered (12.76%)

431 of 964 new or added lines in 18 files covered. (44.71%)

19956 existing lines in 307 files now uncovered.

6452 of 29307 relevant lines covered (22.02%)

249.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

17.86

/projects/igniteui-angular/src/lib/directives/mask/mask-parsing.service.ts

import { Injectable } from '@angular/core';


const FLAGS = new Set('aACL09#&?');
const REGEX = new Map([
    ['C', /(?!^$)/u], // Non-empty
    ['&', /[^\p{Separator}]/u], // Non-whitespace
    ['a', /[\p{Letter}\d\p{Separator}]/u], // Alphanumeric & whitespace
    ['A', /[\p{Letter}\d]/u], // Alphanumeric
    ['?', /[\p{Letter}\p{Separator}]/u], // Alpha & whitespace
    ['L', /\p{Letter}/u], // Alpha
    ['0', /\d/], // Numeric
    ['9', /[\d\p{Separator}]/u], // Numeric & whitespace
    ['#', /[\d\-+]/], // Numeric and sign
]);

/** @hidden */
export interface MaskOptions {
    format: string;
    promptChar: string;
}

/** @hidden */
export interface Replaced {
    value: string;
    end: number;
}

interface ParsedMask {
    literals: Map<number, string>,
    mask: string
}

const replaceCharAt = (string: string, idx: number, char: string) =>
    `${string.substring(0, idx)}${char}${string.substring(idx + 1)}`;


export function parseMask(format: string): ParsedMask {
    const literals = new Map<number, string>();
    let mask = format;

    for (let i = 0, j = 0; i < format.length; i++, j++) {
        const [current, next] = [format.charAt(i), format.charAt(i + 1)];

        if (current === '\\' && FLAGS.has(next)) {
            mask = replaceCharAt(mask, j, '');
            literals.set(j, next);
            i++;
        } else {
            if (!FLAGS.has(current)) {
                literals.set(j, current);
            }
        }
    }

    return { literals, mask };
}

/** @hidden */
@Injectable({
    providedIn: 'root'
})
export class MaskParsingService {

    public applyMask(inputVal: string, maskOptions: MaskOptions, pos = 0): string {
        let outputVal = '';
        let value = '';
        const { literals, mask } = parseMask(maskOptions.format);
        const literalKeys: number[] = Array.from(literals.keys());
        const nonLiteralIndices: number[] = this.getNonLiteralIndices(mask, literalKeys);
        const literalValues: string[] = Array.from(literals.values());

        if (inputVal != null) {
            value = inputVal.toString();
        }

        for (const _maskSym of mask) {
            outputVal += maskOptions.promptChar;
        }

        literals.forEach((val: string, key: number) => {
            outputVal = replaceCharAt(outputVal, key, val);
        });

        if (!value) {
            return outputVal;
        }

        const nonLiteralValues: string[] = this.getNonLiteralValues(value, literalValues);

        for (let i = 0; i < nonLiteralValues.length; i++) {
            const char = nonLiteralValues[i];
            const isCharValid = this.validateCharOnPosition(char, nonLiteralIndices[i], mask);

            if (!isCharValid && char !== maskOptions.promptChar) {
                nonLiteralValues[i] = maskOptions.promptChar;
            }
        }

        if (nonLiteralValues.length > nonLiteralIndices.length) {
            nonLiteralValues.splice(nonLiteralIndices.length);
        }

        for (const nonLiteralValue of nonLiteralValues) {
            const char = nonLiteralValue;
            outputVal = replaceCharAt(outputVal, nonLiteralIndices[pos++], char);
        }

        return outputVal;
    }

    public parseValueFromMask(maskedValue: string, maskOptions: MaskOptions): string {
        let outputVal = '';
        const literalValues: string[] = Array.from(parseMask(maskOptions.format).literals.values());

        for (const val of maskedValue) {
            if (literalValues.indexOf(val) === -1) {
                if (val !== maskOptions.promptChar) {
                    outputVal += val;
                }
            }
        }

        return outputVal;
    }

    public replaceInMask(maskedValue: string, value: string, maskOptions: MaskOptions, start: number, end: number): Replaced {
        const { literals, mask } = parseMask(maskOptions.format);
        const literalsPositions = Array.from(literals.keys());
        value = this.replaceIMENumbers(value);
        const chars = Array.from(value);
        let cursor = start;
        end = Math.min(end, maskedValue.length);

        for (let i = start; i < end || (chars.length && i < maskedValue.length); i++) {
            if (literalsPositions.indexOf(i) !== -1) {
                if (chars[0] === maskedValue[i] || value.length < 1) {
                    cursor = i + 1;
                    chars.shift();
                }
                continue;
            }
            if (chars[0]
                && !this.validateCharOnPosition(chars[0], i, mask)
                && chars[0] !== maskOptions.promptChar) {
                break;
            }

            let char = maskOptions.promptChar;
            if (chars.length) {
                cursor = i + 1;
                char = chars.shift();
            }
            if (value.length < 1) {
                // on `delete` the cursor should move forward
                cursor++;
            }
            maskedValue = replaceCharAt(maskedValue, i, char);
        }

        return { value: maskedValue, end: cursor };
    }

    /** Validates only non literal positions. */
    private validateCharOnPosition(inputChar: string, position: number, mask: string): boolean {
        const regex = REGEX.get(mask.charAt(position));
        return regex ? regex.test(inputChar) : false;
    }

    private getNonLiteralIndices(mask: string, literalKeys: number[]): number[] {
        const nonLiteralsIndices: number[] = [];

        for (let i = 0; i < mask.length; i++) {
            if (literalKeys.indexOf(i) === -1) {
                nonLiteralsIndices.push(i);
            }
        }

        return nonLiteralsIndices;
    }
    private getNonLiteralValues(value: string, literalValues: string[]): string[] {
        const nonLiteralValues: string[] = [];

        for (const val of value) {
            if (literalValues.indexOf(val) === -1) {
                nonLiteralValues.push(val);
            }
        }

        return nonLiteralValues;
    }

    private replaceIMENumbers(value: string): string {
        return value.replace(/[０１２３４５６７８９]/g, (num) => ({
            '１': '1', '２': '2', '３': '3', '４': '4', '５': '5',
            '６': '6', '７': '7', '８': '8', '９': '9', '０': '0'
        }[num]));
    }
}

1	import { Injectable } from '@angular/core';
2
3
4	const FLAGS = new Set('aACL09#&?');	2✔
5	const REGEX = new Map([	2✔
6	['C', /(?!^$)/u], // Non-empty
7	['&', /[^\p{Separator}]/u], // Non-whitespace
8	['a', /[\p{Letter}\d\p{Separator}]/u], // Alphanumeric & whitespace
9	['A', /[\p{Letter}\d]/u], // Alphanumeric
10	['?', /[\p{Letter}\p{Separator}]/u], // Alpha & whitespace
11	['L', /\p{Letter}/u], // Alpha
12	['0', /\d/], // Numeric
13	['9', /[\d\p{Separator}]/u], // Numeric & whitespace
14	['#', /[\d\-+]/], // Numeric and sign
15	]);
16
17	/** @hidden */
18	export interface MaskOptions {
19	format: string;
20	promptChar: string;
21	}
22
23	/** @hidden */
24	export interface Replaced {
25	value: string;
26	end: number;
27	}
28
29	interface ParsedMask {
30	literals: Map<number, string>,
31	mask: string
32	}
33
34	const replaceCharAt = (string: string, idx: number, char: string) =>	2✔
UNCOV 35	`${string.substring(0, idx)}${char}${string.substring(idx + 1)}`;	×
36
37
38	export function parseMask(format: string): ParsedMask {
39	const literals = new Map<number, string>();	4✔
40	let mask = format;	4✔
41
42	for (let i = 0, j = 0; i < format.length; i++, j++) {	4✔
43	const [current, next] = [format.charAt(i), format.charAt(i + 1)];	40✔
44
45	if (current === '\\' && FLAGS.has(next)) {	40!
UNCOV 46	mask = replaceCharAt(mask, j, '');	×
UNCOV 47	literals.set(j, next);	×
UNCOV 48	i++;	×
49	} else {
50	if (!FLAGS.has(current)) {	40!
UNCOV 51	literals.set(j, current);	×
52	}
53	}
54	}
55
56	return { literals, mask };	4✔
57	}
58
59	/** @hidden */
60	@Injectable({
61	providedIn: 'root'
62	})
63	export class MaskParsingService {	2✔
64
65	public applyMask(inputVal: string, maskOptions: MaskOptions, pos = 0): string {	×
UNCOV 66	let outputVal = '';	×
UNCOV 67	let value = '';	×
UNCOV 68	const { literals, mask } = parseMask(maskOptions.format);	×
UNCOV 69	const literalKeys: number[] = Array.from(literals.keys());	×
UNCOV 70	const nonLiteralIndices: number[] = this.getNonLiteralIndices(mask, literalKeys);	×
UNCOV 71	const literalValues: string[] = Array.from(literals.values());	×
72
UNCOV 73	if (inputVal != null) {	×
UNCOV 74	value = inputVal.toString();	×
75	}
76
UNCOV 77	for (const _maskSym of mask) {	×
UNCOV 78	outputVal += maskOptions.promptChar;	×
79	}
80
UNCOV 81	literals.forEach((val: string, key: number) => {	×
UNCOV 82	outputVal = replaceCharAt(outputVal, key, val);	×
83	});
84
UNCOV 85	if (!value) {	×
UNCOV 86	return outputVal;	×
87	}
88
UNCOV 89	const nonLiteralValues: string[] = this.getNonLiteralValues(value, literalValues);	×
90
UNCOV 91	for (let i = 0; i < nonLiteralValues.length; i++) {	×
UNCOV 92	const char = nonLiteralValues[i];	×
UNCOV 93	const isCharValid = this.validateCharOnPosition(char, nonLiteralIndices[i], mask);	×
94
UNCOV 95	if (!isCharValid && char !== maskOptions.promptChar) {	×
UNCOV 96	nonLiteralValues[i] = maskOptions.promptChar;	×
97	}
98	}
99
UNCOV 100	if (nonLiteralValues.length > nonLiteralIndices.length) {	×
UNCOV 101	nonLiteralValues.splice(nonLiteralIndices.length);	×
102	}
103
UNCOV 104	for (const nonLiteralValue of nonLiteralValues) {	×
UNCOV 105	const char = nonLiteralValue;	×
UNCOV 106	outputVal = replaceCharAt(outputVal, nonLiteralIndices[pos++], char);	×
107	}
108
UNCOV 109	return outputVal;	×
110	}
111
112	public parseValueFromMask(maskedValue: string, maskOptions: MaskOptions): string {
113	let outputVal = '';	4✔
114	const literalValues: string[] = Array.from(parseMask(maskOptions.format).literals.values());	4✔
115
116	for (const val of maskedValue) {	4✔
UNCOV 117	if (literalValues.indexOf(val) === -1) {	×
UNCOV 118	if (val !== maskOptions.promptChar) {	×
UNCOV 119	outputVal += val;	×
120	}
121	}
122	}
123
124	return outputVal;	4✔
125	}
126
127	public replaceInMask(maskedValue: string, value: string, maskOptions: MaskOptions, start: number, end: number): Replaced {
UNCOV 128	const { literals, mask } = parseMask(maskOptions.format);	×
UNCOV 129	const literalsPositions = Array.from(literals.keys());	×
UNCOV 130	value = this.replaceIMENumbers(value);	×
UNCOV 131	const chars = Array.from(value);	×
UNCOV 132	let cursor = start;	×
UNCOV 133	end = Math.min(end, maskedValue.length);	×
134
UNCOV 135	for (let i = start; i < end \|\| (chars.length && i < maskedValue.length); i++) {	×
UNCOV 136	if (literalsPositions.indexOf(i) !== -1) {	×
UNCOV 137	if (chars[0] === maskedValue[i] \|\| value.length < 1) {	×
UNCOV 138	cursor = i + 1;	×
UNCOV 139	chars.shift();	×
140	}
UNCOV 141	continue;	×
142	}
UNCOV 143	if (chars[0]	×
144	&& !this.validateCharOnPosition(chars[0], i, mask)
145	&& chars[0] !== maskOptions.promptChar) {
UNCOV 146	break;	×
147	}
148
UNCOV 149	let char = maskOptions.promptChar;	×
UNCOV 150	if (chars.length) {	×
UNCOV 151	cursor = i + 1;	×
UNCOV 152	char = chars.shift();	×
153	}
UNCOV 154	if (value.length < 1) {	×
155	// on `delete` the cursor should move forward
UNCOV 156	cursor++;	×
157	}
UNCOV 158	maskedValue = replaceCharAt(maskedValue, i, char);	×
159	}
160
UNCOV 161	return { value: maskedValue, end: cursor };	×
162	}
163
164	/** Validates only non literal positions. */
165	private validateCharOnPosition(inputChar: string, position: number, mask: string): boolean {
UNCOV 166	const regex = REGEX.get(mask.charAt(position));	×
UNCOV 167	return regex ? regex.test(inputChar) : false;	×
168	}
169
170	private getNonLiteralIndices(mask: string, literalKeys: number[]): number[] {
UNCOV 171	const nonLiteralsIndices: number[] = [];	×
172
UNCOV 173	for (let i = 0; i < mask.length; i++) {	×
UNCOV 174	if (literalKeys.indexOf(i) === -1) {	×
UNCOV 175	nonLiteralsIndices.push(i);	×
176	}
177	}
178
UNCOV 179	return nonLiteralsIndices;	×
180	}
181	private getNonLiteralValues(value: string, literalValues: string[]): string[] {
UNCOV 182	const nonLiteralValues: string[] = [];	×
183
UNCOV 184	for (const val of value) {	×
UNCOV 185	if (literalValues.indexOf(val) === -1) {	×
UNCOV 186	nonLiteralValues.push(val);	×
187	}
188	}
189
UNCOV 190	return nonLiteralValues;	×
191	}
192
193	private replaceIMENumbers(value: string): string {
UNCOV 194	return value.replace(/[０１２３４５６７８９]/g, (num) => ({	×
195	'１': '1', '２': '2', '３': '3', '４': '4', '５': '5',
196	'６': '6', '７': '7', '８': '8', '９': '9', '０': '0'
197	}[num]));
198	}
199	}

IgniteUI / igniteui-angular / 13331632524

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous