@signalwire/js 3.29.2 → 4.0.0-dev-20260220205014

package/src/chat/Client.ts

@@ -1,94 +0,0 @@
-import type {
-  ChatContract,
-  ConsumerContract,
-  UserOptions,
-  Chat as ChatNamespace,
-} from '@signalwire/core'
-import { createClient } from '../createClient'
-
-export interface ClientApiEvents extends ChatNamespace.BaseChatApiEvents {}
-
-/** @ignore */
-export interface ClientFullState extends Client {}
-export interface Client
-  extends ChatContract,
-    Omit<ConsumerContract<ClientApiEvents, ClientFullState>, 'subscribe'> {}
-
-/** @ignore */
-export interface ClientOptions extends UserOptions {}
-
-type ClientMethods = keyof Client
-const INTERCEPTED_METHODS: ClientMethods[] = [
-  'subscribe',
-  'publish',
-  'getMessages',
-  'getMembers',
-  'getMemberState',
-  'getAllowedChannels',
-  'setMemberState',
-]
-
-/**
- * You can use the Client object to build a messaging system into the browser.
- *
- * Example usage:
- *
- * ```js
- * import { Chat } from '@signalwire/js'
- *
- * const chatClient = new Chat.Client({
- *   token: '<your_chat_token>',  // get this from the REST APIs
- * })
- *
- * await chatClient.subscribe([ 'mychannel1', 'mychannel2' ])
- *
- * chatClient.on('message', (message) => {
- *   console.log("Received", message.content,
- *               "on", message.channel,
- *               "at", message.publishedAt)
- * })
- *
- * await chatClient.publish({
- *   channel: 'mychannel1',
- *   content: 'hello world'
- * })
- * ```
- *
- * ## Events
- *
- * Please see {@link ClientApiEvents} for the list of events emitted by a chat
- * Client object.
- */
-export const Client = function (chatOptions: ClientOptions) {
-  const client = createClient(chatOptions)
-
-  const createInterceptor = <K extends keyof Client>(prop: K) => {
-    return async (...params: Parameters<Client[K]>) => {
-      await client.connect()
-
-      // @ts-expect-error
-      return client.chat[prop](...params)
-    }
-  }
-
-  const interceptors = {
-    _session: client,
-    disconnect: () => client.disconnect(),
-  } as const
-
-  return new Proxy<Client>(client.chat, {
-    get(target: Client, prop: keyof Client, receiver: any) {
-      if (prop in interceptors) {
-        // @ts-expect-error
-        return interceptors[prop]
-      }
-
-      if (INTERCEPTED_METHODS.includes(prop)) {
-        return createInterceptor(prop)
-      }
-
-      return Reflect.get(target, prop, receiver)
-    },
-  })
-  // For consistency with other constructors we'll make TS force the use of `new`
-} as unknown as { new (chatOptions: ClientOptions): Client }

package/src/chat/index.ts

@@ -1,31 +0,0 @@
-export { Client, ClientOptions, ClientApiEvents } from './Client'
-
-export { ChatMember, ChatMessage } from '@signalwire/core'
-
-export type { PagingCursor } from '../utils/interfaces'
-
-export type {
-  ChatAction,
-  ChatChannel,
-  ChatChannelMessageEvent,
-  ChatChannelMessageEventParams,
-  ChatChannelState,
-  ChatEvent,
-  ChatGetMembersParams,
-  ChatGetMemberStateParams,
-  ChatGetMessagesParams,
-  ChatMemberContract,
-  ChatMemberEntity,
-  ChatMemberJoinedEvent,
-  ChatMemberJoinedEventParams,
-  ChatMemberLeftEvent,
-  ChatMemberLeftEventParams,
-  ChatMemberUpdatedEvent,
-  ChatMemberUpdatedEventParams,
-  ChatMessageContract,
-  ChatMessageEntity,
-  ChatSetMemberStateParams,
-  InternalChatMemberEntity,
-  InternalChatMessageEntity,
-  PaginationCursor,
-} from '@signalwire/core'

package/src/createClient.test.ts

@@ -1,124 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import WS from 'jest-websocket-mock'
-import { AuthError } from '@signalwire/core'
-import { createClient } from './createClient'
-
-describe('createClient', () => {
-  const host = 'ws://localhost:1234'
-  const token = '<jwt>'
-  const authError = {
-    code: -32002,
-    message:
-      'Authentication service failed with status ProtocolError, 401 Unauthorized: {}',
-  }
-
-  let server: WS
-  let consoleMock: jest.SpyInstance
-  beforeEach(async () => {
-    consoleMock = jest
-      .spyOn(global.console, 'error')
-      .mockImplementation(() => {})
-
-    server = new WS(host)
-    server.on('connection', (socket) => {
-      socket.on('message', (data: any) => {
-        const parsedData = JSON.parse(data)
-
-        if (
-          parsedData.method === 'signalwire.connect' &&
-          parsedData.params.authentication.jwt_token === '<invalid-token>'
-        ) {
-          socket.send(
-            JSON.stringify({
-              jsonrpc: '2.0',
-              id: parsedData.id,
-              error: authError,
-            })
-          )
-          return
-        }
-
-        socket.send(
-          JSON.stringify({
-            jsonrpc: '2.0',
-            id: parsedData.id,
-            result: {},
-          })
-        )
-      })
-    })
-  })
-
-  afterEach(() => {
-    consoleMock.mockRestore()
-    WS.clean()
-  })
-
-  it('should throw an error when invalid credentials are provided', async () => {
-    expect.assertions(1)
-
-    const client = createClient({
-      host,
-      token: '<invalid-token>',
-    })
-
-    try {
-      await client.connect()
-    } catch (e) {
-      expect(e).toBeInstanceOf(AuthError)
-    }
-    client.disconnect()
-  })
-
-  it('should resolve `connect()` when the client is authorized', async () => {
-    expect.assertions(1)
-
-    const client = createClient({
-      host,
-      token,
-    })
-
-    // @ts-expect-error
-    client._waitUntilSessionAuthorized().then((c) => {
-      expect(c).toEqual(client)
-    })
-
-    await client.connect()
-    client.disconnect()
-  })
-
-  it('should automatically resolve (without hitting the network) when calling `.connect()` if the session was already authorized', async () => {
-    const h = 'ws://localhost:2222'
-    const s = new WS(h)
-
-    let messageHandler
-    s.on('connection', (socket) => {
-      messageHandler = jest.fn((data: any) => {
-        const parsedData = JSON.parse(data)
-
-        socket.send(
-          JSON.stringify({
-            jsonrpc: '2.0',
-            id: parsedData.id,
-            result: {},
-          })
-        )
-      })
-
-      socket.on('message', messageHandler)
-    })
-
-    const client = createClient({
-      host: h,
-      token,
-    })
-
-    await Promise.all([client.connect(), client.connect(), client.connect()])
-
-    expect(messageHandler).toHaveBeenCalledTimes(1)
-    client.disconnect()
-  })
-})

package/src/createClient.ts

@@ -1,48 +0,0 @@
-import {
-  ClientEvents,
-  configureStore,
-  connect,
-  getEventEmitter,
-  UserOptions,
-} from '@signalwire/core'
-import { ClientAPI, Client } from './Client'
-import { JWTSession } from './JWTSession'
-
-/**
- * With Video.createClient() you can establish a WebSocket connection
- * with SignalWire and interact with the client.
- *
- * ## Examples
- * Create a client
- *
- * @example
- * ```js
- * try {
- *   const client = Video.createClient({
- *     token: '<YourJWT>',
- *   })
- *
- *   await client.connect()
- *   // Your client is ready now..
- * } catch (error) {
- *   console.error('Error', error)
- * }
- * ```
- * @internal
- */
-export const createClient = <RoomSessionType>(userOptions: UserOptions) => {
-  const baseUserOptions = {
-    ...userOptions,
-    emitter: getEventEmitter<ClientEvents>(),
-  }
-  const store = configureStore({
-    userOptions: baseUserOptions,
-    SessionConstructor: JWTSession,
-  })
-  const client = connect<ClientEvents, ClientAPI, Client<RoomSessionType>>({
-    store,
-    Component: ClientAPI,
-  })(baseUserOptions)
-
-  return client
-}

package/src/createRoomObject.ts

@@ -1,149 +0,0 @@
-import { UserOptions, getLogger } from '@signalwire/core'
-import { createClient } from './createClient'
-import { MakeRoomOptions } from './Client'
-import { BaseRoomSession } from './BaseRoomSession'
-
-/**
- * @internal
- * @deprecated Use {@link RoomSession} instead.
- **/
-export interface Room extends BaseRoomSession<Room> {}
-
-export interface CreateRoomObjectOptions
-  extends UserOptions,
-    Omit<MakeRoomOptions, 'rootElement'> {
-  /** Id of the HTML element in which to display the video stream */
-  rootElementId?: string
-  /** Whether to automatically join the room session. */
-  autoJoin?: boolean
-}
-
-const VIDEO_CONSTRAINTS: MediaTrackConstraints = {
-  aspectRatio: { ideal: 16 / 9 },
-}
-
-/**
- * Using Video.createRoomObject() you can create a `RoomObject` to join a room.
- *
- * @example
- * With an HTMLDivElement with id="root" in the DOM.
- * ```js
- * // <div id="root"></div>
- *
- * try {
- *   const roomObj = await Video.createRoomObject({
- *     token: '<YourJWT>',
- *     rootElementId: 'root',
- *   })
- *
- *   roomObj.join()
- * } catch (error) {
- *   console.error('Error', error)
- * }
- * ```
- * @deprecated Use {@link RoomSession} instead.
- */
-export const createRoomObject = (
-  roomOptions: CreateRoomObjectOptions
-): Promise<Room> => {
-  return new Promise(async (resolve, reject) => {
-    const {
-      audio = true,
-      video = true,
-      iceServers,
-      rootElementId,
-      applyLocalVideoOverlay = true,
-      autoJoin = false,
-      stopCameraWhileMuted = true,
-      stopMicrophoneWhileMuted = true,
-      speakerId,
-      ...userOptions
-    } = roomOptions
-
-    const client = createClient({
-      ...userOptions,
-    })
-    await client.connect()
-
-    if (!client) {
-      return
-    }
-
-    /**
-     * Since `makeRoomObject` now only accepts a
-     * `rootElement` the following is to preserve backwards
-     * compatibility with the previous syntax
-     */
-    let rootElement: HTMLElement | undefined
-    if (rootElementId) {
-      const el = document.getElementById(rootElementId)
-
-      if (el) {
-        rootElement = el
-      } else {
-        rootElement = document.body
-
-        getLogger().warn(
-          `We couldn't find an element with id: ${rootElementId}: using 'document.body' instead.`
-        )
-      }
-    }
-
-    const roomObject = client.rooms.makeRoomObject({
-      audio,
-      video: video === true ? VIDEO_CONSTRAINTS : video,
-      negotiateAudio: true,
-      negotiateVideo: true,
-      iceServers,
-      rootElement,
-      applyLocalVideoOverlay,
-      stopCameraWhileMuted,
-      stopMicrophoneWhileMuted,
-      speakerId,
-    })
-
-    // WebRTC connection left the room.
-    roomObject.once('destroy', () => {
-      roomObject.emit('room.left')
-      client.disconnect()
-    })
-
-    const join = () => {
-      return new Promise(async (resolve, reject) => {
-        try {
-          roomObject.once('room.subscribed', (_payload) => {
-            resolve(roomObject)
-          })
-
-          await roomObject.join()
-        } catch (error) {
-          getLogger().error('Join', error)
-          // Disconnect the underlay client in case of media/signaling errors
-          client.disconnect()
-
-          reject(error)
-        }
-      })
-    }
-
-    const room = new Proxy(roomObject, {
-      get(target: any, prop: any, receiver: any) {
-        if (prop === 'join') {
-          return join
-        }
-        return Reflect.get(target, prop, receiver)
-      },
-    })
-
-    if (autoJoin) {
-      try {
-        await room.join()
-        resolve(room)
-      } catch (error) {
-        reject(error)
-      }
-    } else {
-      resolve(room)
-    }
-  })
-}