@liveblocks/react 1.1.1-dual5 → 1.1.1-dual6

package/dist/index.js

@@ -1,11 +1,575 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }var _react = require('react'); var f = _interopRequireWildcard(_react); var o = _interopRequireWildcard(_react);function oe(c){let[T,b]=f.useState(!1);return f.useEffect(()=>{b(!0)},[]),f.createElement(f.Suspense,{fallback:c.fallback},T?c.children():c.fallback)}var _client = require('@liveblocks/client');var _core = require('@liveblocks/core');var _withselectorjs = require('use-sync-external-store/shim/with-selector.js');function z(){let[,c]=_react.useReducer.call(void 0, T=>T+1,0);return c}function Q(c){return _react.useRef.call(void 0, c).current}var le=()=>{},M=c=>c,de=(c,T)=>`We noticed you\u2019re using React ${c}. Please pass unstable_batchedUpdates at the RoomProvider level until you\u2019re ready to upgrade to React 18:
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/ClientSideSuspense.tsx
+var _react = require('react'); var React = _interopRequireWildcard(_react); var React2 = _interopRequireWildcard(_react);
+function ClientSideSuspense(props) {
+  const [mounted, setMounted] = React.useState(false);
+  React.useEffect(() => {
+    setMounted(true);
+  }, []);
+  return /* @__PURE__ */ React.createElement(React.Suspense, { fallback: props.fallback }, mounted ? props.children() : props.fallback);
+}
+
+// src/factory.tsx
+var _client = require('@liveblocks/client');
+
+
+
+
+var _core = require('@liveblocks/core');
+
+var _withselectorjs = require('use-sync-external-store/shim/with-selector.js');
+
+// src/hooks.ts
+
+function useRerender() {
+  const [, update] = _react.useReducer.call(void 0, 
+    // This implementation works by incrementing a hidden counter value that is
+    // never consumed. Simply incrementing the counter changes the component's
+    // state and, thus, trigger a re-render.
+    (x) => x + 1,
+    0
+  );
+  return update;
+}
+function useInitial(value) {
+  return _react.useRef.call(void 0, value).current;
+}
+
+// src/factory.tsx
+var noop = () => {
+};
+var identity = (x) => x;
+var missing_unstable_batchedUpdates = (reactVersion, roomId) => `We noticed you\u2019re using React ${reactVersion}. Please pass unstable_batchedUpdates at the RoomProvider level until you\u2019re ready to upgrade to React 18:
 
     import { unstable_batchedUpdates } from "react-dom";  // or "react-native"
 
-    <RoomProvider id=${JSON.stringify(T)} ... unstable_batchedUpdates={unstable_batchedUpdates}>
+    <RoomProvider id=${JSON.stringify(
+  roomId
+)} ... unstable_batchedUpdates={unstable_batchedUpdates}>
       ...
     </RoomProvider>
 
-Why? Please see https://liveblocks.io/docs/guides/troubleshooting#stale-props-zombie-child for more information`,Te="You don\u2019t need to pass unstable_batchedUpdates to RoomProvider anymore, since you\u2019re on React 18+ already.";function v(c,T,b){return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, c,T,b,M)}var be=_core.asArrayWithLegacyMethods.call(void 0, []);function pe(){return be}function fe(c){let T="This mutation cannot be used until connected to the Liveblocks room";return{get storage(){let b=c.getStorageSnapshot();if(b===null)throw new Error(T);return b},get self(){let b=c.getSelf();if(b===null)throw new Error(T);return b},get others(){let b=c.getOthers();if(!c.isSelfAware())throw new Error(T);return b},setMyPresence:c.updatePresence}}function he(c){let T=o.createContext(null);function b(e){let{id:t,initialPresence:n,initialStorage:r,unstable_batchedUpdates:a,shouldInitiallyConnect:l}=e;if(process.env.NODE_ENV!=="production"){if(!t)throw new Error("RoomProvider id property is required. For more information: https://liveblocks.io/docs/errors/liveblocks-react/RoomProvider-id-property-is-required");if(typeof t!="string")throw new Error("RoomProvider id property should be a string.");let p=parseInt(o.version)||1,y=p<18;_core.errorIf.call(void 0, y&&e.unstable_batchedUpdates===void 0,de(p,t)),_core.deprecateIf.call(void 0, !y&&e.unstable_batchedUpdates!==void 0,Te)}let s=Q({initialPresence:n,initialStorage:r,unstable_batchedUpdates:a,shouldInitiallyConnect:l===void 0?typeof window!="undefined":l}),[d,i]=o.useState(()=>c.enter(t,{initialPresence:s.initialPresence,initialStorage:s.initialStorage,shouldInitiallyConnect:s.shouldInitiallyConnect,unstable_batchedUpdates:s.unstable_batchedUpdates}));return o.useEffect(()=>(i(c.enter(t,{initialPresence:s.initialPresence,initialStorage:s.initialStorage,shouldInitiallyConnect:s.shouldInitiallyConnect,unstable_batchedUpdates:s.unstable_batchedUpdates})),()=>{c.leave(t)}),[t,s]),o.createElement(T.Provider,{value:d},e.children)}function q(e){return e.map(t=>t.connectionId)}function u(){let e=o.useContext(T);if(e===null)throw new Error("RoomProvider is missing from the react tree");return e}function C(){let e=u(),t=e.events.status.subscribe,n=e.getStatus;return v(t,n,n)}function E(){let e=u(),t=e.events.me.subscribe,n=e.getPresence,r=v(t,n,n),a=e.updatePresence;return[r,a]}function x(){return u().updatePresence}function h(e,t){let n=u(),r=n.events.others.subscribe,a=n.getOthers;return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, r,a,pe,e!=null?e:M,t)}function w(){return h(q,_client.shallow)}function k(e,t){let n=o.useCallback(a=>a.map(l=>[l.connectionId,e(l)]),[e]),r=o.useCallback((a,l)=>{let s=t!=null?t:Object.is;return a.length===l.length&&a.every((d,i)=>{let p=l[i];return d[0]===p[0]&&s(d[1],p[1])})},[t]);return h(n,r)}let S=Symbol();function I(e,t,n){let r=o.useCallback(s=>{let d=s.find(i=>i.connectionId===e);return d!==void 0?t(d):S},[e,t]),a=o.useCallback((s,d)=>s===S||d===S?s===d:(n!=null?n:Object.is)(s,d),[n]),l=h(r,a);if(l===S)throw new Error(`No such other user with connection id ${e} exists`);return l}function L(){let e=u();return o.useCallback((t,n={shouldQueueEventIfNotReady:!1})=>{e.broadcastEvent(t,n)},[e])}function _(e){let t=u(),n=o.useRef(e);o.useEffect(()=>{n.current=e}),o.useEffect(()=>t.events.lostConnection.subscribe(r=>n.current(r)),[t])}function N(e){let t=u(),n=o.useRef(e);o.useEffect(()=>{n.current=e}),o.useEffect(()=>t.events.error.subscribe(r=>n.current(r)),[t])}function j(e){let t=u(),n=o.useRef(e);o.useEffect(()=>{n.current=e}),o.useEffect(()=>{let r=a=>{n.current(a)};return t.events.customEvent.subscribe(r)},[t])}function F(e,t){let n=u(),r=o.useCallback(i=>{let p=n.events.me.subscribe(i),y=n.events.connection.subscribe(i);return()=>{p(),y()}},[n]),a=n.getSelf,l=e!=null?e:M,s=o.useCallback(i=>i!==null?l(i):null,[l]),d=o.useCallback(()=>null,[]);return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, r,a,d,s,t)}function P(){let e=u(),t=e.events.storageDidLoad.subscribeOnce,n=e.getStorageSnapshot,r=o.useCallback(()=>null,[]);return v(t,n,r)}function B(){return[P()]}function R(){return u().history}function A(){return R().undo}function J(){return R().redo}function K(){let e=u(),t=e.events.history.subscribe,n=e.history.canUndo;return v(t,n,n)}function D(){let e=u(),t=e.events.history.subscribe,n=e.history.canRedo;return v(t,n,n)}function H(){return u().batch}function g(e){let t=u(),n=P(),r=z();return o.useEffect(()=>{if(n===null)return;let a=n.get(e);function l(){let i=n.get(e);i!==a&&(s(),a=i,s=t.subscribe(a,r),r())}let s=t.subscribe(a,r),d=t.subscribe(n,l);return r(),()=>{d(),s()}},[n,t,e,r]),n===null?null:n.get(e)}function V(e,t){let n=u(),r=P(),a=o.useCallback(i=>i!==null?e(i):null,[e]),l=o.useCallback(i=>r!==null?n.subscribe(r,i,{isDeep:!0}):le,[n,r]),s=o.useCallback(()=>r===null?null:r.toImmutable(),[r]),d=o.useCallback(()=>null,[]);return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, l,s,d,a,t)}function W(){if(typeof window=="undefined")throw new Error(`You cannot use the Suspense version of this hook on the server side. Make sure to only call them on the client side.
-For tips, see https://liveblocks.io/docs/api-reference/liveblocks-react#suspense-avoid-ssr`)}function Y(){let e=u();if(e.getStorageSnapshot()===null)throw W(),new Promise(t=>{e.events.storageDidLoad.subscribeOnce(()=>t())})}function m(){let e=u();if(!e.isSelfAware())throw W(),new Promise(t=>{e.events.connection.subscribeOnce(()=>t())})}function $(e,t){let n=u();return o.useMemo(()=>(...r)=>n.batch(()=>e(fe(n),...r)),[n,...t])}function G(e,t){return Y(),V(e,t)}function X(e,t){return m(),F(e,t)}function Z(e,t){return m(),h(e,t)}function ee(){return m(),w()}function te(e,t){return m(),k(e,t)}function ne(e,t,n){return m(),I(e,t,n)}function O(e){return Y(),g(e)}return{RoomContext:T,RoomProvider:b,useRoom:u,useStatus:C,useBatch:H,useBroadcastEvent:L,useLostConnectionListener:_,useErrorListener:N,useEventListener:j,useHistory:R,useUndo:A,useRedo:J,useCanRedo:D,useCanUndo:K,useList:g,useMap:g,useObject:g,useStorageRoot:B,useStorage:V,useSelf:F,useMyPresence:E,useUpdateMyPresence:x,useOthers:h,useOthersMapped:k,useOthersConnectionIds:w,useOther:I,useMutation:$,suspense:{RoomContext:T,RoomProvider:b,useRoom:u,useStatus:C,useBatch:H,useBroadcastEvent:L,useLostConnectionListener:_,useErrorListener:N,useEventListener:j,useHistory:R,useUndo:A,useRedo:J,useCanRedo:D,useCanUndo:K,useList:O,useMap:O,useObject:O,useStorageRoot:B,useStorage:G,useSelf:X,useMyPresence:E,useUpdateMyPresence:x,useOthers:Z,useOthersMapped:te,useOthersConnectionIds:ee,useOther:ne,useMutation:$}}}exports.ClientSideSuspense = oe; exports.createRoomContext = he; exports.shallow = _client.shallow;
+Why? Please see https://liveblocks.io/docs/guides/troubleshooting#stale-props-zombie-child for more information`;
+var superfluous_unstable_batchedUpdates = "You don\u2019t need to pass unstable_batchedUpdates to RoomProvider anymore, since you\u2019re on React 18+ already.";
+function useSyncExternalStore(s, gs, gss) {
+  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, s, gs, gss, identity);
+}
+var EMPTY_OTHERS = (
+  // NOTE: asArrayWithLegacyMethods() wrapping should no longer be necessary in 0.19
+  _core.asArrayWithLegacyMethods.call(void 0, [])
+);
+function getEmptyOthers() {
+  return EMPTY_OTHERS;
+}
+function makeMutationContext(room) {
+  const errmsg = "This mutation cannot be used until connected to the Liveblocks room";
+  return {
+    get storage() {
+      const mutableRoot = room.getStorageSnapshot();
+      if (mutableRoot === null) {
+        throw new Error(errmsg);
+      }
+      return mutableRoot;
+    },
+    get self() {
+      const self = room.getSelf();
+      if (self === null) {
+        throw new Error(errmsg);
+      }
+      return self;
+    },
+    get others() {
+      const others = room.getOthers();
+      if (!room.isSelfAware()) {
+        throw new Error(errmsg);
+      }
+      return others;
+    },
+    setMyPresence: room.updatePresence
+  };
+}
+function createRoomContext(client) {
+  const RoomContext = React2.createContext(null);
+  function RoomProvider(props) {
+    const {
+      id: roomId,
+      initialPresence,
+      initialStorage,
+      unstable_batchedUpdates,
+      shouldInitiallyConnect
+    } = props;
+    if (process.env.NODE_ENV !== "production") {
+      if (!roomId) {
+        throw new Error(
+          "RoomProvider id property is required. For more information: https://liveblocks.io/docs/errors/liveblocks-react/RoomProvider-id-property-is-required"
+        );
+      }
+      if (typeof roomId !== "string") {
+        throw new Error("RoomProvider id property should be a string.");
+      }
+      const majorReactVersion = parseInt(React2.version) || 1;
+      const oldReactVersion = majorReactVersion < 18;
+      _core.errorIf.call(void 0, 
+        oldReactVersion && props.unstable_batchedUpdates === void 0,
+        missing_unstable_batchedUpdates(majorReactVersion, roomId)
+      );
+      _core.deprecateIf.call(void 0, 
+        !oldReactVersion && props.unstable_batchedUpdates !== void 0,
+        superfluous_unstable_batchedUpdates
+      );
+    }
+    const frozen = useInitial({
+      initialPresence,
+      initialStorage,
+      unstable_batchedUpdates,
+      shouldInitiallyConnect: shouldInitiallyConnect === void 0 ? typeof window !== "undefined" : shouldInitiallyConnect
+    });
+    const [room, setRoom] = React2.useState(
+      () => client.enter(roomId, {
+        initialPresence: frozen.initialPresence,
+        initialStorage: frozen.initialStorage,
+        shouldInitiallyConnect: frozen.shouldInitiallyConnect,
+        unstable_batchedUpdates: frozen.unstable_batchedUpdates
+      })
+    );
+    React2.useEffect(() => {
+      setRoom(
+        client.enter(roomId, {
+          initialPresence: frozen.initialPresence,
+          initialStorage: frozen.initialStorage,
+          shouldInitiallyConnect: frozen.shouldInitiallyConnect,
+          unstable_batchedUpdates: frozen.unstable_batchedUpdates
+        })
+      );
+      return () => {
+        client.leave(roomId);
+      };
+    }, [roomId, frozen]);
+    return /* @__PURE__ */ React2.createElement(RoomContext.Provider, { value: room }, props.children);
+  }
+  function connectionIdSelector(others) {
+    return others.map((user) => user.connectionId);
+  }
+  function useRoom() {
+    const room = React2.useContext(RoomContext);
+    if (room === null) {
+      throw new Error("RoomProvider is missing from the react tree");
+    }
+    return room;
+  }
+  function useStatus() {
+    const room = useRoom();
+    const subscribe = room.events.status.subscribe;
+    const getSnapshot = room.getStatus;
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  }
+  function useMyPresence() {
+    const room = useRoom();
+    const subscribe = room.events.me.subscribe;
+    const getSnapshot = room.getPresence;
+    const presence = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    const setPresence = room.updatePresence;
+    return [presence, setPresence];
+  }
+  function useUpdateMyPresence() {
+    return useRoom().updatePresence;
+  }
+  function useOthers(selector, isEqual) {
+    const room = useRoom();
+    const subscribe = room.events.others.subscribe;
+    const getSnapshot = room.getOthers;
+    const getServerSnapshot = getEmptyOthers;
+    return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
+      subscribe,
+      getSnapshot,
+      getServerSnapshot,
+      _nullishCoalesce(selector, () => ( identity)),
+      isEqual
+    );
+  }
+  function useOthersConnectionIds() {
+    return useOthers(connectionIdSelector, _client.shallow);
+  }
+  function useOthersMapped(itemSelector, itemIsEqual) {
+    const wrappedSelector = React2.useCallback(
+      (others) => others.map(
+        (other) => [other.connectionId, itemSelector(other)]
+      ),
+      [itemSelector]
+    );
+    const wrappedIsEqual = React2.useCallback(
+      (a, b) => {
+        const eq = _nullishCoalesce(itemIsEqual, () => ( Object.is));
+        return a.length === b.length && a.every((atuple, index) => {
+          const btuple = b[index];
+          return atuple[0] === btuple[0] && eq(atuple[1], btuple[1]);
+        });
+      },
+      [itemIsEqual]
+    );
+    return useOthers(wrappedSelector, wrappedIsEqual);
+  }
+  const NOT_FOUND = Symbol();
+  function useOther(connectionId, selector, isEqual) {
+    const wrappedSelector = React2.useCallback(
+      (others) => {
+        const other2 = others.find(
+          (other3) => other3.connectionId === connectionId
+        );
+        return other2 !== void 0 ? selector(other2) : NOT_FOUND;
+      },
+      [connectionId, selector]
+    );
+    const wrappedIsEqual = React2.useCallback(
+      (prev, curr) => {
+        if (prev === NOT_FOUND || curr === NOT_FOUND) {
+          return prev === curr;
+        }
+        const eq = _nullishCoalesce(isEqual, () => ( Object.is));
+        return eq(prev, curr);
+      },
+      [isEqual]
+    );
+    const other = useOthers(wrappedSelector, wrappedIsEqual);
+    if (other === NOT_FOUND) {
+      throw new Error(
+        `No such other user with connection id ${connectionId} exists`
+      );
+    }
+    return other;
+  }
+  function useBroadcastEvent() {
+    const room = useRoom();
+    return React2.useCallback(
+      (event, options = { shouldQueueEventIfNotReady: false }) => {
+        room.broadcastEvent(event, options);
+      },
+      [room]
+    );
+  }
+  function useLostConnectionListener(callback) {
+    const room = useRoom();
+    const savedCallback = React2.useRef(callback);
+    React2.useEffect(() => {
+      savedCallback.current = callback;
+    });
+    React2.useEffect(
+      () => room.events.lostConnection.subscribe(
+        (event) => savedCallback.current(event)
+      ),
+      [room]
+    );
+  }
+  function useErrorListener(callback) {
+    const room = useRoom();
+    const savedCallback = React2.useRef(callback);
+    React2.useEffect(() => {
+      savedCallback.current = callback;
+    });
+    React2.useEffect(
+      () => room.events.error.subscribe((e) => savedCallback.current(e)),
+      [room]
+    );
+  }
+  function useEventListener(callback) {
+    const room = useRoom();
+    const savedCallback = React2.useRef(callback);
+    React2.useEffect(() => {
+      savedCallback.current = callback;
+    });
+    React2.useEffect(() => {
+      const listener = (eventData) => {
+        savedCallback.current(eventData);
+      };
+      return room.events.customEvent.subscribe(listener);
+    }, [room]);
+  }
+  function useSelf(maybeSelector, isEqual) {
+    const room = useRoom();
+    const subscribe = React2.useCallback(
+      (onChange) => {
+        const unsub1 = room.events.me.subscribe(onChange);
+        const unsub2 = room.events.connection.subscribe(onChange);
+        return () => {
+          unsub1();
+          unsub2();
+        };
+      },
+      [room]
+    );
+    const getSnapshot = room.getSelf;
+    const selector = _nullishCoalesce(maybeSelector, () => ( identity));
+    const wrappedSelector = React2.useCallback(
+      (me) => me !== null ? selector(me) : null,
+      [selector]
+    );
+    const getServerSnapshot = React2.useCallback(() => null, []);
+    return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
+      subscribe,
+      getSnapshot,
+      getServerSnapshot,
+      wrappedSelector,
+      isEqual
+    );
+  }
+  function useMutableStorageRoot() {
+    const room = useRoom();
+    const subscribe = room.events.storageDidLoad.subscribeOnce;
+    const getSnapshot = room.getStorageSnapshot;
+    const getServerSnapshot = React2.useCallback(() => null, []);
+    return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  }
+  function useStorageRoot() {
+    return [useMutableStorageRoot()];
+  }
+  function useHistory() {
+    return useRoom().history;
+  }
+  function useUndo() {
+    return useHistory().undo;
+  }
+  function useRedo() {
+    return useHistory().redo;
+  }
+  function useCanUndo() {
+    const room = useRoom();
+    const subscribe = room.events.history.subscribe;
+    const canUndo = room.history.canUndo;
+    return useSyncExternalStore(subscribe, canUndo, canUndo);
+  }
+  function useCanRedo() {
+    const room = useRoom();
+    const subscribe = room.events.history.subscribe;
+    const canRedo = room.history.canRedo;
+    return useSyncExternalStore(subscribe, canRedo, canRedo);
+  }
+  function useBatch() {
+    return useRoom().batch;
+  }
+  function useLegacyKey(key) {
+    const room = useRoom();
+    const root = useMutableStorageRoot();
+    const rerender = useRerender();
+    React2.useEffect(() => {
+      if (root === null) {
+        return;
+      }
+      let liveValue = root.get(key);
+      function onRootChange() {
+        const newCrdt = root.get(key);
+        if (newCrdt !== liveValue) {
+          unsubscribeCrdt();
+          liveValue = newCrdt;
+          unsubscribeCrdt = room.subscribe(
+            liveValue,
+            // TODO: This is hiding a bug! If `liveValue` happens to be the string `"event"` this actually subscribes an event handler!
+            rerender
+          );
+          rerender();
+        }
+      }
+      let unsubscribeCrdt = room.subscribe(
+        liveValue,
+        // TODO: This is hiding a bug! If `liveValue` happens to be the string `"event"` this actually subscribes an event handler!
+        rerender
+      );
+      const unsubscribeRoot = room.subscribe(
+        root,
+        // TODO: This is hiding a bug! If `liveValue` happens to be the string `"event"` this actually subscribes an event handler!
+        onRootChange
+      );
+      rerender();
+      return () => {
+        unsubscribeRoot();
+        unsubscribeCrdt();
+      };
+    }, [root, room, key, rerender]);
+    if (root === null) {
+      return null;
+    } else {
+      return root.get(key);
+    }
+  }
+  function useStorage(selector, isEqual) {
+    const room = useRoom();
+    const rootOrNull = useMutableStorageRoot();
+    const wrappedSelector = React2.useCallback(
+      (rootOrNull2) => rootOrNull2 !== null ? selector(rootOrNull2) : null,
+      [selector]
+    );
+    const subscribe = React2.useCallback(
+      (onStoreChange) => rootOrNull !== null ? room.subscribe(rootOrNull, onStoreChange, { isDeep: true }) : noop,
+      [room, rootOrNull]
+    );
+    const getSnapshot = React2.useCallback(() => {
+      if (rootOrNull === null) {
+        return null;
+      } else {
+        const root = rootOrNull;
+        const imm = root.toImmutable();
+        return imm;
+      }
+    }, [rootOrNull]);
+    const getServerSnapshot = React2.useCallback(() => null, []);
+    return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
+      subscribe,
+      getSnapshot,
+      getServerSnapshot,
+      wrappedSelector,
+      isEqual
+    );
+  }
+  function ensureNotServerSide() {
+    if (typeof window === "undefined") {
+      throw new Error(
+        "You cannot use the Suspense version of this hook on the server side. Make sure to only call them on the client side.\nFor tips, see https://liveblocks.io/docs/api-reference/liveblocks-react#suspense-avoid-ssr"
+      );
+    }
+  }
+  function useSuspendUntilStorageLoaded() {
+    const room = useRoom();
+    if (room.getStorageSnapshot() !== null) {
+      return;
+    }
+    ensureNotServerSide();
+    throw new Promise((res) => {
+      room.events.storageDidLoad.subscribeOnce(() => res());
+    });
+  }
+  function useSuspendUntilPresenceLoaded() {
+    const room = useRoom();
+    if (room.isSelfAware()) {
+      return;
+    }
+    ensureNotServerSide();
+    throw new Promise((res) => {
+      room.events.connection.subscribeOnce(() => res());
+    });
+  }
+  function useMutation(callback, deps) {
+    const room = useRoom();
+    return React2.useMemo(
+      () => {
+        return (...args) => (
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+          room.batch(
+            () => (
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+              callback(
+                makeMutationContext(room),
+                ...args
+              )
+            )
+          )
+        );
+      },
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [room, ...deps]
+    );
+  }
+  function useStorageSuspense(selector, isEqual) {
+    useSuspendUntilStorageLoaded();
+    return useStorage(
+      selector,
+      isEqual
+    );
+  }
+  function useSelfSuspense(selector, isEqual) {
+    useSuspendUntilPresenceLoaded();
+    return useSelf(
+      selector,
+      isEqual
+    );
+  }
+  function useOthersSuspense(selector, isEqual) {
+    useSuspendUntilPresenceLoaded();
+    return useOthers(
+      selector,
+      isEqual
+    );
+  }
+  function useOthersConnectionIdsSuspense() {
+    useSuspendUntilPresenceLoaded();
+    return useOthersConnectionIds();
+  }
+  function useOthersMappedSuspense(itemSelector, itemIsEqual) {
+    useSuspendUntilPresenceLoaded();
+    return useOthersMapped(itemSelector, itemIsEqual);
+  }
+  function useOtherSuspense(connectionId, selector, isEqual) {
+    useSuspendUntilPresenceLoaded();
+    return useOther(connectionId, selector, isEqual);
+  }
+  function useLegacyKeySuspense(key) {
+    useSuspendUntilStorageLoaded();
+    return useLegacyKey(key);
+  }
+  return {
+    RoomContext,
+    RoomProvider,
+    useRoom,
+    useStatus,
+    useBatch,
+    useBroadcastEvent,
+    useLostConnectionListener,
+    useErrorListener,
+    useEventListener,
+    useHistory,
+    useUndo,
+    useRedo,
+    useCanRedo,
+    useCanUndo,
+    // These are just aliases. The passed-in key will define their return values.
+    useList: useLegacyKey,
+    useMap: useLegacyKey,
+    useObject: useLegacyKey,
+    useStorageRoot,
+    useStorage,
+    useSelf,
+    useMyPresence,
+    useUpdateMyPresence,
+    useOthers,
+    useOthersMapped,
+    useOthersConnectionIds,
+    useOther,
+    useMutation,
+    suspense: {
+      RoomContext,
+      RoomProvider,
+      useRoom,
+      useStatus,
+      useBatch,
+      useBroadcastEvent,
+      useLostConnectionListener,
+      useErrorListener,
+      useEventListener,
+      useHistory,
+      useUndo,
+      useRedo,
+      useCanRedo,
+      useCanUndo,
+      // Legacy hooks
+      useList: useLegacyKeySuspense,
+      useMap: useLegacyKeySuspense,
+      useObject: useLegacyKeySuspense,
+      useStorageRoot,
+      useStorage: useStorageSuspense,
+      useSelf: useSelfSuspense,
+      useMyPresence,
+      useUpdateMyPresence,
+      useOthers: useOthersSuspense,
+      useOthersMapped: useOthersMappedSuspense,
+      useOthersConnectionIds: useOthersConnectionIdsSuspense,
+      useOther: useOtherSuspense,
+      useMutation
+    }
+  };
+}
+
+// src/index.ts
+
+
+
+
+
+exports.ClientSideSuspense = ClientSideSuspense; exports.createRoomContext = createRoomContext; exports.shallow = _client.shallow;
 //# sourceMappingURL=index.js.map