@liveblocks/core 1.2.3 → 1.3.0

package/dist/index.mjs

@@ -1,6 +1,12 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "1.2.3";
+var PKG_VERSION = "1.3.0";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -150,6 +156,13 @@ function makeEventSource() {
 }
 
 // src/lib/fancy-console.ts
+var fancy_console_exports = {};
+__export(fancy_console_exports, {
+  error: () => error2,
+  errorWithTitle: () => errorWithTitle,
+  warn: () => warn,
+  warnWithTitle: () => warnWithTitle
+});
 var badge = "background:#0e0d12;border-radius:9999px;color:#fff;padding:3px 7px;font-family:sans-serif;font-weight:600;";
 var bold = "font-weight:600";
 function wrap(method) {
@@ -624,6 +637,11 @@ var ServerMsgCode = /* @__PURE__ */ ((ServerMsgCode2) => {
   ServerMsgCode2[ServerMsgCode2["UPDATE_STORAGE"] = 201] = "UPDATE_STORAGE";
   ServerMsgCode2[ServerMsgCode2["REJECT_STORAGE_OP"] = 299] = "REJECT_STORAGE_OP";
   ServerMsgCode2[ServerMsgCode2["UPDATE_YDOC"] = 300] = "UPDATE_YDOC";
+  ServerMsgCode2[ServerMsgCode2["THREAD_CREATED"] = 400] = "THREAD_CREATED";
+  ServerMsgCode2[ServerMsgCode2["THREAD_METADATA_UPDATED"] = 401] = "THREAD_METADATA_UPDATED";
+  ServerMsgCode2[ServerMsgCode2["COMMENT_CREATED"] = 402] = "COMMENT_CREATED";
+  ServerMsgCode2[ServerMsgCode2["COMMENT_EDITED"] = 403] = "COMMENT_EDITED";
+  ServerMsgCode2[ServerMsgCode2["COMMENT_DELETED"] = 404] = "COMMENT_DELETED";
   return ServerMsgCode2;
 })(ServerMsgCode || {});
 
@@ -1152,10 +1170,10 @@ function createConnectionStateMachine(delegates, options) {
   };
 }
 var ManagedSocket = class {
-  constructor(delegates, enableDebugLogging = false) {
+  constructor(delegates, enableDebugLogging = false, waitForActorId = true) {
     const { machine, events, cleanups } = createConnectionStateMachine(
       delegates,
-      { waitForActorId: true, enableDebugLogging }
+      { waitForActorId, enableDebugLogging }
     );
     this.machine = machine;
     this.events = events;
@@ -1237,6 +1255,9 @@ var ManagedSocket = class {
 function canWriteStorage(scopes) {
   return scopes.includes("room:write" /* Write */);
 }
+function canComment(scopes) {
+  return scopes.includes("comments:write" /* CommentsWrite */) || scopes.includes("room:write" /* Write */);
+}
 function isValidAuthTokenPayload(data) {
   return isPlainObject(data) && (data.k === "acc" /* ACCESS_TOKEN */ || data.k === "id" /* ID_TOKEN */ || data.k === "sec-legacy" /* SECRET_LEGACY */);
 }
@@ -1647,6 +1668,149 @@ function errorIf(condition, message) {
   }
 }
 
+// src/comments/index.ts
+function getAuthBearerHeaderFromAuthValue(authValue) {
+  if (authValue.type === "public") {
+    return authValue.publicApiKey;
+  } else {
+    return authValue.token.raw;
+  }
+}
+function createCommentsApi(roomId, getAuthValue, { serverEndpoint }) {
+  async function fetchJson(endpoint, options) {
+    const response = await fetchApi(roomId, endpoint, options);
+    if (!response.ok) {
+      if (response.status >= 400 && response.status < 600) {
+        let errorMessage = "";
+        try {
+          const errorBody = await response.json();
+          errorMessage = errorBody.message;
+        } catch (error3) {
+          errorMessage = response.statusText;
+        }
+        throw new Error(
+          `Request failed with status ${response.status}: ${errorMessage}`
+        );
+      }
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = {};
+    }
+    return body;
+  }
+  async function fetchApi(roomId2, endpoint, options) {
+    const authValue = await getAuthValue();
+    const url = `${serverEndpoint}/c/rooms/${roomId2}${endpoint}`;
+    return await fetch(url, {
+      ...options,
+      headers: {
+        ...options?.headers,
+        Authorization: `Bearer ${getAuthBearerHeaderFromAuthValue(authValue)}`
+      }
+    });
+  }
+  async function getThreads() {
+    const response = await fetchApi(roomId, "/threads");
+    if (response.ok) {
+      const json = await response.json();
+      return json.data;
+    } else if (response.status === 404) {
+      return [];
+    } else {
+      throw new Error("There was an error while getting threads.");
+    }
+  }
+  function createThread({
+    metadata,
+    body,
+    commentId,
+    threadId
+  }) {
+    return fetchJson("/threads", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        id: threadId,
+        comment: {
+          id: commentId,
+          body
+        },
+        metadata
+      })
+    });
+  }
+  function editThreadMetadata({
+    metadata,
+    threadId
+  }) {
+    return fetchJson(
+      `/threads/${threadId}/metadata`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(metadata)
+      }
+    );
+  }
+  function createComment({
+    threadId,
+    commentId,
+    body
+  }) {
+    return fetchJson(`/threads/${threadId}/comments`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        id: commentId,
+        body
+      })
+    });
+  }
+  function editComment({
+    threadId,
+    commentId,
+    body
+  }) {
+    return fetchJson(
+      `/threads/${threadId}/comments/${commentId}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          body
+        })
+      }
+    );
+  }
+  async function deleteComment({
+    threadId,
+    commentId
+  }) {
+    await fetchJson(`/threads/${threadId}/comments/${commentId}`, {
+      method: "DELETE"
+    });
+  }
+  return {
+    getThreads,
+    createThread,
+    editThreadMetadata,
+    createComment,
+    editComment,
+    deleteComment
+  };
+}
+
 // src/lib/position.ts
 var MIN_CODE = 32;
 var MAX_CODE = 126;
@@ -4190,19 +4354,6 @@ var ClientMsgCode = /* @__PURE__ */ ((ClientMsgCode2) => {
   return ClientMsgCode2;
 })(ClientMsgCode || {});
 
-// src/lib/LegacyArray.ts
-function asArrayWithLegacyMethods(arr) {
-  Object.defineProperty(arr, "count", {
-    value: arr.length,
-    enumerable: false
-  });
-  Object.defineProperty(arr, "toArray", {
-    value: () => arr,
-    enumerable: false
-  });
-  return freeze(arr);
-}
-
 // src/refs/ImmutableRef.ts
 function merge(target, patch) {
   let updated = false;
@@ -4249,6 +4400,7 @@ function makeUser(conn, presence) {
       id,
       info,
       canWrite,
+      canComment: canComment(conn.scopes),
       isReadOnly: !canWrite,
       // Deprecated, kept for backward-compatibility
       presence
@@ -4275,7 +4427,7 @@ var OthersRef = class extends ImmutableRef {
         (connectionId) => this.getUser(Number(connectionId))
       )
     );
-    return asArrayWithLegacyMethods(users);
+    return users;
   }
   clearOthers() {
     this._connections = /* @__PURE__ */ new Map();
@@ -4636,7 +4788,8 @@ function createRoom(options, config) {
     history: makeEventSource(),
     storageDidLoad: makeEventSource(),
     storageStatus: makeEventSource(),
-    ydoc: makeEventSource()
+    ydoc: makeEventSource(),
+    comments: makeEventSource()
   };
   function sendMessages(messageOrMessages) {
     const message = JSON.stringify(messageOrMessages);
@@ -4677,6 +4830,7 @@ function createRoom(options, config) {
           info: staticSession.userInfo,
           presence: myPresence,
           canWrite,
+          canComment: canComment(dynamicSession.scopes),
           isReadOnly: !canWrite
           // Deprecated, kept for backward-compatibility
         };
@@ -5135,6 +5289,14 @@ ${Array.from(traces).join("\n\n")}`
             }
             break;
           }
+          case 400 /* THREAD_CREATED */:
+          case 401 /* THREAD_METADATA_UPDATED */:
+          case 402 /* COMMENT_CREATED */:
+          case 403 /* COMMENT_EDITED */:
+          case 404 /* COMMENT_DELETED */: {
+            eventHub.comments.notify(message);
+            break;
+          }
         }
       }
       notify(updates, doNotBatchUpdates);
@@ -5401,8 +5563,12 @@ ${Array.from(traces).join("\n\n")}`
     history: eventHub.history.observable,
     storageDidLoad: eventHub.storageDidLoad.observable,
     storageStatus: eventHub.storageStatus.observable,
-    ydoc: eventHub.ydoc.observable
+    ydoc: eventHub.ydoc.observable,
+    comments: eventHub.comments.observable
   };
+  const commentsApi = createCommentsApi(config.roomId, delegates.authenticate, {
+    serverEndpoint: "https://api.liveblocks.io/v2"
+  });
   return Object.defineProperty(
     {
       /* NOTE: Exposing __internal here only to allow testing implementation details in unit tests */
@@ -5460,7 +5626,8 @@ ${Array.from(traces).join("\n\n")}`
       getSelf: () => self.current,
       // Presence
       getPresence: () => context.myPresence.current,
-      getOthers: () => context.others.current
+      getOthers: () => context.others.current,
+      ...commentsApi
     },
     // Explictly make the __internal field non-enumerable, to avoid aggressive
     // freezing when used with Immer
@@ -6085,6 +6252,222 @@ function shallow(a, b) {
   return shallowObj(a, b);
 }
 
+// src/lib/AsyncCache.ts
+var noop = () => {
+};
+function isShallowEqual(a, b) {
+  if (a.isLoading !== b.isLoading || a.data === void 0 !== (b.data === void 0) || a.error === void 0 !== (b.error === void 0)) {
+    return false;
+  } else {
+    return shallow(a.data, b.data) && shallow(a.error, b.error);
+  }
+}
+function createCacheItem(key, defaultAsyncFunction, options) {
+  let asyncFunction = defaultAsyncFunction;
+  const context = {
+    isInvalid: true
+  };
+  let state = { isLoading: false };
+  let previousState = { isLoading: false };
+  const eventSource2 = makeEventSource();
+  function notify() {
+    const isEqual = options?.isStateEqual ?? isShallowEqual;
+    if (!isEqual(previousState, state)) {
+      previousState = state;
+      eventSource2.notify(state);
+    }
+  }
+  async function resolve() {
+    if (!context.promise) {
+      return;
+    }
+    try {
+      const data = await context.promise;
+      context.isInvalid = false;
+      state = {
+        isLoading: false,
+        data
+      };
+    } catch (error3) {
+      state = {
+        isLoading: false,
+        data: state.data,
+        error: error3
+      };
+    }
+    context.promise = void 0;
+    notify();
+  }
+  async function revalidate() {
+    context.isInvalid = true;
+    return get();
+  }
+  async function get() {
+    if (context.isInvalid) {
+      if (!context.promise) {
+        context.isInvalid = true;
+        context.promise = asyncFunction(key);
+        state = { isLoading: true, data: state.data };
+        notify();
+      }
+      await resolve();
+    }
+    return getState();
+  }
+  function getState() {
+    return state;
+  }
+  function setAsyncFunction(overrideAsyncFunction) {
+    asyncFunction = overrideAsyncFunction;
+  }
+  return {
+    ...eventSource2.observable,
+    setAsyncFunction,
+    get,
+    getState,
+    revalidate
+  };
+}
+function createAsyncCache(asyncFunction, options) {
+  const cache = /* @__PURE__ */ new Map();
+  function create(key, overrideAsyncFunction) {
+    let cacheItem = cache.get(key);
+    if (cacheItem) {
+      if (overrideAsyncFunction) {
+        cacheItem.setAsyncFunction(overrideAsyncFunction);
+      }
+      return cacheItem;
+    }
+    cacheItem = createCacheItem(
+      key,
+      overrideAsyncFunction ?? asyncFunction,
+      options
+    );
+    cache.set(key, cacheItem);
+    return cacheItem;
+  }
+  function get(key) {
+    return create(key).get();
+  }
+  function getState(key) {
+    return cache.get(key)?.getState();
+  }
+  function revalidate(key) {
+    return create(key).revalidate();
+  }
+  function subscribe(key, callback) {
+    return create(key).subscribe(callback) ?? noop;
+  }
+  function subscribeOnce(key, callback) {
+    return create(key).subscribeOnce(callback) ?? noop;
+  }
+  function has(key) {
+    return cache.has(key);
+  }
+  function clear() {
+    cache.clear();
+  }
+  return {
+    create,
+    get,
+    getState,
+    revalidate,
+    subscribe,
+    subscribeOnce,
+    has,
+    clear
+  };
+}
+
+// src/lib/Poller.ts
+function makePoller(callback) {
+  let context = {
+    state: "stopped",
+    timeoutHandle: null,
+    interval: null,
+    lastScheduledAt: null,
+    remainingInterval: null
+  };
+  function poll() {
+    if (context.state === "running") {
+      schedule(context.interval);
+    }
+    void callback();
+  }
+  function schedule(interval) {
+    context = {
+      state: "running",
+      interval: context.state !== "stopped" ? context.interval : interval,
+      lastScheduledAt: performance.now(),
+      timeoutHandle: setTimeout(poll, interval),
+      remainingInterval: null
+    };
+  }
+  function scheduleRemaining(remaining) {
+    if (context.state !== "paused") {
+      return;
+    }
+    context = {
+      state: "running",
+      interval: context.interval,
+      lastScheduledAt: context.lastScheduledAt,
+      timeoutHandle: setTimeout(poll, remaining),
+      remainingInterval: null
+    };
+  }
+  function start(interval) {
+    if (context.state === "running") {
+      return;
+    }
+    schedule(interval);
+  }
+  function restart(interval) {
+    stop();
+    start(interval);
+  }
+  function pause() {
+    if (context.state !== "running") {
+      return;
+    }
+    clearTimeout(context.timeoutHandle);
+    context = {
+      state: "paused",
+      interval: context.interval,
+      lastScheduledAt: context.lastScheduledAt,
+      timeoutHandle: null,
+      remainingInterval: context.interval - (performance.now() - context.lastScheduledAt)
+    };
+  }
+  function resume() {
+    if (context.state !== "paused") {
+      return;
+    }
+    scheduleRemaining(context.remainingInterval);
+  }
+  function stop() {
+    if (context.state === "stopped") {
+      return;
+    }
+    if (context.timeoutHandle) {
+      clearTimeout(context.timeoutHandle);
+    }
+    context = {
+      state: "stopped",
+      interval: null,
+      lastScheduledAt: null,
+      timeoutHandle: null,
+      remainingInterval: null
+    };
+  }
+  return {
+    start,
+    restart,
+    pause,
+    resume,
+    stop
+  };
+}
+
 // src/index.ts
 detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
 export {
@@ -6096,12 +6479,14 @@ export {
   OpCode,
   ServerMsgCode,
   WebsocketCloseCodes,
-  asArrayWithLegacyMethods,
   asPos,
   assert,
   assertNever,
   b64decode,
+  fancy_console_exports as console,
+  createAsyncCache,
   createClient,
+  createCommentsApi,
   deprecate,
   deprecateIf,
   detectDupes,
@@ -6115,6 +6500,8 @@ export {
   isRootCrdt,
   legacy_patchImmutableObject,
   lsonToJson,
+  makeEventSource,
+  makePoller,
   makePosition,
   nn,
   patchLiveObjectKey,