sportident.js 1.0.0

package/src/storage/SiBool.ts

@@ -0,0 +1,47 @@
+import _ from 'lodash';
+import { type ISiDataType, type ISiStorageData, ValueFromStringError } from './interfaces';
+import { ModifyUndefinedException, SiDataType } from './SiDataType';
+
+export class SiBool extends SiDataType<boolean> implements ISiDataType<boolean> {
+	constructor(private byteOffset: number, private bitOffset: number = 0) {
+		super();
+	}
+
+	typeSpecificIsValueValid(_value: boolean): boolean {
+		return true;
+	}
+
+	typeSpecificValueToString(value: boolean): string {
+		return value ? 'true' : 'false';
+	}
+
+	typeSpecificValueFromString(string: string): boolean | ValueFromStringError {
+		const valueByString: { [key: string]: boolean } = {
+			true: true,
+			false: false
+		};
+		if (valueByString[string] === undefined) {
+			return new ValueFromStringError(`Value for ${this.constructor.name} must be "true" or "false", not "${string}"`);
+		}
+		return valueByString[string];
+	}
+
+	typeSpecificExtractFromData(data: ISiStorageData): boolean | undefined {
+		const existingByte = data.get(this.byteOffset);
+		if (existingByte === undefined) {
+			return undefined;
+		}
+		return ((existingByte >> this.bitOffset) & 0x01) === 0x01;
+	}
+
+	typeSpecificUpdateData(data: ISiStorageData, newValue: boolean): ISiStorageData {
+		const boolAsInt = newValue ? 0x01 : 0x00;
+		const preservationMask = (0x01 << this.bitOffset) ^ 0xff;
+		const existingByte = data.get(this.byteOffset);
+		if (existingByte === undefined) {
+			throw new ModifyUndefinedException();
+		}
+		const newByte = (existingByte & preservationMask) | (boolAsInt << this.bitOffset);
+		return data.set(this.byteOffset, newByte);
+	}
+}

package/src/storage/SiDataType.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import Immutable from 'immutable';
+import { type ISiStorageData, ValueFromStringError } from './interfaces';
+import { SiFieldValue } from './SiFieldValue';
+import { SiDataType } from './SiDataType';
+
+describe('SiDataType', () => {
+	class MyType extends SiDataType<number> {
+		typeSpecificIsValueValid(value: number): boolean {
+			return _.isInteger(value);
+		}
+
+		typeSpecificValueToString(value: number): string {
+			return `->${value}<-`;
+		}
+
+		typeSpecificValueFromString(string: string): number | ValueFromStringError {
+			const res = /^->(.*)<-$/.exec(string);
+			if (!res) {
+				return new ValueFromStringError();
+			}
+			return parseInt(res[1], 10);
+		}
+
+		typeSpecificExtractFromData(data: ISiStorageData): number | undefined {
+			const byte = data.get(0);
+			if (byte === undefined) {
+				return undefined;
+			}
+			return byte;
+		}
+
+		typeSpecificUpdateData(data: ISiStorageData, newValue: number): ISiStorageData {
+			return data.set(0, newValue);
+		}
+	}
+	const myField = new MyType();
+	const fieldValueOf = (intValue: number): SiFieldValue<number> => new SiFieldValue(myField, intValue);
+	test('valueToString', () => {
+		expect(myField.valueToString(41)).toBe('->41<-');
+	});
+	test('valueFromString', () => {
+		expect(myField.valueFromString('->41<-')).toBe(41);
+		expect(myField.valueFromString('41') instanceof ValueFromStringError).toBe(true);
+	});
+	test('extractFromData', () => {
+		const getExtractedFieldValue = (field: SiDataType<number>, bytes: (number | undefined)[]) => field.extractFromData(Immutable.List(bytes));
+
+		expect(getExtractedFieldValue(myField, [0x61])!.value).toBe(0x61);
+		expect(getExtractedFieldValue(myField, [undefined])).toBe(undefined);
+		expect(getExtractedFieldValue(myField, [])).toBe(undefined);
+	});
+	test('updateData', () => {
+		const updateData = (field: SiDataType<number>, data: number[], newValue: number | SiFieldValue<number>): number[] => field.updateData(Immutable.List(data), newValue).toJS() as number[];
+
+		expect(updateData(myField, [0x00], 0x61)).toEqual([0x61]);
+		expect(updateData(myField, [0x00], fieldValueOf(0x61))).toEqual([0x61]);
+	});
+	//
+	// test('SiStorage plain SiDataType', () => {
+	//     class WeirdStorage extends SiStorage {
+	//         public static size = 0x01;
+	//         public static definitions = {
+	//             wtf: new MyType(),
+	//         };
+	//     }
+	//
+	//     const myWeirdStorage = new WeirdStorage(
+	//         utils.unPrettyHex('00'),
+	//     );
+	//
+	//     expect(() => myWeirdStorage.get('wtf')).toThrow();
+	//     expect(() => myWeirdStorage.set('wtf', 0xFFFFFFFF)).toThrow();
+	//     expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('00'));
+	//
+	//     expect(myWeirdStorage.get('inexistent')).toBe(undefined);
+	//     myWeirdStorage.set('inexistent', 0xFFFFFFFF);
+	//     expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('00'));
+	// });
+});

package/src/storage/SiDataType.ts

@@ -0,0 +1,60 @@
+import _ from 'lodash';
+import { type ISiStorageData, ValueToStringError, ValueFromStringError } from './interfaces';
+import { SiFieldValue } from './SiFieldValue';
+
+export class ModifyUndefinedException {
+	// eslint-disable-next-line no-useless-constructor
+	constructor(
+		public message: string = '' // eslint-disable-next-line no-empty-function
+	) {}
+}
+
+export abstract class SiDataType<T> {
+	isValueValid(value: T): boolean {
+		return this.typeSpecificIsValueValid(value);
+	}
+
+	abstract typeSpecificIsValueValid(_value: T): boolean | never;
+
+	valueToString(value: T): string | ValueToStringError {
+		if (!this.isValueValid(value)) {
+			return new ValueToStringError(`Value "${value}" is invalid`);
+		}
+		return this.typeSpecificValueToString(value);
+	}
+
+	abstract typeSpecificValueToString(_value: T): string | ValueToStringError | never;
+
+	valueFromString(string: string): T | ValueFromStringError {
+		const value = this.typeSpecificValueFromString(string);
+		if (value instanceof ValueFromStringError) {
+			return value;
+		}
+		if (!this.isValueValid(value)) {
+			return new ValueFromStringError(`Value "${value}" is invalid`);
+		}
+		return value;
+	}
+
+	abstract typeSpecificValueFromString(_string: string): T | ValueFromStringError | never;
+
+	extractFromData(data: ISiStorageData): SiFieldValue<T> | undefined {
+		const extractedValue = this.typeSpecificExtractFromData(data);
+		if (extractedValue === undefined) {
+			return undefined;
+		}
+		return new SiFieldValue(this, extractedValue);
+	}
+
+	abstract typeSpecificExtractFromData(_data: ISiStorageData): T | undefined | never;
+
+	updateData(data: ISiStorageData, newValue: T | SiFieldValue<T>): ISiStorageData {
+		const valueForUpdate = newValue instanceof SiFieldValue ? newValue.value : newValue;
+		if (!this.typeSpecificIsValueValid(valueForUpdate as T)) {
+			throw new TypeError();
+		}
+		return this.typeSpecificUpdateData(data, valueForUpdate as T);
+	}
+
+	abstract typeSpecificUpdateData(data: ISiStorageData, _newValue: T): ISiStorageData | never;
+}

package/src/storage/SiDict.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import Immutable from 'immutable';
+import { type ISiStorageData, ValueToStringError, ValueFromStringError } from './interfaces';
+import { ModifyUndefinedException, SiDataType } from './SiDataType';
+import { SiFieldValue } from './SiFieldValue';
+import { SiDict, type SiDictValue } from './SiDict';
+
+type FakeSiStorageData = (number | undefined)[];
+
+describe('SiDict', () => {
+	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) {
+			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 mySiDict = new SiDict({
+		One: new FakeDataType(0x00),
+		Other: new FakeDataType(0x01)
+	});
+	type MySiDictType = { One: string; Other: string };
+	const fieldValueOf = (value: SiDictValue<MySiDictType>): SiFieldValue<SiDictValue<MySiDictType>> => new SiFieldValue(mySiDict, value);
+	test('typeCheckValue', () => {
+		expect(mySiDict.isValueValid({ One: 'A', Other: 'B' })).toBe(true);
+		expect(mySiDict.isValueValid({ One: 'A', Other: undefined })).toBe(false);
+	});
+	test('valueToString', () => {
+		expect(mySiDict.valueToString({ One: 'A', Other: 'B' })).toBe('One: ->A<-, Other: ->B<-');
+		expect(mySiDict.valueToString({ One: 'Y', Other: 'Z' })).toBe('One: ->Y<-, Other: ->Z<-');
+		expect(mySiDict.valueToString({ One: 'Y', Other: undefined }) instanceof ValueToStringError).toBe(true);
+	});
+	test('typeSpecificValueToString handles edge case', () => {
+		expect(mySiDict.typeSpecificValueToString({ One: 'Y', Other: undefined })).toBe('One: ->Y<-, Other: ?');
+	});
+	test('valueFromString', () => {
+		expect(mySiDict.valueFromString('One: ->A<-, Other: ->B<-') instanceof ValueFromStringError).toBe(true);
+		expect(mySiDict.valueFromString('One: ->Y<-, Other: ->Z<-') instanceof ValueFromStringError).toBe(true);
+		expect(mySiDict.valueFromString('test') instanceof ValueFromStringError).toBe(true);
+	});
+	test('extractFromData gives field value', () => {
+		const data = Immutable.List([0x41, 0x42]);
+		const fieldValue = mySiDict.extractFromData(data);
+		expect(fieldValue instanceof SiFieldValue).toBe(true);
+		expect(fieldValue!.field).toBe(mySiDict);
+		expect(fieldValue!.value).toEqual({ One: 'A', Other: 'B' });
+	});
+	test('extractFromData', () => {
+		const getExtractedFieldValue = (bytes: (number | undefined)[]) => mySiDict.extractFromData(Immutable.List(bytes));
+
+		expect(getExtractedFieldValue([0x61, 0x62])!.value).toEqual({ One: 'a', Other: 'b' });
+		expect(getExtractedFieldValue([undefined, 0x62])!.value).toEqual({
+			One: undefined,
+			Other: 'b'
+		});
+		expect(getExtractedFieldValue([0x61, undefined])!.value).toEqual({
+			One: 'a',
+			Other: undefined
+		});
+		expect(getExtractedFieldValue([0x61])!.value).toEqual({ One: 'a', Other: undefined });
+		expect(getExtractedFieldValue([])!.value).toEqual({ One: undefined, Other: undefined });
+	});
+	test('updateData', () => {
+		const initialData = Immutable.List([0x00, 0x00]);
+		const updateInitialData = (newValue: SiDictValue<MySiDictType> | SiFieldValue<SiDictValue<MySiDictType>>): FakeSiStorageData => mySiDict.updateData(initialData, newValue).toJS();
+
+		expect(updateInitialData({ One: 'a', Other: 'b' })).toEqual([0x61, 0x62]);
+		expect(updateInitialData({ One: 'y', Other: 'z' })).toEqual([0x79, 0x7a]);
+		expect(updateInitialData(fieldValueOf({ One: 'a', Other: 'b' }))).toEqual([0x61, 0x62]);
+	});
+	test('updateData modify undefined', () => {
+		const updateData = (data: FakeSiStorageData, newValue: SiDictValue<MySiDictType> | SiFieldValue<SiDictValue<MySiDictType>>): FakeSiStorageData =>
+			mySiDict.updateData(Immutable.List(data), newValue).toJS();
+
+		expect(() => updateData([], { One: 'a', Other: 'b' })).toThrow(ModifyUndefinedException);
+		expect(() => updateData([], { One: 'a', Other: 'b' })).toThrow(ModifyUndefinedException);
+		expect(() => updateData([], fieldValueOf({ One: 'a', Other: 'b' }))).toThrow(ModifyUndefinedException);
+		expect(() => updateData([undefined, 0x00], { One: 'a', Other: 'b' })).toThrow(ModifyUndefinedException);
+		expect(() => updateData([0x00, undefined], { One: 'a', Other: 'b' })).toThrow(ModifyUndefinedException);
+		expect(() => updateData([0x00], fieldValueOf({ One: 'a', Other: 'b' }))).toThrow(ModifyUndefinedException);
+	});
+	test('updateData wrong type', () => {
+		const initialData = Immutable.List([0x00, 0x00]);
+		const updatingInitialData = (newValue: SiDictValue<MySiDictType>) => () => mySiDict.updateData(initialData, newValue);
+
+		expect(updatingInitialData({ One: undefined, Other: 'A' })).toThrow(TypeError);
+	});
+});

package/src/storage/SiDict.ts

@@ -0,0 +1,60 @@
+import { type ISiDataType, type ISiStorageData, ValueFromStringError } from './interfaces';
+import { SiDataType } from './SiDataType';
+
+export type SiDictValue<T> = { [key in keyof T]: T[key] | undefined };
+export type SiPartialDictValue<T> = { [key in keyof T]?: T[key] };
+
+export class SiDict<T> extends SiDataType<SiDictValue<T>> implements ISiDataType<SiDictValue<T>> {
+	constructor(public readonly definitionDict: { [key in keyof T]: ISiDataType<T[key]> }) {
+		super();
+	}
+
+	typeSpecificIsValueValid(value: SiDictValue<T>): boolean {
+		return this.keysOfT.every((key) => value[key] !== undefined);
+	}
+
+	typeSpecificValueToString(value: SiDictValue<T>): string {
+		return this.keysOfT
+			.map((key) => {
+				const definition = this.definitionDict[key];
+				const itemValue = value[key];
+				if (itemValue === undefined) {
+					return `${String(key)}: ?`;
+				}
+				// @ts-ignore
+				const itemValueString = definition.valueToString(itemValue);
+				return `${String(key)}: ${itemValueString}`;
+			})
+			.join(', ');
+	}
+
+	typeSpecificValueFromString(_string: string): ValueFromStringError {
+		return new ValueFromStringError(`${this.constructor.name} does not support string parsing`);
+	}
+
+	typeSpecificExtractFromData(data: ISiStorageData): SiDictValue<T> {
+		const dictValue: SiPartialDictValue<T> = {};
+		this.keysOfT.forEach((key) => {
+			const definition = this.definitionDict[key];
+			const itemFieldValue = definition.extractFromData(data);
+			if (itemFieldValue === undefined) {
+				return;
+			}
+			dictValue[key] = itemFieldValue.value;
+		});
+		return dictValue as SiDictValue<T>;
+	}
+
+	typeSpecificUpdateData(data: ISiStorageData, newValue: SiDictValue<T>): ISiStorageData {
+		let tempData = data;
+		this.keysOfT.forEach((key) => {
+			const definition = this.definitionDict[key];
+			tempData = definition.updateData(tempData, newValue[key]!);
+		});
+		return tempData;
+	}
+
+	get keysOfT(): (keyof T)[] {
+		return Object.keys(this.definitionDict) as (keyof T)[];
+	}
+}

package/src/storage/SiEnum.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import Immutable from 'immutable';
+import { ValueFromStringError } from './interfaces';
+import { SiFieldValue } from './SiFieldValue';
+import { ModifyUndefinedException } from './SiDataType';
+import { SiEnum } from './SiEnum';
+
+type FakeSiStorageData = (number | undefined)[];
+
+describe('SiEnum', () => {
+	const options = { Zero: 0x0, One: 0x1, Two: 0x2, Three: 0x3 };
+	const mySiEnum = new SiEnum([[0x00, 4, 6]], options);
+	type MySiEnumType = keyof typeof options;
+	const fieldValueOf = (value: MySiEnumType): SiFieldValue<MySiEnumType> => new SiFieldValue(mySiEnum, value);
+	test('typeCheckValue', () => {
+		expect(mySiEnum.isValueValid('Zero')).toBe(true);
+		expect(mySiEnum.isValueValid('One')).toBe(true);
+		expect(mySiEnum.isValueValid('Two')).toBe(true);
+		expect(mySiEnum.isValueValid('Three')).toBe(true);
+	});
+	test('valueToString', () => {
+		expect(mySiEnum.valueToString('Zero')).toBe('Zero');
+		expect(mySiEnum.valueToString('One')).toBe('One');
+		expect(mySiEnum.valueToString('Two')).toBe('Two');
+		expect(mySiEnum.valueToString('Three')).toBe('Three');
+	});
+	test('valueFromString', () => {
+		expect(mySiEnum.valueFromString('Zero')).toBe('Zero');
+		expect(mySiEnum.valueFromString('One')).toBe('One');
+		expect(mySiEnum.valueFromString('Two')).toBe('Two');
+		expect(mySiEnum.valueFromString('Three')).toBe('Three');
+		expect(mySiEnum.valueFromString('0') instanceof ValueFromStringError).toBe(true);
+		expect(mySiEnum.valueFromString('1') instanceof ValueFromStringError).toBe(true);
+		expect(mySiEnum.valueFromString('255') instanceof ValueFromStringError).toBe(true);
+		expect(mySiEnum.valueFromString('-1') instanceof ValueFromStringError).toBe(true);
+		expect(mySiEnum.valueFromString('test') instanceof ValueFromStringError).toBe(true);
+	});
+	test('extractFromData gives field value', () => {
+		const data = Immutable.List([0x00]);
+		const fieldValue = mySiEnum.extractFromData(data);
+		expect(fieldValue instanceof SiFieldValue).toBe(true);
+		expect(fieldValue!.field).toBe(mySiEnum);
+		expect(fieldValue!.value).toBe('Zero');
+	});
+	test('extractFromData', () => {
+		const getExtractedFieldValue = (bytes: FakeSiStorageData) => mySiEnum.extractFromData(Immutable.List(bytes));
+
+		expect(getExtractedFieldValue([0x00])!.value).toBe('Zero');
+		expect(getExtractedFieldValue([0x10])!.value).toBe('One');
+		expect(getExtractedFieldValue([0x20])!.value).toBe('Two');
+		expect(getExtractedFieldValue([0x30])!.value).toBe('Three');
+		expect(getExtractedFieldValue([undefined])).toBe(undefined);
+		expect(getExtractedFieldValue([])).toBe(undefined);
+	});
+	test('updateData', () => {
+		const updateData = (data: FakeSiStorageData, newValue: MySiEnumType | SiFieldValue<MySiEnumType>): FakeSiStorageData => mySiEnum.updateData(Immutable.List(data), newValue).toJS();
+
+		expect(updateData([0xff], 'Zero')).toEqual([0xcf]);
+		expect(updateData([0xff], 'One')).toEqual([0xdf]);
+		expect(updateData([0xff], 'Two')).toEqual([0xef]);
+		expect(updateData([0xff], 'Three')).toEqual([0xff]);
+		expect(updateData([0x00], 'Zero')).toEqual([0x00]);
+		expect(updateData([0x00], 'One')).toEqual([0x10]);
+		expect(updateData([0x00], 'Two')).toEqual([0x20]);
+		expect(updateData([0x00], 'Three')).toEqual([0x30]);
+		expect(updateData([0xfe], fieldValueOf('Zero'))).toEqual([0xce]);
+	});
+	test('updateData modify undefined', () => {
+		const updateData = (data: FakeSiStorageData, newValue: MySiEnumType | SiFieldValue<MySiEnumType>): FakeSiStorageData => mySiEnum.updateData(Immutable.List(data), newValue).toJS();
+
+		expect(() => updateData([], 'Zero')).toThrow(ModifyUndefinedException);
+		expect(() => updateData([], 'Three')).toThrow(ModifyUndefinedException);
+		expect(() => updateData([], fieldValueOf('Two'))).toThrow(ModifyUndefinedException);
+		expect(() => updateData([undefined], 'One')).toThrow(ModifyUndefinedException);
+	});
+});

package/src/storage/SiEnum.ts

@@ -0,0 +1,48 @@
+import _ from 'lodash';
+import * as utils from '../utils';
+import type { ISiDataType, ISiStorageData } from './interfaces';
+import { ValueFromStringError } from './interfaces';
+
+import { SiDataType } from './SiDataType';
+import { SiInt, type SiIntegerPartDefinition } from './SiInt';
+
+export class SiEnum<T extends { [key: string]: number }> extends SiDataType<keyof T> implements ISiDataType<keyof T> {
+	private intField: SiInt;
+
+	constructor(parts: SiIntegerPartDefinition[], public readonly dict: T, public readonly getIntValue = (value: unknown): number | undefined => value as number) {
+		super();
+		this.intField = new SiInt(parts);
+	}
+
+	getLookupDict(): { [key: string]: string } {
+		return utils.getLookup(this.dict, (value) => `${this.getIntValue(value)}`);
+	}
+
+	typeSpecificIsValueValid(value: keyof T): boolean {
+		return this.dict[value] !== undefined;
+	}
+
+	typeSpecificValueToString(value: keyof T): string {
+		return String(value);
+	}
+
+	typeSpecificValueFromString(string: string): keyof T | ValueFromStringError {
+		if (this.dict[string] === undefined) {
+			return new ValueFromStringError(`Value for ${this.constructor.name} must be an enum option, not "${string}"`);
+		}
+		return string as keyof T;
+	}
+
+	typeSpecificExtractFromData(data: ISiStorageData): keyof T | undefined {
+		const intValue = this.intField.typeSpecificExtractFromData(data);
+		const intString = `${intValue}`;
+		const lookupDict = this.getLookupDict();
+		const key = lookupDict[intString];
+		return key;
+	}
+
+	typeSpecificUpdateData(data: ISiStorageData, newValue: keyof T): ISiStorageData {
+		const newIntValue = this.dict[newValue];
+		return this.intField.typeSpecificUpdateData(data, newIntValue);
+	}
+}

package/src/storage/SiFieldValue.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import { type ISiDataType, type ISiStorageData, ValueToStringError, ValueFromStringError } from './interfaces';
+import { SiDataType } from './SiDataType';
+import { SiFieldValue } from './SiFieldValue';
+
+describe('SiFieldValue', () => {
+	class MyType extends SiDataType<number> implements ISiDataType<number> {
+		typeSpecificIsValueValid(_value: number) {
+			return true;
+		}
+
+		typeSpecificValueToString(value: number) {
+			if (value === 42) {
+				return new ValueToStringError();
+			}
+			return `${value}`;
+		}
+
+		typeSpecificValueFromString(string: string) {
+			const value = parseInt(string, 10);
+			return _.isInteger(value) ? value : new ValueFromStringError();
+		}
+
+		typeSpecificExtractFromData(_data: ISiStorageData): number {
+			return 1;
+		}
+
+		typeSpecificUpdateData(data: ISiStorageData, _newValue: number): ISiStorageData {
+			return data;
+		}
+	}
+	const field = new MyType();
+	const myFieldValue = new SiFieldValue(field, 3);
+	test('instance', () => {
+		expect(myFieldValue.field).toBe(field);
+		expect(myFieldValue.value).toBe(3);
+	});
+	test('toString', () => {
+		expect(myFieldValue.toString()).toBe('3');
+	});
+	test('toString with error', () => {
+		const invalidFieldValue = new SiFieldValue(field, 42);
+		expect(invalidFieldValue.toString()).toBe('');
+	});
+	test('fromString with success', () => {
+		const myFieldValueFromString = SiFieldValue.fromString(field, '5');
+		if (myFieldValueFromString instanceof ValueFromStringError) {
+			throw new Error('not expecting an error here');
+		}
+		expect(myFieldValueFromString.field).toBe(field);
+		expect(myFieldValueFromString.value).toBe(5);
+	});
+	test('fromString with error', () => {
+		const myFieldValueFromString = SiFieldValue.fromString(field, 'notanumber');
+		expect(myFieldValueFromString instanceof ValueFromStringError).toBe(true);
+	});
+});

package/src/storage/SiFieldValue.ts

@@ -0,0 +1,23 @@
+import { ValueToStringError, ValueFromStringError } from './interfaces';
+import type { ISiFieldValue, ISiDataType } from './interfaces';
+
+export class SiFieldValue<T> implements ISiFieldValue<T> {
+	static fromString<U>(field: ISiDataType<U>, stringValue: string): SiFieldValue<U> | ValueFromStringError {
+		const value = field.valueFromString(stringValue);
+		if (value instanceof ValueFromStringError) {
+			return value;
+		}
+		return new this(field, value);
+	}
+
+	// eslint-disable-next-line no-useless-constructor
+	constructor(
+		public field: ISiDataType<T>,
+		public value: T // eslint-disable-next-line no-empty-function
+	) {}
+
+	toString(): string {
+		const stringValue = this.field.valueToString(this.value);
+		return stringValue instanceof ValueToStringError ? '' : stringValue;
+	}
+}

package/src/storage/SiInt.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import Immutable from 'immutable';
+import { ValueToStringError, ValueFromStringError } from './interfaces';
+import { ModifyUndefinedException } from './SiDataType';
+import { SiFieldValue } from './SiFieldValue';
+import { SiInt } from './SiInt';
+
+type FakeSiStorageData = (number | undefined)[];
+
+describe('SiInt', () => {
+	const mySiInt = new SiInt([[0x00], [0x01, 4, 8]]);
+	const fieldValueOf = (intValue: number): SiFieldValue<number> => new SiFieldValue(mySiInt, intValue);
+	test('typeSpecificIsValueValid', () => {
+		expect(mySiInt.typeSpecificIsValueValid(0)).toBe(true);
+		expect(mySiInt.typeSpecificIsValueValid(1)).toBe(true);
+		expect(mySiInt.typeSpecificIsValueValid(0xff)).toBe(true);
+		expect(mySiInt.typeSpecificIsValueValid(-1)).toBe(false);
+		expect(mySiInt.typeSpecificIsValueValid(1.5)).toBe(false);
+		expect(mySiInt.typeSpecificIsValueValid(-7.5)).toBe(false);
+	});
+	test('valueToString', () => {
+		expect(mySiInt.valueToString(0)).toBe('0');
+		expect(mySiInt.valueToString(1)).toBe('1');
+		expect(mySiInt.valueToString(0xff)).toBe('255');
+		expect(mySiInt.valueToString(-1) instanceof ValueToStringError).toBe(true);
+	});
+	test('valueFromString', () => {
+		expect(mySiInt.valueFromString('0')).toBe(0);
+		expect(mySiInt.valueFromString('1')).toBe(1);
+		expect(mySiInt.valueFromString('255')).toBe(0xff);
+		expect(mySiInt.valueFromString('0xFF')).toBe(0);
+		expect(mySiInt.valueFromString('-1') instanceof ValueFromStringError).toBe(true);
+		expect(mySiInt.valueFromString('test') instanceof ValueFromStringError).toBe(true);
+	});
+	test('extractFromData gives field value', () => {
+		const data = Immutable.List([0x00, 0x00]);
+		const fieldValue = mySiInt.extractFromData(data);
+		expect(fieldValue instanceof SiFieldValue).toBe(true);
+		expect(fieldValue!.field).toBe(mySiInt);
+		expect(fieldValue!.value).toBe(0);
+	});
+	test('extractFromData', () => {
+		const getExtractedFieldValue = (bytes: FakeSiStorageData) => mySiInt.extractFromData(Immutable.List(bytes));
+
+		expect(getExtractedFieldValue([0x00, 0x00])!.value).toBe(0x000);
+		expect(getExtractedFieldValue([0x0f, 0x00])!.value).toBe(0x00f);
+		expect(getExtractedFieldValue([0xff, 0x00])!.value).toBe(0x0ff);
+		expect(getExtractedFieldValue([0xff, 0xf0])!.value).toBe(0xfff);
+		expect(getExtractedFieldValue([0x00, 0xf0])!.value).toBe(0xf00);
+		expect(getExtractedFieldValue([0xab, 0xcd])!.value).toBe(0xcab);
+		expect(getExtractedFieldValue([0x00, undefined])).toBe(undefined);
+		expect(getExtractedFieldValue([undefined, 0x00])).toBe(undefined);
+		expect(getExtractedFieldValue([0x00])).toBe(undefined);
+		expect(getExtractedFieldValue([])).toBe(undefined);
+	});
+	test('updateData', () => {
+		const initialData = Immutable.List([0x00, 0x00]);
+		const updateInitialData = (newValue: number | SiFieldValue<number>): FakeSiStorageData => mySiInt.updateData(initialData, newValue).toJS();
+
+		expect(updateInitialData(0x000)).toEqual([0x00, 0x00]);
+		expect(updateInitialData(0x00f)).toEqual([0x0f, 0x00]);
+		expect(updateInitialData(0x0ff)).toEqual([0xff, 0x00]);
+		expect(updateInitialData(0xfff)).toEqual([0xff, 0xf0]);
+		expect(updateInitialData(0xf00)).toEqual([0x00, 0xf0]);
+		expect(updateInitialData(0xcab)).toEqual([0xab, 0xc0]);
+		expect(updateInitialData(fieldValueOf(0x7357))).toEqual([0x57, 0x30]);
+	});
+	test('updateData modify undefined', () => {
+		const updateData = (data: FakeSiStorageData, newValue: number | SiFieldValue<number>): FakeSiStorageData => mySiInt.updateData(Immutable.List(data), newValue).toJS();
+
+		expect(() => updateData([], 0x000)).toThrow(ModifyUndefinedException);
+		expect(() => updateData([], 0xcab)).toThrow(ModifyUndefinedException);
+		expect(() => updateData([], fieldValueOf(0x7357))).toThrow(ModifyUndefinedException);
+		expect(() => updateData([0x00, undefined], 0xcab)).toThrow(ModifyUndefinedException);
+		expect(() => updateData([undefined, 0x00], 0xcab)).toThrow(ModifyUndefinedException);
+		expect(() => updateData([0xab, undefined], 0x0ab)).toThrow(ModifyUndefinedException);
+		expect(() => updateData([undefined, 0xc0], 0xc00)).toThrow(ModifyUndefinedException);
+	});
+});