@taiga-ui/kit 4.45.0 → 4.46.0-canary.96d3049

package/esm2022/components/input-date-range/input-date-range.directive.mjs

@@ -3,11 +3,11 @@ import { MaskitoDirective } from '@maskito/angular';
 import { maskitoDateRangeOptionsGenerator } from '@maskito/kit';
 import { tuiAsControl, tuiValueTransformerFrom } from '@taiga-ui/cdk/classes';
 import { DATE_RANGE_FILLER_LENGTH, RANGE_SEPARATOR_CHAR, TuiDayRange, } from '@taiga-ui/cdk/date-time';
-import { tuiDirectiveBinding, tuiProvide } from '@taiga-ui/cdk/utils/miscellaneous';
-import { TuiTextfieldComponent, TuiWithTextfield, } from '@taiga-ui/core/components/textfield';
+import { tuiProvide } from '@taiga-ui/cdk/utils/miscellaneous';
+import { TuiWithTextfield } from '@taiga-ui/core/components/textfield';
 import { TuiDropdownAuto } from '@taiga-ui/core/directives/dropdown';
 import { TUI_ITEMS_HANDLERS } from '@taiga-ui/core/directives/items-handlers';
-import { TUI_DATE_ADAPTER, TUI_INPUT_DATE_OPTIONS_NEW, TuiInputDateBase, } from '@taiga-ui/kit/components/input-date';
+import { TUI_DATE_ADAPTER, TUI_INPUT_DATE_OPTIONS_NEW, TuiInputDateBase, tuiWithDateFiller, } from '@taiga-ui/kit/components/input-date';
 import { tuiMaskito } from '@taiga-ui/kit/utils';
 import { TUI_INPUT_DATE_RANGE_OPTIONS } from './input-date-range.options';
 import * as i0 from "@angular/core";
@@ -18,7 +18,7 @@ class TuiInputDateRangeDirective extends TuiInputDateBase {
     constructor() {
         super(...arguments);
         this.identity = inject(TUI_ITEMS_HANDLERS).identityMatcher.set((a, b) => a.daySame(b));
-        this.rangeFiller = tuiDirectiveBinding(TuiTextfieldComponent, 'fillerSetter', computed((filler = this.filler()) => `${filler}${RANGE_SEPARATOR_CHAR}${filler}`), {});
+        this.filler = tuiWithDateFiller((filler) => `${filler}${RANGE_SEPARATOR_CHAR}${filler}`);
         this.mask = tuiMaskito(computed(() => maskitoDateRangeOptionsGenerator({
             dateSeparator: this.format().separator,
             mode: TUI_DATE_ADAPTER[this.format().mode],
@@ -76,4 +76,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: Input,
                 args: ['maxLength']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-date-range.directive.js","sourceRoot":"","sources":["../../../../../projects/kit/components/input-date-range/input-date-range.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {computed, Directive, inject, Input, signal} from '@angular/core';\nimport {MaskitoDirective} from '@maskito/angular';\nimport {maskitoDateRangeOptionsGenerator} from '@maskito/kit';\nimport {tuiAsControl, tuiValueTransformerFrom} from '@taiga-ui/cdk/classes';\nimport type {TuiDayLike} from '@taiga-ui/cdk/date-time';\nimport {\n    DATE_RANGE_FILLER_LENGTH,\n    RANGE_SEPARATOR_CHAR,\n    TuiDayRange,\n} from '@taiga-ui/cdk/date-time';\nimport {tuiDirectiveBinding, tuiProvide} from '@taiga-ui/cdk/utils/miscellaneous';\nimport {\n    TuiTextfieldComponent,\n    TuiWithTextfield,\n} from '@taiga-ui/core/components/textfield';\nimport {TuiDropdownAuto} from '@taiga-ui/core/directives/dropdown';\nimport type {TuiItemsHandlers} from '@taiga-ui/core/directives/items-handlers';\nimport {TUI_ITEMS_HANDLERS} from '@taiga-ui/core/directives/items-handlers';\nimport type {TuiCalendarRange} from '@taiga-ui/kit/components/calendar-range';\nimport {\n    TUI_DATE_ADAPTER,\n    TUI_INPUT_DATE_OPTIONS_NEW,\n    TuiInputDateBase,\n} from '@taiga-ui/kit/components/input-date';\nimport {tuiMaskito} from '@taiga-ui/kit/utils';\n\nimport {TUI_INPUT_DATE_RANGE_OPTIONS} from './input-date-range.options';\n\n@Directive({\n    standalone: true,\n    selector: 'input[tuiInputDateRange]',\n    providers: [\n        // TODO: Add SelectOption after data-list in calendar-range is refactored\n        tuiAsControl(TuiInputDateRangeDirective),\n        tuiValueTransformerFrom(TUI_INPUT_DATE_RANGE_OPTIONS),\n        tuiProvide(TUI_INPUT_DATE_OPTIONS_NEW, TUI_INPUT_DATE_RANGE_OPTIONS),\n    ],\n    hostDirectives: [TuiWithTextfield, TuiDropdownAuto, MaskitoDirective],\n})\nexport class TuiInputDateRangeDirective extends TuiInputDateBase<TuiDayRange> {\n    protected readonly identity = inject<TuiItemsHandlers<TuiDayRange>>(\n        TUI_ITEMS_HANDLERS,\n    ).identityMatcher.set((a, b) => a.daySame(b));\n\n    protected readonly rangeFiller = tuiDirectiveBinding(\n        TuiTextfieldComponent,\n        'fillerSetter',\n        computed((filler = this.filler()) => `${filler}${RANGE_SEPARATOR_CHAR}${filler}`),\n        {},\n    );\n\n    protected override readonly mask = tuiMaskito(\n        computed(() =>\n            maskitoDateRangeOptionsGenerator({\n                dateSeparator: this.format().separator,\n                mode: TUI_DATE_ADAPTER[this.format().mode],\n                min: this.min().toLocalNativeDate(),\n                max: this.max().toLocalNativeDate(),\n                minLength: this.minLength() || {},\n                maxLength: this.maxLength() || {},\n            }),\n        ),\n    );\n\n    public readonly minLength = signal<TuiDayLike | null>(null);\n    public readonly maxLength = signal<TuiDayLike | null>(null);\n\n    @Input('minLength')\n    public set minLengthSetter(minLength: TuiDayLike | null) {\n        this.minLength.set(minLength);\n    }\n\n    @Input('maxLength')\n    public set maxLengthSetter(maxLength: TuiDayLike | null) {\n        this.maxLength.set(maxLength);\n    }\n\n    protected override processCalendar(calendar: TuiCalendarRange): void {\n        super.processCalendar(calendar);\n\n        calendar.minLength = this.minLength();\n        calendar.maxLength = this.maxLength();\n    }\n\n    protected override onValueChange(value: string): void {\n        this.control?.control?.updateValueAndValidity({emitEvent: false});\n        this.onChange(\n            value.length === DATE_RANGE_FILLER_LENGTH\n                ? TuiDayRange.normalizeParse(value, this.format().mode)\n                : null,\n        );\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-date-range.directive.js","sourceRoot":"","sources":["../../../../../projects/kit/components/input-date-range/input-date-range.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {computed, Directive, inject, Input, signal} from '@angular/core';\nimport {MaskitoDirective} from '@maskito/angular';\nimport {maskitoDateRangeOptionsGenerator} from '@maskito/kit';\nimport {tuiAsControl, tuiValueTransformerFrom} from '@taiga-ui/cdk/classes';\nimport type {TuiDayLike} from '@taiga-ui/cdk/date-time';\nimport {\n    DATE_RANGE_FILLER_LENGTH,\n    RANGE_SEPARATOR_CHAR,\n    TuiDayRange,\n} from '@taiga-ui/cdk/date-time';\nimport {tuiProvide} from '@taiga-ui/cdk/utils/miscellaneous';\nimport {TuiWithTextfield} from '@taiga-ui/core/components/textfield';\nimport {TuiDropdownAuto} from '@taiga-ui/core/directives/dropdown';\nimport type {TuiItemsHandlers} from '@taiga-ui/core/directives/items-handlers';\nimport {TUI_ITEMS_HANDLERS} from '@taiga-ui/core/directives/items-handlers';\nimport type {TuiCalendarRange} from '@taiga-ui/kit/components/calendar-range';\nimport {\n    TUI_DATE_ADAPTER,\n    TUI_INPUT_DATE_OPTIONS_NEW,\n    TuiInputDateBase,\n    tuiWithDateFiller,\n} from '@taiga-ui/kit/components/input-date';\nimport {tuiMaskito} from '@taiga-ui/kit/utils';\n\nimport {TUI_INPUT_DATE_RANGE_OPTIONS} from './input-date-range.options';\n\n@Directive({\n    standalone: true,\n    selector: 'input[tuiInputDateRange]',\n    providers: [\n        // TODO: Add SelectOption after data-list in calendar-range is refactored\n        tuiAsControl(TuiInputDateRangeDirective),\n        tuiValueTransformerFrom(TUI_INPUT_DATE_RANGE_OPTIONS),\n        tuiProvide(TUI_INPUT_DATE_OPTIONS_NEW, TUI_INPUT_DATE_RANGE_OPTIONS),\n    ],\n    hostDirectives: [TuiWithTextfield, TuiDropdownAuto, MaskitoDirective],\n})\nexport class TuiInputDateRangeDirective extends TuiInputDateBase<TuiDayRange> {\n    protected readonly identity = inject<TuiItemsHandlers<TuiDayRange>>(\n        TUI_ITEMS_HANDLERS,\n    ).identityMatcher.set((a, b) => a.daySame(b));\n\n    protected override readonly filler = tuiWithDateFiller(\n        (filler) => `${filler}${RANGE_SEPARATOR_CHAR}${filler}`,\n    );\n\n    protected readonly mask = tuiMaskito(\n        computed(() =>\n            maskitoDateRangeOptionsGenerator({\n                dateSeparator: this.format().separator,\n                mode: TUI_DATE_ADAPTER[this.format().mode],\n                min: this.min().toLocalNativeDate(),\n                max: this.max().toLocalNativeDate(),\n                minLength: this.minLength() || {},\n                maxLength: this.maxLength() || {},\n            }),\n        ),\n    );\n\n    public readonly minLength = signal<TuiDayLike | null>(null);\n    public readonly maxLength = signal<TuiDayLike | null>(null);\n\n    @Input('minLength')\n    public set minLengthSetter(minLength: TuiDayLike | null) {\n        this.minLength.set(minLength);\n    }\n\n    @Input('maxLength')\n    public set maxLengthSetter(maxLength: TuiDayLike | null) {\n        this.maxLength.set(maxLength);\n    }\n\n    protected override processCalendar(calendar: TuiCalendarRange): void {\n        super.processCalendar(calendar);\n\n        calendar.minLength = this.minLength();\n        calendar.maxLength = this.maxLength();\n    }\n\n    protected override onValueChange(value: string): void {\n        this.control?.control?.updateValueAndValidity({emitEvent: false});\n        this.onChange(\n            value.length === DATE_RANGE_FILLER_LENGTH\n                ? TuiDayRange.normalizeParse(value, this.format().mode)\n                : null,\n        );\n    }\n}\n"]}

package/esm2022/components/input-date-time/index.mjs

@@ -0,0 +1,5 @@
+export * from './input-date-time';
+export * from './input-date-time.component';
+export * from './input-date-time.directive';
+export * from './input-date-time.options';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9raXQvY29tcG9uZW50cy9pbnB1dC1kYXRlLXRpbWUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW5wdXQtZGF0ZS10aW1lJztcbmV4cG9ydCAqIGZyb20gJy4vaW5wdXQtZGF0ZS10aW1lLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2lucHV0LWRhdGUtdGltZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnB1dC1kYXRlLXRpbWUub3B0aW9ucyc7XG4iXX0=

package/esm2022/components/input-date-time/input-date-time.component.mjs

@@ -0,0 +1,34 @@
+import { NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, computed, inject, ViewEncapsulation, } from '@angular/core';
+import { TuiDay, TuiTime } from '@taiga-ui/cdk/date-time';
+import { TuiTextfieldContent } from '@taiga-ui/core/components/textfield';
+import { TuiNativeTimePicker } from '@taiga-ui/kit/components/input-time';
+import { TuiInputDateTimeDirective } from './input-date-time.directive';
+import * as i0 from "@angular/core";
+class TuiInputDateTimeComponent extends TuiNativeTimePicker {
+    constructor() {
+        super(...arguments);
+        this.host = inject(TuiInputDateTimeDirective);
+        this.step = computed(() => this.getStep(this.host.timeMode()));
+        this.value = computed(() => this.toISOString(this.host.value()));
+        this.min = computed(() => this.toISOString([this.host.min(), this.host.minTime()]));
+        this.max = computed(() => this.toISOString([this.host.max(), this.host.maxTime()]));
+    }
+    onInput(value) {
+        if (!value) {
+            return this.host.setValue(null);
+        }
+        const date = new Date(value);
+        const day = TuiDay.fromLocalNativeDate(date);
+        const time = TuiTime.fromLocalNativeDate(date);
+        this.host.setValue([day, time]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiInputDateTimeComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiInputDateTimeComponent, isStandalone: true, selector: "input[tuiInputDateTime][type=\"datetime-local\"]", host: { attributes: { "ngSkipHydration": "true" } }, usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"host.native\">\n    <input\n        *tuiTextfieldContent\n        type=\"datetime-local\"\n        [attr.list]=\"list\"\n        [max]=\"max()\"\n        [min]=\"min()\"\n        [step]=\"step()\"\n        [value]=\"value()\"\n        (click.stop.zoneless)=\"(0)\"\n        (input)=\"onInput($any($event.target).value)\"\n        (pointerdown.stop.zoneless)=\"(0)\"\n    />\n</ng-container>\n", styles: ["tui-textfield input[tuiInputDateTime]~.t-content input[type=datetime-local]{position:absolute;top:0;left:auto;right:0;bottom:0;inline-size:2.5rem;padding:0;opacity:0}tui-textfield input[tuiInputDateTime]~.t-content input[type=datetime-local]::-webkit-calendar-picker-indicator{position:absolute;top:0;left:0;inline-size:100%;block-size:100%}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: TuiTextfieldContent, selector: "ng-template[tuiTextfieldContent]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { TuiInputDateTimeComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiInputDateTimeComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'input[tuiInputDateTime][type="datetime-local"]', imports: [NgIf, TuiTextfieldContent], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: { ngSkipHydration: 'true' }, template: "<ng-container *ngIf=\"host.native\">\n    <input\n        *tuiTextfieldContent\n        type=\"datetime-local\"\n        [attr.list]=\"list\"\n        [max]=\"max()\"\n        [min]=\"min()\"\n        [step]=\"step()\"\n        [value]=\"value()\"\n        (click.stop.zoneless)=\"(0)\"\n        (input)=\"onInput($any($event.target).value)\"\n        (pointerdown.stop.zoneless)=\"(0)\"\n    />\n</ng-container>\n", styles: ["tui-textfield input[tuiInputDateTime]~.t-content input[type=datetime-local]{position:absolute;top:0;left:auto;right:0;bottom:0;inline-size:2.5rem;padding:0;opacity:0}tui-textfield input[tuiInputDateTime]~.t-content input[type=datetime-local]::-webkit-calendar-picker-indicator{position:absolute;top:0;left:0;inline-size:100%;block-size:100%}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/input-date-time/input-date-time.directive.mjs

@@ -0,0 +1,174 @@
+import { computed, Directive, effect, inject, Input, signal } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { MaskitoDirective } from '@maskito/angular';
+import { maskitoDateTimeOptionsGenerator, maskitoSelectionChangeHandler, } from '@maskito/kit';
+import { tuiAsControl, tuiValueTransformerFrom } from '@taiga-ui/cdk/classes';
+import { DATE_FILLER_LENGTH, MILLISECONDS_IN_DAY, TuiDay, TuiTime, } from '@taiga-ui/cdk/date-time';
+import { tuiClamp, tuiSum } from '@taiga-ui/cdk/utils/math';
+import { tuiDirectiveBinding } from '@taiga-ui/cdk/utils/miscellaneous';
+import { tuiAsOptionContent } from '@taiga-ui/core/components/data-list';
+import { tuiAsTextfieldAccessor, TuiWithTextfield, } from '@taiga-ui/core/components/textfield';
+import { TuiDropdownAuto } from '@taiga-ui/core/directives/dropdown';
+import { TuiItemsHandlersValidator } from '@taiga-ui/core/directives/items-handlers';
+import { TUI_DATE_ADAPTER, TuiInputDateBase, tuiWithDateFiller, } from '@taiga-ui/kit/components/input-date';
+import { TuiSelectOption } from '@taiga-ui/kit/components/select';
+import { TUI_TIME_TEXTS } from '@taiga-ui/kit/tokens';
+import { tuiMaskito } from '@taiga-ui/kit/utils';
+import { noop } from 'rxjs';
+import { TUI_INPUT_DATE_TIME_OPTIONS } from './input-date-time.options';
+import * as i0 from "@angular/core";
+import * as i1 from "@maskito/angular";
+import * as i2 from "@taiga-ui/core/directives/dropdown";
+import * as i3 from "@taiga-ui/core/directives/items-handlers";
+import * as i4 from "@taiga-ui/core/components/textfield";
+const MIN_TIME = new TuiTime(0, 0);
+const MAX_TIME = TuiTime.fromAbsoluteMilliseconds(MILLISECONDS_IN_DAY - 1);
+class TuiInputDateTimeDirective extends TuiInputDateBase {
+    constructor() {
+        super(...arguments);
+        this.timeFillers = toSignal(inject(TUI_TIME_TEXTS));
+        this.options = inject(TUI_INPUT_DATE_TIME_OPTIONS);
+        this.filler = tuiWithDateFiller((date) => {
+            const time = this.timeFillers()?.[this.timeMode()] ?? '';
+            return `${date}${this.options.dateTimeSeparator}${time}`;
+        });
+        this.valueEffect = effect(noop);
+        this.identity = this.handlers.identityMatcher.set((a, b) => tuiSum(...a.map(Number)) === tuiSum(...b.map(Number)));
+        this.disabledItemHandler = tuiDirectiveBinding(TuiItemsHandlersValidator, 'disabledItemHandler', (value) => Boolean(value && this.handlers.disabledItemHandler()(value)));
+        this.mask = tuiMaskito(computed(() => this.computeMask({
+            dateMode: TUI_DATE_ADAPTER[this.format().mode],
+            timeMode: this.timeMode(),
+            min: this.toNativeDate([this.min(), this.minTime()]),
+            max: this.toNativeDate([this.max(), this.maxTime()]),
+            dateSeparator: this.format().separator,
+            dateTimeSeparator: this.options.dateTimeSeparator,
+        })));
+        this.timeMode = signal(this.options.timeMode);
+        this.minTime = signal(MIN_TIME);
+        this.maxTime = signal(MAX_TIME);
+    }
+    // TODO(v5): use signal inputs
+    set timeModeSetter(x) {
+        this.timeMode.set(x);
+    }
+    set minSetter(min) {
+        const [date, time] = Array.isArray(min) ? min : [min, null];
+        this.min.set(date || this.options.min);
+        this.minTime.set(time ?? MIN_TIME);
+    }
+    set maxSetter(max) {
+        const [date, time] = Array.isArray(max) ? max : [max, null];
+        this.max.set(date || this.options.max);
+        this.maxTime.set(time ?? MAX_TIME);
+    }
+    setValue(value) {
+        this.onChange(value);
+        this.textfield.value.set(this.stringify(value));
+    }
+    setDate(newDate) {
+        const [date, time] = this.clampTime([newDate, this.value()?.[1] ?? null]);
+        this.setValue([date, time]);
+        this.open.set(false);
+        setTimeout((caretIndex = DATE_FILLER_LENGTH + this.options.dateTimeSeparator.length) => this.el.setSelectionRange(caretIndex, caretIndex));
+    }
+    writeValue(value) {
+        super.writeValue(value);
+        this.textfield.value.set(this.stringify(this.value()));
+    }
+    processCalendar(calendar) {
+        super.processCalendar(calendar);
+        calendar.disabledItemHandler = (day) => this.handlers.disabledItemHandler()([day, null]);
+    }
+    onValueChange(value) {
+        this.textfield.value.set(value);
+        this.control?.control?.updateValueAndValidity({ emitEvent: false });
+        const [date = '', time = ''] = value.split(this.options.dateTimeSeparator);
+        const parsedDate = date.length >= DATE_FILLER_LENGTH
+            ? TuiDay.normalizeParse(date, this.format().mode)
+            : null;
+        const parsedTime = time.length === this.timeMode().length ? TuiTime.fromString(time) : null;
+        if (!parsedDate || (time && !parsedTime)) {
+            return this.onChange(null);
+        }
+        const [prevDate, prevTime = null] = this.value() ?? [];
+        if (!prevDate?.daySame(parsedDate) || Number(parsedTime) !== Number(prevTime)) {
+            this.onChange([parsedDate, parsedTime]);
+        }
+    }
+    stringify(value) {
+        const [date, time] = value ?? [];
+        const dateString = date?.toString(this.format().mode, this.format().separator) ?? '';
+        const timeString = time?.toString(this.timeMode());
+        return timeString
+            ? `${dateString}${this.options.dateTimeSeparator}${timeString}`
+            : dateString;
+    }
+    clampTime([date, time]) {
+        const min = date.daySame(this.min())
+            ? this.minTime().toAbsoluteMilliseconds()
+            : -Infinity;
+        const max = date.daySame(this.max())
+            ? this.maxTime().toAbsoluteMilliseconds()
+            : Infinity;
+        return [
+            date,
+            time &&
+                TuiTime.fromAbsoluteMilliseconds(tuiClamp(time.toAbsoluteMilliseconds(), min, max)),
+        ];
+    }
+    computeMask(params) {
+        const options = maskitoDateTimeOptionsGenerator(params);
+        const { timeMode, dateMode, dateTimeSeparator } = params;
+        const inputModeSwitchPlugin = maskitoSelectionChangeHandler((element) => {
+            element.inputMode =
+                element.selectionStart >=
+                    dateMode.length + dateTimeSeparator.length + timeMode.indexOf(' AA')
+                    ? 'text'
+                    : 'numeric';
+        });
+        return {
+            ...options,
+            plugins: options.plugins.concat(timeMode.includes('AA') ? inputModeSwitchPlugin : []),
+        };
+    }
+    toNativeDate([{ year, month, day }, { hours, minutes, seconds, ms }]) {
+        return new Date(year, month, day, hours, minutes, seconds, ms);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiInputDateTimeDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: TuiInputDateTimeDirective, isStandalone: true, selector: "input[tuiInputDateTime]", inputs: { timeModeSetter: ["timeMode", "timeModeSetter"], minSetter: ["min", "minSetter"], maxSetter: ["max", "maxSetter"] }, providers: [
+            tuiAsOptionContent(TuiSelectOption),
+            tuiAsControl(TuiInputDateTimeDirective),
+            tuiAsTextfieldAccessor(TuiInputDateTimeDirective),
+            tuiValueTransformerFrom(TUI_INPUT_DATE_TIME_OPTIONS),
+        ], usesInheritance: true, hostDirectives: [{ directive: i1.MaskitoDirective }, { directive: i2.TuiDropdownAuto }, { directive: i3.TuiItemsHandlersValidator }, { directive: i4.TuiWithTextfield }], ngImport: i0 }); }
+}
+export { TuiInputDateTimeDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiInputDateTimeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: 'input[tuiInputDateTime]',
+                    providers: [
+                        tuiAsOptionContent(TuiSelectOption),
+                        tuiAsControl(TuiInputDateTimeDirective),
+                        tuiAsTextfieldAccessor(TuiInputDateTimeDirective),
+                        tuiValueTransformerFrom(TUI_INPUT_DATE_TIME_OPTIONS),
+                    ],
+                    hostDirectives: [
+                        MaskitoDirective,
+                        TuiDropdownAuto,
+                        TuiItemsHandlersValidator,
+                        TuiWithTextfield,
+                    ],
+                }]
+        }], propDecorators: { timeModeSetter: [{
+                type: Input,
+                args: ['timeMode']
+            }], minSetter: [{
+                type: Input,
+                args: ['min']
+            }], maxSetter: [{
+                type: Input,
+                args: ['max']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-date-time.directive.js","sourceRoot":"","sources":["../../../../../projects/kit/components/input-date-time/input-date-time.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {computed, Directive, effect, inject, Input, signal} from '@angular/core';\nimport {toSignal} from '@angular/core/rxjs-interop';\nimport {MaskitoDirective} from '@maskito/angular';\nimport type {MaskitoOptions} from '@maskito/core';\nimport type {MaskitoDateTimeParams, MaskitoTimeMode} from '@maskito/kit';\nimport {\n    maskitoDateTimeOptionsGenerator,\n    maskitoSelectionChangeHandler,\n} from '@maskito/kit';\nimport {tuiAsControl, tuiValueTransformerFrom} from '@taiga-ui/cdk/classes';\nimport {\n    DATE_FILLER_LENGTH,\n    MILLISECONDS_IN_DAY,\n    TuiDay,\n    TuiTime,\n} from '@taiga-ui/cdk/date-time';\nimport {tuiClamp, tuiSum} from '@taiga-ui/cdk/utils/math';\nimport {tuiDirectiveBinding} from '@taiga-ui/cdk/utils/miscellaneous';\nimport type {TuiCalendar} from '@taiga-ui/core/components/calendar';\nimport {tuiAsOptionContent} from '@taiga-ui/core/components/data-list';\nimport type {TuiTextfieldAccessor} from '@taiga-ui/core/components/textfield';\nimport {\n    tuiAsTextfieldAccessor,\n    TuiWithTextfield,\n} from '@taiga-ui/core/components/textfield';\nimport {TuiDropdownAuto} from '@taiga-ui/core/directives/dropdown';\nimport {TuiItemsHandlersValidator} from '@taiga-ui/core/directives/items-handlers';\nimport {\n    TUI_DATE_ADAPTER,\n    TuiInputDateBase,\n    tuiWithDateFiller,\n} from '@taiga-ui/kit/components/input-date';\nimport {TuiSelectOption} from '@taiga-ui/kit/components/select';\nimport {TUI_TIME_TEXTS} from '@taiga-ui/kit/tokens';\nimport {tuiMaskito} from '@taiga-ui/kit/utils';\nimport {noop} from 'rxjs';\n\nimport {TUI_INPUT_DATE_TIME_OPTIONS} from './input-date-time.options';\n\nconst MIN_TIME = new TuiTime(0, 0);\nconst MAX_TIME = TuiTime.fromAbsoluteMilliseconds(MILLISECONDS_IN_DAY - 1);\n\n@Directive({\n    standalone: true,\n    selector: 'input[tuiInputDateTime]',\n    providers: [\n        tuiAsOptionContent(TuiSelectOption),\n        tuiAsControl(TuiInputDateTimeDirective),\n        tuiAsTextfieldAccessor(TuiInputDateTimeDirective),\n        tuiValueTransformerFrom(TUI_INPUT_DATE_TIME_OPTIONS),\n    ],\n    hostDirectives: [\n        MaskitoDirective,\n        TuiDropdownAuto,\n        TuiItemsHandlersValidator,\n        TuiWithTextfield,\n    ],\n})\nexport class TuiInputDateTimeDirective\n    extends TuiInputDateBase<readonly [TuiDay, TuiTime | null]>\n    implements TuiTextfieldAccessor<readonly [TuiDay, TuiTime | null]>\n{\n    private readonly timeFillers = toSignal(inject(TUI_TIME_TEXTS));\n\n    protected override readonly options = inject(TUI_INPUT_DATE_TIME_OPTIONS);\n\n    protected override readonly filler = tuiWithDateFiller((date) => {\n        const time = this.timeFillers()?.[this.timeMode()] ?? '';\n\n        return `${date}${this.options.dateTimeSeparator}${time}`;\n    });\n\n    protected override valueEffect = effect(noop);\n\n    protected readonly identity = this.handlers.identityMatcher.set(\n        (a, b) => tuiSum(...a.map(Number)) === tuiSum(...b.map(Number)),\n    );\n\n    protected readonly disabledItemHandler = tuiDirectiveBinding(\n        TuiItemsHandlersValidator,\n        'disabledItemHandler',\n        (value: readonly [TuiDay, TuiTime | null] | null) =>\n            Boolean(value && this.handlers.disabledItemHandler()(value)),\n    );\n\n    protected readonly mask = tuiMaskito(\n        computed(() =>\n            this.computeMask({\n                dateMode: TUI_DATE_ADAPTER[this.format().mode],\n                timeMode: this.timeMode(),\n                min: this.toNativeDate([this.min(), this.minTime()]),\n                max: this.toNativeDate([this.max(), this.maxTime()]),\n                dateSeparator: this.format().separator,\n                dateTimeSeparator: this.options.dateTimeSeparator,\n            }),\n        ),\n    );\n\n    public readonly timeMode = signal(this.options.timeMode);\n    public readonly minTime = signal(MIN_TIME);\n    public readonly maxTime = signal(MAX_TIME);\n\n    // TODO(v5): use signal inputs\n    @Input('timeMode')\n    public set timeModeSetter(x: MaskitoTimeMode) {\n        this.timeMode.set(x);\n    }\n\n    @Input('min')\n    public override set minSetter(\n        min: TuiDay | readonly [TuiDay, TuiTime | null] | null,\n    ) {\n        const [date, time] = Array.isArray(min) ? min : [min, null];\n\n        this.min.set(date || this.options.min);\n        this.minTime.set(time ?? MIN_TIME);\n    }\n\n    @Input('max')\n    public override set maxSetter(\n        max: TuiDay | readonly [TuiDay, TuiTime | null] | null,\n    ) {\n        const [date, time] = Array.isArray(max) ? max : [max, null];\n\n        this.max.set(date || this.options.max);\n        this.maxTime.set(time ?? MAX_TIME);\n    }\n\n    public setValue(value: readonly [TuiDay, TuiTime | null] | null): void {\n        this.onChange(value);\n        this.textfield.value.set(this.stringify(value));\n    }\n\n    public override setDate(newDate: TuiDay): void {\n        const [date, time] = this.clampTime([newDate, this.value()?.[1] ?? null]);\n\n        this.setValue([date, time]);\n        this.open.set(false);\n        setTimeout(\n            (caretIndex = DATE_FILLER_LENGTH + this.options.dateTimeSeparator.length) =>\n                this.el.setSelectionRange(caretIndex, caretIndex),\n        );\n    }\n\n    public override writeValue(value: [TuiDay, TuiTime | null] | null): void {\n        super.writeValue(value);\n        this.textfield.value.set(this.stringify(this.value()));\n    }\n\n    protected override processCalendar(calendar: TuiCalendar): void {\n        super.processCalendar(calendar);\n        calendar.disabledItemHandler = (day: TuiDay) =>\n            this.handlers.disabledItemHandler()([day, null]);\n    }\n\n    protected override onValueChange(value: string): void {\n        this.textfield.value.set(value);\n        this.control?.control?.updateValueAndValidity({emitEvent: false});\n\n        const [date = '', time = ''] = value.split(this.options.dateTimeSeparator);\n        const parsedDate =\n            date.length >= DATE_FILLER_LENGTH\n                ? TuiDay.normalizeParse(date, this.format().mode)\n                : null;\n        const parsedTime =\n            time.length === this.timeMode().length ? TuiTime.fromString(time) : null;\n\n        if (!parsedDate || (time && !parsedTime)) {\n            return this.onChange(null);\n        }\n\n        const [prevDate, prevTime = null] = this.value() ?? [];\n\n        if (!prevDate?.daySame(parsedDate) || Number(parsedTime) !== Number(prevTime)) {\n            this.onChange([parsedDate, parsedTime]);\n        }\n    }\n\n    protected override stringify(\n        value: readonly [TuiDay, TuiTime | null] | null,\n    ): string {\n        const [date, time] = value ?? [];\n\n        const dateString =\n            date?.toString(this.format().mode, this.format().separator) ?? '';\n        const timeString = time?.toString(this.timeMode());\n\n        return timeString\n            ? `${dateString}${this.options.dateTimeSeparator}${timeString}`\n            : dateString;\n    }\n\n    private clampTime([date, time]: [TuiDay, TuiTime | null]): [TuiDay, TuiTime | null] {\n        const min = date.daySame(this.min())\n            ? this.minTime().toAbsoluteMilliseconds()\n            : -Infinity;\n        const max = date.daySame(this.max())\n            ? this.maxTime().toAbsoluteMilliseconds()\n            : Infinity;\n\n        return [\n            date,\n            time &&\n                TuiTime.fromAbsoluteMilliseconds(\n                    tuiClamp(time.toAbsoluteMilliseconds(), min, max),\n                ),\n        ];\n    }\n\n    private computeMask(\n        params: Omit<Required<MaskitoDateTimeParams>, 'timeStep'>,\n    ): MaskitoOptions {\n        const options = maskitoDateTimeOptionsGenerator(params);\n        const {timeMode, dateMode, dateTimeSeparator} = params;\n        const inputModeSwitchPlugin = maskitoSelectionChangeHandler((element) => {\n            element.inputMode =\n                element.selectionStart! >=\n                dateMode.length + dateTimeSeparator.length + timeMode.indexOf(' AA')\n                    ? 'text'\n                    : 'numeric';\n        });\n\n        return {\n            ...options,\n            plugins: options.plugins.concat(\n                timeMode.includes('AA') ? inputModeSwitchPlugin : [],\n            ),\n        };\n    }\n\n    private toNativeDate([{year, month, day}, {hours, minutes, seconds, ms}]: readonly [\n        TuiDay,\n        TuiTime,\n    ]): Date {\n        return new Date(year, month, day, hours, minutes, seconds, ms);\n    }\n}\n"]}

package/esm2022/components/input-date-time/input-date-time.mjs

@@ -0,0 +1,9 @@
+import { TuiCalendar } from '@taiga-ui/core/components/calendar';
+import { TuiInputDateTimeComponent } from './input-date-time.component';
+import { TuiInputDateTimeDirective } from './input-date-time.directive';
+export const TuiInputDateTime = [
+    TuiInputDateTimeDirective,
+    TuiInputDateTimeComponent,
+    TuiCalendar,
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtZGF0ZS10aW1lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva2l0L2NvbXBvbmVudHMvaW5wdXQtZGF0ZS10aW1lL2lucHV0LWRhdGUtdGltZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsV0FBVyxFQUFDLE1BQU0sb0NBQW9DLENBQUM7QUFFL0QsT0FBTyxFQUFDLHlCQUF5QixFQUFDLE1BQU0sNkJBQTZCLENBQUM7QUFDdEUsT0FBTyxFQUFDLHlCQUF5QixFQUFDLE1BQU0sNkJBQTZCLENBQUM7QUFFdEUsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUc7SUFDNUIseUJBQXlCO0lBQ3pCLHlCQUF5QjtJQUN6QixXQUFXO0NBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7VHVpQ2FsZW5kYXJ9IGZyb20gJ0B0YWlnYS11aS9jb3JlL2NvbXBvbmVudHMvY2FsZW5kYXInO1xuXG5pbXBvcnQge1R1aUlucHV0RGF0ZVRpbWVDb21wb25lbnR9IGZyb20gJy4vaW5wdXQtZGF0ZS10aW1lLmNvbXBvbmVudCc7XG5pbXBvcnQge1R1aUlucHV0RGF0ZVRpbWVEaXJlY3RpdmV9IGZyb20gJy4vaW5wdXQtZGF0ZS10aW1lLmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCBjb25zdCBUdWlJbnB1dERhdGVUaW1lID0gW1xuICAgIFR1aUlucHV0RGF0ZVRpbWVEaXJlY3RpdmUsXG4gICAgVHVpSW5wdXREYXRlVGltZUNvbXBvbmVudCxcbiAgICBUdWlDYWxlbmRhcixcbl0gYXMgY29uc3Q7XG4iXX0=

package/esm2022/components/input-date-time/input-date-time.options.mjs

@@ -0,0 +1,20 @@
+import { inject, InjectionToken } from '@angular/core';
+import { TUI_IDENTITY_VALUE_TRANSFORMER } from '@taiga-ui/cdk/classes';
+import { tuiProvideOptions } from '@taiga-ui/cdk/utils/miscellaneous';
+import { TUI_INPUT_DATE_DEFAULT_OPTIONS_NEW, TUI_INPUT_DATE_OPTIONS_NEW, } from '@taiga-ui/kit/components/input-date';
+export const TUI_INPUT_DATE_TIME_DEFAULT_OPTIONS = {
+    valueTransformer: TUI_IDENTITY_VALUE_TRANSFORMER,
+    timeMode: 'HH:MM',
+    dateTimeSeparator: ', ',
+};
+export const TUI_INPUT_DATE_TIME_OPTIONS = new InjectionToken(ngDevMode ? 'TUI_INPUT_DATE_TIME_OPTIONS' : '', {
+    factory: () => ({
+        ...inject(TUI_INPUT_DATE_OPTIONS_NEW),
+        ...TUI_INPUT_DATE_TIME_DEFAULT_OPTIONS,
+    }),
+});
+export const tuiInputDateTimeOptionsProvider = (options) => tuiProvideOptions(TUI_INPUT_DATE_TIME_OPTIONS, options, {
+    ...TUI_INPUT_DATE_DEFAULT_OPTIONS_NEW,
+    ...TUI_INPUT_DATE_TIME_DEFAULT_OPTIONS,
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/input-date-time/taiga-ui-kit-components-input-date-time.mjs

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

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

@@ -1,46 +1,64 @@
 import { NgIf } from '@angular/common';
-import { ChangeDetectionStrategy, Component, computed, inject, ViewEncapsulation, } from '@angular/core';
+import { ChangeDetectionStrategy, Component, computed, Directive, inject, ViewEncapsulation, } from '@angular/core';
 import { TuiControl } from '@taiga-ui/cdk/classes';
 import { TuiTime } from '@taiga-ui/cdk/date-time';
 import { tuiInjectElement } from '@taiga-ui/cdk/utils/dom';
 import { TuiTextfieldContent, TuiTextfieldDirective, } from '@taiga-ui/core/components/textfield';
 import { TuiInputTimeDirective } from './input-time.directive';
 import * as i0 from "@angular/core";
-class TuiInputTimeComponent {
+class TuiNativeTimePicker {
     constructor() {
-        this.control = inject(TuiControl);
         this.list = tuiInjectElement().getAttribute('list');
+    }
+    getStep(timeMode) {
+        switch (timeMode) {
+            case 'HH:MM:SS':
+            case 'HH:MM:SS AA':
+                return 1;
+            case 'HH:MM:SS.MSS':
+            case 'HH:MM:SS.MSS AA':
+                return 0.001;
+            default:
+                return 60;
+        }
+    }
+    toISOString(value) {
+        const [day, time] = Array.isArray(value) ? value : [null, value];
+        const dateString = day ? day.toJSON() + (time ? 'T' : '') : '';
+        const timeString = time ? time.toString('HH:MM:SS.MSS') : '';
+        return dateString + timeString;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiNativeTimePicker, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: TuiNativeTimePicker, host: { properties: { "type": "\"text\"", "attr.list": "null" } }, ngImport: i0 }); }
+}
+export { TuiNativeTimePicker };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiNativeTimePicker, decorators: [{
+            type: Directive,
+            args: [{
+                    host: {
+                        '[type]': '"text"',
+                        '[attr.list]': 'null',
+                    },
+                }]
+        }] });
+class TuiInputTimeComponent extends TuiNativeTimePicker {
+    constructor() {
+        super(...arguments);
+        this.control = inject(TuiControl);
         this.host = inject(TuiInputTimeDirective);
         this.textfield = inject(TuiTextfieldDirective);
-        this.value = computed((value = this.control.value()) => value
-            ? value.toString(this.host.timeMode().replace(' AA', ''))
-            : '');
-        this.step = computed((mode = this.host.timeMode()) => {
-            switch (mode) {
-                case 'HH:MM:SS':
-                case 'HH:MM:SS AA':
-                    return 1;
-                case 'HH:MM:SS.MSS':
-                case 'HH:MM:SS.MSS AA':
-                    return 0.001;
-                default:
-                    return 60;
-            }
-        });
+        this.value = computed(() => this.toISOString(this.control.value()));
+        this.step = computed(() => this.getStep(this.host.timeMode()));
     }
     setValue(value) {
         this.host.setValue(TuiTime.fromString(value));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiInputTimeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiInputTimeComponent, isStandalone: true, selector: "input[tuiInputTime][type=\"time\"]", host: { attributes: { "ngSkipHydration": "true" }, properties: { "type": "\"text\"", "attr.list": "null" } }, ngImport: i0, template: "<ng-container *ngIf=\"host.native\">\n    <input\n        *tuiTextfieldContent\n        type=\"time\"\n        [attr.list]=\"list\"\n        [step]=\"step()\"\n        [value]=\"value()\"\n        (change)=\"setValue($any($event.target).value)\"\n    />\n</ng-container>\n", styles: ["tui-textfield input[tuiInputTime]~.t-content input[type=time]{position:absolute;right:0;left:auto;inline-size:calc(var(--t-right) + var(--t-padding));opacity:0;margin:0;padding:0}tui-textfield input[tuiInputTime]~.t-content input[type=time]::-webkit-calendar-picker-indicator{position:absolute;top:0;left:0;inline-size:100%;block-size:100%}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: TuiTextfieldContent, selector: "ng-template[tuiTextfieldContent]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiInputTimeComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiInputTimeComponent, isStandalone: true, selector: "input[tuiInputTime][type=\"time\"]", host: { attributes: { "ngSkipHydration": "true" } }, usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"host.native\">\n    <input\n        *tuiTextfieldContent\n        type=\"time\"\n        [attr.list]=\"list\"\n        [step]=\"step()\"\n        [value]=\"value()\"\n        (change)=\"setValue($any($event.target).value)\"\n    />\n</ng-container>\n", styles: ["tui-textfield input[tuiInputTime]~.t-content input[type=time]{position:absolute;right:0;left:auto;inline-size:calc(var(--t-right) + var(--t-padding));opacity:0;margin:0;padding:0}tui-textfield input[tuiInputTime]~.t-content input[type=time]::-webkit-calendar-picker-indicator{position:absolute;top:0;left:0;inline-size:100%;block-size:100%}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: TuiTextfieldContent, selector: "ng-template[tuiTextfieldContent]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 }
 export { TuiInputTimeComponent };
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiInputTimeComponent, decorators: [{
             type: Component,
-            args: [{ standalone: true, selector: 'input[tuiInputTime][type="time"]', imports: [NgIf, TuiTextfieldContent], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: {
-                        ngSkipHydration: 'true',
-                        '[type]': '"text"',
-                        '[attr.list]': 'null',
-                    }, template: "<ng-container *ngIf=\"host.native\">\n    <input\n        *tuiTextfieldContent\n        type=\"time\"\n        [attr.list]=\"list\"\n        [step]=\"step()\"\n        [value]=\"value()\"\n        (change)=\"setValue($any($event.target).value)\"\n    />\n</ng-container>\n", styles: ["tui-textfield input[tuiInputTime]~.t-content input[type=time]{position:absolute;right:0;left:auto;inline-size:calc(var(--t-right) + var(--t-padding));opacity:0;margin:0;padding:0}tui-textfield input[tuiInputTime]~.t-content input[type=time]::-webkit-calendar-picker-indicator{position:absolute;top:0;left:0;inline-size:100%;block-size:100%}\n"] }]
+            args: [{ standalone: true, selector: 'input[tuiInputTime][type="time"]', imports: [NgIf, TuiTextfieldContent], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: { ngSkipHydration: 'true' }, template: "<ng-container *ngIf=\"host.native\">\n    <input\n        *tuiTextfieldContent\n        type=\"time\"\n        [attr.list]=\"list\"\n        [step]=\"step()\"\n        [value]=\"value()\"\n        (change)=\"setValue($any($event.target).value)\"\n    />\n</ng-container>\n", styles: ["tui-textfield input[tuiInputTime]~.t-content input[type=time]{position:absolute;right:0;left:auto;inline-size:calc(var(--t-right) + var(--t-padding));opacity:0;margin:0;padding:0}tui-textfield input[tuiInputTime]~.t-content input[type=time]::-webkit-calendar-picker-indicator{position:absolute;top:0;left:0;inline-size:100%;block-size:100%}\n"] }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtdGltZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9raXQvY29tcG9uZW50cy9pbnB1dC10aW1lL2lucHV0LXRpbWUuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva2l0L2NvbXBvbmVudHMvaW5wdXQtdGltZS9pbnB1dC10aW1lLnRlbXBsYXRlLmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLElBQUksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQ3JDLE9BQU8sRUFDSCx1QkFBdUIsRUFDdkIsU0FBUyxFQUNULFFBQVEsRUFDUixTQUFTLEVBQ1QsTUFBTSxFQUNOLGlCQUFpQixHQUNwQixNQUFNLGVBQWUsQ0FBQztBQUV2QixPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sdUJBQXVCLENBQUM7QUFFakQsT0FBTyxFQUFDLE9BQU8sRUFBQyxNQUFNLHlCQUF5QixDQUFDO0FBQ2hELE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLHlCQUF5QixDQUFDO0FBQ3pELE9BQU8sRUFDSCxtQkFBbUIsRUFDbkIscUJBQXFCLEdBQ3hCLE1BQU0scUNBQXFDLENBQUM7QUFFN0MsT0FBTyxFQUFDLHFCQUFxQixFQUFDLE1BQU0sd0JBQXdCLENBQUM7O0FBRTdELE1BTXNCLG1CQUFtQjtJQU56QztRQU91QixTQUFJLEdBQUcsZ0JBQWdCLEVBQUUsQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUM7S0F3QnJFO0lBdEJhLE9BQU8sQ0FBQyxRQUF5QjtRQUN2QyxRQUFRLFFBQVEsRUFBRTtZQUNkLEtBQUssVUFBVSxDQUFDO1lBQ2hCLEtBQUssYUFBYTtnQkFDZCxPQUFPLENBQUMsQ0FBQztZQUNiLEtBQUssY0FBYyxDQUFDO1lBQ3BCLEtBQUssaUJBQWlCO2dCQUNsQixPQUFPLEtBQUssQ0FBQztZQUNqQjtnQkFDSSxPQUFPLEVBQUUsQ0FBQztTQUNqQjtJQUNMLENBQUM7SUFFUyxXQUFXLENBQ2pCLEtBQXlEO1FBRXpELE1BQU0sQ0FBQyxHQUFHLEVBQUUsSUFBSSxDQUFDLEdBQUcsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQztRQUNqRSxNQUFNLFVBQVUsR0FBRyxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQy9ELE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxjQUFjLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBRTdELE9BQU8sVUFBVSxHQUFHLFVBQVUsQ0FBQztJQUNuQyxDQUFDOytHQXhCaUIsbUJBQW1CO21HQUFuQixtQkFBbUI7O1NBQW5CLG1CQUFtQjs0RkFBbkIsbUJBQW1CO2tCQU54QyxTQUFTO21CQUFDO29CQUNQLElBQUksRUFBRTt3QkFDRixRQUFRLEVBQUUsUUFBUTt3QkFDbEIsYUFBYSxFQUFFLE1BQU07cUJBQ3hCO2lCQUNKOztBQTRCRCxNQVVhLHFCQUFzQixTQUFRLG1CQUFtQjtJQVY5RDs7UUFXcUIsWUFBTyxHQUErQixNQUFNLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFdkQsU0FBSSxHQUFHLE1BQU0sQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO1FBRXJDLGNBQVMsR0FBRyxNQUFNLENBQUMscUJBQXFCLENBQUMsQ0FBQztRQUMxQyxVQUFLLEdBQUcsUUFBUSxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFFL0QsU0FBSSxHQUFHLFFBQVEsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxDQUFDO0tBS2hGO0lBSGEsUUFBUSxDQUFDLEtBQWE7UUFDNUIsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO0lBQ2xELENBQUM7K0dBWlEscUJBQXFCO21HQUFyQixxQkFBcUIsMEtDaEVsQyxrUkFVQSxnWkQrQ2MsSUFBSSw2RkFBRSxtQkFBbUI7O1NBTzFCLHFCQUFxQjs0RkFBckIscUJBQXFCO2tCQVZqQyxTQUFTO2lDQUNNLElBQUksWUFDTixrQ0FBa0MsV0FDbkMsQ0FBQyxJQUFJLEVBQUUsbUJBQW1CLENBQUMsaUJBR3JCLGlCQUFpQixDQUFDLElBQUksbUJBQ3BCLHVCQUF1QixDQUFDLE1BQU0sUUFDekMsRUFBQyxlQUFlLEVBQUUsTUFBTSxFQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ0lmfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHtcbiAgICBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSxcbiAgICBDb21wb25lbnQsXG4gICAgY29tcHV0ZWQsXG4gICAgRGlyZWN0aXZlLFxuICAgIGluamVjdCxcbiAgICBWaWV3RW5jYXBzdWxhdGlvbixcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgdHlwZSB7TWFza2l0b1RpbWVNb2RlfSBmcm9tICdAbWFza2l0by9raXQnO1xuaW1wb3J0IHtUdWlDb250cm9sfSBmcm9tICdAdGFpZ2EtdWkvY2RrL2NsYXNzZXMnO1xuaW1wb3J0IHR5cGUge1R1aURheX0gZnJvbSAnQHRhaWdhLXVpL2Nkay9kYXRlLXRpbWUnO1xuaW1wb3J0IHtUdWlUaW1lfSBmcm9tICdAdGFpZ2EtdWkvY2RrL2RhdGUtdGltZSc7XG5pbXBvcnQge3R1aUluamVjdEVsZW1lbnR9IGZyb20gJ0B0YWlnYS11aS9jZGsvdXRpbHMvZG9tJztcbmltcG9ydCB7XG4gICAgVHVpVGV4dGZpZWxkQ29udGVudCxcbiAgICBUdWlUZXh0ZmllbGREaXJlY3RpdmUsXG59IGZyb20gJ0B0YWlnYS11aS9jb3JlL2NvbXBvbmVudHMvdGV4dGZpZWxkJztcblxuaW1wb3J0IHtUdWlJbnB1dFRpbWVEaXJlY3RpdmV9IGZyb20gJy4vaW5wdXQtdGltZS5kaXJlY3RpdmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgICBob3N0OiB7XG4gICAgICAgICdbdHlwZV0nOiAnXCJ0ZXh0XCInLFxuICAgICAgICAnW2F0dHIubGlzdF0nOiAnbnVsbCcsXG4gICAgfSxcbn0pXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgVHVpTmF0aXZlVGltZVBpY2tlciB7XG4gICAgcHJvdGVjdGVkIHJlYWRvbmx5IGxpc3QgPSB0dWlJbmplY3RFbGVtZW50KCkuZ2V0QXR0cmlidXRlKCdsaXN0Jyk7XG5cbiAgICBwcm90ZWN0ZWQgZ2V0U3RlcCh0aW1lTW9kZTogTWFza2l0b1RpbWVNb2RlKTogbnVtYmVyIHtcbiAgICAgICAgc3dpdGNoICh0aW1lTW9kZSkge1xuICAgICAgICAgICAgY2FzZSAnSEg6TU06U1MnOlxuICAgICAgICAgICAgY2FzZSAnSEg6TU06U1MgQUEnOlxuICAgICAgICAgICAgICAgIHJldHVybiAxO1xuICAgICAgICAgICAgY2FzZSAnSEg6TU06U1MuTVNTJzpcbiAgICAgICAgICAgIGNhc2UgJ0hIOk1NOlNTLk1TUyBBQSc6XG4gICAgICAgICAgICAgICAgcmV0dXJuIDAuMDAxO1xuICAgICAgICAgICAgZGVmYXVsdDpcbiAgICAgICAgICAgICAgICByZXR1cm4gNjA7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICBwcm90ZWN0ZWQgdG9JU09TdHJpbmcoXG4gICAgICAgIHZhbHVlOiBUdWlUaW1lIHwgcmVhZG9ubHkgW1R1aURheSwgVHVpVGltZSB8IG51bGxdIHwgbnVsbCxcbiAgICApOiBzdHJpbmcge1xuICAgICAgICBjb25zdCBbZGF5LCB0aW1lXSA9IEFycmF5LmlzQXJyYXkodmFsdWUpID8gdmFsdWUgOiBbbnVsbCwgdmFsdWVdO1xuICAgICAgICBjb25zdCBkYXRlU3RyaW5nID0gZGF5ID8gZGF5LnRvSlNPTigpICsgKHRpbWUgPyAnVCcgOiAnJykgOiAnJztcbiAgICAgICAgY29uc3QgdGltZVN0cmluZyA9IHRpbWUgPyB0aW1lLnRvU3RyaW5nKCdISDpNTTpTUy5NU1MnKSA6ICcnO1xuXG4gICAgICAgIHJldHVybiBkYXRlU3RyaW5nICsgdGltZVN0cmluZztcbiAgICB9XG59XG5cbkBDb21wb25lbnQoe1xuICAgIHN0YW5kYWxvbmU6IHRydWUsXG4gICAgc2VsZWN0b3I6ICdpbnB1dFt0dWlJbnB1dFRpbWVdW3R5cGU9XCJ0aW1lXCJdJyxcbiAgICBpbXBvcnRzOiBbTmdJZiwgVHVpVGV4dGZpZWxkQ29udGVudF0sXG4gICAgdGVtcGxhdGVVcmw6ICcuL2lucHV0LXRpbWUudGVtcGxhdGUuaHRtbCcsXG4gICAgc3R5bGVVcmxzOiBbJy4vaW5wdXQtdGltZS5zdHlsZS5sZXNzJ10sXG4gICAgZW5jYXBzdWxhdGlvbjogVmlld0VuY2Fwc3VsYXRpb24uTm9uZSxcbiAgICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbiAgICBob3N0OiB7bmdTa2lwSHlkcmF0aW9uOiAndHJ1ZSd9LFxufSlcbmV4cG9ydCBjbGFzcyBUdWlJbnB1dFRpbWVDb21wb25lbnQgZXh0ZW5kcyBUdWlOYXRpdmVUaW1lUGlja2VyIHtcbiAgICBwcml2YXRlIHJlYWRvbmx5IGNvbnRyb2w6IFR1aUNvbnRyb2w8VHVpVGltZSB8IG51bGw+ID0gaW5qZWN0KFR1aUNvbnRyb2wpO1xuXG4gICAgcHJvdGVjdGVkIHJlYWRvbmx5IGhvc3QgPSBpbmplY3QoVHVpSW5wdXRUaW1lRGlyZWN0aXZlKTtcblxuICAgIHByb3RlY3RlZCByZWFkb25seSB0ZXh0ZmllbGQgPSBpbmplY3QoVHVpVGV4dGZpZWxkRGlyZWN0aXZlKTtcbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgdmFsdWUgPSBjb21wdXRlZCgoKSA9PiB0aGlzLnRvSVNPU3RyaW5nKHRoaXMuY29udHJvbC52YWx1ZSgpKSk7XG5cbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgc3RlcCA9IGNvbXB1dGVkKCgpID0+IHRoaXMuZ2V0U3RlcCh0aGlzLmhvc3QudGltZU1vZGUoKSkpO1xuXG4gICAgcHJvdGVjdGVkIHNldFZhbHVlKHZhbHVlOiBzdHJpbmcpOiB2b2lkIHtcbiAgICAgICAgdGhpcy5ob3N0LnNldFZhbHVlKFR1aVRpbWUuZnJvbVN0cmluZyh2YWx1ZSkpO1xuICAgIH1cbn1cbiIsIjxuZy1jb250YWluZXIgKm5nSWY9XCJob3N0Lm5hdGl2ZVwiPlxuICAgIDxpbnB1dFxuICAgICAgICAqdHVpVGV4dGZpZWxkQ29udGVudFxuICAgICAgICB0eXBlPVwidGltZVwiXG4gICAgICAgIFthdHRyLmxpc3RdPVwibGlzdFwiXG4gICAgICAgIFtzdGVwXT1cInN0ZXAoKVwiXG4gICAgICAgIFt2YWx1ZV09XCJ2YWx1ZSgpXCJcbiAgICAgICAgKGNoYW5nZSk9XCJzZXRWYWx1ZSgkYW55KCRldmVudC50YXJnZXQpLnZhbHVlKVwiXG4gICAgLz5cbjwvbmctY29udGFpbmVyPlxuIl19