@progress/kendo-angular-dateinputs 21.4.1 → 22.0.0-develop.1

package/esm2022/calendar/services/month-view.service.mjs

@@ -1,223 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable } from '@angular/core';
-import { IntlService } from '@progress/kendo-angular-intl';
-import { addDays, addWeeks, addMonths, cloneDate, dayOfWeek, durationInMonths, getDate, firstDayOfMonth, lastDayOfMonth, createDate } from '@progress/kendo-date-math';
-import { Action } from '../models/navigation-action.enum';
-import { EMPTY_SELECTIONRANGE } from '../models/selection-range.interface';
-import { getToday, isInSelectionRange, range } from '../../util';
-import { isPresent } from '../../common/utils';
-import * as i0 from "@angular/core";
-import * as i1 from "@progress/kendo-angular-intl";
-const EMPTY_DATA = [[]];
-const CELLS_LENGTH = 7;
-const ROWS_LENGTH = 6;
-const ACTIONS = {
-    [Action.Left]: (date) => addDays(date, -1),
-    [Action.Up]: (date) => addWeeks(date, -1),
-    [Action.Right]: (date) => addDays(date, 1),
-    [Action.Down]: (date) => addWeeks(date, 1),
-    [Action.PrevView]: (date) => addMonths(date, -1),
-    [Action.NextView]: (date) => addMonths(date, 1),
-    [Action.FirstInView]: (date) => firstDayOfMonth(date),
-    [Action.LastInView]: (date) => lastDayOfMonth(date)
-};
-/**
- * @hidden
- */
-export class MonthViewService {
-    _intlService;
-    constructor(_intlService) {
-        this._intlService = _intlService;
-    }
-    addToDate(min, skip) {
-        return addMonths(min, skip);
-    }
-    datesList(start, count) {
-        return range(0, count).map(i => addMonths(start, i));
-    }
-    data(options) {
-        const { cellUID, focusedDate, isActiveView, max, min, selectedDates, selectionRange = EMPTY_SELECTIONRANGE, viewDate, isDateDisabled = () => false, allowReverse } = options;
-        if (!viewDate) {
-            return EMPTY_DATA;
-        }
-        const firstMonthDate = firstDayOfMonth(viewDate);
-        const firstMonthDay = getDate(firstMonthDate);
-        const lastMonthDate = lastDayOfMonth(viewDate);
-        const lastMonthDay = getDate(lastMonthDate);
-        const backward = -1;
-        const date = dayOfWeek(firstMonthDate, this._intlService.firstDay(), backward);
-        const cells = range(0, CELLS_LENGTH);
-        const today = getToday();
-        return range(0, ROWS_LENGTH).map(rowOffset => {
-            const baseDate = addDays(date, rowOffset * CELLS_LENGTH);
-            return cells.map(cellOffset => {
-                const cellDate = this.normalize(addDays(baseDate, cellOffset), min, max);
-                const cellDay = getDate(cellDate);
-                const otherMonth = cellDay < firstMonthDay || cellDay > lastMonthDay;
-                const outOfRange = cellDate < min || cellDate > max;
-                if (outOfRange) {
-                    return null;
-                }
-                let isRangeStart = false;
-                let isRangeEnd = false;
-                if (allowReverse) {
-                    if ((this.isEqual(cellDate, selectionRange.start) && selectionRange.start <= selectionRange.end) ||
-                        (this.isEqual(cellDate, selectionRange.end) && selectionRange.end <= selectionRange.start)) {
-                        isRangeStart = true;
-                    }
-                    if ((this.isEqual(cellDate, selectionRange.start) && selectionRange.start >= selectionRange.end) ||
-                        (this.isEqual(cellDate, selectionRange.end) && selectionRange.end >= selectionRange.start)) {
-                        isRangeEnd = true;
-                    }
-                }
-                else {
-                    isRangeStart = this.isEqual(cellDate, selectionRange.start);
-                    isRangeEnd = this.isEqual(cellDate, selectionRange.end);
-                }
-                const isInMiddle = !isRangeStart && !isRangeEnd;
-                let isRangeMid;
-                if (allowReverse) {
-                    isRangeMid = isInMiddle && (isInSelectionRange(cellDate, selectionRange) || isInSelectionRange(cellDate, { start: selectionRange.end, end: selectionRange.start }));
-                }
-                else {
-                    isRangeMid = isInMiddle && isInSelectionRange(cellDate, selectionRange);
-                }
-                return {
-                    formattedValue: this.value(cellDate),
-                    id: `${cellUID}${otherMonth ? cellDate.getTime() + '1' : cellDate.getTime()}`,
-                    isFocused: this.isEqual(cellDate, focusedDate),
-                    isSelected: isActiveView && selectedDates.some(date => this.isEqual(cellDate, date)),
-                    isWeekend: this.isWeekend(cellDate),
-                    isRangeStart: isRangeStart,
-                    isRangeMid: isRangeMid,
-                    isRangeEnd: isRangeEnd,
-                    isRangeSplitStart: isRangeMid && this.isEqual(cellDate, firstMonthDate),
-                    isRangeSplitEnd: isRangeMid && this.isEqual(cellDate, lastMonthDate),
-                    isToday: this.isEqual(cellDate, today),
-                    title: this.cellTitle(cellDate),
-                    value: cellDate,
-                    isDisabled: isDateDisabled(cellDate),
-                    isOtherMonth: otherMonth,
-                    allowReverse: allowReverse
-                };
-            });
-        });
-    }
-    isEqual(candidate, expected) {
-        if (!candidate || !expected) {
-            return false;
-        }
-        return getDate(candidate).getTime() === getDate(expected).getTime();
-    }
-    isInArray(date, dates) {
-        if (dates.length === 0) {
-            return false;
-        }
-        const lowerBound = this.beginningOfPeriod(dates[0]);
-        const upperBound = this.beginningOfPeriod(addMonths(dates[dates.length - 1], 1));
-        return lowerBound <= date && date < upperBound;
-    }
-    isInRange(candidate, min, max) {
-        const value = getDate(candidate);
-        const aboveMin = !min || getDate(min) <= value;
-        const belowMax = !max || value <= getDate(max);
-        return aboveMin && belowMax;
-    }
-    beginningOfPeriod(date) {
-        if (!date) {
-            return date;
-        }
-        return createDate(date.getFullYear(), date.getMonth(), 1);
-    }
-    lastDayOfPeriod(date) {
-        return lastDayOfMonth(date);
-    }
-    isRangeStart(value) {
-        return !value.getMonth();
-    }
-    move(value, action) {
-        const modifier = ACTIONS[action];
-        if (!modifier) {
-            return value;
-        }
-        return modifier(value);
-    }
-    cellTitle(value) {
-        return this._intlService.formatDate(value, 'D');
-    }
-    navigationTitle(value) {
-        if (!value) {
-            return '';
-        }
-        return this.isRangeStart(value) ? value.getFullYear().toString() : this.abbrMonthNames()[value.getMonth()];
-    }
-    title(current) {
-        return `${this.wideMonthNames()[current.getMonth()]} ${current.getFullYear()}`;
-    }
-    rowLength(options = {}) {
-        return CELLS_LENGTH + (options.prependCell ? 1 : 0);
-    }
-    skip(value, min) {
-        return durationInMonths(min, value);
-    }
-    total(min, max) {
-        return durationInMonths(min, max) + 1;
-    }
-    value(current) {
-        return current ? current.getDate().toString() : "";
-    }
-    viewDate(date, max, viewsCount = 1) {
-        const viewsInRange = this.total(date, max);
-        if (viewsInRange < viewsCount) {
-            const monthsToSubtract = viewsCount - viewsInRange;
-            return addMonths(date, -1 * monthsToSubtract);
-        }
-        return date;
-    }
-    isWeekend(date) {
-        const { start, end } = this._intlService.weekendRange();
-        const day = date.getDay();
-        if (end < start) {
-            return day <= end || start <= day;
-        }
-        return start <= day && day <= end;
-    }
-    dateRange = (start, end) => {
-        if (!isPresent(start) || !isPresent(end)) {
-            return [];
-        }
-        const result = [];
-        let current = start;
-        while (current <= end) {
-            result.push(current);
-            current = addDays(current, 1);
-        }
-        return result;
-    };
-    abbrMonthNames() {
-        return this._intlService.dateFormatNames({ nameType: 'abbreviated', type: 'months' });
-    }
-    normalize(cellDate, min, max) {
-        if (cellDate < min && this.isEqual(cellDate, min)) {
-            return cloneDate(min);
-        }
-        if (cellDate > max && this.isEqual(cellDate, max)) {
-            return cloneDate(max);
-        }
-        return cellDate;
-    }
-    wideMonthNames() {
-        return this._intlService.dateFormatNames({ nameType: 'wide', type: 'months' });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MonthViewService, deps: [{ token: i1.IntlService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MonthViewService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MonthViewService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i1.IntlService }] });

package/esm2022/calendar/services/navigation.service.mjs

@@ -1,60 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable } from '@angular/core';
-import { Action } from '../models/navigation-action.enum';
-import { BusViewService } from '../services/bus-view.service';
-import { normalizeKeys } from '@progress/kendo-angular-common';
-import * as i0 from "@angular/core";
-import * as i1 from "../services/bus-view.service";
-const KEY_TO_ACTION = {
-    'PageUp': Action.PrevView,
-    'PageDown': Action.NextView,
-    'End': Action.LastInView,
-    'Home': Action.FirstInView,
-    'ArrowLeft': Action.Left,
-    'ArrowUp': Action.Up,
-    'ArrowRight': Action.Right,
-    'ArrowDown': Action.Down,
-    'meta+ArrowUp': Action.UpperView,
-    'meta+ArrowDown': Action.LowerView
-};
-/**
- * @hidden
- */
-export class NavigationService {
-    bus;
-    constructor(bus) {
-        this.bus = bus;
-    }
-    action(event) {
-        // on some keyboards arrow keys, PageUp/Down, and Home/End are mapped to Numpad keys
-        const code = normalizeKeys(event);
-        const action = `${event.ctrlKey || event.metaKey ? 'meta+' : ''}${code}`;
-        return KEY_TO_ACTION[action];
-    }
-    move(value, action, activeView) {
-        const service = this.bus.service(activeView);
-        if (!service) {
-            return value;
-        }
-        if (action === Action.UpperView && this.bus.canMoveUp(activeView)) {
-            this.bus.moveUp(activeView);
-            return value;
-        }
-        if (action === Action.LowerView && this.bus.canMoveDown(activeView)) {
-            this.bus.moveDown(activeView);
-            return value;
-        }
-        return service.move(value, action);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationService, deps: [{ token: i1.BusViewService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i1.BusViewService }] });

package/esm2022/calendar/services/scroll-sync.service.mjs

@@ -1,89 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable, NgZone } from '@angular/core';
-import { CalendarDOMService } from './dom.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./dom.service";
-const divideByMagnitude = (magnitude) => x => Math.floor(x / magnitude);
-const powerByMagnitude = (magnitude) => x => x * magnitude;
-/**
- * @hidden
- */
-export class ScrollSyncService {
-    dom;
-    zone;
-    divideByMagnitude;
-    powerByMagnitude;
-    navSubscription;
-    viewSubscription;
-    navigator;
-    view;
-    constructor(dom, zone) {
-        this.dom = dom;
-        this.zone = zone;
-    }
-    configure(activeView) {
-        const magnitude = Math.max(this.dom.viewHeight(activeView) / this.dom.navigationItemHeight, 1);
-        this.divideByMagnitude = divideByMagnitude(magnitude);
-        this.powerByMagnitude = powerByMagnitude(magnitude);
-    }
-    sync(navigator, view) {
-        this.unsubscribe();
-        if (!navigator || !view) {
-            return;
-        }
-        this.navigator = navigator;
-        this.view = view;
-        this.zone.runOutsideAngular(() => {
-            let navScrolled, monthScrolled;
-            this.navSubscription = navigator.scroll$()
-                .subscribe((e) => {
-                if (monthScrolled) {
-                    monthScrolled = false;
-                    return;
-                }
-                navScrolled = true;
-                this.scrollSiblingOf(e.target);
-            });
-            this.viewSubscription = view.scroll$()
-                .subscribe((e) => {
-                if (navScrolled) {
-                    navScrolled = false;
-                    return;
-                }
-                monthScrolled = true;
-                this.scrollSiblingOf(e.target);
-            });
-        });
-    }
-    scrollSiblingOf(scrolledElement) {
-        const component = this.siblingComponent(scrolledElement);
-        const scrollTop = this.calculateScroll(component, scrolledElement.scrollTop);
-        component.scrollTo(scrollTop);
-    }
-    siblingComponent(scrollableElement) {
-        return this.navigator.container.nativeElement === scrollableElement ? this.view : this.navigator;
-    }
-    calculateScroll(component, scrollTop) {
-        const modifier = component === this.navigator ? this.divideByMagnitude : this.powerByMagnitude;
-        return modifier(scrollTop);
-    }
-    destroy() {
-        this.unsubscribe();
-    }
-    unsubscribe() {
-        if (this.navSubscription) {
-            this.navSubscription.unsubscribe();
-        }
-        if (this.viewSubscription) {
-            this.viewSubscription.unsubscribe();
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollSyncService, deps: [{ token: i1.CalendarDOMService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollSyncService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollSyncService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.CalendarDOMService }, { type: i0.NgZone }] });

package/esm2022/calendar/services/selection.service.mjs

@@ -1,62 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable } from '@angular/core';
-import { isEqual } from '@progress/kendo-date-math';
-import { last, sortDates } from '../../util';
-import { BusViewService } from './bus-view.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./bus-view.service";
-/**
- * @hidden
- */
-export class SelectionService {
-    bus;
-    constructor(bus) {
-        this.bus = bus;
-    }
-    lastClicked;
-    performSelection(args) {
-        /* eslint prefer-const: ["error", {"destructuring": "all"}] */
-        let { date, modifiers, selectionMode, activeViewEnum, rangePivot } = args;
-        let selectedDates = args.selectedDates.slice();
-        if (selectionMode === 'multiple') {
-            if (modifiers.ctrlKey || modifiers.metaKey) {
-                if (this.isDateSelected(selectedDates, date)) {
-                    selectedDates = selectedDates.filter(item => !isEqual(item, date));
-                }
-                else {
-                    selectedDates.push(date);
-                }
-                rangePivot = date;
-            }
-            else if (modifiers.shiftKey) {
-                const [start, end] = sortDates([rangePivot || date, date]);
-                selectedDates = this.bus.service(activeViewEnum).dateRange(start, end);
-                rangePivot = date > selectedDates[0] ? selectedDates[0] : last(selectedDates);
-                if (modifiers.anyArrow) {
-                    const [start, end] = sortDates([this.lastClicked || date, date]);
-                    selectedDates = this.bus.service(0).dateRange(start, end);
-                }
-            }
-            else {
-                selectedDates = [date];
-                rangePivot = date;
-            }
-        }
-        else {
-            selectedDates = [date];
-            rangePivot = date;
-        }
-        return { selectedDates, rangePivot };
-    }
-    isDateSelected(selectedDates, date) {
-        return selectedDates.some(item => isEqual(item, date));
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectionService, deps: [{ token: i1.BusViewService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectionService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectionService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.BusViewService }] });

package/esm2022/calendar/services/weeknames.service.mjs

@@ -1,33 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable } from '@angular/core';
-import { IntlService } from '@progress/kendo-angular-intl';
-import { shiftWeekNames } from '../../util';
-import * as i0 from "@angular/core";
-import * as i1 from "@progress/kendo-angular-intl";
-/**
- * @hidden
- * @deprecated
- *
- * This service is deprecated and will be removed in a future major version release.
- */
-export class WeekNamesService {
-    intl;
-    constructor(intl) {
-        this.intl = intl;
-    }
-    getWeekNames(includeWeekNumber = false, nameType) {
-        const weekNames = shiftWeekNames(this.intl.dateFormatNames({ nameType: nameType, type: 'days' }), this.intl.firstDay());
-        return includeWeekNumber ? [''].concat(weekNames) : weekNames;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WeekNamesService, deps: [{ token: i1.IntlService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WeekNamesService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WeekNamesService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i1.IntlService }] });

package/esm2022/calendar/services/year-view.service.mjs

@@ -1,204 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable } from '@angular/core';
-import { IntlService } from '@progress/kendo-angular-intl';
-import { addMonths, addYears, cloneDate, createDate, durationInYears, firstMonthOfYear, lastDayOfMonth, lastMonthOfYear } from '@progress/kendo-date-math';
-import { Action } from '../models/navigation-action.enum';
-import { EMPTY_SELECTIONRANGE } from '../models/selection-range.interface';
-import { getToday, isInSelectionRange, range } from '../../util';
-import { isPresent } from '../../common/utils';
-import * as i0 from "@angular/core";
-import * as i1 from "@progress/kendo-angular-intl";
-const EMPTY_DATA = [[]];
-const CELLS_LENGTH = 4;
-const ROWS_LENGTH = 3;
-const ACTIONS = {
-    [Action.Left]: (date) => addMonths(date, -1),
-    [Action.Up]: (date) => addMonths(date, -4),
-    [Action.Right]: (date) => addMonths(date, 1),
-    [Action.Down]: (date) => addMonths(date, 4),
-    [Action.PrevView]: (date) => addYears(date, -1),
-    [Action.NextView]: (date) => addYears(date, 1),
-    [Action.FirstInView]: (date) => firstMonthOfYear(date),
-    [Action.LastInView]: (date) => lastMonthOfYear(date)
-};
-/**
- * @hidden
- */
-export class YearViewService {
-    _intlService;
-    constructor(_intlService) {
-        this._intlService = _intlService;
-    }
-    addToDate(min, skip) {
-        return addYears(min, skip);
-    }
-    datesList(start, count) {
-        return range(0, count).map(i => addYears(start, i));
-    }
-    data(options) {
-        const { cellUID, focusedDate, isActiveView, max, min, selectedDates, selectionRange = EMPTY_SELECTIONRANGE, viewDate, allowReverse } = options;
-        if (!viewDate) {
-            return EMPTY_DATA;
-        }
-        const months = this.abbrMonthNames();
-        const firstDate = firstMonthOfYear(viewDate);
-        const lastDate = lastMonthOfYear(viewDate);
-        const currentYear = firstDate.getFullYear();
-        const cells = range(0, CELLS_LENGTH);
-        const today = getToday();
-        return range(0, ROWS_LENGTH).map(rowOffset => {
-            const baseDate = addMonths(firstDate, rowOffset * CELLS_LENGTH);
-            return cells.map(cellOffset => {
-                const cellDate = this.normalize(addMonths(baseDate, cellOffset), min, max);
-                const changedYear = currentYear < cellDate.getFullYear();
-                if (!this.isInRange(cellDate, min, max) || changedYear) {
-                    return null;
-                }
-                let isRangeStart = false;
-                let isRangeEnd = false;
-                if (allowReverse) {
-                    if ((this.isEqual(cellDate, selectionRange.start) && selectionRange.start <= selectionRange.end) ||
-                        (this.isEqual(cellDate, selectionRange.end) && selectionRange.end <= selectionRange.start)) {
-                        isRangeStart = true;
-                    }
-                    if ((this.isEqual(cellDate, selectionRange.start) && selectionRange.start >= selectionRange.end) ||
-                        (this.isEqual(cellDate, selectionRange.end) && selectionRange.end >= selectionRange.start)) {
-                        isRangeEnd = true;
-                    }
-                }
-                else {
-                    isRangeStart = this.isEqual(cellDate, selectionRange.start);
-                    isRangeEnd = this.isEqual(cellDate, selectionRange.end);
-                }
-                const isInMiddle = !isRangeStart && !isRangeEnd;
-                let isRangeMid;
-                if (allowReverse) {
-                    isRangeMid = isInMiddle && (isInSelectionRange(cellDate, selectionRange) || isInSelectionRange(cellDate, { start: selectionRange.end, end: selectionRange.start }));
-                }
-                else {
-                    isRangeMid = isInMiddle && isInSelectionRange(cellDate, selectionRange);
-                }
-                return {
-                    formattedValue: months[cellDate.getMonth()],
-                    id: `${cellUID}${cellDate.getTime()}`,
-                    isFocused: this.isEqual(cellDate, focusedDate),
-                    isSelected: isActiveView && selectedDates.some(date => this.isEqual(cellDate, date)),
-                    isWeekend: false,
-                    isRangeStart: isRangeStart,
-                    isRangeMid: isRangeMid,
-                    isRangeEnd: isRangeEnd,
-                    isRangeSplitEnd: isRangeMid && this.isEqual(cellDate, lastDate),
-                    isRangeSplitStart: isRangeMid && this.isEqual(cellDate, firstDate),
-                    isToday: this.isEqual(cellDate, today),
-                    title: this.cellTitle(cellDate),
-                    value: cellDate,
-                    allowReverse: allowReverse
-                };
-            });
-        });
-    }
-    isEqual(candidate, expected) {
-        if (!candidate || !expected) {
-            return false;
-        }
-        return candidate.getFullYear() === expected.getFullYear() &&
-            candidate.getMonth() === expected.getMonth();
-    }
-    isInArray(date, dates) {
-        if (!dates.length) {
-            return false;
-        }
-        const year = date.getFullYear();
-        return dates[0].getFullYear() <= year && year <= dates[dates.length - 1].getFullYear();
-    }
-    isInRange(candidate, min, max) {
-        const candidateValue = createDate(candidate.getFullYear(), candidate.getMonth(), 1);
-        const aboveMin = !min || createDate(min.getFullYear(), min.getMonth(), 1) <= candidateValue;
-        const belowMax = !max || candidateValue <= createDate(max.getFullYear(), max.getMonth(), 1);
-        return aboveMin && belowMax;
-    }
-    beginningOfPeriod(date) {
-        if (!date) {
-            return date;
-        }
-        return createDate(date.getFullYear(), 0, 1);
-    }
-    lastDayOfPeriod(date) {
-        const month = lastMonthOfYear(date);
-        return lastDayOfMonth(month);
-    }
-    isRangeStart(value) {
-        return value.getFullYear() % 10 === 0;
-    }
-    move(value, action) {
-        const modifier = ACTIONS[action];
-        if (!modifier) {
-            return value;
-        }
-        return modifier(value);
-    }
-    cellTitle(value) {
-        return `${value.getFullYear()} ${this.value(value)}`;
-    }
-    navigationTitle(value) {
-        return this.title(value);
-    }
-    title(current) {
-        return current ? current.getFullYear().toString() : '';
-    }
-    rowLength() {
-        return CELLS_LENGTH;
-    }
-    skip(value, min) {
-        return durationInYears(min, value);
-    }
-    total(min, max) {
-        return durationInYears(min, max) + 1;
-    }
-    value(current) {
-        return current ? this.abbrMonthNames()[current.getMonth()] : '';
-    }
-    viewDate(date, max, viewsCount = 1) {
-        const viewsInRange = this.total(date, max);
-        if (viewsInRange < viewsCount) {
-            const yearsToSubtract = viewsCount - viewsInRange;
-            return addYears(date, -1 * yearsToSubtract);
-        }
-        return date;
-    }
-    dateRange = (start, end) => {
-        if (!isPresent(start) || !isPresent(end)) {
-            return [];
-        }
-        const result = [];
-        let current = start;
-        while (current <= end) {
-            result.push(current);
-            current = addMonths(current, 1);
-        }
-        return result;
-    };
-    abbrMonthNames() {
-        return this._intlService.dateFormatNames({ nameType: 'abbreviated', type: 'months' });
-    }
-    normalize(cellDate, min, max) {
-        if (cellDate < min && this.isEqual(cellDate, min)) {
-            return cloneDate(min);
-        }
-        if (cellDate > max && this.isEqual(cellDate, max)) {
-            return cloneDate(max);
-        }
-        return cellDate;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: YearViewService, deps: [{ token: i1.IntlService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: YearViewService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: YearViewService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i1.IntlService }] });