sportident.js 1.0.0 → 1.0.1

package/src/utils/bytes.ts

@@ -1,69 +0,0 @@
-export const isByte = (byte: unknown): boolean => Number(byte) === byte && Math.floor(byte) === byte && byte <= 0xff && byte >= 0x00;
-
-export const isByteArr = (arr: unknown[]): boolean => Array.isArray(arr) && !arr.some((e) => !isByte(e));
-
-export const assertIsByteArr = (arr: unknown[]): void => {
-	if (!isByteArr(arr)) {
-		throw new Error(`${arr} is not a byte array`);
-	}
-};
-
-export const isArrOfLengths = (arr: unknown[], lengths: number[]): boolean => {
-	const actualLength = arr.length;
-	return lengths.some((length) => actualLength === length);
-};
-
-export const assertArrIsOfLengths = (arr: unknown[], lengths: number[]): void => {
-	if (!isArrOfLengths(arr, lengths)) {
-		throw new Error(`${arr} is not of lengths ${lengths}`);
-	}
-};
-
-export const arr2big = (arr: number[]): number => {
-	assertIsByteArr(arr);
-	let outnum = 0;
-	for (let i = 0; i < arr.length; i++) {
-		const byte = arr[i];
-		outnum += byte * Math.pow(0x100, arr.length - i - 1);
-	}
-	return outnum;
-};
-
-export const prettyHex = (input: string | (number | undefined)[], lineLength = 0): string => {
-	let iterable = input;
-	if (typeof input === 'string') {
-		iterable = [];
-		for (let strIndex = 0; strIndex < input.length; strIndex++) {
-			iterable.push(input.charCodeAt(strIndex));
-		}
-	}
-	const prettyBytes = [...(iterable as (number | undefined)[])].map((byte) => (byte !== undefined ? `00${byte.toString(16)}` : '??')).map((paddedStr) => paddedStr.slice(-2).toUpperCase());
-	if (lineLength === 0) {
-		return prettyBytes.join(' ');
-	}
-	const lines = [];
-	for (let lineIndex = 0; lineIndex < prettyBytes.length / lineLength; lineIndex++) {
-		const startIndex = lineIndex * lineLength;
-		const endIndex = (lineIndex + 1) * lineLength;
-		const line = prettyBytes.slice(startIndex, endIndex).join(' ');
-		lines.push(line);
-	}
-	return lines.join('\n');
-};
-
-export const unPrettyHex = (input: string): Array<number | undefined> => {
-	const hexString = input.replace(/\s/g, '');
-	if (hexString.length % 2 !== 0) {
-		throw new Error('Hex String length must be even');
-	}
-	const byteArray = [];
-	for (let byteIndex = 0; byteIndex < hexString.length / 2; byteIndex++) {
-		const hexByteString = hexString.substr(byteIndex * 2, 2);
-		const byteValue = hexByteString === '??' ? undefined : parseInt(hexByteString, 16);
-		if (byteValue !== undefined && (!Number.isInteger(byteValue) || byteValue < 0 || byteValue > 255)) {
-			throw new Error(`Invalid hex: ${hexByteString}`);
-		}
-		byteArray.push(byteValue);
-	}
-	return byteArray;
-};

package/src/utils/errors.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import * as errorUtils from './errors';
-
-describe('error utils', () => {
-	describe('getErrorOrThrow', () => {
-		test('returns error if it is a proper error', () => {
-			const err = new Error('test');
-			const unk = err as unknown;
-			expect(errorUtils.getErrorOrThrow(unk)).toEqual(err);
-		});
-
-		test('throws an error if it is not an error', () => {
-			expect(() => errorUtils.getErrorOrThrow('not an error!')).toThrow(Error);
-		});
-	});
-	test('without message', () => {
-		const testError = new errorUtils.SiError();
-		expect(testError.message).toEqual('');
-	});
-	test('NotImplementedError', () => {
-		const testError = new errorUtils.NotImplementedError('test');
-		expect(testError.message).toEqual('test');
-	});
-	test('notImplemented', () => {
-		expect(() => errorUtils.notImplemented()).toThrow(errorUtils.NotImplementedError);
-		expect(() => errorUtils.notImplemented('test')).toThrow(errorUtils.NotImplementedError);
-		expect(() => errorUtils.notImplemented('test')).toThrow('test');
-	});
-});

package/src/utils/errors.ts

@@ -1,20 +0,0 @@
-export const getErrorOrThrow = (err: unknown): Error | SiError => {
-	if (!(err instanceof Error) && !(err instanceof SiError)) {
-		throw new Error('Thrown thing is not an error');
-	}
-	return err;
-};
-
-export class SiError {
-	// eslint-disable-next-line no-useless-constructor
-	constructor(
-		public message: string = '',
-		public stack = [] // eslint-disable-next-line no-empty-function
-	) {}
-}
-
-export class NotImplementedError extends SiError {}
-
-export const notImplemented = (message?: string): never => {
-	throw new NotImplementedError(message || 'Not implemented');
-};

package/src/utils/events.test.ts

@@ -1,112 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import * as eventUtils from './events';
-import * as mixinUtils from './mixins';
-import * as testUtils from '../testUtils';
-
-testUtils.useFakeTimers();
-
-describe('event utils', () => {
-	class MyEvent extends eventUtils.Event<'myEvent'> {
-		constructor(public eventObject: Record<string, unknown>) {
-			super();
-		}
-	}
-
-	type MyEvents = { myEvent: MyEvent };
-
-	class MyEventTarget {}
-	// eslint-disable-next-line @typescript-eslint/no-empty-interface
-	interface MyEventTarget extends eventUtils.EventTarget<MyEvents> {}
-	mixinUtils.applyMixins(MyEventTarget, [eventUtils.EventTarget]);
-
-	test('works', () => {
-		const myEventTarget = new MyEventTarget();
-		const eventObject = {};
-
-		const callsToCallback: MyEvent[] = [];
-		const callback = (e: MyEvent) => {
-			callsToCallback.push(e);
-		};
-
-		myEventTarget.addEventListener('myEvent', callback);
-		expect(callsToCallback.length).toBe(0);
-
-		myEventTarget.dispatchEvent('myEvent', new MyEvent(eventObject));
-		expect(callsToCallback.length).toBe(1);
-		expect(callsToCallback[0].type).toBe('myEvent');
-		expect(callsToCallback[0].eventObject).toBe(eventObject);
-
-		myEventTarget.removeEventListener('myEvent', callback);
-		expect(callsToCallback.length).toBe(1);
-
-		myEventTarget.dispatchEvent('myEvent', new MyEvent(eventObject));
-		expect(callsToCallback.length).toBe(1);
-	});
-	test('works even if some listeners fail', () => {
-		const myEventTarget = new MyEventTarget();
-		const timeState = {
-			listener1Run: false,
-			listener2Run: false,
-			listener3Run: false
-		};
-		myEventTarget.addEventListener('myEvent', () => {
-			timeState.listener1Run = true;
-		});
-		myEventTarget.addEventListener('myEvent', () => {
-			timeState.listener2Run = true;
-			throw new Error('test');
-		});
-		myEventTarget.addEventListener('myEvent', () => {
-			timeState.listener3Run = true;
-		});
-
-		myEventTarget.dispatchEvent('myEvent', new MyEvent({}));
-		expect(timeState).toEqual({
-			listener1Run: true,
-			listener2Run: true,
-			listener3Run: true
-		});
-	});
-	test('can remove all listeners', () => {
-		const myEventTarget = new MyEventTarget();
-		const timeState = {
-			listener1Run: false,
-			listener2Run: false
-		};
-		myEventTarget.addEventListener('myEvent', () => {
-			timeState.listener1Run = true;
-		});
-		myEventTarget.addEventListener('myEvent', () => {
-			timeState.listener2Run = true;
-		});
-
-		myEventTarget.removeAllEventListeners();
-
-		myEventTarget.dispatchEvent('myEvent', new MyEvent({}));
-		expect(timeState).toEqual({
-			listener1Run: false,
-			listener2Run: false
-		});
-	});
-	test('remove inexistent event listener', () => {
-		const myEventTarget = new MyEventTarget();
-		const eventObject = {};
-
-		const callsToCallback: MyEvent[] = [];
-		const callback = (e: MyEvent) => {
-			callsToCallback.push(e);
-		};
-
-		myEventTarget.removeEventListener('myEvent', callback);
-		expect(callsToCallback.length).toBe(0);
-
-		myEventTarget.dispatchEvent('myEvent', new MyEvent(eventObject));
-		expect(callsToCallback.length).toBe(0);
-	});
-	test('dispatch inexistent event listener', () => {
-		const myEventTarget = new MyEventTarget();
-		const eventObject = {};
-
-		expect(() => myEventTarget.dispatchEvent('myEvent', new MyEvent(eventObject))).not.toThrow();
-	});
-});

package/src/utils/events.ts

@@ -1,68 +0,0 @@
-import * as errorUtils from './errors';
-
-export interface IEvent<T extends string> {
-	type?: T;
-	target: unknown;
-	defaultPrevented: boolean;
-}
-
-export class Event<T extends string> implements IEvent<T> {
-	target: unknown;
-	defaultPrevented = false;
-
-	// eslint-disable-next-line no-useless-constructor
-	constructor(
-		public type?: T // eslint-disable-next-line no-empty-function
-	) {}
-}
-
-export type EventCallback<T extends Event<string>> = (event: T) => void;
-
-interface EventTypeDict {
-	[type: string]: Event<string>;
-}
-
-export interface IEventTarget<T extends EventTypeDict> {
-	addEventListener: <K extends keyof T>(type: K, callback: EventCallback<T[K]>) => void;
-	removeEventListener: <K extends keyof T>(type: K, callback: EventCallback<T[K]>) => void;
-	removeAllEventListeners: () => void;
-	dispatchEvent: <K extends keyof T>(type: K, event: T[K]) => void;
-}
-
-export class EventTarget<T extends EventTypeDict> implements IEventTarget<T> {
-	private eventRegistry?: { [type: string]: EventCallback<Event<string>>[] };
-
-	addEventListener<K extends keyof T>(type: K, callback: EventCallback<T[K]>): void {
-		const eventRegistry = this.eventRegistry || {};
-		const listeners = eventRegistry[type as string] || [];
-		eventRegistry[type as string] = [...listeners, callback as EventCallback<Event<string>>];
-		this.eventRegistry = eventRegistry;
-	}
-
-	removeEventListener<K extends keyof T>(type: K, callback: EventCallback<T[K]>): void {
-		const eventRegistry = this.eventRegistry || {};
-		const listeners = eventRegistry[type as string] || [];
-		eventRegistry[type as string] = listeners.filter((listener: EventCallback<T[K]>) => listener !== callback);
-		this.eventRegistry = eventRegistry;
-	}
-
-	removeAllEventListeners(): void {
-		this.eventRegistry = {};
-	}
-
-	dispatchEvent<K extends keyof T>(type: K, event: T[K]): boolean {
-		event.type = type as string;
-		const eventRegistry = this.eventRegistry || {};
-		const listeners = eventRegistry[type as string] || [];
-		listeners.forEach((listener: EventCallback<T[K]>) => {
-			try {
-				listener(event);
-			} catch (exc) {
-				const err = errorUtils.getErrorOrThrow(exc);
-				console.error(`Event Listener failed (${String(type)}): ${err.message}`);
-				console.info(err.stack);
-			}
-		});
-		return !event.defaultPrevented;
-	}
-}

package/src/utils/general.test.ts

@@ -1,139 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import _ from 'lodash';
-import Immutable from 'immutable';
-import * as testUtils from '../testUtils';
-import * as generalUtils from './general';
-
-testUtils.useFakeTimers();
-
-describe('general utils', () => {
-	test('cached', () => {
-		const cache = {};
-		const numGettersCalled = { foo: 0, bar: 0 };
-		const getFoo = generalUtils.cached(cache, () => {
-			numGettersCalled.foo += 1;
-			return 'foo';
-		});
-		const getBar = generalUtils.cached(cache, () => {
-			numGettersCalled.bar += 1;
-			return 'bar';
-		});
-		expect(_.isFunction(getFoo)).toBe(true);
-		expect(_.isFunction(getBar)).toBe(true);
-		expect(numGettersCalled).toEqual({ foo: 0, bar: 0 });
-		expect(getFoo()).toBe('foo');
-		expect(numGettersCalled).toEqual({ foo: 1, bar: 0 });
-		expect(getFoo()).toBe('foo');
-		expect(numGettersCalled).toEqual({ foo: 1, bar: 0 });
-		expect(getBar()).toBe('bar');
-		expect(numGettersCalled).toEqual({ foo: 1, bar: 1 });
-		expect(getFoo()).toBe('foo');
-		expect(numGettersCalled).toEqual({ foo: 1, bar: 1 });
-	});
-	test('getLookup', () => {
-		expect(generalUtils.getLookup({})).toEqual({});
-		expect(generalUtils.getLookup({ a: '0' })).toEqual({ '0': 'a' });
-		expect(generalUtils.getLookup({ a: '0', b: '1' })).toEqual({ '0': 'a', '1': 'b' });
-		expect(generalUtils.getLookup({ a: '0', b: '1', c: '2' })).toEqual({
-			'0': 'a',
-			'1': 'b',
-			'2': 'c'
-		});
-	});
-	test('getLookup with function', () => {
-		interface ComplexValue {
-			val: string;
-		}
-		const getLookupKey = (value: ComplexValue) => value.val;
-		expect(generalUtils.getLookup({}, getLookupKey)).toEqual({});
-		expect(generalUtils.getLookup({ a: { val: '0' } }, getLookupKey)).toEqual({ '0': 'a' });
-		expect(generalUtils.getLookup({ a: { val: '0' }, b: { val: '1' } }, getLookupKey)).toEqual({
-			'0': 'a',
-			'1': 'b'
-		});
-		expect(generalUtils.getLookup({ a: { val: '0' }, b: { val: '1' }, c: { val: '2' } }, getLookupKey)).toEqual({ '0': 'a', '1': 'b', '2': 'c' });
-	});
-	test('getLookup sanitizes', () => {
-		expect(() => generalUtils.getLookup({ a: '0', b: '1', c: '1' })).toThrow();
-	});
-	test('getLookup is cached', () => {
-		const mapping: generalUtils.MappingWithLookup<string[]> = { a: ['0'], b: ['1', '2'] };
-		const lookup1 = generalUtils.getLookup(mapping, (value) => value[0]);
-		expect(mapping._lookup).not.toBe(undefined);
-		expect(mapping._lookup).toEqual(lookup1);
-		let numCallsToLookupKeyGetter = 0;
-		const lookup2 = generalUtils.getLookup(mapping, () => `${numCallsToLookupKeyGetter++}`);
-		expect(numCallsToLookupKeyGetter).toBe(0);
-		expect(lookup2).toEqual(lookup1);
-	});
-	test('waitFor 0', async () => {
-		let doneWaiting = false;
-		generalUtils.waitFor(0, 'now').then((result) => {
-			expect(result).toBe('now');
-			doneWaiting = true;
-		});
-		expect(doneWaiting).toBe(false);
-		await testUtils.advanceTimersByTime(0);
-		expect(doneWaiting).toBe(true);
-	});
-	test('waitFor 1', async () => {
-		let doneWaiting = false;
-		generalUtils.waitFor(1, 'later').then((result) => {
-			expect(result).toBe('later');
-			doneWaiting = true;
-		});
-		expect(doneWaiting).toBe(false);
-		await testUtils.advanceTimersByTime(0);
-		expect(doneWaiting).toBe(false);
-		await testUtils.advanceTimersByTime(1);
-		expect(doneWaiting).toBe(true);
-	});
-	test('binarySearch length 0', () => {
-		const list: number[] = [];
-		expect(generalUtils.binarySearch(list, -1)).toBe(0);
-		expect(generalUtils.binarySearch(list, 0)).toBe(0);
-		expect(generalUtils.binarySearch(list, 1)).toBe(0);
-	});
-	test('binarySearch length 1', () => {
-		const list = [3];
-		expect(generalUtils.binarySearch(list, -1)).toBe(0);
-		expect(generalUtils.binarySearch(list, 0)).toBe(0);
-		expect(generalUtils.binarySearch(list, 1)).toBe(0);
-		expect(generalUtils.binarySearch(list, 3)).toBe(0);
-		expect(generalUtils.binarySearch(list, 4)).toBe(1);
-	});
-	test('binarySearch length 3', () => {
-		const list = [1, 2, 4];
-		expect(generalUtils.binarySearch(list, -1)).toBe(0);
-		expect(generalUtils.binarySearch(list, 0)).toBe(0);
-		expect(generalUtils.binarySearch(list, 1)).toBe(0);
-		expect(generalUtils.binarySearch(list, 2)).toBe(1);
-		expect(generalUtils.binarySearch(list, 3)).toBe(2);
-		expect(generalUtils.binarySearch(list, 4)).toBe(2);
-		expect(generalUtils.binarySearch(list, 5)).toBe(3);
-	});
-	test('binarySearch duplicates', () => {
-		const listOdd = [1, 2, 2];
-		expect(generalUtils.binarySearch(listOdd, 1)).toBe(0);
-		expect(generalUtils.binarySearch(listOdd, 2)).toBe(1);
-		expect(generalUtils.binarySearch(listOdd, 3)).toBe(3);
-		const listEven = [1, 1, 2];
-		expect(generalUtils.binarySearch(listEven, 1)).toBe(0);
-		expect(generalUtils.binarySearch(listEven, 2)).toBe(2);
-		expect(generalUtils.binarySearch(listEven, 3)).toBe(3);
-	});
-	test('binarySearch immutable', () => {
-		const options: generalUtils.BinarySearchOptions<Immutable.List<number>, number> = {
-			getLength: (list) => list.size,
-			getItemAtIndex: (list, index) => list.get(index)
-		};
-		const list = Immutable.List([1, 2, 4]);
-		expect(generalUtils.binarySearch(list, -1, options)).toBe(0);
-		expect(generalUtils.binarySearch(list, 0, options)).toBe(0);
-		expect(generalUtils.binarySearch(list, 1, options)).toBe(0);
-		expect(generalUtils.binarySearch(list, 2, options)).toBe(1);
-		expect(generalUtils.binarySearch(list, 3, options)).toBe(2);
-		expect(generalUtils.binarySearch(list, 4, options)).toBe(2);
-		expect(generalUtils.binarySearch(list, 5, options)).toBe(3);
-	});
-});

package/src/utils/general.ts

@@ -1,69 +0,0 @@
-export type Cache<T> = { [id: string]: T };
-
-export const cached = <T>(cache: Cache<T>, getThing: () => T): (() => T) => {
-	const getter = (): T => {
-		const getThingIdent = `${getThing.name}-${getThing.toString()}`;
-		const cachedThing = cache[getThingIdent];
-		if (cachedThing === undefined) {
-			const newThing = getThing();
-			cache[getThingIdent] = newThing;
-			return newThing;
-		}
-		return cachedThing;
-	};
-	return getter;
-};
-
-export type Lookup = { [id: string]: string };
-export type MappingWithLookup<T> = { [id: string]: T | string | Lookup };
-
-export const getLookup = <T>(mapping: MappingWithLookup<T>, getLookupKey?: (value: T) => string): Lookup => {
-	if (mapping._lookup) {
-		return mapping._lookup as Lookup;
-	}
-	const lookup: Lookup = {};
-	Object.keys(mapping)
-		.filter((mappingKey) => mappingKey.substr(0, 1) !== '_')
-		.forEach((mappingKey) => {
-			const mappingValue = mapping[mappingKey];
-			const lookupKey = getLookupKey ? getLookupKey(mappingValue as T) : (mappingValue as string);
-			if (lookupKey in lookup) {
-				throw new Error(`Duplicate lookup key: ${lookupKey}`);
-			}
-			lookup[lookupKey] = mappingKey;
-		});
-	mapping._lookup = lookup;
-	return lookup;
-};
-
-export const waitFor = <T>(milliseconds: number, value?: T): Promise<T | undefined> => {
-	const promise: Promise<T | undefined> = new Promise((resolve) => {
-		setTimeout(() => resolve(value), milliseconds);
-	});
-	return promise;
-};
-
-export interface BinarySearchOptions<L, T> {
-	getLength?: (list: L) => number;
-	getItemAtIndex?: (list: L, index: number) => T | undefined;
-	getNewRange?: (list: L, item: T, start: number, end: number) => [number, number];
-}
-
-export const binarySearch = <L, T>(list: L, item: T, options: BinarySearchOptions<L, T> = {}): number => {
-	const defaultGetLength = (list_: L): number => (list_ as unknown as T[]).length;
-	const getLength = options.getLength || defaultGetLength;
-	const defaultGetItemAtIndex = (list_: L, index: number): T => (list_ as unknown as T[])[index];
-	const getItemAtIndex = options.getItemAtIndex || defaultGetItemAtIndex;
-	const defaultGetNewRange = (list_: L, item_: T, start: number, end: number): [number, number] => {
-		const mid = Math.floor((start + end) / 2);
-		const midItem = getItemAtIndex(list_, mid)!;
-		return item_ <= midItem ? [start, mid] : [mid + 1, end];
-	};
-	const getNewRange = options.getNewRange || defaultGetNewRange;
-	let start = 0;
-	let end = getLength(list);
-	while (start < end) {
-		[start, end] = getNewRange(list, item, start, end);
-	}
-	return start;
-};

package/src/utils/mixins.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import * as mixinUtils from './mixins';
-
-describe('mixin utils', () => {
-	test('mixes in', () => {
-		class Disposable {
-			public isDisposed = false;
-
-			dispose() {
-				this.isDisposed = true;
-			}
-		}
-
-		class Activatable {
-			public isActive = false;
-
-			activate() {
-				this.isActive = true;
-			}
-		}
-
-		class MyObject {
-			isMine = true;
-		}
-
-		interface MyObject extends Disposable, Activatable {}
-		mixinUtils.applyMixins(MyObject, [Disposable, Activatable]);
-
-		const myObject = new MyObject();
-		expect(myObject.isMine).toBe(true);
-		expect(myObject.isDisposed).toBe(undefined);
-		expect(myObject.isActive).toBe(undefined);
-		expect(() => myObject.activate()).not.toThrow();
-		expect(myObject.isDisposed).toBe(undefined);
-		expect(myObject.isActive).toBe(true);
-		expect(() => myObject.dispose()).not.toThrow();
-		expect(myObject.isDisposed).toBe(true);
-		expect(myObject.isActive).toBe(true);
-	});
-});

package/src/utils/mixins.ts

@@ -1,13 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export const applyMixins = (derivedCtor: any, baseCtors: any[]): void => {
-	baseCtors.forEach((baseCtor) => {
-		Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
-			Object.defineProperty(
-				derivedCtor.prototype,
-				name,
-				// @ts-ignore
-				Object.getOwnPropertyDescriptor(baseCtor.prototype, name)
-			);
-		});
-	});
-};

package/src/utils/typed.ts

@@ -1,3 +0,0 @@
-export function typedKeys<T extends Record<string | number | symbol, unknown>>(dict: T): (keyof T)[] {
-	return Object.keys(dict) as (keyof T)[];
-}

package/tsconfig.base.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["dom"],
-    "composite": true,
-    "sourceMap": true,
-    "declaration": true,
-    "declarationMap": true,
-    "noImplicitAny": true,
-    "module": "commonjs",
-    "target": "es6",
-    "esModuleInterop": true,
-    "jsx": "react",
-    "allowJs": true,
-    "experimentalDecorators": true,
-    "forceConsistentCasingInFileNames": true,
-    "noImplicitReturns": true,
-    "noUnusedLocals": true,
-    "strict": true,
-    "strictNullChecks": true,
-    "strictPropertyInitialization": true
-  }
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "extends": "./tsconfig.base.json",
-  "files": [],
-  "references": [
-    {"path": "packages/sportident"},
-    {"path": "packages/sportident-example-app"},
-    {"path": "packages/sportident-node-usb"},
-    {"path": "packages/sportident-react"},
-    {"path": "packages/sportident-testbench-client"},
-    {"path": "packages/sportident-testbench-node"},
-    {"path": "packages/sportident-testbench-server"},
-    {"path": "packages/sportident-testbench-shell"},
-    {"path": "packages/sportident-webusb"}
-  ]
-}