@liveblocks/redux 0.16.4-beta2 → 0.16.6

package/index.js

@@ -1,397 +1,227 @@
-'use strict';
+"use strict";
 
-Object.defineProperty(exports, '__esModule', { value: true });
+Object.defineProperty(exports, "__esModule", {
+ value: !0
+});
 
-var client = require('@liveblocks/client');
+var internal = require("@liveblocks/client/internal");
 
 function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+ return _extends = Object.assign || function(target) {
+  for (var i = 1; i < arguments.length; i++) {
+   var source = arguments[i];
+   for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+  }
+  return target;
+ }, _extends.apply(this, arguments);
 }
 
 function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
-  return arr2;
+ (null == len || len > arr.length) && (len = arr.length);
+ for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+ return arr2;
 }
 
 function _createForOfIteratorHelperLoose(o, allowArrayLike) {
-  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-  if (it) return (it = it.call(o)).next.bind(it);
-
-  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-    if (it) o = it;
-    var i = 0;
-    return function () {
-      if (i >= o.length) return {
-        done: true
-      };
-      return {
-        done: false,
-        value: o[i++]
-      };
-    };
+ var it = "undefined" != typeof Symbol && o[Symbol.iterator] || o["@@iterator"];
+ if (it) return (it = it.call(o)).next.bind(it);
+ if (Array.isArray(o) || (it = function(o, minLen) {
+  if (o) {
+   if ("string" == typeof o) return _arrayLikeToArray(o, minLen);
+   var n = Object.prototype.toString.call(o).slice(8, -1);
+   return "Object" === n && o.constructor && (n = o.constructor.name), "Map" === n || "Set" === n ? Array.from(o) : "Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n) ? _arrayLikeToArray(o, minLen) : void 0;
   }
-
-  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }(o)) || allowArrayLike && o && "number" == typeof o.length) {
+  it && (o = it);
+  var i = 0;
+  return function() {
+   return i >= o.length ? {
+    done: !0
+   } : {
+    done: !1,
+    value: o[i++]
+   };
+  };
+ }
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
 var 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");
+ 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.");
+ 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.");
+ 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",
-  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"
+var ACTION_TYPES_ENTER = "@@LIVEBLOCKS/ENTER", ACTION_TYPES_LEAVE = "@@LIVEBLOCKS/LEAVE", ACTION_TYPES_START_LOADING_STORAGE = "@@LIVEBLOCKS/START_LOADING_STORAGE", ACTION_TYPES_INIT_STORAGE = "@@LIVEBLOCKS/INIT_STORAGE", ACTION_TYPES_PATCH_REDUX_STATE = "@@LIVEBLOCKS/PATCH_REDUX_STATE", ACTION_TYPES_UPDATE_CONNECTION = "@@LIVEBLOCKS/UPDATE_CONNECTION", ACTION_TYPES_UPDATE_OTHERS = "@@LIVEBLOCKS/UPDATE_OTHERS", actions = {
+ enterRoom: function(roomId, initialState) {
+  return {
+   type: ACTION_TYPES_ENTER,
+   roomId: roomId,
+   initialState: initialState
+  };
+ },
+ leaveRoom: function(roomId) {
+  return {
+   type: ACTION_TYPES_LEAVE,
+   roomId: roomId
+  };
+ }
 };
 
-var internalEnhancer = function internalEnhancer(options) {
-  if (process.env.NODE_ENV !== "production" && options.client == null) {
-    throw missingClient();
-  }
-
-  var client = options.client;
-  var mapping = validateMapping(options.storageMapping || {}, "storageMapping");
-  var presenceMapping = validateMapping(options.presenceMapping || {}, "presenceMapping");
-
-  if (process.env.NODE_ENV !== "production") {
-    validateNoDuplicateKeys(mapping, presenceMapping);
-  }
-
-  return function (createStore) {
-    return function (reducer, initialState, enhancer) {
-      var room = null;
-      var isPatching = false;
-      var storageRoot = null;
-      var unsubscribeCallbacks = [];
-
-      var newReducer = function newReducer(state, action) {
-        switch (action.type) {
-          case ACTION_TYPES.PATCH_REDUX_STATE:
-            return _extends({}, state, action.state);
-
-          case ACTION_TYPES.INIT_STORAGE:
-            return _extends({}, state, action.state, {
-              liveblocks: _extends({}, state.liveblocks, {
-                isStorageLoading: false
-              })
-            });
-
-          case ACTION_TYPES.START_LOADING_STORAGE:
-            return _extends({}, state, {
-              liveblocks: _extends({}, state.liveblocks, {
-                isStorageLoading: true
-              })
-            });
-
-          case ACTION_TYPES.UPDATE_CONNECTION:
-            {
-              return _extends({}, state, {
-                liveblocks: _extends({}, state.liveblocks, {
-                  connection: action.connection
-                })
-              });
-            }
-
-          case ACTION_TYPES.UPDATE_OTHERS:
-            {
-              return _extends({}, state, {
-                liveblocks: _extends({}, state.liveblocks, {
-                  others: action.others
-                })
-              });
-            }
-
-          default:
-            {
-              var newState = reducer(state, action);
-
-              if (room) {
-                isPatching = true;
-                updatePresence(room, state, newState, presenceMapping);
-                room.batch(function () {
-                  if (storageRoot) {
-                    patchLiveblocksStorage(storageRoot, state, newState, mapping);
-                  }
-                });
-                isPatching = false;
-              }
-
-              if (newState.liveblocks == null) {
-                return _extends({}, newState, {
-                  liveblocks: {
-                    others: [],
-                    isStorageLoading: false,
-                    connection: "closed"
-                  }
-                });
-              }
-
-              return newState;
-            }
-        }
-      };
-
-      var store = createStore(newReducer, initialState, enhancer);
-
-      function enterRoom(roomId, storageInitialState, reduxState) {
-        if (storageInitialState === void 0) {
-          storageInitialState = {};
-        }
-
-        if (storageRoot) {
-          return;
-        }
-
-        room = client.enter(roomId);
-        broadcastInitialPresence(room, reduxState, presenceMapping);
-        unsubscribeCallbacks.push(room.subscribe("connection", function () {
-          store.dispatch({
-            type: ACTION_TYPES.UPDATE_CONNECTION,
-            connection: room.getConnectionState()
-          });
-        }));
-        unsubscribeCallbacks.push(room.subscribe("others", function (others) {
-          store.dispatch({
-            type: ACTION_TYPES.UPDATE_OTHERS,
-            others: others.toArray()
-          });
-        }));
-        unsubscribeCallbacks.push(room.subscribe("my-presence", function () {
-          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(function (_ref) {
-          var root = _ref.root;
-          var updates = {};
-          room.batch(function () {
-            for (var _key in mapping) {
-              var 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, function (updates) {
-            if (isPatching === false) {
-              store.dispatch({
-                type: ACTION_TYPES.PATCH_REDUX_STATE,
-                state: patchState(store.getState(), updates, mapping)
-              });
-            }
-          }, {
-            isDeep: true
-          }));
-        });
+var enhancer = function(options) {
+ if ("production" !== process.env.NODE_ENV && null == options.client) throw new Error(ERROR_PREFIX + " client is missing");
+ var client = options.client, mapping = validateMapping(options.storageMapping || {}, "storageMapping"), presenceMapping = validateMapping(options.presenceMapping || {}, "presenceMapping");
+ return "production" !== process.env.NODE_ENV && function(storageMapping, presenceMapping) {
+  for (var key in storageMapping) if (void 0 !== presenceMapping[key]) throw mappingShouldNotHaveTheSameKeys(key);
+ }(mapping, presenceMapping), function(createStore) {
+  return function(reducer, initialState, enhancer) {
+   var room = null, isPatching = !1, storageRoot = null, unsubscribeCallbacks = [], store = createStore((function(state, action) {
+    switch (action.type) {
+    case ACTION_TYPES_PATCH_REDUX_STATE:
+     return _extends({}, state, action.state);
+
+    case ACTION_TYPES_INIT_STORAGE:
+     return _extends({}, state, action.state, {
+      liveblocks: _extends({}, state.liveblocks, {
+       isStorageLoading: !1
+      })
+     });
+
+    case ACTION_TYPES_START_LOADING_STORAGE:
+     return _extends({}, state, {
+      liveblocks: _extends({}, state.liveblocks, {
+       isStorageLoading: !0
+      })
+     });
+
+    case ACTION_TYPES_UPDATE_CONNECTION:
+     return _extends({}, state, {
+      liveblocks: _extends({}, state.liveblocks, {
+       connection: action.connection
+      })
+     });
+
+    case ACTION_TYPES_UPDATE_OTHERS:
+     return _extends({}, state, {
+      liveblocks: _extends({}, state.liveblocks, {
+       others: action.others
+      })
+     });
+
+    default:
+     var newState = reducer(state, action);
+     return room && (isPatching = !0, function(room, oldState, newState, presenceMapping) {
+      for (var key in presenceMapping) {
+       if ("function" == typeof newState[key]) throw mappingToFunctionIsNotAllowed("value");
+       var _room$updatePresence2;
+       if (oldState[key] !== newState[key]) room.updatePresence(((_room$updatePresence2 = {})[key] = newState[key], 
+       _room$updatePresence2));
       }
-
-      function leaveRoom(roomId) {
-        for (var _iterator = _createForOfIteratorHelperLoose(unsubscribeCallbacks), _step; !(_step = _iterator()).done;) {
-          var unsubscribe = _step.value;
-          unsubscribe();
-        }
-
-        storageRoot = null;
-        room = null;
-        isPatching = false;
-        unsubscribeCallbacks = [];
-        client.leave(roomId);
+     }(room, state, newState, presenceMapping), room.batch((function() {
+      storageRoot && function(root, oldState, newState, mapping) {
+       for (var key in mapping) {
+        if ("production" !== process.env.NODE_ENV && "function" == typeof newState[key]) throw mappingToFunctionIsNotAllowed("value");
+        oldState[key] !== newState[key] && internal.patchLiveObjectKey(root, key, oldState[key], newState[key]);
+       }
+      }(storageRoot, state, newState, mapping);
+     })), isPatching = !1), null == newState.liveblocks ? _extends({}, newState, {
+      liveblocks: {
+       others: [],
+       isStorageLoading: !1,
+       connection: "closed"
       }
-
-      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);
-        }
+     }) : newState;
+    }
+   }), initialState, enhancer);
+   return _extends({}, store, {
+    dispatch: function(action, state) {
+     var roomId, storageInitialState, reduxState;
+     action.type === ACTION_TYPES_ENTER ? (roomId = action.roomId, storageInitialState = action.initialState, 
+     reduxState = store.getState(), void 0 === storageInitialState && (storageInitialState = {}), 
+     storageRoot || (function(room, state, mapping) {
+      for (var key in mapping) {
+       var _room$updatePresence;
+       null == room || room.updatePresence(((_room$updatePresence = {})[key] = state[key], 
+       _room$updatePresence));
       }
-
-      return _extends({}, store, {
-        dispatch: newDispatch
+     }(room = client.enter(roomId), reduxState, presenceMapping), unsubscribeCallbacks.push(room.subscribe("connection", (function() {
+      store.dispatch({
+       type: ACTION_TYPES_UPDATE_CONNECTION,
+       connection: room.getConnectionState()
+      });
+     }))), unsubscribeCallbacks.push(room.subscribe("others", (function(others) {
+      store.dispatch({
+       type: ACTION_TYPES_UPDATE_OTHERS,
+       others: others.toArray()
       });
-    };
+     }))), unsubscribeCallbacks.push(room.subscribe("my-presence", (function() {
+      !1 === isPatching && store.dispatch({
+       type: ACTION_TYPES_PATCH_REDUX_STATE,
+       state: patchPresenceState(room.getPresence(), presenceMapping)
+      });
+     }))), store.dispatch({
+      type: ACTION_TYPES_START_LOADING_STORAGE
+     }), room.getStorage().then((function(_ref) {
+      var root = _ref.root, updates = {};
+      room.batch((function() {
+       for (var key in mapping) {
+        var liveblocksStatePart = root.get(key);
+        null == liveblocksStatePart ? (updates[key] = storageInitialState[key], internal.patchLiveObjectKey(root, key, void 0, storageInitialState[key])) : updates[key] = internal.lsonToJson(liveblocksStatePart);
+       }
+      })), store.dispatch({
+       type: ACTION_TYPES_INIT_STORAGE,
+       state: updates
+      }), storageRoot = root, unsubscribeCallbacks.push(room.subscribe(root, (function(updates) {
+       !1 === isPatching && store.dispatch({
+        type: ACTION_TYPES_PATCH_REDUX_STATE,
+        state: patchState(store.getState(), updates, mapping)
+       });
+      }), {
+       isDeep: !0
+      }));
+     })))) : action.type === ACTION_TYPES_LEAVE ? function(roomId) {
+      for (var _step, _iterator = _createForOfIteratorHelperLoose(unsubscribeCallbacks); !(_step = _iterator()).done; ) (0, 
+      _step.value)();
+      storageRoot = null, room = null, isPatching = !1, unsubscribeCallbacks = [], client.leave(roomId);
+     }(action.roomId) : store.dispatch(action, state);
+    }
+   });
   };
+ };
 };
 
-var actions = {
-  enterRoom: enterRoom,
-  leaveRoom: leaveRoom
-};
-
-function enterRoom(roomId, initialState) {
-  return {
-    type: ACTION_TYPES.ENTER,
-    roomId: roomId,
-    initialState: initialState
-  };
-}
-
-function leaveRoom(roomId) {
-  return {
-    type: ACTION_TYPES.LEAVE,
-    roomId: 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") {
-      throw mappingToFunctionIsNotAllowed("value");
-    }
-
-    if (oldState[_key2] !== newState[_key2]) {
-      patchLiveObjectKey(root, _key2, oldState[_key2], newState[_key2]);
-    }
-  }
-}
-
-function broadcastInitialPresence(room, state, mapping) {
-  for (var _key3 in mapping) {
-    var _room$updatePresence;
-
-    room == null ? void 0 : room.updatePresence((_room$updatePresence = {}, _room$updatePresence[_key3] = state[_key3], _room$updatePresence));
-  }
-}
-
-function updatePresence(room, oldState, newState, presenceMapping) {
-  for (var _key4 in presenceMapping) {
-    if (typeof newState[_key4] === "function") {
-      throw mappingToFunctionIsNotAllowed("value");
-    }
-
-    if (oldState[_key4] !== newState[_key4]) {
-      var _room$updatePresence2;
-
-      room.updatePresence((_room$updatePresence2 = {}, _room$updatePresence2[_key4] = newState[_key4], _room$updatePresence2));
-    }
-  }
-}
-
-function isObject(value) {
-  return Object.prototype.toString.call(value) === "[object Object]";
-}
-
-function validateNoDuplicateKeys(storageMapping, presenceMapping) {
-  for (var _key5 in storageMapping) {
-    if (presenceMapping[_key5] !== undefined) {
-      throw mappingShouldNotHaveTheSameKeys(_key5);
-    }
-  }
-}
-
 function patchPresenceState(presence, mapping) {
-  var partialState = {};
-
-  for (var _key6 in mapping) {
-    partialState[_key6] = presence[_key6];
-  }
-
-  return partialState;
+ var partialState = {};
+ for (var key in mapping) partialState[key] = presence[key];
+ return partialState;
 }
 
 function patchState(state, updates, mapping) {
-  var partialState = {};
-
-  for (var _key7 in mapping) {
-    partialState[_key7] = state[_key7];
-  }
-
-  var patched = patchImmutableObject(partialState, updates);
-  var result = {};
-
-  for (var _key8 in mapping) {
-    result[_key8] = patched[_key8];
-  }
-
-  return result;
+ var partialState = {};
+ for (var key in mapping) partialState[key] = state[key];
+ var patched = internal.patchImmutableObject(partialState, updates), result = {};
+ for (var _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);
-    }
-  }
-
-  var result = {};
-
-  for (var _key9 in mapping) {
-    if (process.env.NODE_ENV !== "production" && typeof mapping[_key9] !== "boolean") {
-      throw mappingValueShouldBeABoolean(mappingType, _key9);
-    }
-
-    if (mapping[_key9] === true) {
-      result[_key9] = true;
-    }
-  }
-
-  return result;
+ if ("production" !== process.env.NODE_ENV && (value = mapping, "[object Object]" !== Object.prototype.toString.call(value))) throw function(mappingType) {
+  return new Error(ERROR_PREFIX + " " + mappingType + " should be an object where the values are boolean.");
+ }(mappingType);
+ var value, result = {};
+ for (var key in mapping) {
+  if ("production" !== process.env.NODE_ENV && "boolean" != typeof mapping[key]) throw mappingValueShouldBeABoolean(mappingType, key);
+  !0 === mapping[key] && (result[key] = !0);
+ }
+ return result;
 }
 
-exports.actions = actions;
-exports.enhancer = enhancer;
+exports.actions = actions, exports.enhancer = enhancer;

package/index.mjs

@@ -1,273 +1,179 @@
-import { internals } from '@liveblocks/client';
+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`);
+ 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.`);
+ 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.`);
+ return new Error(`${ERROR_PREFIX} mapping.${key} is invalid. Mapping to a function is not allowed.`);
 }
 
-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 ACTION_TYPES_ENTER = "@@LIVEBLOCKS/ENTER", ACTION_TYPES_LEAVE = "@@LIVEBLOCKS/LEAVE", ACTION_TYPES_START_LOADING_STORAGE = "@@LIVEBLOCKS/START_LOADING_STORAGE", ACTION_TYPES_INIT_STORAGE = "@@LIVEBLOCKS/INIT_STORAGE", ACTION_TYPES_PATCH_REDUX_STATE = "@@LIVEBLOCKS/PATCH_REDUX_STATE", ACTION_TYPES_UPDATE_CONNECTION = "@@LIVEBLOCKS/UPDATE_CONNECTION", ACTION_TYPES_UPDATE_OTHERS = "@@LIVEBLOCKS/UPDATE_OTHERS", actions = {
+ enterRoom: function(roomId, initialState) {
+  return {
+   type: ACTION_TYPES_ENTER,
+   roomId: roomId,
+   initialState: initialState
+  };
+ },
+ leaveRoom: function(roomId) {
+  return {
+   type: ACTION_TYPES_LEAVE,
+   roomId: roomId
+  };
+ }
 };
-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);
+
+const enhancer = options => {
+ if ("production" !== process.env.NODE_ENV && null == options.client) throw new Error(`${ERROR_PREFIX} client is missing`);
+ const client = options.client, mapping = validateMapping(options.storageMapping || {}, "storageMapping"), presenceMapping = validateMapping(options.presenceMapping || {}, "presenceMapping");
+ return "production" !== process.env.NODE_ENV && function(storageMapping, presenceMapping) {
+  for (const key in storageMapping) if (void 0 !== presenceMapping[key]) throw mappingShouldNotHaveTheSameKeys(key);
+ }(mapping, presenceMapping), createStore => (reducer, initialState, enhancer) => {
+  let room = null, isPatching = !1, storageRoot = null, unsubscribeCallbacks = [];
+  const store = createStore(((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: !1
+     })
+    });
+
+   case ACTION_TYPES_START_LOADING_STORAGE:
+    return Object.assign(Object.assign({}, state), {
+     liveblocks: Object.assign(Object.assign({}, state.liveblocks), {
+      isStorageLoading: !0
+     })
+    });
+
+   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);
+     return room && (isPatching = !0, function(room, oldState, newState, presenceMapping) {
+      for (const key in presenceMapping) {
+       if ("function" == typeof newState[key]) throw mappingToFunctionIsNotAllowed("value");
+       oldState[key] !== newState[key] && room.updatePresence({
+        [key]: newState[key]
+       });
+      }
+     }(room, state, newState, presenceMapping), room.batch((() => {
+      storageRoot && function(root, oldState, newState, mapping) {
+       for (const key in mapping) {
+        if ("production" !== process.env.NODE_ENV && "function" == typeof newState[key]) throw mappingToFunctionIsNotAllowed("value");
+        oldState[key] !== newState[key] && patchLiveObjectKey(root, key, oldState[key], newState[key]);
+       }
+      }(storageRoot, state, newState, mapping);
+     })), isPatching = !1), null == newState.liveblocks ? Object.assign(Object.assign({}, newState), {
+      liveblocks: {
+       others: [],
+       isStorageLoading: !1,
+       connection: "closed"
+      }
+     }) : newState;
     }
-    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 });
-    };
+   }
+  }), initialState, enhancer);
+  return Object.assign(Object.assign({}, store), {
+   dispatch: function(action, state) {
+    action.type === ACTION_TYPES_ENTER ? function(roomId, storageInitialState = {}, reduxState) {
+     storageRoot || (room = client.enter(roomId), function(room, state, mapping) {
+      for (const key in mapping) null == room || room.updatePresence({
+       [key]: state[key]
+      });
+     }(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", (() => {
+      !1 === isPatching && 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: root}) => {
+      const updates = {};
+      room.batch((() => {
+       for (const key in mapping) {
+        const liveblocksStatePart = root.get(key);
+        null == liveblocksStatePart ? (updates[key] = storageInitialState[key], patchLiveObjectKey(root, key, void 0, storageInitialState[key])) : updates[key] = lsonToJson(liveblocksStatePart);
+       }
+      })), store.dispatch({
+       type: ACTION_TYPES_INIT_STORAGE,
+       state: updates
+      }), storageRoot = root, unsubscribeCallbacks.push(room.subscribe(root, (updates => {
+       !1 === isPatching && store.dispatch({
+        type: ACTION_TYPES_PATCH_REDUX_STATE,
+        state: patchState(store.getState(), updates, mapping)
+       });
+      }), {
+       isDeep: !0
+      }));
+     })));
+    }(action.roomId, action.initialState, store.getState()) : action.type === ACTION_TYPES_LEAVE ? function(roomId) {
+     for (const unsubscribe of unsubscribeCallbacks) unsubscribe();
+     storageRoot = null, room = null, isPatching = !1, unsubscribeCallbacks = [], client.leave(roomId);
+    }(action.roomId) : store.dispatch(action, state);
+   }
+  });
+ };
 };
-/**
- * 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;
+ 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;
+
+function patchState(state, updates, mapping) {
+ const partialState = {};
+ for (const key in mapping) partialState[key] = state[key];
+ const patched = patchImmutableObject(partialState, updates), 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;
+ if ("production" !== process.env.NODE_ENV && (value = mapping, "[object Object]" !== Object.prototype.toString.call(value))) throw function(mappingType) {
+  return new Error(`${ERROR_PREFIX} ${mappingType} should be an object where the values are boolean.`);
+ }(mappingType);
+ var value;
+ const result = {};
+ for (const key in mapping) {
+  if ("production" !== process.env.NODE_ENV && "boolean" != typeof mapping[key]) throw mappingValueShouldBeABoolean(mappingType, key);
+  !0 === mapping[key] && (result[key] = !0);
+ }
+ return result;
 }
 
 export { actions, enhancer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/redux",
-  "version": "0.16.4-beta2",
+  "version": "0.16.6",
   "description": "A store enhancer to integrate Liveblocks into Redux stores.",
   "main": "./index.js",
   "module": "./index.mjs",
@@ -18,6 +18,7 @@
   ],
   "scripts": {
     "build": "rollup -c && cp ./package.json ./README.md ./lib",
+    "format": "eslint --fix src/ test/ && prettier --write src/ test/",
     "lint": "eslint src/ test/",
     "test": "jest --watch",
     "test-ci": "jest",
@@ -30,13 +31,13 @@
     "directory": "packages/liveblocks-redux"
   },
   "peerDependencies": {
-    "@liveblocks/client": "0.16.4-beta2",
+    "@liveblocks/client": "0.16.6",
     "redux": "^4"
   },
   "devDependencies": {
-    "@babel/core": "^7.16.7",
-    "@babel/plugin-transform-typescript": "^7.16.8",
-    "@babel/preset-env": "^7.16.8",
+    "@babel/core": "^7.17.10",
+    "@babel/preset-env": "^7.17.10",
+    "@babel/preset-typescript": "^7.16.7",
     "@definitelytyped/dtslint": "^0.0.103",
     "@reduxjs/toolkit": "^1.7.2",
     "@rollup/plugin-babel": "^5.3.0",
@@ -50,12 +51,15 @@
     "@typescript-eslint/eslint-plugin": "^5.18.0",
     "@typescript-eslint/parser": "^5.18.0",
     "eslint": "^8.12.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-simple-import-sort": "^7.0.0",
     "jest": "^27.4.7",
     "msw": "^0.36.4",
     "redux": "^4.1.2",
     "rollup": "^2.64.0",
     "rollup-plugin-command": "^1.1.3",
     "rollup-plugin-dts": "^4.2.1",
+    "rollup-plugin-terser": "^7.0.2",
     "whatwg-fetch": "^3.6.2"
   },
   "sideEffects": false