@unicom-cloud/ui 0.8.44 → 0.8.46

package/slider/Input.js

@@ -0,0 +1,75 @@
+import { jsxs as y, jsx as h } from "react/jsx-runtime";
+import B, { useState as V, useEffect as R, createElement as N } from "react";
+import d from "../InputNumber.js";
+import S from "@unicom-cloud/utils/class-name";
+const b = function(C) {
+  const {
+    value: u,
+    range: i,
+    min: g,
+    max: $,
+    step: I,
+    disabled: j,
+    prefixCls: a,
+    onChange: m,
+    extra: r = []
+  } = C, l = {
+    min: g,
+    max: $,
+    step: I,
+    disabled: j
+  }, [c, p] = V(u), n = r[0], t = i ? r[1] : r[0];
+  R(() => {
+    p(u);
+  }, [u]);
+  const f = (e) => {
+    m == null || m(e);
+  }, k = () => {
+    p([...u].sort((e, o) => e - o));
+  };
+  return /* @__PURE__ */ y(
+    "div",
+    {
+      className: S(`${a}-input`, {
+        [`${a}-input-group`]: i
+      }),
+      onBlur: k,
+      children: [
+        i && [
+          /* @__PURE__ */ N(
+            d,
+            {
+              hideControl: !0,
+              ...n,
+              ...l,
+              value: c[0],
+              key: 0,
+              onChange: (e, o) => {
+                var s;
+                isNaN(e) && e !== e || (f([e, c[1]]), (s = n == null ? void 0 : n.onChange) == null || s.call(n, e, o));
+              }
+            }
+          ),
+          /* @__PURE__ */ h("div", { className: `${a}-input-range`, children: /* @__PURE__ */ h("span", { className: `${a}-input-range-content` }) }, 1)
+        ],
+        /* @__PURE__ */ N(
+          d,
+          {
+            hideControl: !0,
+            ...t,
+            ...l,
+            key: 2,
+            value: c[1],
+            onChange: (e, o) => {
+              var s;
+              isNaN(e) && e !== e || (f([c[0], e]), (s = t == null ? void 0 : t.onChange) == null || s.call(t, e, o));
+            }
+          }
+        )
+      ]
+    }
+  );
+}, A = B.memo(b);
+export {
+  A as default
+};

package/slider/Mark.js

@@ -0,0 +1,28 @@
+import { jsx as l } from "react/jsx-runtime";
+import d from "lodash/isFunction";
+import p from "lodash/isPlainObject";
+import v from "react";
+import { formatPercent as x, getIntervalOffset as g, isNotEmpty as i } from "./util.js";
+const h = function(e) {
+  const { data: s = [], vertical: f, prefixCls: a, reverse: m, intervalConfigs: u } = e;
+  return s.length ? /* @__PURE__ */ l("div", { className: `${a}-marks`, children: s.map(({ key: o, content: t }) => {
+    const n = x(g(+o, u));
+    let r = null;
+    return p(t) && i(t.text) ? r = t.text : i(t) && (r = t), i(r) && /* @__PURE__ */ l(
+      "div",
+      {
+        className: `${a}-marks-text`,
+        "aria-hidden": !0,
+        style: f ? { [m ? "top" : "bottom"]: n } : { [m ? "right" : "left"]: n },
+        onMouseDown: (c) => {
+          c.stopPropagation(), d(e.onMouseDown) && e.onMouseDown(parseFloat(o));
+        },
+        children: r
+      },
+      o
+    );
+  }) }) : null;
+}, b = v.memo(h);
+export {
+  b as default
+};

package/slider/Tick.js

@@ -0,0 +1,44 @@
+import { jsx as i } from "react/jsx-runtime";
+import { plus as M } from "@unicom-cloud/utils/math";
+import A, { useMemo as N } from "react";
+import R from "@unicom-cloud/utils/class-name";
+import { formatPercent as $, getIntervalOffset as b, valueInRange as y } from "./util.js";
+function I(p) {
+  const {
+    min: l,
+    max: u,
+    valueRange: v,
+    prefixCls: r,
+    vertical: d,
+    reverse: n,
+    intervalConfigs: e
+  } = p, c = /* @__PURE__ */ new Map(), h = (t) => {
+    const { step: s, begin: f, end: g } = t, x = Math.floor((g - f) / s);
+    for (let a = 0; a <= x; a++) {
+      const o = M(a * s, f);
+      if (o <= l || o >= u) continue;
+      const m = $(b(o, e));
+      c.set(m, {
+        offset: m,
+        isActive: y(o, v)
+      });
+    }
+  }, k = N(() => {
+    var t;
+    return c.clear(), (t = e == null ? void 0 : e.forEach) == null || t.call(e, (s) => h(s)), Array.from(c.values());
+  }, [e]);
+  return /* @__PURE__ */ i("div", { className: `${r}-ticks`, children: k.map((t, s) => /* @__PURE__ */ i(
+    "div",
+    {
+      className: R(`${r}-tick`, {
+        [`${r}-tick-active`]: t.isActive
+      }),
+      style: d ? { [n ? "top" : "bottom"]: t.offset } : { [n ? "right" : "left"]: t.offset }
+    },
+    s
+  )) });
+}
+const O = A.memo(I);
+export {
+  O as default
+};

package/slider/hook/useInterval.js

@@ -0,0 +1,73 @@
+import O from "lodash/isFunction";
+import w from "lodash/isNumber";
+import { useMemo as k } from "react";
+import { rateToFloat as C } from "../util.js";
+function b(f) {
+  if (f.length < 2)
+    return [];
+  const m = [];
+  for (let c = 1; c < f.length; c++) {
+    const s = f[c - 1], i = f[c];
+    m.push([s, i]);
+  }
+  return m;
+}
+function y(f) {
+  const { marks: m = {}, getIntervalConfig: c, max: s, min: i } = f, { markIntervals: p, markList: I } = k(() => {
+    const u = Object.keys(m).filter((t) => w(+t) && +t >= i && +t <= s).sort((t, e) => +t > +e ? 1 : -1), a = u.map((t) => ({ key: t, content: m[t] }));
+    let r = u.map((t) => +t);
+    return r.length === 0 ? r = [i, s] : (r[0] > i && (r.unshift(i), a.unshift({ key: `${i}`, content: "" })), r.slice(-1)[0] < s && (r.push(s), a.push({ key: `${s}`, content: "" }))), { markIntervals: b(r), markList: a };
+  }, [m, i, s]);
+  return {
+    intervalConfigs: k(() => {
+      if (!O(c))
+        return [
+          {
+            begin: i,
+            end: s,
+            step: f.step,
+            beginOffset: 0,
+            endOffset: 1,
+            width: 1
+          }
+        ];
+      const u = ([e, h], g) => {
+        const l = { step: f.step, width: 0 }, o = c([e, h], g) || {}, n = o.step, d = C(o.width);
+        return w(n) && n && (l.step = n), w(d) && d && (l.width = d), l;
+      };
+      let a = 1, r = s - i;
+      const v = p.map(([e, h], g) => {
+        const l = u([e, h], g);
+        let o = l.width;
+        if (o) {
+          o = Math.min(a, o);
+          const n = h - e;
+          r -= n, a -= o;
+        }
+        return { width: o, step: l.step };
+      });
+      if (v.every(({ width: e }) => e) && a) {
+        const e = v[p.length - 1];
+        e.width += a;
+      }
+      const t = [];
+      return p.forEach(([e, h], g) => {
+        const { step: l, width: o } = v[g], n = {
+          begin: e,
+          end: h,
+          step: l,
+          beginOffset: 0,
+          endOffset: 0,
+          width: o
+        };
+        n.width || (n.width = a * ((h - e) / r));
+        const d = t.length - 1;
+        t[d] && (n.beginOffset = t[d].endOffset), n.endOffset = Math.min(1, n.beginOffset + n.width), t.push(n);
+      }), t;
+    }, [c, p, s, i, f.step]),
+    markList: I
+  };
+}
+export {
+  y as default
+};

package/slider/hook/useLegalValue.js

@@ -0,0 +1,70 @@
+import { isEmptyObject as j } from "@unicom-cloud/utils/is";
+import { times as w, plus as y } from "@unicom-cloud/utils/math";
+import N from "lodash/isArray";
+import O from "lodash/isNumber";
+import F from "lodash/isPlainObject";
+import I from "lodash/isUndefined";
+import { useCallback as u } from "react";
+import { getPrecision as L } from "../util.js";
+function z(i) {
+  const { isRange: b, min: s, max: l, onlyMarkValue: g, intervalConfigs: d, marks: m } = i, k = u(
+    (e) => {
+      const t = d.find((r) => e >= r.begin && e <= r.end);
+      if (t) {
+        const { begin: r, step: n } = t, a = e - r, c = Math.round(a / n), f = L(n), h = parseFloat(
+          w(n, c).toFixed(f)
+        );
+        return y(r, h);
+      }
+      return e;
+    },
+    [d]
+  ), V = u(
+    (e) => {
+      if (!F(m) || j(m))
+        return console.warn("marks must be an object when onlyMarkValue is true"), s;
+      if (m[e])
+        return e;
+      const t = Object.keys(m), r = t.map((a) => Math.abs(e - parseFloat(a))), n = r.indexOf(Math.min.apply(null, r));
+      return parseFloat(t[n]);
+    },
+    [m, s]
+  ), o = u(
+    (e) => I(e) || e <= s ? s : e >= l ? l : g ? V(e) : k(e),
+    [V, k, l, s, g]
+  ), p = u(
+    (e) => o(e) === e,
+    [o]
+  ), M = u(
+    (e) => {
+      let [t, r] = [s, s];
+      if (b) {
+        if (N(e))
+          return t = o(e[0]), e.map((n) => o(n));
+        console.error("value must be an array when range is true");
+      } else O(e) ? r = o(e) : console.error("value must be a number when range is false");
+      return [t, r];
+    },
+    [o, b, s]
+  ), x = u(
+    (e, t) => {
+      const r = t === "subtraction" ? -1 : 1;
+      let n = y(e, r * i.step);
+      if (i.onlyMarkValue) {
+        const a = Object.keys(i.marks), c = a.findIndex((f) => Number(f) === e);
+        n = a[c + r] !== void 0 ? Number(a[c + r]) : e;
+      }
+      return n;
+    },
+    [i.marks, i.onlyMarkValue, i.step]
+  );
+  return {
+    getLegalRangeValue: M,
+    getLegalValue: o,
+    isLegalValue: p,
+    getNextMarkValue: x
+  };
+}
+export {
+  z as default
+};

package/slider/util.js

@@ -0,0 +1,63 @@
+import { minus as i, times as d, plus as m, divide as l } from "@unicom-cloud/utils/math";
+function I(t) {
+  const n = `${t}`.split(".")[1];
+  return n && n.length || 0;
+}
+function O(t) {
+  return `${t * 100}%`;
+}
+function x(t, n) {
+  const e = Number(t);
+  if (n && !isNaN(e)) {
+    const [r, o] = n;
+    return l(i(e, r), i(o, r));
+  }
+  return 0;
+}
+function b(t, n) {
+  const e = Number(t);
+  return n.sort((r, o) => r - o), e >= n[0] && e <= n[1];
+}
+function g(t) {
+  return t || t === 0;
+}
+function v(t) {
+  const n = parseFloat(t), e = n > 1 ? (n / 100).toFixed(2) : n, r = parseFloat(e);
+  if (!isNaN(r) && r >= 0 && r <= 1)
+    return r;
+}
+function h(t, n) {
+  const e = n.find(
+    (r) => t >= r.begin && t <= r.end
+  );
+  if (e) {
+    const { beginOffset: r, begin: o, end: s, endOffset: f } = e, c = x(t, [o, s]), u = i(f, r), a = d(c, u);
+    return m(r, a);
+  }
+}
+function N(t) {
+  const n = t.slice(0);
+  return n.sort((e, r) => e - r), n;
+}
+function F(t) {
+  return t.some((n, e) => n > t[e + 1]);
+}
+function R(t, n) {
+  let e = n.indexOf(t);
+  return e === -1 ? (e = N(n.concat(t)).indexOf(t), [
+    Math.max(e - 1, 0),
+    Math.min(e, n.length - 1)
+  ]) : [e, e + 1];
+}
+export {
+  R as findNearestIndex,
+  O as formatPercent,
+  h as getIntervalOffset,
+  x as getOffset,
+  I as getPrecision,
+  g as isNotEmpty,
+  F as needSort,
+  v as rateToFloat,
+  N as sortNumberArray,
+  b as valueInRange
+};

package/space/toArray.js

@@ -0,0 +1,11 @@
+import e from "react";
+import { isFragment as n } from "react-is";
+function p(t) {
+  let o = [];
+  return e.Children.forEach(t, (r) => {
+    n(r) && r.props ? o = o.concat(p(r.props.children)) : r != null && o.push(r);
+  }), o;
+}
+export {
+  p as default
+};

package/spin/DotLoading.js

@@ -0,0 +1,26 @@
+import { jsx as s } from "react/jsx-runtime";
+import m from "lodash/isNumber";
+import { useContext as a } from "react";
+/* empty css                  */
+import "../config-provider/ConfigProvider.js";
+import { ConfigContext as l } from "../config-provider/context.js";
+function z(t) {
+  const { getPrefixCls: r } = a(l), i = `${r("spin")}-dot`, o = {
+    width: t.size,
+    height: t.size
+  }, e = t.size ? parseInt(String(t.size)) : 0;
+  return /* @__PURE__ */ s(
+    "div",
+    {
+      className: `${i}-list`,
+      style: {
+        height: t.size,
+        width: m(e) && e > 0 ? e * 7 : ""
+      },
+      children: [...new Array(5)].map((d, n) => /* @__PURE__ */ s("div", { className: i, style: o }, n))
+    }
+  );
+}
+export {
+  z as default
+};

package/statistic/Countdown.js

@@ -0,0 +1,57 @@
+import { jsxs as M, jsx as r } from "react/jsx-runtime";
+import T from "dayjs";
+import _ from "lodash/isFunction";
+import { forwardRef as E, useContext as F, useState as d, useRef as O, useEffect as P } from "react";
+/* empty css                  */
+import "../config-provider/ConfigProvider.js";
+import b from "@unicom-cloud/utils/class-name";
+import { getDayjsValue as v, getNow as w } from "../utils/dayjs.js";
+import { getDateString as p } from "./util.js";
+import { ConfigContext as k } from "../config-provider/context.js";
+function q(n, N) {
+  const { getPrefixCls: h } = F(k), {
+    className: x,
+    style: C,
+    title: i,
+    styleValue: g,
+    value: y,
+    onFinish: a,
+    renderFormat: l,
+    format: e = "HH:mm:ss",
+    start: D = !0
+  } = n, o = v(y, e) || T(), S = v(n.now, e), t = h("statistic"), [c, $] = d(
+    o.diff(S, "millisecond")
+  ), [m, j] = d(
+    p(Math.max(c, 0), e)
+  ), s = O(null), f = () => {
+    clearInterval(s.current), s.current = null;
+  }, V = () => {
+    s.current = setInterval(() => {
+      const H = o.diff(w()), u = o.diff(w(), "millisecond");
+      u <= 0 && (f(), a == null || a());
+      const I = p(Math.max(u, 0), e);
+      j(I), $(H);
+    }, 1e3 / 30);
+  };
+  P(() => (!s.current && D && o.valueOf() >= Date.now() && V(), () => {
+    f();
+  }), [n.start]);
+  const R = _(l) ? l(c, m) : m;
+  return /* @__PURE__ */ M(
+    "div",
+    {
+      ref: N,
+      className: b(`${t}`, `${t}-countdown`, x),
+      style: C,
+      children: [
+        i && /* @__PURE__ */ r("div", { className: `${t}-title`, children: i }),
+        /* @__PURE__ */ r("div", { className: `${t}-content`, children: /* @__PURE__ */ r("div", { className: `${t}-value`, style: g, children: R }) })
+      ]
+    }
+  );
+}
+const z = E(q);
+z.displayName = "StatisticCountdown";
+export {
+  z as default
+};

package/statistic/util.js

@@ -0,0 +1,33 @@
+import { padStart as s } from "../utils/pad.js";
+const a = [
+  ["Y", 1e3 * 60 * 60 * 24 * 365],
+  // years
+  ["M", 1e3 * 60 * 60 * 24 * 30],
+  // months
+  ["D", 1e3 * 60 * 60 * 24],
+  // days
+  ["H", 1e3 * 60 * 60],
+  // hours
+  ["m", 1e3 * 60],
+  // minutes
+  ["s", 1e3],
+  // seconds
+  ["S", 1]
+  // million seconds
+];
+function p(l, i) {
+  let t = l;
+  return a.reduce((e, [n, r]) => {
+    if (e.indexOf(n) !== -1) {
+      const o = Math.floor(t / r);
+      return t -= o * r, e.replace(new RegExp(`${n}+`, "g"), (f) => {
+        const g = f.length;
+        return s(o.toString(), g, "0");
+      });
+    }
+    return e;
+  }, i);
+}
+export {
+  p as getDateString
+};

package/steps/Step.js

@@ -0,0 +1,68 @@
+import { jsxs as h, jsx as s } from "react/jsx-runtime";
+import R from "@unicom-cloud/icons/IconUiCheck";
+import W from "@unicom-cloud/icons/IconUiClose";
+import { forwardRef as q } from "react";
+import z from "@unicom-cloud/utils/class-name";
+function A(x, S) {
+  const {
+    style: C,
+    className: b,
+    prefixCls: e,
+    index: i = 1,
+    current: o = 1,
+    status: d,
+    title: f,
+    description: r,
+    icon: l,
+    nextStepError: w,
+    type: p,
+    customDot: N,
+    labelPlacement: y,
+    disabled: u,
+    onClick: a,
+    onChange: m,
+    direction: I,
+    id: $,
+    lineless: j
+  } = x;
+  function k(c) {
+    if (p === "dot")
+      return null;
+    let n = i;
+    return l ? n = l : c === "finish" ? n = /* @__PURE__ */ s(R, {}) : c === "error" && (n = /* @__PURE__ */ s(W, {})), /* @__PURE__ */ s("div", { className: `${e}-icon`, children: n });
+  }
+  function D(c) {
+    u || (o !== i && (m == null || m(i, $)), a == null || a(i, $, c));
+  }
+  let t;
+  d ? t = d : (o < i && (t = "wait"), o === i && (t = "process"), o > i && (t = "finish"));
+  const E = z(
+    `${e}-item`,
+    `${e}-item-${t}`,
+    {
+      [`${e}-item-custom`]: !!l,
+      [`${e}-item-next-error`]: w,
+      [`${e}-item-disabled`]: u,
+      [`${e}-item-active`]: i === o
+    },
+    b
+  ), U = k(t), v = /* @__PURE__ */ s("div", { className: `${e}-item-icon`, children: U }), P = N ? N(v, {
+    index: i,
+    status: t,
+    title: f,
+    description: r
+  }) : v;
+  return /* @__PURE__ */ h("div", { ref: S, className: E, style: C, onClick: D, children: [
+    !j && (y === "vertical" || I === "vertical") && /* @__PURE__ */ s("div", { className: `${e}-item-tail` }),
+    p !== "arrow" && P,
+    /* @__PURE__ */ h("div", { className: `${e}-item-content`, children: [
+      /* @__PURE__ */ s("div", { className: `${e}-item-title`, children: f }),
+      r && /* @__PURE__ */ s("div", { className: `${e}-item-description`, children: r })
+    ] })
+  ] });
+}
+const B = q(A);
+B.displayName = "Step";
+export {
+  B as default
+};