sportident.js 1.0.0 → 1.0.2

package/src/siProtocol.ts

@@ -1,417 +0,0 @@
-import _ from 'lodash';
-import { proto } from './constants';
-import * as utils from './utils';
-import * as storage from './storage';
-import type { SiIntegerPartDefinition } from './storage/SiInt';
-
-export const SI_TIME_CUTOFF = 43200; // Half a day in seconds
-
-export const arr2date = (arr: number[], asOf?: Date): Date | undefined => {
-	utils.assertIsByteArr(arr);
-	utils.assertArrIsOfLengths(arr, [3, 6, 7]);
-	if (arr[0] > 99) {
-		console.warn(`arr2date: Invalid year: ${arr[0]}`);
-		return undefined;
-	}
-	if (arr[1] === 0) {
-		console.warn(`arr2date: Invalid month: ${arr[1]}`);
-		return undefined;
-	}
-	const maxYear = asOf ? asOf.getUTCFullYear() : new Date().getUTCFullYear();
-	const getYear = (lastTwoDigits: number): number => {
-		const maxLastTwo = maxYear % 100;
-		const maxRest = maxYear - maxLastTwo;
-		if (lastTwoDigits <= maxLastTwo) {
-			return lastTwoDigits + maxRest;
-		}
-		return lastTwoDigits + maxRest - 100;
-	};
-	const year = getYear(arr[0]);
-	const month = arr[1] - 1;
-	const day = arr[2];
-	const secs = arr.length < 6 ? 0 : utils.arr2big(arr.slice(4, 6));
-	const hours = arr.length < 6 ? 0 : (arr[3] & 0x01) * 12 + Math.floor(secs / 3600);
-	const minutes = arr.length < 6 ? 0 : Math.floor((secs % 3600) / 60);
-	const seconds = arr.length < 6 ? 0 : secs % 60;
-	const milliseconds = arr.length < 7 ? 0 : (arr[6] * 1000) / 256;
-	const date = new Date(year, month, day, hours, minutes, seconds, milliseconds);
-	const isValidDate =
-		date.getFullYear() === year &&
-		date.getMonth() === month &&
-		date.getDate() === day &&
-		date.getHours() === hours &&
-		date.getMinutes() === minutes &&
-		date.getSeconds() === seconds &&
-		date.getMilliseconds() === Math.floor(milliseconds);
-	if (!isValidDate) {
-		const rawDate = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
-		console.warn(`arr2date: Invalid date: ${date} (raw: ${rawDate})`);
-		return undefined;
-	}
-	return date;
-};
-
-export const date2arr = (dateTime: Date): number[] => {
-	const secs = (dateTime.getHours() % 12) * 3600 + dateTime.getMinutes() * 60 + dateTime.getSeconds();
-	return [
-		dateTime.getFullYear() % 100,
-		dateTime.getMonth() + 1,
-		dateTime.getDate(),
-		(dateTime.getDay() << 1) + Math.floor(dateTime.getHours() / 12),
-		secs >> 8,
-		secs & 0xff,
-		Math.floor((dateTime.getMilliseconds() * 256) / 1000)
-	];
-};
-
-export const arr2cardNumber = (arr: (number | undefined)[]): number | undefined => {
-	if (arr.some((byte) => byte === undefined)) {
-		return undefined;
-	}
-	utils.assertIsByteArr(arr);
-	utils.assertArrIsOfLengths(arr, [3, 4]);
-	let cardnum = (arr[1]! << 8) | arr[0]!;
-	const fourthSet = arr.length === 4 && arr[3]! !== 0x00;
-	if (fourthSet || 4 < arr[2]!) {
-		cardnum |= arr[2]! << 16;
-	} else {
-		cardnum += arr[2]! * 100000;
-	}
-	if (arr.length === 4) {
-		cardnum |= arr[3]! << 24;
-	}
-	return cardnum;
-};
-
-export const cardNumber2arr = (cardNumber: number | undefined): (number | undefined)[] => {
-	if (cardNumber === undefined) {
-		return [undefined, undefined, undefined, undefined];
-	}
-	const arr2 = cardNumber < 500000 ? Math.floor(cardNumber / 100000) & 0xff : (cardNumber >> 16) & 0xff;
-	const newCardNumber = cardNumber < 500000 ? cardNumber - arr2 * 100000 : cardNumber;
-	return [newCardNumber & 0xff, (newCardNumber >> 8) & 0xff, arr2, (newCardNumber >> 24) & 0xff];
-};
-
-export interface SiMessageWithMode {
-	mode: number;
-}
-
-export interface SiMessageWithoutMode {
-	mode?: undefined;
-	command: number;
-	parameters: number[];
-}
-
-export type SiMessage = SiMessageWithMode | SiMessageWithoutMode;
-
-export const prettyMessage = (message: SiMessage): string => {
-	if (message.mode !== undefined) {
-		const prettyMode = `Mode: ${utils.prettyHex([message.mode])} (${message.mode})\n`;
-		return `${prettyMode}`;
-	}
-	const prettyCommand = `Command: ${proto.cmdLookup[message.command]} ${utils.prettyHex([message.command])} (${message.command})\n`;
-	const prettyParameters = `Parameters: ${utils.prettyHex(message.parameters)} (${JSON.stringify(message.parameters)})`;
-	return `${prettyCommand}${prettyParameters}`;
-};
-
-export const CRC16 = (str: number[]): [number, number] => {
-	const CRC_POLYNOM = 0x8005;
-	const CRC_BITF = 0x8000;
-	if (str.length < 3) {
-		return [1 <= str.length ? str[0] : 0x00, 2 <= str.length ? str[1] : 0x00];
-	}
-	const s = str.length % 2 === 0 ? str.concat([0x00, 0x00]) : str.concat([0x00]);
-	let crc = s[0] * 0x100 + s[1];
-	for (let i = 2; i < s.length; i += 2) {
-		const c = s.slice(i, i + 2);
-		let val = c[0] * 0x100 + c[1];
-		for (let j = 0; j < 16; j++) {
-			if ((crc & CRC_BITF) !== 0) {
-				crc = crc << 1;
-				if ((val & CRC_BITF) !== 0) {
-					crc += 1;
-				}
-				crc = crc ^ CRC_POLYNOM;
-			} else {
-				crc = crc << 1;
-				if ((val & CRC_BITF) !== 0) {
-					crc += 1;
-				}
-			}
-			val = val << 1;
-		}
-		crc = crc & 0xffff;
-	}
-	return [crc >> 8, crc & 0xff];
-};
-
-export interface SiMessageParseResult {
-	message: SiMessage | null;
-	remainder: number[];
-}
-
-export const parse = (inputData: number[]): SiMessageParseResult => {
-	const failAndProceed = (numBytes: number): SiMessageParseResult => ({
-		message: null,
-		remainder: inputData.slice(numBytes)
-	});
-	const specialModeAndProceed = (mode: number, numBytes: number): SiMessageParseResult => ({
-		message: {
-			mode: mode
-		},
-		remainder: inputData.slice(numBytes)
-	});
-	if (inputData.length <= 0) {
-		return failAndProceed(0);
-	}
-	if (inputData[0] === proto.WAKEUP) {
-		return specialModeAndProceed(proto.WAKEUP, 1);
-	} else if (inputData[0] === proto.ACK) {
-		return specialModeAndProceed(proto.ACK, 1);
-	} else if (inputData[0] === proto.NAK) {
-		return specialModeAndProceed(proto.NAK, 1);
-	} else if (inputData[0] !== proto.STX) {
-		console.warn(`Invalid start byte: ${utils.prettyHex([inputData[0]])}`);
-		return failAndProceed(1);
-	}
-	if (inputData.length <= 1) {
-		return failAndProceed(0);
-	}
-	const command = inputData[1];
-	if (inputData.length <= 2) {
-		return failAndProceed(0);
-	}
-	const numParameters = inputData[2];
-	if (inputData.length <= 2 + numParameters) {
-		return failAndProceed(0);
-	}
-	const parameters = inputData.slice(3, 3 + numParameters);
-	if (inputData.length <= 4 + numParameters) {
-		return failAndProceed(0);
-	}
-	if (inputData.length <= 5 + numParameters) {
-		return failAndProceed(0);
-	}
-	if (inputData[5 + numParameters] !== proto.ETX) {
-		console.warn(`Invalid ETX byte: ${utils.prettyHex([inputData[5 + numParameters]])}`);
-		return failAndProceed(1);
-	}
-	const expectedCRC = CRC16(inputData.slice(1, 3 + numParameters));
-	const actualCRC = inputData.slice(3 + numParameters, 5 + numParameters);
-	if (!_.isEqual(actualCRC, expectedCRC)) {
-		console.warn(`Invalid CRC: ${utils.prettyHex(actualCRC)} (expected ${utils.prettyHex(expectedCRC)})`);
-		return failAndProceed(6 + numParameters);
-	}
-	return {
-		message: {
-			command: command,
-			parameters: parameters
-		},
-		remainder: inputData.slice(6 + numParameters)
-	};
-};
-
-export interface SiMessagesParseResult {
-	messages: SiMessage[];
-	remainder: number[];
-}
-
-export const parseAll = (inputData: number[]): SiMessagesParseResult => {
-	let currentRemainder = inputData;
-	const messages:SiMessage[] = [];
-	let remainderWasShrinking = true;
-	while (remainderWasShrinking) {
-		const { message, remainder: newRemainder } = parse(currentRemainder);
-		remainderWasShrinking = newRemainder.length < currentRemainder.length;
-		if (message) {
-			messages.push(message);
-		}
-		currentRemainder = newRemainder;
-	}
-	return {
-		messages: messages,
-		remainder: currentRemainder
-	};
-};
-
-export const render = (message: SiMessage): number[] => {
-	const renderCommand = (messageWithoutMode: SiMessageWithoutMode) => {
-		const commandString = [messageWithoutMode.command, messageWithoutMode.parameters.length, ...messageWithoutMode.parameters];
-		const crc = CRC16(commandString);
-		return [proto.STX, ...commandString, ...crc, proto.ETX] as number[];
-	};
-	if (message.mode === undefined) {
-		return renderCommand(message);
-	}
-	const renderFunctionsByMode: { [key: number]: () => number[] } = {
-		[proto.WAKEUP]: () => [proto.WAKEUP],
-		[proto.NAK]: () => [proto.NAK],
-		[proto.ACK]: () => [proto.ACK]
-	};
-	const renderFunction = renderFunctionsByMode[message.mode];
-	if (renderFunction === undefined) {
-		throw new Error(`Cannot render with mode ${utils.prettyHex([message.mode])}`);
-	}
-	return renderFunction();
-};
-
-export class SiDate extends storage.SiDataType<Date> implements storage.ISiDataType<Date> {
-	private readonly arrayField: storage.SiArray<number>;
-
-	constructor(public length: number, public getByteOffsetAtIndex: (index: number) => number) {
-		super();
-		this.arrayField = new storage.SiArray(length, (i) => new storage.SiInt([[getByteOffsetAtIndex(i)]]));
-	}
-
-	typeSpecificIsValueValid(_value: Date): boolean {
-		return true;
-	}
-
-	typeSpecificValueToString(value: Date): string {
-		const year = value.getFullYear();
-		const month = value.getMonth();
-		const day = value.getDate();
-		const hours = value.getHours();
-		const minutes = value.getMinutes();
-		const seconds = value.getSeconds();
-		const milliseconds = value.getMilliseconds();
-		return new Date(Date.UTC(year, month, day, hours, minutes, seconds, milliseconds)).toJSON();
-	}
-
-	typeSpecificValueFromString(string: string): Date | storage.ValueFromStringError {
-		const res = /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})\.([0-9]{3})Z$/.exec(string);
-		if (!res) {
-			return new storage.ValueFromStringError(`Not a correctly formatted date: ${string}`);
-		}
-		return new Date(Number(res[1]), Number(res[2]) - 1, Number(res[3]), Number(res[4]), Number(res[5]), Number(res[6]), Number(res[7]));
-	}
-
-	typeSpecificExtractFromData(data: storage.ISiStorageData): Date | undefined {
-		const dateArray = this.arrayField.typeSpecificExtractFromData(data);
-		if (dateArray === undefined || dateArray.some((byte: number | undefined) => byte === undefined)) {
-			return undefined;
-		}
-		return arr2date(dateArray as number[]);
-	}
-
-	typeSpecificUpdateData(data: storage.ISiStorageData, newValue: Date): storage.ISiStorageData {
-		const newArrayValue = date2arr(newValue).slice(0, this.arrayField.length);
-		return this.arrayField.typeSpecificUpdateData(data, newArrayValue);
-	}
-}
-
-export type SiTimestamp = {
-	time:number,
-	weekday?:number,
-	weekcounter?:number,
-} | null;
-
-export class SiTime extends storage.SiDataType<SiTimestamp> implements storage.ISiDataType<SiTimestamp> {
-	private readonly intFieldTime12: storage.SiInt | undefined
-	private readonly intFieldAmPm: storage.SiInt | undefined
-	private readonly intFieldDayOfWeek: storage.SiInt | undefined
-	private readonly intFieldWeekCounter: storage.SiInt | undefined
-
-	constructor(public byteStorage: [[number], [number], [number]] | [[number], [number]] | undefined) {
-		super();
-		if (byteStorage == undefined){
-			this.intFieldTime12 = undefined
-			this.intFieldAmPm = undefined
-			this.intFieldDayOfWeek = undefined
-			this.intFieldWeekCounter = undefined
-		}else if (byteStorage.length == 3){
-			this.intFieldTime12 = new storage.SiInt([byteStorage[0],byteStorage[1]])
-			this.intFieldAmPm = new storage.SiInt(_.map(byteStorage[2], (b:number):SiIntegerPartDefinition=>{
-				return [b,0,1] // offset, startbit, endbit
-			}))
-			this.intFieldDayOfWeek = new storage.SiInt(_.map(byteStorage[2], (b:number):SiIntegerPartDefinition=>{
-				return [b,1,4] // offset, startbit, endbit
-			}))
-			this.intFieldWeekCounter = new storage.SiInt(_.map(byteStorage[2], (b:number):SiIntegerPartDefinition=>{
-				return [b,4,6] // offset, startbit, endbit
-			}))
-		}else if (byteStorage.length == 2){
-			this.intFieldTime12 = new storage.SiInt(byteStorage)
-			this.intFieldAmPm = undefined
-			this.intFieldDayOfWeek = undefined
-			this.intFieldWeekCounter = undefined
-		}
-	}
-
-	typeSpecificIsValueValid(value: SiTimestamp): boolean {
-		return value === null || 
-		(value.time <= 86400 &&
-			(value.weekday == undefined || (value.weekday >=0 && value.weekday < 7)) &&
-			(value.weekcounter == undefined || (value.weekcounter >=0 && value.weekcounter < 4))
-		)
-	}
-
-	typeSpecificValueToString(value: SiTimestamp): string {
-		if (value === null) {
-			return 'NO_TIME';
-		}
-		const hours = Math.floor(value.time / 3600)
-		const minutes = Math.floor(value.time/60)%60
-		const seconds = value.time % 60
-		const hoursStr = `${hours}`.padStart(2, '0');
-		const minutesStr = `${minutes}`.padStart(2, '0');
-		const secondsStr = `${seconds}`.padStart(2, '0');
-		return `${hoursStr}:${minutesStr}:${secondsStr}`;
-	}
-
-	typeSpecificValueFromString(string: string): SiTimestamp | storage.ValueFromStringError {
-		if (string === 'NO_TIME') {
-			return null;
-		}
-		const res = /^([0-9]{2}):([0-9]{2}):([0-9]{2})$/.exec(string);
-		if (!res) {
-			return new storage.ValueFromStringError(`Not a correctly formatted date: ${string}`);
-		}
-		
-		return {
-			time: Number(res[1]) * 3600 + Number(res[2]) * 60 + Number(res[3]), 
-		};
-	}
-
-	typeSpecificExtractFromData(data: storage.ISiStorageData): SiTimestamp | undefined {
-		if (this.intFieldTime12 === undefined) {
-			return null;
-		}
-		let timeInt = this.intFieldTime12.typeSpecificExtractFromData(data);
-		if (timeInt === proto.NO_TIME) {
-			return null;
-		}
-		if (timeInt === undefined || timeInt > 86400) {
-			return undefined;
-		}
-		
-		const amPm = this.intFieldAmPm === undefined?undefined:this.intFieldAmPm.typeSpecificExtractFromData(data)
-		const weekcounter = this.intFieldWeekCounter === undefined?undefined:this.intFieldWeekCounter.typeSpecificExtractFromData(data)
-		const weekday = this.intFieldDayOfWeek === undefined?undefined:this.intFieldDayOfWeek.typeSpecificExtractFromData(data)
-
-		if (amPm != undefined && amPm == 1){
-			timeInt += 43200;
-		}
-
-		return {time: timeInt, weekcounter: weekcounter, weekday: weekday}
-	}
-
-	typeSpecificUpdateData(data: storage.ISiStorageData, newValue: SiTimestamp): storage.ISiStorageData {
-		if (this.intFieldTime12 === undefined) {
-			return data;
-		}
-		const newIntValue = newValue === null ? proto.NO_TIME : newValue.time;
-		let tempData = this.intFieldTime12.typeSpecificUpdateData(data, newIntValue);
-		if (this.intFieldAmPm !== undefined && newValue != null) {
-			tempData = this.intFieldAmPm.typeSpecificUpdateData(tempData, newValue.time >= 43200?1:0)
-		}
-		if (this.intFieldDayOfWeek !== undefined && newValue != null && newValue.weekday !== undefined) {
-			tempData = this.intFieldDayOfWeek.typeSpecificUpdateData(tempData, newValue.weekday)
-		}
-		if (this.intFieldWeekCounter !== undefined && newValue != null && newValue.weekcounter !== undefined) {
-			tempData = this.intFieldWeekCounter.typeSpecificUpdateData(tempData, newValue.weekcounter)
-		}
-
-		return tempData
-	}
-}

package/src/storage/SiArray.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import _ from 'lodash';
-import Immutable from 'immutable';
-import { type ISiStorageData, ValueFromStringError } from './interfaces';
-import { ModifyUndefinedException, SiDataType } from './SiDataType';
-import { SiFieldValue } from './SiFieldValue';
-import { SiArray } from './SiArray';
-
-describe('SiArray', () => {
-	class FakeDataType extends SiDataType<string> {
-		constructor(public index: number) {
-			super();
-		}
-
-		typeSpecificIsValueValid(_value: string) {
-			return true;
-		}
-
-		typeSpecificValueFromString(str: string): string | ValueFromStringError | never {
-			return str.substr(2, str.length - 2);
-		}
-
-		typeSpecificValueToString(value: string): string {
-			return `->${value}<-`;
-		}
-
-		typeSpecificExtractFromData(data: ISiStorageData): string | undefined {
-			const byte = data.get(this.index);
-			if (byte === undefined) {
-				return undefined;
-			}
-			return String.fromCharCode(byte);
-		}
-
-		typeSpecificUpdateData(data: ISiStorageData, newValue: string): ISiStorageData {
-			const byte = data.get(this.index);
-			if (byte === undefined) {
-				throw new ModifyUndefinedException();
-			}
-			return data.set(this.index, newValue.charCodeAt(0));
-		}
-	}
-	const mySiArray = new SiArray(3, (i) => new FakeDataType(i));
-	const fieldValueOf = (arrayValue: string[]): SiFieldValue<(string | undefined)[]> => new SiFieldValue(mySiArray, arrayValue);
-	test('typeSpecificIsValueValid', () => {
-		expect(mySiArray.isValueValid([])).toBe(true);
-		expect(mySiArray.isValueValid([''])).toBe(true);
-	});
-	test('valueToString', () => {
-		expect(mySiArray.valueToString([])).toBe('');
-		expect(mySiArray.valueToString(['test'])).toBe('->test<-');
-		expect(mySiArray.valueToString(['test', '1234'])).toBe('->test<-, ->1234<-');
-		expect(mySiArray.valueToString(['test', undefined])).toBe('->test<-, ?');
-	});
-	test('valueFromString', () => {
-		expect(mySiArray.valueFromString('->test<-') instanceof ValueFromStringError).toBe(true);
-		expect(mySiArray.valueFromString('->test<-, ->1234<-') instanceof ValueFromStringError).toBe(true);
-		expect(mySiArray.valueFromString('test') instanceof ValueFromStringError).toBe(true);
-	});
-	test('extractFromData gives field value', () => {
-		const data = Immutable.List([0x41, 0x42, 0x43]);
-		const fieldValue = mySiArray.extractFromData(data);
-		expect(fieldValue instanceof SiFieldValue).toBe(true);
-		expect(fieldValue!.field).toBe(mySiArray);
-		expect(fieldValue!.value).toEqual(['A', 'B', 'C']);
-	});
-	test('extractFromData', () => {
-		const getExtractedFieldValue = (bytes: (number | undefined)[]) => mySiArray.extractFromData(Immutable.List(bytes));
-
-		expect(getExtractedFieldValue([0x61, 0x62, 0x63])!.value).toEqual(['a', 'b', 'c']);
-		expect(getExtractedFieldValue([undefined, 0x62, 0x63])!.value).toEqual([undefined, 'b', 'c']);
-		expect(getExtractedFieldValue([0x61, undefined, 0x63])!.value).toEqual(['a', undefined, 'c']);
-		expect(getExtractedFieldValue([0x61, 0x62, undefined])!.value).toEqual(['a', 'b', undefined]);
-		expect(getExtractedFieldValue([0x61, 0x62])!.value).toEqual(['a', 'b', undefined]);
-		expect(getExtractedFieldValue([0x61])!.value).toEqual(['a', undefined, undefined]);
-		expect(getExtractedFieldValue([])!.value).toEqual([undefined, undefined, undefined]);
-	});
-	test('updateData', () => {
-		const initialData = Immutable.List([0x00, 0x00, 0x00]);
-		const updateInitialData = (newValue: (string | undefined)[] | SiFieldValue<(string | undefined)[]>) => mySiArray.updateData(initialData, newValue).toJS();
-
-		expect(updateInitialData(['x', 'y', 'z'])).toEqual([0x78, 0x79, 0x7a]);
-		expect(updateInitialData(['x', 'y'])).toEqual([0x78, 0x79, 0x00]);
-		expect(updateInitialData(['x'])).toEqual([0x78, 0x00, 0x00]);
-		expect(updateInitialData([])).toEqual([0x00, 0x00, 0x00]);
-		expect(updateInitialData(['x', 'y', 'z', 'a'])).toEqual([0x78, 0x79, 0x7a]);
-		expect(updateInitialData(fieldValueOf(['x', 'y', 'z']))).toEqual([0x78, 0x79, 0x7a]);
-	});
-
-	const updateData = (data: (number | undefined)[], newValue: (string | undefined)[] | SiFieldValue<(string | undefined)[]>) => mySiArray.updateData(Immutable.List(data), newValue).toJS();
-	test('updateData modify undefined', () => {
-		expect(() => updateData([], ['x', 'y', 'z'])).toThrow(ModifyUndefinedException);
-		expect(() => updateData([], ['x'])).toThrow(ModifyUndefinedException);
-		expect(() => updateData([], fieldValueOf(['x']))).toThrow(ModifyUndefinedException);
-		expect(() => updateData([undefined, 0x00, 0x00], ['x', 'y', 'z'])).toThrow(ModifyUndefinedException);
-		expect(() => updateData([0x00, undefined, 0x00], ['x', 'y', 'z'])).toThrow(ModifyUndefinedException);
-		expect(() => updateData([0x00, 0x00, undefined], ['x', 'y', 'z'])).toThrow(ModifyUndefinedException);
-		expect(() => updateData([0x78, undefined, undefined], ['x', 'y'])).toThrow(ModifyUndefinedException);
-	});
-	test('updateData with undefined data', () => {
-		expect(updateData([0x00, 0x00, 0x00], ['x', undefined, 'z'])).toEqual([0x78, 0x00, 0x7a]);
-	});
-});

package/src/storage/SiArray.ts

@@ -1,56 +0,0 @@
-import _ from 'lodash';
-import { type ISiDataType, type ISiStorageData, ValueFromStringError } from './interfaces';
-import { SiDataType } from './SiDataType';
-
-export type SiArrayValue<T> = (T | undefined)[];
-
-export class SiArray<T> extends SiDataType<SiArrayValue<T>> implements ISiDataType<SiArrayValue<T>> {
-	constructor(public length: number, public getDefinitionAtIndex: (index: number) => ISiDataType<T>) {
-		super();
-	}
-
-	typeSpecificIsValueValid(_value: SiArrayValue<T>): boolean {
-		return true;
-	}
-
-	typeSpecificValueToString(value: SiArrayValue<T>): string {
-		return value
-			.map((itemValue, index) => {
-				if (itemValue === undefined) {
-					return '?';
-				}
-				const definition = this.getDefinitionAtIndex(index);
-				return definition.valueToString(itemValue);
-			})
-			.join(', ');
-	}
-
-	typeSpecificValueFromString(_string: string): ValueFromStringError {
-		return new ValueFromStringError(`${this.constructor.name} does not support string parsing`);
-	}
-
-	typeSpecificExtractFromData(data: ISiStorageData): SiArrayValue<T> | undefined {
-		const arrayValue = _.range(this.length).map((index) => {
-			const definition = this.getDefinitionAtIndex(index);
-			const itemFieldValue = definition.extractFromData(data);
-			if (itemFieldValue === undefined) {
-				return undefined;
-			}
-			return itemFieldValue.value;
-		});
-		return arrayValue;
-	}
-
-	typeSpecificUpdateData(data: ISiStorageData, newValue: SiArrayValue<T>): ISiStorageData {
-		const updateLength = Math.min(newValue.length, this.length);
-		let tempData = data;
-		_.range(updateLength).forEach((index) => {
-			const definition = this.getDefinitionAtIndex(index);
-			const newItemValue = newValue[index];
-			if (newItemValue !== undefined) {
-				tempData = definition.updateData(tempData, newItemValue);
-			}
-		});
-		return tempData;
-	}
-}

package/src/storage/SiBool.test.ts

@@ -1,81 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import _ from 'lodash';
-import Immutable from 'immutable';
-import { ValueFromStringError } from './interfaces';
-import { ModifyUndefinedException } from './SiDataType';
-import { SiFieldValue } from './SiFieldValue';
-import { SiBool } from './SiBool';
-
-describe('SiBool', () => {
-	const mySiBool = new SiBool(0x00, 4);
-	const myOtherSiBool = new SiBool(0x00);
-	const fieldValueOf = (boolValue: boolean): SiFieldValue<boolean> => new SiFieldValue(mySiBool, boolValue);
-	test('typeCheckValue', () => {
-		expect(mySiBool.isValueValid(false)).toBe(true);
-		expect(mySiBool.isValueValid(true)).toBe(true);
-	});
-	test('valueToString', () => {
-		expect(mySiBool.valueToString(false)).toBe('false');
-		expect(mySiBool.valueToString(true)).toBe('true');
-	});
-	test('valueFromString', () => {
-		expect(mySiBool.valueFromString('false')).toBe(false);
-		expect(mySiBool.valueFromString('true')).toBe(true);
-		expect(mySiBool.valueFromString('test') instanceof ValueFromStringError).toBe(true);
-	});
-	test('extractFromData gives field value', () => {
-		const data = Immutable.List([0x00]);
-		const fieldValue = mySiBool.extractFromData(data);
-		expect(fieldValue instanceof SiFieldValue).toBe(true);
-		expect(fieldValue!.field).toBe(mySiBool);
-		expect(fieldValue!.value).toBe(false);
-	});
-	test('extractFromData', () => {
-		const getExtractedFieldValue = (bytes: (number | undefined)[]) => mySiBool.extractFromData(Immutable.List(bytes));
-
-		expect(getExtractedFieldValue([0x00])!.value).toBe(false);
-		expect(getExtractedFieldValue([0x10])!.value).toBe(true);
-		expect(getExtractedFieldValue([0xff])!.value).toBe(true);
-		expect(getExtractedFieldValue([undefined])).toBe(undefined);
-		expect(getExtractedFieldValue([])).toBe(undefined);
-	});
-	test('extractFromData other', () => {
-		const getExtractedFieldValue = (bytes: (number | undefined)[]) => myOtherSiBool.extractFromData(Immutable.List(bytes));
-
-		expect(getExtractedFieldValue([0x00])!.value).toBe(false);
-		expect(getExtractedFieldValue([0x01])!.value).toBe(true);
-		expect(getExtractedFieldValue([0xff])!.value).toBe(true);
-		expect(getExtractedFieldValue([undefined])).toBe(undefined);
-		expect(getExtractedFieldValue([])).toBe(undefined);
-	});
-	test('updateData', () => {
-		const updateData = (data: (number | undefined)[], newValue: boolean | SiFieldValue<boolean>) => mySiBool.updateData(Immutable.List(data), newValue).toJS();
-
-		expect(updateData([0x10], false)).toEqual([0x00]);
-		expect(updateData([0xff], false)).toEqual([0xef]);
-		expect(updateData([0x00], true)).toEqual([0x10]);
-		expect(updateData([0xef], true)).toEqual([0xff]);
-		expect(updateData([0x10], fieldValueOf(false))).toEqual([0x00]);
-		expect(updateData([0x00], fieldValueOf(true))).toEqual([0x10]);
-	});
-	test('updateData other', () => {
-		const updateData = (data: (number | undefined)[], newValue: boolean | SiFieldValue<boolean>) => myOtherSiBool.updateData(Immutable.List(data), newValue).toJS();
-
-		expect(updateData([0x01], false)).toEqual([0x00]);
-		expect(updateData([0xff], false)).toEqual([0xfe]);
-		expect(updateData([0x00], true)).toEqual([0x01]);
-		expect(updateData([0xfe], true)).toEqual([0xff]);
-		expect(updateData([0x01], fieldValueOf(false))).toEqual([0x00]);
-		expect(updateData([0x00], fieldValueOf(true))).toEqual([0x01]);
-	});
-	test('updateData modify undefined', () => {
-		const updateData = (data: (number | undefined)[], newValue: boolean | SiFieldValue<boolean>) => mySiBool.updateData(Immutable.List(data), newValue).toJS();
-
-		expect(() => updateData([], false)).toThrow(ModifyUndefinedException);
-		expect(() => updateData([], true)).toThrow(ModifyUndefinedException);
-		expect(() => updateData([], fieldValueOf(false))).toThrow(ModifyUndefinedException);
-		expect(() => updateData([], fieldValueOf(true))).toThrow(ModifyUndefinedException);
-		expect(() => updateData([undefined], false)).toThrow(ModifyUndefinedException);
-		expect(() => updateData([undefined], true)).toThrow(ModifyUndefinedException);
-	});
-});