@progress/kendo-vue-dateinputs 3.5.0 → 3.5.1-dev.202208100944

package/dist/esm/calendar/services/DecadeViewService.js

@@ -0,0 +1,157 @@
+var _a;
+import { addDecades, addYears, cloneDate, durationInDecades, firstYearOfDecade, lastYearOfDecade } from '@progress/kendo-date-math';
+import { Action } from '../models/NavigationAction.js';
+import { EMPTY_SELECTIONRANGE } from '../models/SelectionRange.js';
+import { getToday, isInRange, isInSelectionRange, range } from '../../utils.js';
+var EMPTY_DATA = [[]];
+var CELLS_LENGTH = 4;
+var ROWS_LENGTH = 3;
+var ACTIONS = (_a = {},
+    _a[Action.Left] = function (date) { return addYears(date, -1); },
+    _a[Action.Up] = function (date) { return addYears(date, -4); },
+    _a[Action.Right] = function (date) { return addYears(date, 1); },
+    _a[Action.Down] = function (date) { return addYears(date, 4); },
+    _a[Action.PrevView] = function (date) { return addDecades(date, -1); },
+    _a[Action.NextView] = function (date) { return addDecades(date, 1); },
+    _a[Action.FirstInView] = function (date) { return firstYearOfDecade(date); },
+    _a[Action.LastInView] = function (date) { return lastYearOfDecade(date); },
+    _a);
+/**
+ * @hidden
+ */
+var DecadeViewService = /** @class */ (function () {
+    function DecadeViewService() {
+    }
+    DecadeViewService.prototype.addToDate = function (min, skip) {
+        return addDecades(min, skip);
+    };
+    DecadeViewService.prototype.datesList = function (start, count) {
+        return range(0, count).map(function (i) { return addDecades(firstYearOfDecade(start), i); });
+    };
+    DecadeViewService.prototype.data = function (options) {
+        var _this = this;
+        var cellUID = options.cellUID, focusedDate = options.focusedDate, isActiveView = options.isActiveView, max = options.max, min = options.min, selectedDate = options.selectedDate, _a = options.selectionRange, selectionRange = _a === void 0 ? EMPTY_SELECTIONRANGE : _a, viewDate = options.viewDate;
+        if (!viewDate) {
+            return EMPTY_DATA;
+        }
+        var cells = range(0, CELLS_LENGTH);
+        var firstDate = firstYearOfDecade(viewDate);
+        var lastDate = lastYearOfDecade(viewDate);
+        var today = getToday();
+        return range(0, ROWS_LENGTH).map(function (rowOffset) {
+            var baseDate = addYears(firstDate, rowOffset * CELLS_LENGTH);
+            return cells.map(function (cellOffset) {
+                var cellDate = _this.normalize(addYears(baseDate, cellOffset), min, max);
+                var changedDecade = !_this.isInSameView(cellDate, lastDate);
+                if (changedDecade) {
+                    return null;
+                }
+                var isRangeStart = _this.isEqual(cellDate, selectionRange.start);
+                var isRangeEnd = _this.isEqual(cellDate, selectionRange.end);
+                var isInMiddle = !isRangeStart && !isRangeEnd;
+                var isRangeMid = isInMiddle && isInSelectionRange(cellDate, selectionRange);
+                var isSelected = isActiveView && (!Array.isArray(selectedDate)
+                    ? isInRange(selectedDate, min, max) && _this.isEqual(cellDate, selectedDate)
+                    : _this.isSelectedFromArray(cellDate, selectedDate, min, max));
+                return {
+                    formattedValue: _this.value(cellDate),
+                    id: "".concat(cellUID).concat(cellDate.getTime()),
+                    isFocused: _this.isEqual(cellDate, focusedDate),
+                    isSelected: isSelected,
+                    isWeekend: false,
+                    isInRange: isInRange(cellDate, min, max),
+                    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
+                };
+            });
+        });
+    };
+    DecadeViewService.prototype.isSelectedFromArray = function (candidate, dates, min, max) {
+        var _this = this;
+        var result = false;
+        dates.forEach(function (date) {
+            if (isInRange(candidate, min, max) && _this.isEqual(candidate, date)) {
+                result = true;
+            }
+        });
+        return result;
+    };
+    DecadeViewService.prototype.isEqual = function (candidate, expected) {
+        if (!candidate || !expected) {
+            return false;
+        }
+        return candidate.getFullYear() === expected.getFullYear();
+    };
+    DecadeViewService.prototype.isInArray = function (date, dates) {
+        if (!dates.length) {
+            return false;
+        }
+        var year = date.getFullYear();
+        return dates[0].getFullYear() <= year && year <= (dates[dates.length - 1].getFullYear() + 9);
+    };
+    DecadeViewService.prototype.isInRange = function (candidate, min, max) {
+        var year = candidate.getFullYear();
+        var aboveMin = !min || min.getFullYear() <= year;
+        var belowMax = !max || year <= max.getFullYear();
+        return aboveMin && belowMax;
+    };
+    DecadeViewService.prototype.isRangeStart = function (value) {
+        return value.getFullYear() % 100 === 0;
+    };
+    DecadeViewService.prototype.isInSameView = function (candidate, value) {
+        return durationInDecades(candidate, value) === 0;
+    };
+    DecadeViewService.prototype.move = function (value, action) {
+        var modifier = ACTIONS[action];
+        if (!modifier) {
+            return value;
+        }
+        return modifier(value);
+    };
+    DecadeViewService.prototype.cellTitle = function (value) {
+        return value.getFullYear().toString();
+    };
+    DecadeViewService.prototype.navigationTitle = function (value) {
+        return value ? firstYearOfDecade(value).getFullYear().toString() : '';
+    };
+    DecadeViewService.prototype.title = function (value) {
+        if (!value) {
+            return '';
+        }
+        return "".concat(firstYearOfDecade(value).getFullYear(), " - ").concat(lastYearOfDecade(value).getFullYear());
+    };
+    DecadeViewService.prototype.rowLength = function (_) {
+        return CELLS_LENGTH;
+    };
+    DecadeViewService.prototype.skip = function (value, min) {
+        return durationInDecades(min, value);
+    };
+    DecadeViewService.prototype.total = function (min, max) {
+        return durationInDecades(min, max) + 1;
+    };
+    DecadeViewService.prototype.value = function (current) {
+        return current ? current.getFullYear().toString() : '';
+    };
+    DecadeViewService.prototype.viewDate = function (date, max, border) {
+        if (border === void 0) { border = 1; }
+        var renderTwoViews = durationInDecades(date, max) < border;
+        return renderTwoViews ? addDecades(date, -1) : date;
+    };
+    DecadeViewService.prototype.normalize = function (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;
+    };
+    return DecadeViewService;
+}());
+export { DecadeViewService };

package/dist/esm/calendar/services/MonthViewService.d.ts

@@ -0,0 +1,33 @@
+import { IntlService } from '@progress/kendo-vue-intl';
+import { Action } from '../models/NavigationAction';
+import { CellContext } from '../models/CellContext';
+import { ViewService } from '../models/ViewService';
+/**
+ * @hidden
+ */
+export declare class MonthViewService implements ViewService {
+    private intl;
+    constructor(intl: IntlService);
+    addToDate(min: Date, skip: number): Date;
+    datesList(start: Date, count: number): Date[];
+    data(options: any): CellContext[][];
+    isEqual(candidate: Date | null, expected: Date | null): boolean;
+    isSelectedFromArray(candidate: Date, dates: Date[], min: Date, max: Date): boolean;
+    isInArray(date: Date, dates: Date[]): boolean;
+    isInRange(candidate: Date, min: Date, max: Date): boolean;
+    isInSameView(candidate: Date, value: Date): boolean;
+    isRangeStart(value: Date): boolean;
+    move(value: Date, action: Action): Date;
+    cellTitle(value: Date): string;
+    navigationTitle(value?: Date): string;
+    title(current: Date): string;
+    rowLength(prependCell?: boolean): number;
+    skip(value: Date, min: Date): number;
+    total(min: Date, max: Date): number;
+    value(current: Date): string;
+    viewDate(date: Date, max: Date, border?: number): Date;
+    isWeekend(date: Date): boolean;
+    private abbrMonthNames;
+    private normalize;
+    private wideMonthNames;
+}

package/dist/esm/calendar/services/MonthViewService.js

@@ -0,0 +1,169 @@
+var _a;
+import { addDays, addWeeks, addMonths, dayOfWeek, durationInMonths, getDate, firstDayOfMonth, lastDayOfMonth } from '@progress/kendo-date-math';
+import { Action } from '../models/NavigationAction.js';
+import { EMPTY_SELECTIONRANGE } from '../models/SelectionRange.js';
+import { getToday, isInRange, isInSelectionRange, range } from '../../utils.js';
+var EMPTY_DATA = [[]];
+var CELLS_LENGTH = 7;
+var ROWS_LENGTH = 6;
+var SATURDAY = 6;
+var SUNDAY = 0;
+var ACTIONS = (_a = {},
+    _a[Action.Left] = function (date) { return addDays(date, -1); },
+    _a[Action.Up] = function (date) { return addWeeks(date, -1); },
+    _a[Action.Right] = function (date) { return addDays(date, 1); },
+    _a[Action.Down] = function (date) { return addWeeks(date, 1); },
+    _a[Action.PrevView] = function (date) { return addMonths(date, -1); },
+    _a[Action.NextView] = function (date) { return addMonths(date, 1); },
+    _a[Action.FirstInView] = function (date) { return firstDayOfMonth(date); },
+    _a[Action.LastInView] = function (date) { return lastDayOfMonth(date); },
+    _a);
+/**
+ * @hidden
+ */
+var MonthViewService = /** @class */ (function () {
+    function MonthViewService(intl) {
+        this.intl = intl;
+    }
+    MonthViewService.prototype.addToDate = function (min, skip) {
+        return addMonths(min, skip);
+    };
+    MonthViewService.prototype.datesList = function (start, count) {
+        return range(0, count).map(function (i) { return addMonths(start, i); });
+    };
+    MonthViewService.prototype.data = function (options) {
+        var _this = this;
+        var cellUID = options.cellUID, focusedDate = options.focusedDate, isActiveView = options.isActiveView, max = options.max, min = options.min, selectedDate = options.selectedDate, _a = options.selectionRange, selectionRange = _a === void 0 ? EMPTY_SELECTIONRANGE : _a, viewDate = options.viewDate;
+        if (!viewDate) {
+            return EMPTY_DATA;
+        }
+        var firstMonthDate = firstDayOfMonth(viewDate);
+        var lastMonthDate = lastDayOfMonth(viewDate);
+        var backward = -1;
+        var date = dayOfWeek(firstMonthDate, this.intl.firstDay(), backward);
+        var cells = range(0, CELLS_LENGTH);
+        var today = getToday();
+        return range(0, ROWS_LENGTH).map(function (rowOffset) {
+            var baseDate = addDays(date, rowOffset * CELLS_LENGTH);
+            return cells.map(function (cellOffset) {
+                var cellDate = _this.normalize(addDays(baseDate, cellOffset), min, max);
+                var otherMonth = cellDate < firstMonthDate || cellDate > lastMonthDate;
+                if (otherMonth) {
+                    return null;
+                }
+                var isRangeStart = _this.isEqual(cellDate, selectionRange.start);
+                var isRangeEnd = _this.isEqual(cellDate, selectionRange.end);
+                var isInMiddle = !isRangeStart && !isRangeEnd;
+                var isRangeMid = isInMiddle && isInSelectionRange(cellDate, selectionRange);
+                var isSelected = isActiveView && (!Array.isArray(selectedDate)
+                    ? isInRange(selectedDate, min, max) && _this.isEqual(cellDate, selectedDate)
+                    : _this.isSelectedFromArray(cellDate, selectedDate, min, max));
+                var cell = {
+                    formattedValue: _this.value(cellDate),
+                    id: "".concat(cellUID).concat(cellDate.getTime()),
+                    isFocused: _this.isEqual(cellDate, focusedDate),
+                    isSelected: isSelected,
+                    isInRange: isInRange(cellDate, min, max),
+                    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
+                };
+                return cell;
+            });
+        });
+    };
+    MonthViewService.prototype.isEqual = function (candidate, expected) {
+        if (!candidate || !expected) {
+            return false;
+        }
+        return getDate(candidate).getTime() === getDate(expected).getTime();
+    };
+    MonthViewService.prototype.isSelectedFromArray = function (candidate, dates, min, max) {
+        var _this = this;
+        var result = false;
+        dates.forEach(function (date) {
+            if (isInRange(candidate, min, max) && _this.isEqual(candidate, date)) {
+                result = true;
+            }
+        });
+        return result;
+    };
+    MonthViewService.prototype.isInArray = function (date, dates) {
+        return !!dates.length && firstDayOfMonth(dates[0]) <= date && date <= lastDayOfMonth(dates[dates.length - 1]);
+    };
+    MonthViewService.prototype.isInRange = function (candidate, min, max) {
+        var value = getDate(candidate);
+        var aboveMin = !min || getDate(min) <= value;
+        var belowMax = !max || value <= getDate(max);
+        return aboveMin && belowMax;
+    };
+    MonthViewService.prototype.isInSameView = function (candidate, value) {
+        return durationInMonths(candidate, value) === 0;
+    };
+    MonthViewService.prototype.isRangeStart = function (value) {
+        return !value.getMonth();
+    };
+    MonthViewService.prototype.move = function (value, action) {
+        var modifier = ACTIONS[action];
+        if (!modifier) {
+            return value;
+        }
+        return modifier(value);
+    };
+    MonthViewService.prototype.cellTitle = function (value) {
+        return this.intl.formatDate(value, 'D');
+    };
+    MonthViewService.prototype.navigationTitle = function (value) {
+        if (!value) {
+            return '';
+        }
+        return this.isRangeStart(value) ? value.getFullYear().toString() : this.abbrMonthNames()[value.getMonth()];
+    };
+    MonthViewService.prototype.title = function (current) {
+        return "".concat(this.wideMonthNames()[current.getMonth()], " ").concat(current.getFullYear());
+    };
+    MonthViewService.prototype.rowLength = function (prependCell) {
+        return CELLS_LENGTH + (prependCell ? 1 : 0);
+    };
+    MonthViewService.prototype.skip = function (value, min) {
+        return durationInMonths(min, value);
+    };
+    MonthViewService.prototype.total = function (min, max) {
+        return durationInMonths(min, max) + 1;
+    };
+    MonthViewService.prototype.value = function (current) {
+        return current ? current.getDate().toString() : '';
+    };
+    MonthViewService.prototype.viewDate = function (date, max, border) {
+        if (border === void 0) { border = 1; }
+        var renderTwoViews = durationInMonths(date, max) < border;
+        return renderTwoViews ? addMonths(date, -1) : date;
+    };
+    MonthViewService.prototype.isWeekend = function (date) {
+        var day = date.getDay();
+        return day === SATURDAY || day === SUNDAY;
+    };
+    MonthViewService.prototype.abbrMonthNames = function () {
+        return this.intl.dateFormatNames({ nameType: 'abbreviated', type: 'months' });
+    };
+    MonthViewService.prototype.normalize = function (cellDate, min, max) {
+        if (cellDate < min && this.isEqual(cellDate, min)) {
+            return getDate(min);
+        }
+        if (cellDate > max && this.isEqual(cellDate, max)) {
+            return getDate(max);
+        }
+        return cellDate;
+    };
+    MonthViewService.prototype.wideMonthNames = function () {
+        return this.intl.dateFormatNames({ nameType: 'wide', type: 'months', standAlone: true });
+    };
+    return MonthViewService;
+}());
+export { MonthViewService };

package/dist/esm/calendar/services/NavigationService.d.ts

@@ -0,0 +1,13 @@
+import { Action } from '../models/NavigationAction';
+import { CalendarViewEnum } from '../models/CalendarViewEnum';
+import { BusViewService } from '../services/BusViewService';
+import { ViewService } from '../models/ViewService';
+/**
+ * @hidden
+ */
+export declare class NavigationService {
+    private bus;
+    constructor(bus: BusViewService);
+    action(event: any): Action;
+    move(value: Date, action: Action | null, activeView: CalendarViewEnum, service: ViewService, event?: any): Date;
+}

package/dist/esm/calendar/services/NavigationService.js

@@ -0,0 +1,43 @@
+import { Action } from '../models/NavigationAction.js';
+var KEY_TO_ACTION = {
+    '33': Action.PrevView,
+    '34': Action.NextView,
+    '35': Action.LastInView,
+    '36': Action.FirstInView,
+    '37': Action.Left,
+    '38': Action.Up,
+    '39': Action.Right,
+    '40': Action.Down,
+    'meta+38': Action.UpperView,
+    'meta+40': Action.LowerView,
+    'meta+37': Action.PrevView,
+    'meta+39': Action.NextView
+};
+/**
+ * @hidden
+ */
+var NavigationService = /** @class */ (function () {
+    function NavigationService(bus) {
+        this.bus = bus;
+    }
+    NavigationService.prototype.action = function (event) {
+        var action = "".concat(event.ctrlKey || event.metaKey ? 'meta+' : '').concat(event.keyCode);
+        return KEY_TO_ACTION[action];
+    };
+    NavigationService.prototype.move = function (value, action, activeView, service, event) {
+        if (!service) {
+            return value;
+        }
+        if (action === Action.UpperView && this.bus.canMoveUp(activeView)) {
+            this.bus.moveUp(activeView, event);
+            return value;
+        }
+        if (action === Action.LowerView && this.bus.canMoveDown(activeView)) {
+            this.bus.moveDown(activeView, event);
+            return value;
+        }
+        return service.move(value, action);
+    };
+    return NavigationService;
+}());
+export { NavigationService };

package/dist/esm/calendar/services/WeekNamesService.d.ts

@@ -0,0 +1,9 @@
+import { IntlService } from '@progress/kendo-vue-intl';
+/**
+ * @hidden
+ */
+export declare class WeekNamesService {
+    private intl;
+    constructor(intl: IntlService);
+    getWeekNames(includeWeekNumber?: boolean): string[];
+}

package/dist/esm/calendar/services/WeekNamesService.js

@@ -0,0 +1,16 @@
+import { shiftWeekNames } from '../../utils.js';
+/**
+ * @hidden
+ */
+var WeekNamesService = /** @class */ (function () {
+    function WeekNamesService(intl) {
+        this.intl = intl;
+    }
+    WeekNamesService.prototype.getWeekNames = function (includeWeekNumber) {
+        if (includeWeekNumber === void 0) { includeWeekNumber = false; }
+        var weekNames = shiftWeekNames(this.intl.dateFormatNames({ nameType: 'short', type: 'days' }), this.intl.firstDay());
+        return includeWeekNumber ? [''].concat(weekNames) : weekNames;
+    };
+    return WeekNamesService;
+}());
+export { WeekNamesService };

package/dist/esm/calendar/services/YearViewService.d.ts

@@ -0,0 +1,31 @@
+import { IntlService } from '@progress/kendo-vue-intl';
+import { Action } from '../models/NavigationAction';
+import { CellContext } from '../models/CellContext';
+import { ViewService } from '../models/ViewService';
+/**
+ * @hidden
+ */
+export declare class YearViewService implements ViewService {
+    private _intl;
+    constructor(intl: IntlService);
+    addToDate(min: Date, skip: number): Date;
+    datesList(start: Date, count: number): Date[];
+    data(options: any): CellContext[][];
+    isSelectedFromArray(candidate: Date, dates: Date[], min: Date, max: Date): boolean;
+    isEqual(candidate: Date | null, expected: Date | null): boolean;
+    isInArray(date: Date, dates: Date[]): boolean;
+    isInRange(candidate: Date, min: Date | null, max: Date | null): boolean;
+    isInSameView(candidate: Date, value: Date): boolean;
+    isRangeStart(value: Date): boolean;
+    move(value: Date, action: Action): Date;
+    cellTitle(value: Date): string;
+    navigationTitle(value?: Date): string;
+    title(current?: Date): string;
+    rowLength(_?: boolean): number;
+    skip(value: Date, min: Date): number;
+    total(min: Date, max: Date): number;
+    value(current: Date): string;
+    viewDate(date: Date, max: Date, border?: number): Date;
+    private abbrMonthNames;
+    private normalize;
+}

package/dist/esm/calendar/services/YearViewService.js

@@ -0,0 +1,165 @@
+var _a;
+import { addMonths, addYears, createDate, durationInYears, firstMonthOfYear, lastMonthOfYear } from '@progress/kendo-date-math';
+import { Action } from '../models/NavigationAction.js';
+import { getToday, isInRange, isInSelectionRange, range } from '../../utils.js';
+import { EMPTY_SELECTIONRANGE } from '../models/SelectionRange.js';
+import { cloneDate } from '@progress/kendo-vue-common';
+var EMPTY_DATA = [[]];
+var CELLS_LENGTH = 4;
+var ROWS_LENGTH = 3;
+var ACTIONS = (_a = {},
+    _a[Action.Left] = function (date) { return addMonths(date, -1); },
+    _a[Action.Up] = function (date) { return addMonths(date, -4); },
+    _a[Action.Right] = function (date) { return addMonths(date, 1); },
+    _a[Action.Down] = function (date) { return addMonths(date, 4); },
+    _a[Action.PrevView] = function (date) { return addYears(date, -1); },
+    _a[Action.NextView] = function (date) { return addYears(date, 1); },
+    _a[Action.FirstInView] = function (date) { return firstMonthOfYear(date); },
+    _a[Action.LastInView] = function (date) { return lastMonthOfYear(date); },
+    _a);
+/**
+ * @hidden
+ */
+var YearViewService = /** @class */ (function () {
+    function YearViewService(intl) {
+        this._intl = intl;
+    }
+    YearViewService.prototype.addToDate = function (min, skip) {
+        return addYears(min, skip);
+    };
+    YearViewService.prototype.datesList = function (start, count) {
+        return range(0, count).map(function (i) { return addYears(start, i); });
+    };
+    YearViewService.prototype.data = function (options) {
+        var _this = this;
+        var cellUID = options.cellUID, focusedDate = options.focusedDate, isActiveView = options.isActiveView, max = options.max, min = options.min, selectedDate = options.selectedDate, _a = options.selectionRange, selectionRange = _a === void 0 ? EMPTY_SELECTIONRANGE : _a, viewDate = options.viewDate;
+        if (!viewDate) {
+            return EMPTY_DATA;
+        }
+        var months = this.abbrMonthNames();
+        var firstDate = firstMonthOfYear(viewDate);
+        var lastDate = lastMonthOfYear(viewDate);
+        var currentYear = firstDate.getFullYear();
+        var cells = range(0, CELLS_LENGTH);
+        var today = getToday();
+        return range(0, ROWS_LENGTH).map(function (rowOffset) {
+            var baseDate = addMonths(firstDate, rowOffset * CELLS_LENGTH);
+            return cells.map(function (cellOffset) {
+                var cellDate = _this.normalize(addMonths(baseDate, cellOffset), min, max);
+                if (!cellDate) {
+                    return null;
+                }
+                var changedYear = currentYear < cellDate.getFullYear();
+                if (changedYear) {
+                    return null;
+                }
+                var isRangeStart = _this.isEqual(cellDate, selectionRange.start);
+                var isRangeEnd = _this.isEqual(cellDate, selectionRange.end);
+                var isInMiddle = !isRangeStart && !isRangeEnd;
+                var isRangeMid = isInMiddle && isInSelectionRange(cellDate, selectionRange);
+                var isSelected = isActiveView && (!Array.isArray(selectedDate)
+                    ? isInRange(selectedDate, min, max) && _this.isEqual(cellDate, selectedDate)
+                    : _this.isSelectedFromArray(cellDate, selectedDate, min, max));
+                return {
+                    formattedValue: months[cellDate.getMonth()],
+                    id: "".concat(cellUID).concat(cellDate.getTime()),
+                    isFocused: _this.isEqual(cellDate, focusedDate),
+                    isSelected: isSelected,
+                    isInRange: isInRange(cellDate, min, max),
+                    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
+                };
+            });
+        });
+    };
+    YearViewService.prototype.isSelectedFromArray = function (candidate, dates, min, max) {
+        var _this = this;
+        var result = false;
+        dates.forEach(function (date) {
+            if (isInRange(candidate, min, max) && _this.isEqual(candidate, date)) {
+                result = true;
+            }
+        });
+        return result;
+    };
+    YearViewService.prototype.isEqual = function (candidate, expected) {
+        if (!candidate || !expected) {
+            return false;
+        }
+        return candidate.getFullYear() === expected.getFullYear() &&
+            candidate.getMonth() === expected.getMonth();
+    };
+    YearViewService.prototype.isInArray = function (date, dates) {
+        if (!dates.length) {
+            return false;
+        }
+        var year = date.getFullYear();
+        return dates[0].getFullYear() <= year && year <= dates[dates.length - 1].getFullYear();
+    };
+    YearViewService.prototype.isInRange = function (candidate, min, max) {
+        var candidateValue = createDate(candidate.getFullYear(), candidate.getMonth(), 1);
+        var aboveMin = !min || createDate(min.getFullYear(), min.getMonth(), 1) <= candidateValue;
+        var belowMax = !max || candidateValue <= createDate(max.getFullYear(), max.getMonth(), 1);
+        return aboveMin && belowMax;
+    };
+    YearViewService.prototype.isInSameView = function (candidate, value) {
+        return durationInYears(candidate, value) === 0;
+    };
+    YearViewService.prototype.isRangeStart = function (value) {
+        return value.getFullYear() % 10 === 0;
+    };
+    YearViewService.prototype.move = function (value, action) {
+        var modifier = ACTIONS[action];
+        if (!modifier) {
+            return value;
+        }
+        return modifier(value);
+    };
+    YearViewService.prototype.cellTitle = function (value) {
+        return "".concat(value.getFullYear(), " ").concat(this.value(value));
+    };
+    YearViewService.prototype.navigationTitle = function (value) {
+        return this.title(value);
+    };
+    YearViewService.prototype.title = function (current) {
+        return current ? current.getFullYear().toString() : '';
+    };
+    YearViewService.prototype.rowLength = function (_) {
+        return CELLS_LENGTH;
+    };
+    YearViewService.prototype.skip = function (value, min) {
+        return durationInYears(min, value);
+    };
+    YearViewService.prototype.total = function (min, max) {
+        return durationInYears(min, max) + 1;
+    };
+    YearViewService.prototype.value = function (current) {
+        return current ? this.abbrMonthNames()[current.getMonth()] : '';
+    };
+    YearViewService.prototype.viewDate = function (date, max, border) {
+        if (border === void 0) { border = 1; }
+        var renderTwoViews = durationInYears(date, max) < border;
+        return renderTwoViews ? addYears(date, -1) : date;
+    };
+    YearViewService.prototype.abbrMonthNames = function () {
+        return this._intl.dateFormatNames({ nameType: 'abbreviated', type: 'months' });
+    };
+    YearViewService.prototype.normalize = function (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;
+    };
+    return YearViewService;
+}());
+export { YearViewService };

package/dist/esm/calendar/services/index.d.ts

@@ -0,0 +1,9 @@
+import { BusViewService } from './BusViewService';
+import { CenturyViewService } from './CenturyViewService';
+import { DecadeViewService } from './DecadeViewService';
+import { DOMService } from './DOMService';
+import { MonthViewService } from './MonthViewService';
+import { NavigationService } from './NavigationService';
+import { WeekNamesService } from './WeekNamesService';
+import { YearViewService } from './YearViewService';
+export { BusViewService, CenturyViewService, DecadeViewService, DOMService, MonthViewService, NavigationService, WeekNamesService, YearViewService };

package/dist/esm/calendar/services/index.js

@@ -0,0 +1,9 @@
+import { BusViewService } from './BusViewService.js';
+import { CenturyViewService } from './CenturyViewService.js';
+import { DecadeViewService } from './DecadeViewService.js';
+import { DOMService } from './DOMService.js';
+import { MonthViewService } from './MonthViewService.js';
+import { NavigationService } from './NavigationService.js';
+import { WeekNamesService } from './WeekNamesService.js';
+import { YearViewService } from './YearViewService.js';
+export { BusViewService, CenturyViewService, DecadeViewService, DOMService, MonthViewService, NavigationService, WeekNamesService, YearViewService };