npm - @liveblocks/redux - Versions diffs - 0.17.8 → 0.17.10-debug2 - Mend

@liveblocks/redux 0.17.8 → 0.17.10-debug2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/.built-by-link-script ADDED Viewed

	@@ -0,0 +1 @@
1	+ 2d963544ab794518e83521361a7388453b6eebc9

package/index.d.ts CHANGED Viewed

@@ -1,70 +1,57 @@
-import { JsonObject, BaseUserMeta, User, Client } from "@liveblocks/client";
-import { StoreEnhancer } from "redux";
+import { JsonObject, BaseUserMeta, User, Client } from '@liveblocks/client';
+import { StoreEnhancer } from 'redux';
 declare type Mapping<T> = {
-  [K in keyof T]?: boolean;
+    [K in keyof T]?: boolean;
 };
-declare type LiveblocksState<
-  TState,
-  TPresence extends JsonObject,
-  TUserMeta extends BaseUserMeta
-> = TState & {
-  /**
-   * Liveblocks extra state attached by the enhancer
-   */
-  readonly liveblocks: {
+declare type LiveblocksState<TState, TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = TState & {
     /**
-     * Other users in the room. Empty no room is currently synced
+     * Liveblocks extra state attached by the enhancer
      */
-    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";
-  };
+    readonly liveblocks: {
+        /**
+         * 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";
+    };
 };
 /**
  * Actions used to interact with Liveblocks
  */
 declare const actions: {
-  /**
-   * Enters a room and starts sync it with zustand state
-   * @param roomId The id of the room
-   * @param initialState The initial state of the room storage. If a key does not exist if your room storage root, initialState[key] will be used.
-   */
-  enterRoom: typeof enterRoom;
-  /**
-   * Leaves a room and stops sync it with zustand state.
-   * @param roomId The id of the room
-   */
-  leaveRoom: typeof leaveRoom;
+    /**
+     * Enters a room and starts sync it with zustand state
+     * @param roomId The id of the room
+     * @param initialState The initial state of the room storage. If a key does not exist if your room storage root, initialState[key] will be used.
+     */
+    enterRoom: typeof enterRoom;
+    /**
+     * Leaves a room and stops sync it with zustand state.
+     * @param roomId The id of the room
+     */
+    leaveRoom: typeof leaveRoom;
 };
-declare function enterRoom<T>(
-  roomId: string,
-  initialState?: T
-): {
-  type: string;
-  roomId: string;
-  initialState?: T;
+declare function enterRoom<T>(roomId: string, initialState?: T): {
+    type: string;
+    roomId: string;
+    initialState?: T;
 };
 declare function leaveRoom(roomId: string): {
-  type: string;
-  roomId: string;
+    type: string;
+    roomId: string;
 };
 declare const enhancer: <T>(options: {
-  client: Client;
-  storageMapping?: Mapping<T> | undefined;
-  presenceMapping?: Mapping<T> | undefined;
+    client: Client;
+    storageMapping?: Mapping<T> | undefined;
+    presenceMapping?: Mapping<T> | undefined;
 }) => StoreEnhancer;
 export { LiveblocksState, Mapping, actions, enhancer };

package/index.js CHANGED Viewed

@@ -1,358 +1,343 @@
-"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)
-  );
-}
-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;
+"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/redux middleware config.";
+function missingClient() {
+  return new Error(`${ERROR_PREFIX} client 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/redux 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.`
   );
 }
-var ACTION_TYPES_ENTER = "@@LIVEBLOCKS/ENTER",
-  ACTION_TYPES_LEAVE = "@@LIVEBLOCKS/LEAVE",
-  ACTION_TYPES_START_LOADING_STORAGE = "@@LIVEBLOCKS/START_LOADING_STORAGE",
-  ACTION_TYPES_INIT_STORAGE = "@@LIVEBLOCKS/INIT_STORAGE",
-  ACTION_TYPES_PATCH_REDUX_STATE = "@@LIVEBLOCKS/PATCH_REDUX_STATE",
-  ACTION_TYPES_UPDATE_CONNECTION = "@@LIVEBLOCKS/UPDATE_CONNECTION",
-  ACTION_TYPES_UPDATE_OTHERS = "@@LIVEBLOCKS/UPDATE_OTHERS",
-  actions = {
-    enterRoom: function (roomId, initialState) {
-      return {
-        type: ACTION_TYPES_ENTER,
-        roomId: roomId,
-        initialState: initialState,
-      };
-    },
-    leaveRoom: function (roomId) {
-      return { type: ACTION_TYPES_LEAVE, roomId: roomId };
-    },
-  };
-var enhancer = function (options) {
-  if ("production" !== process.env.NODE_ENV && null == options.client)
-    throw new Error(ERROR_PREFIX + " client is missing");
-  var client = options.client,
-    mapping = validateMapping(options.storageMapping || {}, "storageMapping"),
-    presenceMapping = validateMapping(
-      options.presenceMapping || {},
-      "presenceMapping"
-    );
-  return (
-    "production" !== process.env.NODE_ENV &&
-      (function (storageMapping, presenceMapping) {
-        for (var key in storageMapping)
-          if (void 0 !== presenceMapping[key])
-            throw mappingShouldNotHaveTheSameKeys(key);
-      })(mapping, presenceMapping),
-    function (createStore) {
-      return function (reducer, initialState, enhancer) {
-        var room = null,
-          isPatching = !1,
-          storageRoot = null,
-          unsubscribeCallbacks = [],
-          store = createStore(
-            function (state, action) {
-              switch (action.type) {
-                case ACTION_TYPES_PATCH_REDUX_STATE:
-                  return _extends({}, state, action.state);
-                case ACTION_TYPES_INIT_STORAGE:
-                  return _extends({}, state, action.state, {
-                    liveblocks: _extends({}, state.liveblocks, {
-                      isStorageLoading: !1,
-                    }),
-                  });
-                case ACTION_TYPES_START_LOADING_STORAGE:
-                  return _extends({}, state, {
-                    liveblocks: _extends({}, state.liveblocks, {
-                      isStorageLoading: !0,
-                    }),
-                  });
-                case ACTION_TYPES_UPDATE_CONNECTION:
-                  return _extends({}, state, {
-                    liveblocks: _extends({}, state.liveblocks, {
-                      connection: action.connection,
-                    }),
-                  });
-                case ACTION_TYPES_UPDATE_OTHERS:
-                  return _extends({}, state, {
-                    liveblocks: _extends({}, state.liveblocks, {
-                      others: action.others,
-                    }),
-                  });
-                default:
-                  var newState = reducer(state, action);
-                  return (
-                    room &&
-                      ((isPatching = !0),
-                      (function (room, oldState, newState, presenceMapping) {
-                        for (var key in presenceMapping) {
-                          if ("function" == typeof newState[key])
-                            throw mappingToFunctionIsNotAllowed("value");
-                          var _room$updatePresence2;
-                          if (oldState[key] !== newState[key])
-                            room.updatePresence(
-                              (((_room$updatePresence2 = {})[key] =
-                                newState[key]),
-                              _room$updatePresence2)
-                            );
-                        }
-                      })(room, state, newState, presenceMapping),
-                      room.batch(function () {
-                        storageRoot &&
-                          (function (root, oldState, newState, mapping) {
-                            for (var key in mapping) {
-                              if (
-                                "production" !== process.env.NODE_ENV &&
-                                "function" == typeof newState[key]
-                              )
-                                throw mappingToFunctionIsNotAllowed("value");
-                              oldState[key] !== newState[key] &&
-                                internal.patchLiveObjectKey(
-                                  root,
-                                  key,
-                                  oldState[key],
-                                  newState[key]
-                                );
-                            }
-                          })(storageRoot, state, newState, mapping);
-                      }),
-                      (isPatching = !1)),
-                    null == newState.liveblocks
-                      ? _extends({}, newState, {
-                          liveblocks: {
-                            others: [],
-                            isStorageLoading: !1,
-                            connection: "closed",
-                          },
-                        })
-                      : newState
-                  );
-              }
-            },
-            initialState,
-            enhancer
-          );
-        return _extends({}, store, {
-          dispatch: function (action, state) {
-            var roomId, storageInitialState, reduxState;
-            action.type === ACTION_TYPES_ENTER
-              ? ((roomId = action.roomId),
-                (storageInitialState = action.initialState),
-                (reduxState = store.getState()),
-                void 0 === storageInitialState && (storageInitialState = {}),
-                storageRoot ||
-                  ((function (room, state, mapping) {
-                    for (var key in mapping) {
-                      var _room$updatePresence;
-                      null == room ||
-                        room.updatePresence(
-                          (((_room$updatePresence = {})[key] = state[key]),
-                          _room$updatePresence)
-                        );
-                    }
-                  })(
-                    (room = client.enter(roomId)),
-                    reduxState,
-                    presenceMapping
-                  ),
-                  unsubscribeCallbacks.push(
-                    room.subscribe("connection", function () {
-                      store.dispatch({
-                        type: ACTION_TYPES_UPDATE_CONNECTION,
-                        connection: room.getConnectionState(),
-                      });
-                    })
-                  ),
-                  unsubscribeCallbacks.push(
-                    room.subscribe("others", function (others) {
-                      store.dispatch({
-                        type: ACTION_TYPES_UPDATE_OTHERS,
-                        others: others.toArray(),
-                      });
-                    })
-                  ),
-                  unsubscribeCallbacks.push(
-                    room.subscribe("my-presence", function () {
-                      !1 === isPatching &&
-                        store.dispatch({
-                          type: ACTION_TYPES_PATCH_REDUX_STATE,
-                          state: patchPresenceState(
-                            room.getPresence(),
-                            presenceMapping
-                          ),
-                        });
-                    })
-                  ),
-                  store.dispatch({ type: ACTION_TYPES_START_LOADING_STORAGE }),
-                  room.getStorage().then(function (_ref) {
-                    var root = _ref.root,
-                      updates = {};
-                    room.batch(function () {
-                      for (var key in mapping) {
-                        var liveblocksStatePart = root.get(key);
-                        null == liveblocksStatePart
-                          ? ((updates[key] = storageInitialState[key]),
-                            internal.patchLiveObjectKey(
-                              root,
-                              key,
-                              void 0,
-                              storageInitialState[key]
-                            ))
-                          : (updates[key] =
-                              internal.lsonToJson(liveblocksStatePart));
-                      }
-                    }),
-                      store.dispatch({
-                        type: ACTION_TYPES_INIT_STORAGE,
-                        state: updates,
-                      }),
-                      (storageRoot = root),
-                      unsubscribeCallbacks.push(
-                        room.subscribe(
-                          root,
-                          function (updates) {
-                            !1 === isPatching &&
-                              store.dispatch({
-                                type: ACTION_TYPES_PATCH_REDUX_STATE,
-                                state: patchState(
-                                  store.getState(),
-                                  updates,
-                                  mapping
-                                ),
-                              });
-                          },
-                          { isDeep: !0 }
-                        )
-                      );
-                  })))
-              : action.type === ACTION_TYPES_LEAVE
-              ? (function (roomId) {
-                  for (
-                    var _step,
-                      _iterator =
-                        _createForOfIteratorHelperLoose(unsubscribeCallbacks);
-                    !(_step = _iterator()).done;
-                  )
-                    (0, _step.value)();
-                  (storageRoot = null),
-                    (room = null),
-                    (isPatching = !1),
-                    (unsubscribeCallbacks = []),
-                    client.leave(roomId);
-                })(action.roomId)
-              : store.dispatch(action, state);
-          },
+// src/index.ts
+var ACTION_TYPES = {
+  ENTER: "@@LIVEBLOCKS/ENTER",
+  LEAVE: "@@LIVEBLOCKS/LEAVE",
+  START_LOADING_STORAGE: "@@LIVEBLOCKS/START_LOADING_STORAGE",
+  INIT_STORAGE: "@@LIVEBLOCKS/INIT_STORAGE",
+  PATCH_REDUX_STATE: "@@LIVEBLOCKS/PATCH_REDUX_STATE",
+  UPDATE_CONNECTION: "@@LIVEBLOCKS/UPDATE_CONNECTION",
+  UPDATE_OTHERS: "@@LIVEBLOCKS/UPDATE_OTHERS"
+};
+var internalEnhancer = (options) => {
+  if (process.env.NODE_ENV !== "production" && options.client == null) {
+    throw missingClient();
+  }
+  const client = options.client;
+  const mapping = validateMapping(
+    options.storageMapping || {},
+    "storageMapping"
+  );
+  const presenceMapping = validateMapping(
+    options.presenceMapping || {},
+    "presenceMapping"
+  );
+  if (process.env.NODE_ENV !== "production") {
+    validateNoDuplicateKeys(mapping, presenceMapping);
+  }
+  return (createStore) => (reducer, initialState, enhancer2) => {
+    let room = null;
+    let isPatching = false;
+    let storageRoot = null;
+    let unsubscribeCallbacks = [];
+    const newReducer = (state, action) => {
+      switch (action.type) {
+        case ACTION_TYPES.PATCH_REDUX_STATE:
+          return __spreadValues(__spreadValues({}, state), action.state);
+        case ACTION_TYPES.INIT_STORAGE:
+          return __spreadProps(__spreadValues(__spreadValues({}, state), action.state), {
+            liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
+              isStorageLoading: false
+            })
+          });
+        case ACTION_TYPES.START_LOADING_STORAGE:
+          return __spreadProps(__spreadValues({}, state), {
+            liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
+              isStorageLoading: true
+            })
+          });
+        case ACTION_TYPES.UPDATE_CONNECTION: {
+          return __spreadProps(__spreadValues({}, state), {
+            liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
+              connection: action.connection
+            })
+          });
+        }
+        case ACTION_TYPES.UPDATE_OTHERS: {
+          return __spreadProps(__spreadValues({}, state), {
+            liveblocks: __spreadProps(__spreadValues({}, state.liveblocks), {
+              others: action.others
+            })
+          });
+        }
+        default: {
+          const newState = reducer(state, action);
+          if (room) {
+            isPatching = true;
+            updatePresence(room, state, newState, presenceMapping);
+            room.batch(() => {
+              if (storageRoot) {
+                patchLiveblocksStorage(
+                  storageRoot,
+                  state,
+                  newState,
+                  mapping
+                );
+              }
+            });
+            isPatching = false;
+          }
+          if (newState.liveblocks == null) {
+            return __spreadProps(__spreadValues({}, newState), {
+              liveblocks: {
+                others: [],
+                isStorageLoading: false,
+                connection: "closed"
+              }
+            });
+          }
+          return newState;
+        }
+      }
+    };
+    const store = createStore(newReducer, initialState, enhancer2);
+    function enterRoom2(roomId, storageInitialState = {}, reduxState) {
+      if (storageRoot) {
+        return;
+      }
+      room = client.enter(roomId);
+      broadcastInitialPresence(room, reduxState, presenceMapping);
+      unsubscribeCallbacks.push(
+        room.subscribe("connection", () => {
+          store.dispatch({
+            type: ACTION_TYPES.UPDATE_CONNECTION,
+            connection: room.getConnectionState()
+          });
+        })
+      );
+      unsubscribeCallbacks.push(
+        room.subscribe("others", (others) => {
+          store.dispatch({
+            type: ACTION_TYPES.UPDATE_OTHERS,
+            others: others.toArray()
+          });
+        })
+      );
+      unsubscribeCallbacks.push(
+        room.subscribe("my-presence", () => {
+          if (isPatching === false) {
+            store.dispatch({
+              type: ACTION_TYPES.PATCH_REDUX_STATE,
+              state: patchPresenceState(
+                room.getPresence(),
+                presenceMapping
+              )
+            });
+          }
+        })
+      );
+      store.dispatch({
+        type: ACTION_TYPES.START_LOADING_STORAGE
+      });
+      room.getStorage().then(({ root }) => {
+        const updates = {};
+        room.batch(() => {
+          for (const key in mapping) {
+            const liveblocksStatePart = root.get(key);
+            if (liveblocksStatePart == null) {
+              updates[key] = storageInitialState[key];
+              _internal.patchLiveObjectKey.call(void 0,
+                root,
+                key,
+                void 0,
+                storageInitialState[key]
+              );
+            } else {
+              updates[key] = _internal.lsonToJson.call(void 0, liveblocksStatePart);
+            }
+          }
         });
-      };
+        store.dispatch({
+          type: ACTION_TYPES.INIT_STORAGE,
+          state: updates
+        });
+        storageRoot = root;
+        unsubscribeCallbacks.push(
+          room.subscribe(
+            root,
+            (updates2) => {
+              if (isPatching === false) {
+                store.dispatch({
+                  type: ACTION_TYPES.PATCH_REDUX_STATE,
+                  state: patchState(
+                    store.getState(),
+                    updates2,
+                    mapping
+                  )
+                });
+              }
+            },
+            { isDeep: true }
+          )
+        );
+      });
     }
-  );
+    function leaveRoom2(roomId) {
+      for (const unsubscribe of unsubscribeCallbacks) {
+        unsubscribe();
+      }
+      storageRoot = null;
+      room = null;
+      isPatching = false;
+      unsubscribeCallbacks = [];
+      client.leave(roomId);
+    }
+    function newDispatch(action, state) {
+      if (action.type === ACTION_TYPES.ENTER) {
+        enterRoom2(action.roomId, action.initialState, store.getState());
+      } else if (action.type === ACTION_TYPES.LEAVE) {
+        leaveRoom2(action.roomId);
+      } else {
+        store.dispatch(action, state);
+      }
+    }
+    return __spreadProps(__spreadValues({}, store), {
+      dispatch: newDispatch
+    });
+  };
+};
+var actions = {
+  enterRoom,
+  leaveRoom
 };
+function enterRoom(roomId, initialState) {
+  return {
+    type: ACTION_TYPES.ENTER,
+    roomId,
+    initialState
+  };
+}
+function leaveRoom(roomId) {
+  return {
+    type: ACTION_TYPES.LEAVE,
+    roomId
+  };
+}
+var enhancer = internalEnhancer;
+function patchLiveblocksStorage(root, oldState, newState, mapping) {
+  for (const key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof newState[key] === "function") {
+      throw mappingToFunctionIsNotAllowed("value");
+    }
+    if (oldState[key] !== newState[key]) {
+      _internal.patchLiveObjectKey.call(void 0, root, key, oldState[key], newState[key]);
+    }
+  }
+}
+function broadcastInitialPresence(room, state, mapping) {
+  for (const key in mapping) {
+    room == null ? void 0 : room.updatePresence({ [key]: state[key] });
+  }
+}
+function updatePresence(room, oldState, newState, presenceMapping) {
+  for (const key in presenceMapping) {
+    if (typeof newState[key] === "function") {
+      throw mappingToFunctionIsNotAllowed("value");
+    }
+    if (oldState[key] !== newState[key]) {
+      room.updatePresence({ [key]: newState[key] });
+    }
+  }
+}
+function isObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function validateNoDuplicateKeys(storageMapping, presenceMapping) {
+  for (const key in storageMapping) {
+    if (presenceMapping[key] !== void 0) {
+      throw mappingShouldNotHaveTheSameKeys(key);
+    }
+  }
+}
 function patchPresenceState(presence, mapping) {
-  var partialState = {};
-  for (var key in mapping) partialState[key] = presence[key];
+  const partialState = {};
+  for (const key in mapping) {
+    partialState[key] = presence[key];
+  }
   return partialState;
 }
 function patchState(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];
+  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 validateMapping(mapping, mappingType) {
-  if (
-    "production" !== process.env.NODE_ENV &&
-    ((value = mapping),
-    "[object Object]" !== Object.prototype.toString.call(value))
-  )
-    throw (function (mappingType) {
-      return new Error(
-        ERROR_PREFIX +
-          " " +
-          mappingType +
-          " should be an object where the values are boolean."
-      );
-    })(mappingType);
-  var value,
-    result = {};
-  for (var key in mapping) {
-    if (
-      "production" !== process.env.NODE_ENV &&
-      "boolean" != typeof mapping[key]
-    )
+  if (process.env.NODE_ENV !== "production") {
+    if (!isObject(mapping)) {
+      throw mappingShouldBeAnObject(mappingType);
+    }
+  }
+  const result = {};
+  for (const key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof mapping[key] !== "boolean") {
       throw mappingValueShouldBeABoolean(mappingType, key);
-    !0 === mapping[key] && (result[key] = !0);
+    }
+    if (mapping[key] === true) {
+      result[key] = true;
+    }
   }
   return result;
 }
-(exports.actions = actions), (exports.enhancer = enhancer);
+exports.actions = actions; exports.enhancer = enhancer;

package/index.mjs CHANGED Viewed

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

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/redux",
-  "version": "0.17.8",
+  "version": "0.17.10-debug2",
   "description": "A store enhancer to integrate Liveblocks into Redux stores.",
   "main": "./index.js",
   "module": "./index.mjs",
@@ -20,7 +20,7 @@
     "directory": "packages/liveblocks-redux"
   },
   "peerDependencies": {
-    "@liveblocks/client": "0.17.8",
+    "@liveblocks/client": "0.17.10-debug2",
     "redux": "^4"
   },
   "sideEffects": false