@unicom-cloud/ui 0.8.67 → 0.8.68

package/slider/index.js

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

package/slider/interface.js

@@ -0,0 +1 @@
+

package/slider/util.js

@@ -0,0 +1,63 @@
+import { i, o as d, u as l, d as m } from "../chunk/BibHFOCF.js";
+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 m(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 h(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 v(t, n) {
+  const e = n.find(
+    (r) => t >= r.begin && t <= r.end
+  );
+  if (e) {
+    const { beginOffset: r, begin: o, end: f, endOffset: s } = e, c = x(t, [o, f]), u = i(s, r), a = d(c, u);
+    return l(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,
+  v as getIntervalOffset,
+  x as getOffset,
+  I as getPrecision,
+  g as isNotEmpty,
+  F as needSort,
+  h as rateToFloat,
+  N as sortNumberArray,
+  b as valueInRange
+};

package/space/index.js

@@ -0,0 +1,90 @@
+import { jsx as s, jsxs as A } from "react/jsx-runtime";
+import L from "lodash/isArray";
+import M from "lodash/isNumber";
+import P, { forwardRef as b, useContext as j } from "react";
+import { a as k } from "../chunk/ll867Bf3.js";
+import { u as D } from "../chunk/BFTV6myl.js";
+import { m as F } from "../chunk/JPPo5nY_.js";
+import H from "./toArray.js";
+const O = {
+  size: "small",
+  direction: "horizontal"
+};
+function V(c, m) {
+  const { getPrefixCls: v, componentConfig: l, rtl: d } = j(k), N = D(
+    c,
+    O,
+    l == null ? void 0 : l.Space
+  ), {
+    className: S,
+    style: x,
+    children: C,
+    size: i,
+    direction: a,
+    align: w,
+    wrap: p,
+    split: u,
+    ...B
+  } = N, e = v("space"), $ = w || (a === "horizontal" ? "center" : ""), R = F(
+    e,
+    {
+      [`${e}-${a}`]: a,
+      [`${e}-align-${$}`]: $,
+      [`${e}-wrap`]: p,
+      [`${e}-rtl`]: d
+    },
+    S
+  );
+  function f(r) {
+    if (M(r))
+      return r;
+    switch (r) {
+      case "mini":
+        return 4;
+      case "small":
+        return 8;
+      case "medium":
+        return 16;
+      case "large":
+        return 24;
+      default:
+        return 8;
+    }
+  }
+  const y = H(C);
+  function z(r) {
+    const n = y.length === r + 1, o = d ? "marginLeft" : "marginRight";
+    if (typeof i == "string" || typeof i == "number") {
+      const t = f(i);
+      return p ? n ? { marginBottom: t } : {
+        [`${o}`]: t,
+        marginBottom: t
+      } : n ? {} : {
+        [a === "vertical" ? "marginBottom" : o]: t
+      };
+    }
+    if (L(i)) {
+      const t = f(i[0]), g = f(i[1]);
+      return p ? n ? { marginBottom: g } : {
+        [`${o}`]: t,
+        marginBottom: g
+      } : a === "vertical" ? { marginBottom: g } : { [`${o}`]: t };
+    }
+  }
+  return /* @__PURE__ */ s("div", { ref: m, className: R, style: x, ...B, children: y.map((r, n) => {
+    const o = (r == null ? void 0 : r.key) || n, t = u != null && n > 0;
+    return /* @__PURE__ */ A(P.Fragment, { children: [
+      t && /* @__PURE__ */ s("div", { className: `${e}-item-split`, children: u }),
+      /* @__PURE__ */ s("div", { className: `${e}-item`, style: z(n), children: r })
+    ] }, o);
+  }) });
+}
+const h = b(V);
+h.displayName = "Space";
+function U(c, m) {
+  return /* @__PURE__ */ s(h, { ref: m, direction: "vertical", children: c.children });
+}
+export {
+  U as SpaceVertical,
+  h as default
+};

package/space/interface.js

@@ -0,0 +1 @@
+

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/speech-synthesis/index.js

@@ -0,0 +1,109 @@
+import { jsx as m } from "react/jsx-runtime";
+import { memo as k, forwardRef as w, useState as C, useEffect as h, useImperativeHandle as I } from "react";
+import "../chunk/Biupwn8l.js";
+import "../utils/dom.js";
+import "../chunk/D-TPB2Do.js";
+import "react-dom";
+import "../chunk/Ce1j9KTi.js";
+import "lodash/debounce";
+import "../chunk/yl4BU7Sd.js";
+import "../chunk/B6X4lnd0.js";
+import "../chunk/tamGhTJp.js";
+import "lodash/camelCase";
+import "lodash/capitalize";
+import "lodash/cloneDeep";
+import "lodash/get";
+import "lodash/has";
+import "lodash/kebabCase";
+import "lodash/merge";
+import "lodash/mergeWith";
+import "lodash/set";
+import "lodash/setWith";
+import "lodash/snakeCase";
+import "lodash/startCase";
+import "lodash/throttle";
+import "lodash/uniq";
+import "lodash/upperFirst";
+import "lodash/camelCase.js";
+import "lodash/capitalize.js";
+import "lodash/kebabCase.js";
+import "lodash/snakeCase.js";
+import "lodash/startCase.js";
+import "lodash/upperFirst.js";
+import "lodash/isPlainObject.js";
+import "lodash/uniq.js";
+import "lodash/isString.js";
+import "../chunk/DzVH9IBy.js";
+import "lodash/escapeRegExp";
+import "lodash/isArray";
+import "lodash/isNumber";
+import "lodash/isString";
+import "lodash/isPlainObject";
+import "../chunk/Bl7BnD1R.js";
+import "lodash/isFunction";
+import "../chunk/CCv-5KFt.js";
+import "uuid";
+import x from "@unicom-cloud/icons/IconUiMute";
+import P from "@unicom-cloud/icons/IconUiPauseCircleFill";
+import U from "@unicom-cloud/icons/IconUiPlayCircleFill";
+import b from "@unicom-cloud/icons/IconUiSound";
+import g from "../button/index.js";
+function v(l) {
+  function p(i, S) {
+    const { useButton: d = !0 } = i ?? {}, [c, n] = C(!1);
+    function u() {
+      var e, t;
+      (t = (e = window.speechSynthesis) == null ? void 0 : e.cancel) == null || t.call(e);
+    }
+    function y() {
+      var o, r, f;
+      let e = ((o = i.getText) == null ? void 0 : o.call(i)) || i.text, t = new SpeechSynthesisUtterance(e);
+      t.onstart = function() {
+        n(!0);
+      }, t.onerror = () => {
+        n(!1);
+      }, t.onmark = () => {
+      }, t.onpause = () => {
+        n(!1);
+      }, t.onresume = () => {
+        n(!0);
+      }, t.onboundary = () => {
+      }, t.onend = () => {
+        n(!1);
+      }, (f = (r = window.speechSynthesis) == null ? void 0 : r.speak) == null || f.call(r, t);
+    }
+    function a(e) {
+      var t, o;
+      u(), c || y(), (o = (t = i.buttonProps) == null ? void 0 : t.onClick) == null || o.call(t, e);
+    }
+    let s;
+    if (window.speechSynthesis && window.SpeechSynthesisUtterance)
+      if (d) {
+        let { label: e, text: t, children: o, ...r } = i.buttonProps ?? {};
+        s = /* @__PURE__ */ m(
+          l,
+          {
+            ...i,
+            type: "text",
+            size: "mini",
+            icon: c ? /* @__PURE__ */ m(x, {}) : /* @__PURE__ */ m(b, {}),
+            ...r,
+            onClick: a,
+            children: e || t || o
+          }
+        );
+      } else
+        s = /* @__PURE__ */ m(c ? P : U, { ...i.iconProps, onClick: a });
+    return h(() => () => {
+      u();
+    }, []), I(S, () => ({})), s;
+  }
+  return k(w(p));
+}
+const Ut = v(function(p) {
+  return h(() => () => {
+  }, []), /* @__PURE__ */ m(g, { ...p, children: p.children });
+});
+export {
+  Ut as default
+};