sportident.js 1.0.0 → 1.0.1

package/src/fakes/FakeSiCard/types/FakeSiCard5.ts

@@ -1,40 +0,0 @@
-import _ from 'lodash';
-import { proto } from '../../../constants';
-import * as siProtocol from '../../../siProtocol';
-import type * as storage from '../../../storage';
-import { BaseFakeSiCard } from '../BaseFakeSiCard';
-import { type ISiCard5StorageFields, SiCard5, siCard5StorageDefinition } from '../../../SiCard/types/SiCard5';
-import { getSiCard5Examples } from '../../../SiCard/types/siCard5Examples';
-
-export class FakeSiCard5 extends BaseFakeSiCard {
-	static siCardClass = SiCard5;
-	static getAllExamples = getSiCard5Examples;
-
-	public storage: storage.ISiStorage<ISiCard5StorageFields>;
-
-	constructor(storageData: (number | undefined)[] | undefined) {
-		super();
-		this.storage = siCard5StorageDefinition(storageData);
-	}
-
-	handleDetect(): siProtocol.SiMessage {
-		const cardNumberArr = siProtocol.cardNumber2arr(this.storage.get('cardNumber')!.value);
-		cardNumberArr.reverse();
-		return {
-			command: proto.cmd.SI5_DET,
-			parameters: [...cardNumberArr] as number[]
-		};
-	}
-
-	handleRequest(message: siProtocol.SiMessage): siProtocol.SiMessage[] {
-		if (message.mode !== undefined || message.command !== proto.cmd.GET_SI5 || message.parameters.length !== 0) {
-			throw new Error(`SiCard5 can not handle ${siProtocol.prettyMessage(message)}`);
-		}
-		return [
-			{
-				command: proto.cmd.GET_SI5,
-				parameters: this.storage.data.toJS()
-			}
-		] as siProtocol.SiMessage[];
-	}
-}

package/src/fakes/FakeSiCard/types/FakeSiCard6.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { proto } from '../../../constants';
-import * as utils from '../../../utils';
-import * as testUtils from '../../../testUtils';
-import { FakeSiCard6 } from './FakeSiCard6';
-import { getCardWith16Punches } from '../../../SiCard/types/siCard6Examples';
-
-testUtils.useFakeTimers();
-
-describe('FakeSiCard6', () => {
-	test('exists', () => {
-		expect(FakeSiCard6).not.toBe(undefined);
-	});
-	const testData = getCardWith16Punches();
-	const myFakeSiCard6 = new FakeSiCard6(testData.storageData);
-	test('handleDetect works', () => {
-		expect(myFakeSiCard6.handleDetect()).toEqual({
-			command: proto.cmd.SI6_DET,
-			parameters: utils.unPrettyHex('00 07 A1 3D')
-		});
-	});
-	test('handleRequest works', () => {
-		expect(() =>
-			myFakeSiCard6.handleRequest({
-				command: proto.cmd.GET_SI5,
-				parameters: [0x06]
-			})
-		).toThrow();
-
-		expect(
-			myFakeSiCard6.handleRequest({
-				command: proto.cmd.GET_SI6,
-				parameters: [0x06]
-			})
-		).toEqual([
-			{
-				command: proto.cmd.GET_SI6,
-				parameters: [6, ...testData.storageData.slice(6 * 128, 7 * 128)]
-			}
-		]);
-
-		expect(
-			myFakeSiCard6.handleRequest({
-				command: proto.cmd.GET_SI6,
-				parameters: [0x08]
-			})
-		).toEqual([
-			{
-				command: proto.cmd.GET_SI6,
-				parameters: [0, ...testData.storageData.slice(0, 128)]
-			},
-			{
-				command: proto.cmd.GET_SI6,
-				parameters: [6, ...testData.storageData.slice(6 * 128, 7 * 128)]
-			},
-			{
-				command: proto.cmd.GET_SI6,
-				parameters: [7, ...testData.storageData.slice(7 * 128, 8 * 128)]
-			}
-		]);
-	});
-});

package/src/fakes/FakeSiCard/types/FakeSiCard6.ts

@@ -1,44 +0,0 @@
-import _ from 'lodash';
-import { proto } from '../../../constants';
-import * as siProtocol from '../../../siProtocol';
-import type * as storage from '../../../storage';
-import { BaseFakeSiCard } from '../BaseFakeSiCard';
-import { type ISiCard6StorageFields, SiCard6, siCard6StorageDefinition } from '../../../SiCard/types/SiCard6';
-import { getSiCard6Examples } from '../../../SiCard/types/siCard6Examples';
-
-export class FakeSiCard6 extends BaseFakeSiCard {
-	static siCardClass = SiCard6;
-	static getAllExamples = getSiCard6Examples;
-
-	public storage: storage.ISiStorage<ISiCard6StorageFields>;
-
-	constructor(storageData: (number | undefined)[] | undefined) {
-		super();
-		this.storage = siCard6StorageDefinition(storageData);
-	}
-
-	handleDetect(): siProtocol.SiMessage {
-		const cardNumberArr = siProtocol.cardNumber2arr(this.storage.get('cardNumber')!.value);
-		cardNumberArr.reverse();
-		return {
-			command: proto.cmd.SI6_DET,
-			parameters: [...cardNumberArr] as number[]
-		};
-	}
-
-	handleRequest(message: siProtocol.SiMessage): siProtocol.SiMessage[] {
-		if (message.mode !== undefined || message.command !== proto.cmd.GET_SI6 || message.parameters.length !== 1) {
-			throw new Error(`SiCard6 can not handle ${siProtocol.prettyMessage(message)}`);
-		}
-		const pageIndex = message.parameters[0];
-		const getPageAtIndex = (index: number): siProtocol.SiMessage =>
-			({
-				command: proto.cmd.GET_SI6,
-				parameters: [index, ...this.storage.data.slice(index * 128, (index + 1) * 128).toJS()]
-			} as siProtocol.SiMessage);
-		if (pageIndex === 0x08) {
-			return [0, 6, 7].map(getPageAtIndex);
-		}
-		return [getPageAtIndex(pageIndex)];
-	}
-}

package/src/fakes/FakeSiCard/types/FakeSiCard8.ts

@@ -1,16 +0,0 @@
-import type * as storage from '../../../storage';
-import { FakeModernSiCard } from './FakeModernSiCard';
-import { type ISiCard8StorageFields, SiCard8, siCard8StorageDefinition } from '../../../SiCard/types/SiCard8';
-import { getSiCard8Examples } from '../../../SiCard/types/siCard8Examples';
-
-export class FakeSiCard8 extends FakeModernSiCard {
-	static siCardClass = SiCard8;
-	static getAllExamples = getSiCard8Examples;
-
-	public storage: storage.ISiStorage<ISiCard8StorageFields>;
-
-	constructor(storageData: (number | undefined)[] | undefined) {
-		super();
-		this.storage = siCard8StorageDefinition(storageData);
-	}
-}

package/src/fakes/FakeSiCard/types/FakeSiCard9.ts

@@ -1,16 +0,0 @@
-import type * as storage from '../../../storage';
-import { FakeModernSiCard } from './FakeModernSiCard';
-import { type ISiCard9StorageFields, SiCard9, siCard9StorageDefinition } from '../../../SiCard/types/SiCard9';
-import { getSiCard9Examples } from '../../../SiCard/types/siCard9Examples';
-
-export class FakeSiCard9 extends FakeModernSiCard {
-	static siCardClass = SiCard9;
-	static getAllExamples = getSiCard9Examples;
-
-	public storage: storage.ISiStorage<ISiCard9StorageFields>;
-
-	constructor(storageData: (number | undefined)[] | undefined) {
-		super();
-		this.storage = siCard9StorageDefinition(storageData);
-	}
-}

package/src/fakes/FakeSiDeviceDriver.ts

@@ -1,148 +0,0 @@
-import * as utils from '../utils';
-import { DeviceClosedError, SiDeviceState } from '../SiDevice/ISiDevice';
-import type { ISiDevice, ISiDeviceDriverData } from '../SiDevice/ISiDevice';
-
-import { SiDeviceAddEvent, SiDeviceRemoveEvent } from '../SiDevice/ISiDeviceDriver';
-import type { ISiDeviceDriver, ISiDeviceDriverWithAutodetection, ISiDeviceDriverWithDetection, SiDeviceDriverWithAutodetectionEvents } from '../SiDevice/ISiDeviceDriver';
-import { SiDevice } from '../SiDevice/SiDevice';
-
-interface FakeDevice {
-	ident: string;
-	isOpened: boolean;
-}
-
-const getIdent = (fakeDevice: FakeDevice): string => fakeDevice.ident;
-
-export interface FakeSiDeviceDriverData extends ISiDeviceDriverData<FakeSiDeviceDriver> {
-	driver: FakeSiDeviceDriver;
-	device: FakeDevice;
-}
-
-export type IFakeSiDevice = ISiDevice<FakeSiDeviceDriverData>;
-export type FakeSiDevice = SiDevice<FakeSiDeviceDriverData>;
-
-class FakeSiDeviceDriver implements ISiDeviceDriver<FakeSiDeviceDriverData>, ISiDeviceDriverWithDetection<FakeSiDeviceDriverData, []>, ISiDeviceDriverWithAutodetection<FakeSiDeviceDriverData> {
-	public name = 'Fake';
-
-	private siDeviceByIdent: { [ident: string]: FakeSiDevice } = {};
-
-	private autodetectedSiDevices: { [ident: string]: FakeSiDevice } = {};
-
-	private autoDetectionRunning = false;
-
-	public identToBeDetected: string | null = null;
-	public identsToBeAutodetected: string[] = [];
-
-	detect(): Promise<FakeSiDevice> {
-		if (!this.identToBeDetected) {
-			return Promise.reject(new Error('No fake device ident to be detected'));
-		}
-		return this.autodetectSiDevice({
-			ident: this.identToBeDetected,
-			isOpened: false
-		});
-	}
-
-	getSiDevice(fakeDevice: FakeDevice): FakeSiDevice {
-		const ident = getIdent(fakeDevice);
-		if (this.siDeviceByIdent[ident] !== undefined) {
-			return this.siDeviceByIdent[ident];
-		}
-		const newSiDeviceData: FakeSiDeviceDriverData = {
-			driver: this,
-			device: fakeDevice
-		};
-		const newSiDevice = new SiDevice(ident, newSiDeviceData);
-		this.siDeviceByIdent[ident] = newSiDevice;
-		return newSiDevice;
-	}
-
-	async forgetSiDevice(siDevice: FakeSiDevice): Promise<void> {
-		const fakeDevice = siDevice.data.device;
-		const ident = getIdent(fakeDevice);
-		delete this.siDeviceByIdent[ident];
-		if (this.autodetectedSiDevices[ident] !== undefined) {
-			await this.dispatchEvent('remove', new SiDeviceRemoveEvent(siDevice));
-		}
-		delete this.autodetectedSiDevices[ident];
-	}
-
-	public isAutoDetectionRunning(): boolean {
-		return this.autoDetectionRunning;
-	}
-
-	startAutoDetection(): Promise<IFakeSiDevice[]> {
-		this.autoDetectionRunning = true;
-		return this.getAutodetectedDevices();
-	}
-
-	getAutodetectedDevices(): Promise<FakeSiDevice[]> {
-		return this.autodetectSiDevices(this.identsToBeAutodetected);
-	}
-
-	autodetectSiDevices(idents: string[]): Promise<FakeSiDevice[]> {
-		return Promise.all(idents.map((ident) => this.autodetectSiDevice({ ident, isOpened: false })));
-	}
-
-	autodetectSiDevice(fakeDevice: FakeDevice): Promise<FakeSiDevice> {
-		const ident = getIdent(fakeDevice);
-		if (this.autodetectedSiDevices[ident] !== undefined) {
-			return Promise.reject(new Error('Duplicate SI device'));
-		}
-		const siDevice = this.getSiDevice(fakeDevice);
-		this.autodetectedSiDevices[ident] = siDevice;
-		return Promise.resolve(siDevice);
-	}
-
-	public async handleDeviceConnected(ident: string): Promise<void> {
-		if (!this.autoDetectionRunning) {
-			throw new Error('autodetection not running');
-		}
-		const openedDevice = await this.autodetectSiDevice({ ident, isOpened: false });
-		await this.dispatchEvent('add', new SiDeviceAddEvent(openedDevice));
-	}
-
-	public async handleDeviceDisconnected(ident: string): Promise<void> {
-		if (!this.autoDetectionRunning) {
-			throw new Error('autodetection not running');
-		}
-		const siDevice = this.siDeviceByIdent[ident];
-		if (siDevice === undefined) {
-			throw new Error('No such device');
-		}
-		await this.forgetSiDevice(siDevice);
-	}
-
-	stopAutoDetection(): Promise<unknown> {
-		this.autoDetectionRunning = false;
-		return Promise.resolve();
-	}
-
-	open(device: IFakeSiDevice): Promise<void> {
-		device.data.device.isOpened = true;
-		return Promise.resolve();
-	}
-
-	close(device: IFakeSiDevice): Promise<unknown> {
-		device.data.device.isOpened = false;
-		return Promise.resolve();
-	}
-
-	receive(device: IFakeSiDevice): Promise<number[]> {
-		const fakeDevice = device.data.device;
-		if (fakeDevice.isOpened !== true) {
-			device.setState(SiDeviceState.Closed);
-			throw new DeviceClosedError();
-		}
-		return Promise.resolve([]);
-	}
-
-	send(_device: IFakeSiDevice, _uint8Data: number[]): Promise<unknown> {
-		return Promise.resolve(true);
-	}
-}
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-interface FakeSiDeviceDriver extends utils.EventTarget<SiDeviceDriverWithAutodetectionEvents<FakeSiDeviceDriverData>> {}
-utils.applyMixins(FakeSiDeviceDriver, [utils.EventTarget]);
-
-export const getFakeSiDeviceDriver = (): FakeSiDeviceDriver => new FakeSiDeviceDriver();

package/src/fakes/FakeSiMainStation.test.ts

@@ -1,141 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { proto } from '../constants';
-import type * as siProtocol from '../siProtocol';
-import * as testUtils from '../testUtils';
-import { getBSM8Station } from '../SiStation/siStationExamples';
-import type { IFakeSiCard } from './FakeSiCard/IFakeSiCard';
-import type { FakeSiMainStationMessageEvent } from './IFakeSiMainStation';
-import { FakeSiMainStation } from './FakeSiMainStation';
-
-testUtils.useFakeTimers();
-
-describe('FakeSiMainStation', () => {
-	test('exists', () => {
-		expect(FakeSiMainStation).not.toBe(undefined);
-	});
-	const myFakeSiMainStation = new FakeSiMainStation(getBSM8Station().storageData);
-	test('getCode', () => {
-		expect(myFakeSiMainStation.getCode()).toEqual([0, 31]);
-	});
-	test('getDateTime', () => {
-		const dateTime1 = myFakeSiMainStation.getDateTime();
-		expect(dateTime1 instanceof Date).toBe(true);
-		myFakeSiMainStation.dateOffset = 3600;
-		const dateTime2 = myFakeSiMainStation.getDateTime();
-		expect(dateTime1 instanceof Date).toBe(true);
-		const timeDiff = dateTime2.getTime() - dateTime1.getTime();
-		expect(timeDiff).toBeLessThan(3600 + 10);
-		expect(timeDiff).toBeGreaterThan(3600 - 10);
-	});
-	test('dispatching messages', () => {
-		const dispatchedMessages: siProtocol.SiMessage[] = [];
-		const handleMessage = (e: FakeSiMainStationMessageEvent) => {
-			dispatchedMessages.push(e.message);
-		};
-		myFakeSiMainStation.addEventListener('message', handleMessage);
-
-		const randomMessage1 = testUtils.getRandomMessage({ numParameters: 1 });
-		myFakeSiMainStation.dispatchMessage(randomMessage1);
-		expect(dispatchedMessages).toEqual([randomMessage1]);
-
-		const randomMessage2 = testUtils.getRandomMessage({ numParameters: 1 });
-		myFakeSiMainStation.dispatchCardMessage(randomMessage2);
-		expect(dispatchedMessages.length).toBe(2);
-		if (dispatchedMessages[1].mode !== undefined) {
-			throw new Error('message mode must be undefined');
-		}
-		expect(dispatchedMessages[1].command).toBe(randomMessage2.command);
-		expect(dispatchedMessages[1].parameters).toEqual([...myFakeSiMainStation.getCode(), ...randomMessage2.parameters]);
-
-		myFakeSiMainStation.removeEventListener('message', handleMessage);
-	});
-	test('insertCard', () => {
-		let dispatchedMessage: siProtocol.SiMessage | undefined;
-		const handleMessage = (e: FakeSiMainStationMessageEvent) => {
-			dispatchedMessage = e.message;
-		};
-		myFakeSiMainStation.addEventListener('message', handleMessage);
-
-		const cardInsertionMessage = testUtils.getRandomMessage({ numParameters: 1 });
-		const fakeSiCard = {
-			handleDetect: () => cardInsertionMessage
-		} as IFakeSiCard;
-		myFakeSiMainStation.insertCard(fakeSiCard);
-		if (dispatchedMessage === undefined || dispatchedMessage.mode !== undefined) {
-			throw new Error('message mode must be undefined');
-		}
-		expect(dispatchedMessage.command).toBe(cardInsertionMessage.command);
-		expect(dispatchedMessage.parameters).toEqual([...myFakeSiMainStation.getCode(), ...cardInsertionMessage.parameters]);
-
-		myFakeSiMainStation.removeEventListener('message', handleMessage);
-	});
-	test('sendMessage', () => {
-		const code = myFakeSiMainStation.getCode();
-
-		const getResponsesFor = (message: siProtocol.SiMessage) => {
-			const dispatchedMessages: siProtocol.SiMessage[] = [];
-			const handleMessage = (e: FakeSiMainStationMessageEvent) => {
-				dispatchedMessages.push(e.message);
-			};
-			myFakeSiMainStation.addEventListener('message', handleMessage);
-
-			myFakeSiMainStation.sendMessage(message);
-
-			myFakeSiMainStation.removeEventListener('message', handleMessage);
-			return dispatchedMessages;
-		};
-
-		expect(getResponsesFor({ command: proto.cmd.SIGNAL, parameters: [0x01] })).toEqual([{ command: proto.cmd.SIGNAL, parameters: [...code, 0x01] }]);
-
-		expect(getResponsesFor({ command: proto.cmd.GET_MS, parameters: [] })).toEqual([{ command: proto.cmd.GET_MS, parameters: [...code, proto.P_MS_DIRECT] }]);
-
-		expect(getResponsesFor({ command: proto.cmd.SET_MS, parameters: [proto.P_MS_REMOTE] })).toEqual([{ command: proto.cmd.SET_MS, parameters: [...code, proto.P_MS_REMOTE] }]);
-
-		expect(getResponsesFor({ command: proto.cmd.GET_MS, parameters: [] })).toEqual([{ command: proto.cmd.GET_MS, parameters: [...code, proto.P_MS_REMOTE] }]);
-
-		expect(getResponsesFor({ command: proto.cmd.SET_MS, parameters: [proto.P_MS_DIRECT] })).toEqual([{ command: proto.cmd.SET_MS, parameters: [...code, proto.P_MS_DIRECT] }]);
-
-		const getTimeResponses = getResponsesFor({ command: proto.cmd.GET_TIME, parameters: [] });
-		expect(getTimeResponses.length).toBe(1);
-		if (getTimeResponses[0].mode !== undefined) {
-			throw new Error('message mode must be undefined');
-		}
-		expect(getTimeResponses[0].command).toBe(proto.cmd.GET_TIME);
-		expect(getTimeResponses[0].parameters.length).toBe(2 + 7);
-
-		const setTimeResponses = getResponsesFor({
-			command: proto.cmd.SET_TIME,
-			parameters: [0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]
-		});
-		expect(setTimeResponses.length).toBe(1);
-		if (setTimeResponses[0].mode !== undefined) {
-			throw new Error('message mode must be undefined');
-		}
-		expect(setTimeResponses[0].command).toBe(proto.cmd.SET_TIME);
-		expect(setTimeResponses[0].parameters.length).toBe(2 + 7);
-
-		expect(getResponsesFor({ command: proto.cmd.GET_SYS_VAL, parameters: [0, 4] })).toEqual([{ command: proto.cmd.GET_SYS_VAL, parameters: [...code, 0, 0x00, 0x02, 0xc1, 0xa1] }]);
-
-		expect(getResponsesFor({ command: proto.cmd.SET_SYS_VAL, parameters: [0, 0x01, 0x23, 0x45, 0x67] })).toEqual([{ command: proto.cmd.SET_SYS_VAL, parameters: [...code, 0] }]);
-
-		// expect(getResponsesFor(
-		//     {command: proto.cmd.GET_SYS_VAL, parameters: [0, 4]},
-		// )).toEqual([
-		//     {command: proto.cmd.GET_SYS_VAL, parameters: [...code, 0, 0x01, 0x23, 0x45, 0x67]},
-		// ]);
-
-		const cardInsertionMessage = testUtils.getRandomMessage({ numParameters: 1 });
-		const cardRetrievalParameters = [testUtils.getRandomByte()];
-		const fakeSiCard: IFakeSiCard = {
-			handleDetect: () => cardInsertionMessage,
-			handleRequest: (message: siProtocol.SiMessage) => (message.mode === undefined ? [{ command: message.command, parameters: cardRetrievalParameters }] : [])
-		};
-		myFakeSiMainStation.insertCard(fakeSiCard);
-
-		expect(getResponsesFor({ command: proto.cmd.GET_SI5, parameters: [] })).toEqual([{ command: proto.cmd.GET_SI5, parameters: [...code, ...cardRetrievalParameters] }]);
-
-		expect(getResponsesFor({ command: proto.cmd.ERASE_BDATA, parameters: [] })).toEqual([{ command: proto.cmd.ERASE_BDATA, parameters: [...code] }]);
-
-		expect(getResponsesFor({ command: proto.cmd.OFF, parameters: [] })).toEqual([]);
-	});
-});

package/src/fakes/FakeSiMainStation.ts

@@ -1,118 +0,0 @@
-import { proto } from '../constants';
-import * as utils from '../utils';
-import type * as storage from '../storage';
-import * as siProtocol from '../siProtocol';
-import { type ISiStationStorageFields, siStationStorageDefinition } from '../SiStation/BaseSiStation';
-import { type FakeSiMainStationEvents, FakeSiMainStationMessageEvent } from './IFakeSiMainStation';
-import type { IFakeSiCard } from './FakeSiCard/IFakeSiCard';
-
-export class FakeSiMainStation {
-	public storage: storage.ISiStorage<ISiStationStorageFields>;
-	public isMaster = true;
-	public dateOffset = 0;
-	public fakeSiCard?: IFakeSiCard;
-
-	constructor(storageArg: (number | undefined)[] | undefined) {
-		this.storage = siStationStorageDefinition(storageArg);
-	}
-
-	dispatchCardMessage(cardMessage: siProtocol.SiMessage): void {
-		if (cardMessage.mode !== undefined) {
-			return;
-		}
-		const message = {
-			command: cardMessage.command,
-			parameters: [...this.getCode(), ...cardMessage.parameters]
-		};
-		this.dispatchMessage(message);
-	}
-
-	dispatchMessage(message: siProtocol.SiMessage): void {
-		this.dispatchEvent('message', new FakeSiMainStationMessageEvent(this, message));
-	}
-
-	getCode(): number[] {
-		return [(this.storage.data.get(0x73)! & 0xc0) << 2, this.storage.data.get(0x72)!];
-	}
-
-	getDateTime(): Date {
-		return new Date(Date.now() + this.dateOffset);
-	}
-
-	insertCard(fakeSiCard: IFakeSiCard): void {
-		this.fakeSiCard = fakeSiCard;
-		const cardMessage = this.fakeSiCard.handleDetect();
-		this.dispatchCardMessage(cardMessage);
-	}
-
-	sendMessage(message: siProtocol.SiMessage): void {
-		if (message.mode !== undefined) {
-			return;
-		}
-		if (message.command === proto.cmd.SIGNAL) {
-			const numSignal = message.parameters[0];
-			this.dispatchMessage({
-				command: proto.cmd.SIGNAL,
-				parameters: [...this.getCode(), numSignal]
-			});
-		} else if (message.command === proto.cmd.GET_MS) {
-			this.dispatchMessage({
-				command: proto.cmd.GET_MS,
-				parameters: [...this.getCode(), this.isMaster ? proto.P_MS_DIRECT : proto.P_MS_REMOTE]
-			});
-		} else if (message.command === proto.cmd.SET_MS) {
-			this.isMaster = message.parameters[0] === proto.P_MS_DIRECT;
-			this.dispatchMessage({
-				command: proto.cmd.SET_MS,
-				parameters: [...this.getCode(), this.isMaster ? proto.P_MS_DIRECT : proto.P_MS_REMOTE]
-			});
-		} else if (message.command === proto.cmd.GET_TIME) {
-			this.dispatchMessage({
-				command: proto.cmd.GET_TIME,
-				parameters: [...this.getCode(), ...siProtocol.date2arr(this.getDateTime())]
-			});
-		} else if (message.command === proto.cmd.SET_TIME) {
-			const newTime = siProtocol.arr2date(message.parameters.slice(0, 7));
-			console.log(newTime); // TODO: Use new time to set dateOffset
-			this.dispatchMessage({
-				command: proto.cmd.SET_TIME,
-				parameters: [...this.getCode(), ...siProtocol.date2arr(this.getDateTime())]
-			});
-		} else if (message.command === proto.cmd.GET_SYS_VAL) {
-			const offset = message.parameters[0];
-			const length = message.parameters[1];
-			this.dispatchMessage({
-				command: proto.cmd.GET_SYS_VAL,
-				parameters: [...this.getCode(), offset, ...this.storage.data.slice(offset, offset + length)] as number[]
-			});
-		} else if (message.command === proto.cmd.SET_SYS_VAL) {
-			const offset = message.parameters[0];
-			const newContent = message.parameters.slice(1);
-			let data = this.storage.data;
-			newContent.forEach((newByte: number, index: number) => {
-				data = data.set(offset + index, newByte);
-			});
-			this.storage = siStationStorageDefinition(data);
-			this.dispatchMessage({
-				command: proto.cmd.SET_SYS_VAL,
-				parameters: [...this.getCode(), offset]
-			});
-		} else if (message.command === proto.cmd.GET_SI5 || message.command === proto.cmd.GET_SI6 || message.command === proto.cmd.GET_SI8) {
-			if (this.fakeSiCard === undefined) {
-				return;
-			}
-			const cardMessages = this.fakeSiCard.handleRequest(message);
-			cardMessages.forEach((cardMessage: siProtocol.SiMessage) => {
-				this.dispatchCardMessage(cardMessage);
-			});
-		} else if (message.command === proto.cmd.ERASE_BDATA) {
-			this.dispatchMessage({
-				command: proto.cmd.ERASE_BDATA,
-				parameters: [...this.getCode()]
-			});
-		}
-	}
-}
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface FakeSiMainStation extends utils.EventTarget<FakeSiMainStationEvents> {}
-utils.applyMixins(FakeSiMainStation, [utils.EventTarget]);

package/src/fakes/IFakeSiMainStation.ts

@@ -1,15 +0,0 @@
-import * as utils from '../utils';
-import type * as siProtocol from '../siProtocol';
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-interface IFakeSiMainStation {}
-
-export class FakeSiMainStationMessageEvent extends utils.Event<'message'> {
-	constructor(public fakeSiMainStation: IFakeSiMainStation, public message: siProtocol.SiMessage) {
-		super();
-	}
-}
-
-export type FakeSiMainStationEvents = {
-	message: FakeSiMainStationMessageEvent;
-};

package/src/index.ts

@@ -1,24 +0,0 @@
-/* global si */
-/* exported si */
-
-import * as siCardExports from './SiCard';
-import * as siDeviceExports from './SiDevice';
-import * as fakesExports from './fakes';
-import * as siStationExports from './SiStation';
-import * as storageExports from './storage';
-import * as constants from './constants';
-import * as siProtocol from './siProtocol';
-import * as utils from './utils';
-
-export const si = {
-	...siCardExports,
-	...siDeviceExports,
-	...fakesExports,
-	...siStationExports,
-	...storageExports,
-	constants: constants,
-	protocol: siProtocol,
-	utils: utils
-};
-
-export default si;