@xn-lib/core 0.1.2 → 0.1.4

package/dist/types/hooks/index.d.ts

@@ -1,2 +1,4 @@
 export * from './use-dict';
 export * from './use-reset-ref';
+export * from './use-auto-promise';
+export * from './requestQuenue';

package/dist/types/hooks/requestQuenue/index.d.ts

@@ -0,0 +1,2 @@
+export * from './use-request-queue';
+export * from './use-advanced-request-queue';

package/dist/types/hooks/requestQuenue/type.d.ts

@@ -0,0 +1,20 @@
+export interface RequestTask<T = any> {
+    id: string;
+    request: () => Promise<T>;
+    priority?: number;
+    retryCount?: number;
+    timeout?: number;
+    resolve: (value: T) => void;
+    reject: (reason?: any) => void;
+    status: 'pending' | 'running' | 'success' | 'error' | 'cancelled';
+    startTime?: number;
+    timeoutId?: number;
+    cancelController?: AbortController;
+}
+export interface UseRequestQueueOptions {
+    maxConcurrent?: number;
+    timeout?: number;
+    retryCount?: number;
+    autoStart?: boolean;
+    useAbortController?: boolean;
+}

package/dist/types/hooks/requestQuenue/use-advanced-request-queue.d.ts

@@ -0,0 +1,139 @@
+import { RequestTask, UseRequestQueueOptions } from './type';
+export interface AdvancedRequestTask<T = any> extends RequestTask<T> {
+    dependencies?: string[];
+    cacheKey?: string;
+    cacheTTL?: number;
+    group?: string;
+}
+export interface UseAdvancedRequestQueueOptions extends UseRequestQueueOptions {
+    enableCache?: boolean;
+    defaultCacheTTL?: number;
+}
+export declare function useAdvancedRequestQueue(options?: UseAdvancedRequestQueueOptions): {
+    cache: Record<string, {
+        data: any;
+        timestamp: number;
+        ttl: number;
+    }>;
+    taskGroups: Record<string, AdvancedRequestTask<any>[]>;
+    dependencyGraph: Record<string, string[]>;
+    cacheStats: import("vue").ComputedRef<{
+        total: number;
+        expired: number;
+    }>;
+    addTaskWithCache: <T>(request: () => Promise<T>, options?: Partial<AdvancedRequestTask<T>>) => Promise<T>;
+    addTaskWithDependencies: <T>(request: () => Promise<T>, dependencies: string[], options?: Partial<AdvancedRequestTask<T>>) => Promise<T>;
+    addTasksToGroup: <T>(groupName: string, requests: Array<{
+        request: () => Promise<T>;
+        options?: Partial<AdvancedRequestTask<T>>;
+    }>) => Promise<T[]>;
+    clearCache: () => void;
+    clearCacheByKey: (cacheKey: string) => void;
+    clearExpiredCache: () => void;
+    waitForDependencies: (dependencies: string[]) => Promise<void>;
+    queue: import("vue").Reactive<RequestTask<any>[]>;
+    runningTasks: import("vue").Reactive<Map<string, AbortController>>;
+    taskResults: Record<string, any>;
+    taskErrors: Record<string, any>;
+    isRunning: import("vue").Ref<boolean, boolean>;
+    stats: {
+        total: number;
+        success: number;
+        error: number;
+        pending: number;
+        running: number;
+        cancelled: number;
+    };
+    completedCount: import("vue").ComputedRef<number>;
+    progress: import("vue").ComputedRef<number>;
+    activeTasks: import("vue").ComputedRef<{
+        id: string;
+        request: () => Promise<any>;
+        priority?: number | undefined;
+        retryCount?: number | undefined;
+        timeout?: number | undefined;
+        resolve: (value: any) => void;
+        reject: (reason?: any) => void;
+        status: "pending" | "running" | "success" | "error" | "cancelled";
+        startTime?: number | undefined;
+        timeoutId?: number | undefined;
+        cancelController?: {
+            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;
+        } | undefined;
+    }[]>;
+    pendingTasks: import("vue").ComputedRef<{
+        id: string;
+        request: () => Promise<any>;
+        priority?: number | undefined;
+        retryCount?: number | undefined;
+        timeout?: number | undefined;
+        resolve: (value: any) => void;
+        reject: (reason?: any) => void;
+        status: "pending" | "running" | "success" | "error" | "cancelled";
+        startTime?: number | undefined;
+        timeoutId?: number | undefined;
+        cancelController?: {
+            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;
+        } | undefined;
+    }[]>;
+    runningTaskCount: import("vue").ComputedRef<number>;
+    addTask: <T>(request: () => Promise<T>, taskOptions?: Partial<Omit<RequestTask<T>, "resolve" | "reject" | "status" | "request">>) => Promise<T> & {
+        cancel?: () => void;
+    };
+    addTasks: <T>(requests: (() => Promise<T>)[], options?: Partial<Omit<RequestTask<T>, "resolve" | "reject" | "status" | "request">>) => Promise<T[]> & {
+        cancelAll?: () => void;
+    };
+    addTaskList: <T>(tasks: Array<{
+        request: () => Promise<T>;
+        id?: string;
+        priority?: number;
+        retryCount?: number;
+        timeout?: number;
+    }>, commonOptions?: Partial<Omit<RequestTask<T>, "resolve" | "reject" | "status" | "request">>) => Promise<T[]> & {
+        cancelAll?: () => void;
+    };
+    start: () => void;
+    pause: () => void;
+    clear: () => void;
+    removeTask: (taskId: string) => void;
+    processQueue: () => Promise<void>;
+    cancelTask: (taskId: string, reason?: string) => boolean;
+    cancelTasks: (taskIds: string[], reason?: string) => {
+        taskId: string;
+        success: boolean;
+    }[];
+    cancelAll: (reason?: string) => {
+        taskId: string;
+        success: boolean;
+    }[];
+};

package/dist/types/hooks/requestQuenue/use-request-queue.d.ts

@@ -0,0 +1,108 @@
+import { RequestTask, UseRequestQueueOptions } from './type';
+export declare function useRequestQueue(options?: UseRequestQueueOptions): {
+    queue: import("vue").Reactive<RequestTask<any>[]>;
+    runningTasks: import("vue").Reactive<Map<string, AbortController>>;
+    taskResults: Record<string, any>;
+    taskErrors: Record<string, any>;
+    isRunning: import("vue").Ref<boolean, boolean>;
+    stats: {
+        total: number;
+        success: number;
+        error: number;
+        pending: number;
+        running: number;
+        cancelled: number;
+    };
+    completedCount: import("vue").ComputedRef<number>;
+    progress: import("vue").ComputedRef<number>;
+    activeTasks: import("vue").ComputedRef<{
+        id: string;
+        request: () => Promise<any>;
+        priority?: number | undefined;
+        retryCount?: number | undefined;
+        timeout?: number | undefined;
+        resolve: (value: any) => void;
+        reject: (reason?: any) => void;
+        status: "pending" | "running" | "success" | "error" | "cancelled";
+        startTime?: number | undefined;
+        timeoutId?: number | undefined;
+        cancelController?: {
+            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;
+        } | undefined;
+    }[]>;
+    pendingTasks: import("vue").ComputedRef<{
+        id: string;
+        request: () => Promise<any>;
+        priority?: number | undefined;
+        retryCount?: number | undefined;
+        timeout?: number | undefined;
+        resolve: (value: any) => void;
+        reject: (reason?: any) => void;
+        status: "pending" | "running" | "success" | "error" | "cancelled";
+        startTime?: number | undefined;
+        timeoutId?: number | undefined;
+        cancelController?: {
+            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;
+        } | undefined;
+    }[]>;
+    runningTaskCount: import("vue").ComputedRef<number>;
+    addTask: <T>(request: () => Promise<T>, taskOptions?: Partial<Omit<RequestTask<T>, "resolve" | "reject" | "status" | "request">>) => Promise<T> & {
+        cancel?: () => void;
+    };
+    addTasks: <T>(requests: (() => Promise<T>)[], options?: Partial<Omit<RequestTask<T>, "resolve" | "reject" | "status" | "request">>) => Promise<T[]> & {
+        cancelAll?: () => void;
+    };
+    addTaskList: <T>(tasks: Array<{
+        request: () => Promise<T>;
+        id?: string;
+        priority?: number;
+        retryCount?: number;
+        timeout?: number;
+    }>, commonOptions?: Partial<Omit<RequestTask<T>, "resolve" | "reject" | "status" | "request">>) => Promise<T[]> & {
+        cancelAll?: () => void;
+    };
+    start: () => void;
+    pause: () => void;
+    clear: () => void;
+    removeTask: (taskId: string) => void;
+    processQueue: () => Promise<void>;
+    cancelTask: (taskId: string, reason?: string) => boolean;
+    cancelTasks: (taskIds: string[], reason?: string) => {
+        taskId: string;
+        success: boolean;
+    }[];
+    cancelAll: (reason?: string) => {
+        taskId: string;
+        success: boolean;
+    }[];
+};

package/dist/types/hooks/use-auto-promise.d.ts

@@ -0,0 +1,9 @@
+import { type Ref } from 'vue';
+type TApiFun<TData, TParams extends Array<any>> = (...params: TParams) => Promise<TData>;
+interface AutoRequestOptions {
+    loading?: boolean;
+    onSuccess?: (data: any) => void;
+}
+type AutoRequestResult<TData, TParams extends Array<any>> = [Ref<boolean>, TApiFun<TData, TParams>];
+export declare function useAutoPromise<TData, TParams extends any[] = any[]>(fun: TApiFun<TData, TParams>, options?: AutoRequestOptions): AutoRequestResult<TData, TParams>;
+export {};

package/dist/types/index.d.ts

@@ -2,3 +2,4 @@ export * from './dicts';
 export * from './hooks';
 export * from './vue';
 export * from './patterns';
+export * from './utils';

package/dist/types/utils/hash.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 生成字符串的简单哈希码
+ */
+export declare function hashCode(str: string): string;
+/**
+ * 生成更高质量的53位哈希（cyrb53算法）
+ */
+export declare function cyrb53(str: string, seed?: number): number;
+/**
+ * 生成请求缓存键
+ */
+export declare function generateCacheKey(...args: any[]): string;
+/**
+ * 异步生成哈希（使用 Web Crypto API）
+ */
+export declare function generateSHA256Hash(str: string): Promise<string>;

package/dist/types/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './hash';

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@xn-lib/core",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",