ngx-bootstrap 3.0.1 → 3.1.4

package/datepicker/esm2015/bs-datepicker.config.js

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Injectable } from '@angular/core';
+/**
+ * For date range picker there are `BsDaterangepickerConfig` which inherits all properties,
+ * except `displayMonths`, for range picker it default to `2`
+ */
+export class BsDatepickerConfig {
+    constructor() {
+        /**
+         * CSS class which will be applied to datepicker container,
+         * usually used to set color theme
+         */
+        this.containerClass = 'theme-green';
+        // DatepickerRenderOptions
+        this.displayMonths = 1;
+        /**
+         * Allows to hide week numbers in datepicker
+         */
+        this.showWeekNumbers = true;
+        this.dateInputFormat = 'L';
+        // range picker
+        this.rangeSeparator = ' - ';
+        /**
+         * Date format for date range input field
+         */
+        this.rangeInputFormat = 'L';
+        // DatepickerFormatOptions
+        this.monthTitle = 'MMMM';
+        this.yearTitle = 'YYYY';
+        this.dayLabel = 'D';
+        this.monthLabel = 'MMMM';
+        this.yearLabel = 'YYYY';
+        this.weekNumbers = 'w';
+    }
+}
+BsDatepickerConfig.decorators = [
+    { type: Injectable }
+];
+function BsDatepickerConfig_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    BsDatepickerConfig.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    BsDatepickerConfig.ctorParameters;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.value;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.isDisabled;
+    /**
+     * Default min date for all date/range pickers
+     * @type {?}
+     */
+    BsDatepickerConfig.prototype.minDate;
+    /**
+     * Default max date for all date/range pickers
+     * @type {?}
+     */
+    BsDatepickerConfig.prototype.maxDate;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.daysDisabled;
+    /**
+     * Makes dates from other months active
+     * @type {?}
+     */
+    BsDatepickerConfig.prototype.selectFromOtherMonth;
+    /**
+     * Add class to current day
+     * @type {?}
+     */
+    BsDatepickerConfig.prototype.customTodayClass;
+    /**
+     * Defaut mode for all date pickers
+     * @type {?}
+     */
+    BsDatepickerConfig.prototype.minMode;
+    /**
+     * CSS class which will be applied to datepicker container,
+     * usually used to set color theme
+     * @type {?}
+     */
+    BsDatepickerConfig.prototype.containerClass;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.displayMonths;
+    /**
+     * Allows to hide week numbers in datepicker
+     * @type {?}
+     */
+    BsDatepickerConfig.prototype.showWeekNumbers;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.dateInputFormat;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.rangeSeparator;
+    /**
+     * Date format for date range input field
+     * @type {?}
+     */
+    BsDatepickerConfig.prototype.rangeInputFormat;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.monthTitle;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.yearTitle;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.dayLabel;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.monthLabel;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.yearLabel;
+    /** @type {?} */
+    BsDatepickerConfig.prototype.weekNumbers;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm2015/bs-datepicker.module.js

@@ -0,0 +1,90 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
+import { PositioningService } from 'ngx-bootstrap/positioning';
+import { BsDatepickerInputDirective } from './bs-datepicker-input.directive';
+import { BsDatepickerDirective } from './bs-datepicker.component';
+import { BsDatepickerConfig } from './bs-datepicker.config';
+import { BsDaterangepickerInputDirective } from './bs-daterangepicker-input.directive';
+import { BsDaterangepickerDirective } from './bs-daterangepicker.component';
+import { BsDaterangepickerConfig } from './bs-daterangepicker.config';
+import { BsLocaleService } from './bs-locale.service';
+import { BsDatepickerActions } from './reducer/bs-datepicker.actions';
+import { BsDatepickerEffects } from './reducer/bs-datepicker.effects';
+import { BsDatepickerStore } from './reducer/bs-datepicker.store';
+import { BsCalendarLayoutComponent } from './themes/bs/bs-calendar-layout.component';
+import { BsCurrentDateViewComponent } from './themes/bs/bs-current-date-view.component';
+import { BsCustomDatesViewComponent } from './themes/bs/bs-custom-dates-view.component';
+import { BsDatepickerContainerComponent } from './themes/bs/bs-datepicker-container.component';
+import { BsDatepickerDayDecoratorComponent } from './themes/bs/bs-datepicker-day-decorator.directive';
+import { BsDatepickerNavigationViewComponent } from './themes/bs/bs-datepicker-navigation-view.component';
+import { BsDaterangepickerContainerComponent } from './themes/bs/bs-daterangepicker-container.component';
+import { BsDaysCalendarViewComponent } from './themes/bs/bs-days-calendar-view.component';
+import { BsMonthCalendarViewComponent } from './themes/bs/bs-months-calendar-view.component';
+import { BsTimepickerViewComponent } from './themes/bs/bs-timepicker-view.component';
+import { BsYearsCalendarViewComponent } from './themes/bs/bs-years-calendar-view.component';
+const /** @type {?} */ _exports = [
+    BsDatepickerContainerComponent,
+    BsDaterangepickerContainerComponent,
+    BsDatepickerDirective,
+    BsDatepickerInputDirective,
+    BsDaterangepickerInputDirective,
+    BsDaterangepickerDirective
+];
+export class BsDatepickerModule {
+    /**
+     * @return {?}
+     */
+    static forRoot() {
+        return {
+            ngModule: BsDatepickerModule,
+            providers: [
+                ComponentLoaderFactory,
+                PositioningService,
+                BsDatepickerStore,
+                BsDatepickerActions,
+                BsDatepickerConfig,
+                BsDaterangepickerConfig,
+                BsDatepickerEffects,
+                BsLocaleService
+            ]
+        };
+    }
+}
+BsDatepickerModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [CommonModule],
+                declarations: [
+                    BsDatepickerDayDecoratorComponent,
+                    BsCurrentDateViewComponent,
+                    BsDatepickerNavigationViewComponent,
+                    BsTimepickerViewComponent,
+                    BsCalendarLayoutComponent,
+                    BsDaysCalendarViewComponent,
+                    BsMonthCalendarViewComponent,
+                    BsYearsCalendarViewComponent,
+                    BsCustomDatesViewComponent,
+                    ..._exports
+                ],
+                entryComponents: [
+                    BsDatepickerContainerComponent,
+                    BsDaterangepickerContainerComponent
+                ],
+                exports: _exports
+            },] }
+];
+function BsDatepickerModule_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    BsDatepickerModule.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    BsDatepickerModule.ctorParameters;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm2015/bs-daterangepicker-input.directive.js

@@ -0,0 +1,224 @@
+/**
+ * @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, isArray, isDateValid } from 'ngx-bootstrap/chronos';
+import { BsDaterangepickerDirective } from './bs-daterangepicker.component';
+import { BsLocaleService } from './bs-locale.service';
+const /** @type {?} */ BS_DATERANGEPICKER_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(() => BsDaterangepickerInputDirective),
+    multi: true
+};
+const /** @type {?} */ BS_DATERANGEPICKER_VALIDATOR = {
+    provide: NG_VALIDATORS,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(() => BsDaterangepickerInputDirective),
+    multi: true
+};
+export class BsDaterangepickerInputDirective {
+    /**
+     * @param {?} _picker
+     * @param {?} _localeService
+     * @param {?} _renderer
+     * @param {?} _elRef
+     * @param {?} changeDetection
+     */
+    constructor(_picker, _localeService, _renderer, _elRef, changeDetection) {
+        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((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(() => {
+            this._setInputValue(this._value);
+        });
+    }
+    /**
+     * @param {?} date
+     * @return {?}
+     */
+    _setInputValue(date) {
+        let /** @type {?} */ range = '';
+        if (date) {
+            const /** @type {?} */ start = !date[0] ? ''
+                : formatDate(date[0], this._picker._config.rangeInputFormat, this._localeService.currentLocale);
+            const /** @type {?} */ end = !date[1] ? ''
+                : formatDate(date[1], this._picker._config.rangeInputFormat, this._localeService.currentLocale);
+            range = (start && end) ? start + this._picker._config.rangeSeparator + end : '';
+        }
+        this._renderer.setProperty(this._elRef.nativeElement, 'value', range);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onChange(event) {
+        /* tslint:disable-next-line: no-any*/
+        this.writeValue((/** @type {?} */ (event.target)).value);
+        this._onChange(this._value);
+        this._onTouched();
+    }
+    /**
+     * @param {?} c
+     * @return {?}
+     */
+    validate(c) {
+        const /** @type {?} */ _value = c.value;
+        if (_value === null || _value === undefined || !isArray(_value)) {
+            return null;
+        }
+        const /** @type {?} */ _isFirstDateValid = isDateValid(_value[0]);
+        const /** @type {?} */ _isSecondDateValid = isDateValid(_value[1]);
+        if (!_isFirstDateValid) {
+            return { bsDate: { invalid: _value[0] } };
+        }
+        if (!_isSecondDateValid) {
+            return { bsDate: { invalid: _value[1] } };
+        }
+        if (this._picker && this._picker.minDate && isBefore(_value[0], this._picker.minDate, 'date')) {
+            return { bsDate: { minDate: this._picker.minDate } };
+        }
+        if (this._picker && this._picker.maxDate && isAfter(_value[1], this._picker.maxDate, 'date')) {
+            return { bsDate: { maxDate: this._picker.maxDate } };
+        }
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    registerOnValidatorChange(fn) {
+        this._validatorChange = fn;
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    writeValue(value) {
+        if (!value) {
+            this._value = null;
+        }
+        else {
+            const /** @type {?} */ _localeKey = this._localeService.currentLocale;
+            const /** @type {?} */ _locale = getLocale(_localeKey);
+            if (!_locale) {
+                throw new Error(`Locale "${_localeKey}" is not defined, please add it with "defineLocale(...)"`);
+            }
+            let /** @type {?} */ _input = [];
+            if (typeof value === 'string') {
+                _input = value.split(this._picker._config.rangeSeparator);
+            }
+            if (Array.isArray(value)) {
+                _input = value;
+            }
+            this._value = (/** @type {?} */ (_input))
+                .map((_val) => parseDate(_val, this._picker._config.dateInputFormat, this._localeService.currentLocale))
+                .map((date) => (isNaN(date.valueOf()) ? null : date));
+        }
+        this._picker.bsValue = this._value;
+    }
+    /**
+     * @param {?} isDisabled
+     * @return {?}
+     */
+    setDisabledState(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 {?}
+     */
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    /**
+     * @return {?}
+     */
+    onBlur() {
+        this._onTouched();
+    }
+    /**
+     * @return {?}
+     */
+    hide() {
+        this._picker.hide();
+        this._renderer.selectRootElement(this._elRef.nativeElement).blur();
+    }
+}
+BsDaterangepickerInputDirective.decorators = [
+    { type: Directive, args: [{
+                selector: `input[bsDaterangepicker]`,
+                host: {
+                    '(change)': 'onChange($event)',
+                    '(keyup.esc)': 'hide()',
+                    '(blur)': 'onBlur()'
+                },
+                providers: [BS_DATERANGEPICKER_VALUE_ACCESSOR, BS_DATERANGEPICKER_VALIDATOR]
+            },] }
+];
+/** @nocollapse */
+BsDaterangepickerInputDirective.ctorParameters = () => [
+    { type: BsDaterangepickerDirective, decorators: [{ type: Host },] },
+    { type: BsLocaleService, },
+    { type: Renderer2, },
+    { type: ElementRef, },
+    { type: ChangeDetectorRef, },
+];
+function BsDaterangepickerInputDirective_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    BsDaterangepickerInputDirective.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    BsDaterangepickerInputDirective.ctorParameters;
+    /** @type {?} */
+    BsDaterangepickerInputDirective.prototype._onChange;
+    /** @type {?} */
+    BsDaterangepickerInputDirective.prototype._onTouched;
+    /** @type {?} */
+    BsDaterangepickerInputDirective.prototype._validatorChange;
+    /** @type {?} */
+    BsDaterangepickerInputDirective.prototype._value;
+    /** @type {?} */
+    BsDaterangepickerInputDirective.prototype._picker;
+    /** @type {?} */
+    BsDaterangepickerInputDirective.prototype._localeService;
+    /** @type {?} */
+    BsDaterangepickerInputDirective.prototype._renderer;
+    /** @type {?} */
+    BsDaterangepickerInputDirective.prototype._elRef;
+    /** @type {?} */
+    BsDaterangepickerInputDirective.prototype.changeDetection;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-daterangepicker-input.directive.js","sourceRoot":"ng://ngx-bootstrap/datepicker/","sources":["bs-daterangepicker-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';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  NG_VALIDATORS,\n  NG_VALUE_ACCESSOR,\n  ValidationErrors,\n  Validator\n} from '@angular/forms';\nimport { parseDate, formatDate, getLocale, isAfter, isBefore, isArray, isDateValid } from 'ngx-bootstrap/chronos';\nimport { BsDaterangepickerDirective } from './bs-daterangepicker.component';\nimport { BsLocaleService } from './bs-locale.service';\n\nconst BS_DATERANGEPICKER_VALUE_ACCESSOR: Provider = {\n  provide: NG_VALUE_ACCESSOR,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => BsDaterangepickerInputDirective),\n  multi: true\n};\n\nconst BS_DATERANGEPICKER_VALIDATOR: Provider = {\n  provide: NG_VALIDATORS,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => BsDaterangepickerInputDirective),\n  multi: true\n};\n\n\n@Directive({\n  selector: `input[bsDaterangepicker]`,\n  host: {\n    '(change)': 'onChange($event)',\n    '(keyup.esc)': 'hide()',\n    '(blur)': 'onBlur()'\n  },\n  providers: [BS_DATERANGEPICKER_VALUE_ACCESSOR, BS_DATERANGEPICKER_VALIDATOR]\n})\nexport class BsDaterangepickerInputDirective\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: BsDaterangepickerDirective,\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(date: Date[]): void {\n    let range = '';\n    if (date) {\n      const start: string = !date[0] ? ''\n        : formatDate(date[0],\n          this._picker._config.rangeInputFormat,\n          this._localeService.currentLocale\n        );\n      const end: string = !date[1] ? ''\n        : formatDate(\n          date[1],\n          this._picker._config.rangeInputFormat,\n          this._localeService.currentLocale\n        );\n      range = (start && end) ? start + this._picker._config.rangeSeparator + end : '';\n    }\n    this._renderer.setProperty(this._elRef.nativeElement, 'value', range);\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, Date] = c.value;\n\n    if (_value === null || _value === undefined || !isArray(_value)) {\n      return null;\n    }\n\n    const _isFirstDateValid = isDateValid(_value[0]);\n    const _isSecondDateValid = isDateValid(_value[1]);\n\n    if (!_isFirstDateValid) {\n      return { bsDate: { invalid: _value[0] } };\n    }\n\n    if (!_isSecondDateValid) {\n      return { bsDate: { invalid: _value[1] } };\n    }\n\n    if (this._picker && this._picker.minDate && isBefore(_value[0], this._picker.minDate, 'date')) {\n      return { bsDate: { minDate: this._picker.minDate } };\n    }\n\n    if (this._picker && this._picker.maxDate && isAfter(_value[1], this._picker.maxDate, 'date')) {\n      return { bsDate: { maxDate: this._picker.maxDate } };\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\n      let _input: (string[] | Date[]) = [];\n      if (typeof value === 'string') {\n        _input = value.split(this._picker._config.rangeSeparator);\n      }\n\n      if (Array.isArray(value)) {\n        _input = value;\n      }\n\n\n      this._value = (_input as string[])\n        .map((_val: string): Date =>\n          parseDate(_val, this._picker._config.dateInputFormat, this._localeService.currentLocale))\n        .map((date: Date) => (isNaN(date.valueOf()) ? null : date));\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  /* tslint:disable-next-line: no-any*/\n  registerOnChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n\n  /* tslint:disable-next-line: no-any*/\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"]}