@liveblocks/redux 0.18.5 → 0.19.0

package/dist/index.d.ts

@@ -1,57 +1,72 @@
-import { JsonObject, BaseUserMeta, User, Client } from '@liveblocks/client';
+import { JsonObject, BaseUserMeta, Client, User } from '@liveblocks/client';
 import { StoreEnhancer } from 'redux';
 
 declare type Mapping<T> = {
     [K in keyof T]?: boolean;
 };
-declare type LiveblocksState<TState, TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = TState & {
+declare type LiveblocksContext<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = {
     /**
-     * Liveblocks extra state attached by the enhancer
+     * Other users in the room. Empty no room is currently synced
      */
-    readonly liveblocks: {
-        /**
-         * Other users in the room. Empty no room is currently synced
-         */
-        readonly others: Array<User<TPresence, TUserMeta>>;
-        /**
-         * Whether or not the room storage is currently loading
-         */
-        readonly isStorageLoading: boolean;
-        /**
-         * Connection state of the room
-         */
-        readonly connection: "closed" | "authenticating" | "unavailable" | "failed" | "open" | "connecting";
-    };
+    readonly others: readonly User<TPresence, TUserMeta>[];
+    /**
+     * Whether or not the room storage is currently loading
+     */
+    readonly isStorageLoading: boolean;
+    /**
+     * Connection state of the room
+     */
+    readonly connection: "closed" | "authenticating" | "unavailable" | "failed" | "open" | "connecting";
+};
+/**
+ * @deprecated Please rename to WithLiveblocks<...>
+ */
+declare type LiveblocksState<TState, TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = WithLiveblocks<TState, TPresence, TUserMeta>;
+/**
+ * Adds the `liveblocks` property to your custom Redux state.
+ */
+declare type WithLiveblocks<TState, TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = TState & {
+    readonly liveblocks: LiveblocksContext<TPresence, TUserMeta>;
 };
 /**
  * Actions used to interact with Liveblocks
  */
 declare const actions: {
     /**
-     * Enters a room and starts sync it with zustand state
+     * Enters a room and starts sync it with Redux state
      * @param roomId The id of the room
-     * @param initialState The initial state of the room storage. If a key does not exist if your room storage root, initialState[key] will be used.
      */
     enterRoom: typeof enterRoom;
     /**
-     * Leaves a room and stops sync it with zustand state.
+     * Leaves a room and stops sync it with Redux state.
      * @param roomId The id of the room
      */
     leaveRoom: typeof leaveRoom;
 };
-declare function enterRoom<T>(roomId: string, initialState?: T): {
+declare function enterRoom(roomId: string): {
     type: string;
     roomId: string;
-    initialState?: T;
 };
 declare function leaveRoom(roomId: string): {
     type: string;
     roomId: string;
 };
-declare const enhancer: <T>(options: {
+/**
+ * Redux store enhancer that will make the `liveblocks` key available on your
+ * Redux store.
+ */
+declare const liveblocksEnhancer: <TState>(options: {
+    client: Client;
+    storageMapping?: Mapping<TState> | undefined;
+    presenceMapping?: Mapping<TState> | undefined;
+}) => StoreEnhancer;
+/**
+ * @deprecated Renamed to `liveblocksEnhancer`.
+ */
+declare const enhancer: <TState>(options: {
     client: Client;
-    storageMapping?: Mapping<T> | undefined;
-    presenceMapping?: Mapping<T> | undefined;
+    storageMapping?: Mapping<TState> | undefined;
+    presenceMapping?: Mapping<TState> | undefined;
 }) => StoreEnhancer;
 
-export { LiveblocksState, Mapping, actions, enhancer };
+export { LiveblocksState, Mapping, WithLiveblocks, actions, enhancer, liveblocksEnhancer };

package/dist/index.js

@@ -77,186 +77,182 @@ var internalEnhancer = (options) => {
   if (process.env.NODE_ENV !== "production") {
     validateNoDuplicateKeys(mapping, presenceMapping);
   }
-  return (createStore) => (reducer, initialState, enhancer2) => {
-    let room = null;
-    let isPatching = false;
-    let storageRoot = null;
-    let unsubscribeCallbacks = [];
-    const newReducer = (state, action) => {
-      switch (action.type) {
-        case ACTION_TYPES.PATCH_REDUX_STATE:
-          return __spreadValues(__spreadValues({}, state), action.state);
-        case ACTION_TYPES.INIT_STORAGE:
-          return __spreadProps(__spreadValues(__spreadValues({}, state), action.state), {
-            liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
-              isStorageLoading: false
-            })
-          });
-        case ACTION_TYPES.START_LOADING_STORAGE:
-          return __spreadProps(__spreadValues({}, state), {
-            liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
-              isStorageLoading: true
-            })
-          });
-        case ACTION_TYPES.UPDATE_CONNECTION: {
-          return __spreadProps(__spreadValues({}, state), {
-            liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
-              connection: action.connection
-            })
-          });
-        }
-        case ACTION_TYPES.UPDATE_OTHERS: {
-          return __spreadProps(__spreadValues({}, state), {
-            liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
-              others: action.others
-            })
-          });
-        }
-        default: {
-          const newState = reducer(state, action);
-          if (room) {
-            isPatching = true;
-            updatePresence(room, state, newState, presenceMapping);
-            room.batch(() => {
-              if (storageRoot) {
-                patchLiveblocksStorage(
-                  storageRoot,
-                  state,
-                  newState,
-                  mapping
-                );
-              }
+  return (createStore) => {
+    return (reducer, initialState, enhancer2) => {
+      let room = null;
+      let isPatching = false;
+      let storageRoot = null;
+      let unsubscribeCallbacks = [];
+      const newReducer = (state, action) => {
+        switch (action.type) {
+          case ACTION_TYPES.PATCH_REDUX_STATE:
+            return __spreadValues(__spreadValues({}, state), action.state);
+          case ACTION_TYPES.INIT_STORAGE:
+            return __spreadProps(__spreadValues(__spreadValues({}, state), action.state), {
+              liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
+                isStorageLoading: false
+              })
+            });
+          case ACTION_TYPES.START_LOADING_STORAGE:
+            return __spreadProps(__spreadValues({}, state), {
+              liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
+                isStorageLoading: true
+              })
+            });
+          case ACTION_TYPES.UPDATE_CONNECTION: {
+            return __spreadProps(__spreadValues({}, state), {
+              liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
+                connection: action.connection
+              })
             });
-            isPatching = false;
           }
-          if (newState.liveblocks == null) {
-            return __spreadProps(__spreadValues({}, newState), {
-              liveblocks: {
-                others: [],
-                isStorageLoading: false,
-                connection: "closed"
-              }
+          case ACTION_TYPES.UPDATE_OTHERS: {
+            return __spreadProps(__spreadValues({}, state), {
+              liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
+                others: action.others
+              })
             });
           }
-          return newState;
+          default: {
+            const newState = reducer(state, action);
+            if (room) {
+              isPatching = true;
+              updatePresence(room, state, newState, presenceMapping);
+              room.batch(() => {
+                if (storageRoot) {
+                  patchLiveblocksStorage(
+                    storageRoot,
+                    state,
+                    newState,
+                    mapping
+                  );
+                }
+              });
+              isPatching = false;
+            }
+            if (newState.liveblocks == null) {
+              return __spreadProps(__spreadValues({}, newState), {
+                liveblocks: {
+                  others: [],
+                  isStorageLoading: false,
+                  connection: "closed"
+                }
+              });
+            }
+            return newState;
+          }
         }
-      }
-    };
-    const store = createStore(newReducer, initialState, enhancer2);
-    function enterRoom2(roomId, storageInitialState = {}, reduxState) {
-      if (storageRoot) {
-        return;
-      }
-      room = client.enter(roomId, { initialPresence: {} });
-      broadcastInitialPresence(room, reduxState, presenceMapping);
-      unsubscribeCallbacks.push(
-        room.events.connection.subscribe(() => {
-          store.dispatch({
-            type: ACTION_TYPES.UPDATE_CONNECTION,
-            connection: room.getConnectionState()
-          });
-        })
-      );
-      unsubscribeCallbacks.push(
-        room.events.others.subscribe(({ others }) => {
-          store.dispatch({
-            type: ACTION_TYPES.UPDATE_OTHERS,
-            others: others.toArray()
-          });
-        })
-      );
-      unsubscribeCallbacks.push(
-        room.events.me.subscribe(() => {
-          if (isPatching === false) {
+      };
+      const store = createStore(newReducer, initialState, enhancer2);
+      function enterRoom2(roomId) {
+        if (storageRoot) {
+          return;
+        }
+        const initialPresence = selectFields(
+          store.getState(),
+          presenceMapping
+        );
+        room = client.enter(roomId, { initialPresence });
+        unsubscribeCallbacks.push(
+          room.events.connection.subscribe(() => {
             store.dispatch({
-              type: ACTION_TYPES.PATCH_REDUX_STATE,
-              state: patchPresenceState(
-                room.getPresence(),
-                presenceMapping
-              )
+              type: ACTION_TYPES.UPDATE_CONNECTION,
+              connection: room.getConnectionState()
             });
-          }
-        })
-      );
-      store.dispatch({
-        type: ACTION_TYPES.START_LOADING_STORAGE
-      });
-      room.getStorage().then(({ root }) => {
-        const updates = {};
-        room.batch(() => {
-          for (const key in mapping) {
-            const liveblocksStatePart = root.get(key);
-            if (liveblocksStatePart == null) {
-              updates[key] = storageInitialState[key];
-              _core.patchLiveObjectKey.call(void 0, 
-                root,
-                key,
-                void 0,
-                storageInitialState[key]
-              );
-            } else {
-              updates[key] = _core.lsonToJson.call(void 0, liveblocksStatePart);
+          })
+        );
+        unsubscribeCallbacks.push(
+          room.events.others.subscribe(({ others }) => {
+            store.dispatch({
+              type: ACTION_TYPES.UPDATE_OTHERS,
+              others
+            });
+          })
+        );
+        unsubscribeCallbacks.push(
+          room.events.me.subscribe(() => {
+            if (isPatching === false) {
+              store.dispatch({
+                type: ACTION_TYPES.PATCH_REDUX_STATE,
+                state: selectFields(room.getPresence(), presenceMapping)
+              });
             }
-          }
-        });
+          })
+        );
         store.dispatch({
-          type: ACTION_TYPES.INIT_STORAGE,
-          state: updates
+          type: ACTION_TYPES.START_LOADING_STORAGE
         });
-        storageRoot = root;
-        unsubscribeCallbacks.push(
-          room.subscribe(
-            root,
-            (updates2) => {
-              if (isPatching === false) {
-                store.dispatch({
-                  type: ACTION_TYPES.PATCH_REDUX_STATE,
-                  state: patchState(
-                    store.getState(),
-                    updates2,
-                    mapping
-                  )
-                });
+        room.getStorage().then(({ root }) => {
+          const updates = {};
+          room.batch(() => {
+            for (const key in mapping) {
+              const liveblocksStatePart = root.get(key);
+              if (liveblocksStatePart == null) {
+                updates[key] = store.getState()[key];
+                _core.patchLiveObjectKey.call(void 0, root, key, void 0, store.getState()[key]);
+              } else {
+                updates[key] = _core.lsonToJson.call(void 0, liveblocksStatePart);
               }
-            },
-            { isDeep: true }
-          )
-        );
-      });
-    }
-    function leaveRoom2(roomId) {
-      for (const unsubscribe of unsubscribeCallbacks) {
-        unsubscribe();
+            }
+          });
+          store.dispatch({
+            type: ACTION_TYPES.INIT_STORAGE,
+            state: updates
+          });
+          storageRoot = root;
+          unsubscribeCallbacks.push(
+            room.subscribe(
+              root,
+              (updates2) => {
+                if (isPatching === false) {
+                  store.dispatch({
+                    type: ACTION_TYPES.PATCH_REDUX_STATE,
+                    state: patchState(
+                      store.getState(),
+                      updates2,
+                      mapping
+                    )
+                  });
+                }
+              },
+              { isDeep: true }
+            )
+          );
+        });
       }
-      storageRoot = null;
-      room = null;
-      isPatching = false;
-      unsubscribeCallbacks = [];
-      client.leave(roomId);
-    }
-    function newDispatch(action, state) {
-      if (action.type === ACTION_TYPES.ENTER) {
-        enterRoom2(action.roomId, action.initialState, store.getState());
-      } else if (action.type === ACTION_TYPES.LEAVE) {
-        leaveRoom2(action.roomId);
-      } else {
-        store.dispatch(action, state);
+      function leaveRoom2(roomId) {
+        for (const unsubscribe of unsubscribeCallbacks) {
+          unsubscribe();
+        }
+        storageRoot = null;
+        room = null;
+        isPatching = false;
+        unsubscribeCallbacks = [];
+        client.leave(roomId);
       }
-    }
-    return __spreadProps(__spreadValues({}, store), {
-      dispatch: newDispatch
-    });
+      function newDispatch(action) {
+        if (action.type === ACTION_TYPES.ENTER) {
+          enterRoom2(action.roomId);
+        } else if (action.type === ACTION_TYPES.LEAVE) {
+          leaveRoom2(action.roomId);
+        } else {
+          store.dispatch(action);
+        }
+      }
+      return __spreadProps(__spreadValues({}, store), {
+        dispatch: newDispatch
+      });
+    };
   };
 };
 var actions = {
   enterRoom,
   leaveRoom
 };
-function enterRoom(roomId, initialState) {
+function enterRoom(roomId) {
   return {
     type: ACTION_TYPES.ENTER,
-    roomId,
-    initialState
+    roomId
   };
 }
 function leaveRoom(roomId) {
@@ -265,22 +261,20 @@ function leaveRoom(roomId) {
     roomId
   };
 }
-var enhancer = internalEnhancer;
+var liveblocksEnhancer = internalEnhancer;
+var enhancer = liveblocksEnhancer;
 function patchLiveblocksStorage(root, oldState, newState, mapping) {
   for (const key in mapping) {
     if (process.env.NODE_ENV !== "production" && typeof newState[key] === "function") {
       throw mappingToFunctionIsNotAllowed("value");
     }
     if (oldState[key] !== newState[key]) {
-      _core.patchLiveObjectKey.call(void 0, root, key, oldState[key], newState[key]);
+      const oldVal = oldState[key];
+      const newVal = newState[key];
+      _core.patchLiveObjectKey.call(void 0, root, key, oldVal, newVal);
     }
   }
 }
-function broadcastInitialPresence(room, state, mapping) {
-  for (const key in mapping) {
-    room == null ? void 0 : room.updatePresence({ [key]: state[key] });
-  }
-}
 function updatePresence(room, oldState, newState, presenceMapping) {
   for (const key in presenceMapping) {
     if (typeof newState[key] === "function") {
@@ -301,7 +295,7 @@ function validateNoDuplicateKeys(storageMapping, presenceMapping) {
     }
   }
 }
-function patchPresenceState(presence, mapping) {
+function selectFields(presence, mapping) {
   const partialState = {};
   for (const key in mapping) {
     partialState[key] = presence[key];
@@ -340,4 +334,5 @@ function validateMapping(mapping, mappingType) {
 
 
 
-exports.actions = actions; exports.enhancer = enhancer;
+
+exports.actions = actions; exports.enhancer = enhancer; exports.liveblocksEnhancer = liveblocksEnhancer;

package/dist/index.mjs

@@ -3,3 +3,4 @@ import mod from "./index.js";
 export default mod;
 export const actions = mod.actions;
 export const enhancer = mod.enhancer;
+export const liveblocksEnhancer = mod.liveblocksEnhancer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/redux",
-  "version": "0.18.5",
+  "version": "0.19.0",
   "description": "A store enhancer to integrate Liveblocks into Redux stores.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -23,8 +23,7 @@
     "format": "eslint --fix src/ && prettier --write src/",
     "lint": "eslint src/",
     "test": "jest --silent --verbose",
-    "test:watch": "jest --silent --verbose --watch",
-    "dtslint": "dtslint --localTs node_modules/typescript/lib --expectOnly types"
+    "test:watch": "jest --silent --verbose --watch"
   },
   "license": "Apache-2.0",
   "repository": {
@@ -33,14 +32,13 @@
     "directory": "packages/liveblocks-redux"
   },
   "dependencies": {
-    "@liveblocks/client": "0.18.5",
-    "@liveblocks/core": "0.18.5"
+    "@liveblocks/client": "0.19.0",
+    "@liveblocks/core": "0.19.0"
   },
   "peerDependencies": {
     "redux": "^4"
   },
   "devDependencies": {
-    "@definitelytyped/dtslint": "^0.0.103",
     "@liveblocks/eslint-config": "*",
     "@liveblocks/jest-config": "*",
     "@reduxjs/toolkit": "^1.7.2",