@kylexd/composable-kit 0.0.1

package/dist/sdk.d.ts

@@ -0,0 +1,4 @@
+export * from './sdk/useFirebase';
+export * from './sdk/useIntercom';
+export * from './sdk/useSalesmartly';
+export * from './sdk/useTurbolinkSdk';

package/dist/sdk.js

@@ -0,0 +1,2 @@
+import { a as useFirebase, n as useSalesmartly, r as useIntercom, t as useTurbolinkSdk } from "./useTurbolinkSdk-peRMONxI.js";
+export { useFirebase, useIntercom, useSalesmartly, useTurbolinkSdk };

package/dist/tree-Ck3oXYA2.js

@@ -0,0 +1,332 @@
+import { u as deepClone } from "./dayjs-BXpdKo4H.js";
+import { createApp, h, mergeProps, ref } from "vue";
+import copy from "copy-to-clipboard";
+import CryptoJS from "crypto-js";
+import { destr } from "destr";
+import { createPersistedState } from "pinia-plugin-persistedstate";
+//#region src/utils/copy.ts
+function copyText(text, options) {
+	const success = copy(text);
+	if (success) options?.onSuccess?.(text);
+	else options?.onFail?.(text);
+	return success;
+}
+//#endregion
+//#region src/utils/debounce.ts
+function debounce(fn, wait, immediate = false) {
+	let timeout = null;
+	const debounced = function(...args) {
+		const runLater = () => {
+			timeout = null;
+			if (!immediate) fn.apply(this, args);
+		};
+		const shouldCallNow = immediate && !timeout;
+		if (timeout) clearTimeout(timeout);
+		timeout = setTimeout(runLater, wait);
+		if (shouldCallNow) fn.apply(this, args);
+	};
+	debounced.cancel = () => {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = null;
+		}
+	};
+	return debounced;
+}
+//#endregion
+//#region src/utils/encryption.ts
+var defaultKeys = [
+	{
+		id: "0",
+		iv: "x7k9m2p4",
+		key: "n5v8h3j6"
+	},
+	{
+		id: "1",
+		iv: "q4w9e2r5",
+		key: "t6y7u8i9"
+	},
+	{
+		id: "2",
+		iv: "a1s2d3f4",
+		key: "g5h6j7k8"
+	},
+	{
+		id: "3",
+		iv: "z9x8c7v6",
+		key: "b4n5m6l7"
+	},
+	{
+		id: "4",
+		iv: "p0o9i8u7",
+		key: "y6t5r4e3"
+	},
+	{
+		id: "5",
+		iv: "m1n2b3v4",
+		key: "c5x6z7l8"
+	},
+	{
+		id: "6",
+		iv: "k9j8h7g6",
+		key: "f5d4s3a2"
+	},
+	{
+		id: "7",
+		iv: "w3e4r5t6",
+		key: "y7u8i9o0"
+	},
+	{
+		id: "8",
+		iv: "q1w2e3r4",
+		key: "t5y6u7i8"
+	},
+	{
+		id: "9",
+		iv: "a9s8d7f6",
+		key: "g4h5j6k7"
+	}
+];
+var defaultAlphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+function encrypt(text, keyIndex, options) {
+	const { key, letter } = getEncryptionParams(options?.keys ?? defaultKeys, options?.alphabet ?? defaultAlphabet, keyIndex);
+	const encryptedArray = encryptCore(text, key);
+	const insertPos = Number.parseInt(key.id, 10);
+	const arrayWithFlag = new Uint8Array(encryptedArray.length + 1);
+	arrayWithFlag.set(encryptedArray.slice(0, insertPos));
+	arrayWithFlag[insertPos] = 128;
+	arrayWithFlag.set(encryptedArray.slice(insertPos), insertPos + 1);
+	const base64String = btoa(String.fromCharCode.apply(null, Array.from(arrayWithFlag)));
+	return `${key.id}${letter}${encodeURIComponent(base64String)}`;
+}
+function decrypt(encryptedText, options) {
+	const keys = options?.keys ?? defaultKeys;
+	const id = Number.parseInt(encryptedText[0], 10);
+	const base64String = decodeURIComponent(encryptedText.slice(2));
+	const encryptedArray = new Uint8Array(Array.from(atob(base64String), (char) => char.charCodeAt(0)));
+	const arrayWithoutFlag = new Uint8Array(encryptedArray.length - 1);
+	arrayWithoutFlag.set(encryptedArray.slice(0, id));
+	arrayWithoutFlag.set(encryptedArray.slice(id + 1), id);
+	const key = keys.find((item) => item.id === id.toString());
+	if (!key) throw new Error(`Encryption key '${id}' was not found.`);
+	return decryptCore(arrayWithoutFlag, key);
+}
+function getEncryptionParams(keys, alphabet, keyIndex) {
+	const finalKeyIndex = keyIndex ?? Math.floor(Math.random() * keys.length);
+	if (finalKeyIndex < 0 || finalKeyIndex >= keys.length || !Number.isInteger(finalKeyIndex)) throw new Error(`keyIndex must be an integer between 0 and ${keys.length - 1}`);
+	return {
+		key: keys[finalKeyIndex],
+		letter: keyIndex !== void 0 ? alphabet[finalKeyIndex * 5 % alphabet.length] : alphabet[Math.floor(Math.random() * alphabet.length)]
+	};
+}
+function encryptCore(text, key) {
+	const encrypted = CryptoJS.DES.encrypt(text, CryptoJS.enc.Utf8.parse(key.key), {
+		iv: CryptoJS.enc.Utf8.parse(key.iv),
+		mode: CryptoJS.mode.CBC,
+		padding: CryptoJS.pad.Pkcs7
+	});
+	const wordArray = CryptoJS.enc.Base64.parse(encrypted.toString());
+	const encryptedArray = Array.from(new Uint8Array(wordArray.words.length * 4));
+	for (let index = 0; index < wordArray.words.length; index++) {
+		const word = wordArray.words[index];
+		encryptedArray[index * 4] = word >>> 24 & 255;
+		encryptedArray[index * 4 + 1] = word >>> 16 & 255;
+		encryptedArray[index * 4 + 2] = word >>> 8 & 255;
+		encryptedArray[index * 4 + 3] = word & 255;
+	}
+	return new Uint8Array(encryptedArray);
+}
+function decryptCore(encryptedArray, key) {
+	const base64String = btoa(String.fromCharCode.apply(null, Array.from(encryptedArray)));
+	return CryptoJS.DES.decrypt(base64String, CryptoJS.enc.Utf8.parse(key.key), {
+		iv: CryptoJS.enc.Utf8.parse(key.iv),
+		mode: CryptoJS.mode.CBC,
+		padding: CryptoJS.pad.Pkcs7
+	}).toString(CryptoJS.enc.Utf8);
+}
+//#endregion
+//#region src/utils/isNotEmpty.ts
+function isNotEmpty(value) {
+	return value !== null && value !== void 0 && value !== "";
+}
+//#endregion
+//#region src/utils/patterns.ts
+var urlPattern = /(https?):\/\/[^\s/$.?#].[^\s]*/gi;
+//#endregion
+//#region src/utils/piniaPersistedState.ts
+function createVersionedPiniaPersistedState(options) {
+	const baseKeyPrefix = options.keyPrefix ?? `__persisted__${options.mode}`;
+	const baseKey = `${baseKeyPrefix}__${options.appVersion}`;
+	const serializer = options.isProd && options.encodeInProd !== false ? {
+		serialize: encodePersistedState,
+		deserialize: decodePersistedState
+	} : void 0;
+	const plugin = createPersistedState({
+		key: (id) => `${baseKey}__${id}`,
+		serializer
+	});
+	const getPersistedState = (id) => {
+		const rawValue = localStorage.getItem(`${baseKey}__${id}`);
+		if (!rawValue) return null;
+		return serializer ? serializer.deserialize(rawValue) : JSON.parse(rawValue);
+	};
+	const removeOldPersistedState = () => {
+		Object.keys(localStorage).forEach((key) => {
+			if (key.startsWith(baseKeyPrefix) && !key.includes(options.appVersion)) localStorage.removeItem(key);
+		});
+	};
+	return {
+		plugin,
+		getPersistedState,
+		removeOldPersistedState
+	};
+}
+function encodePersistedState(data) {
+	try {
+		return JSON.stringify({
+			data: btoa(encodeURIComponent(JSON.stringify(data))),
+			type: 1
+		});
+	} catch {
+		return JSON.stringify({
+			data: null,
+			type: 0
+		});
+	}
+}
+function decodePersistedState(data) {
+	const parsed = destr(data);
+	if (parsed.type === 1) return destr(decodeURIComponent(atob(parsed.data)));
+	return destr(parsed.data);
+}
+//#endregion
+//#region src/utils/renderSfc.ts
+function renderSFC(sfc, options) {
+	const vnodeRef = ref();
+	const vnode = () => h(sfc, mergeProps(options?.getProps?.() ?? {}, { ref: vnodeRef }), options?.getSlot?.() ?? {});
+	const container = document.createElement("div");
+	if (options?.containerId) container.id = options.containerId;
+	const app = createApp(vnode);
+	options?.install?.(app);
+	app.mount(container);
+	((typeof options?.to === "string" ? document.querySelector(options.to) : options?.to) ?? document.body).appendChild(container);
+	const unmount = () => {
+		app.unmount();
+		container.remove();
+	};
+	return {
+		vnode,
+		container,
+		vnodeRef,
+		unmount
+	};
+}
+//#endregion
+//#region src/utils/singleFlight.ts
+var singleFlightCache = /* @__PURE__ */ new WeakMap();
+function getOrCreateCache(fn) {
+	let cache = singleFlightCache.get(fn);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		singleFlightCache.set(fn, cache);
+	}
+	return cache;
+}
+function singleFlight(fn, options) {
+	const params = options?.params ?? [];
+	const key = options?.params ? options.keyGenerator ? options.keyGenerator(...params) : JSON.stringify(params) : "__default__";
+	const cache = getOrCreateCache(fn);
+	let promise = cache.get(key);
+	if (!promise) {
+		promise = fn(...params).finally(() => cache.delete(key));
+		cache.set(key, promise);
+	}
+	return promise;
+}
+function createSingleFlight(fn, options) {
+	return ((...args) => singleFlight(fn, {
+		params: args,
+		keyGenerator: options?.keyGenerator
+	}));
+}
+//#endregion
+//#region src/utils/thumbnail.ts
+var defaultThumbnailOptions = {
+	width: 100,
+	height: 100,
+	format: "webp"
+};
+function getThumbnailUrl(url, options) {
+	const finalOptions = {
+		...defaultThumbnailOptions,
+		...options
+	};
+	return (options?.isOssUrl ?? ((value) => {
+		return (options?.ossOrigins ?? []).some((origin) => value.includes(origin)) || value.includes("oss-");
+	}))(url) ? getOssThumbnailUrl(url, finalOptions) : getCdnThumbnailUrl(url, finalOptions);
+}
+function getOssThumbnailUrl(url, options) {
+	const params = [`resize,m_fixed,w_${options.width},h_${options.height}`];
+	if (options.quality !== void 0) params.push(`quality,Q_${options.quality}`);
+	if (options.format) params.push(`format,${options.format}`);
+	return `${url}?x-oss-process=image/${params.join("/")}`;
+}
+function getCdnThumbnailUrl(url, options) {
+	const params = [`resize,w_${options.width},h_${options.height}`];
+	if (options.quality !== void 0) params.push(`quality,${options.quality}`);
+	if (options.format) params.push(`format,${options.format}`);
+	return `${url}?image_process=${params.join("/")}`;
+}
+//#endregion
+//#region src/utils/tree.ts
+function listToTreeOptimized(sourceList, options) {
+	const list = deepClone(sourceList);
+	const { idField, parentIdField, childrenField = "children", rootParentId = null } = options;
+	const map = /* @__PURE__ */ new Map();
+	const tree = [];
+	list.forEach((node) => {
+		const nodeId = node[idField];
+		if (nodeId === void 0 || nodeId === null) throw new Error(`Node is missing id field '${String(idField)}'.`);
+		map.set(nodeId, { ...node });
+	});
+	list.forEach((node) => {
+		const parentId = node[parentIdField];
+		const currentNode = map.get(node[idField]);
+		if (!currentNode) return;
+		if (parentId === rootParentId) {
+			tree.push(currentNode);
+			return;
+		}
+		const parentNode = map.get(parentId);
+		if (!parentNode) return;
+		if (!parentNode[childrenField]) parentNode[childrenField] = [];
+		parentNode[childrenField]?.push(currentNode);
+	});
+	return tree;
+}
+function treeOptimizedToList(sourceTree, options) {
+	const { pidKey, childrenKey = "children", idKey = "id" } = options || {};
+	const queue = deepClone(sourceTree).map((node) => ({
+		node,
+		parentId: void 0
+	}));
+	const result = [];
+	while (queue.length > 0) {
+		const { node, parentId } = queue.shift();
+		const { [childrenKey]: children, ...rest } = node;
+		if (pidKey && parentId !== void 0) rest[pidKey] = parentId;
+		result.push(rest);
+		if (Array.isArray(children)) {
+			const currentId = node[idKey];
+			children.forEach((child) => {
+				queue.push({
+					node: child,
+					parentId: currentId
+				});
+			});
+		}
+	}
+	return result;
+}
+//#endregion
+export { copyText as _, getThumbnailUrl as a, renderSFC as c, encodePersistedState as d, urlPattern as f, debounce as g, encrypt as h, getOssThumbnailUrl as i, createVersionedPiniaPersistedState as l, decrypt as m, treeOptimizedToList as n, createSingleFlight as o, isNotEmpty as p, getCdnThumbnailUrl as r, singleFlight as s, listToTreeOptimized as t, decodePersistedState as u };

package/dist/types/shared.d.ts

@@ -0,0 +1,11 @@
+import type { Ref } from 'vue';
+export type MaybeRef<T> = T | Ref<T>;
+export declare function resolveMaybeRef<T>(value: MaybeRef<T>): T;
+export interface UseSdkUser {
+    userId?: string | number;
+    userName?: string;
+    language?: string;
+    level?: string | number;
+    email?: string;
+}
+export type UseSdkUserRef<T extends UseSdkUser = UseSdkUser> = MaybeRef<T | null | undefined>;