@liveblocks/zustand 0.16.4 → 0.16.5

package/index.d.ts

@@ -1,5 +1,5 @@
-import { StateCreator, SetState, GetState, StoreApi } from 'zustand';
 import { Presence, Room, User, Client } from '@liveblocks/client';
+import { StateCreator, SetState, GetState, StoreApi } from 'zustand';
 
 declare type LiveblocksState<TState, TPresence extends Presence = Presence> = TState & {
     /**

package/index.js

@@ -1,315 +1,185 @@
-'use strict';
+"use strict";
 
-Object.defineProperty(exports, '__esModule', { value: true });
+Object.defineProperty(exports, "__esModule", {
+ value: !0
+});
 
-var internal = require('@liveblocks/client/internal');
+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/zustand middleware config.";
-function missingClient() {
-  return new Error(ERROR_PREFIX + " client is missing");
-}
-function missingMapping(mappingType) {
-  return new Error(ERROR_PREFIX + " " + mappingType + " 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.");
 }
 
-function middleware(config, options) {
-  if (process.env.NODE_ENV !== "production" && options.client == null) {
-    throw missingClient();
-  }
-
-  var client = options.client;
-  var storageMapping = validateMapping(options.storageMapping || {}, "storageMapping");
-  var presenceMapping = validateMapping(options.presenceMapping || {}, "presenceMapping");
-
-  if (process.env.NODE_ENV !== "production") {
-    validateNoDuplicateKeys(storageMapping, presenceMapping);
-  }
-
-  return function (set, get, api) {
-    var typedSet = set;
-    var room = null;
-    var isPatching = false;
-    var storageRoot = null;
-    var unsubscribeCallbacks = [];
-    var store = config(function (args) {
-      var oldState = get();
-      set(args);
-      var newState = get();
-
-      if (room) {
-        isPatching = true;
-        updatePresence(room, oldState, newState, presenceMapping);
-        room.batch(function () {
-          if (storageRoot) {
-            patchLiveblocksStorage(storageRoot, oldState, newState, storageMapping);
-          }
-        });
-        isPatching = false;
-      }
-    }, get, api);
-
-    function enterRoom(roomId, initialState) {
-      if (storageRoot) {
-        return;
-      }
+function updateZustandLiveblocksState(set, partial) {
+ set((function(state) {
+  return {
+   liveblocks: _extends({}, state.liveblocks, partial)
+  };
+ }));
+}
 
-      room = client.enter(roomId);
-      updateZustandLiveblocksState(set, {
-        isStorageLoading: true,
-        room: room
+function validateMapping(mapping, mappingType) {
+ if ("production" !== process.env.NODE_ENV) {
+  if (null == mapping) throw function(mappingType) {
+   return new Error(ERROR_PREFIX + " " + mappingType + " is missing.");
+  }(mappingType);
+  if (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.middleware = function(config, options) {
+ if ("production" !== process.env.NODE_ENV && null == options.client) throw new Error(ERROR_PREFIX + " client is missing");
+ var client = options.client, storageMapping = 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);
+ }(storageMapping, presenceMapping), function(set, get, api) {
+  var typedSet = set, room = null, isPatching = !1, storageRoot = null, unsubscribeCallbacks = [], store = config((function(args) {
+   var oldState = get();
+   set(args);
+   var newState = get();
+   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));
+    }
+   }(room, oldState, 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, oldState, newState, storageMapping);
+   })), isPatching = !1);
+  }), get, api);
+  return _extends({}, store, {
+   liveblocks: {
+    enterRoom: function(roomId, initialState) {
+     if (!storageRoot) {
+      room = client.enter(roomId), updateZustandLiveblocksState(set, {
+       isStorageLoading: !0,
+       room: room
       });
       var state = get();
-      broadcastInitialPresence(room, state, presenceMapping);
-      unsubscribeCallbacks.push(room.subscribe("others", function (others) {
-        updateZustandLiveblocksState(set, {
-          others: others.toArray()
-        });
-      }));
-      unsubscribeCallbacks.push(room.subscribe("connection", function () {
-        updateZustandLiveblocksState(set, {
-          connection: room.getConnectionState()
-        });
-      }));
-      unsubscribeCallbacks.push(room.subscribe("my-presence", function () {
-        if (isPatching === false) {
-          set(patchPresenceState(room.getPresence(), presenceMapping));
+      !function(room, state, mapping) {
+       for (var key in mapping) {
+        var _room$updatePresence;
+        null == room || room.updatePresence(((_room$updatePresence = {})[key] = state[key], 
+        _room$updatePresence));
+       }
+      }(room, state, presenceMapping), unsubscribeCallbacks.push(room.subscribe("others", (function(others) {
+       updateZustandLiveblocksState(set, {
+        others: others.toArray()
+       });
+      }))), unsubscribeCallbacks.push(room.subscribe("connection", (function() {
+       updateZustandLiveblocksState(set, {
+        connection: room.getConnectionState()
+       });
+      }))), unsubscribeCallbacks.push(room.subscribe("my-presence", (function() {
+       !1 === isPatching && set(function(presence, mapping) {
+        var partialState = {};
+        for (var key in mapping) partialState[key] = presence[key];
+        return partialState;
+       }(room.getPresence(), presenceMapping));
+      }))), room.getStorage().then((function(_ref) {
+       var root = _ref.root, updates = {};
+       room.batch((function() {
+        for (var key in storageMapping) {
+         var liveblocksStatePart = root.get(key);
+         null == liveblocksStatePart ? (updates[key] = initialState[key], internal.patchLiveObjectKey(root, key, void 0, initialState[key])) : updates[key] = internal.lsonToJson(liveblocksStatePart);
         }
+       })), typedSet(updates), storageRoot = root, unsubscribeCallbacks.push(room.subscribe(root, (function(updates) {
+        !1 === isPatching && set(function(state, updates, mapping) {
+         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;
+        }(get(), updates, storageMapping));
+       }), {
+        isDeep: !0
+       })), updateZustandLiveblocksState(set, {
+        isStorageLoading: !1
+       });
       }));
-      room.getStorage().then(function (_ref) {
-        var root = _ref.root;
-        var updates = {};
-        room.batch(function () {
-          for (var key in storageMapping) {
-            var liveblocksStatePart = root.get(key);
-
-            if (liveblocksStatePart == null) {
-              updates[key] = initialState[key];
-              internal.patchLiveObjectKey(root, key, undefined, initialState[key]);
-            } else {
-              updates[key] = internal.lsonToJson(liveblocksStatePart);
-            }
-          }
-        });
-        typedSet(updates);
-        storageRoot = root;
-        unsubscribeCallbacks.push(room.subscribe(root, function (updates) {
-          if (isPatching === false) {
-            set(patchState(get(), updates, storageMapping));
-          }
-        }, {
-          isDeep: true
-        }));
-        updateZustandLiveblocksState(set, {
-          isStorageLoading: false
-        });
-      });
-    }
-
-    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);
-      updateZustandLiveblocksState(set, {
-        others: [],
-        connection: "closed",
-        isStorageLoading: false,
-        room: null
-      });
-    }
-
-    return _extends({}, store, {
-      liveblocks: {
-        enterRoom: enterRoom,
-        leaveRoom: leaveRoom,
-        room: null,
-        others: [],
-        connection: "closed",
-        isStorageLoading: false
-      }
-    });
-  };
-}
-
-function patchState(state, updates, mapping) {
-  var partialState = {};
-
-  for (var key in mapping) {
-    partialState[key] = state[key];
-  }
-
-  var patched = internal.patchImmutableObject(partialState, updates);
-  var result = {};
-
-  for (var _key in mapping) {
-    result[_key] = patched[_key];
-  }
-
-  return result;
-}
-
-function patchPresenceState(presence, mapping) {
-  var partialState = {};
-
-  for (var key in mapping) {
-    partialState[key] = presence[key];
-  }
-
-  return partialState;
-}
-
-function updateZustandLiveblocksState(set, partial) {
-  set(function (state) {
-    return {
-      liveblocks: _extends({}, state.liveblocks, partial)
-    };
+     }
+    },
+    leaveRoom: function(roomId) {
+     for (var _step, _iterator = _createForOfIteratorHelperLoose(unsubscribeCallbacks); !(_step = _iterator()).done; ) {
+      (0, _step.value)();
+     }
+     storageRoot = null, room = null, isPatching = !1, unsubscribeCallbacks = [], client.leave(roomId), 
+     updateZustandLiveblocksState(set, {
+      others: [],
+      connection: "closed",
+      isStorageLoading: !1,
+      room: null
+     });
+    },
+    room: null,
+    others: [],
+    connection: "closed",
+    isStorageLoading: !1
+   }
   });
-}
-
-function broadcastInitialPresence(room, state, mapping) {
-  for (var key in mapping) {
-    var _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 key in presenceMapping) {
-    if (typeof newState[key] === "function") {
-      throw mappingToFunctionIsNotAllowed("value");
-    }
-
-    if (oldState[key] !== newState[key]) {
-      var _room$updatePresence2;
-
-      room.updatePresence((_room$updatePresence2 = {}, _room$updatePresence2[key] = newState[key], _room$updatePresence2));
-    }
-  }
-}
-
-function patchLiveblocksStorage(root, oldState, newState, mapping) {
-  for (var key in mapping) {
-    if (process.env.NODE_ENV !== "production" && typeof newState[key] === "function") {
-      throw mappingToFunctionIsNotAllowed("value");
-    }
-
-    if (oldState[key] !== newState[key]) {
-      internal.patchLiveObjectKey(root, key, oldState[key], newState[key]);
-    }
-  }
-}
-
-function isObject(value) {
-  return Object.prototype.toString.call(value) === "[object Object]";
-}
-
-function validateNoDuplicateKeys(storageMapping, presenceMapping) {
-  for (var key in storageMapping) {
-    if (presenceMapping[key] !== undefined) {
-      throw mappingShouldNotHaveTheSameKeys(key);
-    }
-  }
-}
-
-function validateMapping(mapping, mappingType) {
-  if (process.env.NODE_ENV !== "production") {
-    if (mapping == null) {
-      throw missingMapping(mappingType);
-    }
-
-    if (!isObject(mapping)) {
-      throw mappingShouldBeAnObject(mappingType);
-    }
-  }
-
-  var result = {};
-
-  for (var 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;
-}
-
-exports.middleware = middleware;
+ };
+};

package/index.mjs

@@ -1,210 +1,137 @@
-import { patchLiveObjectKey, lsonToJson, patchImmutableObject } from '@liveblocks/client/internal';
+import { patchLiveObjectKey, lsonToJson, patchImmutableObject } from "@liveblocks/client/internal";
 
 const ERROR_PREFIX = "Invalid @liveblocks/zustand middleware config.";
-function missingClient() {
-    return new Error(`${ERROR_PREFIX} client is missing`);
-}
-function missingMapping(mappingType) {
-    return new Error(`${ERROR_PREFIX} ${mappingType} 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.`);
 }
 
 function middleware(config, options) {
-    if (process.env.NODE_ENV !== "production" && options.client == null) {
-        throw missingClient();
-    }
-    const client = options.client;
-    const storageMapping = validateMapping(options.storageMapping || {}, "storageMapping");
-    const presenceMapping = validateMapping(options.presenceMapping || {}, "presenceMapping");
-    if (process.env.NODE_ENV !== "production") {
-        validateNoDuplicateKeys(storageMapping, presenceMapping);
-    }
-    return (set, get, api) => {
-        const typedSet = set;
-        let room = null;
-        let isPatching = false;
-        let storageRoot = null;
-        let unsubscribeCallbacks = [];
-        const store = config((args) => {
-            const oldState = get();
-            set(args);
-            const newState = get();
-            if (room) {
-                isPatching = true;
-                updatePresence(room, oldState, newState, presenceMapping);
-                room.batch(() => {
-                    if (storageRoot) {
-                        patchLiveblocksStorage(storageRoot, oldState, newState, storageMapping);
-                    }
-                });
-                isPatching = false;
-            }
-        }, get, api);
-        function enterRoom(roomId, initialState) {
-            if (storageRoot) {
-                return;
-            }
-            room = client.enter(roomId);
-            updateZustandLiveblocksState(set, { isStorageLoading: true, room });
-            const state = get();
-            broadcastInitialPresence(room, state, presenceMapping);
-            unsubscribeCallbacks.push(room.subscribe("others", (others) => {
-                updateZustandLiveblocksState(set, { others: others.toArray() });
-            }));
-            unsubscribeCallbacks.push(room.subscribe("connection", () => {
-                updateZustandLiveblocksState(set, {
-                    connection: room.getConnectionState(),
-                });
-            }));
-            unsubscribeCallbacks.push(room.subscribe("my-presence", () => {
-                if (isPatching === false) {
-                    set(patchPresenceState(room.getPresence(), presenceMapping));
-                }
-            }));
-            room.getStorage().then(({ root }) => {
-                const updates = {};
-                room.batch(() => {
-                    for (const key in storageMapping) {
-                        const liveblocksStatePart = root.get(key);
-                        if (liveblocksStatePart == null) {
-                            updates[key] = initialState[key];
-                            patchLiveObjectKey(root, key, undefined, initialState[key]);
-                        }
-                        else {
-                            updates[key] = lsonToJson(liveblocksStatePart);
-                        }
-                    }
-                });
-                typedSet(updates);
-                storageRoot = root;
-                unsubscribeCallbacks.push(room.subscribe(root, (updates) => {
-                    if (isPatching === false) {
-                        set(patchState(get(), updates, storageMapping));
-                    }
-                }, { isDeep: true }));
-                // set isLoading storage to false once storage is loaded
-                updateZustandLiveblocksState(set, { isStorageLoading: false });
-            });
-        }
-        function leaveRoom(roomId) {
-            for (const unsubscribe of unsubscribeCallbacks) {
-                unsubscribe();
-            }
-            storageRoot = null;
-            room = null;
-            isPatching = false;
-            unsubscribeCallbacks = [];
-            client.leave(roomId);
-            updateZustandLiveblocksState(set, {
-                others: [],
-                connection: "closed",
-                isStorageLoading: false,
-                room: null,
-            });
-        }
-        return Object.assign(Object.assign({}, store), { liveblocks: {
-                enterRoom,
-                leaveRoom,
-                room: null,
-                others: [],
-                connection: "closed",
-                isStorageLoading: false,
-            } });
-    };
-}
-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 patchPresenceState(presence, mapping) {
-    const partialState = {};
-    for (const key in mapping) {
-        partialState[key] = presence[key];
-    }
-    return partialState;
-}
-function updateZustandLiveblocksState(set, partial) {
-    set((state) => ({ liveblocks: Object.assign(Object.assign({}, state.liveblocks), partial) }));
-}
-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) {
+ if ("production" !== process.env.NODE_ENV && null == options.client) throw new Error(`${ERROR_PREFIX} client is missing`);
+ const client = options.client, storageMapping = 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);
+ }(storageMapping, presenceMapping), (set, get, api) => {
+  const typedSet = set;
+  let room = null, isPatching = !1, storageRoot = null, unsubscribeCallbacks = [];
+  const store = config((args => {
+   const oldState = get();
+   set(args);
+   const newState = get();
+   room && (isPatching = !0, function(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] });
-        }
+     if ("function" == typeof newState[key]) throw mappingToFunctionIsNotAllowed("value");
+     oldState[key] !== newState[key] && room.updatePresence({
+      [key]: newState[key]
+     });
     }
+   }(room, oldState, 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, oldState, newState, storageMapping);
+   })), isPatching = !1);
+  }), get, api);
+  return Object.assign(Object.assign({}, store), {
+   liveblocks: {
+    enterRoom: function(roomId, initialState) {
+     if (storageRoot) return;
+     room = client.enter(roomId), updateZustandLiveblocksState(set, {
+      isStorageLoading: !0,
+      room: room
+     });
+     const state = get();
+     !function(room, state, mapping) {
+      for (const key in mapping) null == room || room.updatePresence({
+       [key]: state[key]
+      });
+     }(room, state, presenceMapping), unsubscribeCallbacks.push(room.subscribe("others", (others => {
+      updateZustandLiveblocksState(set, {
+       others: others.toArray()
+      });
+     }))), unsubscribeCallbacks.push(room.subscribe("connection", (() => {
+      updateZustandLiveblocksState(set, {
+       connection: room.getConnectionState()
+      });
+     }))), unsubscribeCallbacks.push(room.subscribe("my-presence", (() => {
+      !1 === isPatching && set(function(presence, mapping) {
+       const partialState = {};
+       for (const key in mapping) partialState[key] = presence[key];
+       return partialState;
+      }(room.getPresence(), presenceMapping));
+     }))), room.getStorage().then((({root: root}) => {
+      const updates = {};
+      room.batch((() => {
+       for (const key in storageMapping) {
+        const liveblocksStatePart = root.get(key);
+        null == liveblocksStatePart ? (updates[key] = initialState[key], patchLiveObjectKey(root, key, void 0, initialState[key])) : updates[key] = lsonToJson(liveblocksStatePart);
+       }
+      })), typedSet(updates), storageRoot = root, unsubscribeCallbacks.push(room.subscribe(root, (updates => {
+       !1 === isPatching && set(function(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;
+       }(get(), updates, storageMapping));
+      }), {
+       isDeep: !0
+      })), updateZustandLiveblocksState(set, {
+       isStorageLoading: !1
+      });
+     }));
+    },
+    leaveRoom: function(roomId) {
+     for (const unsubscribe of unsubscribeCallbacks) unsubscribe();
+     storageRoot = null, room = null, isPatching = !1, unsubscribeCallbacks = [], client.leave(roomId), 
+     updateZustandLiveblocksState(set, {
+      others: [],
+      connection: "closed",
+      isStorageLoading: !1,
+      room: null
+     });
+    },
+    room: null,
+    others: [],
+    connection: "closed",
+    isStorageLoading: !1
+   }
+  });
+ };
 }
-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 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 updateZustandLiveblocksState(set, partial) {
+ set((state => ({
+  liveblocks: Object.assign(Object.assign({}, state.liveblocks), partial)
+ })));
 }
-/**
- * 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 (mapping == null) {
-            throw missingMapping(mappingType);
-        }
-        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) {
+  if (null == mapping) throw function(mappingType) {
+   return new Error(`${ERROR_PREFIX} ${mappingType} is missing.`);
+  }(mappingType);
+  if (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 { middleware };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/zustand",
-  "version": "0.16.4",
+  "version": "0.16.5",
   "description": "A middleware to integrate Liveblocks into Zustand 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-zustand"
   },
   "peerDependencies": {
-    "@liveblocks/client": "0.16.4",
+    "@liveblocks/client": "0.16.5",
     "zustand": "^3"
   },
   "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",
     "@rollup/plugin-babel": "^5.3.0",
     "@rollup/plugin-node-resolve": "^13.1.3",
@@ -49,11 +50,14 @@
     "@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",
     "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",
     "zustand": "^3.6.9"
   },