@liveblocks/core 1.3.5 → 1.4.0-test1

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "1.3.5";
+var PKG_VERSION = "1.4.0-test1";
 var PKG_FORMAT = "cjs";
 
 // src/dupe-detection.ts
@@ -1542,9 +1542,18 @@ function startSyncStream(room) {
     room.events.storage.subscribe(() => partialSyncStorage(room)),
     // Any time "me" or "others" updates, send the new values accordingly
     room.events.self.subscribe(() => partialSyncMe(room)),
-    room.events.others.subscribe(() => partialSyncOthers(room))
+    room.events.others.subscribe(() => partialSyncOthers(room)),
+    // Any time ydoc is updated, forward the update
+    room.events.ydoc.subscribe((update) => syncYdocUpdate(room, update))
   ]);
 }
+function syncYdocUpdate(room, update) {
+  sendToPanel({
+    msg: "room::sync::ydoc",
+    roomId: room.id,
+    update
+  });
+}
 function partialSyncConnection(room) {
   sendToPanel({
     msg: "room::sync::partial",
@@ -1586,6 +1595,7 @@ function fullSync(room) {
   const root = room.getStorageSnapshot();
   const me = room.__internal.getSelf_forDevTools();
   const others = room.__internal.getOthers_forDevTools();
+  room.fetchYDoc("");
   sendToPanel({
     msg: "room::sync::full",
     roomId: room.id,
@@ -1821,13 +1831,47 @@ function createCommentsApi(roomId, getAuthValue, { serverEndpoint }) {
       }
     );
   }
+  function addReaction({
+    threadId,
+    commentId,
+    emoji
+  }) {
+    return fetchJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}/reactions`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ emoji })
+      }
+    );
+  }
+  function removeReaction({
+    threadId,
+    commentId,
+    emoji
+  }) {
+    return fetchJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}/reactions/${encodeURIComponent(emoji)}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
   return {
     getThreads,
     createThread,
     editThreadMetadata,
     createComment,
     editComment,
-    deleteComment
+    deleteComment,
+    addReaction,
+    removeReaction
   };
 }
 
@@ -4596,7 +4640,7 @@ var DerivedRef = class extends ImmutableRef {
 };
 
 // src/room.ts
-var MAX_MESSAGE_SIZE = 1024 * 1024 - 128;
+var MAX_SOCKET_MESSAGE_SIZE = 1024 * 1024 - 1024;
 function makeIdFactory(connectionId) {
   let count = 0;
   return () => `${connectionId}:${count++}`;
@@ -4811,17 +4855,35 @@ function createRoom(options, config) {
     ydoc: makeEventSource(),
     comments: makeEventSource()
   };
-  function sendMessages(messageOrMessages) {
-    const message = JSON.stringify(messageOrMessages);
-    if (config.unstable_fallbackToHTTP) {
-      const size = new TextEncoder().encode(message).length;
-      if (size > MAX_MESSAGE_SIZE && // TODO: support public api key auth in REST API
-      _optionalChain([managedSocket, 'access', _115 => _115.authValue, 'optionalAccess', _116 => _116.type]) === "secret" && config.httpSendEndpoint) {
+  async function httpSend(authTokenOrPublicApiKey, roomId, nonce, messages) {
+    const baseUrl = new URL(config.liveblocksServer);
+    baseUrl.protocol = "https";
+    const url = new URL(
+      `/v2/c/rooms/${encodeURIComponent(roomId)}/send-message`,
+      baseUrl
+    );
+    const fetcher = _optionalChain([config, 'access', _115 => _115.polyfills, 'optionalAccess', _116 => _116.fetch]) || /* istanbul ignore next */
+    fetch;
+    return fetcher(url.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${authTokenOrPublicApiKey}`
+      },
+      body: JSON.stringify({ nonce, messages })
+    });
+  }
+  function sendMessages(messages) {
+    const serializedPayload = JSON.stringify(messages);
+    const nonce = _optionalChain([context, 'access', _117 => _117.dynamicSessionInfo, 'access', _118 => _118.current, 'optionalAccess', _119 => _119.nonce]);
+    if (config.unstable_fallbackToHTTP && managedSocket.authValue && nonce) {
+      const size = new TextEncoder().encode(serializedPayload).length;
+      if (size > MAX_SOCKET_MESSAGE_SIZE) {
         void httpSend(
-          message,
-          managedSocket.authValue.token.raw,
-          config.httpSendEndpoint,
-          _optionalChain([config, 'access', _117 => _117.polyfills, 'optionalAccess', _118 => _118.fetch])
+          managedSocket.authValue.type === "public" ? managedSocket.authValue.publicApiKey : managedSocket.authValue.token.raw,
+          config.roomId,
+          nonce,
+          messages
         ).then((resp) => {
           if (!resp.ok && resp.status === 403) {
             managedSocket.reconnect();
@@ -4833,7 +4895,7 @@ function createRoom(options, config) {
         return;
       }
     }
-    managedSocket.send(message);
+    managedSocket.send(serializedPayload);
   }
   const self = new DerivedRef(
     context.staticSessionInfo,
@@ -5080,7 +5142,7 @@ function createRoom(options, config) {
     }
     context.myPresence.patch(patch);
     if (context.activeBatch) {
-      if (_optionalChain([options2, 'optionalAccess', _119 => _119.addToHistory])) {
+      if (_optionalChain([options2, 'optionalAccess', _120 => _120.addToHistory])) {
         context.activeBatch.reverseOps.unshift({
           type: "presence",
           data: oldValues
@@ -5090,7 +5152,7 @@ function createRoom(options, config) {
     } else {
       flushNowOrSoon();
       batchUpdates(() => {
-        if (_optionalChain([options2, 'optionalAccess', _120 => _120.addToHistory])) {
+        if (_optionalChain([options2, 'optionalAccess', _121 => _121.addToHistory])) {
           addToUndoStack(
             [{ type: "presence", data: oldValues }],
             doNotBatchUpdates
@@ -5133,6 +5195,7 @@ function createRoom(options, config) {
   function onRoomStateMessage(message, batchedUpdatesWrapper) {
     context.dynamicSessionInfo.set({
       actor: message.actor,
+      nonce: message.nonce,
       scopes: message.scopes
     });
     context.idFactory = makeIdFactory(message.actor);
@@ -5242,8 +5305,10 @@ function createRoom(options, config) {
             break;
           }
           case 103 /* BROADCASTED_EVENT */: {
+            const others = context.others.current;
             eventHub.customEvent.notify({
               connectionId: message.actor,
+              user: message.actor < 0 ? null : _nullishCoalesce(others.find((u) => u.connectionId === message.actor), () => ( null)),
               event: message.event
             });
             break;
@@ -5267,7 +5332,7 @@ function createRoom(options, config) {
             const unacknowledgedOps = new Map(context.unacknowledgedOps);
             createOrUpdateRootFromMessage(message, doNotBatchUpdates);
             applyAndSendOps(unacknowledgedOps, doNotBatchUpdates);
-            _optionalChain([_resolveStoragePromise, 'optionalCall', _121 => _121()]);
+            _optionalChain([_resolveStoragePromise, 'optionalCall', _122 => _122()]);
             notifyStorageStatus();
             eventHub.storageDidLoad.notify();
             break;
@@ -5290,7 +5355,7 @@ function createRoom(options, config) {
             if (process.env.NODE_ENV !== "production") {
               const traces = /* @__PURE__ */ new Set();
               for (const opId of message.opIds) {
-                const trace = _optionalChain([context, 'access', _122 => _122.opStackTraces, 'optionalAccess', _123 => _123.get, 'call', _124 => _124(opId)]);
+                const trace = _optionalChain([context, 'access', _123 => _123.opStackTraces, 'optionalAccess', _124 => _124.get, 'call', _125 => _125(opId)]);
                 if (trace) {
                   traces.add(trace);
                 }
@@ -5386,10 +5451,12 @@ ${Array.from(traces).join("\n\n")}`
     return messages;
   }
   function updateYDoc(update) {
-    context.buffer.messages.push({
+    const clientMsg = {
       type: 301 /* UPDATE_YDOC */,
       update
-    });
+    };
+    context.buffer.messages.push(clientMsg);
+    eventHub.ydoc.notify(clientMsg);
     flushNowOrSoon();
   }
   function broadcastEvent(event, options2 = {
@@ -5598,7 +5665,7 @@ ${Array.from(traces).join("\n\n")}`
       /* NOTE: Exposing __internal here only to allow testing implementation details in unit tests */
       __internal: {
         get presenceBuffer() {
-          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _125 => _125.buffer, 'access', _126 => _126.presenceUpdates, 'optionalAccess', _127 => _127.data]), () => ( null)));
+          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _126 => _126.buffer, 'access', _127 => _127.presenceUpdates, 'optionalAccess', _128 => _128.data]), () => ( null)));
         },
         // prettier-ignore
         get undoStack() {
@@ -5734,7 +5801,7 @@ function makeClassicSubscribeFn(events) {
     }
     if (isLiveNode(first)) {
       const node = first;
-      if (_optionalChain([options, 'optionalAccess', _128 => _128.isDeep])) {
+      if (_optionalChain([options, 'optionalAccess', _129 => _129.isDeep])) {
         const storageCallback = second;
         return subscribeToLiveStructureDeeply(node, storageCallback);
       } else {
@@ -5777,18 +5844,6 @@ function makeCreateSocketDelegateForRoom(roomId, liveblocksServer, WebSocketPoly
     return new ws(url.toString());
   };
 }
-async function httpSend(message, token, endpoint, fetchPolyfill) {
-  const fetcher = fetchPolyfill || /* istanbul ignore next */
-  fetch;
-  return fetcher(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: message
-  });
-}
 
 // src/client.ts
 var MIN_THROTTLE = 16;
@@ -5837,17 +5892,13 @@ function createClient(options) {
           createSocket: makeCreateSocketDelegateForRoom(
             roomId,
             getServerFromClientOptions(clientOptions),
-            _optionalChain([clientOptions, 'access', _129 => _129.polyfills, 'optionalAccess', _130 => _130.WebSocket])
+            _optionalChain([clientOptions, 'access', _130 => _130.polyfills, 'optionalAccess', _131 => _131.WebSocket])
           ),
           authenticate: makeAuthDelegateForRoom(roomId, authManager)
         })),
         enableDebugLogging: clientOptions.enableDebugLogging,
-        unstable_batchedUpdates: _optionalChain([options2, 'optionalAccess', _131 => _131.unstable_batchedUpdates]),
+        unstable_batchedUpdates: _optionalChain([options2, 'optionalAccess', _132 => _132.unstable_batchedUpdates]),
         liveblocksServer: getServerFromClientOptions(clientOptions),
-        httpSendEndpoint: buildLiveblocksHttpSendEndpoint(
-          clientOptions,
-          roomId
-        ),
         unstable_fallbackToHTTP: !!clientOptions.unstable_fallbackToHTTP
       }
     );
@@ -5857,7 +5908,7 @@ function createClient(options) {
     const shouldConnect = _nullishCoalesce(options2.shouldInitiallyConnect, () => ( true));
     if (shouldConnect) {
       if (typeof atob === "undefined") {
-        if (_optionalChain([clientOptions, 'access', _132 => _132.polyfills, 'optionalAccess', _133 => _133.atob]) === void 0) {
+        if (_optionalChain([clientOptions, 'access', _133 => _133.polyfills, 'optionalAccess', _134 => _134.atob]) === void 0) {
           throw new Error(
             "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
           );
@@ -5902,14 +5953,6 @@ function getLostConnectionTimeout(value) {
     RECOMMENDED_MIN_LOST_CONNECTION_TIMEOUT
   );
 }
-function buildLiveblocksHttpSendEndpoint(options, roomId) {
-  if (options.httpSendEndpoint) {
-    return options.httpSendEndpoint.replace("{roomId}", roomId);
-  }
-  return `https://api.liveblocks.io/v2/rooms/${encodeURIComponent(
-    roomId
-  )}/send-message`;
-}
 
 // src/crdts/utils.ts
 function toPlainLson(lson) {
@@ -6140,12 +6183,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _134 => _134.updates, 'access', _135 => _135[key], 'optionalAccess', _136 => _136.type]) === "update") {
+          if (_optionalChain([update, 'access', _135 => _135.updates, 'access', _136 => _136[key], 'optionalAccess', _137 => _137.type]) === "update") {
             const val = update.node.get(key);
             if (val !== void 0) {
               newState[key] = lsonToJson(val);
             }
-          } else if (_optionalChain([update, 'access', _137 => _137.updates, 'access', _138 => _138[key], 'optionalAccess', _139 => _139.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _138 => _138.updates, 'access', _139 => _139[key], 'optionalAccess', _140 => _140.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -6206,12 +6249,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _140 => _140.updates, 'access', _141 => _141[key], 'optionalAccess', _142 => _142.type]) === "update") {
+          if (_optionalChain([update, 'access', _141 => _141.updates, 'access', _142 => _142[key], 'optionalAccess', _143 => _143.type]) === "update") {
             const value = update.node.get(key);
             if (value !== void 0) {
               newState[key] = lsonToJson(value);
             }
-          } else if (_optionalChain([update, 'access', _143 => _143.updates, 'access', _144 => _144[key], 'optionalAccess', _145 => _145.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _144 => _144.updates, 'access', _145 => _145[key], 'optionalAccess', _146 => _146.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -6301,7 +6344,7 @@ function createCacheItem(key, defaultAsyncFunction, options) {
   let previousState = { isLoading: false };
   const eventSource2 = makeEventSource();
   function notify() {
-    const isEqual = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _146 => _146.isStateEqual]), () => ( isShallowEqual));
+    const isEqual = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _147 => _147.isStateEqual]), () => ( isShallowEqual));
     if (!isEqual(previousState, state)) {
       previousState = state;
       eventSource2.notify(state);
@@ -6380,7 +6423,7 @@ function createAsyncCache(asyncFunction, options) {
     return create(key).get();
   }
   function getState(key) {
-    return _optionalChain([cache, 'access', _147 => _147.get, 'call', _148 => _148(key), 'optionalAccess', _149 => _149.getState, 'call', _150 => _150()]);
+    return _optionalChain([cache, 'access', _148 => _148.get, 'call', _149 => _149(key), 'optionalAccess', _150 => _150.getState, 'call', _151 => _151()]);
   }
   function revalidate(key) {
     return create(key).revalidate();