@liveblocks/redux 0.16.3 → 0.16.4

package/index.d.ts

@@ -1,9 +1,10 @@
-import { Client, User, Presence } from "@liveblocks/client";
-import { StoreEnhancer } from "redux";
-export declare type Mapping<T> = Partial<{
+import { Presence, User, Client } from '@liveblocks/client';
+import { StoreEnhancer } from 'redux';
+
+declare type Mapping<T> = Partial<{
     [Property in keyof T]: boolean;
 }>;
-export declare type LiveblocksState<TState, TPresence extends Presence = Presence> = TState & {
+declare type LiveblocksState<TState, TPresence extends Presence = Presence> = TState & {
     /**
      * Liveblocks extra state attached by the enhancer
      */
@@ -25,7 +26,7 @@ export declare type LiveblocksState<TState, TPresence extends Presence = Presenc
 /**
  * Actions used to interact with Liveblocks
  */
-export declare const actions: {
+declare const actions: {
     /**
      * Enters a room and starts sync it with zustand state
      * @param roomId The id of the room
@@ -47,9 +48,10 @@ declare function leaveRoom(roomId: string): {
     type: string;
     roomId: string;
 };
-export declare const enhancer: <T>(options: {
+declare const enhancer: <T>(options: {
     client: Client;
     storageMapping?: Partial<{ [Property in keyof T]: boolean; }> | undefined;
     presenceMapping?: Partial<{ [Property in keyof T]: boolean; }> | undefined;
 }) => StoreEnhancer;
-export {};
+
+export { LiveblocksState, Mapping, actions, enhancer };

package/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var client = require('@liveblocks/client');
+var internal = require('@liveblocks/client/internal');
 
 function _extends() {
   _extends = Object.assign || function (target) {
@@ -77,9 +77,6 @@ function mappingToFunctionIsNotAllowed(key) {
   return new Error(ERROR_PREFIX + " mapping." + key + " is invalid. Mapping to a function is not allowed.");
 }
 
-var patchImmutableObject = client.internals.patchImmutableObject,
-    patchLiveObjectKey = client.internals.patchLiveObjectKey,
-    lsonToJson = client.internals.lsonToJson;
 var ACTION_TYPES = {
   ENTER: "@@LIVEBLOCKS/ENTER",
   LEAVE: "@@LIVEBLOCKS/LEAVE",
@@ -217,14 +214,14 @@ var internalEnhancer = function internalEnhancer(options) {
           var root = _ref.root;
           var updates = {};
           room.batch(function () {
-            for (var _key in mapping) {
-              var liveblocksStatePart = root.get(_key);
+            for (var key in mapping) {
+              var liveblocksStatePart = root.get(key);
 
               if (liveblocksStatePart == null) {
-                updates[_key] = storageInitialState[_key];
-                patchLiveObjectKey(root, _key, undefined, storageInitialState[_key]);
+                updates[key] = storageInitialState[key];
+                internal.patchLiveObjectKey(root, key, undefined, storageInitialState[key]);
               } else {
-                updates[_key] = lsonToJson(liveblocksStatePart);
+                updates[key] = internal.lsonToJson(liveblocksStatePart);
               }
             }
           });
@@ -299,35 +296,35 @@ function leaveRoom(roomId) {
 var enhancer = internalEnhancer;
 
 function patchLiveblocksStorage(root, oldState, newState, mapping) {
-  for (var _key2 in mapping) {
-    if (process.env.NODE_ENV !== "production" && typeof newState[_key2] === "function") {
+  for (var key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof newState[key] === "function") {
       throw mappingToFunctionIsNotAllowed("value");
     }
 
-    if (oldState[_key2] !== newState[_key2]) {
-      patchLiveObjectKey(root, _key2, oldState[_key2], newState[_key2]);
+    if (oldState[key] !== newState[key]) {
+      internal.patchLiveObjectKey(root, key, oldState[key], newState[key]);
     }
   }
 }
 
 function broadcastInitialPresence(room, state, mapping) {
-  for (var _key3 in mapping) {
+  for (var key in mapping) {
     var _room$updatePresence;
 
-    room == null ? void 0 : room.updatePresence((_room$updatePresence = {}, _room$updatePresence[_key3] = state[_key3], _room$updatePresence));
+    room == null ? void 0 : room.updatePresence((_room$updatePresence = {}, _room$updatePresence[key] = state[key], _room$updatePresence));
   }
 }
 
 function updatePresence(room, oldState, newState, presenceMapping) {
-  for (var _key4 in presenceMapping) {
-    if (typeof newState[_key4] === "function") {
+  for (var key in presenceMapping) {
+    if (typeof newState[key] === "function") {
       throw mappingToFunctionIsNotAllowed("value");
     }
 
-    if (oldState[_key4] !== newState[_key4]) {
+    if (oldState[key] !== newState[key]) {
       var _room$updatePresence2;
 
-      room.updatePresence((_room$updatePresence2 = {}, _room$updatePresence2[_key4] = newState[_key4], _room$updatePresence2));
+      room.updatePresence((_room$updatePresence2 = {}, _room$updatePresence2[key] = newState[key], _room$updatePresence2));
     }
   }
 }
@@ -337,9 +334,9 @@ function isObject(value) {
 }
 
 function validateNoDuplicateKeys(storageMapping, presenceMapping) {
-  for (var _key5 in storageMapping) {
-    if (presenceMapping[_key5] !== undefined) {
-      throw mappingShouldNotHaveTheSameKeys(_key5);
+  for (var key in storageMapping) {
+    if (presenceMapping[key] !== undefined) {
+      throw mappingShouldNotHaveTheSameKeys(key);
     }
   }
 }
@@ -347,8 +344,8 @@ function validateNoDuplicateKeys(storageMapping, presenceMapping) {
 function patchPresenceState(presence, mapping) {
   var partialState = {};
 
-  for (var _key6 in mapping) {
-    partialState[_key6] = presence[_key6];
+  for (var key in mapping) {
+    partialState[key] = presence[key];
   }
 
   return partialState;
@@ -357,15 +354,15 @@ function patchPresenceState(presence, mapping) {
 function patchState(state, updates, mapping) {
   var partialState = {};
 
-  for (var _key7 in mapping) {
-    partialState[_key7] = state[_key7];
+  for (var key in mapping) {
+    partialState[key] = state[key];
   }
 
-  var patched = patchImmutableObject(partialState, updates);
+  var patched = internal.patchImmutableObject(partialState, updates);
   var result = {};
 
-  for (var _key8 in mapping) {
-    result[_key8] = patched[_key8];
+  for (var _key in mapping) {
+    result[_key] = patched[_key];
   }
 
   return result;
@@ -380,13 +377,13 @@ function validateMapping(mapping, mappingType) {
 
   var result = {};
 
-  for (var _key9 in mapping) {
-    if (process.env.NODE_ENV !== "production" && typeof mapping[_key9] !== "boolean") {
-      throw mappingValueShouldBeABoolean(mappingType, _key9);
+  for (var key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof mapping[key] !== "boolean") {
+      throw mappingValueShouldBeABoolean(mappingType, key);
     }
 
-    if (mapping[_key9] === true) {
-      result[_key9] = true;
+    if (mapping[key] === true) {
+      result[key] = true;
     }
   }
 

package/index.mjs

@@ -0,0 +1,272 @@
+import { patchLiveObjectKey, lsonToJson, patchImmutableObject } from '@liveblocks/client/internal';
+
+const ERROR_PREFIX = "Invalid @liveblocks/redux middleware config.";
+function missingClient() {
+    return new Error(`${ERROR_PREFIX} client is missing`);
+}
+function mappingShouldBeAnObject(mappingType) {
+    return new Error(`${ERROR_PREFIX} ${mappingType} should be an object where the values are boolean.`);
+}
+function mappingValueShouldBeABoolean(mappingType, key) {
+    return new Error(`${ERROR_PREFIX} ${mappingType}.${key} value should be a boolean`);
+}
+function mappingShouldNotHaveTheSameKeys(key) {
+    return new Error(`${ERROR_PREFIX} "${key}" is mapped on presenceMapping and storageMapping. A key shouldn't exist on both mapping.`);
+}
+function mappingToFunctionIsNotAllowed(key) {
+    return new Error(`${ERROR_PREFIX} mapping.${key} is invalid. Mapping to a function is not allowed.`);
+}
+
+const ACTION_TYPES = {
+    ENTER: "@@LIVEBLOCKS/ENTER",
+    LEAVE: "@@LIVEBLOCKS/LEAVE",
+    START_LOADING_STORAGE: "@@LIVEBLOCKS/START_LOADING_STORAGE",
+    INIT_STORAGE: "@@LIVEBLOCKS/INIT_STORAGE",
+    PATCH_REDUX_STATE: "@@LIVEBLOCKS/PATCH_REDUX_STATE",
+    UPDATE_CONNECTION: "@@LIVEBLOCKS/UPDATE_CONNECTION",
+    UPDATE_OTHERS: "@@LIVEBLOCKS/UPDATE_OTHERS",
+};
+const internalEnhancer = (options) => {
+    if (process.env.NODE_ENV !== "production" && options.client == null) {
+        throw missingClient();
+    }
+    const client = options.client;
+    const mapping = validateMapping(options.storageMapping || {}, "storageMapping");
+    const presenceMapping = validateMapping(options.presenceMapping || {}, "presenceMapping");
+    if (process.env.NODE_ENV !== "production") {
+        validateNoDuplicateKeys(mapping, presenceMapping);
+    }
+    return (createStore) => (reducer, initialState, enhancer) => {
+        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 Object.assign(Object.assign({}, state), action.state);
+                case ACTION_TYPES.INIT_STORAGE:
+                    return Object.assign(Object.assign(Object.assign({}, state), action.state), { liveblocks: Object.assign(Object.assign({}, state.liveblocks), { isStorageLoading: false }) });
+                case ACTION_TYPES.START_LOADING_STORAGE:
+                    return Object.assign(Object.assign({}, state), { liveblocks: Object.assign(Object.assign({}, state.liveblocks), { isStorageLoading: true }) });
+                case ACTION_TYPES.UPDATE_CONNECTION: {
+                    return Object.assign(Object.assign({}, state), { liveblocks: Object.assign(Object.assign({}, state.liveblocks), { connection: action.connection }) });
+                }
+                case ACTION_TYPES.UPDATE_OTHERS: {
+                    return Object.assign(Object.assign({}, state), { liveblocks: Object.assign(Object.assign({}, 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);
+                            }
+                        });
+                        isPatching = false;
+                    }
+                    if (newState.liveblocks == null) {
+                        return Object.assign(Object.assign({}, newState), { liveblocks: {
+                                others: [],
+                                isStorageLoading: false,
+                                connection: "closed",
+                            } });
+                    }
+                    return newState;
+                }
+            }
+        };
+        const store = createStore(newReducer, initialState, enhancer);
+        function enterRoom(roomId, storageInitialState = {}, reduxState) {
+            if (storageRoot) {
+                return;
+            }
+            room = client.enter(roomId);
+            broadcastInitialPresence(room, reduxState, presenceMapping);
+            unsubscribeCallbacks.push(room.subscribe("connection", () => {
+                store.dispatch({
+                    type: ACTION_TYPES.UPDATE_CONNECTION,
+                    connection: room.getConnectionState(),
+                });
+            }));
+            unsubscribeCallbacks.push(room.subscribe("others", (others) => {
+                store.dispatch({
+                    type: ACTION_TYPES.UPDATE_OTHERS,
+                    others: others.toArray(),
+                });
+            }));
+            unsubscribeCallbacks.push(room.subscribe("my-presence", () => {
+                if (isPatching === false) {
+                    store.dispatch({
+                        type: ACTION_TYPES.PATCH_REDUX_STATE,
+                        state: patchPresenceState(room.getPresence(), presenceMapping),
+                    });
+                }
+            }));
+            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];
+                            patchLiveObjectKey(root, key, undefined, storageInitialState[key]);
+                        }
+                        else {
+                            updates[key] = lsonToJson(liveblocksStatePart);
+                        }
+                    }
+                });
+                store.dispatch({
+                    type: ACTION_TYPES.INIT_STORAGE,
+                    state: updates,
+                });
+                storageRoot = root;
+                unsubscribeCallbacks.push(room.subscribe(root, (updates) => {
+                    if (isPatching === false) {
+                        store.dispatch({
+                            type: ACTION_TYPES.PATCH_REDUX_STATE,
+                            state: patchState(store.getState(), updates, mapping),
+                        });
+                    }
+                }, { isDeep: true }));
+            });
+        }
+        function leaveRoom(roomId) {
+            for (const unsubscribe of unsubscribeCallbacks) {
+                unsubscribe();
+            }
+            storageRoot = null;
+            room = null;
+            isPatching = false;
+            unsubscribeCallbacks = [];
+            client.leave(roomId);
+        }
+        function newDispatch(action, state) {
+            if (action.type === ACTION_TYPES.ENTER) {
+                enterRoom(action.roomId, action.initialState, store.getState());
+            }
+            else if (action.type === ACTION_TYPES.LEAVE) {
+                leaveRoom(action.roomId);
+            }
+            else {
+                store.dispatch(action, state);
+            }
+        }
+        return Object.assign(Object.assign({}, store), { dispatch: newDispatch });
+    };
+};
+/**
+ * Actions used to interact with Liveblocks
+ */
+const actions = {
+    /**
+     * Enters a room and starts sync it with zustand 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,
+    /**
+     * Leaves a room and stops sync it with zustand state.
+     * @param roomId The id of the room
+     */
+    leaveRoom,
+};
+function enterRoom(roomId, initialState) {
+    return {
+        type: ACTION_TYPES.ENTER,
+        roomId,
+        initialState,
+    };
+}
+function leaveRoom(roomId) {
+    return {
+        type: ACTION_TYPES.LEAVE,
+        roomId,
+    };
+}
+const enhancer = internalEnhancer;
+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]) {
+            patchLiveObjectKey(root, key, oldState[key], newState[key]);
+        }
+    }
+}
+function broadcastInitialPresence(room, state, mapping) {
+    for (const key in mapping) {
+        room === null || room === void 0 ? void 0 : room.updatePresence({ [key]: state[key] });
+    }
+}
+function updatePresence(room, oldState, newState, presenceMapping) {
+    for (const key in presenceMapping) {
+        if (typeof newState[key] === "function") {
+            throw mappingToFunctionIsNotAllowed("value");
+        }
+        if (oldState[key] !== newState[key]) {
+            room.updatePresence({ [key]: newState[key] });
+        }
+    }
+}
+function isObject(value) {
+    return Object.prototype.toString.call(value) === "[object Object]";
+}
+function validateNoDuplicateKeys(storageMapping, presenceMapping) {
+    for (const key in storageMapping) {
+        if (presenceMapping[key] !== undefined) {
+            throw mappingShouldNotHaveTheSameKeys(key);
+        }
+    }
+}
+function patchPresenceState(presence, mapping) {
+    const partialState = {};
+    for (const key in mapping) {
+        partialState[key] = presence[key];
+    }
+    return partialState;
+}
+function patchState(state, updates, // StorageUpdate
+mapping) {
+    const partialState = {};
+    for (const key in mapping) {
+        partialState[key] = state[key];
+    }
+    const patched = patchImmutableObject(partialState, updates);
+    const result = {};
+    for (const key in mapping) {
+        result[key] = patched[key];
+    }
+    return result;
+}
+/**
+ * Remove false keys from mapping and generate to a new object to avoid potential mutation from outside the middleware
+ */
+function validateMapping(mapping, mappingType) {
+    if (process.env.NODE_ENV !== "production") {
+        if (!isObject(mapping)) {
+            throw mappingShouldBeAnObject(mappingType);
+        }
+    }
+    const result = {};
+    for (const key in mapping) {
+        if (process.env.NODE_ENV !== "production" &&
+            typeof mapping[key] !== "boolean") {
+            throw mappingValueShouldBeABoolean(mappingType, key);
+        }
+        if (mapping[key] === true) {
+            result[key] = true;
+        }
+    }
+    return result;
+}
+
+export { actions, enhancer };

package/package.json

@@ -1,21 +1,13 @@
 {
   "name": "@liveblocks/redux",
-  "version": "0.16.3",
-  "sideEffects": false,
+  "version": "0.16.4",
   "description": "A store enhancer to integrate Liveblocks into Redux stores.",
   "main": "./index.js",
+  "module": "./index.mjs",
   "types": "./index.d.ts",
   "files": [
     "**"
   ],
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "module": "./esm/index.js",
-      "import": "./esm/index.mjs",
-      "default": "./index.js"
-    }
-  },
   "keywords": [
     "redux",
     "react",
@@ -26,7 +18,9 @@
   ],
   "scripts": {
     "build": "rollup -c && cp ./package.json ./README.md ./lib",
+    "lint": "eslint src/ test/",
     "test": "jest --watch",
+    "test-ci": "jest",
     "dtslint": "dtslint --localTs node_modules/typescript/lib --expectOnly types"
   },
   "license": "Apache-2.0",
@@ -36,7 +30,7 @@
     "directory": "packages/liveblocks-redux"
   },
   "peerDependencies": {
-    "@liveblocks/client": "0.16.3",
+    "@liveblocks/client": "0.16.4",
     "redux": "^4"
   },
   "devDependencies": {
@@ -47,6 +41,7 @@
     "@reduxjs/toolkit": "^1.7.2",
     "@rollup/plugin-babel": "^5.3.0",
     "@rollup/plugin-node-resolve": "^13.1.3",
+    "@rollup/plugin-replace": "^4.0.0",
     "@rollup/plugin-typescript": "^8.3.0",
     "@testing-library/jest-dom": "^5.16.1",
     "@testing-library/react": "^12.1.2",
@@ -54,13 +49,14 @@
     "@types/jest": "^27.4.1",
     "@typescript-eslint/eslint-plugin": "^5.18.0",
     "@typescript-eslint/parser": "^5.18.0",
-    "esbuild": "0.14.11",
     "eslint": "^8.12.0",
     "jest": "^27.4.7",
     "msw": "^0.36.4",
     "redux": "^4.1.2",
     "rollup": "^2.64.0",
-    "rollup-plugin-esbuild": "^4.8.2",
+    "rollup-plugin-command": "^1.1.3",
+    "rollup-plugin-dts": "^4.2.1",
     "whatwg-fetch": "^3.6.2"
-  }
+  },
+  "sideEffects": false
 }

package/esm/index.js

@@ -1,291 +0,0 @@
-import { internals } from '@liveblocks/client';
-
-const ERROR_PREFIX = "Invalid @liveblocks/redux middleware config.";
-function missingClient() {
-  return new Error(`${ERROR_PREFIX} client is missing`);
-}
-function mappingShouldBeAnObject(mappingType) {
-  return new Error(`${ERROR_PREFIX} ${mappingType} should be an object where the values are boolean.`);
-}
-function mappingValueShouldBeABoolean(mappingType, key) {
-  return new Error(`${ERROR_PREFIX} ${mappingType}.${key} value should be a boolean`);
-}
-function mappingShouldNotHaveTheSameKeys(key) {
-  return new Error(`${ERROR_PREFIX} "${key}" is mapped on presenceMapping and storageMapping. A key shouldn't exist on both mapping.`);
-}
-function mappingToFunctionIsNotAllowed(key) {
-  return new Error(`${ERROR_PREFIX} mapping.${key} is invalid. Mapping to a function is not allowed.`);
-}
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-const { patchImmutableObject, patchLiveObjectKey, lsonToJson } = internals;
-const ACTION_TYPES = {
-  ENTER: "@@LIVEBLOCKS/ENTER",
-  LEAVE: "@@LIVEBLOCKS/LEAVE",
-  START_LOADING_STORAGE: "@@LIVEBLOCKS/START_LOADING_STORAGE",
-  INIT_STORAGE: "@@LIVEBLOCKS/INIT_STORAGE",
-  PATCH_REDUX_STATE: "@@LIVEBLOCKS/PATCH_REDUX_STATE",
-  UPDATE_CONNECTION: "@@LIVEBLOCKS/UPDATE_CONNECTION",
-  UPDATE_OTHERS: "@@LIVEBLOCKS/UPDATE_OTHERS"
-};
-const internalEnhancer = (options) => {
-  if (process.env.NODE_ENV !== "production" && options.client == null) {
-    throw missingClient();
-  }
-  const client = options.client;
-  const mapping = validateMapping(options.storageMapping || {}, "storageMapping");
-  const presenceMapping = validateMapping(options.presenceMapping || {}, "presenceMapping");
-  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);
-              }
-            });
-            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);
-      broadcastInitialPresence(room, reduxState, presenceMapping);
-      unsubscribeCallbacks.push(room.subscribe("connection", () => {
-        store.dispatch({
-          type: ACTION_TYPES.UPDATE_CONNECTION,
-          connection: room.getConnectionState()
-        });
-      }));
-      unsubscribeCallbacks.push(room.subscribe("others", (others) => {
-        store.dispatch({
-          type: ACTION_TYPES.UPDATE_OTHERS,
-          others: others.toArray()
-        });
-      }));
-      unsubscribeCallbacks.push(room.subscribe("my-presence", () => {
-        if (isPatching === false) {
-          store.dispatch({
-            type: ACTION_TYPES.PATCH_REDUX_STATE,
-            state: patchPresenceState(room.getPresence(), presenceMapping)
-          });
-        }
-      }));
-      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];
-              patchLiveObjectKey(root, key, void 0, storageInitialState[key]);
-            } else {
-              updates[key] = lsonToJson(liveblocksStatePart);
-            }
-          }
-        });
-        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 }));
-      });
-    }
-    function leaveRoom2(roomId) {
-      for (const unsubscribe of unsubscribeCallbacks) {
-        unsubscribe();
-      }
-      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);
-      }
-    }
-    return __spreadProps(__spreadValues({}, store), {
-      dispatch: newDispatch
-    });
-  };
-};
-const actions = {
-  enterRoom,
-  leaveRoom
-};
-function enterRoom(roomId, initialState) {
-  return {
-    type: ACTION_TYPES.ENTER,
-    roomId,
-    initialState
-  };
-}
-function leaveRoom(roomId) {
-  return {
-    type: ACTION_TYPES.LEAVE,
-    roomId
-  };
-}
-const enhancer = internalEnhancer;
-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]) {
-      patchLiveObjectKey(root, key, oldState[key], newState[key]);
-    }
-  }
-}
-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") {
-      throw mappingToFunctionIsNotAllowed("value");
-    }
-    if (oldState[key] !== newState[key]) {
-      room.updatePresence({ [key]: newState[key] });
-    }
-  }
-}
-function isObject(value) {
-  return Object.prototype.toString.call(value) === "[object Object]";
-}
-function validateNoDuplicateKeys(storageMapping, presenceMapping) {
-  for (const key in storageMapping) {
-    if (presenceMapping[key] !== void 0) {
-      throw mappingShouldNotHaveTheSameKeys(key);
-    }
-  }
-}
-function patchPresenceState(presence, mapping) {
-  const partialState = {};
-  for (const key in mapping) {
-    partialState[key] = presence[key];
-  }
-  return partialState;
-}
-function patchState(state, updates, mapping) {
-  const partialState = {};
-  for (const key in mapping) {
-    partialState[key] = state[key];
-  }
-  const patched = patchImmutableObject(partialState, updates);
-  const result = {};
-  for (const key in mapping) {
-    result[key] = patched[key];
-  }
-  return result;
-}
-function validateMapping(mapping, mappingType) {
-  if (process.env.NODE_ENV !== "production") {
-    if (!isObject(mapping)) {
-      throw mappingShouldBeAnObject(mappingType);
-    }
-  }
-  const result = {};
-  for (const key in mapping) {
-    if (process.env.NODE_ENV !== "production" && typeof mapping[key] !== "boolean") {
-      throw mappingValueShouldBeABoolean(mappingType, key);
-    }
-    if (mapping[key] === true) {
-      result[key] = true;
-    }
-  }
-  return result;
-}
-
-export { actions, enhancer };

package/esm/index.mjs

@@ -1,291 +0,0 @@
-import { internals } from '@liveblocks/client';
-
-const ERROR_PREFIX = "Invalid @liveblocks/redux middleware config.";
-function missingClient() {
-  return new Error(`${ERROR_PREFIX} client is missing`);
-}
-function mappingShouldBeAnObject(mappingType) {
-  return new Error(`${ERROR_PREFIX} ${mappingType} should be an object where the values are boolean.`);
-}
-function mappingValueShouldBeABoolean(mappingType, key) {
-  return new Error(`${ERROR_PREFIX} ${mappingType}.${key} value should be a boolean`);
-}
-function mappingShouldNotHaveTheSameKeys(key) {
-  return new Error(`${ERROR_PREFIX} "${key}" is mapped on presenceMapping and storageMapping. A key shouldn't exist on both mapping.`);
-}
-function mappingToFunctionIsNotAllowed(key) {
-  return new Error(`${ERROR_PREFIX} mapping.${key} is invalid. Mapping to a function is not allowed.`);
-}
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-const { patchImmutableObject, patchLiveObjectKey, lsonToJson } = internals;
-const ACTION_TYPES = {
-  ENTER: "@@LIVEBLOCKS/ENTER",
-  LEAVE: "@@LIVEBLOCKS/LEAVE",
-  START_LOADING_STORAGE: "@@LIVEBLOCKS/START_LOADING_STORAGE",
-  INIT_STORAGE: "@@LIVEBLOCKS/INIT_STORAGE",
-  PATCH_REDUX_STATE: "@@LIVEBLOCKS/PATCH_REDUX_STATE",
-  UPDATE_CONNECTION: "@@LIVEBLOCKS/UPDATE_CONNECTION",
-  UPDATE_OTHERS: "@@LIVEBLOCKS/UPDATE_OTHERS"
-};
-const internalEnhancer = (options) => {
-  if (process.env.NODE_ENV !== "production" && options.client == null) {
-    throw missingClient();
-  }
-  const client = options.client;
-  const mapping = validateMapping(options.storageMapping || {}, "storageMapping");
-  const presenceMapping = validateMapping(options.presenceMapping || {}, "presenceMapping");
-  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);
-              }
-            });
-            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);
-      broadcastInitialPresence(room, reduxState, presenceMapping);
-      unsubscribeCallbacks.push(room.subscribe("connection", () => {
-        store.dispatch({
-          type: ACTION_TYPES.UPDATE_CONNECTION,
-          connection: room.getConnectionState()
-        });
-      }));
-      unsubscribeCallbacks.push(room.subscribe("others", (others) => {
-        store.dispatch({
-          type: ACTION_TYPES.UPDATE_OTHERS,
-          others: others.toArray()
-        });
-      }));
-      unsubscribeCallbacks.push(room.subscribe("my-presence", () => {
-        if (isPatching === false) {
-          store.dispatch({
-            type: ACTION_TYPES.PATCH_REDUX_STATE,
-            state: patchPresenceState(room.getPresence(), presenceMapping)
-          });
-        }
-      }));
-      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];
-              patchLiveObjectKey(root, key, void 0, storageInitialState[key]);
-            } else {
-              updates[key] = lsonToJson(liveblocksStatePart);
-            }
-          }
-        });
-        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 }));
-      });
-    }
-    function leaveRoom2(roomId) {
-      for (const unsubscribe of unsubscribeCallbacks) {
-        unsubscribe();
-      }
-      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);
-      }
-    }
-    return __spreadProps(__spreadValues({}, store), {
-      dispatch: newDispatch
-    });
-  };
-};
-const actions = {
-  enterRoom,
-  leaveRoom
-};
-function enterRoom(roomId, initialState) {
-  return {
-    type: ACTION_TYPES.ENTER,
-    roomId,
-    initialState
-  };
-}
-function leaveRoom(roomId) {
-  return {
-    type: ACTION_TYPES.LEAVE,
-    roomId
-  };
-}
-const enhancer = internalEnhancer;
-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]) {
-      patchLiveObjectKey(root, key, oldState[key], newState[key]);
-    }
-  }
-}
-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") {
-      throw mappingToFunctionIsNotAllowed("value");
-    }
-    if (oldState[key] !== newState[key]) {
-      room.updatePresence({ [key]: newState[key] });
-    }
-  }
-}
-function isObject(value) {
-  return Object.prototype.toString.call(value) === "[object Object]";
-}
-function validateNoDuplicateKeys(storageMapping, presenceMapping) {
-  for (const key in storageMapping) {
-    if (presenceMapping[key] !== void 0) {
-      throw mappingShouldNotHaveTheSameKeys(key);
-    }
-  }
-}
-function patchPresenceState(presence, mapping) {
-  const partialState = {};
-  for (const key in mapping) {
-    partialState[key] = presence[key];
-  }
-  return partialState;
-}
-function patchState(state, updates, mapping) {
-  const partialState = {};
-  for (const key in mapping) {
-    partialState[key] = state[key];
-  }
-  const patched = patchImmutableObject(partialState, updates);
-  const result = {};
-  for (const key in mapping) {
-    result[key] = patched[key];
-  }
-  return result;
-}
-function validateMapping(mapping, mappingType) {
-  if (process.env.NODE_ENV !== "production") {
-    if (!isObject(mapping)) {
-      throw mappingShouldBeAnObject(mappingType);
-    }
-  }
-  const result = {};
-  for (const key in mapping) {
-    if (process.env.NODE_ENV !== "production" && typeof mapping[key] !== "boolean") {
-      throw mappingValueShouldBeABoolean(mappingType, key);
-    }
-    if (mapping[key] === true) {
-      result[key] = true;
-    }
-  }
-  return result;
-}
-
-export { actions, enhancer };