npm - @unicom-cloud/ui - Versions diffs - 0.8.109 → 0.8.110 - Mend

@@ -1,16 +0,0 @@
-import { useState as c, useEffect as i } from "react";
-const m = (e, t) => t !== void 0 ? t : window.matchMedia(e).matches, h = (e, t) => {
-  const [o, s] = c(m(e, t));
-  return i(() => {
-    let a = !0;
-    const n = window.matchMedia(e), r = () => {
-      a && s(!!n.matches);
-    };
-    return n.addEventListener("change", r), s(n.matches), () => {
-      a = !1, n.removeEventListener("change", r);
-    };
-  }, [e]), o;
-};
-export {
-  h as u
-};

@@ -1,14 +0,0 @@
-import { useRef as u, useCallback as c } from "react";
-function l(e) {
-  const r = u(null);
-  return r.current = e, c(
-    (...n) => {
-      const t = r.current;
-      return t?.(...n);
-    },
-    [r.current]
-  );
-}
-export {
-  l as u
-};

@@ -1,25 +0,0 @@
-import { useState as a, useEffect as l } from "react";
-function i(o) {
-  const [e, r] = a({
-    value: o,
-    resolve: (t) => {
-    }
-  });
-  return l(() => {
-    e.resolve(e.value);
-  }, [e]), [
-    e.value,
-    (t) => new Promise((s) => {
-      r((n) => {
-        let u = t;
-        return typeof t == "function" && (u = t(n.value)), {
-          value: u,
-          resolve: s
-        };
-      });
-    })
-  ];
-}
-export {
-  i as u
-};

@@ -1,33 +0,0 @@
-import d from "lodash/debounce";
-import { useState as l, useDeferredValue as h, useCallback as o, useEffect as m } from "react";
-import { u as z } from "./BL9DMeor.js";
-const R = (s = !1) => {
-  const [i, u] = l({
-    ...t(null)
-  }), c = h(
-    i
-    // 延迟一个值与防抖和节流之间有什么不同？
-    // 防抖 是指在用户停止输入一段时间（例如一秒钟）之后再更新列表。
-    // 节流 是指每隔一段时间（例如最多每秒一次）更新列表。
-    // 虽然这些技术在某些情况下是有用的，但 useDeferredValue 更适合优化渲染，因为它与 React 自身深度集成，并且能够适应用户的设备。
-    // 与防抖或节流不同，useDeferredValue 不需要选择任何固定延迟时间。如果用户的设备很快（比如性能强劲的笔记本电脑），延迟的重渲染几乎会立即发生并且不会被察觉。如果用户的设备较慢，那么列表会相应地“滞后”于输入，滞后的程度与设备的速度有关。
-    // 此外，与防抖或节流不同，useDeferredValue 执行的延迟重新渲染默认是可中断的。这意味着，如果 React 正在重新渲染一个大型列表，但用户进行了另一次键盘输入，React 会放弃该重新渲染，先处理键盘输入，然后再次开始在后台渲染。相比之下，防抖和节流仍会产生不顺畅的体验，因为它们是阻塞的：它们仅仅是将渲染阻塞键盘输入的时刻推迟了。
-    // 如果你要优化的工作不是在渲染期间发生的，那么防抖和节流仍然非常有用。例如，它们可以让你减少网络请求的次数。你也可以同时使用这些技术。
-  );
-  function t(e) {
-    const r = e?.currentTarget ?? e?.target ?? window;
-    return {
-      width: r?.innerWidth ?? 0,
-      height: r?.innerHeight ?? 0
-    };
-  }
-  function n(e) {
-    u(t(e));
-  }
-  const a = o(n, []), f = o(d(n, 123), []);
-  return z(s ? f : a, []), m(() => () => {
-  }, []), c;
-};
-export {
-  R as u
-};

@@ -1,4 +0,0 @@
-import { u as f } from "../chunk/5_U1CBIu.js";
-export {
-  f as default
-};

@@ -1,18 +0,0 @@
-declare const useDynamicList: <T>(initialList?: T[]) => {
-    list: T[];
-    insert: (index: number, item: T) => void;
-    merge: (index: number, items: T[]) => void;
-    replace: (index: number, item: T) => void;
-    remove: (index: number) => void;
-    batchRemove: (indexes: number[]) => void;
-    getKey: (index: number) => number;
-    getIndex: (key: number) => number;
-    move: (oldIndex: number, newIndex: number) => void;
-    push: (item: T) => void;
-    pop: () => void;
-    unshift: (item: T) => void;
-    shift: () => void;
-    sortList: (result: T[]) => T[];
-    resetList: (newList: T[]) => void;
-};
-export default useDynamicList;

@@ -1,11 +0,0 @@
-type Subscription<T> = (val: T) => void;
-export declare class EventEmitter<T> {
-    private subscriptions;
-    emit: (val: T) => void;
-    useSubscription: (callback: Subscription<T>) => void;
-}
-declare function useEventEmitter<T = void>(): EventEmitter<T>;
-declare namespace useEventEmitter {
-    var EventEmitter: typeof import(".").EventEmitter;
-}
-export default useEventEmitter;

@@ -1,8 +0,0 @@
-declare function useMap<K, T>(initialValue?: Iterable<readonly [K, T]>): readonly [Map<K, T>, {
-    readonly set: (this: unknown, key: K, entry: T) => void;
-    readonly setAll: (this: unknown, newMap: Iterable<readonly [K, T]>) => void;
-    readonly remove: (this: unknown, key: K) => void;
-    readonly reset: (this: unknown) => void;
-    readonly get: (this: unknown, key: K) => T | undefined;
-}];
-export default useMap;

@@ -1,6 +0,0 @@
-declare function useSet<K>(initialValue?: Iterable<K>): readonly [Set<K>, {
-    readonly add: (this: unknown, key: K) => void;
-    readonly remove: (this: unknown, key: K) => void;
-    readonly reset: (this: unknown) => void;
-}];
-export default useSet;

	@@ -1,2 +0,0 @@
1	- declare function useCreate(fn: any): void;
2	- export default useCreate;

	@@ -1 +0,0 @@
1	- export { default } from '../../common/hooks/useCreate';

@unicom-cloud/ui 0.8.109 → 0.8.110