@kylexd/composable-kit 0.0.1

package/dist/useRsa-aK-vaZUD.js

@@ -0,0 +1,739 @@
+import { l as formatParams, t as dayjsInstance, u as deepClone } from "./dayjs-BXpdKo4H.js";
+import { nextTick, onBeforeUnmount, reactive, ref, watch } from "vue";
+import Cookies from "js-cookie";
+import isMobile from "ismobilejs";
+import qrcode from "qrcode";
+import JSEncrypt from "jsencrypt";
+//#region src/composables/useCache.ts
+var defaultBaseKey = "hooks-useCache-";
+var defaultMemoryStorage = /* @__PURE__ */ new Map();
+function useCache(options) {
+	const { key, time, useMemory = false, storageType = "localStorage", baseKey = defaultBaseKey, memoryStorage = defaultMemoryStorage, exposeMemoryToWindow } = options;
+	const cacheKey = baseKey + key;
+	if (exposeMemoryToWindow && typeof window !== "undefined") window[exposeMemoryToWindow] = memoryStorage;
+	const cacheData = ref(useMemory ? getDataFromMemory(cacheKey, time, memoryStorage) : getDataFromStorage(cacheKey, time, storageType));
+	watch(cacheData, (newData) => {
+		if (newData !== null && newData !== void 0) if (useMemory) setDataToMemory(cacheKey, newData, time, memoryStorage);
+		else setDataToStorage(cacheKey, newData, time, storageType);
+		else if (useMemory) memoryStorage.delete(cacheKey);
+		else getStorage(storageType).removeItem(cacheKey);
+	});
+	return {
+		cacheData,
+		clearCache: () => {
+			cacheData.value = null;
+		},
+		setCacheData: (data) => {
+			cacheData.value = data;
+		},
+		getCacheData: () => cacheData.value
+	};
+}
+function clearAllHooksCache(baseKey = defaultBaseKey, storageType = "localStorage") {
+	const storage = getStorage(storageType);
+	Object.keys(storage).forEach((key) => {
+		if (key.startsWith(baseKey)) storage.removeItem(key);
+	});
+}
+function clearAllMemoryCache(memoryStorage = defaultMemoryStorage) {
+	memoryStorage.clear();
+}
+function getStorage(storageType) {
+	return storageType === "localStorage" ? localStorage : sessionStorage;
+}
+function getDataFromStorage(key, time, storageType) {
+	const storageData = getStorage(storageType).getItem(key);
+	if (!storageData) return null;
+	const parsedData = JSON.parse(storageData);
+	if (parsedData.data === null || parsedData.data === void 0) return null;
+	if (time === 0 || Date.now() - parsedData.createdTime < time) return parsedData.data;
+	return null;
+}
+function setDataToStorage(key, data, time, storageType) {
+	getStorage(storageType).setItem(key, JSON.stringify({
+		data,
+		createdTime: Date.now(),
+		time
+	}));
+}
+function getDataFromMemory(key, time, memoryStorage) {
+	const storageData = memoryStorage.get(key);
+	if (!storageData?.data) return null;
+	if (time === 0 || Date.now() - storageData.createdTime < time) return storageData.data;
+	return null;
+}
+function setDataToMemory(key, data, time, memoryStorage) {
+	memoryStorage.set(key, {
+		data,
+		createdTime: Date.now(),
+		time
+	});
+}
+//#endregion
+//#region src/composables/useApi.ts
+function useDataApi(asyncApi, options) {
+	const loading = ref(false);
+	const data = ref();
+	const cacheDataInfo = options?.cache ? useCache(options.cache) : null;
+	const sentDataApi = async (params, asyncApiOptions) => {
+		loading.value = true;
+		if (cacheDataInfo && !asyncApiOptions?.forceRefresh) {
+			const cacheData = cacheDataInfo.cacheData.value;
+			if (cacheData) {
+				const clonedCache = deepClone(cacheData);
+				data.value = options?.format ? options.format({ data: clonedCache }, data.value) : clonedCache;
+				loading.value = false;
+				return data.value;
+			}
+		}
+		try {
+			const apiParams = params ?? options?.query?.value ?? void 0;
+			const response = await asyncApi(options?.formatParams ? options.formatParams(apiParams) : apiParams);
+			if (cacheDataInfo) cacheDataInfo.cacheData.value = response.data;
+			data.value = options?.format ? options.format(response, data.value) : response.data;
+			return data.value;
+		} catch (error) {
+			options?.onError?.(error);
+			data.value = options?.catchError ? options.catchError(error, data.value) : void 0;
+			throw error;
+		} finally {
+			loading.value = false;
+		}
+	};
+	watch(data, (newData) => {
+		if (!newData && cacheDataInfo) cacheDataInfo.cacheData.value = null;
+	});
+	return {
+		loading,
+		data,
+		sentDataApi
+	};
+}
+function useListApi(asyncApi, options) {
+	const loading = ref(false);
+	const dataList = ref();
+	const data = ref();
+	const total = ref(0);
+	const getList = async () => {
+		loading.value = true;
+		try {
+			const params = deepClone(options?.query?.value);
+			const response = await asyncApi(formatParams(params, options?.formatParamsOptions));
+			total.value = response.total;
+			dataList.value = options?.format ? options.format(response, dataList.value, params) : response.list;
+			data.value = response.data;
+			return dataList.value;
+		} catch (error) {
+			options?.onError?.(error);
+			dataList.value = options?.catchError ? options.catchError(error, dataList.value) : void 0;
+			loading.value = Boolean(options?.isCancel?.(error));
+			throw error;
+		} finally {
+			if (!loading.value) loading.value = false;
+		}
+	};
+	return {
+		loading,
+		dataList,
+		getList,
+		total,
+		data
+	};
+}
+function useScrollList(asyncApi, options) {
+	const loading = ref(false);
+	const dataList = ref();
+	const data = ref();
+	const total = ref(0);
+	const isError = ref(false);
+	const isNoMore = ref(false);
+	const getList = async () => {
+		loading.value = true;
+		try {
+			isError.value = false;
+			isNoMore.value = false;
+			const params = deepClone(options?.query?.value);
+			const response = await asyncApi(formatParams(params, options?.formatParamsOptions));
+			data.value = response.data;
+			total.value = response.total;
+			const oldList = dataList.value;
+			const newList = options?.format ? options.format(response, params) : response.list;
+			const mergeList = [...oldList || [], ...newList ?? []];
+			dataList.value = (options?.query?.value?.pageNum ?? 1) === 1 ? newList : mergeList;
+			if (!response.list || response.list.length < (options?.query?.value?.pageSize ?? 10)) isNoMore.value = true;
+			if (options?.query?.value && "pageNum" in options.query.value) options.query.value.pageNum = (options.query.value.pageNum ?? 1) + 1;
+			return dataList.value;
+		} catch (error) {
+			options?.onError?.(error);
+			isError.value = true;
+			dataList.value = options?.catchError ? options.catchError(error, dataList.value) : dataList.value;
+			throw error;
+		} finally {
+			loading.value = false;
+		}
+	};
+	return {
+		loading,
+		dataList,
+		getList,
+		total,
+		data,
+		isError,
+		isNoMore
+	};
+}
+//#endregion
+//#region src/composables/useCountdown.ts
+function createCountdownDate(value) {
+	return ref(value);
+}
+function useCountdown() {
+	const getDiff = (targetTime, unit) => {
+		if (!targetTime) return 0;
+		return dayjsInstance.utc(targetTime).diff(dayjsInstance(), unit);
+	};
+	const getCurrentDurationOfDays = (targetTime, options) => {
+		const date = createCountdownDate({
+			s: 0,
+			m: 0,
+			h: 0,
+			d: 0,
+			asSeconds: 0
+		});
+		let timer;
+		const stop = () => {
+			if (timer) clearInterval(timer);
+			timer = void 0;
+		};
+		const update = () => {
+			const seconds = getDiff(targetTime, "seconds");
+			if (seconds <= 0) {
+				stop();
+				date.value = {
+					s: 0,
+					m: 0,
+					h: 0,
+					d: 0,
+					asSeconds: 0
+				};
+				options?.stopCallback?.();
+				return;
+			}
+			date.value = {
+				s: seconds % 60,
+				m: getDiff(targetTime, "minutes") % 60,
+				h: getDiff(targetTime, "hours") % 24,
+				d: getDiff(targetTime, "days"),
+				asSeconds: seconds
+			};
+		};
+		const start = () => {
+			stop();
+			if (getDiff(targetTime, "seconds") > 0) {
+				update();
+				timer = setInterval(update, 1e3);
+			}
+		};
+		const updateTargetTime = (newTargetTime) => {
+			targetTime = newTargetTime;
+			start();
+		};
+		start();
+		return {
+			date,
+			stop,
+			updateTargetTime
+		};
+	};
+	const getCurrentDurationOfHours = (targetTime, options) => {
+		const date = createCountdownDate({
+			s: 0,
+			m: 0,
+			h: 0,
+			asSeconds: 0
+		});
+		let timer;
+		const stop = () => {
+			if (timer) clearInterval(timer);
+			timer = void 0;
+		};
+		const update = () => {
+			const seconds = getDiff(targetTime, "seconds");
+			if (seconds <= 0) {
+				stop();
+				date.value = {
+					s: 0,
+					m: 0,
+					h: 0,
+					asSeconds: 0
+				};
+				options?.stopCallback?.();
+				return;
+			}
+			date.value = {
+				s: seconds % 60,
+				m: getDiff(targetTime, "minutes") % 60,
+				h: getDiff(targetTime, "hours"),
+				asSeconds: seconds
+			};
+		};
+		const start = () => {
+			stop();
+			if (getDiff(targetTime, "seconds") > 0) {
+				update();
+				timer = setInterval(update, 1e3);
+			}
+		};
+		const updateTargetTime = (newTargetTime) => {
+			targetTime = newTargetTime;
+			start();
+		};
+		start();
+		return {
+			date,
+			stop,
+			updateTargetTime
+		};
+	};
+	return {
+		getCurrentDurationOfDays,
+		getCurrentDurationOfHours,
+		getDiff
+	};
+}
+//#endregion
+//#region src/composables/useCookies.ts
+function useCookies(options) {
+	const getDomain = () => typeof options?.domain === "function" ? options.domain() : options?.domain;
+	const setCookie = (key, value, expires) => {
+		Cookies.set(key, value, {
+			domain: getDomain(),
+			expires
+		});
+	};
+	const getCookie = (key) => Cookies.get(key);
+	const removeCookie = (key) => Cookies.remove(key, { domain: getDomain() });
+	return {
+		setCookie,
+		getCookie,
+		removeCookie
+	};
+}
+//#endregion
+//#region src/composables/useCreatedCancelApi.ts
+function useCreatedCancelApi(api) {
+	const cancel = ref(null);
+	const wrappedApi = (params) => {
+		cancel.value?.abort();
+		return api(params, { useAbortController: (controller) => {
+			cancel.value = controller;
+		} });
+	};
+	return {
+		api: wrappedApi,
+		cancel
+	};
+}
+//#endregion
+//#region src/composables/useDownload.ts
+function useDownload() {
+	const downloadBase64File = (base64, name) => downloadByHref(base64, name);
+	const downloadUrlFile = (url, name) => downloadByHref(url, name);
+	const downloadBlobFile = (blob, name) => {
+		const url = URL.createObjectURL(blob);
+		downloadByHref(url, name);
+		URL.revokeObjectURL(url);
+	};
+	return {
+		downloadBase64File,
+		downloadBlobFile,
+		downloadUrlFile
+	};
+}
+function downloadByHref(href, name) {
+	const link = document.createElement("a");
+	link.href = href;
+	link.download = name;
+	link.click();
+	link.remove();
+}
+//#endregion
+//#region src/composables/useIsMobile.ts
+function useIsMobile(userAgent = window.navigator.userAgent) {
+	const result = isMobile(userAgent);
+	return {
+		any: result.any,
+		phone: result.phone,
+		tablet: result.tablet,
+		isIOS: result.apple.device,
+		raw: result
+	};
+}
+//#endregion
+//#region src/composables/useDownloadLink.ts
+function useDownloadLink(options) {
+	const { setCookie, getCookie } = useCookies(options.cookies);
+	const keys = {
+		appleURL: options.cookieKeys?.appleURL ?? "downloadLink-turbo-apple",
+		googleURL: options.cookieKeys?.googleURL ?? "downloadLink-turbo-google"
+	};
+	function setDownloadLinkToCookie(links) {
+		setCookie(keys.appleURL, links.appleURL, options.expires ?? 36500);
+		setCookie(keys.googleURL, links.googleURL, options.expires ?? 36500);
+	}
+	function getDownloadLinkFromCookie() {
+		return {
+			appleURL: getCookie(keys.appleURL),
+			googleURL: getCookie(keys.googleURL)
+		};
+	}
+	function getDownloadLink() {
+		const cookieLinks = getDownloadLinkFromCookie();
+		return {
+			appleURL: cookieLinks.appleURL || options.defaultLinks.appleURL,
+			googleURL: cookieLinks.googleURL || options.defaultLinks.googleURL
+		};
+	}
+	function getPlatformDownloadAppLink() {
+		const links = getDownloadLink();
+		return useIsMobile(options.userAgent ?? window.navigator.userAgent).isIOS ? links.appleURL : links.googleURL;
+	}
+	function downloadApp() {
+		window.location.href = getPlatformDownloadAppLink();
+	}
+	return {
+		setDownloadLinkToCookie,
+		getDownloadLinkFromCookie,
+		getDownloadLink,
+		downloadApp,
+		getPlatformDownloadAppLink
+	};
+}
+//#endregion
+//#region src/composables/useForm.ts
+function useForm(formData, formRef, options) {
+	const originalData = deepClone(formData.value);
+	function resetForm(excludeKeys = options?.excludeKeys ?? []) {
+		const newData = deepClone(originalData);
+		excludeKeys.forEach((key) => {
+			if (key in formData.value) newData[key] = formData.value[key];
+		});
+		if ("pageSize" in formData.value) newData.pageSize = formData.value.pageSize;
+		formData.value = newData;
+		formRef?.value?.resetValidation?.();
+		nextTick(() => formRef?.value?.resetValidation?.());
+	}
+	return { resetForm };
+}
+//#endregion
+//#region src/composables/useOpenLink.ts
+function useOpenLink(options) {
+	const open = options.open ?? ((url, target) => window.open(url, target));
+	const getBaseUrl = () => typeof options.baseUrl === "function" ? options.baseUrl() : options.baseUrl;
+	const openLink = (link) => {
+		if (link.startsWith("http")) {
+			open(link, "_self");
+			return;
+		}
+		const fullLink = `${getBaseUrl()}${link}`;
+		const path = new URL(fullLink).pathname;
+		open(options.isInternalRoute?.(path) ? link : fullLink, "_self");
+	};
+	return { openLink };
+}
+//#endregion
+//#region src/composables/useParseZod.ts
+function useParseZod(defaultOptions) {
+	const parseZod = (schema, data, options) => {
+		const result = schema.safeParse(data);
+		if (!result.success) {
+			const firstError = result.error.issues[0];
+			if (firstError) (options?.onError ?? defaultOptions?.onError)?.(firstError, result.error);
+			return false;
+		}
+		return true;
+	};
+	const asyncParseZod = async (schema, data, options) => {
+		const result = schema.safeParse(data);
+		if (!result.success) {
+			const firstError = result.error.issues[0];
+			if (firstError) (options?.onError ?? defaultOptions?.onError)?.(firstError, result.error);
+			throw firstError ?? result.error;
+		}
+		return result;
+	};
+	return {
+		parseZod,
+		asyncParseZod
+	};
+}
+//#endregion
+//#region src/composables/usePcHtmlToMobile.ts
+function parseStyle(styleStr) {
+	return styleStr.split(";").reduce((style, current) => {
+		const [key, value] = current.split(":");
+		if (key && value) style[key.trim()] = value.trim();
+		return style;
+	}, {});
+}
+function parsePixelWidth(width) {
+	if (!width || width === "100%") return void 0;
+	const value = Number(width.replace("px", ""));
+	return Number.isFinite(value) ? value : void 0;
+}
+function usePcHtmlToMobile(options = {}) {
+	const baseWidth = options.baseWidth ?? 750;
+	const heightOffset = options.heightOffset ?? 50;
+	const containerRef = ref(null);
+	const adaptedHtml = ref("");
+	const contentHeight = ref(0);
+	const transformStyle = reactive({
+		scale: 1,
+		translateX: 0,
+		translateY: 0
+	});
+	let measureNode;
+	let imageLoadCleanups = [];
+	function clearImageLoadListeners() {
+		imageLoadCleanups.forEach((cleanup) => cleanup());
+		imageLoadCleanups = [];
+	}
+	function removeMeasureNode() {
+		clearImageLoadListeners();
+		measureNode?.remove();
+		measureNode = void 0;
+	}
+	function createMeasureNode() {
+		removeMeasureNode();
+		const node = document.createElement("div");
+		if (options.hiddenContainerId) node.id = options.hiddenContainerId;
+		node.setAttribute("style", "width: 0px; height: 0px; overflow: hidden;");
+		document.body.appendChild(node);
+		measureNode = node;
+		return node;
+	}
+	function normalizeLinks(content) {
+		content.querySelectorAll("a").forEach((anchor, index) => {
+			options.transformLink?.(anchor, {
+				index,
+				href: anchor.getAttribute("href"),
+				content
+			});
+			if (!options.transformLink) anchor.setAttribute("href", "javascript:void(0)");
+		});
+	}
+	function normalizeImages(content) {
+		const images = content.querySelectorAll("img");
+		let contentWidth = baseWidth;
+		images.forEach((image, index) => {
+			const src = image.getAttribute("src");
+			const style = parseStyle(image.getAttribute("style") || "");
+			const width = style.width || null;
+			const pixelWidth = parsePixelWidth(width);
+			if (pixelWidth) contentWidth = Math.max(contentWidth, pixelWidth);
+			options.transformImage?.(image, {
+				index,
+				src,
+				width,
+				style,
+				content
+			});
+			if (src) {
+				image.removeAttribute("src");
+				image.setAttribute("src", src);
+			}
+		});
+		return contentWidth;
+	}
+	function updateLayout() {
+		const visibleWidth = containerRef.value?.offsetWidth || 0;
+		if (!visibleWidth || !measureNode) return;
+		const sourceWidth = measureNode.scrollWidth;
+		if (!sourceWidth || sourceWidth < visibleWidth) {
+			transformStyle.scale = 1;
+			contentHeight.value = measureNode.scrollHeight + heightOffset;
+			return;
+		}
+		const scale = visibleWidth / sourceWidth;
+		transformStyle.scale = scale;
+		contentHeight.value = measureNode.scrollHeight * scale + heightOffset;
+		measureNode.querySelectorAll("a").forEach((anchor) => {
+			anchor.setAttribute("href", "javascript:void(0)");
+		});
+	}
+	function bindImageLoadUpdate(node) {
+		clearImageLoadListeners();
+		node.querySelectorAll("img").forEach((image) => {
+			const onLoad = () => updateLayout();
+			image.addEventListener("load", onLoad);
+			imageLoadCleanups.push(() => image.removeEventListener("load", onLoad));
+		});
+	}
+	function preventRenderedLinks() {
+		containerRef.value?.querySelectorAll("a").forEach((anchor) => {
+			anchor.addEventListener("click", (event) => {
+				event.preventDefault();
+			}, { once: false });
+		});
+	}
+	async function formatHtml(html) {
+		const node = createMeasureNode();
+		const box = document.createElement("div");
+		const template = document.createElement("template");
+		template.innerHTML = html;
+		const content = template.content;
+		normalizeLinks(content);
+		const contentWidth = normalizeImages(content);
+		box.setAttribute("style", `width: ${contentWidth}px; height: max-content;`);
+		box.appendChild(content);
+		node.appendChild(box);
+		await nextTick();
+		updateLayout();
+		bindImageLoadUpdate(node);
+		adaptedHtml.value = node.innerHTML;
+		await nextTick();
+		preventRenderedLinks();
+		return adaptedHtml.value;
+	}
+	function getClickedImageSrcList(event) {
+		const images = containerRef.value?.querySelectorAll("img") || [];
+		const x = event.clientX;
+		const y = event.clientY;
+		const srcList = [];
+		images.forEach((image) => {
+			const rect = image.getBoundingClientRect();
+			const inX = x >= rect.left && x <= rect.right;
+			const inY = y >= rect.top && y <= rect.bottom;
+			if (inX && inY) {
+				const src = image.getAttribute("src");
+				if (src) srcList.push(src);
+			}
+		});
+		return srcList;
+	}
+	function handleClick(event) {
+		event.preventDefault();
+		const srcList = getClickedImageSrcList(event);
+		if (srcList.length) options.onImageClick?.(srcList);
+		return srcList;
+	}
+	function cleanup() {
+		removeMeasureNode();
+	}
+	onBeforeUnmount(cleanup);
+	return {
+		containerRef,
+		adaptedHtml,
+		contentHeight,
+		transformStyle,
+		formatHtml,
+		updateLayout,
+		handleClick,
+		cleanup
+	};
+}
+//#endregion
+//#region src/composables/usePopupQueue.ts
+var popupQueueMap = /* @__PURE__ */ new Map();
+function usePopupQueue(options) {
+	const key = Symbol(options.key);
+	const queue = popupQueueMap.get(options.key) || [];
+	const getCurrentItem = () => queue.find((item) => item.key === key);
+	const cleanup = (item) => {
+		if (item.timer) {
+			clearTimeout(item.timer);
+			item.timer = void 0;
+		}
+	};
+	const updateStatus = (item, status) => {
+		if (item.status === status) return;
+		cleanup(item);
+		item.status = status;
+		item.onStateChange?.(status);
+	};
+	const cleanupQueue = (queueKey) => {
+		const list = popupQueueMap.get(queueKey);
+		if (!list) return;
+		const activeItems = list.filter((item) => {
+			if (item.status === "success" || item.status === "cancel") cleanup(item);
+			return item.status !== "success" && item.status !== "cancel";
+		});
+		if (activeItems.length === 0) popupQueueMap.delete(queueKey);
+		else popupQueueMap.set(queueKey, activeItems);
+	};
+	const next = () => {
+		cleanupQueue(options.key);
+		queue.find((item) => item.status === "pending")?.start();
+	};
+	const end = () => {
+		const item = getCurrentItem();
+		if (!item || item.status === "success" || item.status === "cancel") return;
+		if (item.status === "processing") {
+			updateStatus(item, "success");
+			cleanupQueue(options.key);
+			next();
+		}
+	};
+	const setupTimeout = (item) => {
+		if (!item.timeout || item.timeout <= 0) return;
+		item.timer = window.setTimeout(() => {
+			if (item.status === "processing") {
+				options.onTimeout?.();
+				end();
+			}
+		}, item.timeout);
+	};
+	const hookStart = () => {
+		const item = getCurrentItem();
+		if (item?.status === "pending") {
+			updateStatus(item, "processing");
+			setupTimeout(item);
+			options.start();
+		}
+	};
+	const cancel = () => {
+		const item = getCurrentItem();
+		if (!item || item.status === "success" || item.status === "cancel") return;
+		const wasProcessing = item.status === "processing";
+		updateStatus(item, "cancel");
+		if (wasProcessing) {
+			cleanupQueue(options.key);
+			next();
+		}
+	};
+	queue.push({
+		start: hookStart,
+		status: "pending",
+		key,
+		timeout: options.timeout,
+		onStateChange: options.onStateChange
+	});
+	popupQueueMap.set(options.key, queue);
+	if (queue.length === 1) hookStart();
+	return {
+		end,
+		cancel,
+		getStatus: () => getCurrentItem()?.status
+	};
+}
+//#endregion
+//#region src/composables/useQrCode.ts
+function useQrCode(defaultOptions) {
+	const generateQrCode = async (text, options) => {
+		return await qrcode.toDataURL(text, { width: options?.width ?? defaultOptions?.width ?? 480 });
+	};
+	return { generateQrCode };
+}
+//#endregion
+//#region src/composables/useRsa.ts
+function useRsa(options) {
+	async function encrypt(needEncryptData) {
+		const publicKey = await options.getPublicKey();
+		const jse = new JSEncrypt();
+		jse.setPublicKey(publicKey);
+		return jse.encrypt(needEncryptData) || "";
+	}
+	return { encrypt };
+}
+//#endregion
+export { clearAllHooksCache as _, useParseZod as a, useDownloadLink as c, useCreatedCancelApi as d, useCookies as f, useScrollList as g, useListApi as h, usePcHtmlToMobile as i, useIsMobile as l, useDataApi as m, useQrCode as n, useOpenLink as o, useCountdown as p, usePopupQueue as r, useForm as s, useRsa as t, useDownload as u, clearAllMemoryCache as v, useCache as y };