add global search hotkey functionality (#2)

Author: NiklasGollenstede

README.md

@@ -1,11 +1,13 @@
 
 # TST Tab Search -- filter Tree Style Tab's sidebar
 
+<!-- <sub><a href="https://addons.mozilla.org/firefox/addon/tst-search/"><img src="./resources/get-ff-ext.png" width="86" height="30"></a></sub> -->
+
 This is an extension for the browser extension [Tree Style Tabs](https://github.com/piroor/treestyletab#readme) (TST). It adds a search box at the bottom of TST's sidebar, allowing to search the titles and URLs (or whatever) of the tabs in the current window/sidebar, optionally case sensitive, as whole word, or by regular expression.
 Matching tabs will be highlighted in the tree, and/or non-matches will be suppressed (see extension preferences).
 Should the search bar not show up after installing this extension, then have a look at `about:addons` > "Extensions" > "TST Tab Search" > "Preferences".
 
-![Searching for Cats](./resources/screenshot.png)
+<img alt="Searching for Cats" src="./resources/screenshot.png" width="440px">
 
 Thats pretty much all there is to say.
 Many thanks to TST's author [piroor](https://github.com/piroor), who has not only developed TST as a great standalone extension, but also designed a very good API for other extensions to interact and integrate with TST. With that, writing the initial version of this extension from scratch took only about two long afternoons.
@@ -15,11 +17,6 @@ Many thanks to TST's author [piroor](https://github.com/piroor), who has not onl
 - "Access to browser tabs": Get titles and URLs of tabs to be searched.
 - "Display notifications to you": Notify when something went wrong, or right.
 
-<b>Currently Impossible Features</b>:
-
-* set focus to search bar via hotkey (e.g. on Ctrl+Shift+F)
-	* blocked by https://bugzilla.mozilla.org/show_bug.cgi?id=1502713
-
 <!-- NOTE: AMO keeps line breaks within paragraphs ... -->
 
 
@@ -31,11 +28,32 @@ I am happy to receive feedback or contributions on this. This is a (currently sh
 * update the screenshot with active tab and counter (and/or add more screenshots)
 
 
-## Development builds -- [![](https://ci.appveyor.com/api/projects/status/github/NiklasGollenstede/tst-search?svg=true)](https://ci.appveyor.com/project/NiklasGollenstede/tst-search)
+# TODO
+
+* for/before AMO listing (/the README)
+    * add disclaimer: this is a fairly young extension
+    * state: does not mess with FF tabs, only affects how TST displays them (and is thus pretty safe to use, even in beta)
+    * write the short description / summary
+    * maybe rework the entire listing:
+        * short description
+        * features
+        * more screenshots
+        * clear prompt to review the settings
+    * privacy policy
+        * currently does not send anything
+            * except on dev build the update poll once a day, which isn't analyzed at all, and can be disabled in FF
+            * will never send any tab content, URLs or search terms
+                * *maybe*: It is possible, yet unlikely, that ... . But should there would be a clear notification of any changes in that direction, before they would take effect.
+    * add (badge) link to AMO listing
+
+
+## Development builds -- <sub>[![](https://ci.appveyor.com/api/projects/status/github/NiklasGollenstede/tst-search?svg=true)](https://ci.appveyor.com/project/NiklasGollenstede/tst-search)</sub>
 
 Development builds are automatically created on every commit with [appveyor](https://ci.appveyor.com/project/NiklasGollenstede/tst-search/history) and [released](https://github.com/NiklasGollenstede/tst-search/releases) on GitHub.\
-These builds use a different id (`-dev` suffix), so they are installed as an additional extension and do not replace the release version. This means that:
- * you probably want to disable the release version while the development version is active
+To install them, go to [releases](https://github.com/NiklasGollenstede/tst-search/releases), under `Latest release` > "Assets" click `*-an.fx.xpi`, click allow and install; they will then update automatically.
+
+These builds use a different id (`-dev` suffix), so they are installed as a separate extension (from the release version) and do not replace it upon installation. This means that:
+ * you probably want to disable the release version while the development version is active, and vice versa
  * any options set are managed individually (so pre-release versions can't mess with your settings)
  * they never update to release versions, but
     * they update themselves to the latest development version (once a day, or when clicking `about:addons` > ⚙ > "Check for Updates")

src/background/index.js

@@ -1,9 +1,11 @@
 (function(global) { 'use strict'; define(async ({ // This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-	'node_modules/web-ext-utils/browser/': { manifest, Runtime, Windows, Tabs, },
+	'node_modules/web-ext-utils/browser/': { manifest, Commands, BrowserAction, Runtime, Tabs, Windows, },
 	'node_modules/web-ext-utils/browser/messages': messages,
+	'node_modules/web-ext-utils/loader/views': { getViews, },
 	'node_modules/web-ext-utils/utils/notify': notify,
 	'node_modules/es6lib/functional': { debounce, },
 	'common/options': options,
+	'./util': { updateCommand, },
 	tstApi,
 	require,
 }) => {
@@ -63,7 +65,7 @@ const classes = {
 };
 /**@type{{ tabs: Tab[] & { byId: Map<number, Tab>, }, windowId: number, } | null}*/ let cache = null;
 /**@type{() => undefined}*/ const queueClearCache = debounce(() => { cache = null; }, 30e3);
-/**@type{Record<number, { tabId: number, }>}*/ const actives = { __proto__: null, };
+/**@type{Record<number, { tabId: number, term: string, }>}*/ const windowStates = { __proto__: null, };
 
 /**
  * Does the actual search on the tabs in a window. Called from the panel via messaging.
@@ -83,19 +85,19 @@ const classes = {
  *                                              and making it the target of `focusActiveTab`. The active tab's ID is saved per window,
  *                                              and maintained if it still matches the search, otherwise the next matching tab is selected.
  *                                              Then iff `.seek` is `true` the next next, iff `false` the previous matching tab is activated.
- * @returns { { matches: number, } & ({ index: number, } | { cleared: true, } | { failed: true, }) } The number of search `matches`, plus either:
+ * @returns { Promise<{ matches: number, } & ({ index: number, } | { cleared: true, } | { failed: true, })> } The number of search `matches`, plus either:
  *                                              * if `term` was empty: `cleared: true`;
  *                                              * on search success: the active tab's index (or `-1`);
  *                                              * or on any failure: `failed: true`.
  */
 async function doSearch({
-	windowId = this?.windowId, // eslint-disable-line no-invalid-this
+	windowId = this?.windowId || -1, // eslint-disable-line no-invalid-this
 	term = '', matchCase = false, wholeWord = false, regExp = false,
 	fieldsPrefix = !!options.search.children.fieldsPrefix.value?.[0],
 	fieldsDefault = options.search.children.fieldsPrefix.value?.[1]?.split?.(' ') || [ 'title', 'url', ],
 	cached = false, seek = undefined,
 } = { }) { try {
-	windowId != null || (windowId = (await Windows.getCurrent()).id);
+	(windowId != null && windowId !== -1) || (windowId = (await Windows.getCurrent()).id);
 	debug && console.info('TST Search: doSearch', windowId, this, ...arguments); // eslint-disable-line no-invalid-this
 
 	// save search flags
@@ -106,9 +108,9 @@ async function doSearch({
 	// clear previous search on empty term
 	if (!term) {
 		TST.removeTabState({ tabs: '*', state: [ ].concat(...Object.values(classes)), }).catch(onTstError);
-		cache = null; delete actives[windowId];
+		cache = null; delete windowStates[windowId];
 		return { matches: 0, cleared: true, };
-	}
+	} term += '';
 
 	// pick tab properties to search
 	const fields = fieldsDefault; if (fieldsPrefix) {
@@ -169,18 +171,18 @@ async function doSearch({
 
 	// determine active tab
 	const matching = Array.from(result.matching);
-	const active = actives[windowId] || (actives[windowId] = { tabId: -1, });
-	if (matching.length === 0) { active.tabId = -1; }
-	else if (!tabs.byId.has(active.tabId)) { active.tabId = matching[0].id; }
-	else if (result.matching.has(tabs.byId.get(active.tabId))) { void 0; }
-	else {
-		if (matching.length === 1) { active.tabId = matching[0]; } const prev = tabs.byId.get(active.tabId);
-		active.tabId = (matching.find(tab => tab.index > prev.index) || matching[0]).id;
+	const state = windowStates[windowId] || (windowStates[windowId] = { tabId: -1, });
+	state.term = term;
+	if (matching.length === 0) { state.tabId = -1; }
+	else if (!tabs.byId.get(state.tabId)) { state.tabId = matching[0].id; }
+	else if (!result.matching.has(tabs.byId.get(state.tabId))) {
+		const prev = tabs.byId.get(state.tabId);
+		state.tabId = (matching.find(tab => tab.index > prev.index) || matching[0]).id;
 	}
 	if (typeof seek === 'boolean') { if (matching.length > 1) {
-		const current = matching.indexOf(tabs.byId.get(active.tabId));
-		if (seek) { active.tabId = matching[current + 1 < matching.length ? current + 1 : 0].id; }
-		else      { active.tabId = matching[current - 1 >= 0              ? current - 1 : matching.length - 1].id; }
+		const current = matching.indexOf(tabs.byId.get(state.tabId));
+		if (seek) { state.tabId = matching[current + 1 < matching.length ? current + 1 : 0].id; }
+		else      { state.tabId = matching[current - 1 >= 0              ? current - 1 : matching.length - 1].id; }
 	} }
 
 	// apply tab states
@@ -193,29 +195,36 @@ async function doSearch({
 			state => classes[state].length && result[state].size
 			&& TST.addTabState({ tabs: Array.from(result[state], _=>_.id), state: classes[state], })
 		),
-		typeof seek === 'boolean' && active.tabId >= 0 && TST.scroll({ tab: active.tabId, }).catch(onTstError), // This throws (if the target tab is collapsed?). Also, collapsed tabs aren't scrolled to (the parent).
-		active.tabId >= 0 && TST.addTabState({ tabs: [ active.tabId, ], state: classes.active, }),
+		typeof seek === 'boolean' && state.tabId >= 0 && TST.scroll({ tab: state.tabId, }).catch(onTstError), // This throws (if the target tab is collapsed?). Also, collapsed tabs aren't scrolled to (the parent).
+		state.tabId >= 0 && TST.addTabState({ tabs: [ state.tabId, ], state: classes.active, }),
 	]));
 
-	return ((cache || { }).result = { matches: result.matching.size, index: matching.indexOf(tabs.byId.get(active.tabId)), });
+	return ((cache || { }).result = { matches: result.matching.size, index: matching.indexOf(tabs.byId.get(state.tabId)), });
 
 } catch (error) { notify.error('Search failed!', error); return { matches: 0, failed: true, }; } }
-messages.addHandler(doSearch);
+
+
+async function getTerm({
+	windowId = this?.windowId || -1, // eslint-disable-line no-invalid-this
+} = { }) { try {
+	windowId != null && windowId !== -1 || (windowId = (await Windows.getCurrent()).id);
+	debug && console.info('TST Search: getTerm', windowId, this, ...arguments); // eslint-disable-line no-invalid-this
+	return windowStates[windowId]?.term;
+} catch (error) { notify.error('Tab Focus Failed', error); } return null; }
 
 
 async function focusActiveTab({
-	windowId = this?.windowId, // eslint-disable-line no-invalid-this
+	windowId = this?.windowId || -1, // eslint-disable-line no-invalid-this
 } = { }) { try {
-	windowId != null || (windowId = (await Windows.getCurrent()).id);
+	windowId != null && windowId !== -1 || (windowId = (await Windows.getCurrent()).id);
 	debug && console.info('TST Search: focusActiveTab', windowId, this, ...arguments); // eslint-disable-line no-invalid-this
-	const tabId = actives[windowId] && actives[windowId].tabId;
+	const tabId = windowStates[windowId]?.tabId;
 	tabId >= 0 && (await Tabs.update(tabId, { active: true, }));
 	return tabId;
 } catch (error) { notify.error('Tab Focus Failed', error); } return null; }
-messages.addHandler(focusActiveTab);
 
 
-{ // let panel instances know about `options.panel.children.*.value`
+const { getOptions, awaitOptions, } = (() => { // let panel instances know about `options.panel.children.*.value`
 	function getOptions() {
 		return Object.fromEntries(Object.entries(options.panel.children).map(pair => {
 			pair[1] = pair[1].value; return pair;
@@ -227,19 +236,47 @@ messages.addHandler(focusActiveTab);
 		callbacks.forEach(_=>_(opts));
 		callbacks.clear();
 	});
-	messages.addHandlers({ getOptions, awaitOptions() {
+	return { async getOptions() {
+		return getOptions();
+	}, awaitOptions() {
 		return new Promise(resolve => callbacks.add(resolve));
-	}, });
-}
+	}, };
+})();
+
+
+const RPC = { doSearch, getTerm, focusActiveTab, getOptions, awaitOptions, };
+messages.addHandlers(RPC);
+
+
+Commands.onCommand.addListener(async function onCommand(command) { try { {
+	debug && console.info('TST: onCommand', command);
+} switch (command.replace(/_\d$/, '')) {
+	case 'globalFocusKey': {
+		// can't focus sidebar, so open/focus the browserAction popup
+		/**@type{Window}*/ const panel = getViews().find(_=>_.name === 'panel')?.view;
+		/**@type{HTMLInputElement}*/ const input = panel?.document.querySelector('#term');
+		if (input) {
+			if (input.matches(':focus')) {
+				// can't listen to ESC press, so clear on redundant focus command
+				input.value = ''; input.dispatchEvent(new panel.Event('input'));
+			} else {
+				panel.close(); (await BrowserAction.openPopup()); // focus
+			}
+		} else {
+			(await BrowserAction.openPopup());
+		}
+	} break;
+} } catch (error) { notify.error('Command Failed', error); } });
+options.search.children.globalFocusKey.whenChange(values => updateCommand('globalFocusKey', 1, values));
 
 
 Object.assign(global, { // for debugging
 	options,
-	TST, register, unregister,
+	TST, register, unregister, RPC,
 	doSearch, focusActiveTab,
 	Browser: require('node_modules/web-ext-utils/browser/'),
 });
 
-return { TST, register, unregister, };
+return { TST, register, unregister, RPC, };
 
 }); })(this);

src/background/tst-api.js

@@ -43,7 +43,7 @@ function tstAPI({ getManifest, methods = [ ], events = { __proto__: null, }, onE
 		name.replace(/-([a-z])/g, (_, l) => l.toUpperCase()),
 		(options) => {
 			API.debug && console.info(ownName +': sendMessageExternal', TST_ID, { ...options, type: name, });
-			return global.browser.runtime.sendMessage(TST_ID, { ...options, type: name, });
+			return global.browser.runtime.sendMessage(TST_ID, { ...options, type: name, }); // It would be nice if connection errors were distinguishable from errors on TST's side ...
 		},
 	]));
 

src/background/util.js

@@ -0,0 +1,21 @@
+(function(global) { 'use strict'; const factory = function util(exports) { // This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+async function updateCommand(name, count, values) {
+	const commands = (await global.browser.commands.getAll());
+	for (let i = 0; i < count; ++i) { // `value.length` may be smaller than `count`
+		const id = name + (i ? '_'+ i : ''), command = commands.find(_=>_.name === id);
+		command.shortcut = values[i] || null;
+		if (command.shortcut) { try {
+			(await global.browser.commands.update(command));
+		} catch (error) {
+			global.browser.commands.reset(id); throw error;
+		} } else {
+			global.browser.commands.reset(id); // can't remove, so reset instead, which removes if default is unset
+		}
+	}
+}
+
+return { updateCommand, };
+
+}; if (typeof define === 'function' /* global define */ && define.amd) { define([ 'exports', ], factory); } else { const exp = { }, result = factory(exp) || exp; global[factory.name] = result; } })(this);

src/common/options.js

@@ -140,6 +140,14 @@ const model = {
 		expanded: true,
 		description: ``,
 		default: true, children: {
+			globalFocusKey: {
+				title: 'Focus Search Bar Hotkey',
+				description: `Browser-wide hotkey to focus the the search bar.<br>
+				NOTE: Firefox currently does not allow extensions to focus (elements in) their sidebars (see <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1502713">Firefox bug 1502713</a>). So for now, this extension instead opens a small panel at the top of the window with a copy of the search bar. Since <code>Esc</code> keypresses are also unavailable while a panel is open, pressing this hotkey clears the search, when pressed while the panel has focus.`,
+				default: 'Ctrl + Shift + F',
+				minLength: 0, maxLength: 1,
+				input: { type: 'command', default: 'Ctrl + Shift + F', },
+			},
 			fieldsPrefix: {
 				title: 'Tab Property Prefixes',
 				description: String.raw`By default ${manifest.name} will look for the search term, according to the flags set, in the tab's title (the text displayed in the tooltip when holding the mouse cursor the tab) and the URL (the web address displayed at the center top of the window when the tab is active). This should do for most users most of the time.<br>