@calimero-network/mero-react 5.0.0 → 6.0.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));
 }
@@ -1811,6 +1990,15 @@ function useNamespace(namespaceId) {
   );
   return { namespace: data, loading, error, refetch };
 }
+function useNodeIdentity() {
+  const { mero } = useMero();
+  const { data, loading, error, refetch } = useAsyncResource(
+    mero ? () => mero.admin.getNodeIdentity() : null,
+    null,
+    [mero]
+  );
+  return { identity: data, loading, error, refetch };
+}
 function useNamespaceIdentity(namespaceId) {
   const { mero } = useMero();
   const { data, loading, error, refetch } = useAsyncResource(
@@ -2180,6 +2368,35 @@ function useDetachContextFromGroup() {
   );
   return { detachContextFromGroup, loading, error };
 }
+var DEFAULT_MIGRATION_POLL_INTERVAL_MS = 5e3;
+function useMigrationEvents(namespaceId, onEvent) {
+  const { mero } = useMero();
+  const mountedRef = useMountedRef();
+  const [live, setLive] = react.useState(false);
+  const handlerRef = react.useRef(onEvent);
+  handlerRef.current = onEvent;
+  react.useEffect(() => {
+    if (!mero || !namespaceId) return;
+    const sse = mero.events;
+    const unsubscribe = sse.onMigrationEvent((event) => handlerRef.current(event));
+    let cancelled = false;
+    void (async () => {
+      try {
+        await sse.connect();
+        await sse.subscribe({ groupIds: [namespaceId] });
+        if (!cancelled && mountedRef.current) setLive(true);
+      } catch {
+        if (!cancelled && mountedRef.current) setLive(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+      if (mountedRef.current) setLive(false);
+      unsubscribe();
+    };
+  }, [mero, namespaceId, mountedRef]);
+  return live;
+}
 function useMigrationStatus(namespaceId, options) {
   const { mero } = useMero();
   const [status, setStatus] = react.useState(null);
@@ -2224,7 +2441,8 @@ function useMigrationStatus(namespaceId, options) {
   react.useEffect(() => {
     void refetch();
   }, [refetch]);
-  const pollIntervalMs = options?.pollIntervalMs;
+  const sseLive = useMigrationEvents(namespaceId, () => void refetch());
+  const pollIntervalMs = options?.pollIntervalMs ?? (sseLive ? void 0 : DEFAULT_MIGRATION_POLL_INTERVAL_MS);
   react.useEffect(() => {
     if (!pollIntervalMs || !mero || !namespaceId) return;
     const handle = setInterval(() => void refetch(), pollIntervalMs);
@@ -2237,6 +2455,12 @@ function useMigrationStatus(namespaceId, options) {
     rollup,
     members,
     allMigrated: rollup?.allMigrated ?? false,
+    /**
+     * When this node watched the fleet converge, or `null`. Durable, unlike
+     * `allMigrated`, which is recomputed from in-TTL heartbeats and lapses back
+     * to false when a member simply goes quiet.
+     */
+    fleetCompletedAt: status?.fleetCompletedAt ?? null,
     membersPendingSignature: rollup?.membersPendingSignature ?? 0,
     /** Members whose migrate aborted (migration-check failed or apply errored). */
     failed: rollup?.failed ?? 0,
@@ -2356,7 +2580,6 @@ var EMPTY_GROUP_APP_VERSION = {
   version: null,
   applicationId: null,
   pendingApply: false,
-  upgradePolicy: null,
   activeUpgrade: null
 };
 function isZeroAppKey(appKey) {
@@ -2388,17 +2611,14 @@ function useGroupAppVersion(groupId) {
       const namespace = namespaces.find((entry) => entry.namespaceId === groupId);
       let appKey;
       let applicationId;
-      let upgradePolicy;
       let activeUpgrade = null;
       if (namespace) {
         appKey = namespace.appKey;
         applicationId = namespace.targetApplicationId;
-        upgradePolicy = namespace.upgradePolicy ?? null;
       } else {
         const info = await mero.admin.getGroupInfo(groupId);
         appKey = info.appKey;
         applicationId = info.targetApplicationId;
-        upgradePolicy = info.upgradePolicy ?? null;
         activeUpgrade = info.activeUpgrade ?? null;
       }
       let version = null;
@@ -2412,7 +2632,7 @@ function useGroupAppVersion(groupId) {
         }
       }
       if (mountedRef.current && seq === reqRef.current) {
-        setData({ version, applicationId, pendingApply, upgradePolicy, activeUpgrade });
+        setData({ version, applicationId, pendingApply, activeUpgrade });
       }
     } catch (err) {
       const errorValue = toError(err);
@@ -2623,6 +2843,7 @@ exports.AppMode = AppMode;
 exports.CalimeroLogo = CalimeroLogo;
 exports.ConnectButton = ConnectButton;
 exports.ConnectionType = ConnectionType;
+exports.DEFAULT_MIGRATION_POLL_INTERVAL_MS = DEFAULT_MIGRATION_POLL_INTERVAL_MS;
 exports.LoginModal = LoginModal;
 exports.MERO_CSS_VARS = MERO_CSS_VARS;
 exports.MeroContext = MeroContext;
@@ -2665,6 +2886,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;
@@ -2682,6 +2904,7 @@ exports.useJoinSubgroupInheritance = useJoinSubgroupInheritance;
 exports.useLatestVersion = useLatestVersion;
 exports.useMemberMetadata = useMemberMetadata;
 exports.useMero = useMero;
+exports.useMigrationEvents = useMigrationEvents;
 exports.useMigrationStatus = useMigrationStatus;
 exports.useMyAuthoredMigration = useMyAuthoredMigration;
 exports.useNamespace = useNamespace;
@@ -2689,6 +2912,7 @@ exports.useNamespaceGroups = useNamespaceGroups;
 exports.useNamespaceIdentity = useNamespaceIdentity;
 exports.useNamespaces = useNamespaces;
 exports.useNamespacesForApplication = useNamespacesForApplication;
+exports.useNodeIdentity = useNodeIdentity;
 exports.useRemoveGroupMembers = useRemoveGroupMembers;
 exports.useReparentGroup = useReparentGroup;
 exports.useResyncContext = useResyncContext;