docs(repo): added missing drscriptions

Author: mandarini

packages/core/realtime-js/src/RealtimeChannel.ts

@@ -182,6 +182,11 @@ export default class RealtimeChannel {
   private: boolean
 
   /**
+   * Creates a channel that can broadcast messages, sync presence, and listen to Postgres changes.
+   *
+   * The topic determines which realtime stream you are subscribing to. Config options let you
+   * enable acknowledgement for broadcasts, presence tracking, or private channels.
+   *
    * @example
    * ```ts
    * import RealtimeClient from '@supabase/realtime-js'
@@ -364,10 +369,20 @@ export default class RealtimeChannel {
     return this
   }
 
+  /**
+   * Returns the current presence state for this channel.
+   *
+   * The shape is a map keyed by presence key (for example a user id) where each entry contains the
+   * tracked metadata for that user.
+   */
   presenceState<T extends { [key: string]: any } = {}>(): RealtimePresenceState<T> {
     return this.presence.state as RealtimePresenceState<T>
   }
 
+  /**
+   * Sends the supplied payload to the presence tracker so other subscribers can see that this
+   * client is online. Use `untrack` to stop broadcasting presence for the same key.
+   */
   async track(
     payload: { [key: string]: any },
     opts: { [key: string]: any } = {}
@@ -382,6 +397,9 @@ export default class RealtimeChannel {
     )
   }
 
+  /**
+   * Removes the current presence state for this client.
+   */
   async untrack(opts: { [key: string]: any } = {}): Promise<RealtimeChannelSendResponse> {
     return await this.send(
       {
@@ -658,6 +676,10 @@ export default class RealtimeChannel {
     }
   }
 
+  /**
+   * Updates the payload that will be sent the next time the channel joins (reconnects).
+   * Useful for rotating access tokens or updating config without re-creating the channel.
+   */
   updateJoinPayload(payload: { [key: string]: any }): void {
     this.joinPush.updatePayload(payload)
   }

packages/core/realtime-js/src/RealtimeClient.ts

@@ -55,6 +55,10 @@ const CONNECTION_TIMEOUTS = {
 const RECONNECT_INTERVALS = [1000, 2000, 5000, 10000] as const
 const DEFAULT_RECONNECT_FALLBACK = 10000
 
+/**
+ * Minimal WebSocket constructor interface that RealtimeClient can work with.
+ * Supply a compatible implementation (native WebSocket, `ws`, etc) when running outside the browser.
+ */
 export interface WebSocketLikeConstructor {
   new (address: string | URL, subprotocols?: string | string[] | undefined): WebSocketLike
   // Allow additional properties that may exist on WebSocket constructors
@@ -364,6 +368,13 @@ export default class RealtimeClient {
     return this._connectionState === 'disconnecting'
   }
 
+  /**
+   * Creates (or reuses) a {@link RealtimeChannel} for the provided topic.
+   *
+   * Topics are automatically prefixed with `realtime:` to match the Realtime service.
+   * If a channel with the same topic already exists it will be returned instead of creating
+   * a duplicate connection.
+   */
   channel(topic: string, params: RealtimeChannelOptions = { config: {} }): RealtimeChannel {
     const realtimeTopic = `realtime:${topic}`
     const exists = this.getChannels().find((c: RealtimeChannel) => c.topic === realtimeTopic)
@@ -467,6 +478,10 @@ export default class RealtimeClient {
     this._setAuthSafely('heartbeat')
   }
 
+  /**
+   * Sets a callback that receives lifecycle events for internal heartbeat messages.
+   * Useful for instrumenting connection health (e.g. sent/ok/timeout/disconnected).
+   */
   onHeartbeat(callback: (status: HeartbeatStatus) => void): void {
     this.heartbeatCallback = callback
   }

packages/core/realtime-js/src/RealtimePresence.ts

@@ -72,13 +72,11 @@ export default class RealtimePresence {
   }
 
   /**
-   * Initializes the Presence.
+   * Creates a Presence helper that keeps the local presence state in sync with the server.
+   *
+   * @param channel - The realtime channel to bind to.
+   * @param opts - Optional custom event names, e.g. `{ events: { state: 'state', diff: 'diff' } }`.
    *
-   * @param channel - The RealtimeChannel
-   * @param opts - The options,
-   *        for example `{events: {state: 'state', diff: 'diff'}}`
-   */
-  /**
    * @example
    * ```ts
    * const presence = new RealtimePresence(channel)

packages/core/realtime-js/src/lib/websocket-factory.ts

@@ -7,15 +7,27 @@ export interface WebSocketLike {
   readonly url: string
   readonly protocol: string
 
+  /**
+   * Closes the socket, optionally providing a close code and reason.
+   */
   close(code?: number, reason?: string): void
+  /**
+   * Sends data through the socket using the underlying implementation.
+   */
   send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void
 
   onopen: ((this: any, ev: Event) => any) | null
   onmessage: ((this: any, ev: MessageEvent) => any) | null
   onclose: ((this: any, ev: CloseEvent) => any) | null
   onerror: ((this: any, ev: Event) => any) | null
 
+  /**
+   * Registers an event listener on the socket (compatible with browser WebSocket API).
+   */
   addEventListener(type: string, listener: EventListener): void
+  /**
+   * Removes a previously registered event listener.
+   */
   removeEventListener(type: string, listener: EventListener): void
 
   // Add additional properties that may exist on WebSocket implementations
@@ -36,6 +48,10 @@ export interface WebSocketEnvironment {
  * Utilities for creating WebSocket instances across runtimes.
  */
 export class WebSocketFactory {
+  /**
+   * Static-only utility – prevent instantiation.
+   */
+  private constructor() {}
   private static detectEnvironment(): WebSocketEnvironment {
     if (typeof WebSocket !== 'undefined') {
       return { type: 'native', constructor: WebSocket }

packages/core/storage-js/src/lib/vectors/StorageVectorsClient.ts

@@ -82,6 +82,13 @@ export interface StorageVectorsClientOptions {
  * ```
  */
 export class StorageVectorsClient extends VectorBucketApi {
+  /**
+   * Creates a StorageVectorsClient that can manage buckets, indexes, and vectors.
+   *
+   * @param url - Base URL of the Storage Vectors REST API.
+   * @param options.headers - Optional headers (for example `Authorization`) applied to every request.
+   * @param options.fetch - Optional custom `fetch` implementation for non-browser runtimes.
+   */
   constructor(url: string, options: StorageVectorsClientOptions = {}) {
     super(url, options.headers || {}, options.fetch)
   }
@@ -121,6 +128,9 @@ export class StorageVectorsClient extends VectorBucketApi {
 export class VectorBucketScope extends VectorIndexApi {
   private vectorBucketName: string
 
+  /**
+   * Creates a helper that automatically scopes all index operations to the provided bucket.
+   */
   constructor(
     url: string,
     headers: { [key: string]: string },
@@ -258,6 +268,9 @@ export class VectorIndexScope extends VectorDataApi {
   private vectorBucketName: string
   private indexName: string
 
+  /**
+   * Creates a helper that automatically scopes all vector operations to the provided bucket/index names.
+   */
   constructor(
     url: string,
     headers: { [key: string]: string },

packages/core/storage-js/src/lib/vectors/VectorBucketApi.ts

@@ -24,6 +24,11 @@ export default class VectorBucketApi {
    * @param url - The base URL for the storage vectors API
    * @param headers - HTTP headers to include in requests
    * @param fetch - Optional custom fetch implementation
+   * 
+   * @example
+   * ```typescript
+   * const client = new VectorBucketApi(url, headers)
+   * ```
    */
   constructor(url: string, headers: { [key: string]: string } = {}, fetch?: Fetch) {
     this.url = url.replace(/\/$/, '')
@@ -107,9 +112,7 @@ export default class VectorBucketApi {
    * }
    * ```
    */
-  async getBucket(
-    vectorBucketName: string
-  ): Promise<ApiResponse<{ vectorBucket: VectorBucket }>> {
+  async getBucket(vectorBucketName: string): Promise<ApiResponse<{ vectorBucket: VectorBucket }>> {
     try {
       const data = await post(
         this.fetch,

packages/core/storage-js/src/lib/vectors/VectorDataApi.ts

@@ -24,6 +24,13 @@ export default class VectorDataApi {
   protected fetch: Fetch
   protected shouldThrowOnError = false
 
+  /**
+   * Creates a VectorDataApi bound to a Storage Vectors deployment.
+   *
+   * @param url - Base URL for the Storage Vectors API.
+   * @param headers - Default headers (for example authentication tokens).
+   * @param fetch - Optional custom `fetch` implementation for non-browser runtimes.
+   */
   constructor(url: string, headers: { [key: string]: string } = {}, fetch?: Fetch) {
     this.url = url.replace(/\/$/, '')
     this.headers = { ...DEFAULT_HEADERS, ...headers }

packages/core/storage-js/src/lib/vectors/VectorIndexApi.ts

@@ -34,6 +34,13 @@ export default class VectorIndexApi {
   protected fetch: Fetch
   protected shouldThrowOnError = false
 
+  /**
+   * Creates an API client for managing vector indexes.
+   *
+   * @param url - Base URL for the Storage Vectors API.
+   * @param headers - Default headers sent with each request.
+   * @param fetch - Optional custom `fetch` implementation for non-browser runtimes.
+   */
   constructor(url: string, headers: { [key: string]: string } = {}, fetch?: Fetch) {
     this.url = url.replace(/\/$/, '')
     this.headers = { ...DEFAULT_HEADERS, ...headers }