@ethora/chat-component 26.2.20 → 26.2.22

package/dist/firebase-messaging-sw.js

@@ -1,8 +1,7 @@
-/* eslint-disable no-empty, no-restricted-globals */
+/* eslint-disable no-empty */
 /* eslint-env worker */
-/* global firebase, clients */
+/* global firebase, clients, importScripts */
 
-// ── Firebase SDK ──────────────────────────────────────────────
 importScripts(
   'https://www.gstatic.com/firebasejs/10.12.0/firebase-app-compat.js'
 );
@@ -10,9 +9,30 @@ importScripts(
   'https://www.gstatic.com/firebasejs/10.12.0/firebase-messaging-compat.js'
 );
 
-// ── Dynamic Configuration ─────────────────────────────────────
+// ── DEBUG ─────────────────────────────────────────────────────
+const DEBUG = false;
+const DEDUP_TTL = 60 * 1000;
+
 const params = new URL(self.location.href).searchParams;
+const CUSTOM_ICON = (params.get('iconPath') || '').trim();
+const CUSTOM_BADGE = (params.get('badgePath') || '').trim();
+const DEFAULT_ICON = CUSTOM_ICON || '/favicon.ico';
+const DEFAULT_BADGE = CUSTOM_BADGE || CUSTOM_ICON || '/favicon.ico';
+
+// ── LOGGING ───────────────────────────────────────────────────
+function log(...args) {
+  if (DEBUG) console.log('[SW]', ...args);
+}
 
+function warn(...args) {
+  if (DEBUG) console.warn('[SW]', ...args);
+}
+
+function error(...args) {
+  console.error('[SW]', ...args);
+}
+
+// ── CONFIG ────────────────────────────────────────────────────
 const firebaseConfig = {
   apiKey: params.get('apiKey'),
   authDomain: params.get('authDomain'),
@@ -22,477 +42,422 @@ const firebaseConfig = {
   appId: params.get('appId'),
 };
 
-let messaging = null;
+const APP_URL = self.location.origin;
+
+// ── INIT FIREBASE ─────────────────────────────────────────────
+try {
+  if (
+    firebaseConfig.apiKey &&
+    firebaseConfig.appId &&
+    firebaseConfig.messagingSenderId &&
+    firebaseConfig.projectId
+  ) {
+    if (!firebase.apps.length) {
+      firebase.initializeApp(firebaseConfig);
+      log('Firebase initialized');
+    } else {
+      log('Firebase already initialized');
+    }
 
-if (
-  firebaseConfig.apiKey &&
-  firebaseConfig.appId &&
-  firebaseConfig.messagingSenderId &&
-  firebaseConfig.projectId
-) {
-  if (!firebase.apps.length) {
-    firebase.initializeApp(firebaseConfig);
+    firebase.messaging();
+    log('Firebase messaging ready (without onBackgroundMessage)');
+  } else {
+    warn('Firebase config missing', firebaseConfig);
   }
-  messaging = firebase.messaging();
-} else {
-  //   console.warn('[SW] Firebase config missing → FCM disabled');
+} catch (e) {
+  error('Firebase init error', e);
 }
 
-const APP_URL = self.location.origin;
+// ── DEDUP ─────────────────────────────────────────────────────
+const handledPushes = new Map();
 
-// ── Deduplication ─────────────────────────────────────────────
-const _handledByFcm = new Set();
-const DEDUP_TTL_MS = 60_000;
+function cleanupHandledPushes() {
+  const now = Date.now();
 
-function markHandledByFcm(id) {
-  if (!id) return;
-  _handledByFcm.add(id);
-  //   console.log('[SW] FCM handled:', id);
-  setTimeout(() => _handledByFcm.delete(id), DEDUP_TTL_MS);
+  for (const [key, ts] of handledPushes.entries()) {
+    if (now - ts > DEDUP_TTL) {
+      handledPushes.delete(key);
+    }
+  }
 }
 
-function wasHandledByFcm(id) {
-  return id ? _handledByFcm.has(id) : false;
+function rememberPush(key) {
+  if (!key) return;
+  cleanupHandledPushes();
+  handledPushes.set(key, Date.now());
+  log('DEDUP remember:', key);
 }
 
-function buildDedupeKey(payload = {}) {
-  const data = payload.data || {};
-  const notification = payload.notification || {};
-  const explicitMessageId =
-    payload.messageId ||
-    data.msgID ||
-    data.messageId ||
-    data.message_id ||
-    '';
+function wasHandled(key) {
+  if (!key) return false;
+  cleanupHandledPushes();
 
-  const roomJid = data.jid || payload.roomJid || '';
-  const senderId = data.userJid || payload.senderId || '';
-  const title = notification.title || payload.title || '';
-  const body = notification.body || payload.body || payload.message || '';
+  const hit = handledPushes.has(key);
+  if (hit) log('DEDUP hit:', key);
 
-  return explicitMessageId || `${roomJid}|${senderId}|${title}|${body}`;
+  return hit;
 }
 
-// ── Helpers ───────────────────────────────────────────────────
-function isSystemPayload(data) {
-  return !data?.msgID && !data?.jid && !!data?.userJid;
+// ── HELPERS ───────────────────────────────────────────────────
+function isVisibleClients(clientsList) {
+  return clientsList.some((c) => {
+    try {
+      return c.visibilityState === 'visible';
+    } catch {
+      return false;
+    }
+  });
 }
 
-function buildTargetUrl(data, notification, fallbackUrl) {
-  if (fallbackUrl && String(fallbackUrl).startsWith('http')) return fallbackUrl;
-
-  const title = notification?.title || data?.title || '';
-  if (title.startsWith('http')) return title;
-
-  if (isSystemPayload(data)) return `${APP_URL}/?fromPush=1`;
-  if (!data?.jid) return `${APP_URL}/?fromPush=1`;
+function dumpClients(clientsList) {
+  return clientsList.map((c) => ({
+    url: c.url,
+    visibility: c.visibilityState,
+  }));
+}
 
-  const chatId = String(data.jid).split('@')[0];
-  const messageId = data.msgID || data.messageId || data.message_id || '';
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
 
-  const params = new URLSearchParams({ chatId });
-  if (messageId) params.set('messageId', messageId);
-  params.set('fromPush', '1');
+function stableStringify(value) {
+  try {
+    if (value === null || value === undefined) return '';
+    if (typeof value !== 'object') return String(value);
 
-  return `${APP_URL}/chat?${params.toString()}`;
-}
+    if (Array.isArray(value)) {
+      return `[${value.map((v) => stableStringify(v)).join(',')}]`;
+    }
 
-function isAnyClientVisible(windowClients) {
-  return windowClients.some((c) => c.visibilityState === 'visible');
+    const keys = Object.keys(value).sort();
+    return `{${keys
+      .map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`)
+      .join(',')}}`;
+  } catch {
+    return '';
+  }
 }
 
-function postBridgeToClients(windowClients, payload) {
-  windowClients.forEach((client) => {
-    client.postMessage({
-      type: 'PUSH_FOREGROUND_BRIDGE',
-      payload,
-    });
-  });
-}
+function simpleHash(input) {
+  const str = String(input || '');
+  let hash = 0;
 
-function normalizeRawPushPayload(event) {
-  if (!event.data) {
-    //     console.warn('[SW][EMPTY_PUSH] Push without payload');
-    return {
-      sourceType: 'empty',
-      raw: {
-        title: 'New message',
-        body: '',
-        data: {},
-      },
-    };
+  for (let i = 0; i < str.length; i += 1) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash |= 0;
   }
 
-  let textPayload = '';
+  return String(hash);
+}
+
+function normalizeUrl(url) {
+  if (!url) return APP_URL;
 
   try {
-    textPayload = event.data.text();
-  } catch (err) {
-    //     console.warn('[SW][PUSH_TEXT_READ_FAILED]', err);
+    return new URL(url, self.location.origin).toString();
+  } catch {
+    return APP_URL;
   }
+}
 
-  if (!textPayload) {
-    //     console.warn('[SW][EMPTY_PUSH_TEXT] Push payload text is empty');
-    return {
-      sourceType: 'empty',
-      raw: {
-        title: 'New message',
-        body: '',
-        data: {},
-      },
-    };
-  }
+function pickTitle(raw = {}, data = {}, notification = {}) {
+  return notification.title || raw.title || data.title || 'New Message';
+}
 
-  try {
-    const parsed = JSON.parse(textPayload);
-    //     console.log('[SW][JSON_PUSH]', parsed);
-    return {
-      sourceType: 'json',
-      raw: parsed,
-    };
-  } catch (err) {
-    /*    console.warn('[SW][TEXT_PUSH] Non-JSON push received, processing as plain text', {
-      error: err,
-      rawText: textPayload,
-    });*/
-
-    return {
-      sourceType: 'text',
-      raw: {
-        title: 'New message',
-        body: textPayload,
-        data: {},
-      },
-    };
-  }
+function pickBody(raw = {}, data = {}, notification = {}) {
+  return notification.body || raw.body || data.body || 'You have a new message';
 }
 
-// ── FCM ───────────────────────────────────────────────────────
-if (messaging) {
-  messaging.onBackgroundMessage((payload) => {
-    //     console.log('[SW][FCM_PUSH]', payload);
+function pickUrl(raw = {}, data = {}, notification = {}) {
+  return normalizeUrl(
+    data.url ||
+      data.link ||
+      data.click_action ||
+      notification.click_action ||
+      raw.url ||
+      raw.link ||
+      raw.click_action ||
+      APP_URL
+  );
+}
 
-    const data = payload.data || {};
-    const notification = payload.notification || {};
-    const messageId = payload.messageId || data.msgID || null;
-    const dedupeKey = buildDedupeKey({
-      messageId,
-      data,
-      notification,
-    });
+function pickIcon(raw = {}, data = {}, notification = {}) {
+  return data.icon || notification.icon || raw.icon || DEFAULT_ICON;
+}
 
-    markHandledByFcm(messageId);
-    markHandledByFcm(dedupeKey);
+function pickBadge(raw = {}, data = {}, notification = {}) {
+  return data.badge || notification.badge || raw.badge || DEFAULT_BADGE;
+}
 
-    const isSystem = isSystemPayload(data);
-    const title =
-      (isSystem ? 'System' : undefined) ||
-      notification.title ||
-      data.title ||
-      'New Message';
+function pickImage(raw = {}, data = {}, notification = {}) {
+  return data.image || notification.image || raw.image || undefined;
+}
 
-    const body = notification.body || data.body || 'You have a new message.';
+function extractMessageId(raw = {}, data = {}) {
+  return (
+    raw.messageId ||
+    raw.fcmMessageId ||
+    raw.fcmMessageId ||
+    raw.message_id ||
+    data.messageId ||
+    data.fcmMessageId ||
+    data.message_id ||
+    data.msgID ||
+    data['gcm.message_id'] ||
+    data['google.message_id'] ||
+    data['google.c.a.c_id'] ||
+    null
+  );
+}
 
-    const url = buildTargetUrl(data, notification, data.url);
+function hasNotificationPayload(raw = {}, notification = {}) {
+  return Boolean(
+    (notification && (notification.title || notification.body)) ||
+      (raw.notification && (raw.notification.title || raw.notification.body))
+  );
+}
 
-    const bridgePayload = {
-      messageId,
-      notification: {
-        title,
-        body,
-        image: notification.image || notification.icon || '/favicon.ico',
-      },
-      data: {
-        ...data,
-        jid: data.jid || '',
-        userJid: data.userJid || '',
-        msgID: data.msgID || '',
-        workspaceId: data.workspaceId || data.workspace_id || '',
-      },
-      meta: {
-        source: 'fcm',
-      },
-    };
-
-    const options = {
-      body,
-      icon: notification.icon || notification.image || '/favicon.ico',
-      badge: '/favicon.ico',
-      tag: data.tag || 'ethora-notification',
-      data: {
-        url,
-        roomJid: data.jid || null,
-        senderId: data.userJid || null,
-        messageId,
-        workspaceId: data.workspaceId || data.workspace_id || null,
-      },
-      requireInteraction: false,
-      silent: false,
-    };
-
-    return clients
-      .matchAll({ type: 'window', includeUncontrolled: true })
-      .then((windowClients) => {
-        postBridgeToClients(windowClients, bridgePayload);
-
-        if (!isAnyClientVisible(windowClients)) {
-          /*          console.log(
-            `[NotifyPolicy] source=fcm_bg action=show reason=${isSystem ? 'system' : 'background'} msgId=${messageId || ''}`
-          );*/
-          return self.registration.showNotification(title, options);
-        }
-
-        /*        console.log(
-          `[NotifyPolicy] source=fcm_bg action=skip reason=tab_visible msgId=${messageId || ''}`
-        );*/
-      });
+function makeDedupKey(raw = {}, data = {}, notification = {}) {
+  const messageId = extractMessageId(raw, data);
+  if (messageId) return `id:${messageId}`;
+
+  const title = pickTitle(raw, data, notification);
+  const body = pickBody(raw, data, notification);
+  const url = pickUrl(raw, data, notification);
+
+  const canonical = stableStringify({
+    title,
+    body,
+    url,
+    data,
+    notification,
   });
+
+  return `fp:${simpleHash(canonical)}`;
 }
 
-// ── PUSH (WebPush / text / fallback) ──────────────────────────
-self.addEventListener('push', (event) => {
-  //   console.log('[SW] push event');
+function normalizePush(event) {
+  if (!event.data) {
+    warn('EMPTY PUSH');
+    return { type: 'empty', raw: {}, text: '' };
+  }
 
-  const { sourceType, raw } = normalizeRawPushPayload(event);
+  let text = '';
 
-  if (!raw || typeof raw !== 'object') {
-    console.error('[SW][BROKEN_PUSH]', raw);
-    return;
+  try {
+    text = event.data.text();
+    log('PUSH TEXT', text);
+  } catch (e) {
+    warn('TEXT READ FAIL', e);
   }
 
-  const notification = raw.notification || {};
-  const payloadData = raw.data || {};
-  const messageId =
-    raw.messageId ||
-    payloadData.msgID ||
-    payloadData.messageId ||
-    payloadData.message_id ||
-    null;
-  const dedupeKey = buildDedupeKey({
-    messageId,
-    data: payloadData,
-    notification,
-    title: raw.title,
-    body: raw.body || raw.message,
-    roomJid: raw.roomJid,
-    senderId: raw.senderId,
-  });
+  const json = safeJsonParse(text);
 
-  if (wasHandledByFcm(messageId) || wasHandledByFcm(dedupeKey)) {
-    //     console.log(`[SW] push skipped – already handled by FCM (msgId=${messageId})`);
-    return;
+  if (json) {
+    log('PUSH JSON', json);
+    return { type: 'json', raw: json, text };
   }
 
-  markHandledByFcm(messageId);
-  markHandledByFcm(dedupeKey);
+  warn('NOT JSON PUSH', text);
+
+  return {
+    type: 'text',
+    raw: {
+      title: 'New Message',
+      body: text,
+      data: {},
+    },
+    text,
+  };
+}
+
+async function broadcastDebugMessage(payload) {
+  try {
+    const windowClients = await clients.matchAll({
+      type: 'window',
+      includeUncontrolled: true,
+    });
 
-  if (sourceType !== 'json') {
-    /*    console.log('[SW][NON_JSON_PUSH_PROCESSED]', {
-      sourceType,
-      raw,
-    });*/
+    for (const c of windowClients) {
+      try {
+        c.postMessage({
+          type: 'PUSH_DEBUG',
+          payload,
+        });
+      } catch {}
+    }
+  } catch (e) {
+    warn('broadcastDebugMessage failed', e);
   }
+}
+
+// ── MAIN HANDLER ──────────────────────────────────────────────
+async function handlePush(raw = {}, source = 'push') {
+  const data = raw.data || {};
+  const notification = raw.notification || {};
 
-  if (!raw.from && !raw.fcmOptions) {
-    //     console.log('[SW][NON_FCM_PUSH]', raw);
+  const title = pickTitle(raw, data, notification);
+  const body = pickBody(raw, data, notification);
+  const url = pickUrl(raw, data, notification);
+  const icon = pickIcon(raw, data, notification);
+  const badge = pickBadge(raw, data, notification);
+  const image = pickImage(raw, data, notification);
+
+  const messageId = extractMessageId(raw, data);
+  const dedupKey = makeDedupKey(raw, data, notification);
+  const browserWillAutoShow = hasNotificationPayload(raw, notification);
+
+  log('--- PUSH DECISION ---');
+  log('source:', source);
+  log('messageId:', messageId);
+  log('dedupKey:', dedupKey);
+  log('title:', title);
+  log('body:', body);
+  log('url:', url);
+  log('icon:', icon);
+  log('badge:', badge);
+  log('browserWillAutoShow:', browserWillAutoShow);
+
+  if (wasHandled(dedupKey)) {
+    log('SKIP DEDUP');
+    return;
   }
 
-  const isSystem = isSystemPayload(payloadData);
+  rememberPush(dedupKey);
 
-  const title =
-    (isSystem ? 'System' : undefined) ||
-    notification.title ||
-    raw.title ||
-    'Ethora Chat';
+  const windowClients = await clients.matchAll({
+    type: 'window',
+    includeUncontrolled: true,
+  });
 
-  const body =
-    notification.body ||
-    raw.body ||
-    raw.message ||
-    payloadData.body ||
-    'You have a new message.';
+  const visible = isVisibleClients(windowClients);
 
-  const icon =
-    raw.icon || notification.icon || notification.image || '/favicon.ico';
+  log('clients:', dumpClients(windowClients));
+  log('visibleClientExists:', visible);
 
-  const url = buildTargetUrl(
-    payloadData,
+  await broadcastDebugMessage({
+    source,
+    raw,
+    data,
     notification,
-    raw.url || raw.clickAction
-  );
-
-  const bridgePayload = {
+    title,
+    body,
+    url,
+    icon,
+    badge,
+    image,
     messageId,
-    notification: {
-      title,
-      body,
-      image: icon,
-    },
-    data: {
-      ...payloadData,
-      jid: raw.roomJid || payloadData.jid || '',
-      userJid: raw.senderId || payloadData.userJid || '',
-      msgID: messageId || '',
-      workspaceId:
-        raw.workspaceId ||
-        payloadData.workspaceId ||
-        payloadData.workspace_id ||
-        '',
-    },
-    meta: {
-      source: sourceType === 'json' ? 'webpush' : 'text_push',
-    },
-  };
+    dedupKey,
+    browserWillAutoShow,
+  });
 
+  if (browserWillAutoShow) {
+    log('SKIP MANUAL SHOW: browser/FCM should auto-display notification');
+    return;
+  }
+
+  // Data-only push: показуємо вручну
   const options = {
     body,
     icon,
-    badge: raw.badge || '/favicon.ico',
-    tag: raw.tag || 'ethora-notification',
+    badge,
+    image,
+    tag: dedupKey,
+    renotify: false,
     data: {
       url,
-      roomJid: raw.roomJid || payloadData.jid || null,
-      senderId: raw.senderId || payloadData.userJid || null,
       messageId,
-      workspaceId:
-        raw.workspaceId ||
-        payloadData.workspaceId ||
-        payloadData.workspace_id ||
-        null,
-      sourceType,
+      dedupKey,
+      source,
     },
-    requireInteraction: false,
-    silent: false,
   };
 
+  if (!visible) {
+    log('SHOW NOTIFICATION', {
+      reason: 'NO_VISIBLE_CLIENT',
+      tag: options.tag,
+    });
+
+    return self.registration.showNotification(title, options);
+  }
+
+  log('SKIP NOTIFICATION', {
+    reason: 'VISIBLE_CLIENT',
+  });
+}
+
+// ── RAW PUSH ONLY ─────────────────────────────────────────────
+self.addEventListener('push', (event) => {
+  log('RAW PUSH EVENT');
+
   event.waitUntil(
-    clients
-      .matchAll({ type: 'window', includeUncontrolled: true })
-      .then((windowClients) => {
-        postBridgeToClients(windowClients, bridgePayload);
-
-        if (!isAnyClientVisible(windowClients)) {
-          /*          console.log(
-            `[NotifyPolicy] source=push_bg action=show type=${sourceType} msgId=${messageId || ''}`
-          );*/
-          return self.registration.showNotification(title, options);
-        }
-
-        /*        console.log(
-          `[NotifyPolicy] source=push_bg action=skip reason=tab_visible type=${sourceType} msgId=${messageId || ''}`
-        );*/
-      })
+    (async () => {
+      try {
+        const { type, raw } = normalizePush(event);
+
+        log('PARSED PUSH', {
+          type,
+          raw,
+          messageId: extractMessageId(raw, raw.data || {}),
+        });
+
+        return handlePush(raw, `raw_push_${type}`);
+      } catch (e) {
+        error('PUSH HANDLER ERROR', e);
+      }
+    })()
   );
 });
 
-// ── Notification Click ────────────────────────────────────────
+// ── CLICK ─────────────────────────────────────────────────────
 self.addEventListener('notificationclick', (event) => {
-  //   console.log('[NotifyPolicy] source=push_bg action=click_start');
-  event.notification.close();
+  log('NOTIFICATION CLICK', event.notification);
 
-  const targetUrl =
-    (event.notification.data && event.notification.data.url) || APP_URL;
+  event.notification.close();
 
-  /*  console.log('[NotifyPolicy] source=push_bg action=click_url', {
-    url: targetUrl,
-  });*/
+  const url = event.notification?.data?.url || APP_URL;
 
-  async function handleClick() {
-    try {
-      const windowClients = await clients.matchAll({
+  event.waitUntil(
+    (async () => {
+      const allClients = await clients.matchAll({
         type: 'window',
         includeUncontrolled: true,
       });
 
-      /*      console.log('[NotifyPolicy] source=push_bg action=clients_found', {
-        count: windowClients.length,
-      });*/
-
-      const clickPayload = {
-        type: 'PUSH_NOTIFICATION_CLICK',
-        data: event.notification.data || {},
-        notification: {
-          title: event.notification.title || '',
-          body: event.notification.body || '',
-        },
-      };
-
-      windowClients.forEach((client) => {
-        client.postMessage(clickPayload);
-      });
-
-      for (const client of windowClients) {
-        if (client.url === targetUrl && 'focus' in client) {
-          /*          console.log('[NotifyPolicy] source=push_bg action=focus_exact', {
-            url: client.url,
-          });*/
-          return client.focus();
-        }
-      }
-
-      for (const client of windowClients) {
+      for (const client of allClients) {
         try {
-          const clientOrigin = new URL(client.url).origin;
-          const swOrigin = self.location.origin;
-
-          if (clientOrigin === swOrigin && 'focus' in client) {
-            /*            console.log(
-              '[NotifyPolicy] source=push_bg action=focus_and_navigate',
-              { from: client.url, to: targetUrl }
-            );*/
-
-            const focusedClient = await client.focus();
-
-            if (focusedClient && 'navigate' in focusedClient) {
-              return focusedClient.navigate(targetUrl);
-            }
-
-            return focusedClient;
+          if ('focus' in client) {
+            await client.focus();
+
+            try {
+              client.postMessage({
+                type: 'OPEN_FROM_PUSH',
+                url,
+                notificationData: event.notification?.data || {},
+              });
+            } catch {}
+
+            return;
           }
-        } catch (_) {}
-      }
-
-      if (clients.openWindow) {
-        /*        console.log('[NotifyPolicy] source=push_bg action=open_new_window', {
-          url: targetUrl,
-        });*/
-        return clients.openWindow(targetUrl);
+        } catch {}
       }
-    } catch (err) {
-      console.error('[NotifyPolicy] source=push_bg action=click_error', err);
 
-      if (clients.openWindow) {
-        return clients.openWindow(targetUrl);
-      }
-    }
-  }
-
-  event.waitUntil(handleClick());
+      return clients.openWindow(url);
+    })()
+  );
 });
 
-// ── Debug / Subscription ──────────────────────────────────────
-self.addEventListener('pushsubscriptionchange', (event) => {
-  //   console.warn('[SW][POSSIBLE_DROP] subscription changed');
-  event.waitUntil(
-    clients
-      .matchAll({ type: 'window', includeUncontrolled: true })
-      .then((allClients) => {
-        allClients.forEach((client) => {
-          client.postMessage({
-            type: 'PUSH_SUBSCRIPTION_CHANGED',
-          });
-        });
-      })
-  );
+// ── LIFECYCLE ─────────────────────────────────────────────────
+self.addEventListener('install', (event) => {
+  log('SW INSTALLED');
+  event.waitUntil(self.skipWaiting());
 });
 
-// ── Lifecycle ─────────────────────────────────────────────────
 self.addEventListener('activate', (event) => {
-  //   console.warn('[SW] activated');
+  log('SW ACTIVATED');
   event.waitUntil(clients.claim());
 });
-
-self.addEventListener('install', (event) => {
-  //   console.log('[SW] installed');
-  event.waitUntil(self.skipWaiting());
-});