pico.chat/pico.js

const State = {
    websocket: null,
    online: [],
    posts: [],
    media: null,
    username: null,
}

/*
*
* SIGNALING
*
*/
const wire = (message) => State.websocket.send(JSON.stringify(message))
const signal = (message) => dispatchEvent(new CustomEvent(message.kind, {detail: message}))
const listen = (kind, handler) => addEventListener(kind, handler)
listen('login', ({detail}) => State.username = detail.value)
listen('post', ({detail}) => State.posts.push(detail))
listen('peerInfo', (e) => onPeerInfo(e))
const doNotLog = new Set(['login', 'post', 'peerInfo'])

/*
*
* WEBRTC
*
*/
const rpcs = {}
const streams = {}
const getOrCreateRpc = (username) => {
    if(!rpcs[username] && State.media) {
        const rpc = new RTCPeerConnection({iceServers: [{urls: 'stun:stun.sipgate.net:3478'}]})
        State.media.getTracks().forEach(track => rpc.addTrack(track, State.media))
        rpc.onicecandidate = ({candidate}) => {
            if(candidate) {
                wire({kind: 'peerInfo', value: {type: 'candidate', candidate}})
            }
        }
        rpc.ontrack = (e) => {
            streams[username] = e.streams[0]
            m.redraw()
        }
        rpc.onclose = (e) => {
            console.log(username, e)
        }
        rpcs[username] = rpc
    }
    return rpcs[username]
}
const onPeerInfo = async ({detail: message}) => {
    if(State.username === message.source) {
        return
    }
    const rpc = getOrCreateRpc(message.source)
    if(rpc && message.value.type === 'request') {
        const localOffer = await rpc.createOffer()
        await rpc.setLocalDescription(localOffer)
        wire({kind: 'peerInfo', value: localOffer})
    }
    else if(rpc && message.value.type === 'offer') {
        const remoteOffer = new RTCSessionDescription(message.value)
        await rpc.setRemoteDescription(remoteOffer)
        const localAnswer = await rpc.createAnswer()
        await rpc.setLocalDescription(localAnswer)
        wire({kind: 'peerInfo', value: localAnswer})
    }
    else if(rpc && message.value.type === 'answer') {
        const remoteAnswer = new RTCSessionDescription(message.value)
        await rpc.setRemoteDescription(remoteAnswer)
    }
    else if(rpc && message.value.type === 'candidate') {
        const candidate = new RTCIceCandidate(message.value.candidate)
        rpc.addIceCandidate(candidate)
    }
    else if(message.value.type === 'stop') {
        if(streams[message.source]) {
            streams[message.source].getTracks().map(track => track.stop())
            delete streams[message.source]
        }
        if(rpcs[message.source]) {
            rpcs[message.source].close()
            delete rpcs[message.source]
        }
    }
    else {
        console.log('uncaught', message)
    }
}

/*
*
* GUI
*
*/
const autoFocus = (vnode) => {
    vnode.dom.focus()
}
const scrollIntoView = (vnode) => {
    vnode.dom.scrollIntoView()
}
const prettyTime = (ts) => {
    return ts.slice(11, 19)
}
const Video = {
    appendStream: (stream) => ({dom}) => {
        dom.autoplay = true
        dom.muted = true
        dom.srcObject = stream
    },
    view({attrs}) {
        return m('.video-container',
            m('.video-source', attrs.username),
            m('video', {playsinline: true, oncreate: Video.appendStream(attrs.stream)}),
        )
    },
}
const Media = {
    constraints: {audio: true, video: {width: {ideal: 320}, facingMode: 'user'}},
    turnOn: async () => {
        State.media = await navigator.mediaDevices.getUserMedia(Media.constraints)
        wire({kind: 'peerInfo', value: {type: 'request'}})
        m.redraw()
    },
    turnOff: () => {
        wire({kind: 'peerInfo', value: {type: 'stop'}})
        // signal internally
        Object.keys(rpcs).forEach(source => signal({kind: 'peerInfo', value: {type: 'stop'}, source}))
        State.media.getTracks().map(track => track.stop())
        delete State.media
    },
    view() {
        if(!State.media) {
            return m('.media',
                m('button', {onclick: Media.turnOn}, 'turn media on'),
            )
        }
        else {
            return m('.media',
                m('button', {onclick: Media.turnOff}, 'turn media off'),
                m('.videos',
                    m(Video, {username: State.username, stream: State.media}),
                    Object.entries(streams).map(([username, stream]) =>
                        m(Video, {username, stream})
                    ),
                ),
            )
        }
    }
}
const Login = {
    sendLogin: (e) => {
        e.preventDefault()
        const username = e.target.username.value
        localStorage.username = username
        connect(username)
    },
    sendLogout: (e) => {
        State.media && Media.turnOff()
        wire({kind: 'logout'})
        State.posts = []
    },
    view() {
        const attrs = {
            oncreate: autoFocus,
            name: 'username',
            autocomplete: 'off',
            value: localStorage.username,
        }
        return m('.login',
            m('form', {onsubmit: Login.sendLogin},
                m('input', attrs),
                m('button', 'Login'),
            ),
            State.kind === 'error' && m('.error', State.info),
        )
    },
}
const Chat = {
    sendPost: (e) => {
        e.preventDefault()
        const field = e.target.text
        if(field.value) {
            wire({kind: 'post', value: field.value})
            field.value = ''
        }
    },
    view() {
        return m('.chat',
            m('.posts',
                State.posts.map(post => m('.post', {oncreate: scrollIntoView},
                    m('.ts', prettyTime(post.ts)),
                    m('.source', post.source || '~'),
                    m('.text', post.value),
                )),
            ),
            m('form.actions', {onsubmit: Chat.sendPost},
                m('input', {oncreate: autoFocus, name: 'text', autocomplete: 'off'}),
                m('button', 'Send'),
            ),
            m('.online',
                m('button', {onclick: Login.sendLogout}, 'Logout'),
                m('ul.user-list', State.online.map(username => m('li', username))),
            ),
            m(Media),
        )
    },
}
const Main = {
    view() {
        const connected = State.websocket && State.websocket.readyState === 1
        return connected ? m(Chat) : m(Login)
    },
}
m.mount(document.body, Main)

/*
*
* WEBSOCKETS
*
*/
const connect = (username) => {
    const wsUrl = location.href.replace('http', 'ws')

    State.websocket = new WebSocket(wsUrl)

    State.websocket.onopen = (e) => {
        wire({kind: 'login', value: username})
    }

    State.websocket.onmessage = (e) => {
        const message = JSON.parse(e.data)

        if(message.online) {
            State.online = message.online
        }

        if(!doNotLog.has(message.kind)) {
            console.log(message)
        }
        signal(message)

        m.redraw()
    }

    State.websocket.onclose = (e) => {
        if(!e.wasClean) {
            setTimeout(connect, 1000, username)
        }
        m.redraw()
    }
}
if(localStorage.username) {
    connect(localStorage.username)
}