@demlik/tea 0.13.0 → 0.14.0

package/dist/extension/index.js

@@ -1,7 +1,598 @@
-export { bridgeClient, bridgeRuntime, bridgeTabClient, passThroughMsg } from '../chunk-L57ZOT5K.js';
-import '../chunk-G5E74IJB.js';
-import '../chunk-ZSUUOEPL.js';
-import '../chunk-OOYD44JI.js';
+import { describeError } from '../chunk-G5E74IJB.js';
+import { historyTracker, dispatchIfPresent } from '../chunk-RQULHGYH.js';
+import { useRef, useSyncExternalStore, useEffect, useCallback, createContext, useMemo, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/extension/bridge.ts
+function channelTypes(channel) {
+  return {
+    dispatchType: `${channel}:dispatch`,
+    hydrateType: `${channel}:hydrate`
+  };
+}
+function bridgeRuntime(runtime, { channel, parseMsg, serialize, historySize }) {
+  const { dispatchType, hydrateType } = channelTypes(channel);
+  const project = serialize ?? ((state) => state);
+  const tracker = historySize !== void 0 && historySize > 0 ? historyTracker(runtime, historySize) : null;
+  const sendBroadcast = (msg, state) => {
+    const envelope = {
+      type: channel,
+      msg,
+      state: project(state)
+    };
+    chrome.runtime.sendMessage(envelope).catch(() => {
+    });
+  };
+  const unobserve = runtime.observe((msg, state) => {
+    sendBroadcast(msg, state);
+  });
+  const unboot = runtime.onBoot((state) => {
+    sendBroadcast(null, state);
+  });
+  const onMessage = (message, _sender, sendResponse) => {
+    if (!message || typeof message !== "object") return void 0;
+    const obj = message;
+    if (obj.type === hydrateType) {
+      let state;
+      try {
+        state = project(runtime.getState());
+      } catch {
+        state = null;
+      }
+      const backlog = tracker ? tracker.snapshot().map((entry) => ({ msg: entry.msg, state: project(entry.state) })) : [];
+      const response = { state, backlog };
+      sendResponse(response);
+      return false;
+    }
+    if (obj.type === dispatchType) {
+      const msg = parseMsg(obj.msg);
+      if (msg === null) {
+        sendResponse({ ok: false, error: "dispatch msg failed parse" });
+        return false;
+      }
+      runtime.dispatch(msg).then(() => {
+        sendResponse({ ok: true });
+      }).catch((err) => {
+        sendResponse({
+          ok: false,
+          error: describeError(err)
+        });
+      });
+      return true;
+    }
+    return void 0;
+  };
+  chrome.runtime.onMessage.addListener(onMessage);
+  return () => {
+    unobserve();
+    unboot();
+    chrome.runtime.onMessage.removeListener(onMessage);
+    tracker?.stop();
+  };
+}
+function passThroughMsg(raw) {
+  return raw;
+}
+function parseEnvelope(obj, parseState, parseMsg) {
+  const state = parseState(obj.state);
+  if (state === null) return null;
+  let msg;
+  if (obj.msg === null || obj.msg === void 0) {
+    msg = null;
+  } else {
+    msg = parseMsg(obj.msg);
+    if (msg === null) return null;
+  }
+  return { msg, state };
+}
+function replayBacklog(raw, parseState, parseMsg, listeners, commitState) {
+  if (!Array.isArray(raw)) return;
+  for (const entryRaw of raw) {
+    if (!entryRaw || typeof entryRaw !== "object") continue;
+    const entry = entryRaw;
+    const parsed = parseEnvelope(entry, parseState, parseMsg);
+    if (parsed === null) continue;
+    commitState(parsed.state);
+    for (const l of listeners) l(parsed.msg, parsed.state);
+  }
+}
+function makeBridgeClient({
+  channel,
+  parseState,
+  parseMsg,
+  send,
+  senderMatches = () => true
+}) {
+  const { dispatchType, hydrateType } = channelTypes(channel);
+  let latestState = null;
+  const listeners = /* @__PURE__ */ new Set();
+  const client = {
+    async hydrate() {
+      const req = { type: hydrateType };
+      const res = await send(req);
+      replayBacklog(res?.backlog, parseState, parseMsg, listeners, (next) => {
+        latestState = next;
+      });
+      const raw = res?.state;
+      if (raw === void 0 || raw === null) return null;
+      const parsed = parseState(raw);
+      if (parsed === null) return null;
+      latestState = parsed;
+      for (const l of listeners) l(null, parsed);
+      return parsed;
+    },
+    async dispatch(msg) {
+      const env = { type: dispatchType, msg };
+      await send(env);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      const onMessage = (message, sender) => {
+        if (!senderMatches(sender)) return;
+        if (!message || typeof message !== "object") return;
+        const obj = message;
+        if (obj.type !== channel) return;
+        const parsed = parseEnvelope(obj, parseState, parseMsg);
+        if (parsed === null) return;
+        latestState = parsed.state;
+        listener(parsed.msg, parsed.state);
+      };
+      chrome.runtime.onMessage.addListener(onMessage);
+      return () => {
+        chrome.runtime.onMessage.removeListener(onMessage);
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot() {
+      return latestState;
+    }
+  };
+  return client;
+}
+function bridgeClient({
+  channel,
+  parseState,
+  parseMsg
+}) {
+  return makeBridgeClient({
+    channel,
+    parseState,
+    parseMsg,
+    send: (message) => chrome.runtime.sendMessage(message)
+  });
+}
+function bridgeTabClient({
+  tabId,
+  channel,
+  parseState,
+  parseMsg
+}) {
+  return makeBridgeClient({
+    channel,
+    parseState,
+    parseMsg,
+    // SW → content transport: `chrome.runtime.sendMessage` does NOT reach a
+    // tab's content script; `chrome.tabs.sendMessage(tabId, …)` does.
+    send: (message) => chrome.tabs.sendMessage(tabId, message),
+    // Every tab's content script broadcasts through the same SW
+    // `chrome.runtime.onMessage`; filter to this tab so a client subscribed
+    // to one tab never sees another's broadcasts.
+    senderMatches: (sender) => sender.tab?.id === tabId
+  });
+}
+function useBackgroundRuntime({
+  channel,
+  parseState
+}) {
+  const clientRef = useRef(null);
+  if (clientRef.current === null) {
+    clientRef.current = bridgeClient({
+      channel,
+      parseState,
+      parseMsg: passThroughMsg
+    });
+  }
+  const client = clientRef.current;
+  const state = useSyncExternalStore(
+    client.subscribe,
+    client.getSnapshot,
+    client.getSnapshot
+  );
+  useEffect(() => {
+    client.hydrate().catch(() => {
+    });
+  }, [client]);
+  const dispatch = useCallback(
+    async (msg) => {
+      await client.dispatch(msg);
+    },
+    [client]
+  );
+  return { state, dispatch };
+}
+var PROVIDER_ERROR = "createBackgroundRuntimeContext: hook used outside its Provider. Wrap the consumer in <BackgroundRuntime.Provider opts={...}>.";
+function createBackgroundRuntimeContext() {
+  const Ctx = createContext(null);
+  function Provider({
+    opts,
+    children
+  }) {
+    const result = useBackgroundRuntime(opts);
+    const value = useMemo(
+      () => ({ state: result.state, dispatch: result.dispatch }),
+      [result.state, result.dispatch]
+    );
+    return /* @__PURE__ */ jsx(Ctx.Provider, { value, children });
+  }
+  function useRuntime() {
+    const ctx = useContext(Ctx);
+    if (ctx === null) throw new Error(PROVIDER_ERROR);
+    return ctx;
+  }
+  function useDispatch() {
+    return useRuntime().dispatch;
+  }
+  function useStateHook(selector) {
+    const { state } = useRuntime();
+    if (selector === void 0) return state;
+    return selector(state);
+  }
+  return {
+    Provider,
+    useDispatch,
+    useState: useStateHook,
+    useRuntime
+  };
+}
+
+// src/extension/subs/from-chrome-alarm.ts
+function fromChromeAlarm(msgFn) {
+  return (sub, _ctx, dispatch) => {
+    const listener = (alarm) => {
+      if (alarm.name !== sub.alarmName) return;
+      dispatchIfPresent(dispatch, msgFn(alarm, sub));
+    };
+    chrome.alarms.onAlarm.addListener(listener);
+    return () => chrome.alarms.onAlarm.removeListener(listener);
+  };
+}
+
+// src/extension/subs/from-chrome-message.ts
+function fromChromeMessage(opts) {
+  return (sub, _ctx, dispatch) => {
+    const listener = (message, sender, _sendResponse) => {
+      if (opts.filter !== void 0 && !opts.filter(message)) return;
+      dispatchIfPresent(dispatch, opts.msgFn(message, sender, sub));
+    };
+    chrome.runtime.onMessage.addListener(listener);
+    return () => {
+      chrome.runtime.onMessage.removeListener(listener);
+    };
+  };
+}
+
+// src/extension/subs/from-chrome-storage-change.ts
+function fromChromeStorageChange(opts) {
+  return (sub, _ctx, dispatch) => {
+    const listener = (changes, areaName) => {
+      if (areaName !== opts.area) return;
+      if (opts.keys !== void 0) {
+        const changedKeys = Object.keys(changes);
+        let overlap = false;
+        for (const k of opts.keys) {
+          if (changedKeys.includes(k)) {
+            overlap = true;
+            break;
+          }
+        }
+        if (!overlap) return;
+      }
+      dispatchIfPresent(dispatch, opts.msgFn(changes, sub));
+    };
+    chrome.storage.onChanged.addListener(listener);
+    return () => {
+      chrome.storage.onChanged.removeListener(listener);
+    };
+  };
+}
+
+// src/extension/subs/from-chrome-tabs-event.ts
+function fromChromeTabsEvent(opts) {
+  return (sub, _ctx, dispatch) => {
+    const installed = [];
+    const listener = () => {
+      dispatchIfPresent(dispatch, opts.msgFn(sub));
+    };
+    for (const event of opts.events) {
+      const emitter = chrome.tabs[event];
+      emitter.addListener(listener);
+      installed.push(event);
+    }
+    if (opts.fireOnMount === true) {
+      dispatchIfPresent(dispatch, opts.msgFn(sub));
+    }
+    return () => {
+      for (const event of installed) {
+        const emitter = chrome.tabs[event];
+        emitter.removeListener(listener);
+      }
+    };
+  };
+}
+
+// src/extension/test-utils.ts
+function fakeChrome() {
+  const data = /* @__PURE__ */ new Map();
+  const storageListeners = /* @__PURE__ */ new Set();
+  function deepEqual(a, b) {
+    if (a === b) return true;
+    if (typeof a !== typeof b) return false;
+    if (typeof a !== "object" || a === null || b === null) return false;
+    return JSON.stringify(a) === JSON.stringify(b);
+  }
+  function fireStorageChange(changes) {
+    if (Object.keys(changes).length === 0) return;
+    for (const listener of Array.from(storageListeners)) {
+      listener(changes, "local");
+    }
+  }
+  const partial = {
+    async get(keys) {
+      if (keys === void 0 || keys === null) {
+        return Object.fromEntries(data);
+      }
+      if (typeof keys === "string") {
+        const v = data.get(keys);
+        return v === void 0 ? {} : { [keys]: v };
+      }
+      if (Array.isArray(keys)) {
+        return Object.fromEntries(
+          keys.flatMap((k) => data.has(k) ? [[k, data.get(k)]] : [])
+        );
+      }
+      const out = {};
+      for (const [k, def] of Object.entries(keys)) {
+        out[k] = data.has(k) ? data.get(k) : def;
+      }
+      return out;
+    },
+    async set(items) {
+      const changes = {};
+      for (const [k, v] of Object.entries(items)) {
+        const prev = data.get(k);
+        if (deepEqual(prev, v)) continue;
+        const change = { newValue: v };
+        if (data.has(k)) change.oldValue = prev;
+        changes[k] = change;
+        data.set(k, v);
+      }
+      fireStorageChange(changes);
+    },
+    async remove(keys) {
+      const arr = Array.isArray(keys) ? keys : [keys];
+      const changes = {};
+      for (const k of arr) {
+        if (!data.has(k)) continue;
+        changes[k] = { oldValue: data.get(k) };
+        data.delete(k);
+      }
+      fireStorageChange(changes);
+    },
+    async clear() {
+      const changes = {};
+      for (const [k, v] of data) changes[k] = { oldValue: v };
+      data.clear();
+      fireStorageChange(changes);
+    }
+  };
+  const local = partial;
+  const runtimeListeners = /* @__PURE__ */ new Set();
+  const removedTabs = /* @__PURE__ */ new Set();
+  const dispatch = (message, sender) => {
+    return new Promise((resolve, reject) => {
+      let responded = false;
+      const sendResponse = (response) => {
+        if (responded) return;
+        responded = true;
+        resolve(response);
+      };
+      const snapshot = Array.from(runtimeListeners);
+      let willRespondAsync = false;
+      for (const listener of snapshot) {
+        const r = listener(message, sender, sendResponse);
+        if (r === true) willRespondAsync = true;
+        if (responded) return;
+      }
+      if (willRespondAsync) return;
+      reject(
+        new Error(
+          "Could not establish connection. Receiving end does not exist."
+        )
+      );
+    });
+  };
+  const extensionSender = {};
+  const runtimePartial = {
+    sendMessage(message) {
+      return dispatch(message, extensionSender);
+    },
+    onMessage: {
+      addListener(listener) {
+        runtimeListeners.add(listener);
+      },
+      removeListener(listener) {
+        runtimeListeners.delete(listener);
+      },
+      hasListener(listener) {
+        return runtimeListeners.has(listener);
+      },
+      hasListeners() {
+        return runtimeListeners.size > 0;
+      }
+    }
+  };
+  const runtime = runtimePartial;
+  const tabsPartial = {
+    sendMessage(tabId, message) {
+      if (removedTabs.has(tabId)) {
+        return Promise.reject(
+          new Error(
+            `Could not establish connection. Receiving end does not exist. (tabId=${tabId})`
+          )
+        );
+      }
+      return dispatch(message, extensionSender);
+    }
+  };
+  const tabActivatedListeners = /* @__PURE__ */ new Set();
+  const tabUpdatedListeners = /* @__PURE__ */ new Set();
+  const tabRemovedListeners = /* @__PURE__ */ new Set();
+  const tabsFull = {
+    ...tabsPartial,
+    onActivated: {
+      addListener(listener) {
+        tabActivatedListeners.add(listener);
+      },
+      removeListener(listener) {
+        tabActivatedListeners.delete(listener);
+      },
+      hasListener(listener) {
+        return tabActivatedListeners.has(listener);
+      },
+      hasListeners() {
+        return tabActivatedListeners.size > 0;
+      }
+    },
+    onUpdated: {
+      addListener(listener) {
+        tabUpdatedListeners.add(listener);
+      },
+      removeListener(listener) {
+        tabUpdatedListeners.delete(listener);
+      },
+      hasListener(listener) {
+        return tabUpdatedListeners.has(listener);
+      },
+      hasListeners() {
+        return tabUpdatedListeners.size > 0;
+      }
+    },
+    onRemoved: {
+      addListener(listener) {
+        tabRemovedListeners.add(listener);
+      },
+      removeListener(listener) {
+        tabRemovedListeners.delete(listener);
+      },
+      hasListener(listener) {
+        return tabRemovedListeners.has(listener);
+      },
+      hasListeners() {
+        return tabRemovedListeners.size > 0;
+      }
+    }
+  };
+  const tabs = tabsFull;
+  const alarmMap = /* @__PURE__ */ new Map();
+  const alarmListeners = /* @__PURE__ */ new Set();
+  const alarms = {
+    create(name, alarmInfo) {
+      alarmMap.set(name, alarmInfo);
+    },
+    async get(name) {
+      const info = alarmMap.get(name);
+      if (info === void 0) return void 0;
+      return {
+        name,
+        scheduledTime: Date.now(),
+        periodInMinutes: info.periodInMinutes
+      };
+    },
+    async clear(name) {
+      return alarmMap.delete(name);
+    },
+    onAlarm: {
+      addListener(listener) {
+        alarmListeners.add(listener);
+      },
+      removeListener(listener) {
+        alarmListeners.delete(listener);
+      },
+      hasListener(listener) {
+        return alarmListeners.has(listener);
+      },
+      hasListeners() {
+        return alarmListeners.size > 0;
+      }
+    }
+  };
+  return {
+    storage: {
+      local,
+      onChanged: {
+        addListener(listener) {
+          storageListeners.add(listener);
+        },
+        removeListener(listener) {
+          storageListeners.delete(listener);
+        },
+        hasListener(listener) {
+          return storageListeners.has(listener);
+        },
+        hasListeners() {
+          return storageListeners.size > 0;
+        }
+      }
+    },
+    runtime,
+    tabs,
+    alarms,
+    __test: {
+      sendFromTab(tabId, message) {
+        const taggedSender = {
+          tab: { id: tabId }
+        };
+        return dispatch(message, taggedSender);
+      },
+      removeTab(tabId) {
+        removedTabs.add(tabId);
+      },
+      addTab(tabId) {
+        removedTabs.delete(tabId);
+      },
+      fireAlarm(name) {
+        const info = alarmMap.get(name);
+        if (info === void 0) return;
+        const alarm = {
+          name,
+          scheduledTime: Date.now(),
+          periodInMinutes: info.periodInMinutes
+        };
+        for (const listener of Array.from(alarmListeners)) {
+          listener(alarm);
+        }
+      },
+      getAlarms() {
+        return Array.from(alarmMap.keys());
+      },
+      fireTabActivated(info) {
+        for (const listener of Array.from(tabActivatedListeners)) {
+          listener(info);
+        }
+      },
+      fireTabUpdated(tabId, changeInfo, tab) {
+        for (const listener of Array.from(tabUpdatedListeners)) {
+          listener(tabId, changeInfo, tab);
+        }
+      },
+      fireTabRemoved(tabId, removeInfo) {
+        for (const listener of Array.from(tabRemovedListeners)) {
+          listener(tabId, removeInfo);
+        }
+      }
+    }
+  };
+}
 
 // src/extension/index.ts
 var MALFORMED = "chromeStorageStore: stored value is not a string";
@@ -24,6 +615,6 @@ function chromeStorageStore(key, parse, area = chrome.storage.local) {
   };
 }
 
-export { chromeStorageStore };
+export { bridgeClient, bridgeRuntime, bridgeTabClient, chromeStorageStore, createBackgroundRuntimeContext, fakeChrome, fromChromeAlarm, fromChromeMessage, fromChromeStorageChange, fromChromeTabsEvent, passThroughMsg, useBackgroundRuntime };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map