@qiaopeng/tanstack-query-plus 0.5.8 → 0.5.10

package/dist/utils/prefetchManager.d.ts

@@ -1,111 +0,0 @@
-import type { QueryClient, QueryFunction, QueryKey } from "@tanstack/react-query";
-export interface PrefetchConfig {
-    priority?: "high" | "medium" | "low";
-    delay?: number;
-    staleTime?: number;
-    allowSlowNetwork?: boolean;
-}
-export interface PrefetchTask {
-    queryKey: QueryKey;
-    queryFn: QueryFunction<any>;
-    config: PrefetchConfig;
-    timestamp: number;
-    id: string;
-    predictionScore?: number;
-}
-export type NetworkSpeed = "slow" | "medium" | "fast" | "unknown";
-export interface PrefetchStats {
-    queueSize: number;
-    historySize: number;
-    networkSpeed: NetworkSpeed;
-    isProcessing: boolean;
-    totalPrefetches: number;
-    successfulPrefetches: number;
-    failedPrefetches: number;
-    averagePrefetchTime: number;
-    skippedPrefetches: number;
-}
-export interface InteractionRecord {
-    queryKey: QueryKey;
-    timestamp: number;
-    type: "view" | "hover" | "click" | "focus";
-}
-export interface PredictionResult {
-    queryKey: QueryKey;
-    score: number;
-    reason: string;
-}
-export declare class SmartPrefetchManager {
-    private queryClient;
-    private prefetchQueue;
-    private prefetchHistory;
-    private networkSpeed;
-    private isProcessing;
-    private maxQueueSize;
-    private maxHistorySize;
-    private totalPrefetches;
-    private successfulPrefetches;
-    private failedPrefetches;
-    private skippedPrefetches;
-    private prefetchTimes;
-    private maxPrefetchTimesSize;
-    private interactionHistory;
-    private maxInteractionHistorySize;
-    private queryAccessCounts;
-    private querySequences;
-    private maxSequenceSize;
-    private networkCleanup?;
-    constructor(queryClient: QueryClient);
-    private initNetworkMonitoring;
-    private updateNetworkSpeed;
-    getNetworkSpeed(): NetworkSpeed;
-    isSlowNetwork(): boolean;
-    shouldPrefetch(queryKey: QueryKey, config?: PrefetchConfig): boolean;
-    addPrefetchTask(queryKey: QueryKey, queryFn: QueryFunction<any>, config?: PrefetchConfig): boolean;
-    private processQueue;
-    private getSortedTasks;
-    prefetchNow<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, config?: PrefetchConfig): Promise<void>;
-    private addToHistory;
-    clearHistory(): void;
-    clearQueue(): void;
-    reset(): void;
-    destroy(): void;
-    recordInteraction(queryKey: QueryKey, type?: "view" | "hover" | "click" | "focus"): void;
-    getPredictions(currentQueryKey?: QueryKey, limit?: number): PredictionResult[];
-    prefetchPredicted(currentQueryKey: QueryKey | undefined, queryFnMap: Map<string, QueryFunction<any>>, config?: PrefetchConfig): Promise<void>;
-    clearInteractionHistory(): void;
-    private recordPrefetchTime;
-    private getAveragePrefetchTime;
-    getStats(): PrefetchStats;
-    getPerformanceReport(): {
-        stats: PrefetchStats;
-        successRate: number;
-        predictions: {
-            totalInteractions: number;
-            uniqueQueries: number;
-            sequencePatterns: number;
-        };
-        queue: {
-            size: number;
-            byPriority: {
-                high: number;
-                medium: number;
-                low: number;
-            };
-        };
-    };
-    resetStats(): void;
-    private getQueryKeyString;
-    private delay;
-    setMaxQueueSize(size: number): void;
-    setMaxHistorySize(size: number): void;
-    getQueuedTasks(): PrefetchTask[];
-    removeTask(queryKey: QueryKey): boolean;
-    hasTask(queryKey: QueryKey): boolean;
-    updateTaskPriority(queryKey: QueryKey, priority: "high" | "medium" | "low"): boolean;
-    pauseQueue(): void;
-    resumeQueue(): void;
-}
-export declare function getPrefetchManager(queryClient: QueryClient): SmartPrefetchManager;
-export declare function resetPrefetchManager(): void;
-//# sourceMappingURL=prefetchManager.d.ts.map

package/dist/utils/prefetchManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prefetchManager.d.ts","sourceRoot":"","sources":["../../src/utils/prefetchManager.ts"],"names":[],"mappings":"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"}

package/dist/utils/prefetchManager.js

@@ -1,246 +0,0 @@
-import { DEFAULT_STALE_TIME } from "../core/config.js";
-import { getNetworkInfo, getNetworkSpeed } from "./network.js";
-export class SmartPrefetchManager {
-    constructor(queryClient) {
-        this.prefetchQueue = new Map();
-        this.prefetchHistory = new Set();
-        this.networkSpeed = "fast";
-        this.isProcessing = false;
-        this.maxQueueSize = 10;
-        this.maxHistorySize = 100;
-        this.totalPrefetches = 0;
-        this.successfulPrefetches = 0;
-        this.failedPrefetches = 0;
-        this.skippedPrefetches = 0;
-        this.prefetchTimes = [];
-        this.maxPrefetchTimesSize = 50;
-        this.interactionHistory = [];
-        this.maxInteractionHistorySize = 100;
-        this.queryAccessCounts = new Map();
-        this.querySequences = [];
-        this.maxSequenceSize = 50;
-        this.queryClient = queryClient;
-        this.initNetworkMonitoring();
-    }
-    initNetworkMonitoring() {
-        const networkInfo = getNetworkInfo();
-        if (!networkInfo) {
-            return;
-        }
-        this.updateNetworkSpeed();
-        if (typeof navigator !== "undefined" && "connection" in navigator) {
-            const navWithConnection = navigator;
-            const connection = navWithConnection.connection || navWithConnection.mozConnection || navWithConnection.webkitConnection;
-            const handleNetworkChange = () => { this.updateNetworkSpeed(); };
-            connection?.addEventListener?.("change", handleNetworkChange);
-            this.networkCleanup = () => { connection?.removeEventListener("change", handleNetworkChange); };
-        }
-    }
-    updateNetworkSpeed() { this.networkSpeed = getNetworkSpeed(); }
-    getNetworkSpeed() { return this.networkSpeed; }
-    isSlowNetwork() { return this.networkSpeed === "slow" || this.networkSpeed === "unknown"; }
-    shouldPrefetch(queryKey, config = {}) {
-        const key = this.getQueryKeyString(queryKey);
-        if (this.prefetchQueue.has(key))
-            return false;
-        if (this.prefetchHistory.has(key))
-            return false;
-        const cachedData = this.queryClient.getQueryData(queryKey);
-        if (cachedData)
-            return false;
-        if (this.isSlowNetwork() && !config.allowSlowNetwork)
-            return false;
-        if (this.prefetchQueue.size >= this.maxQueueSize)
-            return false;
-        return true;
-    }
-    addPrefetchTask(queryKey, queryFn, config = {}) {
-        if (!this.shouldPrefetch(queryKey, config)) {
-            this.skippedPrefetches++;
-            return false;
-        }
-        const key = this.getQueryKeyString(queryKey);
-        const task = { id: `${key}-${Date.now()}`, queryKey, queryFn, config: { priority: "medium", delay: 0, staleTime: DEFAULT_STALE_TIME, allowSlowNetwork: false, ...config }, timestamp: Date.now() };
-        this.prefetchQueue.set(key, task);
-        this.processQueue();
-        return true;
-    }
-    async processQueue() {
-        if (this.isProcessing || this.prefetchQueue.size === 0) {
-            return;
-        }
-        this.isProcessing = true;
-        try {
-            const sortedTasks = this.getSortedTasks();
-            for (const task of sortedTasks) {
-                const key = this.getQueryKeyString(task.queryKey);
-                const startTime = Date.now();
-                if (task.config.delay && task.config.delay > 0) {
-                    await this.delay(task.config.delay);
-                }
-                try {
-                    this.totalPrefetches++;
-                    await this.queryClient.prefetchQuery({ queryKey: task.queryKey, queryFn: task.queryFn, staleTime: task.config.staleTime });
-                    this.successfulPrefetches++;
-                    const duration = Date.now() - startTime;
-                    this.recordPrefetchTime(duration);
-                    this.addToHistory(key);
-                }
-                catch {
-                    this.failedPrefetches++;
-                }
-                this.prefetchQueue.delete(key);
-            }
-        }
-        finally {
-            this.isProcessing = false;
-        }
-    }
-    getSortedTasks() {
-        const tasks = Array.from(this.prefetchQueue.values());
-        const priorityOrder = { high: 0, medium: 1, low: 2 };
-        return tasks.sort((a, b) => {
-            const priorityA = priorityOrder[a.config.priority || "medium"];
-            const priorityB = priorityOrder[b.config.priority || "medium"];
-            if (priorityA !== priorityB)
-                return priorityA - priorityB;
-            if (a.predictionScore !== undefined && b.predictionScore !== undefined) {
-                if (a.predictionScore !== b.predictionScore) {
-                    return b.predictionScore - a.predictionScore;
-                }
-            }
-            return a.timestamp - b.timestamp;
-        });
-    }
-    async prefetchNow(queryKey, queryFn, config = {}) {
-        const key = this.getQueryKeyString(queryKey);
-        const startTime = Date.now();
-        try {
-            this.totalPrefetches++;
-            await this.queryClient.prefetchQuery({ queryKey, queryFn, staleTime: config.staleTime || DEFAULT_STALE_TIME });
-            this.successfulPrefetches++;
-            const duration = Date.now() - startTime;
-            this.recordPrefetchTime(duration);
-            this.addToHistory(key);
-        }
-        catch (error) {
-            this.failedPrefetches++;
-            throw error;
-        }
-    }
-    addToHistory(key) { this.prefetchHistory.add(key); if (this.prefetchHistory.size > this.maxHistorySize) {
-        const firstKey = this.prefetchHistory.values().next().value;
-        if (firstKey) {
-            this.prefetchHistory.delete(firstKey);
-        }
-    } }
-    clearHistory() { this.prefetchHistory.clear(); }
-    clearQueue() { this.prefetchQueue.clear(); }
-    reset() { this.clearQueue(); this.clearHistory(); this.clearInteractionHistory(); this.resetStats(); }
-    destroy() { if (this.networkCleanup) {
-        this.networkCleanup();
-        this.networkCleanup = undefined;
-    } this.reset(); }
-    recordInteraction(queryKey, type = "view") {
-        const interaction = { queryKey, timestamp: Date.now(), type };
-        this.interactionHistory.push(interaction);
-        if (this.interactionHistory.length > this.maxInteractionHistorySize) {
-            this.interactionHistory.shift();
-        }
-        const key = this.getQueryKeyString(queryKey);
-        this.queryAccessCounts.set(key, (this.queryAccessCounts.get(key) || 0) + 1);
-        if (this.interactionHistory.length >= 2) {
-            const prevInteraction = this.interactionHistory[this.interactionHistory.length - 2];
-            const prevKey = this.getQueryKeyString(prevInteraction.queryKey);
-            const existingSequence = this.querySequences.find((s) => s.from === prevKey && s.to === key);
-            if (existingSequence) {
-                existingSequence.count++;
-            }
-            else {
-                this.querySequences.push({ from: prevKey, to: key, count: 1 });
-                if (this.querySequences.length > this.maxSequenceSize) {
-                    this.querySequences.shift();
-                }
-            }
-        }
-    }
-    getPredictions(currentQueryKey, limit = 5) {
-        const predictions = [];
-        if (currentQueryKey) {
-            const currentKey = this.getQueryKeyString(currentQueryKey);
-            const sequences = this.querySequences.filter((s) => s.from === currentKey).sort((a, b) => b.count - a.count).slice(0, limit);
-            sequences.forEach((seq) => { try {
-                const queryKey = JSON.parse(seq.to);
-                predictions.push({ queryKey, score: Math.min(seq.count / 10, 1), reason: `Frequently accessed after current query (${seq.count} times)` });
-            }
-            catch { } });
-        }
-        const frequentQueries = Array.from(this.queryAccessCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit);
-        frequentQueries.forEach(([key, count]) => { try {
-            const queryKey = JSON.parse(key);
-            if (!predictions.some((p) => this.getQueryKeyString(p.queryKey) === key)) {
-                predictions.push({ queryKey, score: Math.min(count / 20, 1), reason: `Frequently accessed (${count} times)` });
-            }
-        }
-        catch { } });
-        const recentInteractions = this.interactionHistory.slice(-10).reverse();
-        recentInteractions.forEach((interaction, index) => {
-            const key = this.getQueryKeyString(interaction.queryKey);
-            if (!predictions.some((p) => this.getQueryKeyString(p.queryKey) === key)) {
-                predictions.push({ queryKey: interaction.queryKey, score: Math.max(0.3 - index * 0.03, 0.1), reason: `Recently accessed (${index + 1} queries ago)` });
-            }
-        });
-        return predictions.sort((a, b) => b.score - a.score).slice(0, limit);
-    }
-    async prefetchPredicted(currentQueryKey, queryFnMap, config = {}) {
-        const predictions = this.getPredictions(currentQueryKey);
-        for (const prediction of predictions) {
-            const key = this.getQueryKeyString(prediction.queryKey);
-            const queryFn = queryFnMap.get(key);
-            if (queryFn) {
-                const taskConfig = { ...config, priority: prediction.score > 0.7 ? "high" : prediction.score > 0.4 ? "medium" : "low" };
-                const added = this.addPrefetchTask(prediction.queryKey, queryFn, taskConfig);
-                if (added) {
-                    const task = this.prefetchQueue.get(key);
-                    if (task) {
-                        task.predictionScore = prediction.score;
-                    }
-                }
-            }
-        }
-    }
-    clearInteractionHistory() { this.interactionHistory = []; this.queryAccessCounts.clear(); this.querySequences = []; }
-    recordPrefetchTime(duration) { this.prefetchTimes.push(duration); if (this.prefetchTimes.length > this.maxPrefetchTimesSize) {
-        this.prefetchTimes.shift();
-    } }
-    getAveragePrefetchTime() { if (this.prefetchTimes.length === 0) {
-        return 0;
-    } const sum = this.prefetchTimes.reduce((acc, time) => acc + time, 0); return Math.round(sum / this.prefetchTimes.length); }
-    getStats() { return { queueSize: this.prefetchQueue.size, historySize: this.prefetchHistory.size, networkSpeed: this.networkSpeed, isProcessing: this.isProcessing, totalPrefetches: this.totalPrefetches, successfulPrefetches: this.successfulPrefetches, failedPrefetches: this.failedPrefetches, averagePrefetchTime: this.getAveragePrefetchTime(), skippedPrefetches: this.skippedPrefetches }; }
-    getPerformanceReport() {
-        const stats = this.getStats();
-        const successRate = stats.totalPrefetches > 0 ? Math.round((stats.successfulPrefetches / stats.totalPrefetches) * 100) : 0;
-        const queueTasks = Array.from(this.prefetchQueue.values());
-        const byPriority = { high: queueTasks.filter((t) => t.config.priority === "high").length, medium: queueTasks.filter((t) => t.config.priority === "medium").length, low: queueTasks.filter((t) => t.config.priority === "low").length };
-        return { stats, successRate, predictions: { totalInteractions: this.interactionHistory.length, uniqueQueries: this.queryAccessCounts.size, sequencePatterns: this.querySequences.length }, queue: { size: this.prefetchQueue.size, byPriority } };
-    }
-    resetStats() { this.totalPrefetches = 0; this.successfulPrefetches = 0; this.failedPrefetches = 0; this.skippedPrefetches = 0; this.prefetchTimes = []; }
-    getQueryKeyString(queryKey) { return JSON.stringify(queryKey); }
-    delay(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
-    setMaxQueueSize(size) { this.maxQueueSize = size; }
-    setMaxHistorySize(size) { this.maxHistorySize = size; }
-    getQueuedTasks() { return Array.from(this.prefetchQueue.values()); }
-    removeTask(queryKey) { const key = this.getQueryKeyString(queryKey); return this.prefetchQueue.delete(key); }
-    hasTask(queryKey) { const key = this.getQueryKeyString(queryKey); return this.prefetchQueue.has(key); }
-    updateTaskPriority(queryKey, priority) { const key = this.getQueryKeyString(queryKey); const task = this.prefetchQueue.get(key); if (task) {
-        task.config.priority = priority;
-        return true;
-    } return false; }
-    pauseQueue() { this.isProcessing = true; }
-    resumeQueue() { this.isProcessing = false; this.processQueue(); }
-}
-let prefetchManagerInstance = null;
-export function getPrefetchManager(queryClient) { if (!prefetchManagerInstance) {
-    prefetchManagerInstance = new SmartPrefetchManager(queryClient);
-} return prefetchManagerInstance; }
-export function resetPrefetchManager() { prefetchManagerInstance = null; }

package/dist/utils/queryKey.d.ts

@@ -1,24 +0,0 @@
-export interface NormalizeConfig<T = any> {
-    required?: (keyof T)[];
-    defaults?: Partial<T>;
-    sortKeys?: boolean;
-    removeEmpty?: boolean;
-}
-export declare function normalizeQueryParams<T extends Record<string, any>>(params: T | undefined, config?: NormalizeConfig<T>): Record<string, any>;
-export interface QueryKeyFactoryConfig<TParams = any> {
-    namespace: string;
-    normalizeConfig?: NormalizeConfig<TParams>;
-}
-export interface QueryKeyFactory<TParams = any> {
-    all: () => readonly [string];
-    lists: () => readonly [string, string];
-    list: (params?: TParams) => readonly [string, string, Record<string, any>];
-    details: () => readonly [string, string];
-    detail: (id: string) => readonly [string, string, string];
-    custom: (queryName: string, params?: any) => readonly [string, string, string, any?];
-}
-export declare function createQueryKeyFactory<TParams = any>(config: QueryKeyFactoryConfig<TParams>): QueryKeyFactory<TParams>;
-export declare function createSimpleQueryKeyFactory(namespace: string): QueryKeyFactory;
-export declare function isQueryKeyEqual(key1: readonly any[], key2: readonly any[]): boolean;
-export declare function extractParamsFromKey(queryKey: readonly any[]): Record<string, any> | undefined;
-//# sourceMappingURL=queryKey.d.ts.map

package/dist/utils/queryKey.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queryKey.d.ts","sourceRoot":"","sources":["../../src/utils/queryKey.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,GAAG;IAAI,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE;AACtI,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,SAAS,EAAE,MAAM,GAAE,eAAe,CAAC,CAAC,CAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAuB/I;AACD,MAAM,WAAW,qBAAqB,CAAC,OAAO,GAAG,GAAG;IAAI,SAAS,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,eAAe,CAAC,OAAO,CAAC,CAAA;CAAE;AACvH,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,GAAG;IAAI,GAAG,EAAE,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,KAAK,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,CAAA;CAAE;AAC/X,wBAAgB,qBAAqB,CAAC,OAAO,GAAG,GAAG,EAAE,MAAM,EAAE,qBAAqB,CAAC,OAAO,CAAC,GAAG,eAAe,CAAC,OAAO,CAAC,CAUrH;AACD,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,CAAiD;AAChI,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,EAAE,IAAI,EAAE,SAAS,GAAG,EAAE,GAAG,OAAO,CAUnF;AACD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,SAAS,GAAG,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAI9F"}

package/dist/utils/queryKey.js

@@ -1,77 +0,0 @@
-export function normalizeQueryParams(params, config = {}) {
-    const { required = [], defaults = {}, sortKeys = true, removeEmpty = true } = config;
-    if (!params) {
-        return { ...defaults };
-    }
-    const normalized = {};
-    required.forEach((key) => {
-        const value = params[key] ?? defaults[key];
-        if (value !== undefined) {
-            if (typeof value === "number" || (typeof value === "string" && !Number.isNaN(Number(value)))) {
-                normalized[String(key)] = Number(value);
-            }
-            else {
-                normalized[String(key)] = value;
-            }
-        }
-    });
-    const optionalKeys = Object.keys(params).filter((key) => !required.includes(key));
-    if (sortKeys) {
-        optionalKeys.sort();
-    }
-    optionalKeys.forEach((key) => {
-        const value = params[key];
-        if (removeEmpty && (value === undefined || value === null || value === "")) {
-            return;
-        }
-        if (typeof value === "string") {
-            const trimmed = value.trim();
-            if (trimmed || !removeEmpty) {
-                normalized[key] = trimmed;
-            }
-        }
-        else if (value !== undefined && value !== null) {
-            normalized[key] = value;
-        }
-    });
-    return normalized;
-}
-export function createQueryKeyFactory(config) {
-    const { namespace, normalizeConfig } = config;
-    return {
-        all: () => [namespace],
-        lists: () => [namespace, "list"],
-        list: (params) => { const normalized = normalizeQueryParams(params, normalizeConfig); return [namespace, "list", normalized]; },
-        details: () => [namespace, "detail"],
-        detail: (id) => [namespace, "detail", id],
-        custom: (queryName, params) => { if (params !== undefined) {
-            return [namespace, "custom", queryName, params];
-        } return [namespace, "custom", queryName]; }
-    };
-}
-export function createSimpleQueryKeyFactory(namespace) { return createQueryKeyFactory({ namespace }); }
-export function isQueryKeyEqual(key1, key2) {
-    if (key1.length !== key2.length)
-        return false;
-    return key1.every((value, index) => {
-        const other = key2[index];
-        if (typeof value !== "object" || value === null) {
-            return value === other;
-        }
-        if (typeof other !== "object" || other === null) {
-            return false;
-        }
-        const keys1 = Object.keys(value);
-        const keys2 = Object.keys(other);
-        if (keys1.length !== keys2.length)
-            return false;
-        return keys1.every((key) => value[key] === other[key]);
-    });
-}
-export function extractParamsFromKey(queryKey) {
-    const lastItem = queryKey[queryKey.length - 1];
-    if (typeof lastItem === "object" && lastItem !== null && !Array.isArray(lastItem)) {
-        return lastItem;
-    }
-    return undefined;
-}

package/dist/utils/selectors.d.ts

@@ -1,30 +0,0 @@
-import type { EntityWithId, PaginatedData } from "../types/selectors";
-export declare function selectById<T extends EntityWithId>(id: T["id"]): (data: T[] | undefined) => T | undefined;
-export declare function selectByIds<T extends EntityWithId>(ids: T["id"][]): (data: T[] | undefined) => T[];
-export declare function selectFirst<T>(data: T[] | undefined): T | undefined;
-export declare function selectLast<T>(data: T[] | undefined): T | undefined;
-export declare function selectCount<T>(data: T[] | undefined): number;
-export declare function selectTotal<T extends {
-    total?: number;
-}>(data: T | undefined): number;
-export declare function selectItems<TItem, T extends PaginatedData<TItem>>(data: T | undefined): TItem[];
-export declare function selectWhere<T>(predicate: (item: T) => boolean): (data: T[] | undefined) => T[];
-export declare function selectMap<T, R>(mapper: (item: T) => R): (data: T[] | undefined) => R[];
-export declare function selectField<T, K extends keyof T>(field: K): (data: T | undefined) => T[K] | undefined;
-export declare function selectFields<T, K extends keyof T>(fields: K[]): (data: T | undefined) => Pick<T, K> | undefined;
-export declare function compose<T, R1, R2>(selector1: (data: T) => R1, selector2: (data: R1) => R2): (data: T) => R2;
-export declare const selectors: {
-    byId: typeof selectById;
-    byIds: typeof selectByIds;
-    first: typeof selectFirst;
-    last: typeof selectLast;
-    count: typeof selectCount;
-    total: typeof selectTotal;
-    items: typeof selectItems;
-    where: typeof selectWhere;
-    map: typeof selectMap;
-    field: typeof selectField;
-    fields: typeof selectFields;
-    compose: typeof compose;
-};
-//# sourceMappingURL=selectors.d.ts.map

package/dist/utils/selectors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../src/utils/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACtE,wBAAgB,UAAU,CAAC,CAAC,SAAS,YAAY,EAAE,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAY,MAAM,CAAC,EAAE,GAAG,SAAS,KAAG,CAAC,GAAG,SAAS,CAAuD;AACtK,wBAAgB,WAAW,CAAC,CAAC,SAAS,YAAY,EAAE,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,IAAY,MAAM,CAAC,EAAE,GAAG,SAAS,KAAG,CAAC,EAAE,CAAqF;AAC9L,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,SAAS,GAAG,CAAC,GAAG,SAAS,CAAsB;AAC1F,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,SAAS,GAAG,CAAC,GAAG,SAAS,CAAoF;AACvJ,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,SAAS,GAAG,MAAM,CAA8B;AAC3F,wBAAgB,WAAW,CAAC,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,GAAG,MAAM,CAA6B;AACnH,wBAAgB,WAAW,CAAC,KAAK,EAAE,CAAC,SAAS,aAAa,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,GAAG,KAAK,EAAE,CAA8B;AAC9H,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,IAAY,MAAM,CAAC,EAAE,GAAG,SAAS,KAAG,CAAC,EAAE,CAA+D;AACpK,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,IAAY,MAAM,CAAC,EAAE,GAAG,SAAS,KAAG,CAAC,EAAE,CAAyD;AACtJ,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,IAAY,MAAM,CAAC,GAAG,SAAS,KAAG,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAgC;AAC5I,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAY,MAAM,CAAC,GAAG,SAAS,KAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAoJ;AAC1Q,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,IAAY,MAAM,CAAC,KAAG,EAAE,CAA6C;AAC/J,eAAO,MAAM,SAAS;;;;;;;;;;;;;CAAoO,CAAC"}

package/dist/utils/selectors.js

@@ -1,18 +0,0 @@
-export function selectById(id) { return (data) => { return data?.find((item) => item.id === id); }; }
-export function selectByIds(ids) { return (data) => { if (!data)
-    return []; return data.filter((item) => ids.includes(item.id)); }; }
-export function selectFirst(data) { return data?.[0]; }
-export function selectLast(data) { if (!data || data.length === 0)
-    return undefined; return data[data.length - 1]; }
-export function selectCount(data) { return data?.length ?? 0; }
-export function selectTotal(data) { return data?.total ?? 0; }
-export function selectItems(data) { return data?.items ?? []; }
-export function selectWhere(predicate) { return (data) => { if (!data)
-    return []; return data.filter(predicate); }; }
-export function selectMap(mapper) { return (data) => { if (!data)
-    return []; return data.map(mapper); }; }
-export function selectField(field) { return (data) => { return data?.[field]; }; }
-export function selectFields(fields) { return (data) => { if (!data)
-    return undefined; const result = {}; fields.forEach((field) => { result[field] = data[field]; }); return result; }; }
-export function compose(selector1, selector2) { return (data) => { return selector2(selector1(data)); }; }
-export const selectors = { byId: selectById, byIds: selectByIds, first: selectFirst, last: selectLast, count: selectCount, total: selectTotal, items: selectItems, where: selectWhere, map: selectMap, field: selectField, fields: selectFields, compose };

package/dist/utils/storage.d.ts

@@ -1,7 +0,0 @@
-import type { StorageInfo } from "../types/persistence";
-import { StorageType } from "../types/base.js";
-export declare function isStorageAvailable(storageType: StorageType): boolean;
-export declare function getStorageUsage(storageType: StorageType): StorageInfo;
-export declare function formatBytes(bytes: number): string;
-export declare function deepClone<T>(obj: T): T;
-//# sourceMappingURL=storage.d.ts.map

package/dist/utils/storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/utils/storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAa/C,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CASpE;AACD,wBAAgB,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,WAAW,CAiBrE;AACD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIjD;AACD,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAMtC"}

package/dist/utils/storage.js

@@ -1,84 +0,0 @@
-import { StorageType } from "../types/base.js";
-function getStorageByType(storageType) {
-    try {
-        switch (storageType) {
-            case StorageType.LOCAL:
-                return typeof window !== "undefined" ? window.localStorage : null;
-            case StorageType.SESSION:
-                return typeof window !== "undefined" ? window.sessionStorage : null;
-            default:
-                return null;
-        }
-    }
-    catch {
-        return null;
-    }
-}
-export function isStorageAvailable(storageType) {
-    try {
-        const storage = getStorageByType(storageType);
-        if (!storage) {
-            return false;
-        }
-        const testKey = "__storage_test__";
-        storage.setItem(testKey, "test");
-        storage.removeItem(testKey);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function getStorageUsage(storageType) {
-    try {
-        const storage = getStorageByType(storageType);
-        if (!storage) {
-            return { type: storageType, used: 0, total: 0, usage: 0, available: false, error: "Storage not available" };
-        }
-        let used = 0;
-        for (let i = 0; i < storage.length; i++) {
-            const key = storage.key(i);
-            if (key) {
-                const value = storage.getItem(key);
-                if (value) {
-                    used += key.length + value.length;
-                }
-            }
-        }
-        const total = storageType === StorageType.LOCAL ? 5 * 1024 * 1024 : 5 * 1024 * 1024;
-        return { type: storageType, used, total, usage: used / total, available: true };
-    }
-    catch (error) {
-        return { type: storageType, used: 0, total: 0, usage: 0, available: false, error: error instanceof Error ? error.message : "Unknown error" };
-    }
-}
-export function formatBytes(bytes) {
-    if (bytes === 0) {
-        return "0 Bytes";
-    }
-    const k = 1024;
-    const sizes = ["Bytes", "KB", "MB", "GB"];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
-}
-export function deepClone(obj) {
-    if (obj === null || typeof obj !== "object") {
-        return obj;
-    }
-    if (obj instanceof Date) {
-        return new Date(obj.getTime());
-    }
-    if (Array.isArray(obj)) {
-        return obj.map((item) => deepClone(item));
-    }
-    if (typeof obj === "object") {
-        const cloned = {};
-        for (const key in obj) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                cloned[key] = deepClone(obj[key]);
-            }
-        }
-        return cloned;
-    }
-    return obj;
-}