@progress/kendo-react-dateinputs 13.3.0-develop.9 → 13.4.0-develop.1

package/timepicker/TimeList.mjs

@@ -5,97 +5,97 @@
  * Licensed under commercial license. See LICENSE.md in the package root for more information
  *-------------------------------------------------------------------------------------------
  */
-import * as n from "react";
-import m from "prop-types";
-import { cloneDate as O } from "@progress/kendo-date-math";
-import { Keys as c, getActiveElement as I, noop as H, classNames as u, uTime as l } from "@progress/kendo-react-common";
-import { provideIntlService as y, registerForIntl as E } from "@progress/kendo-react-intl";
-import { Virtualization as M } from "../virtualization/Virtualization.mjs";
+import * as r from "react";
+import d from "prop-types";
+import { cloneDate as H } from "@progress/kendo-date-math";
+import { getActiveElement as S, Keys as c, noop as I, classNames as u, uTime as l } from "@progress/kendo-react-common";
+import { provideIntlService as M, registerForIntl as y } from "@progress/kendo-react-intl";
+import { Virtualization as E } from "../virtualization/Virtualization.mjs";
 import { TIME_PART as f } from "./models/TimePart.mjs";
 import { DayPeriodService as D } from "./services/DayPeriodService.mjs";
-import { DOMService as w } from "./services/DOMService.mjs";
-import { HoursService as R } from "./services/HoursService.mjs";
-import { MinutesService as C } from "./services/MinutesService.mjs";
-import { SecondsService as P } from "./services/SecondsService.mjs";
-import { debounce as _, MAX_TIME as z, MIDNIGHT_DATE as A } from "../utils.mjs";
-const F = 2, S = 0.05, N = 100, k = 0, T = 9, B = {
-  [c.end]: (h, i) => h[h.length - 1],
-  [c.home]: (h, i) => h[0],
-  [c.up]: (h, i) => h[i - 1],
-  [c.down]: (h, i) => h[i + 1]
+import { DOMService as _ } from "./services/DOMService.mjs";
+import { HoursService as C } from "./services/HoursService.mjs";
+import { MinutesService as w } from "./services/MinutesService.mjs";
+import { SecondsService as R } from "./services/SecondsService.mjs";
+import { debounce as P, MIDNIGHT_DATE as z, MAX_TIME as A } from "../utils.mjs";
+const F = 2, b = 0.05, N = 100, k = 0, O = 9, B = {
+  [c.end]: (a, i) => a[a.length - 1],
+  [c.home]: (a, i) => a[0],
+  [c.up]: (a, i) => a[i - 1],
+  [c.down]: (a, i) => a[i + 1]
 }, g = {
   [f.dayperiod]: D,
-  [f.hour]: R,
-  [f.minute]: C,
-  [f.second]: P
-}, r = class r extends n.Component {
+  [f.hour]: C,
+  [f.minute]: w,
+  [f.second]: R
+}, h = class h extends r.Component {
   constructor(i) {
-    super(i), this.intl = null, this._element = null, this.service = null, this.virtualization = null, this.topOffset = 0, this.bottomOffset = 0, this.itemHeight = 0, this.listHeight = 0, this.topThreshold = 0, this.bottomThreshold = 0, this.animateToIndex = !1, this.focus = (t) => {
+    super(i), this.intl = null, this._element = null, this.service = null, this.virtualization = null, this.topOffset = 0, this.bottomOffset = 0, this.itemHeight = 0, this.listHeight = 0, this.topThreshold = 0, this.bottomThreshold = 0, this.animateToIndex = !1, this.focus = (e) => {
       Promise.resolve().then(() => {
-        this.element && this.element.focus(t);
+        this.element && this.element.focus(e);
       });
-    }, this.itemOffset = (t) => {
+    }, this.itemOffset = (e) => {
       if (!this.virtualization || !this.service)
         return -1;
-      const s = this.service.selectedIndex(this.props.value), e = this.virtualization.activeIndex(), o = this.virtualization.itemOffset(e), a = Math.abs(Math.ceil(t) - o);
-      if (s === e && a < F)
+      const s = this.service.selectedIndex(this.props.value), t = this.virtualization.activeIndex(), o = this.virtualization.itemOffset(t), n = Math.abs(Math.ceil(e) - o);
+      if (s === t && n < F)
         return o;
-      const d = s > e;
-      return d && a >= this.bottomThreshold || !d && a > this.topThreshold ? this.virtualization.itemOffset(e + 1) : o;
+      const p = s > t;
+      return p && n >= this.bottomThreshold || !p && n > this.topThreshold ? this.virtualization.itemOffset(t + 1) : o;
     }, this.calculateHeights = () => {
-      this.dom.didCalculate && (this.itemHeight = this.dom.itemHeight, this.listHeight = this.dom.timeListHeight, this.topOffset = (this.listHeight - this.itemHeight) / 2, this.bottomOffset = this.listHeight - this.itemHeight, this.props.mobileMode && (this.topOffset += T, this.bottomOffset += T * 2), this.topThreshold = this.itemHeight * S, this.bottomThreshold = this.itemHeight * (1 - S));
-    }, this.configureServices = ({ min: t, max: s, value: e } = this.props) => {
+      this.dom.didCalculate && (this.itemHeight = this.dom.itemHeight, this.listHeight = this.dom.timeListHeight, this.topOffset = (this.listHeight - this.itemHeight) / 2, this.bottomOffset = this.listHeight - this.itemHeight, this.props.mobileMode && (this.topOffset += O, this.bottomOffset += O * 2), this.topThreshold = this.itemHeight * b, this.bottomThreshold = this.itemHeight * (1 - b));
+    }, this.configureServices = ({ min: e, max: s, value: t } = this.props) => {
       if (this.service) {
-        const [o, a] = this.service.limitRange(
-          t || this.min,
+        const [o, n] = this.service.limitRange(
+          e || this.min,
           s || this.max,
-          e || this.props.value
+          t || this.props.value
         );
-        this.service.configure(this.serviceSettings({ min: o, max: a }));
+        this.service.configure(this.serviceSettings({ min: o, max: n }));
       }
-    }, this.serviceSettings = (t) => {
+    }, this.serviceSettings = (e) => {
       const s = {
-        boundRange: this.props.boundRange || r.defaultProps.boundRange,
+        boundRange: this.props.boundRange || h.defaultProps.boundRange,
         insertUndividedMax: !1,
-        min: O(this.min),
-        max: O(this.max),
+        min: H(this.min),
+        max: H(this.max),
         part: this.props.part,
         step: this.step
-      }, e = Object.assign({}, s, t);
-      return e.boundRange = e.part.type !== "hour" || this.props.boundRange || r.defaultProps.boundRange, e;
-    }, this.handleScrollAction = ({ target: t, animationInProgress: s }) => {
-      if (!(!this.virtualization || !this.service) && t && !s) {
+      }, t = Object.assign({}, s, e);
+      return t.boundRange = t.part.type !== "hour" || this.props.boundRange || h.defaultProps.boundRange, t;
+    }, this.handleScrollAction = ({ target: e, animationInProgress: s }) => {
+      if (!(!this.virtualization || !this.service) && e && !s) {
         this.animateToIndex = !1;
-        const e = this.virtualization.itemIndex(this.itemOffset(t.scrollTop)), o = this.service.data(this.props.value)[e];
+        const t = this.virtualization.itemIndex(this.itemOffset(e.scrollTop)), o = this.service.data(this.props.value)[t];
         this.handleChange(o);
       }
-    }, this.handleFocus = (t) => {
+    }, this.handleFocus = (e) => {
       const { onFocus: s } = this.props;
-      s && s.call(void 0, t);
-    }, this.handleBlur = (t) => {
+      s && s.call(void 0, e);
+    }, this.handleBlur = (e) => {
       const { onBlur: s } = this.props;
-      s && s.call(void 0, t);
+      s && s.call(void 0, e);
     }, this.handleMouseOver = () => {
       if (!this._element)
         return;
-      const t = I(document);
-      document && t !== this._element && this.props.show && this._element.focus({ preventScroll: !0 });
-    }, this.handleKeyDown = (t) => {
+      const e = S(document);
+      document && e !== this._element && this.props.show && this._element.focus({ preventScroll: !0 });
+    }, this.handleKeyDown = (e) => {
       if (!this.service)
         return;
-      const { keyCode: s } = t;
-      (s === c.down || s === c.up || s === c.end || s === c.home) && t.preventDefault();
-      const o = (B[t.keyCode] || H)(this.service.data(this.props.value), this.service.selectedIndex(this.props.value));
+      const { keyCode: s } = e;
+      (s === c.down || s === c.up || s === c.end || s === c.home) && e.preventDefault();
+      const o = (B[e.keyCode] || I)(this.service.data(this.props.value), this.service.selectedIndex(this.props.value));
       o && this.handleChange(o);
-    }, this.handleChange = _((t) => {
+    }, this.handleChange = P((e) => {
       if (!this.service)
         return;
-      const s = this.service.apply(this.props.value, t.value);
+      const s = this.service.apply(this.props.value, e.value);
       if (this.props.value.getTime() === s.getTime())
         return;
-      const { onChange: e } = this.props;
-      e && e.call(void 0, s);
-    }, N), this.dom = new w();
+      const { onChange: t } = this.props;
+      t && t.call(void 0, s);
+    }, N), this.dom = new _();
   }
   get element() {
     return this._element;
@@ -104,13 +104,13 @@ const F = 2, S = 0.05, N = 100, k = 0, T = 9, B = {
     return !!(this.props.smoothScroll && this.animateToIndex);
   }
   get min() {
-    return this.props.min || r.defaultProps.min;
+    return this.props.min || h.defaultProps.min;
   }
   get max() {
-    return this.props.max || r.defaultProps.max;
+    return this.props.max || h.defaultProps.max;
   }
   get step() {
-    return this.props.step !== void 0 && this.props.step !== 0 ? Math.floor(this.props.step) : r.defaultProps.step;
+    return this.props.step !== void 0 && this.props.step !== 0 ? Math.floor(this.props.step) : h.defaultProps.step;
   }
   /**
    * @hidden
@@ -118,17 +118,27 @@ const F = 2, S = 0.05, N = 100, k = 0, T = 9, B = {
   componentDidMount() {
     Promise.resolve().then(() => {
       const { unstyled: i } = this.props;
-      this._element && (this.dom.calculateHeights(this._element, i), this.forceUpdate());
+      this._element && (this.dom.calculateHeights(this._element, i), this.lastMeasuredHeight = this._element.clientHeight, this.forceUpdate());
     });
   }
   /**
    * @hidden
    */
-  componentDidUpdate() {
+  componentDidUpdate(i) {
+    var s;
     if (!this.virtualization || !this.service)
       return;
-    const i = this.service.selectedIndex(this.props.value);
-    if (this.virtualization[this.animate ? "animateToIndex" : "scrollToIndex"](i), this.animateToIndex = !0, !this.topOffset && this._element) {
+    if (this._element) {
+      const t = this._element.clientHeight, o = this.lastMeasuredHeight !== void 0 && Math.abs(t - this.lastMeasuredHeight) > 1, n = this.props.mobileMode !== i.mobileMode;
+      if (o || n) {
+        const { unstyled: p } = this.props;
+        this.dom.calculateHeights(this._element, p), this.calculateHeights(), this.lastMeasuredHeight = t, this.animateToIndex = !1, this.forceUpdate();
+        return;
+      }
+      (s = this.lastMeasuredHeight) != null || (this.lastMeasuredHeight = t);
+    }
+    const e = this.service.selectedIndex(this.props.value);
+    if (this.virtualization[this.animate ? "animateToIndex" : "scrollToIndex"](e), this.animateToIndex = !0, !this.topOffset && this._element) {
       const { unstyled: t } = this.props;
       this.dom.calculateHeights(this._element, t);
     }
@@ -137,72 +147,72 @@ const F = 2, S = 0.05, N = 100, k = 0, T = 9, B = {
    * @hidden
    */
   render() {
-    const { part: i, value: t, unstyled: s } = this.props;
+    const { part: i, value: e, unstyled: s } = this.props;
     if (!i.type || !g[i.type])
       return;
-    const e = s && s.uTime;
-    this.calculateHeights(), this.intl = y(this), this.service = new g[i.type](this.intl), this.configureServices();
-    const o = this.service.data(t), a = "translateY(" + this.topOffset + "px)", d = this.service.total(t), v = /* @__PURE__ */ n.createElement(n.Fragment, null, /* @__PURE__ */ n.createElement(
+    const t = s && s.uTime;
+    this.calculateHeights(), this.intl = M(this), this.service = new g[i.type](this.intl), this.configureServices();
+    const o = this.service.data(e), n = "translateY(" + this.topOffset + "px)", p = this.service.total(e), v = /* @__PURE__ */ r.createElement(r.Fragment, null, /* @__PURE__ */ r.createElement(
       "ul",
       {
-        style: { transform: a, msTransform: a },
-        className: u(l.ul({ c: e }))
+        style: { transform: n, msTransform: n },
+        className: u(l.ul({ c: t }))
       },
-      o.map((p, b) => /* @__PURE__ */ n.createElement(
+      o.map((m, T) => /* @__PURE__ */ r.createElement(
         "li",
         {
-          key: b,
-          className: u(l.li({ c: e })),
+          key: T,
+          className: u(l.li({ c: t })),
           onClick: () => {
-            this.handleChange(p);
+            this.handleChange(m);
           }
         },
-        /* @__PURE__ */ n.createElement("span", null, p.text)
+        /* @__PURE__ */ r.createElement("span", null, m.text)
       ))
-    ), /* @__PURE__ */ n.createElement("div", { className: u(l.scrollablePlaceholder({ c: e })) }));
-    return /* @__PURE__ */ n.createElement(
+    ), /* @__PURE__ */ r.createElement("div", { className: u(l.scrollablePlaceholder({ c: t })) }));
+    return /* @__PURE__ */ r.createElement(
       "div",
       {
-        className: u(l.list({ c: e })),
+        className: u(l.list({ c: t })),
         id: String(this.props.id || ""),
         tabIndex: this.props.disabled ? -1 : 0,
-        ref: (p) => {
-          this._element = p;
+        ref: (m) => {
+          this._element = m;
         },
         onKeyDown: this.handleKeyDown,
         onFocus: this.handleFocus,
         onBlur: this.handleBlur,
         onMouseOver: this.handleMouseOver
       },
-      this.dom.didCalculate ? /* @__PURE__ */ n.createElement(
-        M,
+      this.dom.didCalculate ? /* @__PURE__ */ r.createElement(
+        E,
         {
           bottomOffset: this.bottomOffset,
           children: v,
           className: u(
-            l.containerSelector({ c: e }),
-            l.container({ c: e })
+            l.containerSelector({ c: t }),
+            l.container({ c: t })
           ),
           itemHeight: this.itemHeight,
           maxScrollDifference: this.listHeight,
           onScrollAction: this.handleScrollAction,
-          ref: (p) => {
-            this.virtualization = p;
+          ref: (m) => {
+            this.virtualization = m;
           },
           role: "presentation",
           skip: k,
           tabIndex: -1,
-          take: d,
+          take: p,
           topOffset: this.topOffset,
-          total: d,
+          total: p,
           unstyled: s
         }
-      ) : /* @__PURE__ */ n.createElement(
+      ) : /* @__PURE__ */ r.createElement(
         "div",
         {
           className: u(
-            l.containerSelector({ c: e }),
-            l.container({ c: e, content: !0, scrollable: !0 })
+            l.containerSelector({ c: t }),
+            l.container({ c: t, content: !0, scrollable: !0 })
           )
         },
         v
@@ -210,40 +220,40 @@ const F = 2, S = 0.05, N = 100, k = 0, T = 9, B = {
     );
   }
 };
-r.propTypes = {
-  id: m.number,
-  max: m.instanceOf(Date),
-  min: m.instanceOf(Date),
-  part: function(i, t, s) {
-    const e = i[t];
-    if (!e || !g[e.type])
+h.propTypes = {
+  id: d.number,
+  max: d.instanceOf(Date),
+  min: d.instanceOf(Date),
+  part: function(i, e, s) {
+    const t = i[e];
+    if (!t || !g[t.type])
       throw new Error(`
-                    Invalid prop '${t}' supplied to ${s}.
+                    Invalid prop '${e}' supplied to ${s}.
                     Supported part types are hour|minute|second|dayperiod.
                 `);
     return null;
   },
-  step: function(i, t, s) {
-    const e = i[t];
-    if (e !== void 0 && e <= 0)
+  step: function(i, e, s) {
+    const t = i[e];
+    if (t !== void 0 && t <= 0)
       throw new Error(`
-                    Invalid prop '${t}' supplied to ${s}.
-                    ${t} cannot be less than 1.
+                    Invalid prop '${e}' supplied to ${s}.
+                    ${e} cannot be less than 1.
                 `);
     return null;
   },
-  value: m.instanceOf(Date),
-  smoothScroll: m.bool,
-  show: m.bool
-}, r.defaultProps = {
+  value: d.instanceOf(Date),
+  smoothScroll: d.bool,
+  show: d.bool
+}, h.defaultProps = {
   boundRange: !1,
-  max: z,
-  min: A,
+  max: A,
+  min: z,
   step: 1,
   smoothScroll: !0
 };
-let x = r;
-E(x);
+let x = h;
+y(x);
 export {
   x as TimeList
 };

package/timepicker/TimePart.d.ts

@@ -0,0 +1,146 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2026 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+import { default as PropTypes } from 'prop-types';
+import { DateInputsClassStructure } from '@progress/kendo-react-common';
+import { DateFormatPart, IntlService, DateFormatOptions } from '@progress/kendo-react-intl';
+import { TimePickerIncrementalSteps } from './models/IncrementalSteps.js';
+import * as React from 'react';
+/**
+ * @hidden
+ */
+export declare enum Direction {
+    Left = 0,
+    Right = 1
+}
+/**
+ * @hidden
+ */
+export interface TimePartChangeEvent {
+    nativeEvent: any;
+    syntheticEvent: React.SyntheticEvent<any>;
+    value: Date;
+    target: TimePart;
+}
+/**
+ * @hidden
+ */
+export interface TimePartProps {
+    disabled?: boolean;
+    format?: string | DateFormatOptions;
+    max?: Date;
+    min?: Date;
+    nowButton?: boolean;
+    onChange?: any;
+    steps?: TimePickerIncrementalSteps;
+    smoothScroll?: boolean;
+    tabIndex?: number;
+    value?: Date | null;
+    boundRange?: boolean;
+    onNowClick?: any;
+    className?: string;
+    onMount?: (value: Date) => void;
+    onNowKeyDown?: (event: React.KeyboardEvent) => void;
+    show?: boolean;
+    mobileMode?: boolean;
+    unstyled?: DateInputsClassStructure;
+}
+/**
+ * @hidden
+ */
+export interface TimePartState {
+    activeListIndex: number;
+}
+/**
+ * @hidden
+ */
+export declare class TimePart extends React.Component<TimePartProps, TimePartState> {
+    static propTypes: {
+        cancelButton: PropTypes.Requireable<boolean>;
+        disabled: PropTypes.Requireable<boolean>;
+        format: PropTypes.Requireable<NonNullable<string | PropTypes.InferProps<{
+            skeleton: PropTypes.Requireable<string>;
+            pattern: PropTypes.Requireable<string>;
+            date: PropTypes.Requireable<string>;
+            time: PropTypes.Requireable<string>;
+            datetime: PropTypes.Requireable<string>;
+            era: PropTypes.Requireable<string>;
+            year: PropTypes.Requireable<string>;
+            month: PropTypes.Requireable<string>;
+            day: PropTypes.Requireable<string>;
+            weekday: PropTypes.Requireable<string>;
+            hour: PropTypes.Requireable<string>;
+            hour12: PropTypes.Requireable<boolean>;
+            minute: PropTypes.Requireable<string>;
+            second: PropTypes.Requireable<string>;
+            timeZoneName: PropTypes.Requireable<string>;
+        }> | null | undefined>>;
+        max: PropTypes.Requireable<Date>;
+        min: PropTypes.Requireable<Date>;
+        nowButton: PropTypes.Requireable<boolean>;
+        steps: PropTypes.Requireable<PropTypes.InferProps<{
+            hour: PropTypes.Requireable<number>;
+            minute: PropTypes.Requireable<number>;
+            second: PropTypes.Requireable<number>;
+        }>>;
+        smoothScroll: PropTypes.Requireable<boolean>;
+        tabIndex: PropTypes.Requireable<number>;
+        value: PropTypes.Requireable<Date>;
+        show: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        value: null;
+        disabled: boolean;
+        nowButton: boolean;
+        cancelButton: boolean;
+        format: string;
+        min: Date;
+        max: Date;
+        steps: {};
+        boundRange: boolean;
+    };
+    readonly state: TimePartState;
+    private _element;
+    private _nowButton;
+    private dateFormatParts;
+    private timeLists;
+    private snapTime;
+    private nextTickId;
+    constructor(props: TimePartProps);
+    /**
+     * @hidden
+     */
+    get element(): HTMLSpanElement | null;
+    get value(): Date;
+    protected get intl(): IntlService;
+    private get min();
+    private get max();
+    private get steps();
+    protected get boundRange(): boolean;
+    /**
+     * @hidden
+     */
+    componentWillUnmount(): void;
+    componentDidMount(): void;
+    /**
+     * @hidden
+     */
+    render(): React.JSX.Element;
+    focus: (args?: FocusOptions, focusNowButton?: boolean) => void;
+    protected timeFormatReducer: (acc: string, current: DateFormatPart) => string;
+    protected timeFormatFilter: (part: DateFormatPart, index: number, all: DateFormatPart[]) => boolean;
+    protected nextTick(f: () => any): void;
+    protected hasActiveButton(): boolean | null;
+    protected focusList: (dir: Direction) => void;
+    protected listReducer: (state: any, list: any, idx: number, all: any) => any;
+    protected showNowButton: () => boolean | undefined;
+    protected hasSteps(): boolean;
+    private handleKeyDown;
+    private handleListBlur;
+    private handleListFocus;
+    private handleChange;
+}

package/timepicker/TimePart.mjs

@@ -12,7 +12,7 @@ import { Keys as T, classNames as l, uTime as h, getActiveElement as R } from "@
 import { provideIntlService as k, provideLocalizationService as S, registerForIntl as C, registerForLocalization as M } from "@progress/kendo-react-intl";
 import { selectNow as L, messages as x, now as I } from "../messages/index.mjs";
 import { TimeList as P } from "./TimeList.mjs";
-import { MIN_TIME as A, MAX_TIME as K, MIDNIGHT_DATE as _ } from "../utils.mjs";
+import { MAX_TIME as A, MIN_TIME as K, MIDNIGHT_DATE as _ } from "../utils.mjs";
 import { TIME_PART as d } from "./models/TimePart.mjs";
 import { isInTimeRange as $, getNow as z, snapTime as N, generateSnappers as B, timeInRange as W } from "./utils.mjs";
 import { Button as j } from "@progress/kendo-react-buttons";
@@ -239,8 +239,8 @@ a.propTypes = {
   nowButton: !0,
   cancelButton: !0,
   format: "hh:mm a",
-  min: A,
-  max: K,
+  min: K,
+  max: A,
   steps: {},
   boundRange: !1
 };