donar 0.0.1

package/dist/js/utils.CVb1iSAU.js

@@ -0,0 +1,330 @@
+//#region src/utils/thenable.ts
+var e = async (e) => {
+	try {
+		return [
+			!0,
+			null,
+			await Promise.resolve(e)
+		];
+	} catch (e) {
+		return [
+			!1,
+			e instanceof Error ? e : Error(String(e)),
+			null
+		];
+	}
+}, t = (e) => new Promise((t) => {
+	t(typeof e == "function" ? e() : e);
+});
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/typeof.js
+function n(e) {
+	"@babel/helpers - typeof";
+	return n = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+		return typeof e;
+	} : function(e) {
+		return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+	}, n(e);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/toPrimitive.js
+function r(e, t) {
+	if (n(e) != "object" || !e) return e;
+	var r = e[Symbol.toPrimitive];
+	if (r !== void 0) {
+		var i = r.call(e, t || "default");
+		if (n(i) != "object") return i;
+		throw TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (t === "string" ? String : Number)(e);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/toPropertyKey.js
+function i(e) {
+	var t = r(e, "string");
+	return n(t) == "symbol" ? t : t + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/defineProperty.js
+function a(e, t, n) {
+	return (t = i(t)) in e ? Object.defineProperty(e, t, {
+		value: n,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[t] = n, e;
+}
+//#endregion
+//#region src/utils/concurrency.ts
+var o = class {
+	constructor(e = 5) {
+		a(this, "queue", []), a(this, "concurrency", void 0), a(this, "running", 0), this.concurrency = e;
+	}
+	push(e) {
+		return new Promise((t, n) => {
+			this.queue.push({
+				task: e,
+				resolve: t,
+				reject: n
+			}), this.run();
+		});
+	}
+	run() {
+		for (; this.running < this.concurrency && this.queue.length > 0;) this.next();
+	}
+	next() {
+		if (this.running >= this.concurrency) return;
+		let { task: e, resolve: n, reject: r } = this.queue.shift() ?? {};
+		e && (this.running++, t(e).then(n, r).finally(() => {
+			this.running--, this.run();
+		}));
+	}
+}, s = (e, t) => {
+	let n;
+	return function(...r) {
+		n && clearTimeout(n), n = setTimeout(() => {
+			e.apply(this, r);
+		}, t);
+	};
+};
+//#endregion
+//#region src/utils/hash.ts
+async function c(e, t = "SHA-1") {
+	try {
+		if (!e) throw Error("message is empty");
+		let n = new TextEncoder().encode(e), r = await window.crypto.subtle.digest(t, n);
+		return Array.from(new Uint8Array(r)).map((e) => e.toString(16).padStart(2, "0")).join("");
+	} catch (e) {
+		throw e instanceof Error ? e : /* @__PURE__ */ Error("string to hash failed");
+	}
+}
+//#endregion
+//#region src/utils/download.ts
+var l = (e) => new Promise((t, n) => {
+	try {
+		let r = window.open(e, "_blank");
+		!r || r.closed || r.closed === void 0 ? n(/* @__PURE__ */ Error("Tab 可能被拦截了")) : t(!0);
+	} catch {
+		n(/* @__PURE__ */ Error("下载出错"));
+	}
+}), u = (e, t, n = !0) => {
+	let r = URL.createObjectURL(e);
+	try {
+		let e = document.createElement("a");
+		e.href = r, e.download = t, n || e.setAttribute("target", "_blank"), e.click();
+	} finally {
+		URL.revokeObjectURL(r);
+	}
+}, d = (() => {
+	let e = /^\[[a-z]+ ([A-Za-z]+)\]$/;
+	return (t) => t.constructor && t.constructor.name || Object.prototype.toString.call(t).replace(e, "$1");
+})(), f = (e) => e === Object(e), p = (e) => f(e) ? e instanceof Set ? !0 : Object.prototype.hasOwnProperty.call(e, "size") && typeof e.add == "function" && typeof e.has == "function" : !1, m = (e) => f(e) ? e instanceof Map ? !0 : Object.prototype.hasOwnProperty.call(e, "size") && typeof e.set == "function" && typeof e.get == "function" : !1, h = (e) => Array.isArray(e) ? [] : p(e) ? /* @__PURE__ */ new Set() : m(e) ? /* @__PURE__ */ new Map() : {}, g = (e, t = !0) => {
+	let n = /* @__PURE__ */ new WeakMap(), r = (e) => {
+		if (!f(e)) return e;
+		switch (d(e)) {
+			case "Date":
+			case "RegExp":
+			case "Function": {
+				let t = e.constructor;
+				return new t(e);
+			}
+			case "WeakMap":
+			case "WeakSet": return e;
+		}
+		if (n.get(e)) return n.get(e);
+		let i = h(e);
+		if (t && Object.setPrototypeOf(i, Object.getPrototypeOf(e)), n.set(e, i), p(e)) {
+			for (let t of e) i.add(r(t));
+			return i;
+		}
+		if (m(e)) {
+			for (let [t, n] of e) i.set(r(t), r(n));
+			return i;
+		}
+		return Reflect.ownKeys(e).map((t) => i[t] = r(e[t])), i;
+	};
+	return r(e);
+}, _ = (e, t) => {
+	let n = Date.now(), r = !1, i = () => r = !0, a = () => {
+		requestAnimationFrame(() => {
+			let i = Date.now();
+			i - n >= t && (e(), n = i), r || a();
+		});
+	};
+	return requestAnimationFrame(a), { stop: i };
+}, v = (e) => {
+	typeof e == "object" && e.stop && e.stop(), typeof e == "function" && e();
+}, y = (e) => e && e.charAt(0).toUpperCase() + e.slice(1), b = (e) => e && e.charAt(0).toLowerCase() + e.slice(1), x = (e) => e && e.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, ""), S = (e) => e && e.replace(/_([a-zA-Z])/g, (e, t) => t.toUpperCase()).replace(/_(\d+)/g, (e, t) => t).replace(/_/g, ""), C = ({ obj: e, ignoreKeys: t = /* @__PURE__ */ new Set(), convertFn: n }) => {
+	if (Object(e) !== e) return e;
+	if (Array.isArray(e)) return e.map((e) => C({
+		obj: e,
+		ignoreKeys: t,
+		convertFn: n
+	}));
+	let r = {}, i = Object.entries(e);
+	for (let [e, a] of i) {
+		let i = t.has(e) ? e : n(e);
+		r[i] = C({
+			obj: a,
+			ignoreKeys: t,
+			convertFn: n
+		});
+	}
+	return r;
+}, w = {
+	SnakeToCamel: "snakeToCamel",
+	CamelToSnake: "camelToSnake",
+	CamelToPascal: "camelToPascal",
+	PascalToCamel: "pascalToCamel"
+}, T = (e, t) => C({
+	obj: e,
+	ignoreKeys: new Set(t ?? []),
+	convertFn: S
+}), E = (e, t) => C({
+	obj: e,
+	ignoreKeys: new Set(t ?? []),
+	convertFn: x
+}), D = (e, t) => C({
+	obj: e,
+	ignoreKeys: new Set(t ?? []),
+	convertFn: y
+}), O = (e, t) => C({
+	obj: e,
+	ignoreKeys: new Set(t ?? []),
+	convertFn: b
+}), k = (e, t) => {
+	t && (t instanceof Headers ? t.forEach((t, n) => {
+		e.setRequestHeader(n, t);
+	}) : Array.isArray(t) ? t.forEach((t) => {
+		e.setRequestHeader(t[0], t[1]);
+	}) : Object.keys(t).forEach((n) => {
+		e.setRequestHeader(n, t[n]);
+	}));
+}, A = async (e, t) => {
+	if (!(e instanceof ReadableStream)) return e;
+	let n = [], r = e.getReader();
+	for (;;) {
+		t?.throwIfAborted();
+		let { done: e, value: i } = await r.read();
+		if (e) break;
+		n.push(i);
+	}
+	return new Blob(n);
+}, j = /[\r\n]+/, M = function(e) {
+	let t = e.getAllResponseHeaders().trim().split(j).map((e) => {
+		let t = e.indexOf(":");
+		return t <= -1 ? [] : [e.slice(0, t), e.slice(t + 1).trim()];
+	});
+	return new Headers(t);
+}, N = class extends DOMException {
+	constructor(e) {
+		super(e ?? "signal is aborted without reason", "AbortError"), a(this, "isTimeout", !0);
+	}
+}, P = async (e, t) => new Promise((n, r) => {
+	let { body: i, method: a = "GET", headers: o, credentials: s, signal: c, timeout: l, onUploadProgress: u, onDownloadProgress: d } = t || {}, f = new XMLHttpRequest(), p = a.toUpperCase();
+	if (f.open(p, e, !0), k(f, o), s === "include" && (f.withCredentials = !0), f.responseType = "blob", typeof l == "number" && !Number.isNaN(l) && (f.timeout = l), u && (f.upload.onprogress = (e) => u(e.loaded, e.total, e)), d && (f.onprogress = (e) => d(e.loaded, e.total, e)), c) {
+		let e = () => f.abort();
+		c.addEventListener("abort", e, { once: !0 }), f.onloadend = () => c?.removeEventListener("abort", e);
+	}
+	f.onabort = () => r(new DOMException("signal is aborted without reason", "AbortError")), f.ontimeout = () => r(new N("请求超时")), f.onerror = () => r(/* @__PURE__ */ TypeError("网络错误")), f.onload = () => n(new Response(f.response, {
+		status: f.status,
+		statusText: f.statusText,
+		headers: M(f)
+	})), A(i, c).then((e) => f.send(["GET", "HEAD"].includes(p) ? null : e));
+}), F = (e) => {
+	let t, n = new Proxy(e, { construct(n, r) {
+		return t ? console.warn(`${e.name}为单例构造函数，只能有一个实例`) : t = new n(...r), t;
+	} });
+	return e.prototype.constructor = n, n;
+}, I = (e, t) => Object.prototype.hasOwnProperty.call(e, t), L = () => /* @__PURE__ */ new Map(), R = () => ({
+	once: (e, t, n) => {
+		e.get(t)?.delete(n[0]), e.get(t)?.size || e.delete(t);
+	},
+	signal: (e, t, n) => {
+		if (!(n[1]?.signal instanceof AbortSignal)) throw TypeError("参数 signal 类型错误。必须是一个 AbortSignal 对象");
+		n[1].signal.aborted && (e.get(t)?.delete(n[0]), e.get(t)?.size || e.delete(t), Reflect.deleteProperty(n, 0));
+	}
+}), z = () => {
+	let e = [], t = null;
+	return (n) => (e.push(n), t || (t = Promise.resolve().then(() => {
+		let t;
+		for (; t = e.shift();) t();
+	}).finally(() => {
+		t = null;
+	})), t);
+}, B = class extends Map {
+	constructor(e) {
+		super(e ? Object.entries(e) : []);
+	}
+	get(e) {
+		return super.get(e);
+	}
+	set(e, t) {
+		return super.set(e, t);
+	}
+}, V = class {
+	constructor(e) {
+		a(this, "events", new B()), a(this, "eventOptionExecutor", void 0), a(this, "scheduler", void 0), this.scheduler = e ?? z(), this.eventOptionExecutor = R();
+	}
+	addEventListener(e, t, n) {
+		if (n) {
+			let e = Object.keys(this.eventOptionExecutor);
+			if (typeof n != "object" || Array.isArray(n)) throw TypeError("参数 options 类型错误。options 应该为一个配置对象。");
+			if (!e.some((e) => I(n, e))) throw TypeError(`options 仅支持 ${e.join("、")} 参数`);
+		}
+		this.events.has(e) || this.events.set(e, L()), this.events.get(e)?.set(t, n);
+	}
+	removeEventListener(e, t) {
+		this.events.has(e) && this.events.get(e)?.delete(t);
+	}
+	on(e, t, n) {
+		this.addEventListener(e, t, n);
+	}
+	off(e, t) {
+		this.removeEventListener(e, t);
+	}
+	clear(e) {
+		return e ? this.events.delete(e) : this.events.clear() ?? !0;
+	}
+	emit(e, t) {
+		this.events.has(e) && this.scheduler(() => {
+			this.events.get(e)?.forEach((n, r) => {
+				let i = [r, n];
+				n && Object.keys(n).forEach((t) => {
+					I(this.eventOptionExecutor, t) && this.eventOptionExecutor[t](this.events, e, i);
+				}), i[0] && r(t);
+			});
+		});
+	}
+}, H = (e, t = 5, n = 0) => new Promise((r, i) => {
+	let a = (o) => {
+		e().then(r).catch((e) => {
+			if (o <= 0) return i(e);
+			let r = t - o, s = typeof n == "function" ? n(r, e) : n;
+			setTimeout(() => a(o - 1), s ?? 0);
+		});
+	};
+	a(t);
+}), U = (e) => e == null, W = (e, t) => {
+	if (U(e) || U(t)) return Object.is(e, t);
+	if (Object.is(e, t)) return !0;
+	if (typeof e != typeof t) return !1;
+	if (Array.isArray(e) && Array.isArray(t)) {
+		if (e.length !== t.length) return !1;
+		for (let n = 0, r = e.length; n < r; n++) if (!W(e[n], t[n])) return !1;
+		return !0;
+	}
+	if (typeof e == "object" && typeof t == "object") {
+		let n = Object.keys(e), r = Object.keys(t);
+		if (n.length !== r.length) return !1;
+		for (let r of n) if (!Object.hasOwnProperty.call(t, r) || !W(e[r], t[r])) return !1;
+		return !0;
+	}
+	return !1;
+};
+console.clog = (...e) => {
+	let t = typeof e[0] == "string" ? e.shift() : "==>";
+	e.unshift(`%c ${t}`, "padding: 4px 8px; border-radius: 4px; color:#fff; background: linear-gradient(90deg, #833ab4 0%, #fd1d1d 50%, #fcb045 100%);"), console.log(...e);
+};
+//#endregion
+export { a as C, o as S, e as T, g as _, B as a, c as b, P as c, D as d, E as f, _ as g, v as h, V as i, N as l, T as m, U as n, z as o, O as p, H as r, F as s, W as t, w as u, u as v, t as w, s as x, l as y };

package/dist/types/components.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/types/hooks.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/types/src/components/async-custom-show/index.d.ts

@@ -0,0 +1,22 @@
+import { FC, ReactNode, JSX } from 'react';
+export type AsyncCustomShowProps<T> = {
+    /** 异步判断 Promise */
+    when: Promise<T> | undefined | null | false;
+    /** 异步失败时的展示 */
+    fallback?: ReactNode;
+    /** 异步成功时的展示 */
+    children: (value: T | undefined | null | false) => ReactNode;
+};
+export interface AsyncCustomShowType<T> extends FC<AsyncCustomShowProps<T>> {
+    (props: AsyncCustomShowProps<T>): JSX.Element;
+}
+/**
+ * @author sonion
+ * @description 异步展示组件
+ * @param {AsyncCustomShowProps<T>} props - 组件属性
+ * @param {Promise<T> | undefined | null | false} props.when 异步判断 Promise
+ * @param {ReactNode} [props.fallback] 异步失败时的展示
+ * @param {(value: T | undefined | null | false) => ReactNode} props.children 异步成功时的展示
+ */
+declare function AsyncCustomShow<T>({ when, fallback, children, }: AsyncCustomShowProps<T>): import("react/jsx-runtime").JSX.Element;
+export default AsyncCustomShow;

package/dist/types/src/components/carousel/hooks.d.ts

@@ -0,0 +1,74 @@
+import { ReactElement } from 'react';
+export type ShowArrowType = 'always' | 'auto' | 'hover' | 'none';
+type ShowArrowHookParams = {
+    /** 箭头类型 */
+    showArrow: ShowArrowType;
+    /** 轮播图数量 */
+    length: number;
+    /** 轮播图宽度 */
+    cardWidth?: number;
+    /** 轮播图容器 */
+    wrapperRef?: HTMLElement;
+};
+/**
+ * @author sonion
+ * @description 计算是否显示左右箭头
+ * @param {ShowArrowHookParams} params - hook参数
+ * @param {ShowArrowType} params.showArrow - 箭头类型
+ * @param {number} params.length - 轮播图数量
+ * @param {number} params.cardWidth - 轮播图宽度
+ * @param {HTMLElement} params.wrapperRef - 轮播图容器
+ * @returns {(index: number)=>[boolean, boolean]} - 计算是否显示左右箭头的函数
+ */
+export declare const useShowArrow: ({ showArrow, length, cardWidth, wrapperRef, }: ShowArrowHookParams) => (index: number) => [boolean, boolean];
+export type NonLoopEndFuncType = (
+/** 切换方向 */
+direction: 'prev' | 'next', 
+/** 当前索引 */
+current: number, 
+/** 轮播图数量 */
+total: number, 
+/** 非循环轮播结束时的偏移量 */
+offset: number) => void;
+type PlayControlHookParams = {
+    /** 轮播图数量 */
+    length: number;
+    /** 是否无缝轮播 */
+    loop: boolean;
+    /** 箭头类型 */
+    showArrow: ShowArrowType;
+    /** 轮播图宽度 */
+    cardWidth?: number;
+    /** 非循环轮播结束时的回调 */
+    onNonLoopEnd?: NonLoopEndFuncType;
+    /** 非循环轮播结束时的偏移量 */
+    offsetOnEnd?: number;
+};
+/**
+ * @author sonion
+ * @description 播放轮播图控制
+ * @param {PlayControlHookParams} params - hook参数
+ * @param {number} params.length - 轮播图数量
+ * @param {boolean} params.loop - 是否无缝轮播
+ * @param {ShowArrowType} params.showArrow - 箭头类型
+ * @param {number} params.cardWidth - 轮播图宽度
+ * @param {NonLoopEndFuncType} params.onNonLoopEnd - 非循环轮播结束回调
+ * @param {number} params.offsetOnEnd - 非循环轮播结束时的偏移量
+ */
+export declare const usePlayControl: ({ length, loop, showArrow, cardWidth, onNonLoopEnd, offsetOnEnd, }: PlayControlHookParams) => readonly [(node: HTMLElement | null) => void, (direction?: "prev" | "next") => void, (index: number) => void, () => number, import('react').MutableRefObject<boolean>];
+/**
+ * 子元素重渲染的依赖的类型
+ * length 依赖 children的数量
+ * child 依赖 children本身的变化
+ */
+export type RerenderType = 'length' | 'child';
+/**
+ * @author sonion
+ * @description 创建无缝轮播结构
+ * @param {ReactElement} children - 轮播列表
+ * @param {boolean} loop - 是否无缝轮播
+ * @param {RerenderType} rerender - 子元素重渲染的依赖类型
+ * @returns {ReactElement[]} - 无缝轮播结构
+ */
+export declare const useLoopChildren: (children: ReactElement[], loop: boolean, rerender: RerenderType) => ReactElement<any, string | import('react').JSXElementConstructor<any>>[];
+export {};

package/dist/types/src/components/carousel/index.d.ts

@@ -0,0 +1,88 @@
+import { FC, CSSProperties, ReactElement } from 'react';
+import { ShowArrowType, RerenderType, NonLoopEndFuncType } from './hooks';
+type IndicatorType = 'line' | 'dot' | 'none';
+export type CarouselProps = {
+    /** 单个轮播项的宽度 */
+    cardWidth?: number;
+    /** 单个轮播项的高度 */
+    cardHeight?: number;
+    /** 轮播容器的宽度 */
+    wrapperWidth?: number;
+    /** 轮播容器的高度 */
+    wrapperHeight?: number;
+    /** 轮播项之间的间隔 */
+    gapSize?: number;
+    /** 是否无缝轮播 */
+    loop?: boolean;
+    /** 切换时间（毫秒） */
+    duration?: number;
+    /** 是否自动播放 */
+    autoPlay?: boolean;
+    /** 箭头类型 */
+    showArrow?: ShowArrowType;
+    /** 指示器类型 */
+    indicatorType?: IndicatorType;
+    /** 主轮播类名，不包括指示器 */
+    className?: string;
+    /** 主轮播样式，不包括指示器 */
+    style?: CSSProperties;
+    /** 轮播项 */
+    children: ReactElement[];
+    /** 轮播项更新依赖方式 */
+    rerender?: RerenderType;
+    /** 非循环模式下，轮播结束回调 */
+    onNonLoopEnd?: NonLoopEndFuncType;
+    /** 非循环模式下，轮播结束时的偏移量。就是提前第几张就算结束。暂不支持延后。 */
+    offsetOnEnd?: number;
+    /** 自定义渲染箭头 */
+    arrows?: [
+        /** 自定义渲染上一个箭头 */
+        FC<{
+            onClick: () => void;
+            className?: string;
+        }>,
+        /** 自定义渲染下一个箭头 */
+        FC<{
+            onClick: () => void;
+            className?: string;
+        }>
+    ];
+};
+export type CarouselRef = {
+    /** 开始播放 */
+    run: () => void;
+    /** 停止播放 */
+    stop: () => void;
+    /** 切换到上一个或下一个 */
+    stepChange: (arg: 'prev' | 'next') => void;
+    /** 跳转到指定索引 */
+    jumpChange: (arg: number) => void;
+    /** 获取当前索引 */
+    getCurrentIndex: () => number;
+};
+/**
+ * @author sonion
+ * @description 轮播组件，用于展示多个轮播项
+ * @param {CarouselProps} props - 组件的属性
+ * @param {number} [props.cardWidth] - 单个轮播项的宽度
+ * @param {number} [props.cardHeight] - 单个轮播项的高度
+ * @param {number} [props.wrapperWidth] - 轮播容器的宽度
+ * @param {number} [props.wrapperHeight] - 轮播容器的高度
+ * @param {number} [props.gapSize] - 轮播项之间的间隔
+ * @param {boolean} [props.loop] - 是否无缝循环
+ * @param {number} [props.duration=6000] - 切换时间（毫秒）
+ * @param {boolean} [props.autoPlay=true] - 是否自动播放
+ * @param {ShowArrowType} [props.showArrow='always'] - 箭头类型
+ * @param {IndicatorType} [props.indicatorType='line'] - 指示器类型
+ * @param {string} [props.className] - 主轮播类名，不包括指示器
+ * @param {CSSProperties} [props.style] - 主轮播样式，不包括指示器
+ * @param {ReactElement[]} children - 轮播项
+ * @param {RerenderType} [props.rerender='length'] - 轮播项更新依赖方式
+ * @param {(direction: 'prev' | 'next', current: number, total: number, offset: number) => void} [props.onNonLoopEnd] - 非循环模式下，轮播结束回调。
+ * @param {number} [props.offsetOnEnd=0] - 非循环模式下，轮播结束时的偏移量。就是提前第几张就算结束。暂不支持延后。
+ * @param {[FC<{ onClick: () => void; className?: string }>, FC<{ onClick: () => void; className?: string }>]} [props.arrows] - 自定义渲染箭头
+ */
+declare const Carousel: import('react').ForwardRefExoticComponent<CarouselProps & import('react').RefAttributes<CarouselRef>>;
+type CarouselType = typeof Carousel;
+export type { ShowArrowType, RerenderType, CarouselType };
+export default Carousel;

package/dist/types/src/components/custom-show/index.d.ts

@@ -0,0 +1,21 @@
+import { FC, ReactNode, JSX, PropsWithChildren } from 'react';
+export type CustomShowProps<T> = PropsWithChildren<{
+    /** 判断条件 */
+    when: T | null | undefined | false;
+    /** 不满足条件时的渲染内容 */
+    fallback?: ReactNode;
+}>;
+export interface CustomShowType<T> extends FC<CustomShowProps<T>> {
+    (props: CustomShowProps<T>): JSX.Element;
+}
+/**
+ * @author sonion
+ * @description 根据条件渲染内容，替代用三目运算和短路规则条件渲染
+ * @param {CustomShowProps<T>} props 组件属性
+ * @param {T | null | undefined | false} props.when 条件
+ * @param {ReactNode} props.fallback 不满足条件时的渲染内容
+ * @param {(value: T | null | undefined | false) => ReactNode} props.children 满足条件时的渲染内容
+ * @returns {JSX.Element} - 组件节点
+ */
+declare function CustomShow<T>({ when, fallback, children, }: CustomShowProps<T>): JSX.Element;
+export default CustomShow;

package/dist/types/src/components/error-boundary/index.d.ts

@@ -0,0 +1,31 @@
+import { Component, ErrorInfo, ReactNode } from 'react';
+export interface ErrorBoundaryProps {
+    /** 正常展示 */
+    children: ReactNode;
+    /** 错误发生时显示的回退内容 */
+    fallback: ReactNode;
+    /** 错误信息的提示文本 */
+    msg?: string;
+}
+interface State {
+    hasError: boolean;
+}
+/**
+ * @author sonion
+ * @description 错误边界组件，用于捕获子组件的错误并显示自定义的回退内容
+ * @param {ErrorBoundaryProps} props - 组件的属性
+ * @param {ReactNode} props.fallback - 错误发生时显示的回退内容
+ * @param {string} [props.msg='组件加载失败'] - 错误信息的提示文本
+ * @param {ReactNode} props.children - 子组件，可能会触发错误
+ * @returns {import('react').JSX.Element} - 组件节点
+ */
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, State> {
+    state: State;
+    private msg;
+    static getDerivedStateFromError(): State;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): ReactNode;
+}
+type ErrorBoundaryType = typeof ErrorBoundary;
+export type { ErrorBoundaryType };
+export default ErrorBoundary;

package/dist/types/src/components/index.d.ts

@@ -0,0 +1,8 @@
+export * from './carousel';
+export { default as Carousel } from './carousel';
+export * from './custom-show';
+export { default as CustomShow } from './custom-show';
+export * from './async-custom-show';
+export { default as AsyncCustomShow } from './async-custom-show';
+export * from './error-boundary';
+export { default as ErrorBoundary } from './error-boundary';

package/dist/types/src/hooks/async-guard.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @author sonion
+ * @description 异步操作锁，防止重复调用。通过返回的 Promise 确定是否执行中，执行中不可重复触发。
+ * @param {(...args: T)=>Promise<R>} asyncAction - 异步方法，需返回Promise
+ * @param {(isPending: boolean) => void} [onChange] - 状态变化回调
+ * @param {string} [msg] - 警告信息
+ * @returns {[boolean, (...args: T) => (Promise<R> | Promise<void>)]} - 返回是否执行中，执行方法
+ */
+export declare const useAsyncActionLock: <T extends unknown[], R>(asyncAction: (...args: T) => Promise<R>, onChange?: (isPending: boolean) => void, msg?: string) => readonly [boolean, (...args: T) => Promise<R> | Promise<void>];

package/dist/types/src/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './state';
+export * from './timer';
+export * from './observer';
+export * from './storage';
+export * from './async-guard';

package/dist/types/src/hooks/observer.d.ts

@@ -0,0 +1,70 @@
+type MutationObserverCallback = (entry: MutationRecord[], observer: MutationObserver) => void;
+/**
+ * @author sonion
+ * @description dom变化观察器hook
+ * @param {MutationObserverCallback} callback - 回调函数，参数为 MutationRecord[]
+ * @param {boolean} [once] - 是否只观察一次，默认false
+ */
+export declare const useMutationObserver: (callback: MutationObserverCallback, once?: boolean) => {
+    /** 开始观察 因重新生成观察器observe不会更新，故不可以observe是否更新做依赖依据 */
+    observe: (el: Node | null, options?: MutationObserverInit) => void;
+    /** 获取所有未处理的观察记录 */
+    takeRecords: () => MutationRecord[] | undefined;
+    /** 取消所有观察，用observe重新启用 */
+    disconnect: () => void | undefined;
+};
+type IntersectionObserverCallback = (
+/** 交叉目标 */
+target: Element, 
+/** 交叉目标的根元素 */
+root: Element | undefined, 
+/** 交叉观察器实例 */
+observer: IntersectionObserver) => void;
+type IntersectionObserverParams = {
+    callback: IntersectionObserverCallback;
+    rootMargin?: number;
+    threshold?: number;
+    once?: boolean;
+};
+/**
+ * @author sonion
+ * @description 视口交叉观察器hook
+ * @param {IntersectionObserverParams} params - 观察器初始化参数
+ * @param {IntersectionObserverCallback} params.callback - 加载回调。
+ * @param {number} [params.rootMargin] - 提前多少px触发
+ * @param {number} [params.threshold] - 被观察目标与观察区交叉多少触发，0-1
+ * @param {boolean} [params.once] - 是否只触发一次
+ */
+export declare const useIntersectionObserver: ({ callback, rootMargin, threshold, once, }: IntersectionObserverParams) => {
+    rootRef: Element | undefined;
+    /** 设置观察区域 */
+    setRootRef: (node: Element | null) => void;
+    /** 开始观察 */
+    observe: (el: Element | null) => void;
+    /** 取消观察 */
+    unobserve: (el: Element | null) => void | null | undefined;
+    /** 取消所有观察，用observe重新启用 */
+    disconnect: () => void | undefined;
+    /** 获取 未触发回调前，所有未处理的观察记录，触发后清空 */
+    takeRecords: () => IntersectionObserverEntry[] | undefined;
+};
+type ResizeObserverCallback = (
+/** 变化记录 */
+entry: ResizeObserverEntry, 
+/** 观察器实例 */
+observer: ResizeObserver) => void;
+/**
+ * @author sonion
+ * @description 元素尺寸变化观察器hook
+ * @param {ResizeObserverCallback} callback - 回调函数，参数为ResizeObserverEntry
+ * @param {boolean} [once] - 是否只观察一次，默认false
+ */
+export declare const useResizeObserver: (callback: ResizeObserverCallback, once?: boolean) => {
+    /** 开始观察 因重新生成观察器observe不会更新，故不可以observe是否更新做依赖依据 */
+    observe: (el: Element | null, options?: ResizeObserverOptions) => void;
+    /** 取消观察 */
+    unobserve: (el: Element | null) => void | null | undefined;
+    /** 取消所有观察，用observe重新启用 */
+    disconnect: () => void | undefined;
+};
+export {};