@signalwire/js 3.6.0 → 3.7.1-dev.202201180939.d2ef427.0

package/src/createClient.ts

@@ -16,30 +16,10 @@ import { JWTSession } from './JWTSession'
  * Create a client
  *
  * @example
- * With autoConnect true the client is ready to be used.
  * ```js
  * try {
- *   const client = await Video.createClient({
- *     token: '<YourToken>',
- *   })
- *
- *   // Your client is already connected..
- * } catch (error) {
- *   console.error('Auth Error', error)
- * }
- * ```
- *
- * @example
- * With autoConnect false you can attach additional handlers.
- * ```js
- * try {
- *   const client = await Video.createClient({
+ *   const client = Video.createClient({
  *     token: '<YourJWT>',
- *     autoConnect: false,
- *   })
- *
- *   client.on('socket.closed', () => {
- *     // The WebSocket connection is closed
  *   })
  *
  *   await client.connect()

package/src/index.ts

@@ -98,4 +98,4 @@ export type {
 } from './utils/interfaces'
 
 /** @internal */
-export * as __sw__PubSub from './chat/Chat'
+export * as __sw__Chat from './chat'

package/src/utils/constants.ts

@@ -10,8 +10,8 @@ export const ROOM_COMPONENT_LISTENERS = {
 
 export const SCREENSHARE_AUDIO_CONSTRAINTS: MediaTrackConstraints = {
   echoCancellation: false,
-  // @ts-expect-error
   noiseSuppression: false,
   autoGainControl: false,
+  // @ts-expect-error
   googAutoGainControl: false,
 }

package/dist/js/src/chat/Chat.d.ts

@@ -1,16 +0,0 @@
-import type { AssertSameType, ChatContract, ConsumerContract, UserOptions, Chat as ChatNamespace } from '@signalwire/core';
-export interface ChatApiEvents extends ChatNamespace.BaseChatApiEvents {
-}
-export interface ChatFullState extends Chat {
-}
-interface ChatMain extends ChatContract, Omit<ConsumerContract<ChatApiEvents, ChatFullState>, 'subscribe'> {
-}
-interface ChatDocs extends ChatMain {
-}
-export interface Chat extends AssertSameType<ChatMain, ChatDocs> {
-}
-export interface ChatOptions extends UserOptions {
-}
-export declare const Chat: new (chatOptions: ChatOptions) => Chat;
-export {};
-//# sourceMappingURL=Chat.d.ts.map

package/dist/js/src/chat/Chat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Chat.d.ts","sourceRoot":"","sources":["../../../../src/chat/Chat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,IAAI,IAAI,aAAa,EACtB,MAAM,kBAAkB,CAAA;AAIzB,MAAM,WAAW,aAAc,SAAQ,aAAa,CAAC,iBAAiB;CAAG;AAEzE,MAAM,WAAW,aAAc,SAAQ,IAAI;CAAG;AAC9C,UAAU,QACR,SAAQ,YAAY,EAClB,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE,aAAa,CAAC,EAAE,WAAW,CAAC;CAAG;AAExE,UAAU,QAAS,SAAQ,QAAQ;CAAG;AAEtC,MAAM,WAAW,IAAK,SAAQ,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAAG;AAEnE,MAAM,WAAW,WAAY,SAAQ,WAAW;CAAG;AAEnD,eAAO,MAAM,IAAI,oBA+BmB,WAAW,KAAG,IAAM,CAAA"}

package/src/chat/Chat.test.ts

@@ -1,219 +0,0 @@
-import WS from 'jest-websocket-mock'
-import { Chat } from './Chat'
-
-describe('Chat Object', () => {
-  const host = 'ws://localhost:1234'
-  const token = '<jwt>'
-
-  let server: WS
-  beforeEach(async () => {
-    server = new WS(host)
-    server.on('connection', (socket) => {
-      socket.on('message', (data: any) => {
-        const parsedData = JSON.parse(data)
-
-        socket.send(
-          JSON.stringify({
-            jsonrpc: '2.0',
-            id: parsedData.id,
-            result: {},
-          })
-        )
-      })
-    })
-  })
-
-  afterEach(() => {
-    WS.clean()
-  })
-
-  it('should automatically connect when calling either .subscribe() or .publish()', async () => {
-    const chat = new Chat({
-      host,
-      token,
-    })
-
-    chat.on('message', () => {})
-    await chat.subscribe(['test'])
-    await chat.publish({
-      channel: 'test',
-      message: 'test',
-    })
-
-    const connectMsg = JSON.parse(server.messages[0].toString())
-    expect(connectMsg.method).toBe('signalwire.connect')
-    expect(server.messages.length).toBe(3)
-  })
-
-  it('should emit a single "signalwire.connect" at most when subscribing/publishing at the same time', async () => {
-    const chat = new Chat({
-      host,
-      token,
-    })
-
-    chat.on('message', () => {})
-    await Promise.all([
-      chat.subscribe(['test']),
-      chat.publish({
-        channel: 'test',
-        message: 'test',
-      }),
-    ])
-
-    const connectMsg = JSON.parse(server.messages[0].toString())
-    expect(connectMsg.method).toBe('signalwire.connect')
-    expect(
-      server.messages.filter((message) => {
-        const parsedMessage = JSON.parse(message.toString())
-
-        return parsedMessage.method === 'signalwire.connect'
-      }).length
-    ).toBe(1)
-  })
-
-  describe('Subscribe', () => {
-    it('should convert channels into the internal channel notation when calling .subscribe()', async () => {
-      const chat = new Chat({
-        host,
-        token,
-      })
-
-      chat.on('message', () => {})
-      await chat.subscribe(['test1', 'test2', 'test3'])
-
-      const subscribeMsg = JSON.parse(server.messages[1].toString())
-      expect(subscribeMsg.params.channels).toStrictEqual([
-        { name: 'test1' },
-        { name: 'test2' },
-        { name: 'test3' },
-      ])
-    })
-  })
-
-  describe('Publish', () => {
-    it('should support publishing-only mode', async () => {
-      const chat = new Chat({
-        host,
-        token,
-      })
-
-      const params = {
-        channel: 'test',
-        message: 'test',
-      }
-
-      await chat.publish(params)
-
-      server.messages.forEach((message, i) => {
-        const parsedMessage = JSON.parse(message.toString())
-
-        if (i === 0) {
-          expect(parsedMessage.method).toBe('signalwire.connect')
-        } else {
-          expect(parsedMessage.method).toBe('chat.publish')
-          expect(parsedMessage.params).toStrictEqual(params)
-        }
-      })
-    })
-  })
-
-  describe('Unsubscribe', () => {
-    it('should convert channels into the internal channel notation when calling .unsubscribe()', async () => {
-      const chat = new Chat({
-        host,
-        token,
-      })
-
-      chat.on('message', () => {})
-      await chat.subscribe(['test1', 'test2', 'test3'])
-      await chat.unsubscribe(['test1', 'test2', 'test3'])
-
-      const unsubscribeMsg = JSON.parse(server.messages[1].toString())
-      expect(unsubscribeMsg.params.channels).toStrictEqual([
-        { name: 'test1' },
-        { name: 'test2' },
-        { name: 'test3' },
-      ])
-    })
-
-    it('should allow the user to .unsubscribe() from any subgroup of subscribed channels', async () => {
-      expect.assertions(4)
-      const chat = new Chat({
-        host,
-        token,
-      })
-
-      chat.on('message', () => {})
-
-      await chat.subscribe(['test1', 'test2', 'test3'])
-      expect(await chat.unsubscribe(['test1', 'test3'])).toBeUndefined()
-      expect(await chat.unsubscribe(['test1', 'test2'])).toBeUndefined()
-      expect(await chat.unsubscribe(['test2', 'test3'])).toBeUndefined()
-      expect(
-        await chat.unsubscribe(['test1', 'test2', 'test3'])
-      ).toBeUndefined()
-    })
-
-    it('should throw if the user calls .unsubscribe() before the session is authorized', async () => {
-      expect.assertions(1)
-      const chat = new Chat({
-        host,
-        token,
-      })
-
-      chat.on('message', () => {})
-
-      try {
-        await chat.unsubscribe(['test1'])
-      } catch (err) {
-        expect(err.message).toBe(
-          'You must be authenticated to unsubscribe from a channel'
-        )
-      }
-    })
-
-    it('should throw if the user calls .unsubscribe() without being subscribed to channels', async () => {
-      expect.assertions(1)
-      const chat = new Chat({
-        host,
-        token,
-      })
-
-      chat.on('message', () => {})
-
-      // This is to force the session to be connected when
-      // calling unsubscribe()
-      await chat.publish({
-        channel: 'test',
-        message: 'test',
-      })
-
-      try {
-        await chat.unsubscribe(['test1'])
-      } catch (err) {
-        expect(err.message).toBe(
-          'You must subscribe to at least one channel before calling unsubscribe()'
-        )
-      }
-    })
-
-    it('should throw if the user calls .unsubscribe() with channels different than the ones they are subscribed to', async () => {
-      expect.assertions(1)
-      const chat = new Chat({
-        host,
-        token,
-      })
-
-      chat.on('message', () => {})
-
-      try {
-        await chat.subscribe(['test1', 'test2', 'test3', 'test4'])
-        await chat.unsubscribe(['test1', 'test5'])
-      } catch (err) {
-        expect(err.message).toBe(
-          `You can't unsubscribe from a channel that you didn't subscribe to. You're subscribed to the following channels: test1, test2, test3, test4 but tried to unsubscribe from: test1, test5`
-        )
-      }
-    })
-  })
-})