Release v5.2.1

2026-04-27 14:42:51 -04:00 · 2026-04-09 16:17:27 -04:00
parent 05b8456e94
commit c626aca89c
32 changed files with 5749 additions and 1320 deletions
@@ -0,0 +1,164 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { vi } from "vitest";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, "..", "..");
+
+function readRepoFile(relPath) {
+  return fs.readFileSync(path.join(repoRoot, relPath), "utf8");
+}
+
+export function loadHtml(relPath) {
+  document.open();
+  document.write(readRepoFile(relPath));
+  document.close();
+}
+
+export function loadScript(relPath) {
+  window.eval(
+    "var chrome = window.chrome || globalThis.chrome;\n" +
+      readRepoFile(relPath) +
+      "\n//# sourceURL=" +
+      relPath
+  );
+}
+
+export async function flushAsyncWork() {
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+export function triggerDomContentLoaded() {
+  document.dispatchEvent(
+    new window.Event("DOMContentLoaded", {
+      bubbles: true,
+      cancelable: true
+    })
+  );
+}
+
+function createEvent() {
+  const listeners = [];
+  return {
+    addListener(listener) {
+      listeners.push(listener);
+    },
+    trigger(...args) {
+      listeners.forEach((listener) => listener(...args));
+    },
+    listeners
+  };
+}
+
+function createStorageArea(initialState = {}) {
+  const state = { ...initialState };
+
+  function resolveGet(keys) {
+    if (keys == null) return { ...state };
+    if (Array.isArray(keys)) {
+      return keys.reduce((acc, key) => {
+        if (Object.prototype.hasOwnProperty.call(state, key)) {
+          acc[key] = state[key];
+        }
+        return acc;
+      }, {});
+    }
+    if (typeof keys === "string") {
+      return Object.prototype.hasOwnProperty.call(state, keys)
+        ? { [keys]: state[keys] }
+        : {};
+    }
+    if (typeof keys === "object") {
+      const result = { ...keys };
+      Object.keys(state).forEach((key) => {
+        result[key] = state[key];
+      });
+      return result;
+    }
+    return {};
+  }
+
+  return {
+    __state: state,
+    get: vi.fn((keys, callback) => {
+      callback(resolveGet(keys));
+    }),
+    set: vi.fn((items, callback) => {
+      Object.assign(state, items);
+      if (callback) callback();
+    }),
+    remove: vi.fn((keys, callback) => {
+      const list = Array.isArray(keys) ? keys : [keys];
+      list.forEach((key) => {
+        delete state[key];
+      });
+      if (callback) callback();
+    }),
+    clear: vi.fn((callback) => {
+      Object.keys(state).forEach((key) => delete state[key]);
+      if (callback) callback();
+    })
+  };
+}
+
+export function createChromeMock(options = {}) {
+  const syncArea = createStorageArea(options.sync ?? {});
+  const localArea = createStorageArea(options.local ?? {});
+  const tabsOnActivated = createEvent();
+  const tabsOnUpdated = createEvent();
+  const storageOnChanged = createEvent();
+
+  const chrome = {
+    runtime: {
+      lastError: null,
+      getManifest: vi.fn(() => ({
+        version: options.manifestVersion || "9.9.9"
+      })),
+      getURL: vi.fn((url) => "moz-extension://speeder/" + url)
+    },
+    storage: {
+      sync: syncArea,
+      local: localArea,
+      onChanged: storageOnChanged
+    },
+    tabs: {
+      query: vi.fn((queryInfo, callback) => {
+        callback(
+          options.tabs ??
+            [
+              {
+                id: 1,
+                active: true,
+                url: "https://example.com/watch"
+              }
+            ]
+        );
+      }),
+      sendMessage: vi.fn((tabId, message, callback) => {
+        if (callback) {
+          callback(options.sendMessageResponse ?? { speed: 1.25 });
+        }
+      }),
+      executeScript: vi.fn((tabId, details, callback) => {
+        if (callback) {
+          callback(
+            options.executeScriptResponse ?? [
+              { speed: 1.25, preferred: true }
+            ]
+          );
+        }
+      }),
+      create: vi.fn(),
+      onActivated: tabsOnActivated,
+      onUpdated: tabsOnUpdated
+    },
+    browserAction: {
+      setIcon: vi.fn()
+    }
+  };
+
+  return chrome;
+}
@@ -0,0 +1,240 @@
+const fs = require("fs");
+const path = require("path");
+const { vi } = require("vitest");
+
+const ROOT = path.resolve(__dirname, "..", "..");
+
+function clone(value) {
+  if (value === undefined) return undefined;
+  return JSON.parse(JSON.stringify(value));
+}
+
+function workspacePath(relPath) {
+  return path.join(ROOT, relPath);
+}
+
+function readWorkspaceFile(relPath) {
+  return fs.readFileSync(workspacePath(relPath), "utf8");
+}
+
+function loadHtmlFile(relPath) {
+  document.open();
+  document.write(readWorkspaceFile(relPath));
+  document.close();
+}
+
+function loadHtmlString(html) {
+  document.open();
+  document.write(html);
+  document.close();
+}
+
+function evaluateScript(relPath) {
+  const source = readWorkspaceFile(relPath);
+  window.eval(
+    `${source}\n//# sourceURL=${workspacePath(relPath).replace(/\\/g, "/")}`
+  );
+}
+
+function fireDOMContentLoaded() {
+  document.dispatchEvent(
+    new window.Event("DOMContentLoaded", {
+      bubbles: true,
+      cancelable: true
+    })
+  );
+}
+
+async function flushAsyncWork(turns) {
+  const count = turns || 2;
+  for (let i = 0; i < count; i += 1) {
+    await Promise.resolve();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+}
+
+function pickStorageValues(data, keys) {
+  if (keys == null) return clone(data || {});
+
+  if (typeof keys === "string") {
+    return { [keys]: clone(data ? data[keys] : undefined) };
+  }
+
+  if (Array.isArray(keys)) {
+    const result = {};
+    keys.forEach((key) => {
+      result[key] = clone(data ? data[key] : undefined);
+    });
+    return result;
+  }
+
+  if (typeof keys === "object") {
+    const result = clone(keys) || {};
+    Object.keys(keys).forEach((key) => {
+      if (data && Object.prototype.hasOwnProperty.call(data, key)) {
+        result[key] = clone(data[key]);
+      }
+    });
+    return result;
+  }
+
+  return {};
+}
+
+function createChromeEvent() {
+  const listeners = [];
+  return {
+    addListener(listener) {
+      listeners.push(listener);
+    },
+    removeListener(listener) {
+      const index = listeners.indexOf(listener);
+      if (index >= 0) {
+        listeners.splice(index, 1);
+      }
+    },
+    hasListener(listener) {
+      return listeners.includes(listener);
+    },
+    emit(...args) {
+      listeners.slice().forEach((listener) => listener(...args));
+    },
+    listeners
+  };
+}
+
+function createStorageArea(areaName, initialData, onChangedEvent) {
+  let data = clone(initialData) || {};
+
+  function emitChanges(changes) {
+    if (changes && Object.keys(changes).length > 0) {
+      onChangedEvent.emit(changes, areaName);
+    }
+  }
+
+  return {
+    get: vi.fn((keys, callback) => {
+      if (callback) callback(pickStorageValues(data, keys));
+    }),
+    set: vi.fn((items, callback) => {
+      const nextItems = items || {};
+      const changes = {};
+
+      Object.keys(nextItems).forEach((key) => {
+        const oldValue = clone(data[key]);
+        const newValue = clone(nextItems[key]);
+        data[key] = newValue;
+        changes[key] = { oldValue, newValue };
+      });
+
+      emitChanges(changes);
+      if (callback) callback();
+    }),
+    remove: vi.fn((keys, callback) => {
+      const list = Array.isArray(keys) ? keys : [keys];
+      const changes = {};
+
+      list.forEach((key) => {
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+          changes[key] = {
+            oldValue: clone(data[key]),
+            newValue: undefined
+          };
+          delete data[key];
+        }
+      });
+
+      emitChanges(changes);
+      if (callback) callback();
+    }),
+    clear: vi.fn((callback) => {
+      const changes = {};
+      Object.keys(data).forEach((key) => {
+        changes[key] = {
+          oldValue: clone(data[key]),
+          newValue: undefined
+        };
+      });
+      data = {};
+      emitChanges(changes);
+      if (callback) callback();
+    }),
+    _dump() {
+      return clone(data);
+    }
+  };
+}
+
+function createChromeMock(options) {
+  const config = options || {};
+  const storageOnChanged = createChromeEvent();
+  const tabsOnActivated = createChromeEvent();
+  const tabsOnUpdated = createChromeEvent();
+  const runtimeOnMessage = createChromeEvent();
+
+  const chrome = {
+    runtime: {
+      lastError: null,
+      getManifest: vi.fn(() => clone(config.manifest) || { version: "0.0.0-test" }),
+      getURL: vi.fn((relPath) => `moz-extension://${relPath}`),
+      onMessage: runtimeOnMessage
+    },
+    browserAction: {
+      setIcon: vi.fn()
+    },
+    tabs: {
+      query: vi.fn((queryInfo, callback) => {
+        const tabs = clone(config.tabsQueryResult) || [
+          { id: 1, active: true, url: "https://example.com/" }
+        ];
+        if (callback) callback(tabs);
+      }),
+      sendMessage: vi.fn((tabId, message, callback) => {
+        if (callback) callback(null);
+      }),
+      executeScript: vi.fn((tabId, details, callback) => {
+        if (callback) callback([]);
+      }),
+      create: vi.fn(),
+      onActivated: tabsOnActivated,
+      onUpdated: tabsOnUpdated
+    },
+    storage: {
+      onChanged: storageOnChanged,
+      sync: null,
+      local: null
+    }
+  };
+
+  chrome.storage.sync = createStorageArea(
+    "sync",
+    config.syncData,
+    storageOnChanged
+  );
+  chrome.storage.local = createStorageArea(
+    "local",
+    config.localData,
+    storageOnChanged
+  );
+
+  return chrome;
+}
+
+function installCommonWindowMocks() {
+  window.open = vi.fn();
+  window.close = vi.fn();
+  window.requestAnimationFrame = vi.fn((callback) => setTimeout(callback, 0));
+  window.cancelAnimationFrame = vi.fn((id) => clearTimeout(id));
+}
+
+module.exports = {
+  createChromeMock,
+  evaluateScript,
+  fireDOMContentLoaded,
+  flushAsyncWork,
+  installCommonWindowMocks,
+  loadHtmlFile,
+  loadHtmlString,
+  readWorkspaceFile,
+  workspacePath
+};