@kylexd/composable-kit 0.0.1

package/README.md

@@ -0,0 +1,91 @@
+# @kylexd/composable-kit
+
+## Overview
+
+Small utility and composable package for browser-oriented Vue projects.
+
+It includes general helpers, Vue composables, browser helpers, and several SDK wrappers. Some exports require peer packages to be installed by the host project.
+
+## Install
+
+```bash
+npm install @kylexd/composable-kit
+```
+
+## Exports
+
+Utilities:
+
+- `debounce`
+- `singleFlight`
+- `deepClone`
+- `formatParams`
+- `listToTreeOptimized`
+- `treeOptimizedToList`
+- `copyText`
+
+Composables:
+
+- `useCache`
+- `useDataApi`
+- `useListApi`
+- `useScrollList`
+- `useCountdown`
+- `usePcHtmlToMobile`
+- `usePopupQueue`
+- `useQrCode`
+- `useRsa`
+
+Subpath entries:
+
+- `@kylexd/composable-kit/utils`
+- `@kylexd/composable-kit/composables`
+- `@kylexd/composable-kit/sdk`
+
+SDK helpers:
+
+- `useFirebase`
+- `useIntercom`
+- `useSalesmartly`
+- `useTurbolinkSdk`
+
+## Basic usage
+
+```ts
+import { debounce, useCache } from '@kylexd/composable-kit'
+
+const onSearch = debounce(() => {
+  // update search
+}, 300)
+```
+
+```ts
+import { usePopupQueue } from '@kylexd/composable-kit'
+
+const popup = usePopupQueue({
+  key: 'default',
+  start() {},
+})
+```
+
+```ts
+import { debounce } from '@kylexd/composable-kit/utils'
+import { useCache } from '@kylexd/composable-kit/composables'
+```
+
+## Build
+
+```bash
+npm run build
+```
+
+## Notes
+
+- Peer dependencies are optional, but individual exports still need their related packages at runtime.
+- Prefer subpath entries when the host project only needs one group of exports.
+- SDK helpers expect configuration and project data from the host project.
+- Browser-only helpers should not be called in non-browser environments.
+
+## License
+
+UNLICENSED

package/dist/composables/useApi.d.ts

@@ -0,0 +1,78 @@
+import { type Ref } from 'vue';
+import { type CacheConfig } from './useCache';
+import { type FormatParamsOptions } from '../utils/formatParams';
+export interface UseDataApiOptions<R, F, Q> {
+    format?: (response: {
+        data: R;
+    }, oldData?: F) => F;
+    cache?: CacheConfig;
+    query?: Ref<Q>;
+    formatParams?: (params: Q) => Q;
+    catchError?: (error: Error, data?: F) => F | undefined;
+    onError?: (error: unknown) => void;
+}
+export interface AsyncApiOptions {
+    forceRefresh?: boolean;
+}
+export declare function useDataApi<T, R, F = R>(asyncApi: ((params: T) => Promise<{
+    data: R;
+}>) | ((params?: T) => Promise<{
+    data: R;
+}>), options?: UseDataApiOptions<R, F, T>): {
+    loading: Ref<boolean, boolean>;
+    data: Ref<F | undefined, F | undefined>;
+    sentDataApi: (params?: T, asyncApiOptions?: AsyncApiOptions) => Promise<F>;
+};
+export interface UseListApiOptions<R, F, Q, D> {
+    format?: (response: {
+        list: R;
+        total: number;
+        data?: D;
+    }, oldList?: F, params?: Q) => F;
+    formatParamsOptions?: FormatParamsOptions<Q>;
+    query?: Ref<Q>;
+    catchError?: (error: Error, oldList?: F) => F | undefined;
+    isCancel?: (error: unknown) => boolean;
+    onError?: (error: unknown) => void;
+}
+export declare function useListApi<T, R, F = R, D = undefined>(asyncApi: (params?: T) => Promise<{
+    list: R;
+    total: number;
+    data?: D;
+}>, options?: UseListApiOptions<R, F, T, D>): {
+    loading: Ref<boolean, boolean>;
+    dataList: Ref<F | undefined, F | undefined>;
+    getList: () => Promise<F>;
+    total: Ref<number, number>;
+    data: Ref<D | undefined, D | undefined>;
+};
+export interface UseScrollListOptions<R extends unknown[], F, Q, D> {
+    format?: (response: {
+        list: R;
+        total: number;
+        data?: D;
+    }, params?: Q) => F;
+    formatParamsOptions?: FormatParamsOptions<Q>;
+    query?: Ref<Q & {
+        pageNum?: number;
+        pageSize?: number;
+    }>;
+    catchError?: (error: Error, oldList?: F) => F | undefined;
+    onError?: (error: unknown) => void;
+}
+export declare function useScrollList<T extends {
+    pageNum?: number;
+    pageSize?: number;
+}, R extends unknown[], F = R, D = undefined>(asyncApi: (params?: T) => Promise<{
+    list: R;
+    total: number;
+    data?: D;
+}>, options?: UseScrollListOptions<R, F, T, D>): {
+    loading: Ref<boolean, boolean>;
+    dataList: Ref<F | undefined, F | undefined>;
+    getList: () => Promise<F>;
+    total: Ref<number, number>;
+    data: Ref<D | undefined, D | undefined>;
+    isError: Ref<boolean, boolean>;
+    isNoMore: Ref<boolean, boolean>;
+};

package/dist/composables/useCache.d.ts

@@ -0,0 +1,23 @@
+import { type Ref } from 'vue';
+export interface CacheConfig {
+    key: string;
+    time: number;
+    useMemory?: boolean;
+    storageType?: 'localStorage' | 'sessionStorage';
+    baseKey?: string;
+    memoryStorage?: Map<string, StorageData<unknown>>;
+    exposeMemoryToWindow?: string | false;
+}
+export interface StorageData<T> {
+    data: T;
+    createdTime: number;
+    time: number;
+}
+export declare function useCache<T>(options: CacheConfig): {
+    cacheData: Ref<T | null, T | null>;
+    clearCache: () => void;
+    setCacheData: (data: T) => void;
+    getCacheData: () => T | null;
+};
+export declare function clearAllHooksCache(baseKey?: string, storageType?: 'localStorage' | 'sessionStorage'): void;
+export declare function clearAllMemoryCache(memoryStorage?: Map<string, StorageData<unknown>>): void;

package/dist/composables/useCookies.d.ts

@@ -0,0 +1,8 @@
+export interface UseCookiesOptions {
+    domain?: string | (() => string | undefined);
+}
+export declare function useCookies(options?: UseCookiesOptions): {
+    setCookie: (key: string, value: string, expires: number) => void;
+    getCookie: (key: string) => string | undefined;
+    removeCookie: (key: string) => void;
+};

package/dist/composables/useCountdown.d.ts

@@ -0,0 +1,31 @@
+import { type Ref } from 'vue';
+export interface DurationOfDays {
+    s: number;
+    m: number;
+    h: number;
+    d: number;
+    asSeconds: number;
+}
+export interface DurationOfHours {
+    s: number;
+    m: number;
+    h: number;
+    asSeconds: number;
+}
+export interface CountdownOptions {
+    stopCallback?: () => void;
+}
+export type CountdownDateRef<T extends object> = Ref<T> & T;
+export declare function useCountdown(): {
+    getCurrentDurationOfDays: (targetTime?: string | Date, options?: CountdownOptions) => {
+        date: CountdownDateRef<DurationOfDays>;
+        stop: () => void;
+        updateTargetTime: (newTargetTime?: string | Date) => void;
+    };
+    getCurrentDurationOfHours: (targetTime?: string | Date, options?: CountdownOptions) => {
+        date: CountdownDateRef<DurationOfHours>;
+        stop: () => void;
+        updateTargetTime: (newTargetTime?: string | Date) => void;
+    };
+    getDiff: (targetTime: string | Date | undefined, unit: "seconds" | "minutes" | "hours" | "days") => number;
+};

package/dist/composables/useCreatedCancelApi.d.ts

@@ -0,0 +1,41 @@
+export interface AbortControllerReceiver {
+    useAbortController?: (controller: AbortController) => void;
+}
+export declare function useCreatedCancelApi<P, R, O extends AbortControllerReceiver = AbortControllerReceiver>(api: (params: P, options?: O) => Promise<R>): {
+    api: (params?: P) => Promise<R>;
+    cancel: import("vue").Ref<{
+        readonly signal: {
+            readonly aborted: boolean;
+            onabort: ((this: AbortSignal, ev: Event) => any) | null;
+            readonly reason: any;
+            throwIfAborted: () => void;
+            addEventListener: {
+                <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        };
+        abort: (reason?: any) => void;
+    } | null, AbortController | {
+        readonly signal: {
+            readonly aborted: boolean;
+            onabort: ((this: AbortSignal, ev: Event) => any) | null;
+            readonly reason: any;
+            throwIfAborted: () => void;
+            addEventListener: {
+                <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        };
+        abort: (reason?: any) => void;
+    } | null>;
+};

package/dist/composables/useDownload.d.ts

@@ -0,0 +1,5 @@
+export declare function useDownload(): {
+    downloadBase64File: (base64: string, name: string) => void;
+    downloadBlobFile: (blob: Blob, name: string) => void;
+    downloadUrlFile: (url: string, name: string) => void;
+};

package/dist/composables/useDownloadLink.d.ts

@@ -0,0 +1,22 @@
+import { type UseCookiesOptions } from './useCookies';
+export interface DownloadLinkPair {
+    appleURL: string;
+    googleURL: string;
+}
+export interface UseDownloadLinkOptions {
+    cookies?: UseCookiesOptions;
+    defaultLinks: DownloadLinkPair;
+    cookieKeys?: {
+        appleURL?: string;
+        googleURL?: string;
+    };
+    expires?: number;
+    userAgent?: string;
+}
+export declare function useDownloadLink(options: UseDownloadLinkOptions): {
+    setDownloadLinkToCookie: (links: DownloadLinkPair) => void;
+    getDownloadLinkFromCookie: () => Partial<DownloadLinkPair>;
+    getDownloadLink: () => DownloadLinkPair;
+    downloadApp: () => void;
+    getPlatformDownloadAppLink: () => string;
+};

package/dist/composables/useForm.d.ts

@@ -0,0 +1,13 @@
+import { type Ref } from 'vue';
+export interface FormResetAdapter {
+    resetValidation?: () => void;
+}
+export interface UseFormOptions<T> {
+    excludeKeys?: Array<keyof T>;
+}
+export declare function useForm<T extends {
+    pageNum?: number;
+    pageSize?: number;
+} & Record<string, unknown>>(formData: Ref<T>, formRef?: Ref<FormResetAdapter | null | undefined>, options?: UseFormOptions<T>): {
+    resetForm: (excludeKeys?: Array<keyof T>) => void;
+};

package/dist/composables/useIsMobile.d.ts

@@ -0,0 +1,7 @@
+export declare function useIsMobile(userAgent?: string): {
+    any: boolean;
+    phone: boolean;
+    tablet: boolean;
+    isIOS: boolean;
+    raw: import("ismobilejs").isMobileResult;
+};

package/dist/composables/useOpenLink.d.ts

@@ -0,0 +1,8 @@
+export interface UseOpenLinkOptions {
+    baseUrl: string | (() => string);
+    isInternalRoute?: (path: string) => boolean;
+    open?: (url: string, target: string) => void;
+}
+export declare function useOpenLink(options: UseOpenLinkOptions): {
+    openLink: (link: string) => void;
+};

package/dist/composables/useParseZod.d.ts

@@ -0,0 +1,23 @@
+export interface ZodLikeIssue {
+    message: string;
+}
+export interface ZodLikeError {
+    issues: ReadonlyArray<ZodLikeIssue>;
+}
+export type ZodLikeParseResult = {
+    success: true;
+    data: unknown;
+} | {
+    success: false;
+    error: ZodLikeError;
+};
+export interface ZodLikeSchema {
+    safeParse: (data: unknown) => ZodLikeParseResult;
+}
+export interface UseParseZodOptions {
+    onError?: (issue: ZodLikeIssue, error: ZodLikeError) => void;
+}
+export declare function useParseZod(defaultOptions?: UseParseZodOptions): {
+    parseZod: (schema: ZodLikeSchema, data: unknown, options?: UseParseZodOptions) => boolean;
+    asyncParseZod: (schema: ZodLikeSchema, data: unknown, options?: UseParseZodOptions) => Promise<ZodLikeParseResult>;
+};

package/dist/composables/usePcHtmlToMobile.d.ts

@@ -0,0 +1,40 @@
+import { type Ref } from 'vue';
+export interface PcHtmlImageTransformContext {
+    index: number;
+    src: string | null;
+    width: string | null;
+    style: Record<string, string>;
+    content: DocumentFragment;
+}
+export interface PcHtmlLinkTransformContext {
+    index: number;
+    href: string | null;
+    content: DocumentFragment;
+}
+export interface UsePcHtmlToMobileOptions {
+    baseWidth?: number;
+    heightOffset?: number;
+    hiddenContainerId?: string;
+    transformImage?: (image: HTMLImageElement, context: PcHtmlImageTransformContext) => void;
+    transformLink?: (anchor: HTMLAnchorElement, context: PcHtmlLinkTransformContext) => void;
+    onImageClick?: (srcList: string[]) => void;
+}
+export interface PcHtmlTransformStyle {
+    scale: number;
+    translateX: number;
+    translateY: number;
+}
+export declare function usePcHtmlToMobile(options?: UsePcHtmlToMobileOptions): {
+    containerRef: Ref<HTMLElement | null, HTMLElement | null>;
+    adaptedHtml: Ref<string, string>;
+    contentHeight: Ref<number, number>;
+    transformStyle: {
+        scale: number;
+        translateX: number;
+        translateY: number;
+    };
+    formatHtml: (html: string) => Promise<string>;
+    updateLayout: () => void;
+    handleClick: (event: MouseEvent) => string[];
+    cleanup: () => void;
+};

package/dist/composables/usePopupQueue.d.ts

@@ -0,0 +1,22 @@
+export type PopupQueueStatus = 'pending' | 'success' | 'cancel' | 'processing';
+export interface PopupQueueItem {
+    start: () => void;
+    status: PopupQueueStatus;
+    key: symbol;
+    timeout?: number;
+    onStateChange?: (status: PopupQueueStatus) => void;
+    timer?: number;
+}
+export interface UsePopupQueueOptions {
+    key: string;
+    start: () => void;
+    timeout?: number;
+    onStateChange?: (status: PopupQueueStatus) => void;
+    onTimeout?: () => void;
+}
+export interface UsePopupQueueReturn {
+    end: () => void;
+    cancel: () => void;
+    getStatus: () => PopupQueueStatus | undefined;
+}
+export declare function usePopupQueue(options: UsePopupQueueOptions): UsePopupQueueReturn;

package/dist/composables/useQrCode.d.ts

@@ -0,0 +1,6 @@
+export interface UseQrCodeOptions {
+    width?: number;
+}
+export declare function useQrCode(defaultOptions?: UseQrCodeOptions): {
+    generateQrCode: (text: string, options?: UseQrCodeOptions) => Promise<string>;
+};

package/dist/composables/useRsa.d.ts

@@ -0,0 +1,6 @@
+export interface UseRsaOptions {
+    getPublicKey: () => Promise<string> | string;
+}
+export declare function useRsa(options: UseRsaOptions): {
+    encrypt: (needEncryptData: string) => Promise<string>;
+};

package/dist/composables.d.ts

@@ -0,0 +1,15 @@
+export * from './composables/useApi';
+export * from './composables/useCache';
+export * from './composables/useCountdown';
+export * from './composables/useCookies';
+export * from './composables/useCreatedCancelApi';
+export * from './composables/useDownload';
+export * from './composables/useDownloadLink';
+export * from './composables/useForm';
+export * from './composables/useIsMobile';
+export * from './composables/useOpenLink';
+export * from './composables/useParseZod';
+export * from './composables/usePcHtmlToMobile';
+export * from './composables/usePopupQueue';
+export * from './composables/useQrCode';
+export * from './composables/useRsa';

package/dist/composables.js

@@ -0,0 +1,2 @@
+import { _ as clearAllHooksCache, a as useParseZod, c as useDownloadLink, d as useCreatedCancelApi, f as useCookies, g as useScrollList, h as useListApi, i as usePcHtmlToMobile, l as useIsMobile, m as useDataApi, n as useQrCode, o as useOpenLink, p as useCountdown, r as usePopupQueue, s as useForm, t as useRsa, u as useDownload, v as clearAllMemoryCache, y as useCache } from "./useRsa-aK-vaZUD.js";
+export { clearAllHooksCache, clearAllMemoryCache, useCache, useCookies, useCountdown, useCreatedCancelApi, useDataApi, useDownload, useDownloadLink, useForm, useIsMobile, useListApi, useOpenLink, useParseZod, usePcHtmlToMobile, usePopupQueue, useQrCode, useRsa, useScrollList };

package/dist/dayjs-BXpdKo4H.js

@@ -0,0 +1,65 @@
+import dayjs from "dayjs";
+import duration from "dayjs/plugin/duration";
+import minMax from "dayjs/plugin/minMax";
+import relativeTime from "dayjs/plugin/relativeTime";
+import timezone from "dayjs/plugin/timezone";
+import utc from "dayjs/plugin/utc";
+//#region src/utils/deepClone.ts
+function deepClone(value) {
+	try {
+		return structuredClone(value);
+	} catch {
+		return customDeepClone(value);
+	}
+}
+function customDeepClone(value) {
+	if (value === null || typeof value !== "object") return value;
+	if (value instanceof Date) return new Date(value.getTime());
+	if (Array.isArray(value)) return value.map((item) => customDeepClone(item));
+	const output = {};
+	for (const key in value) if (Object.prototype.hasOwnProperty.call(value, key)) output[key] = customDeepClone(value[key]);
+	return output;
+}
+//#endregion
+//#region src/utils/formatParams.ts
+function formatParams(params, options) {
+	if (!params) return params;
+	if (Object.prototype.toString.call(params) !== "[object Object]") return params;
+	return Object.fromEntries(Object.entries(params).filter(([key, value]) => {
+		if (options?.skipFields?.includes(key)) return true;
+		return value !== void 0 && value !== null && value !== "";
+	}));
+}
+//#endregion
+//#region src/utils/dayjs.ts
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(duration);
+dayjs.extend(relativeTime);
+dayjs.extend(minMax);
+var dayjsInstance = dayjs;
+function formatTime(date, format = "YYYY-MM-DD HH:mm:ss") {
+	if (!date) return "--";
+	return dayjsInstance(date).format(format);
+}
+function formatTimeWithUtcOffset(date, offset = 8, format) {
+	const result = dayjsInstance(date).utcOffset(offset);
+	return format ? result.format(format) : result.format();
+}
+function formatLocalStringAsUtcOffset(date, offset = 8) {
+	return dayjsInstance(date).utc(true).utcOffset(offset, true).format();
+}
+function getNowWithUtcOffset(offset = 8, format = "YYYY-MM-DD HH:mm:ss") {
+	return dayjsInstance().utcOffset(offset).format(format);
+}
+function formatTimeBeijingStringToUtc8String(date) {
+	return formatLocalStringAsUtcOffset(date, 8);
+}
+function getNowBeijingTime() {
+	return getNowWithUtcOffset(8);
+}
+function utcFormatToBeijingString(date, format = "YYYY-MM-DD HH:mm:ss") {
+	return formatTimeWithUtcOffset(date, 8, format);
+}
+//#endregion
+export { formatTimeWithUtcOffset as a, utcFormatToBeijingString as c, formatTimeBeijingStringToUtc8String as i, formatParams as l, formatLocalStringAsUtcOffset as n, getNowBeijingTime as o, formatTime as r, getNowWithUtcOffset as s, dayjsInstance as t, deepClone as u };

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+export * from './composables/useApi';
+export * from './composables/useCache';
+export * from './composables/useCountdown';
+export * from './composables/useCookies';
+export * from './composables/useCreatedCancelApi';
+export * from './composables/useDownload';
+export * from './composables/useDownloadLink';
+export * from './composables/useForm';
+export * from './composables/useIsMobile';
+export * from './composables/useOpenLink';
+export * from './composables/useParseZod';
+export * from './composables/usePcHtmlToMobile';
+export * from './composables/usePopupQueue';
+export * from './composables/useQrCode';
+export * from './composables/useRsa';
+export * from './sdk/useFirebase';
+export * from './sdk/useIntercom';
+export * from './sdk/useSalesmartly';
+export * from './sdk/useTurbolinkSdk';
+export * from './types/shared';
+export * from './utils/copy';
+export * from './utils/dayjs';
+export * from './utils/debounce';
+export * from './utils/deepClone';
+export * from './utils/encryption';
+export * from './utils/formatParams';
+export * from './utils/isNotEmpty';
+export * from './utils/patterns';
+export * from './utils/piniaPersistedState';
+export * from './utils/renderSfc';
+export * from './utils/singleFlight';
+export * from './utils/thumbnail';
+export * from './utils/tree';
+export * from './utils/typeUtils';

package/dist/index.js

@@ -0,0 +1,5 @@
+import { _ as clearAllHooksCache, a as useParseZod, c as useDownloadLink, d as useCreatedCancelApi, f as useCookies, g as useScrollList, h as useListApi, i as usePcHtmlToMobile, l as useIsMobile, m as useDataApi, n as useQrCode, o as useOpenLink, p as useCountdown, r as usePopupQueue, s as useForm, t as useRsa, u as useDownload, v as clearAllMemoryCache, y as useCache } from "./useRsa-aK-vaZUD.js";
+import { a as formatTimeWithUtcOffset, c as utcFormatToBeijingString, i as formatTimeBeijingStringToUtc8String, l as formatParams, n as formatLocalStringAsUtcOffset, o as getNowBeijingTime, r as formatTime, s as getNowWithUtcOffset, t as dayjsInstance, u as deepClone } from "./dayjs-BXpdKo4H.js";
+import { a as useFirebase, i as resolveMaybeRef, n as useSalesmartly, r as useIntercom, t as useTurbolinkSdk } from "./useTurbolinkSdk-peRMONxI.js";
+import { _ as copyText, a as getThumbnailUrl, c as renderSFC, d as encodePersistedState, f as urlPattern, g as debounce, h as encrypt, i as getOssThumbnailUrl, l as createVersionedPiniaPersistedState, m as decrypt, n as treeOptimizedToList, o as createSingleFlight, p as isNotEmpty, r as getCdnThumbnailUrl, s as singleFlight, t as listToTreeOptimized, u as decodePersistedState } from "./tree-Ck3oXYA2.js";
+export { clearAllHooksCache, clearAllMemoryCache, copyText, createSingleFlight, createVersionedPiniaPersistedState, dayjsInstance, debounce, decodePersistedState, decrypt, deepClone, encodePersistedState, encrypt, formatLocalStringAsUtcOffset, formatParams, formatTime, formatTimeBeijingStringToUtc8String, formatTimeWithUtcOffset, getCdnThumbnailUrl, getNowBeijingTime, getNowWithUtcOffset, getOssThumbnailUrl, getThumbnailUrl, isNotEmpty, listToTreeOptimized, renderSFC, resolveMaybeRef, singleFlight, treeOptimizedToList, urlPattern, useCache, useCookies, useCountdown, useCreatedCancelApi, useDataApi, useDownload, useDownloadLink, useFirebase, useForm, useIntercom, useIsMobile, useListApi, useOpenLink, useParseZod, usePcHtmlToMobile, usePopupQueue, useQrCode, useRsa, useSalesmartly, useScrollList, useTurbolinkSdk, utcFormatToBeijingString };

package/dist/sdk/useFirebase.d.ts

@@ -0,0 +1,12 @@
+import { type FirebaseApp, type FirebaseOptions } from 'firebase/app';
+import { type Analytics } from 'firebase/analytics';
+export interface UseFirebaseOptions {
+    config: FirebaseOptions;
+    appName?: string;
+    eventExtras?: Record<string, unknown> | (() => Record<string, unknown>);
+}
+export declare function useFirebase(options: UseFirebaseOptions): {
+    app: FirebaseApp;
+    analytics: Analytics;
+    customLogEvent: (eventName: string, params?: Record<string, unknown>) => void;
+};

package/dist/sdk/useIntercom.d.ts

@@ -0,0 +1,19 @@
+import { type UseSdkUser, type UseSdkUserRef } from '../types/shared';
+export interface UseIntercomOptions<T extends UseSdkUser = UseSdkUser> {
+    appId: string;
+    user?: UseSdkUserRef<T>;
+    encryptUserId?: (userId: string) => string;
+    mapUser?: (user: T) => Record<string, unknown>;
+    clearCookies?: (prefix: string) => void;
+    hideDefaultLauncher?: boolean;
+}
+export declare function useIntercom<T extends UseSdkUser = UseSdkUser>(options: UseIntercomOptions<T>): {
+    initIntercom: () => void;
+    updateUserInfo: () => void;
+    deleteIntercom: () => void;
+    shutdown: () => void;
+    showIntercom: () => void;
+    hideIntercom: () => void;
+    intercomLoading: import("vue").Ref<boolean, boolean>;
+    intercomUnreadMessage: import("vue").Ref<number, number>;
+};

package/dist/sdk/useSalesmartly.d.ts

@@ -0,0 +1,24 @@
+import { type UseSdkUser, type UseSdkUserRef } from '../types/shared';
+export type SalesmartlyUnreadCallback = (params: {
+    num: number;
+    list: unknown[];
+}) => void;
+export type SalesmartlyMessageCallback = (params: unknown) => void;
+export interface UseSalesmartlyOptions<T extends UseSdkUser = UseSdkUser> {
+    script: string;
+    user?: UseSdkUserRef<T>;
+    encryptUserId?: (userId: string) => string;
+    mapUser?: (user: T) => Record<string, unknown>;
+    adjustDom?: () => void;
+}
+export declare function useSalesmartly<T extends UseSdkUser = UseSdkUser>(options: UseSalesmartlyOptions<T>): {
+    loadSalesmartly: () => Promise<boolean>;
+    initSalesmartly: () => Promise<void>;
+    updateUserInfo: () => void;
+    deleteSalesmartly: () => Promise<void>;
+    showSalesmartly: () => Promise<void>;
+    hideSalesmartly: () => Promise<void>;
+    hideCloseIcon: () => Promise<void>;
+    onUnRead: (callback: SalesmartlyUnreadCallback) => Promise<void>;
+    onReceiveMessage: (callback: SalesmartlyMessageCallback) => Promise<void>;
+};

package/dist/sdk/useTurbolinkSdk.d.ts

@@ -0,0 +1,30 @@
+import { type MaybeRef, type UseSdkUser, type UseSdkUserRef } from '../types/shared';
+export interface TurbolinkEvent {
+    eventName: string;
+    backCamp?: boolean;
+    customData?: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+export interface UseTurbolinkOptions<T extends UseSdkUser = UseSdkUser> {
+    config: MaybeRef<Record<string, unknown>>;
+    user?: UseSdkUserRef<T>;
+    lang?: MaybeRef<string | undefined>;
+    encryptUserId?: (userId: string) => string;
+    onLoadUrlEvent?: (event: unknown) => void | Promise<void>;
+}
+export declare function useTurbolinkSdk<T extends UseSdkUser = UseSdkUser>(options: UseTurbolinkOptions<T>): {
+    initTurbolink: () => Promise<unknown>;
+    setTurbolinkUserInfo: () => Promise<void>;
+    registerTurbolinkEvent: ({ uid }: {
+        uid: string | number;
+    }) => Promise<void>;
+    loginTurbolinkEvent: ({ uid }: {
+        uid: string | number;
+    }) => Promise<void>;
+    logoutTurbolinkEvent: () => Promise<unknown>;
+    loadUrl: (url: string, params?: Record<string, unknown>) => Promise<unknown>;
+    turbolinkCustomEvent: (event: TurbolinkEvent) => Promise<void>;
+    catchTurbolinkEvent: (event: TurbolinkEvent) => Promise<void>;
+};