@unicom-cloud/ui 0.8.108 → 0.8.110

package/slider/index.js

@@ -1,187 +1,312 @@
-import { jsx as v, jsxs as te } from "react/jsx-runtime";
-import { div as Fe, plus as Je, times as qe } from "@unicom-cloud/utils/math";
-import ne from "lodash/isArray";
-import oe from "lodash/isFunction";
-import re from "lodash/isPlainObject";
-import ze, { forwardRef as Ge, useContext as He, useRef as V, useMemo as Ke } from "react";
-import "../config-provider/ConfigProvider.js";
-import Qe from "../components/common/hooks/useMergeProps.js";
-import We from "../components/common/hooks/useMergeValue.js";
-import Ze from "../components/common/hooks/useUpdateEffect.js";
-import ae from "@unicom-cloud/utils/class-name";
-import { on as ie, off as se } from "../components/common/utils/dom.js";
-import { omit as _e } from "../components/common/utils/omit.js";
-import et from "./Button.js";
-import tt from "./Dot.js";
-import nt from "./Input.js";
-import ot from "./Mark.js";
-import rt from "./Tick.js";
-import at from "./hook/useInterval.js";
-import it from "./hook/useLegalValue.js";
-import { needSort as st, sortNumberArray as le, getIntervalOffset as E, formatPercent as y, findNearestIndex as lt } from "./util.js";
-import ut from "../config-provider/context.js";
-const ct = {
+import { jsx as L, jsxs as Ve } from "react/jsx-runtime";
+import { times as ke, plus as Z, div as ze } from "@unicom-cloud/utils/math";
+import _ from "lodash/isArray";
+import ee from "lodash/isFunction";
+import te from "lodash/isPlainObject";
+import Ge, { useMemo as ne, useCallback as T, forwardRef as He, useContext as Qe, useRef as $ } from "react";
+import { a as Ze } from "../chunk/BcEZk8pT.js";
+import { u as _e } from "../chunk/FgWHhRFz.js";
+import { u as et } from "../chunk/2vdCeheu.js";
+import { u as tt } from "../chunk/DfChiMIE.js";
+import ve from "@unicom-cloud/utils/class-name";
+import { b as be, o as we } from "../chunk/d1c9z8T1.js";
+import { o as nt } from "../chunk/BKKEev13.js";
+import ot from "./Button.js";
+import rt from "./Dot.js";
+import st from "./Input.js";
+import it from "./Mark.js";
+import at from "./Tick.js";
+import U from "lodash/isNumber";
+import { rateToFloat as lt, getPrecision as ut, needSort as ct, sortNumberArray as Ce, getIntervalOffset as Q, formatPercent as F, findNearestIndex as ft } from "./util.js";
+import { isEmptyObject as mt } from "@unicom-cloud/utils/is";
+import gt from "lodash/isUndefined";
+function pt(m) {
+  if (m.length < 2)
+    return [];
+  const y = [];
+  for (let f = 1; f < m.length; f++) {
+    const v = m[f - 1], b = m[f];
+    y.push([v, b]);
+  }
+  return y;
+}
+function dt(m) {
+  const { marks: y = {}, getIntervalConfig: f, max: v, min: b } = m, { markIntervals: g, markList: I } = ne(() => {
+    const x = Object.keys(y).filter((s) => U(+s) && +s >= b && +s <= v).sort((s, e) => +s > +e ? 1 : -1), p = x.map((s) => ({ key: s, content: y[s] }));
+    let V = x.map((s) => +s);
+    return V.length === 0 ? V = [b, v] : (V[0] > b && (V.unshift(b), p.unshift({ key: `${b}`, content: "" })), V.slice(-1)[0] < v && (V.push(v), p.push({ key: `${v}`, content: "" }))), { markIntervals: pt(V), markList: p };
+  }, [y, b, v]);
+  return {
+    intervalConfigs: ne(() => {
+      if (!ee(f))
+        return [
+          {
+            begin: b,
+            end: v,
+            step: m.step,
+            beginOffset: 0,
+            endOffset: 1,
+            width: 1
+          }
+        ];
+      const x = ([e, l], i) => {
+        const a = { step: m.step, width: 0 }, u = f([e, l], i) || {}, r = u.step, d = lt(u.width);
+        return U(r) && r && (a.step = r), U(d) && d && (a.width = d), a;
+      };
+      let p = 1, V = v - b;
+      const w = g.map(([e, l], i) => {
+        const a = x([e, l], i);
+        let u = a.width;
+        if (u) {
+          u = Math.min(p, u);
+          const r = l - e;
+          V -= r, p -= u;
+        }
+        return { width: u, step: a.step };
+      });
+      if (w.every(({ width: e }) => e) && p) {
+        const e = w[g.length - 1];
+        e.width += p;
+      }
+      const s = [];
+      return g.forEach(([e, l], i) => {
+        const { step: a, width: u } = w[i], r = {
+          begin: e,
+          end: l,
+          step: a,
+          beginOffset: 0,
+          endOffset: 0,
+          width: u
+        };
+        r.width || (r.width = p * ((l - e) / V));
+        const d = s.length - 1;
+        s[d] && (r.beginOffset = s[d].endOffset), r.endOffset = Math.min(1, r.beginOffset + r.width), s.push(r);
+      }), s;
+    }, [f, g, v, b, m.step]),
+    markList: I
+  };
+}
+function ht(m) {
+  const { isRange: y, min: f, max: v, onlyMarkValue: b, intervalConfigs: g, marks: I } = m, B = T(
+    (e) => {
+      const l = g.find((i) => e >= i.begin && e <= i.end);
+      if (l) {
+        const { begin: i, step: a } = l, u = e - i, r = Math.round(u / a), d = ut(a), A = parseFloat(
+          ke(a, r).toFixed(d)
+        );
+        return Z(i, A);
+      }
+      return e;
+    },
+    [g]
+  ), x = T(
+    (e) => {
+      if (!te(I) || mt(I))
+        return console.warn("marks must be an object when onlyMarkValue is true"), f;
+      if (I[e])
+        return e;
+      const l = Object.keys(I), i = l.map((u) => Math.abs(e - parseFloat(u))), a = i.indexOf(Math.min.apply(null, i));
+      return parseFloat(l[a]);
+    },
+    [I, f]
+  ), p = T(
+    (e) => gt(e) || e <= f ? f : e >= v ? v : b ? x(e) : B(e),
+    [x, B, v, f, b]
+  ), V = T(
+    (e) => p(e) === e,
+    [p]
+  ), w = T(
+    (e) => {
+      let [l, i] = [f, f];
+      if (y) {
+        if (_(e))
+          return l = p(e[0]), e.map((a, u, r) => p(a));
+        console.error("value must be an array when range is true");
+      } else U(e) ? i = p(e) : console.error("value must be a number when range is false");
+      return [l, i];
+    },
+    [p, y, f]
+  ), s = T(
+    (e, l) => {
+      const i = l === "subtraction" ? -1 : 1;
+      let a = Z(e, i * m.step);
+      if (m.onlyMarkValue) {
+        const u = Object.keys(m.marks), r = u.findIndex((d) => Number(d) === e);
+        a = u[r + i] !== void 0 ? Number(u[r + i]) : e;
+      }
+      return a;
+    },
+    [m.marks, m.onlyMarkValue, m.step]
+  );
+  return {
+    getLegalRangeValue: w,
+    getLegalValue: p,
+    isLegalValue: V,
+    getNextMarkValue: s
+  };
+}
+const Vt = {
   max: 100,
   min: 0,
   step: 1
 };
-function ft(ce, fe) {
-  const { getPrefixCls: me, componentConfig: pe, rtl: L } = He(ut), l = Qe(
-    ce,
-    ct,
-    pe?.Slider
+function vt(m, y) {
+  const { getPrefixCls: f, componentConfig: v, rtl: b } = Qe(Ze), g = _e(
+    m,
+    Vt,
+    v?.Slider
   ), {
-    className: ge,
-    style: de,
-    tooltipVisible: ve,
-    tooltipPosition: he,
-    disabled: C,
-    min: f,
-    max: w,
-    range: I,
-    step: P,
-    showTicks: Ve,
-    marks: R,
-    onlyMarkValue: j,
-    vertical: u,
-    showInput: m,
-    reverse: U,
-    getIntervalConfig: Ce,
-    ...we
-  } = l, p = !!I, Me = re(I) ? { ...I } : { draggableBar: !1 }, s = L ? !U : U, { intervalConfigs: g, markList: X } = at({
-    min: f,
-    max: w,
-    step: P,
-    marks: R,
-    getIntervalConfig: Ce
-  }), { getLegalValue: b, getLegalRangeValue: N, isLegalValue: be, getNextMarkValue: xe } = it({
-    isRange: p,
-    min: f,
-    max: w,
-    onlyMarkValue: j,
-    step: P,
-    intervalConfigs: g,
-    marks: R
-  }), [k, ye] = We(
-    p ? [f, f] : f,
+    className: I,
+    style: B,
+    tooltipVisible: x,
+    tooltipPosition: p,
+    disabled: V,
+    min: w,
+    max: s,
+    range: e,
+    step: l,
+    showTicks: i,
+    marks: a,
+    onlyMarkValue: u,
+    vertical: r,
+    showInput: d,
+    reverse: A,
+    getIntervalConfig: ye,
+    ...Ie
+  } = g, P = !!e, xe = te(e) ? { ...e } : { draggableBar: !1 }, M = b ? !A : A, { intervalConfigs: N, markList: oe } = dt({
+    min: w,
+    max: s,
+    step: l,
+    marks: a,
+    getIntervalConfig: ye
+  }), { getLegalValue: E, getLegalRangeValue: W, isLegalValue: Oe, getNextMarkValue: Pe } = ht({
+    isRange: P,
+    min: w,
+    max: s,
+    onlyMarkValue: u,
+    step: l,
+    intervalConfigs: N,
+    marks: a
+  }), [K, Ne] = et(
+    P ? [w, w] : w,
     {
-      defaultValue: l.defaultValue,
-      value: l.value
+      defaultValue: g.defaultValue,
+      value: g.value
     }
   );
-  let o = N(k);
-  const B = V(o), O = V(st(o));
-  Ze(() => {
-    B.current = N(k);
-  }, [k, N]), O.current && (o = le(o));
-  const S = o[o.length - 1], T = o[0], $ = m && !j && (!p || o.length < 3), Ie = Ke(() => $ && (ne(m) || re(m)) ? ne(m) ? [...m] : [{ ...m }, { ...m }] : [], [$, m]), a = me?.("slider"), Y = V(null), F = V({
+  let c = W(K);
+  const X = $(c), Y = $(ct(c));
+  tt(() => {
+    X.current = W(K);
+  }, [K, W]), Y.current && (c = Ce(c));
+  const J = c[c.length - 1], q = c[0], z = d && !u && (!P || c.length < 3), Re = ne(() => z && (_(d) || te(d)) ? _(d) ? [...d] : [{ ...d }, { ...d }] : [], [z, d]), C = f?.("slider"), re = $(null), se = $({
     left: 0,
     height: 0,
     top: 0,
     width: 0
-  }), J = V(!1), q = V(0);
-  function z(t) {
-    const e = le(t);
-    return p ? e : e[e.length - 1];
+  }), ie = $(!1), ae = $(0);
+  function le(n) {
+    const t = Ce(n);
+    return P ? t : t[t.length - 1];
   }
-  function Pe(t) {
-    const e = t.map((n) => b(n));
-    return B.current = e, e;
+  function Le(n) {
+    const t = n.map((o) => E(o));
+    return X.current = t, t;
   }
-  function h(t, e) {
-    const n = Pe(t), r = z(n);
-    ye(r), e === "inputValueChange" ? O.current = n.some((i, d) => i > n[d]) : O.current = !1, oe(l.onChange) && l.onChange(r);
+  function S(n, t) {
+    const o = Le(n), h = le(o);
+    Ne(h), t === "inputValueChange" ? Y.current = o.some((k, R) => k > o[R]) : Y.current = !1, ee(g.onChange) && g.onChange(h);
   }
-  function x() {
-    if (oe(l.onAfterChange)) {
-      const t = z(B.current);
-      l.onAfterChange(t);
+  function D() {
+    if (ee(g.onAfterChange)) {
+      const n = le(X.current);
+      g.onAfterChange(n);
     }
   }
-  function Re(t) {
-    let [e, n] = [o[0], o[o.length - 1]];
-    return e > n && ([e, n] = [n, e]), p ? t >= e && t <= n : t <= n;
+  function Se(n) {
+    let [t, o] = [c[0], c[c.length - 1]];
+    return t > o && ([t, o] = [o, t]), P ? n >= t && n <= o : n <= o;
   }
-  function A(t, e) {
-    const { left: n, top: r, width: i, height: d } = F.current;
-    let c = i, Q = s ? n + i - t : t - n;
-    if (u && (c = d, Q = s ? e - r : r + d - e), c <= 0)
+  function G(n, t) {
+    const { left: o, top: h, width: k, height: R } = se.current;
+    let O = k, me = M ? o + k - n : n - o;
+    if (r && (O = R, me = M ? t - h : h + R - t), O <= 0)
       return 0;
-    let M = Math.max(Fe(Q, c), 0);
-    M = Math.min(1, M);
-    const De = g.find((ee) => M >= ee.beginOffset && M <= ee.endOffset), {
-      begin: W,
-      beginOffset: Z,
-      step: _,
-      endOffset: Ee,
-      end: Le
-    } = De, je = M - Z, Ue = Ee - Z, Xe = je / Ue * (Le - W), Ye = Math.round(Xe / _);
-    return Je(W, qe(Ye, _));
+    let j = Math.max(ze(me, O), 0);
+    j = Math.min(1, j);
+    const Ue = N.find((he) => j >= he.beginOffset && j <= he.endOffset), {
+      begin: ge,
+      beginOffset: pe,
+      step: de,
+      endOffset: We,
+      end: Ke
+    } = Ue, Xe = j - pe, Ye = We - pe, Je = Xe / Ye * (Ke - ge), qe = Math.round(Je / de);
+    return Z(ge, ke(qe, de));
   }
-  function Ne(t) {
-    let [e, n] = t;
-    e > n && ([e, n] = [n, e]);
-    const r = y(e), i = y(1 - n);
-    return u ? {
-      [s ? "top" : "bottom"]: r,
-      [s ? "bottom" : "top"]: i
+  function Te(n) {
+    let [t, o] = n;
+    t > o && ([t, o] = [o, t]);
+    const h = F(t), k = F(1 - o);
+    return r ? {
+      [M ? "top" : "bottom"]: h,
+      [M ? "bottom" : "top"]: k
     } : {
-      [s ? "right" : "left"]: r,
-      [s ? "left" : "right"]: i
+      [M ? "right" : "left"]: h,
+      [M ? "left" : "right"]: k
     };
   }
-  function ke(t) {
-    return u ? { [s ? "top" : "bottom"]: y(t) } : { [s ? "right" : "left"]: y(t) };
+  function $e(n) {
+    return r ? { [M ? "top" : "bottom"]: F(n) } : { [M ? "right" : "left"]: F(n) };
   }
   function Be() {
-    const t = {
-      getTooltipContainer: l.getTooltipContainer,
-      formatTooltip: l.formatTooltip
+    const n = {
+      getTooltipContainer: g.getTooltipContainer,
+      formatTooltip: g.formatTooltip
     };
-    return "tooltipPosition" in l && (t.tooltipPosition = he), "tooltipVisible" in l && (t.tooltipVisible = ve), t;
+    return "tooltipPosition" in g && (n.tooltipPosition = p), "tooltipVisible" in g && (n.tooltipVisible = x), n;
   }
-  function G() {
-    F.current = Y.current.getBoundingClientRect();
+  function ue() {
+    se.current = re.current.getBoundingClientRect();
   }
-  function Oe(t) {
-    G();
-    const e = A(t.clientX, t.clientY);
-    Me.draggableBar && Re(e) ? (q.current = b(e), ie(window, "mousemove", H), ie(window, "mouseup", K)) : D(e);
+  function je(n) {
+    ue();
+    const t = G(n.clientX, n.clientY);
+    xe.draggableBar && Se(t) ? (ae.current = E(t), be(window, "mousemove", ce), be(window, "mouseup", fe)) : H(t);
   }
-  function D(t) {
-    if (C)
+  function H(n) {
+    if (V)
       return;
-    const e = b(t), [n, r] = lt(e, o), i = o[n], d = o[r], c = o.slice(0);
-    p && d - e > e - i ? (c[n] = e, h(c, "jumpToClick")) : (c[r] = e, h(c, "jumpToClick")), x();
+    const t = E(n), [o, h] = ft(t, c), k = c[o], R = c[h], O = c.slice(0);
+    P && R - t > t - k ? (O[o] = t, S(O, "jumpToClick")) : (O[h] = t, S(O, "jumpToClick")), D();
   }
-  function Se(t) {
-    h(t, "inputValueChange"), x();
+  function Ae(n) {
+    S(n, "inputValueChange"), D();
   }
-  function Te(t, e, n) {
-    J.current = !0;
-    const r = o.slice(0);
-    r[n] = A(t, e), h(r, "mousemove");
+  function Ee(n, t, o) {
+    ie.current = !0;
+    const h = c.slice(0);
+    h[o] = G(n, t), S(h, "mousemove");
   }
-  function $e() {
-    J.current = !1, x();
+  function De() {
+    ie.current = !1, D();
   }
-  function Ae(t, e) {
-    if (C)
+  function Fe(n, t) {
+    if (V)
       return;
-    const n = o.slice(0);
-    n[e] = xe(o[e], t), h(n);
+    const o = c.slice(0);
+    o[t] = Pe(c[t], n), S(o);
   }
-  function H(t) {
-    const n = b(A(t.clientX, t.clientY)) - q.current, r = o.map((i) => i + n);
-    r.every((i, d, c) => be(i)) && h(r, "mousemove");
+  function ce(n) {
+    const o = E(G(n.clientX, n.clientY)) - ae.current, h = c.map((k) => k + o);
+    h.every((k, R, O) => Oe(k)) && S(h, "mousemove");
   }
-  function K() {
-    se(window, "mousemove", H), se(window, "mouseup", K), x();
+  function fe() {
+    we(window, "mousemove", ce), we(window, "mouseup", fe), D();
   }
-  return /* @__PURE__ */ v(
+  return /* @__PURE__ */ L(
     "div",
     {
-      ..._e(we, [
+      ...nt(Ie, [
         "defaultValue",
         "value",
         "onChange",
@@ -189,116 +314,116 @@ function ft(ce, fe) {
         "formatTooltip",
         "onAfterChange"
       ]),
-      className: ae(
-        a,
+      className: ve(
+        C,
         {
-          [`${a}-vertical`]: u,
-          [`${a}-with-marks`]: R,
-          [`${a}-reverse`]: s,
-          [`${a}-rtl`]: L
+          [`${C}-vertical`]: r,
+          [`${C}-with-marks`]: a,
+          [`${C}-reverse`]: M,
+          [`${C}-rtl`]: b
         },
-        ge
+        I
       ),
-      style: de,
-      ref: fe,
-      children: /* @__PURE__ */ te("div", { className: `${a}-wrapper`, children: [
-        /* @__PURE__ */ te(
+      style: B,
+      ref: y,
+      children: /* @__PURE__ */ Ve("div", { className: `${C}-wrapper`, children: [
+        /* @__PURE__ */ Ve(
           "div",
           {
-            ref: Y,
-            className: ae(`${a}-road`, {
-              [`${a}-road-disabled`]: C,
-              [`${a}-road-vertical`]: u
+            ref: re,
+            className: ve(`${C}-road`, {
+              [`${C}-road-disabled`]: V,
+              [`${C}-road-vertical`]: r
             }),
-            onMouseDown: Oe,
+            onMouseDown: je,
             children: [
-              /* @__PURE__ */ v(
+              /* @__PURE__ */ L(
                 "div",
                 {
-                  className: `${a}-bar`,
-                  style: Ne([
-                    E(T, g),
-                    E(S, g)
+                  className: `${C}-bar`,
+                  style: Te([
+                    Q(q, N),
+                    Q(J, N)
                   ])
                 }
               ),
-              Ve && /* @__PURE__ */ v(
-                rt,
+              i && /* @__PURE__ */ L(
+                at,
                 {
-                  intervalConfigs: g,
-                  min: f,
-                  max: w,
-                  valueRange: [T, S],
-                  prefixCls: a,
-                  vertical: u,
-                  reverse: s
+                  intervalConfigs: N,
+                  min: w,
+                  max: s,
+                  valueRange: [q, J],
+                  prefixCls: C,
+                  vertical: r,
+                  reverse: M
                 }
               ),
-              /* @__PURE__ */ v(
-                tt,
+              /* @__PURE__ */ L(
+                rt,
                 {
-                  data: X,
-                  intervalConfigs: g,
-                  valueRange: [T, S],
-                  vertical: u,
-                  prefixCls: a,
-                  reverse: s,
-                  onMouseDown: D
+                  data: oe,
+                  intervalConfigs: N,
+                  valueRange: [q, J],
+                  vertical: r,
+                  prefixCls: C,
+                  reverse: M,
+                  onMouseDown: H
                 }
               ),
-              /* @__PURE__ */ v(
-                ot,
+              /* @__PURE__ */ L(
+                it,
                 {
-                  data: X,
-                  intervalConfigs: g,
-                  vertical: u,
-                  prefixCls: a,
-                  reverse: s,
-                  onMouseDown: D
+                  data: oe,
+                  intervalConfigs: N,
+                  vertical: r,
+                  prefixCls: C,
+                  reverse: M,
+                  onMouseDown: H
                 }
               ),
-              o.map((t, e) => !p && e !== o.length - 1 ? null : /* @__PURE__ */ v(
-                et,
+              c.map((n, t) => !P && t !== c.length - 1 ? null : /* @__PURE__ */ L(
+                ot,
                 {
-                  style: ke(E(t, g)),
-                  disabled: C,
-                  prefixCls: a,
-                  value: t,
-                  maxValue: w,
-                  minValue: f,
-                  vertical: u,
+                  style: $e(Q(n, N)),
+                  disabled: V,
+                  prefixCls: C,
+                  value: n,
+                  maxValue: s,
+                  minValue: w,
+                  vertical: r,
                   ...Be(),
-                  onMoveBegin: G,
-                  onMoving: (n, r) => Te(n, r, e),
-                  onMoveEnd: $e,
-                  onArrowEvent: (n) => Ae(n, e)
+                  onMoveBegin: ue,
+                  onMoving: (o, h) => Ee(o, h, t),
+                  onMoveEnd: De,
+                  onArrowEvent: (o) => Fe(o, t)
                 },
-                e
+                t
               ))
             ]
           }
         ),
-        $ && /* @__PURE__ */ v(
-          nt,
+        z && /* @__PURE__ */ L(
+          st,
           {
-            min: f,
-            max: w,
-            step: P,
-            value: o,
-            range: p,
-            disabled: C,
-            prefixCls: a,
-            onChange: Se,
-            extra: Ie
+            min: w,
+            max: s,
+            step: l,
+            value: c,
+            range: P,
+            disabled: V,
+            prefixCls: C,
+            onChange: Ae,
+            extra: Re
           }
         )
       ] })
     }
   );
 }
-const ue = Ge(ft);
-ue.displayName = "Slider";
-const $t = ze.memo(ue);
+const Me = He(vt);
+Me.displayName = "Slider";
+const Ut = Ge.memo(Me);
 export {
-  $t as default
+  Ut as default
 };