cd64db52-e563-41a3-85f3-a0adb87ce135

Committed 30 Oct 2024 08:03AM UTC coverage: 90.402% (-0.04%) from 90.438%

Build # cd64db52-e563-41a3-85f3-a0adb87ce135

Build Type

push

circleci

Committed by

web-flow

Commit Message

refactor: refactor constructor to the inject function (#3222)

Run Details

5503 of 6730 branches covered (81.77%)

Branch coverage included in aggregate %.

422 of 429 new or added lines in 170 files covered. (98.37%)

344 existing lines in 81 files now uncovered.

13184 of 13941 relevant lines covered (94.57%)

997.19 hits per line

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

98.44

/src/input-number/input-number.component.ts

import { TabIndexDisabledControlValueAccessorMixin, useHostFocusControl } from 'ngx-tethys/core';
import { ThyMaxDirective, ThyMinDirective } from 'ngx-tethys/form';
import { ThyIcon } from 'ngx-tethys/icon';
import { ThyInputDirective } from 'ngx-tethys/input';
import { ThyAutofocusDirective } from 'ngx-tethys/shared';
import { coerceBooleanProperty, DOWN_ARROW, ENTER, isFloat, isNumber, isUndefinedOrNull, UP_ARROW } from 'ngx-tethys/util';

import { FocusOrigin } from '@angular/cdk/a11y';
import {
    ChangeDetectorRef,
    Component,
    ElementRef,
    EventEmitter,
    forwardRef,
    Input,
    numberAttribute,
    OnChanges,
    OnDestroy,
    OnInit,
    Output,
    SimpleChanges,
    ViewChild,
    inject
} from '@angular/core';
import { ControlValueAccessor, FormsModule, NG_VALUE_ACCESSOR } from '@angular/forms';

type InputSize = 'xs' | 'sm' | 'md' | 'lg' | '';

enum Type {
    up,
    down
}

/**
 * 数字输入框
 * @name thy-input-number
 * @order 10
 */
@Component({
    selector: 'thy-input-number',
    templateUrl: './input-number.component.html',
    providers: [
        {
            provide: NG_VALUE_ACCESSOR,
            useExisting: forwardRef(() => ThyInputNumber),
            multi: true
        }
    ],
    standalone: true,
    imports: [ThyIcon, ThyInputDirective, ThyAutofocusDirective, FormsModule, ThyMinDirective, ThyMaxDirective],
    host: {
        class: 'thy-input-number',
        '[attr.tabindex]': 'tabIndex'
    }
})
export class ThyInputNumber
    extends TabIndexDisabledControlValueAccessorMixin
    implements ControlValueAccessor, OnChanges, OnInit, OnDestroy
{
    private cdr = inject(ChangeDetectorRef);

    @ViewChild('input', { static: true }) inputElement: ElementRef<any>;

    private autoStepTimer: any;

    private hostFocusControl = useHostFocusControl();

    validValue: number | string;

    displayValue: number | string;

    disabledUp = false;

    disabledDown = false;

    activeValue: string = '';

    /**
     * 是否自动聚焦
     * @default false
     */
    @Input({ transform: coerceBooleanProperty }) thyAutoFocus: boolean;

    /**
     * 输入框的placeholder
     */
    @Input() thyPlaceholder: string = '';

    /**
     * 是否禁用
     * @default false
     */
    @Input({ transform: coerceBooleanProperty }) thyDisabled: boolean;

    /**
     * 最大值
     * @default Infinity
     */
    @Input() set thyMax(value: number) {
        this.innerMax = isNumber(value) ? value : this.innerMax;
        if (this.displayValue || this.displayValue === 0) {
            const val = Number(this.displayValue);
            this.disabledUp = val >= this.innerMax;
        }
    }

    get thyMax() {
        return this.innerMax;
    }

    /**
     * 最小值
     * @default -Infinity
     */
    @Input() set thyMin(value: number) {
        this.innerMin = isNumber(value) ? value : this.innerMin;
        if (this.displayValue || this.displayValue === 0) {
            const val = Number(this.displayValue);
            this.disabledDown = val <= this.innerMin;
        }
    }

    get thyMin() {
        return this.innerMin;
    }

    /**
     * 每次改变步数，可以为小数
     */
    @Input({ transform: numberAttribute }) thyStep = 1;

    /**
     * 改变步数时的延迟毫秒数，值越小变化的速度越快
     * @default 300
     */
    @Input({ transform: numberAttribute }) thyStepDelay = 300;

    /**
     * 输入框大小
     * @type xs | sm | md | lg
     */
    @Input() thySize: InputSize;

    /**
     * 数值精度
     */
    @Input() thyPrecision: number;

    /**
     * 数值后缀
     */
    @Input() thySuffix: string;

    /**
     * 焦点失去事件
     */
    @Output() thyBlur = new EventEmitter<Event>();

    /**
     * 焦点激活事件
     */
    @Output() thyFocus = new EventEmitter<Event>();

    /**
     * 上下箭头点击事件
     */
    @Output() thyStepChange = new EventEmitter<{ value: number; type: Type }>();

    private innerMax: number = Infinity;

    private innerMin: number = -Infinity;

    private isFocused: boolean;

    constructor() {
        super();
    }

    setDisabledState?(isDisabled: boolean): void {
        this.thyDisabled = isDisabled;
    }

    ngOnInit() {
        this.hostFocusControl.focusChanged = (origin: FocusOrigin) => {
            if (this.thyDisabled) {
                return;
            }

            if (origin) {
                if (!this.isFocused) {
                    this.inputElement.nativeElement.focus();
                }
            } else {
                if (this.isFocused) {
                    this.displayValue = this.formatterValue(this.validValue);
                    this.onTouchedFn();
                    this.thyBlur.emit();
                    this.isFocused = false;
                }
            }
        };
    }

    ngOnChanges(changes: SimpleChanges) {
        if (changes.thySuffix && !changes.thySuffix.isFirstChange()) {
            const validValue = this.getCurrentValidValue(this.validValue);
            this.updateValidValue(validValue);
            this.displayValue = this.formatterValue(validValue);
        }
    }

    writeValue(value: number | string): void {
        const _value = this.getCurrentValidValue(value);
        this.updateValidValue(_value);
        this.displayValue = this.formatterValue(_value);
        this.cdr.markForCheck();
    }

    updateValidValue(value: number | string): void {
        if (this.isNotValid(value)) {
            this.validValue = '';
        } else if (this.validValue !== value) {
            this.validValue = value;
        }
        this.disabledUp = this.disabledDown = false;
        if (value || value === 0) {
            const val = Number(value);
            if (val >= this.thyMax) {
                this.disabledUp = true;
            }
            if (val <= this.thyMin) {
                this.disabledDown = true;
            }
        }
    }

    onModelChange(value: string): void {
        const parseValue = this.parser(value);
        if (this.isInputNumber(value)) {
            this.activeValue = value;
        } else {
            this.displayValue = parseValue;
            this.inputElement.nativeElement.value = parseValue;
        }
        const validValue = this.getCurrentValidValue(parseValue);
        if (`${this.validValue}` !== `${validValue}`) {
            this.updateValidValue(validValue);
            this.onChangeFn(validValue);
        }
    }

    onInputFocus(event?: Event) {
        this.activeValue = this.parser(this.displayValue.toString());
        if (!this.isFocused) {
            this.isFocused = true;
            this.thyFocus.emit(event);
        }
    }

    onKeyDown(e: KeyboardEvent): void {
        if (e.keyCode === UP_ARROW) {
            this.up(e);
            this.stop();
        } else if (e.keyCode === DOWN_ARROW) {
            this.down(e);
            this.stop();
        } else if (e.keyCode === ENTER) {
            this.displayValue = this.formatterValue(this.validValue);
        }
    }

    stop() {
        if (this.autoStepTimer) {
            clearTimeout(this.autoStepTimer);
        }
        this.displayValue = this.toNumber(this.displayValue);
    }

    step(type: Type, e: MouseEvent | KeyboardEvent): void {
        this.stop();
        e.preventDefault();
        if (this.thyDisabled) {
            return;
        }
        const value = this.validValue as number;
        let val;
        if (type === Type.up) {
            val = this.upStep(value);
        } else if (type === Type.down) {
            val = this.downStep(value);
        }
        const outOfRange = val > this.thyMax || val < this.thyMin;
        val = this.getCurrentValidValue(val);
        this.updateValidValue(val);
        this.onChangeFn(this.validValue);
        this.thyStepChange.emit({ value: this.validValue as number, type });
        this.displayValue = this.formatterValue(val);
        if (outOfRange) {
            return;
        }
        this.autoStepTimer = setTimeout(() => {
            (this[Type[type]] as (e: MouseEvent | KeyboardEvent) => void)(e);
        }, this.thyStepDelay);
    }

    upStep(value: number): number {
        const precisionFactor = this.getPrecisionFactor(value);
        const precision = this.getMaxPrecision(value);
        const result = ((precisionFactor * value + precisionFactor * this.thyStep) / precisionFactor).toFixed(precision);
        return this.toNumber(result);
    }

    downStep(value: number): number {
        const precisionFactor = this.getPrecisionFactor(value);
        const precision = Math.abs(this.getMaxPrecision(value));
        const result = ((precisionFactor * value - precisionFactor * this.thyStep) / precisionFactor).toFixed(precision);
        return this.toNumber(result);
    }

    getMaxPrecision(value: string | number): number {
        if (!isUndefinedOrNull(this.thyPrecision)) {
            return this.thyPrecision;
        }
        const stepPrecision = this.getPrecision(this.thyStep);
        const currentValuePrecision = this.getPrecision(value as number);
        if (!value) {
            return stepPrecision;
        }
        return Math.max(currentValuePrecision, stepPrecision);
    }

    getPrecisionFactor(activeValue: string | number): number {
        const precision = this.getMaxPrecision(activeValue);
        return Math.pow(10, precision);
    }

    getPrecision(value: number): number {
        const valueString = value.toString();
        // 0.0000000004.toString() = 4e10  => 10
        if (valueString.indexOf('e-') >= 0) {
            return parseInt(valueString.slice(valueString.indexOf('e-') + 2), 10);
        }
        let precision = 0;
        // 1.2222 =>  4
        if (valueString.indexOf('.') >= 0) {
            precision = valueString.length - valueString.indexOf('.') - 1;
        }
        return precision;
    }

    up(e: MouseEvent | KeyboardEvent) {
        this.inputElement.nativeElement.focus();
        this.step(Type.up, e);
    }

    down(e: MouseEvent | KeyboardEvent) {
        this.inputElement.nativeElement.focus();
        this.step(Type.down, e);
    }

    formatterValue(value: number | string) {
        const parseValue = this.parser(`${value}`);
        if (parseValue) {
            return this.thySuffix ? `${parseValue} ${this.thySuffix}` : parseValue;
        } else {
            return '';
        }
    }

    parser(value: string) {
        return value
            .trim()
            .replace(/。/g, '.')
            .replace(/[^\w\.-]+/g, '')
            .replace(this.thySuffix, '');
    }

    getCurrentValidValue(value: string | number): number | string {
        let val = value;
        if (value === '' || isUndefinedOrNull(value)) {
            return '';
        }
        val = parseFloat(value as string);
        if (this.isNotValid(val)) {
            val = this.validValue;
        }
        if ((val as number) < this.thyMin) {
            val = this.thyMin;
        }
        if ((val as number) > this.thyMax) {
            val = this.thyMax;
        }

        return this.toNumber(val);
    }

    isNotValid(num: string | number): boolean {
        return isNaN(num as number) || num === '' || num === null || !!(num && num.toString().indexOf('.') === num.toString().length - 1);
    }

    toNumber(num: string | number): number {
        if (this.isNotValid(num)) {
            return num as number;
        }
        const numStr = String(num);
        if (numStr.indexOf('.') >= 0 && !isUndefinedOrNull(this.thyPrecision)) {
            return Number(Number(num).toFixed(this.thyPrecision));
        }
        return Number(num);
    }

    isInputNumber(value: string) {
        return isFloat(value) || /^[-+Ee]$|^([-+.]?[0-9])*(([.]|[.eE])?[eE]?[+-]?)?$|^$/.test(value);
    }

    ngOnDestroy() {
        this.hostFocusControl.destroy();
    }
}

1	import { TabIndexDisabledControlValueAccessorMixin, useHostFocusControl } from 'ngx-tethys/core';
2	import { ThyMaxDirective, ThyMinDirective } from 'ngx-tethys/form';
3	import { ThyIcon } from 'ngx-tethys/icon';
4	import { ThyInputDirective } from 'ngx-tethys/input';
5	import { ThyAutofocusDirective } from 'ngx-tethys/shared';
6	import { coerceBooleanProperty, DOWN_ARROW, ENTER, isFloat, isNumber, isUndefinedOrNull, UP_ARROW } from 'ngx-tethys/util';
7
8	import { FocusOrigin } from '@angular/cdk/a11y';
9	import {
10	ChangeDetectorRef,
11	Component,
12	ElementRef,	1✔
13	EventEmitter,	1✔
14	forwardRef,	1✔
15	Input,	2✔
16	numberAttribute,
17	OnChanges,
18	OnDestroy,
19	OnInit,
20	Output,
21	SimpleChanges,	1✔
22	ViewChild,
23	inject	114✔
24	} from '@angular/core';	114✔
25	import { ControlValueAccessor, FormsModule, NG_VALUE_ACCESSOR } from '@angular/forms';	4✔
26		4✔
27	type InputSize = 'xs' \| 'sm' \| 'md' \| 'lg' \| '';
28
29	enum Type {
30	up,	921✔
31	down
32	}
33		114✔
34	/**	114✔
35	* 数字输入框	4✔
36	* @name thy-input-number	4✔
37	* @order 10
38	*/
39	@Component({
40	selector: 'thy-input-number',	922✔
41	templateUrl: './input-number.component.html',
42	providers: [
43	{	110✔
44	provide: NG_VALUE_ACCESSOR,	110✔
45	useExisting: forwardRef(() => ThyInputNumber),	110✔
46	multi: true	110✔
47	}	110✔
48	],	110✔
49	standalone: true,	110✔
50	imports: [ThyIcon, ThyInputDirective, ThyAutofocusDirective, FormsModule, ThyMinDirective, ThyMaxDirective],	110✔
51	host: {	110✔
52	class: 'thy-input-number',	110✔
53	'[attr.tabindex]': 'tabIndex'	110✔
54	}	110✔
55	})	110✔
56	export class ThyInputNumber	110✔
57	extends TabIndexDisabledControlValueAccessorMixin
58	implements ControlValueAccessor, OnChanges, OnInit, OnDestroy
59	{	110✔
60	private cdr = inject(ChangeDetectorRef);
61
62	@ViewChild('input', { static: true }) inputElement: ElementRef<any>;	110✔
63		37✔
64	private autoStepTimer: any;	4✔
65
66	private hostFocusControl = useHostFocusControl();	33✔
67		26✔
68	validValue: number \| string;	23✔
69
70	displayValue: number \| string;
71
72	disabledUp = false;	7✔
73		6✔
74	disabledDown = false;	6✔
75		6✔
76	activeValue: string = '';	6✔
77
78	/**
79	* 是否自动聚焦
80	* @default false
81	*/
82	@Input({ transform: coerceBooleanProperty }) thyAutoFocus: boolean;	137✔
83		2✔
84	/**	2✔
85	* 输入框的placeholder	2✔
86	*/
87	@Input() thyPlaceholder: string = '';
88
89	/**	257✔
90	* 是否禁用	257✔
91	* @default false	257✔
92	*/	257✔
93	@Input({ transform: coerceBooleanProperty }) thyDisabled: boolean;
94
95	/**	306✔
96	* 最大值	174✔
97	* @default Infinity
98	*/	132✔
99	@Input() set thyMax(value: number) {	129✔
100	this.innerMax = isNumber(value) ? value : this.innerMax;
101	if (this.displayValue \|\| this.displayValue === 0) {	306✔
102	const val = Number(this.displayValue);	306✔
103	this.disabledUp = val >= this.innerMax;	132✔
104	}	132✔
105	}	21✔
106
107	get thyMax() {	132✔
108	return this.innerMax;	20✔
109	}
110
111	/**
112	* 最小值
113	* @default -Infinity	20✔
114	*/	20✔
115	@Input() set thyMin(value: number) {	18✔
116	this.innerMin = isNumber(value) ? value : this.innerMin;
117	if (this.displayValue \|\| this.displayValue === 0) {
118	const val = Number(this.displayValue);	2✔
119	this.disabledDown = val <= this.innerMin;	2✔
120	}
121	}	20✔
122		20✔
123	get thyMin() {	14✔
124	return this.innerMin;	14✔
125	}
126
127	/**
128	* 每次改变步数，可以为小数	24✔
129	*/	24✔
130	@Input({ transform: numberAttribute }) thyStep = 1;	16✔
131		16✔
132	/**
133	* 改变步数时的延迟毫秒数，值越小变化的速度越快
134	* @default 300
135	*/	7✔
136	@Input({ transform: numberAttribute }) thyStepDelay = 300;	1✔
137		1✔
138	/**
139	* 输入框大小	6✔
140	* @type xs \| sm \| md \| lg	1✔
141	*/	1✔
142	@Input() thySize: InputSize;
143		5!
144	/**	5✔
145	* 数值精度
146	*/
147	@Input() thyPrecision: number;
148		47✔
149	/**	40✔
150	* 数值后缀
151	*/	47✔
152	@Input() thySuffix: string;
153
154	/**	34✔
155	* 焦点失去事件	34✔
156	*/	34✔
157	@Output() thyBlur = new EventEmitter<Event>();	1✔
158
159	/**	33✔
160	* 焦点激活事件
161	*/	33✔
162	@Output() thyFocus = new EventEmitter<Event>();	19✔
163
164	/**	14!
165	* 上下箭头点击事件	14✔
166	*/
167	@Output() thyStepChange = new EventEmitter<{ value: number; type: Type }>();	33✔
168		33✔
169	private innerMax: number = Infinity;	33✔
170		33✔
171	private innerMin: number = -Infinity;	33✔
172		33✔
173	private isFocused: boolean;	33✔
174		2✔
175	constructor() {
176	super();	31✔
177	}	20✔
178
179	setDisabledState?(isDisabled: boolean): void {
180	this.thyDisabled = isDisabled;
181	}	19✔
182		19✔
183	ngOnInit() {	19✔
184	this.hostFocusControl.focusChanged = (origin: FocusOrigin) => {	19✔
185	if (this.thyDisabled) {
186	return;
187	}	14✔
188		14✔
189	if (origin) {	14✔
190	if (!this.isFocused) {	14✔
191	this.inputElement.nativeElement.focus();
192	}
193	} else {	66✔
194	if (this.isFocused) {	62✔
195	this.displayValue = this.formatterValue(this.validValue);
196	this.onTouchedFn();	4✔
197	this.thyBlur.emit();	4✔
198	this.isFocused = false;	4!
UNCOV 199	}	×
200	}
201	};	4✔
202	}
203
204	ngOnChanges(changes: SimpleChanges) {	33✔
205	if (changes.thySuffix && !changes.thySuffix.isFirstChange()) {	33✔
206	const validValue = this.getCurrentValidValue(this.validValue);
207	this.updateValidValue(validValue);
208	this.displayValue = this.formatterValue(validValue);	8✔
209	}
210	}	8✔
211		2✔
212	writeValue(value: number \| string): void {
213	const _value = this.getCurrentValidValue(value);	6✔
214	this.updateValidValue(_value);
215	this.displayValue = this.formatterValue(_value);	6✔
216	this.cdr.markForCheck();	2✔
217	}
218		6✔
219	updateValidValue(value: number \| string): void {
220	if (this.isNotValid(value)) {
221	this.validValue = '';	20✔
222	} else if (this.validValue !== value) {	20✔
223	this.validValue = value;
224	}
225	this.disabledUp = this.disabledDown = false;	14✔
226	if (value \|\| value === 0) {	14✔
227	const val = Number(value);
228	if (val >= this.thyMax) {
229	this.disabledUp = true;	303✔
230	}	303✔
231	if (val <= this.thyMin) {	125✔
232	this.disabledDown = true;
233	}
234	}	178✔
235	}
236
237	onModelChange(value: string): void {
238	const parseValue = this.parser(value);	346✔
239	if (this.isInputNumber(value)) {
240	this.activeValue = value;
241	} else {
242	this.displayValue = parseValue;
243	this.inputElement.nativeElement.value = parseValue;
244	}
245	const validValue = this.getCurrentValidValue(parseValue);	309✔
246	if (`${this.validValue}` !== `${validValue}`) {	309✔
247	this.updateValidValue(validValue);	173✔
248	this.onChangeFn(validValue);
249	}	136✔
250	}	136✔
251		2✔
252	onInputFocus(event?: Event) {
253	this.activeValue = this.parser(this.displayValue.toString());	136✔
254	if (!this.isFocused) {	6✔
255	this.isFocused = true;
256	this.thyFocus.emit(event);	136✔
257	}	4✔
258	}
259		136✔
260	onKeyDown(e: KeyboardEvent): void {
261	if (e.keyCode === UP_ARROW) {
262	this.up(e);	658✔
263	this.stop();
264	} else if (e.keyCode === DOWN_ARROW) {
265	this.down(e);	216✔
266	this.stop();	6✔
267	} else if (e.keyCode === ENTER) {
268	this.displayValue = this.formatterValue(this.validValue);	210✔
269	}	210✔
270	}	37✔
271
272	stop() {	173✔
273	if (this.autoStepTimer) {
274	clearTimeout(this.autoStepTimer);
275	}	41✔
276	this.displayValue = this.toNumber(this.displayValue);
277	}
278		110✔
279	step(type: Type, e: MouseEvent \| KeyboardEvent): void {
280	this.stop();	1✔
281	e.preventDefault();	1✔
282	if (this.thyDisabled) {
283	return;
284	}
285	const value = this.validValue as number;
286	let val;
287	if (type === Type.up) {
288	val = this.upStep(value);
289	} else if (type === Type.down) {
290	val = this.downStep(value);
291	}
292	const outOfRange = val > this.thyMax \|\| val < this.thyMin;
293	val = this.getCurrentValidValue(val);
294	this.updateValidValue(val);
295	this.onChangeFn(this.validValue);
296	this.thyStepChange.emit({ value: this.validValue as number, type });
297	this.displayValue = this.formatterValue(val);
298	if (outOfRange) {	1✔
299	return;
300	}
301	this.autoStepTimer = setTimeout(() => {
302	(this[Type[type]] as (e: MouseEvent \| KeyboardEvent) => void)(e);
303	}, this.thyStepDelay);
304	}
305		110✔
306	upStep(value: number): number {
307	const precisionFactor = this.getPrecisionFactor(value);
308	const precision = this.getMaxPrecision(value);
309	const result = ((precisionFactor * value + precisionFactor * this.thyStep) / precisionFactor).toFixed(precision);
310	return this.toNumber(result);
311	}
312
313	downStep(value: number): number {
314	const precisionFactor = this.getPrecisionFactor(value);
315	const precision = Math.abs(this.getMaxPrecision(value));
316	const result = ((precisionFactor * value - precisionFactor * this.thyStep) / precisionFactor).toFixed(precision);
317	return this.toNumber(result);
318	}
319
320	getMaxPrecision(value: string \| number): number {
321	if (!isUndefinedOrNull(this.thyPrecision)) {
322	return this.thyPrecision;
323	}
324	const stepPrecision = this.getPrecision(this.thyStep);
325	const currentValuePrecision = this.getPrecision(value as number);
326	if (!value) {
327	return stepPrecision;
328	}
329	return Math.max(currentValuePrecision, stepPrecision);
330	}
331
332	getPrecisionFactor(activeValue: string \| number): number {
333	const precision = this.getMaxPrecision(activeValue);
334	return Math.pow(10, precision);
335	}
336
337	getPrecision(value: number): number {
338	const valueString = value.toString();
339	// 0.0000000004.toString() = 4e10 => 10
340	if (valueString.indexOf('e-') >= 0) {
341	return parseInt(valueString.slice(valueString.indexOf('e-') + 2), 10);
342	}
343	let precision = 0;
344	// 1.2222 => 4
345	if (valueString.indexOf('.') >= 0) {
346	precision = valueString.length - valueString.indexOf('.') - 1;
347	}
348	return precision;
349	}
350
351	up(e: MouseEvent \| KeyboardEvent) {
352	this.inputElement.nativeElement.focus();
353	this.step(Type.up, e);
354	}
355
356	down(e: MouseEvent \| KeyboardEvent) {
357	this.inputElement.nativeElement.focus();
358	this.step(Type.down, e);
359	}
360
361	formatterValue(value: number \| string) {
362	const parseValue = this.parser(`${value}`);
363	if (parseValue) {
364	return this.thySuffix ? `${parseValue} ${this.thySuffix}` : parseValue;
365	} else {
366	return '';
367	}
368	}
369
370	parser(value: string) {
371	return value
372	.trim()
373	.replace(/。/g, '.')
374	.replace(/[^\w\.-]+/g, '')
375	.replace(this.thySuffix, '');
376	}
377
378	getCurrentValidValue(value: string \| number): number \| string {
379	let val = value;
380	if (value === '' \|\| isUndefinedOrNull(value)) {
381	return '';
382	}
383	val = parseFloat(value as string);
384	if (this.isNotValid(val)) {
385	val = this.validValue;
386	}
387	if ((val as number) < this.thyMin) {
388	val = this.thyMin;
389	}
390	if ((val as number) > this.thyMax) {
391	val = this.thyMax;
392	}
393
394	return this.toNumber(val);
395	}
396
397	isNotValid(num: string \| number): boolean {
398	return isNaN(num as number) \|\| num === '' \|\| num === null \|\| !!(num && num.toString().indexOf('.') === num.toString().length - 1);
399	}
400
401	toNumber(num: string \| number): number {
402	if (this.isNotValid(num)) {
403	return num as number;
404	}
405	const numStr = String(num);
406	if (numStr.indexOf('.') >= 0 && !isUndefinedOrNull(this.thyPrecision)) {
407	return Number(Number(num).toFixed(this.thyPrecision));
408	}
409	return Number(num);
410	}
411
412	isInputNumber(value: string) {
413	return isFloat(value) \|\| /^[-+Ee]$\|^([-+.]?[0-9])*(([.]\|[.eE])?[eE]?[+-]?)?$\|^$/.test(value);
414	}
415
416	ngOnDestroy() {
417	this.hostFocusControl.destroy();
418	}
419	}

atinc / ngx-tethys / cd64db52-e563-41a3-85f3-a0adb87ce135

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