@liveblocks/zustand 0.16.15 → 0.17.0-test1

package/index.d.ts

@@ -1,57 +1,85 @@
-import { Presence, Room, User, Client } from '@liveblocks/client';
-import { StateCreator, SetState, GetState, StoreApi } from 'zustand';
+import { JsonObject, LsonObject, Room, User, Client } from "@liveblocks/client";
+import { StateCreator, SetState, GetState, StoreApi } from "zustand";
 
-declare type LiveblocksState<TState, TPresence extends Presence = Presence> = TState & {
+declare type ZustandState = Record<string, unknown>;
+declare type LiveblocksState<
+  TState extends ZustandState,
+  TPresence extends JsonObject,
+  TStorage extends LsonObject
+> = TState & {
+  /**
+   * Liveblocks extra state attached by the middleware
+   */
+  readonly liveblocks: {
     /**
-     * Liveblocks extra state attached by the middleware
+     * 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.
      */
-    readonly liveblocks: {
-        /**
-         * 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.
-         */
-        readonly enterRoom: (roomId: string, initialState: Partial<TState>) => void;
-        /**
-         * Leaves a room and stops sync it with zustand state.
-         * @param roomId The id of the room
-         */
-        readonly leaveRoom: (roomId: string) => void;
-        /**
-         * The room currently synced to your zustand state.
-         */
-        readonly room: Room | null;
-        /**
-         * Other users in the room. Empty no room is currently synced
-         */
-        readonly others: Array<User<TPresence>>;
-        /**
-         * Whether or not the room storage is currently loading
-         */
-        readonly isStorageLoading: boolean;
-        /**
-         * Connection state of the room
-         */
-        readonly connection: "closed" | "authenticating" | "unavailable" | "failed" | "open" | "connecting";
-    };
-};
-declare type Mapping<T> = Partial<{
-    [Property in keyof T]: boolean;
-}>;
-declare type Options<T> = {
+    readonly enterRoom: (roomId: string, initialState: Partial<TState>) => void;
     /**
-     * Liveblocks client created by @liveblocks/client createClient
+     * Leaves a room and stops sync it with zustand state.
+     * @param roomId The id of the room
      */
-    client: Client;
+    readonly leaveRoom: (roomId: string) => void;
     /**
-     * Mapping used to synchronize a part of your zustand state with one Liveblocks Room storage.
+     * The room currently synced to your zustand state.
      */
-    storageMapping?: Mapping<T>;
+    readonly room: Room<TPresence, TStorage> | null;
     /**
-     * Mapping used to synchronize a part of your zustand state with one Liveblocks Room presence.
+     * Other users in the room. Empty no room is currently synced
      */
-    presenceMapping?: Mapping<T>;
+    readonly others: Array<User<TPresence>>;
+    /**
+     * Whether or not the room storage is currently loading
+     */
+    readonly isStorageLoading: boolean;
+    /**
+     * Connection state of the room
+     */
+    readonly connection:
+      | "closed"
+      | "authenticating"
+      | "unavailable"
+      | "failed"
+      | "open"
+      | "connecting";
+  };
+};
+declare type Mapping<T> = {
+  [K in keyof T]?: boolean;
+};
+declare type Options<T> = {
+  /**
+   * Liveblocks client created by @liveblocks/client createClient
+   */
+  client: Client;
+  /**
+   * Mapping used to synchronize a part of your zustand state with one Liveblocks Room storage.
+   */
+  storageMapping?: Mapping<T>;
+  /**
+   * Mapping used to synchronize a part of your zustand state with one Liveblocks Room presence.
+   */
+  presenceMapping?: Mapping<T>;
 };
-declare function middleware<T extends Record<string, unknown>, TPresence extends Record<string, unknown> = Presence>(config: StateCreator<T, SetState<T>, GetState<LiveblocksState<T>>, StoreApi<T>>, options: Options<T>): StateCreator<LiveblocksState<T, TPresence>, SetState<LiveblocksState<T, TPresence>>, GetState<LiveblocksState<T, TPresence>>, StoreApi<LiveblocksState<T, TPresence>>>;
+declare function middleware<
+  T extends ZustandState,
+  TPresence extends JsonObject,
+  TStorage extends LsonObject
+>(
+  config: StateCreator<
+    T,
+    SetState<T>,
+    GetState<LiveblocksState<T, TPresence, TStorage>>,
+    StoreApi<T>
+  >,
+  options: Options<T>
+): StateCreator<
+  LiveblocksState<T, TPresence, TStorage>,
+  SetState<LiveblocksState<T, TPresence, TStorage>>,
+  GetState<LiveblocksState<T, TPresence, TStorage>>,
+  StoreApi<LiveblocksState<T, TPresence, TStorage>>
+>;
 
-export { LiveblocksState, Mapping, middleware };
+export { LiveblocksState, Mapping, ZustandState, middleware };

package/index.js

@@ -1,185 +1,326 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
- value: !0
-});
-
+Object.defineProperty(exports, "__esModule", { value: !0 });
 var internal = require("@liveblocks/client/internal");
-
 function _extends() {
- 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);
+  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) {
- (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;
+  (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 = "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;
+  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
+        );
+      }
+    })(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++] };
+    };
   }
- }(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.");
+  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 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 isJson(value) {
+  return (
+    null === value ||
+    "string" == typeof value ||
+    "number" == typeof value ||
+    "boolean" == typeof value ||
+    (Array.isArray(value) && value.every(isJson)) ||
+    ("object" == typeof value && Object.values(value).every(isJson))
+  );
 }
-
 function updateZustandLiveblocksState(set, partial) {
- set((function(state) {
-  return {
-   liveblocks: _extends({}, state.liveblocks, partial)
-  };
- }));
+  set(function (state) {
+    return { liveblocks: _extends({}, state.liveblocks, partial) };
+  });
 }
-
 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;
+  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");
+                  if (oldState[key] !== newState[key]) {
+                    var _room$updatePresence2,
+                      val = newState[key];
+                    room.updatePresence(
+                      (((_room$updatePresence2 = {})[key] = val),
+                      _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");
+                      if (oldState[key] !== newState[key]) {
+                        var oldVal = oldState[key],
+                          newVal = newState[key];
+                        (void 0 !== oldVal && !isJson(oldVal)) ||
+                          (void 0 !== newVal && !isJson(newVal)) ||
+                          internal.patchLiveObjectKey(
+                            root,
+                            key,
+                            oldVal,
+                            newVal
+                          );
+                      }
+                    }
+                  })(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();
+              !(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 });
+                });
+            }
+          },
+          leaveRoom: function (roomId) {
+            for (
+              var _step,
+                _iterator =
+                  _createForOfIteratorHelperLoose(unsubscribeCallbacks);
+              !(_step = _iterator()).done;
 
-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
+            ) {
+              (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,
+        },
       });
-      var state = get();
-      !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
-       });
-      }));
-     }
-    },
-    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
-   }
-  });
- };
+    }
+  );
 };

package/index.mjs

@@ -1,137 +1,240 @@
-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 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 isJson(value) {
+  return (
+    null === value ||
+    "string" == typeof value ||
+    "number" == typeof value ||
+    "boolean" == typeof value ||
+    (Array.isArray(value) && value.every(isJson)) ||
+    ("object" == typeof value && Object.values(value).every(isJson))
+  );
 }
-
 function middleware(config, options) {
- 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 ("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()
+  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 ("function" == typeof newState[key])
+                  throw mappingToFunctionIsNotAllowed("value");
+                if (oldState[key] !== newState[key]) {
+                  const val = newState[key];
+                  room.updatePresence({ [key]: val });
+                }
+              }
+            })(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");
+                    if (oldState[key] !== newState[key]) {
+                      const oldVal = oldState[key],
+                        newVal = newState[key];
+                      (void 0 !== oldVal && !isJson(oldVal)) ||
+                        (void 0 !== newVal && !isJson(newVal)) ||
+                        patchLiveObjectKey(root, key, oldVal, newVal);
+                    }
+                  }
+                })(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,
+        },
       });
-     }))), 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 updateZustandLiveblocksState(set, partial) {
- set((state => ({
-  liveblocks: Object.assign(Object.assign({}, state.liveblocks), partial)
- })));
+  set((state) => ({
+    liveblocks: Object.assign(Object.assign({}, state.liveblocks), partial),
+  }));
 }
-
 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;
- 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;
+  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.15",
+  "version": "0.17.0-test1",
   "description": "A middleware to integrate Liveblocks into Zustand stores.",
   "main": "./index.js",
   "module": "./index.mjs",
@@ -20,8 +20,8 @@
     "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",
+    "test": "jest --watch --silent --verbose",
+    "test-ci": "jest --silent --verbose",
     "dtslint": "dtslint --localTs node_modules/typescript/lib --expectOnly types"
   },
   "license": "Apache-2.0",
@@ -31,7 +31,7 @@
     "directory": "packages/liveblocks-zustand"
   },
   "peerDependencies": {
-    "@liveblocks/client": "0.16.15",
+    "@liveblocks/client": "0.17.0-test1",
     "zustand": "^3"
   },
   "devDependencies": {
@@ -46,9 +46,9 @@
     "@testing-library/jest-dom": "^5.16.1",
     "@testing-library/react": "^12.1.2",
     "@testing-library/react-hooks": "^7.0.2",
-    "@types/jest": "^27.4.0",
-    "@typescript-eslint/eslint-plugin": "^5.18.0",
-    "@typescript-eslint/parser": "^5.18.0",
+    "@types/jest": "^27.5.1",
+    "@typescript-eslint/eslint-plugin": "^5.26.0",
+    "@typescript-eslint/parser": "^5.26.0",
     "eslint": "^8.12.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-simple-import-sort": "^7.0.0",
@@ -56,8 +56,10 @@
     "msw": "^0.36.4",
     "rollup": "^2.64.0",
     "rollup-plugin-command": "^1.1.3",
-    "rollup-plugin-dts": "^4.2.1",
+    "rollup-plugin-dts": "^4.2.2",
+    "rollup-plugin-prettier": "^2.2.2",
     "rollup-plugin-terser": "^7.0.2",
+    "typescript": "^4.7.2",
     "whatwg-fetch": "^3.6.2",
     "zustand": "^3.6.9"
   },