sard 1.0.0 → 1.0.2

package/utils/scroller/useScrollAnimation.js

@@ -0,0 +1,36 @@
+import { ticker } from "lwa";
+//#region packages/sard/utils/scroller/useScrollAnimation.ts
+/**
+* 创建一个基于 requestAnimationFrame 的动画循环。
+*
+* @param scroll 滚动模型
+* @param onScroll 每帧更新时回调
+* @param onEnd 动画结束时回调
+*/
+function useScrollAnimation(scroll) {
+	let onScroll;
+	let onEnd;
+	const tick = () => {
+		onScroll(scroll);
+		if (scroll.done()) {
+			pause();
+			onEnd(scroll);
+		}
+	};
+	const pause = () => {
+		ticker.remove(tick);
+	};
+	const play = (_onScroll, _onEnd) => {
+		onScroll = _onScroll;
+		onEnd = _onEnd;
+		pause();
+		tick();
+		ticker.add(tick);
+	};
+	return {
+		play,
+		pause
+	};
+}
+//#endregion
+export { useScrollAnimation };

package/utils/scroller/useScrollBinding.d.ts

@@ -0,0 +1,8 @@
+export declare function useScrollBinding(onTouchStart: () => void, onTouchMove: (deltaX: number, deltaY: number) => void, onTouchEnd: (deltaX: number, deltaY: number, v: {
+    x: number;
+    y: number;
+}, event: TouchEvent) => void): {
+    handleTouchStart: (event: TouchEvent) => void;
+    handleTouchMove: (event: TouchEvent) => void;
+    handleTouchEnd: (event: TouchEvent) => void;
+};

package/utils/scroller/useScrollBinding.js

@@ -0,0 +1,51 @@
+import { useInitialVelocity } from "../../use/useInitialVelocity.js";
+//#region packages/sard/utils/scroller/useScrollBinding.ts
+function useScrollBinding(onTouchStart, onTouchMove, onTouchEnd) {
+	const initVelocity = useInitialVelocity();
+	let startX = 0;
+	let startY = 0;
+	let deltaX = 0;
+	let deltaY = 0;
+	/**
+	* 处理手势开始，初始化位置与历史数据。
+	*/
+	function handleTouchStart(event) {
+		if (event.cancelable) event.preventDefault();
+		const { clientX, clientY } = event.touches[0];
+		startX = clientX;
+		startY = clientY;
+		deltaX = 0;
+		deltaY = 0;
+		initVelocity.start(clientX, clientY);
+		onTouchStart();
+	}
+	/**
+	* 处理手势移动，并将速度数据累积到历史记录中。
+	*/
+	function handleTouchMove(event) {
+		if (event.cancelable) event.preventDefault();
+		const { clientX, clientY } = event.touches[0];
+		deltaX = clientX - startX;
+		deltaY = clientY - startY;
+		initVelocity.move(clientX, clientY);
+		onTouchMove(deltaX, deltaY);
+	}
+	/**
+	* 处理手势结束，并根据历史速度计算惯性滚动速度。
+	*/
+	function handleTouchEnd(event) {
+		if (event.cancelable) event.preventDefault();
+		const { x, y } = initVelocity.end();
+		onTouchEnd(deltaX, deltaY, {
+			x: x * 1e3,
+			y: y * 1e3
+		}, event);
+	}
+	return {
+		handleTouchStart,
+		handleTouchMove,
+		handleTouchEnd
+	};
+}
+//#endregion
+export { useScrollBinding };

package/utils/scroller/useScroller.d.ts

@@ -0,0 +1,39 @@
+import { type Ref } from 'vue';
+import type { Friction } from './Friction';
+import type { Spring } from './Spring';
+interface OnScrollEvent {
+    target: {
+        scrollLeft: number;
+        scrollTop: number;
+        scrollHeight: number;
+        scrollWidth: number;
+        offsetHeight: number;
+        offsetWidth: number;
+    };
+}
+export interface ScrollerOptions {
+    enableSnap?: boolean;
+    itemSize?: number;
+    enableX?: boolean;
+    enableY?: boolean;
+    scrollWidth?: number;
+    scrollHeight?: number;
+    friction?: Friction;
+    spring?: Spring;
+    onScroll?: (event: OnScrollEvent) => void;
+    onSnap?: (index: number) => void;
+    onTap?: (event: TouchEvent) => void;
+}
+/**
+ * 触摸滚动器，负责处理触摸/鼠标滚动交互、惯性滚动、越界回弹和 snap 对齐。
+ * @param element 滚动的 DOM 容器元素
+ */
+export declare function useScroller(element: Ref<HTMLElement | null>, options: ScrollerOptions): {
+    update: (height?: number, _scrollHeight?: number, _itemSize?: number) => void;
+    scrollTo: (_position: number, time?: number) => Promise<void>;
+    isIdle: () => boolean;
+    handleTouchStart: (event: TouchEvent) => void;
+    handleTouchMove: (event: TouchEvent) => void;
+    handleTouchEnd: (event: TouchEvent) => void;
+};
+export {};

package/utils/scroller/useScroller.js

@@ -0,0 +1,210 @@
+import { isFunction } from "../is.js";
+import { useScrollBinding } from "./useScrollBinding.js";
+import { Scroll } from "./Scroll.js";
+import { useEasingAnimation } from "./useEasingAnimation.js";
+import { useScrollAnimation } from "./useScrollAnimation.js";
+import { computed, ref, watch, watchPostEffect } from "vue";
+//#region packages/sard/utils/scroller/useScroller.ts
+/**
+* 计算当前滚动位置对应的 snap 索引。
+*
+* @param position 当前滚动偏移值
+* @param itemSize 单个项的高度或宽度
+*/
+function calculateSnapIndex(position, itemSize) {
+	return Math.round(Math.abs(position) / itemSize);
+}
+/**
+* 触摸滚动器，负责处理触摸/鼠标滚动交互、惯性滚动、越界回弹和 snap 对齐。
+* @param element 滚动的 DOM 容器元素
+*/
+function useScroller(element, options) {
+	/** 单项尺寸，用于 snap 计算 */
+	let itemSize = options.itemSize || 0;
+	/** 是否启用 snap 对齐 */
+	const enableSnap = computed(() => options.enableSnap);
+	/** 是否启用水平滚动 */
+	const enableX = computed(() => options.enableX);
+	/** 是否启用垂直滚动 */
+	const enableY = computed(() => options.enableY);
+	/** 可滚动范围大小 */
+	let extent = 0;
+	/** 可滚动内容宽度 */
+	let scrollWidth = 0;
+	/** 可滚动内容高度 */
+	let scrollHeight = 0;
+	/** 当前滚动偏移位置 */
+	const position = ref(0);
+	/** 滚动物理模型 */
+	const scroll = new Scroll(extent, options.friction, options.spring);
+	/** 触摸开始时的位置基准 */
+	let startPosition = 0;
+	/** 当前滚动的状态 */
+	let status = "idle";
+	/** 缓动动画 */
+	const easingAnim = useEasingAnimation(position);
+	/** 滚动动画 */
+	const scrollAnim = useScrollAnimation(scroll);
+	/**
+	* 将当前位置对齐到最近的 snap 项。
+	*/
+	const snap = (time) => {
+		const _itemSize = itemSize;
+		const _position = position.value % _itemSize;
+		const i = Math.abs(_position) > _itemSize / 2 ? position.value - (_itemSize - Math.abs(_position)) : position.value - _position;
+		if (position.value !== i) scrollTo(-i, time).then(() => {
+			if (isFunction(options.onSnap)) options.onSnap(Math.round(Math.abs(position.value) / _itemSize));
+		});
+		else status = "idle";
+	};
+	/**
+	* 直接滚动到指定位置。
+	*/
+	const scrollTo = async (_position, time = 200) => {
+		scrollAnim.pause();
+		_position = -_position;
+		if (_position < -extent) _position = -extent;
+		else if (_position > 0) _position = 0;
+		status = "easing";
+		return easingAnim.play(_position, time).then(() => {
+			status = "idle";
+		});
+	};
+	/**
+	* 触发 onScroll 回调，仅在位置实际变化时执行。
+	*/
+	const dispatchScroll = () => {
+		const el = element.value;
+		if (!el) return;
+		if (isFunction(options.onScroll)) {
+			const event = { target: {
+				scrollLeft: enableX.value ? -position.value : 0,
+				scrollTop: enableY.value ? -position.value : 0,
+				scrollHeight: scrollHeight || el.offsetHeight,
+				scrollWidth: scrollWidth || el.offsetWidth,
+				offsetHeight: el.parentElement.offsetHeight,
+				offsetWidth: el.parentElement.offsetWidth
+			} };
+			options.onScroll(event);
+		}
+	};
+	/**
+	* 更新滚动范围、位置、itemSize，并根据变化派发事件与 snap 回调。
+	*/
+	const update = (height, _scrollHeight, _itemSize) => {
+		const el = element.value;
+		if (!el) return;
+		let nextExtent = 0;
+		const _position = position.value;
+		if (enableX.value) {
+			nextExtent = el.childNodes.length ? (_scrollHeight || el.offsetWidth) - el.parentElement.offsetWidth : 0;
+			scrollWidth = _scrollHeight || 0;
+		} else {
+			nextExtent = el.childNodes.length ? (_scrollHeight || el.offsetHeight) - el.parentElement.offsetHeight : 0;
+			scrollHeight = _scrollHeight || 0;
+		}
+		if (typeof height === "number") position.value = -height;
+		if (position.value < -nextExtent) position.value = -nextExtent;
+		else if (position.value > 0) position.value = 0;
+		itemSize = _itemSize || itemSize;
+		if (_position !== position.value) {
+			if (isFunction(options.onSnap)) options.onSnap(Math.round(Math.abs(position.value) / itemSize));
+		}
+		extent = nextExtent;
+		scroll.extent = nextExtent;
+	};
+	/**
+	* 判断当前是否处于空闲
+	*/
+	const isIdle = () => {
+		return status === "idle";
+	};
+	/**
+	* 触摸开始时调用，停止现有动画并记录当前滚动位置。
+	*/
+	const onTouchStart = () => {
+		startPosition = position.value;
+		if (startPosition > 0) startPosition /= .5;
+		else if (startPosition < -extent) startPosition = (startPosition + extent) / .5 - extent;
+		scrollAnim.pause();
+		easingAnim.pause();
+		if (status !== "idle") status = "drag";
+	};
+	/**
+	* 根据手势移动距离更新当前位置，并触发滚动事件。
+	*/
+	const onTouchMove = (x, y) => {
+		status = "drag";
+		let nextPos = startPosition;
+		if (enableX.value) nextPos += x;
+		else if (enableY.value) nextPos += y;
+		if (nextPos > 0) nextPos *= .5;
+		else if (nextPos < -extent) nextPos = .5 * (nextPos + extent) - extent;
+		position.value = nextPos;
+	};
+	/**
+	* 触摸结束时启动惯性滚动，必要时进行 snap 对齐。
+	*/
+	const onTouchEnd = (x, y, o, event) => {
+		if (status === "idle") {
+			options.onTap?.(event);
+			return;
+		}
+		if (enableSnap.value && position.value > -extent && position.value < 0) {
+			if (enableY.value && (Math.abs(y) < itemSize && Math.abs(o.y) < 300 || Math.abs(o.y) < 150)) {
+				snap();
+				return;
+			}
+			if (enableX.value && (Math.abs(x) < itemSize && Math.abs(o.x) < 300 || Math.abs(o.x) < 150)) {
+				snap();
+				return;
+			}
+		}
+		if (enableX.value) scroll.set(position.value, o.x);
+		else if (enableY.value) scroll.set(position.value, o.y);
+		let c;
+		if (enableSnap.value) {
+			const s = scroll.friction.position(100);
+			const l = s % itemSize;
+			c = Math.abs(l) > itemSize / 2 ? s - (itemSize - Math.abs(l)) : s - l;
+			if (c <= 0 && c >= -extent) scroll.setVelocityByEnd(c);
+		}
+		status = "scroll";
+		scrollAnim.play(() => {
+			const pos = scroll.position((Date.now() - scroll.startTime) / 1e3);
+			position.value = pos;
+		}, () => {
+			status = "idle";
+			if (enableSnap.value) {
+				if (c <= 0 && c >= -extent) {
+					scroll.setVelocityByEnd(c);
+					position.value = c;
+				}
+				if (isFunction(options.onSnap)) options.onSnap(calculateSnapIndex(position.value, itemSize));
+			}
+		});
+	};
+	const { handleTouchStart, handleTouchMove, handleTouchEnd } = useScrollBinding(onTouchStart, onTouchMove, onTouchEnd);
+	watchPostEffect(() => {
+		const el = element.value;
+		if (el) {
+			let transform = "";
+			if (enableX.value) transform = "translateX(" + position.value + "px) translateZ(0)";
+			else if (enableY.value) transform = "translateY(" + position.value + "px) translateZ(0)";
+			el.style.transform = transform;
+		}
+	});
+	watch(position, () => {
+		dispatchScroll();
+	});
+	return {
+		update,
+		scrollTo,
+		isIdle,
+		handleTouchStart,
+		handleTouchMove,
+		handleTouchEnd
+	};
+}
+//#endregion
+export { useScroller };

package/utils/string.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 将字符串首字母转换为小写格式。
+ */
+export declare function lowerFirst(string: string): string;
+/**
+ * 将字符串首字母转换为大写格式。
+ */
+export declare function upperFirst(string: string): string;
+/**
+ * 将字符串转换为 PascalCase 格式（大驼峰）。
+ */
+export declare function pascalCase(string: string): string;
+/**
+ * 将字符串转换为 camelCase 格式（小驼峰）。
+ */
+export declare function camelCase(string: string): string;
+/**
+ * 将字符串转换为 Capitalize 格式（首字母大写，其余小写）。
+ */
+export declare function capitalize(string: string): string;
+/**
+ * 将字符串转换为 kebab-case 格式（使用连字符拼接单词）。
+ */
+export declare function kebabCase(string: string): string;
+/**
+ * 将字符串转换为 snake_case 格式（使用下划线拼接单词）。
+ */
+export declare function snakeCase(string: string): string;
+/**
+ * 每n位数字添加一个分隔符
+ */
+export declare function addSeparator(num: number | string, separator?: string, digit?: number): string;
+export declare function uniqid(): string;
+/**
+ * 判断是否为韩文字符
+ */
+export declare function isKorean(text: string): boolean;

package/utils/string.js

@@ -0,0 +1,68 @@
+//#region packages/sard/utils/string.ts
+function splitWord(string) {
+	return string.split(/[^a-zA-Z0-9$]+/).map((item) => item.split(/([A-Z][^A-Z]*)/)).flat().filter(Boolean);
+}
+/**
+* 将字符串首字母转换为小写格式。
+*/
+function lowerFirst(string) {
+	return string.replace(/^[A-Z]/, (m) => m.toLowerCase());
+}
+/**
+* 将字符串首字母转换为大写格式。
+*/
+function upperFirst(string) {
+	return string.replace(/^[a-z]/, (m) => m.toUpperCase());
+}
+/**
+* 将字符串转换为 PascalCase 格式（大驼峰）。
+*/
+function pascalCase(string) {
+	return splitWord(string).map((word) => upperFirst(word.toLowerCase())).join("");
+}
+/**
+* 将字符串转换为 camelCase 格式（小驼峰）。
+*/
+function camelCase(string) {
+	return lowerFirst(pascalCase(string));
+}
+/**
+* 将字符串转换为 Capitalize 格式（首字母大写，其余小写）。
+*/
+function capitalize(string) {
+	return upperFirst(string.toLowerCase());
+}
+/**
+* 将字符串转换为 kebab-case 格式（使用连字符拼接单词）。
+*/
+function kebabCase(string) {
+	return splitWord(string).map((item) => item.toLowerCase()).join("-");
+}
+/**
+* 将字符串转换为 snake_case 格式（使用下划线拼接单词）。
+*/
+function snakeCase(string) {
+	return splitWord(string).map((item) => item.toLowerCase()).join("_");
+}
+/**
+* 每n位数字添加一个分隔符
+*/
+function addSeparator(num, separator = ",", digit = 3) {
+	return String(num).replace(new RegExp(`\\B(?=(\\d{${digit}})+(?!\\d))`, "g"), separator);
+}
+/**
+* 生成唯一ID，可作为元素选择器，或者用于表示全局唯一字符串，仅限于当前应用生命周期
+*/
+let counter = 0;
+const uid = "sard-" + (~~(Math.random() * 1e9)).toString(36);
+function uniqid() {
+	return uid + "-" + (++counter).toString(36);
+}
+/**
+* 判断是否为韩文字符
+*/
+function isKorean(text) {
+	return /([\uAC00-\uD7AF\u3130-\u318F])+/gi.test(text);
+}
+//#endregion
+export { addSeparator, camelCase, capitalize, isKorean, kebabCase, lowerFirst, pascalCase, snakeCase, uniqid, upperFirst };

package/utils/tree.d.ts

@@ -0,0 +1,26 @@
+type TNode = {
+    children?: TNode[];
+    parent: TNode | null;
+    checked: boolean;
+    indeterminate: boolean;
+    key: number | string;
+    [k: string]: any;
+};
+export declare function walkDescendant<T extends TNode>(node: T, callback: (node: T) => boolean | void | undefined): void;
+export declare function walkAncestor<T extends TNode>(node: T | null, callback: (node: T) => void): void;
+export declare function walkNodes<T extends TNode>(nodes: T[], callback: (node: T) => void): void | boolean;
+export declare function getNodeLevel<T extends TNode>(node: T): number;
+export declare function setCheckedRecursively<T extends TNode>(node: T, checked: boolean, strictly?: boolean): void;
+export declare function updateAncestorsChecked<T extends TNode>(parentNode: T | null, strictly?: boolean): void;
+export declare function initializeCheckNodes<T extends TNode>(nodes: T[], treeMap: Record<string | number, T>, keys: (string | number)[], strictly?: boolean): void;
+export declare function getTreeCheckedKeys<T extends TNode>(nodes: T[]): (string | number)[];
+export declare function getTreeHalfCheckedKeys<T extends TNode>(nodes: T[]): (string | number)[];
+/**
+ * 将嵌套的列配置转换为可以跨多行和多列的表格
+ */
+export declare function mapTreeToGrid<T, R>(columns: T[], map: (col: T, rowspan: number, colspan: number, left: number, right: number) => R, childrenKey?: keyof T): R[][];
+/**
+ * 获取树形结构中的所有叶子节点
+ */
+export declare function getLeafNodes<T>(tree: T[], childrenKey?: keyof T): T[];
+export {};

package/utils/tree.js

@@ -0,0 +1,141 @@
+import { isNoEmptyArray } from "./is.js";
+//#region packages/sard/utils/tree.ts
+function walkDescendant(node, callback) {
+	if (!callback(node) && node.children) node.children.forEach((node) => {
+		walkDescendant(node, callback);
+	});
+}
+function walkAncestor(node, callback) {
+	if (node) {
+		callback(node);
+		walkAncestor(node.parent, callback);
+	}
+}
+function walkNodes(nodes, callback) {
+	nodes.forEach((node) => {
+		callback(node);
+		if (node.children) walkNodes(node.children, callback);
+	});
+}
+function getNodeLevel(node) {
+	let level = 0;
+	while (node.parent) {
+		level++;
+		node = node.parent;
+	}
+	return level;
+}
+function setCheckedRecursively(node, checked, strictly) {
+	if (strictly) node.checked = checked;
+	else {
+		walkDescendant(node, (node) => {
+			node.checked = checked;
+			node.indeterminate = false;
+		});
+		updateAncestorsChecked(node.parent);
+	}
+}
+function updateAncestorsChecked(parentNode, strictly) {
+	if (!strictly) walkAncestor(parentNode, (node) => {
+		const children = node.children || [];
+		const numChecked = children.filter((node) => node.checked).length;
+		node.checked = numChecked > 0 && numChecked === children.length;
+		node.indeterminate = !node.checked && (numChecked > 0 || children.some((node) => node.indeterminate));
+	});
+}
+function initializeCheckNodes(nodes, treeMap, keys, strictly) {
+	if (strictly) {
+		const mapKeys = keys.reduce((map, key) => {
+			map[key] = true;
+			return map;
+		}, {});
+		walkNodes(nodes, (node) => {
+			node.checked = mapKeys[node.key] ? true : false;
+		});
+	} else {
+		walkNodes(nodes, (node) => {
+			node.checked = false;
+			node.indeterminate = false;
+		});
+		keys.forEach((key) => {
+			const node = treeMap[key];
+			if (node && !node.checked) setCheckedRecursively(node, true, strictly);
+		});
+	}
+}
+function getTreeCheckedKeys(nodes) {
+	const checkedKeys = [];
+	walkNodes(nodes, (node) => {
+		if (node.checked) checkedKeys.push(node.key);
+	});
+	return checkedKeys;
+}
+function getTreeHalfCheckedKeys(nodes) {
+	const halfCheckedKeys = [];
+	walkNodes(nodes, (node) => {
+		if (node.indeterminate) halfCheckedKeys.push(node.key);
+	});
+	return halfCheckedKeys;
+}
+/**
+* 将嵌套的列配置转换为可以跨多行和多列的表格
+*/
+function mapTreeToGrid(columns, map, childrenKey = "children") {
+	if (!isNoEmptyArray(columns)) return [];
+	const maxDepth = getMaxDepth(columns, childrenKey);
+	const result = Array.from({ length: maxDepth }, () => []);
+	function processNode(col, level = 0, left = 0) {
+		if (!isNoEmptyArray(col[childrenKey])) {
+			const remainingLevels = maxDepth - level;
+			result[level].push(map(col, remainingLevels, 1, left, left + 1));
+			return {
+				colspan: 1,
+				left
+			};
+		}
+		const children = col[childrenKey];
+		let childLeft = left;
+		let totalColspan = 0;
+		for (const child of children) {
+			const { colspan } = processNode(child, level + 1, childLeft);
+			childLeft += colspan;
+			totalColspan += colspan;
+		}
+		result[level].push(map(col, 1, totalColspan, left, left + totalColspan));
+		return {
+			colspan: totalColspan,
+			left
+		};
+	}
+	let currentLeft = 0;
+	for (const col of columns) {
+		const { colspan } = processNode(col, 0, currentLeft);
+		currentLeft += colspan;
+	}
+	return result;
+}
+/**
+* 计算最大深度（层级数）
+*/
+function getMaxDepth(cols, childrenKey) {
+	let maxDepth = 1;
+	for (const col of cols) if (isNoEmptyArray(col[childrenKey])) {
+		const childDepth = getMaxDepth(col[childrenKey], childrenKey) + 1;
+		maxDepth = Math.max(maxDepth, childDepth);
+	}
+	return maxDepth;
+}
+/**
+* 获取树形结构中的所有叶子节点
+*/
+function getLeafNodes(tree, childrenKey = "children") {
+	const result = [];
+	function traverse(node) {
+		if (isNoEmptyArray(node[childrenKey])) for (const child of node[childrenKey]) traverse(child);
+		else result.push(node);
+	}
+	for (const node of tree) traverse(node);
+	return result;
+}
+//#endregion
+export { getLeafNodes, getNodeLevel, getTreeCheckedKeys, getTreeHalfCheckedKeys, initializeCheckNodes, mapTreeToGrid, setCheckedRecursively, updateAncestorsChecked, walkAncestor, walkDescendant, walkNodes };

package/utils/utils.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @description: 判断一个对象是否为看得到的空
+ * @param {any} target
+ * @return {boolean}
+ */
+export declare function isVisibleEmpty(target: any): boolean;
+/**
+ * @description: 判断一个值是否为空
+ * @param {any} value
+ * @return {boolean}
+ */
+export declare function isEmptyValue(value: any, whitespace?: boolean): boolean;
+/**
+ * @description: 判断一个值渲染到DOM中时是否可见
+ * @param {any} value
+ * @return {boolean}
+ */
+export declare function isRenderVisible(value: any): boolean;
+/**
+ * @description: 判断是否绑定为空值
+ * @param {any} target
+ * @return {boolean}
+ */
+export declare function isEmptyBinding(target: any): target is '' | null | undefined;
+export interface DebounceOptions {
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number, options?: DebounceOptions): {
+    (...args: any[]): ReturnType<T>;
+    cancel: () => void;
+    flush: () => ReturnType<T>;
+};
+export declare function throttle<T extends (...args: any[]) => any>(func: T, wait?: number, options?: DebounceOptions): {
+    (...args: any[]): ReturnType<T>;
+    cancel: () => void;
+    flush: () => ReturnType<T>;
+};
+/**
+ * @description: 获取页面范围
+ * @param {number} current 当前页码
+ * @param {number} pageCount 总页数
+ * @param {number} pageItemCount 要展示的页数
+ * @return {[number, number]}
+ */
+export declare function getPageRange(current: number, pageCount: number, pageItemCount: number): number[];
+/**
+ * @description: 将一个可选单位的字符串或数值拆分为数值和单位组成的数组
+ * @param {number | string} target
+ * @return {[number, string]}
+ */
+export declare function splitUnit(target: number | string): [number, string];
+export declare function addUnit(value: number | string): string | number;
+export declare const noop: () => void;
+export declare function sleep(time: number): Promise<void>;