webext-active-tab 0.9.0 → 1.0.0

package/distribution/on-active-tab.d.ts

@@ -1,3 +1,4 @@
+import { StorageItemMap } from 'webext-storage';
 type TabId = number;
 type Origin = string;
 export type ActiveTab = {
@@ -5,9 +6,9 @@ export type ActiveTab = {
     origin: Origin;
 };
 /**
- * The list is not guaranteed to be up to date. The activeTab permission might be lost before it's detected.
+ The list is not guaranteed to be up to date. The activeTab permission might be lost before it's detected.
  */
-export declare const possiblyActiveTabs: Map<number, string>;
+export declare const possiblyActiveTabs: StorageItemMap<string, string | undefined> | Map<string, string>;
 declare function startActiveTabTracking(): void;
 declare function stopActiveTabTracking(): void;
 export declare const PRIVATE: {

package/distribution/on-active-tab.js

@@ -1,6 +1,7 @@
 import { isScriptableUrl } from 'webext-content-scripts';
 import { isBackground } from 'webext-detect';
 import SimpleEventTarget from 'simple-event-target';
+import { StorageItemMap } from 'webext-storage';
 if (!isBackground()) {
     throw new Error('This module is only allowed in a background script');
 }
@@ -9,63 +10,87 @@ if (!chrome.runtime.getManifest().permissions?.includes('activeTab')) {
 }
 const activation = new SimpleEventTarget();
 const deactivation = new SimpleEventTarget();
-const browserAction = chrome.action ?? chrome.browserAction;
-// TODO: use https://github.com/fregante/webext-storage/issues/5
 /**
- * The list is not guaranteed to be up to date. The activeTab permission might be lost before it's detected.
+ The list is not guaranteed to be up to date. The activeTab permission might be lost before it's detected.
  */
-export const possiblyActiveTabs = new Map();
+// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- Typed as always defined, but `chrome.storage` or `chrome.storage.session` can be missing at runtime
+export const possiblyActiveTabs = chrome.storage?.session
+    ? new StorageItemMap('webext-active-tab', {
+        area: 'session',
+    })
+    : new Map();
 async function addIfScriptable({ url, id }) {
-    if (id && url
+    if (id !== undefined && url !== undefined
         // Skip if it already exists. A previous change of origin already cleared this
-        && !possiblyActiveTabs.has(id)
+        && !await possiblyActiveTabs.has(String(id))
         // ActiveTab doesn't make sense on non-scriptable URLs as they generally don't have scriptable frames
         && isScriptableUrl(url)
     // Note: Do not filter by `isContentScriptRegistered`; `active-tab` also applies to random `executeScript` calls
     ) {
         const { origin } = new URL(url);
         console.debug('activeTab:', id, 'added', { origin });
-        possiblyActiveTabs.set(id, origin);
+        await possiblyActiveTabs.set(String(id), origin);
         activation.emit({ id, origin });
     }
     else {
-        console.debug('activeTab:', id, 'not added', { origin });
+        console.debug('activeTab:', id, 'not added', { url });
     }
 }
-function dropIfOriginChanged(tabId, { url }) {
-    if (url && possiblyActiveTabs.has(tabId)) {
-        const { origin } = new URL(url);
-        if (possiblyActiveTabs.get(tabId) !== origin) {
-            console.debug('activeTab:', tabId, 'removed because origin changed from', possiblyActiveTabs.get(tabId), 'to', origin);
-            possiblyActiveTabs.delete(tabId);
+// Serialized per tab, so overlapping events can't both see the entry and emit twice
+const pendingDrops = new Map();
+// Drops the tab if it's active, unless it's still on `keepOrigin`
+async function drop(tabId, keepOrigin) {
+    const previous = pendingDrops.get(tabId);
+    const { promise: current, resolve: release } = Promise.withResolvers();
+    pendingDrops.set(tabId, current);
+    try {
+        try {
+            await previous;
+        }
+        catch { }
+        const activeOrigin = await possiblyActiveTabs.get(String(tabId));
+        if (activeOrigin !== undefined && activeOrigin !== keepOrigin) {
+            console.debug('activeTab:', tabId, 'removed', { activeOrigin, keepOrigin });
+            await possiblyActiveTabs.delete(String(tabId));
+            deactivation.emit(tabId);
+        }
+    }
+    finally {
+        release();
+        if (pendingDrops.get(tabId) === current) {
+            pendingDrops.delete(tabId);
         }
     }
 }
+async function dropIfActive(tabId) {
+    await drop(tabId);
+}
+async function dropIfOriginChanged(tabId, { url }) {
+    if (url === undefined || url === '') {
+        return;
+    }
+    await drop(tabId, new URL(url).origin);
+}
 function altListener(_, tab) {
     if (tab) {
         void addIfScriptable(tab);
     }
 }
-function drop(tabId) {
-    console.debug('activeTab:', tabId, 'removed');
-    possiblyActiveTabs.delete(tabId);
-    deactivation.emit(tabId);
-}
 // https://developer.chrome.com/docs/extensions/mv3/manifest/activeTab/#invoking-activeTab
 function startActiveTabTracking() {
-    browserAction?.onClicked.addListener(addIfScriptable);
+    chrome.action?.onClicked.addListener(addIfScriptable);
     chrome.contextMenus?.onClicked.addListener(altListener);
     chrome.commands?.onCommand.addListener(altListener);
     chrome.tabs.onUpdated.addListener(dropIfOriginChanged);
-    chrome.tabs.onRemoved.addListener(drop);
+    chrome.tabs.onRemoved.addListener(dropIfActive);
 }
 function stopActiveTabTracking() {
-    browserAction?.onClicked.removeListener(addIfScriptable);
+    chrome.action?.onClicked.removeListener(addIfScriptable);
     chrome.contextMenus?.onClicked.removeListener(altListener);
     chrome.commands?.onCommand.removeListener(altListener);
     chrome.tabs.onUpdated.removeListener(dropIfOriginChanged);
-    chrome.tabs.onRemoved.removeListener(drop);
-    possiblyActiveTabs.clear();
+    chrome.tabs.onRemoved.removeListener(dropIfActive);
+    void possiblyActiveTabs.clear();
 }
 export const PRIVATE = {
     startActiveTabTracking,

package/distribution/register-active-tab-scripts.js

@@ -1,41 +1,44 @@
 import { injectContentScript } from 'webext-content-scripts';
 import { onActiveTab, possiblyActiveTabs } from './on-active-tab.js';
-const gotNavigation = typeof chrome === 'object' && 'webNavigation' in chrome;
+const hasNavigation = typeof chrome === 'object' && 'webNavigation' in chrome;
 const scripts = [];
 async function injectAllFrames({ id: tabId, origin: url }) {
     if (tabId === undefined) {
         return;
     }
-    if (!gotNavigation) {
+    if (!hasNavigation) {
         // Without it, we only inject it into the top frame
         return injectOneFrame({ frameId: 0, url, tabId });
     }
     const frames = await chrome.webNavigation.getAllFrames({ tabId });
     // .map() needed for async loop
-    void frames?.map(async ({ frameId, url }) => injectOneFrame({ frameId, url, tabId }));
+    void frames?.map(async ({ frameId, url: frameUrl }) => injectOneFrame({ frameId, url: frameUrl, tabId }));
 }
 async function injectOneFrame({ tabId, frameId, url }) {
     const { origin } = new URL(url);
+    const activeOrigin = await possiblyActiveTabs.get(String(tabId));
     // Check origin because the request might be for a frame; cross-origin frames do not receive activeTab
-    if (possiblyActiveTabs.get(tabId) === origin) {
+    if (activeOrigin === origin) {
         console.debug('activeTab: will inject', { tabId, frameId, url });
-        await injectContentScript({ tabId, frameId }, scripts);
+        await injectContentScript({ tabId, frameId }, 
+        // `webext-content-scripts` uses the `manifest.json` format
+        scripts.map(({ runAt, matchAboutBlank, ...script }) => ({ ...script, run_at: runAt, match_about_blank: matchAboutBlank })), { ignoreTargetErrors: true });
     }
     else {
-        console.debug('activeTab: won’t inject', { tabId, frameId, url }, { activeTab: possiblyActiveTabs.get(tabId) ?? 'no' });
+        console.debug('activeTab: won’t inject', { tabId, frameId, url }, { activeTab: activeOrigin ?? 'no' });
     }
 }
 async function tabListener(tabId, { status }, { url }) {
     // Only status updates are relevant
     // No URL = no permission
-    if (status === 'loading' && url) {
+    if (status === 'loading' && url !== undefined) {
         await injectOneFrame({ tabId, url, frameId: 0 });
     }
 }
 export default function registerActiveTabScripts(...newScripts) {
     scripts.push(...newScripts);
     onActiveTab.addListener(injectAllFrames);
-    if (gotNavigation) {
+    if (hasNavigation) {
         chrome.webNavigation.onCommitted.addListener(injectOneFrame);
     }
     else {

package/package.json

@@ -1,26 +1,10 @@
 {
 	"name": "webext-active-tab",
-	"version": "0.9.0",
+	"version": "1.0.0",
 	"description": "WebExtension module: Track `activeTab` permission; automatically inject content scripts",
-	"keywords": [
-		"contentscript",
-		"register",
-		"injection",
-		"permissions",
-		"request",
-		"optional_permissions",
-		"host_permissions",
-		"manifest",
-		"new hosts",
-		"chrome",
-		"firefox",
-		"browser",
-		"activetab",
-		"extension"
-	],
+	"license": "MIT",
 	"repository": "fregante/webext-active-tab",
 	"funding": "https://github.com/sponsors/fregante",
-	"license": "MIT",
 	"author": "Federico Brigante <me@fregante.com> (https://fregante.com)",
 	"type": "module",
 	"exports": {
@@ -33,46 +17,54 @@
 			"default": "./distribution/register-active-tab-scripts.js"
 		}
 	},
+	"sideEffects": false,
+	"engines": {
+		"node": ">=24"
+	},
 	"scripts": {
 		"build": "tsc",
 		"demo:build": "parcel build --no-cache",
 		"demo:watch": "parcel watch --no-cache --no-hmr",
-		"prepack": "tsc --sourceMap false",
+		"prepare": "tsc --sourceMap false",
 		"lint": "xo",
 		"fix": "xo --fix",
 		"test": "run-p lint build demo:build",
 		"watch": "tsc --watch"
 	},
-	"xo": {
-		"envs": [
-			"browser",
-			"webextensions"
-		],
-		"rules": {
-			"no-implicit-globals": "off",
-			"@typescript-eslint/prefer-nullish-coalescing": "off",
-			"@typescript-eslint/no-implicit-any-catch": "off",
-			"@typescript-eslint/naming-convention": "off",
-			"import/extensions": "off",
-			"import/no-unassigned-import": "off",
-			"unicorn/prefer-top-level-await": "off",
-			"unicorn/prefer-node-protocol": "off",
-			"n/file-extension-in-import": "off"
-		}
-	},
+	"files": [
+		"distribution"
+	],
+	"keywords": [
+		"contentscript",
+		"register",
+		"injection",
+		"permissions",
+		"request",
+		"optional_permissions",
+		"host_permissions",
+		"manifest",
+		"new hosts",
+		"chrome",
+		"firefox",
+		"browser",
+		"activetab",
+		"extension"
+	],
 	"dependencies": {
-		"simple-event-target": "^2.0.0",
-		"webext-content-scripts": "^2.7.2",
-		"webext-detect": "^5.3.2"
+		"simple-event-target": "^2.1.0",
+		"webext-content-scripts": "^3.1.0",
+		"webext-detect": "^6.0.0",
+		"webext-storage": "^3.1.0"
 	},
 	"devDependencies": {
-		"@parcel/config-webextension": "^2.13.3",
-		"@sindresorhus/tsconfig": "^7.0.0",
-		"@types/chrome": "^0.0.300",
-		"npm-run-all2": "^7.0.2",
-		"parcel": "^2.13.3",
-		"typescript": "^5.7.3",
-		"xo": "^0.60.0"
+		"@parcel/config-webextension": "^2.16.4",
+		"@sindresorhus/tsconfig": "^8.1.0",
+		"@types/chrome": "^0.3.6",
+		"globals": "^17.13.0",
+		"npm-run-all2": "^9.0.3",
+		"parcel": "^2.16.4",
+		"typescript": "^6.0.3",
+		"xo": "^5.0.1"
 	},
 	"@parcel/resolver-default": {
 		"packageExports": true
@@ -86,7 +78,12 @@
 			"sourceMap": {
 				"inline": true
 			},
-			"optimize": false
+			"optimize": false,
+			"engines": {
+				"browsers": [
+					"last 1 Chrome version"
+				]
+			}
 		}
 	},
 	"webExt": {

package/distribution/register.d.ts

@@ -1 +0,0 @@
-export {};

package/distribution/register.js

@@ -1,2 +0,0 @@
-import register from './scripts.js';
-register();

package/distribution/scripts.d.ts

@@ -1 +0,0 @@
-export default function register(): void;

package/distribution/scripts.js

@@ -1,47 +0,0 @@
-import { injectContentScript } from 'webext-content-scripts';
-import { addActiveTabListener, possiblyActiveTabs } from './tracker.js';
-import { isContentScriptRegistered } from './utils.js';
-const gotNavigation = typeof chrome === 'object' && 'webNavigation' in chrome;
-const scripts = chrome.runtime.getManifest().content_scripts;
-async function injectToTabUnlessRegistered({ id: tabId, origin }) {
-    if (tabId === undefined) {
-        return;
-    }
-    const frames = gotNavigation
-        // Only with `webNavigation` we can inject into the frames
-        ? await chrome.webNavigation.getAllFrames({ tabId })
-        // Without it, we only inject it into the top frame
-        : [{ frameId: 0, url: origin }];
-    // .map() needed for async loop
-    void frames?.map(async ({ frameId, url }) => injectIfActive({ frameId, url, tabId }));
-}
-async function injectIfActive({ tabId, frameId, url }) {
-    const { origin } = new URL(url);
-    if (
-    // Check origin because the request might be for a frame; cross-origin frames do not receive activeTab
-    possiblyActiveTabs.get(tabId) === origin
-        // Don't inject if already registered
-        && !(await isContentScriptRegistered(url))) {
-        console.debug('activeTab: will inject', { tabId, frameId, url });
-        await injectContentScript({ tabId, frameId }, scripts);
-    }
-    else {
-        console.debug('activeTab: won’t inject', { tabId, frameId, url }, { activeTab: possiblyActiveTabs.get(tabId) ?? 'no' });
-    }
-}
-async function tabListener(tabId, { status }, { url }) {
-    // Only status updates are relevant
-    // No URL = no permission
-    if (status === 'loading' && url) {
-        await injectIfActive({ tabId, url, frameId: 0 });
-    }
-}
-export default function register() {
-    addActiveTabListener(injectToTabUnlessRegistered);
-    if (gotNavigation) {
-        chrome.webNavigation.onCommitted.addListener(injectIfActive);
-    }
-    else {
-        chrome.tabs.onUpdated.addListener(tabListener);
-    }
-}

package/distribution/tracker.d.ts

@@ -1,11 +0,0 @@
-type TabId = number;
-type Origin = string;
-export type ActiveTab = {
-    id: TabId;
-    origin: Origin;
-};
-export declare const possiblyActiveTabs: Map<number, string>;
-export declare function startActiveTabTracking(): void;
-export declare function stopActiveTabTracking(): void;
-export declare function addActiveTabListener(callback: (tab: ActiveTab) => void): void;
-export {};

package/distribution/tracker.js

@@ -1,65 +0,0 @@
-import { isScriptableUrl } from 'webext-content-scripts';
-import { isBackground } from 'webext-detect';
-import SimpleEventTarget from 'simple-event-target';
-if (!isBackground()) {
-    throw new Error('This module is only allowed in a background script');
-}
-const newActiveTabs = new SimpleEventTarget();
-const browserAction = chrome.action ?? chrome.browserAction;
-// TODO: use webext-storage
-export const possiblyActiveTabs = new Map();
-async function addIfScriptable({ url, id }) {
-    if (id && url
-        // Skip if it already exists. A previous change of origin already cleared this
-        && !possiblyActiveTabs.has(id)
-        // ActiveTab doesn't make sense on non-scriptable URLs as they generally don't have scriptable frames
-        && isScriptableUrl(url)
-    // Note: Do not filter by `isContentScriptRegistered`; `active-tab` also applies to random `executeScript` calls
-    ) {
-        const { origin } = new URL(url);
-        console.debug('activeTab:', id, 'added', { origin });
-        possiblyActiveTabs.set(id, origin);
-        newActiveTabs.emit({ id, origin });
-    }
-    else {
-        console.debug('activeTab:', id, 'not added', { origin });
-    }
-}
-function dropIfOriginChanged(tabId, { url }) {
-    if (url && possiblyActiveTabs.has(tabId)) {
-        const { origin } = new URL(url);
-        if (possiblyActiveTabs.get(tabId) !== origin) {
-            console.debug('activeTab:', tabId, 'removed because origin changed from', possiblyActiveTabs.get(tabId), 'to', origin);
-            possiblyActiveTabs.delete(tabId);
-        }
-    }
-}
-function altListener(_, tab) {
-    if (tab) {
-        void addIfScriptable(tab);
-    }
-}
-function drop(tabId) {
-    console.debug('activeTab:', tabId, 'removed');
-    possiblyActiveTabs.delete(tabId);
-}
-// https://developer.chrome.com/docs/extensions/mv3/manifest/activeTab/#invoking-activeTab
-export function startActiveTabTracking() {
-    browserAction?.onClicked.addListener(addIfScriptable);
-    chrome.contextMenus?.onClicked.addListener(altListener);
-    chrome.commands?.onCommand.addListener(altListener);
-    chrome.tabs.onUpdated.addListener(dropIfOriginChanged);
-    chrome.tabs.onRemoved.addListener(drop);
-}
-export function stopActiveTabTracking() {
-    browserAction?.onClicked.removeListener(addIfScriptable);
-    chrome.contextMenus?.onClicked.removeListener(altListener);
-    chrome.commands?.onCommand.removeListener(altListener);
-    chrome.tabs.onUpdated.removeListener(dropIfOriginChanged);
-    chrome.tabs.onRemoved.removeListener(drop);
-    possiblyActiveTabs.clear();
-}
-export function addActiveTabListener(callback) {
-    startActiveTabTracking();
-    newActiveTabs.listen(callback);
-}

package/distribution/utils.d.ts

@@ -1,7 +0,0 @@
-export declare function isContentScriptStaticallyRegistered(url: string): boolean;
-export declare function isContentScriptDynamicallyRegistered(url: string): Promise<boolean>;
-/**
-Checks whether a URL will have the content scripts automatically injected.
-It returns a promise that resolves with string indicating the type of injection ('static' or 'dynamic') or `false` if it won't be injected on the specified URL.
-*/
-export declare function isContentScriptRegistered(url: string): Promise<'static' | 'dynamic' | false>;

package/distribution/utils.js

@@ -1,30 +0,0 @@
-import { queryAdditionalPermissions } from 'webext-permissions';
-import { patternToRegex } from 'webext-patterns';
-export function isContentScriptStaticallyRegistered(url) {
-    return Boolean(chrome.runtime
-        .getManifest()
-        .content_scripts
-        ?.flatMap(script => script.matches)
-        .some(pattern => patternToRegex(pattern).test(url)));
-}
-export async function isContentScriptDynamicallyRegistered(url) {
-    // Injected by `webext-active-tab`
-    const { origins } = await queryAdditionalPermissions({
-        strictOrigins: false,
-    });
-    // Do not replace the 2 calls above with `permissions.getAll` because it might also include hosts that are permitted by the manifest but have no content script registered
-    return patternToRegex(...origins).test(url);
-}
-/**
-Checks whether a URL will have the content scripts automatically injected.
-It returns a promise that resolves with string indicating the type of injection ('static' or 'dynamic') or `false` if it won't be injected on the specified URL.
-*/
-export async function isContentScriptRegistered(url) {
-    if (isContentScriptStaticallyRegistered(url)) {
-        return 'static';
-    }
-    if (await isContentScriptDynamicallyRegistered(url)) {
-        return 'dynamic';
-    }
-    return false;
-}