@automerge/automerge-repo-react-hooks 2.4.0 → 2.5.0-alpha.1

package/dist/index.js

@@ -1,18 +1,18 @@
-import q, { createContext as I, useContext as j, useRef as $, useState as E, useEffect as g, useCallback as R } from "react";
-function O(o) {
-  let i = "pending", n, f;
-  const h = o.then(
+import q, { createContext as I, useContext as j, useRef as $, useState as E, useEffect as y, useCallback as R } from "react";
+function O(s) {
+  let u = "pending", n, f;
+  const h = s.then(
     (p) => {
-      i = "success", n = p;
+      u = "success", n = p;
     },
     (p) => {
-      i = "error", f = p;
+      u = "error", f = p;
     }
   );
   return {
-    promise: o,
+    promise: s,
     read() {
-      switch (i) {
+      switch (u) {
         case "pending":
           throw h;
         case "error":
@@ -25,46 +25,46 @@ function O(o) {
 }
 const z = I(null);
 function k() {
-  const o = j(z);
-  if (!o) throw new Error("Repo was not found on RepoContext.");
-  return o;
+  const s = j(z);
+  if (!s) throw new Error("Repo was not found on RepoContext.");
+  return s;
 }
 const x = /* @__PURE__ */ new Map();
-function F(o, { suspense: i } = { suspense: !1 }) {
+function F(s, { suspense: u } = { suspense: !1 }) {
   const n = k(), f = $(), [h, p] = E();
-  let u = h;
-  if (o && !u) {
-    const e = n.findWithProgress(o);
-    e.state === "ready" && (u = e.handle);
+  let i = h;
+  if (s && !i) {
+    const e = n.findWithProgress(s);
+    e.state === "ready" && (i = e.handle);
   }
-  let r = o ? x.get(o) : void 0;
-  if (!r && o) {
+  let r = s ? x.get(s) : void 0;
+  if (!r && s) {
     f.current?.abort(), f.current = new AbortController();
-    const e = n.find(o, { signal: f.current.signal });
-    r = O(e), x.set(o, r);
+    const e = n.find(s, { signal: f.current.signal });
+    r = O(e), x.set(s, r);
   }
-  return g(() => {
-    u || i || !r || r.promise.then((e) => {
+  return y(() => {
+    i || u || !r || r.promise.then((e) => {
       p(e);
     }).catch(() => {
       p(void 0);
     });
-  }, [u, i, r]), u || !i || !r ? u : r.read();
+  }, [i, u, r]), i || !u || !r ? i : r.read();
 }
-function X(o, i = { suspense: !1 }) {
-  const n = F(o, i), [f, h] = E(() => n?.doc()), [p, u] = E();
-  g(() => {
+function X(s, u = { suspense: !1 }) {
+  const n = F(s, u), [f, h] = E(() => n?.doc()), [p, i] = E();
+  y(() => {
     h(n?.doc());
-  }, [n]), g(() => {
+  }, [n]), y(() => {
     if (!n)
       return;
     const e = () => h(n.doc()), t = () => {
-      u(new Error(`Document ${o} was deleted`));
+      i(new Error(`Document ${s} was deleted`));
     };
     return n.on("change", e), n.on("delete", t), () => {
       n.removeListener("change", e), n.removeListener("delete", t);
     };
-  }, [n, o]);
+  }, [n, s]);
   const r = R(
     (e, t) => {
       n.change(e, t);
@@ -76,82 +76,82 @@ function X(o, i = { suspense: !1 }) {
   return f ? [f, r] : [void 0, () => {
   }];
 }
-function N(o) {
-  const [i, n] = E(() => new Set(o));
-  return g(() => {
-    const f = new Set(o);
-    W(i, f) || n(f);
-  }, [i, o]), i;
+function N(s) {
+  const [u, n] = E(() => new Set(s));
+  return y(() => {
+    const f = new Set(s);
+    W(u, f) || n(f);
+  }, [u, s]), u;
 }
-function W(o, i) {
-  return o.size === i.size && Array.from(o).every((n) => i.has(n));
+function W(s, u) {
+  return s.size === u.size && Array.from(s).every((n) => u.has(n));
 }
-function T(o, { suspense: i = !1 } = {}) {
-  const n = N(o), f = k(), [h, p] = E(() => {
+function T(s, { suspense: u = !1 } = {}) {
+  const n = N(s), f = k(), [h, p] = E(() => {
     const e = /* @__PURE__ */ new Map();
     for (const t of n.values()) {
-      let s;
+      let o;
       try {
-        s = f.findWithProgress(t);
+        o = f.findWithProgress(t);
       } catch {
         continue;
       }
-      s.state === "ready" && e.set(t, s.handle);
+      o.state === "ready" && e.set(t, o.handle);
     }
     return e;
-  }), u = [], r = /* @__PURE__ */ new Map();
+  }), i = [], r = /* @__PURE__ */ new Map();
   for (const e of n.values()) {
-    let t = h.get(e), s = x.get(e);
-    if (!s)
+    let t = h.get(e), o = x.get(e);
+    if (!o)
       try {
         const c = f.find(e);
-        s = O(c), x.set(e, s);
+        o = O(c), x.set(e, o);
       } catch {
         continue;
       }
     try {
-      t ??= s.read(), r.set(e, t);
+      t ??= o.read(), r.set(e, t);
     } catch (c) {
-      c instanceof Promise ? u.push(s) : r.set(e, void 0);
+      c instanceof Promise ? i.push(o) : r.set(e, void 0);
     }
   }
-  if (g(() => {
-    u.length > 0 ? Promise.allSettled(u.map((e) => e.promise)).then(
+  if (y(() => {
+    i.length > 0 ? Promise.allSettled(i.map((e) => e.promise)).then(
       (e) => {
         e.forEach((t) => {
           if (t.status === "fulfilled") {
-            const s = t.value;
-            r.set(s.url, s);
+            const o = t.value;
+            r.set(o.url, o);
           }
         }), p(r);
       }
     ) : p(r);
-  }, [i, n]), i && u.length > 0)
-    throw Promise.all(u.map((e) => e.promise));
+  }, [u, n]), u && i.length > 0)
+    throw Promise.all(i.map((e) => e.promise));
   return h;
 }
-function Y(o, { suspense: i = !0 } = {}) {
-  const n = T(o, { suspense: i }), [f, h] = E(() => {
-    const u = /* @__PURE__ */ new Map();
+function Y(s, { suspense: u = !0 } = {}) {
+  const n = T(s, { suspense: u }), [f, h] = E(() => {
+    const i = /* @__PURE__ */ new Map();
     return n.forEach((r) => {
       const e = r?.url;
-      e && u.set(e, r?.doc());
-    }), u;
+      e && i.set(e, r?.doc());
+    }), i;
   });
-  g(() => {
-    const u = /* @__PURE__ */ new Map();
+  y(() => {
+    const i = /* @__PURE__ */ new Map();
     return n.forEach((r, e) => {
       if (r) {
         const t = () => {
-          h((s) => {
-            const c = new Map(s);
+          h((o) => {
+            const c = new Map(o);
             return c.set(e, r.doc()), c;
           });
         };
-        h((s) => {
-          const c = new Map(s);
+        h((o) => {
+          const c = new Map(o);
           return c.set(e, r.doc()), c;
-        }), r.on("change", t), u.set(e, t);
+        }), r.on("change", t), i.set(e, t);
       }
     }), h((r) => {
       const e = new Map(r);
@@ -160,32 +160,32 @@ function Y(o, { suspense: i = !0 } = {}) {
       return e;
     }), () => {
       n.forEach((r, e) => {
-        const t = u.get(e);
+        const t = i.get(e);
         r && t && r.removeListener("change", t);
       });
     };
   }, [n]);
   const p = R(
-    (u, r, e) => {
-      const t = n.get(u);
+    (i, r, e) => {
+      const t = n.get(i);
       t && t.change(r, e);
     },
     [n]
   );
   return [f, p];
 }
-function A(o) {
-  return o && o.__esModule && Object.prototype.hasOwnProperty.call(o, "default") ? o.default : o;
+function A(s) {
+  return s && s.__esModule && Object.prototype.hasOwnProperty.call(s, "default") ? s.default : s;
 }
 var S, M;
 function B() {
   if (M) return S;
   M = 1;
-  var o = q, i = function(f) {
+  var s = q, u = function(f) {
     return typeof f == "function";
   }, n = function(f) {
-    var h = o.useState(f), p = h[0], u = h[1], r = o.useRef(p), e = o.useCallback(function(t) {
-      r.current = i(t) ? t(r.current) : t, u(r.current);
+    var h = s.useState(f), p = h[0], i = h[1], r = s.useRef(p), e = s.useCallback(function(t) {
+      r.current = u(t) ? t(r.current) : t, i(r.current);
     }, []);
     return [p, e, r];
   };
@@ -195,166 +195,171 @@ var G = B();
 const D = /* @__PURE__ */ A(G);
 var C = { exports: {} }, P;
 function J() {
-  return P || (P = 1, function(o) {
-    var i = Object.prototype.hasOwnProperty, n = "~";
+  return P || (P = 1, function(s) {
+    var u = Object.prototype.hasOwnProperty, n = "~";
     function f() {
     }
     Object.create && (f.prototype = /* @__PURE__ */ Object.create(null), new f().__proto__ || (n = !1));
-    function h(e, t, s) {
-      this.fn = e, this.context = t, this.once = s || !1;
+    function h(e, t, o) {
+      this.fn = e, this.context = t, this.once = o || !1;
     }
-    function p(e, t, s, c, w) {
-      if (typeof s != "function")
+    function p(e, t, o, c, w) {
+      if (typeof o != "function")
         throw new TypeError("The listener must be a function");
-      var v = new h(s, c || e, w), l = n ? n + t : t;
+      var v = new h(o, c || e, w), l = n ? n + t : t;
       return e._events[l] ? e._events[l].fn ? e._events[l] = [e._events[l], v] : e._events[l].push(v) : (e._events[l] = v, e._eventsCount++), e;
     }
-    function u(e, t) {
+    function i(e, t) {
       --e._eventsCount === 0 ? e._events = new f() : delete e._events[t];
     }
     function r() {
       this._events = new f(), this._eventsCount = 0;
     }
     r.prototype.eventNames = function() {
-      var t = [], s, c;
+      var t = [], o, c;
       if (this._eventsCount === 0) return t;
-      for (c in s = this._events)
-        i.call(s, c) && t.push(n ? c.slice(1) : c);
-      return Object.getOwnPropertySymbols ? t.concat(Object.getOwnPropertySymbols(s)) : t;
+      for (c in o = this._events)
+        u.call(o, c) && t.push(n ? c.slice(1) : c);
+      return Object.getOwnPropertySymbols ? t.concat(Object.getOwnPropertySymbols(o)) : t;
     }, r.prototype.listeners = function(t) {
-      var s = n ? n + t : t, c = this._events[s];
+      var o = n ? n + t : t, c = this._events[o];
       if (!c) return [];
       if (c.fn) return [c.fn];
       for (var w = 0, v = c.length, l = new Array(v); w < v; w++)
         l[w] = c[w].fn;
       return l;
     }, r.prototype.listenerCount = function(t) {
-      var s = n ? n + t : t, c = this._events[s];
+      var o = n ? n + t : t, c = this._events[o];
       return c ? c.fn ? 1 : c.length : 0;
-    }, r.prototype.emit = function(t, s, c, w, v, l) {
+    }, r.prototype.emit = function(t, o, c, w, v, l) {
       var m = n ? n + t : t;
       if (!this._events[m]) return !1;
-      var a = this._events[m], y = arguments.length, _, d;
+      var a = this._events[m], g = arguments.length, _, d;
       if (a.fn) {
-        switch (a.once && this.removeListener(t, a.fn, void 0, !0), y) {
+        switch (a.once && this.removeListener(t, a.fn, void 0, !0), g) {
           case 1:
             return a.fn.call(a.context), !0;
           case 2:
-            return a.fn.call(a.context, s), !0;
+            return a.fn.call(a.context, o), !0;
           case 3:
-            return a.fn.call(a.context, s, c), !0;
+            return a.fn.call(a.context, o, c), !0;
           case 4:
-            return a.fn.call(a.context, s, c, w), !0;
+            return a.fn.call(a.context, o, c, w), !0;
           case 5:
-            return a.fn.call(a.context, s, c, w, v), !0;
+            return a.fn.call(a.context, o, c, w, v), !0;
           case 6:
-            return a.fn.call(a.context, s, c, w, v, l), !0;
+            return a.fn.call(a.context, o, c, w, v, l), !0;
         }
-        for (d = 1, _ = new Array(y - 1); d < y; d++)
+        for (d = 1, _ = new Array(g - 1); d < g; d++)
           _[d - 1] = arguments[d];
         a.fn.apply(a.context, _);
       } else {
         var H = a.length, b;
         for (d = 0; d < H; d++)
-          switch (a[d].once && this.removeListener(t, a[d].fn, void 0, !0), y) {
+          switch (a[d].once && this.removeListener(t, a[d].fn, void 0, !0), g) {
             case 1:
               a[d].fn.call(a[d].context);
               break;
             case 2:
-              a[d].fn.call(a[d].context, s);
+              a[d].fn.call(a[d].context, o);
               break;
             case 3:
-              a[d].fn.call(a[d].context, s, c);
+              a[d].fn.call(a[d].context, o, c);
               break;
             case 4:
-              a[d].fn.call(a[d].context, s, c, w);
+              a[d].fn.call(a[d].context, o, c, w);
               break;
             default:
-              if (!_) for (b = 1, _ = new Array(y - 1); b < y; b++)
+              if (!_) for (b = 1, _ = new Array(g - 1); b < g; b++)
                 _[b - 1] = arguments[b];
               a[d].fn.apply(a[d].context, _);
           }
       }
       return !0;
-    }, r.prototype.on = function(t, s, c) {
-      return p(this, t, s, c, !1);
-    }, r.prototype.once = function(t, s, c) {
-      return p(this, t, s, c, !0);
-    }, r.prototype.removeListener = function(t, s, c, w) {
+    }, r.prototype.on = function(t, o, c) {
+      return p(this, t, o, c, !1);
+    }, r.prototype.once = function(t, o, c) {
+      return p(this, t, o, c, !0);
+    }, r.prototype.removeListener = function(t, o, c, w) {
       var v = n ? n + t : t;
       if (!this._events[v]) return this;
-      if (!s)
-        return u(this, v), this;
+      if (!o)
+        return i(this, v), this;
       var l = this._events[v];
       if (l.fn)
-        l.fn === s && (!w || l.once) && (!c || l.context === c) && u(this, v);
+        l.fn === o && (!w || l.once) && (!c || l.context === c) && i(this, v);
       else {
-        for (var m = 0, a = [], y = l.length; m < y; m++)
-          (l[m].fn !== s || w && !l[m].once || c && l[m].context !== c) && a.push(l[m]);
-        a.length ? this._events[v] = a.length === 1 ? a[0] : a : u(this, v);
+        for (var m = 0, a = [], g = l.length; m < g; m++)
+          (l[m].fn !== o || w && !l[m].once || c && l[m].context !== c) && a.push(l[m]);
+        a.length ? this._events[v] = a.length === 1 ? a[0] : a : i(this, v);
       }
       return this;
     }, r.prototype.removeAllListeners = function(t) {
-      var s;
-      return t ? (s = n ? n + t : t, this._events[s] && u(this, s)) : (this._events = new f(), this._eventsCount = 0), this;
-    }, r.prototype.off = r.prototype.removeListener, r.prototype.addListener = r.prototype.on, r.prefixed = n, r.EventEmitter = r, o.exports = r;
+      var o;
+      return t ? (o = n ? n + t : t, this._events[o] && i(this, o)) : (this._events = new f(), this._eventsCount = 0), this;
+    }, r.prototype.off = r.prototype.removeListener, r.prototype.addListener = r.prototype.on, r.prefixed = n, r.EventEmitter = r, s.exports = r;
   }(C)), C.exports;
 }
 var K = J();
 const Q = /* @__PURE__ */ A(K), L = new Q(), Z = ({
-  handle: o,
-  localUserId: i,
+  handle: s,
+  localUserId: u,
   offlineTimeout: n = 3e4,
   getTime: f = () => (/* @__PURE__ */ new Date()).getTime()
 }) => {
-  const [h, p, u] = D({}), [r, e, t] = D({});
-  return g(() => {
-    const s = (v) => {
+  const [h, p, i] = D({}), [r, e, t] = D({});
+  return y(() => {
+    if (!s)
+      return;
+    const o = (v) => {
       const [l, m] = v.message;
-      l !== i && (t.current[l] || L.emit("new_peer", v), p({
-        ...u.current,
+      l !== u && (t.current[l] || L.emit("new_peer", v), p({
+        ...i.current,
         [l]: m
       }), e({
         ...t.current,
         [l]: f()
       }));
     }, c = () => {
-      const v = u.current, l = t.current, m = f();
-      for (const a in l)
-        m - l[a] > n && (delete v[a], delete l[a]);
-      p(v), e(l);
+      const v = { ...i.current }, l = { ...t.current }, m = f();
+      let a = !1;
+      for (const g in l)
+        m - l[g] > n && (delete v[g], delete l[g], a = !0);
+      a && (p(v), e(l));
     };
-    o.on("ephemeral-message", s);
+    s.on("ephemeral-message", o);
     const w = setInterval(
       c,
       n
     );
     return () => {
-      o.removeListener("ephemeral-message", s), clearInterval(w);
+      s.removeListener("ephemeral-message", o), clearInterval(w);
     };
-  }, [o, i, n, f]), [h, r];
+  }, [s, u, n, f]), [h, r];
 }, U = ({
-  handle: o,
-  userId: i,
+  handle: s,
+  userId: u,
   initialState: n,
   heartbeatTime: f = 15e3
 }) => {
-  const [h, p, u] = D(n), r = (e) => {
-    const t = typeof e == "function" ? e(u.current) : e;
-    p(t), o.broadcast([i, t]);
+  const [h, p, i] = D(n), r = (e) => {
+    const t = typeof e == "function" ? e(i.current) : e;
+    p(t), s && s.broadcast([u, t]);
   };
-  return g(() => {
-    if (!i)
+  return y(() => {
+    if (!u || !s)
       return;
-    const e = () => void o.broadcast([i, u.current]);
+    const e = () => void s.broadcast([u, i.current]);
     e();
     const t = setInterval(e, f);
     return () => void clearInterval(t);
-  }, [o, i, f]), g(() => {
+  }, [s, u, f]), y(() => {
+    if (!s || !u)
+      return;
     let e;
     const t = L.on("new_peer", () => {
       e = setTimeout(
-        () => o.broadcast([i, u.current]),
+        () => s.broadcast([u, i.current]),
         500
         // Wait for the peer to be ready
       );
@@ -362,7 +367,7 @@ const Q = /* @__PURE__ */ A(K), L = new Q(), Z = ({
     return () => {
       t.off("new_peer"), e && clearTimeout(e);
     };
-  }, [o, i, L]), [h, r];
+  }, [s, u, L]), [h, r];
 };
 export {
   z as RepoContext,

package/dist/useLocalAwareness.d.ts

@@ -2,7 +2,7 @@ import { DocHandle } from '@automerge/automerge-repo/slim';
 
 export interface UseLocalAwarenessProps {
     /** The document handle to send ephemeral state on */
-    handle: DocHandle<unknown>;
+    handle?: DocHandle<unknown>;
     /** Our user ID **/
     userId: string;
     /** The initial state object/primitive we should advertise */

package/dist/useLocalAwareness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLocalAwareness.d.ts","sourceRoot":"","sources":["../src/useLocalAwareness.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAA;AAE1D,MAAM,WAAW,sBAAsB;IACrC,qDAAqD;IACrD,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;IAC1B,mBAAmB;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,6DAA6D;IAC7D,YAAY,EAAE,GAAG,CAAA;IACjB,wCAAwC;IACxC,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AACD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAAI,kDAK/B,sBAAsB,UAmDxB,CAAA"}
+{"version":3,"file":"useLocalAwareness.d.ts","sourceRoot":"","sources":["../src/useLocalAwareness.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAA;AAE1D,MAAM,WAAW,sBAAsB;IACrC,qDAAqD;IACrD,MAAM,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;IAC3B,mBAAmB;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,6DAA6D;IAC7D,YAAY,EAAE,GAAG,CAAA;IACjB,wCAAwC;IACxC,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AACD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAAI,kDAK/B,sBAAsB,UAyDxB,CAAA"}

package/dist/useRemoteAwareness.d.ts

@@ -4,7 +4,7 @@ import { EventEmitter } from 'eventemitter3';
 export declare const peerEvents: EventEmitter<string | symbol, any>;
 export interface UseRemoteAwarenessProps<T> {
     /** The handle to receive ephemeral state on */
-    handle: DocHandle<T>;
+    handle?: DocHandle<T>;
     /** Our user ID */
     localUserId?: string;
     /** How long to wait (in ms) before marking a peer as offline */

package/dist/useRemoteAwareness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRemoteAwareness.d.ts","sourceRoot":"","sources":["../src/useRemoteAwareness.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAEV,MAAM,gCAAgC,CAAA;AAGvC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAG5C,eAAO,MAAM,UAAU,oCAAqB,CAAA;AAE5C,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,+CAA+C;IAC/C,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAA;IACpB,kBAAkB;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gEAAgE;IAChE,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,6CAA6C;IAC7C,OAAO,CAAC,EAAE,MAAM,MAAM,CAAA;CACvB;AAED,wCAAwC;AACxC,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAC5C,2DAA2D;AAC3D,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE/C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,mDAKnC,uBAAuB,CAAC,CAAC,CAAC,KAAG,CAAC,UAAU,EAAE,UAAU,CAiDtD,CAAA"}
+{"version":3,"file":"useRemoteAwareness.d.ts","sourceRoot":"","sources":["../src/useRemoteAwareness.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAEV,MAAM,gCAAgC,CAAA;AAGvC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAG5C,eAAO,MAAM,UAAU,oCAAqB,CAAA;AAE5C,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,+CAA+C;IAC/C,MAAM,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAA;IACrB,kBAAkB;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gEAAgE;IAChE,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,6CAA6C;IAC7C,OAAO,CAAC,EAAE,MAAM,MAAM,CAAA;CACvB;AAED,wCAAwC;AACxC,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAC5C,2DAA2D;AAC3D,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE/C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,mDAKnC,uBAAuB,CAAC,CAAC,CAAC,KAAG,CAAC,UAAU,EAAE,UAAU,CAyDtD,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automerge/automerge-repo-react-hooks",
-  "version": "2.4.0",
+  "version": "2.5.0-alpha.1",
   "description": "Hooks to access an Automerge Repo from your react app.",
   "repository": "https://github.com/automerge/automerge-repo/tree/master/packages/automerge-repo-react-hooks",
   "author": "Peter van Hardenberg <pvh@pvh.ca>",
@@ -15,7 +15,7 @@
   },
   "dependencies": {
     "@automerge/automerge": "2.2.8 - 3",
-    "@automerge/automerge-repo": "2.4.0",
+    "@automerge/automerge-repo": "2.5.0-alpha.1",
     "eventemitter3": "^5.0.1",
     "react-usestateref": "^1.0.8"
   },
@@ -46,5 +46,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "586290a804e12206362cf41c87e309bd0fb22d69"
+  "gitHead": "6865d2fca3f7fb1ebaf155aa858f4be3b65bbbef"
 }

package/src/useLocalAwareness.ts

@@ -5,7 +5,7 @@ import { DocHandle } from "@automerge/automerge-repo/slim"
 
 export interface UseLocalAwarenessProps {
   /** The document handle to send ephemeral state on */
-  handle: DocHandle<unknown>
+  handle?: DocHandle<unknown>
   /** Our user ID **/
   userId: string
   /** The initial state object/primitive we should advertise */
@@ -43,13 +43,15 @@ export const useLocalAwareness = ({
         : stateOrUpdater
     setLocalState(state)
     // TODO: Send deltas instead of entire state
-    handle.broadcast([userId, state])
+    if (handle) {
+      handle.broadcast([userId, state])
+    }
   }
 
   useEffect(() => {
-    // Don't broadcast if userId isn't set: this avoids bogus broadcasts
-    // during the loading of a userId document.
-    if (!userId) {
+    // Don't broadcast if userId or handle isn't set: this avoids bogus broadcasts
+    // during the loading of a userId document or handle.
+    if (!userId || !handle) {
       return
     }
 
@@ -64,6 +66,10 @@ export const useLocalAwareness = ({
 
   useEffect(() => {
     // Send entire state to new peers
+    if (!handle || !userId) {
+      return
+    }
+
     let broadcastTimeoutId: ReturnType<typeof setTimeout>
     const newPeerEvents = peerEvents.on("new_peer", () => {
       broadcastTimeoutId = setTimeout(

package/src/useRemoteAwareness.ts

@@ -11,7 +11,7 @@ export const peerEvents = new EventEmitter()
 
 export interface UseRemoteAwarenessProps<T> {
   /** The handle to receive ephemeral state on */
-  handle: DocHandle<T>
+  handle?: DocHandle<T>
   /** Our user ID */
   localUserId?: string
   /** How long to wait (in ms) before marking a peer as offline */
@@ -48,6 +48,10 @@ export const useRemoteAwareness = <T>({
   const [peerStates, setPeerStates, peerStatesRef] = useStateRef<PeerStates>({})
   const [heartbeats, setHeartbeats, heartbeatsRef] = useStateRef<Heartbeats>({})
   useEffect(() => {
+    if (!handle) {
+      return
+    }
+
     // Receive incoming message
     const handleIncomingUpdate = (
       event: DocHandleEphemeralMessagePayload<T>
@@ -66,17 +70,21 @@ export const useRemoteAwareness = <T>({
     }
     // Remove peers we haven't seen recently
     const pruneOfflinePeers = () => {
-      const peerStates = peerStatesRef.current
-      const heartbeats = heartbeatsRef.current
+      const peerStates = { ...peerStatesRef.current }
+      const heartbeats = { ...heartbeatsRef.current }
       const time = getTime()
+      let hasChanges = false
       for (const key in heartbeats) {
         if (time - heartbeats[key] > offlineTimeout) {
           delete peerStates[key]
           delete heartbeats[key]
+          hasChanges = true
         }
       }
-      setPeerStates(peerStates)
-      setHeartbeats(heartbeats)
+      if (hasChanges) {
+        setPeerStates(peerStates)
+        setHeartbeats(heartbeats)
+      }
     }
     handle.on("ephemeral-message", handleIncomingUpdate)
     // Check for offline peers every `offlineTimeout` ms

package/test/useLocalAwareness.test.tsx

@@ -0,0 +1,275 @@
+import { DocHandle } from "@automerge/automerge-repo"
+import { render, waitFor } from "@testing-library/react"
+import React from "react"
+import { describe, expect, it, vi } from "vitest"
+import "@testing-library/jest-dom"
+
+import { useLocalAwareness } from "../src/useLocalAwareness"
+import { setup, ExampleDoc } from "./testSetup"
+
+describe("useLocalAwareness", () => {
+  describe("with defined handle", () => {
+    const Component = ({
+      handle,
+      userId,
+      initialState,
+    }: {
+      handle: DocHandle<ExampleDoc>
+      userId: string
+      initialState: any
+    }) => {
+      const [state, setState] = useLocalAwareness({
+        handle,
+        userId,
+        initialState,
+      })
+      return (
+        <div>
+          <div data-testid="state">{JSON.stringify(state)}</div>
+          <button onClick={() => setState({ updated: true })}>Update</button>
+        </div>
+      )
+    }
+
+    it("should initialize with initial state", () => {
+      const { handleA, wrapper } = setup()
+      const initialState = { foo: "bar" }
+
+      const { getByTestId } = render(
+        <Component
+          handle={handleA}
+          userId="user1"
+          initialState={initialState}
+        />,
+        { wrapper }
+      )
+
+      expect(getByTestId("state")).toHaveTextContent(
+        JSON.stringify(initialState)
+      )
+    })
+
+    it("should broadcast state changes when handle is defined", async () => {
+      const { handleA, wrapper } = setup()
+      const broadcastSpy = vi.spyOn(handleA, "broadcast")
+
+      const { getByText, getByTestId } = render(
+        <Component
+          handle={handleA}
+          userId="user1"
+          initialState={{ initial: true }}
+        />,
+        { wrapper }
+      )
+
+      // Wait for initial heartbeat
+      await waitFor(() => {
+        expect(broadcastSpy).toHaveBeenCalled()
+      })
+
+      // Clear previous calls
+      broadcastSpy.mockClear()
+
+      // Click update button
+      React.act(() => {
+        getByText("Update").click()
+      })
+
+      // Should broadcast the update
+      await waitFor(() => {
+        expect(broadcastSpy).toHaveBeenCalledWith(["user1", { updated: true }])
+      })
+
+      expect(getByTestId("state")).toHaveTextContent(
+        JSON.stringify({ updated: true })
+      )
+    })
+
+    it("should send periodic heartbeats", async () => {
+      const { handleA, wrapper } = setup()
+      const broadcastSpy = vi.spyOn(handleA, "broadcast")
+      const initialState = { heartbeat: true }
+
+      render(
+        <Component
+          handle={handleA}
+          userId="user1"
+          initialState={initialState}
+        />,
+        { wrapper }
+      )
+
+      // Should send initial heartbeat
+      await waitFor(() => {
+        expect(broadcastSpy).toHaveBeenCalledWith(["user1", initialState])
+      })
+    })
+
+    it("should not broadcast if userId is not set", async () => {
+      const { handleA, wrapper } = setup()
+      const broadcastSpy = vi.spyOn(handleA, "broadcast")
+
+      render(
+        <Component handle={handleA} userId="" initialState={{ test: true }} />,
+        { wrapper }
+      )
+
+      // Wait a bit
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      // Should not have broadcast
+      expect(broadcastSpy).not.toHaveBeenCalled()
+    })
+
+    it("should cleanup on unmount", async () => {
+      const { handleA, wrapper } = setup()
+
+      const { unmount } = render(
+        <Component
+          handle={handleA}
+          userId="user1"
+          initialState={{ test: true }}
+        />,
+        { wrapper }
+      )
+
+      // Wait for initial heartbeat
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      // Unmount
+      unmount()
+
+      // No errors should occur
+      expect(true).toBe(true)
+    })
+  })
+
+  describe("with undefined handle", () => {
+    const Component = ({
+      handle,
+      userId,
+      initialState,
+    }: {
+      handle?: DocHandle<ExampleDoc>
+      userId: string
+      initialState: any
+    }) => {
+      const [state, setState] = useLocalAwareness({
+        handle,
+        userId,
+        initialState,
+      })
+      return (
+        <div>
+          <div data-testid="state">{JSON.stringify(state)}</div>
+          <button onClick={() => setState({ updated: true })}>Update</button>
+        </div>
+      )
+    }
+
+    it("should not crash when handle is undefined", () => {
+      const { wrapper } = setup()
+
+      expect(() => {
+        render(<Component userId="user1" initialState={{ test: true }} />, {
+          wrapper,
+        })
+      }).not.toThrow()
+    })
+
+    it("should still maintain local state when handle is undefined", () => {
+      const { wrapper } = setup()
+      const initialState = { foo: "bar" }
+
+      const { getByTestId } = render(
+        <Component userId="user1" initialState={initialState} />,
+        { wrapper }
+      )
+
+      expect(getByTestId("state")).toHaveTextContent(
+        JSON.stringify(initialState)
+      )
+    })
+
+    it("should update local state without broadcasting when handle is undefined", async () => {
+      const { wrapper } = setup()
+
+      const { getByText, getByTestId } = render(
+        <Component userId="user1" initialState={{ initial: true }} />,
+        { wrapper }
+      )
+
+      // Click update button
+      React.act(() => {
+        getByText("Update").click()
+      })
+
+      // State should update
+      await waitFor(() => {
+        expect(getByTestId("state")).toHaveTextContent(
+          JSON.stringify({ updated: true })
+        )
+      })
+    })
+
+    it("should handle transition from undefined to defined handle", async () => {
+      const { handleA, wrapper } = setup()
+      const broadcastSpy = vi.spyOn(handleA, "broadcast")
+
+      const { rerender, getByText } = render(
+        <Component userId="user1" initialState={{ test: true }} />,
+        { wrapper }
+      )
+
+      // Wait a bit with undefined handle
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      // Should not have broadcast yet
+      expect(broadcastSpy).not.toHaveBeenCalled()
+
+      // Now provide a handle
+      rerender(
+        <Component
+          handle={handleA}
+          userId="user1"
+          initialState={{ test: true }}
+        />
+      )
+
+      // Should start broadcasting
+      await waitFor(() => {
+        expect(broadcastSpy).toHaveBeenCalled()
+      })
+    })
+
+    it("should handle transition from defined to undefined handle", async () => {
+      const { handleA, wrapper } = setup()
+      const broadcastSpy = vi.spyOn(handleA, "broadcast")
+
+      const { rerender } = render(
+        <Component
+          handle={handleA}
+          userId="user1"
+          initialState={{ test: true }}
+        />,
+        { wrapper }
+      )
+
+      // Wait for initial broadcast
+      await waitFor(() => {
+        expect(broadcastSpy).toHaveBeenCalled()
+      })
+
+      broadcastSpy.mockClear()
+
+      // Now remove the handle
+      rerender(<Component userId="user1" initialState={{ test: true }} />)
+
+      // Wait a bit
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      // Should not broadcast anymore
+      expect(broadcastSpy).not.toHaveBeenCalled()
+    })
+  })
+})

package/test/useRemoteAwareness.test.tsx

@@ -0,0 +1,326 @@
+import { DocHandle } from "@automerge/automerge-repo"
+import { render, waitFor } from "@testing-library/react"
+import React from "react"
+import { describe, expect, it, vi } from "vitest"
+import "@testing-library/jest-dom"
+
+import { useRemoteAwareness } from "../src/useRemoteAwareness"
+import { setup, ExampleDoc } from "./testSetup"
+
+describe("useRemoteAwareness", () => {
+  describe("with defined handle", () => {
+    const Component = ({
+      handle,
+      localUserId,
+    }: {
+      handle: DocHandle<ExampleDoc>
+      localUserId?: string
+    }) => {
+      const [peerStates, heartbeats] = useRemoteAwareness({
+        handle,
+        localUserId,
+      })
+      return (
+        <div>
+          <div data-testid="peer-states">{JSON.stringify(peerStates)}</div>
+          <div data-testid="heartbeats">{JSON.stringify(heartbeats)}</div>
+        </div>
+      )
+    }
+
+    it("should initialize with empty peer states", () => {
+      const { handleA, wrapper } = setup()
+
+      const { getByTestId } = render(
+        <Component handle={handleA} localUserId="local-user" />,
+        { wrapper }
+      )
+
+      expect(getByTestId("peer-states")).toHaveTextContent("{}")
+      expect(getByTestId("heartbeats")).toHaveTextContent("{}")
+    })
+
+    it("should receive and store remote peer states", async () => {
+      const { handleA, wrapper } = setup()
+
+      const { getByTestId } = render(
+        <Component handle={handleA} localUserId="local-user" />,
+        { wrapper }
+      )
+
+      // Simulate receiving a message from a remote peer
+      const mockEvent = {
+        handle: handleA,
+        message: ["remote-user", { status: "online" }],
+      }
+
+      // @ts-ignore - accessing private emit for testing
+      React.act(() => {
+        handleA.emit("ephemeral-message", mockEvent)
+      })
+
+      await waitFor(() => {
+        expect(getByTestId("peer-states")).toHaveTextContent(
+          JSON.stringify({ "remote-user": { status: "online" } })
+        )
+      })
+    })
+
+    it("should filter out messages from local user", async () => {
+      const { handleA, wrapper } = setup()
+
+      const { getByTestId } = render(
+        <Component handle={handleA} localUserId="local-user" />,
+        { wrapper }
+      )
+
+      // Simulate receiving a message from the local user (should be ignored)
+      const mockEvent = {
+        handle: handleA,
+        message: ["local-user", { status: "online" }],
+      }
+
+      // @ts-ignore - accessing private emit for testing
+      React.act(() => {
+        handleA.emit("ephemeral-message", mockEvent)
+      })
+
+      // Wait a bit
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      // Should still be empty
+      expect(getByTestId("peer-states")).toHaveTextContent("{}")
+    })
+
+    it("should update heartbeat timestamps when receiving messages", async () => {
+      const { handleA, wrapper } = setup()
+      const mockGetTime = vi.fn(() => 1000)
+
+      const ComponentWithTime = () => {
+        const [peerStates, heartbeats] = useRemoteAwareness({
+          handle: handleA,
+          localUserId: "local-user",
+          getTime: mockGetTime,
+        })
+        return (
+          <div>
+            <div data-testid="heartbeats">{JSON.stringify(heartbeats)}</div>
+          </div>
+        )
+      }
+
+      const { getByTestId } = render(<ComponentWithTime />, { wrapper })
+
+      // Simulate receiving a message
+      const mockEvent = {
+        handle: handleA,
+        message: ["remote-user", { status: "online" }],
+      }
+
+      // @ts-ignore - accessing private emit for testing
+      React.act(() => {
+        handleA.emit("ephemeral-message", mockEvent)
+      })
+
+      await waitFor(() => {
+        expect(getByTestId("heartbeats")).toHaveTextContent(
+          JSON.stringify({ "remote-user": 1000 })
+        )
+      })
+    })
+
+    it("should prune offline peers after timeout", async () => {
+      const { handleA, wrapper } = setup()
+      let currentTime = 1000
+      const mockGetTime = vi.fn(() => currentTime)
+
+      const ComponentWithTime = () => {
+        const [peerStates] = useRemoteAwareness({
+          handle: handleA,
+          localUserId: "local-user",
+          offlineTimeout: 100, // Short timeout for testing
+          getTime: mockGetTime,
+        })
+        return (
+          <div>
+            <div data-testid="peer-states">{JSON.stringify(peerStates)}</div>
+          </div>
+        )
+      }
+
+      const { getByTestId } = render(<ComponentWithTime />, { wrapper })
+
+      // Simulate receiving a message
+      const mockEvent = {
+        handle: handleA,
+        message: ["remote-user", { status: "online" }],
+      }
+
+      // @ts-ignore - accessing private emit for testing
+      React.act(() => {
+        handleA.emit("ephemeral-message", mockEvent)
+      })
+
+      // Should have the peer
+      await waitFor(() => {
+        expect(getByTestId("peer-states")).toHaveTextContent(
+          JSON.stringify({ "remote-user": { status: "online" } })
+        )
+      })
+
+      // Advance time past the offline timeout
+      currentTime = 1200
+
+      // Wait for the pruning interval to run (it runs every 100ms)
+      await new Promise(resolve => setTimeout(resolve, 150))
+
+      // Should now be pruned
+      expect(getByTestId("peer-states")).toHaveTextContent("{}")
+    })
+
+    it("should cleanup listeners on unmount", async () => {
+      const { handleA, wrapper } = setup()
+      const removeListenerSpy = vi.spyOn(handleA, "removeListener")
+
+      const { unmount } = render(
+        <Component handle={handleA} localUserId="local-user" />,
+        { wrapper }
+      )
+
+      // Unmount
+      unmount()
+
+      // Should have removed listener
+      expect(removeListenerSpy).toHaveBeenCalledWith(
+        "ephemeral-message",
+        expect.any(Function)
+      )
+    })
+  })
+
+  describe("with undefined handle", () => {
+    const Component = ({
+      handle,
+      localUserId,
+    }: {
+      handle?: DocHandle<ExampleDoc>
+      localUserId?: string
+    }) => {
+      const [peerStates, heartbeats] = useRemoteAwareness({
+        handle,
+        localUserId,
+      })
+      return (
+        <div>
+          <div data-testid="peer-states">{JSON.stringify(peerStates)}</div>
+          <div data-testid="heartbeats">{JSON.stringify(heartbeats)}</div>
+        </div>
+      )
+    }
+
+    it("should not crash when handle is undefined", () => {
+      const { wrapper } = setup()
+
+      expect(() => {
+        render(<Component localUserId="local-user" />, { wrapper })
+      }).not.toThrow()
+    })
+
+    it("should return empty peer states when handle is undefined", () => {
+      const { wrapper } = setup()
+
+      const { getByTestId } = render(<Component localUserId="local-user" />, {
+        wrapper,
+      })
+
+      expect(getByTestId("peer-states")).toHaveTextContent("{}")
+      expect(getByTestId("heartbeats")).toHaveTextContent("{}")
+    })
+
+    it("should handle transition from undefined to defined handle", async () => {
+      const { handleA, wrapper } = setup()
+
+      const { rerender, getByTestId } = render(
+        <Component localUserId="local-user" />,
+        { wrapper }
+      )
+
+      // Should have empty states
+      expect(getByTestId("peer-states")).toHaveTextContent("{}")
+
+      // Now provide a handle
+      rerender(<Component handle={handleA} localUserId="local-user" />)
+
+      // Simulate receiving a message
+      const mockEvent = {
+        handle: handleA,
+        message: ["remote-user", { status: "online" }],
+      }
+
+      // @ts-ignore - accessing private emit for testing
+      React.act(() => {
+        handleA.emit("ephemeral-message", mockEvent)
+      })
+
+      // Should now receive and display the peer state
+      await waitFor(() => {
+        expect(getByTestId("peer-states")).toHaveTextContent(
+          JSON.stringify({ "remote-user": { status: "online" } })
+        )
+      })
+    })
+
+    it("should handle transition from defined to undefined handle", async () => {
+      const { handleA, wrapper } = setup()
+
+      const { rerender, getByTestId } = render(
+        <Component handle={handleA} localUserId="local-user" />,
+        { wrapper }
+      )
+
+      // Simulate receiving a message
+      const mockEvent = {
+        handle: handleA,
+        message: ["remote-user", { status: "online" }],
+      }
+
+      // @ts-ignore - accessing private emit for testing
+      React.act(() => {
+        handleA.emit("ephemeral-message", mockEvent)
+      })
+
+      // Should have the peer
+      await waitFor(() => {
+        expect(getByTestId("peer-states")).toHaveTextContent(
+          JSON.stringify({ "remote-user": { status: "online" } })
+        )
+      })
+
+      // Now remove the handle
+      rerender(<Component localUserId="local-user" />)
+
+      // The peer states should remain (they don't get cleared automatically)
+      // but new messages won't be received
+      expect(getByTestId("peer-states")).toHaveTextContent(
+        JSON.stringify({ "remote-user": { status: "online" } })
+      )
+    })
+
+    it("should not attempt to add listeners when handle is undefined", async () => {
+      const { wrapper } = setup()
+
+      // This should not throw any errors
+      const { unmount } = render(<Component localUserId="local-user" />, {
+        wrapper,
+      })
+
+      // Wait a bit
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      // Unmount should also not throw
+      unmount()
+
+      expect(true).toBe(true)
+    })
+  })
+})