nxt-pick-datetime 11.0.0 → 13.0.1

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

@@ -0,0 +1,264 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, Component, EventEmitter, forwardRef, HostBinding, Inject, Input, Optional, Output, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { OWL_DATE_TIME_FORMATS } from '../../class/date-time-format.class';
+import { OwlDateTimeDirective } from '../../class/date-time.class';
+import { OwlDateTimeContainerComponent } 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";
+export const OWL_DATETIME_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => OwlDateTimeInlineComponent),
+    multi: true
+};
+export class OwlDateTimeInlineComponent extends OwlDateTimeDirective {
+    constructor(changeDetector, dateTimeAdapter, dateTimeFormats) {
+        super(dateTimeAdapter, dateTimeFormats);
+        this.changeDetector = changeDetector;
+        this.dateTimeAdapter = dateTimeAdapter;
+        this.dateTimeFormats = dateTimeFormats;
+        /**
+         * Set the type of the dateTime picker
+         *      'both' -- show both calendar and timer
+         *      'calendar' -- show only calendar
+         *      'timer' -- show only timer
+         */
+        this._pickerType = 'both';
+        this._disabled = false;
+        this._selectMode = 'single';
+        this._values = [];
+        /**
+         * 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 = [];
+        this.onModelChange = () => { };
+        this.onModelTouched = () => { };
+    }
+    get pickerType() {
+        return this._pickerType;
+    }
+    set pickerType(val) {
+        if (val !== this._pickerType) {
+            this._pickerType = val;
+        }
+    }
+    get disabled() {
+        return !!this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    get selectMode() {
+        return this._selectMode;
+    }
+    set selectMode(mode) {
+        if (mode !== 'single' &&
+            mode !== 'range' &&
+            mode !== 'rangeFrom' &&
+            mode !== 'rangeTo') {
+            throw Error('OwlDateTime Error: invalid selectMode value!');
+        }
+        this._selectMode = mode;
+    }
+    get startAt() {
+        if (this._startAt) {
+            return this._startAt;
+        }
+        if (this.selectMode === 'single') {
+            return this.value || null;
+        }
+        else if (this.selectMode === 'range' ||
+            this.selectMode === 'rangeFrom') {
+            return this.values[0] || null;
+        }
+        else if (this.selectMode === 'rangeTo') {
+            return this.values[1] || null;
+        }
+        else {
+            return null;
+        }
+    }
+    set startAt(date) {
+        this._startAt = this.getValidDate(this.dateTimeAdapter.deserialize(date));
+    }
+    get dateTimeFilter() {
+        return this._dateTimeFilter;
+    }
+    set dateTimeFilter(filter) {
+        this._dateTimeFilter = filter;
+    }
+    get minDateTime() {
+        return this._min || null;
+    }
+    // eslint-disable-next-line @angular-eslint/no-input-rename
+    set minDateTime(value) {
+        this._min = this.getValidDate(this.dateTimeAdapter.deserialize(value));
+        this.changeDetector.markForCheck();
+    }
+    get maxDateTime() {
+        return this._max || null;
+    }
+    // eslint-disable-next-line @angular-eslint/no-input-rename
+    set maxDateTime(value) {
+        this._max = this.getValidDate(this.dateTimeAdapter.deserialize(value));
+        this.changeDetector.markForCheck();
+    }
+    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) : null;
+            });
+            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 opened() {
+        return true;
+    }
+    get pickerMode() {
+        return 'inline';
+    }
+    get isInSingleMode() {
+        return this._selectMode === 'single';
+    }
+    get isInRangeMode() {
+        return (this._selectMode === 'range' ||
+            this._selectMode === 'rangeFrom' ||
+            this._selectMode === 'rangeTo');
+    }
+    get owlDTInlineClass() {
+        return true;
+    }
+    ngOnInit() {
+        this.container.picker = this;
+    }
+    writeValue(value) {
+        if (this.isInSingleMode) {
+            this.value = value;
+            this.container.pickerMoment = value;
+        }
+        else {
+            this.values = value;
+            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);
+    }
+}
+OwlDateTimeInlineComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OwlDateTimeInlineComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.DateTimeAdapter, optional: true }, { token: OWL_DATE_TIME_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+OwlDateTimeInlineComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: OwlDateTimeInlineComponent, selector: "owl-date-time-inline", inputs: { pickerType: "pickerType", disabled: "disabled", selectMode: "selectMode", startAt: "startAt", dateTimeFilter: ["owlDateTimeFilter", "dateTimeFilter"], minDateTime: ["min", "minDateTime"], maxDateTime: ["max", "maxDateTime"], value: "value", values: "values" }, outputs: { yearSelected: "yearSelected", monthSelected: "monthSelected" }, host: { properties: { "class.owl-dt-inline": "this.owlDTInlineClass" } }, providers: [OWL_DATETIME_VALUE_ACCESSOR], viewQueries: [{ propertyName: "container", first: true, predicate: OwlDateTimeContainerComponent, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<owl-date-time-container></owl-date-time-container>\n", styles: [""], components: [{ type: i2.OwlDateTimeContainerComponent, selector: "owl-date-time-container", exportAs: ["owlDateTimeContainer"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OwlDateTimeInlineComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'owl-date-time-inline', changeDetection: ChangeDetectionStrategy.OnPush, preserveWhitespaces: false, providers: [OWL_DATETIME_VALUE_ACCESSOR], template: "<owl-date-time-container></owl-date-time-container>\n", styles: [""] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.DateTimeAdapter, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [OWL_DATE_TIME_FORMATS]
+                }] }]; }, propDecorators: { container: [{
+                type: ViewChild,
+                args: [OwlDateTimeContainerComponent, { static: true }]
+            }], pickerType: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], selectMode: [{
+                type: Input
+            }], startAt: [{
+                type: Input
+            }], dateTimeFilter: [{
+                type: Input,
+                args: ['owlDateTimeFilter']
+            }], minDateTime: [{
+                type: Input,
+                args: ['min']
+            }], maxDateTime: [{
+                type: Input,
+                args: ['max']
+            }], value: [{
+                type: Input
+            }], values: [{
+                type: Input
+            }], yearSelected: [{
+                type: Output
+            }], monthSelected: [{
+                type: Output
+            }], owlDTInlineClass: [{
+                type: HostBinding,
+                args: ['class.owl-dt-inline']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time-inline.component.js","sourceRoot":"","sources":["../../../../../../projects/nxt-pick-datetime/src/lib/date-time/date-time-inline/date-time-inline.component.ts","../../../../../../projects/nxt-pick-datetime/src/lib/date-time/date-time-inline/date-time-inline.component.html"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion'\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, forwardRef, HostBinding, Inject, Input, OnInit, Optional, Output, ViewChild } from '@angular/core'\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms'\nimport { DateTimeAdapter } from '../../class/date-time-adapter.class'\nimport { OwlDateTimeFormats, OWL_DATE_TIME_FORMATS } from '../../class/date-time-format.class'\nimport { OwlDateTimeDirective, PickerMode, PickerType, SelectMode } from '../../class/date-time.class'\nimport { OwlDateTimeContainerComponent } from '../date-time-picker-container/date-time-picker-container.component'\n\nexport const OWL_DATETIME_VALUE_ACCESSOR: any = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => OwlDateTimeInlineComponent),\n    multi: true\n}\n\n@Component({\n    selector: 'owl-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: [OWL_DATETIME_VALUE_ACCESSOR]\n})\nexport class OwlDateTimeInlineComponent<T> extends OwlDateTimeDirective<T>\n    implements OnInit, ControlValueAccessor {\n    @ViewChild(OwlDateTimeContainerComponent, { static: true })\n    container: OwlDateTimeContainerComponent<T>\n\n    /**\n     * Set the type of the dateTime picker\n     *      'both' -- show both calendar and timer\n     *      'calendar' -- show only calendar\n     *      'timer' -- show only timer\n     */\n    private _pickerType: PickerType = 'both'\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    @Input()\n    get disabled(): boolean {\n        return !!this._disabled\n    }\n\n    set disabled(value: boolean) {\n        this._disabled = coerceBooleanProperty(value)\n    }\n\n    private _selectMode: SelectMode = 'single'\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('OwlDateTime Error: invalid selectMode value!')\n        }\n\n        this._selectMode = mode\n    }\n\n    /** The date to open the calendar to initially. */\n    private _startAt: T | null\n    @Input()\n    get startAt(): T | null {\n        if (this._startAt) {\n            return this._startAt\n        }\n\n        if (this.selectMode === 'single') {\n            return this.value || null\n        } else if (\n            this.selectMode === 'range' ||\n            this.selectMode === 'rangeFrom'\n        ) {\n            return this.values[0] || null\n        } else if (this.selectMode === 'rangeTo') {\n            return this.values[1] || null\n        } else {\n            return null\n        }\n    }\n\n    set startAt(date: T | null) {\n        this._startAt = this.getValidDate(\n            this.dateTimeAdapter.deserialize(date)\n        )\n    }\n\n    private _dateTimeFilter: (date: T | null) => boolean\n    @Input('owlDateTimeFilter')\n    get dateTimeFilter() {\n        return this._dateTimeFilter\n    }\n\n    set dateTimeFilter(filter: (date: T | null) => boolean) {\n        this._dateTimeFilter = filter\n    }\n\n    /** The minimum valid date. */\n    private _min: T | null\n\n    get minDateTime(): T | null {\n        return this._min || null\n    }\n\n    // eslint-disable-next-line @angular-eslint/no-input-rename\n    @Input('min')\n    set minDateTime(value: T | null) {\n        this._min = this.getValidDate(this.dateTimeAdapter.deserialize(value))\n        this.changeDetector.markForCheck()\n    }\n\n    /** The maximum valid date. */\n    private _max: T | null\n\n    get maxDateTime(): T | null {\n        return this._max || null\n    }\n\n    // eslint-disable-next-line @angular-eslint/no-input-rename\n    @Input('max')\n    set maxDateTime(value: T | null) {\n        this._max = this.getValidDate(this.dateTimeAdapter.deserialize(value))\n        this.changeDetector.markForCheck()\n    }\n\n    private _value: T | null\n    @Input()\n    get value() {\n        return this._value\n    }\n\n    set value(value: T | null) {\n        value = this.dateTimeAdapter.deserialize(value)\n        value = this.getValidDate(value)\n        this._value = value\n        this.selected = value\n    }\n\n    private _values: T[] = []\n    @Input()\n    get values() {\n        return this._values\n    }\n\n    set values(values: T[]) {\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) : null\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     * This doesn't imply a change on the selected date.\n     * */\n    @Output()\n    yearSelected = new EventEmitter<T>()\n\n    /**\n     * Emits selected month in year view\n     * This doesn't imply a change on the selected date.\n     * */\n    @Output()\n    monthSelected = new EventEmitter<T>()\n\n    private _selected: T | null\n    get selected() {\n        return this._selected\n    }\n\n    set selected(value: T | null) {\n        this._selected = value\n        this.changeDetector.markForCheck()\n    }\n\n    private _selecteds: T[] = []\n    get selecteds() {\n        return this._selecteds\n    }\n\n    set selecteds(values: T[]) {\n        this._selecteds = values\n        this.changeDetector.markForCheck()\n    }\n\n    get opened(): 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    @HostBinding('class.owl-dt-inline')\n    get owlDTInlineClass(): boolean {\n        return true\n    }\n\n    private onModelChange: (date: T | T[]) => void = () => { }\n    private onModelTouched: () => void = () => { }\n\n    constructor(\n        protected changeDetector: ChangeDetectorRef,\n        @Optional() protected dateTimeAdapter: DateTimeAdapter<T>,\n        @Optional()\n        @Inject(OWL_DATE_TIME_FORMATS)\n        protected dateTimeFormats: OwlDateTimeFormats\n    ) {\n        super(dateTimeAdapter, dateTimeFormats)\n    }\n\n    public ngOnInit() {\n        this.container.picker = this\n    }\n\n    public writeValue(value: any): void {\n        if (this.isInSingleMode) {\n            this.value = value\n            this.container.pickerMoment = value\n        } else {\n            this.values = value\n            this.container.pickerMoment = this._values[\n                this.container.activeSelectedIndex\n            ]\n        }\n    }\n\n    public registerOnChange(fn: any): void {\n        this.onModelChange = fn\n    }\n\n    public registerOnTouched(fn: any): void {\n        this.onModelTouched = fn\n    }\n\n    public setDisabledState(isDisabled: boolean): void {\n        this.disabled = isDisabled\n    }\n\n    public 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    public selectYear(normalizedYear: T): void {\n        this.yearSelected.emit(normalizedYear)\n    }\n\n    /**\n     * Emits selected month in year view\n     * */\n    public selectMonth(normalizedMonth: T): void {\n        this.monthSelected.emit(normalizedMonth)\n    }\n}\n","<owl-date-time-container></owl-date-time-container>\n"]}