@liveblocks/redux 0.16.4-beta1 → 0.16.5

package/index.d.ts

@@ -1,9 +1,10 @@
-import { Client, User, Presence } from "@liveblocks/client";
-import { StoreEnhancer } from "redux";
-export declare type Mapping<T> = Partial<{
+import { Presence, User, Client } from '@liveblocks/client';
+import { StoreEnhancer } from 'redux';
+
+declare type Mapping<T> = Partial<{
     [Property in keyof T]: boolean;
 }>;
-export declare type LiveblocksState<TState, TPresence extends Presence = Presence> = TState & {
+declare type LiveblocksState<TState, TPresence extends Presence = Presence> = TState & {
     /**
      * Liveblocks extra state attached by the enhancer
      */
@@ -25,7 +26,7 @@ export declare type LiveblocksState<TState, TPresence extends Presence = Presenc
 /**
  * Actions used to interact with Liveblocks
  */
-export declare const actions: {
+declare const actions: {
     /**
      * Enters a room and starts sync it with zustand state
      * @param roomId The id of the room
@@ -47,9 +48,10 @@ declare function leaveRoom(roomId: string): {
     type: string;
     roomId: string;
 };
-export declare const enhancer: <T>(options: {
+declare const enhancer: <T>(options: {
     client: Client;
     storageMapping?: Partial<{ [Property in keyof T]: boolean; }> | undefined;
     presenceMapping?: Partial<{ [Property in keyof T]: boolean; }> | undefined;
 }) => StoreEnhancer;
-export {};
+
+export { LiveblocksState, Mapping, actions, enhancer };

package/index.js

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