@fairfox/polly 0.19.0 → 0.20.1

package/dist/src/shared/lib/resource.js

@@ -0,0 +1,593 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  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: () => ChromeStorageAdapter
+});
+
+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 ChromeStorageAdapter {
+  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 ChromeStorageAdapter;
+  }
+  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") {
+      console.warn("[SyncAdapter] BroadcastChannel not available");
+    } else {
+      this.channel = new BroadcastChannel(channelName);
+      this.channel.onmessage = (event) => {
+        if (event.data.type === "STATE_SYNC") {
+          this.listeners.forEach((listener) => {
+            listener(event.data);
+          });
+        }
+      };
+    }
+  }
+  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/state.ts
+import { effect, signal } from "@preact/signals";
+var stateRegistry = new Map;
+function $sharedState(key, initialValue, options = {}) {
+  const sig = createState(key, initialValue, {
+    ...options,
+    enableSync: true,
+    enablePersist: true
+  });
+  const entry = stateRegistry.get(key);
+  if (entry) {
+    sig.loaded = entry.loaded;
+  }
+  return sig;
+}
+function $syncedState(key, initialValue, options = {}) {
+  return createState(key, initialValue, {
+    ...options,
+    enableSync: true,
+    enablePersist: false
+  });
+}
+function $persistedState(key, initialValue, options = {}) {
+  const sig = createState(key, initialValue, {
+    ...options,
+    enableSync: false,
+    enablePersist: true
+  });
+  const entry = stateRegistry.get(key);
+  if (entry) {
+    sig.loaded = entry.loaded;
+  }
+  return sig;
+}
+function $state(initialValue) {
+  return signal(initialValue);
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a == null || b == null)
+    return false;
+  if (typeof a !== "object" || typeof b !== "object")
+    return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (const key of keysA) {
+    if (!keysB.includes(key))
+      return false;
+    if (!deepEqual(a[key], b[key]))
+      return false;
+  }
+  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 sig = signal(initialValue);
+  if (options.verify) {
+    const mirror = JSON.parse(JSON.stringify(initialValue));
+    sig.verify = mirror;
+  }
+  const entry = {
+    signal: sig,
+    clock: 0,
+    loaded: Promise.resolve(),
+    updating: false
+  };
+  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;
+    let previousValue = sig.value;
+    let isFirstRun = true;
+    effect(() => {
+      if (entry.updating)
+        return;
+      const value = sig.value;
+      if (isFirstRun) {
+        isFirstRun = false;
+        return;
+      }
+      if (deepEqual(value, previousValue)) {
+        return;
+      }
+      previousValue = value;
+      if (options.verify) {
+        const verifySignal = sig;
+        if (verifySignal.verify) {
+          Object.assign(verifySignal.verify, JSON.parse(JSON.stringify(value)));
+        }
+      }
+      entry.clock++;
+      const doUpdate = () => {
+        if (options.enablePersist && adapters.storage) {
+          persistToStorage(key, value, entry.clock, adapters.storage);
+        }
+        if (options.enableSync && adapters.sync) {
+          broadcastUpdate(key, value, entry.clock, adapters.sync);
+        }
+      };
+      if (options.debounceMs) {
+        if (debounceTimer)
+          clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(doUpdate, options.debounceMs);
+      } else {
+        doUpdate();
+      }
+    });
+  });
+  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;
+        }
+        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, storage, validator) {
+  try {
+    const result = await storage.get([key, `${key}:clock`]);
+    if (result[key] !== undefined) {
+      const storedValue = result[key];
+      if (validator) {
+        if (validator(storedValue)) {
+          sig.value = storedValue;
+        } else {
+          console.warn(`[Polly] State "${key}": Stored value failed validation, using initial value`, storedValue);
+        }
+      } else {
+        sig.value = storedValue;
+      }
+    }
+    if (result[`${key}:clock`] !== undefined) {
+      entry.clock = result[`${key}:clock`];
+    }
+  } catch (error) {
+    console.warn(`[Polly] Failed to load state from storage: ${key}`, error);
+  }
+}
+function persistToStorage(key, value, clock, storage) {
+  try {
+    storage.set({
+      [key]: value,
+      [`${key}:clock`]: clock
+    });
+  } catch (error) {
+    console.warn(`[Polly] Failed to persist state to storage: ${key}`, error);
+  }
+}
+function broadcastUpdate(key, value, clock, sync) {
+  try {
+    sync.broadcast({
+      key,
+      value,
+      clock
+    });
+  } catch (error) {
+    console.warn(`[Polly] Failed to broadcast state update: ${key}`, error);
+  }
+}
+function applyUpdate(entry, value, clock) {
+  entry.updating = true;
+  entry.signal.value = value;
+  entry.clock = clock;
+  entry.updating = false;
+}
+function getStateByKey(key) {
+  const entry = stateRegistry.get(key);
+  return entry?.signal;
+}
+function clearStateRegistry() {
+  stateRegistry.clear();
+}
+
+// src/shared/lib/resource.ts
+import { effect as effect2, signal as signal2 } from "@preact/signals";
+function $resource(_name, options) {
+  const { source, fetcher, initialValue } = options;
+  const data = signal2(initialValue);
+  const status = signal2("idle");
+  const error = signal2(undefined);
+  let generation = 0;
+  let lastSource;
+  function runFetch(sourceValue) {
+    const thisGeneration = ++generation;
+    status.value = "loading";
+    error.value = undefined;
+    fetcher(sourceValue).then((result) => {
+      if (thisGeneration !== generation)
+        return;
+      data.value = result;
+      status.value = "success";
+      error.value = undefined;
+    }, (err) => {
+      if (thisGeneration !== generation)
+        return;
+      status.value = "error";
+      error.value = err instanceof Error ? err : new Error(String(err));
+    });
+  }
+  effect2(() => {
+    const sourceValue = source();
+    if (lastSource !== undefined && deepEqual(lastSource, sourceValue)) {
+      return;
+    }
+    lastSource = sourceValue;
+    runFetch(sourceValue);
+  });
+  function refetch() {
+    if (lastSource !== undefined) {
+      runFetch(lastSource);
+    }
+  }
+  return { data, status, error, refetch };
+}
+export {
+  $resource
+};
+
+//# debugId=CA95E0087865A45C64756E2164756E21