background.mjs

import {
  classifyServiceRequest,
  classifyStyleRequest,
  createPageScope,
  createTabTaskQueue,
} from "./service-scanner.mjs";

const MAX_REQUESTS_PER_TAB = 100;
const enqueue = createTabTaskQueue();
const scope = createPageScope();
/** Style documents seen per tab, keyed by the origin that served them. */
const stylesByTab = new Map();
/**
 * The candidate most recently written for each tab. Panning a slippy map turns
 * every tile into the same candidate, so without this each one would queue a
 * `storage.session` read just to discover there is nothing to write.
 */
const lastWritten = new Map();

function candidateKey(service) {
  return [service.url, service.layer ?? "", service.styleUrl ?? ""].join("\u0000");
}

function forgetTab(tabId) {
  stylesByTab.delete(tabId);
  lastWritten.delete(tabId);
}

function rememberStyle(tabId, style) {
  let origins = stylesByTab.get(tabId);
  if (!origins) {
    origins = new Map();
    stylesByTab.set(tabId, origins);
  }
  origins.set(style.origin, style.url);
}

function runForTab(tabId, task) {
  void enqueue(tabId, task).catch((error) => {
    // A failed write leaves the stored list unknown, so drop the shortcut and
    // let the next matching request try again.
    lastWritten.delete(tabId);
    console.warn("GeoLibre could not update detected services.", error);
  });
}

/**
 * Fill in the style of vector tilesets already stored for this tab. Tiles and
 * their style are separate requests and either can finish first, so a tileset
 * recorded before its style arrived would otherwise stay unusable: without the
 * style's source layers, Add Data cannot resolve the layer.
 */
async function applyStyleToStored(tabId, style) {
  const key = `services:${tabId}`;
  const stored = await chrome.storage.session.get(key);
  const existing = Array.isArray(stored[key]) ? stored[key] : [];
  let changed = false;
  const next = existing.map((entry) => {
    if (entry.format !== "Vector tiles" || entry.styleUrl) return entry;
    if (new URL(entry.url).origin !== style.origin) return entry;
    changed = true;
    return { ...entry, styleUrl: style.url };
  });
  if (!changed) return;
  lastWritten.set(tabId, candidateKey(next[0]));
  await chrome.storage.session.set({ [key]: next });
}

// The page boundary is drawn when a navigation starts, not when it finishes,
// so the incoming page's own early requests are not retired along with the
// outgoing page's.
chrome.webRequest.onBeforeRequest.addListener(
  ({ tabId, type }) => {
    if (tabId >= 0 && type === "main_frame") scope.beginPage(tabId);
  },
  { urls: ["http://*/*", "https://*/*"] },
);

chrome.webRequest.onCompleted.addListener(
  ({ tabId, url, type, documentId }) => {
    if (tabId < 0) return;
    if (type === "main_frame") {
      scope.startPage(tabId);
      forgetTab(tabId);
      runForTab(tabId, () => chrome.storage.session.remove(`services:${tabId}`));
    }
    if (!scope.accepts(tabId, documentId)) return;
    const style = classifyStyleRequest(url);
    if (style) {
      rememberStyle(tabId, style);
      const generation = scope.generation(tabId);
      runForTab(tabId, async () => {
        if (scope.generation(tabId) !== generation) return;
        await applyStyleToStored(tabId, style);
      });
    }
    const service = classifyServiceRequest(url);
    if (!service) return;
    // A vector tileset is only addable with the source layers its style names.
    if (service.format === "Vector tiles") {
      service.styleUrl = stylesByTab.get(tabId)?.get(new URL(service.url).origin) ?? null;
    }
    // Identical to the entry already at the head of the list: nothing to write.
    const key = candidateKey(service);
    if (lastWritten.get(tabId) === key) return;
    lastWritten.set(tabId, key);
    const generation = scope.generation(tabId);
    runForTab(tabId, async () => {
      // The tab may have navigated while this write waited its turn.
      if (scope.generation(tabId) !== generation) {
        lastWritten.delete(tabId);
        return;
      }
      const storageKey = `services:${tabId}`;
      const stored = await chrome.storage.session.get(storageKey);
      const existing = Array.isArray(stored[storageKey]) ? stored[storageKey] : [];
      // One service can serve several layers, so an entry is a duplicate only
      // when it repeats the layer too — and a repeat that has since picked up a
      // style still replaces the entry that lacked one.
      const same = (entry) =>
        Boolean(entry) && entry.url === service.url && (entry.layer ?? null) === service.layer;
      const next = [service, ...existing.filter((entry) => !same(entry))].slice(
        0,
        MAX_REQUESTS_PER_TAB,
      );
      await chrome.storage.session.set({ [storageKey]: next });
    });
  },
  { urls: ["http://*/*", "https://*/*"] },
);

chrome.tabs.onRemoved.addListener((tabId) => {
  scope.forget(tabId);
  forgetTab(tabId);
  runForTab(tabId, () => chrome.storage.session.remove(`services:${tabId}`));
});