@liveblocks/node 1.7.1-pre1 → 1.8.0

package/dist/index.js

@@ -3,6 +3,9 @@ var DEFAULT_BASE_URL = "https://api.liveblocks.io";
 async function fetchPolyfill() {
   return typeof globalThis.fetch !== "undefined" ? globalThis.fetch : (await Promise.resolve().then(() => _interopRequireWildcard(require("node-fetch")))).default;
 }
+function isSomething(input) {
+  return input !== null && input !== void 0;
+}
 function isNonEmpty(value) {
   return typeof value === "string" && value.length > 0;
 }
@@ -29,15 +32,31 @@ function normalizeStatusCode(statusCode) {
     return 403;
   }
 }
-function urljoin(baseUrl, path) {
-  const url = new URL(baseUrl);
-  url.pathname = path;
-  return url.toString();
+function toURLSearchParams(params) {
+  const result = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      result.set(key, value.toString());
+    }
+  }
+  return result;
+}
+function urljoin(baseUrl, path, params) {
+  const url2 = new URL(path, baseUrl);
+  if (params !== void 0) {
+    url2.search = (params instanceof URLSearchParams ? params : toURLSearchParams(params)).toString();
+  }
+  return url2.toString();
+}
+function url(strings, ...values) {
+  return strings.reduce(
+    (result, str, i) => result + encodeURIComponent(_nullishCoalesce(values[i - 1], () => ( ""))) + str
+  );
 }
 
 // src/authorize.ts
 async function authorize(options) {
-  let url = null;
+  let url2 = null;
   try {
     const { room, secret, userId, userInfo, groupIds } = (
       // Ensure we'll validate inputs at runtime
@@ -46,7 +65,7 @@ async function authorize(options) {
     assertNonEmpty(secret, "secret");
     assertNonEmpty(room, "room");
     assertNonEmpty(userId, "userId");
-    url = buildLiveblocksAuthorizeEndpoint(options, room);
+    url2 = buildLiveblocksAuthorizeEndpoint(options, room);
     const fetch = await fetchPolyfill();
     const resp = await fetch(buildLiveblocksAuthorizeEndpoint(options, room), {
       method: "POST",
@@ -67,7 +86,7 @@ async function authorize(options) {
   } catch (er) {
     return {
       status: 503,
-      body: (url ? `Call to "${url}" failed.` : "Invalid authorize request.") + ' See "error" for more information.',
+      body: (url2 ? `Call to "${url2}" failed.` : "Invalid authorize request.") + ' See "error" for more information.',
       error: er
     };
   }
@@ -181,7 +200,7 @@ var Session = class {
       };
     }
     try {
-      const resp = await this._postFn("/v2/authorize-user", {
+      const resp = await this._postFn(url`/v2/authorize-user`, {
         // Required
         userId: this._userId,
         permissions: this.serializePermissions(),
@@ -216,28 +235,57 @@ var Liveblocks = class {
   }
   /** @internal */
   async post(path, json) {
-    const url = urljoin(this._baseUrl, path);
+    const url2 = urljoin(this._baseUrl, path);
     const headers = {
       Authorization: `Bearer ${this._secret}`,
       "Content-Type": "application/json"
     };
     const fetch = await fetchPolyfill();
-    return fetch(url, {
+    const res = await fetch(url2, {
       method: "POST",
       headers,
       body: JSON.stringify(json)
     });
+    return res;
   }
   /** @internal */
-  async get(path) {
-    const url = urljoin(this._baseUrl, path);
+  async put(path, json) {
+    const url2 = urljoin(this._baseUrl, path);
     const headers = {
       Authorization: `Bearer ${this._secret}`,
       "Content-Type": "application/json"
     };
     const fetch = await fetchPolyfill();
-    return fetch(url, { method: "GET", headers });
+    const res = await fetch(url2, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify(json)
+    });
+    return res;
   }
+  /** @internal */
+  async delete(path) {
+    const url2 = urljoin(this._baseUrl, path);
+    const headers = {
+      Authorization: `Bearer ${this._secret}`
+    };
+    const fetch = await fetchPolyfill();
+    const res = await fetch(url2, { method: "DELETE", headers });
+    return res;
+  }
+  /** @internal */
+  async get(path, params) {
+    const url2 = urljoin(this._baseUrl, path, params);
+    const headers = {
+      Authorization: `Bearer ${this._secret}`
+    };
+    const fetch = await fetchPolyfill();
+    const res = await fetch(url2, { method: "GET", headers });
+    return res;
+  }
+  /* -------------------------------------------------------------------------------------------------
+   * Authentication
+   * -----------------------------------------------------------------------------------------------*/
   /**
    * Prepares a new session to authorize a user to access Liveblocks.
    *
@@ -255,7 +303,7 @@ var Liveblocks = class {
    *
    */
   prepareSession(userId, options) {
-    return new Session(this.post.bind(this), userId, _optionalChain([options, 'optionalAccess', _ => _.userInfo]));
+    return new Session(this.post.bind(this), userId, _optionalChain([options, 'optionalAccess', _2 => _2.userInfo]));
   }
   /**
    * Call this to authenticate the user as an actor you want to allow to use
@@ -291,7 +339,7 @@ var Liveblocks = class {
    */
   // These fields define the security identity of the user. Whatever you pass in here will define which
   async identifyUser(identity, options) {
-    const path = "/v2/identify-user";
+    const path = url`/v2/identify-user`;
     const userId = typeof identity === "string" ? identity : identity.userId;
     const groupIds = typeof identity === "string" ? void 0 : identity.groupIds;
     assertNonEmpty(userId, "userId");
@@ -300,7 +348,7 @@ var Liveblocks = class {
         userId,
         groupIds,
         // Optional metadata
-        userInfo: _optionalChain([options, 'optionalAccess', _2 => _2.userInfo])
+        userInfo: _optionalChain([options, 'optionalAccess', _3 => _3.userInfo])
       });
       return {
         status: normalizeStatusCode(resp.status),
@@ -317,6 +365,391 @@ var Liveblocks = class {
       };
     }
   }
+  /* -------------------------------------------------------------------------------------------------
+   * Room
+   * -----------------------------------------------------------------------------------------------*/
+  /**
+   * Returns a list of your rooms. The rooms are returned sorted by creation date, from newest to oldest. You can filter rooms by metadata, users accesses and groups accesses.
+   * @param params.limit (optional) A limit on the number of rooms to be returned. The limit can range between 1 and 100, and defaults to 20.
+   * @param params.startingAfter (optional) A cursor used for pagination. You get the value from the response of the previous page.
+   * @param params.userId (optional) A filter on users accesses.
+   * @param params.metadata (optional) A filter on metadata. Multiple metadata keys can be used to filter rooms.
+   * @param params.groupIds (optional) A filter on groups accesses. Multiple groups can be used.
+   * @returns A list of rooms.
+   */
+  async getRooms(params = {}) {
+    const path = url`/v2/rooms`;
+    const queryParams = {
+      limit: params.limit,
+      startingAfter: params.startingAfter,
+      userId: params.userId,
+      groupIds: params.groupIds ? params.groupIds.join(",") : void 0,
+      // "Flatten" {metadata: {foo: "bar"}} to {"metadata.foo": "bar"}
+      ...Object.fromEntries(
+        Object.entries(_nullishCoalesce(params.metadata, () => ( {}))).map(([key, val]) => {
+          const value = Array.isArray(val) ? val.join(",") : val;
+          return [`metadata.${key}`, value];
+        })
+      )
+    };
+    const res = await this.get(path, queryParams);
+    const data = await res.json();
+    const rooms = data.data.map((room) => {
+      const lastConnectionAt = room.lastConnectionAt ? new Date(room.lastConnectionAt) : void 0;
+      const createdAt = room.createdAt ? new Date(room.createdAt) : void 0;
+      return {
+        ...room,
+        lastConnectionAt,
+        createdAt
+      };
+    });
+    return {
+      ...data,
+      data: rooms
+    };
+  }
+  /**
+   * Creates a new room with the given id.
+   * @param roomId The id of the room to create.
+   * @param params.defaultAccesses The default accesses for the room.
+   * @param params.groupAccesses (optional) The group accesses for the room. Can contain a maximum of 100 entries. Key length has a limit of 40 characters.
+   * @param params.userAccesses (optional) The user accesses for the room. Can contain a maximum of 100 entries. Key length has a limit of 40 characters.
+   * @param params.metadata (optional) The metadata for the room. Supports upto a maximum of 50 entries. Key length has a limit of 40 characters. Value length has a limit of 256 characters.
+   * @returns The created room.
+   */
+  async createRoom(roomId, params) {
+    const { defaultAccesses, groupsAccesses, usersAccesses, metadata } = params;
+    const res = await this.post(url`/v2/rooms`, {
+      id: roomId,
+      defaultAccesses,
+      groupsAccesses,
+      usersAccesses,
+      metadata
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    const data = await res.json();
+    const lastConnectionAt = data.lastConnectionAt ? new Date(data.lastConnectionAt) : void 0;
+    const createdAt = data.createdAt ? new Date(data.createdAt) : void 0;
+    return {
+      ...data,
+      lastConnectionAt,
+      createdAt
+    };
+  }
+  /**
+   * Returns a room with the given id.
+   * @param roomId The id of the room to return.
+   * @returns The room with the given id.
+   */
+  async getRoom(roomId) {
+    const res = await this.get(url`/v2/rooms/${roomId}`);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    const data = await res.json();
+    const lastConnectionAt = data.lastConnectionAt ? new Date(data.lastConnectionAt) : void 0;
+    const createdAt = data.createdAt ? new Date(data.createdAt) : void 0;
+    return {
+      ...data,
+      lastConnectionAt,
+      createdAt
+    };
+  }
+  /**
+   * Updates specific properties of a room. It’s not necessary to provide the entire room’s information.
+   * Setting a property to `null` means to delete this property.
+   * @param roomId The id of the room to update.
+   * @param params.defaultAccesses (optional) The default accesses for the room.
+   * @param params.groupAccesses (optional) The group accesses for the room. Can contain a maximum of 100 entries. Key length has a limit of 40 characters.
+   * @param params.userAccesses (optional) The user accesses for the room. Can contain a maximum of 100 entries. Key length has a limit of 40 characters.
+   * @param params.metadata (optional) The metadata for the room. Supports upto a maximum of 50 entries. Key length has a limit of 40 characters. Value length has a limit of 256 characters.
+   * @returns The updated room.
+   */
+  async updateRoom(roomId, params) {
+    const { defaultAccesses, groupsAccesses, usersAccesses, metadata } = params;
+    const res = await this.post(url`/v2/rooms/${roomId}`, {
+      defaultAccesses,
+      groupsAccesses,
+      usersAccesses,
+      metadata
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    const data = await res.json();
+    const lastConnectionAt = data.lastConnectionAt ? new Date(data.lastConnectionAt) : void 0;
+    const createdAt = data.createdAt ? new Date(data.createdAt) : void 0;
+    return {
+      ...data,
+      lastConnectionAt,
+      createdAt
+    };
+  }
+  /**
+   * Deletes a room with the given id. A deleted room is no longer accessible from the API or the dashboard and it cannot be restored.
+   * @param roomId The id of the room to delete.
+   */
+  async deleteRoom(roomId) {
+    const res = await this.delete(url`/v2/rooms/${roomId}`);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+  }
+  /**
+   * Returns a list of users currently present in the requested room. For better performance, we recommand to call this endpoint every 10 seconds maximum. Duplicates can happen if a user is in the requested room with multiple browser tabs opened.
+   * @param roomId The id of the room to get the users from.
+   * @returns A list of users currently present in the requested room.
+   */
+  async getActiveUsers(roomId) {
+    const res = await this.get(url`/v2/rooms/${roomId}/active_users`);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    return await res.json();
+  }
+  /**
+   * Boadcasts an event to a room without having to connect to it via the client from @liveblocks/client. The connectionId passed to event listeners is -1 when using this API.
+   * @param roomId The id of the room to broadcast the event to.
+   * @param message The message to broadcast. It can be any JSON serializable value.
+   */
+  async broadcastEvent(roomId, message) {
+    const res = await this.post(
+      url`/v2/rooms/${roomId}/broadcast_event`,
+      message
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+  }
+  async getStorageDocument(roomId, format = "plain-lson") {
+    const res = await this.get(url`/v2/rooms/${roomId}/storage`, { format });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    return await res.json();
+  }
+  /**
+   * Initializes a room’s Storage. The room must already exist and have an empty Storage.
+   * Calling this endpoint will disconnect all users from the room if there are any.
+   *
+   * @param roomId The id of the room to initialize the storage from.
+   * @param document The document to initialize the storage with.
+   * @returns The initialized storage document. It is of the same format as the one passed in.
+   */
+  async initializeStorageDocument(roomId, document) {
+    const res = await this.post(url`/v2/rooms/${roomId}/storage`, document);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    return await res.json();
+  }
+  /**
+   * Deletes all of the room’s Storage data and disconnect all users from the room if there are any. Note that this does not delete the Yjs document in the room if one exists.
+   * @param roomId The id of the room to delete the storage from.
+   */
+  async deleteStorageDocument(roomId) {
+    const res = await this.delete(url`/v2/rooms/${roomId}/storage`);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+  }
+  /* -------------------------------------------------------------------------------------------------
+   * Yjs
+   * -----------------------------------------------------------------------------------------------*/
+  /**
+   * Returns a JSON representation of the room’s Yjs document.
+   * @param roomId The id of the room to get the Yjs document from.
+   * @param params.format (optional) If true, YText will return formatting.
+   * @param params.key (optional) If provided, returns only a single key’s value, e.g. doc.get(key).toJSON().
+   * @param params.type (optional) Used with key to override the inferred type, i.e. "ymap" will return doc.get(key, Y.Map).
+   * @returns A JSON representation of the room’s Yjs document.
+   */
+  async getYjsDocument(roomId, params = {}) {
+    const { format, key, type } = params;
+    const path = url`v2/rooms/${roomId}/ydoc`;
+    const res = await this.get(path, {
+      formatting: format ? "true" : void 0,
+      key,
+      type
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    return await res.json();
+  }
+  /**
+   * Send a Yjs binary update to the room’s Yjs document. You can use this endpoint to initialize Yjs data for the room or to update the room’s Yjs document.
+   * @param roomId The id of the room to send the Yjs binary update to.
+   * @param params The Yjs binary update to send. Read the [Yjs documentation](https://docs.yjs.dev/api/document-updates) to learn how to create a binary update.
+   */
+  async sendYjsBinaryUpdate(roomId, params) {
+    const { update } = params;
+    const res = await this.put(url`/v2/rooms/${roomId}/ydoc`, {
+      update
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+  }
+  /**
+   * Returns the room’s Yjs document encoded as a single binary update. This can be used by Y.applyUpdate(responseBody) to get a copy of the document in your backend.
+   * See [Yjs documentation](https://docs.yjs.dev/api/document-updates) for more information on working with updates.
+   * @param roomId The id of the room to get the Yjs document from.
+   * @returns The room’s Yjs document encoded as a single binary update.
+   */
+  async getYjsDocumentAsBinaryUpdate(roomId) {
+    const res = await this.get(url`/v2/rooms/${roomId}/ydoc-binary`);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    return res.arrayBuffer();
+  }
+  /* -------------------------------------------------------------------------------------------------
+   * Schema Validation
+   * -----------------------------------------------------------------------------------------------*/
+  /**
+   * Creates a new schema which can be referenced later to enforce a room’s Storage data structure.
+   * @param name The name used to reference the schema. Must be a non-empty string with less than 65 characters and only contain lowercase letters, numbers and dashes
+   * @param body The exact allowed shape of data in the room. It is a multi-line string written in the [Liveblocks schema syntax](https://liveblocks.io/docs/platform/schema-validation/syntax).
+   * @returns The created schema.
+   */
+  async createSchema(name, body) {
+    const res = await this.post(url`/v2/schemas`, {
+      name,
+      body
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    const data = await res.json();
+    const createdAt = new Date(data.createdAt);
+    const updatedAt = new Date(data.updatedAt);
+    return {
+      ...data,
+      createdAt,
+      updatedAt
+    };
+  }
+  /**
+   * Returns a schema by its id.
+   * @param schemaId Id of the schema - this is the combination of the schema name and version of the schema to update. For example, `my-schema@1`.
+   * @returns The schema with the given id.
+   */
+  async getSchema(schemaId) {
+    const res = await this.get(url`/v2/schemas/${schemaId}`);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    const data = await res.json();
+    const createdAt = new Date(data.createdAt);
+    const updatedAt = new Date(data.updatedAt);
+    return {
+      ...data,
+      createdAt,
+      updatedAt
+    };
+  }
+  /**
+   * Updates the body for the schema. A schema can only be updated if it is not used by any room.
+   * @param schemaId Id of the schema - this is the combination of the schema name and version of the schema to update. For example, `my-schema@1`.
+   * @param body The exact allowed shape of data in the room. It is a multi-line string written in the [Liveblocks schema syntax](https://liveblocks.io/docs/platform/schema-validation/syntax).
+   * @returns The updated schema. The version of the schema will be incremented.
+   */
+  async updateSchema(schemaId, body) {
+    const res = await this.put(url`/v2/schemas/${schemaId}`, {
+      body
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    const data = await res.json();
+    const createdAt = new Date(data.createdAt);
+    const updatedAt = new Date(data.updatedAt);
+    return {
+      ...data,
+      createdAt,
+      updatedAt
+    };
+  }
+  /**
+   * Deletes a schema by its id. A schema can only be deleted if it is not used by any room.
+   * @param schemaId Id of the schema - this is the combination of the schema name and version of the schema to update. For example, `my-schema@1`.
+   */
+  async deleteSchema(schemaId) {
+    const res = await this.delete(url`/v2/schemas/${schemaId}`);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+  }
+  /**
+   * Returns the schema attached to a room.
+   * @param roomId The id of the room to get the schema from.
+   * @returns
+   */
+  async getSchemaByRoomId(roomId) {
+    const res = await this.get(url`/v2/rooms/${roomId}/schema`);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    const data = await res.json();
+    const createdAt = new Date(data.createdAt);
+    const updatedAt = new Date(data.updatedAt);
+    return {
+      ...data,
+      createdAt,
+      updatedAt
+    };
+  }
+  /**
+   * Attaches a schema to a room, and instantly enables runtime schema validation for the room.
+   * If the current contents of the room’s Storage do not match the schema, attaching will fail and the error message will give details on why the schema failed to attach.
+   * @param roomId The id of the room to attach the schema to.
+   * @param schemaId Id of the schema - this is the combination of the schema name and version of the schema to update. For example, `my-schema@1`.
+   * @returns The schema id as JSON.
+   */
+  async attachSchemaToRoom(roomId, schemaId) {
+    const res = await this.post(url`/v2/rooms/${roomId}/schema`, {
+      schema: schemaId
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+    return await res.json();
+  }
+  /**
+   * Detaches a schema from a room, and disables runtime schema validation for the room.
+   * @param roomId The id of the room to detach the schema from.
+   */
+  async detachSchemaFromRoom(roomId) {
+    const res = await this.delete(url`/v2/rooms/${roomId}/schema`);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
+    }
+  }
+  /* -------------------------------------------------------------------------------------------------
+   * Comments
+   * -----------------------------------------------------------------------------------------------*/
   /**
    * Gets all the threads in a room.
    *
@@ -325,17 +758,12 @@ var Liveblocks = class {
    */
   async getThreads(params) {
     const { roomId } = params;
-    const resp = await this.get(
-      `/v2/rooms/${encodeURIComponent(roomId)}/threads`
-    );
-    const body = await resp.json();
-    if (resp.status !== 200) {
-      throw {
-        status: resp.status,
-        ...body
-      };
+    const res = await this.get(url`/v2/rooms/${roomId}/threads`);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
     }
-    return body;
+    return await res.json();
   }
   /**
    * Gets a thread.
@@ -346,19 +774,12 @@ var Liveblocks = class {
    */
   async getThread(params) {
     const { roomId, threadId } = params;
-    const resp = await this.get(
-      `/v2/rooms/${encodeURIComponent(roomId)}/threads/${encodeURIComponent(
-        threadId
-      )}`
-    );
-    const body = await resp.json();
-    if (resp.status !== 200) {
-      throw {
-        status: resp.status,
-        ...body
-      };
+    const res = await this.get(url`/v2/rooms/${roomId}/threads/${threadId}`);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
     }
-    return body;
+    return await res.json();
   }
   /**
    * Gets a thread's participants.
@@ -372,19 +793,14 @@ var Liveblocks = class {
    */
   async getThreadParticipants(params) {
     const { roomId, threadId } = params;
-    const resp = await this.get(
-      `/v2/rooms/${encodeURIComponent(roomId)}/threads/${encodeURIComponent(
-        threadId
-      )}/participants`
+    const res = await this.get(
+      url`/v2/rooms/${roomId}/threads/${threadId}/participants`
     );
-    const body = await resp.json();
-    if (resp.status !== 200) {
-      throw {
-        status: resp.status,
-        ...body
-      };
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
     }
-    return body;
+    return await res.json();
   }
   /**
    * Gets a thread's comment.
@@ -396,22 +812,327 @@ var Liveblocks = class {
    */
   async getComment(params) {
     const { roomId, threadId, commentId } = params;
-    const resp = await this.get(
-      `/v2/rooms/${encodeURIComponent(roomId)}/threads/${encodeURIComponent(
-        threadId
-      )}/comments/${encodeURIComponent(commentId)}`
+    const res = await this.get(
+      url`/v2/rooms/${roomId}/threads/${threadId}/comments/${commentId}`
     );
-    const body = await resp.json();
-    if (resp.status !== 200) {
-      throw {
-        status: resp.status,
-        ...body
-      };
+    if (!res.ok) {
+      const text = await res.text();
+      throw new LiveblocksError(res.status, text);
     }
-    return body;
+    return await res.json();
+  }
+};
+var LiveblocksError = class extends Error {
+  constructor(status, message = "") {
+    super(message);
+    this.name = "LiveblocksError";
+    this.status = status;
   }
 };
 
+// src/comment-body.ts
+function isCommentBodyParagraph(element) {
+  return "type" in element && element.type === "mention";
+}
+function isCommentBodyText(element) {
+  return "text" in element && typeof element.text === "string";
+}
+function isCommentBodyMention(element) {
+  return "type" in element && element.type === "mention";
+}
+function isCommentBodyLink(element) {
+  return "type" in element && element.type === "link";
+}
+var commentBodyElementsGuards = {
+  paragraph: isCommentBodyParagraph,
+  text: isCommentBodyText,
+  link: isCommentBodyLink,
+  mention: isCommentBodyMention
+};
+var commentBodyElementsTypes = {
+  paragraph: "block",
+  text: "inline",
+  link: "inline",
+  mention: "inline"
+};
+function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
+  if (!body || !_optionalChain([body, 'optionalAccess', _4 => _4.content])) {
+    return;
+  }
+  const element = typeof elementOrVisitor === "string" ? elementOrVisitor : void 0;
+  const type = element ? commentBodyElementsTypes[element] : "all";
+  const guard = element ? commentBodyElementsGuards[element] : () => true;
+  const visitor = typeof elementOrVisitor === "function" ? elementOrVisitor : possiblyVisitor;
+  for (const block of body.content) {
+    if (type === "all" || type === "block") {
+      if (guard(block)) {
+        _optionalChain([visitor, 'optionalCall', _5 => _5(block)]);
+      }
+    }
+    if (type === "all" || type === "inline") {
+      for (const inline of block.children) {
+        if (guard(inline)) {
+          _optionalChain([visitor, 'optionalCall', _6 => _6(inline)]);
+        }
+      }
+    }
+  }
+}
+function getMentionedIdsFromCommentBody(body) {
+  const mentionedIds = /* @__PURE__ */ new Set();
+  traverseCommentBody(
+    body,
+    "mention",
+    (mention) => mentionedIds.add(mention.id)
+  );
+  return Array.from(mentionedIds);
+}
+async function resolveUsersInCommentBody(body, resolveUsers) {
+  const resolvedUsers = /* @__PURE__ */ new Map();
+  if (!resolveUsers) {
+    return resolvedUsers;
+  }
+  const userIds = getMentionedIdsFromCommentBody(body);
+  const users = await resolveUsers({
+    userIds
+  });
+  for (const [index, userId] of userIds.entries()) {
+    const user = _optionalChain([users, 'optionalAccess', _7 => _7[index]]);
+    if (user) {
+      resolvedUsers.set(userId, user);
+    }
+  }
+  return resolvedUsers;
+}
+var htmlEscapables = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var htmlEscapablesRegex = new RegExp(
+  Object.keys(htmlEscapables).map((entity) => `\\${entity}`).join("|"),
+  "g"
+);
+function htmlSafe(value) {
+  return new HtmlSafeString([String(value)], []);
+}
+function joinHtml(strings) {
+  if (strings.length <= 0) {
+    return new HtmlSafeString([""], []);
+  }
+  return new HtmlSafeString(
+    ["", ...Array(strings.length - 1).fill(""), ""],
+    strings
+  );
+}
+function escapeHtml(value) {
+  if (value instanceof HtmlSafeString) {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return joinHtml(value).toString();
+  }
+  return String(value).replace(
+    htmlEscapablesRegex,
+    (character) => htmlEscapables[character]
+  );
+}
+var HtmlSafeString = class {
+  constructor(strings, values) {
+    this._strings = strings;
+    this._values = values;
+  }
+  toString() {
+    return this._strings.reduce((result, str, i) => {
+      return result + escapeHtml(this._values[i - 1]) + str;
+    });
+  }
+};
+function html(strings, ...values) {
+  return new HtmlSafeString(strings, values);
+}
+var markdownEscapables = {
+  _: "\\_",
+  "*": "\\*",
+  "#": "\\#",
+  "`": "\\`",
+  "~": "\\~",
+  "!": "\\!",
+  "|": "\\|",
+  "(": "\\(",
+  ")": "\\)",
+  "{": "\\{",
+  "}": "\\}",
+  "[": "\\[",
+  "]": "\\]"
+};
+var markdownEscapablesRegex = new RegExp(
+  Object.keys(markdownEscapables).map((entity) => `\\${entity}`).join("|"),
+  "g"
+);
+function joinMarkdown(strings) {
+  if (strings.length <= 0) {
+    return new MarkdownSafeString([""], []);
+  }
+  return new MarkdownSafeString(
+    ["", ...Array(strings.length - 1).fill(""), ""],
+    strings
+  );
+}
+function escapeMarkdown(value) {
+  if (value instanceof MarkdownSafeString) {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return joinMarkdown(value).toString();
+  }
+  return String(value).replace(
+    markdownEscapablesRegex,
+    (character) => markdownEscapables[character]
+  );
+}
+var MarkdownSafeString = class {
+  constructor(strings, values) {
+    this._strings = strings;
+    this._values = values;
+  }
+  toString() {
+    return this._strings.reduce((result, str, i) => {
+      return result + escapeMarkdown(this._values[i - 1]) + str;
+    });
+  }
+};
+function markdown(strings, ...values) {
+  return new MarkdownSafeString(strings, values);
+}
+function toAbsoluteUrl(url2) {
+  if (url2.startsWith("http://") || url2.startsWith("https://")) {
+    return url2;
+  } else if (url2.startsWith("www.")) {
+    return "https://" + url2;
+  }
+  return;
+}
+var stringifyCommentBodyPlainElements = {
+  paragraph: ({ children }) => children,
+  text: ({ element }) => element.text,
+  link: ({ element }) => element.url,
+  mention: ({ element, user }) => {
+    return `@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _8 => _8.name]), () => ( element.id))}`;
+  }
+};
+var stringifyCommentBodyHtmlElements = {
+  paragraph: ({ children }) => {
+    return children ? html`<p>${htmlSafe(children)}</p>` : children;
+  },
+  text: ({ element }) => {
+    let children = element.text;
+    if (!children) {
+      return children;
+    }
+    if (element.bold) {
+      children = html`<strong>${children}</strong>`;
+    }
+    if (element.italic) {
+      children = html`<em>${children}</em>`;
+    }
+    if (element.strikethrough) {
+      children = html`<s>${children}</s>`;
+    }
+    if (element.code) {
+      children = html`<code>${children}</code>`;
+    }
+    return children;
+  },
+  link: ({ element, href }) => {
+    return html`<a href="${href}" target="_blank" rel="noopener noreferrer">${element.url}</a>`;
+  },
+  mention: ({ element, user }) => {
+    return html`<span data-mention>@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _9 => _9.name]), () => ( element.id))}</span>`;
+  }
+};
+var stringifyCommentBodyMarkdownElements = {
+  paragraph: ({ children }) => {
+    return children;
+  },
+  text: ({ element }) => {
+    let children = element.text;
+    if (!children) {
+      return children;
+    }
+    if (element.bold) {
+      children = markdown`**${children}**`;
+    }
+    if (element.italic) {
+      children = markdown`_${children}_`;
+    }
+    if (element.strikethrough) {
+      children = markdown`~~${children}~~`;
+    }
+    if (element.code) {
+      children = markdown`\`${children}\``;
+    }
+    return children;
+  },
+  link: ({ element, href }) => {
+    return markdown`[${element.url}](${href})`;
+  },
+  mention: ({ element, user }) => {
+    return markdown`@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _10 => _10.name]), () => ( element.id))}`;
+  }
+};
+async function stringifyCommentBody(body, options) {
+  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _11 => _11.format]), () => ( "plain"));
+  const separator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _12 => _12.separator]), () => ( (format === "markdown" ? "\n\n" : "\n")));
+  const elements = {
+    ...format === "html" ? stringifyCommentBodyHtmlElements : format === "markdown" ? stringifyCommentBodyMarkdownElements : stringifyCommentBodyPlainElements,
+    ..._optionalChain([options, 'optionalAccess', _13 => _13.elements])
+  };
+  const resolvedUsers = await resolveUsersInCommentBody(
+    body,
+    _optionalChain([options, 'optionalAccess', _14 => _14.resolveUsers])
+  );
+  const blocks = body.content.map((block, blockIndex) => {
+    switch (block.type) {
+      case "paragraph": {
+        const paragraph = block.children.map((inline, inlineIndex) => {
+          if (isCommentBodyMention(inline)) {
+            return inline.id ? elements.mention(
+              {
+                element: inline,
+                user: resolvedUsers.get(inline.id)
+              },
+              inlineIndex
+            ) : null;
+          }
+          if (isCommentBodyLink(inline)) {
+            return elements.link(
+              {
+                element: inline,
+                href: _nullishCoalesce(toAbsoluteUrl(inline.url), () => ( inline.url))
+              },
+              inlineIndex
+            );
+          }
+          if (isCommentBodyText(inline)) {
+            return elements.text({ element: inline }, inlineIndex);
+          }
+          return null;
+        }).filter(isSomething).join("");
+        return elements.paragraph(
+          { element: block, children: paragraph },
+          blockIndex
+        );
+      }
+      default:
+        return null;
+    }
+  });
+  return blocks.filter(isSomething).join(separator);
+}
+
 // src/webhooks.ts
 var _base64 = require('@stablelib/base64'); var base64 = _interopRequireWildcard(_base64);
 var _fastsha256 = require('fast-sha256'); var sha256 = _interopRequireWildcard(_fastsha256);
@@ -530,5 +1251,7 @@ var isNotUndefined = (value) => value !== void 0;
 
 
 
-exports.Liveblocks = Liveblocks; exports.WebhookHandler = WebhookHandler; exports.authorize = authorize;
+
+
+exports.Liveblocks = Liveblocks; exports.WebhookHandler = WebhookHandler; exports.authorize = authorize; exports.getMentionedIdsFromCommentBody = getMentionedIdsFromCommentBody; exports.stringifyCommentBody = stringifyCommentBody;
 //# sourceMappingURL=index.js.map