@calimero-network/mero-react 5.0.0 → 5.1.0

package/dist/index.cjs

@@ -1266,6 +1266,185 @@ function base58ToHex(input) {
 }
 
 // src/hooks/index.ts
+var NO_EPHEMERAL_SURFACE_MESSAGE = "useEphemeral: this client has no `mero.ephemeral` surface. Ephemeral presence requires @calimero-network/mero-js >= 9.1.0; upgrade the installed @calimero-network/mero-js (and any lockfile pin) to use it.";
+var COULD_NOT_RESOLVE_IDENTITY_MESSAGE = "useEphemeral: could not resolve a local context identity, so your own presence cannot be filtered out. Pass includeSelf: true to accept this.";
+var REPLAY_RECONCILE_MS = 50;
+function useEphemeral(contextId, options = {}) {
+  const { includeSelf = false } = options;
+  const { mero } = useMero();
+  const ephemeral = mero ? mero.ephemeral ?? null : null;
+  const [peers, setPeers] = react.useState(/* @__PURE__ */ new Map());
+  const [latchedError, setLatchedError] = react.useState(null);
+  const contextKeyRef = react.useRef(contextId);
+  contextKeyRef.current = contextId;
+  const setSourceError = react.useCallback(
+    (source, err, key) => {
+      if (key !== contextKeyRef.current) return;
+      setLatchedError({ contextKey: key, source, error: err });
+    },
+    []
+  );
+  const clearSourceError = react.useCallback((source, key) => {
+    setLatchedError(
+      (prev) => prev && prev.source === source && prev.contextKey === key ? null : prev
+    );
+  }, []);
+  const surfaceError = react.useMemo(
+    () => mero && !ephemeral ? new Error(NO_EPHEMERAL_SURFACE_MESSAGE) : null,
+    [mero, ephemeral]
+  );
+  const error = surfaceError ?? (latchedError && latchedError.contextKey === contextId && !(latchedError.source === "identity" && includeSelf) ? latchedError.error : null);
+  const receivedAtRef = react.useRef(/* @__PURE__ */ new Map());
+  const codecRef = react.useRef(options.codec);
+  codecRef.current = options.codec;
+  const initialRef = react.useRef(options.initial);
+  initialRef.current = options.initial;
+  const selfRef = react.useRef(null);
+  const lastLocalRef = react.useRef(options.initial);
+  const pendingRef = react.useRef(void 0);
+  const timerRef = react.useRef(null);
+  const lastSentAtRef = react.useRef(Date.now());
+  const replaySeenRef = react.useRef(null);
+  const replayTimerRef = react.useRef(null);
+  const ageOf = react.useCallback((author) => {
+    const at = receivedAtRef.current.get(author);
+    return at === void 0 ? void 0 : Date.now() - at;
+  }, []);
+  react.useEffect(() => {
+    setPeers(/* @__PURE__ */ new Map());
+    receivedAtRef.current = /* @__PURE__ */ new Map();
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    if (replayTimerRef.current) {
+      clearTimeout(replayTimerRef.current);
+      replayTimerRef.current = null;
+    }
+    replaySeenRef.current = null;
+    pendingRef.current = void 0;
+    lastLocalRef.current = initialRef.current;
+    selfRef.current = null;
+    setLatchedError(null);
+  }, [contextId]);
+  react.useEffect(() => {
+    if (!mero || !contextId) return;
+    const key = contextId;
+    let cancelled = false;
+    mero.admin.getContextIdentitiesOwned(contextId).then((res) => {
+      if (cancelled) return;
+      const self = res.identities?.[0] ?? null;
+      selfRef.current = self;
+      if (!self) {
+        setSourceError("identity", new Error(COULD_NOT_RESOLVE_IDENTITY_MESSAGE), key);
+        return;
+      }
+      clearSourceError("identity", key);
+      if (!includeSelf) {
+        receivedAtRef.current.delete(self);
+        setPeers((prev) => {
+          if (!prev.has(self)) return prev;
+          const next = new Map(prev);
+          next.delete(self);
+          return next;
+        });
+      }
+    }).catch((err) => {
+      if (!cancelled) {
+        setSourceError("identity", toError(err), key);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [mero, contextId, includeSelf, setSourceError, clearSourceError]);
+  react.useEffect(() => {
+    if (!ephemeral || !contextId) return;
+    const closeReplayWindow = () => {
+      replayTimerRef.current = null;
+      const seen = replaySeenRef.current;
+      replaySeenRef.current = null;
+      if (!seen) return;
+      setPeers((prev) => {
+        let next = null;
+        for (const author of prev.keys()) {
+          if (seen.has(author)) continue;
+          if (!next) next = new Map(prev);
+          next.delete(author);
+          receivedAtRef.current.delete(author);
+        }
+        return next ?? prev;
+      });
+    };
+    const unsubscribe = ephemeral.subscribe(
+      contextId,
+      (entry) => {
+        const { author, state } = entry;
+        if (entry.ageMs !== void 0) {
+          if (!replaySeenRef.current) replaySeenRef.current = /* @__PURE__ */ new Set();
+          if (replayTimerRef.current) clearTimeout(replayTimerRef.current);
+          replayTimerRef.current = setTimeout(closeReplayWindow, REPLAY_RECONCILE_MS);
+        }
+        if (entry.removed || state === void 0) {
+          replaySeenRef.current?.delete(author);
+          receivedAtRef.current.delete(author);
+          setPeers((prev) => {
+            if (!prev.has(author)) return prev;
+            const next = new Map(prev);
+            next.delete(author);
+            return next;
+          });
+          return;
+        }
+        if (!includeSelf && author === selfRef.current) return;
+        replaySeenRef.current?.add(author);
+        receivedAtRef.current.set(author, Date.now() - (entry.ageMs ?? 0));
+        setPeers((prev) => new Map(prev).set(author, state));
+      },
+      codecRef.current
+    );
+    return () => {
+      if (replayTimerRef.current) {
+        clearTimeout(replayTimerRef.current);
+        replayTimerRef.current = null;
+      }
+      replaySeenRef.current = null;
+      unsubscribe();
+    };
+  }, [ephemeral, contextId, includeSelf]);
+  const publish = react.useCallback((value) => {
+    if (!ephemeral || !contextId) return;
+    const key = contextId;
+    lastSentAtRef.current = Date.now();
+    void ephemeral.set(key, value, codecRef.current).then(
+      () => clearSourceError("publish", key),
+      (err) => setSourceError("publish", toError(err), key)
+    );
+  }, [ephemeral, contextId, setSourceError, clearSourceError]);
+  const setPresence = react.useCallback((partial) => {
+    const next = { ...lastLocalRef.current ?? {}, ...partial };
+    lastLocalRef.current = next;
+    const throttleMs = options.throttleMs ?? 30;
+    if (throttleMs <= 0) {
+      publish(next);
+      return;
+    }
+    pendingRef.current = next;
+    if (timerRef.current) return;
+    const elapsed = Date.now() - lastSentAtRef.current;
+    const delay = Math.max(throttleMs - elapsed, 0);
+    timerRef.current = setTimeout(() => {
+      timerRef.current = null;
+      const queued = pendingRef.current;
+      pendingRef.current = void 0;
+      if (queued !== void 0) publish(queued);
+    }, delay);
+  }, [publish, options.throttleMs]);
+  react.useEffect(() => () => {
+    if (timerRef.current) clearTimeout(timerRef.current);
+  }, []);
+  return { peers, setPresence, ageOf, error };
+}
 function toError(err) {
   return err instanceof Error ? err : new Error(String(err));
 }
@@ -2665,6 +2844,7 @@ exports.useDeleteContext = useDeleteContext;
 exports.useDeleteGroup = useDeleteGroup;
 exports.useDeleteNamespace = useDeleteNamespace;
 exports.useDetachContextFromGroup = useDetachContextFromGroup;
+exports.useEphemeral = useEphemeral;
 exports.useExecute = useExecute;
 exports.useGroupAppVersion = useGroupAppVersion;
 exports.useGroupCapabilities = useGroupCapabilities;