@progress/kendo-angular-dateinputs 21.4.1 → 22.0.0

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

@@ -1,217 +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 { addDecades, addYears, cloneDate, durationInDecades, firstYearOfDecade, lastYearOfDecade, createDate, lastMonthOfYear, lastDayOfMonth } 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";
-const EMPTY_DATA = [[]];
-const CELLS_LENGTH = 4;
-const ROWS_LENGTH = 3;
-const upStep = (year) => {
-    const yearOfDecade = Number(year.toString().slice(-1));
-    if (yearOfDecade < 2) {
-        return -2;
-    }
-    if (yearOfDecade < 4) {
-        return -6;
-    }
-    return -4;
-};
-const downStep = (year) => {
-    const yearOfDecade = Number(year.toString().slice(-1));
-    if (yearOfDecade > 7) {
-        return 2;
-    }
-    if (yearOfDecade > 5) {
-        return 6;
-    }
-    return 4;
-};
-const ACTIONS = {
-    [Action.Left]: (date) => addYears(date, -1),
-    [Action.Up]: (date) => addYears(date, upStep(date.getFullYear())),
-    [Action.Right]: (date) => addYears(date, 1),
-    [Action.Down]: (date) => addYears(date, downStep(date.getFullYear())),
-    [Action.PrevView]: (date) => addDecades(date, -1),
-    [Action.NextView]: (date) => addDecades(date, 1),
-    [Action.FirstInView]: (date) => firstYearOfDecade(date),
-    [Action.LastInView]: (date) => lastYearOfDecade(date)
-};
-/**
- * @hidden
- */
-export class DecadeViewService {
-    addToDate(min, skip) {
-        return addDecades(min, skip);
-    }
-    datesList(start, count) {
-        return range(0, count).map(i => addDecades(start, i));
-    }
-    data(options) {
-        const { cellUID, focusedDate, isActiveView, max, min, selectedDates, selectionRange = EMPTY_SELECTIONRANGE, viewDate, allowReverse } = options;
-        if (!viewDate) {
-            return EMPTY_DATA;
-        }
-        const cells = range(0, CELLS_LENGTH);
-        const firstDate = firstYearOfDecade(viewDate);
-        const lastDate = lastYearOfDecade(viewDate);
-        const today = getToday();
-        return range(0, ROWS_LENGTH).map(rowOffset => {
-            const baseDate = addYears(firstDate, rowOffset * CELLS_LENGTH);
-            return cells.map(cellOffset => {
-                const cellDate = this.normalize(addYears(baseDate, cellOffset), min, max);
-                const nextDecade = cellDate.getFullYear() > lastDate.getFullYear();
-                if (!this.isInRange(cellDate, min, max) || nextDecade) {
-                    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}${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();
-    }
-    isInArray(date, dates) {
-        if (!dates.length) {
-            return false;
-        }
-        const year = date.getFullYear();
-        return dates[0].getFullYear() <= year && year <= (dates[dates.length - 1].getFullYear() + 9);
-    }
-    isInRange(candidate, min, max) {
-        const year = candidate.getFullYear();
-        const aboveMin = !min || min.getFullYear() <= year;
-        const belowMax = !max || year <= max.getFullYear();
-        return aboveMin && belowMax;
-    }
-    beginningOfPeriod(date) {
-        if (!date) {
-            return date;
-        }
-        const firstYear = firstYearOfDecade(date);
-        return createDate(firstYear.getFullYear(), 0, 1);
-    }
-    lastDayOfPeriod(date) {
-        const year = lastYearOfDecade(date);
-        const month = lastMonthOfYear(year);
-        return lastDayOfMonth(month);
-    }
-    isRangeStart(value) {
-        return value.getFullYear() % 100 === 0;
-    }
-    move(value, action) {
-        const modifier = ACTIONS[action];
-        if (!modifier) {
-            return value;
-        }
-        return modifier(value);
-    }
-    cellTitle(value) {
-        return value.getFullYear().toString();
-    }
-    navigationTitle(value) {
-        return value ? firstYearOfDecade(value).getFullYear().toString() : '';
-    }
-    title(value) {
-        if (!value) {
-            return '';
-        }
-        return `${firstYearOfDecade(value).getFullYear()} - ${lastYearOfDecade(value).getFullYear()}`;
-    }
-    rowLength() {
-        return CELLS_LENGTH;
-    }
-    skip(value, min) {
-        return durationInDecades(min, value);
-    }
-    total(min, max) {
-        return durationInDecades(min, max) + 1;
-    }
-    value(current) {
-        return current ? current.getFullYear().toString() : '';
-    }
-    viewDate(date, max, viewsCount = 1) {
-        const viewsInRange = this.total(date, max);
-        if (viewsInRange < viewsCount) {
-            const decadesToSubtract = viewsCount - viewsInRange;
-            return addDecades(date, -1 * decadesToSubtract);
-        }
-        return date;
-    }
-    dateRange = (start, end) => {
-        if (!isPresent(start) || !isPresent(end)) {
-            return [];
-        }
-        const result = [];
-        let current = start;
-        while (current <= end) {
-            result.push(current);
-            current = addYears(current, 1);
-        }
-        return result;
-    };
-    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: DecadeViewService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DecadeViewService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DecadeViewService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });

package/esm2022/calendar/services/disabled-dates.service.mjs

@@ -1,66 +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, isDevMode } from '@angular/core';
-import { getDate } from '@progress/kendo-date-math';
-import { Subject } from 'rxjs';
-import { isNumberArray, isDateArray, isPresent } from '../../common/utils';
-import * as i0 from "@angular/core";
-const noop = () => false;
-const DISABLED_DATES_DOC_LINK = 'https://www.telerik.com/kendo-angular-ui/components/dateinputs/calendar/disabled-dates/';
-/**
- * @hidden
- */
-export class DisabledDatesService {
-    /**
-     * Emits every time the `isDateDisabled` method changes.
-     */
-    changes = new Subject();
-    /**
-     * Based on the user-defined `disabledDates` input evaluates if the date is disabled.
-     * If not set, returns `false`.
-     */
-    isDateDisabled = noop;
-    /**
-     * Configures the `isDateDisabled` function.
-     *
-     * * If a function is provided, uses it as-is and passes each date to it for evaluation.
-     * The time part is set to `midnight`.
-     * * If a `Date[]` is provided, creates a function that checks the targeted date against
-     * the listed dates and, if the targeted date is listed, marks it as disabled.
-     * * If a `Day[]` is provided, creates a function that evaluates the provided days of the
-     * week as disabled.
-     */
-    initialize(disabledDates) {
-        if (typeof disabledDates === 'function') {
-            this.isDateDisabled = (date) => disabledDates(getDate(date));
-        }
-        else if (isNumberArray(disabledDates)) {
-            const disabledWeekDays = new Set(disabledDates);
-            this.isDateDisabled = (date) => disabledWeekDays.has(date.getDay());
-        }
-        else if (isDateArray(disabledDates)) {
-            const normalizedDisabledDates = new Set(disabledDates.map(date => getDate(date).getTime()));
-            this.isDateDisabled = (date) => normalizedDisabledDates.has(getDate(date).getTime());
-        }
-        else {
-            this.isDateDisabled = noop;
-            this.notifyInvalidInput(disabledDates);
-        }
-        this.notifyServiceChange();
-    }
-    notifyInvalidInput(disabledDates) {
-        if (isPresent(disabledDates) && isDevMode()) {
-            throw new Error(`The 'disabledDates' value should be a function, a Day array or a Date array. Check ${DISABLED_DATES_DOC_LINK} for more information.`);
-        }
-    }
-    notifyServiceChange() {
-        this.changes.next();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DisabledDatesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DisabledDatesService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DisabledDatesService, decorators: [{
-            type: Injectable
-        }] });

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

@@ -1,203 +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 { CalendarViewEnum } from '../models/view.enum';
-import { isDocumentAvailable } from '@progress/kendo-angular-common';
-import { domContainerFactory as containerFactory } from '../../util';
-import { isPresent } from '../../common/utils';
-import * as i0 from "@angular/core";
-const div = containerFactory('div');
-const ul = containerFactory('ul');
-const li = containerFactory('li');
-const td = containerFactory('td');
-const th = containerFactory('th');
-const tr = containerFactory('tr');
-const tbody = containerFactory('tbody');
-const thead = containerFactory('thead');
-const table = containerFactory('table');
-const monthHeader = () => (div(`
-            <span class="k-button k-button-md k-rounded-md k-button-flat k-button-flat-base k-calendar-title">March 2017</span>
-            <span class="k-spacer"></span>
-            <span class="k-calendar-nav">
-                <button class="k-calendar-nav-today k-button k-button-md k-button-flat k-button-flat-base k-rounded-md">TODAY</button>
-            </span>
-        `, 'k-calendar-header'));
-const monthWeekHeader = () => (table([
-    thead([
-        tr([th('MO', 'k-calendar-th')], 'k-calendar-tr')
-    ], 'k-calendar-thead')
-], 'k-calendar-weekdays k-calendar-table'));
-const repeat = (count, mapper) => new Array(count).fill('1').map(mapper);
-const content = (rows, cells = 1) => (table([
-    tbody([tr([th('1', 'k-calendar-th')], 'k-calendar-tr')].concat(repeat(rows, () => tr(repeat(cells, c => td(`<span class="k-link">${c}</span>`, 'k-calendar-td')), 'k-calendar-tr'))), 'k-calendar-tbody')
-], 'k-calendar-table'));
-const scrollable = (children) => div(children, 'k-flex k-content k-scrollable');
-const view = (contentElement, className, renderWeekHeader) => (div([
-    monthHeader(),
-    renderWeekHeader ? monthWeekHeader() : null,
-    scrollable([contentElement, contentElement])
-], className, { left: '-10000px', position: 'absolute' }));
-const navigationList = (() => {
-    let navElement;
-    return () => {
-        if (!isDocumentAvailable()) {
-            return null;
-        }
-        if (!navElement) {
-            navElement = div([scrollable([ul([li('<span>FEB</span>')])])], 'k-calendar-navigation', { left: '0px', position: 'absolute' });
-        }
-        return navElement;
-    };
-})();
-const viewFactory = ({ cells, rows }, className, renderWeekHeader) => {
-    let viewElement;
-    return () => {
-        if (!isDocumentAvailable()) {
-            return null;
-        }
-        if (!viewElement) {
-            viewElement = view(content(rows, cells), className, renderWeekHeader);
-        }
-        return viewElement;
-    };
-};
-const getScrollable = (element) => element.querySelector('.k-scrollable');
-const horizontal = element => {
-    const scrollableElement = getScrollable(element);
-    scrollableElement.classList.add('k-scrollable-horizontal');
-    return element;
-};
-const monthView = viewFactory({ cells: 7, rows: 6 }, 'k-vstack k-calendar-view k-calendar-monthview', true);
-const yearView = viewFactory({ cells: 4, rows: 3 }, 'k-vstack k-calendar-view k-calendar-yearview', false);
-const decadeView = viewFactory({ cells: 4, rows: 3 }, 'k-vstack k-calendar-view k-calendar-decadeview', false);
-const horzMonthView = () => horizontal(monthView());
-const horzYearView = () => horizontal(yearView());
-const horzDecadeView = () => horizontal(decadeView());
-const height = (element) => {
-    if (!isDocumentAvailable()) {
-        return element.offsetHeight || 0;
-    }
-    return parseFloat(window.getComputedStyle(element).height) || element.offsetHeight;
-};
-const width = (element) => {
-    if (!isDocumentAvailable()) {
-        return element.offsetWidth || 0;
-    }
-    const styles = window.getComputedStyle(element);
-    const computed = parseFloat(styles.width)
-        + parseFloat(styles.paddingLeft)
-        + parseFloat(styles.paddingRight);
-    return computed || element.offsetWidth;
-};
-const getBody = (element) => element.querySelector('tbody');
-/**
- * @hidden
- */
-export class CalendarDOMService {
-    //heights
-    calendarHeight;
-    headerHeight;
-    monthViewHeight;
-    yearViewHeight;
-    decadeViewHeight;
-    centuryViewHeight;
-    navigationItemHeight;
-    scrollableContentHeight;
-    scrollableYearContentHeight;
-    //widths
-    calendarWidth;
-    monthViewWidth;
-    yearViewWidth;
-    decadeViewWidth;
-    centuryViewWidth;
-    scrollableContentWidth;
-    hostContainer;
-    ensureHeights() {
-        if (this.calendarHeight !== undefined) {
-            return;
-        }
-        this.calculateHeights();
-    }
-    calculateHeights(container) {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        this.hostContainer = container;
-        this.batch(monthView(), (contentElement) => {
-            const viewElement = getBody(contentElement);
-            this.calendarHeight = height(contentElement);
-            this.monthViewHeight = height(viewElement);
-            this.headerHeight = height(viewElement.children[0]);
-            this.scrollableContentHeight = height(getScrollable(contentElement));
-        });
-        this.batch(horzMonthView(), (contentElement) => {
-            const viewElement = getBody(contentElement);
-            this.calendarWidth = width(contentElement);
-            this.monthViewWidth = width(viewElement);
-            this.scrollableContentWidth = width(getScrollable(contentElement));
-        });
-        this.batch(yearView(), (contentElement) => {
-            this.yearViewHeight = height(getBody(contentElement));
-            this.scrollableYearContentHeight = height(getScrollable(contentElement));
-        });
-        this.batch(horzYearView(), (contentElement) => {
-            this.yearViewWidth = width(getBody(contentElement));
-        });
-        this.batch(decadeView(), (contentElement) => {
-            this.decadeViewHeight = height(getBody(contentElement));
-            this.centuryViewHeight = this.decadeViewHeight;
-        });
-        this.batch(horzDecadeView(), (contentElement) => {
-            this.decadeViewWidth = width(getBody(contentElement));
-            this.centuryViewWidth = this.decadeViewWidth;
-        });
-        this.batch(navigationList(), (contentElement) => {
-            this.navigationItemHeight = height(contentElement.querySelector('li'));
-        });
-    }
-    viewHeight(viewType) {
-        return this.viewDimension(viewType, 'height');
-    }
-    viewWidth(viewType) {
-        return this.viewDimension(viewType, 'width');
-    }
-    viewDimension(viewType, dimension) {
-        const viewProp = dimension === 'height' ? 'ViewHeight' : 'ViewWidth';
-        switch (viewType) {
-            case CalendarViewEnum.month:
-                return this[`month${viewProp}`];
-            case CalendarViewEnum.year:
-                return this[`year${viewProp}`];
-            case CalendarViewEnum.decade:
-                return this[`decade${viewProp}`];
-            case CalendarViewEnum.century:
-                return this[`century${viewProp}`];
-            default:
-                return 1;
-        }
-    }
-    batch(contentElement, action) {
-        if (!isPresent(this.hostContainer)) {
-            return;
-        }
-        const hostClone = this.hostContainer.cloneNode();
-        document.body.appendChild(hostClone);
-        try {
-            const appendedContent = hostClone.appendChild(contentElement);
-            action(appendedContent);
-        }
-        finally {
-            document.body.removeChild(hostClone);
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CalendarDOMService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CalendarDOMService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CalendarDOMService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });