@nolag/signal

import { NoLagApi } from "@nolag/js-sdk";

const api = new NoLagApi(process.env.NOLAG_API_KEY); // nlg_live_...
const app = await api.apps.create({ name: "My App", blueprintId: "nolag-signal-sdk" });
console.log(app.slug); // e.g. "my-app-a3f9": this is your appName

const actor = await api.actors.create({ name: "web-client", actorType: "user" });
console.log(actor.accessToken); // shown once; keep it

npm install @nolag/signal @nolag/js-sdk

import { NoLag } from '@nolag/js-sdk'
import { NoLagSignal } from '@nolag/signal'

const client = NoLag(async () => (await (await fetch('/api/nolag-token')).json()).token)

const signal = new NoLagSignal({
  client,
  appName: APP_SLUG, // the slug returned when you created the app
  metadata: { displayName: 'Alice' },
})

await client.connect()
await signal.ready()

// Join the seeded room
const room = signal.joinRoom('call-room')

// One RTCPeerConnection per remote peer, created on demand.
const peers = new Map<string, RTCPeerConnection>()

function peerConnectionFor(peerId: string): RTCPeerConnection {
  let pc = peers.get(peerId)
  if (pc) return pc
  pc = new RTCPeerConnection({ iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] })
  // Trickle ICE as candidates are discovered.
  pc.onicecandidate = ({ candidate }) => {
    if (candidate) room.sendIceCandidate(peerId, candidate)
  }
  peers.set(peerId, pc)
  return pc
}

function teardown(peerId: string) {
  peers.get(peerId)?.close()
  peers.delete(peerId)
}

// Someone new arrived: offer them a connection.
room.on('peerJoined', async (peer) => {
  const pc = peerConnectionFor(peer.peerId)
  const offer = await pc.createOffer()
  await pc.setLocalDescription(offer)
  room.sendOffer(peer.peerId, offer)
})

// Everything addressed to us arrives here.
room.on('signal', async (message) => {
  const pc = peerConnectionFor(message.fromPeerId)

  if (message.type === 'offer') {
    await pc.setRemoteDescription(message.payload as RTCSessionDescriptionInit)
    const answer = await pc.createAnswer()
    await pc.setLocalDescription(answer)
    room.sendAnswer(message.fromPeerId, answer)
  }

  if (message.type === 'answer') {
    await pc.setRemoteDescription(message.payload as RTCSessionDescriptionInit)
  }

  if (message.type === 'ice-candidate') {
    await pc.addIceCandidate(message.payload as RTCIceCandidateInit)
  }

  // A hangup is a signal, not a presence change: peerLeft does not fire for it.
  if (message.type === 'bye') {
    teardown(message.fromPeerId)
  }
})

// Presence says they are gone (closed tab, lost connection).
room.on('peerLeft', (peer) => teardown(peer.peerId))

// Hang up on everyone, then release the wrapper and close the socket.
for (const peerId of peers.keys()) {
  room.sendBye(peerId)
  teardown(peerId)
}
signal.detach()
client.disconnect()