mis-crystal-design-system 14.0.55-test-v4 → 14.0.55-test-v5

package/esm2020/datepicker/datepicker-inner.component.mjs

@@ -0,0 +1,323 @@
+/* tslint:disable: max-file-line-count */
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { DateFormatter } from './date-formatter';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+function DatePickerInnerComponent_div_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 1);
+    i0.ɵɵprojection(1);
+    i0.ɵɵelementEnd();
+} }
+const _c0 = ["*"];
+export class DatePickerInnerComponent {
+    constructor() {
+        this.selectionDone = new EventEmitter(undefined);
+        this.update = new EventEmitter(false);
+        this.activeDateChange = new EventEmitter(undefined);
+        /* tslint:disable-next-line: no-any*/
+        this.stepDay = {};
+        /* tslint:disable-next-line: no-any*/
+        this.stepMonth = {};
+        /* tslint:disable-next-line: no-any*/
+        this.stepYear = {};
+        this.modes = ['day', 'month', 'year'];
+        this.dateFormatter = new DateFormatter();
+    }
+    get activeDate() {
+        return this._activeDate;
+    }
+    set activeDate(value) {
+        this._activeDate = value;
+    }
+    // todo: add formatter value to Date object
+    ngOnInit() {
+        // todo: use date for unique value
+        this.uniqueId = `datepicker--${Math.floor(Math.random() * 10000)}`;
+        if (this.initDate) {
+            this.activeDate = this.initDate;
+            this.selectedDate = new Date(this.activeDate.valueOf());
+            this.update.emit(this.activeDate);
+        }
+        else if (this.activeDate === undefined) {
+            this.activeDate = new Date();
+        }
+    }
+    // this.refreshView should be called here to reflect the changes on the fly
+    // tslint:disable-next-line:no-unused-variable
+    ngOnChanges(changes) {
+        this.refreshView();
+        this.checkIfActiveDateGotUpdated(changes.activeDate);
+    }
+    // Check if activeDate has been update and then emit the activeDateChange with the new date
+    /* tslint:disable-next-line: no-any */
+    checkIfActiveDateGotUpdated(activeDate) {
+        if (activeDate && !activeDate.firstChange) {
+            const previousValue = activeDate.previousValue;
+            if (previousValue &&
+                previousValue instanceof Date &&
+                previousValue.getTime() !== activeDate.currentValue.getTime()) {
+                this.activeDateChange.emit(this.activeDate);
+            }
+        }
+    }
+    setCompareHandler(handler, type) {
+        if (type === 'day') {
+            this.compareHandlerDay = handler;
+        }
+        if (type === 'month') {
+            this.compareHandlerMonth = handler;
+        }
+        if (type === 'year') {
+            this.compareHandlerYear = handler;
+        }
+    }
+    compare(date1, date2) {
+        if (date1 === undefined || date2 === undefined) {
+            return undefined;
+        }
+        if (this.datepickerMode === 'day' && this.compareHandlerDay) {
+            return this.compareHandlerDay(date1, date2);
+        }
+        if (this.datepickerMode === 'month' && this.compareHandlerMonth) {
+            return this.compareHandlerMonth(date1, date2);
+        }
+        if (this.datepickerMode === 'year' && this.compareHandlerYear) {
+            return this.compareHandlerYear(date1, date2);
+        }
+        return void 0;
+    }
+    setRefreshViewHandler(handler, type) {
+        if (type === 'day') {
+            this.refreshViewHandlerDay = handler;
+        }
+        if (type === 'month') {
+            this.refreshViewHandlerMonth = handler;
+        }
+        if (type === 'year') {
+            this.refreshViewHandlerYear = handler;
+        }
+    }
+    refreshView() {
+        if (this.datepickerMode === 'day' && this.refreshViewHandlerDay) {
+            this.refreshViewHandlerDay();
+        }
+        if (this.datepickerMode === 'month' && this.refreshViewHandlerMonth) {
+            this.refreshViewHandlerMonth();
+        }
+        if (this.datepickerMode === 'year' && this.refreshViewHandlerYear) {
+            this.refreshViewHandlerYear();
+        }
+    }
+    dateFilter(date, format) {
+        return this.dateFormatter.format(date, format, this.locale);
+    }
+    /* tslint:disable-next-line: no-any*/
+    isActive(dateObject) {
+        if (this.compare(dateObject.date, this.activeDate) === 0) {
+            this.activeDateId = dateObject.uid;
+            return true;
+        }
+        return false;
+    }
+    /* tslint:disable-next-line: no-any*/
+    createDateObject(date, format) {
+        /* tslint:disable-next-line: no-any*/
+        const dateObject = {};
+        dateObject.date = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+        dateObject.date = this.fixTimeZone(dateObject.date);
+        dateObject.label = this.dateFilter(date, format);
+        dateObject.selected = this.compare(date, this.selectedDate) === 0;
+        dateObject.disabled = this.isDisabled(date);
+        dateObject.current = this.compare(date, new Date()) === 0;
+        dateObject.customClass = this.getCustomClassForDate(dateObject.date);
+        return dateObject;
+    }
+    /* tslint:disable-next-line: no-any*/
+    split(arr, size) {
+        /* tslint:disable-next-line: no-any*/
+        const arrays = [];
+        while (arr.length > 0) {
+            arrays.push(arr.splice(0, size));
+        }
+        return arrays;
+    }
+    // Fix a hard-reproducible bug with timezones
+    // The bug depends on OS, browser, current timezone and current date
+    // i.e.
+    // var date = new Date(2014, 0, 1);
+    // console.log(date.getFullYear(), date.getMonth(), date.getDate(),
+    // date.getHours()); can result in "2013 11 31 23" because of the bug.
+    fixTimeZone(date) {
+        const hours = date.getHours();
+        return new Date(date.getFullYear(), date.getMonth(), date.getDate(), hours === 23 ? hours + 2 : 0);
+    }
+    select(date, isManual = true) {
+        if (this.datepickerMode === this.minMode) {
+            if (!this.activeDate) {
+                this.activeDate = new Date(0, 0, 0, 0, 0, 0, 0);
+            }
+            this.activeDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+            this.activeDate = this.fixTimeZone(this.activeDate);
+            if (isManual) {
+                this.selectionDone.emit(this.activeDate);
+            }
+        }
+        else {
+            this.activeDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+            this.activeDate = this.fixTimeZone(this.activeDate);
+            if (isManual) {
+                this.datepickerMode = this.modes[this.modes.indexOf(this.datepickerMode) - 1];
+            }
+        }
+        this.selectedDate = new Date(this.activeDate.valueOf());
+        this.update.emit(this.activeDate);
+        this.refreshView();
+    }
+    move(direction) {
+        /* tslint:disable-next-line: no-any*/
+        let expectedStep;
+        if (this.datepickerMode === 'day') {
+            expectedStep = this.stepDay;
+        }
+        if (this.datepickerMode === 'month') {
+            expectedStep = this.stepMonth;
+        }
+        if (this.datepickerMode === 'year') {
+            expectedStep = this.stepYear;
+        }
+        if (expectedStep) {
+            const year = this.activeDate.getFullYear() + direction * (expectedStep.years || 0);
+            const month = this.activeDate.getMonth() + direction * (expectedStep.months || 0);
+            this.activeDate = new Date(year, month, 1);
+            this.refreshView();
+            this.activeDateChange.emit(this.activeDate);
+        }
+    }
+    toggleMode(_direction) {
+        const direction = _direction || 1;
+        if ((this.datepickerMode === this.maxMode && direction === 1) ||
+            (this.datepickerMode === this.minMode && direction === -1)) {
+            return;
+        }
+        this.datepickerMode = this.modes[this.modes.indexOf(this.datepickerMode) + direction];
+        this.refreshView();
+    }
+    getCustomClassForDate(date) {
+        if (!this.customClass) {
+            return '';
+        }
+        // todo: build a hash of custom classes, it will work faster
+        const customClassObject = this.customClass.find((customClass) => {
+            return (customClass.date.valueOf() === date.valueOf() &&
+                customClass.mode === this.datepickerMode);
+        }, this);
+        return customClassObject === undefined ? '' : customClassObject.clazz;
+    }
+    compareDateDisabled(date1Disabled, date2) {
+        if (date1Disabled === undefined || date2 === undefined) {
+            return undefined;
+        }
+        if (date1Disabled.mode === 'day' && this.compareHandlerDay) {
+            return this.compareHandlerDay(date1Disabled.date, date2);
+        }
+        if (date1Disabled.mode === 'month' && this.compareHandlerMonth) {
+            return this.compareHandlerMonth(date1Disabled.date, date2);
+        }
+        if (date1Disabled.mode === 'year' && this.compareHandlerYear) {
+            return this.compareHandlerYear(date1Disabled.date, date2);
+        }
+        return undefined;
+    }
+    isDisabled(date) {
+        let isDateDisabled = false;
+        if (this.dateDisabled) {
+            this.dateDisabled.forEach((disabledDate) => {
+                if (this.compareDateDisabled(disabledDate, date) === 0) {
+                    isDateDisabled = true;
+                }
+            });
+        }
+        if (this.dayDisabled) {
+            isDateDisabled =
+                isDateDisabled ||
+                    this.dayDisabled.indexOf(date.getDay()) > -1;
+        }
+        return (isDateDisabled ||
+            (this.minDate && this.compare(date, this.minDate) < 0) ||
+            (this.maxDate && this.compare(date, this.maxDate) > 0));
+    }
+}
+DatePickerInnerComponent.ɵfac = function DatePickerInnerComponent_Factory(t) { return new (t || DatePickerInnerComponent)(); };
+DatePickerInnerComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: DatePickerInnerComponent, selectors: [["datepicker-inner"]], inputs: { locale: "locale", datepickerMode: "datepickerMode", startingDay: "startingDay", yearRange: "yearRange", minDate: "minDate", maxDate: "maxDate", minMode: "minMode", maxMode: "maxMode", showWeeks: "showWeeks", formatDay: "formatDay", formatMonth: "formatMonth", formatYear: "formatYear", formatDayHeader: "formatDayHeader", formatDayTitle: "formatDayTitle", formatMonthTitle: "formatMonthTitle", onlyCurrentMonth: "onlyCurrentMonth", shortcutPropagation: "shortcutPropagation", customClass: "customClass", monthColLimit: "monthColLimit", yearColLimit: "yearColLimit", dateDisabled: "dateDisabled", dayDisabled: "dayDisabled", initDate: "initDate", activeDate: "activeDate" }, outputs: { selectionDone: "selectionDone", update: "update", activeDateChange: "activeDateChange" }, features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 1, consts: [["class", "well well-sm bg-faded p-a card", "role", "application", 4, "ngIf"], ["role", "application", 1, "well", "well-sm", "bg-faded", "p-a", "card"]], template: function DatePickerInnerComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵprojectionDef();
+        i0.ɵɵtemplate(0, DatePickerInnerComponent_div_0_Template, 2, 0, "div", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.datepickerMode);
+    } }, dependencies: [i1.NgIf], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DatePickerInnerComponent, [{
+        type: Component,
+        args: [{
+                selector: 'datepicker-inner',
+                template: `
+    <!--&lt;!&ndash;ng-keydown="keydown($event)"&ndash;&gt;-->
+    <div *ngIf="datepickerMode" class="well well-sm bg-faded p-a card" role="application" >
+      <ng-content></ng-content>
+    </div>
+  `
+            }]
+    }], null, { locale: [{
+            type: Input
+        }], datepickerMode: [{
+            type: Input
+        }], startingDay: [{
+            type: Input
+        }], yearRange: [{
+            type: Input
+        }], minDate: [{
+            type: Input
+        }], maxDate: [{
+            type: Input
+        }], minMode: [{
+            type: Input
+        }], maxMode: [{
+            type: Input
+        }], showWeeks: [{
+            type: Input
+        }], formatDay: [{
+            type: Input
+        }], formatMonth: [{
+            type: Input
+        }], formatYear: [{
+            type: Input
+        }], formatDayHeader: [{
+            type: Input
+        }], formatDayTitle: [{
+            type: Input
+        }], formatMonthTitle: [{
+            type: Input
+        }], onlyCurrentMonth: [{
+            type: Input
+        }], shortcutPropagation: [{
+            type: Input
+        }], customClass: [{
+            type: Input
+        }], monthColLimit: [{
+            type: Input
+        }], yearColLimit: [{
+            type: Input
+        }], dateDisabled: [{
+            type: Input
+        }], dayDisabled: [{
+            type: Input
+        }], initDate: [{
+            type: Input
+        }], selectionDone: [{
+            type: Output
+        }], update: [{
+            type: Output
+        }], activeDateChange: [{
+            type: Output
+        }], activeDate: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker-inner.component.js","sourceRoot":"","sources":["../../../../projects/mis-components/datepicker/datepicker-inner.component.ts"],"names":[],"mappings":"AAAA,yCAAyC;AACzC,OAAO,EACL,SAAS,EACT,YAAY,EACZ,KAAK,EAGL,MAAM,EAEP,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;;;;IAO7C,8BAAuF;IACrF,kBAAyB;IAC3B,iBAAM;;;AAGV,MAAM,OAAO,wBAAwB;IATrC;QAmCY,kBAAa,GAAuB,IAAI,YAAY,CAAO,SAAS,CAAC,CAAC;QACtE,WAAM,GAAuB,IAAI,YAAY,CAAO,KAAK,CAAC,CAAC;QAC3D,qBAAgB,GAAuB,IAAI,YAAY,CAAO,SAAS,CAAC,CAAC;QAEnF,qCAAqC;QACrC,YAAO,GAAQ,EAAE,CAAC;QAClB,qCAAqC;QACrC,cAAS,GAAQ,EAAE,CAAC;QACpB,qCAAqC;QACrC,aAAQ,GAAQ,EAAE,CAAC;QAIT,UAAK,GAAa,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAC3C,kBAAa,GAAkB,IAAI,aAAa,EAAE,CAAC;KAqU9D;IAzTC,IACI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,IAAI,UAAU,CAAC,KAAW;QACxB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;IAED,2CAA2C;IAC3C,QAAQ;QACN,kCAAkC;QAClC,IAAI,CAAC,QAAQ,GAAI,eAAe,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC;QAEpE,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;YACxD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;SACnC;aAAM,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE;YACxC,IAAI,CAAC,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC;SAC9B;IACH,CAAC;IAED,2EAA2E;IAC3E,8CAA8C;IAC9C,WAAW,CAAC,OAAsB;QAChC,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IACvD,CAAC;IAED,2FAA2F;IAC3F,sCAAsC;IACtC,2BAA2B,CAAC,UAAe;QACzC,IAAI,UAAU,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE;YACzC,MAAM,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;YAC/C,IACE,aAAa;gBACb,aAAa,YAAY,IAAI;gBAC7B,aAAa,CAAC,OAAO,EAAE,KAAK,UAAU,CAAC,YAAY,CAAC,OAAO,EAAE,EAC7D;gBACA,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC7C;SACF;IACH,CAAC;IAED,iBAAiB,CAAC,OAAiB,EAAE,IAAY;QAC/C,IAAI,IAAI,KAAK,KAAK,EAAE;YAClB,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC;SAClC;QAED,IAAI,IAAI,KAAK,OAAO,EAAE;YACpB,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC;SACpC;QAED,IAAI,IAAI,KAAK,MAAM,EAAE;YACnB,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC;SACnC;IACH,CAAC;IAED,OAAO,CAAC,KAAW,EAAE,KAAW;QAC9B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,SAAS,EAAE;YAC9C,OAAO,SAAS,CAAC;SAClB;QAED,IAAI,IAAI,CAAC,cAAc,KAAK,KAAK,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAC3D,OAAO,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;SAC7C;QAED,IAAI,IAAI,CAAC,cAAc,KAAK,OAAO,IAAI,IAAI,CAAC,mBAAmB,EAAE;YAC/D,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;SAC/C;QAED,IAAI,IAAI,CAAC,cAAc,KAAK,MAAM,IAAI,IAAI,CAAC,kBAAkB,EAAE;YAC7D,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;SAC9C;QAED,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,qBAAqB,CAAC,OAAiB,EAAE,IAAY;QACnD,IAAI,IAAI,KAAK,KAAK,EAAE;YAClB,IAAI,CAAC,qBAAqB,GAAG,OAAO,CAAC;SACtC;QAED,IAAI,IAAI,KAAK,OAAO,EAAE;YACpB,IAAI,CAAC,uBAAuB,GAAG,OAAO,CAAC;SACxC;QAED,IAAI,IAAI,KAAK,MAAM,EAAE;YACnB,IAAI,CAAC,sBAAsB,GAAG,OAAO,CAAC;SACvC;IACH,CAAC;IAED,WAAW;QACT,IAAI,IAAI,CAAC,cAAc,KAAK,KAAK,IAAI,IAAI,CAAC,qBAAqB,EAAE;YAC/D,IAAI,CAAC,qBAAqB,EAAE,CAAC;SAC9B;QAED,IAAI,IAAI,CAAC,cAAc,KAAK,OAAO,IAAI,IAAI,CAAC,uBAAuB,EAAE;YACnE,IAAI,CAAC,uBAAuB,EAAE,CAAC;SAChC;QAED,IAAI,IAAI,CAAC,cAAc,KAAK,MAAM,IAAI,IAAI,CAAC,sBAAsB,EAAE;YACjE,IAAI,CAAC,sBAAsB,EAAE,CAAC;SAC/B;IACH,CAAC;IAED,UAAU,CAAC,IAAU,EAAE,MAAc;QACnC,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC9D,CAAC;IAED,qCAAqC;IACrC,QAAQ,CAAC,UAAe;QACtB,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE;YACxD,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC;YAEnC,OAAO,IAAI,CAAC;SACb;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,qCAAqC;IACrC,gBAAgB,CAAC,IAAU,EAAE,MAAc;QACzC,qCAAqC;QACrC,MAAM,UAAU,GAAQ,EAAE,CAAC;QAC3B,UAAU,CAAC,IAAI,GAAG,IAAI,IAAI,CACxB,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,OAAO,EAAE,CACf,CAAC;QACF,UAAU,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACpD,UAAU,CAAC,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACjD,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAClE,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC5C,UAAU,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;QAC1D,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAErE,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,qCAAqC;IACrC,KAAK,CAAC,GAAU,EAAE,IAAY;QAC5B,qCAAqC;QACrC,MAAM,MAAM,GAAU,EAAE,CAAC;QACzB,OAAO,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE;YACrB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;SAClC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,6CAA6C;IAC7C,oEAAoE;IACpE,OAAO;IACP,mCAAmC;IACnC,mEAAmE;IACnE,sEAAsE;IACtE,WAAW,CAAC,IAAU;QACpB,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAE9B,OAAO,IAAI,IAAI,CACb,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,OAAO,EAAE,EACd,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAC7B,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,IAAU,EAAE,QAAQ,GAAG,IAAI;QAChC,IAAI,IAAI,CAAC,cAAc,KAAK,IAAI,CAAC,OAAO,EAAE;YACxC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;gBACpB,IAAI,CAAC,UAAU,GAAG,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;aACjD;YAED,IAAI,CAAC,UAAU,GAAG,IAAI,IAAI,CACxB,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,OAAO,EAAE,CACf,CAAC;YACF,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACpD,IAAI,QAAQ,EAAE;gBACZ,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1C;SACF;aAAM;YACL,IAAI,CAAC,UAAU,GAAG,IAAI,IAAI,CACxB,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,OAAO,EAAE,CACf,CAAC;YACF,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACpD,IAAI,QAAQ,EAAE;gBACZ,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,KAAK,CAC9B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAC5C,CAAC;aACH;SACF;QAED,IAAI,CAAC,YAAY,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAClC,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAED,IAAI,CAAC,SAAiB;QACpB,qCAAqC;QACrC,IAAI,YAAiB,CAAC;QACtB,IAAI,IAAI,CAAC,cAAc,KAAK,KAAK,EAAE;YACjC,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC;SAC7B;QAED,IAAI,IAAI,CAAC,cAAc,KAAK,OAAO,EAAE;YACnC,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC;SAC/B;QAED,IAAI,IAAI,CAAC,cAAc,KAAK,MAAM,EAAE;YAClC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;SAC9B;QAED,IAAI,YAAY,EAAE;YAChB,MAAM,IAAI,GACR,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,GAAG,SAAS,GAAG,CAAC,YAAY,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC;YACxE,MAAM,KAAK,GACT,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,GAAG,SAAS,GAAG,CAAC,YAAY,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC;YACtE,IAAI,CAAC,UAAU,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;YAE3C,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;SAC7C;IACH,CAAC;IAED,UAAU,CAAC,UAAkB;QAC3B,MAAM,SAAS,GAAG,UAAU,IAAI,CAAC,CAAC;QAElC,IACE,CAAC,IAAI,CAAC,cAAc,KAAK,IAAI,CAAC,OAAO,IAAI,SAAS,KAAK,CAAC,CAAC;YACzD,CAAC,IAAI,CAAC,cAAc,KAAK,IAAI,CAAC,OAAO,IAAI,SAAS,KAAK,CAAC,CAAC,CAAC,EAC1D;YACA,OAAO;SACR;QAED,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,KAAK,CAC9B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,SAAS,CACpD,CAAC;QACF,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAES,qBAAqB,CAAC,IAAU;QACxC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACrB,OAAO,EAAE,CAAC;SACX;QACD,4DAA4D;QAC5D,MAAM,iBAAiB,GAKnB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,WAAgB,EAAE,EAAE;YAC7C,OAAO,CACL,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,IAAI,CAAC,OAAO,EAAE;gBAC7C,WAAW,CAAC,IAAI,KAAK,IAAI,CAAC,cAAc,CACzC,CAAC;QACJ,CAAC,EAAE,IAAI,CAAC,CAAC;QAET,OAAO,iBAAiB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,iBAAiB,CAAC,KAAK,CAAC;IACxE,CAAC;IAES,mBAAmB,CAC3B,aAA2C,EAC3C,KAAW;QAEX,IAAI,aAAa,KAAK,SAAS,IAAI,KAAK,KAAK,SAAS,EAAE;YACtD,OAAO,SAAS,CAAC;SAClB;QAED,IAAI,aAAa,CAAC,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAC1D,OAAO,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;SAC1D;QAED,IAAI,aAAa,CAAC,IAAI,KAAK,OAAO,IAAI,IAAI,CAAC,mBAAmB,EAAE;YAC9D,OAAO,IAAI,CAAC,mBAAmB,CAAC,aAAa,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;SAC5D;QAED,IAAI,aAAa,CAAC,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,kBAAkB,EAAE;YAC5D,OAAO,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;SAC3D;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAES,UAAU,CAAC,IAAU;QAC7B,IAAI,cAAc,GAAG,KAAK,CAAC;QAC3B,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,IAAI,CAAC,YAAY,CAAC,OAAO,CACvB,CAAC,YAA0C,EAAE,EAAE;gBAC7C,IAAI,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE;oBACtD,cAAc,GAAG,IAAI,CAAC;iBACvB;YACH,CAAC,CACF,CAAC;SACH;QAED,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,cAAc;gBACZ,cAAc;oBACd,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;SAChD;QAED,OAAO,CACL,cAAc;YACd,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACtD,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CACvD,CAAC;IACJ,CAAC;;gGA5WU,wBAAwB;2EAAxB,wBAAwB;;QALjC,yEAEM;;QAFA,yCAAoB;;uFAKjB,wBAAwB;cATpC,SAAS;eAAC;gBACT,QAAQ,EAAE,kBAAkB;gBAC5B,QAAQ,EAAE;;;;;GAKT;aACF;gBAEU,MAAM;kBAAd,KAAK;YACG,cAAc;kBAAtB,KAAK;YACG,WAAW;kBAAnB,KAAK;YACG,SAAS;kBAAjB,KAAK;YAEG,OAAO;kBAAf,KAAK;YACG,OAAO;kBAAf,KAAK;YACG,OAAO;kBAAf,KAAK;YACG,OAAO;kBAAf,KAAK;YACG,SAAS;kBAAjB,KAAK;YACG,SAAS;kBAAjB,KAAK;YACG,WAAW;kBAAnB,KAAK;YACG,UAAU;kBAAlB,KAAK;YACG,eAAe;kBAAvB,KAAK;YACG,cAAc;kBAAtB,KAAK;YACG,gBAAgB;kBAAxB,KAAK;YACG,gBAAgB;kBAAxB,KAAK;YACG,mBAAmB;kBAA3B,KAAK;YACG,WAAW;kBAAnB,KAAK;YACG,aAAa;kBAArB,KAAK;YACG,YAAY;kBAApB,KAAK;YACG,YAAY;kBAApB,KAAK;YACG,WAAW;kBAAnB,KAAK;YACG,QAAQ;kBAAhB,KAAK;YAEI,aAAa;kBAAtB,MAAM;YACG,MAAM;kBAAf,MAAM;YACG,gBAAgB;kBAAzB,MAAM;YAyBH,UAAU;kBADb,KAAK","sourcesContent":["/* tslint:disable: max-file-line-count */\nimport {\n  Component,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnInit,\n  Output,\n  SimpleChanges\n} from '@angular/core';\n\nimport { DateFormatter } from './date-formatter';\n\n\n@Component({\n  selector: 'datepicker-inner',\n  template: `\n    <!--&lt;!&ndash;ng-keydown=\"keydown($event)\"&ndash;&gt;-->\n    <div *ngIf=\"datepickerMode\" class=\"well well-sm bg-faded p-a card\" role=\"application\" >\n      <ng-content></ng-content>\n    </div>\n  `\n})\nexport class DatePickerInnerComponent implements OnInit, OnChanges {\n  @Input() locale: string;\n  @Input() datepickerMode: string;\n  @Input() startingDay: number;\n  @Input() yearRange: number;\n\n  @Input() minDate: Date;\n  @Input() maxDate: Date;\n  @Input() minMode: string;\n  @Input() maxMode: string;\n  @Input() showWeeks: boolean;\n  @Input() formatDay: string;\n  @Input() formatMonth: string;\n  @Input() formatYear: string;\n  @Input() formatDayHeader: string;\n  @Input() formatDayTitle: string;\n  @Input() formatMonthTitle: string;\n  @Input() onlyCurrentMonth: boolean;\n  @Input() shortcutPropagation: boolean;\n  @Input() customClass: { date: Date; mode: string; clazz: string }[];\n  @Input() monthColLimit: number;\n  @Input() yearColLimit: number;\n  @Input() dateDisabled: { date: Date; mode: string }[];\n  @Input() dayDisabled: number[];\n  @Input() initDate: Date;\n\n  @Output() selectionDone: EventEmitter<Date> = new EventEmitter<Date>(undefined);\n  @Output() update: EventEmitter<Date> = new EventEmitter<Date>(false);\n  @Output() activeDateChange: EventEmitter<Date> = new EventEmitter<Date>(undefined);\n\n  /* tslint:disable-next-line: no-any*/\n  stepDay: any = {};\n  /* tslint:disable-next-line: no-any*/\n  stepMonth: any = {};\n  /* tslint:disable-next-line: no-any*/\n  stepYear: any = {};\n\n  uniqueId: string;\n\n  protected modes: string[] = ['day', 'month', 'year'];\n  protected dateFormatter: DateFormatter = new DateFormatter();\n  protected _activeDate: Date;\n  protected selectedDate: Date;\n  protected activeDateId: string;\n\n  protected refreshViewHandlerDay: Function;\n  protected compareHandlerDay: Function;\n  protected refreshViewHandlerMonth: Function;\n  protected compareHandlerMonth: Function;\n  protected refreshViewHandlerYear: Function;\n  protected compareHandlerYear: Function;\n\n  @Input()\n  get activeDate(): Date {\n    return this._activeDate;\n  }\n\n  set activeDate(value: Date) {\n    this._activeDate = value;\n  }\n\n  // todo: add formatter value to Date object\n  ngOnInit(): void {\n    // todo: use date for unique value\n    this.uniqueId =  `datepicker--${Math.floor(Math.random() * 10000)}`;\n\n    if (this.initDate) {\n      this.activeDate = this.initDate;\n      this.selectedDate = new Date(this.activeDate.valueOf());\n      this.update.emit(this.activeDate);\n    } else if (this.activeDate === undefined) {\n      this.activeDate = new Date();\n    }\n  }\n\n  // this.refreshView should be called here to reflect the changes on the fly\n  // tslint:disable-next-line:no-unused-variable\n  ngOnChanges(changes: SimpleChanges): void {\n    this.refreshView();\n    this.checkIfActiveDateGotUpdated(changes.activeDate);\n  }\n\n  // Check if activeDate has been update and then emit the activeDateChange with the new date\n  /* tslint:disable-next-line: no-any */\n  checkIfActiveDateGotUpdated(activeDate: any): void {\n    if (activeDate && !activeDate.firstChange) {\n      const previousValue = activeDate.previousValue;\n      if (\n        previousValue &&\n        previousValue instanceof Date &&\n        previousValue.getTime() !== activeDate.currentValue.getTime()\n      ) {\n        this.activeDateChange.emit(this.activeDate);\n      }\n    }\n  }\n\n  setCompareHandler(handler: Function, type: string): void {\n    if (type === 'day') {\n      this.compareHandlerDay = handler;\n    }\n\n    if (type === 'month') {\n      this.compareHandlerMonth = handler;\n    }\n\n    if (type === 'year') {\n      this.compareHandlerYear = handler;\n    }\n  }\n\n  compare(date1: Date, date2: Date): number | undefined {\n    if (date1 === undefined || date2 === undefined) {\n      return undefined;\n    }\n\n    if (this.datepickerMode === 'day' && this.compareHandlerDay) {\n      return this.compareHandlerDay(date1, date2);\n    }\n\n    if (this.datepickerMode === 'month' && this.compareHandlerMonth) {\n      return this.compareHandlerMonth(date1, date2);\n    }\n\n    if (this.datepickerMode === 'year' && this.compareHandlerYear) {\n      return this.compareHandlerYear(date1, date2);\n    }\n\n    return void 0;\n  }\n\n  setRefreshViewHandler(handler: Function, type: string): void {\n    if (type === 'day') {\n      this.refreshViewHandlerDay = handler;\n    }\n\n    if (type === 'month') {\n      this.refreshViewHandlerMonth = handler;\n    }\n\n    if (type === 'year') {\n      this.refreshViewHandlerYear = handler;\n    }\n  }\n\n  refreshView(): void {\n    if (this.datepickerMode === 'day' && this.refreshViewHandlerDay) {\n      this.refreshViewHandlerDay();\n    }\n\n    if (this.datepickerMode === 'month' && this.refreshViewHandlerMonth) {\n      this.refreshViewHandlerMonth();\n    }\n\n    if (this.datepickerMode === 'year' && this.refreshViewHandlerYear) {\n      this.refreshViewHandlerYear();\n    }\n  }\n\n  dateFilter(date: Date, format: string): string {\n    return this.dateFormatter.format(date, format, this.locale);\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  isActive(dateObject: any): boolean {\n    if (this.compare(dateObject.date, this.activeDate) === 0) {\n      this.activeDateId = dateObject.uid;\n\n      return true;\n    }\n\n    return false;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  createDateObject(date: Date, format: string): any {\n    /* tslint:disable-next-line: no-any*/\n    const dateObject: any = {};\n    dateObject.date = new Date(\n      date.getFullYear(),\n      date.getMonth(),\n      date.getDate()\n    );\n    dateObject.date = this.fixTimeZone(dateObject.date);\n    dateObject.label = this.dateFilter(date, format);\n    dateObject.selected = this.compare(date, this.selectedDate) === 0;\n    dateObject.disabled = this.isDisabled(date);\n    dateObject.current = this.compare(date, new Date()) === 0;\n    dateObject.customClass = this.getCustomClassForDate(dateObject.date);\n\n    return dateObject;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  split(arr: any[], size: number): any[] {\n    /* tslint:disable-next-line: no-any*/\n    const arrays: any[] = [];\n    while (arr.length > 0) {\n      arrays.push(arr.splice(0, size));\n    }\n\n    return arrays;\n  }\n\n  // Fix a hard-reproducible bug with timezones\n  // The bug depends on OS, browser, current timezone and current date\n  // i.e.\n  // var date = new Date(2014, 0, 1);\n  // console.log(date.getFullYear(), date.getMonth(), date.getDate(),\n  // date.getHours()); can result in \"2013 11 31 23\" because of the bug.\n  fixTimeZone(date: Date): Date {\n    const hours = date.getHours();\n\n    return new Date(\n      date.getFullYear(),\n      date.getMonth(),\n      date.getDate(),\n      hours === 23 ? hours + 2 : 0\n    );\n  }\n\n  select(date: Date, isManual = true): void {\n    if (this.datepickerMode === this.minMode) {\n      if (!this.activeDate) {\n        this.activeDate = new Date(0, 0, 0, 0, 0, 0, 0);\n      }\n\n      this.activeDate = new Date(\n        date.getFullYear(),\n        date.getMonth(),\n        date.getDate()\n      );\n      this.activeDate = this.fixTimeZone(this.activeDate);\n      if (isManual) {\n        this.selectionDone.emit(this.activeDate);\n      }\n    } else {\n      this.activeDate = new Date(\n        date.getFullYear(),\n        date.getMonth(),\n        date.getDate()\n      );\n      this.activeDate = this.fixTimeZone(this.activeDate);\n      if (isManual) {\n        this.datepickerMode = this.modes[\n          this.modes.indexOf(this.datepickerMode) - 1\n        ];\n      }\n    }\n\n    this.selectedDate = new Date(this.activeDate.valueOf());\n    this.update.emit(this.activeDate);\n    this.refreshView();\n  }\n\n  move(direction: number): void {\n    /* tslint:disable-next-line: no-any*/\n    let expectedStep: any;\n    if (this.datepickerMode === 'day') {\n      expectedStep = this.stepDay;\n    }\n\n    if (this.datepickerMode === 'month') {\n      expectedStep = this.stepMonth;\n    }\n\n    if (this.datepickerMode === 'year') {\n      expectedStep = this.stepYear;\n    }\n\n    if (expectedStep) {\n      const year =\n        this.activeDate.getFullYear() + direction * (expectedStep.years || 0);\n      const month =\n        this.activeDate.getMonth() + direction * (expectedStep.months || 0);\n      this.activeDate = new Date(year, month, 1);\n\n      this.refreshView();\n      this.activeDateChange.emit(this.activeDate);\n    }\n  }\n\n  toggleMode(_direction: number): void {\n    const direction = _direction || 1;\n\n    if (\n      (this.datepickerMode === this.maxMode && direction === 1) ||\n      (this.datepickerMode === this.minMode && direction === -1)\n    ) {\n      return;\n    }\n\n    this.datepickerMode = this.modes[\n      this.modes.indexOf(this.datepickerMode) + direction\n    ];\n    this.refreshView();\n  }\n\n  protected getCustomClassForDate(date: Date): string {\n    if (!this.customClass) {\n      return '';\n    }\n    // todo: build a hash of custom classes, it will work faster\n    const customClassObject: {\n      date: Date;\n      mode: string;\n      clazz: string;\n    /* tslint:disable-next-line: no-any */\n    } = this.customClass.find((customClass: any) => {\n      return (\n        customClass.date.valueOf() === date.valueOf() &&\n        customClass.mode === this.datepickerMode\n      );\n    }, this);\n\n    return customClassObject === undefined ? '' : customClassObject.clazz;\n  }\n\n  protected compareDateDisabled(\n    date1Disabled: { date: Date; mode: string },\n    date2: Date\n  ): number {\n    if (date1Disabled === undefined || date2 === undefined) {\n      return undefined;\n    }\n\n    if (date1Disabled.mode === 'day' && this.compareHandlerDay) {\n      return this.compareHandlerDay(date1Disabled.date, date2);\n    }\n\n    if (date1Disabled.mode === 'month' && this.compareHandlerMonth) {\n      return this.compareHandlerMonth(date1Disabled.date, date2);\n    }\n\n    if (date1Disabled.mode === 'year' && this.compareHandlerYear) {\n      return this.compareHandlerYear(date1Disabled.date, date2);\n    }\n\n    return undefined;\n  }\n\n  protected isDisabled(date: Date): boolean {\n    let isDateDisabled = false;\n    if (this.dateDisabled) {\n      this.dateDisabled.forEach(\n        (disabledDate: { date: Date; mode: string }) => {\n          if (this.compareDateDisabled(disabledDate, date) === 0) {\n            isDateDisabled = true;\n          }\n        }\n      );\n    }\n\n    if (this.dayDisabled) {\n      isDateDisabled =\n        isDateDisabled ||\n        this.dayDisabled.indexOf(date.getDay()) > -1;\n    }\n\n    return (\n      isDateDisabled ||\n      (this.minDate && this.compare(date, this.minDate) < 0) ||\n      (this.maxDate && this.compare(date, this.maxDate) > 0)\n    );\n  }\n}\n"]}

package/esm2020/datepicker/datepicker.component.mjs

@@ -0,0 +1,182 @@
+import { Component, EventEmitter, forwardRef, Input, Output, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { DatePickerInnerComponent } from './datepicker-inner.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./datepicker.config";
+import * as i2 from "./datepicker-inner.component";
+import * as i3 from "./daypicker.component";
+import * as i4 from "./monthpicker.component";
+import * as i5 from "./yearpicker.component";
+export const DATEPICKER_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(() => DatePickerComponent),
+    multi: true
+};
+/* tslint:disable:component-selector-name component-selector-type */
+/* tslint:enable:component-selector-name component-selector-type */
+export class DatePickerComponent {
+    constructor(config) {
+        /** sets datepicker mode, supports: `day`, `month`, `year` */
+        this.datepickerMode = 'day';
+        /** if false week numbers will be hidden */
+        this.showWeeks = true;
+        this.selectionDone = new EventEmitter(undefined);
+        /** callback to invoke when the activeDate is changed. */
+        this.activeDateChange = new EventEmitter(undefined);
+        /* tslint:disable-next-line: no-any*/
+        this.onChange = Function.prototype;
+        /* tslint:disable-next-line: no-any*/
+        this.onTouched = Function.prototype;
+        this._now = new Date();
+        this.config = config;
+        this.configureOptions();
+    }
+    /** currently active date */
+    get activeDate() {
+        return this._activeDate || this._now;
+    }
+    set activeDate(value) {
+        this._activeDate = value;
+    }
+    configureOptions() {
+        Object.assign(this, this.config);
+    }
+    onUpdate(event) {
+        this.activeDate = event;
+        this.onChange(event);
+    }
+    onSelectionDone(event) {
+        this.selectionDone.emit(event);
+    }
+    onActiveDateChange(event) {
+        this.activeDateChange.emit(event);
+    }
+    // todo: support null value
+    /* tslint:disable-next-line: no-any*/
+    writeValue(value) {
+        if (this._datePicker.compare(value, this._activeDate) === 0) {
+            return;
+        }
+        if (value && value instanceof Date) {
+            this.activeDate = value;
+            this._datePicker.select(value, false);
+            return;
+        }
+        this.activeDate = value ? new Date(value) : void 0;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+}
+DatePickerComponent.ɵfac = function DatePickerComponent_Factory(t) { return new (t || DatePickerComponent)(i0.ɵɵdirectiveInject(i1.DatePickerConfig)); };
+DatePickerComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: DatePickerComponent, selectors: [["datepicker"]], viewQuery: function DatePickerComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(DatePickerInnerComponent, 7);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx._datePicker = _t.first);
+    } }, inputs: { datepickerMode: "datepickerMode", initDate: "initDate", minDate: "minDate", maxDate: "maxDate", minMode: "minMode", maxMode: "maxMode", showWeeks: "showWeeks", formatDay: "formatDay", formatMonth: "formatMonth", formatYear: "formatYear", formatDayHeader: "formatDayHeader", formatDayTitle: "formatDayTitle", formatMonthTitle: "formatMonthTitle", startingDay: "startingDay", yearRange: "yearRange", onlyCurrentMonth: "onlyCurrentMonth", shortcutPropagation: "shortcutPropagation", monthColLimit: "monthColLimit", yearColLimit: "yearColLimit", customClass: "customClass", dateDisabled: "dateDisabled", dayDisabled: "dayDisabled", activeDate: "activeDate" }, outputs: { selectionDone: "selectionDone", activeDateChange: "activeDateChange" }, features: [i0.ɵɵProvidersFeature([DATEPICKER_CONTROL_VALUE_ACCESSOR])], decls: 4, vars: 24, consts: [[3, "activeDate", "locale", "datepickerMode", "initDate", "minDate", "maxDate", "minMode", "maxMode", "showWeeks", "formatDay", "formatMonth", "formatYear", "formatDayHeader", "formatDayTitle", "formatMonthTitle", "startingDay", "yearRange", "customClass", "dateDisabled", "dayDisabled", "onlyCurrentMonth", "shortcutPropagation", "monthColLimit", "yearColLimit", "update", "selectionDone", "activeDateChange"], ["tabindex", "0"]], template: function DatePickerComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "datepicker-inner", 0);
+        i0.ɵɵlistener("update", function DatePickerComponent_Template_datepicker_inner_update_0_listener($event) { return ctx.onUpdate($event); })("selectionDone", function DatePickerComponent_Template_datepicker_inner_selectionDone_0_listener($event) { return ctx.onSelectionDone($event); })("activeDateChange", function DatePickerComponent_Template_datepicker_inner_activeDateChange_0_listener($event) { return ctx.onActiveDateChange($event); });
+        i0.ɵɵelement(1, "daypicker", 1)(2, "monthpicker", 1)(3, "yearpicker", 1);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵproperty("activeDate", ctx.activeDate)("locale", ctx.config.locale)("datepickerMode", ctx.datepickerMode)("initDate", ctx.initDate)("minDate", ctx.minDate)("maxDate", ctx.maxDate)("minMode", ctx.minMode)("maxMode", ctx.maxMode)("showWeeks", ctx.showWeeks)("formatDay", ctx.formatDay)("formatMonth", ctx.formatMonth)("formatYear", ctx.formatYear)("formatDayHeader", ctx.formatDayHeader)("formatDayTitle", ctx.formatDayTitle)("formatMonthTitle", ctx.formatMonthTitle)("startingDay", ctx.startingDay)("yearRange", ctx.yearRange)("customClass", ctx.customClass)("dateDisabled", ctx.dateDisabled)("dayDisabled", ctx.dayDisabled)("onlyCurrentMonth", ctx.onlyCurrentMonth)("shortcutPropagation", ctx.shortcutPropagation)("monthColLimit", ctx.monthColLimit)("yearColLimit", ctx.yearColLimit);
+    } }, dependencies: [i2.DatePickerInnerComponent, i3.DayPickerComponent, i4.MonthPickerComponent, i5.YearPickerComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DatePickerComponent, [{
+        type: Component,
+        args: [{
+                selector: 'datepicker',
+                template: `
+    <datepicker-inner [activeDate]="activeDate"
+                      (update)="onUpdate($event)"
+                      [locale]="config.locale"
+                      [datepickerMode]="datepickerMode"
+                      [initDate]="initDate"
+                      [minDate]="minDate"
+                      [maxDate]="maxDate"
+                      [minMode]="minMode"
+                      [maxMode]="maxMode"
+                      [showWeeks]="showWeeks"
+                      [formatDay]="formatDay"
+                      [formatMonth]="formatMonth"
+                      [formatYear]="formatYear"
+                      [formatDayHeader]="formatDayHeader"
+                      [formatDayTitle]="formatDayTitle"
+                      [formatMonthTitle]="formatMonthTitle"
+                      [startingDay]="startingDay"
+                      [yearRange]="yearRange"
+                      [customClass]="customClass"
+                      [dateDisabled]="dateDisabled"
+                      [dayDisabled]="dayDisabled"
+                      [onlyCurrentMonth]="onlyCurrentMonth"
+                      [shortcutPropagation]="shortcutPropagation"
+                      [monthColLimit]="monthColLimit"
+                      [yearColLimit]="yearColLimit"
+                      (selectionDone)="onSelectionDone($event)"
+                      (activeDateChange)="onActiveDateChange($event)">
+      <daypicker tabindex="0"></daypicker>
+      <monthpicker tabindex="0"></monthpicker>
+      <yearpicker tabindex="0"></yearpicker>
+    </datepicker-inner>
+    `,
+                providers: [DATEPICKER_CONTROL_VALUE_ACCESSOR]
+            }]
+    }], function () { return [{ type: i1.DatePickerConfig }]; }, { datepickerMode: [{
+            type: Input
+        }], initDate: [{
+            type: Input
+        }], minDate: [{
+            type: Input
+        }], maxDate: [{
+            type: Input
+        }], minMode: [{
+            type: Input
+        }], maxMode: [{
+            type: Input
+        }], showWeeks: [{
+            type: Input
+        }], formatDay: [{
+            type: Input
+        }], formatMonth: [{
+            type: Input
+        }], formatYear: [{
+            type: Input
+        }], formatDayHeader: [{
+            type: Input
+        }], formatDayTitle: [{
+            type: Input
+        }], formatMonthTitle: [{
+            type: Input
+        }], startingDay: [{
+            type: Input
+        }], yearRange: [{
+            type: Input
+        }], onlyCurrentMonth: [{
+            type: Input
+        }], shortcutPropagation: [{
+            type: Input
+        }], monthColLimit: [{
+            type: Input
+        }], yearColLimit: [{
+            type: Input
+        }], customClass: [{
+            type: Input
+        }], dateDisabled: [{
+            type: Input
+        }], dayDisabled: [{
+            type: Input
+        }], activeDate: [{
+            type: Input
+        }], selectionDone: [{
+            type: Output
+        }], activeDateChange: [{
+            type: Output
+        }], _datePicker: [{
+            type: ViewChild,
+            args: [DatePickerInnerComponent, { static: true }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker.component.js","sourceRoot":"","sources":["../../../../projects/mis-components/datepicker/datepicker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  EventEmitter,\n  forwardRef,\n  Input,\n  Output,\n  Provider,\n  ViewChild\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { DatePickerInnerComponent } from './datepicker-inner.component';\nimport { DatePickerConfig } from './datepicker.config';\n\nexport const DATEPICKER_CONTROL_VALUE_ACCESSOR: Provider = {\n  provide: NG_VALUE_ACCESSOR,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => DatePickerComponent),\n  multi: true\n};\n\n/* tslint:disable:component-selector-name component-selector-type */\n@Component({\n  selector: 'datepicker',\n  template: `\n    <datepicker-inner [activeDate]=\"activeDate\"\n                      (update)=\"onUpdate($event)\"\n                      [locale]=\"config.locale\"\n                      [datepickerMode]=\"datepickerMode\"\n                      [initDate]=\"initDate\"\n                      [minDate]=\"minDate\"\n                      [maxDate]=\"maxDate\"\n                      [minMode]=\"minMode\"\n                      [maxMode]=\"maxMode\"\n                      [showWeeks]=\"showWeeks\"\n                      [formatDay]=\"formatDay\"\n                      [formatMonth]=\"formatMonth\"\n                      [formatYear]=\"formatYear\"\n                      [formatDayHeader]=\"formatDayHeader\"\n                      [formatDayTitle]=\"formatDayTitle\"\n                      [formatMonthTitle]=\"formatMonthTitle\"\n                      [startingDay]=\"startingDay\"\n                      [yearRange]=\"yearRange\"\n                      [customClass]=\"customClass\"\n                      [dateDisabled]=\"dateDisabled\"\n                      [dayDisabled]=\"dayDisabled\"\n                      [onlyCurrentMonth]=\"onlyCurrentMonth\"\n                      [shortcutPropagation]=\"shortcutPropagation\"\n                      [monthColLimit]=\"monthColLimit\"\n                      [yearColLimit]=\"yearColLimit\"\n                      (selectionDone)=\"onSelectionDone($event)\"\n                      (activeDateChange)=\"onActiveDateChange($event)\">\n      <daypicker tabindex=\"0\"></daypicker>\n      <monthpicker tabindex=\"0\"></monthpicker>\n      <yearpicker tabindex=\"0\"></yearpicker>\n    </datepicker-inner>\n    `,\n  providers: [DATEPICKER_CONTROL_VALUE_ACCESSOR]\n})\n/* tslint:enable:component-selector-name component-selector-type */\nexport class DatePickerComponent implements ControlValueAccessor {\n  /** sets datepicker mode, supports: `day`, `month`, `year` */\n  @Input() datepickerMode = 'day';\n  /** default date to show if `ng-model` value is not specified */\n  @Input() initDate: Date;\n  /**  oldest selectable date */\n  @Input() minDate: Date;\n  /** latest selectable date */\n  @Input() maxDate: Date;\n  /** set lower datepicker mode, supports: `day`, `month`, `year` */\n  @Input() minMode: string;\n  /** sets upper datepicker mode, supports: `day`, `month`, `year` */\n  @Input() maxMode: string;\n  /** if false week numbers will be hidden */\n  @Input() showWeeks = true;\n  /** format of day in month */\n  @Input() formatDay: string;\n  /** format of month in year */\n  @Input() formatMonth: string;\n  /** format of year in year range */\n  @Input() formatYear: string;\n  /** format of day in week header */\n  @Input() formatDayHeader: string;\n  /** format of title when selecting day */\n  @Input() formatDayTitle: string;\n  /** format of title when selecting month */\n  @Input() formatMonthTitle: string;\n  /** starting day of the week from 0-6 (0=Sunday, ..., 6=Saturday) */\n  @Input() startingDay: number;\n  /** number of years displayed in year selection */\n  @Input() yearRange: number;\n  /** if true only dates from the currently displayed month will be shown */\n  @Input() onlyCurrentMonth: boolean;\n  /** if true shortcut`s event propagation will be disabled */\n  @Input() shortcutPropagation: boolean;\n  /** number of months displayed in a single row of month picker */\n  @Input() monthColLimit: number;\n  /** number of years displayed in a single row of year picker */\n  @Input() yearColLimit: number;\n  /** array of custom css classes to be applied to targeted dates */\n  @Input() customClass: { date: Date; mode: string; clazz: string }[];\n  /** array of disabled dates */\n  @Input() dateDisabled: { date: Date; mode: string }[];\n  /** disabled days of the week from 0-6 (0=Sunday, ..., 6=Saturday) */\n  @Input() dayDisabled: number[];\n\n  /** currently active date */\n  @Input()\n  get activeDate(): Date {\n    return this._activeDate || this._now;\n  }\n\n  set activeDate(value: Date) {\n    this._activeDate = value;\n  }\n\n  @Output()\n  selectionDone: EventEmitter<Date> = new EventEmitter<Date>(undefined);\n\n  /** callback to invoke when the activeDate is changed. */\n  @Output()\n  activeDateChange: EventEmitter<Date> = new EventEmitter<Date>(\n    undefined\n  );\n\n  @ViewChild(DatePickerInnerComponent, { static: true })\n  _datePicker: DatePickerInnerComponent;\n\n  /* tslint:disable-next-line: no-any*/\n  onChange: any = Function.prototype;\n  /* tslint:disable-next-line: no-any*/\n  onTouched: any = Function.prototype;\n\n  config: DatePickerConfig;\n\n  protected _now: Date = new Date();\n  protected _activeDate: Date;\n\n  constructor(config: DatePickerConfig) {\n    this.config = config;\n    this.configureOptions();\n  }\n\n  configureOptions(): void {\n    Object.assign(this, this.config);\n  }\n\n  onUpdate(event: Date): void {\n    this.activeDate = event;\n    this.onChange(event);\n  }\n\n  onSelectionDone(event: Date): void {\n    this.selectionDone.emit(event);\n  }\n\n  onActiveDateChange(event: Date): void {\n    this.activeDateChange.emit(event);\n  }\n  // todo: support null value\n  /* tslint:disable-next-line: no-any*/\n  writeValue(value: any): void {\n    if (this._datePicker.compare(value, this._activeDate) === 0) {\n      return;\n    }\n    if (value && value instanceof Date) {\n      this.activeDate = value;\n      this._datePicker.select(value, false);\n\n      return;\n    }\n\n    this.activeDate = value ? new Date(value) : void 0;\n  }\n\n  registerOnChange(fn: () => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n}\n"]}

package/esm2020/datepicker/datepicker.config.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DatePickerConfig {
+    constructor() {
+        this.locale = 'en';
+        this.datepickerMode = 'day';
+        this.startingDay = 0;
+        this.yearRange = 20;
+        this.minMode = 'day';
+        this.maxMode = 'year';
+        this.showWeeks = true;
+        this.formatDay = 'DD';
+        this.formatMonth = 'MMMM';
+        this.formatYear = 'YYYY';
+        this.formatDayHeader = 'dd';
+        this.formatDayTitle = 'MMMM YYYY';
+        this.formatMonthTitle = 'YYYY';
+        this.onlyCurrentMonth = false;
+        this.monthColLimit = 3;
+        this.yearColLimit = 5;
+        this.shortcutPropagation = false;
+    }
+}
+DatePickerConfig.ɵfac = function DatePickerConfig_Factory(t) { return new (t || DatePickerConfig)(); };
+DatePickerConfig.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DatePickerConfig, factory: DatePickerConfig.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DatePickerConfig, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXBpY2tlci5jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9taXMtY29tcG9uZW50cy9kYXRlcGlja2VyL2RhdGVwaWNrZXIuY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyxnQkFBZ0I7SUFIN0I7UUFJRSxXQUFNLEdBQUcsSUFBSSxDQUFDO1FBQ2QsbUJBQWMsR0FBRyxLQUFLLENBQUM7UUFDdkIsZ0JBQVcsR0FBRyxDQUFDLENBQUM7UUFDaEIsY0FBUyxHQUFHLEVBQUUsQ0FBQztRQUNmLFlBQU8sR0FBRyxLQUFLLENBQUM7UUFDaEIsWUFBTyxHQUFHLE1BQU0sQ0FBQztRQUNqQixjQUFTLEdBQUcsSUFBSSxDQUFDO1FBQ2pCLGNBQVMsR0FBRyxJQUFJLENBQUM7UUFDakIsZ0JBQVcsR0FBRyxNQUFNLENBQUM7UUFDckIsZUFBVSxHQUFHLE1BQU0sQ0FBQztRQUNwQixvQkFBZSxHQUFHLElBQUksQ0FBQztRQUN2QixtQkFBYyxHQUFHLFdBQVcsQ0FBQztRQUM3QixxQkFBZ0IsR0FBRyxNQUFNLENBQUM7UUFDMUIscUJBQWdCLEdBQUcsS0FBSyxDQUFDO1FBQ3pCLGtCQUFhLEdBQUcsQ0FBQyxDQUFDO1FBQ2xCLGlCQUFZLEdBQUcsQ0FBQyxDQUFDO1FBQ2pCLHdCQUFtQixHQUFHLEtBQUssQ0FBQztLQUM3Qjs7Z0ZBbEJZLGdCQUFnQjtzRUFBaEIsZ0JBQWdCLFdBQWhCLGdCQUFnQixtQkFGZixNQUFNO3VGQUVQLGdCQUFnQjtjQUg1QixVQUFVO2VBQUM7Z0JBQ1YsVUFBVSxFQUFFLE1BQU07YUFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIERhdGVQaWNrZXJDb25maWcge1xuICBsb2NhbGUgPSAnZW4nO1xuICBkYXRlcGlja2VyTW9kZSA9ICdkYXknO1xuICBzdGFydGluZ0RheSA9IDA7XG4gIHllYXJSYW5nZSA9IDIwO1xuICBtaW5Nb2RlID0gJ2RheSc7XG4gIG1heE1vZGUgPSAneWVhcic7XG4gIHNob3dXZWVrcyA9IHRydWU7XG4gIGZvcm1hdERheSA9ICdERCc7XG4gIGZvcm1hdE1vbnRoID0gJ01NTU0nO1xuICBmb3JtYXRZZWFyID0gJ1lZWVknO1xuICBmb3JtYXREYXlIZWFkZXIgPSAnZGQnO1xuICBmb3JtYXREYXlUaXRsZSA9ICdNTU1NIFlZWVknO1xuICBmb3JtYXRNb250aFRpdGxlID0gJ1lZWVknO1xuICBvbmx5Q3VycmVudE1vbnRoID0gZmFsc2U7XG4gIG1vbnRoQ29sTGltaXQgPSAzO1xuICB5ZWFyQ29sTGltaXQgPSA1O1xuICBzaG9ydGN1dFByb3BhZ2F0aW9uID0gZmFsc2U7XG59XG4iXX0=