@liveblocks/redux 1.1.0 → 1.1.1-dual2

package/dist/index.d.mts

@@ -0,0 +1,90 @@
+import { JsonObject, BaseUserMeta, Client, User, Status } from '@liveblocks/client';
+import { LegacyConnectionStatus } from '@liveblocks/core';
+import { StoreEnhancer } from 'redux';
+
+declare type Mapping<T> = {
+    [K in keyof T]?: boolean;
+};
+declare type LiveblocksContext<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = {
+    /**
+     * Other users in the room. Empty no room is currently synced
+     */
+    readonly others: readonly User<TPresence, TUserMeta>[];
+    /**
+     * Whether or not the room storage is currently loading
+     */
+    readonly isStorageLoading: boolean;
+    /**
+     * Legacy connection status of the room.
+     *
+     * @deprecated This API will be removed in a future version of Liveblocks.
+     * Prefer using the newer `.status` property.
+     *
+     * We recommend making the following changes if you use these APIs:
+     *
+     *     OLD STATUSES         NEW STATUSES
+     *     closed          -->  initial
+     *     authenticating  -->  connecting
+     *     connecting      -->  connecting
+     *     open            -->  connected
+     *     unavailable     -->  reconnecting
+     *     failed          -->  disconnected
+     */
+    readonly connection: LegacyConnectionStatus;
+    /**
+     * Connection status of the room.
+     */
+    readonly status: Status;
+};
+/**
+ * @deprecated Please rename to WithLiveblocks<...>
+ */
+declare type LiveblocksState<TState, TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = WithLiveblocks<TState, TPresence, TUserMeta>;
+/**
+ * Adds the `liveblocks` property to your custom Redux state.
+ */
+declare type WithLiveblocks<TState, TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = TState & {
+    readonly liveblocks: LiveblocksContext<TPresence, TUserMeta>;
+};
+/**
+ * Actions used to interact with Liveblocks
+ */
+declare const actions: {
+    /**
+     * Enters a room and starts sync it with Redux state
+     * @param roomId The id of the room
+     */
+    enterRoom: typeof enterRoom;
+    /**
+     * Leaves a room and stops sync it with Redux state.
+     * @param roomId The id of the room
+     */
+    leaveRoom: typeof leaveRoom;
+};
+declare function enterRoom(roomId: string): {
+    type: string;
+    roomId: string;
+};
+declare function leaveRoom(roomId: string): {
+    type: string;
+    roomId: string;
+};
+/**
+ * Redux store enhancer that will make the `liveblocks` key available on your
+ * Redux store.
+ */
+declare const liveblocksEnhancer: <TState>(options: {
+    client: Client;
+    storageMapping?: Mapping<TState> | undefined;
+    presenceMapping?: Mapping<TState> | undefined;
+}) => StoreEnhancer;
+/**
+ * @deprecated Renamed to `liveblocksEnhancer`.
+ */
+declare const enhancer: <TState>(options: {
+    client: Client;
+    storageMapping?: Mapping<TState> | undefined;
+    presenceMapping?: Mapping<TState> | undefined;
+}) => StoreEnhancer;
+
+export { LiveblocksState, Mapping, WithLiveblocks, actions, enhancer, liveblocksEnhancer };

package/dist/index.mjs

@@ -0,0 +1,349 @@
+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
+import {
+  legacy_patchImmutableObject,
+  lsonToJson,
+  patchLiveObjectKey
+} from "@liveblocks/core";
+
+// 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) => {
+    return (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,
+                status: action.status
+              })
+            });
+          }
+          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",
+                  status: "initial"
+                }
+              });
+            }
+            return newState;
+          }
+        }
+      };
+      const store = createStore(newReducer, initialState, enhancer2);
+      function enterRoom2(roomId) {
+        if (storageRoot) {
+          return;
+        }
+        const initialPresence = selectFields(
+          store.getState(),
+          presenceMapping
+        );
+        room = client.enter(roomId, { initialPresence });
+        unsubscribeCallbacks.push(
+          room.events.connection.subscribe(() => {
+            store.dispatch({
+              type: ACTION_TYPES.UPDATE_CONNECTION,
+              connection: room.getConnectionState(),
+              status: room.getStatus()
+            });
+          })
+        );
+        unsubscribeCallbacks.push(
+          room.events.others.subscribe(({ others }) => {
+            store.dispatch({
+              type: ACTION_TYPES.UPDATE_OTHERS,
+              others
+            });
+          })
+        );
+        unsubscribeCallbacks.push(
+          room.events.me.subscribe(() => {
+            if (isPatching === false) {
+              store.dispatch({
+                type: ACTION_TYPES.PATCH_REDUX_STATE,
+                state: selectFields(room.getPresence(), presenceMapping)
+              });
+            }
+          })
+        );
+        store.dispatch({
+          type: ACTION_TYPES.START_LOADING_STORAGE
+        });
+        void room.getStorage().then(({ root }) => {
+          const updates = {};
+          room.batch(() => {
+            for (const key in mapping) {
+              const liveblocksStatePart = root.get(key);
+              if (liveblocksStatePart == null) {
+                updates[key] = store.getState()[key];
+                patchLiveObjectKey(root, key, void 0, store.getState()[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) {
+        if (action.type === ACTION_TYPES.ENTER) {
+          enterRoom2(action.roomId);
+        } else if (action.type === ACTION_TYPES.LEAVE) {
+          leaveRoom2(action.roomId);
+        } else {
+          store.dispatch(action);
+        }
+      }
+      return __spreadProps(__spreadValues({}, store), {
+        dispatch: newDispatch
+      });
+    };
+  };
+};
+var actions = {
+  /**
+   * Enters a room and starts sync it with Redux state
+   * @param roomId The id of the room
+   */
+  enterRoom,
+  /**
+   * Leaves a room and stops sync it with Redux state.
+   * @param roomId The id of the room
+   */
+  leaveRoom
+};
+function enterRoom(roomId) {
+  return {
+    type: ACTION_TYPES.ENTER,
+    roomId
+  };
+}
+function leaveRoom(roomId) {
+  return {
+    type: ACTION_TYPES.LEAVE,
+    roomId
+  };
+}
+var liveblocksEnhancer = internalEnhancer;
+var enhancer = liveblocksEnhancer;
+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]) {
+      const oldVal = oldState[key];
+      const newVal = newState[key];
+      patchLiveObjectKey(root, key, oldVal, newVal);
+    }
+  }
+}
+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 selectFields(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 = legacy_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,
+  liveblocksEnhancer
+};

package/package.json

@@ -1,10 +1,23 @@
 {
   "name": "@liveblocks/redux",
-  "version": "1.1.0",
+  "version": "1.1.1-dual2",
   "description": "A store enhancer to integrate Liveblocks into Redux stores. Liveblocks is the all-in-one toolkit to build collaborative products like Figma, Notion, and more.",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "module": "./dist/index.mjs",
+        "default": "./dist/index.js"
+      }
+    }
+  },
   "files": [
     "dist/**",
     "README.md"
@@ -12,14 +25,15 @@
   "scripts": {
     "dev": "tsup --watch",
     "build": "tsup",
-    "format": "eslint --fix src/; prettier --write src/",
+    "format": "(eslint --fix src/ || true) && prettier --write src/",
     "lint": "eslint src/",
+    "lint:package": "publint --strict && attw --pack",
     "test": "jest --silent --verbose --color=always",
     "test:watch": "jest --silent --verbose --color=always --watch"
   },
   "dependencies": {
-    "@liveblocks/client": "1.1.0",
-    "@liveblocks/core": "1.1.0"
+    "@liveblocks/client": "1.1.1-dual2",
+    "@liveblocks/core": "1.1.1-dual2"
   },
   "peerDependencies": {
     "redux": "^4"