@unicom-cloud/ui 0.8.115 → 0.8.117

package/dist/ui-common/hooks/use-previous/index.js

@@ -0,0 +1,10 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as t, useEffect as n } from "react";
+function f(r) {
+  const e = t(void 0);
+  return n(() => (e.current = r, () => {
+  })), e.current;
+}
+export {
+  f as default
+};

package/dist/ui-common/hooks/use-raf-interval/index.js

@@ -0,0 +1,36 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as u, useCallback as c, useEffect as s } from "react";
+import "../../utils/is.js";
+import d from "../use-latest/index.js";
+import { isNumber as f, isUndefined as m } from "@unicom-cloud/utils/is";
+const l = (r, e = 0) => {
+  if (m(requestAnimationFrame))
+    return {
+      id: setInterval(r, e)
+    };
+  let i = Date.now();
+  const n = {
+    id: 0
+  }, t = () => {
+    Date.now() - i >= e && (r(), i = Date.now()), n.id = requestAnimationFrame(t);
+  };
+  return n.id = requestAnimationFrame(t), n;
+}, p = (r) => m(cancelAnimationFrame), A = (r) => {
+  if (p(r.id))
+    return clearInterval(r.id);
+  cancelAnimationFrame(r.id);
+};
+function w(r, e, i) {
+  const n = i?.immediate, t = d(r), a = u(void 0), o = c(() => {
+    a.current && A(a.current);
+  }, []);
+  return s(() => {
+    if (!(!f(e) || e < 0))
+      return n && t.current(), a.current = l(() => {
+        t.current();
+      }, e), o;
+  }, [e]), o;
+}
+export {
+  w as default
+};

package/dist/ui-common/hooks/use-raf-state/index.js

@@ -0,0 +1,16 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as m, useState as o, useCallback as u } from "react";
+import i from "../use-unmount/index.js";
+function f(r) {
+  const e = m(0), [t, n] = o(r), a = u((c) => {
+    cancelAnimationFrame(e.current), e.current = requestAnimationFrame(() => {
+      n(c);
+    });
+  }, []);
+  return i(() => {
+    cancelAnimationFrame(e.current);
+  }), [t, a];
+}
+export {
+  f as default
+};

package/dist/ui-common/hooks/use-raf-timeout/index.js

@@ -0,0 +1,35 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as m, useCallback as u, useEffect as a } from "react";
+import "../../utils/is.js";
+import c from "../use-latest/index.js";
+import { isNumber as f, isUndefined as o } from "@unicom-cloud/utils/is";
+const s = (r, e = 0) => {
+  if (o(requestAnimationFrame))
+    return {
+      id: setTimeout(r, e)
+    };
+  const i = {
+    id: 0
+  }, n = Date.now(), t = () => {
+    Date.now() - n >= e ? r() : i.id = requestAnimationFrame(t);
+  };
+  return i.id = requestAnimationFrame(t), i;
+}, d = (r) => o(cancelAnimationFrame), l = (r) => {
+  if (d(r.id))
+    return clearTimeout(r.id);
+  cancelAnimationFrame(r.id);
+};
+function b(r, e) {
+  const i = c(r), n = m(void 0), t = u(() => {
+    n.current && l(n.current);
+  }, []);
+  return a(() => {
+    if (!(!f(e) || e < 0))
+      return n.current = s(() => {
+        i.current();
+      }, e), t;
+  }, [e]), t;
+}
+export {
+  b as default
+};

package/dist/ui-common/hooks/use-reactive/index.js

@@ -0,0 +1,38 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as l } from "react";
+import "../../utils/is.js";
+import m from "../use-creation/index.js";
+import g from "../use-update/index.js";
+import { isPlainObject as w, isArray as y } from "@unicom-cloud/utils/is";
+const u = /* @__PURE__ */ new WeakMap(), p = /* @__PURE__ */ new WeakMap();
+function a(t, o) {
+  const s = u.get(t);
+  if (s)
+    return s;
+  if (p.has(t))
+    return t;
+  const f = new Proxy(t, {
+    get(r, n, c) {
+      const e = Reflect.get(r, n, c), i = Reflect.getOwnPropertyDescriptor(r, n);
+      return !i?.configurable && !i?.writable ? e : w(e) || y(e) ? a(e, o) : e;
+    },
+    set(r, n, c) {
+      const e = Reflect.set(r, n, c);
+      return o(), e;
+    },
+    deleteProperty(r, n) {
+      const c = Reflect.deleteProperty(r, n);
+      return o(), c;
+    }
+  });
+  return u.set(t, f), p.set(f, t), f;
+}
+function x(t) {
+  const o = g(), s = l(t);
+  return m(() => a(s.current, () => {
+    o();
+  }), []);
+}
+export {
+  x as default
+};

package/dist/ui-common/hooks/use-refs/index.js

@@ -0,0 +1,11 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as c } from "react";
+function f(e = []) {
+  const r = c(e), n = (t, u) => {
+    u === void 0 ? r.current.push(t) : r.current[u] = t;
+  };
+  return [r.current, n];
+}
+export {
+  f as default
+};

package/dist/ui-common/hooks/use-request/src/Fetch.js

@@ -0,0 +1,93 @@
+/* 2025-11-03 10:27:46 */
+import "../../../utils/is.js";
+import { isFunction as a } from "@unicom-cloud/utils/is";
+class c {
+  constructor(t, s, r, n = {}) {
+    this.serviceRef = t, this.options = s, this.subscribe = r, this.initState = n, this.count = 0, this.state = {
+      loading: !1,
+      params: void 0,
+      data: void 0,
+      error: void 0
+    }, this.state = {
+      ...this.state,
+      loading: !s.manual,
+      ...n
+    };
+  }
+  setState(t = {}) {
+    this.state = {
+      ...this.state,
+      ...t
+    }, this.subscribe();
+  }
+  runPluginHandler(t, ...s) {
+    const r = this.pluginImpls.map((n) => n[t]?.(...s)).filter(Boolean);
+    return Object.assign({}, ...r);
+  }
+  async runAsync(...t) {
+    this.count += 1;
+    const s = this.count, {
+      stopNow: r = !1,
+      returnNow: n = !1,
+      ...o
+    } = this.runPluginHandler("onBefore", t);
+    if (r)
+      return new Promise(() => {
+      });
+    if (this.setState({
+      loading: !0,
+      params: t,
+      ...o
+    }), n)
+      return Promise.resolve(o.data);
+    this.options.onBefore?.(t);
+    try {
+      let { servicePromise: i } = this.runPluginHandler(
+        "onRequest",
+        this.serviceRef.current,
+        t
+      );
+      i || (i = this.serviceRef.current(...t));
+      const e = await i;
+      return s !== this.count ? new Promise(() => {
+      }) : (this.setState({
+        data: e,
+        error: void 0,
+        loading: !1
+      }), this.options.onSuccess?.(e, t), this.runPluginHandler("onSuccess", e, t), this.options.onFinally?.(t, e, void 0), s === this.count && this.runPluginHandler("onFinally", t, e, void 0), e);
+    } catch (i) {
+      if (s !== this.count)
+        return new Promise(() => {
+        });
+      throw this.setState({
+        error: i,
+        loading: !1
+      }), this.options.onError?.(i, t), this.runPluginHandler("onError", i, t), this.options.onFinally?.(t, void 0, i), s === this.count && this.runPluginHandler("onFinally", t, void 0, i), i;
+    }
+  }
+  run(...t) {
+    this.runAsync(...t).catch((s) => {
+      this.options.onError || console.error(s);
+    });
+  }
+  cancel() {
+    this.count += 1, this.setState({
+      loading: !1
+    }), this.runPluginHandler("onCancel");
+  }
+  refresh() {
+    this.run(...this.state.params || []);
+  }
+  refreshAsync() {
+    return this.runAsync(...this.state.params || []);
+  }
+  mutate(t) {
+    const s = a(t) ? t(this.state.data) : t;
+    this.runPluginHandler("onMutate", s), this.setState({
+      data: s
+    });
+  }
+}
+export {
+  c as default
+};

package/dist/ui-common/hooks/use-request/src/plugins/useAutoRunPlugin.js

@@ -0,0 +1,30 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as f } from "react";
+import a from "../../../use-update-effect/index.js";
+const l = (r, {
+  manual: e,
+  ready: n = !0,
+  defaultParams: o = [],
+  refreshDeps: s = [],
+  refreshDepsAction: u
+}) => {
+  const t = f(!1);
+  return t.current = !1, a(() => {
+    !e && n && (t.current = !0, r.run(...o));
+  }, [n]), a(() => {
+    t.current || e || (t.current = !0, u ? u() : r.refresh());
+  }, [...s]), {
+    onBefore: () => {
+      if (!n)
+        return {
+          stopNow: !0
+        };
+    }
+  };
+};
+l.onInit = ({ ready: r = !0, manual: e }) => ({
+  loading: !e && r
+});
+export {
+  l as default
+};

package/dist/ui-common/hooks/use-request/src/plugins/useCachePlugin.js

@@ -0,0 +1,66 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as f } from "react";
+import l from "../../../use-creation/index.js";
+import g from "../../../use-unmount/index.js";
+import { getCache as w, setCache as v } from "../utils/cache.js";
+import { getCachePromise as C, setCachePromise as P } from "../utils/cachePromise.js";
+import { subscribe as n, trigger as b } from "../utils/cacheSubscribe.js";
+const R = (o, {
+  cacheKey: e,
+  cacheTime: h = 300 * 1e3,
+  staleTime: c = 0,
+  setCache: i,
+  getCache: m
+}) => {
+  const s = f(void 0), d = f(void 0), u = (a, t) => {
+    i ? i(t) : v(a, h, t), b(a, t.data);
+  }, p = (a, t = []) => m ? m(t) : w(a);
+  return l(() => {
+    if (!e)
+      return;
+    const a = p(e);
+    a && Object.hasOwnProperty.call(a, "data") && (o.state.data = a.data, o.state.params = a.params, (c === -1 || Date.now() - a.time <= c) && (o.state.loading = !1)), s.current = n(e, (t) => {
+      o.setState({ data: t });
+    });
+  }, []), g(() => {
+    s.current?.();
+  }), e ? {
+    onBefore: (a) => {
+      const t = p(e, a);
+      return !t || !Object.hasOwnProperty.call(t, "data") ? {} : c === -1 || Date.now() - t.time <= c ? {
+        loading: !1,
+        data: t?.data,
+        error: void 0,
+        returnNow: !0
+      } : {
+        data: t?.data,
+        error: void 0
+      };
+    },
+    onRequest: (a, t) => {
+      let r = C(e);
+      return r && r !== d.current ? { servicePromise: r } : (r = a(...t), d.current = r, P(e, r), { servicePromise: r });
+    },
+    onSuccess: (a, t) => {
+      e && (s.current?.(), u(e, {
+        data: a,
+        params: t,
+        time: Date.now()
+      }), s.current = n(e, (r) => {
+        o.setState({ data: r });
+      }));
+    },
+    onMutate: (a) => {
+      e && (s.current?.(), u(e, {
+        data: a,
+        params: o.state.params,
+        time: Date.now()
+      }), s.current = n(e, (t) => {
+        o.setState({ data: t });
+      }));
+    }
+  } : {};
+};
+export {
+  R as default
+};

package/dist/ui-common/hooks/use-request/src/plugins/useDebouncePlugin.js

@@ -0,0 +1,34 @@
+/* 2025-11-03 10:27:46 */
+import f from "lodash/debounce";
+import { useRef as l, useMemo as m, useEffect as b } from "react";
+const p = (n, { debounceWait: r, debounceLeading: t, debounceTrailing: o, debounceMaxWait: u }) => {
+  const c = l(void 0), a = m(() => {
+    const e = {};
+    return t !== void 0 && (e.leading = t), o !== void 0 && (e.trailing = o), u !== void 0 && (e.maxWait = u), e;
+  }, [t, o, u]);
+  return b(() => {
+    if (r) {
+      const e = n.runAsync.bind(n);
+      return c.current = f(
+        (i) => {
+          i();
+        },
+        r,
+        a
+      ), n.runAsync = (...i) => new Promise((d, s) => {
+        c.current?.(() => {
+          e(...i).then(d).catch(s);
+        });
+      }), () => {
+        c.current?.cancel(), n.runAsync = e;
+      };
+    }
+  }, [r, a]), r ? {
+    onCancel: () => {
+      c.current?.cancel();
+    }
+  } : {};
+};
+export {
+  p as default
+};

package/dist/ui-common/hooks/use-request/src/plugins/useLoadingDelayPlugin.js

@@ -0,0 +1,28 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as a } from "react";
+const u = (o, { loadingDelay: n, ready: r }) => {
+  const e = a(void 0);
+  if (!n)
+    return {};
+  const t = () => {
+    e.current && clearTimeout(e.current);
+  };
+  return {
+    onBefore: () => (t(), r !== !1 && (e.current = setTimeout(() => {
+      o.setState({
+        loading: !0
+      });
+    }, n)), {
+      loading: !1
+    }),
+    onFinally: () => {
+      t();
+    },
+    onCancel: () => {
+      t();
+    }
+  };
+};
+export {
+  u as default
+};

package/dist/ui-common/hooks/use-request/src/plugins/usePollingPlugin.js

@@ -0,0 +1,37 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as u } from "react";
+import f from "../../../use-update-effect/index.js";
+import m from "../utils/isDocumentVisible.js";
+import s from "../utils/subscribeReVisible.js";
+const h = (c, { pollingInterval: r, pollingWhenHidden: l = !0, pollingErrorRetryCount: n = -1 }) => {
+  const o = u(void 0), i = u(void 0), e = u(0), t = () => {
+    o.current && clearTimeout(o.current), i.current?.();
+  };
+  return f(() => {
+    r || t();
+  }, [r]), r ? {
+    onBefore: () => {
+      t();
+    },
+    onError: () => {
+      e.current += 1;
+    },
+    onSuccess: () => {
+      e.current = 0;
+    },
+    onFinally: () => {
+      n === -1 || // When an error occurs, the request is not repeated after pollingErrorRetryCount retries
+      n !== -1 && e.current <= n ? o.current = setTimeout(() => {
+        !l && !m() ? i.current = s(() => {
+          c.refresh();
+        }) : c.refresh();
+      }, r) : e.current = 0;
+    },
+    onCancel: () => {
+      t();
+    }
+  } : {};
+};
+export {
+  h as default
+};

package/dist/ui-common/hooks/use-request/src/plugins/useRefreshOnWindowFocusPlugin.js

@@ -0,0 +1,29 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as n, useEffect as i } from "react";
+import c from "../../../use-unmount/index.js";
+import m from "../utils/limit.js";
+import u from "../utils/subscribeFocus.js";
+const b = (r, { refreshOnWindowFocus: o, focusTimespan: e = 5e3 }) => {
+  const t = n(void 0), f = () => {
+    t.current?.();
+  };
+  return i(() => {
+    if (o) {
+      const s = m(
+        r.refresh.bind(r),
+        e
+      );
+      t.current = u(() => {
+        s();
+      });
+    }
+    return () => {
+      f();
+    };
+  }, [o, e]), c(() => {
+    f();
+  }), {};
+};
+export {
+  b as default
+};

package/dist/ui-common/hooks/use-request/src/plugins/useRetryPlugin.js

@@ -0,0 +1,28 @@
+/* 2025-11-03 10:27:46 */
+import { useRef as u } from "react";
+const f = (c, { retryInterval: o, retryCount: t }) => {
+  const e = u(void 0), r = u(0), n = u(!1);
+  return t ? {
+    onBefore: () => {
+      n.current || (r.current = 0), n.current = !1, e.current && clearTimeout(e.current);
+    },
+    onSuccess: () => {
+      r.current = 0;
+    },
+    onError: () => {
+      if (r.current += 1, t === -1 || r.current <= t) {
+        const s = o ?? Math.min(1e3 * 2 ** r.current, 3e4);
+        e.current = setTimeout(() => {
+          n.current = !0, c.refresh();
+        }, s);
+      } else
+        r.current = 0;
+    },
+    onCancel: () => {
+      r.current = 0, e.current && clearTimeout(e.current);
+    }
+  } : {};
+};
+export {
+  f as default
+};

package/dist/ui-common/hooks/use-request/src/plugins/useThrottlePlugin.js

@@ -0,0 +1,31 @@
+/* 2025-11-03 10:27:46 */
+import s from "lodash/throttle";
+import { useRef as d, useEffect as f } from "react";
+const g = (t, { throttleWait: e, throttleLeading: n, throttleTrailing: c }) => {
+  const r = d(void 0), i = {};
+  return n !== void 0 && (i.leading = n), c !== void 0 && (i.trailing = c), f(() => {
+    if (e) {
+      const u = t.runAsync.bind(t);
+      return r.current = s(
+        (o) => {
+          o();
+        },
+        e,
+        i
+      ), t.runAsync = (...o) => new Promise((a, l) => {
+        r.current?.(() => {
+          u(...o).then(a).catch(l);
+        });
+      }), () => {
+        t.runAsync = u, r.current?.cancel();
+      };
+    }
+  }, [e, n, c]), e ? {
+    onCancel: () => {
+      r.current?.cancel();
+    }
+  } : {};
+};
+export {
+  g as default
+};

package/dist/ui-common/hooks/use-request/src/useRequest.js

@@ -0,0 +1,26 @@
+/* 2025-11-03 10:27:46 */
+import t from "./plugins/useAutoRunPlugin.js";
+import f from "./plugins/useCachePlugin.js";
+import i from "./plugins/useDebouncePlugin.js";
+import p from "./plugins/useLoadingDelayPlugin.js";
+import a from "./plugins/usePollingPlugin.js";
+import e from "./plugins/useRefreshOnWindowFocusPlugin.js";
+import n from "./plugins/useRetryPlugin.js";
+import u from "./plugins/useThrottlePlugin.js";
+import d from "./useRequestImplement.js";
+function $(r, o, m) {
+  return d(r, o, [
+    ...m || [],
+    i,
+    p,
+    a,
+    e,
+    u,
+    t,
+    f,
+    n
+  ]);
+}
+export {
+  $ as default
+};

package/dist/ui-common/hooks/use-request/src/useRequestImplement.js

@@ -0,0 +1,54 @@
+/* 2025-11-03 10:27:46 */
+import "../../../utils/is.js";
+import d from "../../use-creation/index.js";
+import l from "../../use-latest/index.js";
+import r from "../../use-memoized-fn/index.js";
+import y from "../../use-mount/index.js";
+import b from "../../use-unmount/index.js";
+import $ from "../../use-update/index.js";
+import g from "../../utils/isDev.js";
+import A from "./Fetch.js";
+import { isArray as P } from "@unicom-cloud/utils/is";
+function z(i, t = {}, o = []) {
+  const { manual: s = !1, ready: m = !0, ...f } = t;
+  g && t.defaultParams && !P(t.defaultParams) && console.warn(
+    `expected defaultParams is array, got ${typeof t.defaultParams}`
+  );
+  const n = {
+    manual: s,
+    ready: m,
+    ...f
+  }, c = l(i), p = $(), a = d(() => {
+    const e = o.map((u) => u?.onInit?.(n)).filter(Boolean);
+    return new A(
+      c,
+      n,
+      p,
+      Object.assign({}, ...e)
+    );
+  }, []);
+  return a.options = n, a.pluginImpls = o.map(
+    (e) => e(a, n)
+  ), y(() => {
+    if (!s && m) {
+      const e = a.state.params || t.defaultParams || [];
+      a.run(...e);
+    }
+  }), b(() => {
+    a.cancel();
+  }), {
+    loading: a.state.loading,
+    data: a.state.data,
+    error: a.state.error,
+    params: a.state.params || [],
+    cancel: r(a.cancel.bind(a)),
+    refresh: r(a.refresh.bind(a)),
+    refreshAsync: r(a.refreshAsync.bind(a)),
+    run: r(a.run.bind(a)),
+    runAsync: r(a.runAsync.bind(a)),
+    mutate: r(a.mutate.bind(a))
+  };
+}
+export {
+  z as default
+};

package/dist/ui-common/hooks/use-request/src/utils/cache.js

@@ -0,0 +1,20 @@
+/* 2025-11-03 10:27:46 */
+import c from "lodash/castArray";
+const t = /* @__PURE__ */ new Map(), m = (e, a, s) => {
+  const r = t.get(e);
+  r?.timer && clearTimeout(r.timer);
+  let o;
+  a > -1 && (o = setTimeout(() => {
+    t.delete(e);
+  }, a)), t.set(e, {
+    ...s,
+    timer: o
+  });
+}, i = (e) => t.get(e), h = (e) => {
+  e ? c(e).forEach((a) => t.delete(a)) : t.clear();
+};
+export {
+  h as clearCache,
+  i as getCache,
+  m as setCache
+};

package/dist/ui-common/hooks/use-request/src/utils/cachePromise.js

@@ -0,0 +1,10 @@
+/* 2025-11-03 10:27:46 */
+const t = /* @__PURE__ */ new Map(), c = (e) => t.get(e), o = (e, s) => {
+  t.set(e, s), s.then((a) => (t.delete(e), a)).catch(() => {
+    t.delete(e);
+  });
+};
+export {
+  c as getCachePromise,
+  o as setCachePromise
+};

package/dist/ui-common/hooks/use-request/src/utils/cacheSubscribe.js

@@ -0,0 +1,11 @@
+/* 2025-11-03 10:27:46 */
+const o = {}, c = (n, r) => {
+  o[n] && o[n].forEach((t) => t(r));
+}, e = (n, r) => (o[n] || (o[n] = []), o[n].push(r), function() {
+  const t = o[n].indexOf(r);
+  o[n].splice(t, 1);
+});
+export {
+  e as subscribe,
+  c as trigger
+};

package/dist/ui-common/hooks/use-request/src/utils/isDocumentVisible.js

@@ -0,0 +1,8 @@
+/* 2025-11-03 10:27:46 */
+import { isBrowser as t } from "@unicom-cloud/utils/constant/platform";
+function i() {
+  return t ? document.visibilityState !== "hidden" : !0;
+}
+export {
+  i as default
+};

package/dist/ui-common/hooks/use-request/src/utils/isOnline.js

@@ -0,0 +1,8 @@
+/* 2025-11-03 10:27:46 */
+import "../../../../utils/is.js";
+import { isBrowser as o } from "@unicom-cloud/utils/constant/platform";
+import { isUndefined as r } from "@unicom-cloud/utils/is";
+const e = () => o && !r(navigator.onLine) ? navigator.onLine : !0;
+export {
+  e as default
+};