@revealui/core 0.0.1-pre.3 → 0.2.0

package/dist/caching/service-worker.js

@@ -0,0 +1,437 @@
+/**
+ * Service Worker Utilities
+ *
+ * Utilities for service worker registration, caching strategies, and offline support
+ */
+import { logger } from '../observability/logger.js';
+export const DEFAULT_SW_CONFIG = {
+    scope: '/',
+    updateViaCache: 'none',
+    scriptURL: '/sw.js',
+};
+/**
+ * Register service worker
+ */
+export async function registerServiceWorker(config = DEFAULT_SW_CONFIG) {
+    if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
+        logger.warn('Service workers are not supported');
+        return null;
+    }
+    try {
+        const { scriptURL = '/sw.js', scope, updateViaCache } = config;
+        const registration = await navigator.serviceWorker.register(scriptURL, {
+            scope,
+            updateViaCache,
+        });
+        logger.info('Service worker registered', { scope: registration.scope });
+        // Check for updates
+        registration.addEventListener('updatefound', () => {
+            const newWorker = registration.installing;
+            if (newWorker) {
+                newWorker.addEventListener('statechange', () => {
+                    if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
+                        // New service worker available
+                        logger.info('New service worker available');
+                        // Trigger update notification
+                        window.dispatchEvent(new CustomEvent('sw-update-available', {
+                            detail: { registration },
+                        }));
+                    }
+                });
+            }
+        });
+        return registration;
+    }
+    catch (error) {
+        logger.error('Service worker registration failed', error instanceof Error ? error : new Error(String(error)));
+        return null;
+    }
+}
+/**
+ * Unregister service worker
+ */
+export async function unregisterServiceWorker() {
+    if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
+        return false;
+    }
+    try {
+        const registration = await navigator.serviceWorker.ready;
+        return registration.unregister();
+    }
+    catch (error) {
+        logger.error('Service worker unregistration failed', error instanceof Error ? error : new Error(String(error)));
+        return false;
+    }
+}
+/**
+ * Update service worker
+ */
+export async function updateServiceWorker() {
+    if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
+        return;
+    }
+    try {
+        const registration = await navigator.serviceWorker.ready;
+        await registration.update();
+    }
+    catch (error) {
+        logger.error('Service worker update failed', error instanceof Error ? error : new Error(String(error)));
+    }
+}
+/**
+ * Skip waiting and activate new service worker
+ */
+export async function skipWaitingAndActivate() {
+    if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
+        return;
+    }
+    const registration = await navigator.serviceWorker.ready;
+    const waiting = registration.waiting;
+    if (waiting) {
+        // Tell service worker to skip waiting
+        waiting.postMessage({ type: 'SKIP_WAITING' });
+        // Reload when new service worker takes control
+        navigator.serviceWorker.addEventListener('controllerchange', () => {
+            window.location.reload();
+        });
+    }
+}
+/**
+ * Cache Strategies
+ */
+export const CACHE_STRATEGIES = {
+    // Network first, fallback to cache
+    networkFirst: 'network-first',
+    // Cache first, fallback to network
+    cacheFirst: 'cache-first',
+    // Network only
+    networkOnly: 'network-only',
+    // Cache only
+    cacheOnly: 'cache-only',
+    // Stale while revalidate
+    staleWhileRevalidate: 'stale-while-revalidate',
+};
+/**
+ * Default cache configurations
+ */
+export const DEFAULT_CACHES = {
+    static: {
+        name: 'static-assets',
+        version: 1,
+        maxAge: 31536000, // 1 year
+        maxEntries: 100,
+        strategy: CACHE_STRATEGIES.cacheFirst,
+    },
+    images: {
+        name: 'images',
+        version: 1,
+        maxAge: 2592000, // 30 days
+        maxEntries: 50,
+        strategy: CACHE_STRATEGIES.cacheFirst,
+    },
+    api: {
+        name: 'api',
+        version: 1,
+        maxAge: 300, // 5 minutes
+        maxEntries: 50,
+        strategy: CACHE_STRATEGIES.networkFirst,
+    },
+    pages: {
+        name: 'pages',
+        version: 1,
+        maxAge: 3600, // 1 hour
+        maxEntries: 20,
+        strategy: CACHE_STRATEGIES.staleWhileRevalidate,
+    },
+};
+/**
+ * Generate cache name
+ */
+export function generateCacheName(config) {
+    return `${config.name}-v${config.version}`;
+}
+/**
+ * Service worker message types
+ */
+export const SW_MESSAGES = {
+    SKIP_WAITING: 'SKIP_WAITING',
+    CLAIM_CLIENTS: 'CLAIM_CLIENTS',
+    CLEAR_CACHE: 'CLEAR_CACHE',
+    CACHE_URLS: 'CACHE_URLS',
+    DELETE_CACHE: 'DELETE_CACHE',
+    GET_CACHE_SIZE: 'GET_CACHE_SIZE',
+};
+/**
+ * Post message to service worker
+ */
+export async function postMessageToSW(type, payload) {
+    if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
+        throw new Error('Service workers not supported');
+    }
+    const registration = await navigator.serviceWorker.ready;
+    const sw = registration.active;
+    if (!sw) {
+        throw new Error('No active service worker');
+    }
+    return new Promise((resolve, reject) => {
+        const messageChannel = new MessageChannel();
+        messageChannel.port1.onmessage = (event) => {
+            if (event.data.error) {
+                reject(new Error(event.data.error));
+            }
+            else {
+                resolve(event.data);
+            }
+        };
+        sw.postMessage({ type, payload }, [messageChannel.port2]);
+    });
+}
+/**
+ * Clear all caches
+ */
+export async function clearAllCaches() {
+    try {
+        await postMessageToSW(SW_MESSAGES.CLEAR_CACHE);
+    }
+    catch (error) {
+        logger.error('Failed to clear caches', error instanceof Error ? error : new Error(String(error)));
+    }
+}
+/**
+ * Clear specific cache
+ */
+export async function clearCache(cacheName) {
+    try {
+        await postMessageToSW(SW_MESSAGES.DELETE_CACHE, { cacheName });
+    }
+    catch (error) {
+        logger.error('Failed to clear cache', error instanceof Error ? error : new Error(String(error)), { cacheName });
+    }
+}
+/**
+ * Precache URLs
+ */
+export async function precacheURLs(urls) {
+    try {
+        await postMessageToSW(SW_MESSAGES.CACHE_URLS, { urls });
+    }
+    catch (error) {
+        logger.error('Failed to precache URLs', error instanceof Error ? error : new Error(String(error)));
+    }
+}
+/**
+ * Get cache size
+ */
+export async function getCacheSize() {
+    if (typeof navigator === 'undefined' || !navigator.storage?.estimate) {
+        return { quota: 0, usage: 0, available: 0 };
+    }
+    try {
+        const estimate = await navigator.storage.estimate();
+        const quota = estimate.quota || 0;
+        const usage = estimate.usage || 0;
+        const available = quota - usage;
+        return { quota, usage, available };
+    }
+    catch (error) {
+        logger.error('Failed to get cache size', error instanceof Error ? error : new Error(String(error)));
+        return { quota: 0, usage: 0, available: 0 };
+    }
+}
+/**
+ * Check if service worker is supported
+ */
+export function isServiceWorkerSupported() {
+    return typeof window !== 'undefined' && 'serviceWorker' in navigator;
+}
+/**
+ * Check if service worker is registered
+ */
+export async function isServiceWorkerRegistered() {
+    if (!isServiceWorkerSupported()) {
+        return false;
+    }
+    try {
+        const registration = await navigator.serviceWorker.getRegistration();
+        return registration !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get service worker state
+ */
+export async function getServiceWorkerState() {
+    if (!isServiceWorkerSupported()) {
+        return {
+            registered: false,
+            installing: false,
+            waiting: false,
+            active: false,
+            controller: false,
+        };
+    }
+    try {
+        const registration = await navigator.serviceWorker.getRegistration();
+        if (!registration) {
+            return {
+                registered: false,
+                installing: false,
+                waiting: false,
+                active: false,
+                controller: false,
+            };
+        }
+        return {
+            registered: true,
+            installing: registration.installing !== null,
+            waiting: registration.waiting !== null,
+            active: registration.active !== null,
+            controller: navigator.serviceWorker.controller !== null,
+        };
+    }
+    catch {
+        return {
+            registered: false,
+            installing: false,
+            waiting: false,
+            active: false,
+            controller: false,
+        };
+    }
+}
+/**
+ * React hook for service worker
+ */
+export function useServiceWorker(config) {
+    if (typeof window === 'undefined') {
+        return {
+            register: async () => null,
+            unregister: async () => false,
+            update: async () => { },
+            skipWaitingAndActivate: async () => { },
+            state: {
+                registered: false,
+                installing: false,
+                waiting: false,
+                active: false,
+                controller: false,
+            },
+        };
+    }
+    return {
+        register: () => registerServiceWorker(config),
+        unregister: unregisterServiceWorker,
+        update: updateServiceWorker,
+        skipWaitingAndActivate,
+        state: getServiceWorkerState(),
+    };
+}
+/**
+ * Offline detection
+ */
+export function isOffline() {
+    return typeof navigator !== 'undefined' && !navigator.onLine;
+}
+/**
+ * Listen for online/offline events
+ */
+export function onNetworkChange(callback) {
+    if (typeof window === 'undefined') {
+        return () => { };
+    }
+    const handleOnline = () => callback(true);
+    const handleOffline = () => callback(false);
+    window.addEventListener('online', handleOnline);
+    window.addEventListener('offline', handleOffline);
+    return () => {
+        window.removeEventListener('online', handleOnline);
+        window.removeEventListener('offline', handleOffline);
+    };
+}
+/**
+ * Background sync registration
+ */
+export async function registerBackgroundSync(tag) {
+    if (!isServiceWorkerSupported()) {
+        throw new Error('Service workers not supported');
+    }
+    const registration = await navigator.serviceWorker.ready;
+    if (!('sync' in registration)) {
+        throw new Error('Background sync not supported');
+    }
+    try {
+        // @ts-expect-error - sync API not in types yet
+        await registration.sync.register(tag);
+    }
+    catch (error) {
+        logger.error('Background sync registration failed', error instanceof Error ? error : new Error(String(error)));
+        throw error;
+    }
+}
+/**
+ * Push notification permission
+ */
+export async function requestNotificationPermission() {
+    if (typeof window === 'undefined' || !('Notification' in window)) {
+        throw new Error('Notifications not supported');
+    }
+    return Notification.requestPermission();
+}
+/**
+ * Subscribe to push notifications
+ */
+export async function subscribeToPush(vapidPublicKey) {
+    if (!isServiceWorkerSupported()) {
+        throw new Error('Service workers not supported');
+    }
+    const registration = await navigator.serviceWorker.ready;
+    if (!('pushManager' in registration)) {
+        throw new Error('Push notifications not supported');
+    }
+    try {
+        const subscription = await registration.pushManager.subscribe({
+            userVisibleOnly: true,
+            applicationServerKey: urlBase64ToUint8Array(vapidPublicKey),
+        });
+        return subscription;
+    }
+    catch (error) {
+        logger.error('Push subscription failed', error instanceof Error ? error : new Error(String(error)));
+        return null;
+    }
+}
+/**
+ * Unsubscribe from push notifications
+ */
+export async function unsubscribeFromPush() {
+    if (!isServiceWorkerSupported()) {
+        return false;
+    }
+    try {
+        const registration = await navigator.serviceWorker.ready;
+        const subscription = await registration.pushManager.getSubscription();
+        if (subscription) {
+            return subscription.unsubscribe();
+        }
+        return false;
+    }
+    catch (error) {
+        logger.error('Push unsubscription failed', error instanceof Error ? error : new Error(String(error)));
+        return false;
+    }
+}
+/**
+ * Convert VAPID key
+ */
+function urlBase64ToUint8Array(base64String) {
+    const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
+    const base64 = (base64String + padding).replace(/-/g, '+').replace(/_/g, '/');
+    const rawData = window.atob(base64);
+    const outputArray = new Uint8Array(rawData.length);
+    for (let i = 0; i < rawData.length; ++i) {
+        outputArray[i] = rawData.charCodeAt(i);
+    }
+    return outputArray;
+}

package/dist/client/admin/RichText.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Rich Text Editor Adapter
+ * @module @revealui/core/admin/RichText
+ */
+export interface RichTextAdapter {
+    name: string;
+    features?: unknown[];
+    serialize?: (content: unknown) => string;
+    deserialize?: (content: string) => unknown;
+}
+export default RichTextAdapter;
+//# sourceMappingURL=RichText.d.ts.map

package/dist/client/admin/RichText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RichText.d.ts","sourceRoot":"","sources":["../../../src/client/admin/RichText.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAA;IACpB,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAA;IACxC,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAA;CAC3C;AAED,eAAe,eAAe,CAAA"}

package/dist/client/admin/RichText.js

@@ -0,0 +1,5 @@
+/**
+ * Rich Text Editor Adapter
+ * @module @revealui/core/admin/RichText
+ */
+export {};

package/dist/client/admin/components/AdminDashboard.d.ts

@@ -0,0 +1,7 @@
+import type { RevealConfig } from '../../../types/index.js';
+interface AdminDashboardProps {
+    config: RevealConfig;
+}
+export declare function AdminDashboard({ config }: AdminDashboardProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=AdminDashboard.d.ts.map

package/dist/client/admin/components/AdminDashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdminDashboard.d.ts","sourceRoot":"","sources":["../../../../src/client/admin/components/AdminDashboard.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,YAAY,EAGb,MAAM,yBAAyB,CAAA;AAMhC,UAAU,mBAAmB;IAC3B,MAAM,EAAE,YAAY,CAAA;CACrB;AAWD,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,EAAE,mBAAmB,2CA0rB7D"}