@ng-matero/extensions 15.5.0 → 16.0.0

package/esm2022/datetimepicker/month-view.mjs

@@ -0,0 +1,149 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Inject, Input, Optional, Output, ViewEncapsulation, } from '@angular/core';
+import { MTX_DATETIME_FORMATS, } from '@ng-matero/extensions/core';
+import { MtxCalendarCell } from './calendar-body';
+import { mtxDatetimepickerAnimations } from './datetimepicker-animations';
+import { createMissingDateImplError } from './datetimepicker-errors';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-matero/extensions/core";
+import * as i2 from "@angular/common";
+import * as i3 from "./calendar-body";
+const DAYS_PER_WEEK = 7;
+/**
+ * An internal component used to display a single month in the datetimepicker.
+ * @docs-private
+ */
+class MtxMonthView {
+    constructor(_adapter, _dateFormats) {
+        this._adapter = _adapter;
+        this._dateFormats = _dateFormats;
+        this.type = 'date';
+        /** Emits when a new date is selected. */
+        this.selectedChange = new EventEmitter();
+        /** Emits when any date is selected. */
+        this._userSelection = new EventEmitter();
+        if (!this._adapter) {
+            throw createMissingDateImplError('DatetimeAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('MTX_DATETIME_FORMATS');
+        }
+        const firstDayOfWeek = this._adapter.getFirstDayOfWeek();
+        const narrowWeekdays = this._adapter.getDayOfWeekNames('narrow');
+        const longWeekdays = this._adapter.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) => {
+            return { long, narrow: narrowWeekdays[i] };
+        });
+        this._weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));
+        this._activeDate = this._adapter.today();
+    }
+    /**
+     * The date to display in this month view (everything other than the month and year is ignored).
+     */
+    get activeDate() {
+        return this._activeDate;
+    }
+    set activeDate(value) {
+        const oldActiveDate = this._activeDate;
+        this._activeDate = value || this._adapter.today();
+        if (oldActiveDate &&
+            this._activeDate &&
+            !this._adapter.sameMonthAndYear(oldActiveDate, this._activeDate)) {
+            this._init();
+            if (this._adapter.isInNextMonth(oldActiveDate, this._activeDate)) {
+                this.calendarState('right');
+            }
+            else {
+                this.calendarState('left');
+            }
+        }
+    }
+    /** The currently selected date. */
+    get selected() {
+        return this._selected;
+    }
+    set selected(value) {
+        this._selected = value;
+        this._selectedDate = this._getDateInCurrentMonth(this.selected);
+    }
+    ngAfterContentInit() {
+        this._init();
+    }
+    /** Handles when a new date is selected. */
+    _dateSelected(date) {
+        this.selectedChange.emit(this._adapter.createDatetime(this._adapter.getYear(this.activeDate), this._adapter.getMonth(this.activeDate), date, this._adapter.getHour(this.activeDate), this._adapter.getMinute(this.activeDate)));
+        if (this.type === 'date') {
+            this._userSelection.emit();
+        }
+    }
+    _calendarStateDone() {
+        this._calendarState = '';
+    }
+    /** Initializes this month view. */
+    _init() {
+        this._selectedDate = this._getDateInCurrentMonth(this.selected);
+        this._todayDate = this._getDateInCurrentMonth(this._adapter.today());
+        const firstOfMonth = this._adapter.createDatetime(this._adapter.getYear(this.activeDate), this._adapter.getMonth(this.activeDate), 1, this._adapter.getHour(this.activeDate), this._adapter.getMinute(this.activeDate));
+        this._firstWeekOffset =
+            (DAYS_PER_WEEK +
+                this._adapter.getDayOfWeek(firstOfMonth) -
+                this._adapter.getFirstDayOfWeek()) %
+                DAYS_PER_WEEK;
+        this._createWeekCells();
+    }
+    /** Creates MdCalendarCells for the dates in this month. */
+    _createWeekCells() {
+        const daysInMonth = this._adapter.getNumDaysInMonth(this.activeDate);
+        const dateNames = this._adapter.getDateNames();
+        this._weeks = [[]];
+        for (let i = 0, cell = this._firstWeekOffset; i < daysInMonth; i++, cell++) {
+            if (cell === DAYS_PER_WEEK) {
+                this._weeks.push([]);
+                cell = 0;
+            }
+            const date = this._adapter.createDatetime(this._adapter.getYear(this.activeDate), this._adapter.getMonth(this.activeDate), i + 1, this._adapter.getHour(this.activeDate), this._adapter.getMinute(this.activeDate));
+            const enabled = !this.dateFilter || this.dateFilter(date);
+            const ariaLabel = this._adapter.format(date, this._dateFormats.display.dateA11yLabel);
+            this._weeks[this._weeks.length - 1].push(new MtxCalendarCell(i + 1, dateNames[i], ariaLabel, enabled));
+        }
+    }
+    /**
+     * 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 this._adapter.sameMonthAndYear(date, this.activeDate)
+            ? this._adapter.getDate(date)
+            : null;
+    }
+    calendarState(direction) {
+        this._calendarState = direction;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxMonthView, deps: [{ token: i1.DatetimeAdapter, optional: true }, { token: MTX_DATETIME_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.3", type: MtxMonthView, selector: "mtx-month-view", inputs: { type: "type", dateFilter: "dateFilter", activeDate: "activeDate", selected: "selected" }, outputs: { selectedChange: "selectedChange", _userSelection: "_userSelection" }, exportAs: ["mtxMonthView"], ngImport: i0, template: "<table class=\"mtx-calendar-table\" role=\"grid\">\n  <thead class=\"mtx-calendar-table-header\">\n    <tr>\n      <th *ngFor=\"let day of _weekdays\" [attr.aria-label]=\"day.long\">{{day.narrow}}</th>\n    </tr>\n  </thead>\n  <tbody mtx-calendar-body\n         (@slideCalendar.done)=\"_calendarStateDone()\"\n         [@slideCalendar]=\"_calendarState\"\n         [rows]=\"_weeks\"\n         [todayValue]=\"_todayDate!\"\n         [activeCell]=\"_adapter.getDate(activeDate) - 1\"\n         [selectedValue]=\"_selectedDate!\"\n         (selectedValueChange)=\"_dateSelected($event)\"></tbody>\n</table>\n", dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i3.MtxCalendarBody, selector: "[mtx-calendar-body]", inputs: ["label", "rows", "todayValue", "selectedValue", "labelMinRequiredCells", "numCols", "allowDisabledSelection", "activeCell"], outputs: ["selectedValueChange"], exportAs: ["mtxCalendarBody"] }], animations: [mtxDatetimepickerAnimations.slideCalendar], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { MtxMonthView };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxMonthView, decorators: [{
+            type: Component,
+            args: [{ selector: 'mtx-month-view', exportAs: 'mtxMonthView', animations: [mtxDatetimepickerAnimations.slideCalendar], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<table class=\"mtx-calendar-table\" role=\"grid\">\n  <thead class=\"mtx-calendar-table-header\">\n    <tr>\n      <th *ngFor=\"let day of _weekdays\" [attr.aria-label]=\"day.long\">{{day.narrow}}</th>\n    </tr>\n  </thead>\n  <tbody mtx-calendar-body\n         (@slideCalendar.done)=\"_calendarStateDone()\"\n         [@slideCalendar]=\"_calendarState\"\n         [rows]=\"_weeks\"\n         [todayValue]=\"_todayDate!\"\n         [activeCell]=\"_adapter.getDate(activeDate) - 1\"\n         [selectedValue]=\"_selectedDate!\"\n         (selectedValueChange)=\"_dateSelected($event)\"></tbody>\n</table>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.DatetimeAdapter, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MTX_DATETIME_FORMATS]
+                }] }]; }, propDecorators: { type: [{
+                type: Input
+            }], dateFilter: [{
+                type: Input
+            }], selectedChange: [{
+                type: Output
+            }], _userSelection: [{
+                type: Output
+            }], activeDate: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"month-view.js","sourceRoot":"","sources":["../../../../projects/extensions/datetimepicker/month-view.ts","../../../../projects/extensions/datetimepicker/month-view.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Inject,\n  Input,\n  Optional,\n  Output,\n  ViewEncapsulation,\n} from '@angular/core';\nimport {\n  MTX_DATETIME_FORMATS,\n  MtxDatetimeFormats,\n  DatetimeAdapter,\n} from '@ng-matero/extensions/core';\nimport { MtxCalendarCell } from './calendar-body';\nimport { mtxDatetimepickerAnimations } from './datetimepicker-animations';\nimport { createMissingDateImplError } from './datetimepicker-errors';\nimport { MtxDatetimepickerType } from './datetimepicker-types';\n\nconst DAYS_PER_WEEK = 7;\n\n/**\n * An internal component used to display a single month in the datetimepicker.\n * @docs-private\n */\n@Component({\n  selector: 'mtx-month-view',\n  templateUrl: 'month-view.html',\n  exportAs: 'mtxMonthView',\n  animations: [mtxDatetimepickerAnimations.slideCalendar],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MtxMonthView<D> implements AfterContentInit {\n  @Input() type: MtxDatetimepickerType = 'date';\n\n  /** A function used to filter which dates are selectable. */\n  @Input() dateFilter!: (date: D) => boolean;\n\n  /** Emits when a new date is selected. */\n  @Output() selectedChange = new EventEmitter<D>();\n\n  /** Emits when any date is selected. */\n  @Output() readonly _userSelection = new EventEmitter<void>();\n\n  /** Grid of calendar cells representing the dates of the month. */\n  _weeks!: MtxCalendarCell[][];\n\n  /** The number of blank cells in the first row before the 1st of the month. */\n  _firstWeekOffset!: number;\n\n  /**\n   * The date of the month that the currently selected Date falls on.\n   * Null if the currently selected Date is in another month.\n   */\n  _selectedDate!: number | null;\n\n  /** The date of the month that today falls on. Null if today is in another month. */\n  _todayDate!: number | null;\n\n  /** The names of the weekdays. */\n  _weekdays: { long: string; narrow: string }[];\n\n  _calendarState!: string;\n\n  constructor(\n    @Optional() public _adapter: DatetimeAdapter<D>,\n    @Optional() @Inject(MTX_DATETIME_FORMATS) private _dateFormats: MtxDatetimeFormats\n  ) {\n    if (!this._adapter) {\n      throw createMissingDateImplError('DatetimeAdapter');\n    }\n\n    if (!this._dateFormats) {\n      throw createMissingDateImplError('MTX_DATETIME_FORMATS');\n    }\n\n    const firstDayOfWeek = this._adapter.getFirstDayOfWeek();\n    const narrowWeekdays = this._adapter.getDayOfWeekNames('narrow');\n    const longWeekdays = this._adapter.getDayOfWeekNames('long');\n\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) => {\n      return { long, narrow: narrowWeekdays[i] };\n    });\n    this._weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));\n\n    this._activeDate = this._adapter.today();\n  }\n\n  private _activeDate: D;\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(): D {\n    return this._activeDate;\n  }\n\n  set activeDate(value: D) {\n    const oldActiveDate = this._activeDate;\n    this._activeDate = value || this._adapter.today();\n    if (\n      oldActiveDate &&\n      this._activeDate &&\n      !this._adapter.sameMonthAndYear(oldActiveDate, this._activeDate)\n    ) {\n      this._init();\n      if (this._adapter.isInNextMonth(oldActiveDate, this._activeDate)) {\n        this.calendarState('right');\n      } else {\n        this.calendarState('left');\n      }\n    }\n  }\n\n  /** The currently selected date. */\n  @Input()\n  get selected(): D {\n    return this._selected;\n  }\n  set selected(value: D) {\n    this._selected = value;\n    this._selectedDate = this._getDateInCurrentMonth(this.selected);\n  }\n  private _selected!: D;\n\n  ngAfterContentInit(): void {\n    this._init();\n  }\n\n  /** Handles when a new date is selected. */\n  _dateSelected(date: number) {\n    this.selectedChange.emit(\n      this._adapter.createDatetime(\n        this._adapter.getYear(this.activeDate),\n        this._adapter.getMonth(this.activeDate),\n        date,\n        this._adapter.getHour(this.activeDate),\n        this._adapter.getMinute(this.activeDate)\n      )\n    );\n    if (this.type === 'date') {\n      this._userSelection.emit();\n    }\n  }\n\n  _calendarStateDone() {\n    this._calendarState = '';\n  }\n\n  /** Initializes this month view. */\n  private _init() {\n    this._selectedDate = this._getDateInCurrentMonth(this.selected);\n    this._todayDate = this._getDateInCurrentMonth(this._adapter.today());\n\n    const firstOfMonth = this._adapter.createDatetime(\n      this._adapter.getYear(this.activeDate),\n      this._adapter.getMonth(this.activeDate),\n      1,\n      this._adapter.getHour(this.activeDate),\n      this._adapter.getMinute(this.activeDate)\n    );\n    this._firstWeekOffset =\n      (DAYS_PER_WEEK +\n        this._adapter.getDayOfWeek(firstOfMonth) -\n        this._adapter.getFirstDayOfWeek()) %\n      DAYS_PER_WEEK;\n\n    this._createWeekCells();\n  }\n\n  /** Creates MdCalendarCells for the dates in this month. */\n  private _createWeekCells() {\n    const daysInMonth = this._adapter.getNumDaysInMonth(this.activeDate);\n    const dateNames = this._adapter.getDateNames();\n    this._weeks = [[]];\n    for (let i = 0, cell = this._firstWeekOffset; i < daysInMonth; i++, cell++) {\n      if (cell === DAYS_PER_WEEK) {\n        this._weeks.push([]);\n        cell = 0;\n      }\n      const date = this._adapter.createDatetime(\n        this._adapter.getYear(this.activeDate),\n        this._adapter.getMonth(this.activeDate),\n        i + 1,\n        this._adapter.getHour(this.activeDate),\n        this._adapter.getMinute(this.activeDate)\n      );\n      const enabled = !this.dateFilter || this.dateFilter(date);\n      const ariaLabel = this._adapter.format(date, this._dateFormats.display.dateA11yLabel);\n      this._weeks[this._weeks.length - 1].push(\n        new MtxCalendarCell(i + 1, dateNames[i], ariaLabel, enabled)\n      );\n    }\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: D): number | null {\n    return this._adapter.sameMonthAndYear(date, this.activeDate)\n      ? this._adapter.getDate(date)\n      : null;\n  }\n\n  private calendarState(direction: string): void {\n    this._calendarState = direction;\n  }\n}\n","<table class=\"mtx-calendar-table\" role=\"grid\">\n  <thead class=\"mtx-calendar-table-header\">\n    <tr>\n      <th *ngFor=\"let day of _weekdays\" [attr.aria-label]=\"day.long\">{{day.narrow}}</th>\n    </tr>\n  </thead>\n  <tbody mtx-calendar-body\n         (@slideCalendar.done)=\"_calendarStateDone()\"\n         [@slideCalendar]=\"_calendarState\"\n         [rows]=\"_weeks\"\n         [todayValue]=\"_todayDate!\"\n         [activeCell]=\"_adapter.getDate(activeDate) - 1\"\n         [selectedValue]=\"_selectedDate!\"\n         (selectedValueChange)=\"_dateSelected($event)\"></tbody>\n</table>\n"]}

package/esm2022/datetimepicker/multi-year-view.mjs

@@ -0,0 +1,215 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Inject, Input, Optional, Output, ViewEncapsulation, } from '@angular/core';
+import { createMissingDateImplError } from './datetimepicker-errors';
+import { MtxCalendarCell } from './calendar-body';
+import { mtxDatetimepickerAnimations } from './datetimepicker-animations';
+import { MTX_DATETIME_FORMATS, } from '@ng-matero/extensions/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-matero/extensions/core";
+import * as i2 from "./calendar-body";
+export const yearsPerPage = 24;
+export const yearsPerRow = 4;
+/**
+ * An internal component used to display multiple years in the datetimepicker.
+ * @docs-private
+ */
+class MtxMultiYearView {
+    constructor(_adapter, _dateFormats) {
+        this._adapter = _adapter;
+        this._dateFormats = _dateFormats;
+        this.type = 'date';
+        /** Emits when a new month is selected. */
+        this.selectedChange = new EventEmitter();
+        /** Emits when any date is selected. */
+        this._userSelection = new EventEmitter();
+        if (!this._adapter) {
+            throw createMissingDateImplError('DatetimeAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('MTX_DATETIME_FORMATS');
+        }
+        this._activeDate = this._adapter.today();
+    }
+    /** The date to display in this multi year view */
+    get activeDate() {
+        return this._activeDate;
+    }
+    set activeDate(value) {
+        const oldActiveDate = this._activeDate;
+        this._activeDate = value || this._adapter.today();
+        if (oldActiveDate &&
+            this._activeDate &&
+            !isSameMultiYearView(this._adapter, oldActiveDate, this._activeDate, this.minDate, this.maxDate)) {
+            this._init();
+        }
+    }
+    /** The currently selected date. */
+    get selected() {
+        return this._selected;
+    }
+    set selected(value) {
+        this._selected = value;
+        this._selectedYear = this._selected && this._adapter.getYear(this._selected);
+    }
+    /** The minimum selectable date. */
+    get minDate() {
+        return this._minDate;
+    }
+    set minDate(value) {
+        this._minDate = this._getValidDateOrNull(this._adapter.deserialize(value));
+    }
+    /** The maximum selectable date. */
+    get maxDate() {
+        return this._maxDate;
+    }
+    set maxDate(value) {
+        this._maxDate = this._getValidDateOrNull(this._adapter.deserialize(value));
+    }
+    ngAfterContentInit() {
+        this._init();
+    }
+    /** Handles when a new year is selected. */
+    _yearSelected(year) {
+        const month = this._adapter.getMonth(this.activeDate);
+        const normalizedDate = this._adapter.createDatetime(year, month, 1, 0, 0);
+        this.selectedChange.emit(this._adapter.createDatetime(year, month, Math.min(this._adapter.getDate(this.activeDate), this._adapter.getNumDaysInMonth(normalizedDate)), this._adapter.getHour(this.activeDate), this._adapter.getMinute(this.activeDate)));
+        if (this.type === 'year') {
+            this._userSelection.emit();
+        }
+    }
+    _getActiveCell() {
+        return getActiveOffset(this._adapter, this.activeDate, this.minDate, this.maxDate);
+    }
+    _calendarStateDone() {
+        this._calendarState = '';
+    }
+    /** Initializes this year view. */
+    _init() {
+        this._todayYear = this._adapter.getYear(this._adapter.today());
+        this._yearLabel = this._adapter.getYearName(this.activeDate);
+        const activeYear = this._adapter.getYear(this.activeDate);
+        const minYearOfPage = activeYear - getActiveOffset(this._adapter, this.activeDate, this.minDate, this.maxDate);
+        this._years = [];
+        for (let i = 0, row = []; i < yearsPerPage; i++) {
+            row.push(minYearOfPage + i);
+            if (row.length === yearsPerRow) {
+                this._years.push(row.map(year => this._createCellForYear(year)));
+                row = [];
+            }
+        }
+    }
+    /** Creates an MtxCalendarCell for the given year. */
+    _createCellForYear(year) {
+        const yearName = this._adapter.getYearName(this._adapter.createDate(year, 0, 1));
+        return new MtxCalendarCell(year, yearName, yearName, this._shouldEnableYear(year));
+    }
+    /** Whether the given year is enabled. */
+    _shouldEnableYear(year) {
+        // disable if the year is greater than maxDate lower than minDate
+        if (year === undefined ||
+            year === null ||
+            (this.maxDate && year > this._adapter.getYear(this.maxDate)) ||
+            (this.minDate && year < this._adapter.getYear(this.minDate))) {
+            return false;
+        }
+        // enable if it reaches here and there's no filter defined
+        if (!this.dateFilter) {
+            return true;
+        }
+        const firstOfYear = this._adapter.createDate(year, 0, 1);
+        // If any date in the year is enabled count the year as enabled.
+        for (let date = firstOfYear; this._adapter.getYear(date) === year; date = this._adapter.addCalendarDays(date, 1)) {
+            if (this.dateFilter(date)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Gets the year in this years range that the given Date falls on.
+     * Returns null if the given Date is not in this range.
+     */
+    _getYearInCurrentRange(date) {
+        const year = this._adapter.getYear(date);
+        return this._isInRange(year) ? year : null;
+    }
+    /**
+     * Validate if the current year is in the current range
+     * Returns true if is in range else returns false
+     */
+    _isInRange(year) {
+        return true;
+    }
+    /**
+     * @param obj The object to check.
+     * @returns The given object if it is both a date instance and valid, otherwise null.
+     */
+    _getValidDateOrNull(obj) {
+        return this._adapter.isDateInstance(obj) && this._adapter.isValid(obj) ? obj : null;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxMultiYearView, deps: [{ token: i1.DatetimeAdapter, optional: true }, { token: MTX_DATETIME_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.3", type: MtxMultiYearView, selector: "mtx-multi-year-view", inputs: { type: "type", dateFilter: "dateFilter", activeDate: "activeDate", selected: "selected", minDate: "minDate", maxDate: "maxDate" }, outputs: { selectedChange: "selectedChange", _userSelection: "_userSelection" }, exportAs: ["mtxMultiYearView"], ngImport: i0, template: "<table class=\"mtx-calendar-table\" role=\"grid\">\n  <thead class=\"mtx-calendar-table-header\"></thead>\n  <tbody mtx-calendar-body\n         (@slideCalendar.done)=\"_calendarStateDone()\"\n         [@slideCalendar]=\"_calendarState\"\n         [todayValue]=\"_todayYear\"\n         [rows]=\"_years\"\n         [numCols]=\"4\"\n         [activeCell]=\"_getActiveCell()\"\n         [allowDisabledSelection]=\"true\"\n         [selectedValue]=\"_selectedYear!\"\n         (selectedValueChange)=\"_yearSelected($event)\"></tbody>\n</table>\n", dependencies: [{ kind: "component", type: i2.MtxCalendarBody, selector: "[mtx-calendar-body]", inputs: ["label", "rows", "todayValue", "selectedValue", "labelMinRequiredCells", "numCols", "allowDisabledSelection", "activeCell"], outputs: ["selectedValueChange"], exportAs: ["mtxCalendarBody"] }], animations: [mtxDatetimepickerAnimations.slideCalendar], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { MtxMultiYearView };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxMultiYearView, decorators: [{
+            type: Component,
+            args: [{ selector: 'mtx-multi-year-view', exportAs: 'mtxMultiYearView', animations: [mtxDatetimepickerAnimations.slideCalendar], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<table class=\"mtx-calendar-table\" role=\"grid\">\n  <thead class=\"mtx-calendar-table-header\"></thead>\n  <tbody mtx-calendar-body\n         (@slideCalendar.done)=\"_calendarStateDone()\"\n         [@slideCalendar]=\"_calendarState\"\n         [todayValue]=\"_todayYear\"\n         [rows]=\"_years\"\n         [numCols]=\"4\"\n         [activeCell]=\"_getActiveCell()\"\n         [allowDisabledSelection]=\"true\"\n         [selectedValue]=\"_selectedYear!\"\n         (selectedValueChange)=\"_yearSelected($event)\"></tbody>\n</table>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.DatetimeAdapter, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MTX_DATETIME_FORMATS]
+                }] }]; }, propDecorators: { type: [{
+                type: Input
+            }], dateFilter: [{
+                type: Input
+            }], selectedChange: [{
+                type: Output
+            }], _userSelection: [{
+                type: Output
+            }], activeDate: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }] } });
+export function isSameMultiYearView(dateAdapter, date1, date2, minDate, maxDate) {
+    const year1 = dateAdapter.getYear(date1);
+    const year2 = dateAdapter.getYear(date2);
+    const startingYear = getStartingYear(dateAdapter, minDate, maxDate);
+    return (Math.floor((year1 - startingYear) / yearsPerPage) ===
+        Math.floor((year2 - startingYear) / yearsPerPage));
+}
+/**
+ * When the multi-year view is first opened, the active year will be in view.
+ * So we compute how many years are between the active year and the *slot* where our
+ * "startingYear" will render when paged into view.
+ */
+export function getActiveOffset(dateAdapter, activeDate, minDate, maxDate) {
+    const activeYear = dateAdapter.getYear(activeDate);
+    return euclideanModulo(activeYear - getStartingYear(dateAdapter, minDate, maxDate), yearsPerPage);
+}
+/**
+ * We pick a "starting" year such that either the maximum year would be at the end
+ * or the minimum year would be at the beginning of a page.
+ */
+function getStartingYear(dateAdapter, minDate, maxDate) {
+    let startingYear = 0;
+    if (maxDate) {
+        const maxYear = dateAdapter.getYear(maxDate);
+        startingYear = maxYear - yearsPerPage + 1;
+    }
+    else if (minDate) {
+        startingYear = dateAdapter.getYear(minDate);
+    }
+    return startingYear;
+}
+/** Gets remainder that is non-negative, even if first number is negative */
+function euclideanModulo(a, b) {
+    return ((a % b) + b) % b;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-year-view.js","sourceRoot":"","sources":["../../../../projects/extensions/datetimepicker/multi-year-view.ts","../../../../projects/extensions/datetimepicker/multi-year-view.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Inject,\n  Input,\n  Optional,\n  Output,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { createMissingDateImplError } from './datetimepicker-errors';\nimport { MtxCalendarCell } from './calendar-body';\nimport { mtxDatetimepickerAnimations } from './datetimepicker-animations';\nimport {\n  MTX_DATETIME_FORMATS,\n  MtxDatetimeFormats,\n  DatetimeAdapter,\n} from '@ng-matero/extensions/core';\nimport { MtxDatetimepickerType } from './datetimepicker-types';\n\nexport const yearsPerPage = 24;\n\nexport const yearsPerRow = 4;\n\n/**\n * An internal component used to display multiple years in the datetimepicker.\n * @docs-private\n */\n@Component({\n  selector: 'mtx-multi-year-view',\n  templateUrl: 'multi-year-view.html',\n  exportAs: 'mtxMultiYearView',\n  animations: [mtxDatetimepickerAnimations.slideCalendar],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MtxMultiYearView<D> implements AfterContentInit {\n  @Input() type: MtxDatetimepickerType = 'date';\n\n  /** A function used to filter which dates are selectable. */\n  @Input() dateFilter!: (date: D) => boolean;\n\n  /** Emits when a new month is selected. */\n  @Output() selectedChange = new EventEmitter<D>();\n\n  /** Emits when any date is selected. */\n  @Output() readonly _userSelection = new EventEmitter<void>();\n\n  /** Grid of calendar cells representing the years in the range. */\n  _years!: MtxCalendarCell[][];\n\n  /** The label for this year range (e.g. \"2000-2020\"). */\n  _yearLabel!: string;\n\n  /** The year in this range that today falls on. Null if today is in a different range. */\n  _todayYear!: number;\n\n  /**\n   * The year in this range that the selected Date falls on.\n   * Null if the selected Date is in a different range.\n   */\n  _selectedYear!: number | null;\n\n  _calendarState!: string;\n\n  constructor(\n    @Optional() public _adapter: DatetimeAdapter<D>,\n    @Optional() @Inject(MTX_DATETIME_FORMATS) private _dateFormats: MtxDatetimeFormats\n  ) {\n    if (!this._adapter) {\n      throw createMissingDateImplError('DatetimeAdapter');\n    }\n\n    if (!this._dateFormats) {\n      throw createMissingDateImplError('MTX_DATETIME_FORMATS');\n    }\n\n    this._activeDate = this._adapter.today();\n  }\n\n  /** The date to display in this multi year view */\n  @Input()\n  get activeDate(): D {\n    return this._activeDate;\n  }\n  set activeDate(value: D) {\n    const oldActiveDate = this._activeDate;\n    this._activeDate = value || this._adapter.today();\n    if (\n      oldActiveDate &&\n      this._activeDate &&\n      !isSameMultiYearView(\n        this._adapter,\n        oldActiveDate,\n        this._activeDate,\n        this.minDate,\n        this.maxDate\n      )\n    ) {\n      this._init();\n    }\n  }\n  private _activeDate: D;\n\n  /** The currently selected date. */\n  @Input()\n  get selected(): D {\n    return this._selected;\n  }\n  set selected(value: D) {\n    this._selected = value;\n    this._selectedYear = this._selected && this._adapter.getYear(this._selected);\n  }\n  private _selected!: D;\n\n  /** The minimum selectable date. */\n  @Input()\n  get minDate(): D | null {\n    return this._minDate;\n  }\n  set minDate(value: D | null) {\n    this._minDate = this._getValidDateOrNull(this._adapter.deserialize(value));\n  }\n  private _minDate!: D | null;\n\n  /** The maximum selectable date. */\n  @Input()\n  get maxDate(): D | null {\n    return this._maxDate;\n  }\n  set maxDate(value: D | null) {\n    this._maxDate = this._getValidDateOrNull(this._adapter.deserialize(value));\n  }\n  private _maxDate!: D | null;\n\n  ngAfterContentInit() {\n    this._init();\n  }\n\n  /** Handles when a new year is selected. */\n  _yearSelected(year: number) {\n    const month = this._adapter.getMonth(this.activeDate);\n    const normalizedDate = this._adapter.createDatetime(year, month, 1, 0, 0);\n\n    this.selectedChange.emit(\n      this._adapter.createDatetime(\n        year,\n        month,\n        Math.min(\n          this._adapter.getDate(this.activeDate),\n          this._adapter.getNumDaysInMonth(normalizedDate)\n        ),\n        this._adapter.getHour(this.activeDate),\n        this._adapter.getMinute(this.activeDate)\n      )\n    );\n\n    if (this.type === 'year') {\n      this._userSelection.emit();\n    }\n  }\n\n  _getActiveCell(): number {\n    return getActiveOffset(this._adapter, this.activeDate, this.minDate, this.maxDate);\n  }\n\n  _calendarStateDone() {\n    this._calendarState = '';\n  }\n\n  /** Initializes this year view. */\n  private _init() {\n    this._todayYear = this._adapter.getYear(this._adapter.today());\n    this._yearLabel = this._adapter.getYearName(this.activeDate);\n\n    const activeYear = this._adapter.getYear(this.activeDate);\n\n    const minYearOfPage =\n      activeYear - getActiveOffset(this._adapter, this.activeDate, this.minDate, this.maxDate);\n\n    this._years = [];\n    for (let i = 0, row: number[] = []; i < yearsPerPage; i++) {\n      row.push(minYearOfPage + i);\n      if (row.length === yearsPerRow) {\n        this._years.push(row.map(year => this._createCellForYear(year)));\n        row = [];\n      }\n    }\n  }\n\n  /** Creates an MtxCalendarCell for the given year. */\n  private _createCellForYear(year: number) {\n    const yearName = this._adapter.getYearName(this._adapter.createDate(year, 0, 1));\n    return new MtxCalendarCell(year, yearName, yearName, this._shouldEnableYear(year));\n  }\n\n  /** Whether the given year is enabled. */\n  private _shouldEnableYear(year: number) {\n    // disable if the year is greater than maxDate lower than minDate\n    if (\n      year === undefined ||\n      year === null ||\n      (this.maxDate && year > this._adapter.getYear(this.maxDate)) ||\n      (this.minDate && year < this._adapter.getYear(this.minDate))\n    ) {\n      return false;\n    }\n\n    // enable if it reaches here and there's no filter defined\n    if (!this.dateFilter) {\n      return true;\n    }\n\n    const firstOfYear = this._adapter.createDate(year, 0, 1);\n\n    // If any date in the year is enabled count the year as enabled.\n    for (\n      let date = firstOfYear;\n      this._adapter.getYear(date) === year;\n      date = this._adapter.addCalendarDays(date, 1)\n    ) {\n      if (this.dateFilter(date)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Gets the year in this years range that the given Date falls on.\n   * Returns null if the given Date is not in this range.\n   */\n  private _getYearInCurrentRange(date: D) {\n    const year = this._adapter.getYear(date);\n    return this._isInRange(year) ? year : null;\n  }\n\n  /**\n   * Validate if the current year is in the current range\n   * Returns true if is in range else returns false\n   */\n  private _isInRange(year: number): boolean {\n    return true;\n  }\n\n  /**\n   * @param obj The object to check.\n   * @returns The given object if it is both a date instance and valid, otherwise null.\n   */\n  private _getValidDateOrNull(obj: any): D | null {\n    return this._adapter.isDateInstance(obj) && this._adapter.isValid(obj) ? obj : null;\n  }\n}\n\nexport function isSameMultiYearView<D>(\n  dateAdapter: DatetimeAdapter<D>,\n  date1: D,\n  date2: D,\n  minDate: D | null,\n  maxDate: D | null\n): boolean {\n  const year1 = dateAdapter.getYear(date1);\n  const year2 = dateAdapter.getYear(date2);\n  const startingYear = getStartingYear(dateAdapter, minDate, maxDate);\n  return (\n    Math.floor((year1 - startingYear) / yearsPerPage) ===\n    Math.floor((year2 - startingYear) / yearsPerPage)\n  );\n}\n\n/**\n * When the multi-year view is first opened, the active year will be in view.\n * So we compute how many years are between the active year and the *slot* where our\n * \"startingYear\" will render when paged into view.\n */\nexport function getActiveOffset<D>(\n  dateAdapter: DatetimeAdapter<D>,\n  activeDate: D,\n  minDate: D | null,\n  maxDate: D | null\n): number {\n  const activeYear = dateAdapter.getYear(activeDate);\n  return euclideanModulo(activeYear - getStartingYear(dateAdapter, minDate, maxDate), yearsPerPage);\n}\n\n/**\n * We pick a \"starting\" year such that either the maximum year would be at the end\n * or the minimum year would be at the beginning of a page.\n */\nfunction getStartingYear<D>(\n  dateAdapter: DatetimeAdapter<D>,\n  minDate: D | null,\n  maxDate: D | null\n): number {\n  let startingYear = 0;\n  if (maxDate) {\n    const maxYear = dateAdapter.getYear(maxDate);\n    startingYear = maxYear - yearsPerPage + 1;\n  } else if (minDate) {\n    startingYear = dateAdapter.getYear(minDate);\n  }\n  return startingYear;\n}\n\n/** Gets remainder that is non-negative, even if first number is negative */\nfunction euclideanModulo(a: number, b: number): number {\n  return ((a % b) + b) % b;\n}\n","<table class=\"mtx-calendar-table\" role=\"grid\">\n  <thead class=\"mtx-calendar-table-header\"></thead>\n  <tbody mtx-calendar-body\n         (@slideCalendar.done)=\"_calendarStateDone()\"\n         [@slideCalendar]=\"_calendarState\"\n         [todayValue]=\"_todayYear\"\n         [rows]=\"_years\"\n         [numCols]=\"4\"\n         [activeCell]=\"_getActiveCell()\"\n         [allowDisabledSelection]=\"true\"\n         [selectedValue]=\"_selectedYear!\"\n         (selectedValueChange)=\"_yearSelected($event)\"></tbody>\n</table>\n"]}