npm - @liveblocks/redux - Versions diffs - 0.16.4-beta1 → 0.16.5 - Mend

@liveblocks/redux 0.16.4-beta1 → 0.16.5

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 (6) hide show

package/index.mjs ADDED Viewed

@@ -0,0 +1,179 @@
+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 };

package/package.json CHANGED Viewed

@@ -1,21 +1,13 @@
 {
   "name": "@liveblocks/redux",
-  "version": "0.16.4-beta1",
-  "sideEffects": false,
+  "version": "0.16.5",
   "description": "A store enhancer to integrate Liveblocks into Redux stores.",
   "main": "./index.js",
+  "module": "./index.mjs",
   "types": "./index.d.ts",
   "files": [
     "**"
   ],
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "module": "./esm/index.js",
-      "import": "./esm/index.mjs",
-      "default": "./index.js"
-    }
-  },
   "keywords": [
     "redux",
     "react",
@@ -26,6 +18,7 @@
   ],
   "scripts": {
     "build": "rollup -c && cp ./package.json ./README.md ./lib",
+    "format": "eslint --fix src/ test/ && prettier --write src/ test/",
     "lint": "eslint src/ test/",
     "test": "jest --watch",
     "test-ci": "jest",
@@ -38,17 +31,18 @@
     "directory": "packages/liveblocks-redux"
   },
   "peerDependencies": {
-    "@liveblocks/client": "0.16.4-beta1",
+    "@liveblocks/client": "0.16.5",
     "redux": "^4"
   },
   "devDependencies": {
-    "@babel/core": "^7.16.7",
-    "@babel/plugin-transform-typescript": "^7.16.8",
-    "@babel/preset-env": "^7.16.8",
+    "@babel/core": "^7.17.10",
+    "@babel/preset-env": "^7.17.10",
+    "@babel/preset-typescript": "^7.16.7",
     "@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-replace": "^4.0.0",
     "@rollup/plugin-typescript": "^8.3.0",
     "@testing-library/jest-dom": "^5.16.1",
     "@testing-library/react": "^12.1.2",
@@ -56,13 +50,17 @@
     "@types/jest": "^27.4.1",
     "@typescript-eslint/eslint-plugin": "^5.18.0",
     "@typescript-eslint/parser": "^5.18.0",
-    "esbuild": "0.14.11",
     "eslint": "^8.12.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-simple-import-sort": "^7.0.0",
     "jest": "^27.4.7",
     "msw": "^0.36.4",
     "redux": "^4.1.2",
     "rollup": "^2.64.0",
-    "rollup-plugin-esbuild": "^4.8.2",
+    "rollup-plugin-command": "^1.1.3",
+    "rollup-plugin-dts": "^4.2.1",
+    "rollup-plugin-terser": "^7.0.2",
     "whatwg-fetch": "^3.6.2"
-  }
+  },
+  "sideEffects": false
 }

package/esm/index.js DELETED Viewed

@@ -1,291 +0,0 @@
-import { internals } from '@liveblocks/client';
-const 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.`);
-}
-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 { patchImmutableObject, patchLiveObjectKey, lsonToJson } = internals;
-const 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"
-};
-const 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
-    });
-  };
-};
-const actions = {
-  enterRoom,
-  leaveRoom
-};
-function enterRoom(roomId, initialState) {
-  return {
-    type: ACTION_TYPES.ENTER,
-    roomId,
-    initialState
-  };
-}
-function leaveRoom(roomId) {
-  return {
-    type: ACTION_TYPES.LEAVE,
-    roomId
-  };
-}
-const 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 };