@taiga-ui/kit 4.19.0-canary.2c14206 → 4.19.0-canary.c786189

package/components/index.d.ts

@@ -21,6 +21,7 @@ export * from '@taiga-ui/kit/components/elastic-container';
 export * from '@taiga-ui/kit/components/files';
 export * from '@taiga-ui/kit/components/filter';
 export * from '@taiga-ui/kit/components/input-inline';
+export * from '@taiga-ui/kit/components/input-number';
 export * from '@taiga-ui/kit/components/input-password';
 export * from '@taiga-ui/kit/components/input-phone-international';
 export * from '@taiga-ui/kit/components/items-with-more';

package/components/input-number/index.d.ts

@@ -0,0 +1,2 @@
+export * from './input-number.component';
+export * from './input-number.options';

package/components/input-number/input-number.component.d.ts

@@ -0,0 +1,34 @@
+import type { MaskitoOptions } from '@maskito/core';
+import { TuiControl } from '@taiga-ui/cdk/classes';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/components/textfield";
+import * as i2 from "@maskito/angular";
+export declare class TuiInputNumber extends TuiControl<number | null> {
+    private readonly element;
+    private readonly isIOS;
+    private readonly options;
+    private readonly numberFormat;
+    private readonly min;
+    private readonly max;
+    private readonly prefix;
+    private readonly postfix;
+    private readonly precision;
+    private readonly isIntermediateState;
+    protected textfieldValue: import("@angular/core").WritableSignal<string>;
+    protected readonly inputMode: import("@angular/core").Signal<"text" | "decimal" | "numeric">;
+    protected readonly maxLength: import("@angular/core").Signal<number>;
+    protected readonly mask: import("@angular/core").Signal<MaskitoOptions | null>;
+    set minSetter(x: number | null);
+    set maxSetter(x: number | null);
+    set prefixSetter(x: string);
+    set postfixSetter(x: string);
+    writeValue(value: number | null): void;
+    protected onInput(): void;
+    protected onBlur(): void;
+    protected onFocus(): void;
+    private formatNumber;
+    private updateMinMaxLimits;
+    private computeMask;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputNumber, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputNumber, "input[tuiInputNumber]", never, { "minSetter": { "alias": "min"; "required": false; }; "maxSetter": { "alias": "max"; "required": false; }; "prefixSetter": { "alias": "prefix"; "required": false; }; "postfixSetter": { "alias": "postfix"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithTextfield; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }]>;
+}

package/components/input-number/input-number.options.d.ts

@@ -0,0 +1,10 @@
+import type { TuiValueTransformer } from '@taiga-ui/cdk/classes';
+export interface TuiInputNumberOptions {
+    readonly max: number;
+    readonly min: number;
+    readonly prefix: string;
+    readonly postfix: string;
+    readonly valueTransformer: TuiValueTransformer<number | null> | null;
+}
+export declare const TUI_INPUT_NUMBER_DEFAULT_OPTIONS: TuiInputNumberOptions;
+export declare const TUI_INPUT_NUMBER_OPTIONS: import("@angular/core").InjectionToken<TuiInputNumberOptions>, tuiInputNumberOptionsProvider: (item: Partial<TuiInputNumberOptions> | import("@angular/core").ProviderToken<Partial<TuiInputNumberOptions>>) => import("@angular/core").FactoryProvider;

package/esm2022/components/index.mjs

@@ -21,6 +21,7 @@ export * from '@taiga-ui/kit/components/elastic-container';
 export * from '@taiga-ui/kit/components/files';
 export * from '@taiga-ui/kit/components/filter';
 export * from '@taiga-ui/kit/components/input-inline';
+export * from '@taiga-ui/kit/components/input-number';
 export * from '@taiga-ui/kit/components/input-password';
 export * from '@taiga-ui/kit/components/input-phone-international';
 export * from '@taiga-ui/kit/components/items-with-more';
@@ -47,4 +48,4 @@ export * from '@taiga-ui/kit/components/switch';
 export * from '@taiga-ui/kit/components/tabs';
 export * from '@taiga-ui/kit/components/tiles';
 export * from '@taiga-ui/kit/components/tree';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/input-number/index.mjs

@@ -0,0 +1,3 @@
+export * from './input-number.component';
+export * from './input-number.options';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9raXQvY29tcG9uZW50cy9pbnB1dC1udW1iZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9pbnB1dC1udW1iZXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vaW5wdXQtbnVtYmVyLm9wdGlvbnMnO1xuIl19

package/esm2022/components/input-number/input-number.component.mjs

@@ -0,0 +1,199 @@
+import { ChangeDetectionStrategy, Component, computed, inject, Input, signal, } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { MaskitoDirective } from '@maskito/angular';
+import { maskitoInitialCalibrationPlugin } from '@maskito/core';
+import { maskitoCaretGuard, maskitoNumberOptionsGenerator, maskitoParseNumber, } from '@maskito/kit';
+import { TuiControl, tuiValueTransformerFrom } from '@taiga-ui/cdk/classes';
+import { CHAR_HYPHEN, CHAR_MINUS } from '@taiga-ui/cdk/constants';
+import { TUI_IS_IOS, tuiFallbackValueProvider } from '@taiga-ui/cdk/tokens';
+import { tuiInjectElement } from '@taiga-ui/cdk/utils/dom';
+import { tuiIsSafeToRound } from '@taiga-ui/cdk/utils/math';
+import { TuiWithTextfield } from '@taiga-ui/core/components/textfield';
+import { TUI_DEFAULT_NUMBER_FORMAT, TUI_NUMBER_FORMAT } from '@taiga-ui/core/tokens';
+import { tuiFormatNumber } from '@taiga-ui/core/utils/format';
+import { tuiMaskito } from '@taiga-ui/kit/utils';
+import { TUI_INPUT_NUMBER_OPTIONS } from './input-number.options';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/components/textfield";
+import * as i2 from "@maskito/angular";
+const DEFAULT_MAX_LENGTH = 18;
+class TuiInputNumber extends TuiControl {
+    constructor() {
+        super(...arguments);
+        this.element = tuiInjectElement();
+        this.isIOS = inject(TUI_IS_IOS);
+        this.options = inject(TUI_INPUT_NUMBER_OPTIONS);
+        this.numberFormat = toSignal(inject(TUI_NUMBER_FORMAT), {
+            initialValue: TUI_DEFAULT_NUMBER_FORMAT,
+        });
+        this.min = signal(this.options.min);
+        this.max = signal(this.options.max);
+        this.prefix = signal(this.options.prefix);
+        this.postfix = signal(this.options.postfix);
+        this.precision = computed(() => Number.isNaN(this.numberFormat().precision) ? 2 : this.numberFormat().precision);
+        this.isIntermediateState = computed(() => {
+            const value = maskitoParseNumber(this.textfieldValue(), this.numberFormat().decimalSeparator);
+            return value < 0 ? value > this.max() : value < this.min();
+        });
+        this.textfieldValue = signal(this.element.value || '');
+        this.inputMode = computed(() => {
+            if (this.isIOS && this.min() < 0) {
+                // iPhone does not have minus sign if inputMode is equal to 'numeric' / 'decimal'
+                return 'text';
+            }
+            return this.precision() ? 'decimal' : 'numeric';
+        });
+        this.maxLength = computed(() => {
+            const { decimalSeparator, thousandSeparator } = this.numberFormat();
+            const decimalPart = !!this.precision() && this.textfieldValue().includes(decimalSeparator);
+            const precision = decimalPart ? Math.min(this.precision() + 1, 20) : 0;
+            const takeThousand = thousandSeparator.repeat(5).length;
+            return DEFAULT_MAX_LENGTH + precision + takeThousand;
+        });
+        this.mask = tuiMaskito(computed(({ decimalMode, ...numberFormat } = this.numberFormat()) => this.computeMask({
+            ...numberFormat,
+            precision: this.precision(),
+            min: this.min(),
+            max: this.max(),
+            prefix: this.prefix(),
+            postfix: this.postfix(),
+            decimalZeroPadding: decimalMode === 'always',
+        })));
+    }
+    set minSetter(x) {
+        this.updateMinMaxLimits(x, this.max());
+    }
+    set maxSetter(x) {
+        this.updateMinMaxLimits(this.min(), x);
+    }
+    // TODO(v5): replace with signal input
+    set prefixSetter(x) {
+        this.prefix.set(x);
+    }
+    // TODO(v5): replace with signal input
+    set postfixSetter(x) {
+        this.postfix.set(x);
+    }
+    writeValue(value) {
+        super.writeValue(value);
+        this.textfieldValue.set(this.formatNumber(value));
+    }
+    onInput() {
+        const value = this.element.value;
+        const parsedValue = maskitoParseNumber(value, this.numberFormat().decimalSeparator);
+        this.textfieldValue.set(value);
+        if (Number.isNaN(parsedValue)) {
+            this.onChange(null);
+            return;
+        }
+        if (this.isIntermediateState() ||
+            parsedValue < this.min() ||
+            parsedValue > this.max()) {
+            return;
+        }
+        this.onChange(parsedValue);
+    }
+    onBlur() {
+        this.onTouched();
+        if (!this.isIntermediateState()) {
+            this.textfieldValue.set(this.formatNumber(this.value()));
+        }
+    }
+    onFocus() {
+        const value = maskitoParseNumber(this.textfieldValue(), this.numberFormat().decimalSeparator);
+        if (Number.isNaN(value) && !this.readOnly()) {
+            this.textfieldValue.set(this.prefix() + this.postfix());
+        }
+    }
+    formatNumber(value) {
+        if (value === null) {
+            return '';
+        }
+        return (this.prefix() +
+            tuiFormatNumber(value, {
+                ...this.numberFormat(),
+                /**
+                 * Number can satisfy interval [Number.MIN_SAFE_INTEGER; Number.MAX_SAFE_INTEGER]
+                 * but its rounding can violate it.
+                 * Before BigInt support there is no perfect solution – only trade off.
+                 * No rounding is better than lose precision and incorrect mutation of already valid value.
+                 */
+                precision: tuiIsSafeToRound(value, this.precision())
+                    ? this.precision()
+                    : Infinity,
+            }).replace(CHAR_HYPHEN, CHAR_MINUS) +
+            this.postfix());
+    }
+    updateMinMaxLimits(nullableMin, nullableMax) {
+        const min = this.transformer?.fromControlValue(nullableMin) ??
+            nullableMin ??
+            this.options.min;
+        const max = this.transformer?.fromControlValue(nullableMax) ??
+            nullableMax ??
+            this.options.max;
+        this.min.set(Math.min(min, max));
+        this.max.set(Math.max(min, max));
+    }
+    computeMask(params) {
+        const { prefix = '', postfix = '' } = params;
+        const { plugins, ...options } = maskitoNumberOptionsGenerator(params);
+        const initialCalibrationPlugin = maskitoInitialCalibrationPlugin(maskitoNumberOptionsGenerator({
+            ...params,
+            min: Number.MIN_SAFE_INTEGER,
+            max: Number.MAX_SAFE_INTEGER,
+        }));
+        return {
+            ...options,
+            plugins: [
+                ...plugins,
+                initialCalibrationPlugin,
+                maskitoCaretGuard((value) => [
+                    prefix.length,
+                    value.length - postfix.length,
+                ]),
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiInputNumber, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiInputNumber, isStandalone: true, selector: "input[tuiInputNumber]", inputs: { minSetter: ["min", "minSetter"], maxSetter: ["max", "maxSetter"], prefixSetter: ["prefix", "prefixSetter"], postfixSetter: ["postfix", "postfixSetter"] }, host: { listeners: { "input": "onInput()", "blur": "onBlur()", "focus": "onFocus()" }, properties: { "value": "textfieldValue()", "disabled": "disabled()", "attr.inputMode": "inputMode()", "attr.maxLength": "maxLength()" } }, providers: [
+            tuiFallbackValueProvider(null),
+            tuiValueTransformerFrom(TUI_INPUT_NUMBER_OPTIONS),
+        ], usesInheritance: true, hostDirectives: [{ directive: i1.TuiWithTextfield }, { directive: i2.MaskitoDirective }], ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { TuiInputNumber };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiInputNumber, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: 'input[tuiInputNumber]',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [
+                        tuiFallbackValueProvider(null),
+                        tuiValueTransformerFrom(TUI_INPUT_NUMBER_OPTIONS),
+                    ],
+                    hostDirectives: [TuiWithTextfield, MaskitoDirective],
+                    host: {
+                        '[value]': 'textfieldValue()',
+                        '[disabled]': 'disabled()',
+                        '[attr.inputMode]': 'inputMode()',
+                        '[attr.maxLength]': 'maxLength()',
+                        '(input)': 'onInput()',
+                        '(blur)': 'onBlur()',
+                        '(focus)': 'onFocus()',
+                    },
+                }]
+        }], propDecorators: { minSetter: [{
+                type: Input,
+                args: ['min']
+            }], maxSetter: [{
+                type: Input,
+                args: ['max']
+            }], prefixSetter: [{
+                type: Input,
+                args: ['prefix']
+            }], postfixSetter: [{
+                type: Input,
+                args: ['postfix']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-number.component.js","sourceRoot":"","sources":["../../../../../projects/kit/components/input-number/input-number.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ChangeDetectionStrategy,\n    Component,\n    computed,\n    inject,\n    Input,\n    signal,\n} from '@angular/core';\nimport {toSignal} from '@angular/core/rxjs-interop';\nimport {MaskitoDirective} from '@maskito/angular';\nimport type {MaskitoOptions} from '@maskito/core';\nimport {maskitoInitialCalibrationPlugin} from '@maskito/core';\nimport {\n    maskitoCaretGuard,\n    maskitoNumberOptionsGenerator,\n    maskitoParseNumber,\n} from '@maskito/kit';\nimport {TuiControl, tuiValueTransformerFrom} from '@taiga-ui/cdk/classes';\nimport {CHAR_HYPHEN, CHAR_MINUS} from '@taiga-ui/cdk/constants';\nimport {TUI_IS_IOS, tuiFallbackValueProvider} from '@taiga-ui/cdk/tokens';\nimport {tuiInjectElement} from '@taiga-ui/cdk/utils/dom';\nimport {tuiIsSafeToRound} from '@taiga-ui/cdk/utils/math';\nimport {TuiWithTextfield} from '@taiga-ui/core/components/textfield';\nimport {TUI_DEFAULT_NUMBER_FORMAT, TUI_NUMBER_FORMAT} from '@taiga-ui/core/tokens';\nimport {tuiFormatNumber} from '@taiga-ui/core/utils/format';\nimport {tuiMaskito} from '@taiga-ui/kit/utils';\n\nimport {TUI_INPUT_NUMBER_OPTIONS} from './input-number.options';\n\nconst DEFAULT_MAX_LENGTH = 18;\n\n@Component({\n    standalone: true,\n    selector: 'input[tuiInputNumber]',\n    template: '',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [\n        tuiFallbackValueProvider(null),\n        tuiValueTransformerFrom(TUI_INPUT_NUMBER_OPTIONS),\n    ],\n    hostDirectives: [TuiWithTextfield, MaskitoDirective],\n    host: {\n        '[value]': 'textfieldValue()',\n        '[disabled]': 'disabled()',\n        '[attr.inputMode]': 'inputMode()',\n        '[attr.maxLength]': 'maxLength()',\n        '(input)': 'onInput()',\n        '(blur)': 'onBlur()',\n        '(focus)': 'onFocus()',\n    },\n})\nexport class TuiInputNumber extends TuiControl<number | null> {\n    private readonly element = tuiInjectElement<HTMLInputElement>();\n    private readonly isIOS = inject(TUI_IS_IOS);\n    private readonly options = inject(TUI_INPUT_NUMBER_OPTIONS);\n    private readonly numberFormat = toSignal(inject(TUI_NUMBER_FORMAT), {\n        initialValue: TUI_DEFAULT_NUMBER_FORMAT,\n    });\n\n    private readonly min = signal(this.options.min);\n    private readonly max = signal(this.options.max);\n    private readonly prefix = signal(this.options.prefix);\n    private readonly postfix = signal(this.options.postfix);\n\n    private readonly precision = computed(() =>\n        Number.isNaN(this.numberFormat().precision) ? 2 : this.numberFormat().precision,\n    );\n\n    private readonly isIntermediateState = computed(() => {\n        const value = maskitoParseNumber(\n            this.textfieldValue(),\n            this.numberFormat().decimalSeparator,\n        );\n\n        return value < 0 ? value > this.max() : value < this.min();\n    });\n\n    protected textfieldValue = signal(this.element.value || '');\n\n    protected readonly inputMode = computed(() => {\n        if (this.isIOS && this.min() < 0) {\n            // iPhone does not have minus sign if inputMode is equal to 'numeric' / 'decimal'\n            return 'text';\n        }\n\n        return this.precision() ? 'decimal' : 'numeric';\n    });\n\n    protected readonly maxLength = computed(() => {\n        const {decimalSeparator, thousandSeparator} = this.numberFormat();\n        const decimalPart =\n            !!this.precision() && this.textfieldValue().includes(decimalSeparator);\n        const precision = decimalPart ? Math.min(this.precision() + 1, 20) : 0;\n        const takeThousand = thousandSeparator.repeat(5).length;\n\n        return DEFAULT_MAX_LENGTH + precision + takeThousand;\n    });\n\n    protected readonly mask = tuiMaskito(\n        computed(({decimalMode, ...numberFormat} = this.numberFormat()) =>\n            this.computeMask({\n                ...numberFormat,\n                precision: this.precision(),\n                min: this.min(),\n                max: this.max(),\n                prefix: this.prefix(),\n                postfix: this.postfix(),\n                decimalZeroPadding: decimalMode === 'always',\n            }),\n        ),\n    );\n\n    @Input('min')\n    public set minSetter(x: number | null) {\n        this.updateMinMaxLimits(x, this.max());\n    }\n\n    @Input('max')\n    public set maxSetter(x: number | null) {\n        this.updateMinMaxLimits(this.min(), x);\n    }\n\n    // TODO(v5): replace with signal input\n    @Input('prefix')\n    public set prefixSetter(x: string) {\n        this.prefix.set(x);\n    }\n\n    // TODO(v5): replace with signal input\n    @Input('postfix')\n    public set postfixSetter(x: string) {\n        this.postfix.set(x);\n    }\n\n    public override writeValue(value: number | null): void {\n        super.writeValue(value);\n        this.textfieldValue.set(this.formatNumber(value));\n    }\n\n    protected onInput(): void {\n        const value = this.element.value;\n        const parsedValue = maskitoParseNumber(\n            value,\n            this.numberFormat().decimalSeparator,\n        );\n\n        this.textfieldValue.set(value);\n\n        if (Number.isNaN(parsedValue)) {\n            this.onChange(null);\n\n            return;\n        }\n\n        if (\n            this.isIntermediateState() ||\n            parsedValue < this.min() ||\n            parsedValue > this.max()\n        ) {\n            return;\n        }\n\n        this.onChange(parsedValue);\n    }\n\n    protected onBlur(): void {\n        this.onTouched();\n\n        if (!this.isIntermediateState()) {\n            this.textfieldValue.set(this.formatNumber(this.value()));\n        }\n    }\n\n    protected onFocus(): void {\n        const value = maskitoParseNumber(\n            this.textfieldValue(),\n            this.numberFormat().decimalSeparator,\n        );\n\n        if (Number.isNaN(value) && !this.readOnly()) {\n            this.textfieldValue.set(this.prefix() + this.postfix());\n        }\n    }\n\n    private formatNumber(value: number | null): string {\n        if (value === null) {\n            return '';\n        }\n\n        return (\n            this.prefix() +\n            tuiFormatNumber(value, {\n                ...this.numberFormat(),\n                /**\n                 * Number can satisfy interval [Number.MIN_SAFE_INTEGER; Number.MAX_SAFE_INTEGER]\n                 * but its rounding can violate it.\n                 * Before BigInt support there is no perfect solution – only trade off.\n                 * No rounding is better than lose precision and incorrect mutation of already valid value.\n                 */\n                precision: tuiIsSafeToRound(value, this.precision())\n                    ? this.precision()\n                    : Infinity,\n            }).replace(CHAR_HYPHEN, CHAR_MINUS) +\n            this.postfix()\n        );\n    }\n\n    private updateMinMaxLimits(\n        nullableMin: number | null,\n        nullableMax: number | null,\n    ): void {\n        const min =\n            this.transformer?.fromControlValue(nullableMin) ??\n            nullableMin ??\n            this.options.min;\n        const max =\n            this.transformer?.fromControlValue(nullableMax) ??\n            nullableMax ??\n            this.options.max;\n\n        this.min.set(Math.min(min, max));\n        this.max.set(Math.max(min, max));\n    }\n\n    private computeMask(\n        params: NonNullable<Parameters<typeof maskitoNumberOptionsGenerator>[0]>,\n    ): MaskitoOptions {\n        const {prefix = '', postfix = ''} = params;\n        const {plugins, ...options} = maskitoNumberOptionsGenerator(params);\n        const initialCalibrationPlugin = maskitoInitialCalibrationPlugin(\n            maskitoNumberOptionsGenerator({\n                ...params,\n                min: Number.MIN_SAFE_INTEGER,\n                max: Number.MAX_SAFE_INTEGER,\n            }),\n        );\n\n        return {\n            ...options,\n            plugins: [\n                ...plugins,\n                initialCalibrationPlugin,\n                maskitoCaretGuard((value) => [\n                    prefix.length,\n                    value.length - postfix.length,\n                ]),\n            ],\n        };\n    }\n}\n"]}

package/esm2022/components/input-number/input-number.options.mjs

@@ -0,0 +1,10 @@
+import { tuiCreateOptions } from '@taiga-ui/cdk/utils/di';
+export const TUI_INPUT_NUMBER_DEFAULT_OPTIONS = {
+    min: Number.MIN_SAFE_INTEGER,
+    max: Number.MAX_SAFE_INTEGER,
+    prefix: '',
+    postfix: '',
+    valueTransformer: null,
+};
+export const [TUI_INPUT_NUMBER_OPTIONS, tuiInputNumberOptionsProvider] = tuiCreateOptions(TUI_INPUT_NUMBER_DEFAULT_OPTIONS);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtbnVtYmVyLm9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9raXQvY29tcG9uZW50cy9pbnB1dC1udW1iZXIvaW5wdXQtbnVtYmVyLm9wdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFDLGdCQUFnQixFQUFDLE1BQU0sd0JBQXdCLENBQUM7QUFVeEQsTUFBTSxDQUFDLE1BQU0sZ0NBQWdDLEdBQTBCO0lBQ25FLEdBQUcsRUFBRSxNQUFNLENBQUMsZ0JBQWdCO0lBQzVCLEdBQUcsRUFBRSxNQUFNLENBQUMsZ0JBQWdCO0lBQzVCLE1BQU0sRUFBRSxFQUFFO0lBQ1YsT0FBTyxFQUFFLEVBQUU7SUFDWCxnQkFBZ0IsRUFBRSxJQUFJO0NBQ3pCLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxDQUFDLHdCQUF3QixFQUFFLDZCQUE2QixDQUFDLEdBQUcsZ0JBQWdCLENBQ3JGLGdDQUFnQyxDQUNuQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUge1R1aVZhbHVlVHJhbnNmb3JtZXJ9IGZyb20gJ0B0YWlnYS11aS9jZGsvY2xhc3Nlcyc7XG5pbXBvcnQge3R1aUNyZWF0ZU9wdGlvbnN9IGZyb20gJ0B0YWlnYS11aS9jZGsvdXRpbHMvZGknO1xuXG5leHBvcnQgaW50ZXJmYWNlIFR1aUlucHV0TnVtYmVyT3B0aW9ucyB7XG4gICAgcmVhZG9ubHkgbWF4OiBudW1iZXI7XG4gICAgcmVhZG9ubHkgbWluOiBudW1iZXI7XG4gICAgcmVhZG9ubHkgcHJlZml4OiBzdHJpbmc7XG4gICAgcmVhZG9ubHkgcG9zdGZpeDogc3RyaW5nO1xuICAgIHJlYWRvbmx5IHZhbHVlVHJhbnNmb3JtZXI6IFR1aVZhbHVlVHJhbnNmb3JtZXI8bnVtYmVyIHwgbnVsbD4gfCBudWxsO1xufVxuXG5leHBvcnQgY29uc3QgVFVJX0lOUFVUX05VTUJFUl9ERUZBVUxUX09QVElPTlM6IFR1aUlucHV0TnVtYmVyT3B0aW9ucyA9IHtcbiAgICBtaW46IE51bWJlci5NSU5fU0FGRV9JTlRFR0VSLFxuICAgIG1heDogTnVtYmVyLk1BWF9TQUZFX0lOVEVHRVIsXG4gICAgcHJlZml4OiAnJyxcbiAgICBwb3N0Zml4OiAnJyxcbiAgICB2YWx1ZVRyYW5zZm9ybWVyOiBudWxsLFxufTtcblxuZXhwb3J0IGNvbnN0IFtUVUlfSU5QVVRfTlVNQkVSX09QVElPTlMsIHR1aUlucHV0TnVtYmVyT3B0aW9uc1Byb3ZpZGVyXSA9IHR1aUNyZWF0ZU9wdGlvbnMoXG4gICAgVFVJX0lOUFVUX05VTUJFUl9ERUZBVUxUX09QVElPTlMsXG4pO1xuIl19

package/esm2022/components/input-number/taiga-ui-kit-components-input-number.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFpZ2EtdWkta2l0LWNvbXBvbmVudHMtaW5wdXQtbnVtYmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva2l0L2NvbXBvbmVudHMvaW5wdXQtbnVtYmVyL3RhaWdhLXVpLWtpdC1jb21wb25lbnRzLWlucHV0LW51bWJlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/fesm2022/taiga-ui-kit-components-input-number.mjs

@@ -0,0 +1,214 @@
+import * as i0 from '@angular/core';
+import { inject, signal, computed, Component, ChangeDetectionStrategy, Input } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import * as i2 from '@maskito/angular';
+import { MaskitoDirective } from '@maskito/angular';
+import { maskitoInitialCalibrationPlugin } from '@maskito/core';
+import { maskitoParseNumber, maskitoNumberOptionsGenerator, maskitoCaretGuard } from '@maskito/kit';
+import { TuiControl, tuiValueTransformerFrom } from '@taiga-ui/cdk/classes';
+import { CHAR_HYPHEN, CHAR_MINUS } from '@taiga-ui/cdk/constants';
+import { TUI_IS_IOS, tuiFallbackValueProvider } from '@taiga-ui/cdk/tokens';
+import { tuiInjectElement } from '@taiga-ui/cdk/utils/dom';
+import { tuiIsSafeToRound } from '@taiga-ui/cdk/utils/math';
+import * as i1 from '@taiga-ui/core/components/textfield';
+import { TuiWithTextfield } from '@taiga-ui/core/components/textfield';
+import { TUI_NUMBER_FORMAT, TUI_DEFAULT_NUMBER_FORMAT } from '@taiga-ui/core/tokens';
+import { tuiFormatNumber } from '@taiga-ui/core/utils/format';
+import { tuiMaskito } from '@taiga-ui/kit/utils';
+import { tuiCreateOptions } from '@taiga-ui/cdk/utils/di';
+
+const TUI_INPUT_NUMBER_DEFAULT_OPTIONS = {
+    min: Number.MIN_SAFE_INTEGER,
+    max: Number.MAX_SAFE_INTEGER,
+    prefix: '',
+    postfix: '',
+    valueTransformer: null,
+};
+const [TUI_INPUT_NUMBER_OPTIONS, tuiInputNumberOptionsProvider] = tuiCreateOptions(TUI_INPUT_NUMBER_DEFAULT_OPTIONS);
+
+const DEFAULT_MAX_LENGTH = 18;
+class TuiInputNumber extends TuiControl {
+    constructor() {
+        super(...arguments);
+        this.element = tuiInjectElement();
+        this.isIOS = inject(TUI_IS_IOS);
+        this.options = inject(TUI_INPUT_NUMBER_OPTIONS);
+        this.numberFormat = toSignal(inject(TUI_NUMBER_FORMAT), {
+            initialValue: TUI_DEFAULT_NUMBER_FORMAT,
+        });
+        this.min = signal(this.options.min);
+        this.max = signal(this.options.max);
+        this.prefix = signal(this.options.prefix);
+        this.postfix = signal(this.options.postfix);
+        this.precision = computed(() => Number.isNaN(this.numberFormat().precision) ? 2 : this.numberFormat().precision);
+        this.isIntermediateState = computed(() => {
+            const value = maskitoParseNumber(this.textfieldValue(), this.numberFormat().decimalSeparator);
+            return value < 0 ? value > this.max() : value < this.min();
+        });
+        this.textfieldValue = signal(this.element.value || '');
+        this.inputMode = computed(() => {
+            if (this.isIOS && this.min() < 0) {
+                // iPhone does not have minus sign if inputMode is equal to 'numeric' / 'decimal'
+                return 'text';
+            }
+            return this.precision() ? 'decimal' : 'numeric';
+        });
+        this.maxLength = computed(() => {
+            const { decimalSeparator, thousandSeparator } = this.numberFormat();
+            const decimalPart = !!this.precision() && this.textfieldValue().includes(decimalSeparator);
+            const precision = decimalPart ? Math.min(this.precision() + 1, 20) : 0;
+            const takeThousand = thousandSeparator.repeat(5).length;
+            return DEFAULT_MAX_LENGTH + precision + takeThousand;
+        });
+        this.mask = tuiMaskito(computed(({ decimalMode, ...numberFormat } = this.numberFormat()) => this.computeMask({
+            ...numberFormat,
+            precision: this.precision(),
+            min: this.min(),
+            max: this.max(),
+            prefix: this.prefix(),
+            postfix: this.postfix(),
+            decimalZeroPadding: decimalMode === 'always',
+        })));
+    }
+    set minSetter(x) {
+        this.updateMinMaxLimits(x, this.max());
+    }
+    set maxSetter(x) {
+        this.updateMinMaxLimits(this.min(), x);
+    }
+    // TODO(v5): replace with signal input
+    set prefixSetter(x) {
+        this.prefix.set(x);
+    }
+    // TODO(v5): replace with signal input
+    set postfixSetter(x) {
+        this.postfix.set(x);
+    }
+    writeValue(value) {
+        super.writeValue(value);
+        this.textfieldValue.set(this.formatNumber(value));
+    }
+    onInput() {
+        const value = this.element.value;
+        const parsedValue = maskitoParseNumber(value, this.numberFormat().decimalSeparator);
+        this.textfieldValue.set(value);
+        if (Number.isNaN(parsedValue)) {
+            this.onChange(null);
+            return;
+        }
+        if (this.isIntermediateState() ||
+            parsedValue < this.min() ||
+            parsedValue > this.max()) {
+            return;
+        }
+        this.onChange(parsedValue);
+    }
+    onBlur() {
+        this.onTouched();
+        if (!this.isIntermediateState()) {
+            this.textfieldValue.set(this.formatNumber(this.value()));
+        }
+    }
+    onFocus() {
+        const value = maskitoParseNumber(this.textfieldValue(), this.numberFormat().decimalSeparator);
+        if (Number.isNaN(value) && !this.readOnly()) {
+            this.textfieldValue.set(this.prefix() + this.postfix());
+        }
+    }
+    formatNumber(value) {
+        if (value === null) {
+            return '';
+        }
+        return (this.prefix() +
+            tuiFormatNumber(value, {
+                ...this.numberFormat(),
+                /**
+                 * Number can satisfy interval [Number.MIN_SAFE_INTEGER; Number.MAX_SAFE_INTEGER]
+                 * but its rounding can violate it.
+                 * Before BigInt support there is no perfect solution – only trade off.
+                 * No rounding is better than lose precision and incorrect mutation of already valid value.
+                 */
+                precision: tuiIsSafeToRound(value, this.precision())
+                    ? this.precision()
+                    : Infinity,
+            }).replace(CHAR_HYPHEN, CHAR_MINUS) +
+            this.postfix());
+    }
+    updateMinMaxLimits(nullableMin, nullableMax) {
+        const min = this.transformer?.fromControlValue(nullableMin) ??
+            nullableMin ??
+            this.options.min;
+        const max = this.transformer?.fromControlValue(nullableMax) ??
+            nullableMax ??
+            this.options.max;
+        this.min.set(Math.min(min, max));
+        this.max.set(Math.max(min, max));
+    }
+    computeMask(params) {
+        const { prefix = '', postfix = '' } = params;
+        const { plugins, ...options } = maskitoNumberOptionsGenerator(params);
+        const initialCalibrationPlugin = maskitoInitialCalibrationPlugin(maskitoNumberOptionsGenerator({
+            ...params,
+            min: Number.MIN_SAFE_INTEGER,
+            max: Number.MAX_SAFE_INTEGER,
+        }));
+        return {
+            ...options,
+            plugins: [
+                ...plugins,
+                initialCalibrationPlugin,
+                maskitoCaretGuard((value) => [
+                    prefix.length,
+                    value.length - postfix.length,
+                ]),
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiInputNumber, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiInputNumber, isStandalone: true, selector: "input[tuiInputNumber]", inputs: { minSetter: ["min", "minSetter"], maxSetter: ["max", "maxSetter"], prefixSetter: ["prefix", "prefixSetter"], postfixSetter: ["postfix", "postfixSetter"] }, host: { listeners: { "input": "onInput()", "blur": "onBlur()", "focus": "onFocus()" }, properties: { "value": "textfieldValue()", "disabled": "disabled()", "attr.inputMode": "inputMode()", "attr.maxLength": "maxLength()" } }, providers: [
+            tuiFallbackValueProvider(null),
+            tuiValueTransformerFrom(TUI_INPUT_NUMBER_OPTIONS),
+        ], usesInheritance: true, hostDirectives: [{ directive: i1.TuiWithTextfield }, { directive: i2.MaskitoDirective }], ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiInputNumber, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: 'input[tuiInputNumber]',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [
+                        tuiFallbackValueProvider(null),
+                        tuiValueTransformerFrom(TUI_INPUT_NUMBER_OPTIONS),
+                    ],
+                    hostDirectives: [TuiWithTextfield, MaskitoDirective],
+                    host: {
+                        '[value]': 'textfieldValue()',
+                        '[disabled]': 'disabled()',
+                        '[attr.inputMode]': 'inputMode()',
+                        '[attr.maxLength]': 'maxLength()',
+                        '(input)': 'onInput()',
+                        '(blur)': 'onBlur()',
+                        '(focus)': 'onFocus()',
+                    },
+                }]
+        }], propDecorators: { minSetter: [{
+                type: Input,
+                args: ['min']
+            }], maxSetter: [{
+                type: Input,
+                args: ['max']
+            }], prefixSetter: [{
+                type: Input,
+                args: ['prefix']
+            }], postfixSetter: [{
+                type: Input,
+                args: ['postfix']
+            }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { TUI_INPUT_NUMBER_DEFAULT_OPTIONS, TUI_INPUT_NUMBER_OPTIONS, TuiInputNumber, tuiInputNumberOptionsProvider };
+//# sourceMappingURL=taiga-ui-kit-components-input-number.mjs.map

package/fesm2022/taiga-ui-kit-components-input-number.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"taiga-ui-kit-components-input-number.mjs","sources":["../../../projects/kit/components/input-number/input-number.options.ts","../../../projects/kit/components/input-number/input-number.component.ts","../../../projects/kit/components/input-number/taiga-ui-kit-components-input-number.ts"],"sourcesContent":["import type {TuiValueTransformer} from '@taiga-ui/cdk/classes';\nimport {tuiCreateOptions} from '@taiga-ui/cdk/utils/di';\n\nexport interface TuiInputNumberOptions {\n    readonly max: number;\n    readonly min: number;\n    readonly prefix: string;\n    readonly postfix: string;\n    readonly valueTransformer: TuiValueTransformer<number | null> | null;\n}\n\nexport const TUI_INPUT_NUMBER_DEFAULT_OPTIONS: TuiInputNumberOptions = {\n    min: Number.MIN_SAFE_INTEGER,\n    max: Number.MAX_SAFE_INTEGER,\n    prefix: '',\n    postfix: '',\n    valueTransformer: null,\n};\n\nexport const [TUI_INPUT_NUMBER_OPTIONS, tuiInputNumberOptionsProvider] = tuiCreateOptions(\n    TUI_INPUT_NUMBER_DEFAULT_OPTIONS,\n);\n","import {\n    ChangeDetectionStrategy,\n    Component,\n    computed,\n    inject,\n    Input,\n    signal,\n} from '@angular/core';\nimport {toSignal} from '@angular/core/rxjs-interop';\nimport {MaskitoDirective} from '@maskito/angular';\nimport type {MaskitoOptions} from '@maskito/core';\nimport {maskitoInitialCalibrationPlugin} from '@maskito/core';\nimport {\n    maskitoCaretGuard,\n    maskitoNumberOptionsGenerator,\n    maskitoParseNumber,\n} from '@maskito/kit';\nimport {TuiControl, tuiValueTransformerFrom} from '@taiga-ui/cdk/classes';\nimport {CHAR_HYPHEN, CHAR_MINUS} from '@taiga-ui/cdk/constants';\nimport {TUI_IS_IOS, tuiFallbackValueProvider} from '@taiga-ui/cdk/tokens';\nimport {tuiInjectElement} from '@taiga-ui/cdk/utils/dom';\nimport {tuiIsSafeToRound} from '@taiga-ui/cdk/utils/math';\nimport {TuiWithTextfield} from '@taiga-ui/core/components/textfield';\nimport {TUI_DEFAULT_NUMBER_FORMAT, TUI_NUMBER_FORMAT} from '@taiga-ui/core/tokens';\nimport {tuiFormatNumber} from '@taiga-ui/core/utils/format';\nimport {tuiMaskito} from '@taiga-ui/kit/utils';\n\nimport {TUI_INPUT_NUMBER_OPTIONS} from './input-number.options';\n\nconst DEFAULT_MAX_LENGTH = 18;\n\n@Component({\n    standalone: true,\n    selector: 'input[tuiInputNumber]',\n    template: '',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [\n        tuiFallbackValueProvider(null),\n        tuiValueTransformerFrom(TUI_INPUT_NUMBER_OPTIONS),\n    ],\n    hostDirectives: [TuiWithTextfield, MaskitoDirective],\n    host: {\n        '[value]': 'textfieldValue()',\n        '[disabled]': 'disabled()',\n        '[attr.inputMode]': 'inputMode()',\n        '[attr.maxLength]': 'maxLength()',\n        '(input)': 'onInput()',\n        '(blur)': 'onBlur()',\n        '(focus)': 'onFocus()',\n    },\n})\nexport class TuiInputNumber extends TuiControl<number | null> {\n    private readonly element = tuiInjectElement<HTMLInputElement>();\n    private readonly isIOS = inject(TUI_IS_IOS);\n    private readonly options = inject(TUI_INPUT_NUMBER_OPTIONS);\n    private readonly numberFormat = toSignal(inject(TUI_NUMBER_FORMAT), {\n        initialValue: TUI_DEFAULT_NUMBER_FORMAT,\n    });\n\n    private readonly min = signal(this.options.min);\n    private readonly max = signal(this.options.max);\n    private readonly prefix = signal(this.options.prefix);\n    private readonly postfix = signal(this.options.postfix);\n\n    private readonly precision = computed(() =>\n        Number.isNaN(this.numberFormat().precision) ? 2 : this.numberFormat().precision,\n    );\n\n    private readonly isIntermediateState = computed(() => {\n        const value = maskitoParseNumber(\n            this.textfieldValue(),\n            this.numberFormat().decimalSeparator,\n        );\n\n        return value < 0 ? value > this.max() : value < this.min();\n    });\n\n    protected textfieldValue = signal(this.element.value || '');\n\n    protected readonly inputMode = computed(() => {\n        if (this.isIOS && this.min() < 0) {\n            // iPhone does not have minus sign if inputMode is equal to 'numeric' / 'decimal'\n            return 'text';\n        }\n\n        return this.precision() ? 'decimal' : 'numeric';\n    });\n\n    protected readonly maxLength = computed(() => {\n        const {decimalSeparator, thousandSeparator} = this.numberFormat();\n        const decimalPart =\n            !!this.precision() && this.textfieldValue().includes(decimalSeparator);\n        const precision = decimalPart ? Math.min(this.precision() + 1, 20) : 0;\n        const takeThousand = thousandSeparator.repeat(5).length;\n\n        return DEFAULT_MAX_LENGTH + precision + takeThousand;\n    });\n\n    protected readonly mask = tuiMaskito(\n        computed(({decimalMode, ...numberFormat} = this.numberFormat()) =>\n            this.computeMask({\n                ...numberFormat,\n                precision: this.precision(),\n                min: this.min(),\n                max: this.max(),\n                prefix: this.prefix(),\n                postfix: this.postfix(),\n                decimalZeroPadding: decimalMode === 'always',\n            }),\n        ),\n    );\n\n    @Input('min')\n    public set minSetter(x: number | null) {\n        this.updateMinMaxLimits(x, this.max());\n    }\n\n    @Input('max')\n    public set maxSetter(x: number | null) {\n        this.updateMinMaxLimits(this.min(), x);\n    }\n\n    // TODO(v5): replace with signal input\n    @Input('prefix')\n    public set prefixSetter(x: string) {\n        this.prefix.set(x);\n    }\n\n    // TODO(v5): replace with signal input\n    @Input('postfix')\n    public set postfixSetter(x: string) {\n        this.postfix.set(x);\n    }\n\n    public override writeValue(value: number | null): void {\n        super.writeValue(value);\n        this.textfieldValue.set(this.formatNumber(value));\n    }\n\n    protected onInput(): void {\n        const value = this.element.value;\n        const parsedValue = maskitoParseNumber(\n            value,\n            this.numberFormat().decimalSeparator,\n        );\n\n        this.textfieldValue.set(value);\n\n        if (Number.isNaN(parsedValue)) {\n            this.onChange(null);\n\n            return;\n        }\n\n        if (\n            this.isIntermediateState() ||\n            parsedValue < this.min() ||\n            parsedValue > this.max()\n        ) {\n            return;\n        }\n\n        this.onChange(parsedValue);\n    }\n\n    protected onBlur(): void {\n        this.onTouched();\n\n        if (!this.isIntermediateState()) {\n            this.textfieldValue.set(this.formatNumber(this.value()));\n        }\n    }\n\n    protected onFocus(): void {\n        const value = maskitoParseNumber(\n            this.textfieldValue(),\n            this.numberFormat().decimalSeparator,\n        );\n\n        if (Number.isNaN(value) && !this.readOnly()) {\n            this.textfieldValue.set(this.prefix() + this.postfix());\n        }\n    }\n\n    private formatNumber(value: number | null): string {\n        if (value === null) {\n            return '';\n        }\n\n        return (\n            this.prefix() +\n            tuiFormatNumber(value, {\n                ...this.numberFormat(),\n                /**\n                 * Number can satisfy interval [Number.MIN_SAFE_INTEGER; Number.MAX_SAFE_INTEGER]\n                 * but its rounding can violate it.\n                 * Before BigInt support there is no perfect solution – only trade off.\n                 * No rounding is better than lose precision and incorrect mutation of already valid value.\n                 */\n                precision: tuiIsSafeToRound(value, this.precision())\n                    ? this.precision()\n                    : Infinity,\n            }).replace(CHAR_HYPHEN, CHAR_MINUS) +\n            this.postfix()\n        );\n    }\n\n    private updateMinMaxLimits(\n        nullableMin: number | null,\n        nullableMax: number | null,\n    ): void {\n        const min =\n            this.transformer?.fromControlValue(nullableMin) ??\n            nullableMin ??\n            this.options.min;\n        const max =\n            this.transformer?.fromControlValue(nullableMax) ??\n            nullableMax ??\n            this.options.max;\n\n        this.min.set(Math.min(min, max));\n        this.max.set(Math.max(min, max));\n    }\n\n    private computeMask(\n        params: NonNullable<Parameters<typeof maskitoNumberOptionsGenerator>[0]>,\n    ): MaskitoOptions {\n        const {prefix = '', postfix = ''} = params;\n        const {plugins, ...options} = maskitoNumberOptionsGenerator(params);\n        const initialCalibrationPlugin = maskitoInitialCalibrationPlugin(\n            maskitoNumberOptionsGenerator({\n                ...params,\n                min: Number.MIN_SAFE_INTEGER,\n                max: Number.MAX_SAFE_INTEGER,\n            }),\n        );\n\n        return {\n            ...options,\n            plugins: [\n                ...plugins,\n                initialCalibrationPlugin,\n                maskitoCaretGuard((value) => [\n                    prefix.length,\n                    value.length - postfix.length,\n                ]),\n            ],\n        };\n    }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}

package/fesm2022/taiga-ui-kit-components.mjs

@@ -21,6 +21,7 @@ export * from '@taiga-ui/kit/components/elastic-container';
 export * from '@taiga-ui/kit/components/files';
 export * from '@taiga-ui/kit/components/filter';
 export * from '@taiga-ui/kit/components/input-inline';
+export * from '@taiga-ui/kit/components/input-number';
 export * from '@taiga-ui/kit/components/input-password';
 export * from '@taiga-ui/kit/components/input-phone-international';
 export * from '@taiga-ui/kit/components/items-with-more';

package/fesm2022/taiga-ui-kit-components.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"taiga-ui-kit-components.mjs","sources":["../../../projects/kit/components/taiga-ui-kit-components.ts"],"sourcesContent":["/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AAEG"}
+{"version":3,"file":"taiga-ui-kit-components.mjs","sources":["../../../projects/kit/components/taiga-ui-kit-components.ts"],"sourcesContent":["/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AAEG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/kit",
-  "version": "4.19.0-canary.2c14206",
+  "version": "4.19.0-canary.c786189",
   "description": "Taiga UI Angular main components kit",
   "keywords": [
     "angular",
@@ -179,12 +179,24 @@
       "esm": "./esm2022/components/files/taiga-ui-kit-components-files.mjs",
       "default": "./fesm2022/taiga-ui-kit-components-files.mjs"
     },
+    "./components/filter": {
+      "types": "./components/filter/index.d.ts",
+      "esm2022": "./esm2022/components/filter/taiga-ui-kit-components-filter.mjs",
+      "esm": "./esm2022/components/filter/taiga-ui-kit-components-filter.mjs",
+      "default": "./fesm2022/taiga-ui-kit-components-filter.mjs"
+    },
     "./components/input-inline": {
       "types": "./components/input-inline/index.d.ts",
       "esm2022": "./esm2022/components/input-inline/taiga-ui-kit-components-input-inline.mjs",
       "esm": "./esm2022/components/input-inline/taiga-ui-kit-components-input-inline.mjs",
       "default": "./fesm2022/taiga-ui-kit-components-input-inline.mjs"
     },
+    "./components/input-number": {
+      "types": "./components/input-number/index.d.ts",
+      "esm2022": "./esm2022/components/input-number/taiga-ui-kit-components-input-number.mjs",
+      "esm": "./esm2022/components/input-number/taiga-ui-kit-components-input-number.mjs",
+      "default": "./fesm2022/taiga-ui-kit-components-input-number.mjs"
+    },
     "./components/input-password": {
       "types": "./components/input-password/index.d.ts",
       "esm2022": "./esm2022/components/input-password/taiga-ui-kit-components-input-password.mjs",
@@ -197,12 +209,6 @@
       "esm": "./esm2022/components/input-phone-international/taiga-ui-kit-components-input-phone-international.mjs",
       "default": "./fesm2022/taiga-ui-kit-components-input-phone-international.mjs"
     },
-    "./components/filter": {
-      "types": "./components/filter/index.d.ts",
-      "esm2022": "./esm2022/components/filter/taiga-ui-kit-components-filter.mjs",
-      "esm": "./esm2022/components/filter/taiga-ui-kit-components-filter.mjs",
-      "default": "./fesm2022/taiga-ui-kit-components-filter.mjs"
-    },
     "./components/items-with-more": {
       "types": "./components/items-with-more/index.d.ts",
       "esm2022": "./esm2022/components/items-with-more/taiga-ui-kit-components-items-with-more.mjs",