@fairfox/polly 0.14.0 → 0.15.0

package/dist/src/index.js

@@ -48,6 +48,293 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/shared/lib/storage-adapter.ts
+var exports_storage_adapter = {};
+__export(exports_storage_adapter, {
+  createStorageAdapter: () => createStorageAdapter,
+  MemoryStorageAdapter: () => MemoryStorageAdapter,
+  IndexedDBAdapter: () => IndexedDBAdapter,
+  ChromeStorageAdapter: () => ChromeStorageAdapter2
+});
+
+class IndexedDBAdapter {
+  dbName;
+  storeName = "state";
+  dbPromise = null;
+  constructor(dbName = "polly-state") {
+    this.dbName = dbName;
+  }
+  getDB() {
+    if (this.dbPromise)
+      return this.dbPromise;
+    this.dbPromise = new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, 1);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName);
+        }
+      };
+    });
+    return this.dbPromise;
+  }
+  async get(keys) {
+    try {
+      const db = await this.getDB();
+      const result = {};
+      await Promise.all(keys.map((key) => new Promise((resolve, reject) => {
+        const transaction = db.transaction([this.storeName], "readonly");
+        const store = transaction.objectStore(this.storeName);
+        const request = store.get(key);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => {
+          if (request.result !== undefined) {
+            result[key] = request.result;
+          }
+          resolve();
+        };
+      })));
+      return result;
+    } catch (error) {
+      console.warn("[Polly] IndexedDB get failed:", error);
+      return {};
+    }
+  }
+  async set(items) {
+    try {
+      const db = await this.getDB();
+      await Promise.all(Object.entries(items).map(([key, value]) => new Promise((resolve, reject) => {
+        const transaction = db.transaction([this.storeName], "readwrite");
+        const store = transaction.objectStore(this.storeName);
+        const request = store.put(value, key);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve();
+      })));
+    } catch (error) {
+      console.warn("[Polly] IndexedDB set failed:", error);
+    }
+  }
+  async remove(keys) {
+    try {
+      const db = await this.getDB();
+      await Promise.all(keys.map((key) => new Promise((resolve, reject) => {
+        const transaction = db.transaction([this.storeName], "readwrite");
+        const store = transaction.objectStore(this.storeName);
+        const request = store.delete(key);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve();
+      })));
+    } catch (error) {
+      console.warn("[Polly] IndexedDB remove failed:", error);
+    }
+  }
+}
+
+class ChromeStorageAdapter2 {
+  async get(keys) {
+    if (typeof chrome === "undefined" || !chrome.storage) {
+      return {};
+    }
+    try {
+      return await chrome.storage.local.get(keys);
+    } catch (error) {
+      console.warn("[Polly] Chrome storage get failed:", error);
+      return {};
+    }
+  }
+  async set(items) {
+    if (typeof chrome === "undefined" || !chrome.storage) {
+      return;
+    }
+    try {
+      await chrome.storage.local.set(items);
+    } catch (error) {
+      console.warn("[Polly] Chrome storage set failed:", error);
+    }
+  }
+  async remove(keys) {
+    if (typeof chrome === "undefined" || !chrome.storage) {
+      return;
+    }
+    try {
+      await chrome.storage.local.remove(keys);
+    } catch (error) {
+      console.warn("[Polly] Chrome storage remove failed:", error);
+    }
+  }
+}
+
+class MemoryStorageAdapter {
+  storage = new Map;
+  async get(keys) {
+    const result = {};
+    for (const key of keys) {
+      const value = this.storage.get(key);
+      if (value !== undefined) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  async set(items) {
+    for (const [key, value] of Object.entries(items)) {
+      this.storage.set(key, value);
+    }
+  }
+  async remove(keys) {
+    for (const key of keys) {
+      this.storage.delete(key);
+    }
+  }
+}
+function createStorageAdapter() {
+  if (typeof chrome !== "undefined" && chrome.storage && chrome.runtime) {
+    return new ChromeStorageAdapter2;
+  }
+  if (typeof indexedDB !== "undefined") {
+    return new IndexedDBAdapter;
+  }
+  return new MemoryStorageAdapter;
+}
+
+// src/shared/lib/sync-adapter.ts
+var exports_sync_adapter = {};
+__export(exports_sync_adapter, {
+  createSyncAdapter: () => createSyncAdapter,
+  NoOpSyncAdapter: () => NoOpSyncAdapter,
+  ChromeRuntimeSyncAdapter: () => ChromeRuntimeSyncAdapter,
+  BroadcastChannelSyncAdapter: () => BroadcastChannelSyncAdapter
+});
+
+class NoOpSyncAdapter {
+  broadcast(_message) {}
+  onMessage(_callback) {
+    return () => {};
+  }
+}
+
+class ChromeRuntimeSyncAdapter {
+  listeners = [];
+  port = null;
+  constructor() {
+    if (typeof chrome !== "undefined" && chrome.runtime) {
+      chrome.runtime.onMessage.addListener((message, _sender, _sendResponse) => {
+        if (message.type === "STATE_SYNC") {
+          this.listeners.forEach((listener) => {
+            listener(message);
+          });
+        }
+      });
+    }
+  }
+  broadcast(message) {
+    if (typeof chrome === "undefined" || !chrome.runtime) {
+      console.warn("[SyncAdapter] chrome.runtime not available");
+      return;
+    }
+    try {
+      chrome.runtime.sendMessage({
+        type: "STATE_SYNC",
+        key: message.key,
+        value: message.value,
+        clock: message.clock
+      });
+    } catch (error) {
+      console.warn("[SyncAdapter] Failed to broadcast state update:", error);
+    }
+  }
+  onMessage(callback) {
+    this.listeners.push(callback);
+    return () => {
+      const index = this.listeners.indexOf(callback);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  connect() {
+    return Promise.resolve();
+  }
+  disconnect() {
+    this.listeners = [];
+    if (this.port) {
+      this.port.disconnect();
+      this.port = null;
+    }
+  }
+  isConnected() {
+    return typeof chrome !== "undefined" && !!chrome.runtime;
+  }
+}
+
+class BroadcastChannelSyncAdapter {
+  channel = null;
+  listeners = [];
+  constructor(channelName = "polly-sync") {
+    if (typeof BroadcastChannel !== "undefined") {
+      this.channel = new BroadcastChannel(channelName);
+      this.channel.onmessage = (event) => {
+        if (event.data.type === "STATE_SYNC") {
+          this.listeners.forEach((listener) => {
+            listener(event.data);
+          });
+        }
+      };
+    } else {
+      console.warn("[SyncAdapter] BroadcastChannel not available");
+    }
+  }
+  broadcast(message) {
+    if (!this.channel) {
+      console.warn("[SyncAdapter] BroadcastChannel not initialized");
+      return;
+    }
+    try {
+      this.channel.postMessage({
+        type: "STATE_SYNC",
+        key: message.key,
+        value: message.value,
+        clock: message.clock
+      });
+    } catch (error) {
+      console.warn("[SyncAdapter] Failed to broadcast state update:", error);
+    }
+  }
+  onMessage(callback) {
+    this.listeners.push(callback);
+    return () => {
+      const index = this.listeners.indexOf(callback);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  connect() {
+    return Promise.resolve();
+  }
+  disconnect() {
+    this.listeners = [];
+    if (this.channel) {
+      this.channel.close();
+      this.channel = null;
+    }
+  }
+  isConnected() {
+    return this.channel !== null;
+  }
+}
+function createSyncAdapter() {
+  if (typeof chrome !== "undefined" && chrome.runtime) {
+    return new ChromeRuntimeSyncAdapter;
+  }
+  if (typeof BroadcastChannel !== "undefined") {
+    return new BroadcastChannelSyncAdapter;
+  }
+  return new NoOpSyncAdapter;
+}
+
 // src/shared/lib/constraints.ts
 var exports_constraints = {};
 __export(exports_constraints, {
@@ -413,8 +700,60 @@ class MessageLoggerAdapter {
   }
 }
 
+// src/shared/lib/adapter-factory.ts
+function createStateAdapters(options = {}) {
+  if (options.storage && options.sync) {
+    return {
+      storage: options.storage,
+      sync: options.sync
+    };
+  }
+  const storage = options.storage || createStorageAdapter();
+  let sync;
+  if (options.sync) {
+    sync = options.sync;
+  } else if (options.singleTab) {
+    const { NoOpSyncAdapter: NoOpSyncAdapter2 } = __toCommonJS(exports_sync_adapter);
+    sync = new NoOpSyncAdapter2;
+  } else {
+    sync = createSyncAdapter();
+  }
+  return { storage, sync };
+}
+function createChromeAdapters() {
+  const { ChromeStorageAdapter: ChromeStorageAdapter3 } = __toCommonJS(exports_storage_adapter);
+  const { ChromeRuntimeSyncAdapter: ChromeRuntimeSyncAdapter2 } = __toCommonJS(exports_sync_adapter);
+  return {
+    storage: new ChromeStorageAdapter3,
+    sync: new ChromeRuntimeSyncAdapter2
+  };
+}
+function createWebAdapters(options = {}) {
+  const { IndexedDBAdapter: IndexedDBAdapter2 } = __toCommonJS(exports_storage_adapter);
+  const { BroadcastChannelSyncAdapter: BroadcastChannelSyncAdapter2, NoOpSyncAdapter: NoOpSyncAdapter2 } = __toCommonJS(exports_sync_adapter);
+  const storage = new IndexedDBAdapter2(options.dbName);
+  const sync = options.singleTab ? new NoOpSyncAdapter2 : new BroadcastChannelSyncAdapter2(options.channelName);
+  return { storage, sync };
+}
+function createNodeAdapters() {
+  const { MemoryStorageAdapter: MemoryStorageAdapter2 } = __toCommonJS(exports_storage_adapter);
+  const { NoOpSyncAdapter: NoOpSyncAdapter2 } = __toCommonJS(exports_sync_adapter);
+  return {
+    storage: new MemoryStorageAdapter2,
+    sync: new NoOpSyncAdapter2
+  };
+}
+function createMockAdapters() {
+  const { MemoryStorageAdapter: MemoryStorageAdapter2 } = __toCommonJS(exports_storage_adapter);
+  const { NoOpSyncAdapter: NoOpSyncAdapter2 } = __toCommonJS(exports_sync_adapter);
+  return {
+    storage: new MemoryStorageAdapter2,
+    sync: new NoOpSyncAdapter2
+  };
+}
+
 // src/shared/adapters/index.ts
-function createChromeAdapters(context, options) {
+function createChromeAdapters2(context, options) {
   const runtime2 = new ChromeRuntimeAdapter;
   return {
     runtime: runtime2,
@@ -812,7 +1151,7 @@ class MessageBus {
   messageListener = null;
   constructor(context, adapters, options) {
     this.context = context;
-    this.adapters = adapters || createChromeAdapters(context);
+    this.adapters = adapters || createChromeAdapters2(context);
     this.errorHandler = new ErrorHandler(this.adapters.logger);
     this.helpers = this.createContextHelpers();
     if (!options?.skipListenerSetup) {
@@ -1257,41 +1596,11 @@ function runInContext(context, contexts, fn, adapters) {
 // src/shared/lib/state.ts
 import { effect, signal } from "@preact/signals";
 var stateRegistry = new Map;
-function getCurrentContext() {
-  if (typeof chrome !== "undefined") {
-    if (typeof chrome.devtools !== "undefined") {
-      return "devtools";
-    }
-    if (typeof chrome.runtime !== "undefined") {
-      try {
-        if (typeof self !== "undefined" && "ServiceWorkerGlobalScope" in self) {
-          return "background";
-        }
-      } catch {}
-    }
-  }
-  if (typeof window !== "undefined" && typeof document !== "undefined") {
-    if (typeof chrome === "undefined" || typeof chrome.runtime === "undefined") {
-      return "page";
-    }
-    if (typeof window.location !== "undefined" && window.location.protocol === "chrome-extension:") {
-      const path = window.location.pathname;
-      if (path.includes("/popup"))
-        return "popup";
-      if (path.includes("/options"))
-        return "options";
-      if (path.includes("/offscreen"))
-        return "offscreen";
-    }
-    return "content";
-  }
-  return "background";
-}
 function $sharedState(key, initialValue, options = {}) {
   const sig = createState(key, initialValue, {
     ...options,
-    sync: true,
-    persist: true
+    enableSync: true,
+    enablePersist: true
   });
   const entry = stateRegistry.get(key);
   if (entry) {
@@ -1302,15 +1611,15 @@ function $sharedState(key, initialValue, options = {}) {
 function $syncedState(key, initialValue, options = {}) {
   return createState(key, initialValue, {
     ...options,
-    sync: true,
-    persist: false
+    enableSync: true,
+    enablePersist: false
   });
 }
 function $persistedState(key, initialValue, options = {}) {
   const sig = createState(key, initialValue, {
     ...options,
-    sync: false,
-    persist: true
+    enableSync: false,
+    enablePersist: true
   });
   const entry = stateRegistry.get(key);
   if (entry) {
@@ -1340,17 +1649,28 @@ function deepEqual(a, b) {
   }
   return true;
 }
+function resolveAdapters(options) {
+  if (options.storage || options.sync) {
+    return {
+      storage: options.storage || (options.enablePersist ? createStorageAdapter() : null),
+      sync: options.sync || (options.enableSync ? createSyncAdapter() : null)
+    };
+  }
+  if (options.bus) {
+    return {
+      storage: options.bus.adapters.storage,
+      sync: options.enableSync ? createSyncAdapter() : null
+    };
+  }
+  return {
+    storage: options.enablePersist ? createStorageAdapter() : null,
+    sync: options.enableSync ? createSyncAdapter() : null
+  };
+}
 function createState(key, initialValue, options) {
   if (stateRegistry.has(key)) {
     return stateRegistry.get(key)?.signal;
   }
-  const currentContext = getCurrentContext();
-  if (currentContext === "page" && (options.sync || options.persist)) {
-    const stateFn = options.sync && options.persist ? "$sharedState" : options.persist ? "$persistedState" : "$syncedState";
-    throw new Error(`[web-ext] ${stateFn}() is not available in page context.
-Page scripts are execution contexts for content scripts and should not maintain state.
-Use state in the content script instead, or use $state() for local-only state.`);
-  }
   const sig = signal(initialValue);
   if (options.verify) {
     const mirror = JSON.parse(JSON.stringify(initialValue));
@@ -1362,15 +1682,9 @@ Use state in the content script instead, or use $state() for local-only state.`)
     loaded: Promise.resolve(),
     updating: false
   };
-  let bus = null;
-  const getBus = () => {
-    if (!bus && typeof chrome !== "undefined") {
-      bus = options.bus || getMessageBus(currentContext);
-    }
-    return bus;
-  };
-  if (options.persist) {
-    entry.loaded = loadFromStorage(key, sig, entry, getBus(), options.validator);
+  const adapters = resolveAdapters(options);
+  if (options.enablePersist && adapters.storage) {
+    entry.loaded = loadFromStorage(key, sig, entry, adapters.storage, options.validator);
   }
   entry.loaded.then(() => {
     let debounceTimer = null;
@@ -1396,11 +1710,11 @@ Use state in the content script instead, or use $state() for local-only state.`)
       }
       entry.clock++;
       const doUpdate = () => {
-        if (options.persist) {
-          persistToStorage(key, value, entry.clock, getBus());
+        if (options.enablePersist && adapters.storage) {
+          persistToStorage(key, value, entry.clock, adapters.storage);
         }
-        if (options.sync) {
-          broadcastUpdate(key, value, entry.clock, getBus());
+        if (options.enableSync && adapters.sync) {
+          broadcastUpdate(key, value, entry.clock, adapters.sync);
         }
       };
       if (options.debounceMs) {
@@ -1412,46 +1726,40 @@ Use state in the content script instead, or use $state() for local-only state.`)
       }
     });
   });
-  if (options.sync) {
-    const messageBus = getBus();
-    if (messageBus) {
-      if (currentContext === "popup" || currentContext === "options" || currentContext === "devtools") {
-        messageBus.connect(currentContext);
-      }
-      messageBus.on("STATE_SYNC", async (payload) => {
-        if (payload.key !== key)
+  if (options.enableSync && adapters.sync) {
+    if (adapters.sync.connect) {
+      adapters.sync.connect();
+    }
+    adapters.sync.onMessage((message) => {
+      if (message.key !== key)
+        return;
+      const oldClock = entry.clock;
+      entry.clock = Math.max(entry.clock, message.clock);
+      if (message.clock > oldClock) {
+        if (options.validator && !options.validator(message.value)) {
+          console.warn(`[Polly] State "${key}": Received invalid value from sync (clock: ${message.clock})`, message.value);
           return;
-        const oldClock = entry.clock;
-        entry.clock = Math.max(entry.clock, payload.clock);
-        if (payload.clock > oldClock) {
-          if (options.validator && !options.validator(payload.value)) {
-            console.warn(`[web-ext] State "${key}": Received invalid value from sync (clock: ${payload.clock})`, payload.value);
-            return;
-          }
-          if (deepEqual(entry.signal.value, payload.value)) {
-            return;
-          }
-          applyUpdate(entry, payload.value, payload.clock);
         }
-        return;
-      });
-    }
+        if (deepEqual(entry.signal.value, message.value)) {
+          return;
+        }
+        applyUpdate(entry, message.value, message.clock);
+      }
+    });
   }
   stateRegistry.set(key, entry);
   return sig;
 }
-async function loadFromStorage(key, sig, entry, bus, validator) {
-  if (!bus)
-    return;
+async function loadFromStorage(key, sig, entry, storage2, validator) {
   try {
-    const result = await bus.adapters.storage.get([key, `${key}:clock`]);
+    const result = await storage2.get([key, `${key}:clock`]);
     if (result[key] !== undefined) {
       const storedValue = result[key];
       if (validator) {
         if (validator(storedValue)) {
           sig.value = storedValue;
         } else {
-          console.warn(`[web-ext] State "${key}": Stored value failed validation, using initial value`, storedValue);
+          console.warn(`[Polly] State "${key}": Stored value failed validation, using initial value`, storedValue);
         }
       } else {
         sig.value = storedValue;
@@ -1461,33 +1769,28 @@ async function loadFromStorage(key, sig, entry, bus, validator) {
       entry.clock = result[`${key}:clock`];
     }
   } catch (error) {
-    console.warn(`[web-ext] Failed to load state from storage: ${key}`, error);
+    console.warn(`[Polly] Failed to load state from storage: ${key}`, error);
   }
 }
-function persistToStorage(key, value, clock, bus) {
-  if (!bus)
-    return;
+function persistToStorage(key, value, clock, storage2) {
   try {
-    bus.adapters.storage.set({
+    storage2.set({
       [key]: value,
       [`${key}:clock`]: clock
     });
   } catch (error) {
-    console.warn(`Failed to persist state to storage: ${key}`, error);
+    console.warn(`[Polly] Failed to persist state to storage: ${key}`, error);
   }
 }
-function broadcastUpdate(key, value, clock, bus) {
-  if (!bus)
-    return;
+function broadcastUpdate(key, value, clock, sync) {
   try {
-    bus.broadcast({
-      type: "STATE_SYNC",
+    sync.broadcast({
       key,
       value,
       clock
     });
   } catch (error) {
-    console.warn(`Failed to broadcast state update: ${key}`, error);
+    console.warn(`[Polly] Failed to broadcast state update: ${key}`, error);
   }
 }
 function applyUpdate(entry, value, clock) {
@@ -1709,7 +2012,7 @@ export {
   getMessageBus,
   createTestSuite,
   createContext,
-  createChromeAdapters,
+  createChromeAdapters2 as createChromeAdapters,
   clearConstraints,
   checkPreconditions,
   checkPostconditions,
@@ -1726,4 +2029,4 @@ export {
   $persistedState
 };
 
-//# debugId=24654C31897ECEF564756E2164756E21
+//# debugId=2C9C410817D4600B64756E2164756E21