ngx-bootstrap 3.0.1 → 3.1.4

package/timepicker/esm2015/timepicker.component.js

@@ -0,0 +1,480 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, forwardRef, Input, Output, ViewEncapsulation } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { TimepickerActions } from './reducer/timepicker.actions';
+import { TimepickerStore } from './reducer/timepicker.store';
+import { getControlsValue } from './timepicker-controls.util';
+import { TimepickerConfig } from './timepicker.config';
+import { isValidDate, padNumber, parseTime, isInputValid, isHourInputValid, isMinuteInputValid, isSecondInputValid, isInputLimitValid } from './timepicker.utils';
+export const /** @type {?} */ TIMEPICKER_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(() => TimepickerComponent),
+    multi: true
+};
+export class TimepickerComponent {
+    /**
+     * @param {?} _config
+     * @param {?} _cd
+     * @param {?} _store
+     * @param {?} _timepickerActions
+     */
+    constructor(_config, _cd, _store, _timepickerActions) {
+        this._store = _store;
+        this._timepickerActions = _timepickerActions;
+        /**
+         * emits true if value is a valid date
+         */
+        this.isValid = new EventEmitter();
+        // min\max validation for input fields
+        this.invalidHours = false;
+        this.invalidMinutes = false;
+        this.invalidSeconds = false;
+        // control value accessor methods
+        // tslint:disable-next-line:no-any
+        this.onChange = Function.prototype;
+        // tslint:disable-next-line:no-any
+        this.onTouched = Function.prototype;
+        Object.assign(this, _config);
+        this.timepickerSub = _store
+            .select(state => state.value)
+            .subscribe((value) => {
+            // update UI values if date changed
+            this._renderTime(value);
+            this.onChange(value);
+            this._store.dispatch(this._timepickerActions.updateControls(getControlsValue(this)));
+        });
+        _store
+            .select(state => state.controls)
+            .subscribe((controlsState) => {
+            this.isValid.emit(isInputValid(this.hours, this.minutes, this.seconds, this.isPM()));
+            Object.assign(this, controlsState);
+            _cd.markForCheck();
+        });
+    }
+    /**
+     * @deprecated - please use `isEditable` instead
+     * @return {?}
+     */
+    get isSpinnersVisible() {
+        return this.showSpinners && !this.readonlyInput;
+    }
+    /**
+     * @return {?}
+     */
+    get isEditable() {
+        return !(this.readonlyInput || this.disabled);
+    }
+    /**
+     * @return {?}
+     */
+    resetValidation() {
+        this.invalidHours = false;
+        this.invalidMinutes = false;
+        this.invalidSeconds = false;
+    }
+    /**
+     * @return {?}
+     */
+    isPM() {
+        return this.showMeridian && this.meridian === this.meridians[1];
+    }
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    prevDef($event) {
+        $event.preventDefault();
+    }
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    wheelSign($event) {
+        return Math.sign($event.deltaY) * -1;
+    }
+    /**
+     * @param {?} changes
+     * @return {?}
+     */
+    ngOnChanges(changes) {
+        this._store.dispatch(this._timepickerActions.updateControls(getControlsValue(this)));
+    }
+    /**
+     * @param {?} step
+     * @param {?=} source
+     * @return {?}
+     */
+    changeHours(step, source = '') {
+        this.resetValidation();
+        this._store.dispatch(this._timepickerActions.changeHours({ step, source }));
+    }
+    /**
+     * @param {?} step
+     * @param {?=} source
+     * @return {?}
+     */
+    changeMinutes(step, source = '') {
+        this.resetValidation();
+        this._store.dispatch(this._timepickerActions.changeMinutes({ step, source }));
+    }
+    /**
+     * @param {?} step
+     * @param {?=} source
+     * @return {?}
+     */
+    changeSeconds(step, source = '') {
+        this.resetValidation();
+        this._store.dispatch(this._timepickerActions.changeSeconds({ step, source }));
+    }
+    /**
+     * @param {?} hours
+     * @return {?}
+     */
+    updateHours(hours) {
+        this.resetValidation();
+        this.hours = hours;
+        const /** @type {?} */ isValid = isHourInputValid(this.hours, this.isPM()) && this.isValidLimit();
+        if (!isValid) {
+            this.invalidHours = true;
+            this.isValid.emit(false);
+            this.onChange(null);
+            return;
+        }
+        this._updateTime();
+    }
+    /**
+     * @param {?} minutes
+     * @return {?}
+     */
+    updateMinutes(minutes) {
+        this.resetValidation();
+        this.minutes = minutes;
+        const /** @type {?} */ isValid = isMinuteInputValid(this.minutes) && this.isValidLimit();
+        if (!isValid) {
+            this.invalidMinutes = true;
+            this.isValid.emit(false);
+            this.onChange(null);
+            return;
+        }
+        this._updateTime();
+    }
+    /**
+     * @param {?} seconds
+     * @return {?}
+     */
+    updateSeconds(seconds) {
+        this.resetValidation();
+        this.seconds = seconds;
+        const /** @type {?} */ isValid = isSecondInputValid(this.seconds) && this.isValidLimit();
+        if (!isValid) {
+            this.invalidSeconds = true;
+            this.isValid.emit(false);
+            this.onChange(null);
+            return;
+        }
+        this._updateTime();
+    }
+    /**
+     * @return {?}
+     */
+    isValidLimit() {
+        return isInputLimitValid({
+            hour: this.hours,
+            minute: this.minutes,
+            seconds: this.seconds,
+            isPM: this.isPM()
+        }, this.max, this.min);
+    }
+    /**
+     * @return {?}
+     */
+    _updateTime() {
+        const /** @type {?} */ _seconds = this.showSeconds ? this.seconds : void 0;
+        const /** @type {?} */ _minutes = this.showMinutes ? this.minutes : void 0;
+        if (!isInputValid(this.hours, _minutes, _seconds, this.isPM())) {
+            this.isValid.emit(false);
+            this.onChange(null);
+            return;
+        }
+        this._store.dispatch(this._timepickerActions.setTime({
+            hour: this.hours,
+            minute: this.minutes,
+            seconds: this.seconds,
+            isPM: this.isPM()
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    toggleMeridian() {
+        if (!this.showMeridian || !this.isEditable) {
+            return;
+        }
+        const /** @type {?} */ _hoursPerDayHalf = 12;
+        this._store.dispatch(this._timepickerActions.changeHours({
+            step: _hoursPerDayHalf,
+            source: ''
+        }));
+    }
+    /**
+     * Write a new value to the element.
+     * @param {?} obj
+     * @return {?}
+     */
+    writeValue(obj) {
+        if (isValidDate(obj)) {
+            this._store.dispatch(this._timepickerActions.writeValue(parseTime(obj)));
+        }
+        else if (obj == null) {
+            this._store.dispatch(this._timepickerActions.writeValue(null));
+        }
+    }
+    /**
+     * Set the function to be called when the control receives a change event.
+     * @param {?} fn
+     * @return {?}
+     */
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    /**
+     * Set the function to be called when the control receives a touch event.
+     * @param {?} fn
+     * @return {?}
+     */
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * This function is called when the control status changes to or from "disabled".
+     * Depending on the value, it will enable or disable the appropriate DOM element.
+     *
+     * @param {?} isDisabled
+     * @return {?}
+     */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.timepickerSub.unsubscribe();
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    _renderTime(value) {
+        if (!isValidDate(value)) {
+            this.hours = '';
+            this.minutes = '';
+            this.seconds = '';
+            this.meridian = this.meridians[0];
+            return;
+        }
+        const /** @type {?} */ _value = parseTime(value);
+        const /** @type {?} */ _hoursPerDayHalf = 12;
+        let /** @type {?} */ _hours = _value.getHours();
+        if (this.showMeridian) {
+            this.meridian = this.meridians[_hours >= _hoursPerDayHalf ? 1 : 0];
+            _hours = _hours % _hoursPerDayHalf;
+            // should be 12 PM, not 00 PM
+            if (_hours === 0) {
+                _hours = _hoursPerDayHalf;
+            }
+        }
+        this.hours = padNumber(_hours);
+        this.minutes = padNumber(_value.getMinutes());
+        this.seconds = padNumber(_value.getUTCSeconds());
+    }
+}
+TimepickerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'timepicker',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                providers: [TIMEPICKER_CONTROL_VALUE_ACCESSOR, TimepickerStore],
+                template: "<table>\n  <tbody>\n  <tr class=\"text-center\" [hidden]=\"!showSpinners\">\n    <!-- increment hours button-->\n    <td>\n      <a class=\"btn btn-link\" [class.disabled]=\"!canIncrementHours || !isEditable\"\n         (click)=\"changeHours(hourStep)\"\n      ><span class=\"bs-chevron bs-chevron-up\"></span></a>\n    </td>\n    <!-- divider -->\n    <td *ngIf=\"showMinutes\">&nbsp;&nbsp;&nbsp;</td>\n    <!-- increment minutes button -->\n    <td *ngIf=\"showMinutes\">\n      <a class=\"btn btn-link\" [class.disabled]=\"!canIncrementMinutes || !isEditable\"\n         (click)=\"changeMinutes(minuteStep)\"\n      ><span class=\"bs-chevron bs-chevron-up\"></span></a>\n    </td>\n    <!-- divider -->\n    <td *ngIf=\"showSeconds\">&nbsp;</td>\n    <!-- increment seconds button -->\n    <td *ngIf=\"showSeconds\">\n      <a class=\"btn btn-link\" [class.disabled]=\"!canIncrementSeconds || !isEditable\"\n         (click)=\"changeSeconds(secondsStep)\">\n        <span class=\"bs-chevron bs-chevron-up\"></span>\n      </a>\n    </td>\n    <!-- space between -->\n    <td *ngIf=\"showMeridian\">&nbsp;&nbsp;&nbsp;</td>\n    <!-- meridian placeholder-->\n    <td *ngIf=\"showMeridian\"></td>\n  </tr>\n  <tr>\n    <!-- hours -->\n    <td class=\"form-group\" [class.has-error]=\"invalidHours\">\n      <input type=\"text\" [class.is-invalid]=\"invalidHours\"\n             class=\"form-control text-center bs-timepicker-field\"\n             placeholder=\"HH\"\n             maxlength=\"2\"\n             [readonly]=\"readonlyInput\"\n             [disabled]=\"disabled\"\n             [value]=\"hours\"\n             (wheel)=\"prevDef($event);changeHours(hourStep * wheelSign($event), 'wheel')\"\n             (keydown.ArrowUp)=\"changeHours(hourStep, 'key')\"\n             (keydown.ArrowDown)=\"changeHours(-hourStep, 'key')\"\n             (change)=\"updateHours($event.target.value)\"></td>\n    <!-- divider -->\n    <td *ngIf=\"showMinutes\">&nbsp;:&nbsp;</td>\n    <!-- minutes -->\n    <td class=\"form-group\" *ngIf=\"showMinutes\" [class.has-error]=\"invalidMinutes\">\n      <input type=\"text\" [class.is-invalid]=\"invalidMinutes\"\n             class=\"form-control text-center bs-timepicker-field\"\n             placeholder=\"MM\"\n             maxlength=\"2\"\n             [readonly]=\"readonlyInput\"\n             [disabled]=\"disabled\"\n             [value]=\"minutes\"\n             (wheel)=\"prevDef($event);changeMinutes(minuteStep * wheelSign($event), 'wheel')\"\n             (keydown.ArrowUp)=\"changeMinutes(minuteStep, 'key')\"\n             (keydown.ArrowDown)=\"changeMinutes(-minuteStep, 'key')\"\n             (change)=\"updateMinutes($event.target.value)\">\n    </td>\n    <!-- divider -->\n    <td *ngIf=\"showSeconds\">&nbsp;:&nbsp;</td>\n    <!-- seconds -->\n    <td class=\"form-group\" *ngIf=\"showSeconds\" [class.has-error]=\"invalidSeconds\">\n      <input type=\"text\" [class.is-invalid]=\"invalidSeconds\"\n             class=\"form-control text-center bs-timepicker-field\"\n             placeholder=\"SS\"\n             maxlength=\"2\"\n             [readonly]=\"readonlyInput\"\n             [disabled]=\"disabled\"\n             [value]=\"seconds\"\n             (wheel)=\"prevDef($event);changeSeconds(secondsStep * wheelSign($event), 'wheel')\"\n             (keydown.ArrowUp)=\"changeSeconds(secondsStep, 'key')\"\n             (keydown.ArrowDown)=\"changeSeconds(-secondsStep, 'key')\"\n             (change)=\"updateSeconds($event.target.value)\">\n    </td>\n    <!-- space between -->\n    <td *ngIf=\"showMeridian\">&nbsp;&nbsp;&nbsp;</td>\n    <!-- meridian -->\n    <td *ngIf=\"showMeridian\">\n      <button type=\"button\" class=\"btn btn-default text-center\"\n              [disabled]=\"!isEditable || !canToggleMeridian\"\n              [class.disabled]=\"!isEditable || !canToggleMeridian\"\n              (click)=\"toggleMeridian()\"\n      >{{ meridian }}\n      </button>\n    </td>\n  </tr>\n  <tr class=\"text-center\" [hidden]=\"!showSpinners\">\n    <!-- decrement hours button-->\n    <td>\n      <a class=\"btn btn-link\" [class.disabled]=\"!canDecrementHours || !isEditable\"\n         (click)=\"changeHours(-hourStep)\">\n        <span class=\"bs-chevron bs-chevron-down\"></span>\n      </a>\n    </td>\n    <!-- divider -->\n    <td *ngIf=\"showMinutes\">&nbsp;&nbsp;&nbsp;</td>\n    <!-- decrement minutes button-->\n    <td *ngIf=\"showMinutes\">\n      <a class=\"btn btn-link\" [class.disabled]=\"!canDecrementMinutes || !isEditable\"\n         (click)=\"changeMinutes(-minuteStep)\">\n        <span class=\"bs-chevron bs-chevron-down\"></span>\n      </a>\n    </td>\n    <!-- divider -->\n    <td *ngIf=\"showSeconds\">&nbsp;</td>\n    <!-- decrement seconds button-->\n    <td *ngIf=\"showSeconds\">\n      <a class=\"btn btn-link\" [class.disabled]=\"!canDecrementSeconds || !isEditable\"\n         (click)=\"changeSeconds(-secondsStep)\">\n        <span class=\"bs-chevron bs-chevron-down\"></span>\n      </a>\n    </td>\n    <!-- space between -->\n    <td *ngIf=\"showMeridian\">&nbsp;&nbsp;&nbsp;</td>\n    <!-- meridian placeholder-->\n    <td *ngIf=\"showMeridian\"></td>\n  </tr>\n  </tbody>\n</table>\n",
+                encapsulation: ViewEncapsulation.None,
+                styles: [`
+    .bs-chevron {
+      border-style: solid;
+      display: block;
+      width: 9px;
+      height: 9px;
+      position: relative;
+      border-width: 3px 0px 0 3px;
+    }
+
+    .bs-chevron-up {
+      -webkit-transform: rotate(45deg);
+      transform: rotate(45deg);
+      top: 2px;
+    }
+
+    .bs-chevron-down {
+      -webkit-transform: rotate(-135deg);
+      transform: rotate(-135deg);
+      top: -2px;
+    }
+
+    .bs-timepicker-field {
+      width: 50px;
+    }
+  `]
+            }] }
+];
+/** @nocollapse */
+TimepickerComponent.ctorParameters = () => [
+    { type: TimepickerConfig, },
+    { type: ChangeDetectorRef, },
+    { type: TimepickerStore, },
+    { type: TimepickerActions, },
+];
+TimepickerComponent.propDecorators = {
+    "hourStep": [{ type: Input },],
+    "minuteStep": [{ type: Input },],
+    "secondsStep": [{ type: Input },],
+    "readonlyInput": [{ type: Input },],
+    "disabled": [{ type: Input },],
+    "mousewheel": [{ type: Input },],
+    "arrowkeys": [{ type: Input },],
+    "showSpinners": [{ type: Input },],
+    "showMeridian": [{ type: Input },],
+    "showMinutes": [{ type: Input },],
+    "showSeconds": [{ type: Input },],
+    "meridians": [{ type: Input },],
+    "min": [{ type: Input },],
+    "max": [{ type: Input },],
+    "isValid": [{ type: Output },],
+};
+function TimepickerComponent_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    TimepickerComponent.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    TimepickerComponent.ctorParameters;
+    /** @type {!Object<string,!Array<{type: !Function, args: (undefined|!Array<?>)}>>} */
+    TimepickerComponent.propDecorators;
+    /**
+     * hours change step
+     * @type {?}
+     */
+    TimepickerComponent.prototype.hourStep;
+    /**
+     * hours change step
+     * @type {?}
+     */
+    TimepickerComponent.prototype.minuteStep;
+    /**
+     * seconds change step
+     * @type {?}
+     */
+    TimepickerComponent.prototype.secondsStep;
+    /**
+     * if true hours and minutes fields will be readonly
+     * @type {?}
+     */
+    TimepickerComponent.prototype.readonlyInput;
+    /**
+     * if true hours and minutes fields will be disabled
+     * @type {?}
+     */
+    TimepickerComponent.prototype.disabled;
+    /**
+     * if true scroll inside hours and minutes inputs will change time
+     * @type {?}
+     */
+    TimepickerComponent.prototype.mousewheel;
+    /**
+     * if true the values of hours and minutes can be changed using the up/down arrow keys on the keyboard
+     * @type {?}
+     */
+    TimepickerComponent.prototype.arrowkeys;
+    /**
+     * if true spinner arrows above and below the inputs will be shown
+     * @type {?}
+     */
+    TimepickerComponent.prototype.showSpinners;
+    /**
+     * if true meridian button will be shown
+     * @type {?}
+     */
+    TimepickerComponent.prototype.showMeridian;
+    /**
+     * show minutes in timepicker
+     * @type {?}
+     */
+    TimepickerComponent.prototype.showMinutes;
+    /**
+     * show seconds in timepicker
+     * @type {?}
+     */
+    TimepickerComponent.prototype.showSeconds;
+    /**
+     * meridian labels based on locale
+     * @type {?}
+     */
+    TimepickerComponent.prototype.meridians;
+    /**
+     * minimum time user can select
+     * @type {?}
+     */
+    TimepickerComponent.prototype.min;
+    /**
+     * maximum time user can select
+     * @type {?}
+     */
+    TimepickerComponent.prototype.max;
+    /**
+     * emits true if value is a valid date
+     * @type {?}
+     */
+    TimepickerComponent.prototype.isValid;
+    /** @type {?} */
+    TimepickerComponent.prototype.hours;
+    /** @type {?} */
+    TimepickerComponent.prototype.minutes;
+    /** @type {?} */
+    TimepickerComponent.prototype.seconds;
+    /** @type {?} */
+    TimepickerComponent.prototype.meridian;
+    /** @type {?} */
+    TimepickerComponent.prototype.invalidHours;
+    /** @type {?} */
+    TimepickerComponent.prototype.invalidMinutes;
+    /** @type {?} */
+    TimepickerComponent.prototype.invalidSeconds;
+    /** @type {?} */
+    TimepickerComponent.prototype.canIncrementHours;
+    /** @type {?} */
+    TimepickerComponent.prototype.canIncrementMinutes;
+    /** @type {?} */
+    TimepickerComponent.prototype.canIncrementSeconds;
+    /** @type {?} */
+    TimepickerComponent.prototype.canDecrementHours;
+    /** @type {?} */
+    TimepickerComponent.prototype.canDecrementMinutes;
+    /** @type {?} */
+    TimepickerComponent.prototype.canDecrementSeconds;
+    /** @type {?} */
+    TimepickerComponent.prototype.canToggleMeridian;
+    /** @type {?} */
+    TimepickerComponent.prototype.onChange;
+    /** @type {?} */
+    TimepickerComponent.prototype.onTouched;
+    /** @type {?} */
+    TimepickerComponent.prototype.timepickerSub;
+    /** @type {?} */
+    TimepickerComponent.prototype._store;
+    /** @type {?} */
+    TimepickerComponent.prototype._timepickerActions;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timepicker.component.js","sourceRoot":"ng://ngx-bootstrap/timepicker/","sources":["timepicker.component.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable:no-forward-ref max-file-line-count */\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  forwardRef,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges, ViewEncapsulation\n} from '@angular/core';\n\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport { TimepickerActions } from './reducer/timepicker.actions';\nimport { TimepickerStore } from './reducer/timepicker.store';\nimport { getControlsValue } from './timepicker-controls.util';\nimport { TimepickerConfig } from './timepicker.config';\n\nimport {\n  TimeChangeSource,\n  TimepickerComponentState,\n  TimepickerControls\n} from './timepicker.models';\n\nimport {\n  isValidDate,\n  padNumber,\n  parseTime,\n  isInputValid,\n  isHourInputValid,\n  isMinuteInputValid,\n  isSecondInputValid,\n  isInputLimitValid\n} from './timepicker.utils';\n\nimport { Subscription } from 'rxjs';\n\nimport { ControlValueAccessorModel } from './models';\n\nexport const TIMEPICKER_CONTROL_VALUE_ACCESSOR: ControlValueAccessorModel = {\n  provide: NG_VALUE_ACCESSOR,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => TimepickerComponent),\n  multi: true\n};\n\n@Component({\n  selector: 'timepicker',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [TIMEPICKER_CONTROL_VALUE_ACCESSOR, TimepickerStore],\n  templateUrl: './timepicker.component.html',\n  styles: [`\n    .bs-chevron {\n      border-style: solid;\n      display: block;\n      width: 9px;\n      height: 9px;\n      position: relative;\n      border-width: 3px 0px 0 3px;\n    }\n\n    .bs-chevron-up {\n      -webkit-transform: rotate(45deg);\n      transform: rotate(45deg);\n      top: 2px;\n    }\n\n    .bs-chevron-down {\n      -webkit-transform: rotate(-135deg);\n      transform: rotate(-135deg);\n      top: -2px;\n    }\n\n    .bs-timepicker-field {\n      width: 50px;\n    }\n  `],\n  encapsulation: ViewEncapsulation.None\n})\nexport class TimepickerComponent\n  implements ControlValueAccessor,\n    TimepickerComponentState,\n    TimepickerControls,\n    OnChanges,\n    OnDestroy {\n  /** hours change step */\n  @Input() hourStep: number;\n  /** hours change step */\n  @Input() minuteStep: number;\n  /** seconds change step */\n  @Input() secondsStep: number;\n  /** if true hours and minutes fields will be readonly */\n  @Input() readonlyInput: boolean;\n  /** if true hours and minutes fields will be disabled */\n  @Input() disabled: boolean;\n  /** if true scroll inside hours and minutes inputs will change time */\n  @Input() mousewheel: boolean;\n  /** if true the values of hours and minutes can be changed using the up/down arrow keys on the keyboard */\n  @Input() arrowkeys: boolean;\n  /** if true spinner arrows above and below the inputs will be shown */\n  @Input() showSpinners: boolean;\n  /** if true meridian button will be shown */\n  @Input() showMeridian: boolean;\n  /** show minutes in timepicker */\n  @Input() showMinutes: boolean;\n  /** show seconds in timepicker */\n  @Input() showSeconds: boolean;\n  /** meridian labels based on locale */\n  @Input() meridians: string[];\n  /** minimum time user can select */\n  @Input() min: Date;\n  /** maximum time user can select */\n  @Input() max: Date;\n\n  /** emits true if value is a valid date */\n  @Output() isValid = new EventEmitter<boolean>();\n\n  // ui variables\n  hours: string;\n  minutes: string;\n  seconds: string;\n  meridian: string;\n\n  /** @deprecated - please use `isEditable` instead */\n  get isSpinnersVisible(): boolean {\n    return this.showSpinners && !this.readonlyInput;\n  }\n\n  get isEditable(): boolean {\n    return !(this.readonlyInput || this.disabled);\n  }\n\n  // min\\max validation for input fields\n  invalidHours = false;\n  invalidMinutes = false;\n  invalidSeconds = false;\n\n  // time picker controls state\n  canIncrementHours: boolean;\n  canIncrementMinutes: boolean;\n  canIncrementSeconds: boolean;\n\n  canDecrementHours: boolean;\n  canDecrementMinutes: boolean;\n  canDecrementSeconds: boolean;\n\n  canToggleMeridian: boolean;\n\n  // control value accessor methods\n  // tslint:disable-next-line:no-any\n  onChange = Function.prototype;\n  // tslint:disable-next-line:no-any\n  onTouched = Function.prototype;\n\n  timepickerSub: Subscription;\n\n  constructor(\n    _config: TimepickerConfig,\n    _cd: ChangeDetectorRef,\n    private _store: TimepickerStore,\n    private _timepickerActions: TimepickerActions\n  ) {\n    Object.assign(this, _config);\n\n    this.timepickerSub = _store\n      .select(state => state.value)\n      .subscribe((value: Date) => {\n        // update UI values if date changed\n        this._renderTime(value);\n        this.onChange(value);\n\n        this._store.dispatch(\n          this._timepickerActions.updateControls(getControlsValue(this))\n        );\n      });\n\n    _store\n      .select(state => state.controls)\n      .subscribe((controlsState: TimepickerControls) => {\n        this.isValid.emit(isInputValid(this.hours, this.minutes, this.seconds, this.isPM()));\n        Object.assign(this, controlsState);\n        _cd.markForCheck();\n      });\n  }\n\n  resetValidation(): void {\n    this.invalidHours = false;\n    this.invalidMinutes = false;\n    this.invalidSeconds = false;\n  }\n\n  isPM(): boolean {\n    return this.showMeridian && this.meridian === this.meridians[1];\n  }\n\n  prevDef($event: Event) {\n    $event.preventDefault();\n  }\n\n  wheelSign($event: WheelEventInit): number {\n    return Math.sign($event.deltaY) * -1;\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    this._store.dispatch(\n      this._timepickerActions.updateControls(getControlsValue(this))\n    );\n  }\n\n  changeHours(step: number, source: TimeChangeSource = ''): void {\n    this.resetValidation();\n    this._store.dispatch(this._timepickerActions.changeHours({ step, source }));\n  }\n\n  changeMinutes(step: number, source: TimeChangeSource = ''): void {\n    this.resetValidation();\n    this._store.dispatch(\n      this._timepickerActions.changeMinutes({ step, source })\n    );\n  }\n\n  changeSeconds(step: number, source: TimeChangeSource = ''): void {\n    this.resetValidation();\n    this._store.dispatch(\n      this._timepickerActions.changeSeconds({ step, source })\n    );\n  }\n\n  updateHours(hours: string): void {\n    this.resetValidation();\n    this.hours = hours;\n\n    const isValid = isHourInputValid(this.hours, this.isPM()) && this.isValidLimit();\n\n    if (!isValid) {\n      this.invalidHours = true;\n      this.isValid.emit(false);\n      this.onChange(null);\n\n      return;\n    }\n\n    this._updateTime();\n  }\n\n  updateMinutes(minutes: string) {\n    this.resetValidation();\n    this.minutes = minutes;\n\n    const isValid = isMinuteInputValid(this.minutes) && this.isValidLimit();\n\n    if (!isValid) {\n      this.invalidMinutes = true;\n      this.isValid.emit(false);\n      this.onChange(null);\n\n      return;\n    }\n\n    this._updateTime();\n  }\n\n  updateSeconds(seconds: string) {\n    this.resetValidation();\n    this.seconds = seconds;\n\n    const isValid = isSecondInputValid(this.seconds) && this.isValidLimit();\n\n    if (!isValid) {\n      this.invalidSeconds = true;\n      this.isValid.emit(false);\n      this.onChange(null);\n\n      return;\n    }\n\n    this._updateTime();\n  }\n\n  isValidLimit(): boolean {\n    return isInputLimitValid({\n      hour: this.hours,\n      minute: this.minutes,\n      seconds: this.seconds,\n      isPM: this.isPM()\n    }, this.max, this.min);\n  }\n\n  _updateTime() {\n    const _seconds = this.showSeconds ? this.seconds : void 0;\n    const _minutes = this.showMinutes ? this.minutes : void 0;\n    if (!isInputValid(this.hours, _minutes, _seconds, this.isPM())) {\n      this.isValid.emit(false);\n      this.onChange(null);\n\n      return;\n    }\n\n    this._store.dispatch(\n      this._timepickerActions.setTime({\n        hour: this.hours,\n        minute: this.minutes,\n        seconds: this.seconds,\n        isPM: this.isPM()\n      })\n    );\n  }\n\n  toggleMeridian(): void {\n    if (!this.showMeridian || !this.isEditable) {\n      return;\n    }\n\n    const _hoursPerDayHalf = 12;\n    this._store.dispatch(\n      this._timepickerActions.changeHours({\n        step: _hoursPerDayHalf,\n        source: ''\n      })\n    );\n  }\n\n  /**\n   * Write a new value to the element.\n   */\n  writeValue(obj: string | null | undefined | Date): void {\n    if (isValidDate(obj)) {\n      this._store.dispatch(this._timepickerActions.writeValue(parseTime(obj)));\n    } else if (obj == null) {\n      this._store.dispatch(this._timepickerActions.writeValue(null));\n    }\n  }\n\n  /**\n   * Set the function to be called when the control receives a change event.\n   */\n  // tslint:disable-next-line:no-any\n  registerOnChange(fn: (_: any) => {}): void {\n    this.onChange = fn;\n  }\n\n  /**\n   * Set the function to be called when the control receives a touch event.\n   */\n  registerOnTouched(fn: () => {}): void {\n    this.onTouched = fn;\n  }\n\n  /**\n   * This function is called when the control status changes to or from \"disabled\".\n   * Depending on the value, it will enable or disable the appropriate DOM element.\n   *\n   * @param isDisabled\n   */\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  ngOnDestroy(): void {\n    this.timepickerSub.unsubscribe();\n  }\n\n  private _renderTime(value: string | Date): void {\n    if (!isValidDate(value)) {\n      this.hours = '';\n      this.minutes = '';\n      this.seconds = '';\n      this.meridian = this.meridians[0];\n\n      return;\n    }\n\n    const _value = parseTime(value);\n    const _hoursPerDayHalf = 12;\n    let _hours = _value.getHours();\n\n    if (this.showMeridian) {\n      this.meridian = this.meridians[_hours >= _hoursPerDayHalf ? 1 : 0];\n      _hours = _hours % _hoursPerDayHalf;\n      // should be 12 PM, not 00 PM\n      if (_hours === 0) {\n        _hours = _hoursPerDayHalf;\n      }\n    }\n\n    this.hours = padNumber(_hours);\n    this.minutes = padNumber(_value.getMinutes());\n    this.seconds = padNumber(_value.getUTCSeconds());\n  }\n}\n"]}

package/timepicker/esm2015/timepicker.config.js

@@ -0,0 +1,144 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Injectable } from '@angular/core';
+/**
+ * Provides default configuration values for timepicker
+ */
+export class TimepickerConfig {
+    constructor() {
+        /**
+         * hours change step
+         */
+        this.hourStep = 1;
+        /**
+         * hours change step
+         */
+        this.minuteStep = 5;
+        /**
+         * seconds changes step
+         */
+        this.secondsStep = 10;
+        /**
+         * if true works in 12H mode and displays AM/PM. If false works in 24H mode and hides AM/PM
+         */
+        this.showMeridian = true;
+        /**
+         * meridian labels based on locale
+         */
+        this.meridians = ['AM', 'PM'];
+        /**
+         * if true hours and minutes fields will be readonly
+         */
+        this.readonlyInput = false;
+        /**
+         * if true hours and minutes fields will be disabled
+         */
+        this.disabled = false;
+        /**
+         * if true scroll inside hours and minutes inputs will change time
+         */
+        this.mousewheel = true;
+        /**
+         * if true the values of hours and minutes can be changed using the up/down arrow keys on the keyboard
+         */
+        this.arrowkeys = true;
+        /**
+         * if true spinner arrows above and below the inputs will be shown
+         */
+        this.showSpinners = true;
+        /**
+         * show seconds in timepicker
+         */
+        this.showSeconds = false;
+        /**
+         * show minutes in timepicker
+         */
+        this.showMinutes = true;
+    }
+}
+TimepickerConfig.decorators = [
+    { type: Injectable }
+];
+function TimepickerConfig_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    TimepickerConfig.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    TimepickerConfig.ctorParameters;
+    /**
+     * hours change step
+     * @type {?}
+     */
+    TimepickerConfig.prototype.hourStep;
+    /**
+     * hours change step
+     * @type {?}
+     */
+    TimepickerConfig.prototype.minuteStep;
+    /**
+     * seconds changes step
+     * @type {?}
+     */
+    TimepickerConfig.prototype.secondsStep;
+    /**
+     * if true works in 12H mode and displays AM/PM. If false works in 24H mode and hides AM/PM
+     * @type {?}
+     */
+    TimepickerConfig.prototype.showMeridian;
+    /**
+     * meridian labels based on locale
+     * @type {?}
+     */
+    TimepickerConfig.prototype.meridians;
+    /**
+     * if true hours and minutes fields will be readonly
+     * @type {?}
+     */
+    TimepickerConfig.prototype.readonlyInput;
+    /**
+     * if true hours and minutes fields will be disabled
+     * @type {?}
+     */
+    TimepickerConfig.prototype.disabled;
+    /**
+     * if true scroll inside hours and minutes inputs will change time
+     * @type {?}
+     */
+    TimepickerConfig.prototype.mousewheel;
+    /**
+     * if true the values of hours and minutes can be changed using the up/down arrow keys on the keyboard
+     * @type {?}
+     */
+    TimepickerConfig.prototype.arrowkeys;
+    /**
+     * if true spinner arrows above and below the inputs will be shown
+     * @type {?}
+     */
+    TimepickerConfig.prototype.showSpinners;
+    /**
+     * show seconds in timepicker
+     * @type {?}
+     */
+    TimepickerConfig.prototype.showSeconds;
+    /**
+     * show minutes in timepicker
+     * @type {?}
+     */
+    TimepickerConfig.prototype.showMinutes;
+    /**
+     * minimum time user can select
+     * @type {?}
+     */
+    TimepickerConfig.prototype.min;
+    /**
+     * maximum time user can select
+     * @type {?}
+     */
+    TimepickerConfig.prototype.max;
+}
+
+//# sourceMappingURL=data:application/json;base64,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