sportident.js 1.0.0 → 1.0.2

package/src/SiDevice/SiDevice.test.ts

@@ -1,354 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import * as testUtils from '../testUtils';
-import type { ISiDeviceDriver } from './ISiDeviceDriver';
-import { DeviceClosedError, type ISiDeviceDriverData, SiDeviceState, SiDeviceStateChangeEvent } from './ISiDevice';
-import { SiDevice } from './SiDevice';
-
-testUtils.useFakeTimers();
-
-function mockDriver(driver: Partial<ISiDeviceDriver<ISiDeviceDriverData<unknown>>>) {
-	return driver as unknown as ISiDeviceDriver<ISiDeviceDriverData<unknown>>;
-}
-
-describe('SiDevice', () => {
-	test('state management', () => {
-		const siDevice = new SiDevice('stateManagement', {
-			driver: mockDriver({ name: 'FakeDriver' })
-		});
-		const stateChanges: SiDeviceState[] = [];
-		const onStateChange = (e: SiDeviceStateChangeEvent) => {
-			stateChanges.push(e.state);
-		};
-		siDevice.addEventListener('stateChange', onStateChange);
-		expect(stateChanges).toEqual([]);
-		expect(siDevice.state).toBe(SiDeviceState.Closed);
-		siDevice.setState(SiDeviceState.Closed);
-		expect(stateChanges).toEqual([]);
-		expect(siDevice.state).toBe(SiDeviceState.Closed);
-		siDevice.setState(SiDeviceState.Opening);
-		expect(stateChanges).toEqual([SiDeviceState.Opening]);
-		expect(siDevice.state).toBe(SiDeviceState.Opening);
-		siDevice.setState(SiDeviceState.Opened);
-		expect(stateChanges).toEqual([SiDeviceState.Opening, SiDeviceState.Opened]);
-		expect(siDevice.state).toBe(SiDeviceState.Opened);
-		siDevice.removeEventListener('stateChange', onStateChange);
-	});
-	test('fails opening while opening', (done) => {
-		const data = {
-			driver: mockDriver({})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		siDevice.setState(SiDeviceState.Opening);
-		siDevice.open().catch(() => done());
-	});
-	test('fails opening while closing', (done) => {
-		let count = 0;
-		const siDevice = new SiDevice('receiveLoopFail', {
-			driver: mockDriver({
-				receive: (_device: unknown) => {
-					if (count > 2) {
-						throw new DeviceClosedError('test');
-					}
-					count += 1;
-					throw new Error('test');
-				}
-			})
-		});
-
-		siDevice.setState(SiDeviceState.Closing);
-		siDevice.open().catch(() => done());
-	});
-	test('immediately opens when opened', (done) => {
-		let count = 0;
-		const data = {
-			driver: mockDriver({
-				receive: (_device: unknown) => {
-					if (count > 2) {
-						throw new DeviceClosedError('test');
-					}
-					count += 1;
-					throw new Error('test');
-				}
-			})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		siDevice.setState(SiDeviceState.Opened);
-		siDevice.open().then((openedDevice) => {
-			expect(openedDevice).toBe(siDevice);
-			done();
-		});
-	});
-	test('opens when closed', (done) => {
-		let opened = false;
-		const data = {
-			driver: mockDriver({
-				open: (_device: unknown) => {
-					opened = true;
-					return Promise.resolve();
-				}
-			})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		siDevice.setState(SiDeviceState.Closed);
-		siDevice.open().then((openedDevice) => {
-			expect(openedDevice).toBe(siDevice);
-			expect(opened).toBe(true);
-			done();
-		});
-	});
-	test('opening can fail', (done) => {
-		const data = {
-			driver: mockDriver({
-				open: (_device: unknown) => {
-					throw new Error('test');
-				}
-			})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		siDevice.setState(SiDeviceState.Closed);
-		siDevice.open().catch((err) => {
-			expect(err.message).toBe('test');
-			done();
-		});
-	});
-	test('opening can reject', (done) => {
-		const data = {
-			driver: mockDriver({
-				open: (_device: unknown) => Promise.reject(new Error('test'))
-			})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		siDevice.setState(SiDeviceState.Closed);
-		siDevice.open().catch((err) => {
-			expect(err.message).toBe('test');
-			done();
-		});
-	});
-	test('fails closing while opening', (done) => {
-		const data = {
-			driver: mockDriver({})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		siDevice.setState(SiDeviceState.Opening);
-		siDevice.close().catch(() => done());
-	});
-	test('fails closing while closing', (done) => {
-		const data = {
-			driver: mockDriver({})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		siDevice.setState(SiDeviceState.Closing);
-		siDevice.close().catch(() => done());
-	});
-	test('immediately closes when closed', (done) => {
-		const data = {
-			driver: mockDriver({})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		siDevice.setState(SiDeviceState.Closed);
-		siDevice.close().then((openedDevice) => {
-			expect(openedDevice).toBe(siDevice);
-			done();
-		});
-	});
-	test('closes when opened', (done) => {
-		let opened = true;
-		const data = {
-			driver: mockDriver({
-				close: (_device: unknown) => {
-					opened = false;
-					return Promise.resolve();
-				}
-			})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		siDevice.setState(SiDeviceState.Opened);
-		siDevice.close().then((openedDevice) => {
-			expect(openedDevice).toBe(siDevice);
-			expect(opened).toBe(false);
-			done();
-		});
-	});
-	test('closing can fail', (done) => {
-		const data = {
-			driver: mockDriver({
-				close: (_device: unknown) => {
-					throw new Error('test');
-				}
-			})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		siDevice.setState(SiDeviceState.Opened);
-		siDevice.close().catch((err) => {
-			expect(err.message).toBe('test');
-			done();
-		});
-	});
-	test('closing can reject', (done) => {
-		const data = {
-			driver: mockDriver({
-				close: (_device: unknown) => Promise.reject(new Error('test'))
-			})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		siDevice.setState(SiDeviceState.Opened);
-		siDevice.close().catch((err) => {
-			expect(err.message).toBe('test');
-			done();
-		});
-	});
-	test('receiveLoop succeed', async () => {
-		let count = 0;
-		const data = {
-			driver: mockDriver({
-				receive: (_device: unknown) =>
-					new Promise((resolve) => {
-						if (count > 2) {
-							throw new DeviceClosedError('test');
-						}
-						setTimeout(() => {
-							count += 1;
-							resolve([0x12]);
-						}, 1);
-					})
-			})
-		};
-		const siDevice = new SiDevice('receiveLoopSucceed', data);
-
-		const received: number[][] = [];
-		siDevice.addEventListener('receive', (e) => {
-			received.push(e.uint8Data);
-		});
-		siDevice.setState(SiDeviceState.Opened);
-		siDevice.receiveLoop();
-
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(1));
-		expect(count).toBe(1);
-		expect(received).toEqual([[0x12]]);
-
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(1));
-		expect(count).toBe(2);
-		expect(received).toEqual([[0x12], [0x12]]);
-	});
-	test('receiveLoop can fail', async () => {
-		let count = 0;
-		const data = {
-			driver: mockDriver({
-				receive: (_device: unknown) => {
-					if (count > 2) {
-						throw new DeviceClosedError('test');
-					}
-					count += 1;
-					throw new Error('test');
-				}
-			})
-		};
-		const siDevice = new SiDevice('receiveLoopFail', data);
-
-		const received: number[][] = [];
-		siDevice.addEventListener('receive', (e) => {
-			received.push(e.uint8Data);
-		});
-		siDevice.setState(SiDeviceState.Opened);
-		siDevice.receiveLoop();
-
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(1));
-		expect(count).toBe(1);
-		expect(received).toEqual([]);
-
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(100));
-		expect(count).toBe(2);
-		expect(received).toEqual([]);
-	});
-	test('receiveLoop can reject', async () => {
-		let count = 0;
-		const data = {
-			driver: mockDriver({
-				receive: (_device: unknown) => {
-					if (count > 2) {
-						throw new DeviceClosedError('test');
-					}
-					count += 1;
-					return Promise.reject(new Error('test'));
-				}
-			})
-		};
-		const siDevice = new SiDevice('receiveLoopReject', data);
-
-		const received: number[][] = [];
-		siDevice.addEventListener('receive', (e) => {
-			received.push(e.uint8Data);
-		});
-		siDevice.setState(SiDeviceState.Opened);
-		siDevice.receiveLoop();
-
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(1));
-		expect(count).toBe(1);
-		expect(received).toEqual([]);
-
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(100));
-		expect(count).toBe(2);
-		expect(received).toEqual([]);
-	});
-	test('receiveLoop can fail if device closed', async () => {
-		let count = 0;
-		const data = {
-			driver: mockDriver({
-				receive: (_device: unknown) => {
-					count += 1;
-					throw new DeviceClosedError('test');
-				}
-			})
-		};
-		const siDevice = new SiDevice('receiveLoopFailIfClosed', data);
-
-		const received: number[][] = [];
-		siDevice.addEventListener('receive', (e) => {
-			received.push(e.uint8Data);
-		});
-		siDevice.setState(SiDeviceState.Opened);
-		siDevice.receiveLoop();
-
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(1));
-		expect(count).toBe(1);
-		expect(received).toEqual([]);
-
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(100));
-		expect(count).toBe(1);
-		expect(received).toEqual([]);
-	});
-
-	test('can send', async () => {
-		const sent: number[][] = [];
-		const data = {
-			driver: mockDriver({
-				send: (_device: unknown, buffer: number[]) => {
-					sent.push(buffer);
-					return Promise.resolve();
-				}
-			})
-		};
-		const siDevice = new SiDevice('canSend', data);
-
-		siDevice.setState(SiDeviceState.Opened);
-		siDevice.send([0x34]);
-
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
-		expect(sent).toEqual([[0x34]]);
-		siDevice.send([0x56]);
-
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(100));
-		expect(sent).toEqual([[0x34], [0x56]]);
-	});
-});

package/src/SiDevice/SiDevice.ts

@@ -1,132 +0,0 @@
-import { DeviceClosedError, type ISiDevice, type ISiDeviceDriverData, type SiDeviceEvents, SiDeviceReceiveEvent, SiDeviceState, SiDeviceStateChangeEvent } from './ISiDevice';
-import * as utils from '../utils';
-import type { ISiDeviceDriver } from './ISiDeviceDriver';
-
-export class SiDevice<T extends ISiDeviceDriverData<ISiDeviceDriver<T>>> implements ISiDevice<T> {
-	name: string;
-	ident: string;
-	data: T;
-	private internalState: SiDeviceState;
-
-	constructor(typeSpecificIdent: string, data: T) {
-		this.data = data;
-		this.name = `${data.driver.name}(${typeSpecificIdent})`;
-		this.ident = `${data.driver.name}-${typeSpecificIdent}`;
-		this.internalState = SiDeviceState.Closed;
-	}
-
-	get state(): SiDeviceState {
-		return this.internalState;
-	}
-
-	setState(newState: SiDeviceState): void {
-		if (newState !== this.internalState) {
-			this.internalState = newState;
-			this.dispatchEvent('stateChange', new SiDeviceStateChangeEvent(this, newState));
-		}
-	}
-
-	open(): Promise<SiDevice<T>> {
-		if (this.state === SiDeviceState.Closing) {
-			return Promise.reject(new Error(`Cannot open closing ${this.constructor.name}`));
-		}
-		if (this.state === SiDeviceState.Opening) {
-			return Promise.reject(new Error(`Cannot open opening ${this.constructor.name}`));
-		}
-		if (this.state === SiDeviceState.Opened) {
-			return Promise.resolve(this);
-		}
-		this.setState(SiDeviceState.Opening);
-		try {
-			return this.data.driver
-				.open(this)
-				.then(() => {
-					console.debug('Starting Receive Loop...');
-					this.receiveLoop();
-					this.setState(SiDeviceState.Opened);
-					return this;
-				})
-				.catch((err: Error) => {
-					this.setState(SiDeviceState.Closed);
-					throw err;
-				});
-		} catch (err) {
-			return Promise.reject(err);
-		}
-	}
-
-	close(): Promise<SiDevice<T>> {
-		if (this.state === SiDeviceState.Closing) {
-			return Promise.reject(new Error(`Cannot close closing ${this.constructor.name}`));
-		}
-		if (this.state === SiDeviceState.Opening) {
-			return Promise.reject(new Error(`Cannot close opening ${this.constructor.name}`));
-		}
-		if (this.state === SiDeviceState.Closed) {
-			return Promise.resolve(this);
-		}
-		this.setState(SiDeviceState.Closing);
-		try {
-			return this.data.driver
-				.close(this)
-				.then(() => {
-					this.setState(SiDeviceState.Closed);
-					return this;
-				})
-				.catch((err: Error) => {
-					this.setState(SiDeviceState.Closed);
-					throw err;
-				});
-		} catch (err) {
-			return Promise.reject(err);
-		}
-	}
-
-	receiveLoop(): void {
-		try {
-			// Stop receive loop when closing
-			if (this.internalState == SiDeviceState.Closing || this.internalState == SiDeviceState.Closed) {
-				return;
-			}
-			this.receive()
-				.then((uint8Data) => {
-					console.debug(`<= (${this.name})\n${utils.prettyHex(uint8Data, 16)}`);
-					this.dispatchEvent('receive', new SiDeviceReceiveEvent(this, uint8Data));
-				})
-				.catch((err: Error) => {
-					if (this.shouldStopReceivingBecauseOfError(err)) {
-						console.warn('Receive loop stopped while receiving');
-						throw err;
-					}
-					console.warn(`${this.name}: Error receiving: ${err.message}`);
-					return utils.waitFor(100);
-				})
-				.then(() => this.receiveLoop())
-				.catch(() => undefined);
-		} catch (exc: unknown) {
-			const err = utils.getErrorOrThrow(exc);
-			console.warn(`${this.name}: Error starting receiving: ${err.message}`);
-			if (this.shouldStopReceivingBecauseOfError(err)) {
-				console.warn('Receive loop stopped while starting receiving');
-				return;
-			}
-			utils.waitFor(100).then(() => this.receiveLoop());
-		}
-	}
-
-	shouldStopReceivingBecauseOfError(error: unknown): boolean {
-		return error instanceof DeviceClosedError || error instanceof utils.NotImplementedError;
-	}
-
-	receive(): Promise<number[]> {
-		return this.data.driver.receive(this);
-	}
-
-	send(buffer: number[]): Promise<unknown> {
-		console.debug(`=> (${this.name})\n${utils.prettyHex(buffer, 16)}`);
-		return this.data.driver.send(this, buffer);
-	}
-}
-// eslint-disable-next-line @typescript-eslint/no-empty-interface,@typescript-eslint/no-unused-vars
-export interface SiDevice<T extends ISiDeviceDriverData<ISiDeviceDriver<T>>> extends utils.EventTarget<SiDeviceEvents> {}
-utils.applyMixins(SiDevice, [utils.EventTarget]);

package/src/SiDevice/WebSerialSiDeviceDriver.ts

@@ -1,146 +0,0 @@
-import * as utils from '../utils';
-import type { ISiDevice, ISiDeviceDriverData } from '../SiDevice/ISiDevice';
-import type { ISiDeviceDriver, SiDeviceDriverWithAutodetectionEvents } from '../SiDevice/ISiDeviceDriver';
-import { SiDeviceRemoveEvent } from '../SiDevice/ISiDeviceDriver';
-import { SiDevice } from '../SiDevice/SiDevice';
-import type * as nav from './INavigatorWebSerial';
-
-const siDeviceFilters = [{ usbVendorId: 0x10c4, usbProductId: 0x800a }];
-const matchesSiDeviceFilters = (usbVendorId: number, usbProductId: number) => siDeviceFilters.some((filter) => usbVendorId === filter.usbVendorId && usbProductId === filter.usbProductId);
-
-const getIdent = (device: nav.WebSerialDevice) => `${device.getInfo().usbProductId}`;
-
-export interface WebSerialSiDeviceDriverData extends ISiDeviceDriverData<WebSerialSiDeviceDriver> {
-	driver: WebSerialSiDeviceDriver;
-	device: nav.WebSerialDevice;
-}
-
-export type IWebSerialSiDevice = ISiDevice<WebSerialSiDeviceDriverData>;
-export type WebSerialSiDevice = SiDevice<WebSerialSiDeviceDriverData>;
-
-class WebSerialSiDeviceDriver implements ISiDeviceDriver<WebSerialSiDeviceDriverData> {
-	public name = 'WebSerial';
-
-	private siDeviceByIdent: { [ident: string]: WebSerialSiDevice } = {};
-
-	private autodetectedSiDevices: { [ident: string]: WebSerialSiDevice } = {};
-
-	private reader: ReadableStreamDefaultReader<any> | undefined;
-
-	constructor(private navigatorSerial: nav.Serial) {}
-
-	detect(): Promise<WebSerialSiDevice> {
-		return this.navigatorSerial
-			.requestPort({
-				filters: siDeviceFilters
-			})
-			.catch((e) => {
-				return Promise.reject(new Error('Failed to get access to Serial device!' + e.toString()));
-			})
-			.then((navigatorWebSerialDevice: nav.WebSerialDevice) => {
-				if (!matchesSiDeviceFilters(navigatorWebSerialDevice.getInfo().usbVendorId || 0, navigatorWebSerialDevice.getInfo().usbProductId || 0)) {
-					return Promise.reject(new Error('Not a SI device'));
-				}
-				const ident = getIdent(navigatorWebSerialDevice);
-				if (this.autodetectedSiDevices[ident] !== undefined) {
-					return Promise.reject(new Error('Duplicate SI device'));
-				}
-				const siDevice = this.getSiDevice(navigatorWebSerialDevice);
-				this.autodetectedSiDevices[ident] = siDevice;
-				return siDevice.open();
-			});
-	}
-
-	getSiDevice(navigatorWebSerialDevice: nav.WebSerialDevice): WebSerialSiDevice {
-		const ident = getIdent(navigatorWebSerialDevice);
-		if (this.siDeviceByIdent[ident] !== undefined) {
-			return this.siDeviceByIdent[ident];
-		}
-		const newSiDeviceData: WebSerialSiDeviceDriverData = {
-			driver: this,
-			device: navigatorWebSerialDevice
-		};
-		const newSiDevice = new SiDevice(ident, newSiDeviceData);
-		this.siDeviceByIdent[ident] = newSiDevice;
-		return newSiDevice;
-	}
-
-	forgetSiDevice(siDevice: IWebSerialSiDevice) {
-		const navigatorWebSerialDevice = siDevice.data.device;
-		const ident = getIdent(navigatorWebSerialDevice);
-		delete this.siDeviceByIdent[ident];
-		if (this.autodetectedSiDevices[ident] !== undefined) {
-			this.dispatchEvent('remove', new SiDeviceRemoveEvent(siDevice));
-		}
-		delete this.autodetectedSiDevices[ident];
-	}
-
-	open(device: IWebSerialSiDevice): Promise<void> {
-		console.debug('Opening...');
-		const navigatorDevice = device.data.device;
-		return navigatorDevice.open({ baudRate: 38400 })
-		.catch((e) => {
-			return Promise.reject(new Error("Failed to open serial device"))
-		});
-	}
-
-	async close(device: IWebSerialSiDevice): Promise<void> {
-		console.debug('Disabling Serial...');
-		const navigatorDevice = device.data.device;
-		try {
-			if (this.reader != undefined) {
-				this.reader.releaseLock();
-			}
-		} catch (e) {
-			console.warn(e);
-		}
-		this.forgetSiDevice(device);
-		await navigatorDevice.readable.cancel();
-		await navigatorDevice.close();
-	}
-
-	async receive(device: IWebSerialSiDevice): Promise<number[]> {
-		const navigatorDevice = device.data.device;
-		this.reader = navigatorDevice.readable.getReader();
-		try {
-			while (true) {
-				const { value, done } = await this.reader.read();
-				if (done) {
-					if (value == undefined) {
-						return [];
-					}
-					return value;
-				}
-				if (value != undefined) {
-					return value;
-				}
-			}
-		} catch (error) {
-			console.warn(error);
-		} finally {
-			this.reader.releaseLock();
-		}
-		return [];
-	}
-
-	async send(device: IWebSerialSiDevice, uint8Data: number[]): Promise<void> {
-		const navigatorDevice = device.data.device;
-		const buffer = new Uint8Array(uint8Data);
-		if (navigatorDevice.writable == null) {
-			console.error('SiStation is not writable!');
-			return;
-		}
-		const writer = navigatorDevice.writable.getWriter();
-		await writer
-			.write(buffer)
-			.then(() => {
-				return writer.releaseLock();
-			})
-			.then(() => true);
-	}
-}
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-interface WebSerialSiDeviceDriver extends utils.EventTarget<SiDeviceDriverWithAutodetectionEvents<WebSerialSiDeviceDriverData>> {}
-utils.applyMixins(WebSerialSiDeviceDriver, [utils.EventTarget]);
-
-export const getWebSerialSiDeviceDriver = (navigatorWebSerial: Serial): WebSerialSiDeviceDriver => new WebSerialSiDeviceDriver(<nav.Serial>(<unknown>navigatorWebSerial));