@revealui/core 0.0.1-pre.3 → 0.2.0

package/dist/caching/edge-cache.js

@@ -0,0 +1,381 @@
+/**
+ * Edge Caching and ISR (Incremental Static Regeneration)
+ *
+ * Utilities for Next.js edge caching, ISR, and on-demand revalidation
+ */
+import { logger } from '../observability/logger.js';
+export const ISR_PRESETS = {
+    // Revalidate every request
+    always: {
+        revalidate: 0,
+    },
+    // Revalidate every minute
+    minute: {
+        revalidate: 60,
+    },
+    // Revalidate every 5 minutes
+    fiveMinutes: {
+        revalidate: 300,
+    },
+    // Revalidate every hour
+    hourly: {
+        revalidate: 3600,
+    },
+    // Revalidate daily
+    daily: {
+        revalidate: 86400,
+    },
+    // Never revalidate (static)
+    never: {
+        revalidate: false,
+    },
+};
+/**
+ * Generate static params for ISR
+ */
+export async function generateStaticParams(fetchFn, mapFn) {
+    try {
+        const items = await fetchFn();
+        return items.map(mapFn);
+    }
+    catch (error) {
+        logger.error('Failed to generate static params', error instanceof Error ? error : new Error(String(error)));
+        return [];
+    }
+}
+/**
+ * Revalidate tag
+ */
+export async function revalidateTag(tag, secret) {
+    try {
+        const url = new URL('/api/revalidate', process.env.NEXT_PUBLIC_URL || 'http://localhost:3000');
+        url.searchParams.set('tag', tag);
+        if (secret) {
+            url.searchParams.set('secret', secret);
+        }
+        const response = await fetch(url.toString(), {
+            method: 'POST',
+        });
+        const data = await response.json();
+        return {
+            revalidated: response.ok,
+            error: data.error,
+        };
+    }
+    catch (error) {
+        return {
+            revalidated: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Revalidate path
+ */
+export async function revalidatePath(path, secret) {
+    try {
+        const url = new URL('/api/revalidate', process.env.NEXT_PUBLIC_URL || 'http://localhost:3000');
+        url.searchParams.set('path', path);
+        if (secret) {
+            url.searchParams.set('secret', secret);
+        }
+        const response = await fetch(url.toString(), {
+            method: 'POST',
+        });
+        const data = await response.json();
+        return {
+            revalidated: response.ok,
+            error: data.error,
+        };
+    }
+    catch (error) {
+        return {
+            revalidated: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Revalidate multiple paths
+ */
+export async function revalidatePaths(paths, secret) {
+    const results = await Promise.allSettled(paths.map((path) => revalidatePath(path, secret)));
+    let revalidated = 0;
+    let failed = 0;
+    const errors = [];
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const path = paths[i];
+        if (!(result && path)) {
+            continue;
+        }
+        if (result.status === 'fulfilled' && result.value.revalidated) {
+            revalidated++;
+        }
+        else {
+            failed++;
+            const error = result.status === 'fulfilled'
+                ? result.value.error || 'Unknown error'
+                : String(result.reason) || 'Unknown error';
+            errors.push({ path, error });
+        }
+    }
+    return { revalidated, failed, errors };
+}
+/**
+ * Revalidate multiple tags
+ */
+export async function revalidateTags(tags, secret) {
+    const results = await Promise.allSettled(tags.map((tag) => revalidateTag(tag, secret)));
+    let revalidated = 0;
+    let failed = 0;
+    const errors = [];
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const tag = tags[i];
+        if (!(result && tag)) {
+            continue;
+        }
+        if (result.status === 'fulfilled' && result.value.revalidated) {
+            revalidated++;
+        }
+        else {
+            failed++;
+            const error = result.status === 'fulfilled'
+                ? result.value.error || 'Unknown error'
+                : String(result.reason) || 'Unknown error';
+            errors.push({ tag, error });
+        }
+    }
+    return { revalidated, failed, errors };
+}
+/**
+ * Create edge cached fetch
+ */
+export function createEdgeCachedFetch(config = {}) {
+    return async (url, options) => {
+        const fetchOptions = {
+            ...options,
+            ...config,
+            next: {
+                ...options?.next,
+                ...config.next,
+            },
+        };
+        const response = await fetch(url, fetchOptions);
+        if (!response.ok) {
+            throw new Error(`Fetch failed: ${response.statusText}`);
+        }
+        return response.json();
+    };
+}
+/**
+ * Unstable cache wrapper (Next.js 14+)
+ */
+export function createCachedFunction(fn, _options = {}) {
+    // In production, this would use Next.js unstable_cache
+    // For now, return the function as-is
+    return fn;
+}
+export class EdgeRateLimiter {
+    config;
+    cache = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Check rate limit
+     */
+    check(request) {
+        const key = this.config.key
+            ? this.config.key(request)
+            : request.headers.get('x-forwarded-for') || 'unknown';
+        const now = Date.now();
+        let entry = this.cache.get(key);
+        // Reset if window expired
+        if (!entry || now > entry.resetTime) {
+            entry = {
+                count: 0,
+                resetTime: now + this.config.window,
+            };
+            this.cache.set(key, entry);
+        }
+        // Increment count
+        entry.count++;
+        const allowed = entry.count <= this.config.limit;
+        const remaining = Math.max(0, this.config.limit - entry.count);
+        return {
+            allowed,
+            limit: this.config.limit,
+            remaining,
+            reset: entry.resetTime,
+        };
+    }
+    /**
+     * Clean up expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now > entry.resetTime) {
+                this.cache.delete(key);
+            }
+        }
+    }
+}
+export function getGeoLocation(request) {
+    // Vercel edge headers
+    const country = request.headers.get('x-vercel-ip-country');
+    const region = request.headers.get('x-vercel-ip-country-region');
+    const city = request.headers.get('x-vercel-ip-city');
+    const latitude = request.headers.get('x-vercel-ip-latitude');
+    const longitude = request.headers.get('x-vercel-ip-longitude');
+    if (!country) {
+        // Cloudflare headers
+        const cfCountry = request.headers.get('cf-ipcountry');
+        if (cfCountry) {
+            return {
+                country: cfCountry,
+            };
+        }
+        return null;
+    }
+    return {
+        country: country || undefined,
+        region: region || undefined,
+        city: city ? decodeURIComponent(city) : undefined,
+        latitude: latitude ? parseFloat(latitude) : undefined,
+        longitude: longitude ? parseFloat(longitude) : undefined,
+    };
+}
+/**
+ * Edge A/B testing with cache
+ */
+export function getABTestVariant(request, testName, variants) {
+    // Check cookie first
+    const cookieName = `ab-test-${testName}`;
+    const cookieVariant = request.cookies.get(cookieName)?.value;
+    if (cookieVariant && variants.includes(cookieVariant)) {
+        return cookieVariant;
+    }
+    // Assign variant based on IP hash
+    const ip = request.headers.get('x-forwarded-for') || 'unknown';
+    const hash = simpleHash(ip + testName);
+    const variantIndex = hash % variants.length;
+    const variant = variants[variantIndex];
+    if (!variant) {
+        throw new Error('No variant found for A/B test');
+    }
+    return variant;
+}
+/**
+ * Simple hash function
+ */
+function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+    }
+    return Math.abs(hash);
+}
+export function getPersonalizationConfig(request) {
+    const userAgent = request.headers.get('user-agent') || '';
+    const device = getDeviceType(userAgent);
+    const location = getGeoLocation(request);
+    return {
+        userId: request.cookies.get('user-id')?.value,
+        location: location || undefined,
+        device,
+    };
+}
+/**
+ * Detect device type
+ */
+function getDeviceType(userAgent) {
+    if (/mobile/i.test(userAgent) && !/tablet|ipad/i.test(userAgent)) {
+        return 'mobile';
+    }
+    if (/tablet|ipad/i.test(userAgent)) {
+        return 'tablet';
+    }
+    return 'desktop';
+}
+/**
+ * Edge cache headers helper
+ */
+export function setEdgeCacheHeaders(response, config) {
+    const cacheControl = [];
+    if (config.maxAge !== undefined) {
+        cacheControl.push(`max-age=${config.maxAge}`);
+    }
+    if (config.sMaxAge !== undefined) {
+        cacheControl.push(`s-maxage=${config.sMaxAge}`);
+    }
+    if (config.staleWhileRevalidate !== undefined) {
+        cacheControl.push(`stale-while-revalidate=${config.staleWhileRevalidate}`);
+    }
+    if (cacheControl.length > 0) {
+        response.headers.set('Cache-Control', cacheControl.join(', '));
+    }
+    if (config.tags && config.tags.length > 0) {
+        response.headers.set('Cache-Tag', config.tags.join(','));
+    }
+    return response;
+}
+/**
+ * Preload links for critical resources
+ */
+export function addPreloadLinks(response, resources) {
+    const links = resources.map((resource) => {
+        const attrs = [`<${resource.href}>`, `rel="preload"`, `as="${resource.as}"`];
+        if (resource.type) {
+            attrs.push(`type="${resource.type}"`);
+        }
+        if (resource.crossorigin) {
+            attrs.push('crossorigin');
+        }
+        return attrs.join('; ');
+    });
+    if (links.length > 0) {
+        response.headers.set('Link', links.join(', '));
+    }
+    return response;
+}
+/**
+ * Cache warming for ISR pages
+ */
+export async function warmISRCache(paths, baseURL = process.env.NEXT_PUBLIC_URL || 'http://localhost:3000') {
+    const results = await Promise.allSettled(paths.map(async (path) => {
+        const url = new URL(path, baseURL);
+        const response = await fetch(url.toString());
+        if (!response.ok) {
+            throw new Error(`${response.status} ${response.statusText}`);
+        }
+        return true;
+    }));
+    let warmed = 0;
+    let failed = 0;
+    const errors = [];
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const path = paths[i];
+        if (!(result && path)) {
+            continue;
+        }
+        if (result.status === 'fulfilled') {
+            warmed++;
+        }
+        else {
+            failed++;
+            errors.push({
+                path,
+                error: result.reason instanceof Error
+                    ? result.reason.message
+                    : String(result.reason) || 'Unknown error',
+            });
+        }
+    }
+    return { warmed, failed, errors };
+}

package/dist/caching/service-worker.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Service Worker Utilities
+ *
+ * Utilities for service worker registration, caching strategies, and offline support
+ */
+/**
+ * Service Worker Configuration
+ */
+export interface ServiceWorkerConfig {
+    scope?: string;
+    updateViaCache?: 'all' | 'imports' | 'none';
+    scriptURL?: string;
+}
+export declare const DEFAULT_SW_CONFIG: ServiceWorkerConfig;
+/**
+ * Register service worker
+ */
+export declare function registerServiceWorker(config?: ServiceWorkerConfig): Promise<ServiceWorkerRegistration | null>;
+/**
+ * Unregister service worker
+ */
+export declare function unregisterServiceWorker(): Promise<boolean>;
+/**
+ * Update service worker
+ */
+export declare function updateServiceWorker(): Promise<void>;
+/**
+ * Skip waiting and activate new service worker
+ */
+export declare function skipWaitingAndActivate(): Promise<void>;
+/**
+ * Cache Strategies
+ */
+export declare const CACHE_STRATEGIES: {
+    readonly networkFirst: "network-first";
+    readonly cacheFirst: "cache-first";
+    readonly networkOnly: "network-only";
+    readonly cacheOnly: "cache-only";
+    readonly staleWhileRevalidate: "stale-while-revalidate";
+};
+export type CacheStrategy = (typeof CACHE_STRATEGIES)[keyof typeof CACHE_STRATEGIES];
+/**
+ * Cache Configuration
+ */
+export interface CacheConfig {
+    name: string;
+    version: number;
+    maxAge?: number;
+    maxEntries?: number;
+    strategy?: CacheStrategy;
+}
+/**
+ * Default cache configurations
+ */
+export declare const DEFAULT_CACHES: Record<string, CacheConfig>;
+/**
+ * Generate cache name
+ */
+export declare function generateCacheName(config: CacheConfig): string;
+/**
+ * Service worker message types
+ */
+export declare const SW_MESSAGES: {
+    readonly SKIP_WAITING: "SKIP_WAITING";
+    readonly CLAIM_CLIENTS: "CLAIM_CLIENTS";
+    readonly CLEAR_CACHE: "CLEAR_CACHE";
+    readonly CACHE_URLS: "CACHE_URLS";
+    readonly DELETE_CACHE: "DELETE_CACHE";
+    readonly GET_CACHE_SIZE: "GET_CACHE_SIZE";
+};
+/**
+ * Post message to service worker
+ */
+export declare function postMessageToSW(type: string, payload?: unknown): Promise<unknown>;
+/**
+ * Clear all caches
+ */
+export declare function clearAllCaches(): Promise<void>;
+/**
+ * Clear specific cache
+ */
+export declare function clearCache(cacheName: string): Promise<void>;
+/**
+ * Precache URLs
+ */
+export declare function precacheURLs(urls: string[]): Promise<void>;
+/**
+ * Get cache size
+ */
+export declare function getCacheSize(): Promise<{
+    quota: number;
+    usage: number;
+    available: number;
+}>;
+/**
+ * Check if service worker is supported
+ */
+export declare function isServiceWorkerSupported(): boolean;
+/**
+ * Check if service worker is registered
+ */
+export declare function isServiceWorkerRegistered(): Promise<boolean>;
+/**
+ * Get service worker state
+ */
+export declare function getServiceWorkerState(): Promise<{
+    registered: boolean;
+    installing: boolean;
+    waiting: boolean;
+    active: boolean;
+    controller: boolean;
+}>;
+/**
+ * React hook for service worker
+ */
+export declare function useServiceWorker(config?: ServiceWorkerConfig): {
+    register: () => Promise<null>;
+    unregister: () => Promise<boolean>;
+    update: () => Promise<void>;
+    skipWaitingAndActivate: () => Promise<void>;
+    state: {
+        registered: boolean;
+        installing: boolean;
+        waiting: boolean;
+        active: boolean;
+        controller: boolean;
+    };
+} | {
+    register: () => Promise<ServiceWorkerRegistration | null>;
+    unregister: typeof unregisterServiceWorker;
+    update: typeof updateServiceWorker;
+    skipWaitingAndActivate: typeof skipWaitingAndActivate;
+    state: Promise<{
+        registered: boolean;
+        installing: boolean;
+        waiting: boolean;
+        active: boolean;
+        controller: boolean;
+    }>;
+};
+/**
+ * Offline detection
+ */
+export declare function isOffline(): boolean;
+/**
+ * Listen for online/offline events
+ */
+export declare function onNetworkChange(callback: (online: boolean) => void): () => void;
+/**
+ * Background sync registration
+ */
+export declare function registerBackgroundSync(tag: string): Promise<void>;
+/**
+ * Push notification permission
+ */
+export declare function requestNotificationPermission(): Promise<NotificationPermission>;
+/**
+ * Subscribe to push notifications
+ */
+export declare function subscribeToPush(vapidPublicKey: string): Promise<PushSubscription | null>;
+/**
+ * Unsubscribe from push notifications
+ */
+export declare function unsubscribeFromPush(): Promise<boolean>;
+//# sourceMappingURL=service-worker.d.ts.map

package/dist/caching/service-worker.d.ts.map

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