@liveblocks/zustand 0.17.10-debug2 → 0.17.11-debug2

package/index.mjs

@@ -1 +1,285 @@
-export { middleware } from "./index.js";
+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 {
+  lsonToJson,
+  patchImmutableObject,
+  patchLiveObjectKey
+} from "@liveblocks/client/internal";
+
+// src/errors.ts
+var ERROR_PREFIX = "Invalid @liveblocks/zustand 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.`
+  );
+}
+
+// src/index.ts
+function isJson(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) && value.every(isJson) || typeof value === "object" && Object.values(value).every(isJson);
+}
+function middleware(config, options) {
+  if (process.env.NODE_ENV !== "production" && options.client == null) {
+    throw missingClient();
+  }
+  const client = options.client;
+  const storageMapping = validateMapping(
+    options.storageMapping || {},
+    "storageMapping"
+  );
+  const presenceMapping = validateMapping(
+    options.presenceMapping || {},
+    "presenceMapping"
+  );
+  if (process.env.NODE_ENV !== "production") {
+    validateNoDuplicateKeys(storageMapping, presenceMapping);
+  }
+  return (set, get, api) => {
+    const typedSet = set;
+    let room = null;
+    let isPatching = false;
+    let storageRoot = null;
+    let unsubscribeCallbacks = [];
+    const store = config(
+      (args) => {
+        const oldState = get();
+        set(args);
+        const newState = get();
+        if (room) {
+          isPatching = true;
+          updatePresence(
+            room,
+            oldState,
+            newState,
+            presenceMapping
+          );
+          room.batch(() => {
+            if (storageRoot) {
+              patchLiveblocksStorage(
+                storageRoot,
+                oldState,
+                newState,
+                storageMapping
+              );
+            }
+          });
+          isPatching = false;
+        }
+      },
+      get,
+      api
+    );
+    function enterRoom(roomId, initialState) {
+      if (storageRoot) {
+        return;
+      }
+      room = client.enter(roomId);
+      updateZustandLiveblocksState(set, {
+        isStorageLoading: true,
+        room
+      });
+      const state = get();
+      broadcastInitialPresence(room, state, presenceMapping);
+      unsubscribeCallbacks.push(
+        room.subscribe("others", (others) => {
+          updateZustandLiveblocksState(set, { others: others.toArray() });
+        })
+      );
+      unsubscribeCallbacks.push(
+        room.subscribe("connection", () => {
+          updateZustandLiveblocksState(set, {
+            connection: room.getConnectionState()
+          });
+        })
+      );
+      unsubscribeCallbacks.push(
+        room.subscribe("my-presence", () => {
+          if (isPatching === false) {
+            set(
+              patchPresenceState(room.getPresence(), presenceMapping)
+            );
+          }
+        })
+      );
+      room.getStorage().then(({ root }) => {
+        const updates = {};
+        room.batch(() => {
+          for (const key in storageMapping) {
+            const liveblocksStatePart = root.get(key);
+            if (liveblocksStatePart == null) {
+              updates[key] = initialState[key];
+              patchLiveObjectKey(root, key, void 0, initialState[key]);
+            } else {
+              updates[key] = lsonToJson(liveblocksStatePart);
+            }
+          }
+        });
+        typedSet(updates);
+        storageRoot = root;
+        unsubscribeCallbacks.push(
+          room.subscribe(
+            root,
+            (updates2) => {
+              if (isPatching === false) {
+                set(patchState(get(), updates2, storageMapping));
+              }
+            },
+            { isDeep: true }
+          )
+        );
+        updateZustandLiveblocksState(set, { isStorageLoading: false });
+      });
+    }
+    function leaveRoom(roomId) {
+      for (const unsubscribe of unsubscribeCallbacks) {
+        unsubscribe();
+      }
+      storageRoot = null;
+      room = null;
+      isPatching = false;
+      unsubscribeCallbacks = [];
+      client.leave(roomId);
+      updateZustandLiveblocksState(set, {
+        others: [],
+        connection: "closed",
+        isStorageLoading: false,
+        room: null
+      });
+    }
+    return __spreadProps(__spreadValues({}, store), {
+      liveblocks: {
+        enterRoom,
+        leaveRoom,
+        room: null,
+        others: [],
+        connection: "closed",
+        isStorageLoading: false
+      }
+    });
+  };
+}
+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 patchPresenceState(presence, mapping) {
+  const partialState = {};
+  for (const key in mapping) {
+    partialState[key] = presence[key];
+  }
+  return partialState;
+}
+function updateZustandLiveblocksState(set, partial) {
+  set((state) => ({ liveblocks: __spreadValues(__spreadValues({}, state.liveblocks), partial) }));
+}
+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]) {
+      const val = newState[key];
+      room.updatePresence({ [key]: val });
+    }
+  }
+}
+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];
+      if ((oldVal === void 0 || isJson(oldVal)) && (newVal === void 0 || isJson(newVal))) {
+        patchLiveObjectKey(root, key, oldVal, newVal);
+      }
+    }
+  }
+}
+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 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 {
+  middleware
+};

package/package.json

@@ -1,10 +1,17 @@
 {
   "name": "@liveblocks/zustand",
-  "version": "0.17.10-debug2",
+  "version": "0.17.11-debug2",
   "description": "A middleware to integrate Liveblocks into Zustand stores.",
   "main": "./index.js",
   "module": "./index.mjs",
   "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs",
+      "types": "./index.d.ts"
+    }
+  },
   "keywords": [
     "zustand",
     "react",
@@ -20,7 +27,7 @@
     "directory": "packages/liveblocks-zustand"
   },
   "peerDependencies": {
-    "@liveblocks/client": "0.17.10-debug2",
+    "@liveblocks/client": "0.17.11-debug2",
     "zustand": "^3"
   },
   "sideEffects": false