Merge remote-tracking branch 'origin/master' into feat/move-tab-to-existing-window

Author: IdoKendo

CHANGELOG.md

@@ -1,7 +1,33 @@
+2.1.2 (2024-04-03)
+
+- Better fix for Vomnibar doesn't always list tabs by recency.
+  ([#4368](https://github.com/philc/vimium/issues/4368))
+- Add a workaround to make link hints work on Github Enterprise.
+  ([#4446](https://github.com/philc/vimium/issues/4446))
+- Fix position=end is ignored in createTab command
+  ([#4450](https://github.com/philc/vimium/issues/4450))
+
+2.1.1 (2024-03-29)
+
+- Fix exclusion rule popup not working. ([#4447](https://github.com/philc/vimium/issues/4447))
+
+2.1.0 (2024-03-27)
+
+- Fix Vomnibar doesn't always list tabs by recency.
+  ([#4368](https://github.com/philc/vimium/issues/4368))
+- Better domain detection in the Vomnibar ([#3268](https://github.com/philc/vimium/issues/3268))
+- Exclude keys based on the top frame URL, not a subframe's URL. This fixes many cases where the
+  excluded keys feature didn't seem to work. ([#4402](https://github.com/philc/vimium/issues/4402))
+- After selecting a link, if ESC is pressed, mouse out of the link. With this, Wikipedia's and
+  Github's link preview popups can be dismissed after following a link.
+  ([#3073](https://github.com/philc/vimium/issues/3073))
+- Fix link hints do not appear for links inside of github's popups. This fix is available on Chrome
+  114+, and soon Firefox. ([#4408](https://github.com/philc/vimium/issues/4408))
+
 2.0.5, 2.0.6 (2023-11-06)
 
 - Fix bug where "esc" wouldn't unfocus a textarea like it should.
-  ([#4336](https://github.com/philc/vimium/issues/4336)),
+  ([#4336](https://github.com/philc/vimium/issues/4336))
 - Fix passNextKey command.
 
 2.0.4 (2023-10-19)

background_scripts/background.js

@@ -1,6 +1,7 @@
 import "../lib/utils.js";
 import "../lib/settings.js";
 import "../lib/url_utils.js";
+import "../background_scripts/tab_recency.js";
 import "../background_scripts/bg_utils.js";
 import "../background_scripts/commands.js";
 import "../background_scripts/exclusions.js";

background_scripts/bg_utils.js

@@ -1,77 +1,3 @@
-const TIME_DELTA = 500; // Milliseconds.
-
-// TabRecency associates a logical timestamp with each tab id. These are used to provide an initial
-// recency-based ordering in the tabs vomnibar (which allows jumping quickly between
-// recently-visited tabs).
-class TabRecency {
-  constructor() {
-    this.timestamp = 1;
-    this.current = -1;
-    this.cache = {};
-    this.lastVisited = null;
-    this.lastVisitedTime = null;
-
-    chrome.tabs.onActivated.addListener((activeInfo) => this.register(activeInfo.tabId));
-    chrome.tabs.onRemoved.addListener((tabId) => this.deregister(tabId));
-
-    chrome.tabs.onReplaced.addListener((addedTabId, removedTabId) => {
-      this.deregister(removedTabId);
-      this.register(addedTabId);
-    });
-
-    if (chrome.windows != null) {
-      chrome.windows.onFocusChanged.addListener((wnd) => {
-        if (wnd !== chrome.windows.WINDOW_ID_NONE) {
-          chrome.tabs.query({ windowId: wnd, active: true }, (tabs) => {
-            if (tabs[0]) {
-              this.register(tabs[0].id);
-            }
-          });
-        }
-      });
-    }
-  }
-
-  register(tabId) {
-    const currentTime = new Date();
-    // Register tabId if it's been visited for at least @timeDelta ms. Tabs which are visited only
-    // for a very-short time (e.g. those passed through with `5J`) aren't registered as visited.
-    if ((this.lastVisitedTime != null) && (TIME_DELTA <= (currentTime - this.lastVisitedTime))) {
-      this.cache[this.lastVisited] = ++this.timestamp;
-    }
-
-    this.current = this.lastVisited = tabId;
-    this.lastVisitedTime = currentTime;
-  }
-
-  deregister(tabId) {
-    if (tabId === this.lastVisited) {
-      // Ensure we don't register this tab, since it's going away.
-      this.lastVisited = this.lastVisitedTime = null;
-    }
-    delete this.cache[tabId];
-  }
-
-  // Recently-visited tabs get a higher score (except the current tab, which gets a low score).
-  recencyScore(tabId) {
-    if (!this.cache[tabId]) {
-      this.cache[tabId] = 1;
-    }
-    if (tabId === this.current) {
-      return 0.0;
-    } else {
-      return this.cache[tabId] / this.timestamp;
-    }
-  }
-
-  // Returns a list of tab Ids sorted by recency, most recent tab first.
-  getTabsByRecency() {
-    const tabIds = Object.keys(this.cache || {});
-    tabIds.sort((a, b) => this.cache[b] - this.cache[a]);
-    return tabIds.map((tId) => parseInt(tId));
-  }
-}
-
 const BgUtils = {
   tabRecency: new TabRecency(),
 
@@ -91,21 +17,9 @@ const BgUtils = {
   async getFirefoxVersion() {
     return globalThis.browser ? (await browser.runtime.getBrowserInfo()).version : null;
   },
-
-  escapedEntities: {
-    '"': "&quots;",
-    "&": "&amp;",
-    "'": "&apos;",
-    "<": "&lt;",
-    ">": "&gt;",
-  },
-
-  escapeAttribute(string) {
-    return string.replace(/["&'<>]/g, (char) => BgUtils.escapedEntities[char]);
-  },
 };
 
-BgUtils.TIME_DELTA = TIME_DELTA; // Referenced by our tests.
+BgUtils.tabRecency.init();
 
 Object.assign(globalThis, {
   BgUtils,

background_scripts/completion.js

@@ -479,6 +479,7 @@ class DomainCompleter {
 // If the query is empty, then return a list of open tabs, sorted by recency.
 class TabCompleter {
   async filter({ queryTerms }) {
+    await BgUtils.tabRecency.init();
     // We search all tabs, not just those in the current window.
     const tabs = await chrome.tabs.query({});
     const results = tabs.filter((tab) => RankingUtils.matches(queryTerms, tab.url, tab.title));

background_scripts/main.js

@@ -202,8 +202,11 @@ const BackgroundCommands = {
         request.urls = [request.url];
       } else {
         // Otherwise, if we have a registryEntry containing URLs, then use them.
-        const urlList = request.registryEntry.optionList
-          .filter(async (opt) => await UrlUtils.isUrl(opt));
+        // TODO(philc): This would be clearer if we try to detect options (a=b) rather than URLs,
+        // because the syntax for options is well defined ([a-zA-Z]+=\S+).
+        const promises = request.registryEntry.optionList.map((opt) => UrlUtils.isUrl(opt));
+        const isUrl = await Promise.all(promises);
+        const urlList = request.registryEntry.optionList.filter((_, i) => isUrl[i]);
         if (urlList.length > 0) {
           request.urls = urlList;
         } else {
@@ -355,10 +358,13 @@ const BackgroundCommands = {
     await removeTabsRelative("both", request);
   },
 
-  visitPreviousTab({ count, tab }) {
-    const tabIds = BgUtils.tabRecency.getTabsByRecency().filter((tabId) => tabId !== tab.id);
+  async visitPreviousTab({ count, tab }) {
+    await BgUtils.tabRecency.init();
+    let tabIds = BgUtils.tabRecency.getTabsByRecency();
+    tabIds = tabIds.filter((tabId) => tabId !== tab.id);
     if (tabIds.length > 0) {
-      selectSpecificTab({ id: tabIds[(count - 1) % tabIds.length] });
+      const id = tabIds[(count - 1) % tabIds.length];
+      selectSpecificTab({ id });
     }
   },
 

background_scripts/tab_operations.js

@@ -12,7 +12,6 @@ async function openUrlInCurrentTab(request) {
   // (like github.com, developer.mozilla.org) will raise an error when we try to run this code. See
   // https://github.com/philc/vimium/issues/4331.
   if (UrlUtils.hasJavascriptPrefix(request.url)) {
-    const tabId = request.tabId;
     const scriptingArgs = {
       target: { tabId: request.tabId },
       func: (text) => {
@@ -87,7 +86,8 @@ async function openUrlInNewTab(request, callback) {
 
   tabConfig.openerTabId = request.tab.id;
 
-  // clean position and active, so following `openUrlInNewTab(request)` will create a tab just next to this new tab
+  // clean position and active, so following `openUrlInNewTab(request)` will create a tab just next
+  // to this new tab
   return chrome.tabs.create(
     tabConfig,
     (tab) => callback(Object.assign(request, { tab, tabId: tab.id, position: "", active: false })),

background_scripts/tab_recency.js

@@ -0,0 +1,139 @@
+// TabRecency associates an integer with each tab id representing how recently it has been accessed.
+// The order of tabs as tracked by TabRecency is used to provide a recency-based ordering in the
+// tabs vomnibar.
+//
+// The values are persisted to chrome.storage.session so that they're not lost when the extension's
+// background page is unloaded.
+//
+// Callers must await TabRecency.init before calling recencyScore or getTabsByRecency.
+//
+// In theory, the browser's tab.lastAccessed timestamp field should allow us to sort tabs by
+// recency, but in practice it does not work across several edge cases. See the comments on #4368.
+class TabRecency {
+  constructor() {
+    this.counter = 1;
+    this.tabIdToCounter = {};
+    this.loaded = false;
+    this.queuedActions = [];
+  }
+
+  // Add listeners to chrome.tabs, and load the index from session storage.
+  async init() {
+    if (this.initPromise) {
+      await this.initPromise;
+      return;
+    }
+    let resolveFn;
+    this.initPromise = new Promise((resolve, _reject) => {
+      resolveFn = resolve;
+    });
+
+    chrome.tabs.onActivated.addListener((activeInfo) => {
+      this.queueAction("register", activeInfo.tabId);
+    });
+    chrome.tabs.onRemoved.addListener((tabId) => {
+      this.queueAction("deregister", tabId);
+    });
+
+    chrome.tabs.onReplaced.addListener((addedTabId, removedTabId) => {
+      this.queueAction("deregister", removedTabId);
+      this.queueAction("register", addedTabId);
+    });
+
+    chrome.windows.onFocusChanged.addListener(async (windowId) => {
+      if (windowId == chrome.windows.WINDOW_ID_NONE) return;
+      const tabs = await chrome.tabs.query({ windowId, active: true });
+      if (tabs[0]) {
+        this.queueAction("register", tabs[0].id);
+      }
+    });
+
+    await this.loadFromStorage();
+    while (this.queuedActions.length > 0) {
+      const [action, tabId] = this.queuedActions.shift();
+      this.handleAction(action, tabId);
+    }
+    this.loaded = true;
+    resolveFn();
+  }
+
+  // Loads the index from session storage.
+  async loadFromStorage() {
+    const tabsPromise = chrome.tabs.query({});
+    const storagePromise = chrome.storage.session.get("tabRecency");
+    const [tabs, storage] = await Promise.all([tabsPromise, storagePromise]);
+    if (storage.tabRecency == null) return;
+
+    let maxCounter = 0;
+    for (const counter of Object.values(storage.tabRecency)) {
+      if (maxCounter < counter) maxCounter = counter;
+    }
+    if (this.counter < maxCounter) {
+      this.counter = maxCounter;
+    }
+
+    this.tabIdToCounter = Object.assign({}, storage.tabRecency);
+
+    // Remove any tab IDs which aren't currently loaded.
+    const tabIds = new Set(tabs.map((t) => t.id));
+    for (const id in this.tabIdToCounter) {
+      if (!tabIds.has(parseInt(id))) {
+        delete this.tabIdToCounter[id];
+      }
+    }
+  }
+
+  async saveToStorage() {
+    await chrome.storage.session.set({ tabRecency: this.tabIdToCounter });
+  }
+
+  // - action: "register" or "unregister".
+  queueAction(action, tabId) {
+    if (!this.loaded) {
+      this.queuedActions.push([action, tabId]);
+    } else {
+      this.handleAction(action, tabId);
+    }
+  }
+
+  // - action: "register" or "unregister".
+  handleAction(action, tabId) {
+    if (action == "register") {
+      this.register(tabId);
+    } else if (action == "deregister") {
+      this.deregister(tabId);
+    } else {
+      throw new Error(`Unexpected action type: ${action}`);
+    }
+  }
+
+  register(tabId) {
+    this.counter++;
+    this.tabIdToCounter[tabId] = this.counter;
+    this.saveToStorage();
+  }
+
+  deregister(tabId) {
+    delete this.tabIdToCounter[tabId];
+    this.saveToStorage();
+  }
+
+  // Recently-visited tabs get a higher score (except the current tab, which gets a low score).
+  recencyScore(tabId) {
+    if (!this.loaded) throw new Error("TabRecency hasn't yet been loaded.");
+    const tabCounter = this.tabIdToCounter[tabId];
+    const isCurrentTab = tabCounter == this.counter;
+    if (isCurrentTab) return 0;
+    return (tabCounter ?? 1) / this.counter; // tabCounter may be null.
+  }
+
+  // Returns a list of tab Ids sorted by recency, most recent tab first.
+  getTabsByRecency() {
+    if (!this.loaded) throw new Error("TabRecency hasn't yet been loaded.");
+    const ids = Object.keys(this.tabIdToCounter);
+    ids.sort((a, b) => this.tabIdToCounter[b] - this.tabIdToCounter[a]);
+    return ids.map((id) => parseInt(id));
+  }
+}
+
+Object.assign(globalThis, { TabRecency });

content_scripts/link_hints.js

@@ -409,6 +409,25 @@ class LinkHintsMode {
       { id: "vimiumHintMarkerContainer", className: "vimiumReset" },
     );
 
+    // TODO(philc): 2024-03-27 Remove this hasPopoverSupport check once Firefox has popover support.
+    // Also move this CSS into vimium.css.
+    const hasPopoverSupport = this.hintMarkerContainingDiv.showPopover != null;
+    if (hasPopoverSupport) {
+      this.hintMarkerContainingDiv.popover = "manual";
+      this.hintMarkerContainingDiv.showPopover();
+      Object.assign(this.hintMarkerContainingDiv.style, {
+        top: 0,
+        left: 0,
+        position: "absolute",
+        // This display: block is required to override Github Enterprise's CSS circa 2024-04-01. See
+        // #4446.
+        display: "block",
+        width: "100%",
+        height: "100%",
+        overflow: "visible",
+      });
+    }
+
     this.setIndicator();
   }
 

content_scripts/vimium.css

@@ -73,6 +73,10 @@ tbody.vimiumReset {
 
 /* Linkhints CSS */
 
+div#vimiumHintMarkerContainer {
+  pointer-events: none;
+}
+
 div.internalVimiumHintMarker {
   position: absolute;
   display: block;

manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Vimium",
-  "version": "2.0.6",
+  "version": "2.1.2",
   "description": "The Hacker's Browser. Vimium provides keyboard shortcuts for navigation and control in the spirit of Vim.",
   "icons": { "16": "icons/icon16.png", "48": "icons/icon48.png", "128": "icons/icon128.png" },
   "minimum_chrome_version": "105.0",