sportident.js 1.0.0

package/src/SiCard/types/SiCard8.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import { proto } from '../../constants';
+import type * as siProtocol from '../../siProtocol';
+import * as testUtils from '../../testUtils';
+import { BaseSiCard } from '../BaseSiCard';
+import { ModernSiCardSeries } from './ModernSiCard';
+import { getPunchOffset, SiCard8 } from './SiCard8';
+import { getSiCard8Examples } from './siCard8Examples';
+import { FakeSiCard8 } from '../../fakes/FakeSiCard/types/FakeSiCard8';
+
+describe('SiCard8', () => {
+	test('is registered', () => {
+		expect(BaseSiCard.getTypeByCardNumber(1999999)).not.toEqual(SiCard8);
+		expect(BaseSiCard.getTypeByCardNumber(2000000)).toEqual(SiCard8);
+		expect(BaseSiCard.getTypeByCardNumber(2002999)).toEqual(SiCard8);
+		expect(BaseSiCard.getTypeByCardNumber(2003000)).not.toEqual(SiCard8);
+		expect(BaseSiCard.getTypeByCardNumber(2003999)).not.toEqual(SiCard8);
+		expect(BaseSiCard.getTypeByCardNumber(2004000)).toEqual(SiCard8);
+		expect(BaseSiCard.getTypeByCardNumber(2999999)).toEqual(SiCard8);
+		expect(BaseSiCard.getTypeByCardNumber(3000000)).not.toEqual(SiCard8);
+	});
+	describe('typeSpecificInstanceFromMessage', () => {
+		test('works for valid message', () => {
+			const instance = SiCard8.typeSpecificInstanceFromMessage({
+				command: proto.cmd.SI8_DET,
+				parameters: [0x00, 0x00, ModernSiCardSeries.SiCard8, 0x22, 0x22, 0x22]
+			});
+			if (instance === undefined) {
+				throw new Error('expect instance');
+			}
+			expect(instance instanceof SiCard8).toBe(true);
+			expect(instance.cardNumber).toBe(2236962);
+		});
+		test('returns undefined when message has mode', () => {
+			expect(
+				SiCard8.typeSpecificInstanceFromMessage({
+					mode: proto.NAK
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when message has wrong command', () => {
+			expect(
+				SiCard8.typeSpecificInstanceFromMessage({
+					command: testUtils.getRandomByteExcept([proto.cmd.SI8_DET]),
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when there are too few parameters', () => {
+			expect(
+				SiCard8.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI8_DET,
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when the series does not match', () => {
+			expect(
+				SiCard8.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI8_DET,
+					parameters: [0x00, 0x00, testUtils.getRandomByteExcept([ModernSiCardSeries.SiCard8]), 0x22, 0x22, 0x22]
+				})
+			).toBe(undefined);
+		});
+	});
+	test('getPunchOffset', () => {
+		expect(getPunchOffset(0)).toEqual(0x88);
+		expect(getPunchOffset(1)).toEqual(0x8c);
+		expect(getPunchOffset(29)).toEqual(0xfc);
+	});
+	const examples = getSiCard8Examples();
+	Object.keys(examples).forEach((exampleName) => {
+		const { storageData, cardData } = examples[exampleName];
+		const myFakeSiCard8 = new FakeSiCard8(storageData);
+		const mainStationSimulation = {
+			sendMessage: (message: siProtocol.SiMessage, numResponses?: number) => {
+				const responses: siProtocol.SiMessage[] = myFakeSiCard8.handleRequest(message);
+				if (responses.length !== numResponses) {
+					throw new Error('Invalid numResponses');
+				}
+				return Promise.resolve(responses.map((response: siProtocol.SiMessage) => (response.mode === undefined ? [0x00, 0x00, ...response.parameters] : [])));
+			}
+		};
+
+		test(`typeSpecificRead works with ${exampleName} example`, (done) => {
+			const mySiCard8 = new SiCard8(cardData.cardNumber);
+			mySiCard8.mainStation = mainStationSimulation;
+			mySiCard8.typeSpecificRead().then(() => {
+				expect(mySiCard8.raceResult.cardNumber).toEqual(cardData.cardNumber);
+				expect(mySiCard8.raceResult.startTime).toEqual(cardData.startTime);
+				expect(mySiCard8.raceResult.finishTime).toEqual(cardData.finishTime);
+				expect(mySiCard8.raceResult.checkTime).toEqual(cardData.checkTime);
+				expect(mySiCard8.raceResult.punches).toEqual(cardData.punches);
+				expect(mySiCard8.raceResult.cardHolder).toEqual(cardData.cardHolder);
+				expect(mySiCard8.punchCount).toEqual(cardData.punchCount);
+				expect(mySiCard8.uid).toEqual(cardData.uid);
+
+				const cardSeriesString = mySiCard8.storage.get('cardSeries')!.toString();
+				expect(cardSeriesString in ModernSiCardSeries).toBe(true);
+				done();
+			});
+		});
+
+		test(`typeSpecificRead works with wrong card number in ${exampleName} example`, (done) => {
+			const mySiCard8 = new SiCard8(cardData.cardNumber + 1);
+			mySiCard8.mainStation = mainStationSimulation;
+			mySiCard8.typeSpecificRead().then(() => {
+				expect(mySiCard8.raceResult.cardNumber).toEqual(cardData.cardNumber);
+				expect(mySiCard8.raceResult.startTime).toEqual(cardData.startTime);
+				expect(mySiCard8.raceResult.finishTime).toEqual(cardData.finishTime);
+				expect(mySiCard8.raceResult.checkTime).toEqual(cardData.checkTime);
+				expect(mySiCard8.raceResult.punches).toEqual(cardData.punches);
+				expect(mySiCard8.raceResult.cardHolder).toEqual(cardData.cardHolder);
+				expect(mySiCard8.punchCount).toEqual(cardData.punchCount);
+				expect(mySiCard8.uid).toEqual(cardData.uid);
+				done();
+			});
+		});
+	});
+	test('typeSpecificRead if typeSpecificGetPage fails', (done) => {
+		const testError = new Error('test');
+		let attemptedToGetPage = false;
+		class ModernSiCardWithoutCardHolder extends SiCard8 {
+			typeSpecificGetPage() {
+				attemptedToGetPage = true;
+				return Promise.reject(testError);
+			}
+		}
+		const myModernSiCard = new ModernSiCardWithoutCardHolder(7123456);
+		myModernSiCard.typeSpecificRead().catch((err) => {
+			expect(attemptedToGetPage).toBe(true);
+			expect(err).toBe(testError);
+			done();
+		});
+	});
+});

package/src/SiCard/types/SiCard8.ts

@@ -0,0 +1,129 @@
+import _ from 'lodash';
+import * as storage from '../../storage';
+import * as siProtocol from '../../siProtocol';
+import { cropPunches, getCroppedString, ModernSiCard, ModernSiCardSeries } from './ModernSiCard';
+import type { IBaseSiCardStorageFields } from '../ISiCard';
+import { BaseSiCard } from '../BaseSiCard';
+
+class ReadFinishedException {}
+const punchesPerPage = 32;
+const bytesPerPage = 128;
+const MAX_NUM_PUNCHES = 30;
+
+export const getPunchOffset = (i: number): number => 0x88 + i * 4;
+
+const parseCardHolderString = (semicolonSeparatedString: string): { [property: string]: unknown } => {
+	const informationComponents = semicolonSeparatedString.split(';');
+	return {
+		firstName: informationComponents.length > 1 ? informationComponents[0] : undefined,
+		lastName: informationComponents.length > 2 ? informationComponents[1] : undefined,
+		isComplete: informationComponents.length > 2
+	};
+};
+
+const parseCardHolder = (maybeCharCodes: (number | undefined)[]) => {
+	const semicolonSeparatedString = getCroppedString(maybeCharCodes);
+	return parseCardHolderString(semicolonSeparatedString || '');
+};
+
+export interface ISiCard8StorageFields extends IBaseSiCardStorageFields {
+	uid: number;
+	cardSeries: keyof typeof ModernSiCardSeries;
+}
+
+export const siCard8StorageLocations: storage.ISiStorageLocations<ISiCard8StorageFields> = {
+	uid: new storage.SiInt([[0x03], [0x02], [0x01], [0x00]]),
+	cardSeries: new storage.SiEnum([[0x18]], ModernSiCardSeries),
+	cardNumber: new storage.SiModified(
+		new storage.SiArray(3, (i) => new storage.SiInt([[0x19 + (2 - i)]])),
+		(extractedValue) => siProtocol.arr2cardNumber(extractedValue)
+		// (cardNumber) => siProtocol.cardNumber2arr(cardNumber),
+		// (cardNumber) => `${cardNumber}`,
+		// (cardNumberString) => parseInt(cardNumberString, 10),
+		// (cardNumber) => cardNumber !== undefined && _.isInteger(cardNumber) && cardNumber >= 0,
+	),
+	startTime: new siProtocol.SiTime([[0x0f], [0x0e], [0x0c]]),
+	finishTime: new siProtocol.SiTime([[0x13], [0x12], [0x10]]),
+	checkTime: new siProtocol.SiTime([[0x0b], [0x0a], [0x08]]),
+	punchCount: new storage.SiInt([[0x16]]),
+	punches: new storage.SiModified(
+		new storage.SiArray(
+			MAX_NUM_PUNCHES,
+			(i) =>
+				new storage.SiDict({
+					code: new storage.SiInt([[getPunchOffset(i) + 1]]),
+					time: new siProtocol.SiTime([[getPunchOffset(i) + 3], [getPunchOffset(i) + 2], [getPunchOffset(i) + 0]])
+				})
+		),
+		(allPunches) => cropPunches(allPunches)
+	),
+	cardHolder: new storage.SiModified(new storage.SiArray(0x60, (i) => new storage.SiInt([[0x20 + i]])), (charCodes) => parseCardHolder(charCodes))
+};
+export const siCard8StorageDefinition = storage.defineStorage(0x100, siCard8StorageLocations);
+
+export class SiCard8 extends ModernSiCard {
+	static maxNumPunches = MAX_NUM_PUNCHES;
+
+	static typeSpecificInstanceFromMessage(message: siProtocol.SiMessage): SiCard8 | undefined {
+		const info = this.parseModernSiCardDetectionMessage(message);
+		if (info === undefined) {
+			return undefined;
+		}
+		if (info.cardSeries !== 'SiCard8') {
+			return undefined;
+		}
+		return new this(info.cardNumber);
+	}
+
+	public storage: storage.ISiStorage<ISiCard8StorageFields>;
+
+	public uid?: number;
+
+	constructor(cardNumber: number) {
+		super(cardNumber);
+		this.storage = siCard8StorageDefinition();
+	}
+
+	typeSpecificRead(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			this.typeSpecificGetPage(0)
+				.then((page0: number[]) => {
+					this.storage.splice(bytesPerPage * 0, bytesPerPage, ...page0);
+
+					const readCardNumber = this.storage.get('cardNumber')!.value;
+					if (this.cardNumber !== readCardNumber) {
+						console.warn(`SICard8 Number ${readCardNumber} (expected ${this.cardNumber})`);
+					}
+
+					if (this.storage.get('punchCount')!.value <= punchesPerPage * 0) {
+						throw new ReadFinishedException();
+					}
+					return this.typeSpecificGetPage(1);
+				})
+				.then((page1: number[]) => {
+					this.storage.splice(bytesPerPage * 1, bytesPerPage, ...page1);
+					throw new ReadFinishedException();
+				})
+				.catch((exc: Error) => {
+					if (exc instanceof ReadFinishedException) {
+						this.raceResult = {
+							cardNumber: this.storage.get('cardNumber')!.value,
+							startTime: this.storage.get('startTime')?.value,
+							finishTime: this.storage.get('finishTime')?.value,
+							checkTime: this.storage.get('checkTime')?.value,
+							punches: this.storage.get('punches')!.value,
+							cardHolder: this.storage.get('cardHolder')!.value
+						};
+						this.punchCount = this.storage.get('punchCount')!.value;
+						this.cardSeries = this.storage.get('cardSeries')!.value;
+						this.uid = this.storage.get('uid')!.value;
+						resolve();
+					} else {
+						reject(exc);
+					}
+				});
+		});
+	}
+}
+BaseSiCard.registerNumberRange(2000000, 2003000, SiCard8);
+BaseSiCard.registerNumberRange(2004000, 3000000, SiCard8);

package/src/SiCard/types/SiCard9.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from '@jest/globals';
+import { proto } from '../../constants';
+import type * as siProtocol from '../../siProtocol';
+import * as testUtils from '../../testUtils';
+import { BaseSiCard } from '../BaseSiCard';
+import { ModernSiCardSeries } from './ModernSiCard';
+import { getPunchOffset, SiCard9 } from './SiCard9';
+import { getSiCard9Examples } from './siCard9Examples';
+import { FakeSiCard9 } from '../../fakes/FakeSiCard/types/FakeSiCard9';
+
+describe('SiCard9', () => {
+	test('is registered', () => {
+		expect(BaseSiCard.getTypeByCardNumber(999999)).not.toEqual(SiCard9);
+		expect(BaseSiCard.getTypeByCardNumber(1000000)).toEqual(SiCard9);
+		expect(BaseSiCard.getTypeByCardNumber(1999999)).toEqual(SiCard9);
+		expect(BaseSiCard.getTypeByCardNumber(2000000)).not.toEqual(SiCard9);
+	});
+	describe('typeSpecificInstanceFromMessage', () => {
+		test('works for valid message', () => {
+			const instance = SiCard9.typeSpecificInstanceFromMessage({
+				command: proto.cmd.SI8_DET,
+				parameters: [0x00, 0x00, ModernSiCardSeries.SiCard9, 0x11, 0x11, 0x11]
+			});
+			if (instance === undefined) {
+				throw new Error('expect instance');
+			}
+			expect(instance instanceof SiCard9).toBe(true);
+			expect(instance.cardNumber).toBe(1118481);
+		});
+		test('returns undefined when message has mode', () => {
+			expect(
+				SiCard9.typeSpecificInstanceFromMessage({
+					mode: proto.NAK
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when message has wrong command', () => {
+			expect(
+				SiCard9.typeSpecificInstanceFromMessage({
+					command: testUtils.getRandomByteExcept([proto.cmd.SI8_DET]),
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when there are too few parameters', () => {
+			expect(
+				SiCard9.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI8_DET,
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when the series does not match', () => {
+			expect(
+				SiCard9.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI8_DET,
+					parameters: [0x00, 0x00, testUtils.getRandomByteExcept([ModernSiCardSeries.SiCard9]), 0x22, 0x22, 0x22]
+				})
+			).toBe(undefined);
+		});
+	});
+	test('getPunchOffset', () => {
+		expect(getPunchOffset(0)).toEqual(0x38);
+		expect(getPunchOffset(1)).toEqual(0x3c);
+		expect(getPunchOffset(49)).toEqual(0xfc);
+	});
+	const examples = getSiCard9Examples();
+	Object.keys(examples).forEach((exampleName) => {
+		const { storageData, cardData } = examples[exampleName];
+		const myFakeSiCard9 = new FakeSiCard9(storageData);
+		const mainStationSimulation = {
+			sendMessage: (message: siProtocol.SiMessage, numResponses?: number) => {
+				const responses: siProtocol.SiMessage[] = myFakeSiCard9.handleRequest(message);
+				if (responses.length !== numResponses) {
+					throw new Error('Invalid numResponses');
+				}
+				return Promise.resolve(responses.map((response: siProtocol.SiMessage) => (response.mode === undefined ? [0x00, 0x00, ...response.parameters] : [])));
+			}
+		};
+
+		test(`typeSpecificRead works with ${exampleName} example`, (done) => {
+			const mySiCard9 = new SiCard9(cardData.cardNumber);
+			mySiCard9.mainStation = mainStationSimulation;
+			mySiCard9.typeSpecificRead().then(() => {
+				expect(mySiCard9.raceResult.cardNumber).toEqual(cardData.cardNumber);
+				expect(mySiCard9.raceResult.startTime).toEqual(cardData.startTime);
+				expect(mySiCard9.raceResult.finishTime).toEqual(cardData.finishTime);
+				expect(mySiCard9.raceResult.checkTime).toEqual(cardData.checkTime);
+				expect(mySiCard9.raceResult.punches).toEqual(cardData.punches);
+				expect(mySiCard9.raceResult.cardHolder).toEqual(cardData.cardHolder);
+				expect(mySiCard9.punchCount).toEqual(cardData.punchCount);
+				expect(mySiCard9.uid).toEqual(cardData.uid);
+
+				const cardSeriesString = mySiCard9.storage.get('cardSeries')!.toString();
+				expect(cardSeriesString in ModernSiCardSeries).toBe(true);
+				done();
+			});
+		});
+
+		test(`typeSpecificRead works with wrong card number in ${exampleName} example`, (done) => {
+			const mySiCard9 = new SiCard9(cardData.cardNumber + 1);
+			mySiCard9.mainStation = mainStationSimulation;
+			mySiCard9.typeSpecificRead().then(() => {
+				expect(mySiCard9.raceResult.cardNumber).toEqual(cardData.cardNumber);
+				expect(mySiCard9.raceResult.startTime).toEqual(cardData.startTime);
+				expect(mySiCard9.raceResult.finishTime).toEqual(cardData.finishTime);
+				expect(mySiCard9.raceResult.checkTime).toEqual(cardData.checkTime);
+				expect(mySiCard9.raceResult.punches).toEqual(cardData.punches);
+				expect(mySiCard9.raceResult.cardHolder).toEqual(cardData.cardHolder);
+				expect(mySiCard9.punchCount).toEqual(cardData.punchCount);
+				expect(mySiCard9.uid).toEqual(cardData.uid);
+				done();
+			});
+		});
+	});
+	test('typeSpecificRead if typeSpecificGetPage fails', (done) => {
+		const testError = new Error('test');
+		let attemptedToGetPage = false;
+		class ModernSiCardWithoutCardHolder extends SiCard9 {
+			typeSpecificGetPage() {
+				attemptedToGetPage = true;
+				return Promise.reject(testError);
+			}
+		}
+		const myModernSiCard = new ModernSiCardWithoutCardHolder(7123456);
+		myModernSiCard.typeSpecificRead().catch((err) => {
+			expect(attemptedToGetPage).toBe(true);
+			expect(err).toBe(testError);
+			done();
+		});
+	});
+});

package/src/SiCard/types/SiCard9.ts

@@ -0,0 +1,128 @@
+import _ from 'lodash';
+import * as storage from '../../storage';
+import * as siProtocol from '../../siProtocol';
+import { cropPunches, getCroppedString, ModernSiCard, ModernSiCardSeries } from './ModernSiCard';
+import type { IBaseSiCardStorageFields } from '../ISiCard';
+import { BaseSiCard } from '../BaseSiCard';
+
+class ReadFinishedException {}
+const punchesPerPage = 32;
+const bytesPerPage = 128;
+const MAX_NUM_PUNCHES = 50;
+
+export const getPunchOffset = (i: number): number => 0x38 + i * 4;
+
+const parseCardHolderString = (semicolonSeparatedString: string): { [property: string]: unknown } => {
+	const informationComponents = semicolonSeparatedString.split(';');
+	return {
+		firstName: informationComponents.length > 1 ? informationComponents[0] : undefined,
+		lastName: informationComponents.length > 2 ? informationComponents[1] : undefined,
+		isComplete: informationComponents.length > 2
+	};
+};
+
+const parseCardHolder = (maybeCharCodes: (number | undefined)[]) => {
+	const semicolonSeparatedString = getCroppedString(maybeCharCodes);
+	return parseCardHolderString(semicolonSeparatedString || '');
+};
+
+export interface ISiCard9StorageFields extends IBaseSiCardStorageFields {
+	uid: number;
+	cardSeries: keyof typeof ModernSiCardSeries;
+}
+
+export const siCard9StorageLocations: storage.ISiStorageLocations<ISiCard9StorageFields> = {
+	uid: new storage.SiInt([[0x03], [0x02], [0x01], [0x00]]),
+	cardSeries: new storage.SiEnum([[0x18]], ModernSiCardSeries),
+	cardNumber: new storage.SiModified(
+		new storage.SiArray(3, (i) => new storage.SiInt([[0x19 + (2 - i)]])),
+		(extractedValue) => siProtocol.arr2cardNumber(extractedValue)
+		// (cardNumber) => siProtocol.cardNumber2arr(cardNumber),
+		// (cardNumber) => `${cardNumber}`,
+		// (cardNumberString) => parseInt(cardNumberString, 10),
+		// (cardNumber) => cardNumber !== undefined && _.isInteger(cardNumber) && cardNumber >= 0,
+	),
+	startTime: new siProtocol.SiTime([[0x0f], [0x0e], [0x0c]]),
+	finishTime: new siProtocol.SiTime([[0x13], [0x12], [0x10]]),
+	checkTime: new siProtocol.SiTime([[0x0b], [0x0a], [0x08]]),
+	punchCount: new storage.SiInt([[0x16]]),
+	punches: new storage.SiModified(
+		new storage.SiArray(
+			MAX_NUM_PUNCHES,
+			(i) =>
+				new storage.SiDict({
+					code: new storage.SiInt([[getPunchOffset(i) + 1]]),
+					time: new siProtocol.SiTime([[getPunchOffset(i) + 3], [getPunchOffset(i) + 2], [getPunchOffset(i) + 0]])
+				})
+		),
+		(allPunches) => cropPunches(allPunches)
+	),
+	cardHolder: new storage.SiModified(new storage.SiArray(0x18, (i) => new storage.SiInt([[0x20 + i]])), (charCodes) => parseCardHolder(charCodes))
+};
+export const siCard9StorageDefinition = storage.defineStorage(0x100, siCard9StorageLocations);
+
+export class SiCard9 extends ModernSiCard {
+	static maxNumPunches = MAX_NUM_PUNCHES;
+
+	static typeSpecificInstanceFromMessage(message: siProtocol.SiMessage): SiCard9 | undefined {
+		const info = this.parseModernSiCardDetectionMessage(message);
+		if (info === undefined) {
+			return undefined;
+		}
+		if (info.cardSeries !== 'SiCard9') {
+			return undefined;
+		}
+		return new this(info.cardNumber);
+	}
+
+	public storage: storage.ISiStorage<ISiCard9StorageFields>;
+
+	public uid?: number;
+
+	constructor(cardNumber: number) {
+		super(cardNumber);
+		this.storage = siCard9StorageDefinition();
+	}
+
+	typeSpecificRead(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			this.typeSpecificGetPage(0)
+				.then((page0: number[]) => {
+					this.storage.splice(bytesPerPage * 0, bytesPerPage, ...page0);
+
+					const readCardNumber = this.storage.get('cardNumber')!.value;
+					if (this.cardNumber !== readCardNumber) {
+						console.warn(`SICard9 Number ${readCardNumber} (expected ${this.cardNumber})`);
+					}
+
+					if (this.storage.get('punchCount')!.value <= punchesPerPage * 0) {
+						throw new ReadFinishedException();
+					}
+					return this.typeSpecificGetPage(1);
+				})
+				.then((page1: number[]) => {
+					this.storage.splice(bytesPerPage * 1, bytesPerPage, ...page1);
+					throw new ReadFinishedException();
+				})
+				.catch((exc: Error) => {
+					if (exc instanceof ReadFinishedException) {
+						this.raceResult = {
+							cardNumber: this.storage.get('cardNumber')!.value,
+							startTime: this.storage.get('startTime')?.value,
+							finishTime: this.storage.get('finishTime')?.value,
+							checkTime: this.storage.get('checkTime')?.value,
+							punches: this.storage.get('punches')!.value,
+							cardHolder: this.storage.get('cardHolder')!.value
+						};
+						this.punchCount = this.storage.get('punchCount')!.value;
+						this.cardSeries = this.storage.get('cardSeries')!.value;
+						this.uid = this.storage.get('uid')!.value;
+						resolve();
+					} else {
+						reject(exc);
+					}
+				});
+		});
+	}
+}
+BaseSiCard.registerNumberRange(1000000, 2000000, SiCard9);

package/src/SiCard/types/TCard.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from '@jest/globals';
+import { BaseSiCard } from '../BaseSiCard';
+import { TCard } from './TCard';
+
+describe('TCard', () => {
+	test('is registered', () => {
+		expect(BaseSiCard.getTypeByCardNumber(5999999)).not.toEqual(TCard);
+		expect(BaseSiCard.getTypeByCardNumber(6000000)).toEqual(TCard);
+		expect(BaseSiCard.getTypeByCardNumber(6999999)).toEqual(TCard);
+		expect(BaseSiCard.getTypeByCardNumber(7000000)).not.toEqual(TCard);
+	});
+	test('is not implemented', (done) => {
+		const tCard = new TCard(6000000);
+		tCard.read().then(
+			() => done(new Error('expect reject')),
+			() => done()
+		);
+	});
+});

package/src/SiCard/types/TCard.ts

@@ -0,0 +1,14 @@
+import * as utils from '../../utils';
+import type * as siProtocol from '../../siProtocol';
+import { BaseSiCard } from '../BaseSiCard';
+
+export class TCard extends BaseSiCard {
+	static typeSpecificInstanceFromMessage(_message: siProtocol.SiMessage): TCard | undefined {
+		return undefined;
+	}
+
+	typeSpecificRead(): Promise<void> {
+		return Promise.reject(new utils.NotImplementedError());
+	}
+}
+BaseSiCard.registerNumberRange(6000000, 7000000, TCard);

package/src/SiCard/types/index.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import * as utils from '../../utils';
+import type { SiCardSample } from '../ISiCardExamples';
+import { BaseSiCard, type SiCardType } from '../BaseSiCard';
+import * as siCardIndex from './index';
+
+describe('SiCard index', () => {
+	const cardTypesInRegistry = BaseSiCard.cardNumberRangeRegistry.values;
+	utils.typedKeys(siCardIndex).forEach((siCardExportName) => {
+		const siCardExport = siCardIndex[siCardExportName];
+		if (siCardExport.prototype instanceof BaseSiCard) {
+			const cardType = siCardExport as SiCardType<BaseSiCard>;
+			test(`card type ${siCardExportName} has been registered`, () => {
+				expect(cardTypesInRegistry.includes(cardType)).toBe(true);
+			});
+		} else if (/^get\S+Examples$/.exec(siCardExportName)) {
+			const getExamples = siCardExport as () => { [name: string]: SiCardSample };
+			test(`card type examples ${siCardExportName} can be retrieved`, () => {
+				expect(_.isPlainObject(getExamples())).toBe(true);
+			});
+		} else {
+			throw new Error('There are currently no other exports allowed');
+		}
+	});
+});

package/src/SiCard/types/index.ts

@@ -0,0 +1,15 @@
+export { FCard } from './FCard';
+export { PCard } from './PCard';
+export { SIAC } from './SIAC';
+export { SiCard5 } from './SiCard5';
+export { SiCard6 } from './SiCard6';
+export { SiCard8 } from './SiCard8';
+export { SiCard9 } from './SiCard9';
+export { SiCard10 } from './SiCard10';
+export { SiCard11 } from './SiCard11';
+export { TCard } from './TCard';
+export { getSiCard5Examples } from './siCard5Examples';
+export { getSiCard6Examples } from './siCard6Examples';
+export { getSiCard8Examples } from './siCard8Examples';
+export { getSiCard9Examples } from './siCard9Examples';
+export { getModernSiCardExamples } from './modernSiCardExamples';