sard 1.0.0 → 1.0.2

package/utils/utils.js

@@ -0,0 +1,163 @@
+import { isNumber, isObject, isPlainObject } from "./is.js";
+//#region packages/sard/utils/utils.ts
+/**
+* @description: 判断一个对象是否为看得到的空
+* @param {any} target
+* @return {boolean}
+*/
+function isVisibleEmpty(target) {
+	return target === null || target === void 0 || typeof target === "string" && target.trim() === "";
+}
+/**
+* @description: 判断一个值是否为空
+* @param {any} value
+* @return {boolean}
+*/
+function isEmptyValue(value, whitespace = true) {
+	return value === null || value === void 0 || value === "" || typeof value === "string" && !whitespace && value.trim() === "" || Array.isArray(value) && value.length === 0;
+}
+/**
+* @description: 判断一个值渲染到DOM中时是否可见
+* @param {any} value
+* @return {boolean}
+*/
+function isRenderVisible(value) {
+	return value !== null && value !== void 0 && (typeof value !== "string" || value.trim() !== "");
+}
+/**
+* @description: 判断是否绑定为空值
+* @param {any} target
+* @return {boolean}
+*/
+function isEmptyBinding(target) {
+	return target === null || target === void 0 || target === "";
+}
+function debounce(func, wait = 0, options = {}) {
+	let lastArgs;
+	let maxWait = 0;
+	let result;
+	let timerId;
+	let lastCallTime;
+	let lastInvokeTime = 0;
+	let leading = false;
+	let maxing = false;
+	let trailing = true;
+	if (isObject(options)) {
+		leading = !!options.leading;
+		maxing = "maxWait" in options;
+		maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;
+		trailing = "trailing" in options ? !!options.trailing : trailing;
+	}
+	function invokeFunc(time) {
+		const args = lastArgs || [];
+		lastInvokeTime = time;
+		result = func(...args);
+		return result;
+	}
+	function leadingEdge(time) {
+		lastInvokeTime = time;
+		timerId = setTimeout(timerExpired, wait);
+		return leading ? invokeFunc(time) : result;
+	}
+	function remainingWait(time) {
+		const timeSinceLastCall = time - lastCallTime;
+		const timeSinceLastInvoke = time - lastInvokeTime;
+		const timeWaiting = wait - timeSinceLastCall;
+		return maxing ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+	}
+	function shouldInvoke(time) {
+		if (lastCallTime === void 0) return true;
+		const timeSinceLastCall = time - lastCallTime;
+		const timeSinceLastInvoke = time - lastInvokeTime;
+		return timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+	}
+	function timerExpired() {
+		const time = Date.now();
+		if (shouldInvoke(time)) return trailingEdge(time);
+		timerId = setTimeout(timerExpired, remainingWait(time));
+	}
+	function trailingEdge(time) {
+		timerId = void 0;
+		if (trailing && lastArgs) return invokeFunc(time);
+		lastArgs = void 0;
+		return result;
+	}
+	function cancel() {
+		if (timerId !== void 0) clearTimeout(timerId);
+		lastInvokeTime = 0;
+		lastArgs = lastCallTime = timerId = void 0;
+	}
+	function flush() {
+		return timerId === void 0 ? result : trailingEdge(Date.now());
+	}
+	function debounced(...args) {
+		const time = Date.now();
+		const isInvoking = shouldInvoke(time);
+		lastArgs = args;
+		lastCallTime = time;
+		if (isInvoking) {
+			if (timerId === void 0) return leadingEdge(lastCallTime);
+			if (maxing) {
+				clearTimeout(timerId);
+				timerId = setTimeout(timerExpired, wait);
+				return invokeFunc(lastCallTime);
+			}
+		}
+		if (timerId === void 0) timerId = setTimeout(timerExpired, wait);
+		return result;
+	}
+	debounced.cancel = cancel;
+	debounced.flush = flush;
+	return debounced;
+}
+function throttle(func, wait = 0, options = {}) {
+	let leading = true;
+	let trailing = true;
+	if (isPlainObject(options)) {
+		leading = "leading" in options ? !!options.leading : leading;
+		trailing = "trailing" in options ? !!options.trailing : trailing;
+	}
+	return debounce(func, wait, {
+		leading,
+		trailing,
+		maxWait: wait
+	});
+}
+/**
+* @description: 获取页面范围
+* @param {number} current 当前页码
+* @param {number} pageCount 总页数
+* @param {number} pageItemCount 要展示的页数
+* @return {[number, number]}
+*/
+function getPageRange(current, pageCount, pageItemCount) {
+	let min = current - Math.ceil((pageItemCount - 1) / 2);
+	let max = current + Math.floor((pageItemCount - 1) / 2);
+	const minLack = 1 - min;
+	const maxLack = max - pageCount;
+	if (maxLack > 0) min -= maxLack;
+	if (min < 1) min = 1;
+	if (minLack > 0) max += minLack;
+	if (max > pageCount) max = pageCount;
+	return [min, max];
+}
+/**
+* @description: 将一个可选单位的字符串或数值拆分为数值和单位组成的数组
+* @param {number | string} target
+* @return {[number, string]}
+*/
+function splitUnit(target) {
+	const result = /([+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|))([a-z]+|%|)$/i.exec(String(target)) || [0, ""];
+	return [+result[1], result[2]];
+}
+function addUnit(value) {
+	return value && (isNumber(value) || /\d$/.test(value)) ? value + "px" : value;
+}
+const noop = () => {};
+async function sleep(time) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, time);
+	});
+}
+//#endregion
+export { addUnit, debounce, getPageRange, isEmptyBinding, isEmptyValue, isRenderVisible, isVisibleEmpty, noop, sleep, splitUnit, throttle };

package/utils/vnode.d.ts

@@ -0,0 +1,9 @@
+import { type VNode } from 'vue';
+export declare function flatVNode(nodes: any): VNode[];
+export declare const OnlyChild: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    update(_el: HTMLElement | null): true;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onUpdate?: ((_el: HTMLElement | null) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/utils/vnode.js

@@ -0,0 +1,69 @@
+import { isObject } from "./is.js";
+import { logError } from "./log.js";
+import { Comment, Fragment, Text, cloneVNode, createVNode, defineComponent, isVNode, withDirectives } from "vue";
+//#region packages/sard/utils/vnode.tsx
+function flatVNode(nodes) {
+	const array = [];
+	if (Array.isArray(nodes)) nodes.forEach((vnode) => {
+		if (isVNode(vnode)) {
+			if (vnode.type === Fragment) array.push(...flatVNode(vnode.children));
+			else if (vnode.type !== Comment) array.push(vnode);
+		} else if (Array.isArray(vnode)) array.push(...flatVNode(vnode));
+	});
+	return array;
+}
+function wrapTextContent(s) {
+	return createVNode("span", null, [s]);
+}
+function findFirstLegitChild(node) {
+	if (!node) return [null, 0];
+	const children = node;
+	const len = children.filter((c) => c.type !== Comment).length;
+	for (const child of children) {
+		/**
+		* when user uses h(Fragment, [text]) to render plain string,
+		* this switch case just cannot handle, when the value is primitives
+		* we should just return the wrapped string
+		*/
+		if (isObject(child)) switch (child.type) {
+			case Comment: continue;
+			case Text:
+			case "svg": return [wrapTextContent(child), len];
+			case Fragment: return findFirstLegitChild(child.children);
+			default: return [child, len];
+		}
+		return [wrapTextContent(child), len];
+	}
+	return [null, 0];
+}
+const OnlyChild = defineComponent({
+	emits: { update(_el) {
+		return true;
+	} },
+	setup(_, { slots, attrs, emit }) {
+		const getElDirective = {
+			mounted(el) {
+				emit("update", el);
+			},
+			updated(el) {
+				emit("update", el);
+			},
+			unmounted() {
+				emit("update", null);
+			}
+		};
+		return () => {
+			const defaultSlot = slots.default?.(attrs);
+			if (!defaultSlot) return null;
+			const [firstLegitNode, length] = findFirstLegitChild(defaultSlot);
+			if (!firstLegitNode) {
+				logError("no valid child node found");
+				return null;
+			}
+			if (length > 1) logError("requires exact only one valid child.");
+			return withDirectives(cloneVNode(firstLegitNode, attrs), [[getElDirective]]);
+		};
+	}
+});
+//#endregion
+export { OnlyChild, flatVNode };