@updevs/components 1.0.0-alpha.3 → 1.0.0-alpha.31

package/esm2022/calendar/components/calendar-month-view/calendar-month-view.component.mjs

@@ -0,0 +1,423 @@
+import { ChangeDetectorRef, Component, EventEmitter, Input, Output, ViewChild, effect, inject } from '@angular/core';
+import { DateService } from '@updevs/sdk/core';
+import { BaseComponent } from '@updevs/sdk/layout';
+import { TranslocoService } from '@jsverse/transloco';
+import { startWith } from 'rxjs';
+import { CalendarBodyComponent } from '../calendar-body/calendar-body.component';
+import { DateRangeModel } from '../../models/date-range.model';
+import { CalendarCellModel } from '../../models/calendar-cell.model';
+import { KeyboardTools } from '../../tools/keyboard-tools';
+import { CalendarRangeStrategyService } from '../../services/calendar-range-strategy.service';
+import { CalendarSignalsService } from '../../services/calendar-signals.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../calendar-header/calendar-header.component";
+import * as i2 from "../calendar-body/calendar-body.component";
+const daysPerWeek = 7;
+let uniqueIdCounter = 0;
+export class CalendarMonthViewComponent extends BaseComponent {
+    /**
+     * The date to display in this month view (everything other than the month and year is ignored).
+     */
+    get activeDate() {
+        return this.calendarSignalsService.activeDate();
+    }
+    set activeDate(value) {
+        this.updateActiveDate(value);
+    }
+    /** The currently selected date. */
+    get selected() {
+        return this.calendarSignalsService.selectedDate();
+    }
+    set selected(value) {
+        let currValue;
+        if (value instanceof DateRangeModel) {
+            currValue = value;
+        }
+        else {
+            currValue = this.dateService.getValidOrUndefined(this.dateService.deserialize(value));
+        }
+        this.calendarSignalsService.selectedDate = currValue;
+        this.setRanges(currValue);
+    }
+    /** The minimum selectable date. */
+    get minDate() {
+        return this._minDate;
+    }
+    set minDate(value) {
+        this._minDate = this.dateService.getValidOrUndefined(this.dateService.deserialize(value));
+    }
+    /** The maximum selectable date. */
+    get maxDate() {
+        return this._maxDate;
+    }
+    set maxDate(value) {
+        this._maxDate = this.dateService.getValidOrUndefined(this.dateService.deserialize(value));
+    }
+    constructor() {
+        super();
+        /**
+         * First day of week.
+         * Zero-based starting from Sunday.
+         * Default: 0 - Sunday.
+         */
+        this.firstDayOfWeek = 0;
+        /** Whether the user is currently selecting a range of dates. */
+        this.isRange = false;
+        /** Emits when a new date is selected. */
+        this.selectedChange = new EventEmitter();
+        /** Emits when any date is selected. */
+        this.userSelection = new EventEmitter();
+        /** Emits when the user initiates a date range drag via mouse or touch. */
+        this.dragStarted = new EventEmitter();
+        /**
+         * Emits when the user completes or cancels a date range drag.
+         * Emits null when the drag was canceled or the newly selected date range if completed.
+         */
+        this.dragEnded = new EventEmitter();
+        /** Emits when any date is activated. */
+        this.activeDateChange = new EventEmitter();
+        /** Grid of calendar cells representing the dates of the month. */
+        this.weeks = [];
+        /** The number of blank cells in the first row before the 1st of the month. */
+        this.firstWeekOffset = 0;
+        /** The names of the weekdays. */
+        this.weekdays = [];
+        /** Flag used to filter out space/enter keyup events that originated outside of the view. */
+        this._selectionKeyPressed = false;
+        this.translocoService = inject(TranslocoService);
+        this.changeDetectorRef = inject(ChangeDetectorRef);
+        this.dateService = inject(DateService);
+        this.calendarSignalsService = inject(CalendarSignalsService);
+        this.calendarRangeStrategy = inject(CalendarRangeStrategyService);
+        effect(() => this.updateActiveDate(this.calendarSignalsService.activeDate(), true));
+    }
+    ngAfterContentInit() {
+        const langSub = this.translocoService.langChanges$
+            .pipe(startWith(undefined))
+            .subscribe(() => this.init());
+        this.addSubscriptions(langSub);
+    }
+    ngOnChanges(changes) {
+        const comparisonChange = changes['comparisonStart'] || changes['comparisonEnd'];
+        if (comparisonChange && !comparisonChange.firstChange) {
+            this.setRanges(this.selected);
+        }
+        if (changes['activeDrag'] && !this.activeDrag) {
+            this.clearPreview();
+        }
+    }
+    /** Handles when a new date is selected. */
+    dateSelected(event) {
+        const date = event.value;
+        const selectedDate = this.getDateFromDayOfMonth(date);
+        const currSelection = this.calendarSignalsService.selectedDate();
+        let rangeStartDate;
+        let rangeEndDate;
+        if (currSelection instanceof DateRangeModel) {
+            rangeStartDate = this.getDateInCurrentMonth(currSelection.start);
+            rangeEndDate = this.getDateInCurrentMonth(currSelection.end);
+        }
+        else {
+            rangeStartDate = rangeEndDate = this.getDateInCurrentMonth(currSelection);
+        }
+        if (rangeStartDate !== date || rangeEndDate !== date) {
+            this.calendarSignalsService.selectedDate = selectedDate;
+        }
+        this.userSelection.emit({ value: selectedDate, event: event.event });
+        this.clearPreview();
+        this.changeDetectorRef.markForCheck();
+    }
+    /** Handles keydown events on the calendar body when calendar is in month view. */
+    handleCalendarBodyKeydown(event) {
+        // TODO(mmalerba): We currently allow keyboard navigation to disabled dates, but just prevent
+        // disabled ones from being selected. This may not be ideal, we should look into whether
+        // navigation should skip over disabled dates, and if so, how to implement that efficiently.
+        const oldActiveDate = this.activeDate;
+        let tempActiveDate;
+        switch (event.key) {
+            case 'LEFT_ARROW':
+                tempActiveDate = this.dateService.addDays(this.activeDate, -1);
+                break;
+            case 'RIGHT_ARROW':
+                tempActiveDate = this.dateService.addDays(this.activeDate, 1);
+                break;
+            case 'UP_ARROW':
+                tempActiveDate = this.dateService.addDays(this.activeDate, -7);
+                break;
+            case 'DOWN_ARROW':
+                tempActiveDate = this.dateService.addDays(this.activeDate, 7);
+                break;
+            case 'HOME':
+                tempActiveDate = this.dateService.addDays(this.activeDate, 1 - this.activeDate.getDate());
+                break;
+            case 'END':
+                tempActiveDate = this.dateService.addDays(this.activeDate, this.dateService.getNumDaysInMonth(this.activeDate) -
+                    this.activeDate.getDate());
+                break;
+            case 'PAGE_UP':
+                tempActiveDate = event.altKey
+                    ? this.dateService.addYears(this.activeDate, -1)
+                    : this.dateService.addMonths(this.activeDate, -1);
+                break;
+            case 'PAGE_DOWN':
+                tempActiveDate = event.altKey
+                    ? this.dateService.addYears(this.activeDate, 1)
+                    : this.dateService.addMonths(this.activeDate, 1);
+                break;
+            case 'ENTER':
+            case 'SPACE':
+                this._selectionKeyPressed = true;
+                if (this.canSelect(this.activeDate)) {
+                    // Prevent unexpected default actions such as form submission.
+                    // Note that we only prevent the default action here while the selection happens in
+                    // `keyup` below. We can't do the selection here, because it can cause the calendar to
+                    // reopen if focus is restored immediately. We also can't call `preventDefault` on `keyup`
+                    // because it's too late (see #23305).
+                    event.preventDefault();
+                }
+                return;
+            case 'ESCAPE':
+                // Abort the current range selection if the user presses escape mid-selection.
+                if (this.previewEnd !== undefined && !KeyboardTools.hasModifierKey(event)) {
+                    this.clearPreview();
+                    // If a drag is in progress, cancel the drag without changing the
+                    // current selection.
+                    if (this.activeDrag) {
+                        this.dragEnded.emit({ value: undefined, event });
+                    }
+                    else {
+                        this.selectedChange.emit(undefined);
+                        this.userSelection.emit({ value: undefined, event });
+                    }
+                    event.preventDefault();
+                    event.stopPropagation(); // Prevents the overlay from closing.
+                }
+                return;
+            default:
+                // Don't prevent default or focus active cell on keys that we don't explicitly handle.
+                return;
+        }
+        if (this.dateService.compare(oldActiveDate, this.activeDate)) {
+            this.calendarSignalsService.activeDate = tempActiveDate;
+            this.focusActiveCellAfterViewChecked();
+        }
+        // Prevent unexpected default actions such as form submission.
+        event.preventDefault();
+    }
+    /** Handles keyup events on the calendar body when calendar is in month view. */
+    handleCalendarBodyKeyup(event) {
+        if (event.key === 'SPACE' || event.key === 'ENTER') {
+            if (this._selectionKeyPressed && this.canSelect(this.activeDate)) {
+                this.dateSelected({ value: this.activeDate.getDate(), event });
+            }
+            this._selectionKeyPressed = false;
+        }
+    }
+    /** Initializes this month view. */
+    init() {
+        this.setRanges(this.selected);
+        this.todayDate = this.getCellCompareValue(new Date());
+        this.monthLabel = this.dateService.getMonthNames('short')[this.activeDate.getMonth()].toLocaleUpperCase();
+        const firstOfMonth = this.dateService.create(this.activeDate.getFullYear(), this.activeDate.getMonth(), 1);
+        this.firstWeekOffset = (daysPerWeek + firstOfMonth.getDay() - this.firstDayOfWeek) % daysPerWeek;
+        this.initWeekdays();
+        this.createWeekCells();
+        this.changeDetectorRef.markForCheck();
+    }
+    /** Focuses the active cell after the microtask queue is empty. */
+    focusActiveCell(movePreview) {
+        this._matCalendarBody.focusActiveCell(movePreview);
+    }
+    /** Focuses the active cell after change detection has run and the microtask queue is empty. */
+    focusActiveCellAfterViewChecked() {
+        this._matCalendarBody.scheduleFocusActiveCellAfterViewChecked();
+    }
+    /** Called when the user has activated a new cell and the preview needs to be updated. */
+    previewChanged({ value: cell }) {
+        if (!this.selected) {
+            return;
+        }
+        if (this.isRange && !(this.selected instanceof DateRangeModel)) {
+            this.selected = new DateRangeModel(this.selected);
+        }
+        // We can assume that this will be a range, because preview
+        // events aren't fired for single date selections.
+        const value = cell ? cell.rawValue : undefined;
+        const previewRange = this.calendarRangeStrategy.createPreview(value, this.selected);
+        this.previewStart = this.getCellCompareValue(previewRange.start);
+        this.previewEnd = this.getCellCompareValue(previewRange.end);
+        if (!!this.activeDrag && !!value) {
+            const dragRange = this.calendarRangeStrategy.createDrag?.(this.activeDrag.value, this.selected, value);
+            if (!!dragRange) {
+                this.previewStart = this.getCellCompareValue(dragRange.start);
+                this.previewEnd = this.getCellCompareValue(dragRange.end);
+            }
+        }
+        // Note that here we need to use `detectChanges`, rather than `markForCheck`, because
+        // the way `_focusActiveCell` is set up at the moment makes it fire at the wrong time
+        // when navigating one month back using the keyboard which will cause this handler
+        // to throw a "changed after checked" error when updating the preview state.
+        this.changeDetectorRef.detectChanges();
+    }
+    /**
+     * Called when the user has ended a drag. If the drag/drop was successful,
+     * computes and emits the new range selection.
+     */
+    _dragEnded(event) {
+        if (!this.activeDrag) {
+            return;
+        }
+        if (event.value) {
+            // Propagate drag effect
+            const dragDropResult = this.calendarRangeStrategy?.createDrag?.(this.activeDrag.value, this.selected, event.value);
+            this.dragEnded.emit({ value: dragDropResult ?? undefined, event: event.event });
+        }
+        else {
+            this.dragEnded.emit({ value: undefined, event: event.event });
+        }
+    }
+    updateActiveDate(value, isFromEffect = false) {
+        this.oldActiveDate = this.oldActiveDate || value;
+        const validDate = this.dateService.getValidOrUndefined(this.dateService.deserialize(value)) || new Date();
+        if (!isFromEffect) {
+            this.calendarSignalsService.activeDate = this.dateService.clamp(validDate, this.minDate, this.maxDate);
+        }
+        if (!this.isSameMonthAndYearAsActiveDate(this.oldActiveDate, this.calendarSignalsService.activeDate())) {
+            this.init();
+        }
+        this.oldActiveDate = value;
+        this.activeDateChange.emit(this.calendarSignalsService.activeDate());
+    }
+    /**
+     * Takes a day of the month and returns a new date in the same month and year as the currently
+     *  active date. The returned date will have the same day of the month as the argument date.
+     */
+    getDateFromDayOfMonth(dayOfMonth) {
+        return this.dateService.create(this.activeDate.getFullYear(), this.activeDate.getMonth(), dayOfMonth);
+    }
+    /** Initializes the weekdays. */
+    initWeekdays() {
+        const firstDayOfWeek = this.firstDayOfWeek;
+        const narrowWeekdays = this.dateService.getDayOfWeekNames('narrow');
+        const longWeekdays = this.dateService.getDayOfWeekNames('long');
+        // Rotate the labels for days of the week based on the configured first day of the week.
+        const weekdays = longWeekdays.map((long, i) => ({ long, narrow: narrowWeekdays[i], id: uniqueIdCounter++ }));
+        this.weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));
+    }
+    /** Creates MatCalendarCells for the dates in this month. */
+    createWeekCells() {
+        const daysInMonth = this.dateService.getNumDaysInMonth(this.activeDate);
+        const dateNames = this.dateService.getDateNames();
+        this.weeks = [[]];
+        for (let i = 0, cell = this.firstWeekOffset; i < daysInMonth; i++, cell++) {
+            if (cell === daysPerWeek) {
+                this.weeks.push([]);
+                cell = 0;
+            }
+            const date = this.dateService.create(this.activeDate.getFullYear(), this.activeDate.getMonth(), i + 1);
+            const isEnabled = this.shouldEnableDate(date);
+            const ariaLabel = this.dateService.format(date, { year: 'numeric', month: 'long', day: 'numeric' });
+            const cellClasses = this.dateClass ? this.dateClass(date, 'month') : undefined;
+            this.weeks[this.weeks.length - 1].push(new CalendarCellModel(i + 1, dateNames[i], ariaLabel, isEnabled, cellClasses, this.getCellCompareValue(date), date));
+        }
+    }
+    /** Date filter for the month */
+    shouldEnableDate(date) {
+        return !!date &&
+            (!this.minDate || this.dateService.compare(date, this.minDate) >= 0) &&
+            (!this.maxDate || this.dateService.compare(date, this.maxDate) <= 0) &&
+            (!this.dateFilter || this.dateFilter(date));
+    }
+    /**
+     * Gets the date in this month that the given Date falls on.
+     * Returns null if the given Date is in another month.
+     */
+    getDateInCurrentMonth(date) {
+        return !!date && this.isSameMonthAndYearAsActiveDate(date, this.calendarSignalsService.activeDate())
+            ? date.getDate()
+            : undefined;
+    }
+    /** Checks whether the 2 dates are non-null and fall within the same month of the same year. */
+    isSameMonthAndYearAsActiveDate(d1, d2) {
+        return (!!d1 && !!d2 && d1.getMonth() === d2.getMonth() && d1.getFullYear() === d2.getFullYear());
+    }
+    /** Gets the value that will be used to one cell to another. */
+    getCellCompareValue(date) {
+        if (!!date) {
+            // We use the time since the Unix epoch to compare dates in this view, rather than the
+            // cell values, because we need to support ranges that span across multiple months/years.
+            const year = date.getFullYear();
+            const month = date.getMonth();
+            const day = date.getDate();
+            return new Date(year, month, day).getTime();
+        }
+        return undefined;
+    }
+    /** Sets the current range based on a model value. */
+    setRanges(selectedValue) {
+        if (selectedValue instanceof DateRangeModel) {
+            this.rangeStart = this.getCellCompareValue(selectedValue.start);
+            this.rangeEnd = this.getCellCompareValue(selectedValue.end);
+            this.isRange = true;
+        }
+        else {
+            this.rangeStart = this.rangeEnd = this.getCellCompareValue(selectedValue);
+        }
+        this.comparisonRangeStart = this.getCellCompareValue(this.comparisonStart);
+        this.comparisonRangeEnd = this.getCellCompareValue(this.comparisonEnd);
+    }
+    /** Gets whether a date can be selected in the month view. */
+    canSelect(date) {
+        return !this.dateFilter || this.dateFilter(date);
+    }
+    /** Clears out preview state. */
+    clearPreview() {
+        this.previewStart = this.previewEnd = undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CalendarMonthViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.1.0", type: CalendarMonthViewComponent, selector: "upd-calendar-month-view", inputs: { activeDate: "activeDate", selected: "selected", minDate: "minDate", maxDate: "maxDate", dateFilter: "dateFilter", dateClass: "dateClass", comparisonStart: "comparisonStart", comparisonEnd: "comparisonEnd", startDateAccessibleName: "startDateAccessibleName", endDateAccessibleName: "endDateAccessibleName", firstDayOfWeek: "firstDayOfWeek", activeDrag: "activeDrag", isRange: "isRange" }, outputs: { selectedChange: "selectedChange", userSelection: "userSelection", dragStarted: "dragStarted", dragEnded: "dragEnded", activeDateChange: "activeDateChange" }, viewQueries: [{ propertyName: "_matCalendarBody", first: true, predicate: CalendarBodyComponent, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<upd-calendar-header></upd-calendar-header>\n<div class=\"container mt-2\">\n    <div class=\"row seven-cols\">\n        @for (day of weekdays; track day.id) {\n            <div class=\"col-1 p-1 d-flex justify-content-center align-items-center\">\n                <span class=\"visually-hidden\">{{ day.long }}</span>\n                <span aria-hidden=\"true\">{{ day.narrow }}</span>\n            </div>\n        }\n    </div>\n</div>\n<upd-calendar-body [label]=\"monthLabel\" [rows]=\"weeks\" [todayValue]=\"todayDate!\" [startValue]=\"rangeStart!\"\n    [endValue]=\"rangeEnd!\" [comparisonStart]=\"comparisonRangeStart\" [comparisonEnd]=\"comparisonRangeEnd\"\n    [previewStart]=\"previewStart\" [previewEnd]=\"previewEnd\" [isRange]=\"isRange\" [labelMinRequiredCells]=\"3\"\n    [activeCell]=\"activeDate.getDate() - 1\" [startDateAccessibleName]=\"startDateAccessibleName\"\n    [endDateAccessibleName]=\"endDateAccessibleName\" (selectedValueChange)=\"dateSelected($event)\"\n    (previewChange)=\"previewChanged($event)\" (dragStarted)=\"dragStarted.emit($event)\" (dragEnded)=\"_dragEnded($event)\"\n    (keyup)=\"handleCalendarBodyKeyup($event)\" (keydown)=\"handleCalendarBodyKeydown($event)\">\n</upd-calendar-body>\n", styles: ["@media (min-width: 768px){.seven-cols .col-1{width:100%}.seven-cols .col-6{width:85.7142857143%}}@media (min-width: 992px){.seven-cols .col-1{width:14.2857142857%}.seven-cols .col-2{width:28.5714285714%}.seven-cols .col-3{width:42.8571428571%}.seven-cols .col-4{width:57.1428571429%}.seven-cols .col-5{width:71.4285714286%}.seven-cols .col-6{width:85.7142857143%}.seven-cols .col-7{width:100%}}@media (min-width: 1200px){.seven-cols .col-1{width:14.2857142857%}.seven-cols .col-2{width:28.5714285714%}.seven-cols .col-3{width:42.8571428571%}.seven-cols .col-4{width:57.1428571429%}.seven-cols .col-5{width:71.4285714286%}.seven-cols .col-6{width:85.7142857143%}.seven-cols .col-7{width:100%}}\n"], dependencies: [{ kind: "component", type: i1.CalendarHeaderComponent, selector: "upd-calendar-header" }, { kind: "component", type: i2.CalendarBodyComponent, selector: "upd-calendar-body", inputs: ["label", "rows", "todayValue", "startValue", "endValue", "labelMinRequiredCells", "numCols", "activeCell", "isRange", "cellAspectRatio", "comparisonStart", "comparisonEnd", "previewStart", "previewEnd", "startDateAccessibleName", "endDateAccessibleName"], outputs: ["selectedValueChange", "previewChange", "dragStarted", "dragEnded"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CalendarMonthViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'upd-calendar-month-view', template: "<upd-calendar-header></upd-calendar-header>\n<div class=\"container mt-2\">\n    <div class=\"row seven-cols\">\n        @for (day of weekdays; track day.id) {\n            <div class=\"col-1 p-1 d-flex justify-content-center align-items-center\">\n                <span class=\"visually-hidden\">{{ day.long }}</span>\n                <span aria-hidden=\"true\">{{ day.narrow }}</span>\n            </div>\n        }\n    </div>\n</div>\n<upd-calendar-body [label]=\"monthLabel\" [rows]=\"weeks\" [todayValue]=\"todayDate!\" [startValue]=\"rangeStart!\"\n    [endValue]=\"rangeEnd!\" [comparisonStart]=\"comparisonRangeStart\" [comparisonEnd]=\"comparisonRangeEnd\"\n    [previewStart]=\"previewStart\" [previewEnd]=\"previewEnd\" [isRange]=\"isRange\" [labelMinRequiredCells]=\"3\"\n    [activeCell]=\"activeDate.getDate() - 1\" [startDateAccessibleName]=\"startDateAccessibleName\"\n    [endDateAccessibleName]=\"endDateAccessibleName\" (selectedValueChange)=\"dateSelected($event)\"\n    (previewChange)=\"previewChanged($event)\" (dragStarted)=\"dragStarted.emit($event)\" (dragEnded)=\"_dragEnded($event)\"\n    (keyup)=\"handleCalendarBodyKeyup($event)\" (keydown)=\"handleCalendarBodyKeydown($event)\">\n</upd-calendar-body>\n", styles: ["@media (min-width: 768px){.seven-cols .col-1{width:100%}.seven-cols .col-6{width:85.7142857143%}}@media (min-width: 992px){.seven-cols .col-1{width:14.2857142857%}.seven-cols .col-2{width:28.5714285714%}.seven-cols .col-3{width:42.8571428571%}.seven-cols .col-4{width:57.1428571429%}.seven-cols .col-5{width:71.4285714286%}.seven-cols .col-6{width:85.7142857143%}.seven-cols .col-7{width:100%}}@media (min-width: 1200px){.seven-cols .col-1{width:14.2857142857%}.seven-cols .col-2{width:28.5714285714%}.seven-cols .col-3{width:42.8571428571%}.seven-cols .col-4{width:57.1428571429%}.seven-cols .col-5{width:71.4285714286%}.seven-cols .col-6{width:85.7142857143%}.seven-cols .col-7{width:100%}}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { _matCalendarBody: [{
+                type: ViewChild,
+                args: [CalendarBodyComponent]
+            }], activeDate: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], dateFilter: [{
+                type: Input
+            }], dateClass: [{
+                type: Input
+            }], comparisonStart: [{
+                type: Input
+            }], comparisonEnd: [{
+                type: Input
+            }], startDateAccessibleName: [{
+                type: Input
+            }], endDateAccessibleName: [{
+                type: Input
+            }], firstDayOfWeek: [{
+                type: Input
+            }], activeDrag: [{
+                type: Input
+            }], isRange: [{
+                type: Input
+            }], selectedChange: [{
+                type: Output
+            }], userSelection: [{
+                type: Output
+            }], dragStarted: [{
+                type: Output
+            }], dragEnded: [{
+                type: Output
+            }], activeDateChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar-month-view.component.js","sourceRoot":"","sources":["../../../../../../../libs/components/calendar/src/components/calendar-month-view/calendar-month-view.component.ts","../../../../../../../libs/components/calendar/src/components/calendar-month-view/calendar-month-view.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    ChangeDetectorRef,\n    Component,\n    EventEmitter,\n    Input,\n    OnChanges,\n    Output,\n    SimpleChanges,\n    ViewChild,\n    effect,\n    inject\n} from '@angular/core';\nimport { OptionalType } from '@updevs/sdk/types';\nimport { DateService } from '@updevs/sdk/core';\nimport { BaseComponent } from '@updevs/sdk/layout';\nimport { TranslocoService } from '@jsverse/transloco';\nimport { startWith } from 'rxjs';\n\nimport { CalendarUserEventModel } from '../../models/calendar-user-event.model';\nimport { CalendarBodyComponent } from '../calendar-body/calendar-body.component';\nimport { DateRangeModel } from '../../models/date-range.model';\nimport { CalendarCellModel } from '../../models/calendar-cell.model';\nimport { CalendarCellClassFunctionType } from '../../types/calendar-cell-class-function.type';\nimport { KeyboardTools } from '../../tools/keyboard-tools';\nimport { CalendarRangeStrategyService } from '../../services/calendar-range-strategy.service';\nimport { CalendarSignalsService } from '../../services/calendar-signals.service';\n\nconst daysPerWeek = 7;\n\nlet uniqueIdCounter = 0;\n\n@Component({\n    selector: 'upd-calendar-month-view',\n    templateUrl: './calendar-month-view.component.html',\n    styleUrl: './calendar-month-view.component.scss'\n})\nexport class CalendarMonthViewComponent extends BaseComponent implements AfterContentInit, OnChanges {\n    /**\n     * The body of calendar table\n     */\n    @ViewChild(CalendarBodyComponent) _matCalendarBody!: CalendarBodyComponent;\n\n    /**\n     * The date to display in this month view (everything other than the month and year is ignored).\n     */\n    @Input()\n    get activeDate(): Date {\n        return this.calendarSignalsService.activeDate();\n    }\n    set activeDate(value: Date) {\n        this.updateActiveDate(value);\n    }\n\n    /** The currently selected date. */\n    @Input()\n    get selected(): DateRangeModel | OptionalType<Date> {\n        return this.calendarSignalsService.selectedDate();\n    }\n    set selected(value: DateRangeModel | OptionalType<Date>) {\n        let currValue: DateRangeModel | OptionalType<Date>;\n\n        if (value instanceof DateRangeModel) {\n            currValue = value;\n        } else {\n            currValue = this.dateService.getValidOrUndefined(this.dateService.deserialize(value));\n        }\n\n        this.calendarSignalsService.selectedDate = currValue;\n\n        this.setRanges(currValue);\n    }\n\n    /** The minimum selectable date. */\n    @Input()\n    get minDate(): OptionalType<Date> {\n        return this._minDate;\n    }\n    set minDate(value: OptionalType<Date>) {\n        this._minDate = this.dateService.getValidOrUndefined(this.dateService.deserialize(value));\n    }\n\n    /** The maximum selectable date. */\n    @Input()\n    get maxDate(): OptionalType<Date> {\n        return this._maxDate;\n    }\n    set maxDate(value: OptionalType<Date>) {\n        this._maxDate = this.dateService.getValidOrUndefined(this.dateService.deserialize(value));\n    }\n\n    /** Function used to filter which dates are selectable. */\n    @Input() dateFilter?: (date: Date) => boolean;\n\n    /** Function that can be used to add custom CSS classes to dates. */\n    @Input() dateClass?: CalendarCellClassFunctionType;\n\n    /** Start of the comparison range. */\n    @Input() comparisonStart?: Date;\n\n    /** End of the comparison range. */\n    @Input() comparisonEnd?: Date;\n\n    /** ARIA Accessible name of the `<input matStartDate/>` */\n    @Input() startDateAccessibleName?: string;\n\n    /** ARIA Accessible name of the `<input matEndDate/>` */\n    @Input() endDateAccessibleName?: string;\n\n    /**\n     * First day of week.\n     * Zero-based starting from Sunday.\n     * Default: 0 - Sunday.\n     */\n    @Input() firstDayOfWeek = 0;\n\n    /** Origin of active drag, or null when dragging is not active. */\n    @Input() activeDrag?: CalendarUserEventModel<Date>;\n\n    /** Whether the user is currently selecting a range of dates. */\n    @Input() isRange = false;\n\n    /** Emits when a new date is selected. */\n    @Output() readonly selectedChange = new EventEmitter<OptionalType<Date>>();\n\n    /** Emits when any date is selected. */\n    @Output() readonly userSelection = new EventEmitter<CalendarUserEventModel<OptionalType<Date>>>();\n\n    /** Emits when the user initiates a date range drag via mouse or touch. */\n    @Output() readonly dragStarted = new EventEmitter<CalendarUserEventModel<Date>>();\n\n    /**\n     * Emits when the user completes or cancels a date range drag.\n     * Emits null when the drag was canceled or the newly selected date range if completed.\n     */\n    @Output() readonly dragEnded = new EventEmitter<CalendarUserEventModel<OptionalType<DateRangeModel>>>();\n\n    /** Emits when any date is activated. */\n    @Output() readonly activeDateChange = new EventEmitter<Date>();\n\n    /** The label for this month (e.g. \"January 2017\"). */\n    monthLabel!: string;\n\n    /** Grid of calendar cells representing the dates of the month. */\n    weeks: CalendarCellModel[][] = [];\n\n    /** The number of blank cells in the first row before the 1st of the month. */\n    firstWeekOffset = 0;\n\n    /** Start value of the currently-shown date range. */\n    rangeStart?: number;\n\n    /** End value of the currently-shown date range. */\n    rangeEnd?: number;\n\n    /** Start value of the currently-shown comparison date range. */\n    comparisonRangeStart?: number;\n\n    /** End value of the currently-shown comparison date range. */\n    comparisonRangeEnd?: number;\n\n    /** Start of the preview range. */\n    previewStart?: number;\n\n    /** End of the preview range. */\n    previewEnd?: number;\n\n    /** The date of the month that today falls on. Null if today is in another month. */\n    todayDate?: number;\n\n    /** The names of the weekdays. */\n    weekdays: { long: string; narrow: string; id: number }[] = [];\n\n    /** Flag used to filter out space/enter keyup events that originated outside of the view. */\n    private _selectionKeyPressed = false;\n    private _minDate?: Date;\n    private _maxDate?: Date;\n    private oldActiveDate?: Date;\n\n    private readonly translocoService = inject(TranslocoService);\n    private readonly changeDetectorRef = inject(ChangeDetectorRef);\n    private readonly dateService = inject(DateService);\n    private readonly calendarSignalsService = inject(CalendarSignalsService);\n    private readonly calendarRangeStrategy = inject(CalendarRangeStrategyService);\n\n    constructor() {\n        super();\n        effect(() => this.updateActiveDate(this.calendarSignalsService.activeDate(), true));\n    }\n\n    ngAfterContentInit(): void {\n        const langSub = this.translocoService.langChanges$\n            .pipe(startWith(undefined))\n            .subscribe(() => this.init());\n        this.addSubscriptions(langSub);\n    }\n\n    ngOnChanges(changes: SimpleChanges): void {\n        const comparisonChange = changes['comparisonStart'] || changes['comparisonEnd'];\n\n        if (comparisonChange && !comparisonChange.firstChange) {\n            this.setRanges(this.selected);\n        }\n\n        if (changes['activeDrag'] && !this.activeDrag) {\n            this.clearPreview();\n        }\n    }\n\n    /** Handles when a new date is selected. */\n    dateSelected(event: CalendarUserEventModel<number>): void {\n        const date = event.value;\n        const selectedDate = this.getDateFromDayOfMonth(date);\n        const currSelection = this.calendarSignalsService.selectedDate();\n        let rangeStartDate: OptionalType<number>;\n        let rangeEndDate: OptionalType<number>;\n\n        if (currSelection instanceof DateRangeModel) {\n            rangeStartDate = this.getDateInCurrentMonth(currSelection.start);\n            rangeEndDate = this.getDateInCurrentMonth(currSelection.end);\n        } else {\n            rangeStartDate = rangeEndDate = this.getDateInCurrentMonth(currSelection);\n        }\n\n        if (rangeStartDate !== date || rangeEndDate !== date) {\n            this.calendarSignalsService.selectedDate = selectedDate;\n        }\n\n        this.userSelection.emit({ value: selectedDate, event: event.event });\n        this.clearPreview();\n        this.changeDetectorRef.markForCheck();\n    }\n\n    /** Handles keydown events on the calendar body when calendar is in month view. */\n    handleCalendarBodyKeydown(event: KeyboardEvent): void {\n        // TODO(mmalerba): We currently allow keyboard navigation to disabled dates, but just prevent\n        // disabled ones from being selected. This may not be ideal, we should look into whether\n        // navigation should skip over disabled dates, and if so, how to implement that efficiently.\n\n        const oldActiveDate = this.activeDate;\n        let tempActiveDate: OptionalType<Date>;\n\n        switch (event.key) {\n            case 'LEFT_ARROW':\n                tempActiveDate = this.dateService.addDays(this.activeDate, -1);\n                break;\n            case 'RIGHT_ARROW':\n                tempActiveDate = this.dateService.addDays(this.activeDate, 1);\n                break;\n            case 'UP_ARROW':\n                tempActiveDate = this.dateService.addDays(this.activeDate, -7);\n                break;\n            case 'DOWN_ARROW':\n                tempActiveDate = this.dateService.addDays(this.activeDate, 7);\n                break;\n            case 'HOME':\n                tempActiveDate = this.dateService.addDays(this.activeDate, 1 - this.activeDate.getDate());\n                break;\n            case 'END':\n                tempActiveDate = this.dateService.addDays(\n                    this.activeDate,\n                    this.dateService.getNumDaysInMonth(this.activeDate) -\n                    this.activeDate.getDate()\n                );\n                break;\n            case 'PAGE_UP':\n                tempActiveDate = event.altKey\n                    ? this.dateService.addYears(this.activeDate, -1)\n                    : this.dateService.addMonths(this.activeDate, -1);\n                break;\n            case 'PAGE_DOWN':\n                tempActiveDate = event.altKey\n                    ? this.dateService.addYears(this.activeDate, 1)\n                    : this.dateService.addMonths(this.activeDate, 1);\n                break;\n            case 'ENTER':\n            case 'SPACE':\n                this._selectionKeyPressed = true;\n\n                if (this.canSelect(this.activeDate)) {\n                    // Prevent unexpected default actions such as form submission.\n                    // Note that we only prevent the default action here while the selection happens in\n                    // `keyup` below. We can't do the selection here, because it can cause the calendar to\n                    // reopen if focus is restored immediately. We also can't call `preventDefault` on `keyup`\n                    // because it's too late (see #23305).\n                    event.preventDefault();\n                }\n                return;\n            case 'ESCAPE':\n                // Abort the current range selection if the user presses escape mid-selection.\n                if (this.previewEnd !== undefined && !KeyboardTools.hasModifierKey(event)) {\n                    this.clearPreview();\n                    // If a drag is in progress, cancel the drag without changing the\n                    // current selection.\n                    if (this.activeDrag) {\n                        this.dragEnded.emit({ value: undefined, event });\n                    } else {\n                        this.selectedChange.emit(undefined);\n                        this.userSelection.emit({ value: undefined, event });\n                    }\n                    event.preventDefault();\n                    event.stopPropagation(); // Prevents the overlay from closing.\n                }\n                return;\n            default:\n                // Don't prevent default or focus active cell on keys that we don't explicitly handle.\n                return;\n        }\n\n        if (this.dateService.compare(oldActiveDate, this.activeDate)) {\n            this.calendarSignalsService.activeDate = tempActiveDate;\n            this.focusActiveCellAfterViewChecked();\n        }\n\n        // Prevent unexpected default actions such as form submission.\n        event.preventDefault();\n    }\n\n    /** Handles keyup events on the calendar body when calendar is in month view. */\n    handleCalendarBodyKeyup(event: KeyboardEvent): void {\n        if (event.key === 'SPACE' || event.key === 'ENTER') {\n            if (this._selectionKeyPressed && this.canSelect(this.activeDate)) {\n                this.dateSelected({ value: this.activeDate.getDate(), event });\n            }\n\n            this._selectionKeyPressed = false;\n        }\n    }\n\n    /** Initializes this month view. */\n    init(): void {\n        this.setRanges(this.selected);\n        this.todayDate = this.getCellCompareValue(new Date());\n        this.monthLabel = this.dateService.getMonthNames('short')[this.activeDate.getMonth()].toLocaleUpperCase();\n        const firstOfMonth = this.dateService.create(\n            this.activeDate.getFullYear(),\n            this.activeDate.getMonth(),\n            1\n        );\n        this.firstWeekOffset = (daysPerWeek + firstOfMonth.getDay() - this.firstDayOfWeek) % daysPerWeek;\n\n        this.initWeekdays();\n        this.createWeekCells();\n        this.changeDetectorRef.markForCheck();\n    }\n\n    /** Focuses the active cell after the microtask queue is empty. */\n    focusActiveCell(movePreview?: boolean): void {\n        this._matCalendarBody.focusActiveCell(movePreview);\n    }\n\n    /** Focuses the active cell after change detection has run and the microtask queue is empty. */\n    focusActiveCellAfterViewChecked(): void {\n        this._matCalendarBody.scheduleFocusActiveCellAfterViewChecked();\n    }\n\n    /** Called when the user has activated a new cell and the preview needs to be updated. */\n    previewChanged({ value: cell }: CalendarUserEventModel<OptionalType<CalendarCellModel>>): void {\n        if (!this.selected) {\n            return;\n        }\n\n        if (this.isRange && !(this.selected instanceof DateRangeModel)) {\n            this.selected = new DateRangeModel(this.selected);\n        }\n\n        // We can assume that this will be a range, because preview\n        // events aren't fired for single date selections.\n        const value = cell ? cell.rawValue! : undefined;\n        const previewRange = this.calendarRangeStrategy.createPreview(value, this.selected as DateRangeModel);\n        this.previewStart = this.getCellCompareValue(previewRange.start);\n        this.previewEnd = this.getCellCompareValue(previewRange.end);\n\n        if (!!this.activeDrag && !!value) {\n            const dragRange = this.calendarRangeStrategy.createDrag?.(this.activeDrag.value, this.selected as DateRangeModel, value);\n\n            if (!!dragRange) {\n                this.previewStart = this.getCellCompareValue(dragRange.start);\n                this.previewEnd = this.getCellCompareValue(dragRange.end);\n            }\n        }\n\n        // Note that here we need to use `detectChanges`, rather than `markForCheck`, because\n        // the way `_focusActiveCell` is set up at the moment makes it fire at the wrong time\n        // when navigating one month back using the keyboard which will cause this handler\n        // to throw a \"changed after checked\" error when updating the preview state.\n        this.changeDetectorRef.detectChanges();\n    }\n\n    /**\n     * Called when the user has ended a drag. If the drag/drop was successful,\n     * computes and emits the new range selection.\n     */\n    protected _dragEnded(event: CalendarUserEventModel<OptionalType<Date>>): void {\n        if (!this.activeDrag) {\n            return;\n        }\n\n        if (event.value) {\n            // Propagate drag effect\n            const dragDropResult = this.calendarRangeStrategy?.createDrag?.(\n                this.activeDrag.value,\n                this.selected as DateRangeModel,\n                event.value\n            );\n\n            this.dragEnded.emit({ value: dragDropResult ?? undefined, event: event.event });\n        } else {\n            this.dragEnded.emit({ value: undefined, event: event.event });\n        }\n    }\n\n    private updateActiveDate(value: Date, isFromEffect = false): void {\n        this.oldActiveDate = this.oldActiveDate || value;\n        const validDate = this.dateService.getValidOrUndefined(this.dateService.deserialize(value)) || new Date();\n\n        if (!isFromEffect) {\n            this.calendarSignalsService.activeDate = this.dateService.clamp(validDate, this.minDate, this.maxDate);\n        }\n\n        if (!this.isSameMonthAndYearAsActiveDate(this.oldActiveDate, this.calendarSignalsService.activeDate())) {\n            this.init();\n        }\n\n        this.oldActiveDate = value;\n\n        this.activeDateChange.emit(this.calendarSignalsService.activeDate());\n    }\n\n    /**\n     * Takes a day of the month and returns a new date in the same month and year as the currently\n     *  active date. The returned date will have the same day of the month as the argument date.\n     */\n    private getDateFromDayOfMonth(dayOfMonth: number): Date {\n        return this.dateService.create(this.activeDate.getFullYear(), this.activeDate.getMonth(), dayOfMonth);\n    }\n\n    /** Initializes the weekdays. */\n    private initWeekdays(): void {\n        const firstDayOfWeek = this.firstDayOfWeek;\n        const narrowWeekdays = this.dateService.getDayOfWeekNames('narrow');\n        const longWeekdays = this.dateService.getDayOfWeekNames('long');\n        // Rotate the labels for days of the week based on the configured first day of the week.\n        const weekdays = longWeekdays.map((long, i) => ({ long, narrow: narrowWeekdays[i], id: uniqueIdCounter++ }));\n        this.weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));\n    }\n\n    /** Creates MatCalendarCells for the dates in this month. */\n    private createWeekCells(): void {\n        const daysInMonth = this.dateService.getNumDaysInMonth(this.activeDate);\n        const dateNames = this.dateService.getDateNames();\n        this.weeks = [[]];\n\n        for (let i = 0, cell = this.firstWeekOffset; i < daysInMonth; i++, cell++) {\n            if (cell === daysPerWeek) {\n                this.weeks.push([]);\n                cell = 0;\n            }\n\n            const date = this.dateService.create(this.activeDate.getFullYear(), this.activeDate.getMonth(), i + 1);\n            const isEnabled = this.shouldEnableDate(date);\n            const ariaLabel = this.dateService.format(date, { year: 'numeric', month: 'long', day: 'numeric' });\n            const cellClasses = this.dateClass ? this.dateClass(date, 'month') : undefined;\n\n            this.weeks[this.weeks.length - 1].push(\n                new CalendarCellModel(\n                    i + 1,\n                    dateNames[i],\n                    ariaLabel,\n                    isEnabled,\n                    cellClasses,\n                    this.getCellCompareValue(date)!,\n                    date\n                )\n            );\n        }\n    }\n\n    /** Date filter for the month */\n    private shouldEnableDate(date: Date): boolean {\n        return !!date &&\n            (!this.minDate || this.dateService.compare(date, this.minDate) >= 0) &&\n            (!this.maxDate || this.dateService.compare(date, this.maxDate) <= 0) &&\n            (!this.dateFilter || this.dateFilter(date));\n    }\n\n    /**\n     * Gets the date in this month that the given Date falls on.\n     * Returns null if the given Date is in another month.\n     */\n    private getDateInCurrentMonth(date?: Date): OptionalType<number> {\n        return !!date && this.isSameMonthAndYearAsActiveDate(date, this.calendarSignalsService.activeDate())\n            ? date.getDate()\n            : undefined;\n    }\n\n    /** Checks whether the 2 dates are non-null and fall within the same month of the same year. */\n    private isSameMonthAndYearAsActiveDate(d1?: Date, d2?: Date): boolean {\n        return (!!d1 && !!d2 && d1.getMonth() === d2.getMonth() && d1.getFullYear() === d2.getFullYear());\n    }\n\n    /** Gets the value that will be used to one cell to another. */\n    private getCellCompareValue(date?: Date): OptionalType<number> {\n        if (!!date) {\n            // We use the time since the Unix epoch to compare dates in this view, rather than the\n            // cell values, because we need to support ranges that span across multiple months/years.\n            const year = date.getFullYear();\n            const month = date.getMonth();\n            const day = date.getDate();\n\n            return new Date(year, month, day).getTime();\n        }\n\n        return undefined;\n    }\n\n    /** Sets the current range based on a model value. */\n    private setRanges(selectedValue: DateRangeModel | OptionalType<Date>): void {\n        if (selectedValue instanceof DateRangeModel) {\n            this.rangeStart = this.getCellCompareValue(selectedValue.start);\n            this.rangeEnd = this.getCellCompareValue(selectedValue.end);\n            this.isRange = true;\n        } else {\n            this.rangeStart = this.rangeEnd = this.getCellCompareValue(selectedValue);\n        }\n\n        this.comparisonRangeStart = this.getCellCompareValue(this.comparisonStart);\n        this.comparisonRangeEnd = this.getCellCompareValue(this.comparisonEnd);\n    }\n\n    /** Gets whether a date can be selected in the month view. */\n    private canSelect(date: Date): boolean {\n        return !this.dateFilter || this.dateFilter(date);\n    }\n\n    /** Clears out preview state. */\n    private clearPreview(): void {\n        this.previewStart = this.previewEnd = undefined;\n    }\n}\n","<upd-calendar-header></upd-calendar-header>\n<div class=\"container mt-2\">\n    <div class=\"row seven-cols\">\n        @for (day of weekdays; track day.id) {\n            <div class=\"col-1 p-1 d-flex justify-content-center align-items-center\">\n                <span class=\"visually-hidden\">{{ day.long }}</span>\n                <span aria-hidden=\"true\">{{ day.narrow }}</span>\n            </div>\n        }\n    </div>\n</div>\n<upd-calendar-body [label]=\"monthLabel\" [rows]=\"weeks\" [todayValue]=\"todayDate!\" [startValue]=\"rangeStart!\"\n    [endValue]=\"rangeEnd!\" [comparisonStart]=\"comparisonRangeStart\" [comparisonEnd]=\"comparisonRangeEnd\"\n    [previewStart]=\"previewStart\" [previewEnd]=\"previewEnd\" [isRange]=\"isRange\" [labelMinRequiredCells]=\"3\"\n    [activeCell]=\"activeDate.getDate() - 1\" [startDateAccessibleName]=\"startDateAccessibleName\"\n    [endDateAccessibleName]=\"endDateAccessibleName\" (selectedValueChange)=\"dateSelected($event)\"\n    (previewChange)=\"previewChanged($event)\" (dragStarted)=\"dragStarted.emit($event)\" (dragEnded)=\"_dragEnded($event)\"\n    (keyup)=\"handleCalendarBodyKeyup($event)\" (keydown)=\"handleCalendarBodyKeydown($event)\">\n</upd-calendar-body>\n"]}

package/esm2022/calendar/components/calendar-multi-year-view/calendar-multi-year-view.component.mjs

@@ -0,0 +1,18 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export const yearsPerPage = 24;
+export class CalendarMultiYearViewComponent {
+    /** Initializes this month view. */
+    init() {
+    }
+    /** Focuses the active cell after the microtask queue is empty. */
+    focusActiveCell(movePreview) {
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CalendarMultiYearViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.0", type: CalendarMultiYearViewComponent, selector: "upd-calendar-multi-year-view", ngImport: i0, template: "<p>calendar-multi-year-view works!</p>\n", styles: [""] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CalendarMultiYearViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'upd-calendar-multi-year-view', template: "<p>calendar-multi-year-view works!</p>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsZW5kYXItbXVsdGkteWVhci12aWV3LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jYWxlbmRhci9zcmMvY29tcG9uZW50cy9jYWxlbmRhci1tdWx0aS15ZWFyLXZpZXcvY2FsZW5kYXItbXVsdGkteWVhci12aWV3LmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jYWxlbmRhci9zcmMvY29tcG9uZW50cy9jYWxlbmRhci1tdWx0aS15ZWFyLXZpZXcvY2FsZW5kYXItbXVsdGkteWVhci12aWV3LmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRTFDLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxFQUFFLENBQUM7QUFPL0IsTUFBTSxPQUFPLDhCQUE4QjtJQUN2QyxtQ0FBbUM7SUFDbkMsSUFBSTtJQUVKLENBQUM7SUFFRCxrRUFBa0U7SUFDbEUsZUFBZSxDQUFDLFdBQXFCO0lBQ3JDLENBQUM7OEdBUlEsOEJBQThCO2tHQUE5Qiw4QkFBOEIsb0VDVDNDLDBDQUNBOzsyRkRRYSw4QkFBOEI7a0JBTDFDLFNBQVM7K0JBQ0ksOEJBQThCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCB5ZWFyc1BlclBhZ2UgPSAyNDtcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICd1cGQtY2FsZW5kYXItbXVsdGkteWVhci12aWV3JyxcbiAgICB0ZW1wbGF0ZVVybDogJy4vY2FsZW5kYXItbXVsdGkteWVhci12aWV3LmNvbXBvbmVudC5odG1sJyxcbiAgICBzdHlsZVVybDogJy4vY2FsZW5kYXItbXVsdGkteWVhci12aWV3LmNvbXBvbmVudC5zY3NzJ1xufSlcbmV4cG9ydCBjbGFzcyBDYWxlbmRhck11bHRpWWVhclZpZXdDb21wb25lbnQge1xuICAgIC8qKiBJbml0aWFsaXplcyB0aGlzIG1vbnRoIHZpZXcuICovXG4gICAgaW5pdCgpOiB2b2lkIHtcblxuICAgIH1cblxuICAgIC8qKiBGb2N1c2VzIHRoZSBhY3RpdmUgY2VsbCBhZnRlciB0aGUgbWljcm90YXNrIHF1ZXVlIGlzIGVtcHR5LiAqL1xuICAgIGZvY3VzQWN0aXZlQ2VsbChtb3ZlUHJldmlldz86IGJvb2xlYW4pOiB2b2lkIHtcbiAgICB9XG59XG4iLCI8cD5jYWxlbmRhci1tdWx0aS15ZWFyLXZpZXcgd29ya3MhPC9wPlxuIl19

package/esm2022/calendar/components/calendar-year-view/calendar-year-view.component.mjs

@@ -0,0 +1,17 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CalendarYearViewComponent {
+    /** Initializes this month view. */
+    init() {
+    }
+    /** Focuses the active cell after the microtask queue is empty. */
+    focusActiveCell(movePreview) {
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CalendarYearViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.0", type: CalendarYearViewComponent, selector: "upd-calendar-year-view", ngImport: i0, template: "<p>calendar-year-view works!</p>\n", styles: [""] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CalendarYearViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'upd-calendar-year-view', template: "<p>calendar-year-view works!</p>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsZW5kYXIteWVhci12aWV3LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jYWxlbmRhci9zcmMvY29tcG9uZW50cy9jYWxlbmRhci15ZWFyLXZpZXcvY2FsZW5kYXIteWVhci12aWV3LmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jYWxlbmRhci9zcmMvY29tcG9uZW50cy9jYWxlbmRhci15ZWFyLXZpZXcvY2FsZW5kYXIteWVhci12aWV3LmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTzFDLE1BQU0sT0FBTyx5QkFBeUI7SUFDbEMsbUNBQW1DO0lBQ25DLElBQUk7SUFFSixDQUFDO0lBRUQsa0VBQWtFO0lBQ2xFLGVBQWUsQ0FBQyxXQUFxQjtJQUNyQyxDQUFDOzhHQVJRLHlCQUF5QjtrR0FBekIseUJBQXlCLDhEQ1B0QyxvQ0FDQTs7MkZETWEseUJBQXlCO2tCQUxyQyxTQUFTOytCQUNJLHdCQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ3VwZC1jYWxlbmRhci15ZWFyLXZpZXcnLFxuICAgIHRlbXBsYXRlVXJsOiAnLi9jYWxlbmRhci15ZWFyLXZpZXcuY29tcG9uZW50Lmh0bWwnLFxuICAgIHN0eWxlVXJsOiAnLi9jYWxlbmRhci15ZWFyLXZpZXcuY29tcG9uZW50LnNjc3MnXG59KVxuZXhwb3J0IGNsYXNzIENhbGVuZGFyWWVhclZpZXdDb21wb25lbnQge1xuICAgIC8qKiBJbml0aWFsaXplcyB0aGlzIG1vbnRoIHZpZXcuICovXG4gICAgaW5pdCgpOiB2b2lkIHtcblxuICAgIH1cblxuICAgIC8qKiBGb2N1c2VzIHRoZSBhY3RpdmUgY2VsbCBhZnRlciB0aGUgbWljcm90YXNrIHF1ZXVlIGlzIGVtcHR5LiAqL1xuICAgIGZvY3VzQWN0aXZlQ2VsbChtb3ZlUHJldmlldz86IGJvb2xlYW4pOiB2b2lkIHtcbiAgICB9XG59XG4iLCI8cD5jYWxlbmRhci15ZWFyLXZpZXcgd29ya3MhPC9wPlxuIl19

package/esm2022/calendar/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvY2FsZW5kYXIvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/calendar/models/calendar-cell.model.mjs

@@ -0,0 +1,18 @@
+let uniqueIdCounter = 0;
+/**
+ * An internal class that represents the data corresponding to a single calendar cell.
+ * @docs-private
+ */
+export class CalendarCellModel {
+    constructor(value, displayValue, ariaLabel, isEnabled, cssClasses = {}, compareValue = value, rawValue) {
+        this.value = value;
+        this.displayValue = displayValue;
+        this.ariaLabel = ariaLabel;
+        this.isEnabled = isEnabled;
+        this.cssClasses = cssClasses;
+        this.compareValue = compareValue;
+        this.rawValue = rawValue;
+        this.id = uniqueIdCounter++;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsZW5kYXItY2VsbC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jYWxlbmRhci9zcmMvbW9kZWxzL2NhbGVuZGFyLWNlbGwubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsSUFBSSxlQUFlLEdBQUcsQ0FBQyxDQUFDO0FBRXhCOzs7R0FHRztBQUNILE1BQU0sT0FBTyxpQkFBaUI7SUFHMUIsWUFDVyxLQUFhLEVBQ2IsWUFBb0IsRUFDcEIsU0FBaUIsRUFDakIsU0FBa0IsRUFDbEIsYUFBeUMsRUFBRSxFQUMzQyxlQUFlLEtBQUssRUFDcEIsUUFBZTtRQU5mLFVBQUssR0FBTCxLQUFLLENBQVE7UUFDYixpQkFBWSxHQUFaLFlBQVksQ0FBUTtRQUNwQixjQUFTLEdBQVQsU0FBUyxDQUFRO1FBQ2pCLGNBQVMsR0FBVCxTQUFTLENBQVM7UUFDbEIsZUFBVSxHQUFWLFVBQVUsQ0FBaUM7UUFDM0MsaUJBQVksR0FBWixZQUFZLENBQVE7UUFDcEIsYUFBUSxHQUFSLFFBQVEsQ0FBTztRQVRqQixPQUFFLEdBQUcsZUFBZSxFQUFFLENBQUM7SUFXaEMsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2FsZW5kYXJDZWxsQ3NzQ2xhc3Nlc1R5cGUgfSBmcm9tICcuLi90eXBlcy9jYWxlbmRhci1jZWxsLWNzcy1jbGFzc2VzLnR5cGUnO1xuXG5sZXQgdW5pcXVlSWRDb3VudGVyID0gMDtcblxuLyoqXG4gKiBBbiBpbnRlcm5hbCBjbGFzcyB0aGF0IHJlcHJlc2VudHMgdGhlIGRhdGEgY29ycmVzcG9uZGluZyB0byBhIHNpbmdsZSBjYWxlbmRhciBjZWxsLlxuICogQGRvY3MtcHJpdmF0ZVxuICovXG5leHBvcnQgY2xhc3MgQ2FsZW5kYXJDZWxsTW9kZWwge1xuICAgIHJlYWRvbmx5IGlkID0gdW5pcXVlSWRDb3VudGVyKys7XG5cbiAgICBjb25zdHJ1Y3RvcihcbiAgICAgICAgcHVibGljIHZhbHVlOiBudW1iZXIsXG4gICAgICAgIHB1YmxpYyBkaXNwbGF5VmFsdWU6IHN0cmluZyxcbiAgICAgICAgcHVibGljIGFyaWFMYWJlbDogc3RyaW5nLFxuICAgICAgICBwdWJsaWMgaXNFbmFibGVkOiBib29sZWFuLFxuICAgICAgICBwdWJsaWMgY3NzQ2xhc3NlczogQ2FsZW5kYXJDZWxsQ3NzQ2xhc3Nlc1R5cGUgPSB7fSxcbiAgICAgICAgcHVibGljIGNvbXBhcmVWYWx1ZSA9IHZhbHVlLFxuICAgICAgICBwdWJsaWMgcmF3VmFsdWU/OiBEYXRlXG4gICAgKSB7XG4gICAgfVxufVxuIl19

package/esm2022/calendar/models/calendar-user-event.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsZW5kYXItdXNlci1ldmVudC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jYWxlbmRhci9zcmMvbW9kZWxzL2NhbGVuZGFyLXVzZXItZXZlbnQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQ2FsZW5kYXJVc2VyRXZlbnRNb2RlbDxUVmFsdWU+IHtcbiAgICB2YWx1ZTogVFZhbHVlO1xuICAgIGV2ZW50OiBFdmVudDtcbn1cbiJdfQ==

package/esm2022/calendar/models/date-range.model.mjs

@@ -0,0 +1,18 @@
+/**
+ * A class representing a range of dates.
+ */
+export class DateRangeModel {
+    constructor(
+    /**
+     * The start date of the range.
+     */
+    start, 
+    /**
+     * The end date of the range.
+     */
+    end) {
+        this.start = start;
+        this.end = end;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1yYW5nZS5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9jYWxlbmRhci9zcmMvbW9kZWxzL2RhdGUtcmFuZ2UubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sY0FBYztJQU92QjtJQUNJOztPQUVHO0lBQ00sS0FBWTtJQUNyQjs7T0FFRztJQUNNLEdBQVU7UUFKVixVQUFLLEdBQUwsS0FBSyxDQUFPO1FBSVosUUFBRyxHQUFILEdBQUcsQ0FBTztJQUV2QixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgY2xhc3MgcmVwcmVzZW50aW5nIGEgcmFuZ2Ugb2YgZGF0ZXMuXG4gKi9cbmV4cG9ydCBjbGFzcyBEYXRlUmFuZ2VNb2RlbCB7XG4gICAgLyoqXG4gICAgICogRW5zdXJlcyB0aGF0IG9iamVjdHMgd2l0aCBhIGBzdGFydGAgYW5kIGBlbmRgIHByb3BlcnR5IGNhbid0IGJlIGFzc2lnbmVkIHRvIGEgdmFyaWFibGUgdGhhdFxuICAgICAqIGV4cGVjdHMgYSBgRGF0ZVJhbmdlYFxuICAgICAqLy8vIEB0cy1pZ25vcmVcbiAgICBwcml2YXRlIGRpc2FibGVTdHJ1Y3R1cmFsRXF1aXZhbGVuY3k6IG5ldmVyO1xuXG4gICAgY29uc3RydWN0b3IoXG4gICAgICAgIC8qKlxuICAgICAgICAgKiBUaGUgc3RhcnQgZGF0ZSBvZiB0aGUgcmFuZ2UuXG4gICAgICAgICAqL1xuICAgICAgICByZWFkb25seSBzdGFydD86IERhdGUsXG4gICAgICAgIC8qKlxuICAgICAgICAgKiBUaGUgZW5kIGRhdGUgb2YgdGhlIHJhbmdlLlxuICAgICAgICAgKi9cbiAgICAgICAgcmVhZG9ubHkgZW5kPzogRGF0ZVxuICAgICkge1xuICAgIH1cbn1cbiJdfQ==