ngx-bootstrap 3.0.1 → 3.1.4

package/datepicker/esm5/base/bs-datepicker-container.js

@@ -0,0 +1,170 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @abstract
+ */
+var /**
+ * @abstract
+ */
+BsDatepickerAbstractComponent = /** @class */ (function () {
+    function BsDatepickerAbstractComponent() {
+        this._customRangesFish = [];
+    }
+    Object.defineProperty(BsDatepickerAbstractComponent.prototype, "minDate", {
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._effects.setMinDate(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BsDatepickerAbstractComponent.prototype, "maxDate", {
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._effects.setMaxDate(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BsDatepickerAbstractComponent.prototype, "daysDisabled", {
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._effects.setDaysDisabled(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BsDatepickerAbstractComponent.prototype, "isDisabled", {
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._effects.setDisabled(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.setViewMode = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.navigateTo = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.dayHoverHandler = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.monthHoverHandler = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.yearHoverHandler = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} day
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.daySelectHandler = /**
+     * @param {?} day
+     * @return {?}
+     */
+    function (day) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.monthSelectHandler = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.yearSelectHandler = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /* tslint:disable-next-line: no-any */
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype._stopPropagation = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        event.stopPropagation();
+    };
+    return BsDatepickerAbstractComponent;
+}());
+/**
+ * @abstract
+ */
+export { BsDatepickerAbstractComponent };
+function BsDatepickerAbstractComponent_tsickle_Closure_declarations() {
+    /** @type {?} */
+    BsDatepickerAbstractComponent.prototype.containerClass;
+    /** @type {?} */
+    BsDatepickerAbstractComponent.prototype.isOtherMonthsActive;
+    /** @type {?} */
+    BsDatepickerAbstractComponent.prototype._effects;
+    /** @type {?} */
+    BsDatepickerAbstractComponent.prototype._customRangesFish;
+    /** @type {?} */
+    BsDatepickerAbstractComponent.prototype.viewMode;
+    /** @type {?} */
+    BsDatepickerAbstractComponent.prototype.daysCalendar;
+    /** @type {?} */
+    BsDatepickerAbstractComponent.prototype.monthsCalendar;
+    /** @type {?} */
+    BsDatepickerAbstractComponent.prototype.yearsCalendar;
+    /** @type {?} */
+    BsDatepickerAbstractComponent.prototype.options;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm5/bs-datepicker-input.directive.js

@@ -0,0 +1,242 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { ChangeDetectorRef, Directive, ElementRef, forwardRef, Host, Renderer2 } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { parseDate, formatDate, getLocale, isAfter, isBefore, isDate, isDateValid } from 'ngx-bootstrap/chronos';
+import { BsDatepickerDirective } from './bs-datepicker.component';
+import { BsLocaleService } from './bs-locale.service';
+var /** @type {?} */ BS_DATEPICKER_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(function () { return BsDatepickerInputDirective; }),
+    multi: true
+};
+var /** @type {?} */ BS_DATEPICKER_VALIDATOR = {
+    provide: NG_VALIDATORS,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(function () { return BsDatepickerInputDirective; }),
+    multi: true
+};
+var BsDatepickerInputDirective = /** @class */ (function () {
+    function BsDatepickerInputDirective(_picker, _localeService, _renderer, _elRef, changeDetection) {
+        var _this = this;
+        this._picker = _picker;
+        this._localeService = _localeService;
+        this._renderer = _renderer;
+        this._elRef = _elRef;
+        this.changeDetection = changeDetection;
+        this._onChange = Function.prototype;
+        this._onTouched = Function.prototype;
+        this._validatorChange = Function.prototype;
+        // update input value on datepicker value update
+        this._picker.bsValueChange.subscribe(function (value) {
+            _this._setInputValue(value);
+            if (_this._value !== value) {
+                _this._value = value;
+                _this._onChange(value);
+                _this._onTouched();
+            }
+            _this.changeDetection.markForCheck();
+        });
+        // update input value on locale change
+        this._localeService.localeChange.subscribe(function () {
+            _this._setInputValue(_this._value);
+        });
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype._setInputValue = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        var /** @type {?} */ initialDate = !value ? ''
+            : formatDate(value, this._picker._config.dateInputFormat, this._localeService.currentLocale);
+        this._renderer.setProperty(this._elRef.nativeElement, 'value', initialDate);
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.onChange = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        /* tslint:disable-next-line: no-any*/
+        this.writeValue((/** @type {?} */ (event.target)).value);
+        this._onChange(this._value);
+        this._onTouched();
+    };
+    /**
+     * @param {?} c
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.validate = /**
+     * @param {?} c
+     * @return {?}
+     */
+    function (c) {
+        var /** @type {?} */ _value = c.value;
+        /* tslint:disable-next-line: prefer-switch */
+        if (_value === null || _value === undefined || _value === '') {
+            return null;
+        }
+        if (isDate(_value)) {
+            var /** @type {?} */ _isDateValid = isDateValid(_value);
+            if (!_isDateValid) {
+                return { bsDate: { invalid: _value } };
+            }
+            if (this._picker && this._picker.minDate && isBefore(_value, this._picker.minDate, 'date')) {
+                return { bsDate: { minDate: this._picker.minDate } };
+            }
+            if (this._picker && this._picker.maxDate && isAfter(_value, this._picker.maxDate, 'date')) {
+                return { bsDate: { maxDate: this._picker.maxDate } };
+            }
+        }
+    };
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.registerOnValidatorChange = /**
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this._validatorChange = fn;
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.writeValue = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        if (!value) {
+            this._value = null;
+        }
+        else {
+            var /** @type {?} */ _localeKey = this._localeService.currentLocale;
+            var /** @type {?} */ _locale = getLocale(_localeKey);
+            if (!_locale) {
+                throw new Error("Locale \"" + _localeKey + "\" is not defined, please add it with \"defineLocale(...)\"");
+            }
+            this._value = parseDate(value, this._picker._config.dateInputFormat, this._localeService.currentLocale);
+        }
+        this._picker.bsValue = this._value;
+    };
+    /**
+     * @param {?} isDisabled
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.setDisabledState = /**
+     * @param {?} isDisabled
+     * @return {?}
+     */
+    function (isDisabled) {
+        this._picker.isDisabled = isDisabled;
+        if (isDisabled) {
+            this._renderer.setAttribute(this._elRef.nativeElement, 'disabled', 'disabled');
+            return;
+        }
+        this._renderer.removeAttribute(this._elRef.nativeElement, 'disabled');
+    };
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.registerOnChange = /**
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this._onChange = fn;
+    };
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.registerOnTouched = /**
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this._onTouched = fn;
+    };
+    /**
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.onBlur = /**
+     * @return {?}
+     */
+    function () {
+        this._onTouched();
+    };
+    /**
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.hide = /**
+     * @return {?}
+     */
+    function () {
+        this._picker.hide();
+        this._renderer.selectRootElement(this._elRef.nativeElement).blur();
+    };
+    BsDatepickerInputDirective.decorators = [
+        { type: Directive, args: [{
+                    selector: "input[bsDatepicker]",
+                    host: {
+                        '(change)': 'onChange($event)',
+                        '(keyup.esc)': 'hide()',
+                        '(blur)': 'onBlur()'
+                    },
+                    providers: [BS_DATEPICKER_VALUE_ACCESSOR, BS_DATEPICKER_VALIDATOR]
+                },] }
+    ];
+    /** @nocollapse */
+    BsDatepickerInputDirective.ctorParameters = function () { return [
+        { type: BsDatepickerDirective, decorators: [{ type: Host },] },
+        { type: BsLocaleService, },
+        { type: Renderer2, },
+        { type: ElementRef, },
+        { type: ChangeDetectorRef, },
+    ]; };
+    return BsDatepickerInputDirective;
+}());
+export { BsDatepickerInputDirective };
+function BsDatepickerInputDirective_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    BsDatepickerInputDirective.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    BsDatepickerInputDirective.ctorParameters;
+    /** @type {?} */
+    BsDatepickerInputDirective.prototype._onChange;
+    /** @type {?} */
+    BsDatepickerInputDirective.prototype._onTouched;
+    /** @type {?} */
+    BsDatepickerInputDirective.prototype._validatorChange;
+    /** @type {?} */
+    BsDatepickerInputDirective.prototype._value;
+    /** @type {?} */
+    BsDatepickerInputDirective.prototype._picker;
+    /** @type {?} */
+    BsDatepickerInputDirective.prototype._localeService;
+    /** @type {?} */
+    BsDatepickerInputDirective.prototype._renderer;
+    /** @type {?} */
+    BsDatepickerInputDirective.prototype._elRef;
+    /** @type {?} */
+    BsDatepickerInputDirective.prototype.changeDetection;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-datepicker-input.directive.js","sourceRoot":"ng://ngx-bootstrap/datepicker/","sources":["bs-datepicker-input.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Directive,\n  ElementRef,\n  forwardRef,\n  Host,\n  Provider,\n  Renderer2\n} from '@angular/core';\n\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  NG_VALIDATORS,\n  NG_VALUE_ACCESSOR,\n  ValidationErrors,\n  Validator\n} from '@angular/forms';\n\nimport {\n  parseDate,\n  formatDate,\n  getLocale,\n  isAfter,\n  isBefore,\n  isDate,\n  isDateValid\n} from 'ngx-bootstrap/chronos';\n\nimport { BsDatepickerDirective } from './bs-datepicker.component';\nimport { BsLocaleService } from './bs-locale.service';\n\nconst BS_DATEPICKER_VALUE_ACCESSOR: Provider = {\n  provide: NG_VALUE_ACCESSOR,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => BsDatepickerInputDirective),\n  multi: true\n};\n\nconst BS_DATEPICKER_VALIDATOR: Provider = {\n  provide: NG_VALIDATORS,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => BsDatepickerInputDirective),\n  multi: true\n};\n\n@Directive({\n  selector: `input[bsDatepicker]`,\n  host: {\n    '(change)': 'onChange($event)',\n    '(keyup.esc)': 'hide()',\n    '(blur)': 'onBlur()'\n  },\n  providers: [BS_DATEPICKER_VALUE_ACCESSOR, BS_DATEPICKER_VALIDATOR]\n})\nexport class BsDatepickerInputDirective\n  implements ControlValueAccessor, Validator {\n  private _onChange = Function.prototype;\n  private _onTouched = Function.prototype;\n  /* tslint:disable-next-line: no-unused-variable */\n  private _validatorChange = Function.prototype;\n  private _value: Date;\n\n  constructor(@Host() private _picker: BsDatepickerDirective,\n              private _localeService: BsLocaleService,\n              private _renderer: Renderer2,\n              private _elRef: ElementRef,\n              private changeDetection: ChangeDetectorRef) {\n    // update input value on datepicker value update\n    this._picker.bsValueChange.subscribe((value: Date) => {\n      this._setInputValue(value);\n      if (this._value !== value) {\n        this._value = value;\n        this._onChange(value);\n        this._onTouched();\n      }\n      this.changeDetection.markForCheck();\n    });\n\n    // update input value on locale change\n    this._localeService.localeChange.subscribe(() => {\n      this._setInputValue(this._value);\n    });\n  }\n\n  _setInputValue(value: Date): void {\n    const initialDate = !value ? ''\n      : formatDate(value, this._picker._config.dateInputFormat, this._localeService.currentLocale);\n\n    this._renderer.setProperty(this._elRef.nativeElement, 'value', initialDate);\n  }\n\n  onChange(event: Event) {\n    /* tslint:disable-next-line: no-any*/\n    this.writeValue((event.target as any).value);\n    this._onChange(this._value);\n    this._onTouched();\n  }\n\n  validate(c: AbstractControl): ValidationErrors | null {\n    const _value: Date | string = c.value;\n\n    /* tslint:disable-next-line: prefer-switch */\n    if (_value === null || _value === undefined || _value === '') {\n      return null;\n    }\n\n    if (isDate(_value)) {\n      const _isDateValid = isDateValid(_value);\n      if (!_isDateValid) {\n        return { bsDate: { invalid: _value } };\n      }\n\n      if (this._picker && this._picker.minDate && isBefore(_value, this._picker.minDate, 'date')) {\n        return { bsDate: { minDate: this._picker.minDate } };\n      }\n\n      if (this._picker && this._picker.maxDate && isAfter(_value, this._picker.maxDate, 'date')) {\n        return { bsDate: { maxDate: this._picker.maxDate } };\n      }\n    }\n  }\n\n  registerOnValidatorChange(fn: () => void): void {\n    this._validatorChange = fn;\n  }\n\n  writeValue(value: Date | string) {\n    if (!value) {\n      this._value = null;\n    } else {\n      const _localeKey = this._localeService.currentLocale;\n      const _locale = getLocale(_localeKey);\n      if (!_locale) {\n        throw new Error(\n          `Locale \"${_localeKey}\" is not defined, please add it with \"defineLocale(...)\"`\n        );\n      }\n      this._value = parseDate(value, this._picker._config.dateInputFormat, this._localeService.currentLocale);\n    }\n\n    this._picker.bsValue = this._value;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this._picker.isDisabled = isDisabled;\n    if (isDisabled) {\n      this._renderer.setAttribute(this._elRef.nativeElement, 'disabled', 'disabled');\n\n      return;\n    }\n    this._renderer.removeAttribute(this._elRef.nativeElement, 'disabled');\n  }\n\n  registerOnChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this._onTouched = fn;\n  }\n\n  onBlur() {\n    this._onTouched();\n  }\n\n  hide() {\n    this._picker.hide();\n    this._renderer.selectRootElement(this._elRef.nativeElement).blur();\n  }\n}\n"]}