@liveblocks/react 0.16.4-beta2 → 0.16.6

package/index.d.ts

@@ -1,6 +1,8 @@
-import * as React from 'react';
-import { Client, Room, Presence, Others, BroadcastOptions, Json, User, LiveObject, Lson, LiveMap, LiveList, LsonObject, History } from '@liveblocks/client';
+/// <reference types="react" />
+import { Client } from '@liveblocks/client';
 export { Json, JsonObject } from '@liveblocks/client';
+import * as React from 'react';
+import * as _liveblocks_client_shared from '@liveblocks/client/shared';
 
 declare type LiveblocksProviderProps = {
     children: React.ReactNode;
@@ -16,196 +18,45 @@ declare function LiveblocksProvider(props: LiveblocksProviderProps): JSX.Element
  */
 declare function useClient(): Client;
 
-declare type RoomProviderProps<TStorage> = {
-    /**
-     * The id of the room you want to connect to
-     */
+declare const RoomProvider: <TStorage>(props: {
     id: string;
-    /**
-     * A callback that let you initialize the default presence when entering the room.
-     * If ommited, the default presence will be an empty object
-     */
-    defaultPresence?: () => Presence;
-    defaultStorageRoot?: TStorage;
     children: React.ReactNode;
-};
-/**
- * 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.
- */
-declare function RoomProvider<TStorage>(props: RoomProviderProps<TStorage>): JSX.Element;
-/**
- * Returns the Room of the nearest RoomProvider above in the React component
- * tree.
- */
-declare function useRoom(): 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 }"
- */
-declare function useMyPresence<T extends Presence>(): [
-    T,
-    (overrides: Partial<T>, options?: {
-        addToHistory: boolean;
-    }) => void
-];
-/**
- * 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 }"
- */
-declare function useUpdateMyPresence<T extends Presence>(): (overrides: Partial<T>, options?: {
+    initialPresence?: Record<string, unknown> | ((roomId: string) => Record<string, unknown>) | undefined;
+    initialStorage?: TStorage | ((roomId: string) => TStorage) | undefined;
+    defaultPresence?: (() => Record<string, unknown>) | undefined;
+    defaultStorageRoot?: TStorage | undefined;
+}) => JSX.Element;
+declare const useRoom: () => _liveblocks_client_shared.R;
+declare const useMyPresence: <T extends Record<string, unknown>>() => [T, (overrides: Partial<T>, options?: {
     addToHistory: boolean;
-}) => void;
-/**
- * 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} />
- *   })
- * }
- */
-declare function useOthers<T extends Presence>(): Others<T>;
-/**
- * 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 } });
- */
-declare function useBroadcastEvent(): (event: any, options?: BroadcastOptions) => void;
-/**
- * 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);
- * })
- */
-declare function useErrorListener(callback: (err: Error) => void): void;
-/**
- * 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
- *   }
- * });
- */
-declare function useEventListener<TEvent extends Json>(callback: ({ connectionId, event, }: {
+} | undefined) => void];
+declare const useUpdateMyPresence: <T extends Record<string, unknown>>() => (overrides: Partial<T>, options?: {
+    addToHistory: boolean;
+} | undefined) => void;
+declare const useOthers: <T extends Record<string, unknown>>() => _liveblocks_client_shared.O<T>;
+declare const useBroadcastEvent: () => (event: any, options?: _liveblocks_client_shared.B | undefined) => void;
+declare const useErrorListener: (callback: (err: Error) => void) => void;
+declare const useEventListener: <TEvent extends _liveblocks_client_shared.J>(callback: ({ connectionId, event, }: {
     connectionId: number;
     event: TEvent;
-}) => void): void;
-/**
- * Gets the current user once it is connected to the room.
- *
- * @example
- * import { useSelf } from "@liveblocks/react";
- *
- * const user = useSelf();
- */
-declare function useSelf<TPresence extends Presence = Presence>(): User<TPresence> | null;
-declare function useStorage<TStorage extends Record<string, any>>(): [
-    root: LiveObject<TStorage> | null
-];
-/**
- * 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"]]);
- */
-declare function useMap<TKey extends string, TValue extends Lson>(key: string, entries?: readonly (readonly [TKey, TValue])[] | null | undefined): LiveMap<TKey, TValue> | null;
-/**
- * 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"]);
- */
-declare function useList<TValue extends Lson>(key: string, items?: TValue[] | undefined): LiveList<TValue> | null;
-/**
- * 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"
- * });
- */
-declare function useObject<TData extends LsonObject>(key: string, initialData?: TData): LiveObject<TData> | null;
-/**
- * Returns a function that undoes the last operation executed by the current client.
- * It does not impact operations made by other clients.
- */
-declare function useUndo(): () => void;
-/**
- * Returns a function that redoes the last operation executed by the current client.
- * It does not impact operations made by other clients.
- */
-declare function useRedo(): () => void;
-/**
- * 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.
- */
-declare function useBatch(): (callback: () => void) => void;
-/**
- * Returns the room.history
- */
-declare function useHistory(): History;
+}) => void) => void;
+declare const useSelf: <TPresence extends Record<string, unknown> = Record<string, unknown>>() => _liveblocks_client_shared.U<TPresence> | null;
+declare const useStorage: <TStorage extends Record<string, any>>() => [root: _liveblocks_client_shared.L<TStorage> | null];
+declare const useMap: {
+    <TKey extends string, TValue extends _liveblocks_client_shared.e>(key: string): _liveblocks_client_shared.b<TKey, TValue> | null;
+    <TKey_1 extends string, TValue_1 extends _liveblocks_client_shared.e>(key: string, entries: readonly (readonly [TKey_1, TValue_1])[] | null): _liveblocks_client_shared.b<TKey_1, TValue_1> | null;
+};
+declare const useList: {
+    <TValue extends _liveblocks_client_shared.e>(key: string): _liveblocks_client_shared.c<TValue> | null;
+    <TValue_1 extends _liveblocks_client_shared.e>(key: string, items: TValue_1[]): _liveblocks_client_shared.c<TValue_1> | null;
+};
+declare const useObject: {
+    <TData extends _liveblocks_client_shared.f>(key: string): _liveblocks_client_shared.L<TData> | null;
+    <TData_1 extends _liveblocks_client_shared.f>(key: string, initialData: TData_1): _liveblocks_client_shared.L<TData_1> | null;
+};
+declare const useUndo: () => () => void;
+declare const useRedo: () => () => void;
+declare const useBatch: () => (callback: () => void) => void;
+declare const useHistory: () => _liveblocks_client_shared.H;
 
 export { LiveblocksProvider, RoomProvider, useBatch, useBroadcastEvent, useClient, useErrorListener, useEventListener, useHistory, useList, useMap, useMyPresence, useObject, useOthers, useRedo, useRoom, useSelf, useStorage, useUndo, useUpdateMyPresence };