InterfaceHelper.js

'use strict'

class InterfaceHelper {
	static #initiated = false
	static #wired = false
	static #onInit = null
	static #onWorkerAdded = null
	static #workers = new Map()

	static preInit() {
		if (InterfaceHelper.#initiated) {
			console.error('InterfaceHelper is already initiated.')
			return
		}
		InterfaceHelper.#initiated = true

		const globalStyle = document.createElement('link')
		globalStyle.rel = 'stylesheet'
		globalStyle.href = '/global.css'
		document.head.prepend(globalStyle)

		const fallbackStyle = document.createElement('style')
		fallbackStyle.textContent = 'html { background-color: var(--main-background-color); }'
		document.head.prepend(fallbackStyle)
	}

	/** Coordinator shell: popup opener or `/join` parent. */
	static #target() {
		return globalThis.opener ?? globalThis.parent
	}

	static #ensureWired() {
		if (InterfaceHelper.#wired) {
			return
		}
		InterfaceHelper.#wired = true
		globalThis.addEventListener('message', InterfaceHelper.#onWindowMessage)
	}

	/**
	 * Called once with cloned match settings (`{ settings, opponents, … }`).
	 * Register workers with the `workerAdded` callback (slot `0` after this handler returns, then each `{ type: 'WorkerAdded', slot }`).
	 * @param {(init: unknown, workerAdded: (participant: InterfaceHelperWorker) => void) => void} handler
	 */
	static onInit(handler) {
		InterfaceHelper.#onInit = handler
		InterfaceHelper.#ensureWired()
	}

	/**
	 * @deprecated Register workers via the `workerAdded` argument to {@link InterfaceHelper.onInit} instead.
	 * @param {(worker: InterfaceHelperWorker) => void} handler
	 */
	static workerAdded(handler) {
		InterfaceHelper.#onWorkerAdded = handler
		InterfaceHelper.#ensureWired()
	}

	static #registerWorker(handler) {
		InterfaceHelper.#onWorkerAdded = handler
	}

	static #dispatchInit(init) {
		InterfaceHelper.#onInit?.(init, InterfaceHelper.#registerWorker)
		InterfaceHelper.#attachWorker(0)
	}

	/** Tell the coordinator the interface applied init and is listening. */
	static signalReady() {
		const t = InterfaceHelper.#target()
		if (t) {
			t.postMessage(null, '*')
		}
	}

	/** Coordinator init: `{ settings, opponents }` (see `cloneInterfaceWorkerInit`). */
	static #isInit(data) {
		if (typeof data !== 'object' || data === null) {
			return false
		}
		const type = data.type
		if (type === 'Post' || type === 'Response' || type === 'Arena-Interface-Ready' || type === 'Arena-Interface-Disconnected') {
			return false
		}
		const settings = data.settings
		if (settings !== undefined && typeof settings === 'object' && settings !== null) {
			return true
		}
		return data.general !== undefined && typeof data.general === 'object' && data.general !== null
	}

	static #unwrapPostEnvelope(data) {
		if (
			typeof data === 'object' &&
			data !== null &&
			data.type !== 'Post' &&
			typeof data.message === 'object' &&
			data.message !== null &&
			data.message.type === 'Post'
		) {
			return data.message
		}
		return data
	}

	static #isSystemPost(data) {
		return typeof data === 'object' && data !== null && data.type === 'Post' && data.systemMessage === true
	}

	static #isPost(data) {
		return typeof data === 'object' && data !== null && data.type === 'Post' && data.systemMessage !== true
	}

	static #isWorkerAddedMessage(message) {
		return (
			typeof message === 'object' &&
			message !== null &&
			message.type === 'WorkerAdded' &&
			typeof message.slot === 'number'
		)
	}

	static #isKillMessage(message) {
		return message === 'Kill' || (typeof message === 'object' && message !== null && message.type === 'Kill')
	}

	static #isDisconnected(data) {
		return typeof data === 'object' && data !== null && data.type === 'Arena-Interface-Disconnected'
	}

	static #showDisconnectedState(label) {
		const lock = document.getElementById('lock')
		if (!lock) {
			return
		}
		lock.classList.add('engaged')
		lock.classList.remove('booting')
		const span = lock.querySelector('span')
		if (span) {
			span.textContent = label
		}
	}

	static #coerceWorkerSlot(value) {
		if (typeof value === 'number' && Number.isFinite(value)) {
			return value
		}
		if (typeof value === 'string' && value !== '') {
			const n = Number(value)
			return Number.isFinite(n) ? n : 0
		}
		return 0
	}

	static #workerSlotFromEnvelope(data) {
		if (typeof data.workerSlot === 'number') {
			return data.workerSlot
		}
		if (typeof data.workerSlot === 'string') {
			return InterfaceHelper.#coerceWorkerSlot(data.workerSlot)
		}
		if (typeof data.workerName === 'string') {
			return data.workerName === '' ? 0 : InterfaceHelper.#coerceWorkerSlot(data.workerName)
		}
		if (InterfaceHelper.#isKillMessage(data.message) && typeof data.message === 'object' && data.message !== null) {
			return InterfaceHelper.#coerceWorkerSlot(data.message.slot ?? 0)
		}
		return 0
	}

	static #sendResponse(value, options, messageIndex) {
		const t = InterfaceHelper.#target()
		if (!t) {
			return
		}
		const executionSteps = options?.executionSteps ?? { toRespond: 0, toTerminate: 0 }
		const idx = options?.messageIndex ?? messageIndex
		t.postMessage({
			type: 'Response',
			response: {
				value,
				executionSteps,
				...(typeof idx === 'number' ? { messageIndex: idx } : {}),
				...(options?.console ? { console: options.console } : {}),
			},
		}, '*')
	}

	static #createWorker() {
		/** @type {number | null} */
		let lastMessageIndex = null
		const worker = {
			onMessage: null,
			onKilled: null,
			respond(value, options) {
				InterfaceHelper.#sendResponse(value, options, options?.messageIndex ?? lastMessageIndex)
			},
		}
		Object.defineProperty(worker, '_lastMessageIndex', {
			get: () => lastMessageIndex,
			set: (v) => {
				lastMessageIndex = v
			},
		})
		return worker
	}

	static #attachWorker(workerSlot) {
		if (!InterfaceHelper.#onWorkerAdded) {
			return
		}
		let worker = InterfaceHelper.#workers.get(workerSlot)
		if (worker) {
			return worker
		}
		worker = InterfaceHelper.#createWorker()
		InterfaceHelper.#workers.set(workerSlot, worker)
		InterfaceHelper.#onWorkerAdded(worker)
		return worker
	}

	static #onWindowMessage(messageEvent) {
		const data = InterfaceHelper.#unwrapPostEnvelope(messageEvent.data)
		if (InterfaceHelper.#isDisconnected(data)) {
			const label = typeof data.message === 'string' && data.message.trim() ? data.message.trim() : 'Match has ended'
			InterfaceHelper.#showDisconnectedState(label)
			return
		}
		if (InterfaceHelper.#isInit(data)) {
			InterfaceHelper.#dispatchInit(data)
			return
		}
		if (InterfaceHelper.#isSystemPost(data)) {
			const workerSlot = InterfaceHelper.#workerSlotFromEnvelope(data)
			if (InterfaceHelper.#isWorkerAddedMessage(data.message)) {
				InterfaceHelper.#attachWorker(data.message.slot)
				return
			}
			if (InterfaceHelper.#isKillMessage(data.message)) {
				const worker = InterfaceHelper.#workers.get(workerSlot)
				if (!worker) {
					InterfaceHelper.#sendResponse('Dead', {}, data.messageIndex)
					return
				}
				let responded = false
				const priorRespond = worker.respond
				worker.respond = function (value, options) {
					responded = true
					return priorRespond.call(
						this,
						value,
						{ ...options, messageIndex: options?.messageIndex ?? data.messageIndex },
					)
				}
				worker.onKilled?.()
				worker.respond = priorRespond
				if (!responded) {
					priorRespond.call(worker, 'Dead', { messageIndex: data.messageIndex })
				}
			}
			return
		}
		if (InterfaceHelper.#isPost(data)) {
			const workerSlot = InterfaceHelper.#workerSlotFromEnvelope(data)
			const worker = InterfaceHelper.#workers.get(workerSlot)
			if (!worker) {
				return
			}
			worker._lastMessageIndex = typeof data.messageIndex === 'number' ? data.messageIndex : null
			const message = {
				data: data.message,
				respond(value, options) {
					InterfaceHelper.#sendResponse(value, options, data.messageIndex)
				},
			}
			worker.onMessage?.(message)
		}
	}
}

globalThis.InterfaceHelper = InterfaceHelper
InterfaceHelper.preInit()