import { WsKit } from "websocketkit";
import Pusher from 'pusher-js';
 
declare module 'websocketkit' {
  interface ChannelRegistry {
    'orders': {
      type: 'private';
      params: {};
      events: {
        orderShipped: {
          orderId: string,
          trackId: string,
          status: number,
          timestamp: string,
        }
      };
      whispers: {
        noteAdded: {
          orderId: string,
          note: string,
        }
      }
    };
  }
}
 
const pusher = new Pusher('TEST', {cluster: 'mt1'});
const wskit = new WsKit(pusher);
// ---cut---
 

Private channel

Private channels should be used when access to the channel needs to be restricted in some way. In order for a user to subscribe to a private channel permission must be authorized.

Subscribe

Create a subscription to a specific channel. Provide any required parameters for public, private or presence channels.

const sub = wskit.subscribe('orders', { type: 'private', params: {} })

Unsubscribe

Stop receiving events and clear all listeners from the subscription.

sub.dispose();

Events

Listen for an event

Subscribe to a specific event on the channel.

sub.on('orderShipped', (event) => {
  /** Do something with the event **/
})

Stop listening for an event

Remove a specific listener using either the returned unsubscribe function or the original callback reference.

const unsub = sub.on('orderShipped', (event) => {
  /** Do something with the event **/
})
 
// Later
unsub();

/** You have to explicitly define the type of the event **/
const orderShippedHandler = (event: { orderId: string, trackId: string, status: number, timestamp: string }) => {
  /** Do something with the event **/
};
 
sub.on('orderShipped', orderShippedHandler);
 
// Later
sub.off('orderShipped', orderShippedHandler);

Notifications

Listen for a notification

Listen for .Illuminate\\Notifications\\Events\\BroadcastNotificationCreated event on a channel.

sub.notification((notif) => {
  /** Do something with a notification event **/
});

Stop listening for a notification

const unsub = sub.notification((notif) => {
  /** Do something with a notification event **/
});
 
unsub()

Client Events

Communicate directly with other subscribers on the channel.

Send a whisper

sub.whisper('noteAdded', { orderId: 'rBei1FD7egstHQrplQeou', note: 'Review required' });

Listen for a whisper

sub.listenForWhisper('noteAdded', (event) => {
  /** Do something with a notification event **/
});

Stop listening for a whisper

// Using returned unsubscribe function
const unsub = sub.listenForWhisper('noteAdded', (event) => {
  /** Do something with a notification event **/
});
 
unsub();

/** You have to explicitly define the type of the event **/
const noteAddedHandler = (event: { orderId: string, note: string }) => {
  /** Do something with a notification event **/
}
 
sub.listenForWhisper('noteAdded', noteAddedHandler);
 
// Later
sub.stopListeningForWhisper('noteAdded', noteAddedHandler);

Internal Events

Subscription succeeded

Triggered when the subscription is successfully established.

sub.subscribed(() => {
  /** Do something after successful subscription **/
})

Subscription error

Triggered when authorization fails for private or presence channels. Internally, this listens for the pusher:subscription_error event .

sub.error((error) => {
  /** Handle subscription error **/
})