pico.chat/pico.js

const isLandscape = screen.width > screen.height
const State = {
    username: null,
    websocket: null,
    online: [],
    posts: [],
    rpcs: {},
    media: {},
}
const markedOptions = {
    breaks: true,
}
marked.setOptions(markedOptions)

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

/*
*
* ALERTS
*
*/
State.unseen = 0
listen('post', () => {State.unseen += !document.hasFocus(); updateTitle()})
listen('focus', () => {State.unseen = 0; updateTitle()})
const updateTitle = () => {
    document.title = `Pico.Chat` + (State.unseen ? ` (${State.unseen})` : ``)
}

/*
*
* WEBRTC
*
*/
const getOrCreateRpc = (username) => {
    if(State.username === username) {
        return
    }
    const myStream = State.media[State.username]
    if(!State.rpcs[username] && myStream) {
        const rpc = new RTCPeerConnection({iceServers: [{urls: 'stun:stun.sipgate.net:3478'}]})
        myStream.getTracks().forEach(track => rpc.addTrack(track, myStream))
        rpc.onicecandidate = ({candidate}) => {
            if(candidate) {
                wire({kind: 'peerInfo', value: {type: 'candidate', candidate}})
            }
        }
        rpc.ontrack = (e) => {
            State.media[username] = e.streams[0]
            m.redraw()
        }
        rpc.onclose = (e) => {
            console.log(username, e)
        }
        rpc.oniceconnectionstatechange = (e) => {
            m.redraw()
        }
        State.rpcs[username] = rpc
    }
    return State.rpcs[username]
}
const onPeerInfo = async ({detail: message}) => {
    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, target: message.source})
    }
    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, target: message.source})
    }
    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(State.media[message.source]) {
            State.media[message.source].getTracks().map(track => track.stop())
            delete State.media[message.source]
        }
        if(State.rpcs[message.source]) {
            State.rpcs[message.source].close()
            delete State.rpcs[message.source]
        }
    }
    else if(rpc) {
        console.log('uncaught', message)
    }
}

/*
*
* GUI
*
*/
const autoFocus = (vnode) => {
    vnode.dom.focus()
}
const scrollIntoView = (vnode) => {
    vnode.dom.scrollIntoView()
}
const prettyTime = (ts) => {
    const dt = new Date(ts)
    const H = `0${dt.getHours()}`.slice(-2)
    const M = `0${dt.getMinutes()}`.slice(-2)
    const S = `0${dt.getSeconds()}`.slice(-2)
    return `${H}:${M}:${S}`
}
const hotKey = (e) => {
    // if isDesktop, Enter posts, unless Shift+Enter
    // use isLandscape as proxy for isDesktop
    if(e.key === 'Enter' && isLandscape && !e.shiftKey) {
        e.preventDefault()
        Chat.sendPost()
    }
}
const Video = {
    appendStream: ({username, stream}) => ({dom}) => {
        dom.autoplay = true
        dom.muted = (username === State.username)
        dom.srcObject = stream
    },
    view({attrs}) {
        const rpc = State.rpcs[attrs.username] || {iceConnectionState: m.trust(' ')}
        return m('.video-container',
            m('.video-source', attrs.username),
            m('.video-state', rpc.iceConnectionState),
            m('video', {playsinline: true, oncreate: Video.appendStream(attrs)}),
        )
    },
}
const Media = {
    audioVideo: {audio: true, video: {width: {ideal: 320}, facingMode: 'user'}},
    audioOnly: {audio: true, video: false},
    turnOn: (constraints) => async () => {
        const media = await navigator.mediaDevices.getUserMedia(constraints)
        State.media[State.username] = media
        wire({kind: 'peerInfo', value: {type: 'request'}})
        m.redraw()
    },
    turnOff: () => {
        wire({kind: 'peerInfo', value: {type: 'stop'}})
        State.online.forEach(signalPeerStop)
    },
    view() {
        if(!State.media[State.username]) {
            return m('.media',
                m('button', {onclick: Media.turnOn(Media.audioVideo)}, 'turn media on'),
                m('button', {onclick: Media.turnOn(Media.audioOnly)}, 'turn audio on'),
            )
        }
        else {
            return m('.media',
                m('button', {onclick: Media.turnOff}, 'turn media off'),
                m('.videos',
                    Object.entries(State.media).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) => {
        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'),
            ),
            m('.error', State.info),
        )
    },
}
const Chat = {
    sendPost: () => {
        if(textbox.value) {
            wire({kind: 'post', value: textbox.value})
            textbox.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', m.trust(DOMPurify.sanitize(marked(post.value)))),
                )),
            ),
            m('.actions',
                m('textarea#textbox', {oncreate: autoFocus, onkeydown: hotKey}),
                m('button', {onclick: Chat.sendPost}, '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(!doNotLog.has(message.kind)) {
            console.log(message)
        }
        signal(message)

        m.redraw()
    }

    State.websocket.onclose = (e) => {
        State.online.forEach(signalPeerStop)
        if(!e.wasClean) {
            setTimeout(connect, 1000, username)
        }
        m.redraw()
    }
}
if(localStorage.username) {
    connect(localStorage.username)
}
addEventListener('pagehide', Media.turnOff)