sportident.js 1.0.0 → 1.0.1

package/src/storage/SiInt.ts

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

@@ -1,135 +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 { 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

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

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

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

@@ -1,222 +0,0 @@
-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/interfaces.ts

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