@revealui/core 0.0.1-pre.4 → 0.2.1

package/dist/caching/app-cache.js

@@ -0,0 +1,430 @@
+/**
+ * Application-Level Caching
+ *
+ * Utilities for React Query, SWR, and application-level cache management
+ */
+import { logger } from '../observability/logger.js';
+export const DEFAULT_REACT_QUERY_CONFIG = {
+    defaultOptions: {
+        queries: {
+            staleTime: 1000 * 60 * 5, // 5 minutes
+            cacheTime: 1000 * 60 * 30, // 30 minutes
+            refetchOnWindowFocus: true,
+            refetchOnReconnect: true,
+            refetchOnMount: true,
+            retry: 3,
+            retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
+        },
+        mutations: {
+            retry: 3,
+            retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
+        },
+    },
+};
+export const DEFAULT_SWR_CONFIG = {
+    revalidateOnFocus: true,
+    revalidateOnReconnect: true,
+    refreshInterval: 0,
+    dedupingInterval: 2000,
+    loadingTimeout: 3000,
+    errorRetryInterval: 5000,
+    errorRetryCount: 3,
+    focusThrottleInterval: 5000,
+    shouldRetryOnError: true,
+    keepPreviousData: false,
+};
+/**
+ * Cache Key Generator
+ */
+export class CacheKeyGenerator {
+    prefix;
+    constructor(prefix = 'app') {
+        this.prefix = prefix;
+    }
+    /**
+     * Generate key for list queries
+     */
+    list(resource, filters) {
+        const key = [this.prefix, resource, 'list'];
+        if (filters && Object.keys(filters).length > 0) {
+            key.push(JSON.stringify(filters));
+        }
+        return key;
+    }
+    /**
+     * Generate key for detail queries
+     */
+    detail(resource, id) {
+        return [this.prefix, resource, 'detail', String(id)];
+    }
+    /**
+     * Generate key for custom queries
+     */
+    custom(...parts) {
+        return [
+            this.prefix,
+            ...parts.map((part) => (typeof part === 'object' ? JSON.stringify(part) : String(part))),
+        ];
+    }
+    /**
+     * Generate key for infinite queries
+     */
+    infinite(resource, filters) {
+        const key = [this.prefix, resource, 'infinite'];
+        if (filters && Object.keys(filters).length > 0) {
+            key.push(JSON.stringify(filters));
+        }
+        return key;
+    }
+}
+/**
+ * Cache Invalidation Strategies
+ */
+export class CacheInvalidator {
+    /**
+     * Invalidate by resource
+     */
+    static byResource(resource) {
+        return ['app', resource];
+    }
+    /**
+     * Invalidate by ID
+     */
+    static byId(resource, id) {
+        return ['app', resource, 'detail', String(id)];
+    }
+    /**
+     * Invalidate lists
+     */
+    static lists(resource) {
+        return ['app', resource, 'list'];
+    }
+    /**
+     * Invalidate infinite queries
+     */
+    static infinite(resource) {
+        return ['app', resource, 'infinite'];
+    }
+    /**
+     * Invalidate all
+     */
+    static all() {
+        return ['app'];
+    }
+}
+/**
+ * Optimistic Update Helper
+ */
+export class OptimisticUpdater {
+    /**
+     * Update list (add item)
+     */
+    static addToList(oldData, newItem) {
+        if (!oldData)
+            return [newItem];
+        return [...oldData, newItem];
+    }
+    /**
+     * Update list (remove item)
+     */
+    static removeFromList(oldData, id) {
+        if (!oldData)
+            return [];
+        return oldData.filter((item) => item.id !== id);
+    }
+    /**
+     * Update list (update item)
+     */
+    static updateInList(oldData, id, updates) {
+        if (!oldData)
+            return [];
+        return oldData.map((item) => (item.id === id ? { ...item, ...updates } : item));
+    }
+    /**
+     * Update detail
+     */
+    static updateDetail(oldData, updates) {
+        if (!oldData)
+            return undefined;
+        return { ...oldData, ...updates };
+    }
+    /**
+     * Update paginated list
+     */
+    static updatePaginatedList(oldData, id, updates) {
+        if (!oldData)
+            return undefined;
+        return {
+            ...oldData,
+            pages: oldData.pages.map((page) => ({
+                ...page,
+                data: page.data.map((item) => (item.id === id ? { ...item, ...updates } : item)),
+            })),
+        };
+    }
+}
+export class CachePrefetcher {
+    /**
+     * Prefetch on hover
+     */
+    static onHover(prefetchFn, delay = 300) {
+        let timeout = null;
+        return {
+            onMouseEnter: () => {
+                timeout = setTimeout(() => {
+                    prefetchFn();
+                }, delay);
+            },
+            onMouseLeave: () => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                    timeout = null;
+                }
+            },
+        };
+    }
+    /**
+     * Prefetch on visibility
+     */
+    static onVisible(element, prefetchFn, options) {
+        if (!element || typeof IntersectionObserver === 'undefined') {
+            return () => { };
+        }
+        const observer = new IntersectionObserver((entries) => {
+            for (const entry of entries) {
+                if (entry.isIntersecting) {
+                    prefetchFn();
+                    observer.disconnect();
+                }
+            }
+        }, options);
+        observer.observe(element);
+        return () => observer.disconnect();
+    }
+    /**
+     * Prefetch on idle
+     */
+    static onIdle(prefetchFn) {
+        if ('requestIdleCallback' in window) {
+            window.requestIdleCallback(() => prefetchFn());
+        }
+        else {
+            setTimeout(() => prefetchFn(), 1);
+        }
+    }
+}
+export class CachePersistence {
+    config;
+    constructor(config) {
+        this.config = {
+            storage: 'localStorage',
+            version: 1,
+            maxAge: 1000 * 60 * 60 * 24, // 1 day
+            ...config,
+        };
+    }
+    /**
+     * Save to storage
+     */
+    async save(data) {
+        const entry = {
+            data,
+            version: this.config.version,
+            timestamp: Date.now(),
+        };
+        try {
+            if (this.config.storage === 'indexedDB') {
+                await this.saveToIndexedDB(entry);
+            }
+            else {
+                const storage = this.config.storage === 'localStorage' ? localStorage : sessionStorage;
+                storage.setItem(this.config.key, JSON.stringify(entry));
+            }
+        }
+        catch (error) {
+            logger.error('Cache persistence save failed', error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Load from storage
+     */
+    async load() {
+        try {
+            let entry;
+            if (this.config.storage === 'indexedDB') {
+                entry = await this.loadFromIndexedDB();
+            }
+            else {
+                const storage = this.config.storage === 'localStorage' ? localStorage : sessionStorage;
+                const stored = storage.getItem(this.config.key);
+                if (!stored)
+                    return null;
+                entry = JSON.parse(stored);
+            }
+            if (!entry)
+                return null;
+            // Check version
+            if (entry.version !== this.config.version) {
+                await this.remove();
+                return null;
+            }
+            // Check age
+            const age = Date.now() - entry.timestamp;
+            if (age > this.config.maxAge) {
+                await this.remove();
+                return null;
+            }
+            return entry.data;
+        }
+        catch (error) {
+            logger.error('Cache persistence load failed', error instanceof Error ? error : new Error(String(error)));
+            return null;
+        }
+    }
+    /**
+     * Remove from storage
+     */
+    async remove() {
+        try {
+            if (this.config.storage === 'indexedDB') {
+                await this.removeFromIndexedDB();
+            }
+            else {
+                const storage = this.config.storage === 'localStorage' ? localStorage : sessionStorage;
+                storage.removeItem(this.config.key);
+            }
+        }
+        catch (error) {
+            logger.error('Cache persistence remove failed', error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Save to IndexedDB
+     */
+    async saveToIndexedDB(entry) {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open('app-cache', 1);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                const db = request.result;
+                const transaction = db.transaction(['cache'], 'readwrite');
+                const store = transaction.objectStore('cache');
+                const putRequest = store.put(entry, this.config.key);
+                putRequest.onerror = () => reject(putRequest.error);
+                putRequest.onsuccess = () => resolve();
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains('cache')) {
+                    db.createObjectStore('cache');
+                }
+            };
+        });
+    }
+    /**
+     * Load from IndexedDB
+     */
+    async loadFromIndexedDB() {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open('app-cache', 1);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                const db = request.result;
+                const transaction = db.transaction(['cache'], 'readonly');
+                const store = transaction.objectStore('cache');
+                const getRequest = store.get(this.config.key);
+                getRequest.onerror = () => reject(getRequest.error);
+                getRequest.onsuccess = () => resolve(getRequest.result || null);
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains('cache')) {
+                    db.createObjectStore('cache');
+                }
+            };
+        });
+    }
+    /**
+     * Remove from IndexedDB
+     */
+    async removeFromIndexedDB() {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open('app-cache', 1);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                const db = request.result;
+                const transaction = db.transaction(['cache'], 'readwrite');
+                const store = transaction.objectStore('cache');
+                const deleteRequest = store.delete(this.config.key);
+                deleteRequest.onerror = () => reject(deleteRequest.error);
+                deleteRequest.onsuccess = () => resolve();
+            };
+        });
+    }
+}
+export class CacheStatsTracker {
+    hits = 0;
+    misses = 0;
+    /**
+     * Record cache hit
+     */
+    recordHit() {
+        this.hits++;
+    }
+    /**
+     * Record cache miss
+     */
+    recordMiss() {
+        this.misses++;
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        const totalQueries = this.hits + this.misses;
+        const hitRate = totalQueries > 0 ? (this.hits / totalQueries) * 100 : 0;
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            hitRate,
+            totalQueries,
+            cacheSize: 0, // Would need cache implementation
+        };
+    }
+    /**
+     * Reset statistics
+     */
+    reset() {
+        this.hits = 0;
+        this.misses = 0;
+    }
+}
+/**
+ * Query dedupe helper
+ */
+export class QueryDeduplicator {
+    pending = new Map();
+    /**
+     * Deduplicate query
+     */
+    async dedupe(key, queryFn) {
+        // Check if query is already pending
+        const existing = this.pending.get(key);
+        if (existing) {
+            return existing;
+        }
+        // Execute query
+        const promise = queryFn();
+        // Store pending query
+        this.pending.set(key, promise);
+        // Remove from pending when done
+        promise.then(() => this.pending.delete(key)).catch(() => this.pending.delete(key));
+        return promise;
+    }
+    /**
+     * Clear pending queries
+     */
+    clear() {
+        this.pending.clear();
+    }
+}

package/dist/caching/cdn-config.d.ts

@@ -0,0 +1,155 @@
+/**
+ * CDN Configuration and Cache Management
+ *
+ * Utilities for CDN caching, edge caching, and cache invalidation
+ */
+/**
+ * CDN Cache Configuration
+ */
+export interface CDNCacheConfig {
+    provider?: 'cloudflare' | 'vercel' | 'fastly' | 'custom';
+    zones?: string[];
+    ttl?: number;
+    staleWhileRevalidate?: number;
+    staleIfError?: number;
+    bypassCache?: boolean;
+    cacheKey?: string[];
+    varyHeaders?: string[];
+}
+export declare const DEFAULT_CDN_CONFIG: CDNCacheConfig;
+/**
+ * Generate Cache-Control header
+ */
+export declare function generateCacheControl(config: {
+    maxAge?: number;
+    sMaxAge?: number;
+    staleWhileRevalidate?: number;
+    staleIfError?: number;
+    public?: boolean;
+    private?: boolean;
+    immutable?: boolean;
+    noCache?: boolean;
+    noStore?: boolean;
+}): string;
+/**
+ * Cache presets for different asset types
+ */
+export declare const CDN_CACHE_PRESETS: {
+    readonly immutable: {
+        readonly maxAge: 31536000;
+        readonly sMaxAge: 31536000;
+        readonly public: true;
+        readonly immutable: true;
+    };
+    readonly static: {
+        readonly maxAge: 2592000;
+        readonly sMaxAge: 31536000;
+        readonly staleWhileRevalidate: 86400;
+        readonly public: true;
+    };
+    readonly api: {
+        readonly maxAge: 0;
+        readonly sMaxAge: 60;
+        readonly staleWhileRevalidate: 30;
+        readonly public: true;
+    };
+    readonly page: {
+        readonly maxAge: 0;
+        readonly sMaxAge: 300;
+        readonly staleWhileRevalidate: 60;
+        readonly public: true;
+    };
+    readonly private: {
+        readonly maxAge: 300;
+        readonly private: true;
+        readonly staleWhileRevalidate: 60;
+    };
+    readonly noCache: {
+        readonly noStore: true;
+    };
+    readonly revalidate: {
+        readonly maxAge: 0;
+        readonly sMaxAge: 0;
+        readonly noCache: true;
+    };
+};
+/**
+ * CDN Purge Configuration
+ */
+export interface CDNPurgeConfig {
+    provider: 'cloudflare' | 'vercel' | 'fastly';
+    apiKey?: string;
+    apiSecret?: string;
+    zoneId?: string;
+    distributionId?: string;
+}
+/**
+ * Purge CDN cache
+ */
+export declare function purgeCDNCache(urls: string[], config: CDNPurgeConfig): Promise<{
+    success: boolean;
+    purged: number;
+    errors?: string[];
+}>;
+/**
+ * Purge by cache tag
+ */
+export declare function purgeCacheByTag(tags: string[], config: CDNPurgeConfig): Promise<{
+    success: boolean;
+    purged: number;
+    errors?: string[];
+}>;
+/**
+ * Purge everything
+ */
+export declare function purgeAllCache(config: CDNPurgeConfig): Promise<{
+    success: boolean;
+    errors?: string[];
+}>;
+/**
+ * CDN cache warming
+ */
+export declare function warmCDNCache(urls: string[], options?: {
+    concurrency?: number;
+    headers?: Record<string, string>;
+}): Promise<{
+    warmed: number;
+    failed: number;
+    errors: string[];
+}>;
+/**
+ * Generate cache tags
+ */
+export declare function generateCacheTags(resource: {
+    type: string;
+    id?: string | number;
+    related?: string[];
+}): string[];
+/**
+ * Edge cache configuration for Vercel
+ */
+export declare function generateVercelCacheConfig(preset: keyof typeof CDN_CACHE_PRESETS): {
+    headers: {
+        'Cache-Control': string;
+        'CDN-Cache-Control': string;
+        'Vercel-CDN-Cache-Control': string;
+    };
+};
+/**
+ * Edge cache configuration for Cloudflare
+ */
+export declare function generateCloudflareConfig(preset: keyof typeof CDN_CACHE_PRESETS, options?: {
+    cacheTags?: string[];
+    bypassOnCookie?: string;
+}): {
+    headers: Record<string, string>;
+};
+/**
+ * Check if response should be cached
+ */
+export declare function shouldCacheResponse(status: number, headers: Headers): boolean;
+/**
+ * Calculate cache TTL from headers
+ */
+export declare function getCacheTTL(headers: Headers): number;
+//# sourceMappingURL=cdn-config.d.ts.map

package/dist/caching/cdn-config.d.ts.map

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