@liveblocks/zustand 1.1.0 → 1.1.1-dual2

package/dist/index.d.mts

@@ -0,0 +1,84 @@
+import { JsonObject, LsonObject, BaseUserMeta, Json, Room, User, Status, Client } from '@liveblocks/client';
+import { LegacyConnectionStatus } from '@liveblocks/core';
+import { StoreMutatorIdentifier, StateCreator } from 'zustand';
+
+declare type LiveblocksContext<TPresence extends JsonObject, TStorage extends LsonObject, TUserMeta extends BaseUserMeta, TRoomEvent extends Json> = {
+    /**
+     * Enters a room and starts sync it with zustand state
+     * @param roomId The id of the room
+     */
+    readonly enterRoom: (roomId: string) => void;
+    /**
+     * Leaves a room and stops sync it with zustand state.
+     * @param roomId The id of the room
+     */
+    readonly leaveRoom: (roomId: string) => void;
+    /**
+     * The room currently synced to your zustand state.
+     */
+    readonly room: Room<TPresence, TStorage, TUserMeta, TRoomEvent> | null;
+    /**
+     * 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 Renamed to WithLiveblocks<...>
+ */
+declare type LiveblocksState<TState, TPresence extends JsonObject = JsonObject, TStorage extends LsonObject = LsonObject, TUserMeta extends BaseUserMeta = BaseUserMeta, TRoomEvent extends Json = Json> = WithLiveblocks<TState, TPresence, TStorage, TUserMeta, TRoomEvent>;
+/**
+ * Adds the `liveblocks` property to your custom Zustand state.
+ */
+declare type WithLiveblocks<TState, TPresence extends JsonObject = JsonObject, TStorage extends LsonObject = LsonObject, TUserMeta extends BaseUserMeta = BaseUserMeta, TRoomEvent extends Json = Json> = TState & {
+    readonly liveblocks: LiveblocksContext<TPresence, TStorage, TUserMeta, TRoomEvent>;
+};
+declare type Mapping<T> = {
+    [K in keyof T]?: boolean;
+};
+declare type Options<T> = {
+    /**
+     * Liveblocks client created by @liveblocks/client createClient
+     */
+    client: Client;
+    /**
+     * Mapping used to synchronize a part of your zustand state with one Liveblocks Room storage.
+     */
+    storageMapping?: Mapping<T>;
+    /**
+     * Mapping used to synchronize a part of your zustand state with one Liveblocks Room presence.
+     */
+    presenceMapping?: Mapping<T>;
+};
+declare type OuterLiveblocksMiddleware = <TState, Mps extends [StoreMutatorIdentifier, unknown][] = [], Mcs extends [StoreMutatorIdentifier, unknown][] = []>(config: StateCreator<TState, Mps, Mcs, Omit<TState, "liveblocks">>, options: Options<Omit<TState, "liveblocks">>) => StateCreator<TState, Mps, Mcs, TState>;
+declare const liveblocks: OuterLiveblocksMiddleware;
+/**
+ * @deprecated Renamed to `liveblocks`.
+ */
+declare const middleware: OuterLiveblocksMiddleware;
+
+export { LiveblocksContext, LiveblocksState, Mapping, WithLiveblocks, liveblocks, middleware };

package/dist/index.mjs

@@ -0,0 +1,275 @@
+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));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/index.ts
+import {
+  errorIf,
+  legacy_patchImmutableObject,
+  lsonToJson,
+  patchLiveObjectKey
+} from "@liveblocks/core";
+var ERROR_PREFIX = "Invalid @liveblocks/zustand middleware config.";
+function mappingToFunctionIsNotAllowed(key) {
+  return new Error(
+    `${ERROR_PREFIX} mapping.${key} is invalid. Mapping to a function is not allowed.`
+  );
+}
+var middlewareImpl = (config, options) => {
+  const { client, presenceMapping, storageMapping } = validateOptions(options);
+  return (set, get, api) => {
+    let maybeRoom = null;
+    let isPatching = false;
+    let storageRoot = null;
+    let unsubscribeCallbacks = [];
+    function enterRoom(roomId) {
+      if (storageRoot) {
+        return;
+      }
+      const initialPresence = selectFields(
+        get(),
+        presenceMapping
+      );
+      const room = client.enter(roomId, {
+        initialPresence
+      });
+      maybeRoom = room;
+      updateLiveblocksContext(set, { isStorageLoading: true, room });
+      unsubscribeCallbacks.push(
+        room.events.others.subscribe(({ others }) => {
+          updateLiveblocksContext(set, { others });
+        })
+      );
+      unsubscribeCallbacks.push(
+        room.events.connection.subscribe(() => {
+          updateLiveblocksContext(set, {
+            connection: room.getConnectionState(),
+            status: room.getStatus()
+          });
+        })
+      );
+      unsubscribeCallbacks.push(
+        room.events.me.subscribe(() => {
+          if (isPatching === false) {
+            set(
+              selectFields(
+                room.getPresence(),
+                presenceMapping
+              )
+            );
+          }
+        })
+      );
+      void room.getStorage().then(({ root }) => {
+        const updates = {};
+        room.batch(() => {
+          for (const key in storageMapping) {
+            const liveblocksStatePart = root.get(key);
+            if (liveblocksStatePart === void 0) {
+              updates[key] = get()[key];
+              patchLiveObjectKey(root, key, void 0, get()[key]);
+            } else {
+              updates[key] = lsonToJson(
+                liveblocksStatePart
+              );
+            }
+          }
+        });
+        set(updates);
+        storageRoot = root;
+        unsubscribeCallbacks.push(
+          room.subscribe(
+            root,
+            (updates2) => {
+              if (isPatching === false) {
+                set(patchState(get(), updates2, storageMapping));
+              }
+            },
+            { isDeep: true }
+          )
+        );
+        updateLiveblocksContext(set, {
+          isStorageLoading: false
+        });
+      });
+    }
+    function leaveRoom(roomId) {
+      for (const unsubscribe of unsubscribeCallbacks) {
+        unsubscribe();
+      }
+      storageRoot = null;
+      maybeRoom = null;
+      isPatching = false;
+      unsubscribeCallbacks = [];
+      client.leave(roomId);
+      updateLiveblocksContext(set, {
+        others: [],
+        connection: "closed",
+        isStorageLoading: false,
+        room: null
+      });
+    }
+    const store = config(
+      (args) => {
+        const _a = get(), { liveblocks: _ } = _a, oldState = __objRest(_a, ["liveblocks"]);
+        set(args);
+        const _b = get(), { liveblocks: __ } = _b, newState = __objRest(_b, ["liveblocks"]);
+        if (maybeRoom) {
+          const room = maybeRoom;
+          isPatching = true;
+          updatePresence(room, oldState, newState, presenceMapping);
+          room.batch(() => {
+            if (storageRoot) {
+              patchLiveblocksStorage(
+                storageRoot,
+                oldState,
+                newState,
+                storageMapping
+              );
+            }
+          });
+          isPatching = false;
+        }
+      },
+      get,
+      api
+    );
+    return __spreadProps(__spreadValues({}, store), {
+      liveblocks: {
+        enterRoom,
+        leaveRoom,
+        room: null,
+        others: [],
+        connection: "closed",
+        isStorageLoading: false
+      }
+    });
+  };
+};
+var liveblocks = middlewareImpl;
+var middleware = liveblocks;
+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 selectFields(presence, mapping) {
+  const partialState = {};
+  for (const key in mapping) {
+    partialState[key] = presence[key];
+  }
+  return partialState;
+}
+function updateLiveblocksContext(set, partial) {
+  set((state) => ({ liveblocks: __spreadValues(__spreadValues({}, state.liveblocks), partial) }));
+}
+function updatePresence(room, oldState, newState, presenceMapping) {
+  for (const key in presenceMapping) {
+    if (typeof newState[key] === "function") {
+      throw mappingToFunctionIsNotAllowed(key);
+    }
+    if (oldState[key] !== newState[key]) {
+      const val = newState == null ? void 0 : newState[key];
+      const patch = {};
+      patch[key] = val;
+      room.updatePresence(patch);
+    }
+  }
+}
+function patchLiveblocksStorage(root, oldState, newState, mapping) {
+  for (const key in mapping) {
+    if (process.env.NODE_ENV !== "production" && typeof newState[key] === "function") {
+      throw mappingToFunctionIsNotAllowed(key);
+    }
+    if (oldState[key] !== newState[key]) {
+      const oldVal = oldState[key];
+      const newVal = newState[key];
+      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 new Error(
+        `${ERROR_PREFIX} "${key}" is mapped on both presenceMapping and storageMapping. A key shouldn't exist on both mapping.`
+      );
+    }
+  }
+}
+function validateMapping(mapping, mappingType) {
+  errorIf(
+    !isObject(mapping),
+    `${ERROR_PREFIX} ${mappingType} should be an object where the values are boolean.`
+  );
+  const result = {};
+  for (const key in mapping) {
+    errorIf(
+      typeof mapping[key] !== "boolean",
+      `${ERROR_PREFIX} ${mappingType}.${key} value should be a boolean`
+    );
+    if (mapping[key] === true) {
+      result[key] = true;
+    }
+  }
+  return result;
+}
+function validateOptions(options) {
+  var _a, _b;
+  const client = options.client;
+  errorIf(!client, `${ERROR_PREFIX} client is missing`);
+  const storageMapping = validateMapping(
+    (_a = options.storageMapping) != null ? _a : {},
+    "storageMapping"
+  );
+  const presenceMapping = validateMapping(
+    (_b = options.presenceMapping) != null ? _b : {},
+    "presenceMapping"
+  );
+  if (process.env.NODE_ENV !== "production") {
+    validateNoDuplicateKeys(storageMapping, presenceMapping);
+  }
+  return { client, storageMapping, presenceMapping };
+}
+export {
+  liveblocks,
+  middleware
+};

package/package.json

@@ -1,10 +1,23 @@
 {
   "name": "@liveblocks/zustand",
-  "version": "1.1.0",
+  "version": "1.1.1-dual2",
   "description": "A middleware to integrate Liveblocks into Zustand 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,15 +25,16 @@
   "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:types": "tsd",
     "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": {
     "zustand": "^4.1.3"