mis-crystal-design-system 2.3.18 → 2.3.21

package/esm2015/datepicker/themes/bs/bs-daterangepicker-inline-container.component.js

@@ -0,0 +1,36 @@
+import { ElementRef, Component, Renderer2 } from '@angular/core';
+import { MisDateRangePickerContainerComponent } from './bs-daterangepicker-container.component';
+import { MisDatePickerActions } from '../../reducer/bs-datepicker.actions';
+import { MisDatePickerConfig } from '../../bs-datepicker.config';
+import { MisDatePickerEffects } from '../../reducer/bs-datepicker.effects';
+import { MisDatePickerStore } from '../../reducer/bs-datepicker.store';
+import { PositioningService } from '../../sub-components/positioning';
+import { datepickerAnimation } from '../../datepicker-animations';
+export class MisDateRangePickerInlineContainerComponent extends MisDateRangePickerContainerComponent {
+    constructor(_renderer, _config, _store, _element, _actions, _effects, _positioningService) {
+        super(_renderer, _config, _store, _element, _actions, _effects, _positioningService);
+        _renderer.setStyle(_element.nativeElement, 'display', 'inline-block');
+        _renderer.setStyle(_element.nativeElement, 'position', 'static');
+    }
+}
+MisDateRangePickerInlineContainerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'mis-daterangepicker-inline-container',
+                providers: [MisDatePickerStore, MisDatePickerEffects],
+                template: "<!-- days calendar view mode -->\n<div class=\"bs-datepicker\" [ngClass]=\"containerClass\" *ngIf=\"viewMode | async\">\n  <div class=\"bs-datepicker-container\" [@datepickerAnimation]=\"animationState\"\n    (@datepickerAnimation.done)=\"positionServiceEnable()\">\n    <!--calendars-->\n    <div class=\"bs-calendar-container\" [ngSwitch]=\"viewMode | async\" role=\"application\">\n      <!--days calendar-->\n      <div *ngSwitchCase=\"'day'\" class=\"bs-media-container\">\n        <mis-days-calendar-view *ngFor=\"let calendar of daysCalendar | async\"\n          [class.bs-datepicker-multiple]=\"(daysCalendar | async)?.length > 1\" [calendar]=\"calendar\"\n          [options]=\"options | async\" (onNavigate)=\"navigateTo($event)\" (onViewMode)=\"setViewMode($event)\"\n          (onHover)=\"dayHoverHandler($event)\" (onHoverWeek)=\"weekHoverHandler($event)\"\n          (onSelect)=\"daySelectHandler($event)\">\n        </mis-days-calendar-view>\n      </div>\n\n      <!--months calendar-->\n      <div *ngSwitchCase=\"'month'\" class=\"bs-media-container\">\n        <mis-month-calendar-view *ngFor=\"let calendar of monthsCalendar | async\"\n          [class.bs-datepicker-multiple]=\"(daysCalendar | async)?.length > 1\" [calendar]=\"calendar\"\n          (onNavigate)=\"navigateTo($event)\" (onViewMode)=\"setViewMode($event)\" (onHover)=\"monthHoverHandler($event)\"\n          (onSelect)=\"monthSelectHandler($event)\">\n        </mis-month-calendar-view>\n      </div>\n\n      <!--years calendar-->\n      <div *ngSwitchCase=\"'year'\" class=\"bs-media-container\">\n        <mis-years-calendar-view *ngFor=\"let calendar of yearsCalendar | async\"\n          [class.bs-datepicker-multiple]=\"(daysCalendar | async)?.length > 1\" [calendar]=\"calendar\"\n          (onNavigate)=\"navigateTo($event)\" (onViewMode)=\"setViewMode($event)\" (onHover)=\"yearHoverHandler($event)\"\n          (onSelect)=\"yearSelectHandler($event)\">\n        </mis-years-calendar-view>\n      </div>\n    </div>\n\n    <!--applycancel buttons-->\n    <div class=\"bs-datepicker-buttons\" *ngIf=\"(daysCalendar | async)?.length > 1\">\n      <button class=\"btn btn-default\" (click)=\"cancel()\" type=\"button\">Cancel</button>\n      <button class=\"btn mis-btn-primary\" (click)=\"dayApplyHandler($event)\" type=\"button\">Apply</button>\n    </div>\n\n    <div class=\"bs-datepicker-buttons\" *ngIf=\"showTodayBtn || showClearBtn\">\n      <div class=\"btn-today-wrapper\" [class.today-left]=\"todayPos === 'left'\" [class.today-right]=\"todayPos === 'right'\"\n        [class.today-center]=\"todayPos === 'center'\" *ngIf=\"showTodayBtn\">\n        <button class=\"btn btn-success\" (click)=\"setToday()\">{{todayBtnLbl}}</button>\n      </div>\n\n      <div class=\"btn-clear-wrapper\" [class.clear-left]=\"clearPos === 'left'\" [class.clear-right]=\"clearPos === 'right'\"\n        [class.clear-center]=\"clearPos === 'center'\" *ngIf=\"showClearBtn\">\n        <button class=\"btn btn-success\" (click)=\"clearDate()\">{{clearBtnLbl}}</button>\n      </div>\n    </div>\n\n  </div>\n\n  <!--custom dates or date ranges picker-->\n  <div class=\"bs-datepicker-custom-range\" *ngIf=\"customRanges?.length > 0\">\n    <mis-custom-date-view [selectedRange]=\"chosenRange\" [ranges]=\"customRanges\" [customRangeLabel]=\"customRangeBtnLbl\"\n      (onSelect)=\"setRangeOnCalendar($event)\">\n    </mis-custom-date-view>\n  </div>\n</div>",
+                host: {
+                    '(click)': '_stopPropagation($event)'
+                },
+                animations: [datepickerAnimation]
+            },] }
+];
+MisDateRangePickerInlineContainerComponent.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: MisDatePickerConfig },
+    { type: MisDatePickerStore },
+    { type: ElementRef },
+    { type: MisDatePickerActions },
+    { type: MisDatePickerEffects },
+    { type: PositioningService }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnMtZGF0ZXJhbmdlcGlja2VyLWlubGluZS1jb250YWluZXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWlzLWNvbXBvbmVudHMvZGF0ZXBpY2tlci90aGVtZXMvYnMvYnMtZGF0ZXJhbmdlcGlja2VyLWlubGluZS1jb250YWluZXIuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBcUIsVUFBVSxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDcEYsT0FBTyxFQUFFLG9DQUFvQyxFQUFFLE1BQU0sMENBQTBDLENBQUM7QUFFaEcsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDM0UsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDakUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDM0UsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFFdkUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDdEUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFXbEUsTUFBTSxPQUFPLDBDQUEyQyxTQUFRLG9DQUFvQztJQUdsRyxZQUNFLFNBQW9CLEVBQ3BCLE9BQTRCLEVBQzVCLE1BQTBCLEVBQzFCLFFBQW9CLEVBQ3BCLFFBQThCLEVBQzlCLFFBQThCLEVBQzlCLG1CQUF1QztRQUV2QyxLQUFLLENBQUMsU0FBUyxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUUsbUJBQW1CLENBQUMsQ0FBQztRQUVyRixTQUFTLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxhQUFhLEVBQUUsU0FBUyxFQUFFLGNBQWMsQ0FBQyxDQUFDO1FBQ3RFLFNBQVMsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLGFBQWEsRUFBRSxVQUFVLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDbkUsQ0FBQzs7O1lBekJGLFNBQVMsU0FBQztnQkFDVCxRQUFRLEVBQUUsc0NBQXNDO2dCQUNoRCxTQUFTLEVBQUUsQ0FBQyxrQkFBa0IsRUFBRSxvQkFBb0IsQ0FBQztnQkFDckQsMjNHQUF3QztnQkFDeEMsSUFBSSxFQUFFO29CQUNKLFNBQVMsRUFBRSwwQkFBMEI7aUJBQ3RDO2dCQUNELFVBQVUsRUFBRSxDQUFDLG1CQUFtQixDQUFDO2FBQ2xDOzs7WUFuQmtELFNBQVM7WUFJbkQsbUJBQW1CO1lBRW5CLGtCQUFrQjtZQU5DLFVBQVU7WUFHN0Isb0JBQW9CO1lBRXBCLG9CQUFvQjtZQUdwQixrQkFBa0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPbkluaXQsIE9uRGVzdHJveSwgRWxlbWVudFJlZiwgQ29tcG9uZW50LCBSZW5kZXJlcjIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE1pc0RhdGVSYW5nZVBpY2tlckNvbnRhaW5lckNvbXBvbmVudCB9IGZyb20gJy4vYnMtZGF0ZXJhbmdlcGlja2VyLWNvbnRhaW5lci5jb21wb25lbnQnO1xuXG5pbXBvcnQgeyBNaXNEYXRlUGlja2VyQWN0aW9ucyB9IGZyb20gJy4uLy4uL3JlZHVjZXIvYnMtZGF0ZXBpY2tlci5hY3Rpb25zJztcbmltcG9ydCB7IE1pc0RhdGVQaWNrZXJDb25maWcgfSBmcm9tICcuLi8uLi9icy1kYXRlcGlja2VyLmNvbmZpZyc7XG5pbXBvcnQgeyBNaXNEYXRlUGlja2VyRWZmZWN0cyB9IGZyb20gJy4uLy4uL3JlZHVjZXIvYnMtZGF0ZXBpY2tlci5lZmZlY3RzJztcbmltcG9ydCB7IE1pc0RhdGVQaWNrZXJTdG9yZSB9IGZyb20gJy4uLy4uL3JlZHVjZXIvYnMtZGF0ZXBpY2tlci5zdG9yZSc7XG5cbmltcG9ydCB7IFBvc2l0aW9uaW5nU2VydmljZSB9IGZyb20gJy4uLy4uL3N1Yi1jb21wb25lbnRzL3Bvc2l0aW9uaW5nJztcbmltcG9ydCB7IGRhdGVwaWNrZXJBbmltYXRpb24gfSBmcm9tICcuLi8uLi9kYXRlcGlja2VyLWFuaW1hdGlvbnMnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdtaXMtZGF0ZXJhbmdlcGlja2VyLWlubGluZS1jb250YWluZXInLFxuICBwcm92aWRlcnM6IFtNaXNEYXRlUGlja2VyU3RvcmUsIE1pc0RhdGVQaWNrZXJFZmZlY3RzXSxcbiAgdGVtcGxhdGVVcmw6ICcuL2JzLWRhdGVwaWNrZXItdmlldy5odG1sJyxcbiAgaG9zdDoge1xuICAgICcoY2xpY2spJzogJ19zdG9wUHJvcGFnYXRpb24oJGV2ZW50KSdcbiAgfSxcbiAgYW5pbWF0aW9uczogW2RhdGVwaWNrZXJBbmltYXRpb25dXG59KVxuZXhwb3J0IGNsYXNzIE1pc0RhdGVSYW5nZVBpY2tlcklubGluZUNvbnRhaW5lckNvbXBvbmVudCBleHRlbmRzIE1pc0RhdGVSYW5nZVBpY2tlckNvbnRhaW5lckNvbXBvbmVudFxuICBpbXBsZW1lbnRzIE9uSW5pdCwgT25EZXN0cm95IHtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBfcmVuZGVyZXI6IFJlbmRlcmVyMixcbiAgICBfY29uZmlnOiBNaXNEYXRlUGlja2VyQ29uZmlnLFxuICAgIF9zdG9yZTogTWlzRGF0ZVBpY2tlclN0b3JlLFxuICAgIF9lbGVtZW50OiBFbGVtZW50UmVmLFxuICAgIF9hY3Rpb25zOiBNaXNEYXRlUGlja2VyQWN0aW9ucyxcbiAgICBfZWZmZWN0czogTWlzRGF0ZVBpY2tlckVmZmVjdHMsXG4gICAgX3Bvc2l0aW9uaW5nU2VydmljZTogUG9zaXRpb25pbmdTZXJ2aWNlXG4gICkge1xuICAgIHN1cGVyKF9yZW5kZXJlciwgX2NvbmZpZywgX3N0b3JlLCBfZWxlbWVudCwgX2FjdGlvbnMsIF9lZmZlY3RzLCBfcG9zaXRpb25pbmdTZXJ2aWNlKTtcblxuICAgIF9yZW5kZXJlci5zZXRTdHlsZShfZWxlbWVudC5uYXRpdmVFbGVtZW50LCAnZGlzcGxheScsICdpbmxpbmUtYmxvY2snKTtcbiAgICBfcmVuZGVyZXIuc2V0U3R5bGUoX2VsZW1lbnQubmF0aXZlRWxlbWVudCwgJ3Bvc2l0aW9uJywgJ3N0YXRpYycpO1xuICB9XG59XG4iXX0=

package/esm2015/datepicker/themes/bs/bs-days-calendar-view.component.js

@@ -0,0 +1,162 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { isSameDay } from '../../sub-components/chronos';
+import { BsNavigationDirection } from '../../models';
+import { MisDatePickerConfig } from '../../bs-datepicker.config';
+export class MisDaysCalendarViewComponent {
+    constructor(_config) {
+        this._config = _config;
+        this.onNavigate = new EventEmitter();
+        this.onViewMode = new EventEmitter();
+        this.onSelect = new EventEmitter();
+        this.onHover = new EventEmitter();
+        this.onHoverWeek = new EventEmitter();
+        this.isiOS = (/iPad|iPhone|iPod/.test(navigator.platform) ||
+            (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1));
+        if (this._config.dateTooltipTexts && this._config.dateTooltipTexts.length > 0) {
+            this.isShowTooltip = true;
+        }
+    }
+    navigateTo(event) {
+        const step = BsNavigationDirection.DOWN === event ? -1 : 1;
+        this.onNavigate.emit({ step: { month: step } });
+    }
+    changeViewMode(event) {
+        this.onViewMode.emit(event);
+    }
+    selectDay(event) {
+        this.onSelect.emit(event);
+    }
+    selectWeek(week) {
+        if (!this._config.selectWeek && !this._config.selectWeekDateRange) {
+            return;
+        }
+        if (week.days.length === 0) {
+            return;
+        }
+        if (this._config.selectWeek && week.days[0]
+            && !week.days[0].isDisabled
+            && this._config.selectFromOtherMonth) {
+            this.onSelect.emit(week.days[0]);
+            return;
+        }
+        const selectedDay = week.days.find((day) => {
+            return this._config.selectFromOtherMonth
+                ? !day.isDisabled
+                : !day.isOtherMonth && !day.isDisabled;
+        });
+        this.onSelect.emit(selectedDay);
+        if (this._config.selectWeekDateRange) {
+            const days = week.days.slice(0);
+            const lastDayOfRange = days.reverse().find((day) => {
+                return this._config.selectFromOtherMonth
+                    ? !day.isDisabled
+                    : !day.isOtherMonth && !day.isDisabled;
+            });
+            this.onSelect.emit(lastDayOfRange);
+        }
+    }
+    weekHoverHandler(cell, isHovered) {
+        if (!this._config.selectWeek && !this._config.selectWeekDateRange) {
+            return;
+        }
+        const hasActiveDays = cell.days.find((day) => {
+            return this._config.selectFromOtherMonth
+                ? !day.isDisabled
+                : !day.isOtherMonth && !day.isDisabled;
+        });
+        if (hasActiveDays) {
+            cell.isHovered = isHovered;
+            this.isWeekHovered = isHovered;
+            this.onHoverWeek.emit(cell);
+        }
+    }
+    hoverDay(cell, isHovered) {
+        if (this._config.selectFromOtherMonth && cell.isOtherMonth) {
+            cell.isOtherMonthHovered = isHovered;
+        }
+        if (this._config.dateTooltipTexts) {
+            cell.tooltipText = '';
+            this._config.dateTooltipTexts.forEach((dateData) => {
+                if (isSameDay(dateData.date, cell.date)) {
+                    cell.tooltipText = dateData.tooltipText;
+                    return;
+                }
+            });
+        }
+        this.onHover.emit({ cell, isHovered });
+    }
+}
+MisDaysCalendarViewComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'mis-days-calendar-view',
+                // changeDetection: ChangeDetectionStrategy.OnPush,
+                template: `
+    <mis-calendar-layout>
+      <mis-datepicker-navigation-view
+        [calendar]="calendar"
+        (onNavigate)="navigateTo($event)"
+        (onViewMode)="changeViewMode($event)"
+      ></mis-datepicker-navigation-view>
+
+      <!--days matrix-->
+      <table role="grid" class="days weeks">
+        <thead>
+        <tr>
+          <!--if show weeks-->
+          <th *ngIf="options.showWeekNumbers"></th>
+          <th *ngFor="let weekday of calendar.weekdays; let i = index"
+              aria-label="weekday">{{ calendar.weekdays[i] }}
+          </th>
+        </tr>
+        </thead>
+        <tbody>
+        <tr *ngFor="let week of calendar.weeks; let i = index">
+          <td class="week" [class.active-week]="isWeekHovered"  *ngIf="options.showWeekNumbers">
+            <span *ngIf="isiOS" (click)="selectWeek(week)">{{ calendar.weekNumbers[i] }}</span>
+            <span *ngIf="!isiOS"
+                (click)="selectWeek(week)"
+                (mouseenter)="weekHoverHandler(week, true)"
+                (mouseleave)="weekHoverHandler(week, false)">{{ calendar.weekNumbers[i] }}</span>
+          </td>
+          <td *ngFor="let day of week.days" role="gridcell">
+
+            <!-- When we want to show tooltips for dates -->
+            <span *ngIf="!isiOS && isShowTooltip" misDatePickerDayDecorator
+                [day]="day"
+                (click)="selectDay(day)"
+                tooltip="{{day.tooltipText}}"
+                (mouseenter)="hoverDay(day, true)"
+                (mouseleave)="hoverDay(day, false)">{{ day.label }} 3</span>
+            <!-- When tooltips for dates are disabled -->
+            <span *ngIf="!isiOS && !isShowTooltip" misDatePickerDayDecorator
+                  [day]="day"
+                  (click)="selectDay(day)"
+                  (mouseenter)="hoverDay(day, true)"
+                  (mouseleave)="hoverDay(day, false)">{{ day.label }} 2</span>
+
+            <!-- For mobile iOS view, tooltips are not needed -->
+            <span *ngIf="isiOS" misDatePickerDayDecorator
+                  [day]="day"
+                  (click)="selectDay(day)">{{ day.label }} 1</span>
+          </td>
+        </tr>
+        </tbody>
+      </table>
+
+    </mis-calendar-layout>
+  `
+            },] }
+];
+MisDaysCalendarViewComponent.ctorParameters = () => [
+    { type: MisDatePickerConfig }
+];
+MisDaysCalendarViewComponent.propDecorators = {
+    calendar: [{ type: Input }],
+    options: [{ type: Input }],
+    onNavigate: [{ type: Output }],
+    onViewMode: [{ type: Output }],
+    onSelect: [{ type: Output }],
+    onHover: [{ type: Output }],
+    onHoverWeek: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-days-calendar-view.component.js","sourceRoot":"","sources":["../../../../../../projects/mis-components/datepicker/themes/bs/bs-days-calendar-view.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,YAAY,EACZ,KAAK,EACL,MAAM,EACP,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEzD,OAAO,EAEL,qBAAqB,EAMtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AA6DjE,MAAM,OAAO,4BAA4B;IAevC,YAAoB,OAA4B;QAA5B,YAAO,GAAP,OAAO,CAAqB;QAXtC,eAAU,GAAG,IAAI,YAAY,EAAqB,CAAC;QACnD,eAAU,GAAG,IAAI,YAAY,EAAyB,CAAC;QAEvD,aAAQ,GAAG,IAAI,YAAY,EAAgB,CAAC;QAC5C,YAAO,GAAG,IAAI,YAAY,EAAkB,CAAC;QAC7C,gBAAW,GAAG,IAAI,YAAY,EAAiB,CAAC;QAOxD,IAAI,CAAC,KAAK,GAAG,CAAC,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;YACvD,CAAC,SAAS,CAAC,QAAQ,KAAK,UAAU,IAAI,SAAS,CAAC,cAAc,GAAG,CAAC,CAAC,CAAC,CAAC;QACvE,IAAI,IAAI,CAAC,OAAO,CAAC,gBAAgB,IAAI,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE;YAC7E,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;SAC3B;IACH,CAAC;IAED,UAAU,CAAC,KAA4B;QACrC,MAAM,IAAI,GAAG,qBAAqB,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3D,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;IAClD,CAAC;IAED,cAAc,CAAC,KAA4B;QACzC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,SAAS,CAAC,KAAmB;QAC3B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED,UAAU,CAAC,IAAmB;QAC5B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE;YACjE,OAAO;SACR;QAED,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,OAAO;SACR;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;eACpC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU;eACxB,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE;YAEtC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAEjC,OAAO;SACV;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAiB,EAAE,EAAE;YACvD,OAAO,IAAI,CAAC,OAAO,CAAC,oBAAoB;gBACtC,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU;gBACjB,CAAC,CAAC,CAAC,GAAG,CAAC,YAAY,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAEhC,IAAI,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE;YACpC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAChC,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,GAAiB,EAAE,EAAE;gBAC/D,OAAO,IAAI,CAAC,OAAO,CAAC,oBAAoB;oBACtC,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU;oBACjB,CAAC,CAAC,CAAC,GAAG,CAAC,YAAY,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC;YAC3C,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;SACpC;IACH,CAAC;IAED,gBAAgB,CAAC,IAAmB,EAAE,SAAkB;QACtD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE;YACjE,OAAO;SACR;QAED,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAiB,EAAE,EAAE;YACzD,OAAO,IAAI,CAAC,OAAO,CAAC,oBAAoB;gBACtC,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU;gBACjB,CAAC,CAAC,CAAC,GAAG,CAAC,YAAY,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,IAAI,aAAa,EAAE;YACjB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;YAC3B,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;YAC/B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC7B;IACH,CAAC;IAED,QAAQ,CAAC,IAAkB,EAAE,SAAkB;QAC7C,IAAI,IAAI,CAAC,OAAO,CAAC,oBAAoB,IAAI,IAAI,CAAC,YAAY,EAAE;YAC1D,IAAI,CAAC,mBAAmB,GAAG,SAAS,CAAC;SACtC;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE;YACjC,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;YACtB,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,QAAmC,EAAE,EAAE;gBAE5E,IAAI,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE;oBACvC,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC;oBAExC,OAAO;iBACR;YACH,CAAC,CAAC,CAAC;SACJ;QAED,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IACzC,CAAC;;;YAzKF,SAAS,SAAC;gBACT,QAAQ,EAAE,wBAAwB;gBAClC,mDAAmD;gBACnD,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDT;aACF;;;YA5DQ,mBAAmB;;;uBA8DzB,KAAK;sBACL,KAAK;yBAEL,MAAM;yBACN,MAAM;uBAEN,MAAM;sBACN,MAAM;0BACN,MAAM","sourcesContent":["import {\n  Component,\n  EventEmitter,\n  Input,\n  Output\n} from '@angular/core';\n\nimport { isSameDay } from '../../sub-components/chronos';\n\nimport {\n  MisDatePickerViewMode,\n  BsNavigationDirection,\n  BsNavigationEvent,\n  CellHoverEvent, DatePickerDateTooltipText,\n  DatePickerRenderOptions,\n  DaysCalendarViewModel,\n  DayViewModel, WeekViewModel\n} from '../../models';\n\nimport { MisDatePickerConfig } from '../../bs-datepicker.config';\n\n@Component({\n  selector: 'mis-days-calendar-view',\n  // changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <mis-calendar-layout>\n      <mis-datepicker-navigation-view\n        [calendar]=\"calendar\"\n        (onNavigate)=\"navigateTo($event)\"\n        (onViewMode)=\"changeViewMode($event)\"\n      ></mis-datepicker-navigation-view>\n\n      <!--days matrix-->\n      <table role=\"grid\" class=\"days weeks\">\n        <thead>\n        <tr>\n          <!--if show weeks-->\n          <th *ngIf=\"options.showWeekNumbers\"></th>\n          <th *ngFor=\"let weekday of calendar.weekdays; let i = index\"\n              aria-label=\"weekday\">{{ calendar.weekdays[i] }}\n          </th>\n        </tr>\n        </thead>\n        <tbody>\n        <tr *ngFor=\"let week of calendar.weeks; let i = index\">\n          <td class=\"week\" [class.active-week]=\"isWeekHovered\"  *ngIf=\"options.showWeekNumbers\">\n            <span *ngIf=\"isiOS\" (click)=\"selectWeek(week)\">{{ calendar.weekNumbers[i] }}</span>\n            <span *ngIf=\"!isiOS\"\n                (click)=\"selectWeek(week)\"\n                (mouseenter)=\"weekHoverHandler(week, true)\"\n                (mouseleave)=\"weekHoverHandler(week, false)\">{{ calendar.weekNumbers[i] }}</span>\n          </td>\n          <td *ngFor=\"let day of week.days\" role=\"gridcell\">\n\n            <!-- When we want to show tooltips for dates -->\n            <span *ngIf=\"!isiOS && isShowTooltip\" misDatePickerDayDecorator\n                [day]=\"day\"\n                (click)=\"selectDay(day)\"\n                tooltip=\"{{day.tooltipText}}\"\n                (mouseenter)=\"hoverDay(day, true)\"\n                (mouseleave)=\"hoverDay(day, false)\">{{ day.label }} 3</span>\n            <!-- When tooltips for dates are disabled -->\n            <span *ngIf=\"!isiOS && !isShowTooltip\" misDatePickerDayDecorator\n                  [day]=\"day\"\n                  (click)=\"selectDay(day)\"\n                  (mouseenter)=\"hoverDay(day, true)\"\n                  (mouseleave)=\"hoverDay(day, false)\">{{ day.label }} 2</span>\n\n            <!-- For mobile iOS view, tooltips are not needed -->\n            <span *ngIf=\"isiOS\" misDatePickerDayDecorator\n                  [day]=\"day\"\n                  (click)=\"selectDay(day)\">{{ day.label }} 1</span>\n          </td>\n        </tr>\n        </tbody>\n      </table>\n\n    </mis-calendar-layout>\n  `\n})\nexport class MisDaysCalendarViewComponent  {\n  @Input() calendar: DaysCalendarViewModel;\n  @Input() options: DatePickerRenderOptions;\n\n  @Output() onNavigate = new EventEmitter<BsNavigationEvent>();\n  @Output() onViewMode = new EventEmitter<MisDatePickerViewMode>();\n\n  @Output() onSelect = new EventEmitter<DayViewModel>();\n  @Output() onHover = new EventEmitter<CellHoverEvent>();\n  @Output() onHoverWeek = new EventEmitter<WeekViewModel>();\n\n  isWeekHovered: boolean;\n  isiOS: boolean;\n  isShowTooltip: boolean;\n\n  constructor(private _config: MisDatePickerConfig) {\n    this.isiOS = (/iPad|iPhone|iPod/.test(navigator.platform) ||\n      (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1));\n    if (this._config.dateTooltipTexts && this._config.dateTooltipTexts.length > 0) {\n      this.isShowTooltip = true;\n    }\n  }\n\n  navigateTo(event: BsNavigationDirection): void {\n    const step = BsNavigationDirection.DOWN === event ? -1 : 1;\n    this.onNavigate.emit({ step: { month: step } });\n  }\n\n  changeViewMode(event: MisDatePickerViewMode): void {\n    this.onViewMode.emit(event);\n  }\n\n  selectDay(event: DayViewModel): void {\n    this.onSelect.emit(event);\n  }\n\n  selectWeek(week: WeekViewModel): void {\n    if (!this._config.selectWeek && !this._config.selectWeekDateRange) {\n      return;\n    }\n\n    if (week.days.length === 0) {\n      return;\n    }\n\n    if (this._config.selectWeek && week.days[0]\n        && !week.days[0].isDisabled\n        && this._config.selectFromOtherMonth) {\n\n        this.onSelect.emit(week.days[0]);\n\n        return;\n    }\n\n    const selectedDay = week.days.find((day: DayViewModel) => {\n      return this._config.selectFromOtherMonth\n        ? !day.isDisabled\n        : !day.isOtherMonth && !day.isDisabled;\n    });\n\n    this.onSelect.emit(selectedDay);\n\n    if (this._config.selectWeekDateRange) {\n      const days = week.days.slice(0);\n      const lastDayOfRange = days.reverse().find((day: DayViewModel) => {\n        return this._config.selectFromOtherMonth\n          ? !day.isDisabled\n          : !day.isOtherMonth && !day.isDisabled;\n      });\n\n      this.onSelect.emit(lastDayOfRange);\n    }\n  }\n\n  weekHoverHandler(cell: WeekViewModel, isHovered: boolean): void {\n    if (!this._config.selectWeek && !this._config.selectWeekDateRange) {\n      return;\n    }\n\n    const hasActiveDays = cell.days.find((day: DayViewModel) => {\n      return this._config.selectFromOtherMonth\n        ? !day.isDisabled\n        : !day.isOtherMonth && !day.isDisabled;\n    });\n\n    if (hasActiveDays) {\n      cell.isHovered = isHovered;\n      this.isWeekHovered = isHovered;\n      this.onHoverWeek.emit(cell);\n    }\n  }\n\n  hoverDay(cell: DayViewModel, isHovered: boolean): void {\n    if (this._config.selectFromOtherMonth && cell.isOtherMonth) {\n      cell.isOtherMonthHovered = isHovered;\n    }\n\n    if (this._config.dateTooltipTexts) {\n      cell.tooltipText = '';\n      this._config.dateTooltipTexts.forEach((dateData: DatePickerDateTooltipText) => {\n\n        if (isSameDay(dateData.date, cell.date)) {\n          cell.tooltipText = dateData.tooltipText;\n\n          return;\n        }\n      });\n    }\n\n    this.onHover.emit({ cell, isHovered });\n  }\n}\n"]}

package/esm2015/datepicker/themes/bs/bs-months-calendar-view.component.js

@@ -0,0 +1,60 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { BsNavigationDirection } from '../../models';
+export class BsMonthCalendarViewComponent {
+    constructor() {
+        this.onNavigate = new EventEmitter();
+        this.onViewMode = new EventEmitter();
+        this.onSelect = new EventEmitter();
+        this.onHover = new EventEmitter();
+    }
+    navigateTo(event) {
+        const step = BsNavigationDirection.DOWN === event ? -1 : 1;
+        this.onNavigate.emit({ step: { year: step } });
+    }
+    viewMonth(month) {
+        this.onSelect.emit(month);
+    }
+    hoverMonth(cell, isHovered) {
+        this.onHover.emit({ cell, isHovered });
+    }
+    changeViewMode(event) {
+        this.onViewMode.emit(event);
+    }
+}
+BsMonthCalendarViewComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'mis-month-calendar-view',
+                template: `
+    <mis-calendar-layout>
+      <mis-datepicker-navigation-view
+        [calendar]="calendar"
+        (onNavigate)="navigateTo($event)"
+        (onViewMode)="changeViewMode($event)"
+      ></mis-datepicker-navigation-view>
+
+      <table role="grid" class="months">
+        <tbody>
+        <tr *ngFor="let row of calendar.months">
+          <td *ngFor="let month of row" role="gridcell"
+              (click)="viewMonth(month)"
+              (mouseenter)="hoverMonth(month, true)"
+              (mouseleave)="hoverMonth(month, false)"
+              [class.disabled]="month.isDisabled"
+              [class.is-highlighted]="month.isHovered">
+            <span [class.selected]="month.isSelected">{{ month.label }}</span>
+          </td>
+        </tr>
+        </tbody>
+      </table>
+    </mis-calendar-layout>
+  `
+            },] }
+];
+BsMonthCalendarViewComponent.propDecorators = {
+    calendar: [{ type: Input }],
+    onNavigate: [{ type: Output }],
+    onViewMode: [{ type: Output }],
+    onSelect: [{ type: Output }],
+    onHover: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/datepicker/themes/bs/bs-timepicker-view.component.js

@@ -0,0 +1,34 @@
+// tslint:disable:max-line-length
+import { Component } from '@angular/core';
+export class BsTimepickerViewComponent {
+    constructor() {
+        this.ampm = 'ok';
+        this.hours = 0;
+        this.minutes = 0;
+    }
+}
+BsTimepickerViewComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'mis-timepicker',
+                template: `
+    <div class="mis-timepicker-container">
+      <div class="mis-timepicker-controls">
+        <button class="bs-decrease" type="button">-</button>
+        <input type="text" [value]="hours" placeholder="00">
+        <button class="bs-increase" type="button">+</button>
+      </div>
+      <div class="mis-timepicker-controls">
+        <button class="bs-decrease" type="button">-</button>
+        <input type="text" [value]="minutes" placeholder="00">
+        <button class="bs-increase" type="button">+</button>
+      </div>
+      <button class="switch-time-format" type="button">{{ ampm }}
+        <img
+          src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAAKCAYAAABi8KSDAAABSElEQVQYV3XQPUvDUBQG4HNuagtVqc6KgouCv6GIuIntYBLB9hcIQpLStCAIV7DYmpTcRWcXqZio3Vwc/UCc/QEqfgyKGbr0I7nS1EiHeqYzPO/h5SD0jaxUZjmSLCB+OFb+UFINFwASAEAdpu9gaGXVyAHHFQBkHpKHc6a9dzECvADyY9sqlAMsK9W0jzxDXqeytr3mhQckxSji27TJJ5/rPmIpwJJq3HrtduriYOurv1a4i1p5HnhkG9OFymi0ReoO05cGwb+ayv4dysVygjeFmsP05f8wpZQ8fsdvfmuY9zjWSNqUtgYFVnOVReILYoBFzdQI5/GGFzNHhGbeZnopDGU29sZbscgldmC99w35VOATTycIMMcBXIfpSVGzZhA6C8hh00conln6VQ9TGgV32OEAKQC4DrBq7CJwd0ggR7Vq/rPrfgB+C3sGypY5DAAAAABJRU5ErkJggg=="
+          alt="">
+      </button>
+    </div>
+  `
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/datepicker/themes/bs/bs-years-calendar-view.component.js

@@ -0,0 +1,61 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { yearsPerCalendar } from '../../engine/format-years-calendar';
+import { BsNavigationDirection } from '../../models';
+export class BsYearsCalendarViewComponent {
+    constructor() {
+        this.onNavigate = new EventEmitter();
+        this.onViewMode = new EventEmitter();
+        this.onSelect = new EventEmitter();
+        this.onHover = new EventEmitter();
+    }
+    navigateTo(event) {
+        const step = BsNavigationDirection.DOWN === event ? -1 : 1;
+        this.onNavigate.emit({ step: { year: step * yearsPerCalendar } });
+    }
+    viewYear(year) {
+        this.onSelect.emit(year);
+    }
+    hoverYear(cell, isHovered) {
+        this.onHover.emit({ cell, isHovered });
+    }
+    changeViewMode(event) {
+        this.onViewMode.emit(event);
+    }
+}
+BsYearsCalendarViewComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'mis-years-calendar-view',
+                template: `
+    <mis-calendar-layout>
+      <mis-datepicker-navigation-view
+        [calendar]="calendar"
+        (onNavigate)="navigateTo($event)"
+        (onViewMode)="changeViewMode($event)"
+      ></mis-datepicker-navigation-view>
+
+      <table role="grid" class="years">
+        <tbody>
+        <tr *ngFor="let row of calendar.years">
+          <td *ngFor="let year of row" role="gridcell"
+              (click)="viewYear(year)"
+              (mouseenter)="hoverYear(year, true)"
+              (mouseleave)="hoverYear(year, false)"
+              [class.disabled]="year.isDisabled"
+              [class.is-highlighted]="year.isHovered">
+            <span [class.selected]="year.isSelected">{{ year.label }}</span>
+          </td>
+        </tr>
+        </tbody>
+      </table>
+    </mis-calendar-layout>
+  `
+            },] }
+];
+BsYearsCalendarViewComponent.propDecorators = {
+    calendar: [{ type: Input }],
+    onNavigate: [{ type: Output }],
+    onViewMode: [{ type: Output }],
+    onSelect: [{ type: Output }],
+    onHover: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/datepicker/utils/bs-calendar-utils.js

@@ -0,0 +1,43 @@
+import { getDay, isFirstDayOfWeek, isAfter, isBefore, shiftDate, endOf, startOf, isArray, isSame } from '../sub-components/chronos';
+export function getStartingDayOfCalendar(date, options) {
+    if (isFirstDayOfWeek(date, options.firstDayOfWeek)) {
+        return date;
+    }
+    const weekDay = getDay(date);
+    const offset = calculateDateOffset(weekDay, options.firstDayOfWeek);
+    return shiftDate(date, { day: -offset });
+}
+export function calculateDateOffset(weekday, startingDayOffset) {
+    if (startingDayOffset === 0) {
+        return weekday;
+    }
+    const offset = weekday - startingDayOffset % 7;
+    return offset < 0 ? offset + 7 : offset;
+}
+export function isMonthDisabled(date, min, max) {
+    const minBound = min && isBefore(endOf(date, 'month'), min, 'day');
+    const maxBound = max && isAfter(startOf(date, 'month'), max, 'day');
+    return minBound || maxBound;
+}
+export function isYearDisabled(date, min, max) {
+    const minBound = min && isBefore(endOf(date, 'year'), min, 'day');
+    const maxBound = max && isAfter(startOf(date, 'year'), max, 'day');
+    return minBound || maxBound;
+}
+export function isDisabledDate(date, datesDisabled) {
+    if (!datesDisabled || !isArray(datesDisabled) || !datesDisabled.length) {
+        return false;
+    }
+    return datesDisabled.some((dateDisabled) => isSame(date, dateDisabled, 'date'));
+}
+export function isEnabledDate(date, datesEnabled) {
+    if (!datesEnabled || !isArray(datesEnabled) || !datesEnabled.length) {
+        return false;
+    }
+    return !datesEnabled.some((enabledDate) => isSame(date, enabledDate, 'date'));
+}
+export function getYearsCalendarInitialDate(state, calendarIndex = 0) {
+    const model = state && state.yearsCalendarModel && state.yearsCalendarModel[calendarIndex];
+    return model && model.years && model.years[0] && model.years[0][0] && model.years[0][0].date;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/datepicker/utils/matrix-utils.js

@@ -0,0 +1,14 @@
+import { shiftDate } from '../sub-components/chronos';
+export function createMatrix(options, fn) {
+    let prevValue = options.initialDate;
+    const matrix = new Array(options.height);
+    for (let i = 0; i < options.height; i++) {
+        matrix[i] = new Array(options.width);
+        for (let j = 0; j < options.width; j++) {
+            matrix[i][j] = fn(prevValue);
+            prevValue = shiftDate(prevValue, options.shift);
+        }
+    }
+    return matrix;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0cml4LXV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWlzLWNvbXBvbmVudHMvZGF0ZXBpY2tlci91dGlscy9tYXRyaXgtdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFZLFNBQVMsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBV2hFLE1BQU0sVUFBVSxZQUFZLENBQzFCLE9BQXNCLEVBQ3RCLEVBQXFCO0lBRXJCLElBQUksU0FBUyxHQUFHLE9BQU8sQ0FBQyxXQUFXLENBQUM7SUFDcEMsTUFBTSxNQUFNLEdBQVUsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2hELEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFO1FBQ3ZDLE1BQU0sQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDckMsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxFQUFFLEVBQUU7WUFDdEMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUM3QixTQUFTLEdBQUcsU0FBUyxDQUFDLFNBQVMsRUFBRSxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7U0FDakQ7S0FDRjtJQUVELE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUaW1lVW5pdCwgc2hpZnREYXRlIH0gZnJvbSAnLi4vc3ViLWNvbXBvbmVudHMvY2hyb25vcyc7XG5cbmV4cG9ydCB0eXBlIENyZWF0ZU1hdHJpeENiPFQ+ID0gKGRhdGU6IERhdGUpID0+IFQ7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTWF0cml4T3B0aW9ucyB7XG4gIGhlaWdodDogbnVtYmVyO1xuICB3aWR0aDogbnVtYmVyO1xuICBpbml0aWFsRGF0ZTogRGF0ZTtcbiAgc2hpZnQ6IFRpbWVVbml0O1xufVxuXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlTWF0cml4PFQ+KFxuICBvcHRpb25zOiBNYXRyaXhPcHRpb25zLFxuICBmbjogQ3JlYXRlTWF0cml4Q2I8VD5cbik6IFRbXVtdIHtcbiAgbGV0IHByZXZWYWx1ZSA9IG9wdGlvbnMuaW5pdGlhbERhdGU7XG4gIGNvbnN0IG1hdHJpeDogVFtdW10gPSBuZXcgQXJyYXkob3B0aW9ucy5oZWlnaHQpO1xuICBmb3IgKGxldCBpID0gMDsgaSA8IG9wdGlvbnMuaGVpZ2h0OyBpKyspIHtcbiAgICBtYXRyaXhbaV0gPSBuZXcgQXJyYXkob3B0aW9ucy53aWR0aCk7XG4gICAgZm9yIChsZXQgaiA9IDA7IGogPCBvcHRpb25zLndpZHRoOyBqKyspIHtcbiAgICAgIG1hdHJpeFtpXVtqXSA9IGZuKHByZXZWYWx1ZSk7XG4gICAgICBwcmV2VmFsdWUgPSBzaGlmdERhdGUocHJldlZhbHVlLCBvcHRpb25zLnNoaWZ0KTtcbiAgICB9XG4gIH1cblxuICByZXR1cm4gbWF0cml4O1xufVxuIl19

package/esm2015/datepicker/yearpicker.component.js

@@ -0,0 +1,90 @@
+// @deprecated
+// tslint:disable
+import { Component } from '@angular/core';
+import { isBs3 } from './sub-components/utils';
+import { DatePickerInnerComponent } from './datepicker-inner.component';
+export class YearPickerComponent {
+    constructor(datePicker) {
+        this.rows = [];
+        this.datePicker = datePicker;
+    }
+    get isBs4() {
+        return !isBs3();
+    }
+    ngOnInit() {
+        const self = this;
+        this.datePicker.stepYear = { years: this.datePicker.yearRange };
+        this.datePicker.setRefreshViewHandler(function () {
+            const years = new Array(this.yearRange);
+            let date;
+            const start = self.getStartingYear(this.activeDate.getFullYear());
+            for (let i = 0; i < this.yearRange; i++) {
+                date = new Date(start + i, 0, 1);
+                date = this.fixTimeZone(date);
+                years[i] = this.createDateObject(date, this.formatYear);
+                years[i].uid = this.uniqueId + '-' + i;
+            }
+            self.title = [years[0].label, years[this.yearRange - 1].label].join(' - ');
+            self.rows = this.split(years, self.datePicker.yearColLimit);
+        }, 'year');
+        this.datePicker.setCompareHandler(function (date1, date2) {
+            return date1.getFullYear() - date2.getFullYear();
+        }, 'year');
+        this.datePicker.refreshView();
+    }
+    getStartingYear(year) {
+        // todo: parseInt
+        return ((year - 1) / this.datePicker.yearRange * this.datePicker.yearRange + 1);
+    }
+}
+YearPickerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'yearpicker',
+                template: `
+<table *ngIf="datePicker.datepickerMode==='year'" role="grid">
+  <thead>
+    <tr>
+      <th>
+        <button type="button" class="btn btn-default btn-sm pull-left float-left"
+                (click)="datePicker.move(-1)" tabindex="-1">‹</button>
+      </th>
+      <th [attr.colspan]="((datePicker.yearColLimit - 2) <= 0) ? 1 : datePicker.yearColLimit - 2">
+        <button [id]="datePicker.uniqueId + '-title'" role="heading"
+                type="button" class="btn btn-default btn-sm"
+                (click)="datePicker.toggleMode(0)"
+                [disabled]="datePicker.datepickerMode === datePicker.maxMode"
+                [ngClass]="{disabled: datePicker.datepickerMode === datePicker.maxMode}" tabindex="-1" style="width:100%;">
+          <strong>{{ title }}</strong>
+        </button>
+      </th>
+      <th>
+        <button type="button" class="btn btn-default btn-sm pull-right float-right"
+                (click)="datePicker.move(1)" tabindex="-1">›</button>
+      </th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr *ngFor="let rowz of rows">
+      <td *ngFor="let dtz of rowz" class="text-center" role="gridcell" [attr.id]="dtz.uid">
+        <button type="button" style="min-width:100%;" class="btn btn-default"
+                [ngClass]="{'btn-link': isBs4 && !dtz.selected && !datePicker.isActive(dtz), 'btn-info': dtz.selected || (isBs4 && !dtz.selected && datePicker.isActive(dtz)), disabled: dtz.disabled, active: !isBs4 && datePicker.isActive(dtz)}"
+                [disabled]="dtz.disabled"
+                (click)="datePicker.select(dtz.date)" tabindex="-1">
+          <span [ngClass]="{'text-success': isBs4 && dtz.current, 'text-info': !isBs4 && dtz.current}">{{ dtz.label }}</span>
+        </button>
+      </td>
+    </tr>
+  </tbody>
+</table>
+  `,
+                styles: [`
+    :host .btn-info .text-success {
+      color: #fff !important;
+    }
+  `]
+            },] }
+];
+YearPickerComponent.ctorParameters = () => [
+    { type: DatePickerInnerComponent }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWVhcnBpY2tlci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9taXMtY29tcG9uZW50cy9kYXRlcGlja2VyL3llYXJwaWNrZXIuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWM7QUFDZCxpQkFBaUI7QUFDakIsT0FBTyxFQUFFLFNBQVMsRUFBVSxNQUFNLGVBQWUsQ0FBQztBQUVsRCxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFpRHhFLE1BQU0sT0FBTyxtQkFBbUI7SUFLOUIsWUFBWSxVQUFvQztRQUZoRCxTQUFJLEdBQVUsRUFBRSxDQUFDO1FBR2YsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7SUFDL0IsQ0FBQztJQUVELElBQUksS0FBSztRQUNQLE9BQU8sQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUNsQixDQUFDO0lBRUQsUUFBUTtRQUNOLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQztRQUVsQixJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsR0FBRyxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsVUFBVSxDQUFDLFNBQVMsRUFBRSxDQUFDO1FBRWhFLElBQUksQ0FBQyxVQUFVLENBQUMscUJBQXFCLENBQUM7WUFDcEMsTUFBTSxLQUFLLEdBQVUsSUFBSSxLQUFLLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBQy9DLElBQUksSUFBVSxDQUFDO1lBQ2YsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUM7WUFFbEUsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQyxFQUFFLEVBQUU7Z0JBQ3ZDLElBQUksR0FBRyxJQUFJLElBQUksQ0FBQyxLQUFLLEdBQUcsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztnQkFDakMsSUFBSSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLENBQUM7Z0JBQzlCLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztnQkFDeEQsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsUUFBUSxHQUFHLEdBQUcsR0FBRyxDQUFDLENBQUM7YUFDeEM7WUFFRCxJQUFJLENBQUMsS0FBSyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssRUFBRSxLQUFLLENBQUMsSUFBSSxDQUFDLFNBQVMsR0FBRyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxJQUFJLENBQ2pFLEtBQUssQ0FDTixDQUFDO1lBQ0YsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsVUFBVSxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQzlELENBQUMsRUFBRSxNQUFNLENBQUMsQ0FBQztRQUVYLElBQUksQ0FBQyxVQUFVLENBQUMsaUJBQWlCLENBQUMsVUFDaEMsS0FBVyxFQUNYLEtBQVc7WUFFWCxPQUFPLEtBQUssQ0FBQyxXQUFXLEVBQUUsR0FBRyxLQUFLLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDbkQsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBRVgsSUFBSSxDQUFDLFVBQVUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUNoQyxDQUFDO0lBRVMsZUFBZSxDQUFDLElBQVk7UUFDcEMsaUJBQWlCO1FBQ2pCLE9BQU8sQ0FDTCxDQUFDLElBQUksR0FBRyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLFNBQVMsR0FBRyxDQUFDLENBQ3ZFLENBQUM7SUFDSixDQUFDOzs7WUFsR0YsU0FBUyxTQUFDO2dCQUNULFFBQVEsRUFBRSxZQUFZO2dCQUN0QixRQUFRLEVBQUU7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQW9DVDt5QkFFQzs7OztHQUlEO2FBRUY7OztZQWhEUSx3QkFBd0IiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAZGVwcmVjYXRlZFxuLy8gdHNsaW50OmRpc2FibGVcbmltcG9ydCB7IENvbXBvbmVudCwgT25Jbml0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IGlzQnMzIH0gZnJvbSAnLi9zdWItY29tcG9uZW50cy91dGlscyc7XG5pbXBvcnQgeyBEYXRlUGlja2VySW5uZXJDb21wb25lbnQgfSBmcm9tICcuL2RhdGVwaWNrZXItaW5uZXIuY29tcG9uZW50JztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAneWVhcnBpY2tlcicsXG4gIHRlbXBsYXRlOiBgXG48dGFibGUgKm5nSWY9XCJkYXRlUGlja2VyLmRhdGVwaWNrZXJNb2RlPT09J3llYXInXCIgcm9sZT1cImdyaWRcIj5cbiAgPHRoZWFkPlxuICAgIDx0cj5cbiAgICAgIDx0aD5cbiAgICAgICAgPGJ1dHRvbiB0eXBlPVwiYnV0dG9uXCIgY2xhc3M9XCJidG4gYnRuLWRlZmF1bHQgYnRuLXNtIHB1bGwtbGVmdCBmbG9hdC1sZWZ0XCJcbiAgICAgICAgICAgICAgICAoY2xpY2spPVwiZGF0ZVBpY2tlci5tb3ZlKC0xKVwiIHRhYmluZGV4PVwiLTFcIj7igLk8L2J1dHRvbj5cbiAgICAgIDwvdGg+XG4gICAgICA8dGggW2F0dHIuY29sc3Bhbl09XCIoKGRhdGVQaWNrZXIueWVhckNvbExpbWl0IC0gMikgPD0gMCkgPyAxIDogZGF0ZVBpY2tlci55ZWFyQ29sTGltaXQgLSAyXCI+XG4gICAgICAgIDxidXR0b24gW2lkXT1cImRhdGVQaWNrZXIudW5pcXVlSWQgKyAnLXRpdGxlJ1wiIHJvbGU9XCJoZWFkaW5nXCJcbiAgICAgICAgICAgICAgICB0eXBlPVwiYnV0dG9uXCIgY2xhc3M9XCJidG4gYnRuLWRlZmF1bHQgYnRuLXNtXCJcbiAgICAgICAgICAgICAgICAoY2xpY2spPVwiZGF0ZVBpY2tlci50b2dnbGVNb2RlKDApXCJcbiAgICAgICAgICAgICAgICBbZGlzYWJsZWRdPVwiZGF0ZVBpY2tlci5kYXRlcGlja2VyTW9kZSA9PT0gZGF0ZVBpY2tlci5tYXhNb2RlXCJcbiAgICAgICAgICAgICAgICBbbmdDbGFzc109XCJ7ZGlzYWJsZWQ6IGRhdGVQaWNrZXIuZGF0ZXBpY2tlck1vZGUgPT09IGRhdGVQaWNrZXIubWF4TW9kZX1cIiB0YWJpbmRleD1cIi0xXCIgc3R5bGU9XCJ3aWR0aDoxMDAlO1wiPlxuICAgICAgICAgIDxzdHJvbmc+e3sgdGl0bGUgfX08L3N0cm9uZz5cbiAgICAgICAgPC9idXR0b24+XG4gICAgICA8L3RoPlxuICAgICAgPHRoPlxuICAgICAgICA8YnV0dG9uIHR5cGU9XCJidXR0b25cIiBjbGFzcz1cImJ0biBidG4tZGVmYXVsdCBidG4tc20gcHVsbC1yaWdodCBmbG9hdC1yaWdodFwiXG4gICAgICAgICAgICAgICAgKGNsaWNrKT1cImRhdGVQaWNrZXIubW92ZSgxKVwiIHRhYmluZGV4PVwiLTFcIj7igLo8L2J1dHRvbj5cbiAgICAgIDwvdGg+XG4gICAgPC90cj5cbiAgPC90aGVhZD5cbiAgPHRib2R5PlxuICAgIDx0ciAqbmdGb3I9XCJsZXQgcm93eiBvZiByb3dzXCI+XG4gICAgICA8dGQgKm5nRm9yPVwibGV0IGR0eiBvZiByb3d6XCIgY2xhc3M9XCJ0ZXh0LWNlbnRlclwiIHJvbGU9XCJncmlkY2VsbFwiIFthdHRyLmlkXT1cImR0ei51aWRcIj5cbiAgICAgICAgPGJ1dHRvbiB0eXBlPVwiYnV0dG9uXCIgc3R5bGU9XCJtaW4td2lkdGg6MTAwJTtcIiBjbGFzcz1cImJ0biBidG4tZGVmYXVsdFwiXG4gICAgICAgICAgICAgICAgW25nQ2xhc3NdPVwieydidG4tbGluayc6IGlzQnM0ICYmICFkdHouc2VsZWN0ZWQgJiYgIWRhdGVQaWNrZXIuaXNBY3RpdmUoZHR6KSwgJ2J0bi1pbmZvJzogZHR6LnNlbGVjdGVkIHx8IChpc0JzNCAmJiAhZHR6LnNlbGVjdGVkICYmIGRhdGVQaWNrZXIuaXNBY3RpdmUoZHR6KSksIGRpc2FibGVkOiBkdHouZGlzYWJsZWQsIGFjdGl2ZTogIWlzQnM0ICYmIGRhdGVQaWNrZXIuaXNBY3RpdmUoZHR6KX1cIlxuICAgICAgICAgICAgICAgIFtkaXNhYmxlZF09XCJkdHouZGlzYWJsZWRcIlxuICAgICAgICAgICAgICAgIChjbGljayk9XCJkYXRlUGlja2VyLnNlbGVjdChkdHouZGF0ZSlcIiB0YWJpbmRleD1cIi0xXCI+XG4gICAgICAgICAgPHNwYW4gW25nQ2xhc3NdPVwieyd0ZXh0LXN1Y2Nlc3MnOiBpc0JzNCAmJiBkdHouY3VycmVudCwgJ3RleHQtaW5mbyc6ICFpc0JzNCAmJiBkdHouY3VycmVudH1cIj57eyBkdHoubGFiZWwgfX08L3NwYW4+XG4gICAgICAgIDwvYnV0dG9uPlxuICAgICAgPC90ZD5cbiAgICA8L3RyPlxuICA8L3Rib2R5PlxuPC90YWJsZT5cbiAgYCxcbiAgc3R5bGVzOiBbXG4gICAgYFxuICAgIDpob3N0IC5idG4taW5mbyAudGV4dC1zdWNjZXNzIHtcbiAgICAgIGNvbG9yOiAjZmZmICFpbXBvcnRhbnQ7XG4gICAgfVxuICBgXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgWWVhclBpY2tlckNvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG4gIGRhdGVQaWNrZXI6IERhdGVQaWNrZXJJbm5lckNvbXBvbmVudDtcbiAgdGl0bGU6IHN0cmluZztcbiAgcm93czogYW55W10gPSBbXTtcblxuICBjb25zdHJ1Y3RvcihkYXRlUGlja2VyOiBEYXRlUGlja2VySW5uZXJDb21wb25lbnQpIHtcbiAgICB0aGlzLmRhdGVQaWNrZXIgPSBkYXRlUGlja2VyO1xuICB9XG5cbiAgZ2V0IGlzQnM0KCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiAhaXNCczMoKTtcbiAgfVxuXG4gIG5nT25Jbml0KCk6IHZvaWQge1xuICAgIGNvbnN0IHNlbGYgPSB0aGlzO1xuXG4gICAgdGhpcy5kYXRlUGlja2VyLnN0ZXBZZWFyID0geyB5ZWFyczogdGhpcy5kYXRlUGlja2VyLnllYXJSYW5nZSB9O1xuXG4gICAgdGhpcy5kYXRlUGlja2VyLnNldFJlZnJlc2hWaWV3SGFuZGxlcihmdW5jdGlvbigpOiB2b2lkIHtcbiAgICAgIGNvbnN0IHllYXJzOiBhbnlbXSA9IG5ldyBBcnJheSh0aGlzLnllYXJSYW5nZSk7XG4gICAgICBsZXQgZGF0ZTogRGF0ZTtcbiAgICAgIGNvbnN0IHN0YXJ0ID0gc2VsZi5nZXRTdGFydGluZ1llYXIodGhpcy5hY3RpdmVEYXRlLmdldEZ1bGxZZWFyKCkpO1xuXG4gICAgICBmb3IgKGxldCBpID0gMDsgaSA8IHRoaXMueWVhclJhbmdlOyBpKyspIHtcbiAgICAgICAgZGF0ZSA9IG5ldyBEYXRlKHN0YXJ0ICsgaSwgMCwgMSk7XG4gICAgICAgIGRhdGUgPSB0aGlzLmZpeFRpbWVab25lKGRhdGUpO1xuICAgICAgICB5ZWFyc1tpXSA9IHRoaXMuY3JlYXRlRGF0ZU9iamVjdChkYXRlLCB0aGlzLmZvcm1hdFllYXIpO1xuICAgICAgICB5ZWFyc1tpXS51aWQgPSB0aGlzLnVuaXF1ZUlkICsgJy0nICsgaTtcbiAgICAgIH1cblxuICAgICAgc2VsZi50aXRsZSA9IFt5ZWFyc1swXS5sYWJlbCwgeWVhcnNbdGhpcy55ZWFyUmFuZ2UgLSAxXS5sYWJlbF0uam9pbihcbiAgICAgICAgJyAtICdcbiAgICAgICk7XG4gICAgICBzZWxmLnJvd3MgPSB0aGlzLnNwbGl0KHllYXJzLCBzZWxmLmRhdGVQaWNrZXIueWVhckNvbExpbWl0KTtcbiAgICB9LCAneWVhcicpO1xuXG4gICAgdGhpcy5kYXRlUGlja2VyLnNldENvbXBhcmVIYW5kbGVyKGZ1bmN0aW9uKFxuICAgICAgZGF0ZTE6IERhdGUsXG4gICAgICBkYXRlMjogRGF0ZVxuICAgICk6IG51bWJlciB7XG4gICAgICByZXR1cm4gZGF0ZTEuZ2V0RnVsbFllYXIoKSAtIGRhdGUyLmdldEZ1bGxZZWFyKCk7XG4gICAgfSwgJ3llYXInKTtcblxuICAgIHRoaXMuZGF0ZVBpY2tlci5yZWZyZXNoVmlldygpO1xuICB9XG5cbiAgcHJvdGVjdGVkIGdldFN0YXJ0aW5nWWVhcih5ZWFyOiBudW1iZXIpOiBudW1iZXIge1xuICAgIC8vIHRvZG86IHBhcnNlSW50XG4gICAgcmV0dXJuIChcbiAgICAgICh5ZWFyIC0gMSkgLyB0aGlzLmRhdGVQaWNrZXIueWVhclJhbmdlICogdGhpcy5kYXRlUGlja2VyLnllYXJSYW5nZSArIDFcbiAgICApO1xuICB9XG59XG4iXX0=