@wavemaker/app-ng-runtime 11.13.0-rc.6255 → 11.14.0-rc.232

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

@@ -0,0 +1,433 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, Injector, Input, Output, TemplateRef, ViewChild } from '@angular/core';
+import { BsDatepickerConfig, BsDatepickerModule } from 'ngx-bootstrap/datepicker';
+import { BsModalService } from 'ngx-bootstrap/modal';
+import { App } from '@wm/core';
+import { filter } from "lodash-es";
+import { PickerGroupComponent, PickerComponent } from "@wm/components/input/epoch/picker";
+import { BsDropdownModule } from 'ngx-bootstrap/dropdown';
+import * as momentLib from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-bootstrap/modal";
+import * as i2 from "ngx-bootstrap/datepicker";
+const moment = momentLib.default || window['moment'];
+export class DateTimePickerComponent {
+    constructor(inj, bsModalService) {
+        this.inj = inj;
+        this.bsModalService = bsModalService;
+        this.isDateOpen = true;
+        this.isTimeOpen = false;
+        this.mode = 'DATE_TIME';
+        this.placement = 'MODAL';
+        this.change = new EventEmitter();
+        this._value = new Date();
+        this.changedValue = null;
+        this.appLocale = inj.get(App).appLocale || {};
+    }
+    set value(d) {
+        d = d || new Date();
+        this._value = d;
+        this.changedValue = d;
+    }
+    set bsDatepickerConfig(config) {
+        this._bsDatepickerConfig = config;
+        this._bsDatepickerConfig.showClearButton = false;
+        this._bsDatepickerConfig.showTodayButton = false;
+    }
+    set excludedDaysToDisable(v) {
+        this._bsDatepickerConfig.daysDisabled = v;
+    }
+    get bsDatepickerConfig() {
+        return this._bsDatepickerConfig;
+    }
+    set displayFormat(format) {
+        if (format) {
+            this._displayFormat = format.replace(/y/g, "Y").replace(/d/g, "D").replace("a", "A");
+        }
+    }
+    validateSelectedDate() {
+        if (!this.changedValue) {
+            return true;
+        }
+        const cd = moment(this.changedValue);
+        const minDate = this._bsDatepickerConfig?.minDate;
+        const maxDate = this._bsDatepickerConfig?.maxDate;
+        if (minDate
+            && ((this.mode === 'DATE'
+                && moment(minDate).startOf('day').toDate() > this.changedValue)
+                || (this.mode !== 'DATE'
+                    && minDate > this.changedValue))) {
+            return false;
+        }
+        if (maxDate
+            && ((this.mode === 'DATE'
+                && moment(maxDate).endOf('day').toDate() < this.changedValue)
+                || (this.mode !== 'DATE'
+                    && maxDate < this.changedValue))) {
+            return false;
+        }
+        if (this._bsDatepickerConfig?.daysDisabled?.indexOf(cd.day()) >= 0) {
+            return false;
+        }
+        const cdSt = cd.startOf('day').toDate().getTime();
+        if (this.excludedDatesToDisable?.find(d => d.getTime() === cdSt)) {
+            return false;
+        }
+        return true;
+    }
+    get displayFormat() {
+        if (this._displayFormat) {
+            return this._displayFormat;
+        }
+    }
+    /**
+     * This method is used to highlight the current date
+     */
+    hightlightToday() {
+        const toDay = new Date().getDate().toString();
+        filter($(`body > modal-container .date-picker-modal span:contains(${toDay})`)
+            .not('.is-other-month,.current-date'), (obj) => {
+            if ($(obj).text() === toDay) {
+                $(obj).addClass('current-date text-info');
+            }
+        });
+    }
+    hideOnClick() {
+        $('body>modal-container .date-picker-modal .app-datetime-picker')
+            .click(($event) => $event.stopPropagation());
+        $('body>modal-container .date-picker-modal').click(() => this.onCancelClick());
+    }
+    getDateLabel() {
+        return moment(this.changedValue).format(this.displayFormat);
+    }
+    openDatePicker() {
+        this.isTimeOpen = false;
+        this.isDateOpen = true;
+    }
+    openTimePicker() {
+        this.isTimeOpen = true;
+        this.isDateOpen = false;
+    }
+    onDateUpdate(newVal) {
+        const oldVal = this.changedValue;
+        if (this.mode === 'DATE') {
+            newVal.setHours(0);
+            newVal.setMinutes(0);
+            newVal.setSeconds(0);
+            newVal.setMilliseconds(0);
+        }
+        else if (oldVal && newVal) {
+            newVal.setHours(oldVal.getHours());
+            newVal.setMinutes(oldVal.getMinutes());
+            newVal.setSeconds(oldVal.getSeconds());
+            newVal.setMilliseconds(oldVal.getMilliseconds());
+        }
+        this.changedValue = newVal;
+        if (this.mode === 'DATE'
+            && oldVal !== newVal
+            && this.validateSelectedDate()) {
+            this.onOkClick();
+        }
+    }
+    onTimeUpdate(newVal) {
+        this.changedValue = newVal;
+    }
+    show() {
+        this.reset();
+        this.modalRef = this.bsModalService.show(this.datetimepickerTemplate, {
+            animated: true,
+            backdrop: 'static',
+            class: 'date-picker-modal modal-dialog-centered'
+        });
+        setTimeout(() => { this.hideOnClick(); }, 500);
+    }
+    clear() {
+        this.changedValue = null;
+        this.triggerChange();
+        this.hideModal();
+    }
+    setToday() {
+        const today = moment().startOf('day').toDate();
+        this.onDateUpdate(today);
+    }
+    reset() {
+        this.changedValue = this._value;
+    }
+    hideModal() {
+        if (this.modalRef?.id) {
+            this.bsModalService.hide(this.modalRef.id);
+        }
+    }
+    onCancelClick() {
+        this.changedValue = this._value;
+        this.hideModal();
+    }
+    onOkClick() {
+        if (this.validateSelectedDate()) {
+            this.triggerChange();
+        }
+        this.hideModal();
+    }
+    triggerChange() {
+        if (this.value !== this.changedValue) {
+            this.change.emit(this.changedValue);
+        }
+    }
+    ngAfterViewInit() {
+    }
+    ngOnDestroy() {
+        this.hideModal();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DateTimePickerComponent, deps: [{ token: i0.Injector }, { token: i1.BsModalService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: DateTimePickerComponent, isStandalone: true, selector: "wm-datetimepicker", inputs: { mode: "mode", placement: "placement", _bsDatepickerConfig: ["config", "_bsDatepickerConfig"], minTime: "minTime", maxTime: "maxTime", _displayFormat: "_displayFormat", excludedDatesToDisable: "excludedDatesToDisable", value: "value", bsDatepickerConfig: ["config", "bsDatepickerConfig"], excludedDaysToDisable: "excludedDaysToDisable", displayFormat: "displayFormat" }, outputs: { change: "change" }, viewQueries: [{ propertyName: "datetimepickerTemplate", first: true, predicate: ["datetimepickerTemplate"], descendants: true, static: true }], ngImport: i0, template: `
+    <ng-template #datetimepickerTemplate>
+      <div class="app-datetime-picker">
+        <div class="modal-body">
+          <div class="mobile-datetime-picker-options">
+    
+          </div>
+          @if (mode === 'DATE_TIME' || mode === 'DATE') {
+            <bs-datepicker-inline
+              [bsConfig]="bsDatepickerConfig"
+              [datesDisabled]="excludedDatesToDisable"
+              bsDatepicker
+              [bsValue]="changedValue"
+              (bsValueChange)="onDateUpdate($event)"
+              >
+            </bs-datepicker-inline>
+          }
+          @if (mode === 'DATE_TIME' || mode === 'TIME') {
+            <wm-timepicker
+              [value]="changedValue"
+              [min]="minTime"
+              [max]="maxTime"
+              (change)="onTimeUpdate($event)"
+            ></wm-timepicker>
+          }
+          <span class="text-primary date-picker-value">
+            {{getDateLabel()}}
+          </span>
+        </div>
+        <div class="modal-footer">
+          @if (mode === 'DATE_TIME' || mode === 'DATE') {
+            <button
+              class="btn btn-secondary today-btn"
+            (click)="setToday()">{{appLocale.LABEL_TODAY_DATE || "Today" }}</button>
+          }
+          @if (mode === 'DATE_TIME' || mode === 'TIME') {
+            <button
+              class="btn btn-primary pull-right ok-btn"
+            (click)="onOkClick()">{{appLocale.LABEL_OK || "Ok" }}</button>
+          }
+          <button
+            class="btn btn-secondary pull-right clear-btn"
+          (click)="clear()">{{appLocale.LABEL_CLEAR_DATE || "Clear" }}</button>
+        </div>
+      </div>
+    </ng-template>
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: BsDatepickerModule }, { kind: "directive", type: i2.BsDatepickerDirective, selector: "[bsDatepicker]", inputs: ["placement", "triggers", "outsideClick", "container", "outsideEsc", "isDisabled", "minDate", "maxDate", "minMode", "daysDisabled", "datesDisabled", "datesEnabled", "dateCustomClasses", "dateTooltipTexts", "isOpen", "bsValue", "bsConfig"], outputs: ["onShown", "onHidden", "bsValueChange"], exportAs: ["bsDatepicker"] }, { kind: "directive", type: i2.BsDatepickerInlineDirective, selector: "bs-datepicker-inline", inputs: ["bsConfig", "isDisabled", "minDate", "maxDate", "dateCustomClasses", "dateTooltipTexts", "datesEnabled", "datesDisabled", "bsValue"], outputs: ["bsValueChange"], exportAs: ["bsDatepickerInline"] }, { kind: "ngmodule", type: BsDropdownModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DateTimePickerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [CommonModule, BsDatepickerModule, BsDropdownModule],
+                    selector: 'wm-datetimepicker',
+                    template: `
+    <ng-template #datetimepickerTemplate>
+      <div class="app-datetime-picker">
+        <div class="modal-body">
+          <div class="mobile-datetime-picker-options">
+    
+          </div>
+          @if (mode === 'DATE_TIME' || mode === 'DATE') {
+            <bs-datepicker-inline
+              [bsConfig]="bsDatepickerConfig"
+              [datesDisabled]="excludedDatesToDisable"
+              bsDatepicker
+              [bsValue]="changedValue"
+              (bsValueChange)="onDateUpdate($event)"
+              >
+            </bs-datepicker-inline>
+          }
+          @if (mode === 'DATE_TIME' || mode === 'TIME') {
+            <wm-timepicker
+              [value]="changedValue"
+              [min]="minTime"
+              [max]="maxTime"
+              (change)="onTimeUpdate($event)"
+            ></wm-timepicker>
+          }
+          <span class="text-primary date-picker-value">
+            {{getDateLabel()}}
+          </span>
+        </div>
+        <div class="modal-footer">
+          @if (mode === 'DATE_TIME' || mode === 'DATE') {
+            <button
+              class="btn btn-secondary today-btn"
+            (click)="setToday()">{{appLocale.LABEL_TODAY_DATE || "Today" }}</button>
+          }
+          @if (mode === 'DATE_TIME' || mode === 'TIME') {
+            <button
+              class="btn btn-primary pull-right ok-btn"
+            (click)="onOkClick()">{{appLocale.LABEL_OK || "Ok" }}</button>
+          }
+          <button
+            class="btn btn-secondary pull-right clear-btn"
+          (click)="clear()">{{appLocale.LABEL_CLEAR_DATE || "Clear" }}</button>
+        </div>
+      </div>
+    </ng-template>
+    `
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.BsModalService }], propDecorators: { datetimepickerTemplate: [{
+                type: ViewChild,
+                args: ['datetimepickerTemplate', { static: true }]
+            }], mode: [{
+                type: Input
+            }], placement: [{
+                type: Input
+            }], _bsDatepickerConfig: [{
+                type: Input,
+                args: ["config"]
+            }], minTime: [{
+                type: Input
+            }], maxTime: [{
+                type: Input
+            }], _displayFormat: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }], excludedDatesToDisable: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], bsDatepickerConfig: [{
+                type: Input,
+                args: ["config"]
+            }], excludedDaysToDisable: [{
+                type: Input
+            }], displayFormat: [{
+                type: Input
+            }] } });
+export class TimePickerComponent {
+    constructor(inj) {
+        this.inj = inj;
+        this.options = {
+            hour: [],
+            minute: [],
+            second: [],
+            meridian: ['AM', 'PM']
+        };
+        this.value = new Date();
+        this.min = null;
+        this.max = null;
+        this.change = new EventEmitter();
+        this.options.hour = this.populateNumbers(0, 23);
+        this.options.minute = this.populateNumbers(0, 59);
+        this.options.second = this.populateNumbers(0, 59);
+    }
+    populateNumbers(start, to) {
+        const arr = [];
+        for (let i = start; i <= to; i++) {
+            arr.push({
+                label: (i < 10 ? '0' : '') + i,
+                value: i
+            });
+        }
+        return arr;
+    }
+    set({ index, value }, unit) {
+        if (unit === 'HOUR') {
+            this.value = moment(this.value).hour(parseInt(value)).toDate();
+        }
+        else if (unit === 'MINUTE') {
+            this.value = moment(this.value).minute(parseInt(value)).toDate();
+        }
+        else if (unit === 'SECOND') {
+            this.value = moment(this.value).second(parseInt(value)).toDate();
+        }
+        else if (unit === 'MERIDIAN') {
+            this.value = moment(this.value).minute(value).toDate();
+        }
+        if (this.min && this.value < this.min) {
+            this.value = this.min;
+        }
+        if (this.max && this.value > this.max) {
+            this.value = this.max;
+        }
+        this.change.emit(this.value);
+    }
+    get hour() {
+        return moment(this.value).hour();
+    }
+    get minute() {
+        return moment(this.value).minute();
+    }
+    get second() {
+        return moment(this.value).second();
+    }
+    get meridian() {
+        return 'AM';
+    }
+    onDateUpdate(newVal) {
+        debugger;
+    }
+    ngAfterViewInit() {
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TimePickerComponent, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TimePickerComponent, isStandalone: true, selector: "wm-timepicker", inputs: { value: "value", min: "min", max: "max" }, outputs: { change: "change" }, ngImport: i0, template: `
+        <wm-pickergroup>
+            <wm-picker
+                [options]="options.hour"
+                [selectedValue]="hour"
+                (change)="set($event, 'HOUR')"></wm-picker>
+            <span class="app-time-separator">:</span>
+            <wm-picker
+                [options]="options.minute"
+                [selectedValue]="minute"
+                (change)="set($event, 'MINUTE')"></wm-picker>
+            <span class="app-time-separator">:</span>
+            <wm-picker
+                [options]="options.minute"
+                [selectedValue]="second"
+                (change)="set($event, 'SECOND')"></wm-picker>
+        </wm-pickergroup>
+    `, isInline: true, dependencies: [{ kind: "component", type: PickerGroupComponent, selector: "wm-pickergroup" }, { kind: "component", type: PickerComponent, selector: "wm-picker", inputs: ["selectedValue", "options"], outputs: ["change"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TimePickerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'wm-timepicker',
+                    standalone: true,
+                    template: `
+        <wm-pickergroup>
+            <wm-picker
+                [options]="options.hour"
+                [selectedValue]="hour"
+                (change)="set($event, 'HOUR')"></wm-picker>
+            <span class="app-time-separator">:</span>
+            <wm-picker
+                [options]="options.minute"
+                [selectedValue]="minute"
+                (change)="set($event, 'MINUTE')"></wm-picker>
+            <span class="app-time-separator">:</span>
+            <wm-picker
+                [options]="options.minute"
+                [selectedValue]="second"
+                (change)="set($event, 'SECOND')"></wm-picker>
+        </wm-pickergroup>
+    `,
+                    imports: [PickerGroupComponent, PickerComponent]
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }], propDecorators: { value: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time-picker.component.js","sourceRoot":"","sources":["../../../../../../projects/components/widgets/input/epoch/date-time-picker/src/date-time-picker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { AfterViewInit, Component, EventEmitter, Injector, Input, OnDestroy, Output, TemplateRef, ViewChild } from '@angular/core';\nimport { BsDatepickerConfig, BsDatepickerModule } from 'ngx-bootstrap/datepicker';\nimport { BsModalRef, BsModalService } from 'ngx-bootstrap/modal';\nimport { App } from '@wm/core';\nimport {filter} from \"lodash-es\";\nimport { PickerGroupComponent, PickerComponent } from \"@wm/components/input/epoch/picker\";\nimport { BsDropdownModule } from 'ngx-bootstrap/dropdown';\n\ndeclare const $;\nimport * as momentLib  from 'moment';\nconst moment = momentLib.default || window['moment'];\n\n@Component({\n    standalone: true,\n    imports: [CommonModule, BsDatepickerModule, BsDropdownModule],\n    selector: 'wm-datetimepicker',\n    template: `\n    <ng-template #datetimepickerTemplate>\n      <div class=\"app-datetime-picker\">\n        <div class=\"modal-body\">\n          <div class=\"mobile-datetime-picker-options\">\n    \n          </div>\n          @if (mode === 'DATE_TIME' || mode === 'DATE') {\n            <bs-datepicker-inline\n              [bsConfig]=\"bsDatepickerConfig\"\n              [datesDisabled]=\"excludedDatesToDisable\"\n              bsDatepicker\n              [bsValue]=\"changedValue\"\n              (bsValueChange)=\"onDateUpdate($event)\"\n              >\n            </bs-datepicker-inline>\n          }\n          @if (mode === 'DATE_TIME' || mode === 'TIME') {\n            <wm-timepicker\n              [value]=\"changedValue\"\n              [min]=\"minTime\"\n              [max]=\"maxTime\"\n              (change)=\"onTimeUpdate($event)\"\n            ></wm-timepicker>\n          }\n          <span class=\"text-primary date-picker-value\">\n            {{getDateLabel()}}\n          </span>\n        </div>\n        <div class=\"modal-footer\">\n          @if (mode === 'DATE_TIME' || mode === 'DATE') {\n            <button\n              class=\"btn btn-secondary today-btn\"\n            (click)=\"setToday()\">{{appLocale.LABEL_TODAY_DATE || \"Today\" }}</button>\n          }\n          @if (mode === 'DATE_TIME' || mode === 'TIME') {\n            <button\n              class=\"btn btn-primary pull-right ok-btn\"\n            (click)=\"onOkClick()\">{{appLocale.LABEL_OK || \"Ok\" }}</button>\n          }\n          <button\n            class=\"btn btn-secondary pull-right clear-btn\"\n          (click)=\"clear()\">{{appLocale.LABEL_CLEAR_DATE || \"Clear\" }}</button>\n        </div>\n      </div>\n    </ng-template>\n    `\n})\nexport class DateTimePickerComponent implements AfterViewInit, OnDestroy {\n\n    private isDateOpen = true;\n\n    private isTimeOpen = false;\n\n    private appLocale: any;\n\n    @ViewChild('datetimepickerTemplate' , { static: true }) datetimepickerTemplate: TemplateRef<any>;\n\n    @Input()\n    private mode: 'DATE' | 'TIME' | 'DATE_TIME' = 'DATE_TIME';\n\n    @Input()\n    private placement: 'MODAL' | 'INLINE' = 'MODAL';\n\n    @Input(\"config\")\n    private _bsDatepickerConfig: BsDatepickerConfig;\n\n    @Input()\n    private minTime: Date;\n\n    @Input()\n    private maxTime: Date;\n\n    @Input()\n    private _displayFormat: string;\n\n    @Output() change = new EventEmitter<Date>();\n\n    private _value = new Date();\n\n    private changedValue = null;\n\n    private modalRef: BsModalRef;\n\n    @Input()\n    private excludedDatesToDisable;\n\n    constructor(\n        protected inj: Injector,\n        private bsModalService: BsModalService) {\n        this.appLocale = inj.get(App).appLocale || {};\n    }\n\n    @Input()\n    set value(d: Date) {\n        d = d || new Date();\n        this._value = d;\n        this.changedValue = d;\n    }\n\n\n    @Input(\"config\")\n    set bsDatepickerConfig(config: BsDatepickerConfig) {\n        this._bsDatepickerConfig = config;\n        this._bsDatepickerConfig.showClearButton = false;\n        this._bsDatepickerConfig.showTodayButton = false;\n    }\n\n    @Input()\n    set excludedDaysToDisable(v: number[]) {\n        this._bsDatepickerConfig.daysDisabled = v;\n    }\n\n    get bsDatepickerConfig() {\n        return this._bsDatepickerConfig;\n    }\n\n    @Input()\n    set displayFormat(format: string) {\n        if (format) {\n            this._displayFormat = format.replace(/y/g, \"Y\").replace(/d/g, \"D\").replace(\"a\", \"A\");\n        }\n    }\n\n    validateSelectedDate() {\n        if (!this.changedValue) {\n            return true;\n        }\n        const cd = moment(this.changedValue);\n        const minDate = this._bsDatepickerConfig?.minDate;\n        const maxDate = this._bsDatepickerConfig?.maxDate;\n        if (minDate\n            && ((this.mode === 'DATE'\n                    && moment(minDate).startOf('day').toDate() > this.changedValue)\n                || (this.mode !== 'DATE'\n                    && minDate > this.changedValue))) {\n            return false;\n        }\n        if (maxDate\n            && ((this.mode === 'DATE'\n                    && moment(maxDate).endOf('day').toDate() < this.changedValue)\n                || (this.mode !== 'DATE'\n                    && maxDate < this.changedValue))) {\n            return false;\n        }\n        if (this._bsDatepickerConfig?.daysDisabled?.indexOf(cd.day()) >= 0) {\n            return false;\n        }\n        const cdSt = cd.startOf('day').toDate().getTime();\n        if (this.excludedDatesToDisable?.find(d => d.getTime() === cdSt)) {\n            return false;\n        }\n        return true;\n    }\n\n    get displayFormat() {\n        if (this._displayFormat) {\n            return this._displayFormat;\n        }\n    }\n    /**\n     * This method is used to highlight the current date\n     */\n    private hightlightToday() {\n        const toDay = new Date().getDate().toString();\n        filter($(`body > modal-container .date-picker-modal span:contains(${toDay})`)\n            .not('.is-other-month,.current-date'), (obj) => {\n            if ($(obj).text() === toDay) {\n                $(obj).addClass('current-date text-info');\n            }\n        });\n    }\n\n    private hideOnClick() {\n        $('body>modal-container .date-picker-modal .app-datetime-picker')\n            .click(($event) => $event.stopPropagation());\n        $('body>modal-container .date-picker-modal').click(() => this.onCancelClick());\n    }\n\n    getDateLabel() {\n        return moment(this.changedValue).format(this.displayFormat);\n    }\n\n    openDatePicker() {\n        this.isTimeOpen = false;\n        this.isDateOpen = true;\n    }\n\n    openTimePicker() {\n        this.isTimeOpen = true;\n        this.isDateOpen = false;\n    }\n\n    public onDateUpdate(newVal) {\n        const oldVal = this.changedValue;\n         if (this.mode === 'DATE') {\n            newVal.setHours(0);\n            newVal.setMinutes(0);\n            newVal.setSeconds(0);\n            newVal.setMilliseconds(0);\n        } else if (oldVal && newVal) {\n            newVal.setHours(oldVal.getHours());\n            newVal.setMinutes(oldVal.getMinutes());\n            newVal.setSeconds(oldVal.getSeconds());\n            newVal.setMilliseconds(oldVal.getMilliseconds());\n        }\n        this.changedValue = newVal;\n        if (this.mode === 'DATE'\n            && oldVal !== newVal\n            && this.validateSelectedDate()) {\n            this.onOkClick();\n        }\n    }\n\n    public onTimeUpdate(newVal) {\n        this.changedValue = newVal;\n    }\n\n    show() {\n        this.reset();\n        this.modalRef = this.bsModalService.show(this.datetimepickerTemplate, {\n            animated: true,\n            backdrop: 'static',\n            class: 'date-picker-modal modal-dialog-centered'\n        });\n        setTimeout(() => { this.hideOnClick()}, 500);\n    }\n\n    clear() {\n        this.changedValue = null;\n        this.triggerChange();\n        this.hideModal();\n    }\n\n    setToday() {\n        const today = moment().startOf('day').toDate();\n        this.onDateUpdate(today);\n    }\n\n    reset() {\n        this.changedValue = this._value;\n    }\n\n    hideModal() {\n        if (this.modalRef?.id) {\n            this.bsModalService.hide(this.modalRef.id);\n        }\n    }\n\n    onCancelClick() {\n        this.changedValue = this._value;\n        this.hideModal();\n    }\n\n    onOkClick() {\n        if (this.validateSelectedDate()) {\n            this.triggerChange();\n        }\n        this.hideModal();\n    }\n\n    triggerChange() {\n        if (this.value !== this.changedValue) {\n            this.change.emit(this.changedValue);\n        }\n    }\n\n    ngAfterViewInit(): void {\n\n    }\n\n    ngOnDestroy(): void {\n        this.hideModal();\n    }\n\n}\n\n\n@Component({\n    selector: 'wm-timepicker',\n    standalone: true,\n    template: `\n        <wm-pickergroup>\n            <wm-picker\n                [options]=\"options.hour\"\n                [selectedValue]=\"hour\"\n                (change)=\"set($event, 'HOUR')\"></wm-picker>\n            <span class=\"app-time-separator\">:</span>\n            <wm-picker\n                [options]=\"options.minute\"\n                [selectedValue]=\"minute\"\n                (change)=\"set($event, 'MINUTE')\"></wm-picker>\n            <span class=\"app-time-separator\">:</span>\n            <wm-picker\n                [options]=\"options.minute\"\n                [selectedValue]=\"second\"\n                (change)=\"set($event, 'SECOND')\"></wm-picker>\n        </wm-pickergroup>\n    `,\n    imports: [PickerGroupComponent, PickerComponent]\n})\nexport class TimePickerComponent implements AfterViewInit {\n\n    options = {\n        hour: [],\n        minute: [],\n        second: [],\n        meridian: ['AM', 'PM']\n    };\n\n    @Input()\n    private value = new Date();\n\n    @Input()\n    private min: Date = null;\n\n    @Input()\n    private max: Date = null;\n\n    @Output() change = new EventEmitter<Date>();\n\n    constructor(\n        protected inj: Injector) {\n        this.options.hour = this.populateNumbers(0, 23);\n        this.options.minute = this.populateNumbers(0, 59);\n        this.options.second = this.populateNumbers(0, 59);\n    }\n\n    private populateNumbers(start: number, to: number) {\n        const arr = [];\n        for(let i = start; i <= to; i++) {\n            arr.push({\n                label: (i < 10 ? '0' : '') + i,\n                value: i\n            })\n        }\n        return arr;\n    }\n\n    set({index, value}, unit: 'HOUR' | 'MINUTE' | 'SECOND' | 'MERIDIAN') {\n        if (unit === 'HOUR') {\n            this.value = moment(this.value).hour(parseInt(value)).toDate();\n        } else if (unit === 'MINUTE') {\n            this.value = moment(this.value).minute(parseInt(value)).toDate();\n        } else if (unit === 'SECOND') {\n            this.value = moment(this.value).second(parseInt(value)).toDate();\n        } else if (unit === 'MERIDIAN') {\n            this.value = moment(this.value).minute(value).toDate();\n        }\n        if (this.min && this.value < this.min) {\n            this.value = this.min;\n        }\n        if (this.max && this.value > this.max) {\n            this.value = this.max;\n        }\n        this.change.emit(this.value);\n    }\n\n    get hour() {\n        return moment(this.value).hour();\n    }\n\n    get minute() {\n        return moment(this.value).minute();\n    }\n\n    get second() {\n        return moment(this.value).second();\n    }\n\n    get meridian() {\n        return 'AM';\n    }\n\n    public onDateUpdate(newVal) {\n        debugger;\n    }\n\n    ngAfterViewInit(): void {\n\n    }\n\n}\n"]}

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

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

package/components/input/epoch/date-time-picker/esm2022/public_api.mjs

@@ -0,0 +1,2 @@
+export * from './date-time-picker.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvd2lkZ2V0cy9pbnB1dC9lcG9jaC9kYXRlLXRpbWUtcGlja2VyL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsOEJBQThCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RhdGUtdGltZS1waWNrZXIuY29tcG9uZW50JzsiXX0=