ngx-bootstrap 3.0.1 → 3.1.4

package/timepicker/bundles/ngx-bootstrap-timepicker.umd.js

@@ -0,0 +1,1183 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('rxjs'), require('ngx-bootstrap/mini-ngrx'), require('@angular/forms'), require('@angular/common')) :
+    typeof define === 'function' && define.amd ? define('ngx-bootstrap/timepicker', ['exports', '@angular/core', 'rxjs', 'ngx-bootstrap/mini-ngrx', '@angular/forms', '@angular/common'], factory) :
+    (factory((global['ngx-bootstrap'] = global['ngx-bootstrap'] || {}, global['ngx-bootstrap'].timepicker = {}),global.ng.core,global.rxjs,global.miniNgrx,global.ng.forms,global.ng.common));
+}(this, (function (exports,core,rxjs,miniNgrx,forms,common) { 'use strict';
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var TimepickerActions = (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: core.Injectable }
+        ];
+        return TimepickerActions;
+    }());
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at http://www.apache.org/licenses/LICENSE-2.0
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b)
+                if (b.hasOwnProperty(p))
+                    d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    function __extends(d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    /**
+     * @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 = (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: core.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 = (function (_super) {
+        __extends(TimepickerStore, _super);
+        function TimepickerStore() {
+            var _this = this;
+            var /** @type {?} */ _dispatcher = new rxjs.BehaviorSubject({
+                type: '[mini-ngrx] dispatcher init'
+            });
+            var /** @type {?} */ state = new miniNgrx.MiniState(initialState, _dispatcher, timepickerReducer);
+            _this = _super.call(this, _dispatcher, timepickerReducer, state) || this;
+            return _this;
+        }
+        TimepickerStore.decorators = [
+            { type: core.Injectable }
+        ];
+        /** @nocollapse */
+        TimepickerStore.ctorParameters = function () { return []; };
+        return TimepickerStore;
+    }(miniNgrx.MiniStore));
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var /** @type {?} */ TIMEPICKER_CONTROL_VALUE_ACCESSOR = {
+        provide: forms.NG_VALUE_ACCESSOR,
+        /* tslint:disable-next-line: no-use-before-declare */
+        useExisting: core.forwardRef(function () { return TimepickerComponent; }),
+        multi: true
+    };
+    var TimepickerComponent = (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 core.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: core.Component, args: [{
+                        selector: 'timepicker',
+                        changeDetection: core.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: core.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: core.ChangeDetectorRef, },
+                { type: TimepickerStore, },
+                { type: TimepickerActions, },
+            ];
+        };
+        TimepickerComponent.propDecorators = {
+            "hourStep": [{ type: core.Input },],
+            "minuteStep": [{ type: core.Input },],
+            "secondsStep": [{ type: core.Input },],
+            "readonlyInput": [{ type: core.Input },],
+            "disabled": [{ type: core.Input },],
+            "mousewheel": [{ type: core.Input },],
+            "arrowkeys": [{ type: core.Input },],
+            "showSpinners": [{ type: core.Input },],
+            "showMeridian": [{ type: core.Input },],
+            "showMinutes": [{ type: core.Input },],
+            "showSeconds": [{ type: core.Input },],
+            "meridians": [{ type: core.Input },],
+            "min": [{ type: core.Input },],
+            "max": [{ type: core.Input },],
+            "isValid": [{ type: core.Output },],
+        };
+        return TimepickerComponent;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var TimepickerModule = (function () {
+        function TimepickerModule() {
+        }
+        /**
+         * @return {?}
+         */
+        TimepickerModule.forRoot = /**
+         * @return {?}
+         */
+            function () {
+                return {
+                    ngModule: TimepickerModule,
+                    providers: [TimepickerConfig, TimepickerActions, TimepickerStore]
+                };
+            };
+        TimepickerModule.decorators = [
+            { type: core.NgModule, args: [{
+                        imports: [common.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
+     */
+
+    exports.TimepickerComponent = TimepickerComponent;
+    exports.TimepickerActions = TimepickerActions;
+    exports.TimepickerStore = TimepickerStore;
+    exports.TimepickerConfig = TimepickerConfig;
+    exports.TimepickerModule = TimepickerModule;
+    exports.ɵa = TIMEPICKER_CONTROL_VALUE_ACCESSOR;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-timepicker.umd.js.map","sources":["ng://ngx-bootstrap/timepicker/reducer/timepicker.actions.ts","node_modules/tslib/tslib.es6.js","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","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\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":["Injectable","tslib_1.__extends","BehaviorSubject","MiniState","MiniStore","NG_VALUE_ACCESSOR","forwardRef","EventEmitter","Component","ChangeDetectionStrategy","ViewEncapsulation","ChangeDetectorRef","Input","Output","NgModule","CommonModule"],"mappings":"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"}