@progress/kendo-react-dateinputs 14.4.1-develop.9 → 14.5.0-develop.1

package/virtualization/Virtualization.mjs

@@ -5,171 +5,170 @@
  * Licensed under commercial license. See LICENSE.md in the package root for more information
  *-------------------------------------------------------------------------------------------
  */
-import * as u from "react";
+import * as n from "react";
 import o from "prop-types";
-import { RowHeightService as b, classNames as v, uCalendar as p } from "@progress/kendo-react-common";
-import { ScrollerService as P } from "./services/ScrollerService.mjs";
-const T = (s, i, t) => Math.min(Math.abs(i - s), t), A = 17, C = 10, x = {
-  1: (s) => (i) => i + s,
-  0: (s) => (i) => i - s
-}, I = {
-  1: (s) => (i) => Math.min(i, s),
-  0: (s) => (i) => Math.max(i, s)
-}, M = {
-  1: (s) => (i) => i < s,
-  0: (s) => (i) => i > s
-}, a = class a extends u.Component {
-  constructor(i) {
-    super(i), this.rowHeightService = null, this.scrollContainer = null, this.lastDirection = null, this.lastTotal = 0, this.lastTake = 0, this.animationInProgress = !1, this.restrictScroll = !1, this.scrollTo = (t) => {
-      const e = this.direction === "vertical" ? "scrollTop" : "scrollLeft";
-      if (!this.scrollContainer)
-        return;
-      const r = this.scrollContainer[e];
-      this.restrictScroll && e === "scrollTop" && (!Number.isInteger(r) || !Number.isInteger(t)) && Math.abs(r - t) < C || (this.scrollContainer[e] = t);
-    }, this.scrollToIndex = (t) => {
-      this.animationInProgress = !1, this.rowHeightService && this.scrollTo(this.rowHeightService.offset(t));
-    }, this.animateToIndex = (t) => {
-      if (!this.rowHeightService || !window)
-        return;
-      window.cancelAnimationFrame(this.cancelAnimation);
-      const e = this.rowHeightService.offset(t), r = this.getContainerScrollDirection(e), { start: n, end: l } = this.scrollRange(e, r);
-      if (n === l)
-        return;
-      const f = this.scrollStep(n, l), c = x[r](f), h = I[r](l), d = M[r](c(l)), m = (g) => {
-        this.animationInProgress = !0;
-        const S = c(g);
-        this.scrollTo(h(S)), d(S) ? this.cancelAnimation = window.requestAnimationFrame(() => {
-          m(S);
-        }) : this.animationInProgress = !1;
-      };
-      this.cancelAnimation = window.requestAnimationFrame(() => {
-        m(n);
-      });
-    }, this.scrollToBottom = () => {
-      this.rowHeightService && this.scrollTo(this.rowHeightService.totalHeight() + this.props.bottomOffset);
-    }, this.scrollStep = (t, e) => {
-      const r = this.props.scrollDuration || a.defaultProps.scrollDuration;
-      return Math.abs(e - t) / (r / A);
-    }, this.scrollRange = (t, e) => {
-      const r = this.containerScrollPosition;
-      if (parseInt(`${t}`, 10) === parseInt(`${r}`, 10))
-        return { start: t, end: t };
-      const n = this.containerMaxScroll(), l = e === 0 ? 1 : -1, f = T(r, t, this.props.maxScrollDifference || 0), c = Math.min(t, n);
-      return { start: Math.min(Math.max(c + l * f, 0), n), end: c };
-    }, this.containerMaxScroll = () => this.containerScrollSize - this.containerOffsetSize, this.getContainerScrollDirection = (t) => t < this.containerScrollPosition ? 0 : 1, this.initServices = (t = this.props) => {
-      const e = this.direction === "vertical" ? t.itemHeight : t.itemWidth;
-      e !== void 0 && (this.rowHeightService = new b(t.total, e), this.scrollerService.create(
-        this.rowHeightService,
-        t.skip,
-        t.take,
-        t.total,
-        t.topOffset,
-        this.scrollOffsetSize,
-        this.direction
-      ));
-    }, this.getContainerProperty = (t) => this.scrollContainer ? this.scrollContainer[t] : 0, this.handleScroll = (t) => {
-      if (!this.scrollContainer || !this.rowHeightService)
-        return;
-      const e = t.target;
-      this.scrollerService.onScroll({
-        scrollLeft: e.scrollLeft,
-        scrollTop: e.scrollTop,
-        offsetHeight: e.offsetHeight,
-        offsetWidth: e.offsetWidth
-      });
-      const r = this.rowHeightService.index(this.containerScrollPosition - this.props.topOffset), { onScrollAction: n } = this.props, l = {
-        index: r,
-        target: e,
-        scrollAction: this.scrollAction,
-        pageAction: this.pageAction,
-        animationInProgress: this.animationInProgress
-      };
-      this.props.onScroll && this.props.onScroll.call(void 0, t), n && n.call(void 0, l), this.scrollAction = void 0, this.pageAction = void 0;
-    }, this.handleScrollAction = (t) => {
-      this.scrollAction = t;
-    }, this.handlePageAction = (t) => {
-      this.pageAction = t;
-    }, this.scrollerService = new P(this.handleScrollAction, this.handlePageAction), this.restrictScroll = Number.parseFloat(u.version) > 17;
-  }
-  get element() {
-    return this.scrollContainer;
-  }
-  get containerOffsetSize() {
-    return this.getContainerProperty(this.direction === "vertical" ? "offsetHeight" : "offsetWidth");
-  }
-  get containerScrollSize() {
-    return this.getContainerProperty(this.direction === "vertical" ? "scrollHeight" : "scrollWidth");
-  }
-  get containerScrollPosition() {
-    return this.getContainerProperty(this.direction === "vertical" ? "scrollTop" : "scrollLeft");
-  }
-  get direction() {
-    return this.props.direction !== void 0 ? this.props.direction : a.defaultProps.direction;
-  }
-  get scrollOffsetSize() {
-    return this.props.scrollOffsetSize !== void 0 ? this.props.scrollOffsetSize : a.defaultProps.scrollOffsetSize;
-  }
-  activeIndex() {
-    return this.itemIndex(Math.ceil(this.containerScrollPosition));
-  }
-  itemIndex(i) {
-    return this.rowHeightService ? this.rowHeightService.index(i) : 0;
-  }
-  itemOffset(i) {
-    return this.rowHeightService ? this.rowHeightService.offset(i) : 0;
-  }
-  isIndexVisible(i) {
-    if (!this.rowHeightService)
+import { classNames as K, uCalendar as D, RowHeightService as ze } from "@progress/kendo-react-common";
+import { ScrollerService as Ie } from "./services/ScrollerService.mjs";
+const Ne = (c, s, i) => Math.min(Math.abs(s - c), i), Me = 17, Ae = 10, De = {
+  1: (c) => (s) => s + c,
+  0: (c) => (s) => s - c
+}, Ce = {
+  1: (c) => (s) => Math.min(s, c),
+  0: (c) => (s) => Math.max(s, c)
+}, He = {
+  1: (c) => (s) => s < c,
+  0: (c) => (s) => s > c
+}, h = {
+  direction: "vertical",
+  scrollOffsetSize: 0,
+  maxScrollDifference: 100,
+  scrollDuration: 100
+}, C = n.forwardRef((c, s) => {
+  const {
+    direction: i = h.direction,
+    scrollOffsetSize: U = h.scrollOffsetSize,
+    maxScrollDifference: j = h.maxScrollDifference,
+    scrollDuration: G = h.scrollDuration,
+    bottomOffset: H,
+    className: J,
+    tabIndex: Q,
+    role: X,
+    children: Y,
+    unstyled: b,
+    total: S,
+    take: v,
+    skip: Z,
+    topOffset: P,
+    itemHeight: ee,
+    itemWidth: re,
+    onMount: O,
+    onScroll: L,
+    onScrollAction: q
+  } = c, T = (e) => u.current ? u.current[e] : 0, y = () => T(i === "vertical" ? "offsetHeight" : "offsetWidth"), w = () => T(i === "vertical" ? "scrollHeight" : "scrollWidth"), m = () => T(i === "vertical" ? "scrollTop" : "scrollLeft"), te = () => w() - y(), ne = (e) => e < m() ? 0 : 1, oe = (e, t) => {
+    const l = G || h.scrollDuration;
+    return Math.abs(t - e) / (l / Me);
+  }, ce = (e, t) => {
+    const l = m();
+    if (Number.parseInt(`${e}`, 10) === Number.parseInt(`${l}`, 10))
+      return { start: e, end: e };
+    const a = te(), f = t === 0 ? 1 : -1, M = Ne(l, e, j || 0), d = Math.min(e, a);
+    return { start: Math.min(Math.max(d + f * M, 0), a), end: d };
+  }, V = (e) => r.current ? r.current.index(e) : 0, se = (e) => r.current ? r.current.offset(e) : 0, le = () => V(Math.ceil(m())), ie = (e) => {
+    if (!r.current)
       return !1;
-    const t = this.containerScrollPosition, e = t + this.containerOffsetSize, r = this.rowHeightService.offset(i), n = r + this.rowHeightService.height(i);
-    return r >= t && n <= e;
-  }
-  isListScrolled(i) {
-    return this.rowHeightService ? this.containerScrollPosition !== this.rowHeightService.offset(i) : !1;
-  }
-  componentDidMount() {
-    const { onMount: i } = this.props;
-    i && i.call(void 0, this);
-  }
-  render() {
-    const { total: i, take: t, bottomOffset: e, className: r, tabIndex: n, role: l, children: f, unstyled: c } = this.props, h = c && c.uCalendar;
-    (this.lastTotal !== i || this.lastDirection !== this.direction || this.lastTake !== t) && (this.initServices(), this.lastTotal = i, this.lastDirection = this.direction, this.lastTake = t);
-    const d = `${(this.rowHeightService ? this.rowHeightService.totalHeight() : 0) + e}`, m = this.direction === "vertical" ? { height: `${d}px` } : { width: `${d}px` }, g = v(
-      p.scrollableSelector({
-        c: h
-      }),
-      p.scrollable({
-        c: h,
-        horizontal: this.direction === "horizontal"
-      }),
-      r
-    ), S = v(
-      p.scrollablePlaceholder({
-        c: h,
-        horizontal: this.direction === "horizontal"
-      })
-    );
-    return /* @__PURE__ */ u.createElement(
-      "div",
-      {
-        ref: (H) => {
-          this.scrollContainer = H;
-        },
-        onScroll: this.handleScroll,
-        className: g,
-        tabIndex: n,
-        role: l
-      },
-      f,
-      /* @__PURE__ */ u.createElement("div", { style: m, className: S })
-    );
-  }
-};
-a.propTypes = {
+    const t = m(), l = t + y(), a = r.current.offset(e), f = a + r.current.height(e);
+    return a >= t && f <= l;
+  }, ae = (e) => r.current ? m() !== r.current.offset(e) : !1, p = (e) => {
+    const t = i === "vertical" ? "scrollTop" : "scrollLeft";
+    if (!u.current)
+      return;
+    const l = u.current[t];
+    Re.current && t === "scrollTop" && (!Number.isInteger(l) || !Number.isInteger(e)) && Math.abs(l - e) < Ae || (u.current[t] = e);
+  }, ue = (e) => {
+    g.current = !1, r.current && p(r.current.offset(e));
+  }, fe = (e) => {
+    if (!r.current || !globalThis)
+      return;
+    globalThis.cancelAnimationFrame(x.current);
+    const t = r.current.offset(e), l = ne(t), { start: a, end: f } = ce(t, l);
+    if (a === f)
+      return;
+    const M = oe(a, f), d = De[l](M), _ = Ce[l](f), Te = He[l](d(f)), B = (xe) => {
+      g.current = !0;
+      const A = d(xe);
+      p(_(A)), Te(A) ? x.current = globalThis.requestAnimationFrame(() => {
+        B(A);
+      }) : g.current = !1;
+    };
+    x.current = globalThis.requestAnimationFrame(() => {
+      B(a);
+    });
+  }, me = () => {
+    r.current && p(r.current.totalHeight() + H);
+  }, de = (e) => {
+    z.current = e;
+  }, he = (e) => {
+    I.current = e;
+  }, Se = (e) => {
+    if (!u.current || !r.current)
+      return;
+    const t = e.target;
+    W.current.onScroll({
+      scrollLeft: t.scrollLeft,
+      scrollTop: t.scrollTop,
+      offsetHeight: t.offsetHeight,
+      offsetWidth: t.offsetWidth
+    });
+    const a = {
+      index: r.current.index(m() - P),
+      target: t,
+      scrollAction: z.current,
+      pageAction: I.current,
+      animationInProgress: g.current
+    };
+    L && L(e), q && q(a), z.current = void 0, I.current = void 0;
+  }, pe = () => {
+    const e = i === "vertical" ? ee : re;
+    e !== void 0 && (r.current = new ze(S, e), W.current.create(
+      r.current,
+      Z,
+      v,
+      S,
+      P,
+      U,
+      i
+    ));
+  }, R = n.useRef(null), u = n.useRef(null), W = n.useRef(new Ie(de, he)), r = n.useRef(null), x = n.useRef(0), g = n.useRef(!1), Re = n.useRef(Number.parseFloat(n.version) > 17), z = n.useRef(void 0), I = n.useRef(void 0), k = n.useRef(0), E = n.useRef(0), F = n.useRef(null);
+  n.useImperativeHandle(R, () => ({
+    element: u.current,
+    containerScrollSize: w(),
+    containerScrollPosition: m(),
+    activeIndex: le,
+    scrollTo: p,
+    scrollToIndex: ue,
+    animateToIndex: fe,
+    scrollToBottom: me,
+    isIndexVisible: ie,
+    isListScrolled: ae,
+    itemIndex: V,
+    itemOffset: se
+  })), n.useImperativeHandle(s, () => R.current), n.useEffect(() => {
+    O && R.current && O(R.current);
+  }, []);
+  const N = b == null ? void 0 : b.uCalendar;
+  (k.current !== S || F.current !== i || E.current !== v) && (pe(), k.current = S, F.current = i, E.current = v);
+  const $ = `${(r.current ? r.current.totalHeight() : 0) + H}`, ge = i === "vertical" ? { height: `${$}px` } : { width: `${$}px` }, be = K(
+    D.scrollableSelector({
+      c: N
+    }),
+    D.scrollable({
+      c: N,
+      horizontal: i === "horizontal"
+    }),
+    J
+  ), ve = K(
+    D.scrollablePlaceholder({
+      c: N,
+      horizontal: i === "horizontal"
+    })
+  );
+  return /* @__PURE__ */ n.createElement(
+    "div",
+    {
+      ref: u,
+      onScroll: Se,
+      className: be,
+      tabIndex: Q,
+      role: X
+    },
+    Y,
+    /* @__PURE__ */ n.createElement("div", { style: ge, className: ve })
+  );
+});
+C.propTypes = {
   bottomOffset: o.number.isRequired,
   className: o.string,
   direction: o.oneOf(["horizontal", "vertical"]),
-  forceScroll: o.bool,
   itemHeight: o.number,
   itemWidth: o.number,
   maxScrollDifference: o.number,
@@ -183,14 +182,10 @@ a.propTypes = {
   topOffset: o.number.isRequired,
   total: o.number.isRequired,
   role: o.string
-}, a.defaultProps = {
-  direction: "vertical",
-  forceScroll: !1,
-  scrollOffsetSize: 0,
-  maxScrollDifference: 100,
-  scrollDuration: 100
 };
-let w = a;
+C.displayName = "KendoReactVirtualization";
+const qe = C;
 export {
-  w as Virtualization
+  qe as Virtualization,
+  h as virtualizationDefaultProps
 };