@dbs-portal/tool-mock/dist/build/service-worker.js

API mocking toolkit using MSW for DBS Portal development workflows

/**
 * Service worker utilities for MSW
 */
/**
 * Initialize MSW service worker
 */
export async function initializeServiceWorker(config = {}) {
    if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
        console.warn('Service Worker not supported in this environment');
        return null;
    }
    const { url = '/mockServiceWorker.js', scope = '/', updateViaCache = 'none', registrationOptions = {}, } = config;
    try {
        const registration = await navigator.serviceWorker.register(url, {
            scope,
            updateViaCache,
            ...registrationOptions,
        });
        console.log('MSW Service Worker registered:', registration);
        return registration;
    }
    catch (error) {
        console.error('Failed to register MSW Service Worker:', error);
        return null;
    }
}
/**
 * Check if service worker is ready
 */
export async function isServiceWorkerReady() {
    if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
        return false;
    }
    try {
        const registration = await navigator.serviceWorker.ready;
        return registration.active !== null;
    }
    catch {
        return false;
    }
}
/**
 * Update service worker
 */
export async function updateServiceWorker() {
    if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
        return null;
    }
    try {
        const registration = await navigator.serviceWorker.getRegistration();
        if (registration) {
            await registration.update();
            return registration;
        }
        return null;
    }
    catch (error) {
        console.error('Failed to update service worker:', 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.getRegistration();
        if (registration) {
            const result = await registration.unregister();
            console.log('MSW Service Worker unregistered:', result);
            return result;
        }
        return true;
    }
    catch (error) {
        console.error('Failed to unregister service worker:', error);
        return false;
    }
}
/**
 * Get service worker status
 */
export async function getServiceWorkerStatus() {
    const status = {
        supported: typeof window !== 'undefined' && 'serviceWorker' in navigator,
        registered: false,
        active: false,
        installing: false,
        waiting: false,
    };
    if (!status.supported) {
        return status;
    }
    try {
        const registration = await navigator.serviceWorker.getRegistration();
        if (registration) {
            status.registered = true;
            status.active = registration.active !== null;
            status.installing = registration.installing !== null;
            status.waiting = registration.waiting !== null;
        }
    }
    catch {
        // Registration check failed
    }
    return status;
}
/**
 * Listen for service worker updates
 */
export function onServiceWorkerUpdate(callback) {
    if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
        return () => { };
    }
    const handleUpdate = (event) => {
        const registration = event.target?.registration;
        if (registration) {
            callback(registration);
        }
    };
    navigator.serviceWorker.addEventListener('controllerchange', handleUpdate);
    return () => {
        navigator.serviceWorker.removeEventListener('controllerchange', handleUpdate);
    };
}
/**
 * Wait for service worker to be ready
 */
export async function waitForServiceWorker(timeout = 10000) {
    if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
        throw new Error('Service Worker not supported');
    }
    return new Promise((resolve, reject) => {
        const timeoutId = setTimeout(() => {
            reject(new Error('Service Worker ready timeout'));
        }, timeout);
        navigator.serviceWorker.ready
            .then(registration => {
            clearTimeout(timeoutId);
            resolve(registration);
        })
            .catch(error => {
            clearTimeout(timeoutId);
            reject(error);
        });
    });
}
/**
 * Generate service worker content
 */
export function generateServiceWorkerContent(options = {}) {
    const { mswVersion = '2.6.4', customCode = '', enableLogging = false, } = options;
    return `
/**
 * Mock Service Worker
 * Generated by @dbs-portal/tool-mock
 */

// Import MSW
importScripts('https://unpkg.com/msw@${mswVersion}/lib/mockServiceWorker.js');

${enableLogging ? `
// Enable logging
self.addEventListener('message', (event) => {
  console.log('MSW Service Worker message:', event.data);
});
` : ''}

// Handle MSW lifecycle events
self.addEventListener('message', async function (event) {
  const { type, payload } = event.data;

  switch (type) {
    case 'MOCK_ACTIVATE': {
      self.registration.addEventListener('activate', () => {
        event.ports[0].postMessage({ type: 'MOCK_ACTIVATED' });
      });
      break;
    }
    
    case 'MOCK_DEACTIVATE': {
      await self.registration.unregister();
      event.ports[0].postMessage({ type: 'MOCK_DEACTIVATED' });
      break;
    }
    
    case 'CLIENT_CLOSED': {
      // Handle client closed
      break;
    }
    
    default: {
      // Forward other messages to MSW
      break;
    }
  }
});

// Handle fetch events
self.addEventListener('fetch', (event) => {
  // MSW will handle this
});

// Handle install event
self.addEventListener('install', (event) => {
  ${enableLogging ? `console.log('MSW Service Worker installed');` : ''}
  self.skipWaiting();
});

// Handle activate event
self.addEventListener('activate', (event) => {
  ${enableLogging ? `console.log('MSW Service Worker activated');` : ''}
  event.waitUntil(self.clients.claim());
});

${customCode}
`;
}
/**
 * Create service worker file
 */
export async function createServiceWorkerFile(outputPath, options = {}) {
    const content = generateServiceWorkerContent(options);
    // In a real implementation, you'd write to the file system
    // For now, we'll just log the content
    console.log(`Service worker content generated for: ${outputPath}`);
    console.log(content);
}
/**
 * Service worker development utilities
 */
export const serviceWorkerDevUtils = {
    /**
     * Clear service worker cache
     */
    async clearCache() {
        if (typeof window === 'undefined' || !('caches' in window)) {
            return;
        }
        try {
            const cacheNames = await caches.keys();
            await Promise.all(cacheNames.map(cacheName => caches.delete(cacheName)));
            console.log('Service worker cache cleared');
        }
        catch (error) {
            console.error('Failed to clear service worker cache:', error);
        }
    },
    /**
     * Force service worker update
     */
    async forceUpdate() {
        if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
            return;
        }
        try {
            const registration = await navigator.serviceWorker.getRegistration();
            if (registration) {
                await registration.update();
                console.log('Service worker update forced');
            }
        }
        catch (error) {
            console.error('Failed to force service worker update:', error);
        }
    },
    /**
     * Get service worker info
     */
    async getInfo() {
        const status = await getServiceWorkerStatus();
        let registration = null;
        if (status.supported) {
            try {
                registration = await navigator.serviceWorker.getRegistration();
            }
            catch {
                // Ignore error
            }
        }
        return {
            status,
            registration: registration ? {
                scope: registration.scope,
                updateViaCache: registration.updateViaCache,
                active: registration.active?.state,
                installing: registration.installing?.state,
                waiting: registration.waiting?.state,
            } : null,
        };
    },
};
//# sourceMappingURL=service-worker.js.map