@calimero-network/mero-react 4.6.1 → 5.1.0

package/README.md

@@ -352,7 +352,6 @@ useGroupInfo, useGroupMembers, useGroupContexts, useGroupInvitations, useGroupCa
 useJoinGroup, useDeleteGroup, useAddGroupMembers, useRemoveGroupMembers
 useSyncGroup, useReparentGroup, useSubgroups
 useUpgradeGroup, useGroupUpgradeStatus, useRetryGroupUpgrade
-useRegisterGroupSigningKey, useUpdateGroupSettings
 useSetGroupMetadata, useSetMemberMetadata, useSetContextMetadata
 useGroupMetadata, useMemberMetadata, useUpdateMemberRole
 useSetDefaultCapabilities, useDefaultCapabilities

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));
 }
@@ -1464,7 +1643,6 @@ function useGroupMembers(groupId) {
   );
   return {
     members: data?.members ?? [],
-    selfIdentity: data?.selfIdentity ?? null,
     loading,
     error,
     refetch
@@ -1965,18 +2143,6 @@ function useSetTeeAdmissionPolicy() {
   );
   return { setTeeAdmissionPolicy, loading, error };
 }
-function useUpdateGroupSettings() {
-  const { mero } = useMero();
-  const { loading, error, run } = useAsyncMutation();
-  const updateGroupSettings = react.useCallback(
-    async (groupId, request) => {
-      if (!mero) return null;
-      return run(() => mero.admin.updateGroupSettings(groupId, request));
-    },
-    [mero, run]
-  );
-  return { updateGroupSettings, loading, error };
-}
 function useSetGroupMetadata() {
   const { mero } = useMero();
   const { loading, error, run } = useAsyncMutation();
@@ -2065,18 +2231,6 @@ function useMemberMetadata(groupId, identity) {
   }, [run]);
   return { metadata, loading, error, refetch };
 }
-function useRegisterGroupSigningKey() {
-  const { mero } = useMero();
-  const { loading, error, run } = useAsyncMutation();
-  const registerGroupSigningKey = react.useCallback(
-    async (groupId, request) => {
-      if (!mero) return null;
-      return run(() => mero.admin.registerGroupSigningKey(groupId, request));
-    },
-    [mero, run]
-  );
-  return { registerGroupSigningKey, loading, error };
-}
 function useUpgradeGroup() {
   const { mero } = useMero();
   const { loading, error, run } = useAsyncMutation();
@@ -2418,12 +2572,12 @@ function useGroupAppVersion(groupId) {
       if (namespace) {
         appKey = namespace.appKey;
         applicationId = namespace.targetApplicationId;
-        upgradePolicy = namespace.upgradePolicy;
+        upgradePolicy = namespace.upgradePolicy ?? null;
       } else {
         const info = await mero.admin.getGroupInfo(groupId);
         appKey = info.appKey;
         applicationId = info.targetApplicationId;
-        upgradePolicy = info.upgradePolicy;
+        upgradePolicy = info.upgradePolicy ?? null;
         activeUpgrade = info.activeUpgrade ?? null;
       }
       let version = null;
@@ -2690,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;
@@ -2714,7 +2869,6 @@ exports.useNamespaceGroups = useNamespaceGroups;
 exports.useNamespaceIdentity = useNamespaceIdentity;
 exports.useNamespaces = useNamespaces;
 exports.useNamespacesForApplication = useNamespacesForApplication;
-exports.useRegisterGroupSigningKey = useRegisterGroupSigningKey;
 exports.useRemoveGroupMembers = useRemoveGroupMembers;
 exports.useReparentGroup = useReparentGroup;
 exports.useResyncContext = useResyncContext;
@@ -2729,7 +2883,6 @@ exports.useSubgroupVisibility = useSubgroupVisibility;
 exports.useSubgroups = useSubgroups;
 exports.useSubscription = useSubscription;
 exports.useSyncGroup = useSyncGroup;
-exports.useUpdateGroupSettings = useUpdateGroupSettings;
 exports.useUpdateMemberRole = useUpdateMemberRole;
 exports.useUpgradeGroup = useUpgradeGroup;
 Object.keys(meroJs).forEach(function (k) {