// Tab Park - settings and discard helpers shared by the background page, // the popup and the options page. Loaded as a classic script, so declarations // here are visible to whatever script follows. const TU_DEFAULTS = { autoUnload: false, idleSeconds: 300, skipAudible: true }; // Below this the sweep would fight the user's own tab switching. const TU_MIN_IDLE_SECONDS = 10; async function tuSettings() { const stored = await browser.storage.local.get(TU_DEFAULTS); const idle = Math.round(Number(stored.idleSeconds)); return { autoUnload: Boolean(stored.autoUnload), idleSeconds: Number.isFinite(idle) && idle >= TU_MIN_IDLE_SECONDS ? idle : TU_DEFAULTS.idleSeconds, skipAudible: Boolean(stored.skipAudible) }; } async function tuSaveSettings(patch) { await browser.storage.local.set(patch); } // A tab is a discard candidate when it is loaded, not pinned, not the active // tab of its window, and not mid-navigation. Firefox refuses to discard the // active tab, so filtering it here keeps the counts honest. function tuCandidates(tabs, { skipAudible = false } = {}) { return tabs.filter(tab => !tab.discarded && !tab.pinned && !tab.active && tab.status !== 'loading' && (!skipAudible || !tab.audible) ); } const TU_PARKING_KEY = 'parkingTabId'; // The blank tab we opened to park the window on. Without the "tabs" // permission Firefox does not reveal a tab's URL, so the id is the only way // to tell this tab apart from a page the user opened. async function tuParkingTabId() { const stored = await browser.storage.session.get(TU_PARKING_KEY); const id = stored[TU_PARKING_KEY]; return typeof id === 'number' ? id : null; } async function tuSetParkingTabId(tabId) { await browser.storage.session.set({ [TU_PARKING_KEY]: tabId }); } // A blank tab is the one place unloading makes no sense: there is nothing to // free, and unloading it would only put another blank tab in its place. // Without the "tabs" permission Firefox does not reveal tab URLs, so the id // of the tab we opened is the only signal available. async function tuIsParkingTab(tab) { if (!tab) return false; return tab.id === await tuParkingTabId(); } const TU_PROTECTED_KEY = 'protectedTabIds'; // Tabs the user marked "never park". Stored by id, so the mark lives as long // as the tab does. Without the "tabs" permission there is no stable // identifier to carry it across a restart. async function tuProtectedIds() { const stored = await browser.storage.session.get(TU_PROTECTED_KEY); const ids = stored[TU_PROTECTED_KEY]; return new Set(Array.isArray(ids) ? ids.filter(id => typeof id === 'number') : []); } async function tuIsProtected(tabId) { return (await tuProtectedIds()).has(tabId); } async function tuSetProtected(tabId, protect) { const ids = await tuProtectedIds(); if (protect) ids.add(tabId); else ids.delete(tabId); await browser.storage.session.set({ [TU_PROTECTED_KEY]: [...ids] }); } async function tuWaitActive(tabId, timeoutMs = 1000) { const deadline = Date.now() + timeoutMs; while (Date.now() < deadline) { const tab = await browser.tabs.get(tabId).catch(() => null); if (!tab) return false; if (tab.active) return true; await new Promise(resolve => setTimeout(resolve, 25)); } return false; } async function tuWaitComplete(tabId, timeoutMs = 2000) { const deadline = Date.now() + timeoutMs; while (Date.now() < deadline) { const tab = await browser.tabs.get(tabId).catch(() => null); if (!tab) return false; if (tab.status === 'complete') return true; await new Promise(resolve => setTimeout(resolve, 25)); } return false; } // Opens the blank tab the window parks on. The id is recorded only after the // initial load finishes, so a later "loading" event means the user navigated // it and the id can be dropped. async function tuCreateParkingTab(windowId) { const created = await browser.tabs.create({ windowId, active: true }); await tuWaitActive(created.id); await tuWaitComplete(created.id); await tuSetParkingTabId(created.id); return created; } // Discards in one batch, then reads the tabs back so the caller gets the // number that actually unloaded. A tab with a beforeunload prompt cannot be // discarded and rejects the batch, so fall back to one at a time. async function tuDiscard(tabs) { const ids = tabs.map(tab => tab.id).filter(id => typeof id === 'number'); if (ids.length === 0) return 0; try { await browser.tabs.discard(ids); } catch (e) { for (const id of ids) { await browser.tabs.discard(id).catch(() => {}); } } const after = await browser.tabs.query({}); const byId = new Map(after.map(tab => [tab.id, tab])); return ids.filter(id => { const tab = byId.get(id); return !tab || tab.discarded; }).length; } // Unloads every candidate in the window except the tab the user asked to // keep. tuCandidates already excludes the active tab; keepTabId covers the // context menu case, where the tab to keep is not the active one. async function tuUnloadOtherTabs(windowId, keepTabId) { if (typeof windowId !== 'number') return 0; const { skipAudible } = await tuSettings(); const protectedIds = await tuProtectedIds(); const tabs = await browser.tabs.query({ windowId }); return tuDiscard( tuCandidates(tabs, { skipAudible }) .filter(tab => tab.id !== keepTabId && !protectedIds.has(tab.id)) ); } // Unloads the active tab without leaving a blank window: switch to the next // loaded tab first (wrapping around), or open a fresh tab when every other // tab is already unloaded. Firefox will not discard the active tab, so the // order matters. The discard is verified because tabs.discard() resolves // without doing anything if the tab is still selected. async function tuUnloadActiveTab(tab) { if (await tuIsParkingTab(tab)) return false; const tabs = await browser.tabs.query({ windowId: tab.windowId }); const current = tabs.find(other => other.id === tab.id) || tab; const loaded = tabs .filter(other => other.id !== current.id && !other.discarded && other.status !== 'loading') .sort((a, b) => a.index - b.index); const next = loaded.find(other => other.index > current.index) || loaded[0]; if (next) { await browser.tabs.update(next.id, { active: true }); } else if (tabs.length > 1) { await tuCreateParkingTab(current.windowId); } else { // The only tab in the window: there is nowhere to switch to. return false; } for (let attempt = 0; attempt < 3; attempt++) { try { await browser.tabs.discard(current.id); } catch (e) { return false; } const after = await browser.tabs.get(current.id).catch(() => null); if (!after || after.discarded) return true; await new Promise(resolve => setTimeout(resolve, 120)); } return false; }