nxt-pick-datetime 16.0.0-alpha.6 → 16.0.0

package/esm2022/lib/date-time/date-time-inline/date-time-inline.component.mjs

@@ -0,0 +1,276 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, forwardRef, HostBinding, Inject, Input, Output, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { NXT_DATE_TIME_FORMATS } from '../../class/date-time-format.class';
+import { DateTimeDirective } from '../../class/date-time.class';
+import { DateTimeContainerComponent } from '../date-time-picker-container/date-time-picker-container.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../class/date-time-adapter.class";
+import * as i2 from "../date-time-picker-container/date-time-picker-container.component";
+/** @internal */
+export const NXT_DATETIME_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => DateTimeInlineComponent),
+    multi: true
+};
+class DateTimeInlineComponent extends DateTimeDirective {
+    /**
+     * Set the type of the dateTime picker
+     *
+     * -    `'both'` - show both calendar and timer
+     * -    `'calendar'` - show only calendar
+     * -    `'timer'` - show only timer
+     */
+    get pickerType() {
+        return this._pickerType;
+    }
+    set pickerType(val) {
+        if (val !== this._pickerType) {
+            this._pickerType = val;
+        }
+    }
+    /** Whether the date time picker should be disabled */
+    get disabled() {
+        return !!this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = !!value;
+    }
+    /**
+     * The picker select mode
+     *
+     * -    `'single'` - select a single date
+     * -    `'range'` - select a range [from, to]
+     * -    `'rangeFrom'` - an open range with a fixed start date
+     * -    `'rangeTo'` - an open range with a fixed end date
+     */
+    get selectMode() {
+        return this._selectMode;
+    }
+    set selectMode(mode) {
+        if (mode !== 'single' &&
+            mode !== 'range' &&
+            mode !== 'rangeFrom' &&
+            mode !== 'rangeTo') {
+            throw Error('DateTime Error: invalid selectMode value!');
+        }
+        this._selectMode = mode;
+    }
+    /**
+     * The date to show when picker opens
+     *
+     * Defaults to selected date (if available) or current date.
+     */
+    get startAt() {
+        if (this._startAt) {
+            return this._startAt;
+        }
+        if (this.selectMode === 'single') {
+            return this.value;
+        }
+        else if (this.selectMode === 'range' ||
+            this.selectMode === 'rangeFrom') {
+            return this.values?.[0];
+        }
+        else if (this.selectMode === 'rangeTo') {
+            return this.values?.[1];
+        }
+        else {
+            return;
+        }
+    }
+    set startAt(date) {
+        this._startAt = this.getValidDate(this.dateTimeAdapter.deserialize(date));
+    }
+    /** A function to filter available date & time */
+    get dateTimeFilter() {
+        return this._dateTimeFilter;
+    }
+    set dateTimeFilter(filter) {
+        this._dateTimeFilter = filter;
+    }
+    /** The minimum valid date */
+    set min(value) {
+        this._min = this.getValidDate(this.dateTimeAdapter.deserialize(value));
+        this.changeDetector.markForCheck();
+    }
+    get min() {
+        return this._min;
+    }
+    /** The maximum valid date */
+    set max(value) {
+        this._max = this.getValidDate(this.dateTimeAdapter.deserialize(value));
+        this.changeDetector.markForCheck();
+    }
+    get max() {
+        return this._max;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        value = this.dateTimeAdapter.deserialize(value);
+        value = this.getValidDate(value);
+        this._value = value;
+        this.selected = value;
+    }
+    get values() {
+        return this._values;
+    }
+    set values(values) {
+        if (values && values.length > 0) {
+            values = values.map(v => {
+                v = this.dateTimeAdapter.deserialize(v);
+                v = this.getValidDate(v);
+                return (v && this.dateTimeAdapter.clone(v));
+            });
+            this._values = [...values];
+            this.selecteds = [...values];
+        }
+        else {
+            this._values = [];
+            this.selecteds = [];
+        }
+    }
+    get selected() {
+        return this._selected;
+    }
+    set selected(value) {
+        this._selected = value;
+        this.changeDetector.markForCheck();
+    }
+    get selecteds() {
+        return this._selecteds;
+    }
+    set selecteds(values) {
+        this._selecteds = values;
+        this.changeDetector.markForCheck();
+    }
+    get isOpen() {
+        return true;
+    }
+    get pickerMode() {
+        return 'inline';
+    }
+    get isInSingleMode() {
+        return this._selectMode === 'single';
+    }
+    get isInRangeMode() {
+        return (this._selectMode === 'range' ||
+            this._selectMode === 'rangeFrom' ||
+            this._selectMode === 'rangeTo');
+    }
+    /** @internal */
+    get inlineClass() {
+        return true;
+    }
+    constructor(changeDetector, dateTimeAdapter, dateTimeFormats) {
+        super(dateTimeAdapter, dateTimeFormats);
+        this.changeDetector = changeDetector;
+        this._pickerType = 'both';
+        this._disabled = false;
+        this._selectMode = 'single';
+        /**
+         * Emits selected year in multi-year view
+         *
+         * This doesn't imply a change on the selected date.
+         */
+        this.yearSelected = new EventEmitter();
+        /**
+         * Emits selected month in year view
+         *
+         * This doesn't imply a change on the selected date.
+         */
+        this.monthSelected = new EventEmitter();
+        this._selecteds = new Array();
+    }
+    ngOnInit() {
+        if (this.container)
+            this.container.picker = this;
+    }
+    writeValue(value) {
+        value = value ?? undefined;
+        if (this.isInSingleMode) {
+            this.value = value;
+            if (this.container)
+                this.container.pickerMoment = value;
+        }
+        else {
+            this.values = value;
+            if (this.container)
+                this.container.pickerMoment = this._values?.[this.container.activeSelectedIndex];
+        }
+    }
+    registerOnChange(fn) {
+        this.onModelChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onModelTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    select(date) {
+        if (this.disabled) {
+            return;
+        }
+        if (Array.isArray(date)) {
+            this.values = [...date];
+        }
+        else {
+            this.value = date;
+        }
+        this.onModelChange?.(date);
+        this.onModelTouched?.();
+    }
+    /**
+     * Emits the selected year in multi-year view
+     */
+    selectYear(normalizedYear) {
+        this.yearSelected.emit(normalizedYear);
+    }
+    /**
+     * Emits selected month in year view
+     */
+    selectMonth(normalizedMonth) {
+        this.monthSelected.emit(normalizedMonth);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DateTimeInlineComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.DateTimeAdapter }, { token: NXT_DATE_TIME_FORMATS }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: DateTimeInlineComponent, selector: "nxt-date-time-inline", inputs: { pickerType: "pickerType", disabled: "disabled", selectMode: "selectMode", startAt: "startAt", dateTimeFilter: "dateTimeFilter", min: "min", max: "max", value: "value", values: "values" }, outputs: { yearSelected: "yearSelected", monthSelected: "monthSelected" }, host: { properties: { "class.nxt-dt-inline": "this.inlineClass" } }, providers: [NXT_DATETIME_VALUE_ACCESSOR], viewQueries: [{ propertyName: "container", first: true, predicate: DateTimeContainerComponent, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<nxt-date-time-container></nxt-date-time-container>\n", styles: [""], dependencies: [{ kind: "component", type: i2.DateTimeContainerComponent, selector: "nxt-date-time-container" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { DateTimeInlineComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DateTimeInlineComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'nxt-date-time-inline', changeDetection: ChangeDetectionStrategy.OnPush, preserveWhitespaces: false, providers: [NXT_DATETIME_VALUE_ACCESSOR], template: "<nxt-date-time-container></nxt-date-time-container>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.DateTimeAdapter }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NXT_DATE_TIME_FORMATS]
+                }] }]; }, propDecorators: { container: [{
+                type: ViewChild,
+                args: [DateTimeContainerComponent, { static: true }]
+            }], pickerType: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], selectMode: [{
+                type: Input
+            }], startAt: [{
+                type: Input
+            }], dateTimeFilter: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], values: [{
+                type: Input
+            }], yearSelected: [{
+                type: Output
+            }], monthSelected: [{
+                type: Output
+            }], inlineClass: [{
+                type: HostBinding,
+                args: ['class.nxt-dt-inline']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time-inline.component.js","sourceRoot":"","sources":["../../../../../../packages/pick-datetime/src/lib/date-time/date-time-inline/date-time-inline.component.ts","../../../../../../packages/pick-datetime/src/lib/date-time/date-time-inline/date-time-inline.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAqB,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,EAAY,SAAS,EAAE,MAAM,eAAe,CAAA;AAChL,OAAO,EAAwB,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAExE,OAAO,EAAmB,qBAAqB,EAAE,MAAM,oCAAoC,CAAA;AAC3F,OAAO,EAAc,iBAAiB,EAAsC,MAAM,6BAA6B,CAAA;AAC/G,OAAO,EAAE,0BAA0B,EAAE,MAAM,oEAAoE,CAAA;;;;AAE/G,gBAAgB;AAChB,MAAM,CAAC,MAAM,2BAA2B,GAAa;IACjD,OAAO,EAAE,iBAAiB;IAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,uBAAuB,CAAC;IACtD,KAAK,EAAE,IAAI;CACd,CAAA;AAED,MAQa,uBAA2B,SAAQ,iBAAoB;IAMhE;;;;;;OAMG;IACH,IACI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,CAAA;IAC3B,CAAC;IAED,IAAI,UAAU,CAAC,GAAe;QAC1B,IAAI,GAAG,KAAK,IAAI,CAAC,WAAW,EAAE;YAC1B,IAAI,CAAC,WAAW,GAAG,GAAG,CAAA;SACzB;IACL,CAAC;IAGD,sDAAsD;IACtD,IACa,QAAQ;QACjB,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,CAAA;IAC3B,CAAC;IAED,IAAa,QAAQ,CAAC,KAAc;QAChC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,KAAK,CAAA;IAC5B,CAAC;IAGD;;;;;;;OAOG;IACH,IACI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,CAAA;IAC3B,CAAC;IAED,IAAI,UAAU,CAAC,IAAgB;QAC3B,IACI,IAAI,KAAK,QAAQ;YACjB,IAAI,KAAK,OAAO;YAChB,IAAI,KAAK,WAAW;YACpB,IAAI,KAAK,SAAS,EACpB;YACE,MAAM,KAAK,CAAC,2CAA2C,CAAC,CAAA;SAC3D;QAED,IAAI,CAAC,WAAW,GAAG,IAAI,CAAA;IAC3B,CAAC;IAGD;;;;OAIG;IACH,IACI,OAAO;QACP,IAAI,IAAI,CAAC,QAAQ,EAAE;YACf,OAAO,IAAI,CAAC,QAAQ,CAAA;SACvB;QAED,IAAI,IAAI,CAAC,UAAU,KAAK,QAAQ,EAAE;YAC9B,OAAO,IAAI,CAAC,KAAK,CAAA;SACpB;aAAM,IACH,IAAI,CAAC,UAAU,KAAK,OAAO;YAC3B,IAAI,CAAC,UAAU,KAAK,WAAW,EACjC;YACE,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAA;SAC1B;aAAM,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE;YACtC,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAA;SAC1B;aAAM;YACH,OAAM;SACT;IACL,CAAC;IAED,IAAI,OAAO,CAAC,IAAmB;QAC3B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,YAAY,CAC7B,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,CAAC,CACzC,CAAA;IACL,CAAC;IAGD,iDAAiD;IACjD,IACI,cAAc;QACd,OAAO,IAAI,CAAC,eAAe,CAAA;IAC/B,CAAC;IAED,IAAI,cAAc,CAAC,MAAiC;QAChD,IAAI,CAAC,eAAe,GAAG,MAAM,CAAA;IACjC,CAAC;IAGD,6BAA6B;IAC7B,IACI,GAAG,CAAC,KAAoB;QACxB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAA;QACtE,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAA;IACtC,CAAC;IAED,IAAI,GAAG;QACH,OAAO,IAAI,CAAC,IAAI,CAAA;IACpB,CAAC;IAGD,6BAA6B;IAC7B,IACI,GAAG,CAAC,KAAoB;QACxB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAA;QACtE,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAA;IACtC,CAAC;IAED,IAAI,GAAG;QACH,OAAO,IAAI,CAAC,IAAI,CAAA;IACpB,CAAC;IAGD,IACI,KAAK;QACL,OAAO,IAAI,CAAC,MAAM,CAAA;IACtB,CAAC;IAED,IAAI,KAAK,CAAC,KAAoB;QAC1B,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;QAC/C,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAA;QAChC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QACnB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAA;IACzB,CAAC;IAGD,IACI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAA;IACvB,CAAC;IAED,IAAI,MAAM,CAAC,MAAwC;QAC/C,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YAC7B,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;gBACpB,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC,CAAA;gBACvC,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAA;gBACxB,OAAO,CAAC,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;YAC/C,CAAC,CAAC,CAAA;YACF,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,MAAM,CAAC,CAAA;YAC1B,IAAI,CAAC,SAAS,GAAG,CAAC,GAAG,MAAM,CAAC,CAAA;SAC/B;aAAM;YACH,IAAI,CAAC,OAAO,GAAG,EAAE,CAAA;YACjB,IAAI,CAAC,SAAS,GAAG,EAAE,CAAA;SACtB;IACL,CAAC;IAmBD,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,SAAS,CAAA;IACzB,CAAC;IAED,IAAI,QAAQ,CAAC,KAAoB;QAC7B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAA;QACtB,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAA;IACtC,CAAC;IAGD,IAAI,SAAS;QACT,OAAO,IAAI,CAAC,UAAU,CAAA;IAC1B,CAAC;IAED,IAAI,SAAS,CAAC,MAA4B;QACtC,IAAI,CAAC,UAAU,GAAG,MAAM,CAAA;QACxB,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAA;IACtC,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAA;IACf,CAAC;IAED,IAAI,UAAU;QACV,OAAO,QAAQ,CAAA;IACnB,CAAC;IAED,IAAI,cAAc;QACd,OAAO,IAAI,CAAC,WAAW,KAAK,QAAQ,CAAA;IACxC,CAAC;IAED,IAAI,aAAa;QACb,OAAO,CACH,IAAI,CAAC,WAAW,KAAK,OAAO;YAC5B,IAAI,CAAC,WAAW,KAAK,WAAW;YAChC,IAAI,CAAC,WAAW,KAAK,SAAS,CACjC,CAAA;IACL,CAAC;IAED,gBAAgB;IAChB,IACI,WAAW;QACX,OAAO,IAAI,CAAA;IACf,CAAC;IAKD,YACuB,cAAiC,EACpD,eAAmC,EAEnC,eAAgC;QAEhC,KAAK,CAAC,eAAe,EAAE,eAAe,CAAC,CAAA;QALpB,mBAAc,GAAd,cAAc,CAAmB;QAhOhD,gBAAW,GAAe,MAAM,CAAA;QAmBhC,cAAS,GAAG,KAAK,CAAA;QAWjB,gBAAW,GAAe,QAAQ,CAAA;QAgI1C;;;;WAIG;QAEM,iBAAY,GAAG,IAAI,YAAY,EAAK,CAAA;QAE7C;;;;WAIG;QAEM,kBAAa,GAAG,IAAI,YAAY,EAAK,CAAA;QAYtC,eAAU,GAAG,IAAI,KAAK,EAAiB,CAAA;IA8C/C,CAAC;IAED,QAAQ;QACJ,IAAI,IAAI,CAAC,SAAS;YACd,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,IAAI,CAAA;IACpC,CAAC;IAED,UAAU,CAAC,KAAU;QACjB,KAAK,GAAG,KAAK,IAAI,SAAS,CAAA;QAC1B,IAAI,IAAI,CAAC,cAAc,EAAE;YACrB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;YAClB,IAAI,IAAI,CAAC,SAAS;gBACd,IAAI,CAAC,SAAS,CAAC,YAAY,GAAG,KAAK,CAAA;SAC1C;aAAM;YACH,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;YACnB,IAAI,IAAI,CAAC,SAAS;gBACd,IAAI,CAAC,SAAS,CAAC,YAAY,GAAG,IAAI,CAAC,OAAO,EAAE,CACxC,IAAI,CAAC,SAAS,CAAC,mBAAmB,CACrC,CAAA;SACR;IACL,CAAC;IAED,gBAAgB,CAAC,EAAO;QACpB,IAAI,CAAC,aAAa,GAAG,EAAE,CAAA;IAC3B,CAAC;IAED,iBAAiB,CAAC,EAAO;QACrB,IAAI,CAAC,cAAc,GAAG,EAAE,CAAA;IAC5B,CAAC;IAED,gBAAgB,CAAC,UAAmB;QAChC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAA;IAC9B,CAAC;IAED,MAAM,CAAC,IAAa;QAChB,IAAI,IAAI,CAAC,QAAQ,EAAE;YACf,OAAM;SACT;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACrB,IAAI,CAAC,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,CAAA;SAC1B;aAAM;YACH,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;SACpB;QACD,IAAI,CAAC,aAAa,EAAE,CAAC,IAAI,CAAC,CAAA;QAC1B,IAAI,CAAC,cAAc,EAAE,EAAE,CAAA;IAC3B,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,cAAiB;QACxB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;IAC1C,CAAC;IAED;;OAEG;IACH,WAAW,CAAC,eAAkB;QAC1B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;IAC5C,CAAC;8GAvSQ,uBAAuB,kFAuOpB,qBAAqB;kGAvOxB,uBAAuB,qYAFrB,CAAC,2BAA2B,CAAC,qEAI7B,0BAA0B,qFCxBzC,uDACA;;SDqBa,uBAAuB;2FAAvB,uBAAuB;kBARnC,SAAS;+BACI,sBAAsB,mBAGf,uBAAuB,CAAC,MAAM,uBAC1B,KAAK,aACf,CAAC,2BAA2B,CAAC;;0BAyOnC,MAAM;2BAAC,qBAAqB;4CApOzB,SAAS;sBADhB,SAAS;uBAAC,0BAA0B,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAYnD,UAAU;sBADb,KAAK;gBAcO,QAAQ;sBADpB,KAAK;gBAmBF,UAAU;sBADb,KAAK;gBAyBF,OAAO;sBADV,KAAK;gBA6BF,cAAc;sBADjB,KAAK;gBAYF,GAAG;sBADN,KAAK;gBAaF,GAAG;sBADN,KAAK;gBAYF,KAAK;sBADR,KAAK;gBAcF,MAAM;sBADT,KAAK;gBA0BG,YAAY;sBADpB,MAAM;gBASE,aAAa;sBADrB,MAAM;gBA6CH,WAAW;sBADd,WAAW;uBAAC,qBAAqB","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, forwardRef, HostBinding, Inject, Input, OnInit, Output, Provider, ViewChild } from '@angular/core'\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms'\nimport { DateTimeAdapter } from '../../class/date-time-adapter.class'\nimport { DateTimeFormats, NXT_DATE_TIME_FORMATS } from '../../class/date-time-format.class'\nimport { DateFilter, DateTimeDirective, PickerMode, PickerType, SelectMode } from '../../class/date-time.class'\nimport { DateTimeContainerComponent } from '../date-time-picker-container/date-time-picker-container.component'\n\n/** @internal */\nexport const NXT_DATETIME_VALUE_ACCESSOR: Provider = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => DateTimeInlineComponent),\n    multi: true\n}\n\n@Component({\n    selector: 'nxt-date-time-inline',\n    templateUrl: './date-time-inline.component.html',\n    styleUrls: ['./date-time-inline.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    preserveWhitespaces: false,\n    providers: [NXT_DATETIME_VALUE_ACCESSOR]\n})\nexport class DateTimeInlineComponent<T> extends DateTimeDirective<T> implements OnInit, ControlValueAccessor {\n\n    @ViewChild(DateTimeContainerComponent, { static: true })\n    private container?: DateTimeContainerComponent<T>\n\n    private _pickerType: PickerType = 'both'\n    /**\n     * Set the type of the dateTime picker\n     *\n     * -    `'both'` - show both calendar and timer\n     * -    `'calendar'` - show only calendar\n     * -    `'timer'` - show only timer\n     */\n    @Input()\n    get pickerType(): PickerType {\n        return this._pickerType\n    }\n\n    set pickerType(val: PickerType) {\n        if (val !== this._pickerType) {\n            this._pickerType = val\n        }\n    }\n\n    private _disabled = false\n    /** Whether the date time picker should be disabled */\n    @Input()\n    override get disabled(): boolean {\n        return !!this._disabled\n    }\n\n    override set disabled(value: boolean) {\n        this._disabled = !!value\n    }\n\n    private _selectMode: SelectMode = 'single'\n    /**\n     * The picker select mode\n     *\n     * -    `'single'` - select a single date\n     * -    `'range'` - select a range [from, to]\n     * -    `'rangeFrom'` - an open range with a fixed start date\n     * -    `'rangeTo'` - an open range with a fixed end date\n     */\n    @Input()\n    get selectMode() {\n        return this._selectMode\n    }\n\n    set selectMode(mode: SelectMode) {\n        if (\n            mode !== 'single' &&\n            mode !== 'range' &&\n            mode !== 'rangeFrom' &&\n            mode !== 'rangeTo'\n        ) {\n            throw Error('DateTime Error: invalid selectMode value!')\n        }\n\n        this._selectMode = mode\n    }\n\n    private _startAt?: T\n    /**\n     * The date to show when picker opens\n     *\n     * Defaults to selected date (if available) or current date.\n     */\n    @Input()\n    get startAt() {\n        if (this._startAt) {\n            return this._startAt\n        }\n\n        if (this.selectMode === 'single') {\n            return this.value\n        } else if (\n            this.selectMode === 'range' ||\n            this.selectMode === 'rangeFrom'\n        ) {\n            return this.values?.[0]\n        } else if (this.selectMode === 'rangeTo') {\n            return this.values?.[1]\n        } else {\n            return\n        }\n    }\n\n    set startAt(date: T | undefined) {\n        this._startAt = this.getValidDate(\n            this.dateTimeAdapter.deserialize(date)\n        )\n    }\n\n    private _dateTimeFilter?: DateFilter<T>\n    /** A function to filter available date & time */\n    @Input()\n    get dateTimeFilter() {\n        return this._dateTimeFilter\n    }\n\n    set dateTimeFilter(filter: DateFilter<T> | undefined) {\n        this._dateTimeFilter = filter\n    }\n\n    private _min?: T\n    /** The minimum valid date */\n    @Input()\n    set min(value: T | undefined) {\n        this._min = this.getValidDate(this.dateTimeAdapter.deserialize(value))\n        this.changeDetector.markForCheck()\n    }\n\n    get min() {\n        return this._min\n    }\n\n    private _max?: T\n    /** The maximum valid date */\n    @Input()\n    set max(value: T | undefined) {\n        this._max = this.getValidDate(this.dateTimeAdapter.deserialize(value))\n        this.changeDetector.markForCheck()\n    }\n\n    get max() {\n        return this._max\n    }\n\n    private _value?: T\n    @Input()\n    get value() {\n        return this._value\n    }\n\n    set value(value: T | undefined) {\n        value = this.dateTimeAdapter.deserialize(value)\n        value = this.getValidDate(value)\n        this._value = value\n        this.selected = value\n    }\n\n    private _values?: Array<T | undefined>\n    @Input()\n    get values() {\n        return this._values\n    }\n\n    set values(values: Array<T | undefined> | undefined) {\n        if (values && values.length > 0) {\n            values = values.map(v => {\n                v = this.dateTimeAdapter.deserialize(v)\n                v = this.getValidDate(v)\n                return (v && this.dateTimeAdapter.clone(v))\n            })\n            this._values = [...values]\n            this.selecteds = [...values]\n        } else {\n            this._values = []\n            this.selecteds = []\n        }\n    }\n\n    /**\n     * Emits selected year in multi-year view\n     *\n     * This doesn't imply a change on the selected date.\n     */\n    @Output()\n    readonly yearSelected = new EventEmitter<T>()\n\n    /**\n     * Emits selected month in year view\n     *\n     * This doesn't imply a change on the selected date.\n     */\n    @Output()\n    readonly monthSelected = new EventEmitter<T>()\n\n    private _selected?: T\n    get selected() {\n        return this._selected\n    }\n\n    set selected(value: T | undefined) {\n        this._selected = value\n        this.changeDetector.markForCheck()\n    }\n\n    private _selecteds = new Array<T | undefined>()\n    get selecteds() {\n        return this._selecteds\n    }\n\n    set selecteds(values: Array<T | undefined>) {\n        this._selecteds = values\n        this.changeDetector.markForCheck()\n    }\n\n    get isOpen(): boolean {\n        return true\n    }\n\n    get pickerMode(): PickerMode {\n        return 'inline'\n    }\n\n    get isInSingleMode(): boolean {\n        return this._selectMode === 'single'\n    }\n\n    get isInRangeMode(): boolean {\n        return (\n            this._selectMode === 'range' ||\n            this._selectMode === 'rangeFrom' ||\n            this._selectMode === 'rangeTo'\n        )\n    }\n\n    /** @internal */\n    @HostBinding('class.nxt-dt-inline')\n    get inlineClass(): boolean {\n        return true\n    }\n\n    private onModelChange?: (date: T | T[]) => void\n    private onModelTouched?: () => void\n\n    constructor(\n        protected readonly changeDetector: ChangeDetectorRef,\n        dateTimeAdapter: DateTimeAdapter<T>,\n        @Inject(NXT_DATE_TIME_FORMATS)\n        dateTimeFormats: DateTimeFormats\n    ) {\n        super(dateTimeAdapter, dateTimeFormats)\n    }\n\n    ngOnInit() {\n        if (this.container)\n            this.container.picker = this\n    }\n\n    writeValue(value: any): void {\n        value = value ?? undefined\n        if (this.isInSingleMode) {\n            this.value = value\n            if (this.container)\n                this.container.pickerMoment = value\n        } else {\n            this.values = value\n            if (this.container)\n                this.container.pickerMoment = this._values?.[\n                    this.container.activeSelectedIndex\n                ]\n        }\n    }\n\n    registerOnChange(fn: any): void {\n        this.onModelChange = fn\n    }\n\n    registerOnTouched(fn: any): void {\n        this.onModelTouched = fn\n    }\n\n    setDisabledState(isDisabled: boolean): void {\n        this.disabled = isDisabled\n    }\n\n    select(date: T[] | T): void {\n        if (this.disabled) {\n            return\n        }\n\n        if (Array.isArray(date)) {\n            this.values = [...date]\n        } else {\n            this.value = date\n        }\n        this.onModelChange?.(date)\n        this.onModelTouched?.()\n    }\n\n    /**\n     * Emits the selected year in multi-year view\n     */\n    selectYear(normalizedYear: T): void {\n        this.yearSelected.emit(normalizedYear)\n    }\n\n    /**\n     * Emits selected month in year view\n     */\n    selectMonth(normalizedMonth: T): void {\n        this.monthSelected.emit(normalizedMonth)\n    }\n}\n","<nxt-date-time-container></nxt-date-time-container>\n"]}