serviceWorker.js

import {
  handleInstancesAndConstructRules,
  changeInstance,
  changeDefaultInstance,
  getCurrentInstanceUrl,
} from "./utils.js";

const instance24hAlarm = "update-instances-24h";

function getAndUpdateInstances() {
  return new Promise((resolvePromise, rejectPromise) => {
    chrome.storage.local.get(["services"], async (result) => {
      const servicesList = result.services;
      const instancesResponse = await fetch(
        "https://raw.githubusercontent.com/efficientwrite/farside/refs/heads/main/services.json",
      );
      const instancesJson = await instancesResponse.json();
      const instanceJsonMap = {};
      instancesJson.forEach((serviceObject) => {
        let { type, instances } = serviceObject;
        if (type === "piped") {
          instances = instances.map((instance) => instance.split("|")?.[0]);
        }
        instanceJsonMap[type] = instances.filter(
          (instance) => !instance.includes(".onion"),
        );
      });
      servicesList.forEach((service) => {
        const instances = instanceJsonMap[service.serviceName];
        service["instances"] = instances;
      });
      chrome.storage.local.set({ services: servicesList });
      resolvePromise(servicesList);
    });
  });
}

function updateRules(services) {
  const rules = services
    .filter(
      (service) => service.instances?.length > 0 && (service.enabled ?? true),
    )
    .flatMap((service) => {
      return handleInstancesAndConstructRules(service);
    });
  chrome.declarativeNetRequest.updateDynamicRules({
    removeRuleIds: services.flatMap((service) => service.ids),
    addRules: rules,
  });
  chrome.storage.local.set({ services });
}

chrome.alarms.onAlarm.addListener((alarm) => {
  if (alarm.name === instance24hAlarm) {
    getAndUpdateInstances();
  }
});

async function checkAndSetAlarm() {
  const alarm = await chrome.alarms.get(instance24hAlarm);

  if (!alarm) {
    chrome.alarms.create(instance24hAlarm, {
      periodInMinutes: 1440,
    });
  }
}

chrome.runtime.onInstalled.addListener(async () => {
  const result = await chrome.storage.local.get(["services"]);
  fetch(chrome.runtime.getURL("services.json"))
    .then((response) => response.json())
    .then((json) => {
      let newJson = json;
      if (result.services) {
        const jsonFromStorage = result.services;
        newJson = json.map((service) => {
          const found = jsonFromStorage.find(
            (temp) => temp.name === service.name,
          );
          if (found) return { ...service, enabled: found.enabled };
          return service;
        });
      }
      chrome.storage.local.set({ services: newJson }).then(() => {
        getAndUpdateInstances().then((services) => {
          updateRules(services);
        });
      });
    });
  checkAndSetAlarm();
});

chrome.runtime.onStartup.addListener(async () => {
  chrome.storage.local.get(["services"], async (result) => {
    if (result.services) updateRules(result.services);
  });
});

function handleCommandCallback(fn) {
  chrome.storage.local.get(["services"], async (result) => {
    const services = result.services;
    chrome.tabs.query({ currentWindow: true, active: true }, ([tab]) => {
      const serviceMatched = services?.find((item) => {
        return item.instances?.find((instance) =>
          instance.includes(new URL(tab.url).hostname),
        );
      });
      if (serviceMatched) {
        fn(tab, serviceMatched, services);
      }
    });
  });
}

function handleChangeInstanceCallback(tab, serviceMatched, services) {
  changeInstance(tab.id, tab.url, services);
}

async function handleChangeDefaultInstanceCallback(tab, serviceMatched) {
  const success = await changeDefaultInstance(serviceMatched);
  if (success) {
    const rules = await chrome.declarativeNetRequest.getDynamicRules();
    const defaultInstance = getCurrentInstanceUrl(rules, serviceMatched);
    const currentUrl = new URL(tab.url);
    chrome.tabs.update(tab.id, {
      url: `${defaultInstance.scheme}://${defaultInstance.host}${currentUrl.pathname}${currentUrl.search}`,
    });
  }
}

chrome.commands.onCommand.addListener((command) => {
  if (command === "change_instance") {
    handleCommandCallback(handleChangeInstanceCallback);
  } else if (command === "change_default_instance") {
    handleCommandCallback(handleChangeDefaultInstanceCallback);
  }
});