easy-ping 0.7.0 → 0.8.0

package/dist/react-native.js

@@ -0,0 +1,609 @@
+// src/react-native/index.ts
+import { useMemo as useMemo2, useRef as useRef2 } from "react";
+import { AppState } from "react-native";
+
+// src/client/index.ts
+var INITIAL = {
+  notifications: [],
+  unseenCount: 0,
+  unreadCount: 0,
+  nextCursor: null,
+  isLoading: true,
+  error: null
+};
+var countUnread = (rows) => rows.reduce((total, row) => row.readAt === null ? total + 1 : total, 0);
+var SHORT_STREAM_MS = 15e3;
+var SHORT_STREAMS_BEFORE_GIVING_UP = 3;
+function createNotifyClient(options = {}) {
+  const baseUrl = (options.baseUrl ?? "/api/notifications").replace(/\/$/, "");
+  const doFetch = options.fetch ?? ((...args) => globalThis.fetch(...args));
+  const limit = options.limit ?? 20;
+  const pollIntervalMs = options.pollIntervalMs ?? 15e3;
+  const maxPollIntervalMs = options.maxPollIntervalMs ?? 10 * 6e4;
+  const safetyNetMs = options.safetyNetMs ?? 5 * 6e4;
+  const activeWindowMs = options.activeWindowMs ?? 6e4;
+  const now = options.now ?? (() => Date.now());
+  const groupKey = options.scope ? `${baseUrl}#${options.scope}` : baseUrl;
+  const hasDom = typeof window !== "undefined" && typeof document !== "undefined";
+  const transport = options.transport ?? "auto";
+  const wantsStream = transport === "sse" || transport === "auto" && hasDom;
+  const isHidden = options.isDocumentHidden ?? (() => typeof document !== "undefined" && document.visibilityState === "hidden");
+  const locks = options.locks === void 0 ? typeof navigator !== "undefined" ? navigator.locks ?? null : null : options.locks;
+  const makeChannel = options.channel === void 0 ? typeof BroadcastChannel !== "undefined" ? () => new BroadcastChannel(`easy-ping:${groupKey}`) : null : options.channel;
+  const serviceWorker = options.serviceWorker === void 0 ? typeof navigator !== "undefined" ? navigator.serviceWorker ?? null : null : options.serviceWorker;
+  const activityTarget = options.activityTarget === void 0 ? hasDom ? window : null : options.activityTarget;
+  let state = INITIAL;
+  const listeners = /* @__PURE__ */ new Set();
+  let role = "solo";
+  let running = false;
+  let channel;
+  let releaseLock;
+  let lockAbort;
+  let timer;
+  let consecutiveFailures = 0;
+  let idleTicks = 0;
+  let activeUntil = 0;
+  let lastRefreshAt = 0;
+  let refreshing;
+  let refreshAgain = false;
+  let streamAbort;
+  let streamConnected = false;
+  let streamDisabled = !wantsStream;
+  let shortStreams = 0;
+  let streamFailures = 0;
+  let generation = 0;
+  const localReads = /* @__PURE__ */ new Set();
+  let localSeen = false;
+  const stamp = () => (/* @__PURE__ */ new Date()).toISOString();
+  function emit() {
+    for (const listener of listeners) listener(state);
+  }
+  function set(patch) {
+    state = { ...state, ...patch };
+    state = { ...state, unreadCount: countUnread(state.notifications) };
+    emit();
+    if (role === "leader") post2({ type: "state", state });
+  }
+  function post2(message) {
+    try {
+      channel?.postMessage(message);
+    } catch {
+    }
+  }
+  async function request(path, init) {
+    const response = await doFetch(`${baseUrl}${path}`, {
+      ...init,
+      headers: { "content-type": "application/json", ...init?.headers }
+    });
+    if (!response.ok)
+      throw new Error(`${init?.method ?? "GET"} ${path} failed: ${response.status}`);
+    return await response.json();
+  }
+  async function fetchPage() {
+    const startedAt = generation;
+    const page = await request(`/?limit=${limit}`);
+    const unseenCount = page.unseenCount ?? (await request("/count")).unseen;
+    if (generation !== startedAt) return;
+    set({
+      notifications: page.notifications,
+      nextCursor: page.nextCursor,
+      unseenCount,
+      isLoading: false,
+      error: null
+    });
+  }
+  function refresh() {
+    if (refreshing) {
+      refreshAgain = true;
+      return refreshing;
+    }
+    refreshing = (async () => {
+      try {
+        do {
+          refreshAgain = false;
+          await fetchPage();
+          lastRefreshAt = now();
+        } while (refreshAgain);
+      } finally {
+        refreshing = void 0;
+      }
+    })();
+    return refreshing;
+  }
+  let loadingMore;
+  async function loadMore() {
+    if (!state.nextCursor) return;
+    if (loadingMore) return loadingMore;
+    const cursor = state.nextCursor;
+    loadingMore = (async () => {
+      try {
+        const page = await request(`/?limit=${limit}&cursor=${encodeURIComponent(cursor)}`);
+        const known = new Set(state.notifications.map((row) => row.id));
+        set({
+          notifications: [
+            ...state.notifications,
+            ...page.notifications.filter((row) => !known.has(row.id))
+          ],
+          nextCursor: page.nextCursor
+        });
+      } finally {
+        loadingMore = void 0;
+      }
+    })();
+    return loadingMore;
+  }
+  async function optimistic(apply, patch, send) {
+    const previous = state;
+    generation += 1;
+    set({ notifications: apply(state.notifications), ...patch });
+    try {
+      await send();
+      if (role === "follower") post2({ type: "mutated" });
+    } catch (error) {
+      generation += 1;
+      state = previous;
+      emit();
+      throw error;
+    }
+  }
+  async function markAsRead(id) {
+    if (role === "follower") localReads.add(id);
+    await optimistic(
+      (rows) => rows.map((row) => row.id === id ? { ...row, readAt: row.readAt ?? stamp() } : row),
+      {},
+      () => request("/read", { method: "POST", body: JSON.stringify({ ids: [id] }) })
+    ).catch((error) => {
+      localReads.delete(id);
+      throw error;
+    });
+  }
+  async function markAllRead() {
+    if (role === "follower") for (const row of state.notifications) localReads.add(row.id);
+    await optimistic(
+      (rows) => rows.map((row) => ({ ...row, readAt: row.readAt ?? stamp() })),
+      {},
+      () => request("/read-all", { method: "POST" })
+    ).catch((error) => {
+      localReads.clear();
+      throw error;
+    });
+  }
+  async function markSeen() {
+    const newest = state.notifications[0]?.createdAt;
+    if (role === "follower") localSeen = true;
+    await optimistic(
+      (rows) => rows.map((row) => ({ ...row, seenAt: row.seenAt ?? stamp() })),
+      { unseenCount: 0 },
+      () => request("/seen", {
+        method: "POST",
+        body: JSON.stringify(newest ? { before: newest } : {})
+      })
+    ).catch((error) => {
+      localSeen = false;
+      throw error;
+    });
+  }
+  function applyRemoteState(remote) {
+    const notifications = remote.notifications.map((row) => {
+      if (!localReads.has(row.id)) return row;
+      if (row.readAt) {
+        localReads.delete(row.id);
+        return row;
+      }
+      return { ...row, readAt: stamp() };
+    });
+    if (localSeen && remote.unseenCount === 0) localSeen = false;
+    state = {
+      ...remote,
+      notifications,
+      unseenCount: localSeen ? 0 : remote.unseenCount,
+      unreadCount: countUnread(notifications)
+    };
+    emit();
+  }
+  function onTabMessage(event) {
+    const message = event.data;
+    if (!message || typeof message !== "object") return;
+    if (role === "leader") {
+      if (message.type === "hello") post2({ type: "state", state });
+      else if (message.type === "mutated") void refresh().catch(() => {
+      });
+      return;
+    }
+    if (message.type === "state") applyRemoteState(message.state);
+  }
+  function schedule(delay) {
+    clearTimeout(timer);
+    timer = setTimeout(tick, delay);
+  }
+  function nextDelay() {
+    if (consecutiveFailures > 0) {
+      return Math.min(pollIntervalMs * 2 ** consecutiveFailures, maxPollIntervalMs);
+    }
+    if (streamConnected) return safetyNetMs;
+    if (now() < activeUntil) return pollIntervalMs;
+    idleTicks += 1;
+    return Math.min(pollIntervalMs * 2 ** idleTicks, maxPollIntervalMs);
+  }
+  async function tick() {
+    if (!running) return;
+    if (isHidden()) {
+      schedule(pollIntervalMs);
+      return;
+    }
+    try {
+      await refresh();
+      consecutiveFailures = 0;
+    } catch (error) {
+      consecutiveFailures += 1;
+      set({ isLoading: false, error: error instanceof Error ? error : new Error(String(error)) });
+    }
+    if (running) schedule(nextDelay());
+  }
+  function onActivity() {
+    if (!running || role === "follower") return;
+    activeUntil = now() + activeWindowMs;
+    idleTicks = 0;
+    if (!isHidden() && now() - lastRefreshAt > pollIntervalMs) {
+      void refresh().catch(() => {
+      });
+      schedule(nextDelay());
+    }
+  }
+  const onVisibility = () => {
+    if (!isHidden()) onActivity();
+  };
+  const ACTIVITY_EVENTS = ["focus", "pointerdown", "keydown", "online"];
+  function changed() {
+    if (!running) return;
+    void refresh().catch(() => {
+    });
+  }
+  async function readStream(signal) {
+    const openedAt = now();
+    const response = await doFetch(`${baseUrl}/events`, {
+      headers: { accept: "text/event-stream" },
+      signal
+    });
+    if (!response.ok) throw new Error(`GET /events failed: ${response.status}`);
+    if (!response.body) {
+      streamDisabled = true;
+      schedule(nextDelay());
+      return;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let eventName = "";
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        let newline = buffer.indexOf("\n");
+        while (newline >= 0) {
+          const line = buffer.slice(0, newline).replace(/\r$/, "");
+          buffer = buffer.slice(newline + 1);
+          if (line === "") {
+            if (eventName === "ready") {
+              streamConnected = true;
+              streamFailures = 0;
+              schedule(nextDelay());
+            } else if (eventName === "changed") changed();
+            eventName = "";
+          } else if (line.startsWith("event:")) eventName = line.slice(6).trim();
+          newline = buffer.indexOf("\n");
+        }
+      }
+    } finally {
+      streamConnected = false;
+      if (now() - openedAt < SHORT_STREAM_MS) shortStreams += 1;
+      else shortStreams = 0;
+    }
+  }
+  const isFollower = () => role === "follower";
+  async function streamLoop() {
+    while (running && !streamDisabled && !isFollower()) {
+      streamAbort = new AbortController();
+      try {
+        await readStream(streamAbort.signal);
+      } catch {
+        if (!running) return;
+        streamFailures += 1;
+      }
+      if (!running || isFollower() || streamDisabled) return;
+      if (shortStreams >= SHORT_STREAMS_BEFORE_GIVING_UP) {
+        streamDisabled = true;
+        schedule(nextDelay());
+        return;
+      }
+      await new Promise(
+        (resolve) => setTimeout(resolve, Math.min(3e3 * 2 ** streamFailures, 6e4))
+      );
+    }
+  }
+  function becomeLeader() {
+    role = "leader";
+    post2({ type: "leader" });
+    post2({ type: "state", state });
+    void tick();
+    if (!streamDisabled) void streamLoop();
+  }
+  function becomeFollower() {
+    role = "follower";
+    post2({ type: "hello" });
+  }
+  function acquireLeadership() {
+    if (!locks || !channel) {
+      role = "solo";
+      void tick();
+      if (!streamDisabled) void streamLoop();
+      return;
+    }
+    becomeFollower();
+    lockAbort = new AbortController();
+    locks.request(
+      `easy-ping:leader:${groupKey}`,
+      { mode: "exclusive", signal: lockAbort.signal },
+      () => new Promise((resolve) => {
+        releaseLock = resolve;
+        if (running) becomeLeader();
+        else resolve();
+      })
+    ).catch(() => {
+    });
+  }
+  function start() {
+    running = true;
+    channel = makeChannel ? makeChannel() : void 0;
+    channel?.addEventListener("message", onTabMessage);
+    serviceWorker?.addEventListener("message", onRelay);
+    if (activityTarget) {
+      for (const name of ACTIVITY_EVENTS) activityTarget.addEventListener(name, onActivity);
+    }
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", onVisibility);
+    }
+    activeUntil = now() + activeWindowMs;
+    acquireLeadership();
+  }
+  function stop() {
+    running = false;
+    clearTimeout(timer);
+    timer = void 0;
+    streamAbort?.abort();
+    streamAbort = void 0;
+    lockAbort?.abort();
+    lockAbort = void 0;
+    releaseLock?.();
+    releaseLock = void 0;
+    channel?.removeEventListener("message", onTabMessage);
+    channel?.close();
+    channel = void 0;
+    serviceWorker?.removeEventListener("message", onRelay);
+    if (activityTarget) {
+      for (const name of ACTIVITY_EVENTS) activityTarget.removeEventListener(name, onActivity);
+    }
+    if (typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", onVisibility);
+    }
+    role = "solo";
+  }
+  function onRelay(event) {
+    const data = event.data;
+    if (data?.source === "easy-ping" && data.type === "changed") changed();
+  }
+  let lastInboxVersion = null;
+  const sameOrigin = (response) => {
+    if (!response.url || typeof location === "undefined") return true;
+    try {
+      return new URL(response.url).origin === location.origin;
+    } catch {
+      return false;
+    }
+  };
+  function instrument(inner) {
+    return (async (...args) => {
+      const response = await inner(...args);
+      const version = sameOrigin(response) ? response.headers.get("x-easy-ping-inbox") : null;
+      if (version !== null && version !== lastInboxVersion) {
+        const first = lastInboxVersion === null;
+        lastInboxVersion = version;
+        if (!first && role !== "follower") changed();
+      }
+      return response;
+    });
+  }
+  function subscribe(listener) {
+    listeners.add(listener);
+    listener(state);
+    if (listeners.size === 1) start();
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) stop();
+    };
+  }
+  return {
+    subscribe,
+    refresh,
+    loadMore,
+    markAsRead,
+    markAllRead,
+    markSeen,
+    instrument,
+    getState: () => state,
+    getTransport: () => ({
+      role,
+      transport: streamDisabled ? "poll" : "sse",
+      connected: streamConnected
+    })
+  };
+}
+
+// src/react/index.ts
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+function useNotifications(options = {}) {
+  const {
+    client: provided,
+    baseUrl,
+    limit,
+    pollIntervalMs,
+    maxPollIntervalMs,
+    safetyNetMs,
+    activeWindowMs,
+    transport
+  } = options;
+  const callbacksRef = useRef(options);
+  callbacksRef.current = options;
+  const client = useMemo(
+    () => provided ?? createNotifyClient({
+      baseUrl,
+      limit,
+      pollIntervalMs,
+      maxPollIntervalMs,
+      safetyNetMs,
+      activeWindowMs,
+      transport,
+      fetch: (...args) => (callbacksRef.current.fetch ?? globalThis.fetch)(...args),
+      isDocumentHidden: () => callbacksRef.current.isDocumentHidden?.() ?? (typeof document !== "undefined" && document.visibilityState === "hidden")
+    }),
+    [
+      provided,
+      baseUrl,
+      limit,
+      pollIntervalMs,
+      maxPollIntervalMs,
+      safetyNetMs,
+      activeWindowMs,
+      transport
+    ]
+  );
+  const [state, setState] = useState(() => client.getState());
+  useEffect(() => client.subscribe(setState), [client]);
+  return {
+    ...state,
+    markAsRead: useCallback((id) => client.markAsRead(id), [client]),
+    markAllRead: useCallback(() => client.markAllRead(), [client]),
+    markSeen: useCallback(() => client.markSeen(), [client]),
+    loadMore: useCallback(() => client.loadMore(), [client]),
+    refresh: useCallback(() => client.refresh(), [client])
+  };
+}
+
+// src/react-native/index.ts
+function appStateTarget(appState) {
+  const listeners = /* @__PURE__ */ new Map();
+  let subscription;
+  let last = appState.currentState;
+  const ensure = () => {
+    subscription ??= appState.addEventListener("change", (state) => {
+      if (state === "active" && last !== "active") {
+        for (const listener of listeners.get("focus") ?? []) listener({});
+      }
+      last = state;
+    });
+  };
+  return {
+    addEventListener(type, handler) {
+      listeners.set(type, (listeners.get(type) ?? /* @__PURE__ */ new Set()).add(handler));
+      ensure();
+    },
+    removeEventListener(type, handler) {
+      listeners.get(type)?.delete(handler);
+      if ([...listeners.values()].every((set) => set.size === 0)) {
+        subscription?.remove();
+        subscription = void 0;
+      }
+    }
+  };
+}
+function createNativeNotifyClient(options = {}) {
+  const { appState = AppState, ...rest } = options;
+  return createNotifyClient({
+    transport: "sse",
+    ...rest,
+    locks: null,
+    channel: null,
+    serviceWorker: null,
+    isDocumentHidden: () => appState.currentState !== "active",
+    activityTarget: appStateTarget(appState)
+  });
+}
+function useNotifications2(options = {}) {
+  const {
+    client: provided,
+    baseUrl,
+    limit,
+    pollIntervalMs,
+    maxPollIntervalMs,
+    safetyNetMs,
+    activeWindowMs,
+    transport,
+    scope,
+    appState
+  } = options;
+  const fetchRef = useRef2(options.fetch);
+  fetchRef.current = options.fetch;
+  const client = useMemo2(
+    () => provided ?? createNativeNotifyClient({
+      baseUrl,
+      limit,
+      pollIntervalMs,
+      maxPollIntervalMs,
+      safetyNetMs,
+      activeWindowMs,
+      transport,
+      scope,
+      appState,
+      fetch: (...args) => (fetchRef.current ?? globalThis.fetch)(...args)
+    }),
+    [
+      provided,
+      baseUrl,
+      limit,
+      pollIntervalMs,
+      maxPollIntervalMs,
+      safetyNetMs,
+      activeWindowMs,
+      transport,
+      scope,
+      appState
+    ]
+  );
+  return useNotifications({ client });
+}
+var post = async (doFetch, url, body) => doFetch(url, {
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify(body)
+});
+async function registerMobilePushDevice(options) {
+  const base = (options.baseUrl ?? "/api/notifications").replace(/\/$/, "");
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const response = await post(doFetch, `${base}/mobile-push/devices`, {
+    token: options.token,
+    platform: options.platform,
+    deviceName: options.deviceName
+  });
+  if (!response.ok) {
+    const detail = await response.json().catch(() => ({}));
+    throw new Error(detail.error ?? `registering the device failed: ${response.status}`);
+  }
+}
+async function unregisterMobilePushDevice(options) {
+  const base = (options.baseUrl ?? "/api/notifications").replace(/\/$/, "");
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const response = await post(doFetch, `${base}/mobile-push/devices/remove`, {
+    token: options.token
+  });
+  if (response.status === 404) return false;
+  if (!response.ok) throw new Error(`unregistering the device failed: ${response.status}`);
+  return true;
+}
+export {
+  createNativeNotifyClient,
+  registerMobilePushDevice,
+  unregisterMobilePushDevice,
+  useNotifications2 as useNotifications
+};
+//# sourceMappingURL=react-native.js.map