@colijnit/corecomponents_v12 12.2.21 → 12.2.23

package/esm2015/lib/components/calendar/calendar-template.component.js

@@ -0,0 +1,342 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from "@angular/core";
+import { CoreComponentsIcon } from "../../core/enum/core-components-icon.enum";
+export class CalendarTemplateComponent {
+    constructor() {
+        this.icons = CoreComponentsIcon;
+        this.showWeekNumbers = true;
+        this.weekNumbers = [];
+        this.locale = "nl-NL";
+        this.highlightDaysBetweenDates = false;
+        this.dateSelected = new EventEmitter();
+        this.hoveringDate = new EventEmitter();
+        this.showCalendarBody = true;
+        this.showMonthSelection = false;
+        this.showYearSelection = false;
+        this.monthHeader = '';
+        this.yearHeader = '';
+        this.monthSelection = true;
+        this.yearSelection = false;
+        this.dayNames = [];
+        this.monthNames = [];
+        this.monthSelectionNames = [];
+        this.yearSelectionYears = [];
+        this.daysInMonth = [];
+        this.daysUnixTimestamps = [];
+        this.daysToHighlight = [];
+    }
+    set selectedDate(date) {
+        this._selectedDate = !!date ? new Date(date.getFullYear(), date.getMonth(), date.getDate()) : date;
+        if (this.secondSelectedDate && date && this.secondSelectedDate.getTime() < this.selectedDate.getTime() && this.temporarySelectedSecondaryDate) {
+            this.daysToHighlight = [];
+        }
+    }
+    get selectedDate() {
+        return this._selectedDate;
+    }
+    set secondSelectedDate(date) {
+        this._secondSelectedDate = !!date ? new Date(date.getFullYear(), date.getMonth(), date.getDate()) : date;
+        if (!this.selectedDate) {
+            this.daysToHighlight = [];
+        }
+        else {
+            this._fillDatesBetweenSelected();
+        }
+    }
+    get secondSelectedDate() {
+        return this._secondSelectedDate;
+    }
+    set secondHoveringDate(date) {
+        this._secondHoveringDate = date;
+        if (!!date) {
+            this.temporarySelectedSecondaryDate = null;
+        }
+        if (this.selectedDate && !this.secondSelectedDate) {
+            this.temporarySelectedSecondaryDate = new Date(date);
+        }
+        this.handleMouseOverDay(date);
+    }
+    get secondHoveringDate() {
+        return this._secondHoveringDate;
+    }
+    showClass() {
+        return true;
+    }
+    ngOnInit() {
+        this._setInitialValues();
+        this.generateMonthNames();
+        this.generateCalendar();
+        this._fillDatesBetweenSelected();
+    }
+    prevMonth() {
+        if (this.workingMonth === 0) {
+            this.workingMonth = 11;
+            this.workingYear--;
+        }
+        else {
+            this.workingMonth--;
+        }
+        this.generateCalendar();
+        this._fillDatesBetweenSelected();
+        this.calculateWeekNumbers();
+    }
+    nextMonth() {
+        if (this.workingMonth === 11) {
+            this.workingMonth = 0;
+            this.workingYear++;
+        }
+        else {
+            this.workingMonth++;
+        }
+        this.generateCalendar();
+        this._fillDatesBetweenSelected();
+        this.calculateWeekNumbers();
+    }
+    prevYear() {
+        this.workingYear--;
+        this.generateCalendar();
+    }
+    nextYear() {
+        this.workingYear++;
+        this.generateCalendar();
+    }
+    generateCalendar() {
+        this._setMonthDaysForDate(this.workingMonth);
+        // Update the displayed month
+        const month = this.monthNames[this.workingMonth];
+        const year = this.workingYear;
+        // Update headerText
+        this.monthHeader = `${month} ${year}`;
+        this.yearHeader = `${year}`;
+        this.generateYearSelectionYears();
+        this.calculateWeekNumbers();
+    }
+    _setInitialValues() {
+        this.workingDay = this.selectedDate ? this.selectedDate : new Date();
+        this.workingYear = this.workingDay.getFullYear();
+        this.workingMonth = this.workingDay.getMonth();
+    }
+    _setMonthDaysForDate(monthNumber) {
+        this.daysInMonth = [];
+        const firstDayOfMonth = new Date(this.workingYear, monthNumber, 0).getDay();
+        const lastDayOfMonth = new Date(this.workingYear, monthNumber + 1, 0).getDate();
+        // Add null values to the beginning of the array to align the first day with the correct day of the week
+        for (let i = 0; i < firstDayOfMonth; i++) {
+            this.daysInMonth.push(null);
+        }
+        // Add the days of the current month to the array
+        for (let i = 1; i <= lastDayOfMonth; i++) {
+            const date = new Date(this.workingYear, this.workingMonth, i);
+            this.daysInMonth.push(date);
+        }
+        // Add null values to the end of the array to fill out the grid
+        // const remainingCells = 42 - this.daysInMonth.length;
+        // for (let i = 0; i < remainingCells; i++) {
+        //   this.daysInMonth.push(null);
+        // }
+        this.daysUnixTimestamps = this.daysInMonth.map(day => { return day ? day.getTime() : undefined; });
+    }
+    generateYearSelectionYears() {
+        const pastYears = 5;
+        const futureYears = 3;
+        const years = [];
+        for (let i = pastYears; i >= 1; i--) {
+            years.push(this.workingYear - i);
+        }
+        years.push(this.workingYear);
+        for (let i = 1; i <= futureYears; i++) {
+            years.push(this.workingYear + i);
+        }
+        this.yearSelectionYears = years.reverse();
+    }
+    openMonthSelection() {
+        this.showCalendarBody = false;
+        this.monthSelection = false;
+        this.yearSelection = true;
+        this.showMonthSelection = true;
+    }
+    openYearSelection() {
+        this.showMonthSelection = false;
+        this.showYearSelection = true;
+    }
+    selectDate(day) {
+        this.selectedDate = day;
+        this._fillDatesBetweenSelected();
+        this.dateSelected.emit(new Date(this.selectedDate));
+    }
+    selectMonth(month) {
+        this.showSelectedMonth = month;
+        this.workingMonth = this.monthSelectionNames.indexOf(month);
+        this.showMonthSelection = false;
+        this.yearSelection = false;
+        this.monthSelection = true;
+        this.showCalendarBody = true;
+        this.generateCalendar();
+    }
+    selectYear(year) {
+        this.workingYear = year;
+        this.showYearSelection = false;
+        this.showMonthSelection = true;
+        this.generateCalendar();
+    }
+    generateMonthNames() {
+        for (let i = 0; i < 12; i++) {
+            const date = new Date(2000, i, 1);
+            const monthNameShort = date.toLocaleString(this.locale, { month: 'short' });
+            const monthNameFull = date.toLocaleString(this.locale, { month: 'long' });
+            this.monthSelectionNames.push(this._capitalizeFirstLetter(monthNameShort));
+            this.monthNames.push(this._capitalizeFirstLetter(monthNameFull));
+        }
+        for (let i = 1; i <= 7; i++) {
+            const date = new Date(2018, 0, i);
+            const weekdayName = date.toLocaleString(this.locale, { weekday: 'short' });
+            this.dayNames.push(this._capitalizeFirstLetter(weekdayName));
+        }
+    }
+    handleMouseOverDay(day) {
+        if (this.highlightDaysBetweenDates && day && (this.selectedDate || this.secondSelectedDate) && !(this.selectedDate && this.secondSelectedDate) && !(this.selectedDate && !this.temporarySelectedSecondaryDate && !this.secondSelectedDate)) {
+            this.daysToHighlight = [];
+            if (this.daysUnixTimestamps.includes(day.getTime())) {
+                this.daysToHighlight.push(...this.daysInMonth.map((dayInMonth) => {
+                    if (this.selectedDate) {
+                        if (dayInMonth &&
+                            // day in the month is after selected date and day in the month is before the hovering day
+                            (dayInMonth.getTime() > this.selectedDate.getTime() && dayInMonth.getTime() < day.getTime()) ||
+                            // second date is after selected date and day in the month is before hovering day and day in month is after selected date
+                            (this._secondHoveringDate && this._secondHoveringDate.getTime() > this.selectedDate.getTime() && day && dayInMonth && dayInMonth.getTime() < day.getTime() && dayInMonth.getTime() > this.selectedDate.getTime())) {
+                            return dayInMonth;
+                        }
+                    }
+                    else {
+                        if (dayInMonth &&
+                            // day in the month is after second date and day in the month is before the hovering day
+                            (dayInMonth.getTime() > this.secondSelectedDate.getTime() && dayInMonth.getTime() < day.getTime())) {
+                            return dayInMonth;
+                        }
+                    }
+                }));
+            }
+            else {
+                this.daysToHighlight.push(...this.daysInMonth.map((day) => {
+                    if (day > this.selectedDate) {
+                        return day;
+                    }
+                }));
+            }
+        }
+        this.hoveringDate.next(day);
+    }
+    _fillDatesBetweenSelected() {
+        if (this.selectedDate && this.secondSelectedDate) {
+            this.daysToHighlight = [];
+            this.daysToHighlight.push(...this.daysInMonth.map((dayInMonth) => {
+                if (dayInMonth && (dayInMonth > this.selectedDate && dayInMonth < this.secondSelectedDate) || (dayInMonth > this.secondSelectedDate && dayInMonth < this.selectedDate)) {
+                    return dayInMonth;
+                }
+            }));
+        }
+    }
+    _capitalizeFirstLetter(value) {
+        return value.charAt(0).toUpperCase() + value.slice(1);
+    }
+    calculateWeekNumbers() {
+        this.weekNumbers = [];
+        let weekNumber = null;
+        for (let i = 0; i < this.daysInMonth.length; i++) {
+            const day = this.daysInMonth[i];
+            if (day) {
+                // Start of a new week or first day of the month, calculate and set weekNumber
+                weekNumber = this.getISOWeek(day);
+                // Check if the weekNumber is not already in the array
+                if (!this.weekNumbers.includes(weekNumber)) {
+                    this.weekNumbers.push(weekNumber);
+                }
+            }
+        }
+    }
+    getISOWeek(date) {
+        const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+        d.setUTCDate(d.getUTCDate() + 4 - (d.getUTCDay() || 7));
+        const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+        const weekNumber = Math.ceil(((d.valueOf() - yearStart.valueOf()) / 86400000 + 1) / 7);
+        return weekNumber;
+    }
+}
+CalendarTemplateComponent.decorators = [
+    { type: Component, args: [{
+                selector: "calendar-template",
+                template: `
+      <div class="calendar">
+        <div class="calendar-header" *ngIf="monthSelection || yearSelection">
+          <co-icon class="calendar-change-month-button" [icon]="icons.ArrowPointLeft" (click)="prevMonth()"></co-icon>
+
+          <div class="calendar-header-title-wrapper">
+            <span class="calendar-header-title" [textContent]="monthSelection ? monthHeader : yearHeader"
+                  (click)="monthSelection ? openMonthSelection() : openYearSelection()"
+            ></span>
+          </div>
+
+          <co-icon class="calendar-change-month-button" [icon]="icons.ArrowPointRight" (click)="nextMonth()"></co-icon>
+        </div>
+
+        <div class="selection-grid month" *ngIf="showMonthSelection">
+          <div *ngFor="let month of monthSelectionNames"
+               class="calendar-month-or-year"
+               (click)="selectMonth(month)">
+            <ng-container *ngIf="month">
+              <div class="month" [textContent]="month"></div>
+            </ng-container>
+          </div>
+        </div>
+
+        <div class="selection-grid year" *ngIf="showYearSelection">
+          <div *ngFor="let year of yearSelectionYears"
+               class="calendar-month-or-year"
+               (click)="selectYear(year)"
+               [textContent]="year">
+            <ng-container *ngIf="year">
+              <div class="year" [textContent]="year"></div>
+            </ng-container>
+          </div>
+        </div>
+        <div class="calendar-wrapper">
+          <div class="week-wrapper" *ngIf="showWeekNumbers && showCalendarBody">
+            <div class="week-number" [textContent]="'W'"></div>
+            <div class="week-number" *ngFor="let weekNumber of weekNumbers">
+              {{ weekNumber }}
+            </div>
+          </div>
+          <div class="calendar-body" *ngIf="showCalendarBody">
+            <div class="day-names">
+              <div class="weekday" *ngFor="let dayName of dayNames" [textContent]="dayName"></div>
+            </div>
+            <div *ngFor="let day of daysInMonth" class="calendar-day"
+                 [class.highlighted-day]="daysToHighlight.includes(day)"
+                 [class.selected-day]="selectedDate && (day && day.getTime() === selectedDate.getTime()) ||
+            secondSelectedDate && (day && day.getTime() === secondSelectedDate.getTime()) ||
+            temporarySelectedSecondaryDate && (day && day.getTime() === temporarySelectedSecondaryDate.getTime())"
+                 (click)="selectDate(day)"
+                 (mouseover)="handleMouseOverDay(day)">
+              <!-- Day number -->
+              <ng-container *ngIf="day">
+                <div class="day-number" [textContent]="day.getDate()"></div>
+              </ng-container>
+            </div>
+          </div>
+        </div>
+      </div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+CalendarTemplateComponent.propDecorators = {
+    showWeekNumbers: [{ type: Input }],
+    locale: [{ type: Input }],
+    highlightDaysBetweenDates: [{ type: Input }],
+    selectedDate: [{ type: Input }],
+    secondSelectedDate: [{ type: Input }],
+    secondHoveringDate: [{ type: Input }],
+    dateSelected: [{ type: Output }],
+    hoveringDate: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.calendar-template",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar-template.component.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/calendar/calendar-template.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAc,YAAY,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAC,MAAM,eAAe,CAAC;AACjH,OAAO,EAAC,kBAAkB,EAAC,MAAM,2CAA2C,CAAC;AAmE7E,MAAM,OAAO,yBAAyB;IAjEtC;QAkEkB,UAAK,GAA8B,kBAAkB,CAAC;QAG/D,oBAAe,GAAY,IAAI,CAAC;QAEhC,gBAAW,GAAa,EAAE,CAAC;QAE3B,WAAM,GAAW,OAAO,CAAC;QAGzB,8BAAyB,GAAY,KAAK,CAAC;QA6C3C,iBAAY,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAG5D,iBAAY,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAE5D,qBAAgB,GAAY,IAAI,CAAC;QACjC,uBAAkB,GAAY,KAAK,CAAC;QACpC,sBAAiB,GAAY,KAAK,CAAC;QAOnC,gBAAW,GAAW,EAAE,CAAC;QACzB,eAAU,GAAW,EAAE,CAAC;QAExB,mBAAc,GAAY,IAAI,CAAC;QAC/B,kBAAa,GAAY,KAAK,CAAC;QAE/B,aAAQ,GAAG,EAAE,CAAC;QACd,eAAU,GAAG,EAAE,CAAC;QAChB,wBAAmB,GAAa,EAAE,CAAC;QACnC,uBAAkB,GAAa,EAAE,CAAC;QAClC,gBAAW,GAAW,EAAE,CAAC;QAEzB,uBAAkB,GAAa,EAAE,CAAC;QAClC,oBAAe,GAAW,EAAE,CAAC;IAgPtC,CAAC;IAtTC,IACW,YAAY,CAAC,IAAU;QAChC,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACnG,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,IAAI,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,8BAA8B,EAAE;YAC7I,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;SAC3B;IACH,CAAC;IAED,IAAW,YAAY;QACrB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,IACW,kBAAkB,CAAC,IAAU;QACtC,IAAI,CAAC,mBAAmB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACzG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACtB,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;SAC3B;aAAM;YACL,IAAI,CAAC,yBAAyB,EAAE,CAAC;SAClC;IACH,CAAC;IAED,IAAW,kBAAkB;QAC3B,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAED,IACW,kBAAkB,CAAC,IAAW;QACvC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAChC,IAAI,CAAC,CAAC,IAAI,EAAE;YACV,IAAI,CAAC,8BAA8B,GAAG,IAAI,CAAC;SAC5C;QACD,IAAI,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE;YACjD,IAAI,CAAC,8BAA8B,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;SACtD;QACD,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,IAAW,kBAAkB;QAC3B,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAsCM,SAAS;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,QAAQ;QACb,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,yBAAyB,EAAE,CAAC;IACnC,CAAC;IAEM,SAAS;QACd,IAAI,IAAI,CAAC,YAAY,KAAK,CAAC,EAAE;YAC3B,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;YACvB,IAAI,CAAC,WAAW,EAAE,CAAC;SACpB;aAAM;YACL,IAAI,CAAC,YAAY,EAAE,CAAC;SACrB;QACD,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACjC,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAEM,SAAS;QACd,IAAI,IAAI,CAAC,YAAY,KAAK,EAAE,EAAE;YAC5B,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;YACtB,IAAI,CAAC,WAAW,EAAE,CAAC;SACpB;aAAM;YACL,IAAI,CAAC,YAAY,EAAE,CAAC;SACrB;QACD,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACjC,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAEM,QAAQ;QACb,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAEM,QAAQ;QACb,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAEM,gBAAgB;QACrB,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAE7C,6BAA6B;QAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACjD,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC;QAE9B,oBAAoB;QACpB,IAAI,CAAC,WAAW,GAAG,GAAG,KAAK,IAAI,IAAI,EAAE,CAAC;QACtC,IAAI,CAAC,UAAU,GAAG,GAAG,IAAI,EAAE,CAAC;QAE5B,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAClC,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAEO,iBAAiB;QACvB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC;QACrE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;QACjD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IACjD,CAAC;IAEO,oBAAoB,CAAC,WAAmB;QAC9C,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;QAEtB,MAAM,eAAe,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QAC5E,MAAM,cAAc,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;QAEhF,wGAAwG;QACxG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC,EAAE,EAAE;YACxC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC7B;QAED,iDAAiD;QACjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,cAAc,EAAE,CAAC,EAAE,EAAE;YACxC,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;YAC9D,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC7B;QAED,+DAA+D;QAC/D,uDAAuD;QACvD,6CAA6C;QAC7C,iCAAiC;QACjC,IAAI;QAEJ,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,OAAO,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,SAAS,CAAA,CAAC,CAAC,CAAC,CAAC;IACpG,CAAC;IAEM,0BAA0B;QAC/B,MAAM,SAAS,GAAG,CAAC,CAAC;QACpB,MAAM,WAAW,GAAG,CAAC,CAAC;QACtB,MAAM,KAAK,GAAG,EAAE,CAAC;QAEjB,KAAK,IAAI,CAAC,GAAG,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YAEnC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;SAClC;QAED,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAE7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,WAAW,EAAE,CAAC,EAAE,EAAE;YACrC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;SAClC;QAED,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;IAC5C,CAAC;IAEM,kBAAkB;QACvB,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;IACjC,CAAC;IAEM,iBAAiB;QACtB,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAChC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAChC,CAAC;IAEM,UAAU,CAAC,GAAS;QACzB,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC;QACxB,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACjC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;IACtD,CAAC;IAEM,WAAW,CAAC,KAAa;QAC9B,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;QAC/B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAC5D,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAChC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAC3B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAEM,UAAU,CAAC,IAAY;QAC5B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;QAC/B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAC/B,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAEM,kBAAkB;QACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE;YAC3B,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YAClC,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,EAAC,KAAK,EAAE,OAAO,EAAC,CAAC,CAAC;YAC1E,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,EAAC,KAAK,EAAE,MAAM,EAAC,CAAC,CAAC;YACxE,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,cAAc,CAAC,CAAC,CAAC;YAC3E,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,aAAa,CAAC,CAAC,CAAC;SAClE;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YAC3B,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YAClC,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;YAC3E,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC,CAAC;SAC9D;IACH,CAAC;IAEM,kBAAkB,CAAC,GAAS;QACjC,IAAI,IAAI,CAAC,yBAAyB,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,8BAA8B,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAAE;YAC1O,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;YAC1B,IAAI,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,EAAE;gBACnD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,UAAgB,EAAE,EAAE;oBACrE,IAAI,IAAI,CAAC,YAAY,EAAE;wBACrB,IAAI,UAAU;4BACZ,0FAA0F;4BAC1F,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,IAAI,UAAU,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC;4BAC5F,yHAAyH;4BACzH,CAAC,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,UAAU,IAAI,UAAU,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,OAAO,EAAE,IAAI,UAAU,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC,EAAE;4BACnN,OAAO,UAAU,CAAC;yBACnB;qBACF;yBAAM;wBACL,IAAI,UAAU;4BACZ,wFAAwF;4BACxF,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,IAAI,UAAU,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC,EAAE;4BACpG,OAAO,UAAU,CAAC;yBACnB;qBACF;gBACH,CAAC,CAAC,CAAC,CAAC;aACL;iBAAM;gBACL,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;oBACxD,IAAI,GAAG,GAAG,IAAI,CAAC,YAAY,EAAE;wBAC3B,OAAO,GAAG,CAAC;qBACZ;gBACH,CAAC,CAAC,CAAC,CAAC;aACL;SACF;QACD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAEO,yBAAyB;QAC/B,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,kBAAkB,EAAE;YAChD,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;YAC1B,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,UAAgB,EAAE,EAAE;gBACrE,IAAI,UAAU,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,IAAI,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,kBAAkB,IAAI,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,EAAE;oBACtK,OAAO,UAAU,CAAC;iBACnB;YACH,CAAC,CAAC,CAAC,CAAC;SACL;IACH,CAAC;IAEO,sBAAsB,CAAC,KAAa;QAC1C,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACxD,CAAC;IACO,oBAAoB;QAC1B,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;QACtB,IAAI,UAAU,GAAkB,IAAI,CAAC;QACrC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAChD,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YAChC,IAAI,GAAG,EAAE;gBACL,8EAA8E;gBAC9E,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;gBAClC,sDAAsD;gBACtD,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;oBAC1C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;iBACnC;aACJ;SACF;IACH,CAAC;IAGM,UAAU,CAAC,IAAU;QACxB,MAAM,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;QAClF,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,cAAc,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/D,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,QAAQ,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACvF,OAAO,UAAU,CAAC;IACtB,CAAC;;;YAnYF,SAAS,SAAC;gBACT,QAAQ,EAAE,mBAAmB;gBAC7B,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DT;gBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;aACtC;;;8BAIE,KAAK;qBAIL,KAAK;wCAGL,KAAK;2BAGL,KAAK;iCAYL,KAAK;iCAcL,KAAK;2BAgBL,MAAM;2BAGN,MAAM;wBAgCN,WAAW,SAAC,yBAAyB","sourcesContent":["import {Component, ElementRef, EventEmitter, HostBinding, Input, Output, ViewEncapsulation} from \"@angular/core\";\r\nimport {CoreComponentsIcon} from \"../../core/enum/core-components-icon.enum\";\r\n\r\n@Component({\r\n  selector: \"calendar-template\",\r\n  template: `\r\n      <div class=\"calendar\">\r\n        <div class=\"calendar-header\" *ngIf=\"monthSelection || yearSelection\">\r\n          <co-icon class=\"calendar-change-month-button\" [icon]=\"icons.ArrowPointLeft\" (click)=\"prevMonth()\"></co-icon>\r\n\r\n          <div class=\"calendar-header-title-wrapper\">\r\n            <span class=\"calendar-header-title\" [textContent]=\"monthSelection ? monthHeader : yearHeader\"\r\n                  (click)=\"monthSelection ? openMonthSelection() : openYearSelection()\"\r\n            ></span>\r\n          </div>\r\n\r\n          <co-icon class=\"calendar-change-month-button\" [icon]=\"icons.ArrowPointRight\" (click)=\"nextMonth()\"></co-icon>\r\n        </div>\r\n\r\n        <div class=\"selection-grid month\" *ngIf=\"showMonthSelection\">\r\n          <div *ngFor=\"let month of monthSelectionNames\"\r\n               class=\"calendar-month-or-year\"\r\n               (click)=\"selectMonth(month)\">\r\n            <ng-container *ngIf=\"month\">\r\n              <div class=\"month\" [textContent]=\"month\"></div>\r\n            </ng-container>\r\n          </div>\r\n        </div>\r\n\r\n        <div class=\"selection-grid year\" *ngIf=\"showYearSelection\">\r\n          <div *ngFor=\"let year of yearSelectionYears\"\r\n               class=\"calendar-month-or-year\"\r\n               (click)=\"selectYear(year)\"\r\n               [textContent]=\"year\">\r\n            <ng-container *ngIf=\"year\">\r\n              <div class=\"year\" [textContent]=\"year\"></div>\r\n            </ng-container>\r\n          </div>\r\n        </div>\r\n        <div class=\"calendar-wrapper\">\r\n          <div class=\"week-wrapper\" *ngIf=\"showWeekNumbers && showCalendarBody\">\r\n            <div class=\"week-number\" [textContent]=\"'W'\"></div>\r\n            <div class=\"week-number\" *ngFor=\"let weekNumber of weekNumbers\">\r\n              {{ weekNumber }}\r\n            </div>\r\n          </div>\r\n          <div class=\"calendar-body\" *ngIf=\"showCalendarBody\">\r\n            <div class=\"day-names\">\r\n              <div class=\"weekday\" *ngFor=\"let dayName of dayNames\" [textContent]=\"dayName\"></div>\r\n            </div>\r\n            <div *ngFor=\"let day of daysInMonth\" class=\"calendar-day\"\r\n                 [class.highlighted-day]=\"daysToHighlight.includes(day)\"\r\n                 [class.selected-day]=\"selectedDate && (day && day.getTime() === selectedDate.getTime()) ||\r\n            secondSelectedDate && (day && day.getTime() === secondSelectedDate.getTime()) ||\r\n            temporarySelectedSecondaryDate && (day && day.getTime() === temporarySelectedSecondaryDate.getTime())\"\r\n                 (click)=\"selectDate(day)\"\r\n                 (mouseover)=\"handleMouseOverDay(day)\">\r\n              <!-- Day number -->\r\n              <ng-container *ngIf=\"day\">\r\n                <div class=\"day-number\" [textContent]=\"day.getDate()\"></div>\r\n              </ng-container>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class CalendarTemplateComponent {\r\n  public readonly icons: typeof CoreComponentsIcon = CoreComponentsIcon;\r\n\r\n  @Input()\r\n  public showWeekNumbers: boolean = true;\r\n\r\n  public weekNumbers: number[] = [];\r\n  @Input()\r\n  public locale: string = \"nl-NL\";\r\n\r\n  @Input()\r\n  public highlightDaysBetweenDates: boolean = false;\r\n\r\n  @Input()\r\n  public set selectedDate(date: Date) {\r\n    this._selectedDate = !!date ? new Date(date.getFullYear(), date.getMonth(), date.getDate()) : date;\r\n    if (this.secondSelectedDate && date && this.secondSelectedDate.getTime() < this.selectedDate.getTime() && this.temporarySelectedSecondaryDate) {\r\n      this.daysToHighlight = [];\r\n    }\r\n  }\r\n\r\n  public get selectedDate(): Date {\r\n    return this._selectedDate;\r\n  }\r\n\r\n  @Input()\r\n  public set secondSelectedDate(date: Date) {\r\n    this._secondSelectedDate = !!date ? new Date(date.getFullYear(), date.getMonth(), date.getDate()) : date;\r\n    if (!this.selectedDate) {\r\n      this.daysToHighlight = [];\r\n    } else {\r\n      this._fillDatesBetweenSelected();\r\n    }\r\n  }\r\n\r\n  public get secondSelectedDate(): Date {\r\n    return this._secondSelectedDate;\r\n  }\r\n\r\n  @Input()\r\n  public set secondHoveringDate(date : Date) {\r\n    this._secondHoveringDate = date;\r\n    if (!!date) {\r\n      this.temporarySelectedSecondaryDate = null;\r\n    }\r\n    if (this.selectedDate && !this.secondSelectedDate) {\r\n      this.temporarySelectedSecondaryDate = new Date(date);\r\n    }\r\n    this.handleMouseOverDay(date);\r\n  }\r\n\r\n  public get secondHoveringDate(): Date {\r\n    return this._secondHoveringDate;\r\n  }\r\n\r\n  @Output()\r\n  public dateSelected: EventEmitter<Date> = new EventEmitter<Date>();\r\n\r\n  @Output()\r\n  public hoveringDate: EventEmitter<Date> = new EventEmitter<Date>();\r\n\r\n  public showCalendarBody: boolean = true;\r\n  public showMonthSelection: boolean = false;\r\n  public showYearSelection: boolean = false;\r\n  public showSelectedMonth: string;\r\n\r\n  public workingDay: Date;\r\n  public workingYear: number;\r\n  public workingMonth: number;\r\n\r\n  public monthHeader: string = '';\r\n  public yearHeader: string = '';\r\n\r\n  public monthSelection: boolean = true;\r\n  public yearSelection: boolean = false;\r\n\r\n  public dayNames = [];\r\n  public monthNames = [];\r\n  public monthSelectionNames: string[] = [];\r\n  public yearSelectionYears: number[] = [];\r\n  public daysInMonth: Date[] = [];\r\n\r\n  public daysUnixTimestamps: number[] = [];\r\n  public daysToHighlight: Date[] = [];\r\n  public temporarySelectedSecondaryDate: Date;\r\n\r\n  private _secondHoveringDate: Date;\r\n  private _secondSelectedDate: Date;\r\n  private _selectedDate: Date;\r\n\r\n  @HostBinding(\"class.calendar-template\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  public ngOnInit(): void {\r\n    this._setInitialValues();\r\n    this.generateMonthNames();\r\n    this.generateCalendar();\r\n    this._fillDatesBetweenSelected();\r\n  }\r\n\r\n  public prevMonth(): void {\r\n    if (this.workingMonth === 0) {\r\n      this.workingMonth = 11;\r\n      this.workingYear--;\r\n    } else {\r\n      this.workingMonth--;\r\n    }\r\n    this.generateCalendar();\r\n    this._fillDatesBetweenSelected();\r\n    this.calculateWeekNumbers();\r\n  }\r\n\r\n  public nextMonth(): void {\r\n    if (this.workingMonth === 11) {\r\n      this.workingMonth = 0;\r\n      this.workingYear++;\r\n    } else {\r\n      this.workingMonth++;\r\n    }\r\n    this.generateCalendar();\r\n    this._fillDatesBetweenSelected();\r\n    this.calculateWeekNumbers();\r\n  }\r\n\r\n  public prevYear(): void {\r\n    this.workingYear--;\r\n    this.generateCalendar();\r\n  }\r\n\r\n  public nextYear(): void {\r\n    this.workingYear++;\r\n    this.generateCalendar();\r\n  }\r\n\r\n  public generateCalendar(): void {\r\n    this._setMonthDaysForDate(this.workingMonth);\r\n\r\n    // Update the displayed month\r\n    const month = this.monthNames[this.workingMonth];\r\n    const year = this.workingYear;\r\n\r\n    // Update headerText\r\n    this.monthHeader = `${month} ${year}`;\r\n    this.yearHeader = `${year}`;\r\n\r\n    this.generateYearSelectionYears();\r\n    this.calculateWeekNumbers();\r\n  }\r\n\r\n  private _setInitialValues(): void {\r\n    this.workingDay = this.selectedDate ? this.selectedDate : new Date();\r\n    this.workingYear = this.workingDay.getFullYear();\r\n    this.workingMonth = this.workingDay.getMonth();\r\n  }\r\n\r\n  private _setMonthDaysForDate(monthNumber: number): void {\r\n    this.daysInMonth = [];\r\n\r\n    const firstDayOfMonth = new Date(this.workingYear, monthNumber, 0).getDay();\r\n    const lastDayOfMonth = new Date(this.workingYear, monthNumber + 1, 0).getDate();\r\n\r\n    // Add null values to the beginning of the array to align the first day with the correct day of the week\r\n    for (let i = 0; i < firstDayOfMonth; i++) {\r\n      this.daysInMonth.push(null);\r\n    }\r\n\r\n    // Add the days of the current month to the array\r\n    for (let i = 1; i <= lastDayOfMonth; i++) {\r\n      const date = new Date(this.workingYear, this.workingMonth, i);\r\n      this.daysInMonth.push(date);\r\n    }\r\n\r\n    // Add null values to the end of the array to fill out the grid\r\n    // const remainingCells = 42 - this.daysInMonth.length;\r\n    // for (let i = 0; i < remainingCells; i++) {\r\n    //   this.daysInMonth.push(null);\r\n    // }\r\n\r\n    this.daysUnixTimestamps = this.daysInMonth.map(day => { return day ? day.getTime() : undefined });\r\n  }\r\n\r\n  public generateYearSelectionYears(): void {\r\n    const pastYears = 5;\r\n    const futureYears = 3;\r\n    const years = [];\r\n\r\n    for (let i = pastYears; i >= 1; i--) {\r\n\r\n      years.push(this.workingYear - i);\r\n    }\r\n\r\n    years.push(this.workingYear);\r\n\r\n    for (let i = 1; i <= futureYears; i++) {\r\n      years.push(this.workingYear + i);\r\n    }\r\n\r\n    this.yearSelectionYears = years.reverse();\r\n  }\r\n\r\n  public openMonthSelection(): void {\r\n    this.showCalendarBody = false;\r\n    this.monthSelection = false;\r\n    this.yearSelection = true;\r\n    this.showMonthSelection = true;\r\n  }\r\n\r\n  public openYearSelection(): void {\r\n    this.showMonthSelection = false;\r\n    this.showYearSelection = true;\r\n  }\r\n\r\n  public selectDate(day: Date): void {\r\n    this.selectedDate = day;\r\n    this._fillDatesBetweenSelected();\r\n    this.dateSelected.emit(new Date(this.selectedDate));\r\n  }\r\n\r\n  public selectMonth(month: string): void {\r\n    this.showSelectedMonth = month;\r\n    this.workingMonth = this.monthSelectionNames.indexOf(month);\r\n    this.showMonthSelection = false;\r\n    this.yearSelection = false;\r\n    this.monthSelection = true;\r\n    this.showCalendarBody = true;\r\n    this.generateCalendar();\r\n  }\r\n\r\n  public selectYear(year: number): void {\r\n    this.workingYear = year;\r\n    this.showYearSelection = false;\r\n    this.showMonthSelection = true;\r\n    this.generateCalendar();\r\n  }\r\n\r\n  public generateMonthNames(): void {\r\n    for (let i = 0; i < 12; i++) {\r\n      const date = new Date(2000, i, 1);\r\n      const monthNameShort = date.toLocaleString(this.locale, {month: 'short'});\r\n      const monthNameFull = date.toLocaleString(this.locale, {month: 'long'});\r\n      this.monthSelectionNames.push(this._capitalizeFirstLetter(monthNameShort));\r\n      this.monthNames.push(this._capitalizeFirstLetter(monthNameFull));\r\n    }\r\n\r\n    for (let i = 1; i <= 7; i++) {\r\n      const date = new Date(2018, 0, i);\r\n      const weekdayName = date.toLocaleString(this.locale, { weekday: 'short' });\r\n      this.dayNames.push(this._capitalizeFirstLetter(weekdayName));\r\n    }\r\n  }\r\n\r\n  public handleMouseOverDay(day: Date): void {\r\n    if (this.highlightDaysBetweenDates && day && (this.selectedDate || this.secondSelectedDate) && !(this.selectedDate && this.secondSelectedDate) && !(this.selectedDate && !this.temporarySelectedSecondaryDate && !this.secondSelectedDate)) {\r\n      this.daysToHighlight = [];\r\n      if (this.daysUnixTimestamps.includes(day.getTime())) {\r\n        this.daysToHighlight.push(...this.daysInMonth.map((dayInMonth: Date) => {\r\n          if (this.selectedDate) {\r\n            if (dayInMonth &&\r\n              // day in the month is after selected date and day in the month is before the hovering day\r\n              (dayInMonth.getTime() > this.selectedDate.getTime() && dayInMonth.getTime() < day.getTime()) ||\r\n              // second date is after selected date and day in the month is before hovering day and day in month is after selected date\r\n              (this._secondHoveringDate && this._secondHoveringDate.getTime() > this.selectedDate.getTime() && day && dayInMonth && dayInMonth.getTime() < day.getTime() && dayInMonth.getTime() > this.selectedDate.getTime())) {\r\n              return dayInMonth;\r\n            }\r\n          } else {\r\n            if (dayInMonth &&\r\n              // day in the month is after second date and day in the month is before the hovering day\r\n              (dayInMonth.getTime() > this.secondSelectedDate.getTime() && dayInMonth.getTime() < day.getTime())) {\r\n              return dayInMonth;\r\n            }\r\n          }\r\n        }));\r\n      } else {\r\n        this.daysToHighlight.push(...this.daysInMonth.map((day) => {\r\n          if (day > this.selectedDate) {\r\n            return day;\r\n          }\r\n        }));\r\n      }\r\n    }\r\n    this.hoveringDate.next(day);\r\n  }\r\n\r\n  private _fillDatesBetweenSelected(): void {\r\n    if (this.selectedDate && this.secondSelectedDate) {\r\n      this.daysToHighlight = [];\r\n      this.daysToHighlight.push(...this.daysInMonth.map((dayInMonth: Date) => {\r\n        if (dayInMonth && (dayInMonth > this.selectedDate && dayInMonth < this.secondSelectedDate) || (dayInMonth > this.secondSelectedDate && dayInMonth < this.selectedDate)) {\r\n          return dayInMonth;\r\n        }\r\n      }));\r\n    }\r\n  }\r\n\r\n  private _capitalizeFirstLetter(value: string): string {\r\n    return value.charAt(0).toUpperCase() + value.slice(1);\r\n  }\r\n  private calculateWeekNumbers(): void {\r\n    this.weekNumbers = [];\r\n    let weekNumber: number | null = null;\r\n    for (let i = 0; i < this.daysInMonth.length; i++) {\r\n      const day = this.daysInMonth[i];\r\n      if (day) {\r\n          // Start of a new week or first day of the month, calculate and set weekNumber\r\n          weekNumber = this.getISOWeek(day);\r\n          // Check if the weekNumber is not already in the array\r\n          if (!this.weekNumbers.includes(weekNumber)) {\r\n            this.weekNumbers.push(weekNumber);\r\n          }\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n  public getISOWeek(date: Date): number {\r\n      const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));\r\n      d.setUTCDate(d.getUTCDate() + 4 - (d.getUTCDay() || 7));\r\n      const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));\r\n      const weekNumber = Math.ceil(((d.valueOf() - yearStart.valueOf()) / 86400000 + 1) / 7);\r\n      return weekNumber;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/components/calendar/calendar.component.js

@@ -0,0 +1,45 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from "@angular/core";
+export class CalendarComponent {
+    constructor() {
+        this.locale = "nl-NL";
+        this.highlightDaysBetweenDates = false;
+        this.dateSelected = new EventEmitter();
+        this.hoveringDate = new EventEmitter();
+        this.clickedOutside = new EventEmitter();
+    }
+    showClass() {
+        return true;
+    }
+}
+CalendarComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-calendar",
+                template: `
+    <div class="date-picker-container" [overlay]="parentForOverlay" (clickOutside)="clickedOutside.next()">
+      <calendar-template
+        [locale]="locale"
+        [highlightDaysBetweenDates]="highlightDaysBetweenDates"
+        [selectedDate]="selectedDate"
+        [secondSelectedDate]="secondSelectedDate"
+        [secondHoveringDate]="secondHoveringDate"
+        (dateSelected)="dateSelected.next($event)"
+        (hoveringDate)="hoveringDate.next($event)"
+      ></calendar-template>
+    </div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+CalendarComponent.propDecorators = {
+    locale: [{ type: Input }],
+    parentForOverlay: [{ type: Input }],
+    highlightDaysBetweenDates: [{ type: Input }],
+    selectedDate: [{ type: Input }],
+    secondSelectedDate: [{ type: Input }],
+    secondHoveringDate: [{ type: Input }],
+    dateSelected: [{ type: Output }],
+    hoveringDate: [{ type: Output }],
+    clickedOutside: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-calendar",] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/calendar/calendar.module.js

@@ -0,0 +1,28 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { CalendarComponent } from "./calendar.component";
+import { IconModule } from "../icon/icon.module";
+import { OverlayModule } from "../../directives/overlay/overlay.module";
+import { ClickoutsideModule } from "../../directives/clickoutside/clickoutside.module";
+import { CalendarTemplateComponent } from "./calendar-template.component";
+export class CalendarModule {
+}
+CalendarModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    IconModule,
+                    OverlayModule,
+                    ClickoutsideModule
+                ],
+                declarations: [
+                    CalendarComponent,
+                    CalendarTemplateComponent
+                ],
+                exports: [
+                    CalendarComponent,
+                    CalendarTemplateComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/card/card.component.js

@@ -0,0 +1,72 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, HostBinding, HostListener, Input, Output, ViewEncapsulation } from '@angular/core';
+import { IconCacheService } from '../icon/icon-cache.service';
+import { CoreComponentsIcon } from '../../core/enum/core-components-icon.enum';
+export class CardComponent {
+    constructor(icons, _changeDetector) {
+        this.icons = icons;
+        this._changeDetector = _changeDetector;
+        this.isSelected = false;
+        this.isSmallModus = false;
+        this.hasMagnifierButton = false;
+        this.hasInfoButton = false;
+        // does not emit when you click one of the predefined buttons, but emits on a click on any of our other content
+        this.contentClick = new EventEmitter();
+        this.infoButtonClick = new EventEmitter();
+        this.magnifierButtonClick = new EventEmitter();
+        this.showClass = true;
+        this.Icons = CoreComponentsIcon;
+        this.heightCard = 150;
+    }
+    onHostClick(event) {
+        this.contentClick.emit(event);
+    }
+}
+CardComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'co-card',
+                template: `
+    <div class="co-card-wrapper">
+      <div class="content-wrapper">
+        <co-icon *ngIf="isSelected" [iconData]="icons.getIcon(Icons.Check)" class="check light circle"></co-icon>
+        <co-button *ngIf="hasMagnifierButton" [iconData]="icons.getIcon(Icons.MagnifierPlus)" class="magnify white small circle"
+                   [stopClick]="true" (click)="magnifierButtonClick.emit($event)"></co-button>
+        <div class="image">
+          <co-image [source]="imageData"></co-image>
+          <ng-content select="[over-image]"></ng-content>
+        </div>
+        <co-level-indicator class="co-level-indicator" *ngIf="!!level" [model]="level"></co-level-indicator>
+        <co-button *ngIf="hasInfoButton" [iconData]="icons.getIcon(Icons.Information)" class="info white small circle"
+                   [class.small]="!isSmallModus" [stopClick]="true" [class.mini]="isSmallModus"
+                   (click)="infoButtonClick.emit($event)"></co-button>
+      </div>
+      <div class="description-wrapper">
+        <span *ngIf="!!description" class="description" [innerText]="description"></span>
+        <span *ngIf="!!price" class="price" [innerText]="price | priceDisplay"></span>
+        <ng-content></ng-content>
+      </div>
+    </div>
+  `,
+                encapsulation: ViewEncapsulation.None,
+                changeDetection: ChangeDetectionStrategy.OnPush
+            },] }
+];
+CardComponent.ctorParameters = () => [
+    { type: IconCacheService },
+    { type: ChangeDetectorRef }
+];
+CardComponent.propDecorators = {
+    imageData: [{ type: Input }],
+    description: [{ type: Input }],
+    price: [{ type: Input }],
+    level: [{ type: Input }],
+    isSelected: [{ type: Input }],
+    isSmallModus: [{ type: Input }, { type: HostBinding, args: ['class.small-modus',] }],
+    hasMagnifierButton: [{ type: Input }],
+    hasInfoButton: [{ type: Input }],
+    contentClick: [{ type: Output }],
+    infoButtonClick: [{ type: Output }],
+    magnifierButtonClick: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ['class.co-card',] }],
+    onHostClick: [{ type: HostListener, args: ['click', ['$event'],] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/card/card.module.js

@@ -0,0 +1,35 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { HttpClientModule } from "@angular/common/http";
+import { CardComponent } from "./card.component";
+import { IconModule } from "../icon/icon.module";
+import { ButtonModule } from "../button/button.module";
+import { ImageModule } from "../image/image.module";
+import { StopClickModule } from "../../directives/stopclick/stop-click.module";
+import { LevelIndicatorModule } from "../level-indicator/level-indicator.module";
+import { PriceDisplayPipeModule } from "../../pipes/price-display-pipe.module";
+import { TileModule } from '../tile/tile.module';
+import { IconCacheService } from '../icon/icon-cache.service';
+export class CardModule {
+}
+CardModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    HttpClientModule,
+                    IconModule,
+                    ButtonModule,
+                    ImageModule,
+                    StopClickModule,
+                    LevelIndicatorModule,
+                    PriceDisplayPipeModule,
+                    TileModule
+                ],
+                declarations: [CardComponent],
+                providers: [
+                    IconCacheService
+                ],
+                exports: [CardComponent]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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