ngx-bootstrap 3.0.1 → 3.1.4

package/timepicker/fesm5/ngx-bootstrap-timepicker.js

@@ -0,0 +1,1132 @@
+import { Injectable, ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, forwardRef, Input, Output, ViewEncapsulation, NgModule } from '@angular/core';
+import { __extends } from 'tslib';
+import { BehaviorSubject } from 'rxjs';
+import { MiniStore, MiniState } from 'ngx-bootstrap/mini-ngrx';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var TimepickerActions = /** @class */ (function () {
+    function TimepickerActions() {
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    TimepickerActions.prototype.writeValue = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        return {
+            type: TimepickerActions.WRITE_VALUE,
+            payload: value
+        };
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    TimepickerActions.prototype.changeHours = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        return {
+            type: TimepickerActions.CHANGE_HOURS,
+            payload: event
+        };
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    TimepickerActions.prototype.changeMinutes = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        return {
+            type: TimepickerActions.CHANGE_MINUTES,
+            payload: event
+        };
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    TimepickerActions.prototype.changeSeconds = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        return {
+            type: TimepickerActions.CHANGE_SECONDS,
+            payload: event
+        };
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    TimepickerActions.prototype.setTime = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        return {
+            type: TimepickerActions.SET_TIME_UNIT,
+            payload: value
+        };
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    TimepickerActions.prototype.updateControls = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        return {
+            type: TimepickerActions.UPDATE_CONTROLS,
+            payload: value
+        };
+    };
+    TimepickerActions.WRITE_VALUE = '[timepicker] write value from ng model';
+    TimepickerActions.CHANGE_HOURS = '[timepicker] change hours';
+    TimepickerActions.CHANGE_MINUTES = '[timepicker] change minutes';
+    TimepickerActions.CHANGE_SECONDS = '[timepicker] change seconds';
+    TimepickerActions.SET_TIME_UNIT = '[timepicker] set time unit';
+    TimepickerActions.UPDATE_CONTROLS = '[timepicker] update controls';
+    TimepickerActions.decorators = [
+        { type: Injectable }
+    ];
+    return TimepickerActions;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var /** @type {?} */ dex = 10;
+var /** @type {?} */ hoursPerDay = 24;
+var /** @type {?} */ hoursPerDayHalf = 12;
+var /** @type {?} */ minutesPerHour = 60;
+var /** @type {?} */ secondsPerMinute = 60;
+/**
+ * @param {?=} value
+ * @return {?}
+ */
+function isValidDate(value) {
+    if (!value) {
+        return false;
+    }
+    if (value instanceof Date && isNaN(value.getHours())) {
+        return false;
+    }
+    if (typeof value === 'string') {
+        return isValidDate(new Date(value));
+    }
+    return true;
+}
+/**
+ * @param {?} controls
+ * @param {?} newDate
+ * @return {?}
+ */
+function isValidLimit(controls, newDate) {
+    if (controls.min && newDate < controls.min) {
+        return false;
+    }
+    if (controls.max && newDate > controls.max) {
+        return false;
+    }
+    return true;
+}
+/**
+ * @param {?} value
+ * @return {?}
+ */
+function toNumber(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    return parseInt(value, dex);
+}
+/**
+ * @param {?} value
+ * @param {?=} isPM
+ * @return {?}
+ */
+function parseHours(value, isPM) {
+    if (isPM === void 0) { isPM = false; }
+    var /** @type {?} */ hour = toNumber(value);
+    if (isNaN(hour) ||
+        hour < 0 ||
+        hour > (isPM ? hoursPerDayHalf : hoursPerDay)) {
+        return NaN;
+    }
+    return hour;
+}
+/**
+ * @param {?} value
+ * @return {?}
+ */
+function parseMinutes(value) {
+    var /** @type {?} */ minute = toNumber(value);
+    if (isNaN(minute) || minute < 0 || minute > minutesPerHour) {
+        return NaN;
+    }
+    return minute;
+}
+/**
+ * @param {?} value
+ * @return {?}
+ */
+function parseSeconds(value) {
+    var /** @type {?} */ seconds = toNumber(value);
+    if (isNaN(seconds) || seconds < 0 || seconds > secondsPerMinute) {
+        return NaN;
+    }
+    return seconds;
+}
+/**
+ * @param {?} value
+ * @return {?}
+ */
+function parseTime(value) {
+    if (typeof value === 'string') {
+        return new Date(value);
+    }
+    return value;
+}
+/**
+ * @param {?} value
+ * @param {?} diff
+ * @return {?}
+ */
+function changeTime(value, diff) {
+    if (!value) {
+        return changeTime(createDate(new Date(), 0, 0, 0), diff);
+    }
+    var /** @type {?} */ hour = value.getHours();
+    var /** @type {?} */ minutes = value.getMinutes();
+    var /** @type {?} */ seconds = value.getSeconds();
+    if (diff.hour) {
+        hour = (hour + toNumber(diff.hour)) % hoursPerDay;
+        if (hour < 0) {
+            hour += hoursPerDay;
+        }
+    }
+    if (diff.minute) {
+        minutes = minutes + toNumber(diff.minute);
+    }
+    if (diff.seconds) {
+        seconds = seconds + toNumber(diff.seconds);
+    }
+    return createDate(value, hour, minutes, seconds);
+}
+/**
+ * @param {?} value
+ * @param {?} opts
+ * @return {?}
+ */
+function setTime(value, opts) {
+    var /** @type {?} */ hour = parseHours(opts.hour);
+    var /** @type {?} */ minute = parseMinutes(opts.minute);
+    var /** @type {?} */ seconds = parseSeconds(opts.seconds) || 0;
+    if (opts.isPM) {
+        hour += hoursPerDayHalf;
+    }
+    if (!value) {
+        if (!isNaN(hour) && !isNaN(minute)) {
+            return createDate(new Date(), hour, minute, seconds);
+        }
+        return value;
+    }
+    if (isNaN(hour) || isNaN(minute)) {
+        return value;
+    }
+    return createDate(value, hour, minute, seconds);
+}
+/**
+ * @param {?} value
+ * @param {?} hours
+ * @param {?} minutes
+ * @param {?} seconds
+ * @return {?}
+ */
+function createDate(value, hours, minutes, seconds) {
+    return new Date(value.getFullYear(), value.getMonth(), value.getDate(), hours, minutes, seconds, value.getMilliseconds());
+}
+/**
+ * @param {?} value
+ * @return {?}
+ */
+function padNumber(value) {
+    var /** @type {?} */ _value = value.toString();
+    if (_value.length > 1) {
+        return _value;
+    }
+    return "0" + _value;
+}
+/**
+ * @param {?} hours
+ * @param {?} isPM
+ * @return {?}
+ */
+function isHourInputValid(hours, isPM) {
+    return !isNaN(parseHours(hours, isPM));
+}
+/**
+ * @param {?} minutes
+ * @return {?}
+ */
+function isMinuteInputValid(minutes) {
+    return !isNaN(parseMinutes(minutes));
+}
+/**
+ * @param {?} seconds
+ * @return {?}
+ */
+function isSecondInputValid(seconds) {
+    return !isNaN(parseSeconds(seconds));
+}
+/**
+ * @param {?} diff
+ * @param {?} max
+ * @param {?} min
+ * @return {?}
+ */
+function isInputLimitValid(diff, max, min) {
+    var /** @type {?} */ newDate = changeTime(new Date(), diff);
+    if (max && newDate > max) {
+        return false;
+    }
+    if (min && newDate < min) {
+        return false;
+    }
+    return true;
+}
+/**
+ * @param {?} hours
+ * @param {?=} minutes
+ * @param {?=} seconds
+ * @param {?=} isPM
+ * @return {?}
+ */
+function isInputValid(hours, minutes, seconds, isPM) {
+    if (minutes === void 0) { minutes = '0'; }
+    if (seconds === void 0) { seconds = '0'; }
+    return isHourInputValid(hours, isPM)
+        && isMinuteInputValid(minutes)
+        && isSecondInputValid(seconds);
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @param {?} state
+ * @param {?=} event
+ * @return {?}
+ */
+function canChangeValue(state, event) {
+    if (state.readonlyInput || state.disabled) {
+        return false;
+    }
+    if (event) {
+        if (event.source === 'wheel' && !state.mousewheel) {
+            return false;
+        }
+        if (event.source === 'key' && !state.arrowkeys) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @param {?} event
+ * @param {?} controls
+ * @return {?}
+ */
+function canChangeHours(event, controls) {
+    if (!event.step) {
+        return false;
+    }
+    if (event.step > 0 && !controls.canIncrementHours) {
+        return false;
+    }
+    if (event.step < 0 && !controls.canDecrementHours) {
+        return false;
+    }
+    return true;
+}
+/**
+ * @param {?} event
+ * @param {?} controls
+ * @return {?}
+ */
+function canChangeMinutes(event, controls) {
+    if (!event.step) {
+        return false;
+    }
+    if (event.step > 0 && !controls.canIncrementMinutes) {
+        return false;
+    }
+    if (event.step < 0 && !controls.canDecrementMinutes) {
+        return false;
+    }
+    return true;
+}
+/**
+ * @param {?} event
+ * @param {?} controls
+ * @return {?}
+ */
+function canChangeSeconds(event, controls) {
+    if (!event.step) {
+        return false;
+    }
+    if (event.step > 0 && !controls.canIncrementSeconds) {
+        return false;
+    }
+    if (event.step < 0 && !controls.canDecrementSeconds) {
+        return false;
+    }
+    return true;
+}
+/**
+ * @param {?} state
+ * @return {?}
+ */
+function getControlsValue(state) {
+    var hourStep = state.hourStep, minuteStep = state.minuteStep, secondsStep = state.secondsStep, readonlyInput = state.readonlyInput, disabled = state.disabled, mousewheel = state.mousewheel, arrowkeys = state.arrowkeys, showSpinners = state.showSpinners, showMeridian = state.showMeridian, showSeconds = state.showSeconds, meridians = state.meridians, min = state.min, max = state.max;
+    return {
+        hourStep: hourStep,
+        minuteStep: minuteStep,
+        secondsStep: secondsStep,
+        readonlyInput: readonlyInput,
+        disabled: disabled,
+        mousewheel: mousewheel,
+        arrowkeys: arrowkeys,
+        showSpinners: showSpinners,
+        showMeridian: showMeridian,
+        showSeconds: showSeconds,
+        meridians: meridians,
+        min: min,
+        max: max
+    };
+}
+/**
+ * @param {?} value
+ * @param {?} state
+ * @return {?}
+ */
+function timepickerControls(value, state) {
+    var /** @type {?} */ hoursPerDayHalf = 12;
+    var min = state.min, max = state.max, hourStep = state.hourStep, minuteStep = state.minuteStep, secondsStep = state.secondsStep, showSeconds = state.showSeconds;
+    var /** @type {?} */ res = {
+        canIncrementHours: true,
+        canIncrementMinutes: true,
+        canIncrementSeconds: true,
+        canDecrementHours: true,
+        canDecrementMinutes: true,
+        canDecrementSeconds: true,
+        canToggleMeridian: true
+    };
+    if (!value) {
+        return res;
+    }
+    // compare dates
+    if (max) {
+        var /** @type {?} */ _newHour = changeTime(value, { hour: hourStep });
+        res.canIncrementHours = max > _newHour;
+        if (!res.canIncrementHours) {
+            var /** @type {?} */ _newMinutes = changeTime(value, { minute: minuteStep });
+            res.canIncrementMinutes = showSeconds
+                ? max > _newMinutes
+                : max >= _newMinutes;
+        }
+        if (!res.canIncrementMinutes) {
+            var /** @type {?} */ _newSeconds = changeTime(value, { seconds: secondsStep });
+            res.canIncrementSeconds = max >= _newSeconds;
+        }
+        if (value.getHours() < hoursPerDayHalf) {
+            res.canToggleMeridian = changeTime(value, { hour: hoursPerDayHalf }) < max;
+        }
+    }
+    if (min) {
+        var /** @type {?} */ _newHour = changeTime(value, { hour: -hourStep });
+        res.canDecrementHours = min < _newHour;
+        if (!res.canDecrementHours) {
+            var /** @type {?} */ _newMinutes = changeTime(value, { minute: -minuteStep });
+            res.canDecrementMinutes = showSeconds
+                ? min < _newMinutes
+                : min <= _newMinutes;
+        }
+        if (!res.canDecrementMinutes) {
+            var /** @type {?} */ _newSeconds = changeTime(value, { seconds: -secondsStep });
+            res.canDecrementSeconds = min <= _newSeconds;
+        }
+        if (value.getHours() >= hoursPerDayHalf) {
+            res.canToggleMeridian = changeTime(value, { hour: -hoursPerDayHalf }) > min;
+        }
+    }
+    return res;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Provides default configuration values for timepicker
+ */
+var TimepickerConfig = /** @class */ (function () {
+    function TimepickerConfig() {
+        /**
+         * 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 }
+    ];
+    return TimepickerConfig;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var /** @type {?} */ initialState = {
+    value: null,
+    config: new TimepickerConfig(),
+    controls: {
+        canIncrementHours: true,
+        canIncrementMinutes: true,
+        canIncrementSeconds: true,
+        canDecrementHours: true,
+        canDecrementMinutes: true,
+        canDecrementSeconds: true,
+        canToggleMeridian: true
+    }
+};
+/**
+ * @param {?=} state
+ * @param {?=} action
+ * @return {?}
+ */
+function timepickerReducer(state, action) {
+    if (state === void 0) { state = initialState; }
+    switch (action.type) {
+        case TimepickerActions.WRITE_VALUE: {
+            return Object.assign({}, state, { value: action.payload });
+        }
+        case TimepickerActions.CHANGE_HOURS: {
+            if (!canChangeValue(state.config, action.payload) ||
+                !canChangeHours(action.payload, state.controls)) {
+                return state;
+            }
+            var /** @type {?} */ _newTime = changeTime(state.value, { hour: action.payload.step });
+            if ((state.config.max || state.config.min) && !isValidLimit(state.config, _newTime)) {
+                return state;
+            }
+            return Object.assign({}, state, { value: _newTime });
+        }
+        case TimepickerActions.CHANGE_MINUTES: {
+            if (!canChangeValue(state.config, action.payload) ||
+                !canChangeMinutes(action.payload, state.controls)) {
+                return state;
+            }
+            var /** @type {?} */ _newTime = changeTime(state.value, { minute: action.payload.step });
+            if ((state.config.max || state.config.min) && !isValidLimit(state.config, _newTime)) {
+                return state;
+            }
+            return Object.assign({}, state, { value: _newTime });
+        }
+        case TimepickerActions.CHANGE_SECONDS: {
+            if (!canChangeValue(state.config, action.payload) ||
+                !canChangeSeconds(action.payload, state.controls)) {
+                return state;
+            }
+            var /** @type {?} */ _newTime = changeTime(state.value, {
+                seconds: action.payload.step
+            });
+            if ((state.config.max || state.config.min) && !isValidLimit(state.config, _newTime)) {
+                return state;
+            }
+            return Object.assign({}, state, { value: _newTime });
+        }
+        case TimepickerActions.SET_TIME_UNIT: {
+            if (!canChangeValue(state.config)) {
+                return state;
+            }
+            var /** @type {?} */ _newTime = setTime(state.value, action.payload);
+            return Object.assign({}, state, { value: _newTime });
+        }
+        case TimepickerActions.UPDATE_CONTROLS: {
+            var /** @type {?} */ _newControlsState = timepickerControls(state.value, action.payload);
+            var /** @type {?} */ _newState = {
+                value: state.value,
+                config: action.payload,
+                controls: _newControlsState
+            };
+            if (state.config.showMeridian !== _newState.config.showMeridian) {
+                if (state.value) {
+                    _newState.value = new Date(state.value);
+                }
+            }
+            return Object.assign({}, state, _newState);
+        }
+        default:
+            return state;
+    }
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var TimepickerStore = /** @class */ (function (_super) {
+    __extends(TimepickerStore, _super);
+    function TimepickerStore() {
+        var _this = this;
+        var /** @type {?} */ _dispatcher = new BehaviorSubject({
+            type: '[mini-ngrx] dispatcher init'
+        });
+        var /** @type {?} */ state = new MiniState(initialState, _dispatcher, timepickerReducer);
+        _this = _super.call(this, _dispatcher, timepickerReducer, state) || this;
+        return _this;
+    }
+    TimepickerStore.decorators = [
+        { type: Injectable }
+    ];
+    /** @nocollapse */
+    TimepickerStore.ctorParameters = function () { return []; };
+    return TimepickerStore;
+}(MiniStore));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var /** @type {?} */ TIMEPICKER_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(function () { return TimepickerComponent; }),
+    multi: true
+};
+var TimepickerComponent = /** @class */ (function () {
+    function TimepickerComponent(_config, _cd, _store, _timepickerActions) {
+        var _this = this;
+        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(function (state) { return state.value; })
+            .subscribe(function (value) {
+            // update UI values if date changed
+            // update UI values if date changed
+            _this._renderTime(value);
+            _this.onChange(value);
+            _this._store.dispatch(_this._timepickerActions.updateControls(getControlsValue(_this)));
+        });
+        _store
+            .select(function (state) { return state.controls; })
+            .subscribe(function (controlsState) {
+            _this.isValid.emit(isInputValid(_this.hours, _this.minutes, _this.seconds, _this.isPM()));
+            Object.assign(_this, controlsState);
+            _cd.markForCheck();
+        });
+    }
+    Object.defineProperty(TimepickerComponent.prototype, "isSpinnersVisible", {
+        /** @deprecated - please use `isEditable` instead */
+        get: /**
+         * @deprecated - please use `isEditable` instead
+         * @return {?}
+         */
+        function () {
+            return this.showSpinners && !this.readonlyInput;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TimepickerComponent.prototype, "isEditable", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return !(this.readonlyInput || this.disabled);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    TimepickerComponent.prototype.resetValidation = /**
+     * @return {?}
+     */
+    function () {
+        this.invalidHours = false;
+        this.invalidMinutes = false;
+        this.invalidSeconds = false;
+    };
+    /**
+     * @return {?}
+     */
+    TimepickerComponent.prototype.isPM = /**
+     * @return {?}
+     */
+    function () {
+        return this.showMeridian && this.meridian === this.meridians[1];
+    };
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    TimepickerComponent.prototype.prevDef = /**
+     * @param {?} $event
+     * @return {?}
+     */
+    function ($event) {
+        $event.preventDefault();
+    };
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    TimepickerComponent.prototype.wheelSign = /**
+     * @param {?} $event
+     * @return {?}
+     */
+    function ($event) {
+        return Math.sign($event.deltaY) * -1;
+    };
+    /**
+     * @param {?} changes
+     * @return {?}
+     */
+    TimepickerComponent.prototype.ngOnChanges = /**
+     * @param {?} changes
+     * @return {?}
+     */
+    function (changes) {
+        this._store.dispatch(this._timepickerActions.updateControls(getControlsValue(this)));
+    };
+    /**
+     * @param {?} step
+     * @param {?=} source
+     * @return {?}
+     */
+    TimepickerComponent.prototype.changeHours = /**
+     * @param {?} step
+     * @param {?=} source
+     * @return {?}
+     */
+    function (step, source) {
+        if (source === void 0) { source = ''; }
+        this.resetValidation();
+        this._store.dispatch(this._timepickerActions.changeHours({ step: step, source: source }));
+    };
+    /**
+     * @param {?} step
+     * @param {?=} source
+     * @return {?}
+     */
+    TimepickerComponent.prototype.changeMinutes = /**
+     * @param {?} step
+     * @param {?=} source
+     * @return {?}
+     */
+    function (step, source) {
+        if (source === void 0) { source = ''; }
+        this.resetValidation();
+        this._store.dispatch(this._timepickerActions.changeMinutes({ step: step, source: source }));
+    };
+    /**
+     * @param {?} step
+     * @param {?=} source
+     * @return {?}
+     */
+    TimepickerComponent.prototype.changeSeconds = /**
+     * @param {?} step
+     * @param {?=} source
+     * @return {?}
+     */
+    function (step, source) {
+        if (source === void 0) { source = ''; }
+        this.resetValidation();
+        this._store.dispatch(this._timepickerActions.changeSeconds({ step: step, source: source }));
+    };
+    /**
+     * @param {?} hours
+     * @return {?}
+     */
+    TimepickerComponent.prototype.updateHours = /**
+     * @param {?} hours
+     * @return {?}
+     */
+    function (hours) {
+        this.resetValidation();
+        this.hours = hours;
+        var /** @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 {?}
+     */
+    TimepickerComponent.prototype.updateMinutes = /**
+     * @param {?} minutes
+     * @return {?}
+     */
+    function (minutes) {
+        this.resetValidation();
+        this.minutes = minutes;
+        var /** @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 {?}
+     */
+    TimepickerComponent.prototype.updateSeconds = /**
+     * @param {?} seconds
+     * @return {?}
+     */
+    function (seconds) {
+        this.resetValidation();
+        this.seconds = seconds;
+        var /** @type {?} */ isValid = isSecondInputValid(this.seconds) && this.isValidLimit();
+        if (!isValid) {
+            this.invalidSeconds = true;
+            this.isValid.emit(false);
+            this.onChange(null);
+            return;
+        }
+        this._updateTime();
+    };
+    /**
+     * @return {?}
+     */
+    TimepickerComponent.prototype.isValidLimit = /**
+     * @return {?}
+     */
+    function () {
+        return isInputLimitValid({
+            hour: this.hours,
+            minute: this.minutes,
+            seconds: this.seconds,
+            isPM: this.isPM()
+        }, this.max, this.min);
+    };
+    /**
+     * @return {?}
+     */
+    TimepickerComponent.prototype._updateTime = /**
+     * @return {?}
+     */
+    function () {
+        var /** @type {?} */ _seconds = this.showSeconds ? this.seconds : void 0;
+        var /** @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 {?}
+     */
+    TimepickerComponent.prototype.toggleMeridian = /**
+     * @return {?}
+     */
+    function () {
+        if (!this.showMeridian || !this.isEditable) {
+            return;
+        }
+        var /** @type {?} */ _hoursPerDayHalf = 12;
+        this._store.dispatch(this._timepickerActions.changeHours({
+            step: _hoursPerDayHalf,
+            source: ''
+        }));
+    };
+    /**
+     * Write a new value to the element.
+     */
+    /**
+     * Write a new value to the element.
+     * @param {?} obj
+     * @return {?}
+     */
+    TimepickerComponent.prototype.writeValue = /**
+     * Write a new value to the element.
+     * @param {?} obj
+     * @return {?}
+     */
+    function (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.
+     */
+    // tslint:disable-next-line:no-any
+    /**
+     * Set the function to be called when the control receives a change event.
+     * @param {?} fn
+     * @return {?}
+     */
+    TimepickerComponent.prototype.registerOnChange = /**
+     * Set the function to be called when the control receives a change event.
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this.onChange = fn;
+    };
+    /**
+     * Set the function to be called when the control receives a touch event.
+     */
+    /**
+     * Set the function to be called when the control receives a touch event.
+     * @param {?} fn
+     * @return {?}
+     */
+    TimepickerComponent.prototype.registerOnTouched = /**
+     * Set the function to be called when the control receives a touch event.
+     * @param {?} fn
+     * @return {?}
+     */
+    function (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
+     */
+    /**
+     * 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 {?}
+     */
+    TimepickerComponent.prototype.setDisabledState = /**
+     * 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 {?}
+     */
+    function (isDisabled) {
+        this.disabled = isDisabled;
+    };
+    /**
+     * @return {?}
+     */
+    TimepickerComponent.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        this.timepickerSub.unsubscribe();
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    TimepickerComponent.prototype._renderTime = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        if (!isValidDate(value)) {
+            this.hours = '';
+            this.minutes = '';
+            this.seconds = '';
+            this.meridian = this.meridians[0];
+            return;
+        }
+        var /** @type {?} */ _value = parseTime(value);
+        var /** @type {?} */ _hoursPerDayHalf = 12;
+        var /** @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: ["\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  "]
+                }] }
+    ];
+    /** @nocollapse */
+    TimepickerComponent.ctorParameters = function () { return [
+        { 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 },],
+    };
+    return TimepickerComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var TimepickerModule = /** @class */ (function () {
+    function TimepickerModule() {
+    }
+    /**
+     * @return {?}
+     */
+    TimepickerModule.forRoot = /**
+     * @return {?}
+     */
+    function () {
+        return {
+            ngModule: TimepickerModule,
+            providers: [TimepickerConfig, TimepickerActions, TimepickerStore]
+        };
+    };
+    TimepickerModule.decorators = [
+        { type: NgModule, args: [{
+                    imports: [CommonModule],
+                    declarations: [TimepickerComponent],
+                    exports: [TimepickerComponent]
+                },] }
+    ];
+    return TimepickerModule;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+export { TimepickerComponent, TimepickerActions, TimepickerStore, TimepickerConfig, TimepickerModule, TIMEPICKER_CONTROL_VALUE_ACCESSOR as ɵa };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-timepicker.js.map","sources":["ng://ngx-bootstrap/timepicker/reducer/timepicker.actions.ts","ng://ngx-bootstrap/timepicker/timepicker.utils.ts","ng://ngx-bootstrap/timepicker/timepicker-controls.util.ts","ng://ngx-bootstrap/timepicker/timepicker.config.ts","ng://ngx-bootstrap/timepicker/reducer/timepicker.reducer.ts","ng://ngx-bootstrap/timepicker/reducer/timepicker.store.ts","ng://ngx-bootstrap/timepicker/timepicker.component.ts","ng://ngx-bootstrap/timepicker/timepicker.module.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\nimport { Action } from 'ngx-bootstrap/mini-ngrx';\nimport {\n  TimeChangeEvent,\n  TimepickerComponentState,\n  Time\n} from '../timepicker.models';\n\n@Injectable()\nexport class TimepickerActions {\n  static readonly WRITE_VALUE = '[timepicker] write value from ng model';\n  static readonly CHANGE_HOURS = '[timepicker] change hours';\n  static readonly CHANGE_MINUTES = '[timepicker] change minutes';\n  static readonly CHANGE_SECONDS = '[timepicker] change seconds';\n  static readonly SET_TIME_UNIT = '[timepicker] set time unit';\n  static readonly UPDATE_CONTROLS = '[timepicker] update controls';\n\n  writeValue(value: Date | string) {\n    return {\n      type: TimepickerActions.WRITE_VALUE,\n      payload: value\n    };\n  }\n\n  changeHours(event: TimeChangeEvent) {\n    return {\n      type: TimepickerActions.CHANGE_HOURS,\n      payload: event\n    };\n  }\n\n  changeMinutes(event: TimeChangeEvent) {\n    return {\n      type: TimepickerActions.CHANGE_MINUTES,\n      payload: event\n    };\n  }\n\n  changeSeconds(event: TimeChangeEvent): Action {\n    return {\n      type: TimepickerActions.CHANGE_SECONDS,\n      payload: event\n    };\n  }\n\n  setTime(value: Time): Action {\n    return {\n      type: TimepickerActions.SET_TIME_UNIT,\n      payload: value\n    };\n  }\n\n  updateControls(value: TimepickerComponentState): Action {\n    return {\n      type: TimepickerActions.UPDATE_CONTROLS,\n      payload: value\n    };\n  }\n}\n","import { Time, TimepickerComponentState } from './timepicker.models';\n\nconst dex = 10;\nconst hoursPerDay = 24;\nconst hoursPerDayHalf = 12;\nconst minutesPerHour = 60;\nconst secondsPerMinute = 60;\n\nexport function isValidDate(value?: string | Date): boolean {\n  if (!value) {\n    return false;\n  }\n\n  if (value instanceof Date && isNaN(value.getHours())) {\n    return false;\n  }\n\n  if (typeof value === 'string') {\n    return isValidDate(new Date(value));\n  }\n\n  return true;\n}\n\nexport function isValidLimit(controls: TimepickerComponentState, newDate: Date): boolean {\n  if (controls.min && newDate < controls.min) {\n    return false;\n  }\n\n  if (controls.max && newDate > controls.max) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function toNumber(value: string | number): number {\n  if (typeof value === 'number') {\n    return value;\n  }\n\n  return parseInt(value, dex);\n}\n\nexport function isNumber(value: string | number): value is number {\n  return !isNaN(toNumber(value));\n}\n\nexport function parseHours(\n  value: string | number,\n  isPM = false\n): number {\n  const hour = toNumber(value);\n  if (\n    isNaN(hour) ||\n    hour < 0 ||\n    hour > (isPM ? hoursPerDayHalf : hoursPerDay)\n  ) {\n    return NaN;\n  }\n\n  return hour;\n}\n\nexport function parseMinutes(value: string | number): number {\n  const minute = toNumber(value);\n  if (isNaN(minute) || minute < 0 || minute > minutesPerHour) {\n    return NaN;\n  }\n\n  return minute;\n}\n\nexport function parseSeconds(value: string | number): number {\n  const seconds = toNumber(value);\n  if (isNaN(seconds) || seconds < 0 || seconds > secondsPerMinute) {\n    return NaN;\n  }\n\n  return seconds;\n}\n\nexport function parseTime(value: string | Date): Date {\n  if (typeof value === 'string') {\n    return new Date(value);\n  }\n\n  return value;\n}\n\nexport function changeTime(value: Date, diff: Time): Date {\n  if (!value) {\n    return changeTime(createDate(new Date(), 0, 0, 0), diff);\n  }\n\n  let hour = value.getHours();\n  let minutes = value.getMinutes();\n  let seconds = value.getSeconds();\n\n  if (diff.hour) {\n    hour = (hour + toNumber(diff.hour)) % hoursPerDay;\n    if (hour < 0) {\n      hour += hoursPerDay;\n    }\n  }\n\n  if (diff.minute) {\n    minutes = minutes + toNumber(diff.minute);\n  }\n\n  if (diff.seconds) {\n    seconds = seconds + toNumber(diff.seconds);\n  }\n\n  return createDate(value, hour, minutes, seconds);\n}\n\nexport function setTime(value: Date, opts: Time): Date {\n  let hour = parseHours(opts.hour);\n  const minute = parseMinutes(opts.minute);\n  const seconds = parseSeconds(opts.seconds) || 0;\n\n  if (opts.isPM) {\n    hour += hoursPerDayHalf;\n  }\n\n  if (!value) {\n    if (!isNaN(hour) && !isNaN(minute)) {\n      return createDate(new Date(), hour, minute, seconds);\n    }\n\n    return value;\n  }\n\n  if (isNaN(hour) || isNaN(minute)) {\n    return value;\n  }\n\n  return createDate(value, hour, minute, seconds);\n}\n\nexport function createDate(\n  value: Date,\n  hours: number,\n  minutes: number,\n  seconds: number\n): Date {\n  return new Date(\n    value.getFullYear(),\n    value.getMonth(),\n    value.getDate(),\n    hours,\n    minutes,\n    seconds,\n    value.getMilliseconds()\n  );\n}\n\nexport function padNumber(value: number): string {\n  const _value = value.toString();\n  if (_value.length > 1) {\n    return _value;\n  }\n\n  return `0${_value}`;\n}\n\nexport function isHourInputValid(hours: string, isPM: boolean): boolean {\n  return !isNaN(parseHours(hours, isPM));\n}\n\nexport function isMinuteInputValid(minutes: string): boolean {\n  return !isNaN(parseMinutes(minutes));\n}\n\nexport function isSecondInputValid(seconds: string): boolean {\n  return !isNaN(parseSeconds(seconds));\n}\n\nexport function isInputLimitValid(diff: Time, max: Date, min: Date): boolean {\n  const newDate = changeTime(new Date(), diff);\n\n  if (max && newDate > max) {\n    return false;\n  }\n\n  if (min && newDate < min) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isInputValid(\n  hours: string,\n  minutes = '0',\n  seconds = '0',\n  isPM: boolean\n): boolean {\n  return isHourInputValid(hours, isPM)\n    && isMinuteInputValid(minutes)\n    && isSecondInputValid(seconds);\n}\n","import { changeTime } from './timepicker.utils';\nimport {\n  TimeChangeEvent,\n  TimepickerComponentState,\n  TimepickerControls\n} from './timepicker.models';\n\nexport function canChangeValue(\n  state: TimepickerComponentState,\n  event?: TimeChangeEvent\n): boolean {\n  if (state.readonlyInput || state.disabled) {\n    return false;\n  }\n\n  if (event) {\n    if (event.source === 'wheel' && !state.mousewheel) {\n      return false;\n    }\n\n    if (event.source === 'key' && !state.arrowkeys) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nexport function canChangeHours(\n  event: TimeChangeEvent,\n  controls: TimepickerControls\n): boolean {\n  if (!event.step) {\n    return false;\n  }\n\n  if (event.step > 0 && !controls.canIncrementHours) {\n    return false;\n  }\n\n  if (event.step < 0 && !controls.canDecrementHours) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function canChangeMinutes(\n  event: TimeChangeEvent,\n  controls: TimepickerControls\n): boolean {\n  if (!event.step) {\n    return false;\n  }\n  if (event.step > 0 && !controls.canIncrementMinutes) {\n    return false;\n  }\n  if (event.step < 0 && !controls.canDecrementMinutes) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function canChangeSeconds(\n  event: TimeChangeEvent,\n  controls: TimepickerControls\n): boolean {\n  if (!event.step) {\n    return false;\n  }\n  if (event.step > 0 && !controls.canIncrementSeconds) {\n    return false;\n  }\n  if (event.step < 0 && !controls.canDecrementSeconds) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function getControlsValue(\n  state: TimepickerComponentState\n): TimepickerComponentState {\n  const {\n    hourStep,\n    minuteStep,\n    secondsStep,\n    readonlyInput,\n    disabled,\n    mousewheel,\n    arrowkeys,\n    showSpinners,\n    showMeridian,\n    showSeconds,\n    meridians,\n    min,\n    max\n  } = state;\n\n  return {\n    hourStep,\n    minuteStep,\n    secondsStep,\n    readonlyInput,\n    disabled,\n    mousewheel,\n    arrowkeys,\n    showSpinners,\n    showMeridian,\n    showSeconds,\n    meridians,\n    min,\n    max\n  };\n}\n\nexport function timepickerControls(\n  value: Date,\n  state: TimepickerComponentState\n): TimepickerControls {\n  const hoursPerDayHalf = 12;\n  const { min, max, hourStep, minuteStep, secondsStep, showSeconds } = state;\n  const res: TimepickerControls = {\n    canIncrementHours: true,\n    canIncrementMinutes: true,\n    canIncrementSeconds: true,\n\n    canDecrementHours: true,\n    canDecrementMinutes: true,\n    canDecrementSeconds: true,\n\n    canToggleMeridian: true\n  };\n\n  if (!value) {\n    return res;\n  }\n\n  // compare dates\n  if (max) {\n    const _newHour = changeTime(value, { hour: hourStep });\n    res.canIncrementHours = max > _newHour;\n\n    if (!res.canIncrementHours) {\n      const _newMinutes = changeTime(value, { minute: minuteStep });\n      res.canIncrementMinutes = showSeconds\n        ? max > _newMinutes\n        : max >= _newMinutes;\n    }\n\n    if (!res.canIncrementMinutes) {\n      const _newSeconds = changeTime(value, { seconds: secondsStep });\n      res.canIncrementSeconds = max >= _newSeconds;\n    }\n\n    if (value.getHours() < hoursPerDayHalf) {\n      res.canToggleMeridian = changeTime(value, { hour: hoursPerDayHalf }) < max;\n    }\n  }\n\n  if (min) {\n    const _newHour = changeTime(value, { hour: -hourStep });\n    res.canDecrementHours = min < _newHour;\n\n    if (!res.canDecrementHours) {\n      const _newMinutes = changeTime(value, { minute: -minuteStep });\n      res.canDecrementMinutes = showSeconds\n        ? min < _newMinutes\n        : min <= _newMinutes;\n    }\n\n    if (!res.canDecrementMinutes) {\n      const _newSeconds = changeTime(value, { seconds: -secondsStep });\n      res.canDecrementSeconds = min <= _newSeconds;\n    }\n\n    if (value.getHours() >= hoursPerDayHalf) {\n      res.canToggleMeridian = changeTime(value, { hour: -hoursPerDayHalf }) > min;\n    }\n  }\n\n  return res;\n}\n","import { Injectable } from '@angular/core';\n\n/** Provides default configuration values for timepicker */\n@Injectable()\nexport class TimepickerConfig {\n  /** hours change step */\n  hourStep = 1;\n  /** hours change step */\n  minuteStep = 5;\n  /** seconds changes step */\n  secondsStep = 10;\n  /** if true works in 12H mode and displays AM/PM. If false works in 24H mode and hides AM/PM */\n  showMeridian = true;\n  /** meridian labels based on locale */\n  meridians = ['AM', 'PM'];\n  /** if true hours and minutes fields will be readonly */\n  readonlyInput = false;\n  /** if true hours and minutes fields will be disabled */\n  disabled = false;\n  /** if true scroll inside hours and minutes inputs will change time */\n  mousewheel = true;\n  /** if true the values of hours and minutes can be changed using the up/down arrow keys on the keyboard */\n  arrowkeys = true;\n  /** if true spinner arrows above and below the inputs will be shown */\n  showSpinners = true;\n  /** show seconds in timepicker */\n  showSeconds = false;\n  /** show minutes in timepicker */\n  showMinutes = true;\n  /** minimum time user can select */\n  min: Date;\n  /** maximum time user can select */\n  max: Date;\n}\n","import { Action } from 'ngx-bootstrap/mini-ngrx';\nimport {\n  canChangeHours,\n  canChangeMinutes,\n  canChangeSeconds,\n  canChangeValue,\n  timepickerControls\n} from '../timepicker-controls.util';\nimport { TimepickerConfig } from '../timepicker.config';\nimport {\n  TimepickerComponentState,\n  TimepickerControls\n} from '../timepicker.models';\nimport { changeTime, setTime, isValidLimit } from '../timepicker.utils';\nimport { TimepickerActions } from './timepicker.actions';\n\nexport class TimepickerState {\n  value: Date;\n  config: TimepickerComponentState;\n  controls: TimepickerControls;\n}\n\nexport const initialState: TimepickerState = {\n  value: null,\n  config: new TimepickerConfig(),\n  controls: {\n    canIncrementHours: true,\n    canIncrementMinutes: true,\n    canIncrementSeconds: true,\n\n    canDecrementHours: true,\n    canDecrementMinutes: true,\n    canDecrementSeconds: true,\n\n    canToggleMeridian: true\n  }\n};\n\n// tslint:disable-next-line:cyclomatic-complexity\nexport function timepickerReducer(state = initialState, action: Action) {\n  switch (action.type) {\n    case TimepickerActions.WRITE_VALUE: {\n      return Object.assign({}, state, { value: action.payload });\n    }\n\n    case TimepickerActions.CHANGE_HOURS: {\n      if (\n        !canChangeValue(state.config, action.payload) ||\n        !canChangeHours(action.payload, state.controls)\n      ) {\n        return state;\n      }\n\n      const _newTime = changeTime(state.value, { hour: action.payload.step });\n\n      if ((state.config.max || state.config.min) && !isValidLimit(state.config, _newTime)) {\n          return state;\n      }\n\n      return Object.assign({}, state, { value: _newTime });\n    }\n\n    case TimepickerActions.CHANGE_MINUTES: {\n      if (\n        !canChangeValue(state.config, action.payload) ||\n        !canChangeMinutes(action.payload, state.controls)\n      ) {\n        return state;\n      }\n\n      const _newTime = changeTime(state.value, { minute: action.payload.step });\n\n      if ((state.config.max || state.config.min) && !isValidLimit(state.config, _newTime)) {\n        return state;\n      }\n\n      return Object.assign({}, state, { value: _newTime });\n    }\n\n    case TimepickerActions.CHANGE_SECONDS: {\n      if (\n        !canChangeValue(state.config, action.payload) ||\n        !canChangeSeconds(action.payload, state.controls)\n      ) {\n        return state;\n      }\n\n      const _newTime = changeTime(state.value, {\n        seconds: action.payload.step\n      });\n\n      if ((state.config.max || state.config.min) && !isValidLimit(state.config, _newTime)) {\n        return state;\n      }\n\n      return Object.assign({}, state, { value: _newTime });\n    }\n\n    case TimepickerActions.SET_TIME_UNIT: {\n      if (!canChangeValue(state.config)) {\n        return state;\n      }\n\n      const _newTime = setTime(state.value, action.payload);\n\n      return Object.assign({}, state, { value: _newTime });\n    }\n\n    case TimepickerActions.UPDATE_CONTROLS: {\n      const _newControlsState = timepickerControls(state.value, action.payload);\n      const _newState: TimepickerState = {\n        value: state.value,\n        config: action.payload,\n        controls: _newControlsState\n      };\n\n      if (state.config.showMeridian !== _newState.config.showMeridian) {\n        if (state.value) {\n          _newState.value = new Date(state.value);\n        }\n      }\n\n      return Object.assign({}, state, _newState);\n    }\n\n    default:\n      return state;\n  }\n}\n","import { Injectable } from '@angular/core';\nimport {\n  timepickerReducer,\n  TimepickerState,\n  initialState\n} from './timepicker.reducer';\nimport { BehaviorSubject } from 'rxjs';\n\nimport { Action, MiniStore, MiniState } from 'ngx-bootstrap/mini-ngrx';\n\n@Injectable()\nexport class TimepickerStore extends MiniStore<TimepickerState> {\n  constructor() {\n    const _dispatcher = new BehaviorSubject<Action>({\n      type: '[mini-ngrx] dispatcher init'\n    });\n    const state = new MiniState<TimepickerState>(\n      initialState,\n      _dispatcher,\n      timepickerReducer\n    );\n    super(_dispatcher, timepickerReducer, state);\n  }\n}\n","/* 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","import { ModuleWithProviders, NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\n\nimport { TimepickerComponent } from './timepicker.component';\nimport { TimepickerActions } from './reducer/timepicker.actions';\nimport { TimepickerConfig } from './timepicker.config';\nimport { TimepickerStore } from './reducer/timepicker.store';\n\n@NgModule({\n  imports: [CommonModule],\n  declarations: [TimepickerComponent],\n  exports: [TimepickerComponent]\n})\nexport class TimepickerModule {\n  static forRoot(): ModuleWithProviders {\n    return {\n      ngModule: TimepickerModule,\n      providers: [TimepickerConfig, TimepickerActions, TimepickerStore]\n    };\n  }\n}\n"],"names":["tslib_1.__extends"],"mappings":"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"}