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

package/esm2022/timepicker/services/hours.service.mjs

@@ -1,130 +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 { getDate, isEqual } from '@progress/kendo-date-math';
-import { IntlService } from '@progress/kendo-angular-intl';
-import { MIDNIGHT_DATE } from '../../defaults';
-import { range, setHours } from '../../util';
-import * as i0 from "@angular/core";
-import * as i1 from "@progress/kendo-angular-intl";
-const HOURS_IN_DAY = 24;
-const clampToRange = (rangeValue) => (value) => value % rangeValue;
-const clamp = clampToRange(HOURS_IN_DAY);
-const stepper = (start, step) => (idx) => clamp(start + (idx * step));
-const distanceFromMin = (value, min) => clamp(HOURS_IN_DAY + value - min);
-const limit = (borderValue) => (barrier, value) => {
-    const useBarrier = !value || getDate(barrier).getTime() === getDate(value).getTime();
-    return useBarrier ? barrier : setHours(barrier, borderValue);
-};
-const limitDown = limit(0);
-const limitUp = limit(HOURS_IN_DAY - 1);
-/**
- * @hidden
- */
-export class HoursService {
-    intl;
-    boundRange = false;
-    insertUndividedMax = false;
-    min;
-    max;
-    step;
-    toListItem;
-    constructor(intl) {
-        this.intl = intl;
-    }
-    apply(value, candidate) {
-        return setHours(value, candidate.getHours());
-    }
-    configure(settings) {
-        const { boundRange = this.boundRange, insertUndividedMax = this.insertUndividedMax, min = this.min, max = this.max, part, step = this.step } = settings;
-        this.boundRange = boundRange;
-        this.insertUndividedMax = insertUndividedMax;
-        this.toListItem = (hour) => {
-            const date = setHours(MIDNIGHT_DATE, hour);
-            return {
-                text: this.intl.formatDate(date, part.pattern),
-                value: date
-            };
-        };
-        this.min = min;
-        this.max = max;
-        this.step = step;
-    }
-    data(selectedValue) {
-        const [min] = this.range(selectedValue);
-        const getHour = stepper(min, this.step);
-        const convertToItem = (idx) => (this.toListItem(getHour(idx)));
-        const data = range(0, this.countFromMin(selectedValue)).map(convertToItem);
-        this.addLast(data);
-        this.addMissing(data, selectedValue);
-        return data;
-    }
-    isRangeChanged(min, max) {
-        return !isEqual(this.min, min) || !isEqual(this.max, max);
-    }
-    limitRange(min, max, value) {
-        return this.boundRange ? [limitDown(min, value), limitUp(max, value)] : [min, max];
-    }
-    total(value) {
-        const last = this.insertUndividedMax && this.isLastMissing(value) ? 1 : 0;
-        const missing = this.isMissing(value) ? 1 : 0;
-        return this.countFromMin(value) + missing + last;
-    }
-    selectedIndex(value) {
-        return Math.ceil(this.divideByStep(value));
-    }
-    valueInList(value) {
-        if (!value) {
-            return true;
-        }
-        const matchMax = this.insertUndividedMax && this.lastHour(value) === value.getHours();
-        return matchMax || !this.isMissing(value);
-    }
-    addLast(data, value) {
-        if (this.insertUndividedMax && this.isLastMissing(value)) {
-            data.push(this.toListItem(this.lastHour(value)));
-        }
-        return data;
-    }
-    addMissing(data, value) {
-        if (this.valueInList(value)) {
-            return data;
-        }
-        const missingItem = this.toListItem(value.getHours());
-        data.splice(this.selectedIndex(value), 0, missingItem);
-        return data;
-    }
-    countFromMin(value) {
-        const [min, max] = this.range(value);
-        return Math.floor(distanceFromMin(max, min) / this.step) + 1; /* include min */
-    }
-    isMissing(value) {
-        if (!value) {
-            return false;
-        }
-        return this.selectedIndex(value) !== this.divideByStep(value);
-    }
-    isLastMissing(value) {
-        return this.isMissing(setHours(this.max, this.lastHour(value)));
-    }
-    divideByStep(value) {
-        return distanceFromMin(value.getHours(), this.min.getHours()) / this.step;
-    }
-    lastHour(value) {
-        return this.range(value)[1];
-    }
-    range(value) {
-        const [min, max] = this.limitRange(this.min, this.max, value);
-        return [min.getHours(), max.getHours()];
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HoursService, deps: [{ token: i1.IntlService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HoursService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HoursService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i1.IntlService }] });

package/esm2022/timepicker/services/milliseconds.service.mjs

@@ -1,131 +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 { IntlService } from '@progress/kendo-angular-intl';
-import { MIDNIGHT_DATE } from '../../defaults';
-import { range, setMilliseconds } from '../../util';
-import * as i0 from "@angular/core";
-import * as i1 from "@progress/kendo-angular-intl";
-const MILLISECONDS_IN_SECOND = 1000;
-const clampToRange = (rangeValue) => (value) => value % rangeValue;
-const clamp = clampToRange(MILLISECONDS_IN_SECOND);
-const stepper = (start, step) => (idx) => clamp(start + (idx * step));
-const distanceFromMin = (value, min) => clamp(MILLISECONDS_IN_SECOND + value - min);
-const limit = (borderValue) => (barrier, value) => {
-    const useBarrier = !value ||
-        (barrier.getHours() === value.getHours() &&
-            barrier.getMinutes() === value.getMinutes() &&
-            barrier.getSeconds() === value.getSeconds());
-    return useBarrier ? barrier : setMilliseconds(barrier, borderValue);
-};
-const limitDown = limit(0);
-const limitUp = limit(MILLISECONDS_IN_SECOND - 1);
-/**
- * @hidden
- */
-export class MillisecondsService {
-    intl;
-    toListItem;
-    min;
-    max;
-    step;
-    insertUndividedMax = false;
-    constructor(intl) {
-        this.intl = intl;
-    }
-    apply(value, candidate) {
-        return setMilliseconds(value, candidate.getMilliseconds());
-    }
-    configure(settings) {
-        const { insertUndividedMax = this.insertUndividedMax, min = this.min, max = this.max, step = this.step } = settings;
-        this.insertUndividedMax = insertUndividedMax;
-        this.toListItem = (millisecond) => {
-            const date = setMilliseconds(MIDNIGHT_DATE, millisecond);
-            return {
-                text: this.intl.formatDate(date, "SSS"), // Always "SSS" for the popup UI
-                value: date
-            };
-        };
-        this.min = min;
-        this.max = max;
-        this.step = step;
-    }
-    data(selectedValue) {
-        const [min] = this.range(selectedValue);
-        const getMillisecond = stepper(min, this.step);
-        const convertToItem = (idx) => (this.toListItem(getMillisecond(idx)));
-        const data = range(0, this.countFromMin(selectedValue)).map(convertToItem);
-        this.addLast(data);
-        this.addMissing(data, selectedValue);
-        return data;
-    }
-    isRangeChanged(min, max) {
-        return !isEqual(this.min, min) || !isEqual(this.max, max);
-    }
-    limitRange(min, max, value) {
-        return [limitDown(min, value), limitUp(max, value)];
-    }
-    total(value) {
-        const last = this.insertUndividedMax && this.isLastMissing(value) ? 1 : 0;
-        const missing = this.isMissing(value) ? 1 : 0;
-        return this.countFromMin(value) + missing + last;
-    }
-    selectedIndex(value) {
-        return Math.ceil(this.divideByStep(value));
-    }
-    valueInList(value) {
-        if (!value) {
-            return true;
-        }
-        const matchMax = this.insertUndividedMax && this.lastMillisecond(value) === value.getMilliseconds();
-        return matchMax || !this.isMissing(value);
-    }
-    divideByStep(value) {
-        return distanceFromMin(value.getMilliseconds(), this.min.getMilliseconds()) / this.step;
-    }
-    addLast(data, value) {
-        if (this.insertUndividedMax && this.isLastMissing(value)) {
-            data.push(this.toListItem(this.lastMillisecond(value)));
-        }
-        return data;
-    }
-    addMissing(data, value) {
-        if (this.valueInList(value)) {
-            return data;
-        }
-        const missingItem = this.toListItem(value.getMilliseconds());
-        data.splice(this.selectedIndex(value), 0, missingItem);
-        return data;
-    }
-    countFromMin(value) {
-        const [min, max] = this.range(value);
-        return Math.floor(distanceFromMin(max, min) / this.step) + 1; /* include min */
-    }
-    isMissing(value) {
-        if (!value) {
-            return false;
-        }
-        return this.selectedIndex(value) !== this.divideByStep(value);
-    }
-    isLastMissing(value) {
-        return this.isMissing(setMilliseconds(this.max, this.lastMillisecond(value)));
-    }
-    lastMillisecond(value) {
-        return this.range(value)[1];
-    }
-    range(value) {
-        const [min, max] = this.limitRange(this.min, this.max, value);
-        return [min.getMilliseconds(), max.getMilliseconds()];
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MillisecondsService, deps: [{ token: i1.IntlService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MillisecondsService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MillisecondsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i1.IntlService }] });

package/esm2022/timepicker/services/minutes.service.mjs

@@ -1,128 +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 { IntlService } from '@progress/kendo-angular-intl';
-import { MIDNIGHT_DATE } from '../../defaults';
-import { range, setMinutes } from '../../util';
-import * as i0 from "@angular/core";
-import * as i1 from "@progress/kendo-angular-intl";
-const MINUTES_IN_HOUR = 60;
-const clampToRange = (rangeValue) => (value) => value % rangeValue;
-const clamp = clampToRange(MINUTES_IN_HOUR);
-const stepper = (start, step) => (idx) => clamp(start + (idx * step));
-const distanceFromMin = (value, min) => clamp(MINUTES_IN_HOUR + value - min);
-const limit = (borderValue) => (barrier, value) => {
-    const useBarrier = !value || barrier.getHours() === value.getHours();
-    return useBarrier ? barrier : setMinutes(barrier, borderValue);
-};
-const limitDown = limit(0);
-const limitUp = limit(MINUTES_IN_HOUR - 1);
-/**
- * @hidden
- */
-export class MinutesService {
-    intl;
-    toListItem;
-    min;
-    max;
-    step;
-    insertUndividedMax = false;
-    constructor(intl) {
-        this.intl = intl;
-    }
-    apply(value, candidate) {
-        return setMinutes(value, candidate.getMinutes());
-    }
-    configure(settings) {
-        const { insertUndividedMax = this.insertUndividedMax, min = this.min, max = this.max, part, step = this.step } = settings;
-        this.insertUndividedMax = insertUndividedMax;
-        this.toListItem = (minute) => {
-            const date = setMinutes(MIDNIGHT_DATE, minute);
-            return {
-                text: this.intl.formatDate(date, part.pattern),
-                value: date
-            };
-        };
-        this.min = min;
-        this.max = max;
-        this.step = step;
-    }
-    data(selectedValue) {
-        const [min] = this.range(selectedValue);
-        const getMinute = stepper(min, this.step);
-        const convertToItem = (idx) => (this.toListItem(getMinute(idx)));
-        const data = range(0, this.countFromMin(selectedValue)).map(convertToItem);
-        this.addLast(data);
-        this.addMissing(data, selectedValue);
-        return data;
-    }
-    isRangeChanged(min, max) {
-        return !isEqual(this.min, min) || !isEqual(this.max, max);
-    }
-    limitRange(min, max, value) {
-        return [limitDown(min, value), limitUp(max, value)];
-    }
-    total(value) {
-        const last = this.insertUndividedMax && this.isLastMissing(value) ? 1 : 0;
-        const missing = this.isMissing(value) ? 1 : 0;
-        return this.countFromMin(value) + missing + last;
-    }
-    selectedIndex(value) {
-        return Math.ceil(this.divideByStep(value));
-    }
-    valueInList(value) {
-        if (!value) {
-            return true;
-        }
-        const matchMax = this.insertUndividedMax && this.lastMinute(value) === value.getMinutes();
-        return matchMax || !this.isMissing(value);
-    }
-    addLast(data, value) {
-        if (this.insertUndividedMax && this.isLastMissing(value)) {
-            data.push(this.toListItem(this.lastMinute(value)));
-        }
-        return data;
-    }
-    addMissing(data, value) {
-        if (this.valueInList(value)) {
-            return data;
-        }
-        const missingItem = this.toListItem(value.getMinutes());
-        data.splice(this.selectedIndex(value), 0, missingItem);
-        return data;
-    }
-    countFromMin(value) {
-        const [min, max] = this.range(value);
-        return Math.floor(distanceFromMin(max, min) / this.step) + 1; /* include min */
-    }
-    isMissing(value) {
-        if (!value) {
-            return false;
-        }
-        return this.selectedIndex(value) !== this.divideByStep(value);
-    }
-    isLastMissing(value) {
-        return this.isMissing(setMinutes(this.max, this.lastMinute(value)));
-    }
-    divideByStep(value) {
-        return distanceFromMin(value.getMinutes(), this.min.getMinutes()) / this.step;
-    }
-    lastMinute(value) {
-        return this.range(value)[1];
-    }
-    range(value) {
-        const [min, max] = this.limitRange(this.min, this.max, value);
-        return [min.getMinutes(), max.getMinutes()];
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MinutesService, deps: [{ token: i1.IntlService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MinutesService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MinutesService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i1.IntlService }] });

package/esm2022/timepicker/services/seconds.service.mjs

@@ -1,128 +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 { IntlService } from '@progress/kendo-angular-intl';
-import { MIDNIGHT_DATE } from '../../defaults';
-import { range, setSeconds } from '../../util';
-import * as i0 from "@angular/core";
-import * as i1 from "@progress/kendo-angular-intl";
-const SECONDS_IN_HOUR = 60;
-const clampToRange = (rangeValue) => (value) => value % rangeValue;
-const clamp = clampToRange(SECONDS_IN_HOUR);
-const stepper = (start, step) => (idx) => clamp(start + (idx * step));
-const distanceFromMin = (value, min) => clamp(SECONDS_IN_HOUR + value - min);
-const limit = (borderValue) => (barrier, value) => {
-    const useBarrier = !value || barrier.getHours() === value.getHours() && barrier.getMinutes() === value.getMinutes();
-    return useBarrier ? barrier : setSeconds(barrier, borderValue);
-};
-const limitDown = limit(0);
-const limitUp = limit(SECONDS_IN_HOUR - 1);
-/**
- * @hidden
- */
-export class SecondsService {
-    intl;
-    toListItem;
-    min;
-    max;
-    step;
-    insertUndividedMax = false;
-    constructor(intl) {
-        this.intl = intl;
-    }
-    apply(value, candidate) {
-        return setSeconds(value, candidate.getSeconds());
-    }
-    configure(settings) {
-        const { insertUndividedMax = this.insertUndividedMax, min = this.min, max = this.max, part, step = this.step } = settings;
-        this.insertUndividedMax = insertUndividedMax;
-        this.toListItem = (second) => {
-            const date = setSeconds(MIDNIGHT_DATE, second);
-            return {
-                text: this.intl.formatDate(date, part.pattern),
-                value: date
-            };
-        };
-        this.min = min;
-        this.max = max;
-        this.step = step;
-    }
-    data(selectedValue) {
-        const [min] = this.range(selectedValue);
-        const getSecond = stepper(min, this.step);
-        const convertToItem = (idx) => (this.toListItem(getSecond(idx)));
-        const data = range(0, this.countFromMin(selectedValue)).map(convertToItem);
-        this.addLast(data);
-        this.addMissing(data, selectedValue);
-        return data;
-    }
-    isRangeChanged(min, max) {
-        return !isEqual(this.min, min) || !isEqual(this.max, max);
-    }
-    limitRange(min, max, value) {
-        return [limitDown(min, value), limitUp(max, value)];
-    }
-    total(value) {
-        const last = this.insertUndividedMax && this.isLastMissing(value) ? 1 : 0;
-        const missing = this.isMissing(value) ? 1 : 0;
-        return this.countFromMin(value) + missing + last;
-    }
-    selectedIndex(value) {
-        return Math.ceil(this.divideByStep(value));
-    }
-    valueInList(value) {
-        if (!value) {
-            return true;
-        }
-        const matchMax = this.insertUndividedMax && this.lastSecond(value) === value.getSeconds();
-        return matchMax || !this.isMissing(value);
-    }
-    divideByStep(value) {
-        return distanceFromMin(value.getSeconds(), this.min.getSeconds()) / this.step;
-    }
-    addLast(data, value) {
-        if (this.insertUndividedMax && this.isLastMissing(value)) {
-            data.push(this.toListItem(this.lastSecond(value)));
-        }
-        return data;
-    }
-    addMissing(data, value) {
-        if (this.valueInList(value)) {
-            return data;
-        }
-        const missingItem = this.toListItem(value.getSeconds());
-        data.splice(this.selectedIndex(value), 0, missingItem);
-        return data;
-    }
-    countFromMin(value) {
-        const [min, max] = this.range(value);
-        return Math.floor(distanceFromMin(max, min) / this.step) + 1; /* include min */
-    }
-    isMissing(value) {
-        if (!value) {
-            return false;
-        }
-        return this.selectedIndex(value) !== this.divideByStep(value);
-    }
-    isLastMissing(value) {
-        return this.isMissing(setSeconds(this.max, this.lastSecond(value)));
-    }
-    lastSecond(value) {
-        return this.range(value)[1];
-    }
-    range(value) {
-        const [min, max] = this.limitRange(this.min, this.max, value);
-        return [min.getSeconds(), max.getSeconds()];
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SecondsService, deps: [{ token: i1.IntlService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SecondsService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SecondsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i1.IntlService }] });