@liveblocks/zustand 0.17.8 → 0.17.9

package/.built-by-link-script

@@ -0,0 +1 @@
+ba5e65b5d95af44c0fcdda18d51bc943741ca13f

package/index.d.ts

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

package/index.js

@@ -1,326 +1,285 @@
-"use strict";
-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)
-  );
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/index.ts
+
+
+
+
+var _internal = require('@liveblocks/client/internal');
+
+// src/errors.ts
+var ERROR_PREFIX = "Invalid @liveblocks/zustand middleware config.";
+function missingClient() {
+  return new Error(`${ERROR_PREFIX} client is missing`);
 }
-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;
+function missingMapping(mappingType) {
+  return new Error(`${ERROR_PREFIX} ${mappingType} is missing.`);
 }
-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
-        );
-      }
-    })(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."
+function mappingShouldBeAnObject(mappingType) {
+  return new Error(
+    `${ERROR_PREFIX} ${mappingType} should be an object where the values are boolean.`
   );
 }
-var ERROR_PREFIX = "Invalid @liveblocks/zustand middleware config.";
 function mappingValueShouldBeABoolean(mappingType, key) {
   return new Error(
-    ERROR_PREFIX + " " + mappingType + "." + key + " value should be a boolean"
+    `${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."
+    `${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."
+    `${ERROR_PREFIX} mapping.${key} is invalid. Mapping to a function is not allowed.`
   );
 }
+
+// src/index.ts
 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))
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) && value.every(isJson) || typeof value === "object" && Object.values(value).every(isJson);
+}
+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];
+              _internal.patchLiveObjectKey.call(void 0, root, key, void 0, initialState[key]);
+            } else {
+              updates[key] = _internal.lsonToJson.call(void 0, liveblocksStatePart);
+            }
+          }
+        });
+        typedSet(updates);
+        storageRoot = root;
+        unsubscribeCallbacks.push(
+          room.subscribe(
+            root,
+            (updates2) => {
+              if (isPatching === false) {
+                set(patchState(get(), updates2, storageMapping));
+              }
+            },
+            { isDeep: true }
+          )
+        );
+        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 __spreadProps(__spreadValues({}, store), {
+      liveblocks: {
+        enterRoom,
+        leaveRoom,
+        room: null,
+        others: [],
+        connection: "closed",
+        isStorageLoading: false
+      }
+    });
+  };
+}
+function patchState(state, updates, mapping) {
+  const partialState = {};
+  for (const key in mapping) {
+    partialState[key] = state[key];
+  }
+  const patched = _internal.patchImmutableObject.call(void 0, 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(function (state) {
-    return { liveblocks: _extends({}, state.liveblocks, partial) };
-  });
+  set((state) => ({ liveblocks: __spreadValues(__spreadValues({}, state.liveblocks), partial) }));
+}
+function broadcastInitialPresence(room, state, mapping) {
+  for (const key in mapping) {
+    room == null ? void 0 : room.updatePresence({ [key]: state[key] });
+  }
+}
+function updatePresence(room, oldState, newState, presenceMapping) {
+  for (const key in presenceMapping) {
+    if (typeof newState[key] === "function") {
+      throw mappingToFunctionIsNotAllowed("value");
+    }
+    if (oldState[key] !== newState[key]) {
+      const val = newState[key];
+      room.updatePresence({ [key]: val });
+    }
+  }
+}
+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]) {
+      const oldVal = oldState[key];
+      const newVal = newState[key];
+      if ((oldVal === void 0 || isJson(oldVal)) && (newVal === void 0 || isJson(newVal))) {
+        _internal.patchLiveObjectKey.call(void 0, root, key, oldVal, newVal);
+      }
+    }
+  }
+}
+function isObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function validateNoDuplicateKeys(storageMapping, presenceMapping) {
+  for (const key in storageMapping) {
+    if (presenceMapping[key] !== void 0) {
+      throw mappingShouldNotHaveTheSameKeys(key);
+    }
+  }
 }
 function 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);
+  if (process.env.NODE_ENV !== "production") {
+    if (mapping == null) {
+      throw missingMapping(mappingType);
+    }
+    if (!isObject(mapping)) {
+      throw mappingShouldBeAnObject(mappingType);
+    }
   }
-  var value,
-    result = {};
-  for (var key in mapping) {
-    if (
-      "production" !== process.env.NODE_ENV &&
-      "boolean" != typeof mapping[key]
-    )
+  const result = {};
+  for (const key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof mapping[key] !== "boolean") {
       throw mappingValueShouldBeABoolean(mappingType, key);
-    !0 === mapping[key] && (result[key] = !0);
+    }
+    if (mapping[key] === true) {
+      result[key] = true;
+    }
   }
   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;
 
-            ) {
-              (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,
-        },
-      });
-    }
-  );
-};
+
+exports.middleware = middleware;

package/index.mjs

@@ -1,240 +1,4 @@
-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`
-  );
-}
-function mappingShouldNotHaveTheSameKeys(key) {
-  return new Error(
-    `${ERROR_PREFIX} "${key}" is mapped on presenceMapping and storageMapping. A key shouldn't exist on both mapping.`
-  );
-}
-function mappingToFunctionIsNotAllowed(key) {
-  return new Error(
-    `${ERROR_PREFIX} mapping.${key} is invalid. Mapping to a function is not allowed.`
-  );
-}
-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");
-                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,
-        },
-      });
-    }
-  );
-}
-function updateZustandLiveblocksState(set, 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;
-}
-export { middleware };
+import mod from "./index.js";
+
+export default mod;
+export const middleware = mod.middleware;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/zustand",
-  "version": "0.17.8",
+  "version": "0.17.9",
   "description": "A middleware to integrate Liveblocks into Zustand stores.",
   "main": "./index.js",
   "module": "./index.mjs",
@@ -20,7 +20,7 @@
     "directory": "packages/liveblocks-zustand"
   },
   "peerDependencies": {
-    "@liveblocks/client": "0.17.8",
+    "@liveblocks/client": "0.17.9",
     "zustand": "^3"
   },
   "sideEffects": false