@liphium/neoroute-ts 0.1.0

package/src/transporter/transporter_http.ts

@@ -0,0 +1,37 @@
+import type { Sender } from '../sender.js';
+
+export class HTTPTransporter {
+	private sender: Sender;
+
+	constructor(s: Sender, method: string, url: string) {
+		this.sender = s;
+
+		this.sender.setSendFunc(async (data: Uint8Array): Promise<void> => {
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(), 20000);
+
+			try {
+				const response = await fetch(url, {
+					method: method,
+					body: data as unknown as BodyInit,
+					signal: controller.signal,
+					headers: {
+						'Content-Type': 'application/octet-stream',
+					},
+				});
+
+				// Check for transporter errors
+				if (!response.ok) {
+					throw new Error(
+						`received non ok status ${response.status} ${response.statusText}`,
+					);
+				}
+
+				// Let sender handle the response routing
+				this.sender.handle(await response.bytes());
+			} finally {
+				clearTimeout(timeout);
+			}
+		});
+	}
+}

package/src/transporter/transporter_websocket.ts

@@ -0,0 +1,115 @@
+import { logger } from '../logger.js';
+import type { Receiver } from '../receiver.js';
+
+export interface WebSocketOptions {
+	// Timeout for the initial connection attempt, default is 20 seconds.
+	connectionTimeout?: number;
+
+	// When the connection actually opens.
+	onOpen?: () => void;
+}
+
+export class WebSocketTransporter {
+	private conn: WebSocket | null = null;
+	private receiver: Receiver;
+	private options: WebSocketOptions;
+	private connected: boolean = false;
+	private queue: Uint8Array[] = [];
+
+	constructor(receiver: Receiver, options: WebSocketOptions) {
+		this.receiver = receiver;
+		this.options = options;
+	}
+
+	/// Will start a connection to the server. Will not block until the connection is open.
+	///
+	/// All things sent before the connection is open are queued, so feel free to send already after calling connect.
+	public connect(url: string) {
+		if (this.connected || this.conn) {
+			return;
+		}
+
+		// Queue outgoing messages until connection is open
+		this.receiver.setSendFunc(async (data: Uint8Array): Promise<void> => {
+			if (this.connected && this.conn?.readyState === WebSocket.OPEN) {
+				this.conn.send(data as any); // TODO: Find out if this is actually fine xd
+			} else {
+				this.queue.push(data);
+			}
+		});
+
+		// Add a timeout to make sure the connection actually happens
+		const timeout = setTimeout(() => {
+			if (this.conn?.readyState !== WebSocket.OPEN) {
+				this.close('connection timeout');
+			}
+		}, this.options.connectionTimeout ?? 20000);
+
+		// Init WebSocket to open the actual connection
+		this.conn = new WebSocket(url);
+		this.conn.binaryType = 'arraybuffer';
+
+		this.conn.onopen = () => {
+			if (!this.conn) return;
+
+			clearTimeout(timeout);
+			this.connected = true;
+
+			// Call onOpen callback
+			this.options.onOpen?.();
+
+			// Flush queue
+			while (this.queue.length > 0) {
+				const data = this.queue.shift();
+				if (data) {
+					this.conn.send(data as any);
+				}
+			}
+		};
+
+		// When there is an error, we immediately disconnect
+		this.conn.onerror = () => {
+			if (this.conn) {
+				this.close('websocket error');
+			}
+		};
+
+		// Even on a close, we want to quickly close the thingy to notify the event handler for onError and update internal state
+		this.conn.onclose = (event) => {
+			if (this.conn) {
+				this.close(
+					`websocket connection closed: ${event.code} ${event.reason}`,
+				);
+			}
+		};
+
+		// Forward messages to the receiver
+		this.conn.onmessage = (event) => {
+			if (event.data instanceof ArrayBuffer) {
+				this.receiver.handle(new Uint8Array(event.data));
+			} else {
+				// If we get this, the browser is doing something weird
+				logger.error('wrong message type received:', typeof event.data);
+				this.close('wrong kind of message received');
+			}
+		};
+	}
+
+	/// Closes the connection to the server. Will not throw if the connection is already closed.
+	public close(reason: string = 'Connection closed'): void {
+		const wasConnected = this.connected || !!this.conn;
+		this.connected = false;
+		if (this.conn) {
+			const c = this.conn;
+			this.conn = null;
+			c.close(1000, reason);
+		}
+		if (wasConnected) {
+			this.receiver.getConfig().errorHandler(new Error(reason));
+		}
+	}
+
+	public isConnected(): boolean {
+		return this.connected;
+	}
+}

package/src/user_error.ts

@@ -0,0 +1,21 @@
+export class UserError extends Error {
+	constructor(message: string) {
+		super(message);
+
+		this.name = 'UserError';
+
+		if (
+			typeof (Error as ErrorConstructor & { captureStackTrace?: unknown })
+				.captureStackTrace === 'function'
+		) {
+			(
+				Error as ErrorConstructor & {
+					captureStackTrace: (
+						targetObject: object,
+						constructorOpt?: Function,
+					) => void;
+				}
+			).captureStackTrace(this, UserError);
+		}
+	}
+}

package/src/util.ts

@@ -0,0 +1,58 @@
+import { decode, encode } from '@msgpack/msgpack';
+
+// Creates a promise that can be resolved or rejected externally. This is useful for creating a promise that can be resolved or rejected at a later time, such as when waiting for an event to occur.
+export function newPromiseWithResolver<T>(): {
+	resolve: (value: T | PromiseLike<T>) => void;
+	reject: (reason?: any) => void;
+	promise: Promise<T>;
+} {
+	let resolve!: (value: T | PromiseLike<T>) => void;
+	let reject!: (reason?: any) => void;
+
+	const promise = new Promise<T>((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+
+	return { resolve, reject, promise };
+}
+
+// Helper to create a timeout promise
+export function withTimeout<T>(
+	promise: Promise<T>,
+	timeoutMs: number,
+	onTimeout?: () => void,
+): Promise<T> {
+	let timeoutId: ReturnType<typeof setTimeout>;
+	const timeoutPromise = new Promise<T>((_, reject) => {
+		timeoutId = setTimeout(() => {
+			onTimeout?.();
+			reject(
+				new Error(
+					`waiting for response timed out after ${timeoutMs}ms`,
+				),
+			);
+		}, timeoutMs);
+	});
+
+	return Promise.race([
+		promise.finally(() => clearTimeout(timeoutId)),
+		timeoutPromise,
+	]);
+}
+
+export function marshalRequestData<RQ>(req: RQ): Uint8Array {
+	try {
+		return encode(req);
+	} catch (error) {
+		throw new Error(`failed to marshal request data: ${error}`);
+	}
+}
+
+export function unmarshalResponseData<RS>(respBytes: Uint8Array): RS {
+	try {
+		return decode(respBytes) as RS;
+	} catch (error) {
+		throw new Error(`failed to unmarshal response data: ${error}`);
+	}
+}

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+	// Visit https://aka.ms/tsconfig to read more about this file
+	"compilerOptions": {
+		// File Layout
+		"rootDir": ".",
+		"outDir": "./dist",
+
+		// Environment Settings
+		// See also https://aka.ms/tsconfig/module
+		"module": "nodenext",
+		"target": "esnext",
+		"types": ["node"],
+		// For nodejs:
+		// "lib": ["esnext"],
+		// "types": ["node"],
+		// and npm install -D @types/node
+
+		// Other Outputs
+		"sourceMap": true,
+		"declaration": true,
+		"declarationMap": true,
+
+		// Stricter Typechecking Options
+		"noUncheckedIndexedAccess": true,
+		"exactOptionalPropertyTypes": true,
+
+		// Style Options
+		// "noImplicitReturns": true,
+		// "noImplicitOverride": true,
+		// "noUnusedLocals": true,
+		// "noUnusedParameters": true,
+		// "noFallthroughCasesInSwitch": true,
+		// "noPropertyAccessFromIndexSignature": true,
+
+		// Recommended Options
+		"strict": true,
+		"jsx": "react-jsx",
+		"verbatimModuleSyntax": true,
+		"isolatedModules": true,
+		"noUncheckedSideEffectImports": true,
+		"moduleDetection": "force",
+		"skipLibCheck": true,
+	},
+}