@liveblocks/zustand 0.17.11-debug2 → 0.18.0-beta1

package/.built-by-link-script

@@ -1 +1 @@
-cee9f7e7c838f96a08436ef427e52a81b3c66977
+316aa44b7e15c044dbf114b7979e2440dee03982

package/index.d.ts

@@ -25,7 +25,7 @@ declare type LiveblocksState<TState extends ZustandState, TPresence extends Json
         /**
          * Other users in the room. Empty no room is currently synced
          */
-        readonly others: Array<User<TPresence, TUserMeta>>;
+        readonly others: readonly User<TPresence, TUserMeta>[];
         /**
          * Whether or not the room storage is currently loading
          */

package/index.js

@@ -113,7 +113,7 @@ function middleware(config, options) {
       if (storageRoot) {
         return;
       }
-      room = client.enter(roomId);
+      room = client.enter(roomId, { initialPresence: {} });
       updateZustandLiveblocksState(set, {
         isStorageLoading: true,
         room
@@ -121,19 +121,19 @@ function middleware(config, options) {
       const state = get();
       broadcastInitialPresence(room, state, presenceMapping);
       unsubscribeCallbacks.push(
-        room.subscribe("others", (others) => {
+        room.events.others.subscribe(({ others }) => {
           updateZustandLiveblocksState(set, { others: others.toArray() });
         })
       );
       unsubscribeCallbacks.push(
-        room.subscribe("connection", () => {
+        room.events.connection.subscribe(() => {
           updateZustandLiveblocksState(set, {
             connection: room.getConnectionState()
           });
         })
       );
       unsubscribeCallbacks.push(
-        room.subscribe("my-presence", () => {
+        room.events.me.subscribe(() => {
           if (isPatching === false) {
             set(
               patchPresenceState(room.getPresence(), presenceMapping)
@@ -203,7 +203,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,285 +1,4 @@
-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/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
-};
+export default mod;
+export const middleware = mod.middleware;

package/package.json

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