sportident.js 1.0.0

package/src/storage/SiInt.ts

@@ -0,0 +1,84 @@
+import _ from 'lodash';
+import type { ISiDataType, ISiStorageData } from './interfaces';
+import { ValueFromStringError } from './interfaces';
+
+import { ModifyUndefinedException, SiDataType } from './SiDataType';
+
+export type SiIntegerPartDefinition = [number, number, number] | [number];
+
+export interface SiIntegerPart {
+	byteOffset: number;
+	startBit: number;
+	endBit: number;
+}
+
+export class SiInt extends SiDataType<number> implements ISiDataType<number> {
+	public parts: SiIntegerPart[];
+
+	constructor(parts: SiIntegerPartDefinition[]) {
+		super();
+		this.parts = parts.map((rawPart) => ({
+			byteOffset: rawPart[0],
+			startBit: rawPart.length === 3 ? rawPart[1] : 0,
+			endBit: rawPart.length === 3 ? rawPart[2] : 8
+		}));
+	}
+
+	typeSpecificIsValueValid(value: number): boolean {
+		return _.isInteger(value) && value >= 0;
+	}
+
+	typeSpecificValueToString(value: number): string {
+		return value.toString();
+	}
+
+	typeSpecificValueFromString(string: string): number | ValueFromStringError {
+		const intValue = parseInt(string, 10);
+		if (!_.isInteger(intValue)) {
+			return new ValueFromStringError(`Value for SiInt must be integer, not "${string}"`);
+		}
+		return intValue;
+	}
+
+	isUndefined(data: ISiStorageData): boolean {
+		return this.parts.some((part) => data.get(part.byteOffset) === undefined);
+	}
+
+	typeSpecificExtractFromData(data: ISiStorageData): number | undefined {
+		if (this.isUndefined(data)) {
+			return undefined;
+		}
+		let bitOffset = 0;
+		let intValue = 0;
+		this.parts.forEach((part) => {
+			const { byteOffset, startBit, endBit } = part;
+			const bitLength = endBit - startBit;
+			const lengthMask = (0x01 << bitLength) - 1;
+			const existingByte = data.get(byteOffset) as number;
+			const partValue = (existingByte >> startBit) & lengthMask;
+			intValue |= partValue << bitOffset;
+			bitOffset += bitLength;
+		});
+		return intValue;
+	}
+
+	typeSpecificUpdateData(data: ISiStorageData, newValue: number): ISiStorageData {
+		if (this.isUndefined(data)) {
+			throw new ModifyUndefinedException();
+		}
+		let bitOffset = 0;
+		let tempData = data;
+		this.parts.forEach((part) => {
+			const { byteOffset, startBit, endBit } = part;
+			const bitLength = endBit - startBit;
+			const lengthMask = (0x01 << bitLength) - 1;
+			const newPartValue = (newValue >> bitOffset) & lengthMask;
+			const existingByte = tempData.get(byteOffset) as number;
+			const preservationMask = (lengthMask << startBit) ^ 0xff;
+			const newByte = (existingByte & preservationMask) | (newPartValue << startBit);
+			tempData = tempData.set(byteOffset, newByte);
+			bitOffset += bitLength;
+		});
+		return tempData;
+	}
+}

package/src/storage/SiModified.test.ts

@@ -0,0 +1,135 @@
+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 { SiModified } from './SiModified';
+
+type FakeSiStorageData = (number | undefined)[];
+
+describe('SiModified', () => {
+	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) & 0xff);
+		}
+	}
+
+	const mySiModified = new SiModified(
+		new FakeDataType(1),
+		(char: string) => char.charCodeAt(0),
+		(charCode: number) => (charCode < 32 ? undefined : String.fromCharCode(charCode)),
+		(charCode: number) => charCode.toString(16),
+		(hexString: string) => {
+			const num = parseInt(hexString, 16);
+			return Number.isNaN(num) ? new ValueFromStringError('NaN') : num;
+		},
+		(charCode: number) => _.isInteger(charCode) && charCode >= 0
+	);
+	const fieldValueOf = (modifiedValue: number) => new SiFieldValue(mySiModified, modifiedValue);
+	test('typeSpecificIsValueValid', () => {
+		expect(mySiModified.typeSpecificIsValueValid(0)).toBe(true);
+		expect(mySiModified.typeSpecificIsValueValid(1)).toBe(true);
+		expect(mySiModified.typeSpecificIsValueValid(0xff)).toBe(true);
+		expect(mySiModified.typeSpecificIsValueValid(-1)).toBe(false);
+		expect(mySiModified.typeSpecificIsValueValid(1.5)).toBe(false);
+		expect(mySiModified.typeSpecificIsValueValid(-7.5)).toBe(false);
+	});
+	test('valueToString', () => {
+		expect(mySiModified.valueToString(0)).toBe('0');
+		expect(mySiModified.valueToString(1)).toBe('1');
+		expect(mySiModified.valueToString(0xff)).toBe('ff');
+		expect(mySiModified.valueToString(-1) instanceof ValueToStringError).toBe(true);
+		expect(mySiModified.valueToString(-15) instanceof ValueToStringError).toBe(true);
+	});
+	test('valueFromString', () => {
+		expect(mySiModified.valueFromString('0')).toBe(0);
+		expect(mySiModified.valueFromString('1')).toBe(1);
+		expect(mySiModified.valueFromString('ff')).toBe(0xff);
+		expect(mySiModified.valueFromString('0xFF')).toBe(0xff);
+		expect(mySiModified.valueFromString('g') instanceof ValueFromStringError).toBe(true);
+		expect(mySiModified.valueFromString('test') instanceof ValueFromStringError).toBe(true);
+	});
+	test('extractFromData gives field value', () => {
+		const data = Immutable.List([0x00, 0x00]);
+		const fieldValue = mySiModified.extractFromData(data);
+		expect(fieldValue instanceof SiFieldValue).toBe(true);
+		expect(fieldValue!.field).toBe(mySiModified);
+		expect(fieldValue!.value).toBe(0);
+	});
+	test('extractFromData', () => {
+		const getExtractedFieldValue = (bytes: FakeSiStorageData) => mySiModified.extractFromData(Immutable.List(bytes));
+
+		expect(getExtractedFieldValue([0x00, 0x00])!.value).toBe(0x00);
+		expect(getExtractedFieldValue([0x0f, 0x00])!.value).toBe(0x00);
+		expect(getExtractedFieldValue([0x00, 0x0f])!.value).toBe(0x0f);
+		expect(getExtractedFieldValue([0xff, 0x0f])!.value).toBe(0x0f);
+		expect(getExtractedFieldValue([0x00, 0xf0])!.value).toBe(0xf0);
+		expect(getExtractedFieldValue([0xab, 0xcd])!.value).toBe(0xcd);
+		expect(getExtractedFieldValue([0x00, undefined])).toBe(undefined);
+		expect(getExtractedFieldValue([undefined, 0x00])!.value).toBe(0x00);
+		expect(getExtractedFieldValue([0x00])).toBe(undefined);
+		expect(getExtractedFieldValue([])).toBe(undefined);
+	});
+	test('updateData', () => {
+		const initialData = Immutable.List([0x00, 0x00]);
+		const updateInitialData = (newValue: number | SiFieldValue<number>): FakeSiStorageData => mySiModified.updateData(initialData, newValue).toJS();
+
+		expect(updateInitialData(0x000)).toEqual([0x00, 0x00]);
+		expect(updateInitialData(0x00f)).toEqual([0x00, 0x00]);
+		expect(updateInitialData(0x020)).toEqual([0x00, 0x20]);
+		expect(updateInitialData(0x0ff)).toEqual([0x00, 0xff]);
+		expect(updateInitialData(0xfff)).toEqual([0x00, 0xff]);
+		expect(updateInitialData(0xf00)).toEqual([0x00, 0x00]);
+		expect(updateInitialData(0xcab)).toEqual([0x00, 0xab]);
+		expect(updateInitialData(fieldValueOf(0x7357))).toEqual([0x00, 0x57]);
+	});
+	test('updateData modify undefined', () => {
+		const updateData = (data: FakeSiStorageData, newValue: number | SiFieldValue<number>): FakeSiStorageData => mySiModified.updateData(Immutable.List(data), newValue).toJS();
+
+		expect(() => updateData([], 0x000)).not.toThrow(ModifyUndefinedException);
+		expect(() => updateData([], 0x01f)).not.toThrow(ModifyUndefinedException);
+		expect(() => updateData([], 0x020)).toThrow(ModifyUndefinedException);
+		expect(() => updateData([], 0xcab)).toThrow(ModifyUndefinedException);
+		expect(() => updateData([], fieldValueOf(0x7357))).toThrow(ModifyUndefinedException);
+		expect(() => updateData([0x00, undefined], 0xcab)).toThrow(ModifyUndefinedException);
+		expect(() => updateData([0xab, undefined], fieldValueOf(0x0ab))).toThrow(ModifyUndefinedException);
+	});
+
+	const nullSiModified = new SiModified(new FakeDataType(1));
+	test('defaults if modification functions are undefined', () => {
+		expect(nullSiModified.isValueValid(0)).toBe(true);
+		expect(nullSiModified.valueToString(5) instanceof ValueToStringError).toBe(true);
+		expect(nullSiModified.valueFromString('5') instanceof ValueFromStringError).toBe(true);
+		expect(nullSiModified.extractFromData(Immutable.List([]))).toBe(undefined);
+		expect(nullSiModified.updateData(Immutable.List([]), 0)).toEqual(Immutable.List([]));
+	});
+});

package/src/storage/SiModified.ts

@@ -0,0 +1,59 @@
+import type { ISiDataType, ISiStorageData } from './interfaces';
+import { ValueToStringError, ValueFromStringError } from './interfaces';
+import { SiDataType } from './SiDataType';
+
+export class SiModified<T, U> extends SiDataType<U> implements ISiDataType<U> {
+	constructor(
+		public readonly dataType: ISiDataType<T>,
+		public readonly modifyExtracted?: (value: T) => U | undefined,
+		public readonly modifyForUpdate?: (value: U) => T | undefined,
+		public readonly modifiedToString?: (value: U) => string | ValueToStringError,
+		public readonly modifiedFromString?: (value: string) => U | ValueFromStringError,
+		public readonly modifiedIsValid?: (value: U) => boolean
+	) {
+		super();
+	}
+
+	typeSpecificIsValueValid(value: U): boolean {
+		if (!this.modifiedIsValid) {
+			return true;
+		}
+		return this.modifiedIsValid(value);
+	}
+
+	typeSpecificValueToString(value: U): string | ValueToStringError {
+		if (!this.modifiedToString) {
+			return new ValueToStringError('modifiedToString was not provided');
+		}
+		return this.modifiedToString(value);
+	}
+
+	typeSpecificValueFromString(string: string): U | ValueFromStringError {
+		if (!this.modifiedFromString) {
+			return new ValueFromStringError('modifiedFromString was not provided');
+		}
+		return this.modifiedFromString(string);
+	}
+
+	typeSpecificExtractFromData(data: ISiStorageData): U | undefined {
+		if (!this.modifyExtracted) {
+			return undefined;
+		}
+		const internalData = this.dataType.typeSpecificExtractFromData(data);
+		if (internalData === undefined) {
+			return undefined;
+		}
+		return this.modifyExtracted(internalData);
+	}
+
+	typeSpecificUpdateData(data: ISiStorageData, newValue: U): ISiStorageData {
+		if (!this.modifyForUpdate) {
+			return data;
+		}
+		const internalData = this.modifyForUpdate(newValue);
+		if (internalData === undefined) {
+			return data;
+		}
+		return this.dataType.typeSpecificUpdateData(data, internalData);
+	}
+}

package/src/storage/SiStorage.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import Immutable from 'immutable';
+import * as utils from '../utils';
+import { defineStorage } from './SiStorage';
+import { SiFieldValue } from './SiFieldValue';
+import { SiBool } from './SiBool';
+import { SiInt } from './SiInt';
+
+describe('storage utils', () => {
+	const isWeirdField = new SiBool(0x00, 7);
+	const weirdnessField = new SiInt([[0x01], [0x00, 0, 7]]);
+	const locations = {
+		isWeird: isWeirdField,
+		weirdness: weirdnessField
+	};
+	test('SiStorage init', () => {
+		const weirdStorage = defineStorage(0x02, locations);
+		const weirdStorageFromArray = weirdStorage(utils.unPrettyHex('01 23'));
+		expect(weirdStorageFromArray.locations).toEqual(locations);
+		expect(weirdStorageFromArray.data.toJS()).toEqual(utils.unPrettyHex('01 23'));
+		const weirdStorageFromList = weirdStorage(Immutable.List(utils.unPrettyHex('45 67')));
+		expect(weirdStorageFromList.locations).toEqual(locations);
+		expect(weirdStorageFromList.data.toJS()).toEqual(utils.unPrettyHex('45 67'));
+		const weirdStorageFromUndefined = weirdStorage();
+		expect(weirdStorageFromUndefined.locations).toEqual(locations);
+		expect(weirdStorageFromUndefined.data.toJS()).toEqual(utils.unPrettyHex('?? ??'));
+	});
+	test('SiStorage init wrong length', () => {
+		const weirdStorage = defineStorage(0x02, {});
+		expect(() => weirdStorage([0x00])).toThrow();
+	});
+	test('SiStorage splice', () => {
+		const weirdStorage = defineStorage(0x04, {});
+		const myWeirdStorage = weirdStorage(utils.unPrettyHex('00 00 00 00'));
+
+		myWeirdStorage.splice(1, 2, ...(utils.unPrettyHex('12 34') as number[]));
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('00 12 34 00'));
+
+		expect(() => myWeirdStorage.splice(1, 2)).toThrow();
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('00 12 34 00'));
+	});
+	test('SiStorage get', () => {
+		const weirdStorage = defineStorage(0x02, locations);
+		const myWeirdStorage = weirdStorage(utils.unPrettyHex('01 23'));
+		const isWeirdFieldValue = myWeirdStorage.get('isWeird')!;
+		expect(isWeirdFieldValue instanceof SiFieldValue).toBe(true);
+		expect(isWeirdFieldValue.field).toBe(isWeirdField);
+		expect(isWeirdFieldValue.value).toBe(false);
+	});
+});

package/src/storage/SiStorage.ts

@@ -0,0 +1,44 @@
+import _ from 'lodash';
+import Immutable from 'immutable';
+import type { ISiFieldValue, ISiStorage, ISiStorageData, ISiStorageDefinition, ISiStorageLocations } from './interfaces';
+
+export class SiStorage<T> implements ISiStorage<T> {
+	private internalData: ISiStorageData;
+
+	// eslint-disable-next-line no-useless-constructor
+	constructor(public readonly size: number, public readonly locations: ISiStorageLocations<T>, initArg?: Immutable.List<number | undefined> | Array<number | undefined>) {
+		const initArrayOrList = (initArg === undefined ? _.range(size).map(() => undefined) : initArg) as Immutable.List<number | undefined> | Array<number | undefined>;
+		const initList = (initArrayOrList instanceof Immutable.List ? initArrayOrList : Immutable.List(initArrayOrList)) as Immutable.List<number | undefined>;
+		if (initList.size !== size) {
+			throw new Error(`SiStorage constructor list "${initArg}" => "${initList}" ` + `must have size ${size} (but is ${initList.size})`);
+		}
+		this.internalData = initList;
+	}
+
+	get data(): ISiStorageData {
+		return this.internalData;
+	}
+
+	get<U extends keyof T>(fieldName: U): ISiFieldValue<T[U]> | undefined {
+		const fieldDefinition = this.locations[fieldName];
+		return fieldDefinition.extractFromData(this.internalData);
+	}
+
+	set<U extends keyof T>(fieldName: U, newValue: ISiFieldValue<T[U]> | T[U]): void {
+		const fieldDefinition = this.locations[fieldName];
+		this.internalData = fieldDefinition.updateData(this.internalData, newValue);
+	}
+
+	splice(index: number, removeNum: number, ...values: number[]): void {
+		const newData = this.internalData.splice(index, removeNum, ...values);
+		if (newData.size !== this.internalData.size) {
+			throw new Error('SiStorage.splice must preserve the size of the storage data ' + `(${this.internalData.size} -> ${newData.size})`);
+		}
+		this.internalData = newData;
+	}
+}
+
+export const defineStorage =
+	<T>(size: number, locations: ISiStorageLocations<T>): ISiStorageDefinition<T> =>
+	(initArg?: Immutable.List<number | undefined> | Array<number | undefined>): ISiStorage<T> =>
+		new SiStorage<T>(size, locations, initArg);

package/src/storage/index.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import * as utils from '../utils';
+import * as storage from './index';
+
+describe('storage', () => {
+	test('SiBool SiStorage integration', () => {
+		const weirdStorage = storage.defineStorage(0x02, {
+			isWeird: new storage.SiBool(0x00, 7),
+			isCrazy: new storage.SiBool(0x01),
+			isLoco: new storage.SiBool(0x01, 1)
+		});
+		const myWeirdStorage = weirdStorage(utils.unPrettyHex('00 00') as number[]);
+		expect(myWeirdStorage instanceof storage.SiStorage).toBe(true);
+
+		expect(myWeirdStorage.get('isWeird')!.value).toBe(false);
+		myWeirdStorage.set('isWeird', true);
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('80 00') as number[]);
+		expect(myWeirdStorage.get('isWeird')!.value).toBe(true);
+
+		expect(myWeirdStorage.get('isLoco')!.value).toBe(false);
+		myWeirdStorage.set('isLoco', true);
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('80 02') as number[]);
+		expect(myWeirdStorage.get('isLoco')!.value).toBe(true);
+
+		expect(myWeirdStorage.get('isCrazy')!.value).toBe(false);
+		myWeirdStorage.set('isCrazy', true);
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('80 03') as number[]);
+		expect(myWeirdStorage.get('isCrazy')!.value).toBe(true);
+
+		const unknownWeirdStorage = weirdStorage();
+		const { ModifyUndefinedException } = storage;
+
+		expect(unknownWeirdStorage.get('isWeird')).toBe(undefined);
+		expect(() => unknownWeirdStorage.set('isWeird', true)).toThrow(ModifyUndefinedException);
+
+		expect(unknownWeirdStorage.get('isLoco')).toBe(undefined);
+		expect(() => unknownWeirdStorage.set('isLoco', true)).toThrow(ModifyUndefinedException);
+
+		expect(unknownWeirdStorage.get('isCrazy')).toBe(undefined);
+		expect(() => unknownWeirdStorage.set('isCrazy', true)).toThrow(ModifyUndefinedException);
+	});
+	test('SiInt SiStorage integration', () => {
+		const weirdStorage = storage.defineStorage(0x03, {
+			weirdness: new storage.SiInt([[0x00]]),
+			crazyness: new storage.SiInt([[0x01, 0, 4]]),
+			loconess: new storage.SiInt([[0x02], [0x01, 4, 8]])
+		});
+		const myWeirdStorage = weirdStorage(utils.unPrettyHex('00 00 00') as number[]);
+		expect(myWeirdStorage instanceof storage.SiStorage).toBe(true);
+
+		expect(myWeirdStorage.get('weirdness')!.value).toBe(0x00);
+		myWeirdStorage.set('weirdness', 0x555);
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('55 00 00') as number[]);
+		expect(myWeirdStorage.get('weirdness')!.value).toBe(0x55);
+
+		expect(myWeirdStorage.get('crazyness')!.value).toBe(0x00);
+		myWeirdStorage.set('crazyness', 0xaa);
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('55 0A 00') as number[]);
+		expect(myWeirdStorage.get('crazyness')!.value).toBe(0x0a);
+
+		expect(myWeirdStorage.get('loconess')!.value).toBe(0x00);
+		myWeirdStorage.set('loconess', 0xabcd);
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('55 BA CD') as number[]);
+		expect(myWeirdStorage.get('loconess')!.value).toBe(0xbcd);
+
+		const unknownWeirdStorage = weirdStorage();
+		const { ModifyUndefinedException } = storage;
+
+		expect(unknownWeirdStorage.get('weirdness')).toBe(undefined);
+		expect(() => unknownWeirdStorage.set('weirdness', 0x555)).toThrow(ModifyUndefinedException);
+
+		expect(unknownWeirdStorage.get('crazyness')).toBe(undefined);
+		expect(() => unknownWeirdStorage.set('crazyness', 0xaa)).toThrow(ModifyUndefinedException);
+
+		expect(unknownWeirdStorage.get('loconess')).toBe(undefined);
+		expect(() => unknownWeirdStorage.set('loconess', 0xabcd)).toThrow(ModifyUndefinedException);
+	});
+	test('SiEnum SiStorage integration', () => {
+		const weirdStorage = storage.defineStorage(0x03, {
+			weirdness: new storage.SiEnum([[0x00]], { NotWeird: 0x00, Weird: 0x55 }),
+			crazyness: new storage.SiEnum([[0x01, 0, 4]], { NotCrazy: 0x00, Crazy: 0x0a }),
+			loconess: new storage.SiEnum([[0x02], [0x01, 4, 8]], { NotLoco: 0x000, Loco: 0xbcd })
+		});
+		const myWeirdStorage = weirdStorage(utils.unPrettyHex('00 00 00') as number[]);
+		expect(myWeirdStorage instanceof storage.SiStorage).toBe(true);
+
+		expect(myWeirdStorage.get('weirdness')!.value).toBe('NotWeird');
+		myWeirdStorage.set('weirdness', 'Weird');
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('55 00 00') as number[]);
+		expect(myWeirdStorage.get('weirdness')!.value).toBe('Weird');
+
+		expect(myWeirdStorage.get('crazyness')!.value).toBe('NotCrazy');
+		myWeirdStorage.set('crazyness', 'Crazy');
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('55 0A 00') as number[]);
+		expect(myWeirdStorage.get('crazyness')!.value).toBe('Crazy');
+
+		expect(myWeirdStorage.get('loconess')!.value).toBe('NotLoco');
+		myWeirdStorage.set('loconess', 'Loco');
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('55 BA CD') as number[]);
+		expect(myWeirdStorage.get('loconess')!.value).toBe('Loco');
+
+		const unknownWeirdStorage = weirdStorage();
+		const { ModifyUndefinedException } = storage;
+
+		expect(unknownWeirdStorage.get('weirdness')).toBe(undefined);
+		expect(() => unknownWeirdStorage.set('weirdness', 'Weird')).toThrow(ModifyUndefinedException);
+
+		expect(unknownWeirdStorage.get('crazyness')).toBe(undefined);
+		expect(() => unknownWeirdStorage.set('crazyness', 'Crazy')).toThrow(ModifyUndefinedException);
+
+		expect(unknownWeirdStorage.get('loconess')).toBe(undefined);
+		expect(() => unknownWeirdStorage.set('loconess', 'Loco')).toThrow(ModifyUndefinedException);
+	});
+	test('SiArray SiStorage integration', () => {
+		const weirdStorage = storage.defineStorage(0x03, {
+			areWeird: new storage.SiArray(3, (i) => new storage.SiBool(0x00, i)),
+			crazynesses: new storage.SiArray(2, (i) => new storage.SiInt([[0x01 + i]]))
+		});
+		const myWeirdStorage = weirdStorage(utils.unPrettyHex('00 00 00') as number[]);
+		expect(myWeirdStorage instanceof storage.SiStorage).toBe(true);
+
+		expect(myWeirdStorage.get('areWeird')!.value).toEqual([false, false, false]);
+		myWeirdStorage.set('areWeird', [true, true, false]);
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('03 00 00') as number[]);
+		expect(myWeirdStorage.get('areWeird')!.value).toEqual([true, true, false]);
+
+		expect(myWeirdStorage.get('crazynesses')!.value).toEqual([0x00, 0x00]);
+		myWeirdStorage.set('crazynesses', [0x01, 0x23]);
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('03 01 23') as number[]);
+		expect(myWeirdStorage.get('crazynesses')!.value).toEqual([0x01, 0x23]);
+
+		const unknownWeirdStorage = weirdStorage();
+		const { ModifyUndefinedException } = storage;
+
+		expect(unknownWeirdStorage.get('areWeird')!.value).toEqual([undefined, undefined, undefined]);
+		expect(() => unknownWeirdStorage.set('areWeird', [true, true, false])).toThrow(ModifyUndefinedException);
+
+		expect(unknownWeirdStorage.get('crazynesses')!.value).toEqual([undefined, undefined]);
+		expect(() => unknownWeirdStorage.set('crazynesses', [0x01, 0x23])).toThrow(ModifyUndefinedException);
+	});
+	test('SiDict SiStorage integration', () => {
+		const weirdStorage = storage.defineStorage(0x03, {
+			bustWaistHip: new storage.SiDict({
+				bust: new storage.SiInt([[0x00]]),
+				waist: new storage.SiInt([[0x01]]),
+				hip: new storage.SiInt([[0x02]])
+			})
+		});
+		const myWeirdStorage = weirdStorage(utils.unPrettyHex('00 00 00') as number[]);
+		expect(myWeirdStorage instanceof storage.SiStorage).toBe(true);
+
+		expect(myWeirdStorage.get('bustWaistHip')!.value).toEqual({
+			bust: 0x00,
+			waist: 0x00,
+			hip: 0x00
+		});
+		myWeirdStorage.set('bustWaistHip', { bust: 0x90, waist: 0x60, hip: 0x90 });
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('90 60 90') as number[]);
+		expect(myWeirdStorage.get('bustWaistHip')!.value).toEqual({
+			bust: 0x90,
+			waist: 0x60,
+			hip: 0x90
+		});
+
+		const unknownWeirdStorage = weirdStorage();
+		const { ModifyUndefinedException } = storage;
+
+		expect(unknownWeirdStorage.get('bustWaistHip')!.value).toEqual({
+			bust: undefined,
+			waist: undefined,
+			hip: undefined
+		});
+		expect(() => unknownWeirdStorage.set('bustWaistHip', { bust: 0x90, waist: 0x60, hip: 0x90 })).toThrow(ModifyUndefinedException);
+	});
+	test('SiArray SiDict combinations', () => {
+		const weirdStorage = storage.defineStorage(0x06, {
+			measurements: new storage.SiArray(
+				3,
+				(i) =>
+					new storage.SiDict({
+						time: new storage.SiInt([[0x00 + i * 2]]),
+						value: new storage.SiInt([[0x01 + i * 2]])
+					})
+			)
+		});
+		const myWeirdStorage = weirdStorage(utils.unPrettyHex('00 00 00 00 00 00') as number[]);
+		expect(myWeirdStorage instanceof storage.SiStorage).toBe(true);
+
+		expect(myWeirdStorage.get('measurements')!.value).toEqual([
+			{ time: 0x00, value: 0x00 },
+			{ time: 0x00, value: 0x00 },
+			{ time: 0x00, value: 0x00 }
+		]);
+		myWeirdStorage.set('measurements', [
+			{ time: 0x01, value: 0x01 },
+			{ time: 0x03, value: 0x09 },
+			{ time: 0x04, value: 0x10 }
+		]);
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('01 01 03 09 04 10') as number[]);
+		expect(myWeirdStorage.get('measurements')!.value).toEqual([
+			{ time: 0x01, value: 0x01 },
+			{ time: 0x03, value: 0x09 },
+			{ time: 0x04, value: 0x10 }
+		]);
+	});
+	test('everything exported', () => {
+		expect(storage.ValueToStringError).not.toBe(undefined);
+		expect(storage.ValueFromStringError).not.toBe(undefined);
+		expect(storage.defineStorage).not.toBe(undefined);
+		expect(storage.SiStorage).not.toBe(undefined);
+		expect(storage.SiFieldValue).not.toBe(undefined);
+		expect(storage.ModifyUndefinedException).not.toBe(undefined);
+		expect(storage.SiDataType).not.toBe(undefined);
+		expect(storage.SiArray).not.toBe(undefined);
+		expect(storage.SiBool).not.toBe(undefined);
+		expect(storage.SiDict).not.toBe(undefined);
+		expect(storage.SiEnum).not.toBe(undefined);
+		expect(storage.SiInt).not.toBe(undefined);
+		expect(storage.SiModified).not.toBe(undefined);
+	});
+});

package/src/storage/index.ts

@@ -0,0 +1,12 @@
+export { ValueToStringError, ValueFromStringError } from './interfaces';
+export type { ISiDataType, ISiFieldValue, ISiStorage, ISiStorageData, ISiStorageLocations } from './interfaces';
+export { defineStorage, SiStorage } from './SiStorage';
+export { SiFieldValue } from './SiFieldValue';
+export { ModifyUndefinedException, SiDataType } from './SiDataType';
+export { SiArray } from './SiArray';
+export { SiBool } from './SiBool';
+export { SiDict } from './SiDict';
+export { SiEnum } from './SiEnum';
+export { SiInt } from './SiInt';
+export { SiModified } from './SiModified';
+export { siStringToUtf8 } from './siStringEncoding'

package/src/storage/interfaces.ts

@@ -0,0 +1,41 @@
+import type Immutable from 'immutable';
+import * as utils from '../utils';
+
+export class ValueToStringError extends utils.SiError {}
+export class ValueFromStringError extends utils.SiError {}
+
+export interface ISiFieldValue<T> {
+	field: ISiDataType<T>;
+	value: T;
+	toString: () => string;
+}
+
+export type ISiStorageData = Immutable.List<number | undefined>;
+
+export interface ISiDataType<T> {
+	isValueValid: (value: T) => boolean;
+	typeSpecificIsValueValid: (value: T) => boolean;
+	valueToString: (value: T) => string | ValueToStringError;
+	typeSpecificValueToString: (value: T) => string | ValueToStringError;
+	valueFromString: (string: string) => T | ValueFromStringError;
+	typeSpecificValueFromString: (string: string) => T | ValueFromStringError;
+	extractFromData: (data: ISiStorageData) => ISiFieldValue<T> | undefined;
+	typeSpecificExtractFromData: (data: ISiStorageData) => T | undefined;
+	updateData: (data: ISiStorageData, newValue: T | ISiFieldValue<T>) => ISiStorageData;
+	typeSpecificUpdateData: (data: ISiStorageData, newValue: T) => ISiStorageData;
+}
+
+export type ISiStorageLocations<Fields> = {
+	[id in keyof Fields]: ISiDataType<Fields[id]>;
+};
+/** Consists of locations and size */
+export type ISiStorageDefinition<Fields> = (initArg?: Immutable.List<number | undefined> | Array<number | undefined>) => ISiStorage<Fields>;
+
+export interface ISiStorage<T> {
+	size: number;
+	locations: ISiStorageLocations<T>;
+	data: ISiStorageData;
+	get: <U extends keyof T>(fieldName: U) => ISiFieldValue<T[U]> | undefined;
+	set: <U extends keyof T>(fieldName: U, newValue: ISiFieldValue<T[U]> | T[U]) => void;
+	splice: (index: number, removeNum: number, ...values: number[]) => void;
+}