Endpoint.js

import Ws from 'isomorphic-ws'

/* import { version } from './package.json' with { type: 'json' } */
var version = '0.16'

import { CLOSED } from './status.js'

import Events from './_/Events.js'

import Websocket from './transport/Websocket.js'


/* * */
function noop () {}

var defaults =
{
	should_reconnect: void 0,
	reconnect_interval: 1e3,
	should_cleanup: void 0,
	emit_on_open_success: true,
}


export default function Endpoint (transport, options) /* eslint-disable-line max-statements, complexity */
{
	var internal = (arguments[2] ?? {})
	var { ws, dispatch, events } = internal

	options = { ...defaults, ...options }

	events ??= Events()

	var $buffer = null
	if (! dispatch)
	{
		$buffer = []
	}

	var $ws
	if (dispatch)
	{
		$ws = ws
		ws  = null
	}


	var endp =
	{
		on,
		send,

		status,

		open,
		close,

		aux: {},
	}


	function status ()
	{
		return $ws?.readyState ?? CLOSED
	}

	function on (...args)
	{
		if (dispatch)
		{
			return noop
		}
		else if (events)
		{
			return events.on(...args)
		}
		else
		{
			return noop
		}
	}

	function send (key, data)
	{
		if ($buffer)
		{
			$buffer.push([ key, data ])
		}
		else if ($ws)
		{
			if (typeof key === 'string')
			{
				$ws.send(`@${ key }:${ String(data ?? '') }`)
			}
			else
			{
				send_binary(key)
			}
		}
	}

	function send_binary (msg)
	{
		if ($ws instanceof Ws)
		{
			$ws.send(msg)
			return
		}
		if ($ws.capabilities?.binary)
		{
			$ws.send(msg)
			return
		}

		/* TODO: impl binary emulation */
		throw new TypeError('binary_not_supported')
	}

	function recv (event)
	{
		var msg = event.data

		events.emit('@recv', msg, { endp })

		if (typeof msg    !== 'string') return recv_binary(msg)
		if (msg.charAt(0) !== '@') return
		if (msg.charAt(1) === '@') return

		var colon = msg.indexOf(':')
		if (colon === -1) return

		var key  = msg.slice(1, colon)
		var data = msg.slice(colon + 1)

		var meta = { key, msg, data, endp }
		events.emit(key, data, meta)
	}

	function recv_binary (msg)
	{
		var key  = '@binary'
		var data = msg

		var meta = { key, msg, data, endp }
		events.emit(key, data, meta)
	}

	function open () /* eslint-disable-line max-statements, complexity */
	{
		if (! endp)
		{
			throw new ReferenceError('has_been_cleaned')
		}

		// TODO: TBD: pre-close (async involved)
		// TBD: check status

		if (! dispatch)
		{
			if (typeof transport === 'function')
			{
				$ws = transport()
			}
			else if (typeof transport === 'string')
			{
				$ws = Websocket(transport)
			}
			else
			{
				throw new TypeError('unknown_transport')
			}
		}

		/* #1 */
		if (! dispatch)
		{
			ev('open', on_open_endp)
		}

		/* #2 */
		ev('close',  () => events.emit('@close', void 0, { endp }))
		ev('error', (e) => events.emit('@error',      e, { endp }))

		ev('message', recv)

		/* #3 */
		if (! dispatch)
		{
			ev('close', on_close_endp)
		}
		else
		{
			ev('close', cleanup)
		}

		function ev (name, handler)
		{
			$ws.addEventListener(name, handler)
		}

		if (dispatch)
		{
			/* instantly opened when under Dispatch, we're in a callback already */
			events.emit('@open',    void 0, { endp })
			events.emit('@connect', void 0, { endp })

			dispatch.rooms.join_if_any('@all', endp)

			$ws.send(`@@booth:${ version }`)
		}
	}

	function on_open_endp ()
	{
		events.emit('@open', void 0, { endp })

		$ws.send(`@@booth:${ version }:endp`)

		if (options.emit_on_open_success)
		{
			on_open_success()
		}
	}

	function on_open_success ()
	{
		flush()
		on_connect_or_reconnect()
	}

	if (internal.events && (! options.on_open_success))
	{
		events.on('@@open/success', on_open_success)
	}

	function flush ()
	{
		if (! $buffer) return

		var to_flush = $buffer
		$buffer = null

		for (var pair of to_flush)
		{
			send(...pair)
		}
	}

	var been_connected = false
	function on_connect_or_reconnect ()
	{
		if (! been_connected)
		{
			been_connected = true

			events.emit('@connect',   void 0, { endp })
		}
		else
		{
			events.emit('@reconnect', void 0, { endp })
		}
	}

	function on_close_endp ()
	{
		if (! $ws)
		{
			cleanup()
			return
		}
		if (! should_reconnect())
		{
			cleanup()
			return
		}

		$buffer = []
		$ws = null

		setTimeout(open, options.reconnect_interval)
	}

	function should_reconnect ()
	{
		if (options.should_reconnect !== void 0)
		{
			return options.should_reconnect
		}

		if ($ws instanceof Ws)
		{
			return true
		}

		return ($ws?.capabilities?.reconnect ?? true)
	}

	function close ()
	{
		if (! $ws) return

		// TODO: TBD: await close (async involved)
		// TBD: check status

		$ws.close()
		$ws = null
	}

	function cleanup ()
	{
		if (! endp) return
		if (options.should_cleanup === false) return

		dispatch?.rooms.leave_every(endp)

		$buffer = null
		$ws = null

		dispatch = null
		events = null

		endp = null
	}

	return (open(), endp)
}