@liveblocks/redux 0.15.0-alpha.3

package/lib/esm/index.js

@@ -0,0 +1,277 @@
+import { patchLiveObjectKey, liveNodeToJson, patchImmutableObject } from '@liveblocks/client';
+
+const ERROR_PREFIX = "Invalid @liveblocks/redux middleware config.";
+function missingClient() {
+  return new Error(`${ERROR_PREFIX} client is missing`);
+}
+function missingMapping(mappingType) {
+  return new Error(`${ERROR_PREFIX} ${mappingType} is missing.`);
+}
+function mappingShouldBeAnObject(mappingType) {
+  return new Error(`${ERROR_PREFIX} ${mappingType} should be an object where the values are boolean.`);
+}
+function mappingValueShouldBeABoolean(mappingType, key) {
+  return new Error(`${ERROR_PREFIX} ${mappingType}.${key} value should be a boolean`);
+}
+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.`);
+}
+
+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));
+const ACTION_TYPES = {
+  ENTER: "@@LIVEBLOCKS/ENTER",
+  LEAVE: "@@LIVEBLOCKS/LEAVE",
+  START_LOADING_STORAGE: "@@LIVEBLOCKS/START_LOADING_STORAGE",
+  INIT_STORAGE: "@@LIVEBLOCKS/INIT_STORAGE",
+  PATCH_STORAGE: "@@LIVEBLOCKS/PATCH_STORAGE",
+  UPDATE_CONNECTION: "@@LIVEBLOCKS/UPDATE_CONNECTION",
+  UPDATE_OTHERS: "@@LIVEBLOCKS/UPDATE_OTHERS"
+};
+const internalPlugin = (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_STORAGE:
+          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()
+        });
+      }));
+      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];
+              patchLiveObjectKey(root, key, void 0, storageInitialState[key]);
+            } else {
+              updates[key] = liveNodeToJson(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_STORAGE,
+              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
+    });
+  };
+};
+function enterRoom(roomId, initialState) {
+  return {
+    type: ACTION_TYPES.ENTER,
+    roomId,
+    initialState
+  };
+}
+function leaveRoom(roomId) {
+  return {
+    type: ACTION_TYPES.LEAVE,
+    roomId
+  };
+}
+const enhancer = internalPlugin;
+function patchLiveblocksStorage(root, oldState, newState, mapping) {
+  for (const key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof newState[key] === "function") {
+      throw mappingToFunctionIsNotAllowed("value");
+    }
+    if (oldState[key] !== newState[key]) {
+      patchLiveObjectKey(root, key, oldState[key], newState[key]);
+    }
+  }
+}
+function 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 patchState(state, updates, mapping) {
+  const partialState = {};
+  for (const key in mapping) {
+    partialState[key] = state[key];
+  }
+  const patched = patchImmutableObject(partialState, updates);
+  const result = {};
+  for (const key in mapping) {
+    result[key] = patched[key];
+  }
+  return result;
+}
+function validateMapping(mapping, mappingType) {
+  if (process.env.NODE_ENV !== "production") {
+    if (mapping == null) {
+      throw missingMapping(mappingType);
+    }
+    if (!isObject(mapping)) {
+      throw mappingShouldBeAnObject(mappingType);
+    }
+  }
+  const result = {};
+  for (const key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof mapping[key] !== "boolean") {
+      throw mappingValueShouldBeABoolean(mappingType, key);
+    }
+    if (mapping[key] === true) {
+      result[key] = true;
+    }
+  }
+  return result;
+}
+
+export { enhancer, enterRoom, leaveRoom };

package/lib/esm/index.mjs

@@ -0,0 +1,277 @@
+import { patchLiveObjectKey, liveNodeToJson, patchImmutableObject } from '@liveblocks/client';
+
+const ERROR_PREFIX = "Invalid @liveblocks/redux middleware config.";
+function missingClient() {
+  return new Error(`${ERROR_PREFIX} client is missing`);
+}
+function missingMapping(mappingType) {
+  return new Error(`${ERROR_PREFIX} ${mappingType} is missing.`);
+}
+function mappingShouldBeAnObject(mappingType) {
+  return new Error(`${ERROR_PREFIX} ${mappingType} should be an object where the values are boolean.`);
+}
+function mappingValueShouldBeABoolean(mappingType, key) {
+  return new Error(`${ERROR_PREFIX} ${mappingType}.${key} value should be a boolean`);
+}
+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.`);
+}
+
+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));
+const ACTION_TYPES = {
+  ENTER: "@@LIVEBLOCKS/ENTER",
+  LEAVE: "@@LIVEBLOCKS/LEAVE",
+  START_LOADING_STORAGE: "@@LIVEBLOCKS/START_LOADING_STORAGE",
+  INIT_STORAGE: "@@LIVEBLOCKS/INIT_STORAGE",
+  PATCH_STORAGE: "@@LIVEBLOCKS/PATCH_STORAGE",
+  UPDATE_CONNECTION: "@@LIVEBLOCKS/UPDATE_CONNECTION",
+  UPDATE_OTHERS: "@@LIVEBLOCKS/UPDATE_OTHERS"
+};
+const internalPlugin = (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_STORAGE:
+          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()
+        });
+      }));
+      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];
+              patchLiveObjectKey(root, key, void 0, storageInitialState[key]);
+            } else {
+              updates[key] = liveNodeToJson(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_STORAGE,
+              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
+    });
+  };
+};
+function enterRoom(roomId, initialState) {
+  return {
+    type: ACTION_TYPES.ENTER,
+    roomId,
+    initialState
+  };
+}
+function leaveRoom(roomId) {
+  return {
+    type: ACTION_TYPES.LEAVE,
+    roomId
+  };
+}
+const enhancer = internalPlugin;
+function patchLiveblocksStorage(root, oldState, newState, mapping) {
+  for (const key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof newState[key] === "function") {
+      throw mappingToFunctionIsNotAllowed("value");
+    }
+    if (oldState[key] !== newState[key]) {
+      patchLiveObjectKey(root, key, oldState[key], newState[key]);
+    }
+  }
+}
+function 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 patchState(state, updates, mapping) {
+  const partialState = {};
+  for (const key in mapping) {
+    partialState[key] = state[key];
+  }
+  const patched = patchImmutableObject(partialState, updates);
+  const result = {};
+  for (const key in mapping) {
+    result[key] = patched[key];
+  }
+  return result;
+}
+function validateMapping(mapping, mappingType) {
+  if (process.env.NODE_ENV !== "production") {
+    if (mapping == null) {
+      throw missingMapping(mappingType);
+    }
+    if (!isObject(mapping)) {
+      throw mappingShouldBeAnObject(mappingType);
+    }
+  }
+  const result = {};
+  for (const key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof mapping[key] !== "boolean") {
+      throw mappingValueShouldBeABoolean(mappingType, key);
+    }
+    if (mapping[key] === true) {
+      result[key] = true;
+    }
+  }
+  return result;
+}
+
+export { enhancer, enterRoom, leaveRoom };

package/lib/index.d.ts

@@ -0,0 +1,38 @@
+import { Client, User } from "@liveblocks/client";
+import { StoreEnhancer } from "redux";
+export declare type Mapping<T> = Partial<{
+    [Property in keyof T]: boolean;
+}>;
+export declare type LiveblocksState<TState, TPresence = any> = TState & {
+    /**
+     * Liveblocks extra state attached by the middleware
+     */
+    readonly liveblocks: {
+        /**
+         * Other users in the room. Empty no room is currently synced
+         */
+        readonly others: Array<User<TPresence>>;
+        /**
+         * Whether or not the room storage is currently loading
+         */
+        readonly isStorageLoading: boolean;
+        /**
+         * Connection state of the room
+         */
+        readonly connection: "closed" | "authenticating" | "unavailable" | "failed" | "open" | "connecting";
+    };
+};
+export declare function enterRoom(roomId: string, initialState?: any): {
+    type: string;
+    roomId: string;
+    initialState: any;
+};
+export declare function leaveRoom(roomId: string): {
+    type: string;
+    roomId: string;
+};
+export declare const enhancer: <T>(options: {
+    client: Client;
+    storageMapping: Partial<{ [Property in keyof T]: boolean; }>;
+    presenceMapping?: Partial<{ [Property in keyof T]: boolean; }> | undefined;
+}) => StoreEnhancer;

package/lib/index.js

@@ -0,0 +1,377 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var client = require('@liveblocks/client');
+
+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);
+}
+
+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;
+}
+
+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++]
+      };
+    };
+  }
+
+  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 missingMapping(mappingType) {
+  return new Error(ERROR_PREFIX + " " + mappingType + " is missing.");
+}
+function mappingShouldBeAnObject(mappingType) {
+  return new Error(ERROR_PREFIX + " " + mappingType + " should be an object where the values are boolean.");
+}
+function mappingValueShouldBeABoolean(mappingType, key) {
+  return new Error(ERROR_PREFIX + " " + mappingType + "." + key + " value should be a boolean");
+}
+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.");
+}
+
+var ACTION_TYPES = {
+  ENTER: "@@LIVEBLOCKS/ENTER",
+  LEAVE: "@@LIVEBLOCKS/LEAVE",
+  START_LOADING_STORAGE: "@@LIVEBLOCKS/START_LOADING_STORAGE",
+  INIT_STORAGE: "@@LIVEBLOCKS/INIT_STORAGE",
+  PATCH_STORAGE: "@@LIVEBLOCKS/PATCH_STORAGE",
+  UPDATE_CONNECTION: "@@LIVEBLOCKS/UPDATE_CONNECTION",
+  UPDATE_OTHERS: "@@LIVEBLOCKS/UPDATE_OTHERS"
+};
+
+var internalPlugin = function internalPlugin(options) {
+  if (process.env.NODE_ENV !== "production" && options.client == null) {
+    throw missingClient();
+  }
+
+  var client$1 = 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_STORAGE:
+            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$1.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()
+          });
+        }));
+        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];
+                client.patchLiveObjectKey(root, key, undefined, storageInitialState[key]);
+              } else {
+                updates[key] = client.liveNodeToJson(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_STORAGE,
+                state: patchState(store.getState(), updates, mapping)
+              });
+            }
+          }, {
+            isDeep: true
+          }));
+        });
+      }
+
+      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$1.leave(roomId);
+      }
+
+      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);
+        }
+      }
+
+      return _extends({}, store, {
+        dispatch: newDispatch
+      });
+    };
+  };
+};
+
+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 = internalPlugin;
+
+function patchLiveblocksStorage(root, oldState, newState, mapping) {
+  for (var key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof newState[key] === "function") {
+      throw mappingToFunctionIsNotAllowed("value");
+    }
+
+    if (oldState[key] !== newState[key]) {
+      client.patchLiveObjectKey(root, key, oldState[key], newState[key]);
+    }
+  }
+}
+
+function broadcastInitialPresence(room, state, mapping) {
+  for (var key in mapping) {
+    var _room$updatePresence;
+
+    room == null ? void 0 : room.updatePresence((_room$updatePresence = {}, _room$updatePresence[key] = state[key], _room$updatePresence));
+  }
+}
+
+function updatePresence(room, oldState, newState, presenceMapping) {
+  for (var key in presenceMapping) {
+    if (typeof newState[key] === "function") {
+      throw mappingToFunctionIsNotAllowed("value");
+    }
+
+    if (oldState[key] !== newState[key]) {
+      var _room$updatePresence2;
+
+      room.updatePresence((_room$updatePresence2 = {}, _room$updatePresence2[key] = newState[key], _room$updatePresence2));
+    }
+  }
+}
+
+function isObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+
+function validateNoDuplicateKeys(storageMapping, presenceMapping) {
+  for (var key in storageMapping) {
+    if (presenceMapping[key] !== undefined) {
+      throw mappingShouldNotHaveTheSameKeys(key);
+    }
+  }
+}
+
+function patchState(state, updates, mapping) {
+  var partialState = {};
+
+  for (var key in mapping) {
+    partialState[key] = state[key];
+  }
+
+  var patched = client.patchImmutableObject(partialState, updates);
+  var result = {};
+
+  for (var _key in mapping) {
+    result[_key] = patched[_key];
+  }
+
+  return result;
+}
+
+function validateMapping(mapping, mappingType) {
+  if (process.env.NODE_ENV !== "production") {
+    if (mapping == null) {
+      throw missingMapping(mappingType);
+    }
+
+    if (!isObject(mapping)) {
+      throw mappingShouldBeAnObject(mappingType);
+    }
+  }
+
+  var result = {};
+
+  for (var key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof mapping[key] !== "boolean") {
+      throw mappingValueShouldBeABoolean(mappingType, key);
+    }
+
+    if (mapping[key] === true) {
+      result[key] = true;
+    }
+  }
+
+  return result;
+}
+
+exports.enhancer = enhancer;
+exports.enterRoom = enterRoom;
+exports.leaveRoom = leaveRoom;

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@liveblocks/redux",
+  "version": "0.15.0-alpha.3",
+  "sideEffects": false,
+  "description": "",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib/"
+  ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "module": "./lib/esm/index.js",
+      "import": "./lib/esm/index.mjs",
+      "default": "./lib/index.js"
+    }
+  },
+  "keywords": [
+    "redux",
+    "react",
+    "liveblocks",
+    "multiplayer",
+    "live-cursors",
+    "collaborative"
+  ],
+  "scripts": {
+    "build": "rollup -c",
+    "test": "jest --watch",
+    "dtslint": "dtslint --localTs node_modules/typescript/lib --expectOnly types"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/liveblocks/liveblocks.git",
+    "directory": "packages/liveblocks-redux"
+  },
+  "peerDependencies": {
+    "@liveblocks/client": "0.15.0-alpha.3",
+    "redux": "^4"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.16.7",
+    "@babel/plugin-transform-typescript": "^7.16.8",
+    "@babel/preset-env": "^7.16.8",
+    "@definitelytyped/dtslint": "^0.0.103",
+    "@reduxjs/toolkit": "^1.7.2",
+    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-node-resolve": "^13.1.3",
+    "@rollup/plugin-typescript": "^8.3.0",
+    "@testing-library/jest-dom": "^5.16.1",
+    "@testing-library/react": "^12.1.2",
+    "@testing-library/react-hooks": "^7.0.2",
+    "@types/jest": "^27.4.1",
+    "esbuild": "0.14.11",
+    "jest": "^27.4.7",
+    "msw": "^0.36.4",
+    "redux": "^4.1.2",
+    "rollup": "^2.64.0",
+    "rollup-plugin-esbuild": "^4.8.2",
+    "whatwg-fetch": "^3.6.2"
+  }
+}