@fairfox/polly 0.14.0 → 0.15.0

package/dist/src/background/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) {
@@ -1480,4 +1819,4 @@ export {
   MessageRouter
 };
 
-//# debugId=6D0BF9905E57154464756E2164756E21
+//# debugId=55057EE1E1BCC1B964756E2164756E21