Fixed issue #16: Do not duplicate tabs on a closed space when reopening via Spaces window tab-clicking.

Author: codedread

CHANGELOG.md

@@ -6,8 +6,9 @@ All notable changes to this project will be documented in this file.
 
 ### Changes
 
+- Fixed [issue #16](https://github.com/codedread/spaces/issues/16): Stop duplicating tabs of a closed Space when tab is clicked from the Spaces window.
 - Fixed [issue #14](https://github.com/codedread/spaces/issues/14): Open Spaces windows on the currently-active display.
-- Increased unit test coverage from 8.11% to 8.72%.
+- Increased unit test coverage from 8.11% to 9.32%.
 
 
 ## [1.1.5] - 2025-09-08

js/background/background.js

@@ -55,7 +55,7 @@ async function rediscoverWindowByUrl(storageKey, htmlFilename) {
 }
 
 export function initializeServiceWorker() {
-    console.log(`Initializing service worker...(1.1.5)`);
+    console.log(`Initializing service worker...`);
 
     chrome.runtime.onInstalled.addListener(details => {
         console.log(`Extension installed: ${JSON.stringify(details)}`);
@@ -883,10 +883,7 @@ async function handleLoadSession(sessionId, tabUrl) {
             if (curSessionTab.pinned) {
                 let pinnedTabId = false;
                 newWindow.tabs.some(curNewTab => {
-                    if (
-                        curNewTab.url === curSessionTab.url ||
-                        curNewTab.pendingUrl === curSessionTab.url
-                    ) {
+                    if (getEffectiveTabUrl(curNewTab) === curSessionTab.url) {
                         pinnedTabId = curNewTab.id;
                         return true;
                     }
@@ -933,16 +930,16 @@ async function focusWindow(windowId) {
 
 async function focusOrLoadTabInWindow(window, tabUrl) {
     let match = false;
-    for (const tab of window.tabs) {
-        if (tab.url === tabUrl) {
+    for (const tab of window.tabs || []) {
+        if (getEffectiveTabUrl(tab) === tabUrl) {
             await chrome.tabs.update(tab.id, { active: true });
             match = true;
             break;
         }
     }
 
     if (!match) {
-        await chrome.tabs.create({ url: tabUrl });
+        await chrome.tabs.create({ url: tabUrl, active: true });
     }
 }
 
@@ -1254,6 +1251,20 @@ function moveTabToWindow(tab, windowId) {
     spacesService.queueWindowEvent(windowId);
 }
 
+// Module-level helper functions.
+
+/**
+ * Gets the effective URL of a tab, preferring pendingUrl for loading tabs.
+ * @param {chrome.tabs.Tab} tab The tab object to get the effective URL from.
+ * @returns {string} The effective URL of the tab.
+ */
+function getEffectiveTabUrl(tab) {
+    if (tab.status === 'loading' && tab.pendingUrl) {
+        return tab.pendingUrl;
+    }
+    return tab.url;
+}
+
 /**
  * Determines the most appropriate display to show a new window on.
  * It prefers the display containing the currently focused Chrome window.
@@ -1286,4 +1297,9 @@ async function getTargetDisplayWorkArea() {
 }
 
 // Exports for testing.
-export { cleanParameter, getTargetDisplayWorkArea };
+export {
+    cleanParameter,
+    focusOrLoadTabInWindow,
+    getEffectiveTabUrl,
+    getTargetDisplayWorkArea,
+};

manifest.json

@@ -1,7 +1,7 @@
 {
     "name": "Spaces",
     "description": "Intuitive tab management",
-    "version": "1.1.6.0",
+    "version": "1.1.6.1",
     "permissions": [
         "contextMenus",
         "favicon",

tests/focusOrLoadTabInWindow.test.js

@@ -0,0 +1,70 @@
+
+import { setupChromeMocks, jest } from './helpers.js';
+
+jest.mock('../js/background/spacesService.js', () => ({
+  cleanUrl: jest.fn(url => url),
+}));
+
+describe('focusOrLoadTabInWindow', () => {
+  let focusOrLoadTabInWindow;
+
+  beforeEach(async () => {
+    setupChromeMocks();
+    const background = await import('../js/background/background.js');
+    focusOrLoadTabInWindow = background.focusOrLoadTabInWindow;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should focus existing tab when match is found', async () => {
+    const window = {
+      tabs: [
+        { id: 1, url: 'https://example.com', status: 'complete' },
+        { id: 2, url: 'https://google.com', status: 'complete' },
+      ],
+    };
+    const tabUrl = 'https://example.com';
+
+    await focusOrLoadTabInWindow(window, tabUrl);
+
+    expect(chrome.tabs.update).toHaveBeenCalledWith(1, { active: true });
+    expect(chrome.tabs.create).not.toHaveBeenCalled();
+  });
+
+  test('should create new tab when no match is found', async () => {
+    const window = {
+      tabs: [
+        { id: 1, url: 'https://google.com', status: 'complete' },
+        { id: 2, url: 'https://github.com', status: 'complete' },
+      ],
+    };
+    const tabUrl = 'https://example.com';
+
+    await focusOrLoadTabInWindow(window, tabUrl);
+
+    expect(chrome.tabs.update).not.toHaveBeenCalled();
+    expect(chrome.tabs.create).toHaveBeenCalledWith({ url: tabUrl, active: true });
+  });
+
+  test('should handle window with no tabs gracefully', async () => {
+    const window = { tabs: [] };
+    const tabUrl = 'https://example.com';
+
+    await focusOrLoadTabInWindow(window, tabUrl);
+
+    expect(chrome.tabs.update).not.toHaveBeenCalled();
+    expect(chrome.tabs.create).toHaveBeenCalledWith({ url: tabUrl, active: true });
+  });
+
+  test('should handle window with missing tabs property', async () => {
+    const window = {};
+    const tabUrl = 'https://example.com';
+
+    await focusOrLoadTabInWindow(window, tabUrl);
+
+    expect(chrome.tabs.update).not.toHaveBeenCalled();
+    expect(chrome.tabs.create).toHaveBeenCalledWith({ url: tabUrl, active: true });
+  });
+});

tests/getEffectiveTabUrl.test.js

@@ -0,0 +1,79 @@
+import { getEffectiveTabUrl } from '../js/background/background.js';
+
+describe('getEffectiveTabUrl', () => {
+  test('should return tab URL when status is complete', () => {
+    const tab = {
+      id: 1,
+      url: 'https://example.com?param=value',
+      status: 'complete'
+    };
+
+    const result = getEffectiveTabUrl(tab);
+
+    // Should return URL as-is (no cleaning)
+    expect(result).toBe('https://example.com?param=value');
+  });
+
+  test('should return pendingUrl when status is loading and pendingUrl exists', () => {
+    const tab = {
+      id: 1,
+      url: 'about:blank',
+      pendingUrl: 'https://example.com/path#section',
+      status: 'loading'
+    };
+
+    const result = getEffectiveTabUrl(tab);
+
+    // Should use pendingUrl as-is (no cleaning)
+    expect(result).toBe('https://example.com/path#section');
+  });
+
+  test('should return tab URL when status is loading but no pendingUrl', () => {
+    const tab = {
+      id: 1,
+      url: 'https://example.com?foo=bar',
+      status: 'loading'
+    };
+
+    const result = getEffectiveTabUrl(tab);
+
+    expect(result).toBe('https://example.com?foo=bar');
+  });
+
+  test('should return tab URL when pendingUrl exists but status is not loading', () => {
+    const tab = {
+      id: 1,
+      url: 'https://example.com?foo=bar',
+      pendingUrl: 'https://different.com',
+      status: 'complete'
+    };
+
+    const result = getEffectiveTabUrl(tab);
+
+    expect(result).toBe('https://example.com?foo=bar');
+  });
+
+  test('should handle tab with no status property', () => {
+    const tab = {
+      id: 1,
+      url: 'https://example.com#hash'
+    };
+
+    const result = getEffectiveTabUrl(tab);
+
+    expect(result).toBe('https://example.com#hash');
+  });
+
+  test('should handle tab with empty pendingUrl', () => {
+    const tab = {
+      id: 1,
+      url: 'https://example.com?query=test',
+      pendingUrl: '',
+      status: 'loading'
+    };
+
+    const result = getEffectiveTabUrl(tab);
+
+    expect(result).toBe('https://example.com?query=test');
+  });
+});

tests/helpers.js

@@ -21,7 +21,9 @@ export const setupChromeMocks = () => {
             },
         },
         tabs: {
+            create: jest.fn(),
             query: jest.fn(),
+            update: jest.fn(),
         },
         windows: {
             getCurrent: jest.fn(),