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

package/dist/esm/timepicker/services/DOMService.js

@@ -0,0 +1,40 @@
+import { domContainerFactory as containerFactory } from '../../utils.js';
+import { canUseDOM } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+var DOMService = /** @class */ (function () {
+    function DOMService() {
+        this.didCalculate = false;
+    }
+    DOMService.prototype.ensureHeights = function () {
+        if (this.timeListHeight !== undefined) {
+            return;
+        }
+        this.calculateHeights();
+    };
+    DOMService.prototype.calculateHeights = function (container) {
+        if (!canUseDOM) {
+            return;
+        }
+        var div = containerFactory('div');
+        var ul = containerFactory('ul');
+        var li = containerFactory('li');
+        var listItem = function () { return li('<span>02</span>', 'k-item'); };
+        var list = function () { return ul([listItem()], 'k-reset'); };
+        var scrollable = function () { return (div([list()], 'k-time-container k-content k-scrollable')); };
+        var timeListWrapper = function () {
+            return div([div([scrollable()], 'k-time-list')], 'k-time-list-wrapper', { left: '-10000px', position: 'absolute' });
+        };
+        var timeWrapper = timeListWrapper();
+        var listContainer = container && container.querySelector('.k-time-container');
+        var hostContainer = listContainer || document.body;
+        var wrapper = hostContainer.appendChild(timeWrapper);
+        this.timeListHeight = listContainer.offsetHeight;
+        this.itemHeight = wrapper.querySelector('li').offsetHeight;
+        hostContainer.removeChild(wrapper);
+        this.didCalculate = true;
+    };
+    return DOMService;
+}());
+export { DOMService };

package/dist/esm/timepicker/services/DayPeriodService.d.ts

@@ -0,0 +1,47 @@
+import { IntlService } from '@progress/kendo-vue-intl';
+import { ListServiceSettings } from '../models/ListServiceSettings';
+import { ListService } from '../models/ListService';
+import { ListItem } from '../models/ListItem';
+/**
+ * @hidden
+ */
+export declare class DayPeriodService implements ListService {
+    private intl;
+    private min;
+    private max;
+    private part;
+    constructor(intl: IntlService);
+    /**
+     * @hidden
+     */
+    apply(value: Date, candidate: Date): Date;
+    /**
+     * @hidden
+     */
+    configure(settings: ListServiceSettings): void;
+    /**
+     * @hidden
+     */
+    data(_?: Date): ListItem[];
+    /**
+     * @hidden
+     */
+    isRangeChanged(_: Date, __: Date): boolean;
+    /**
+     * @hidden
+     */
+    limitRange(min: Date, max: Date, _?: Date): Date[];
+    /**
+     * @hidden
+     */
+    total(): number;
+    /**
+     * @hidden
+     */
+    selectedIndex(value: Date): number;
+    /**
+     * @hidden
+     */
+    valueInList(value: Date): boolean;
+    private normalizedRange;
+}

package/dist/esm/timepicker/services/DayPeriodService.js

@@ -0,0 +1,113 @@
+import { cloneDate } from '@progress/kendo-date-math';
+var setHours = function (date, hours) {
+    var clone = cloneDate(date);
+    clone.setHours(hours);
+    return clone;
+};
+var isAM = function (value) { return value !== null && value < 12; };
+var isPM = function (value) { return value !== null && (!value || value > 11); };
+var inRange = function (value, min, max) { return ((!min && !max) || (value >= min && value <= max)); };
+var inReverseRange = function (value, min, max) { return ((!min && !max) || value >= min || value <= max); };
+/**
+ * @hidden
+ */
+var DayPeriodService = /** @class */ (function () {
+    function DayPeriodService(intl) {
+        this.intl = intl;
+    }
+    /**
+     * @hidden
+     */
+    DayPeriodService.prototype.apply = function (value, candidate) {
+        var hour = value.getHours();
+        var hourAM = isAM(hour);
+        var candidateAM = isAM(candidate.getHours());
+        if ((hourAM && candidateAM) || (!hourAM && !candidateAM)) {
+            return value;
+        }
+        var _a = this.normalizedRange(), min = _a[0], _b = _a[1], max = _b === void 0 ? 24 : _b;
+        var result = hour + (candidateAM ? -12 : 12);
+        return setHours(value, Math.min(Math.max(min, result), (max || 24)));
+    };
+    /**
+     * @hidden
+     */
+    DayPeriodService.prototype.configure = function (settings) {
+        var _a = settings.min, min = _a === void 0 ? this.min : _a, _b = settings.max, max = _b === void 0 ? this.max : _b, _c = settings.part, part = _c === void 0 ? this.part : _c;
+        this.min = min;
+        this.max = max;
+        this.part = part;
+    };
+    /**
+     * @hidden
+     */
+    DayPeriodService.prototype.data = function (_) {
+        var names = this.part.names;
+        if (!names) {
+            return [];
+        }
+        var data = [];
+        var _a = this.normalizedRange(), min = _a[0], max = _a[1];
+        var dayPeriod = this.intl.dateFormatNames(names);
+        if (isAM(min)) {
+            data.push({ text: dayPeriod.am, value: setHours(this.min, min) });
+        }
+        if (isPM(max)) {
+            data.push({ text: dayPeriod.pm, value: setHours(this.min, Math.max(12, max)) });
+        }
+        return this.min.getHours() !== min ? data.reverse() : data;
+    };
+    /**
+     * @hidden
+     */
+    DayPeriodService.prototype.isRangeChanged = function (_, __) {
+        return false;
+    };
+    /**
+     * @hidden
+     */
+    DayPeriodService.prototype.limitRange = function (min, max, _) {
+        return [min, max];
+    };
+    /**
+     * @hidden
+     */
+    DayPeriodService.prototype.total = function () {
+        var _a = this.normalizedRange(), min = _a[0], max = _a[1];
+        if (!min && !max) {
+            return 2;
+        }
+        if (min > 11 || max < 12) {
+            return 1;
+        }
+        return 2;
+    };
+    /**
+     * @hidden
+     */
+    DayPeriodService.prototype.selectedIndex = function (value) {
+        if (!this.valueInList(value)) {
+            return -1;
+        }
+        var index = Math.floor(value.getHours() / 12);
+        return this.min.getHours() === this.normalizedRange()[0] ? index : (index === 0 ? 1 : 0);
+    };
+    /**
+     * @hidden
+     */
+    DayPeriodService.prototype.valueInList = function (value) {
+        var reverse = this.min.getHours() !== this.normalizedRange()[0];
+        var isInRange = reverse ? inReverseRange : inRange;
+        return isInRange(value.getHours(), this.min.getHours(), this.max.getHours());
+    };
+    DayPeriodService.prototype.normalizedRange = function () {
+        var minHour = this.min.getHours();
+        var maxHour = this.max.getHours();
+        return [
+            Math.min(minHour, maxHour),
+            Math.max(minHour, maxHour)
+        ];
+    };
+    return DayPeriodService;
+}());
+export { DayPeriodService };

package/dist/esm/timepicker/services/HoursService.d.ts

@@ -0,0 +1,33 @@
+import { IntlService } from '@progress/kendo-vue-intl';
+import { ListServiceSettings } from '../models/ListServiceSettings';
+import { ListService } from '../models/ListService';
+import { ListItem } from '../models/ListItem';
+/**
+ * @hidden
+ */
+export declare class HoursService implements ListService {
+    private intl;
+    private boundRange;
+    private insertUndividedMax;
+    private min;
+    private max;
+    private step;
+    private toListItem;
+    constructor(intl: IntlService);
+    apply(value: Date, candidate: Date): Date;
+    configure(settings: ListServiceSettings): void;
+    data(selectedValue?: Date): ListItem[];
+    isRangeChanged(min: Date, max: Date): boolean;
+    limitRange(min: Date, max: Date, value?: Date): Date[];
+    total(value?: Date): number;
+    selectedIndex(value: Date): number;
+    valueInList(value?: Date): boolean;
+    private addLast;
+    private addMissing;
+    private countFromMin;
+    private isMissing;
+    private isLastMissing;
+    private divideByStep;
+    private lastHour;
+    private range;
+}

package/dist/esm/timepicker/services/HoursService.js

@@ -0,0 +1,115 @@
+import { getDate, isEqual } from '@progress/kendo-date-math';
+import { MIDNIGHT_DATE } from '../../utils.js';
+import { range, setHours } from '../utils.js';
+var HOURS_IN_DAY = 24;
+var clampToRange = function (rangeValue) { return function (value) { return value % rangeValue; }; };
+var clamp = clampToRange(HOURS_IN_DAY);
+var stepper = function (start, step) { return function (idx) { return clamp(start + (idx * step)); }; };
+var distanceFromMin = function (value, min) { return clamp(HOURS_IN_DAY + value - min); };
+var limit = function (borderValue) { return function (barrier, value) {
+    var useBarrier = !value || getDate(barrier).getTime() === getDate(value).getTime();
+    return useBarrier ? barrier : setHours(barrier, borderValue);
+}; };
+var limitDown = limit(0);
+var limitUp = limit(HOURS_IN_DAY - 1);
+/**
+ * @hidden
+ */
+var HoursService = /** @class */ (function () {
+    function HoursService(intl) {
+        this.intl = intl;
+        this.boundRange = false;
+        this.insertUndividedMax = false;
+    }
+    HoursService.prototype.apply = function (value, candidate) {
+        return setHours(value, candidate.getHours());
+    };
+    HoursService.prototype.configure = function (settings) {
+        var _this = this;
+        var _a = settings.boundRange, boundRange = _a === void 0 ? this.boundRange : _a, _b = settings.insertUndividedMax, insertUndividedMax = _b === void 0 ? this.insertUndividedMax : _b, _c = settings.min, min = _c === void 0 ? this.min : _c, _d = settings.max, max = _d === void 0 ? this.max : _d, part = settings.part, _e = settings.step, step = _e === void 0 ? this.step : _e;
+        this.boundRange = boundRange;
+        this.insertUndividedMax = insertUndividedMax;
+        this.toListItem = function (hour) {
+            var date = setHours(MIDNIGHT_DATE, hour);
+            return {
+                text: _this.intl.formatDate(date, part.pattern),
+                value: date
+            };
+        };
+        this.min = min;
+        this.max = max;
+        this.step = step;
+    };
+    HoursService.prototype.data = function (selectedValue) {
+        var _this = this;
+        var min = this.range(selectedValue)[0];
+        var getHour = stepper(min, this.step);
+        var convertToItem = function (idx) { return (_this.toListItem(getHour(idx))); };
+        var data = range(0, this.countFromMin(selectedValue)).map(convertToItem);
+        this.addLast(data);
+        if (selectedValue) {
+            this.addMissing(data, selectedValue);
+        }
+        return data;
+    };
+    HoursService.prototype.isRangeChanged = function (min, max) {
+        return !isEqual(this.min, min) || !isEqual(this.max, max);
+    };
+    HoursService.prototype.limitRange = function (min, max, value) {
+        return this.boundRange ? [limitDown(min, value), limitUp(max, value)] : [min, max];
+    };
+    HoursService.prototype.total = function (value) {
+        var last = this.insertUndividedMax && this.isLastMissing(value) ? 1 : 0;
+        var missing = this.isMissing(value) ? 1 : 0;
+        return this.countFromMin(value) + missing + last;
+    };
+    HoursService.prototype.selectedIndex = function (value) {
+        return Math.ceil(this.divideByStep(value));
+    };
+    HoursService.prototype.valueInList = function (value) {
+        if (!value) {
+            return true;
+        }
+        var matchMax = this.insertUndividedMax && this.lastHour(value) === value.getHours();
+        return matchMax || !this.isMissing(value);
+    };
+    HoursService.prototype.addLast = function (data, value) {
+        if (this.insertUndividedMax && this.isLastMissing(value)) {
+            data.push(this.toListItem(this.lastHour(value)));
+        }
+        return data;
+    };
+    HoursService.prototype.addMissing = function (data, value) {
+        if (this.valueInList(value)) {
+            return data;
+        }
+        var missingItem = this.toListItem(value.getHours());
+        data.splice(this.selectedIndex(value), 0, missingItem);
+        return data;
+    };
+    HoursService.prototype.countFromMin = function (value) {
+        var _a = this.range(value), min = _a[0], max = _a[1];
+        return Math.floor(distanceFromMin(max, min) / this.step) + 1; /* include min */
+    };
+    HoursService.prototype.isMissing = function (value) {
+        if (!value) {
+            return false;
+        }
+        return this.selectedIndex(value) !== this.divideByStep(value);
+    };
+    HoursService.prototype.isLastMissing = function (value) {
+        return this.isMissing(setHours(this.max, this.lastHour(value)));
+    };
+    HoursService.prototype.divideByStep = function (value) {
+        return distanceFromMin(value.getHours(), this.min.getHours()) / this.step;
+    };
+    HoursService.prototype.lastHour = function (value) {
+        return this.range(value)[1];
+    };
+    HoursService.prototype.range = function (value) {
+        var _a = this.limitRange(this.min, this.max, value), min = _a[0], max = _a[1];
+        return [min.getHours(), max.getHours()];
+    };
+    return HoursService;
+}());
+export { HoursService };

package/dist/esm/timepicker/services/MinutesService.d.ts

@@ -0,0 +1,32 @@
+import { IntlService } from '@progress/kendo-vue-intl';
+import { ListServiceSettings } from '../models/ListServiceSettings';
+import { ListService } from '../models/ListService';
+import { ListItem } from '../models/ListItem';
+/**
+ * @hidden
+ */
+export declare class MinutesService implements ListService {
+    private intl;
+    private toListItem;
+    private min;
+    private max;
+    private step;
+    private insertUndividedMax;
+    constructor(intl: IntlService);
+    apply(value: Date, candidate: Date): Date;
+    configure(settings: ListServiceSettings): void;
+    data(selectedValue?: Date): ListItem[];
+    isRangeChanged(min: Date, max: Date): boolean;
+    limitRange(min: Date, max: Date, value?: Date): Date[];
+    total(value?: Date): number;
+    selectedIndex(value: Date): number;
+    valueInList(value: Date): boolean;
+    private addLast;
+    private addMissing;
+    private countFromMin;
+    private isMissing;
+    private isLastMissing;
+    private divideByStep;
+    private lastMinute;
+    private range;
+}

package/dist/esm/timepicker/services/MinutesService.js

@@ -0,0 +1,113 @@
+import { isEqual } from '@progress/kendo-date-math';
+import { MIDNIGHT_DATE } from '../../utils.js';
+import { range, setMinutes } from '../utils.js';
+var MINUTES_IN_HOUR = 60;
+var clampToRange = function (rangeValue) { return function (value) { return value % rangeValue; }; };
+var clamp = clampToRange(MINUTES_IN_HOUR);
+var stepper = function (start, step) { return function (idx) { return clamp(start + (idx * step)); }; };
+var distanceFromMin = function (value, min) { return clamp(MINUTES_IN_HOUR + value - min); };
+var limit = function (borderValue) { return function (barrier, value) {
+    var useBarrier = !value || barrier.getHours() === value.getHours();
+    return useBarrier ? barrier : setMinutes(barrier, borderValue);
+}; };
+var limitDown = limit(0);
+var limitUp = limit(MINUTES_IN_HOUR - 1);
+/**
+ * @hidden
+ */
+var MinutesService = /** @class */ (function () {
+    function MinutesService(intl) {
+        this.intl = intl;
+        this.insertUndividedMax = false;
+    }
+    MinutesService.prototype.apply = function (value, candidate) {
+        return setMinutes(value, candidate.getMinutes());
+    };
+    MinutesService.prototype.configure = function (settings) {
+        var _this = this;
+        var _a = settings.insertUndividedMax, insertUndividedMax = _a === void 0 ? this.insertUndividedMax : _a, _b = settings.min, min = _b === void 0 ? this.min : _b, _c = settings.max, max = _c === void 0 ? this.max : _c, part = settings.part, _d = settings.step, step = _d === void 0 ? this.step : _d;
+        this.insertUndividedMax = insertUndividedMax;
+        this.toListItem = function (minute) {
+            var date = setMinutes(MIDNIGHT_DATE, minute);
+            return {
+                text: _this.intl.formatDate(date, part.pattern),
+                value: date
+            };
+        };
+        this.min = min;
+        this.max = max;
+        this.step = step;
+    };
+    MinutesService.prototype.data = function (selectedValue) {
+        var _this = this;
+        var min = this.range(selectedValue)[0];
+        var getMinute = stepper(min, this.step);
+        var convertToItem = function (idx) { return (_this.toListItem(getMinute(idx))); };
+        var data = range(0, this.countFromMin(selectedValue)).map(convertToItem);
+        this.addLast(data);
+        if (selectedValue) {
+            this.addMissing(data, selectedValue);
+        }
+        return data;
+    };
+    MinutesService.prototype.isRangeChanged = function (min, max) {
+        return !isEqual(this.min, min) || !isEqual(this.max, max);
+    };
+    MinutesService.prototype.limitRange = function (min, max, value) {
+        return [limitDown(min, value), limitUp(max, value)];
+    };
+    MinutesService.prototype.total = function (value) {
+        var last = this.insertUndividedMax && this.isLastMissing(value) ? 1 : 0;
+        var missing = this.isMissing(value) ? 1 : 0;
+        return this.countFromMin(value) + missing + last;
+    };
+    MinutesService.prototype.selectedIndex = function (value) {
+        return Math.ceil(this.divideByStep(value));
+    };
+    MinutesService.prototype.valueInList = function (value) {
+        if (!value) {
+            return true;
+        }
+        var matchMax = this.insertUndividedMax && this.lastMinute(value) === value.getMinutes();
+        return matchMax || !this.isMissing(value);
+    };
+    MinutesService.prototype.addLast = function (data, value) {
+        if (this.insertUndividedMax && this.isLastMissing(value)) {
+            data.push(this.toListItem(this.lastMinute(value)));
+        }
+        return data;
+    };
+    MinutesService.prototype.addMissing = function (data, value) {
+        if (this.valueInList(value)) {
+            return data;
+        }
+        var missingItem = this.toListItem(value.getMinutes());
+        data.splice(this.selectedIndex(value), 0, missingItem);
+        return data;
+    };
+    MinutesService.prototype.countFromMin = function (value) {
+        var _a = this.range(value), min = _a[0], max = _a[1];
+        return Math.floor(distanceFromMin(max, min) / this.step) + 1; /* include min */
+    };
+    MinutesService.prototype.isMissing = function (value) {
+        if (!value) {
+            return false;
+        }
+        return this.selectedIndex(value) !== this.divideByStep(value);
+    };
+    MinutesService.prototype.isLastMissing = function (value) {
+        return this.isMissing(setMinutes(this.max, this.lastMinute(value)));
+    };
+    MinutesService.prototype.divideByStep = function (value) {
+        return distanceFromMin(value.getMinutes(), this.min.getMinutes()) / this.step;
+    };
+    MinutesService.prototype.lastMinute = function (value) {
+        return this.range(value)[1];
+    };
+    MinutesService.prototype.range = function (value) {
+        var _a = this.limitRange(this.min, this.max, value), min = _a[0], max = _a[1];
+        return [min.getMinutes(), max.getMinutes()];
+    };
+    return MinutesService;
+}());
+export { MinutesService };

package/dist/esm/timepicker/services/SecondsService.d.ts

@@ -0,0 +1,32 @@
+import { IntlService } from '@progress/kendo-vue-intl';
+import { ListServiceSettings } from '../models/ListServiceSettings';
+import { ListService } from '../models/ListService';
+import { ListItem } from '../models/ListItem';
+/**
+ * @hidden
+ */
+export declare class SecondsService implements ListService {
+    private intl;
+    private toListItem;
+    private min;
+    private max;
+    private step;
+    private insertUndividedMax;
+    constructor(intl: IntlService);
+    apply(value: Date, candidate: Date): Date;
+    configure(settings: ListServiceSettings): void;
+    data(selectedValue?: Date): ListItem[];
+    isRangeChanged(min: Date, max: Date): boolean;
+    limitRange(min: Date, max: Date, value?: Date): Date[];
+    total(value?: Date): number;
+    selectedIndex(value: Date): number;
+    valueInList(value: Date): boolean;
+    private divideByStep;
+    private addLast;
+    private addMissing;
+    private countFromMin;
+    private isMissing;
+    private isLastMissing;
+    private lastSecond;
+    private range;
+}

package/dist/esm/timepicker/services/SecondsService.js

@@ -0,0 +1,114 @@
+import { isEqual } from '@progress/kendo-date-math';
+import { MIDNIGHT_DATE } from '../../utils.js';
+import { range, setSeconds } from '../utils.js';
+var SECONDS_IN_HOUR = 60;
+var clampToRange = function (rangeValue) { return function (value) { return value % rangeValue; }; };
+var clamp = clampToRange(SECONDS_IN_HOUR);
+var stepper = function (start, step) { return function (idx) { return clamp(start + (idx * step)); }; };
+var distanceFromMin = function (value, min) { return clamp(SECONDS_IN_HOUR + value - min); };
+var limit = function (borderValue) { return function (barrier, value) {
+    var useBarrier = !value ||
+        (barrier.getMinutes() === value.getMinutes() && barrier.getHours() === value.getHours());
+    return useBarrier ? barrier : setSeconds(barrier, borderValue);
+}; };
+var limitDown = limit(0);
+var limitUp = limit(SECONDS_IN_HOUR - 1);
+/**
+ * @hidden
+ */
+var SecondsService = /** @class */ (function () {
+    function SecondsService(intl) {
+        this.intl = intl;
+        this.insertUndividedMax = false;
+    }
+    SecondsService.prototype.apply = function (value, candidate) {
+        return setSeconds(value, candidate.getSeconds());
+    };
+    SecondsService.prototype.configure = function (settings) {
+        var _this = this;
+        var _a = settings.insertUndividedMax, insertUndividedMax = _a === void 0 ? this.insertUndividedMax : _a, _b = settings.min, min = _b === void 0 ? this.min : _b, _c = settings.max, max = _c === void 0 ? this.max : _c, part = settings.part, _d = settings.step, step = _d === void 0 ? this.step : _d;
+        this.insertUndividedMax = insertUndividedMax;
+        this.toListItem = function (minute) {
+            var date = setSeconds(MIDNIGHT_DATE, minute);
+            return {
+                text: _this.intl.formatDate(date, part.pattern),
+                value: date
+            };
+        };
+        this.min = min;
+        this.max = max;
+        this.step = step;
+    };
+    SecondsService.prototype.data = function (selectedValue) {
+        var _this = this;
+        var min = this.range(selectedValue)[0];
+        var getSecond = stepper(min, this.step);
+        var convertToItem = function (idx) { return (_this.toListItem(getSecond(idx))); };
+        var data = range(0, this.countFromMin(selectedValue)).map(convertToItem);
+        this.addLast(data);
+        if (selectedValue) {
+            this.addMissing(data, selectedValue);
+        }
+        return data;
+    };
+    SecondsService.prototype.isRangeChanged = function (min, max) {
+        return !isEqual(this.min, min) || !isEqual(this.max, max);
+    };
+    SecondsService.prototype.limitRange = function (min, max, value) {
+        return [limitDown(min, value), limitUp(max, value)];
+    };
+    SecondsService.prototype.total = function (value) {
+        var last = this.insertUndividedMax && this.isLastMissing(value) ? 1 : 0;
+        var missing = this.isMissing(value) ? 1 : 0;
+        return this.countFromMin(value) + missing + last;
+    };
+    SecondsService.prototype.selectedIndex = function (value) {
+        return Math.ceil(this.divideByStep(value));
+    };
+    SecondsService.prototype.valueInList = function (value) {
+        if (!value) {
+            return true;
+        }
+        var matchMax = this.insertUndividedMax && this.lastSecond(value) === value.getSeconds();
+        return matchMax || !this.isMissing(value);
+    };
+    SecondsService.prototype.divideByStep = function (value) {
+        return distanceFromMin(value.getSeconds(), this.min.getSeconds()) / this.step;
+    };
+    SecondsService.prototype.addLast = function (data, value) {
+        if (this.insertUndividedMax && this.isLastMissing(value)) {
+            data.push(this.toListItem(this.lastSecond(value)));
+        }
+        return data;
+    };
+    SecondsService.prototype.addMissing = function (data, value) {
+        if (this.valueInList(value)) {
+            return data;
+        }
+        var missingItem = this.toListItem(value.getSeconds());
+        data.splice(this.selectedIndex(value), 0, missingItem);
+        return data;
+    };
+    SecondsService.prototype.countFromMin = function (value) {
+        var _a = this.range(value), min = _a[0], max = _a[1];
+        return Math.floor(distanceFromMin(max, min) / this.step) + 1; /* include min */
+    };
+    SecondsService.prototype.isMissing = function (value) {
+        if (!value) {
+            return false;
+        }
+        return this.selectedIndex(value) !== this.divideByStep(value);
+    };
+    SecondsService.prototype.isLastMissing = function (value) {
+        return this.isMissing(setSeconds(this.max, this.lastSecond(value)));
+    };
+    SecondsService.prototype.lastSecond = function (value) {
+        return this.range(value)[1];
+    };
+    SecondsService.prototype.range = function (value) {
+        var _a = this.limitRange(this.min, this.max, value), min = _a[0], max = _a[1];
+        return [min.getSeconds(), max.getSeconds()];
+    };
+    return SecondsService;
+}());
+export { SecondsService };

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

@@ -0,0 +1,6 @@
+import { DayPeriodService } from './DayPeriodService';
+import { DOMService } from './DOMService';
+import { HoursService } from './HoursService';
+import { MinutesService } from './MinutesService';
+import { SecondsService } from './SecondsService';
+export { DayPeriodService, DOMService, HoursService, MinutesService, SecondsService };

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

@@ -0,0 +1,6 @@
+import { DayPeriodService } from './DayPeriodService.js';
+import { DOMService } from './DOMService.js';
+import { HoursService } from './HoursService.js';
+import { MinutesService } from './MinutesService.js';
+import { SecondsService } from './SecondsService.js';
+export { DayPeriodService, DOMService, HoursService, MinutesService, SecondsService };