@openmrs/ngx-formentry 3.0.0

package/esm2015/components/ngx-pick-datetime/lib/date-time/date-time.class.js

@@ -0,0 +1,166 @@
+/**
+ * date-time.class
+ */
+import { Inject, Injectable, Input, Optional } from '@angular/core';
+import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { DateTimeAdapter } from './adapter/date-time-adapter.class';
+import { OWL_DATE_TIME_FORMATS } from './adapter/date-time-format.class';
+import * as i0 from "@angular/core";
+import * as i1 from "./adapter/date-time-adapter.class";
+let nextUniqueId = 0;
+export class OwlDateTime {
+    constructor(dateTimeAdapter, dateTimeFormats) {
+        this.dateTimeAdapter = dateTimeAdapter;
+        this.dateTimeFormats = dateTimeFormats;
+        /**
+         * Whether to show the second's timer
+         */
+        this._showSecondsTimer = false;
+        /**
+         * Whether the timer is in hour12 format
+         */
+        this._hour12Timer = false;
+        /**
+         * The view that the calendar should start in.
+         */
+        this.startView = 'month';
+        /**
+         * Hours to change per step
+         */
+        this._stepHour = 1;
+        /**
+         * Minutes to change per step
+         */
+        this._stepMinute = 1;
+        /**
+         * Seconds to change per step
+         */
+        this._stepSecond = 1;
+        /**
+         * Set the first day of week
+         */
+        this._firstDayOfWeek = 0;
+        /**
+         * Whether to hide dates in other months at the start or end of the current month.
+         */
+        this._hideOtherMonths = false;
+        /**
+         * Date Time Checker to check if the give dateTime is selectable
+         */
+        this.dateTimeChecker = (dateTime) => {
+            return (!!dateTime &&
+                (!this.dateTimeFilter || this.dateTimeFilter(dateTime)) &&
+                (!this.minDateTime ||
+                    this.dateTimeAdapter.compare(dateTime, this.minDateTime) >= 0) &&
+                (!this.maxDateTime ||
+                    this.dateTimeAdapter.compare(dateTime, this.maxDateTime) <= 0));
+        };
+        if (!this.dateTimeAdapter) {
+            throw Error(`OwlDateTimePicker: No provider found for DateTimeAdapter. You must import one of the following ` +
+                `modules at your application root: OwlNativeDateTimeModule, OwlMomentDateTimeModule, or provide a ` +
+                `custom implementation.`);
+        }
+        if (!this.dateTimeFormats) {
+            throw Error(`OwlDateTimePicker: No provider found for OWL_DATE_TIME_FORMATS. You must import one of the following ` +
+                `modules at your application root: OwlNativeDateTimeModule, OwlMomentDateTimeModule, or provide a ` +
+                `custom implementation.`);
+        }
+        this._id = `owl-dt-picker-${nextUniqueId++}`;
+    }
+    get showSecondsTimer() {
+        return this._showSecondsTimer;
+    }
+    set showSecondsTimer(val) {
+        this._showSecondsTimer = coerceBooleanProperty(val);
+    }
+    get hour12Timer() {
+        return this._hour12Timer;
+    }
+    set hour12Timer(val) {
+        this._hour12Timer = coerceBooleanProperty(val);
+    }
+    get stepHour() {
+        return this._stepHour;
+    }
+    set stepHour(val) {
+        this._stepHour = coerceNumberProperty(val, 1);
+    }
+    get stepMinute() {
+        return this._stepMinute;
+    }
+    set stepMinute(val) {
+        this._stepMinute = coerceNumberProperty(val, 1);
+    }
+    get stepSecond() {
+        return this._stepSecond;
+    }
+    set stepSecond(val) {
+        this._stepSecond = coerceNumberProperty(val, 1);
+    }
+    get firstDayOfWeek() {
+        return this._firstDayOfWeek;
+    }
+    set firstDayOfWeek(value) {
+        value = coerceNumberProperty(value, 0);
+        if (value > 6 || value < 0) {
+            this._firstDayOfWeek = 0;
+        }
+        else {
+            this._firstDayOfWeek = value;
+        }
+    }
+    get hideOtherMonths() {
+        return this._hideOtherMonths;
+    }
+    set hideOtherMonths(val) {
+        this._hideOtherMonths = coerceBooleanProperty(val);
+    }
+    get id() {
+        return this._id;
+    }
+    get formatString() {
+        return this.pickerType === 'both'
+            ? this.dateTimeFormats.fullPickerInput
+            : this.pickerType === 'calendar'
+                ? this.dateTimeFormats.datePickerInput
+                : this.dateTimeFormats.timePickerInput;
+    }
+    get disabled() {
+        return false;
+    }
+    getValidDate(obj) {
+        return this.dateTimeAdapter.isDateInstance(obj) &&
+            this.dateTimeAdapter.isValid(obj)
+            ? obj
+            : null;
+    }
+}
+OwlDateTime.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlDateTime, deps: [{ token: i1.DateTimeAdapter, optional: true }, { token: OWL_DATE_TIME_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+OwlDateTime.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlDateTime });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlDateTime, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DateTimeAdapter, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [OWL_DATE_TIME_FORMATS]
+                }] }]; }, propDecorators: { showSecondsTimer: [{
+                type: Input
+            }], hour12Timer: [{
+                type: Input
+            }], stepHour: [{
+                type: Input
+            }], stepMinute: [{
+                type: Input
+            }], stepSecond: [{
+                type: Input
+            }], firstDayOfWeek: [{
+                type: Input
+            }], hideOtherMonths: [{
+                type: Input
+            }], startView: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time.class.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-formentry/src/components/ngx-pick-datetime/lib/date-time/date-time.class.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * date-time.class\n */\nimport {\n  Component,\n  EventEmitter,\n  Inject,\n  Injectable,\n  Input,\n  Optional\n} from '@angular/core';\nimport {\n  coerceBooleanProperty,\n  coerceNumberProperty\n} from '@angular/cdk/coercion';\nimport { DateTimeAdapter } from './adapter/date-time-adapter.class';\nimport {\n  OWL_DATE_TIME_FORMATS,\n  OwlDateTimeFormats\n} from './adapter/date-time-format.class';\n\nlet nextUniqueId = 0;\n\nexport type PickerType = 'both' | 'calendar' | 'timer';\n\nexport type PickerMode = 'popup' | 'dialog' | 'inline';\n\nexport type SelectMode = 'single' | 'range' | 'rangeFrom' | 'rangeTo';\n\n@Injectable()\nexport abstract class OwlDateTime<T> {\n  @Input()\n  get showSecondsTimer(): boolean {\n    return this._showSecondsTimer;\n  }\n\n  set showSecondsTimer(val: boolean) {\n    this._showSecondsTimer = coerceBooleanProperty(val);\n  }\n  @Input()\n  get hour12Timer(): boolean {\n    return this._hour12Timer;\n  }\n\n  set hour12Timer(val: boolean) {\n    this._hour12Timer = coerceBooleanProperty(val);\n  }\n  @Input()\n  get stepHour(): number {\n    return this._stepHour;\n  }\n\n  set stepHour(val: number) {\n    this._stepHour = coerceNumberProperty(val, 1);\n  }\n  @Input()\n  get stepMinute(): number {\n    return this._stepMinute;\n  }\n\n  set stepMinute(val: number) {\n    this._stepMinute = coerceNumberProperty(val, 1);\n  }\n  @Input()\n  get stepSecond(): number {\n    return this._stepSecond;\n  }\n\n  set stepSecond(val: number) {\n    this._stepSecond = coerceNumberProperty(val, 1);\n  }\n  @Input()\n  get firstDayOfWeek() {\n    return this._firstDayOfWeek;\n  }\n\n  set firstDayOfWeek(value: number) {\n    value = coerceNumberProperty(value, 0);\n    if (value > 6 || value < 0) {\n      this._firstDayOfWeek = 0;\n    } else {\n      this._firstDayOfWeek = value;\n    }\n  }\n  @Input()\n  get hideOtherMonths(): boolean {\n    return this._hideOtherMonths;\n  }\n\n  set hideOtherMonths(val: boolean) {\n    this._hideOtherMonths = coerceBooleanProperty(val);\n  }\n  get id(): string {\n    return this._id;\n  }\n\n  abstract get selected(): T | null;\n\n  abstract get selecteds(): T[] | null;\n\n  abstract get dateTimeFilter(): (date: T | null) => boolean;\n\n  abstract get maxDateTime(): T | null;\n\n  abstract get minDateTime(): T | null;\n\n  abstract get selectMode(): SelectMode;\n\n  abstract get startAt(): T | null;\n\n  abstract get opened(): boolean;\n\n  abstract get pickerMode(): PickerMode;\n\n  abstract get pickerType(): PickerType;\n\n  abstract get isInSingleMode(): boolean;\n\n  abstract get isInRangeMode(): boolean;\n\n  get formatString(): string {\n    return this.pickerType === 'both'\n      ? this.dateTimeFormats.fullPickerInput\n      : this.pickerType === 'calendar'\n      ? this.dateTimeFormats.datePickerInput\n      : this.dateTimeFormats.timePickerInput;\n  }\n\n  get disabled(): boolean {\n    return false;\n  }\n\n  constructor(\n    @Optional() protected dateTimeAdapter: DateTimeAdapter<T>,\n    @Optional()\n    @Inject(OWL_DATE_TIME_FORMATS)\n    protected dateTimeFormats: OwlDateTimeFormats\n  ) {\n    if (!this.dateTimeAdapter) {\n      throw Error(\n        `OwlDateTimePicker: No provider found for DateTimeAdapter. You must import one of the following ` +\n          `modules at your application root: OwlNativeDateTimeModule, OwlMomentDateTimeModule, or provide a ` +\n          `custom implementation.`\n      );\n    }\n\n    if (!this.dateTimeFormats) {\n      throw Error(\n        `OwlDateTimePicker: No provider found for OWL_DATE_TIME_FORMATS. You must import one of the following ` +\n          `modules at your application root: OwlNativeDateTimeModule, OwlMomentDateTimeModule, or provide a ` +\n          `custom implementation.`\n      );\n    }\n\n    this._id = `owl-dt-picker-${nextUniqueId++}`;\n  }\n  /**\n   * Whether to show the second's timer\n   */\n  private _showSecondsTimer = false;\n\n  /**\n   * Whether the timer is in hour12 format\n   */\n  private _hour12Timer = false;\n\n  /**\n   * The view that the calendar should start in.\n   */\n  @Input()\n  startView: 'month' | 'year' | 'multi-years' = 'month';\n\n  /**\n   * Hours to change per step\n   */\n  private _stepHour = 1;\n\n  /**\n   * Minutes to change per step\n   */\n  private _stepMinute = 1;\n\n  /**\n   * Seconds to change per step\n   */\n  private _stepSecond = 1;\n\n  /**\n   * Set the first day of week\n   */\n  private _firstDayOfWeek = 0;\n\n  /**\n   * Whether to hide dates in other months at the start or end of the current month.\n   */\n  private _hideOtherMonths = false;\n\n  private _id: string;\n\n  abstract yearSelected: EventEmitter<T>;\n\n  abstract monthSelected: EventEmitter<T>;\n\n  abstract select(date: T | T[]): void;\n\n  abstract selectYear(normalizedYear: T): void;\n\n  abstract selectMonth(normalizedMonth: T): void;\n\n  /**\n   * Date Time Checker to check if the give dateTime is selectable\n   */\n  public dateTimeChecker = (dateTime: T) => {\n    return (\n      !!dateTime &&\n      (!this.dateTimeFilter || this.dateTimeFilter(dateTime)) &&\n      (!this.minDateTime ||\n        this.dateTimeAdapter.compare(dateTime, this.minDateTime) >= 0) &&\n      (!this.maxDateTime ||\n        this.dateTimeAdapter.compare(dateTime, this.maxDateTime) <= 0)\n    );\n  };\n\n  protected getValidDate(obj: any): T | null {\n    return this.dateTimeAdapter.isDateInstance(obj) &&\n      this.dateTimeAdapter.isValid(obj)\n      ? obj\n      : null;\n  }\n}\n"]}

package/esm2015/components/ngx-pick-datetime/lib/date-time/date-time.module.js

@@ -0,0 +1,83 @@
+/**
+ * date-time.module
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { A11yModule } from '@angular/cdk/a11y';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { OwlDateTimeTriggerDirective } from './date-time-picker-trigger.directive';
+import { OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER, OwlDateTimeComponent } from './date-time-picker.component';
+import { OwlDateTimeContainerComponent } from './date-time-picker-container.component';
+import { OwlDateTimeInputDirective } from './date-time-picker-input.directive';
+import { OwlDateTimeIntl } from './date-time-picker-intl.service';
+import { OwlMonthViewComponent } from './calendar-month-view.component';
+import { OwlCalendarBodyComponent } from './calendar-body.component';
+import { OwlYearViewComponent } from './calendar-year-view.component';
+import { OwlMultiYearViewComponent } from './calendar-multi-year-view.component';
+import { OwlTimerBoxComponent } from './timer-box.component';
+import { OwlTimerComponent } from './timer.component';
+import { NumberFixedLenPipe } from './numberedFixLen.pipe';
+import { OwlCalendarComponent } from './calendar.component';
+import { OwlDateTimeInlineComponent } from './date-time-inline.component';
+import { OwlDialogModule } from '../dialog/dialog.module';
+import * as i0 from "@angular/core";
+export class OwlDateTimeModule {
+}
+OwlDateTimeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlDateTimeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+OwlDateTimeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlDateTimeModule, declarations: [OwlDateTimeTriggerDirective,
+        OwlDateTimeInputDirective,
+        OwlDateTimeComponent,
+        OwlDateTimeContainerComponent,
+        OwlMultiYearViewComponent,
+        OwlYearViewComponent,
+        OwlMonthViewComponent,
+        OwlTimerComponent,
+        OwlTimerBoxComponent,
+        OwlCalendarComponent,
+        OwlCalendarBodyComponent,
+        NumberFixedLenPipe,
+        OwlDateTimeInlineComponent], imports: [CommonModule, OverlayModule, OwlDialogModule, A11yModule], exports: [OwlCalendarComponent,
+        OwlTimerComponent,
+        OwlDateTimeTriggerDirective,
+        OwlDateTimeInputDirective,
+        OwlDateTimeComponent,
+        OwlDateTimeInlineComponent,
+        OwlMultiYearViewComponent,
+        OwlYearViewComponent,
+        OwlMonthViewComponent] });
+OwlDateTimeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlDateTimeModule, providers: [OwlDateTimeIntl, OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER], imports: [[CommonModule, OverlayModule, OwlDialogModule, A11yModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlDateTimeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, OverlayModule, OwlDialogModule, A11yModule],
+                    exports: [
+                        OwlCalendarComponent,
+                        OwlTimerComponent,
+                        OwlDateTimeTriggerDirective,
+                        OwlDateTimeInputDirective,
+                        OwlDateTimeComponent,
+                        OwlDateTimeInlineComponent,
+                        OwlMultiYearViewComponent,
+                        OwlYearViewComponent,
+                        OwlMonthViewComponent
+                    ],
+                    declarations: [
+                        OwlDateTimeTriggerDirective,
+                        OwlDateTimeInputDirective,
+                        OwlDateTimeComponent,
+                        OwlDateTimeContainerComponent,
+                        OwlMultiYearViewComponent,
+                        OwlYearViewComponent,
+                        OwlMonthViewComponent,
+                        OwlTimerComponent,
+                        OwlTimerBoxComponent,
+                        OwlCalendarComponent,
+                        OwlCalendarBodyComponent,
+                        NumberFixedLenPipe,
+                        OwlDateTimeInlineComponent
+                    ],
+                    providers: [OwlDateTimeIntl, OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER],
+                    entryComponents: [OwlDateTimeContainerComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/ngx-pick-datetime/lib/date-time/numberedFixLen.pipe.js

@@ -0,0 +1,28 @@
+/**
+ * numberFixedLen.pipe
+ */
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NumberFixedLenPipe {
+    transform(num, len) {
+        const number = Math.floor(num);
+        const length = Math.floor(len);
+        if (num === null || isNaN(number) || isNaN(length)) {
+            return num;
+        }
+        let numString = number.toString();
+        while (numString.length < length) {
+            numString = '0' + numString;
+        }
+        return numString;
+    }
+}
+NumberFixedLenPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NumberFixedLenPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NumberFixedLenPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NumberFixedLenPipe, name: "numberFixedLen" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NumberFixedLenPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'numberFixedLen'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVtYmVyZWRGaXhMZW4ucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1mb3JtZW50cnkvc3JjL2NvbXBvbmVudHMvbmd4LXBpY2stZGF0ZXRpbWUvbGliL2RhdGUtdGltZS9udW1iZXJlZEZpeExlbi5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7O0FBS3BELE1BQU0sT0FBTyxrQkFBa0I7SUFDN0IsU0FBUyxDQUFDLEdBQVcsRUFBRSxHQUFXO1FBQ2hDLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDL0IsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUUvQixJQUFJLEdBQUcsS0FBSyxJQUFJLElBQUksS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLEtBQUssQ0FBQyxNQUFNLENBQUMsRUFBRTtZQUNsRCxPQUFPLEdBQUcsQ0FBQztTQUNaO1FBRUQsSUFBSSxTQUFTLEdBQUcsTUFBTSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBRWxDLE9BQU8sU0FBUyxDQUFDLE1BQU0sR0FBRyxNQUFNLEVBQUU7WUFDaEMsU0FBUyxHQUFHLEdBQUcsR0FBRyxTQUFTLENBQUM7U0FDN0I7UUFFRCxPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDOztnSEFoQlUsa0JBQWtCOzhHQUFsQixrQkFBa0I7NEZBQWxCLGtCQUFrQjtrQkFIOUIsSUFBSTttQkFBQztvQkFDSixJQUFJLEVBQUUsZ0JBQWdCO2lCQUN2QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogbnVtYmVyRml4ZWRMZW4ucGlwZVxuICovXG5cbmltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQFBpcGUoe1xuICBuYW1lOiAnbnVtYmVyRml4ZWRMZW4nXG59KVxuZXhwb3J0IGNsYXNzIE51bWJlckZpeGVkTGVuUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICB0cmFuc2Zvcm0obnVtOiBudW1iZXIsIGxlbjogbnVtYmVyKTogYW55IHtcbiAgICBjb25zdCBudW1iZXIgPSBNYXRoLmZsb29yKG51bSk7XG4gICAgY29uc3QgbGVuZ3RoID0gTWF0aC5mbG9vcihsZW4pO1xuXG4gICAgaWYgKG51bSA9PT0gbnVsbCB8fCBpc05hTihudW1iZXIpIHx8IGlzTmFOKGxlbmd0aCkpIHtcbiAgICAgIHJldHVybiBudW07XG4gICAgfVxuXG4gICAgbGV0IG51bVN0cmluZyA9IG51bWJlci50b1N0cmluZygpO1xuXG4gICAgd2hpbGUgKG51bVN0cmluZy5sZW5ndGggPCBsZW5ndGgpIHtcbiAgICAgIG51bVN0cmluZyA9ICcwJyArIG51bVN0cmluZztcbiAgICB9XG5cbiAgICByZXR1cm4gbnVtU3RyaW5nO1xuICB9XG59XG4iXX0=

package/esm2015/components/ngx-pick-datetime/lib/date-time/timer-box.component.js

@@ -0,0 +1,96 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, HostBinding, Input, Output } from '@angular/core';
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { Subject, Subscription } from 'rxjs';
+import { debounceTime, distinctUntilChanged } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./numberedFixLen.pipe";
+export class OwlTimerBoxComponent {
+    constructor() {
+        this.showDivider = false;
+        this.step = 1;
+        this.valueChange = new EventEmitter();
+        this.inputChange = new EventEmitter();
+        this.inputStream = new Subject();
+        this.inputStreamSub = Subscription.EMPTY;
+    }
+    get owlDTTimerBoxClass() {
+        return true;
+    }
+    get displayValue() {
+        return this.boxValue || this.value;
+    }
+    ngOnInit() {
+        this.inputStreamSub = this.inputStream
+            .pipe(debounceTime(500), distinctUntilChanged())
+            .subscribe((val) => {
+            if (val) {
+                const inputValue = coerceNumberProperty(val, 0);
+                this.updateValueViaInput(inputValue);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.inputStreamSub.unsubscribe();
+    }
+    upBtnClicked() {
+        this.updateValue(this.value + this.step);
+    }
+    downBtnClicked() {
+        this.updateValue(this.value - this.step);
+    }
+    handleInputChange(val) {
+        this.inputStream.next(val);
+    }
+    updateValue(value) {
+        this.valueChange.emit(value);
+    }
+    updateValueViaInput(value) {
+        if (value > this.max || value < this.min) {
+            return;
+        }
+        this.inputChange.emit(value);
+    }
+}
+OwlTimerBoxComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlTimerBoxComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+OwlTimerBoxComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: OwlTimerBoxComponent, selector: "ofe-owl-date-time-timer-box", inputs: { showDivider: "showDivider", upBtnAriaLabel: "upBtnAriaLabel", upBtnDisabled: "upBtnDisabled", downBtnAriaLabel: "downBtnAriaLabel", downBtnDisabled: "downBtnDisabled", boxValue: "boxValue", value: "value", min: "min", max: "max", step: "step", inputLabel: "inputLabel" }, outputs: { valueChange: "valueChange", inputChange: "inputChange" }, host: { properties: { "class.owl-dt-timer-box": "this.owlDTTimerBoxClass" } }, exportAs: ["owlDateTimeTimerBox"], ngImport: i0, template: "<div *ngIf=\"showDivider\" class=\"owl-dt-timer-divider\" aria-hidden=\"true\"></div>\n<button\n  class=\"owl-dt-control-button owl-dt-control-arrow-button\"\n  type=\"button\"\n  tabindex=\"-1\"\n  [disabled]=\"upBtnDisabled\"\n  [attr.aria-label]=\"upBtnAriaLabel\"\n  (click)=\"upBtnClicked()\"\n>\n  <span class=\"owl-dt-control-button-content\" tabindex=\"-1\">\n    <!-- <editor-fold desc=\"SVG Arrow Up\"> -->\n    <svg\n      xmlns=\"http://www.w3.org/2000/svg\"\n      xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n      version=\"1.1\"\n      x=\"0px\"\n      y=\"0px\"\n      viewBox=\"0 0 451.847 451.846\"\n      style=\"enable-background: new 0 0 451.847 451.846\"\n      xml:space=\"preserve\"\n      width=\"100%\"\n      height=\"100%\"\n    >\n      <path\n        d=\"M248.292,106.406l194.281,194.29c12.365,12.359,12.365,32.391,0,44.744c-12.354,12.354-32.391,12.354-44.744,0\n                        L225.923,173.529L54.018,345.44c-12.36,12.354-32.395,12.354-44.748,0c-12.359-12.354-12.359-32.391,0-44.75L203.554,106.4\n                        c6.18-6.174,14.271-9.259,22.369-9.259C234.018,97.141,242.115,100.232,248.292,106.406z\"\n      />\n    </svg>\n    <!-- </editor-fold> -->\n  </span>\n</button>\n<label class=\"owl-dt-timer-content\">\n  <input\n    class=\"owl-dt-timer-input\"\n    maxlength=\"2\"\n    [value]=\"displayValue | numberFixedLen: 2\"\n    (input)=\"handleInputChange(valueInput.value)\"\n    #valueInput\n  />\n  <span class=\"owl-hidden-accessible\">{{ inputLabel }}</span>\n</label>\n<button\n  class=\"owl-dt-control-button owl-dt-control-arrow-button\"\n  type=\"button\"\n  tabindex=\"-1\"\n  [disabled]=\"downBtnDisabled\"\n  [attr.aria-label]=\"downBtnAriaLabel\"\n  (click)=\"downBtnClicked()\"\n>\n  <span class=\"owl-dt-control-button-content\" tabindex=\"-1\">\n    <!-- <editor-fold desc=\"SVG Arrow Down\"> -->\n    <svg\n      xmlns=\"http://www.w3.org/2000/svg\"\n      xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n      version=\"1.1\"\n      x=\"0px\"\n      y=\"0px\"\n      viewBox=\"0 0 451.847 451.846\"\n      style=\"enable-background: new 0 0 451.847 451.846\"\n      xml:space=\"preserve\"\n      width=\"100%\"\n      height=\"100%\"\n    >\n      <path\n        d=\"M225.923,354.706c-8.098,0-16.195-3.092-22.369-9.263L9.27,151.157c-12.359-12.359-12.359-32.397,0-44.751\n                        c12.354-12.354,32.388-12.354,44.748,0l171.905,171.915l171.906-171.909c12.359-12.354,32.391-12.354,44.744,0\n                        c12.365,12.354,12.365,32.392,0,44.751L248.292,345.449C242.115,351.621,234.018,354.706,225.923,354.706z\"\n      />\n    </svg>\n    <!-- </editor-fold> -->\n  </span>\n</button>\n", styles: [""], directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "numberFixedLen": i2.NumberFixedLenPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlTimerBoxComponent, decorators: [{
+            type: Component,
+            args: [{
+                    exportAs: 'owlDateTimeTimerBox',
+                    selector: 'ofe-owl-date-time-timer-box',
+                    templateUrl: './timer-box.component.html',
+                    styleUrls: ['./timer-box.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { owlDTTimerBoxClass: [{
+                type: HostBinding,
+                args: ['class.owl-dt-timer-box']
+            }], showDivider: [{
+                type: Input
+            }], upBtnAriaLabel: [{
+                type: Input
+            }], upBtnDisabled: [{
+                type: Input
+            }], downBtnAriaLabel: [{
+                type: Input
+            }], downBtnDisabled: [{
+                type: Input
+            }], boxValue: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], step: [{
+                type: Input
+            }], inputLabel: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], inputChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timer-box.component.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-formentry/src/components/ngx-pick-datetime/lib/date-time/timer-box.component.ts","../../../../../../../projects/ngx-formentry/src/components/ngx-pick-datetime/lib/date-time/timer-box.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  HostBinding,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output\n} from '@angular/core';\nimport { coerceNumberProperty } from '@angular/cdk/coercion';\nimport { Subject, Subscription } from 'rxjs';\nimport { debounceTime, distinctUntilChanged } from 'rxjs/operators';\n\n@Component({\n  exportAs: 'owlDateTimeTimerBox',\n  selector: 'ofe-owl-date-time-timer-box',\n  templateUrl: './timer-box.component.html',\n  styleUrls: ['./timer-box.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class OwlTimerBoxComponent implements OnInit, OnDestroy {\n  @HostBinding('class.owl-dt-timer-box')\n  get owlDTTimerBoxClass() {\n    return true;\n  }\n\n  @Input() showDivider = false;\n\n  @Input() upBtnAriaLabel: string;\n\n  @Input() upBtnDisabled: boolean;\n\n  @Input() downBtnAriaLabel: string;\n\n  @Input() downBtnDisabled: boolean;\n\n  /**\n   * Value would be displayed in the box\n   * If it is null, the box would display [value]\n   * */\n  @Input() boxValue: number;\n\n  @Input() value: number;\n\n  @Input() min: number;\n\n  @Input() max: number;\n\n  @Input() step = 1;\n\n  @Input() inputLabel: string;\n\n  @Output() valueChange = new EventEmitter<number>();\n\n  @Output() inputChange = new EventEmitter<number>();\n\n  private inputStream = new Subject<string>();\n\n  private inputStreamSub = Subscription.EMPTY;\n\n  get displayValue(): number {\n    return this.boxValue || this.value;\n  }\n\n  constructor() {}\n\n  public ngOnInit() {\n    this.inputStreamSub = this.inputStream\n      .pipe(debounceTime(500), distinctUntilChanged())\n      .subscribe((val: string) => {\n        if (val) {\n          const inputValue = coerceNumberProperty(val, 0);\n          this.updateValueViaInput(inputValue);\n        }\n      });\n  }\n\n  public ngOnDestroy(): void {\n    this.inputStreamSub.unsubscribe();\n  }\n\n  public upBtnClicked(): void {\n    this.updateValue(this.value + this.step);\n  }\n\n  public downBtnClicked(): void {\n    this.updateValue(this.value - this.step);\n  }\n\n  public handleInputChange(val: string): void {\n    this.inputStream.next(val);\n  }\n\n  private updateValue(value: number): void {\n    this.valueChange.emit(value);\n  }\n\n  private updateValueViaInput(value: number): void {\n    if (value > this.max || value < this.min) {\n      return;\n    }\n    this.inputChange.emit(value);\n  }\n}\n","<div *ngIf=\"showDivider\" class=\"owl-dt-timer-divider\" aria-hidden=\"true\"></div>\n<button\n  class=\"owl-dt-control-button owl-dt-control-arrow-button\"\n  type=\"button\"\n  tabindex=\"-1\"\n  [disabled]=\"upBtnDisabled\"\n  [attr.aria-label]=\"upBtnAriaLabel\"\n  (click)=\"upBtnClicked()\"\n>\n  <span class=\"owl-dt-control-button-content\" tabindex=\"-1\">\n    <!-- <editor-fold desc=\"SVG Arrow Up\"> -->\n    <svg\n      xmlns=\"http://www.w3.org/2000/svg\"\n      xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n      version=\"1.1\"\n      x=\"0px\"\n      y=\"0px\"\n      viewBox=\"0 0 451.847 451.846\"\n      style=\"enable-background: new 0 0 451.847 451.846\"\n      xml:space=\"preserve\"\n      width=\"100%\"\n      height=\"100%\"\n    >\n      <path\n        d=\"M248.292,106.406l194.281,194.29c12.365,12.359,12.365,32.391,0,44.744c-12.354,12.354-32.391,12.354-44.744,0\n                        L225.923,173.529L54.018,345.44c-12.36,12.354-32.395,12.354-44.748,0c-12.359-12.354-12.359-32.391,0-44.75L203.554,106.4\n                        c6.18-6.174,14.271-9.259,22.369-9.259C234.018,97.141,242.115,100.232,248.292,106.406z\"\n      />\n    </svg>\n    <!-- </editor-fold> -->\n  </span>\n</button>\n<label class=\"owl-dt-timer-content\">\n  <input\n    class=\"owl-dt-timer-input\"\n    maxlength=\"2\"\n    [value]=\"displayValue | numberFixedLen: 2\"\n    (input)=\"handleInputChange(valueInput.value)\"\n    #valueInput\n  />\n  <span class=\"owl-hidden-accessible\">{{ inputLabel }}</span>\n</label>\n<button\n  class=\"owl-dt-control-button owl-dt-control-arrow-button\"\n  type=\"button\"\n  tabindex=\"-1\"\n  [disabled]=\"downBtnDisabled\"\n  [attr.aria-label]=\"downBtnAriaLabel\"\n  (click)=\"downBtnClicked()\"\n>\n  <span class=\"owl-dt-control-button-content\" tabindex=\"-1\">\n    <!-- <editor-fold desc=\"SVG Arrow Down\"> -->\n    <svg\n      xmlns=\"http://www.w3.org/2000/svg\"\n      xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n      version=\"1.1\"\n      x=\"0px\"\n      y=\"0px\"\n      viewBox=\"0 0 451.847 451.846\"\n      style=\"enable-background: new 0 0 451.847 451.846\"\n      xml:space=\"preserve\"\n      width=\"100%\"\n      height=\"100%\"\n    >\n      <path\n        d=\"M225.923,354.706c-8.098,0-16.195-3.092-22.369-9.263L9.27,151.157c-12.359-12.359-12.359-32.397,0-44.751\n                        c12.354-12.354,32.388-12.354,44.748,0l171.905,171.915l171.906-171.909c12.359-12.354,32.391-12.354,44.744,0\n                        c12.365,12.354,12.365,32.392,0,44.751L248.292,345.449C242.115,351.621,234.018,354.706,225.923,354.706z\"\n      />\n    </svg>\n    <!-- </editor-fold> -->\n  </span>\n</button>\n"]}