sportident.js 1.0.0

package/src/utils/bytes.ts

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,112 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,139 @@
+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

@@ -0,0 +1,69 @@
+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/index.ts

@@ -0,0 +1,8 @@
+export * from './bytes';
+export * from './errors';
+export * from './events';
+export * from './general';
+export * from './mixins';
+export * from './NumberRange';
+export * from './NumberRangeRegistry';
+export * from './typed';

package/src/utils/mixins.test.ts

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,13 @@
+// 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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,22 @@
+{
+  "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

@@ -0,0 +1,15 @@
+{
+  "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"}
+  ]
+}