@liveblocks/react 0.16.4-beta2 → 0.16.6

package/index.mjs

@@ -1,409 +1,230 @@
-import * as React from 'react';
-import { useReducer } from 'react';
-import { LiveMap, LiveList, LiveObject } from '@liveblocks/client';
+import * as React from "react";
+
+import { useReducer } from "react";
+
+import { LiveMap, LiveList, LiveObject } from "@liveblocks/client";
+
+import { deprecateIf } from "@liveblocks/client/internal";
 
 const ClientContext = React.createContext(null);
-/**
- * Makes the Liveblocks client available in the component hierarchy below.
- */
+
 function LiveblocksProvider(props) {
-    return (React.createElement(ClientContext.Provider, { value: props.client }, props.children));
+ return React.createElement(ClientContext.Provider, {
+  value: props.client
+ }, props.children);
 }
-/**
- * Returns the Client of the nearest LiveblocksProvider above in the React
- * component tree.
- */
+
 function useClient() {
-    const client = React.useContext(ClientContext);
-    if (client == null) {
-        throw new Error("LiveblocksProvider is missing from the react tree");
-    }
-    return client;
+ const client = React.useContext(ClientContext);
+ if (null == client) throw new Error("LiveblocksProvider is missing from the react tree");
+ return client;
 }
 
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+function __awaiter(thisArg, _arguments, P, generator) {
+ return new (P || (P = Promise))((function(resolve, reject) {
+  function fulfilled(value) {
+   try {
+    step(generator.next(value));
+   } catch (e) {
+    reject(e);
+   }
+  }
+  function rejected(value) {
+   try {
+    step(generator.throw(value));
+   } catch (e) {
+    reject(e);
+   }
+  }
+  function step(result) {
+   var value;
+   result.done ? resolve(result.value) : (value = result.value, value instanceof P ? value : new P((function(resolve) {
+    resolve(value);
+   }))).then(fulfilled, rejected);
+  }
+  step((generator = generator.apply(thisArg, _arguments || [])).next());
+ }));
 }
 
-/**
- * Trigger a re-render programmatically, without changing the component's
- * state.
- *
- * Usage:
- *
- *   const rerender = useRerender();
- *   return (
- *     <button onClick={rerender}>
- *       {Math.random()}
- *     </button>
- *   )
- *
- */
 function useRerender() {
-    const [, update] = useReducer(
-    // 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;
+ const [, update] = useReducer((x => x + 1), 0);
+ return update;
 }
 
-const RoomContext = React.createContext(null);
-/**
- * Makes a Room available in the component hierarchy below.
- * When this component is unmounted, the current user leave the room.
- * That means that you can't have 2 RoomProvider with the same room id in your react tree.
- */
-function RoomProvider(props) {
-    const { id: roomId, defaultPresence, defaultStorageRoot } = props;
-    if (process.env.NODE_ENV !== "production") {
-        if (roomId == null) {
-            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 client = useClient();
-    const [room, setRoom] = React.useState(() => client.enter(roomId, {
-        defaultPresence: defaultPresence ? defaultPresence() : undefined,
-        defaultStorageRoot,
-        DO_NOT_USE_withoutConnecting: typeof window === "undefined",
+const {RoomProvider: RoomProvider, useRoom: useRoom, useMyPresence: useMyPresence, useUpdateMyPresence: useUpdateMyPresence, useOthers: useOthers, useBroadcastEvent: useBroadcastEvent, useErrorListener: useErrorListener, useEventListener: useEventListener, useSelf: useSelf, useStorage: useStorage, useMap: useMap, useList: useList, useObject: useObject, useUndo: useUndo, useRedo: useRedo, useBatch: useBatch, useHistory: useHistory} = function() {
+ const RoomContext = React.createContext(null);
+ function useRoom() {
+  const room = React.useContext(RoomContext);
+  if (null == room) throw new Error("RoomProvider is missing from the react tree");
+  return room;
+ }
+ function useStorage() {
+  const room = useRoom(), [root, setState] = React.useState(null);
+  return React.useEffect((() => {
+   let didCancel = !1;
+   return function() {
+    __awaiter(this, void 0, void 0, (function*() {
+     const storage = yield room.getStorage();
+     didCancel || setState(storage.root);
     }));
-    React.useEffect(() => {
-        setRoom(client.enter(roomId, {
-            defaultPresence: defaultPresence ? defaultPresence() : undefined,
-            defaultStorageRoot,
-            DO_NOT_USE_withoutConnecting: typeof window === "undefined",
-        }));
-        return () => {
-            client.leave(roomId);
-        };
-    }, [client, roomId]);
-    return (React.createElement(RoomContext.Provider, { value: room }, props.children));
-}
-/**
- * Returns the Room of the nearest RoomProvider above in the React component
- * tree.
- */
-function useRoom() {
-    const room = React.useContext(RoomContext);
-    if (room == null) {
-        throw new Error("RoomProvider is missing from the react tree");
-    }
-    return room;
-}
-/**
- * Returns the presence of the current user of the current room, and a function to update it.
- * It is different from the setState function returned by the useState hook from React.
- * You don't need to pass the full presence object to update it.
- *
- * @example
- * import { useMyPresence } from "@liveblocks/react";
- *
- * const [myPresence, updateMyPresence] = useMyPresence();
- * updateMyPresence({ x: 0 });
- * updateMyPresence({ y: 0 });
- *
- * // At the next render, "myPresence" will be equal to "{ x: 0, y: 0 }"
- */
-function useMyPresence() {
-    const room = useRoom();
-    const presence = room.getPresence();
-    const rerender = useRerender();
-    React.useEffect(() => {
-        const unsubscribe = room.subscribe("my-presence", rerender);
-        return () => {
-            unsubscribe();
-        };
-    }, [room]);
-    const setPresence = React.useCallback((overrides, options) => room.updatePresence(overrides, options), [room]);
-    return [presence, setPresence];
-}
-/**
- * useUpdateMyPresence is similar to useMyPresence but it only returns the function to update the current user presence.
- * If you don't use the current user presence in your component, but you need to update it (e.g. live cursor), it's better to use useUpdateMyPresence to avoid unnecessary renders.
- *
- * @example
- * import { useUpdateMyPresence } from "@liveblocks/react";
- *
- * const updateMyPresence = useUpdateMyPresence();
- * updateMyPresence({ x: 0 });
- * updateMyPresence({ y: 0 });
- *
- * // At the next render, the presence of the current user will be equal to "{ x: 0, y: 0 }"
- */
-function useUpdateMyPresence() {
-    const room = useRoom();
-    return React.useCallback((overrides, options) => {
-        room.updatePresence(overrides, options);
-    }, [room]);
-}
-/**
- * Returns an object that lets you get information about all the the users currently connected in the room.
- *
- * @example
- * import { useOthers } from "@liveblocks/react";
- *
- * const others = useOthers();
- *
- * // Example to map all cursors in jsx
- * {
- *   others.map(({ connectionId, presence }) => {
- *     if(presence == null || presence.cursor == null) {
- *       return null;
- *     }
- *     return <Cursor key={connectionId} cursor={presence.cursor} />
- *   })
- * }
- */
-function useOthers() {
-    const room = useRoom();
-    const rerender = useRerender();
-    React.useEffect(() => {
-        const unsubscribe = room.subscribe("others", rerender);
-        return () => {
-            unsubscribe();
-        };
-    }, [room]);
-    return room.getOthers();
-}
-/**
- * Returns a callback that lets you broadcast custom events to other users in the room
- *
- * @example
- * import { useBroadcastEvent } from "@liveblocks/react";
- *
- * const broadcast = useBroadcastEvent();
- *
- * broadcast({ type: "CUSTOM_EVENT", data: { x: 0, y: 0 } });
- */
-function useBroadcastEvent() {
-    const room = useRoom();
-    return React.useCallback((event, options = { shouldQueueEventIfNotReady: false }) => {
-        room.broadcastEvent(event, options);
-    }, [room]);
-}
-/**
- * useErrorListener is a react hook that lets you react to potential room connection errors.
- *
- * @example
- * import { useErrorListener } from "@liveblocks/react";
- *
- * useErrorListener(er => {
- *   console.error(er);
- * })
- */
-function useErrorListener(callback) {
-    const room = useRoom();
-    const savedCallback = React.useRef(callback);
-    React.useEffect(() => {
-        savedCallback.current = callback;
-    });
-    React.useEffect(() => {
-        const listener = (e) => savedCallback.current(e);
-        const unsubscribe = room.subscribe("error", listener);
-        return () => {
-            unsubscribe();
-        };
-    }, [room]);
-}
-/**
- * useEventListener is a react hook that lets you react to event broadcasted by other users in the room.
- *
- * @example
- * import { useEventListener } from "@liveblocks/react";
- *
- * useEventListener(({ connectionId, event }) => {
- *   if (event.type === "CUSTOM_EVENT") {
- *     // Do something
- *   }
- * });
- */
-function useEventListener(callback) {
-    const room = useRoom();
-    const savedCallback = React.useRef(callback);
-    React.useEffect(() => {
-        savedCallback.current = callback;
-    });
-    React.useEffect(() => {
-        const listener = (e) => savedCallback.current(e);
-        const unsubscribe = room.subscribe("event", listener);
-        return () => {
-            unsubscribe();
-        };
-    }, [room]);
-}
-/**
- * Gets the current user once it is connected to the room.
- *
- * @example
- * import { useSelf } from "@liveblocks/react";
- *
- * const user = useSelf();
- */
-function useSelf() {
-    const room = useRoom();
-    const rerender = useRerender();
-    React.useEffect(() => {
-        const unsubscribePresence = room.subscribe("my-presence", rerender);
-        const unsubscribeConnection = room.subscribe("connection", rerender);
-        return () => {
-            unsubscribePresence();
-            unsubscribeConnection();
-        };
-    }, [room]);
-    return room.getSelf();
-}
-function useStorage() {
-    const room = useRoom();
-    const [root, setState] = React.useState(null);
-    React.useEffect(() => {
-        let didCancel = false;
-        function fetchStorage() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const storage = yield room.getStorage();
-                if (!didCancel) {
-                    setState(storage.root);
-                }
-            });
-        }
-        fetchStorage();
-        return () => {
-            didCancel = true;
-        };
-    }, [room]);
-    return [root];
-}
-/**
- * Returns the LiveMap associated with the provided key. If the LiveMap does not exist, a new empty LiveMap will be created.
- * The hook triggers a re-render if the LiveMap is updated, however it does not triggers a re-render if a nested CRDT is updated.
- *
- * @param key The storage key associated with the LiveMap
- * @param entries Optional entries that are used to create the LiveMap for the first time
- * @returns null while the storage is loading, otherwise, returns the LiveMap associated to the storage
- *
- * @example
- * const emptyMap = useMap("mapA");
- * const mapWithItems = useMap("mapB", [["keyA", "valueA"], ["keyB", "valueB"]]);
- */
-function useMap(key, entries) {
-    return useCrdt(key, new LiveMap(entries));
-}
-/**
- * Returns the LiveList associated with the provided key. If the LiveList does not exist, a new LiveList will be created.
- * The hook triggers a re-render if the LiveList is updated, however it does not triggers a re-render if a nested CRDT is updated.
- *
- * @param key The storage key associated with the LiveList
- * @param items Optional items that are used to create the LiveList for the first time
- * @returns null while the storage is loading, otherwise, returns the LiveList associated to the storage
- *
- * @example
- * const emptyList = useList("listA");
- * const listWithItems = useList("listB", ["a", "b", "c"]);
- */
-function useList(key, items) {
-    return useCrdt(key, new LiveList(items));
-}
-/**
- * Returns the LiveObject associated with the provided key. If the LiveObject does not exist, it will be created with the initialData parameter.
- * The hook triggers a re-render if the LiveObject is updated, however it does not triggers a re-render if a nested CRDT is updated.
- *
- * @param key The storage key associated with the LiveObject
- * @param initialData Optional data that is used to create the LiveObject for the first time
- * @returns null while the storage is loading, otherwise, returns the LveObject associated to the storage
- *
- * @example
- * const object = useObject("obj", {
- *   company: "Liveblocks",
- *   website: "https://liveblocks.io"
- * });
- */
-function useObject(key, initialData) {
-    return useCrdt(key, new LiveObject(initialData));
-}
-/**
- * Returns a function that undoes the last operation executed by the current client.
- * It does not impact operations made by other clients.
- */
-function useUndo() {
-    return useRoom().history.undo;
-}
-/**
- * Returns a function that redoes the last operation executed by the current client.
- * It does not impact operations made by other clients.
- */
-function useRedo() {
-    return useRoom().history.redo;
-}
-/**
- * Returns a function that batches modifications made during the given function.
- * All the modifications are sent to other clients in a single message.
- * All the modifications are merged in a single history item (undo/redo).
- * All the subscribers are called only after the batch is over.
- */
-function useBatch() {
-    return useRoom().batch;
-}
-/**
- * Returns the room.history
- */
-function useHistory() {
-    return useRoom().history;
-}
-function useCrdt(key, initialCrdt) {
-    var _a;
-    const room = useRoom();
-    const [root] = useStorage();
-    const rerender = useRerender();
-    React.useEffect(() => {
-        if (root == null) {
-            return;
-        }
-        let crdt = root.get(key);
-        if (crdt == null) {
-            crdt = initialCrdt;
-            root.set(key, crdt);
-        }
-        function onRootChange() {
-            const newCrdt = root.get(key);
-            if (newCrdt !== crdt) {
-                unsubscribeCrdt();
-                crdt = newCrdt;
-                unsubscribeCrdt = room.subscribe(crdt /* AbstractCrdt */, rerender);
-                rerender();
-            }
-        }
-        let unsubscribeCrdt = room.subscribe(crdt /* AbstractCrdt */, rerender);
-        const unsubscribeRoot = room.subscribe(root /* AbstractCrdt */, onRootChange);
-        rerender();
-        return () => {
-            unsubscribeRoot();
-            unsubscribeCrdt();
-        };
-    }, [root, room]);
-    return (_a = root === null || root === void 0 ? void 0 : root.get(key)) !== null && _a !== void 0 ? _a : null;
-}
+   }(), () => {
+    didCancel = !0;
+   };
+  }), [ room ]), [ root ];
+ }
+ function useHistory() {
+  return useRoom().history;
+ }
+ function useStorageValue(key, initialValue) {
+  const room = useRoom(), [root] = useStorage(), rerender = useRerender();
+  if (React.useEffect((() => {
+   if (null == root) return;
+   let liveValue = root.get(key);
+   null == liveValue && (liveValue = initialValue, root.set(key, liveValue));
+   let unsubscribeCrdt = room.subscribe(liveValue, rerender);
+   const unsubscribeRoot = room.subscribe(root, (function() {
+    const newCrdt = root.get(key);
+    newCrdt !== liveValue && (unsubscribeCrdt(), liveValue = newCrdt, unsubscribeCrdt = room.subscribe(liveValue, rerender), 
+    rerender());
+   }));
+   return rerender(), () => {
+    unsubscribeRoot(), unsubscribeCrdt();
+   };
+  }), [ root, room ]), null == root) return {
+   status: "loading"
+  };
+  {
+   const value = root.get(key);
+   return null == value ? {
+    status: "notfound"
+   } : {
+    status: "ok",
+    value: value
+   };
+  }
+ }
+ return {
+  RoomProvider: function(props) {
+   const {id: roomId, initialPresence: initialPresence, initialStorage: initialStorage, defaultPresence: defaultPresence, defaultStorageRoot: defaultStorageRoot} = props;
+   if ("production" !== process.env.NODE_ENV) {
+    if (null == 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 ("string" != typeof roomId) throw new Error("RoomProvider id property should be a string.");
+   }
+   deprecateIf(defaultPresence, "RoomProvider's `defaultPresence` prop will be removed in @liveblocks/react 0.18. Please use `initialPresence` instead. For more info, see https://bit.ly/3Niy5aP", "defaultPresence"), 
+   deprecateIf(defaultStorageRoot, "RoomProvider's `defaultStorageRoot` prop will be removed in @liveblocks/react 0.18. Please use `initialStorage` instead. For more info, see https://bit.ly/3Niy5aP", "defaultStorageRoot");
+   const client = useClient(), [room, setRoom] = React.useState((() => client.enter(roomId, {
+    initialPresence: initialPresence,
+    initialStorage: initialStorage,
+    defaultPresence: defaultPresence,
+    defaultStorageRoot: defaultStorageRoot,
+    DO_NOT_USE_withoutConnecting: "undefined" == typeof window
+   })));
+   return React.useEffect((() => (setRoom(client.enter(roomId, {
+    initialPresence: initialPresence,
+    initialStorage: initialStorage,
+    defaultPresence: defaultPresence,
+    defaultStorageRoot: defaultStorageRoot,
+    DO_NOT_USE_withoutConnecting: "undefined" == typeof window
+   })), () => {
+    client.leave(roomId);
+   })), [ client, roomId ]), React.createElement(RoomContext.Provider, {
+    value: room
+   }, props.children);
+  },
+  useBatch: function() {
+   return useRoom().batch;
+  },
+  useBroadcastEvent: function() {
+   const room = useRoom();
+   return React.useCallback(((event, options = {
+    shouldQueueEventIfNotReady: !1
+   }) => {
+    room.broadcastEvent(event, options);
+   }), [ room ]);
+  },
+  useErrorListener: function(callback) {
+   const room = useRoom(), savedCallback = React.useRef(callback);
+   React.useEffect((() => {
+    savedCallback.current = callback;
+   })), React.useEffect((() => {
+    const unsubscribe = room.subscribe("error", (e => savedCallback.current(e)));
+    return () => {
+     unsubscribe();
+    };
+   }), [ room ]);
+  },
+  useEventListener: function(callback) {
+   const room = useRoom(), savedCallback = React.useRef(callback);
+   React.useEffect((() => {
+    savedCallback.current = callback;
+   })), React.useEffect((() => {
+    const unsubscribe = room.subscribe("event", (e => savedCallback.current(e)));
+    return () => {
+     unsubscribe();
+    };
+   }), [ room ]);
+  },
+  useHistory: useHistory,
+  useList: function(key, items) {
+   deprecateIf(items, `Support for initializing items in useList() directly will be removed in @liveblocks/react 0.18.\n\nInstead, please initialize this data where you set up your RoomProvider:\n\n    import { LiveList } from "@liveblocks/client";\n\n    const initialStorage = () => ({\n      ${JSON.stringify(key)}: new LiveList(...),\n      ...\n    });\n\n    <RoomProvider initialStorage={initialStorage}>\n      ...\n    </RoomProvider>\n\nPlease see https://bit.ly/3Niy5aP for details.`);
+   const value = useStorageValue(key, new LiveList(items));
+   return "ok" === value.status ? value.value : (deprecateIf("notfound" === value.status, `Key ${JSON.stringify(key)} was not found in Storage. Starting with 0.18, useList() will no longer automatically create this key.\n\nInstead, please initialize your storage where you set up your RoomProvider:\n\n    import { LiveList } from "@liveblocks/client";\n\n    const initialStorage = () => ({\n      ${JSON.stringify(key)}: new LiveList(...),\n      ...\n    });\n\n    <RoomProvider initialStorage={initialStorage}>\n      ...\n    </RoomProvider>\n\nPlease see https://bit.ly/3Niy5aP for details.`), 
+   null);
+  },
+  useMap: function(key, entries) {
+   deprecateIf(entries, `Support for initializing entries in useMap() directly will be removed in @liveblocks/react 0.18.\n\nInstead, please initialize this data where you set up your RoomProvider:\n\n    const initialStorage = () => ({\n      ${JSON.stringify(key)}: new LiveMap(...),\n      ...\n    });\n\n    <RoomProvider initialStorage={initialStorage}>\n      ...\n    </RoomProvider>\n\nPlease see https://bit.ly/3Niy5aP for details.`);
+   const value = useStorageValue(key, new LiveMap(null != entries ? entries : void 0));
+   return "ok" === value.status ? value.value : (deprecateIf("notfound" === value.status, `Key ${JSON.stringify(key)} was not found in Storage. Starting with 0.18, useMap() will no longer automatically create this key.\n\nInstead, please initialize your storage where you set up your RoomProvider:\n\n    import { LiveMap } from "@liveblocks/client";\n\n    const initialStorage = () => ({\n      ${JSON.stringify(key)}: new LiveMap(...),\n      ...\n    });\n\n    <RoomProvider initialStorage={initialStorage}>\n      ...\n    </RoomProvider>\n\nPlease see https://bit.ly/3Niy5aP for details.`), 
+   null);
+  },
+  useMyPresence: function() {
+   const room = useRoom(), presence = room.getPresence(), rerender = useRerender();
+   return React.useEffect((() => {
+    const unsubscribe = room.subscribe("my-presence", rerender);
+    return () => {
+     unsubscribe();
+    };
+   }), [ room ]), [ presence, React.useCallback(((overrides, options) => room.updatePresence(overrides, options)), [ room ]) ];
+  },
+  useObject: function(key, initialData) {
+   deprecateIf(initialData, `Support for initializing data in useObject() directly will be removed in @liveblocks/react 0.18.\n\nInstead, please initialize this data where you set up your RoomProvider:\n\n    import { LiveObject } from "@liveblocks/client";\n\n    const initialStorage = () => ({\n      ${JSON.stringify(key)}: new LiveObject(...),\n      ...\n    });\n\n    <RoomProvider initialStorage={initialStorage}>\n      ...\n    </RoomProvider>\n\nPlease see https://bit.ly/3Niy5aP for details.`);
+   const value = useStorageValue(key, new LiveObject(initialData));
+   return "ok" === value.status ? value.value : (deprecateIf("notfound" === value.status, `Key ${JSON.stringify(key)} was not found in Storage. Starting with 0.18, useObject() will no longer automatically create this key.\n\nInstead, please initialize your storage where you set up your RoomProvider:\n\n    import { LiveObject } from "@liveblocks/client";\n\n    const initialStorage = () => ({\n      ${JSON.stringify(key)}: new LiveObject(...),\n      ...\n    });\n\n    <RoomProvider initialStorage={initialStorage}>\n      ...\n    </RoomProvider>\n\nPlease see https://bit.ly/3Niy5aP for details.`), 
+   null);
+  },
+  useOthers: function() {
+   const room = useRoom(), rerender = useRerender();
+   return React.useEffect((() => {
+    const unsubscribe = room.subscribe("others", rerender);
+    return () => {
+     unsubscribe();
+    };
+   }), [ room ]), room.getOthers();
+  },
+  useRedo: function() {
+   return useHistory().redo;
+  },
+  useRoom: useRoom,
+  useSelf: function() {
+   const room = useRoom(), rerender = useRerender();
+   return React.useEffect((() => {
+    const unsubscribePresence = room.subscribe("my-presence", rerender), unsubscribeConnection = room.subscribe("connection", rerender);
+    return () => {
+     unsubscribePresence(), unsubscribeConnection();
+    };
+   }), [ room ]), room.getSelf();
+  },
+  useStorage: useStorage,
+  useUndo: function() {
+   return useHistory().undo;
+  },
+  useUpdateMyPresence: function() {
+   const room = useRoom();
+   return React.useCallback(((overrides, options) => {
+    room.updatePresence(overrides, options);
+   }), [ room ]);
+  }
+ };
+}();
 
 export { LiveblocksProvider, RoomProvider, useBatch, useBroadcastEvent, useClient, useErrorListener, useEventListener, useHistory, useList, useMap, useMyPresence, useObject, useOthers, useRedo, useRoom, useSelf, useStorage, useUndo, useUpdateMyPresence };