Client

You can use the Client object to build a messaging system into the browser.

Example usage:

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 ClientApiEvents for the list of events emitted by a chat Client object.

Constructors

• new Client(chatOptions)

Creates a new Chat client.

Parameters

Example

import { Chat } from '@signalwire/js'

const chatClient = new Chat.Client({
  token: '<your_chat_token>',
})

Methods

▸ getMemberState(params): Promise<{ channels: Record<string, ChatChannelState> }>

Returns the states of a member in the specified channels.

Parameters

Returns

Promise<{ channels: Record<string, ChatChannelState> }>

Example

const s = await chatClient.getMemberState({
  channels: ['chan1', 'chan2'],
  memberId: 'my-member-id'
})

s.channels.length;  // 2
s.channels.chan1.state;  // the state object for chan1

---

▸ getMembers(params): Promise<{ members: ChatMemberEntity[] }>

Returns the list of members in the given channel.

Parameters

Returns

Promise<{ members: ChatMemberEntity[] }>

Example

const m = await chatClient.getMembers({ channel: 'my-channel' })

m.members.length;  // 7
m.members[0];  // { id: ..., channel: ..., state: ... }

---

▸ getMessages(params): Promise<{ cursor: PagingCursor ; messages: ChatMessageEntity[] }>

Returns the list of messages that were sent to the specified channel.

Parameters

Returns

Promise<{ cursor: PagingCursor ; messages: ChatMessageEntity[] }>

Example

const m = await chatClient.getMessages({ channel: 'chan1' })

m.messages.length;  // 23
m.messages[0];  // the most recent message
m.messages[0].member;  // the sender
m.messages[0].content;  // the content
m.messages[0].meta;  // the metadata (if any)

m.cursor.next;  // if not null, there are more messages.

// Get the next page using the cursor
const next = await chatClient.getMessages({
  channel: 'chan1',
  cursor: {
    after: m.cursor.after
  }
})

---

▸ off<T>(event, fn?): EmitterContract<ClientApiEvents>

Type parameters

Parameters

Returns

EmitterContract<ClientApiEvents>

---

▸ on<T>(event, fn): EmitterContract<ClientApiEvents>

Type parameters

Parameters

Returns

EmitterContract<ClientApiEvents>

---

▸ once<T>(event, fn): EmitterContract<ClientApiEvents>

Type parameters

Parameters

Returns

EmitterContract<ClientApiEvents>

---

▸ publish(params): Promise<void>

Publish a message into the specified channel.

Parameters

Returns

Promise<void>

Examples

Publishing a message as a string:

await chatClient.publish({
  channel: 'my-channel',
  content: 'Hello, world.'
})

Publishing a message as an object:

await chatClient.publish({
  channel: 'my-channel',
  content: {
    field_one: 'value_one',
    field_two: 'value_two',
  }
})

---

▸ removeAllListeners<T>(event?): EmitterContract<ClientApiEvents>

Type parameters

Parameters

Returns

EmitterContract<ClientApiEvents>

---

▸ setMemberState(params): Promise<void>

Sets a state object for a member, for the specified channels. The previous state object will be completely replaced.

Parameters

Returns

Promise<void>

Example

await chatClient.setMemberState({
  channels: ['chan1', 'chan2'],
  state: {
    online: true,
    typing: false
  }
})

---

▸ subscribe(channels): Promise<void>

List of channels for which you want to receive messages. You can only subscribe to those channels for which your token has read permission.

Note that the subscribe function is idempotent, and calling it again with a different set of channels will not unsubscribe you from the old ones. To unsubscribe, use unsubscribe.

Parameters

Returns

Promise<void>

Example

const chatClient = new Chat.Client({
  token: '<your chat token>'
})

chatClient.on('message', m => console.log(m))

await chatClient.subscribe("my-channel")
await chatClient.subscribe(["chan-2", "chan-3"])

---

▸ unsubscribe(channels): Promise<void>

List of channels from which you want to unsubscribe.

Parameters

Returns

Promise<void>

Example

await chatClient.unsubscribe("my-channel")
await chatClient.unsubscribe(["chan-2", "chan-3"])

---

▸ updateToken(token): Promise<void>

Replaces the token used by the client with a new one. You can use this method to replace the token when for example it is expiring, in order to keep the session alive.

The new token can contain different channels from the previous one. In that case, you will need to subscribe to the new channels if you want to receive messages for those. Channels that were in the previous token but are not in the new one will get unsubscribed automatically.

Parameters

Returns

Promise<void>

Example

const chatClient = new Chat.Client({
  token: '<your chat token>'
})

chatClient.on('session.expiring', async () => {
  const newToken = await fetchNewToken(..)

  await chatClient.updateToken(newToken)
})