sportident.js 1.0.0 → 1.0.1

package/src/storage/SiBool.ts

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

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

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

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

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

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

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

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

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

@@ -1,80 +0,0 @@
-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);
-	});
-});