2024

Author: arzafran

background.js

@@ -1,32 +1,86 @@
+let currentTabId = null;
+
 // Event to toggle Lenis when extension's button is clicked
 chrome.action.onClicked.addListener(async (tab) => {
+  currentTabId = tab.id;
+  await injectScripts(tab.id);
   chrome.tabs.sendMessage(tab.id, { action: "toggleLenis" });
 });
 
+async function injectScripts(tabId) {
+  try {
+    await chrome.scripting.executeScript({
+      target: { tabId: tabId },
+      files: ['lenis-wrapper.js']
+    });
+    await chrome.scripting.executeScript({
+      target: { tabId: tabId },
+      files: ['execute.js']
+    });
+  } catch (error) {
+    console.error('Error injecting scripts:', error);
+  }
+}
+
 // Function to update the icon
 function updateIcon(enabled) {
-  const path = enabled ? {
-    16: 'icon16.png',
-    48: 'icon48.png',
-    128: 'icon128.png'
-  } : {
-    16: 'icon16-gray.png',
-    48: 'icon48-gray.png',
-    128: 'icon128-gray.png'
-  };
-  chrome.action.setIcon({ path: path });
+  if (!currentTabId) {
+    console.error('No current tab ID when updating icon');
+    return;
+  }
+
+  const iconName = enabled ? 'icon' : 'icon-gray';
+  const iconSizes = [16, 48, 128];
+
+  const path = {};
+  iconSizes.forEach(size => {
+    path[size] = `${iconName}${size}.png`;
+  });
+
+  console.log('Attempting to set icon with path:', path);
+
+  chrome.action.setIcon({ 
+    tabId: currentTabId,
+    path: path 
+  }, () => {
+    if (chrome.runtime.lastError) {
+      console.error('Error setting icon:', chrome.runtime.lastError.message);
+    } else {
+      console.log('Icon set successfully');
+    }
+  });
 }
 
 // Listen for changes in storage
 chrome.storage.onChanged.addListener((changes, namespace) => {
   if (namespace === 'local' && 'smooth' in changes) {
+    console.log('Smooth scrolling state changed:', changes.smooth.newValue);
     updateIcon(changes.smooth.newValue);
   }
 });
 
-// Set initial icon state on extension load
-chrome.runtime.onStartup.addListener(() => {
+// Set initial icon state when a tab is activated
+chrome.tabs.onActivated.addListener((activeInfo) => {
+  currentTabId = activeInfo.tabId;
   chrome.storage.local.get(['smooth'], (result) => {
+    console.log('Tab activated, current smooth state:', result.smooth);
     updateIcon(result.smooth || false);
   });
+});
+
+// Update icon when a tab is updated (e.g., page refresh)
+chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
+  if (changeInfo.status === 'complete' && tabId === currentTabId) {
+    chrome.storage.local.get(['smooth'], (result) => {
+      console.log('Tab updated, current smooth state:', result.smooth);
+      updateIcon(result.smooth || false);
+    });
+  }
+});
+
+// Log errors from extension context
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  if (message.type === 'error') {
+    console.error('Error from content script:', message.error);
+  }
 });

execute.js

@@ -1,68 +1,49 @@
-// This code will be executed when the extension's button is clicked
-
 (function() {
   let lenis = null;
-
-  function loadLenis() {
-    return new Promise((resolve, reject) => {
-      if (window.Lenis) {
-        resolve(window.Lenis);
-      } else {
-        const script = document.createElement('script');
-        script.src = 'https://cdn.jsdelivr.net/npm/lenis';
-        script.onload = () => resolve(window.Lenis);
-        script.onerror = reject;
-        document.head.appendChild(script);
-      }
-    });
-  }
+  let rafId = null;
 
   function enableLenis() {
-    if (!lenis) {
-      lenis = new window.Lenis();
+    if (!lenis && typeof Lenis === 'function') {
+      lenis = new Lenis();
       function raf(time) {
         lenis.raf(time);
-        requestAnimationFrame(raf);
+        rafId = requestAnimationFrame(raf);
       }
-      requestAnimationFrame(raf);
+      rafId = requestAnimationFrame(raf);
+      chrome.storage.local.set({ smooth: true });
+      console.log("Smooth scrolling enabled");
+    } else if (!Lenis) {
+      console.error('Lenis is not available');
     }
   }
 
   function disableLenis() {
     if (lenis) {
+      if (rafId) {
+        cancelAnimationFrame(rafId);
+        rafId = null;
+      }
       lenis.destroy();
       lenis = null;
+      chrome.storage.local.set({ smooth: false });
+      console.log("Smooth scrolling disabled");
     }
   }
 
   function toggleLenis() {
     chrome.storage.local.get(["smooth"], function(result) {
-      const newState = !result.smooth;
-      
-      if (newState) {
-        loadLenis().then(() => {
-          enableLenis();
-          chrome.storage.local.set({ smooth: true });
-          console.log("Smooth scrolling enabled");
-        }).catch(error => {
-          console.error('Failed to load Lenis:', error);
-        });
-      } else {
+      if (result.smooth) {
         disableLenis();
-        chrome.storage.local.set({ smooth: false });
-        console.log("Smooth scrolling disabled");
+      } else {
+        enableLenis();
       }
     });
   }
 
   // Check if we need to initialize Lenis on page load
   chrome.storage.local.get(["smooth"], function(result) {
     if (result.smooth) {
-      loadLenis().then(() => {
-        enableLenis();
-      }).catch(error => {
-        console.error('Failed to load Lenis:', error);
-      });
+      enableLenis();
     }
   });
 
@@ -72,4 +53,12 @@
       toggleLenis();
     }
   });
+
+  // Cleanup function
+  function cleanup() {
+    disableLenis();
+  }
+
+  // Add event listener for when the script is about to be unloaded
+  window.addEventListener('beforeunload', cleanup);
 })();