ngx-bootstrap 3.0.1 → 3.1.4

package/datepicker/esm5/daypicker.component.js

@@ -0,0 +1,157 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Component } from '@angular/core';
+import { isBs3 } from 'ngx-bootstrap/utils';
+import { DatePickerInnerComponent } from './datepicker-inner.component';
+var DayPickerComponent = /** @class */ (function () {
+    function DayPickerComponent(datePicker) {
+        this.labels = [];
+        this.rows = [];
+        this.weekNumbers = [];
+        this.datePicker = datePicker;
+    }
+    Object.defineProperty(DayPickerComponent.prototype, "isBs4", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return !isBs3();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /*protected getDaysInMonth(year:number, month:number) {
+     return ((month === 1) && (year % 4 === 0) &&
+     ((year % 100 !== 0) || (year % 400 === 0))) ? 29 : DAYS_IN_MONTH[month];
+     }*/
+    /**
+     * @return {?}
+     */
+    DayPickerComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var /** @type {?} */ self = this;
+        this.datePicker.stepDay = { months: 1 };
+        this.datePicker.setRefreshViewHandler(function () {
+            var /** @type {?} */ year = this.activeDate.getFullYear();
+            var /** @type {?} */ month = this.activeDate.getMonth();
+            var /** @type {?} */ firstDayOfMonth = new Date(year, month, 1);
+            var /** @type {?} */ difference = this.startingDay - firstDayOfMonth.getDay();
+            var /** @type {?} */ numDisplayedFromPreviousMonth = difference > 0 ? 7 - difference : -difference;
+            var /** @type {?} */ firstDate = new Date(firstDayOfMonth.getTime());
+            if (numDisplayedFromPreviousMonth > 0) {
+                firstDate.setDate(-numDisplayedFromPreviousMonth + 1);
+            }
+            // 42 is the number of days on a six-week calendar
+            var /** @type {?} */ _days = self.getDates(firstDate, 42);
+            var /** @type {?} */ days = [];
+            for (var /** @type {?} */ i = 0; i < 42; i++) {
+                var /** @type {?} */ _dateObject = this.createDateObject(_days[i], this.formatDay);
+                _dateObject.secondary = _days[i].getMonth() !== month;
+                _dateObject.uid = this.uniqueId + '-' + i;
+                days[i] = _dateObject;
+            }
+            self.labels = [];
+            for (var /** @type {?} */ j = 0; j < 7; j++) {
+                self.labels[j] = {};
+                self.labels[j].abbr = this.dateFilter(days[j].date, this.formatDayHeader);
+                self.labels[j].full = this.dateFilter(days[j].date, 'EEEE');
+            }
+            self.title = this.dateFilter(this.activeDate, this.formatDayTitle);
+            self.rows = this.split(days, 7);
+            if (this.showWeeks) {
+                self.weekNumbers = [];
+                var /** @type {?} */ thursdayIndex = (4 + 7 - this.startingDay) % 7;
+                var /** @type {?} */ numWeeks = self.rows.length;
+                for (var /** @type {?} */ curWeek = 0; curWeek < numWeeks; curWeek++) {
+                    self.weekNumbers.push(self.getISO8601WeekNumber(self.rows[curWeek][thursdayIndex].date));
+                }
+            }
+        }, 'day');
+        this.datePicker.setCompareHandler(function (date1, date2) {
+            var /** @type {?} */ d1 = new Date(date1.getFullYear(), date1.getMonth(), date1.getDate());
+            var /** @type {?} */ d2 = new Date(date2.getFullYear(), date2.getMonth(), date2.getDate());
+            return d1.getTime() - d2.getTime();
+        }, 'day');
+        this.datePicker.refreshView();
+    };
+    /**
+     * @param {?} startDate
+     * @param {?} n
+     * @return {?}
+     */
+    DayPickerComponent.prototype.getDates = /**
+     * @param {?} startDate
+     * @param {?} n
+     * @return {?}
+     */
+    function (startDate, n) {
+        var /** @type {?} */ dates = new Array(n);
+        var /** @type {?} */ current = new Date(startDate.getTime());
+        var /** @type {?} */ i = 0;
+        var /** @type {?} */ date;
+        while (i < n) {
+            date = new Date(current.getTime());
+            date = this.datePicker.fixTimeZone(date);
+            dates[i++] = date;
+            current = new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1);
+        }
+        return dates;
+    };
+    /**
+     * @param {?} date
+     * @return {?}
+     */
+    DayPickerComponent.prototype.getISO8601WeekNumber = /**
+     * @param {?} date
+     * @return {?}
+     */
+    function (date) {
+        var /** @type {?} */ checkDate = new Date(date.getTime());
+        // Thursday
+        checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
+        var /** @type {?} */ time = checkDate.getTime();
+        // Compare with Jan 1
+        checkDate.setMonth(0);
+        checkDate.setDate(1);
+        return (Math.floor(Math.round((time - checkDate.getTime()) / 86400000) / 7) + 1);
+    };
+    DayPickerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'daypicker',
+                    template: "\n<table *ngIf=\"datePicker.datepickerMode === 'day'\" role=\"grid\" [attr.aria-labelledby]=\"datePicker.uniqueId + '-title'\" aria-activedescendant=\"activeDateId\">\n  <thead>\n    <tr>\n      <th>\n        <button *ngIf=\"!isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\"\n                tabindex=\"-1\">\u2039</button>\n        <button *ngIf=\"isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\"\n                tabindex=\"-1\">&lt;</button>\n      </th>\n      <th [attr.colspan]=\"5 + (datePicker.showWeeks ? 1 : 0)\">\n        <button [id]=\"datePicker.uniqueId + '-title'\"\n                type=\"button\" class=\"btn btn-default btn-secondary btn-sm\"\n                (click)=\"datePicker.toggleMode(0)\"\n                [disabled]=\"datePicker.datepickerMode === datePicker.maxMode\"\n                [ngClass]=\"{disabled: datePicker.datepickerMode === datePicker.maxMode}\" tabindex=\"-1\" style=\"width:100%;\">\n          <strong>{{ title }}</strong>\n        </button>\n      </th>\n      <th>\n        <button *ngIf=\"!isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\"\n                tabindex=\"-1\">\u203A</button>\n        <button *ngIf=\"isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\"\n                tabindex=\"-1\">&gt;\n        </button>\n      </th>\n    </tr>\n    <tr>\n      <th *ngIf=\"datePicker.showWeeks\"></th>\n      <th *ngFor=\"let labelz of labels\" class=\"text-center\">\n        <small aria-label=\"labelz.full\"><b>{{ labelz.abbr }}</b></small>\n      </th>\n    </tr>\n  </thead>\n  <tbody>\n    <ng-template ngFor [ngForOf]=\"rows\" let-rowz=\"$implicit\" let-index=\"index\">\n      <tr *ngIf=\"!(datePicker.onlyCurrentMonth && rowz[0].secondary && rowz[6].secondary)\">\n        <td *ngIf=\"datePicker.showWeeks\" class=\"h6\" class=\"text-center\">\n          <em>{{ weekNumbers[index] }}</em>\n        </td>\n        <td *ngFor=\"let dtz of rowz\" class=\"text-center\" role=\"gridcell\" [id]=\"dtz.uid\">\n          <button type=\"button\" style=\"min-width:100%;\" class=\"btn btn-sm {{dtz.customClass}}\"\n                  *ngIf=\"!(datePicker.onlyCurrentMonth && dtz.secondary)\"\n                  [ngClass]=\"{'btn-secondary': isBs4 && !dtz.selected && !datePicker.isActive(dtz), 'btn-info': dtz.selected, disabled: dtz.disabled, active: !isBs4 && datePicker.isActive(dtz), 'btn-default': !isBs4}\"\n                  [disabled]=\"dtz.disabled\"\n                  (click)=\"datePicker.select(dtz.date)\" tabindex=\"-1\">\n            <span [ngClass]=\"{'text-muted': dtz.secondary || dtz.current, 'text-info': !isBs4 && dtz.current}\">{{ dtz.label }}</span>\n          </button>\n        </td>\n      </tr>\n    </ng-template>\n  </tbody>\n</table>\n  ",
+                    styles: ["\n    :host .btn-secondary {\n      color: #292b2c;\n      background-color: #fff;\n      border-color: #ccc;\n    }\n    :host .btn-info .text-muted {\n      color: #292b2c !important;\n    }\n  "]
+                }] }
+    ];
+    // todo: key events implementation
+    /** @nocollapse */
+    DayPickerComponent.ctorParameters = function () { return [
+        { type: DatePickerInnerComponent, },
+    ]; };
+    return DayPickerComponent;
+}());
+export { DayPickerComponent };
+function DayPickerComponent_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    DayPickerComponent.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    DayPickerComponent.ctorParameters;
+    /** @type {?} */
+    DayPickerComponent.prototype.labels;
+    /** @type {?} */
+    DayPickerComponent.prototype.title;
+    /** @type {?} */
+    DayPickerComponent.prototype.rows;
+    /** @type {?} */
+    DayPickerComponent.prototype.weekNumbers;
+    /** @type {?} */
+    DayPickerComponent.prototype.datePicker;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daypicker.component.js","sourceRoot":"ng://ngx-bootstrap/datepicker/","sources":["daypicker.component.ts"],"names":[],"mappings":"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","sourcesContent":["// @deprecated\n// tslint:disable\nimport { Component, OnInit } from '@angular/core';\nimport { isBs3 } from 'ngx-bootstrap/utils';\nimport { DatePickerInnerComponent } from './datepicker-inner.component';\n\n@Component({\n  selector: 'daypicker',\n  template: `\n<table *ngIf=\"datePicker.datepickerMode === 'day'\" role=\"grid\" [attr.aria-labelledby]=\"datePicker.uniqueId + '-title'\" aria-activedescendant=\"activeDateId\">\n  <thead>\n    <tr>\n      <th>\n        <button *ngIf=\"!isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\"\n                tabindex=\"-1\">‹</button>\n        <button *ngIf=\"isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\"\n                tabindex=\"-1\">&lt;</button>\n      </th>\n      <th [attr.colspan]=\"5 + (datePicker.showWeeks ? 1 : 0)\">\n        <button [id]=\"datePicker.uniqueId + '-title'\"\n                type=\"button\" class=\"btn btn-default btn-secondary btn-sm\"\n                (click)=\"datePicker.toggleMode(0)\"\n                [disabled]=\"datePicker.datepickerMode === datePicker.maxMode\"\n                [ngClass]=\"{disabled: datePicker.datepickerMode === datePicker.maxMode}\" tabindex=\"-1\" style=\"width:100%;\">\n          <strong>{{ title }}</strong>\n        </button>\n      </th>\n      <th>\n        <button *ngIf=\"!isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\"\n                tabindex=\"-1\">›</button>\n        <button *ngIf=\"isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\"\n                tabindex=\"-1\">&gt;\n        </button>\n      </th>\n    </tr>\n    <tr>\n      <th *ngIf=\"datePicker.showWeeks\"></th>\n      <th *ngFor=\"let labelz of labels\" class=\"text-center\">\n        <small aria-label=\"labelz.full\"><b>{{ labelz.abbr }}</b></small>\n      </th>\n    </tr>\n  </thead>\n  <tbody>\n    <ng-template ngFor [ngForOf]=\"rows\" let-rowz=\"$implicit\" let-index=\"index\">\n      <tr *ngIf=\"!(datePicker.onlyCurrentMonth && rowz[0].secondary && rowz[6].secondary)\">\n        <td *ngIf=\"datePicker.showWeeks\" class=\"h6\" class=\"text-center\">\n          <em>{{ weekNumbers[index] }}</em>\n        </td>\n        <td *ngFor=\"let dtz of rowz\" class=\"text-center\" role=\"gridcell\" [id]=\"dtz.uid\">\n          <button type=\"button\" style=\"min-width:100%;\" class=\"btn btn-sm {{dtz.customClass}}\"\n                  *ngIf=\"!(datePicker.onlyCurrentMonth && dtz.secondary)\"\n                  [ngClass]=\"{'btn-secondary': isBs4 && !dtz.selected && !datePicker.isActive(dtz), 'btn-info': dtz.selected, disabled: dtz.disabled, active: !isBs4 && datePicker.isActive(dtz), 'btn-default': !isBs4}\"\n                  [disabled]=\"dtz.disabled\"\n                  (click)=\"datePicker.select(dtz.date)\" tabindex=\"-1\">\n            <span [ngClass]=\"{'text-muted': dtz.secondary || dtz.current, 'text-info': !isBs4 && dtz.current}\">{{ dtz.label }}</span>\n          </button>\n        </td>\n      </tr>\n    </ng-template>\n  </tbody>\n</table>\n  `,\n  styles: [\n    `\n    :host .btn-secondary {\n      color: #292b2c;\n      background-color: #fff;\n      border-color: #ccc;\n    }\n    :host .btn-info .text-muted {\n      color: #292b2c !important;\n    }\n  `\n  ]\n})\nexport class DayPickerComponent implements OnInit {\n  labels: any[] = [];\n  title: string;\n  rows: any[] = [];\n  weekNumbers: number[] = [];\n  datePicker: DatePickerInnerComponent;\n\n  constructor(datePicker: DatePickerInnerComponent) {\n    this.datePicker = datePicker;\n  }\n\n  get isBs4(): boolean {\n    return !isBs3();\n  }\n\n  /*protected getDaysInMonth(year:number, month:number) {\n   return ((month === 1) && (year % 4 === 0) &&\n   ((year % 100 !== 0) || (year % 400 === 0))) ? 29 : DAYS_IN_MONTH[month];\n   }*/\n  ngOnInit(): void {\n    const self = this;\n\n    this.datePicker.stepDay = { months: 1 };\n\n    this.datePicker.setRefreshViewHandler(function(): void {\n      const year = this.activeDate.getFullYear();\n      const month = this.activeDate.getMonth();\n      const firstDayOfMonth = new Date(year, month, 1);\n      const difference = this.startingDay - firstDayOfMonth.getDay();\n      const numDisplayedFromPreviousMonth =\n        difference > 0 ? 7 - difference : -difference;\n      const firstDate = new Date(firstDayOfMonth.getTime());\n\n      if (numDisplayedFromPreviousMonth > 0) {\n        firstDate.setDate(-numDisplayedFromPreviousMonth + 1);\n      }\n\n      // 42 is the number of days on a six-week calendar\n      const _days: Date[] = self.getDates(firstDate, 42);\n      const days: any[] = [];\n      for (let i = 0; i < 42; i++) {\n        const _dateObject = this.createDateObject(_days[i], this.formatDay);\n        _dateObject.secondary = _days[i].getMonth() !== month;\n        _dateObject.uid = this.uniqueId + '-' + i;\n        days[i] = _dateObject;\n      }\n\n      self.labels = [];\n      for (let j = 0; j < 7; j++) {\n        self.labels[j] = {};\n        self.labels[j].abbr = this.dateFilter(\n          days[j].date,\n          this.formatDayHeader\n        );\n        self.labels[j].full = this.dateFilter(days[j].date, 'EEEE');\n      }\n\n      self.title = this.dateFilter(this.activeDate, this.formatDayTitle);\n      self.rows = this.split(days, 7);\n\n      if (this.showWeeks) {\n        self.weekNumbers = [];\n        const thursdayIndex = (4 + 7 - this.startingDay) % 7;\n        const numWeeks = self.rows.length;\n        for (let curWeek = 0; curWeek < numWeeks; curWeek++) {\n          self.weekNumbers.push(\n            self.getISO8601WeekNumber(self.rows[curWeek][thursdayIndex].date)\n          );\n        }\n      }\n    }, 'day');\n\n    this.datePicker.setCompareHandler(function(\n      date1: Date,\n      date2: Date\n    ): number {\n      const d1 = new Date(date1.getFullYear(), date1.getMonth(), date1.getDate());\n      const d2 = new Date(date2.getFullYear(), date2.getMonth(), date2.getDate());\n      return d1.getTime() - d2.getTime();\n    }, 'day');\n\n    this.datePicker.refreshView();\n  }\n\n  protected getDates(startDate: Date, n: number): Date[] {\n    const dates: Date[] = new Array(n);\n    let current = new Date(startDate.getTime());\n    let i = 0;\n    let date: Date;\n    while (i < n) {\n      date = new Date(current.getTime());\n      date = this.datePicker.fixTimeZone(date);\n      dates[i++] = date;\n      current = new Date(\n        date.getFullYear(),\n        date.getMonth(),\n        date.getDate() + 1\n      );\n    }\n    return dates;\n  }\n\n  protected getISO8601WeekNumber(date: Date): number {\n    const checkDate = new Date(date.getTime());\n    // Thursday\n    checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));\n    const time = checkDate.getTime();\n    // Compare with Jan 1\n    checkDate.setMonth(0);\n    checkDate.setDate(1);\n    return (\n      Math.floor(Math.round((time - checkDate.getTime()) / 86400000) / 7) + 1\n    );\n  }\n\n  // todo: key events implementation\n}\n"]}

package/datepicker/esm5/engine/calc-days-calendar.js

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { getFirstDayOfMonth } from 'ngx-bootstrap/chronos';
+import { getStartingDayOfCalendar } from '../utils/bs-calendar-utils';
+import { createMatrix } from '../utils/matrix-utils';
+/**
+ * @param {?} startingDate
+ * @param {?} options
+ * @return {?}
+ */
+export function calcDaysCalendar(startingDate, options) {
+    var /** @type {?} */ firstDay = getFirstDayOfMonth(startingDate);
+    var /** @type {?} */ initialDate = getStartingDayOfCalendar(firstDay, options);
+    var /** @type {?} */ matrixOptions = {
+        width: options.width,
+        height: options.height,
+        initialDate: initialDate,
+        shift: { day: 1 }
+    };
+    var /** @type {?} */ daysMatrix = createMatrix(matrixOptions, function (date) { return date; });
+    return {
+        daysMatrix: daysMatrix,
+        month: firstDay
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm5/engine/flag-days-calendar.js

@@ -0,0 +1,115 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { isAfter, isBefore, isDisabledDay, isSameDay, isSameMonth, shiftDate } from 'ngx-bootstrap/chronos';
+import { isMonthDisabled } from '../utils/bs-calendar-utils';
+/**
+ * @record
+ */
+export function FlagDaysCalendarOptions() { }
+function FlagDaysCalendarOptions_tsickle_Closure_declarations() {
+    /** @type {?} */
+    FlagDaysCalendarOptions.prototype.isDisabled;
+    /** @type {?} */
+    FlagDaysCalendarOptions.prototype.minDate;
+    /** @type {?} */
+    FlagDaysCalendarOptions.prototype.maxDate;
+    /** @type {?} */
+    FlagDaysCalendarOptions.prototype.daysDisabled;
+    /** @type {?} */
+    FlagDaysCalendarOptions.prototype.hoveredDate;
+    /** @type {?} */
+    FlagDaysCalendarOptions.prototype.selectedDate;
+    /** @type {?} */
+    FlagDaysCalendarOptions.prototype.selectedRange;
+    /** @type {?} */
+    FlagDaysCalendarOptions.prototype.displayMonths;
+    /** @type {?} */
+    FlagDaysCalendarOptions.prototype.monthIndex;
+}
+/**
+ * @param {?} formattedMonth
+ * @param {?} options
+ * @return {?}
+ */
+export function flagDaysCalendar(formattedMonth, options) {
+    formattedMonth.weeks.forEach(function (week) {
+        /* tslint:disable-next-line: cyclomatic-complexity */
+        week.days.forEach(function (day, dayIndex) {
+            // datepicker
+            var /** @type {?} */ isOtherMonth = !isSameMonth(day.date, formattedMonth.month);
+            var /** @type {?} */ isHovered = !isOtherMonth && isSameDay(day.date, options.hoveredDate);
+            // date range picker
+            var /** @type {?} */ isSelectionStart = !isOtherMonth &&
+                options.selectedRange &&
+                isSameDay(day.date, options.selectedRange[0]);
+            var /** @type {?} */ isSelectionEnd = !isOtherMonth &&
+                options.selectedRange &&
+                isSameDay(day.date, options.selectedRange[1]);
+            var /** @type {?} */ isSelected = (!isOtherMonth && isSameDay(day.date, options.selectedDate)) ||
+                isSelectionStart ||
+                isSelectionEnd;
+            var /** @type {?} */ isInRange = !isOtherMonth &&
+                options.selectedRange &&
+                isDateInRange(day.date, options.selectedRange, options.hoveredDate);
+            var /** @type {?} */ isDisabled = options.isDisabled ||
+                isBefore(day.date, options.minDate, 'day') ||
+                isAfter(day.date, options.maxDate, 'day') ||
+                isDisabledDay(day.date, options.daysDisabled);
+            var /** @type {?} */ currentDate = new Date();
+            var /** @type {?} */ isToday = !isOtherMonth && isSameDay(day.date, currentDate);
+            // decide update or not
+            var /** @type {?} */ newDay = Object.assign({}, day, {
+                isOtherMonth: isOtherMonth,
+                isHovered: isHovered,
+                isSelected: isSelected,
+                isSelectionStart: isSelectionStart,
+                isSelectionEnd: isSelectionEnd,
+                isInRange: isInRange,
+                isDisabled: isDisabled,
+                isToday: isToday
+            });
+            if (day.isOtherMonth !== newDay.isOtherMonth ||
+                day.isHovered !== newDay.isHovered ||
+                day.isSelected !== newDay.isSelected ||
+                day.isSelectionStart !== newDay.isSelectionStart ||
+                day.isSelectionEnd !== newDay.isSelectionEnd ||
+                day.isDisabled !== newDay.isDisabled ||
+                day.isInRange !== newDay.isInRange) {
+                week.days[dayIndex] = newDay;
+            }
+        });
+    });
+    // todo: add check for linked calendars
+    formattedMonth.hideLeftArrow =
+        options.isDisabled ||
+            (options.monthIndex > 0 && options.monthIndex !== options.displayMonths);
+    formattedMonth.hideRightArrow =
+        options.isDisabled ||
+            (options.monthIndex < options.displayMonths &&
+                options.monthIndex + 1 !== options.displayMonths);
+    formattedMonth.disableLeftArrow = isMonthDisabled(shiftDate(formattedMonth.month, { month: -1 }), options.minDate, options.maxDate);
+    formattedMonth.disableRightArrow = isMonthDisabled(shiftDate(formattedMonth.month, { month: 1 }), options.minDate, options.maxDate);
+    return formattedMonth;
+}
+/**
+ * @param {?} date
+ * @param {?} selectedRange
+ * @param {?} hoveredDate
+ * @return {?}
+ */
+function isDateInRange(date, selectedRange, hoveredDate) {
+    if (!date || !selectedRange[0]) {
+        return false;
+    }
+    if (selectedRange[1]) {
+        return date > selectedRange[0] && date <= selectedRange[1];
+    }
+    if (hoveredDate) {
+        return date > selectedRange[0] && date <= hoveredDate;
+    }
+    return false;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flag-days-calendar.js","sourceRoot":"ng://ngx-bootstrap/datepicker/","sources":["engine/flag-days-calendar.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DaysCalendarViewModel,\n  DayViewModel,\n  WeekViewModel\n} from '../models';\n\nimport {\n  isAfter,\n  isBefore,\n  isDisabledDay,\n  isSameDay,\n  isSameMonth,\n  shiftDate\n} from 'ngx-bootstrap/chronos';\n\nimport { isMonthDisabled } from '../utils/bs-calendar-utils';\n\nexport interface FlagDaysCalendarOptions {\n  isDisabled: boolean;\n  minDate: Date;\n  maxDate: Date;\n  daysDisabled: number[];\n  hoveredDate: Date;\n  selectedDate: Date;\n  selectedRange: Date[];\n  displayMonths: number;\n  monthIndex: number;\n}\n\nexport function flagDaysCalendar(\n  formattedMonth: DaysCalendarViewModel,\n  options: FlagDaysCalendarOptions\n): DaysCalendarViewModel {\n  formattedMonth.weeks.forEach((week: WeekViewModel) => {\n    /* tslint:disable-next-line: cyclomatic-complexity */\n    week.days.forEach((day: DayViewModel, dayIndex: number) => {\n      // datepicker\n      const isOtherMonth = !isSameMonth(day.date, formattedMonth.month);\n\n      const isHovered =\n        !isOtherMonth && isSameDay(day.date, options.hoveredDate);\n      // date range picker\n      const isSelectionStart =\n        !isOtherMonth &&\n        options.selectedRange &&\n        isSameDay(day.date, options.selectedRange[0]);\n      const isSelectionEnd =\n        !isOtherMonth &&\n        options.selectedRange &&\n        isSameDay(day.date, options.selectedRange[1]);\n\n      const isSelected =\n        (!isOtherMonth && isSameDay(day.date, options.selectedDate)) ||\n        isSelectionStart ||\n        isSelectionEnd;\n\n      const isInRange =\n        !isOtherMonth &&\n        options.selectedRange &&\n        isDateInRange(day.date, options.selectedRange, options.hoveredDate);\n\n      const isDisabled =\n        options.isDisabled ||\n        isBefore(day.date, options.minDate, 'day') ||\n        isAfter(day.date, options.maxDate, 'day') ||\n        isDisabledDay(day.date, options.daysDisabled);\n\n      const currentDate = new Date();\n      const isToday = !isOtherMonth && isSameDay(day.date, currentDate);\n\n      // decide update or not\n      const newDay = Object.assign({}, day, {\n        isOtherMonth,\n        isHovered,\n        isSelected,\n        isSelectionStart,\n        isSelectionEnd,\n        isInRange,\n        isDisabled,\n        isToday\n      });\n\n      if (\n        day.isOtherMonth !== newDay.isOtherMonth ||\n        day.isHovered !== newDay.isHovered ||\n        day.isSelected !== newDay.isSelected ||\n        day.isSelectionStart !== newDay.isSelectionStart ||\n        day.isSelectionEnd !== newDay.isSelectionEnd ||\n        day.isDisabled !== newDay.isDisabled ||\n        day.isInRange !== newDay.isInRange\n      ) {\n        week.days[dayIndex] = newDay;\n      }\n    });\n  });\n\n  // todo: add check for linked calendars\n  formattedMonth.hideLeftArrow =\n    options.isDisabled ||\n    (options.monthIndex > 0 && options.monthIndex !== options.displayMonths);\n  formattedMonth.hideRightArrow =\n    options.isDisabled ||\n    (options.monthIndex < options.displayMonths &&\n      options.monthIndex + 1 !== options.displayMonths);\n\n  formattedMonth.disableLeftArrow = isMonthDisabled(\n    shiftDate(formattedMonth.month, { month: -1 }),\n    options.minDate,\n    options.maxDate\n  );\n  formattedMonth.disableRightArrow = isMonthDisabled(\n    shiftDate(formattedMonth.month, { month: 1 }),\n    options.minDate,\n    options.maxDate\n  );\n\n  return formattedMonth;\n}\n\nfunction isDateInRange(\n  date: Date,\n  selectedRange: Date[],\n  hoveredDate: Date\n): boolean {\n  if (!date || !selectedRange[0]) {\n    return false;\n  }\n\n  if (selectedRange[1]) {\n    return date > selectedRange[0] && date <= selectedRange[1];\n  }\n\n  if (hoveredDate) {\n    return date > selectedRange[0] && date <= hoveredDate;\n  }\n\n  return false;\n}\n"]}

package/datepicker/esm5/engine/flag-months-calendar.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { isSameMonth, shiftDate } from 'ngx-bootstrap/chronos';
+import { isMonthDisabled, isYearDisabled } from '../utils/bs-calendar-utils';
+/**
+ * @record
+ */
+export function FlagMonthCalendarOptions() { }
+function FlagMonthCalendarOptions_tsickle_Closure_declarations() {
+    /** @type {?} */
+    FlagMonthCalendarOptions.prototype.isDisabled;
+    /** @type {?} */
+    FlagMonthCalendarOptions.prototype.minDate;
+    /** @type {?} */
+    FlagMonthCalendarOptions.prototype.maxDate;
+    /** @type {?} */
+    FlagMonthCalendarOptions.prototype.hoveredMonth;
+    /** @type {?} */
+    FlagMonthCalendarOptions.prototype.displayMonths;
+    /** @type {?} */
+    FlagMonthCalendarOptions.prototype.monthIndex;
+}
+/**
+ * @param {?} monthCalendar
+ * @param {?} options
+ * @return {?}
+ */
+export function flagMonthsCalendar(monthCalendar, options) {
+    monthCalendar.months.forEach(function (months, rowIndex) {
+        months.forEach(function (month, monthIndex) {
+            var /** @type {?} */ isHovered = isSameMonth(month.date, options.hoveredMonth);
+            var /** @type {?} */ isDisabled = options.isDisabled ||
+                isMonthDisabled(month.date, options.minDate, options.maxDate);
+            var /** @type {?} */ newMonth = Object.assign(/*{},*/ month, {
+                isHovered: isHovered,
+                isDisabled: isDisabled
+            });
+            if (month.isHovered !== newMonth.isHovered ||
+                month.isDisabled !== newMonth.isDisabled) {
+                monthCalendar.months[rowIndex][monthIndex] = newMonth;
+            }
+        });
+    });
+    // todo: add check for linked calendars
+    monthCalendar.hideLeftArrow =
+        options.monthIndex > 0 && options.monthIndex !== options.displayMonths;
+    monthCalendar.hideRightArrow =
+        options.monthIndex < options.displayMonths &&
+            options.monthIndex + 1 !== options.displayMonths;
+    monthCalendar.disableLeftArrow = isYearDisabled(shiftDate(monthCalendar.months[0][0].date, { year: -1 }), options.minDate, options.maxDate);
+    monthCalendar.disableRightArrow = isYearDisabled(shiftDate(monthCalendar.months[0][0].date, { year: 1 }), options.minDate, options.maxDate);
+    return monthCalendar;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm5/engine/flag-years-calendar.js

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { isSameYear, shiftDate } from 'ngx-bootstrap/chronos';
+import { isYearDisabled } from '../utils/bs-calendar-utils';
+/**
+ * @record
+ */
+export function FlagYearsCalendarOptions() { }
+function FlagYearsCalendarOptions_tsickle_Closure_declarations() {
+    /** @type {?} */
+    FlagYearsCalendarOptions.prototype.isDisabled;
+    /** @type {?} */
+    FlagYearsCalendarOptions.prototype.minDate;
+    /** @type {?} */
+    FlagYearsCalendarOptions.prototype.maxDate;
+    /** @type {?} */
+    FlagYearsCalendarOptions.prototype.hoveredYear;
+    /** @type {?} */
+    FlagYearsCalendarOptions.prototype.displayMonths;
+    /** @type {?} */
+    FlagYearsCalendarOptions.prototype.yearIndex;
+}
+/**
+ * @param {?} yearsCalendar
+ * @param {?} options
+ * @return {?}
+ */
+export function flagYearsCalendar(yearsCalendar, options) {
+    yearsCalendar.years.forEach(function (years, rowIndex) {
+        years.forEach(function (year, yearIndex) {
+            var /** @type {?} */ isHovered = isSameYear(year.date, options.hoveredYear);
+            var /** @type {?} */ isDisabled = options.isDisabled ||
+                isYearDisabled(year.date, options.minDate, options.maxDate);
+            var /** @type {?} */ newMonth = Object.assign(/*{},*/ year, { isHovered: isHovered, isDisabled: isDisabled });
+            if (year.isHovered !== newMonth.isHovered ||
+                year.isDisabled !== newMonth.isDisabled) {
+                yearsCalendar.years[rowIndex][yearIndex] = newMonth;
+            }
+        });
+    });
+    // todo: add check for linked calendars
+    yearsCalendar.hideLeftArrow =
+        options.yearIndex > 0 && options.yearIndex !== options.displayMonths;
+    yearsCalendar.hideRightArrow =
+        options.yearIndex < options.displayMonths &&
+            options.yearIndex + 1 !== options.displayMonths;
+    yearsCalendar.disableLeftArrow = isYearDisabled(shiftDate(yearsCalendar.years[0][0].date, { year: -1 }), options.minDate, options.maxDate);
+    var /** @type {?} */ i = yearsCalendar.years.length - 1;
+    var /** @type {?} */ j = yearsCalendar.years[i].length - 1;
+    yearsCalendar.disableRightArrow = isYearDisabled(shiftDate(yearsCalendar.years[i][j].date, { year: 1 }), options.minDate, options.maxDate);
+    return yearsCalendar;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm5/engine/format-days-calendar.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { formatDate, getLocale } from 'ngx-bootstrap/chronos';
+/**
+ * @param {?} daysCalendar
+ * @param {?} formatOptions
+ * @param {?} monthIndex
+ * @return {?}
+ */
+export function formatDaysCalendar(daysCalendar, formatOptions, monthIndex) {
+    return {
+        month: daysCalendar.month,
+        monthTitle: formatDate(daysCalendar.month, formatOptions.monthTitle, formatOptions.locale),
+        yearTitle: formatDate(daysCalendar.month, formatOptions.yearTitle, formatOptions.locale),
+        weekNumbers: getWeekNumbers(daysCalendar.daysMatrix, formatOptions.weekNumbers, formatOptions.locale),
+        weekdays: getShiftedWeekdays(formatOptions.locale),
+        weeks: daysCalendar.daysMatrix.map(function (week, weekIndex) {
+            return ({
+                days: week.map(function (date, dayIndex) {
+                    return ({
+                        date: date,
+                        label: formatDate(date, formatOptions.dayLabel, formatOptions.locale),
+                        monthIndex: monthIndex,
+                        weekIndex: weekIndex,
+                        dayIndex: dayIndex
+                    });
+                })
+            });
+        })
+    };
+}
+/**
+ * @param {?} daysMatrix
+ * @param {?} format
+ * @param {?} locale
+ * @return {?}
+ */
+export function getWeekNumbers(daysMatrix, format, locale) {
+    return daysMatrix.map(function (days) { return (days[0] ? formatDate(days[0], format, locale) : ''); });
+}
+/**
+ * @param {?} locale
+ * @return {?}
+ */
+export function getShiftedWeekdays(locale) {
+    var /** @type {?} */ _locale = getLocale(locale);
+    var /** @type {?} */ weekdays = /** @type {?} */ (_locale.weekdaysShort());
+    var /** @type {?} */ firstDayOfWeek = _locale.firstDayOfWeek();
+    return tslib_1.__spread(weekdays.slice(firstDayOfWeek), weekdays.slice(0, firstDayOfWeek));
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm5/engine/format-months-calendar.js

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { startOf, formatDate } from 'ngx-bootstrap/chronos';
+import { createMatrix } from '../utils/matrix-utils';
+var /** @type {?} */ height = 4;
+var /** @type {?} */ width = 3;
+var /** @type {?} */ shift = { month: 1 };
+/**
+ * @param {?} viewDate
+ * @param {?} formatOptions
+ * @return {?}
+ */
+export function formatMonthsCalendar(viewDate, formatOptions) {
+    var /** @type {?} */ initialDate = startOf(viewDate, 'year');
+    var /** @type {?} */ matrixOptions = { width: width, height: height, initialDate: initialDate, shift: shift };
+    var /** @type {?} */ monthMatrix = createMatrix(matrixOptions, function (date) {
+        return ({
+            date: date,
+            label: formatDate(date, formatOptions.monthLabel, formatOptions.locale)
+        });
+    });
+    return {
+        months: monthMatrix,
+        monthTitle: '',
+        yearTitle: formatDate(viewDate, formatOptions.yearTitle, formatOptions.locale)
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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