sportident.js 1.0.0

package/src/SiCard/types/ModernSiCard.ts

@@ -0,0 +1,241 @@
+import _ from 'lodash';
+import { proto } from '../../constants';
+import * as storage from '../../storage';
+import * as utils from '../../utils';
+import * as siProtocol from '../../siProtocol';
+import type { IBaseSiCardStorageFields } from '../ISiCard';
+import { BaseSiCard } from '../BaseSiCard';
+import type { IPunch } from '../IRaceResultData';
+
+class ReadFinishedException {}
+const punchesPerPage = 32;
+const bytesPerPage = 128;
+
+const MAX_NUM_PUNCHES = 128;
+
+export const ModernSiCardSeries = {
+	SiCard8: 0x02,
+	SiCard9: 0x01,
+	SiCard10: 0x0f,
+	PCard: 0x04,
+	TCard: 0x06
+	// TODO: Find out these values
+	// SiCard11: ?,
+	// SIAC: ?,
+	// FCard: ?,
+};
+
+export interface PotentialModernSiCardPunch {
+	code: number | undefined;
+	time: siProtocol.SiTimestamp | undefined;
+}
+
+export const getPunchOffset = (i: number): number => bytesPerPage * 4 + i * 4;
+
+export const cropPunches = (allPunches: (PotentialModernSiCardPunch | undefined)[]): IPunch[] => {
+	const isPunchEntryValid = (punch: PotentialModernSiCardPunch | undefined): punch is IPunch => punch !== undefined && punch.code !== undefined && punch.time !== undefined && punch.time !== null;
+	const firstInvalidIndex = allPunches.findIndex((punch) => !isPunchEntryValid(punch));
+	const punchesUntilInvalid = firstInvalidIndex === -1 ? allPunches : allPunches.slice(0, firstInvalidIndex);
+	return punchesUntilInvalid.filter<IPunch>(isPunchEntryValid);
+};
+
+export const getCroppedString = (charCodes: (number | undefined)[]): string => {
+	const isCharacterInvalid = (charCode: number | undefined) => charCode === undefined || charCode === 0xee;
+	const firstInvalidIndex = charCodes.findIndex(isCharacterInvalid);
+	const croppedCharCodes = (firstInvalidIndex === -1 ? charCodes : charCodes.slice(0, firstInvalidIndex)) as number[];
+	return croppedCharCodes.map((charCode: number) => storage.siStringToUtf8(charCode)).join('');
+};
+
+export 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,
+		gender: informationComponents.length > 3 ? informationComponents[2] : undefined,
+		birthday: informationComponents.length > 4 ? informationComponents[3] : undefined,
+		club: informationComponents.length > 5 ? informationComponents[4] : undefined,
+		email: informationComponents.length > 6 ? informationComponents[5] : undefined,
+		phone: informationComponents.length > 7 ? informationComponents[6] : undefined,
+		city: informationComponents.length > 8 ? informationComponents[7] : undefined,
+		street: informationComponents.length > 9 ? informationComponents[8] : undefined,
+		zip: informationComponents.length > 10 ? informationComponents[9] : undefined,
+		country: informationComponents.length > 11 ? informationComponents[10] : undefined,
+		isComplete: informationComponents.length > 11
+	};
+};
+
+export const parseCardHolder = (maybeCharCodes: (number | undefined)[]): { [property: string]: unknown } => {
+	const semicolonSeparatedString = getCroppedString(maybeCharCodes);
+	return parseCardHolderString(semicolonSeparatedString || '');
+};
+
+export interface IModernSiCardStorageFields extends IBaseSiCardStorageFields {
+	uid: number;
+	cardSeries: keyof typeof ModernSiCardSeries;
+}
+
+export const modernSiCardStorageLocations: storage.ISiStorageLocations<IModernSiCardStorageFields> = {
+	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(0x80, (i) => new storage.SiInt([[0x20 + i]])), (charCodes) => parseCardHolder(charCodes))
+};
+export const modernSiCardStorageDefinition = storage.defineStorage(0x400, modernSiCardStorageLocations);
+
+export class ModernSiCard extends BaseSiCard {
+	static maxNumPunches = MAX_NUM_PUNCHES;
+
+	static parseModernSiCardDetectionMessage(message: siProtocol.SiMessage): { cardNumber: number; cardSeries: keyof typeof ModernSiCardSeries } | undefined {
+		if (message.mode !== undefined) {
+			return undefined;
+		}
+		if (message.command !== proto.cmd.SI8_DET) {
+			return undefined;
+		}
+		if (message.parameters.length < 6) {
+			return undefined;
+		}
+		const cardNumber = siProtocol.arr2cardNumber([message.parameters[5], message.parameters[4], message.parameters[3]]);
+		/* istanbul ignore next */
+		if (cardNumber === undefined) {
+			throw new Error('card number cannot be undefined');
+		}
+		const cardSeries = message.parameters[2];
+		const lookup = utils.getLookup(ModernSiCardSeries);
+		return {
+			cardNumber: cardNumber,
+			cardSeries: lookup[cardSeries] as keyof typeof ModernSiCardSeries
+		};
+	}
+
+	public storage: storage.ISiStorage<IModernSiCardStorageFields>;
+
+	public punchCount?: number;
+	public cardSeries?: keyof typeof ModernSiCardSeries;
+
+	constructor(cardNumber: number) {
+		super(cardNumber);
+		this.storage = modernSiCardStorageDefinition();
+	}
+
+	typeSpecificGetPage(pageNumber: number): Promise<number[]> {
+		if (!this.mainStation) {
+			return Promise.reject(new Error('No main station'));
+		}
+		return this.mainStation
+			.sendMessage(
+				{
+					command: proto.cmd.GET_SI8,
+					parameters: [pageNumber]
+				},
+				1
+			)
+			.then((data: number[][]) => {
+				console.assert(data[0][2] === pageNumber, `Page number ${data[0][2]} retrieved (expected ${pageNumber})`);
+				return data[0].slice(3);
+			});
+	}
+
+	typeSpecificRead(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			this.typeSpecificReadBasic()
+				.then(() => this.typeSpecificReadCardHolder())
+				.then(() => this.typeSpecificReadPunches())
+				.then(() => {
+					this.raceResult = {
+						cardNumber: this.storage.get('cardNumber')?.value || 0,
+						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;
+					resolve();
+				})
+				.catch((exc: Error) => reject(exc));
+		});
+	}
+
+	typeSpecificReadBasic(): Promise<void> {
+		return 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(`ModernSiCard Number ${readCardNumber} (expected ${this.cardNumber})`);
+			}
+		});
+	}
+
+	typeSpecificReadCardHolder(): Promise<void> {
+		const cardHolderSoFar = this.storage.get('cardHolder')!.value;
+		if (cardHolderSoFar && cardHolderSoFar.isComplete) {
+			return Promise.resolve();
+		}
+		return this.typeSpecificGetPage(1).then((page1: number[]) => {
+			this.storage.splice(bytesPerPage * 1, bytesPerPage, ...page1);
+		});
+	}
+
+	typeSpecificReadPunches(): Promise<void> {
+		if (this.storage.get('punchCount')!.value <= punchesPerPage * 0) {
+			return Promise.resolve();
+		}
+		return this.typeSpecificGetPage(4)
+			.then((page4: number[]) => {
+				this.storage.splice(bytesPerPage * 4, bytesPerPage, ...page4);
+				if (this.storage.get('punchCount')!.value <= punchesPerPage * 1) {
+					throw new ReadFinishedException();
+				}
+				return this.typeSpecificGetPage(5);
+			})
+			.then((page5: number[]) => {
+				this.storage.splice(bytesPerPage * 5, bytesPerPage, ...page5);
+				if (this.storage.get('punchCount')!.value <= punchesPerPage * 2) {
+					throw new ReadFinishedException();
+				}
+				return this.typeSpecificGetPage(6);
+			})
+			.then((page6: number[]) => {
+				this.storage.splice(bytesPerPage * 6, bytesPerPage, ...page6);
+				if (this.storage.get('punchCount')!.value <= punchesPerPage * 3) {
+					throw new ReadFinishedException();
+				}
+				return this.typeSpecificGetPage(7);
+			})
+			.then((page7: number[]) => {
+				this.storage.splice(bytesPerPage * 7, bytesPerPage, ...page7);
+				throw new ReadFinishedException();
+			})
+			.catch((exc: Error) => {
+				if (exc instanceof ReadFinishedException) {
+					return;
+				}
+				throw exc;
+			});
+	}
+}

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

@@ -0,0 +1,19 @@
+import { describe, expect, test } from '@jest/globals';
+import { BaseSiCard } from '../BaseSiCard';
+import { PCard } from './PCard';
+
+describe('PCard', () => {
+	test('is registered', () => {
+		expect(BaseSiCard.getTypeByCardNumber(3999999)).not.toEqual(PCard);
+		expect(BaseSiCard.getTypeByCardNumber(4000000)).toEqual(PCard);
+		expect(BaseSiCard.getTypeByCardNumber(4999999)).toEqual(PCard);
+		expect(BaseSiCard.getTypeByCardNumber(5000000)).not.toEqual(PCard);
+	});
+	test('is not implemented', (done) => {
+		const pCard = new PCard(4000000);
+		pCard.read().then(
+			() => done(new Error('expect reject')),
+			() => done()
+		);
+	});
+});

package/src/SiCard/types/PCard.ts

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

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

@@ -0,0 +1,84 @@
+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 { SIAC } from './SIAC';
+
+describe('SIAC', () => {
+	test('is registered', () => {
+		expect(BaseSiCard.getTypeByCardNumber(7999999)).not.toEqual(SIAC);
+		expect(BaseSiCard.getTypeByCardNumber(8000000)).toEqual(SIAC);
+		expect(BaseSiCard.getTypeByCardNumber(8999999)).toEqual(SIAC);
+		expect(BaseSiCard.getTypeByCardNumber(9000000)).not.toEqual(SIAC);
+	});
+	describe('typeSpecificInstanceFromMessage', () => {
+		test('works for valid message', () => {
+			const instance = SIAC.typeSpecificInstanceFromMessage({
+				command: proto.cmd.SI8_DET,
+				parameters: [0x00, 0x00, /* TODO: */ 0x00, 0x88, 0x88, 0x88]
+			});
+			if (instance === undefined) {
+				throw new Error('expect instance');
+			}
+			expect(instance instanceof SIAC).toBe(true);
+			expect(instance.cardNumber).toBe(8947848);
+		});
+		test('returns undefined when message has mode', () => {
+			expect(
+				SIAC.typeSpecificInstanceFromMessage({
+					mode: proto.NAK
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when message has wrong command', () => {
+			expect(
+				SIAC.typeSpecificInstanceFromMessage({
+					command: testUtils.getRandomByteExcept([proto.cmd.SI8_DET]),
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when there are too few parameters', () => {
+			expect(
+				SIAC.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI8_DET,
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when the card number does not match', () => {
+			expect(
+				SIAC.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI8_DET,
+					parameters: [0x00, 0x00, /* TODO: */ 0x00, 0x22, 0x22, 0x22]
+				})
+			).toBe(undefined);
+		});
+	});
+	test('is modern', (done) => {
+		const mySIAC = new SIAC(8500000);
+		mySIAC.mainStation = {
+			sendMessage: (message: siProtocol.SiMessage, numResponses?: number) => {
+				if (message.mode !== undefined) {
+					return Promise.reject(new Error('message mode is not undefined'));
+				}
+				const { command, parameters } = message;
+				expect(command).toBe(proto.cmd.GET_SI8);
+				expect(numResponses).toBe(1);
+				const pageNumberToGet = parameters[0];
+				const getPage = (pageNumber: number) => [...[0x00, 0x00, pageNumber], ..._.range(128).map(() => 0)];
+				return Promise.resolve([getPage(pageNumberToGet)]);
+			}
+		};
+		mySIAC.typeSpecificRead().then(() => {
+			expect(mySIAC.raceResult.cardNumber).toBe(0);
+			expect(JSON.stringify(mySIAC.raceResult.startTime)).toBe(JSON.stringify({"time":0,"weekcounter":0,"weekday":0}));
+			expect(JSON.stringify(mySIAC.raceResult.finishTime)).toBe(JSON.stringify({"time":0,"weekcounter":0,"weekday":0}));
+			expect(mySIAC.raceResult.punches).toEqual([]);
+			expect(mySIAC.punchCount).toBe(0);
+			done();
+		});
+	});
+});

package/src/SiCard/types/SIAC.ts

@@ -0,0 +1,19 @@
+import type * as siProtocol from '../../siProtocol';
+import { ModernSiCard } from './ModernSiCard';
+import { BaseSiCard } from '../BaseSiCard';
+
+export class SIAC extends ModernSiCard {
+	static typeSpecificInstanceFromMessage(message: siProtocol.SiMessage): SIAC | undefined {
+		const info = this.parseModernSiCardDetectionMessage(message);
+		if (info === undefined) {
+			return undefined;
+		}
+		// if (info.cardSeries !== ModernSiCardSeries.SIAC) {
+		// TODO: find out the series value and remove this hack
+		if (info.cardNumber < 8000000 || info.cardNumber >= 9000000) {
+			return undefined;
+		}
+		return new this(info.cardNumber);
+	}
+}
+BaseSiCard.registerNumberRange(8000000, 9000000, SIAC);

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

@@ -0,0 +1,85 @@
+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 { SiCard10 } from './SiCard10';
+
+describe('SiCard10', () => {
+	test('is registered', () => {
+		expect(BaseSiCard.getTypeByCardNumber(6999999)).not.toEqual(SiCard10);
+		expect(BaseSiCard.getTypeByCardNumber(7000000)).toEqual(SiCard10);
+		expect(BaseSiCard.getTypeByCardNumber(7999999)).toEqual(SiCard10);
+		expect(BaseSiCard.getTypeByCardNumber(8000000)).not.toEqual(SiCard10);
+	});
+	describe('typeSpecificInstanceFromMessage', () => {
+		test('works for valid message', () => {
+			const instance = SiCard10.typeSpecificInstanceFromMessage({
+				command: proto.cmd.SI8_DET,
+				parameters: [0x00, 0x00, ModernSiCardSeries.SiCard10, 0x77, 0x77, 0x77]
+			});
+			if (instance === undefined) {
+				throw new Error('expect instance');
+			}
+			expect(instance instanceof SiCard10).toBe(true);
+			expect(instance.cardNumber).toBe(7829367);
+		});
+		test('returns undefined when message has mode', () => {
+			expect(
+				SiCard10.typeSpecificInstanceFromMessage({
+					mode: proto.NAK
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when message has wrong command', () => {
+			expect(
+				SiCard10.typeSpecificInstanceFromMessage({
+					command: testUtils.getRandomByteExcept([proto.cmd.SI8_DET]),
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when there are too few parameters', () => {
+			expect(
+				SiCard10.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI8_DET,
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when the series does not match', () => {
+			expect(
+				SiCard10.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI8_DET,
+					parameters: [0x00, 0x00, testUtils.getRandomByteExcept([ModernSiCardSeries.SiCard10]), 0x22, 0x22, 0x22]
+				})
+			).toBe(undefined);
+		});
+	});
+	test('is modern', (done) => {
+		const mySiCard10 = new SiCard10(8500000);
+		mySiCard10.mainStation = {
+			sendMessage: (message: siProtocol.SiMessage, numResponses?: number) => {
+				if (message.mode !== undefined) {
+					return Promise.reject(new Error('message mode is not undefined'));
+				}
+				const { command, parameters } = message;
+				expect(command).toBe(proto.cmd.GET_SI8);
+				expect(numResponses).toBe(1);
+				const pageNumberToGet = parameters[0];
+				const getPage = (pageNumber: number) => [...[0x00, 0x00, pageNumber], ..._.range(128).map(() => 0)];
+				return Promise.resolve([getPage(pageNumberToGet)]);
+			}
+		};
+		mySiCard10.typeSpecificRead().then(() => {
+			expect(mySiCard10.raceResult.cardNumber).toBe(0);
+			expect(JSON.stringify(mySiCard10.raceResult.startTime)).toBe(JSON.stringify({"time":0,"weekcounter":0,"weekday":0}));
+			expect(JSON.stringify(mySiCard10.raceResult.finishTime)).toBe(JSON.stringify({"time":0,"weekcounter":0,"weekday":0}));
+			expect(mySiCard10.raceResult.punches).toEqual([]);
+			expect(mySiCard10.punchCount).toBe(0);
+			done();
+		});
+	});
+});

package/src/SiCard/types/SiCard10.ts

@@ -0,0 +1,17 @@
+import type * as siProtocol from '../../siProtocol';
+import { ModernSiCard } from './ModernSiCard';
+import { BaseSiCard } from '../BaseSiCard';
+
+export class SiCard10 extends ModernSiCard {
+	static typeSpecificInstanceFromMessage(message: siProtocol.SiMessage): SiCard10 | undefined {
+		const info = this.parseModernSiCardDetectionMessage(message);
+		if (info === undefined) {
+			return undefined;
+		}
+		if (info.cardSeries !== 'SiCard10') {
+			return undefined;
+		}
+		return new this(info.cardNumber);
+	}
+}
+BaseSiCard.registerNumberRange(7000000, 8000000, SiCard10);

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

@@ -0,0 +1,84 @@
+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 { SiCard11 } from './SiCard11';
+
+describe('SiCard11', () => {
+	test('is registered', () => {
+		expect(BaseSiCard.getTypeByCardNumber(8999999)).not.toEqual(SiCard11);
+		expect(BaseSiCard.getTypeByCardNumber(9000000)).toEqual(SiCard11);
+		expect(BaseSiCard.getTypeByCardNumber(9999999)).toEqual(SiCard11);
+		expect(BaseSiCard.getTypeByCardNumber(10000000)).not.toEqual(SiCard11);
+	});
+	describe('typeSpecificInstanceFromMessage', () => {
+		test('works for valid message', () => {
+			const instance = SiCard11.typeSpecificInstanceFromMessage({
+				command: proto.cmd.SI8_DET,
+				parameters: [0x00, 0x00, /* TODO: */ 0x00, 0x98, 0x76, 0x54]
+			});
+			if (instance === undefined) {
+				throw new Error('expect instance');
+			}
+			expect(instance instanceof SiCard11).toBe(true);
+			expect(instance.cardNumber).toBe(9991764);
+		});
+		test('returns undefined when message has mode', () => {
+			expect(
+				SiCard11.typeSpecificInstanceFromMessage({
+					mode: proto.NAK
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when message has wrong command', () => {
+			expect(
+				SiCard11.typeSpecificInstanceFromMessage({
+					command: testUtils.getRandomByteExcept([proto.cmd.SI8_DET]),
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when there are too few parameters', () => {
+			expect(
+				SiCard11.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI8_DET,
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when the card number does not match', () => {
+			expect(
+				SiCard11.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI8_DET,
+					parameters: [0x00, 0x00, /* TODO: */ 0x00, 0x22, 0x22, 0x22]
+				})
+			).toBe(undefined);
+		});
+	});
+	test('is modern', (done) => {
+		const mySiCard11 = new SiCard11(8500000);
+		mySiCard11.mainStation = {
+			sendMessage: (message: siProtocol.SiMessage, numResponses?: number) => {
+				if (message.mode !== undefined) {
+					return Promise.reject(new Error('message mode is not undefined'));
+				}
+				const { command, parameters } = message;
+				expect(command).toBe(proto.cmd.GET_SI8);
+				expect(numResponses).toBe(1);
+				const pageNumberToGet = parameters[0];
+				const getPage = (pageNumber: number) => [...[0x00, 0x00, pageNumber], ..._.range(128).map(() => 0)];
+				return Promise.resolve([getPage(pageNumberToGet)]);
+			}
+		};
+		mySiCard11.typeSpecificRead().then(() => {
+			expect(mySiCard11.raceResult.cardNumber).toBe(0);
+			expect(JSON.stringify(mySiCard11.raceResult.startTime)).toBe(JSON.stringify({"time":0,"weekcounter":0,"weekday":0}));
+			expect(JSON.stringify(mySiCard11.raceResult.finishTime)).toBe(JSON.stringify({"time":0,"weekcounter":0,"weekday":0}));
+			expect(mySiCard11.raceResult.punches).toEqual([]);
+			expect(mySiCard11.punchCount).toBe(0);
+			done();
+		});
+	});
+});

package/src/SiCard/types/SiCard11.ts

@@ -0,0 +1,19 @@
+import type * as siProtocol from '../../siProtocol';
+import { ModernSiCard } from './ModernSiCard';
+import { BaseSiCard } from '../BaseSiCard';
+
+export class SiCard11 extends ModernSiCard {
+	static typeSpecificInstanceFromMessage(message: siProtocol.SiMessage): SiCard11 | undefined {
+		const info = this.parseModernSiCardDetectionMessage(message);
+		if (info === undefined) {
+			return undefined;
+		}
+		// if (info.cardSeries !== ModernSiCardSeries.SiCard11) {
+		// TODO: find out the series value and remove this hack
+		if (info.cardNumber < 9000000 || info.cardNumber >= 10000000) {
+			return undefined;
+		}
+		return new this(info.cardNumber);
+	}
+}
+BaseSiCard.registerNumberRange(9000000, 10000000, SiCard11);