damus.io

index.js (2251B)

---

 
 async function damus_init()
 {
 	const relay = await Relay("wss://relay.damus.io")
 	const now = (new Date().getTime()) / 1000
 	const el = document.querySelector("#content")
 	const model = {events: []}
 
 	el.innerHTML = render_initial_content()
 	model.el = el.querySelector("#home")
 
 	relay.subscribe("test_sub_id", {kinds: [1], limit: 20})
 	relay.event = (sub_id, ev) => {
 		insert_event_sorted(model.events, ev)
 		if (model.realtime)
 			render_home_view(model)
 	}
 
 	relay.eose = () => {
 		model.realtime = true
 		render_home_view(model)
 	}
 
 	return relay
 }
 
 function render_home_view(model) {
 	model.el.innerHTML = render_events(model.events)
 }
 
 function render_initial_content() {
 	return `<ul id="home"> </ul>`
 }
 
 function insert_event_sorted(evs, new_ev) {
 	for (let i = 0; i < evs.length; i++) {
 		const ev = evs[i]
 
 		if (new_ev.id === ev.id) {
 			return false
 		}
 
 		if (new_ev.created_at > ev.created_at) {
 			evs.splice(i, 0, new_ev)
 			return true
 		}
 	}
 
 	evs.push(new_ev)
 	return true
 }
 
 function render_events(evs) {
 	return evs.map(render_event).join("\n")
 }
 
 function render_event(ev) {
 	return `<li>${ev.content}</li>`
 }
 
 function Relay(relay, opts={})
 {
 	if (!(this instanceof Relay))
 		return new Relay(relay, opts)
 
 	this.relay = relay
 	this.opts = opts
 
 	const me = this
 	return new Promise((resolve, reject) => {
 		const ws = me.ws = new WebSocket(relay);
 		let resolved = false
 		ws.onmessage = (m) => { handle_message(me, m) }
 		ws.onclose = () => { me.close && me.close() }
 		ws.onerror = () => { me.error && me.error() }
 		ws.onopen = () => {
 			if (resolved) {
 				me.open.bind(me)
 				return
 			}
 
 			resolved = true
 			resolve(me)
 		}
 	})
 }
 
 Relay.prototype.subscribe = function relay_subscribe(sub_id, ...filters) {
 	const tosend = ["REQ", sub_id, ...filters]
 	console.log("sending", tosend)
 	this.ws.send(JSON.stringify(tosend))
 }
 
 function handle_message(relay, msg)
 {
 	const data = JSON.parse(msg.data)
 	if (data.length >= 2) {
 		switch (data[0]) {
 		case "EVENT":
 			if (data.length < 3)
 				return
 			return relay.event && relay.event(data[1], data[2])
 		case "EOSE":
 			return relay.eose && relay.eose(data[1])
 		case "NOTICE":
 			return relay.note && relay.note(...data.slice(1))
 		}
 	}
 }
 
 const relay = damus_init()