sportident.js 1.0.0

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

@@ -0,0 +1,42 @@
+import { describe, expect, test } from '@jest/globals';
+import { proto } from '../../../constants';
+import * as utils from '../../../utils';
+import * as testUtils from '../../../testUtils';
+import { FakeSiCard5 } from './FakeSiCard5';
+import { getCardWith16Punches } from '../../../SiCard/types/siCard5Examples';
+
+testUtils.useFakeTimers();
+
+describe('FakeSiCard5', () => {
+	test('exists', () => {
+		expect(FakeSiCard5).not.toBe(undefined);
+	});
+	const testData = getCardWith16Punches();
+	const myFakeSiCard5 = new FakeSiCard5(testData.storageData);
+	test('handleDetect works', () => {
+		expect(myFakeSiCard5.handleDetect()).toEqual({
+			command: proto.cmd.SI5_DET,
+			parameters: utils.unPrettyHex('00 04 19 02')
+		});
+	});
+	test('handleRequest works', () => {
+		expect(() =>
+			myFakeSiCard5.handleRequest({
+				command: proto.cmd.GET_SI8,
+				parameters: [0x06]
+			})
+		).toThrow();
+
+		expect(
+			myFakeSiCard5.handleRequest({
+				command: proto.cmd.GET_SI5,
+				parameters: []
+			})
+		).toEqual([
+			{
+				command: proto.cmd.GET_SI5,
+				parameters: testData.storageData
+			}
+		]);
+	});
+});

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+export { FakeSiCard5 } from './FakeSiCard5';
+export { FakeSiCard6 } from './FakeSiCard6';
+export { FakeSiCard8 } from './FakeSiCard8';
+export { FakeSiCard9 } from './FakeSiCard9';
+export { FakeSiCard10 } from './FakeSiCard10';
+export { FakeSiCard11 } from './FakeSiCard11';
+export { FakeSIAC } from './FakeSIAC';

package/src/fakes/FakeSiDeviceDriver.ts

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

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

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

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

@@ -0,0 +1,2 @@
+export { FakeSiMainStation } from './FakeSiMainStation';
+export * from './FakeSiCard';

package/src/index.ts

@@ -0,0 +1,24 @@
+/* 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;