@liveblocks/core 3.13.0 → 3.13.1-hackathon

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "3.13.0";
+var PKG_VERSION = "3.13.1-hackathon";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -3132,6 +3132,9 @@ var ServerMsgCode = Object.freeze({
   COMMENT_REACTION_ADDED: 405,
   COMMENT_REACTION_REMOVED: 406,
   COMMENT_METADATA_UPDATED: 409,
+  // For Agent Sessions
+  AGENT_SESSIONS: 501,
+  AGENT_MESSAGES: 503,
   // Error codes
   REJECT_STORAGE_OP: 299
   // Sent if a mutation was not allowed on the server (i.e. due to permissions, limit exceeded, etc)
@@ -8507,7 +8510,10 @@ var ClientMsgCode = Object.freeze({
   UPDATE_STORAGE: 201,
   // For Yjs support
   FETCH_YDOC: 300,
-  UPDATE_YDOC: 301
+  UPDATE_YDOC: 301,
+  // For Agent Sessions
+  FETCH_AGENT_SESSIONS: 500,
+  FETCH_AGENT_MESSAGES: 502
 });
 
 // src/refs/ManagedOthers.ts
@@ -8965,6 +8971,7 @@ function createRoom(options, config) {
     storageStatus: makeEventSource(),
     ydoc: makeEventSource(),
     comments: makeEventSource(),
+    agentSessions: makeEventSource(),
     roomWillDestroy: makeEventSource()
   };
   async function createTextMention(mentionId, mention) {
@@ -9575,6 +9582,45 @@ function createRoom(options, config) {
           eventHub.comments.notify(message);
           break;
         }
+        case ServerMsgCode.AGENT_SESSIONS: {
+          const agentSessionsMsg = message;
+          if (agentSessionsMsg.operation === "list") {
+            for (const [
+              requestId,
+              { resolve }
+            ] of pendingAgentSessionsRequests) {
+              resolve({
+                sessions: agentSessionsMsg.sessions,
+                nextCursor: agentSessionsMsg.nextCursor
+              });
+              pendingAgentSessionsRequests.delete(requestId);
+              break;
+            }
+          }
+          eventHub.agentSessions.notify(agentSessionsMsg);
+          break;
+        }
+        case ServerMsgCode.AGENT_MESSAGES: {
+          const agentMessagesMsg = message;
+          if (agentMessagesMsg.operation === "list") {
+            for (const [
+              requestId,
+              { resolve }
+            ] of pendingAgentMessagesRequests) {
+              const parsedRequestId = JSON.parse(requestId);
+              if (parsedRequestId.sessionId === agentMessagesMsg.sessionId) {
+                resolve({
+                  messages: agentMessagesMsg.messages,
+                  nextCursor: agentMessagesMsg.nextCursor
+                });
+                pendingAgentMessagesRequests.delete(requestId);
+                break;
+              }
+            }
+          }
+          eventHub.agentSessions.notify(agentMessagesMsg);
+          break;
+        }
         default:
           break;
       }
@@ -9676,6 +9722,8 @@ function createRoom(options, config) {
   }
   let _getStorage$ = null;
   let _resolveStoragePromise = null;
+  const pendingAgentSessionsRequests = /* @__PURE__ */ new Map();
+  const pendingAgentMessagesRequests = /* @__PURE__ */ new Map();
   function processInitialStorage(message) {
     const unacknowledgedOps = new Map(context.unacknowledgedOps);
     createOrUpdateRootFromMessage(message);
@@ -9743,6 +9791,65 @@ function createRoom(options, config) {
     }
     flushNowOrSoon();
   }
+  async function fetchAgentSessions(options2) {
+    const requestId = JSON.stringify({
+      cursor: options2?.cursor,
+      since: options2?.since,
+      limit: options2?.limit,
+      metadata: options2?.metadata
+    });
+    const { promise, resolve, reject } = Promise_withResolvers();
+    pendingAgentSessionsRequests.set(requestId, { resolve, reject });
+    const message = {
+      type: ClientMsgCode.FETCH_AGENT_SESSIONS,
+      cursor: options2?.cursor,
+      since: options2?.since,
+      limit: options2?.limit,
+      metadata: options2?.metadata
+    };
+    context.buffer.messages.push(message);
+    flushNowOrSoon();
+    setTimeout(() => {
+      if (pendingAgentSessionsRequests.has(requestId)) {
+        pendingAgentSessionsRequests.delete(requestId);
+        reject(new Error("Agent sessions fetch timeout"));
+      }
+    }, 3e4);
+    return promise;
+  }
+  async function fetchAgentMessages(sessionId, options2) {
+    const requestId = JSON.stringify({
+      sessionId,
+      cursor: options2?.cursor,
+      since: options2?.since,
+      limit: options2?.limit
+    });
+    const existingRequest = pendingAgentMessagesRequests.get(requestId);
+    if (existingRequest) {
+      return new Promise((resolve2, reject2) => {
+        existingRequest.resolve = resolve2;
+        existingRequest.reject = reject2;
+      });
+    }
+    const { promise, resolve, reject } = Promise_withResolvers();
+    pendingAgentMessagesRequests.set(requestId, { resolve, reject });
+    const message = {
+      type: ClientMsgCode.FETCH_AGENT_MESSAGES,
+      sessionId,
+      cursor: options2?.cursor,
+      since: options2?.since,
+      limit: options2?.limit
+    };
+    context.buffer.messages.push(message);
+    flushNowOrSoon();
+    setTimeout(() => {
+      if (pendingAgentMessagesRequests.has(requestId)) {
+        pendingAgentMessagesRequests.delete(requestId);
+        reject(new Error("Agent messages fetch timeout"));
+      }
+    }, 3e4);
+    return promise;
+  }
   function undo() {
     if (context.activeBatch) {
       throw new Error("undo is not allowed during a batch");
@@ -9885,6 +9992,7 @@ function createRoom(options, config) {
     storageStatus: eventHub.storageStatus.observable,
     ydoc: eventHub.ydoc.observable,
     comments: eventHub.comments.observable,
+    agentSessions: eventHub.agentSessions.observable,
     roomWillDestroy: eventHub.roomWillDestroy.observable
   };
   async function getThreadsSince(options2) {
@@ -10093,7 +10201,7 @@ function createRoom(options, config) {
       id: roomId,
       subscribe: makeClassicSubscribeFn(
         roomId,
-        events,
+        eventHub,
         config.errorEventSource
       ),
       connect: () => managedSocket.connect(),
@@ -10128,6 +10236,8 @@ function createRoom(options, config) {
         resume: resumeHistory
       },
       fetchYDoc,
+      fetchAgentSessions,
+      fetchAgentMessages,
       getStorage,
       getStorageSnapshot,
       getStorageStatus,
@@ -11080,9 +11190,9 @@ function lsonToJson(value) {
   }
   return value;
 }
-function deepLiveify(value) {
+function _deepLiveify(value) {
   if (Array.isArray(value)) {
-    return new LiveList(value.map(deepLiveify));
+    return new LiveList(value.map(_deepLiveify));
   } else if (isPlainObject(value)) {
     const init = {};
     for (const key in value) {
@@ -11090,7 +11200,7 @@ function deepLiveify(value) {
       if (val === void 0) {
         continue;
       }
-      init[key] = deepLiveify(val);
+      init[key] = _deepLiveify(val);
     }
     return new LiveObject(init);
   } else {
@@ -11127,7 +11237,7 @@ function patchLiveList(liveList, prev, next) {
   if (i > prevEnd) {
     if (i <= nextEnd) {
       while (i <= nextEnd) {
-        liveList.insert(deepLiveify(next[i]), i);
+        liveList.insert(_deepLiveify(next[i]), i);
         i++;
       }
     }
@@ -11145,12 +11255,12 @@ function patchLiveList(liveList, prev, next) {
       if (isLiveObject(liveListNode) && isPlainObject(prevNode) && isPlainObject(nextNode)) {
         patchLiveObject(liveListNode, prevNode, nextNode);
       } else {
-        liveList.set(i, deepLiveify(nextNode));
+        liveList.set(i, _deepLiveify(nextNode));
       }
       i++;
     }
     while (i <= nextEnd) {
-      liveList.insert(deepLiveify(next[i]), i);
+      liveList.insert(_deepLiveify(next[i]), i);
       i++;
     }
     let localI = i;
@@ -11177,7 +11287,7 @@ Only serializable value can be synced with Liveblocks.`
   if (next === void 0) {
     liveObject.delete(key);
   } else if (value === void 0) {
-    liveObject.set(key, deepLiveify(next));
+    liveObject.set(key, _deepLiveify(next));
   } else if (prev === next) {
     return;
   } else if (isLiveList(value) && Array.isArray(prev) && Array.isArray(next)) {
@@ -11185,7 +11295,7 @@ Only serializable value can be synced with Liveblocks.`
   } else if (isLiveObject(value) && isPlainObject(prev) && isPlainObject(next)) {
     patchLiveObject(value, prev, next);
   } else {
-    liveObject.set(key, deepLiveify(next));
+    liveObject.set(key, _deepLiveify(next));
   }
 }
 function patchLiveObject(root, prev, next) {
@@ -11486,6 +11596,90 @@ function makePoller(callback, intervalMs, options) {
   };
 }
 
+// src/mutations.ts
+function generateOpsFromJson(nodes, mutation, actorId = 1) {
+  const capturedOps = [];
+  const pool = createManagedPool("mutation-temp", {
+    getCurrentConnectionId: () => actorId,
+    onDispatch: (ops) => {
+      capturedOps.push(...ops);
+    }
+  });
+  const root = LiveObject._fromItems(nodes, pool);
+  if (isPlainObject(mutation)) {
+    applyMutationToLiveObject(root, mutation);
+  } else {
+    throw new Error(
+      "Root mutation must be an object. Use a nested key to update specific values."
+    );
+  }
+  return capturedOps;
+}
+function applyMutationToLiveObject(target, mutation) {
+  for (const key in mutation) {
+    const mutationValue = mutation[key];
+    if (mutationValue === void 0) {
+      continue;
+    }
+    const existingValue = target.get(key);
+    if (isLiveNode(mutationValue)) {
+      target.set(key, mutationValue);
+      continue;
+    }
+    if (isLiveObject(existingValue) && isPlainObject(mutationValue)) {
+      applyMutationToLiveObject(
+        existingValue,
+        mutationValue
+      );
+    } else if (isLiveMap(existingValue) && isPlainObject(mutationValue)) {
+      applyMutationToLiveMap(existingValue, mutationValue);
+    } else if (isLiveList(existingValue) && Array.isArray(mutationValue)) {
+      applyMutationToLiveList(existingValue, mutationValue);
+    } else if (existingValue === void 0 && isPlainObject(mutationValue)) {
+      const convertedValue = _deepLiveify(mutationValue);
+      target.set(key, convertedValue);
+    } else {
+      target.set(key, mutationValue);
+    }
+  }
+}
+function applyMutationToLiveMap(target, mutation) {
+  for (const key in mutation) {
+    const mutationValue = mutation[key];
+    if (mutationValue === void 0) {
+      continue;
+    }
+    const existingValue = target.get(key);
+    if (isLiveNode(mutationValue)) {
+      target.set(key, mutationValue);
+      continue;
+    }
+    if (isLiveObject(existingValue) && isPlainObject(mutationValue)) {
+      applyMutationToLiveObject(
+        existingValue,
+        mutationValue
+      );
+    } else if (isLiveMap(existingValue) && isPlainObject(mutationValue)) {
+      applyMutationToLiveMap(existingValue, mutationValue);
+    } else if (isLiveList(existingValue) && Array.isArray(mutationValue)) {
+      applyMutationToLiveList(existingValue, mutationValue);
+    } else if (existingValue === void 0 && isPlainObject(mutationValue)) {
+      const convertedValue = _deepLiveify(mutationValue);
+      target.set(key, convertedValue);
+    } else {
+      const newValue = isLiveNode(mutationValue) ? mutationValue : mutationValue;
+      target.set(key, newValue);
+    }
+  }
+}
+function applyMutationToLiveList(target, mutation) {
+  target.clear();
+  for (const item of mutation) {
+    const liveItem = isLiveNode(item) ? item : item;
+    target.push(liveItem);
+  }
+}
+
 // src/protocol/Subscriptions.ts
 function getSubscriptionKey(subscription, subjectId) {
   if (typeof subscription === "string") {
@@ -11558,6 +11752,7 @@ export {
   errorIf,
   findLastIndex,
   freeze,
+  generateOpsFromJson,
   generateUrl,
   getMentionsFromCommentBody,
   getSubscriptionKey,