@liveblocks/redux 0.17.11-debug2 → 0.18.0-beta1

package/.built-by-link-script

@@ -1 +1 @@
-2d963544ab794518e83521361a7388453b6eebc9
+6e3ffd33bbe9ad997044eb981372aef0633fb131

package/index.js

@@ -147,10 +147,10 @@ var internalEnhancer = (options) => {
       if (storageRoot) {
         return;
       }
-      room = client.enter(roomId);
+      room = client.enter(roomId, { initialPresence: {} });
       broadcastInitialPresence(room, reduxState, presenceMapping);
       unsubscribeCallbacks.push(
-        room.subscribe("connection", () => {
+        room.events.connection.subscribe(() => {
           store.dispatch({
             type: ACTION_TYPES.UPDATE_CONNECTION,
             connection: room.getConnectionState()
@@ -158,7 +158,7 @@ var internalEnhancer = (options) => {
         })
       );
       unsubscribeCallbacks.push(
-        room.subscribe("others", (others) => {
+        room.events.others.subscribe(({ others }) => {
           store.dispatch({
             type: ACTION_TYPES.UPDATE_OTHERS,
             others: others.toArray()
@@ -166,7 +166,7 @@ var internalEnhancer = (options) => {
         })
       );
       unsubscribeCallbacks.push(
-        room.subscribe("my-presence", () => {
+        room.events.me.subscribe(() => {
           if (isPatching === false) {
             store.dispatch({
               type: ACTION_TYPES.PATCH_REDUX_STATE,
@@ -313,7 +313,7 @@ function patchState(state, updates, mapping) {
   for (const key in mapping) {
     partialState[key] = state[key];
   }
-  const patched = _internal.patchImmutableObject.call(void 0, partialState, updates);
+  const patched = _internal.legacy_patchImmutableObject.call(void 0, partialState, updates);
   const result = {};
   for (const key in mapping) {
     result[key] = patched[key];

package/index.mjs

@@ -1,343 +1,5 @@
-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));
+import mod from "./index.js";
 
-// src/index.ts
-import {
-  lsonToJson,
-  patchImmutableObject,
-  patchLiveObjectKey
-} from "@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 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.`
-  );
-}
-
-// 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];
-              patchLiveObjectKey(
-                root,
-                key,
-                void 0,
-                storageInitialState[key]
-              );
-            } else {
-              updates[key] = lsonToJson(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]) {
-      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 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);
-  const result = {};
-  for (const 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);
-    }
-  }
-  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 {
-  actions,
-  enhancer
-};
+export default mod;
+export const actions = mod.actions;
+export const enhancer = mod.enhancer;

package/package.json

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