@liveblocks/core 2.5.1 → 2.6.0

package/dist/index.mjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "2.5.1";
+var PKG_VERSION = "2.6.0";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -5172,297 +5172,6 @@ var CommentsApiError = class extends Error {
     this.details = details;
   }
 };
-function createCommentsApi(roomId, getAuthValue, fetchClientApi) {
-  async function fetchCommentsApi(endpoint, params, options) {
-    const authValue = await getAuthValue();
-    return fetchClientApi(roomId, endpoint, authValue, options, params);
-  }
-  async function fetchJson(endpoint, options, params) {
-    const response = await fetchCommentsApi(endpoint, params, options);
-    if (!response.ok) {
-      if (response.status >= 400 && response.status < 600) {
-        let error3;
-        try {
-          const errorBody = await response.json();
-          error3 = new CommentsApiError(
-            errorBody.message,
-            response.status,
-            errorBody
-          );
-        } catch {
-          error3 = new CommentsApiError(response.statusText, response.status);
-        }
-        throw error3;
-      }
-    }
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      body = {};
-    }
-    return body;
-  }
-  async function getThreadsSince(options) {
-    const response = await fetchCommentsApi(
-      "/threads",
-      {
-        since: options?.since?.toISOString()
-      },
-      {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      }
-    );
-    if (response.ok) {
-      const json = await response.json();
-      return {
-        threads: {
-          updated: json.data.map(convertToThreadData),
-          deleted: json.deletedThreads.map(convertToThreadDeleteInfo)
-        },
-        inboxNotifications: {
-          updated: json.inboxNotifications.map(convertToInboxNotificationData),
-          deleted: json.deletedInboxNotifications.map(
-            convertToInboxNotificationDeleteInfo
-          )
-        },
-        requestedAt: new Date(json.meta.requestedAt)
-      };
-    } else if (response.status === 404) {
-      return {
-        threads: {
-          updated: [],
-          deleted: []
-        },
-        inboxNotifications: {
-          updated: [],
-          deleted: []
-        },
-        requestedAt: /* @__PURE__ */ new Date()
-      };
-    } else {
-      throw new Error("There was an error while getting threads.");
-    }
-  }
-  async function getThreads(options) {
-    let query;
-    if (options?.query) {
-      query = objectToQuery(options.query);
-    }
-    const response = await fetchCommentsApi(
-      "/threads",
-      {
-        query
-      },
-      {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      }
-    );
-    if (response.ok) {
-      const json = await response.json();
-      return {
-        threads: json.data.map(convertToThreadData),
-        inboxNotifications: json.inboxNotifications.map(
-          convertToInboxNotificationData
-        ),
-        requestedAt: new Date(json.meta.requestedAt)
-      };
-    } else if (response.status === 404) {
-      return {
-        threads: [],
-        inboxNotifications: [],
-        deletedThreads: [],
-        deletedInboxNotifications: [],
-        requestedAt: /* @__PURE__ */ new Date()
-      };
-    } else {
-      throw new Error("There was an error while getting threads.");
-    }
-  }
-  async function getThread(threadId) {
-    const response = await fetchCommentsApi(
-      `/thread-with-notification/${threadId}`
-    );
-    if (response.ok) {
-      const json = await response.json();
-      return {
-        thread: convertToThreadData(json.thread),
-        inboxNotification: json.inboxNotification ? convertToInboxNotificationData(json.inboxNotification) : void 0
-      };
-    } else if (response.status === 404) {
-      return {
-        thread: void 0,
-        inboxNotification: void 0
-      };
-    } else {
-      throw new Error(`There was an error while getting thread ${threadId}.`);
-    }
-  }
-  async function createThread({
-    metadata,
-    body,
-    commentId = createCommentId(),
-    threadId = createThreadId()
-  }) {
-    const thread = await fetchJson("/threads", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        id: threadId,
-        comment: {
-          id: commentId,
-          body
-        },
-        metadata
-      })
-    });
-    return convertToThreadData(thread);
-  }
-  async function deleteThread(threadId) {
-    await fetchJson(`/threads/${encodeURIComponent(threadId)}`, {
-      method: "DELETE"
-    });
-  }
-  async function editThreadMetadata({
-    metadata,
-    threadId
-  }) {
-    return await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/metadata`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(metadata)
-      }
-    );
-  }
-  async function markThreadAsResolved(threadId) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/mark-as-resolved`,
-      {
-        method: "POST"
-      }
-    );
-  }
-  async function markThreadAsUnresolved(threadId) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/mark-as-unresolved`,
-      {
-        method: "POST"
-      }
-    );
-  }
-  async function createComment({
-    threadId,
-    commentId = createCommentId(),
-    body
-  }) {
-    const comment = await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          id: commentId,
-          body
-        })
-      }
-    );
-    return convertToCommentData(comment);
-  }
-  async function editComment({
-    threadId,
-    commentId,
-    body
-  }) {
-    const comment = await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          body
-        })
-      }
-    );
-    return convertToCommentData(comment);
-  }
-  async function deleteComment2({
-    threadId,
-    commentId
-  }) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}`,
-      {
-        method: "DELETE"
-      }
-    );
-  }
-  async function addReaction2({
-    threadId,
-    commentId,
-    emoji
-  }) {
-    const reaction = await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}/reactions`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ emoji })
-      }
-    );
-    return convertToCommentUserReaction(reaction);
-  }
-  async function removeReaction2({
-    threadId,
-    commentId,
-    emoji
-  }) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}/reactions/${encodeURIComponent(emoji)}`,
-      {
-        method: "DELETE"
-      }
-    );
-  }
-  return {
-    getThreads,
-    getThreadsSince,
-    getThread,
-    createThread,
-    deleteThread,
-    editThreadMetadata,
-    markThreadAsResolved,
-    markThreadAsUnresolved,
-    createComment,
-    editComment,
-    deleteComment: deleteComment2,
-    addReaction: addReaction2,
-    removeReaction: removeReaction2
-  };
-}
 var MARK_INBOX_NOTIFICATIONS_AS_READ_BATCH_DELAY2 = 50;
 function createRoom(options, config) {
   const initialPresence = options.initialPresence;
@@ -6466,137 +6175,406 @@ ${Array.from(traces).join("\n\n")}`
     if (context.activeBatch) {
       throw new Error("redo is not allowed during a batch");
     }
-    const historyOps = context.redoStack.pop();
-    if (historyOps === void 0) {
-      return;
+    const historyOps = context.redoStack.pop();
+    if (historyOps === void 0) {
+      return;
+    }
+    context.pausedHistory = null;
+    const result = applyOps(historyOps, true);
+    batchUpdates(() => {
+      notify(result.updates, doNotBatchUpdates);
+      context.undoStack.push(result.reverse);
+      onHistoryChange(doNotBatchUpdates);
+    });
+    for (const op of result.ops) {
+      if (op.type !== "presence") {
+        context.buffer.storageOperations.push(op);
+      }
+    }
+    flushNowOrSoon();
+  }
+  function clear() {
+    context.undoStack.length = 0;
+    context.redoStack.length = 0;
+  }
+  function batch(callback) {
+    if (context.activeBatch) {
+      return callback();
+    }
+    let returnValue = void 0;
+    batchUpdates(() => {
+      context.activeBatch = {
+        ops: [],
+        updates: {
+          storageUpdates: /* @__PURE__ */ new Map(),
+          presence: false,
+          others: []
+        },
+        reverseOps: []
+      };
+      try {
+        returnValue = callback();
+      } finally {
+        const currentBatch = context.activeBatch;
+        context.activeBatch = null;
+        if (currentBatch.reverseOps.length > 0) {
+          addToUndoStack(currentBatch.reverseOps, doNotBatchUpdates);
+        }
+        if (currentBatch.ops.length > 0) {
+          context.redoStack.length = 0;
+        }
+        if (currentBatch.ops.length > 0) {
+          dispatchOps(currentBatch.ops);
+        }
+        notify(currentBatch.updates, doNotBatchUpdates);
+        flushNowOrSoon();
+      }
+    });
+    return returnValue;
+  }
+  function pauseHistory() {
+    if (context.pausedHistory === null) {
+      context.pausedHistory = [];
+    }
+  }
+  function resumeHistory() {
+    const historyOps = context.pausedHistory;
+    context.pausedHistory = null;
+    if (historyOps !== null && historyOps.length > 0) {
+      _addToRealUndoStack(historyOps, batchUpdates);
+    }
+  }
+  function getStorageStatus() {
+    if (context.root === void 0) {
+      return _getStorage$ === null ? "not-loaded" : "loading";
+    } else {
+      return context.unacknowledgedOps.size === 0 ? "synchronized" : "synchronizing";
+    }
+  }
+  let _lastStorageStatus = getStorageStatus();
+  function notifyStorageStatus() {
+    const storageStatus = getStorageStatus();
+    if (_lastStorageStatus !== storageStatus) {
+      _lastStorageStatus = storageStatus;
+      eventHub.storageStatus.notify(storageStatus);
+    }
+  }
+  function isPresenceReady() {
+    return self.current !== null;
+  }
+  async function waitUntilPresenceReady() {
+    while (!isPresenceReady()) {
+      const { promise, resolve } = Promise_withResolvers();
+      const unsub1 = events.self.subscribeOnce(resolve);
+      const unsub2 = events.status.subscribeOnce(resolve);
+      await promise;
+      unsub1();
+      unsub2();
+    }
+  }
+  function isStorageReady() {
+    return getStorageSnapshot() !== null;
+  }
+  async function waitUntilStorageReady() {
+    while (!isStorageReady()) {
+      await getStorage();
+    }
+  }
+  const others_forDevTools = new DerivedRef(
+    context.others,
+    (others) => others.map((other, index) => userToTreeNode(`Other ${index}`, other))
+  );
+  const events = {
+    status: eventHub.status.observable,
+    lostConnection: eventHub.lostConnection.observable,
+    customEvent: eventHub.customEvent.observable,
+    others: eventHub.others.observable,
+    self: eventHub.self.observable,
+    myPresence: eventHub.myPresence.observable,
+    error: eventHub.error.observable,
+    /** @deprecated */
+    storage: eventHub.storageBatch.observable,
+    storageBatch: eventHub.storageBatch.observable,
+    history: eventHub.history.observable,
+    storageDidLoad: eventHub.storageDidLoad.observable,
+    storageStatus: eventHub.storageStatus.observable,
+    ydoc: eventHub.ydoc.observable,
+    comments: eventHub.comments.observable
+  };
+  async function fetchCommentsApi(endpoint, params, options2) {
+    const authValue = await delegates.authenticate();
+    return fetchClientApi(config.roomId, endpoint, authValue, options2, params);
+  }
+  async function fetchCommentsJson(endpoint, options2, params) {
+    const response = await fetchCommentsApi(endpoint, params, options2);
+    if (!response.ok) {
+      if (response.status >= 400 && response.status < 600) {
+        let error3;
+        try {
+          const errorBody = await response.json();
+          error3 = new CommentsApiError(
+            errorBody.message,
+            response.status,
+            errorBody
+          );
+        } catch {
+          error3 = new CommentsApiError(response.statusText, response.status);
+        }
+        throw error3;
+      }
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = {};
+    }
+    return body;
+  }
+  async function getThreadsSince(options2) {
+    const response = await fetchCommentsApi(
+      "/threads",
+      {
+        since: options2?.since?.toISOString()
+      },
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (response.ok) {
+      const json = await response.json();
+      return {
+        threads: {
+          updated: json.data.map(convertToThreadData),
+          deleted: json.deletedThreads.map(convertToThreadDeleteInfo)
+        },
+        inboxNotifications: {
+          updated: json.inboxNotifications.map(convertToInboxNotificationData),
+          deleted: json.deletedInboxNotifications.map(
+            convertToInboxNotificationDeleteInfo
+          )
+        },
+        requestedAt: new Date(json.meta.requestedAt)
+      };
+    } else if (response.status === 404) {
+      return {
+        threads: {
+          updated: [],
+          deleted: []
+        },
+        inboxNotifications: {
+          updated: [],
+          deleted: []
+        },
+        requestedAt: /* @__PURE__ */ new Date()
+      };
+    } else {
+      throw new Error("There was an error while getting threads.");
+    }
+  }
+  async function getThreads(options2) {
+    let query;
+    if (options2?.query) {
+      query = objectToQuery(options2.query);
+    }
+    const response = await fetchCommentsApi(
+      "/threads",
+      {
+        query
+      },
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (response.ok) {
+      const json = await response.json();
+      return {
+        threads: json.data.map(convertToThreadData),
+        inboxNotifications: json.inboxNotifications.map(
+          convertToInboxNotificationData
+        ),
+        requestedAt: new Date(json.meta.requestedAt)
+      };
+    } else if (response.status === 404) {
+      return {
+        threads: [],
+        inboxNotifications: [],
+        deletedThreads: [],
+        deletedInboxNotifications: [],
+        requestedAt: /* @__PURE__ */ new Date()
+      };
+    } else {
+      throw new Error("There was an error while getting threads.");
+    }
+  }
+  async function getThread(threadId) {
+    const response = await fetchCommentsApi(
+      `/thread-with-notification/${threadId}`
+    );
+    if (response.ok) {
+      const json = await response.json();
+      return {
+        thread: convertToThreadData(json.thread),
+        inboxNotification: json.inboxNotification ? convertToInboxNotificationData(json.inboxNotification) : void 0
+      };
+    } else if (response.status === 404) {
+      return {
+        thread: void 0,
+        inboxNotification: void 0
+      };
+    } else {
+      throw new Error(`There was an error while getting thread ${threadId}.`);
     }
-    context.pausedHistory = null;
-    const result = applyOps(historyOps, true);
-    batchUpdates(() => {
-      notify(result.updates, doNotBatchUpdates);
-      context.undoStack.push(result.reverse);
-      onHistoryChange(doNotBatchUpdates);
+  }
+  async function createThread({
+    metadata,
+    body,
+    commentId = createCommentId(),
+    threadId = createThreadId()
+  }) {
+    const thread = await fetchCommentsJson("/threads", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        id: threadId,
+        comment: {
+          id: commentId,
+          body
+        },
+        metadata
+      })
     });
-    for (const op of result.ops) {
-      if (op.type !== "presence") {
-        context.buffer.storageOperations.push(op);
-      }
-    }
-    flushNowOrSoon();
+    return convertToThreadData(thread);
   }
-  function clear() {
-    context.undoStack.length = 0;
-    context.redoStack.length = 0;
+  async function deleteThread(threadId) {
+    await fetchCommentsJson(`/threads/${encodeURIComponent(threadId)}`, {
+      method: "DELETE"
+    });
   }
-  function batch(callback) {
-    if (context.activeBatch) {
-      return callback();
-    }
-    let returnValue = void 0;
-    batchUpdates(() => {
-      context.activeBatch = {
-        ops: [],
-        updates: {
-          storageUpdates: /* @__PURE__ */ new Map(),
-          presence: false,
-          others: []
+  async function editThreadMetadata({
+    metadata,
+    threadId
+  }) {
+    return await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/metadata`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
         },
-        reverseOps: []
-      };
-      try {
-        returnValue = callback();
-      } finally {
-        const currentBatch = context.activeBatch;
-        context.activeBatch = null;
-        if (currentBatch.reverseOps.length > 0) {
-          addToUndoStack(currentBatch.reverseOps, doNotBatchUpdates);
-        }
-        if (currentBatch.ops.length > 0) {
-          context.redoStack.length = 0;
-        }
-        if (currentBatch.ops.length > 0) {
-          dispatchOps(currentBatch.ops);
-        }
-        notify(currentBatch.updates, doNotBatchUpdates);
-        flushNowOrSoon();
+        body: JSON.stringify(metadata)
       }
-    });
-    return returnValue;
-  }
-  function pauseHistory() {
-    if (context.pausedHistory === null) {
-      context.pausedHistory = [];
-    }
+    );
   }
-  function resumeHistory() {
-    const historyOps = context.pausedHistory;
-    context.pausedHistory = null;
-    if (historyOps !== null && historyOps.length > 0) {
-      _addToRealUndoStack(historyOps, batchUpdates);
-    }
+  async function markThreadAsResolved(threadId) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/mark-as-resolved`,
+      {
+        method: "POST"
+      }
+    );
   }
-  function getStorageStatus() {
-    if (context.root === void 0) {
-      return _getStorage$ === null ? "not-loaded" : "loading";
-    } else {
-      return context.unacknowledgedOps.size === 0 ? "synchronized" : "synchronizing";
-    }
+  async function markThreadAsUnresolved(threadId) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/mark-as-unresolved`,
+      {
+        method: "POST"
+      }
+    );
   }
-  let _lastStorageStatus = getStorageStatus();
-  function notifyStorageStatus() {
-    const storageStatus = getStorageStatus();
-    if (_lastStorageStatus !== storageStatus) {
-      _lastStorageStatus = storageStatus;
-      eventHub.storageStatus.notify(storageStatus);
-    }
+  async function createComment({
+    threadId,
+    commentId = createCommentId(),
+    body
+  }) {
+    const comment = await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          id: commentId,
+          body
+        })
+      }
+    );
+    return convertToCommentData(comment);
   }
-  function isPresenceReady() {
-    return self.current !== null;
+  async function editComment({
+    threadId,
+    commentId,
+    body
+  }) {
+    const comment = await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          body
+        })
+      }
+    );
+    return convertToCommentData(comment);
   }
-  async function waitUntilPresenceReady() {
-    while (!isPresenceReady()) {
-      const { promise, resolve } = Promise_withResolvers();
-      const unsub1 = events.self.subscribeOnce(resolve);
-      const unsub2 = events.status.subscribeOnce(resolve);
-      await promise;
-      unsub1();
-      unsub2();
-    }
+  async function deleteComment2({
+    threadId,
+    commentId
+  }) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}`,
+      {
+        method: "DELETE"
+      }
+    );
   }
-  function isStorageReady() {
-    return getStorageSnapshot() !== null;
+  async function addReaction2({
+    threadId,
+    commentId,
+    emoji
+  }) {
+    const reaction = await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}/reactions`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ emoji })
+      }
+    );
+    return convertToCommentUserReaction(reaction);
   }
-  async function waitUntilStorageReady() {
-    while (!isStorageReady()) {
-      await getStorage();
-    }
+  async function removeReaction2({
+    threadId,
+    commentId,
+    emoji
+  }) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}/reactions/${encodeURIComponent(emoji)}`,
+      {
+        method: "DELETE"
+      }
+    );
   }
-  const others_forDevTools = new DerivedRef(
-    context.others,
-    (others) => others.map((other, index) => userToTreeNode(`Other ${index}`, other))
-  );
-  const events = {
-    status: eventHub.status.observable,
-    lostConnection: eventHub.lostConnection.observable,
-    customEvent: eventHub.customEvent.observable,
-    others: eventHub.others.observable,
-    self: eventHub.self.observable,
-    myPresence: eventHub.myPresence.observable,
-    error: eventHub.error.observable,
-    /** @deprecated */
-    storage: eventHub.storageBatch.observable,
-    storageBatch: eventHub.storageBatch.observable,
-    history: eventHub.history.observable,
-    storageDidLoad: eventHub.storageDidLoad.observable,
-    storageStatus: eventHub.storageStatus.observable,
-    ydoc: eventHub.ydoc.observable,
-    comments: eventHub.comments.observable
-  };
-  const commentsApi = createCommentsApi(
-    config.roomId,
-    delegates.authenticate,
-    fetchClientApi
-  );
   async function fetchNotificationsJson(endpoint, options2) {
     const authValue = await delegates.authenticate();
     const response = await fetchClientApi(
@@ -6747,10 +6725,24 @@ ${Array.from(traces).join("\n\n")}`
       // Presence
       getPresence: () => context.myPresence.current,
       getOthers: () => context.others.current,
+      // Comments
+      getThreads,
+      getThreadsSince,
+      getThread,
+      createThread,
+      deleteThread,
+      editThreadMetadata,
+      markThreadAsResolved,
+      markThreadAsUnresolved,
+      createComment,
+      editComment,
+      deleteComment: deleteComment2,
+      addReaction: addReaction2,
+      removeReaction: removeReaction2,
+      // Notifications
       getNotificationSettings,
       updateNotificationSettings,
-      markInboxNotificationAsRead,
-      ...commentsApi
+      markInboxNotificationAsRead
     },
     // Explictly make the internal field non-enumerable, to avoid aggressive
     // freezing when used with Immer