url-safe-bitpacking 0.1.4 → 0.1.6

package/README.md

@@ -2,6 +2,16 @@
 
 Package for creating definitions of parametric models that can be stored as compactly as possible in a URL by storing it in a web-safe base-64 string. This pacakge is till very much WIP. Feel free to suggest by making an issue or pull-request [GitHub](https://github.com/JonasWard/url-safe-bitpacking).
 
+### goal for version 0.2
+
+| what                                                 | code     | tests    | docs     |
+| ---------------------------------------------------- | -------- | -------- | -------- |
+| data types                                           | ✓  | ✓  | ✓  |
+| nested object model                                  | ✓  | ✓  | ¼ |
+| updating model entries                               | ✓  | ✓  |          |
+| re-using data from old model on change in definition | ½ | ¼ |          |
+| flattening and reading of the objects                | ✓  | ✓  | ¿ |
+
 ## concept
 
 The goal of this library is to offer a flexible, minimal and, variable object definition that can be stored in the browser URL. The main imagined use-case is parametric models that have nested and variable sub-object definitions.
@@ -40,7 +50,7 @@ DataEntryFactory.createInt(5, 3, 20, 'circleDivisions');
 
 ### float
 
-Floating points work very much like the integer type, with the main difference that one can also define a precision to define at what order of magnitude (from -3 to +3) the variable should be considered. The significand can be up to 20 bits, which eg. at precision -3 would allow a range of .001 to 1048.576. Floating points are assumed to be always positive.
+Floating points work very much like the integer type, with the main difference that one can also define a precision to define at what order of magnitude (from -3 to +3) the variable should be considered. The significand can be up to 20 bits, which eg. at precision -3 would allow a range of .001 to 1048.576.
 
 ```typescript
 DataEntryFactory.createFloat(20, 10, 200, -1, 'shapePreProcessingWarptotal');

package/dist/enums/dataTypes.d.ts

@@ -5,3 +5,4 @@ export declare enum DataType {
     INT = 3,
     FLOAT = 4
 }
+export declare const getDataTypeName: (type: DataType) => string;

package/dist/factory/booleanFactory.d.ts

@@ -1,2 +1,2 @@
-import { BooleanData } from '../types/booleanData';
-export declare const create: () => BooleanData;
+import { BooleanDataEntry } from '../types';
+export declare const create: (value: boolean, name?: string, index?: number) => BooleanDataEntry;

package/dist/factory/enumFactory.d.ts

@@ -1,2 +1,2 @@
-import { EnumData } from '../types/enumData';
-export declare const create: (max: number) => EnumData;
+import { EnumDataEntry } from '../types';
+export declare const create: (value: number, max?: number, name?: string, index?: number) => EnumDataEntry;

package/dist/factory/factory.d.ts

@@ -3,27 +3,10 @@ import { create as createInt } from './intFactory';
 import { create as createBoolean } from './booleanFactory';
 import { create as createVersion } from './versionFactory';
 import { create as createEnum } from './enumFactory';
-import { BooleanDescriptionWithValueType, IntDescriptionWithValueType, FloatDescriptionWithValueType, VersionDescriptionWithValueType, FloatDiscriptionType, BooleanDiscriptionType, VersionDiscriptionType, IntDiscriptionType, EnumDiscriptionType, EnumDescriptionWithValueType } from '../types/dataEntry';
-import { PrecisionRangeType } from '../types/floatData';
-import { VersionRangeType } from '../types/versionData';
-export declare class DataRangeDescriptionFactory {
-    static createFloat: typeof createFloat;
-    static createInt: typeof createInt;
-    static createEnum: typeof createEnum;
-    static createBoolean: typeof createBoolean;
-    static createVersion: typeof createVersion;
-}
-export declare class DataDescriptionFactory {
-    static createFloat: (min?: number, max?: number, precision?: PrecisionRangeType, name?: string, index?: number) => FloatDiscriptionType;
-    static createInt: (min?: number, max?: number, name?: string, index?: number) => IntDiscriptionType;
-    static createEnum: (max?: number, name?: string, index?: number) => EnumDiscriptionType;
-    static createBoolean: (name?: string, index?: number) => BooleanDiscriptionType;
-    static createVersion: (bits?: VersionRangeType, name?: string, index?: number) => VersionDiscriptionType;
-}
-export declare class DataEntryFactory {
-    static createFloat: (value: number, min?: number, max?: number, precision?: PrecisionRangeType, name?: string, index?: number) => FloatDescriptionWithValueType;
-    static createInt: (value: number, min?: number, max?: number, name?: string, index?: number) => IntDescriptionWithValueType;
-    static createEnum: (value: number, max?: number, name?: string, index?: number) => EnumDescriptionWithValueType;
-    static createBoolean: (value: boolean, name?: string, index?: number) => BooleanDescriptionWithValueType;
-    static createVersion: (value: number, bits?: VersionRangeType, name?: string, index?: number) => VersionDescriptionWithValueType;
-}
+export declare const DataEntryFactory: {
+    createFloat: typeof createFloat;
+    createInt: typeof createInt;
+    createEnum: typeof createEnum;
+    createBoolean: typeof createBoolean;
+    createVersion: typeof createVersion;
+};

package/dist/factory/floatFactory.d.ts

@@ -1,2 +1,3 @@
-import { FloatData, PrecisionRangeType } from '../types/floatData';
-export declare const create: (min: number, max: number, precision: PrecisionRangeType) => FloatData;
+import { FloatDataEntry } from '../types';
+import { PrecisionRangeType } from '../types/floatData';
+export declare const create: (value: number, min?: number, max?: number, precision?: PrecisionRangeType, name?: string, index?: number) => FloatDataEntry;

package/dist/factory/intFactory.d.ts

@@ -1,2 +1,2 @@
-import { IntData } from '../types/intData';
-export declare const create: (min: number, max: number) => IntData;
+import { IntDataEntry } from '../types';
+export declare const create: (value: number, min?: number, max?: number, name?: string, index?: number) => IntDataEntry;

package/dist/factory/versionFactory.d.ts

@@ -1,2 +1,3 @@
-import { VersionRangeType, VersionData } from '../types/versionData';
-export declare const create: (bits: VersionRangeType) => VersionData;
+import { VersionDataEntry } from '../types';
+import { VersionRangeType } from '../types/versionData';
+export declare const create: (value: number, bits?: VersionRangeType, name?: string, index?: number) => VersionDataEntry;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { ObjectGenerationOutputStatus, DataType } from './enums';
-export { DataRangeDescriptionFactory, DataDescriptionFactory, DataEntryFactory } from './factory';
+export { DataEntryFactory } from './factory';
 export { getDefaultObject, updateDataEntry } from './objectmap';
 export { valueBitsParser, dataBitsParser, getBitsCount, dataBitsArrayParser, dataBitsStringifier, dataEntryCorrecting, parseBitsToBase64, parseBase64ToBits, dataArrayStringifier, } from './parsers';
-export { SingleLevelContentType, NestedContentDataType, NestedContentType, DoubleLevelContentType, NonEmptyValidEntryArrayType, OptionalEntryDataType, EnumEntryDataType, VersionArrayDefinitionType, PrecisionRangeType, SignificandMaxBits, FloatData, IntegerMaxBits, IntData, VersionRangeType, VersionData, GlobalVersion, BooleanData, DataRangeDescription, BooleanDiscriptionType, IntDiscriptionType, EnumDiscriptionType, FloatDiscriptionType, VersionDiscriptionType, DataDescription, BooleanDescriptionWithValueType, IntDescriptionWithValueType, EnumDescriptionWithValueType, FloatDescriptionWithValueType, VersionDescriptionWithValueType, DataEntry, DataEntryArray, SemanticlyNestedDataEntry, SemanticlyNestedDataDescription, ObjectGeneratorMethod, DefinitionGenerationObject, DefinitionNestedArray, DefinitionNestedGenerationObject, DefinitionSubObject, DefinitionArrayObject, VersionDefinitionObject, VersionEnumSemantics, ParserForVersion, VersionParsers, } from './types';
+export { SingleLevelContentType, NestedContentDataType, NestedContentType, DoubleLevelContentType, NonEmptyValidEntryArrayType, OptionalEntryDataType, EnumEntryDataType, VersionArrayDefinitionType, PrecisionRangeType, SignificandMaxBits, FloatData, IntegerMaxBits, IntData, VersionRangeType, VersionData, BooleanData, DataEntry, DataEntryArray, SemanticlyNestedDataEntry, ObjectGeneratorMethod, DefinitionGenerationObject, DefinitionNestedArray, DefinitionNestedGenerationObject, DefinitionSubObject, DefinitionArrayObject, VersionDefinitionObject, VersionEnumSemantics, ParserForVersion, ParsersForVersionObject, } from './types';
 export {} from './update';
 export { interpolateEntryAt, getRelativeValue } from './utils';

package/dist/index.js

@@ -27,18 +27,21 @@ var getBitsForIntegerNumber = (number, maxBits) => {
 };
 
 // src/factory/floatFactory.ts
-var create = (min, max, precision) => {
+var create = (value, min = 0, max = 1, precision = 2, name = "", index = -1) => {
   const precisionMultiplier = 10 ** precision;
   const roundedMin = Math.floor(min * precisionMultiplier);
   const roundedMax = Math.ceil(max * precisionMultiplier);
   const delta = roundedMax - roundedMin;
   const significand = Math.max(1, getBitsForIntegerNumber(delta, SignificandMaxBits));
   return {
+    value,
     type: DataType.FLOAT,
     min: roundedMin / precisionMultiplier,
     max: roundedMax / precisionMultiplier,
     precision,
-    significand
+    significand,
+    name,
+    index
   };
 };
 
@@ -46,7 +49,7 @@ var create = (min, max, precision) => {
 var IntegerMaxBits = 12;
 
 // src/factory/intFactory.ts
-var create2 = (min, max) => {
+var create2 = (value, min = 0, max = 10, name = "", index = -1) => {
   if (!Number.isInteger(min) || !Number.isInteger(max))
     throw new Error("min and max must be integers");
   if (max - min < 1)
@@ -54,23 +57,26 @@ var create2 = (min, max) => {
   if (Math.abs(max - min) > 2 ** IntegerMaxBits - 1)
     throw new Error("max - min must be less than 1024");
   const bits = getBitsForIntegerNumber(max - min + 1, IntegerMaxBits);
-  return { type: DataType.INT, min, max, bits };
+  return { value, type: DataType.INT, min, max, bits, name, index };
 };
 
 // src/factory/booleanFactory.ts
-var create3 = () => ({ type: DataType.BOOLEAN });
+var create3 = (value, name = "", index = -1) => ({ value, type: DataType.BOOLEAN, name, index });
 
 // src/factory/versionFactory.ts
-var create4 = (bits) => ({
+var create4 = (value, bits = 8, name = "", index = -1) => ({
+  value,
   type: DataType.VERSION,
-  bits
+  bits,
+  name,
+  index
 });
 
 // src/types/enumData.ts
 var EnumMaxBits = 8;
 
 // src/factory/enumFactory.ts
-var create5 = (max) => {
+var create5 = (value, max = 10, name = "", index = -1) => {
   if (!Number.isInteger(max))
     throw new Error("min and max must be integers");
   if (max < 1)
@@ -78,78 +84,17 @@ var create5 = (max) => {
   if (max > 2 ** EnumMaxBits - 1)
     throw new Error("max - min must be less than 256");
   const bits = getBitsForIntegerNumber(max + 1, EnumMaxBits);
-  return { type: DataType.ENUM, max, bits };
+  return { value, type: DataType.ENUM, max, bits, name, index };
 };
 
 // src/factory/factory.ts
-class DataRangeDescriptionFactory {
-  static createFloat = create;
-  static createInt = create2;
-  static createEnum = create5;
-  static createBoolean = create3;
-  static createVersion = create4;
-}
-
-class DataDescriptionFactory {
-  static createFloat = (min = 0, max = 1, precision = 2, name = "", index = 0) => ({
-    ...create(min, max, precision),
-    name,
-    index
-  });
-  static createInt = (min = 0, max = 10, name = "", index = 0) => ({
-    ...create2(min, max),
-    name,
-    index
-  });
-  static createEnum = (max = 10, name = "", index = 0) => ({
-    ...create5(max),
-    name,
-    index
-  });
-  static createBoolean = (name = "", index = 0) => ({
-    ...create3(),
-    name,
-    index
-  });
-  static createVersion = (bits = 8, name = "", index = 0) => ({
-    ...create4(bits),
-    name,
-    index
-  });
-}
-
-class DataEntryFactory {
-  static createFloat = (value, min = 0, max = 1, precision = 2, name = "", index = 0) => ({
-    ...create(min, max, precision),
-    value,
-    name,
-    index
-  });
-  static createInt = (value, min = 0, max = 10, name = "", index = 0) => ({
-    ...create2(min, max),
-    value,
-    name,
-    index
-  });
-  static createEnum = (value, max = 10, name = "", index = 0) => ({
-    ...create5(max),
-    value,
-    name,
-    index
-  });
-  static createBoolean = (value, name = "", index = 0) => ({
-    ...create3(),
-    value,
-    name,
-    index
-  });
-  static createVersion = (value, bits = 8, name = "", index = 0) => ({
-    ...create4(bits),
-    value,
-    name,
-    index
-  });
-}
+var DataEntryFactory = {
+  createFloat: create,
+  createInt: create2,
+  createEnum: create5,
+  createBoolean: create3,
+  createVersion: create4
+};
 // src/parsers/intParser.ts
 var getBitsCount = (intData2) => intData2.bits;
 var rawValueParser = (stateString, bitCount) => {
@@ -309,17 +254,20 @@ var dataArrayStringifier = (dataEntryArray) => {
 };
 
 // src/objectmap/versionReading.ts
-var parameterOffset = 100;
-var nestedDataEntryArrayToObject = (definitionArrayObject, startIndex) => {
-  const baseIndex = startIndex * parameterOffset;
-  return Object.fromEntries(definitionArrayObject.map((value, i) => {
+var currentObjectIndex = -1;
+var nestedDataEntryArrayToObject = (definitionArrayObject) => {
+  currentObjectIndex = -1;
+  return internalNestedDataEntryArrayToObject(definitionArrayObject);
+};
+var internalNestedDataEntryArrayToObject = (definitionArrayObject) => {
+  return Object.fromEntries(definitionArrayObject.map((value) => {
     if (Array.isArray(value)) {
       if (value.length === 2)
-        return [value[0], nestedDataEntryArrayToObject(value[1], baseIndex + i)];
+        return [value[0], internalNestedDataEntryArrayToObject(value[1])];
       else
-        return [value[0], nestedDataEntryArrayToObject(value[2](value[1]), baseIndex + i)];
+        return [value[0], internalNestedDataEntryArrayToObject(value[2](value[1]))];
     }
-    return [value.name, { ...value, index: baseIndex + i }];
+    return [value.name, { ...value, index: ++currentObjectIndex }];
   }));
 };
 var parseDownNestedDataDescription = (nestedDataDescription) => {
@@ -385,19 +333,24 @@ var updateValue6 = (original, update) => {
       return updateValue2(original, update);
     case DataType.ENUM:
       return updateValue3(original, update);
-    case DataType.VERSION:
-      return updateValue4(original, update);
     case DataType.BOOLEAN:
       return updateValue5(original, update);
+    case DataType.VERSION:
+      return updateValue4(original, update);
   }
 };
 
 // src/objectmap/versionUpdate.ts
+var currentObjectIndex2 = 0;
+var findExistingDataEntry = (dataEntry, dataEntryArray) => {
+  const dataEntryName = dataEntry.internalName ?? dataEntry.name;
+  return dataEntryArray.find((d) => (d.internalName ?? d.name) === dataEntryName);
+};
 var dataEntryUpdating = (dataEntry, dataEntryArray) => {
-  const existingDataEntry = dataEntryArray.find((d) => d.name === dataEntry.name);
+  const existingDataEntry = findExistingDataEntry(dataEntry, dataEntryArray);
   if (!existingDataEntry)
-    return [dataEntry.name, dataEntry];
-  return [dataEntry.name, updateValue6(dataEntry, existingDataEntry)];
+    return [dataEntry.name, { ...dataEntry, index: currentObjectIndex2++ }];
+  return [dataEntry.name, { ...updateValue6(dataEntry, existingDataEntry), index: currentObjectIndex2++ }];
 };
 var nestedDataEntryArrayUpdating = (definitionNestedArrray, dataEntryArray) => {
   const [keyString, nestedDefinitionArray] = definitionNestedArrray;
@@ -405,7 +358,7 @@ var nestedDataEntryArrayUpdating = (definitionNestedArrray, dataEntryArray) => {
 };
 var generationObjectUpdating = (definitionArrayObject, dataEntryArray) => {
   const [keyString, keyDataEntry, methodGenerator] = definitionArrayObject;
-  const foundKeyDataEntry = dataEntryArray.find((d) => d.name === keyDataEntry.name);
+  const foundKeyDataEntry = findExistingDataEntry(keyDataEntry, dataEntryArray);
   const newKeyData = foundKeyDataEntry ? updateValue6(keyDataEntry, foundKeyDataEntry) : keyDataEntry;
   return [keyString, updateDataEntryObject(methodGenerator(newKeyData), dataEntryArray)];
 };
@@ -427,15 +380,15 @@ var updateDataEntryObject = (definitionArrayObject, dataArray) => {
   });
   return newNestedObject;
 };
-var getDefaultObject = (versionObjects, versionindex) => {
-  const versionParser = versionObjects[versionindex];
-  if (!versionParser)
+var getDefaultObject = (versionParser, versionindex) => {
+  if (!versionParser.parsers[versionindex])
     throw new Error(`No parser for version ${versionindex} index`);
-  return nestedDataEntryArrayToObject(versionParser.objectGeneratorParameters, 0);
+  return nestedDataEntryArrayToObject(versionParser.parsers[versionindex].objectGeneratorParameters);
 };
-var updateDataEntry = (data, newDataEntry, versionObjects) => {
+var updateDataEntry = (data, newDataEntry, parsersForVersion) => {
+  currentObjectIndex2 = 0;
   const version = data.version;
-  const versionParser = versionObjects[version.value];
+  const versionParser = parsersForVersion[version.value];
   if (!versionParser)
     throw new Error(`No parser for version ${version.value}`);
   const correctedDataEntry = dataEntryCorrecting(newDataEntry);
@@ -493,7 +446,5 @@ export {
   ObjectGenerationOutputStatus,
   IntegerMaxBits,
   DataType,
-  DataRangeDescriptionFactory,
-  DataEntryFactory,
-  DataDescriptionFactory
+  DataEntryFactory
 };

package/dist/objectmap/versionArrayDefinitionToObjectDefintion.d.ts

@@ -6,9 +6,9 @@ export declare const singleLevelContentTypeIsDataEntry: (data: SingleLevelConten
 export declare const singleLevelContentTypeIsNestedContentDataType: (data: SingleLevelContentType) => boolean;
 export declare const singleLevelContentTypeIsEnumEntryDataType: (data: NestedContentType) => boolean;
 export declare const singleLevelContentTypeIsOptionalEntryDataType: (data: NestedContentType) => boolean;
-export declare const parseSingleLevelContentTypeToDefinitionSubObject: (data: SingleLevelContentType, currentIndex: number) => [number, DefinitionSubObject];
-export declare const parseNestedContentDataTypeToDefinitionNestedArray: (data: NestedContentDataType, currentIndex: number) => [number, DefinitionNestedArray | DefinitionNestedGenerationObject];
-export declare const parseEnumEntryDataTypeToDefinitionNestedGenerationObject: (data: EnumEntryDataType, name: string, currentIndex: number) => [number, DefinitionNestedGenerationObject];
-export declare const parseOptionalEntryDataTypeToDefinitionNestedGenerationObject: (data: OptionalEntryDataType, name: string, currentIndex: number) => [number, DefinitionNestedGenerationObject];
-export declare const parseDataEntry: (d: DataEntry, currentIndex: number) => [number, DataEntry];
+export declare const parseSingleLevelContentTypeToDefinitionSubObject: (data: SingleLevelContentType, internalPrecedingName?: string) => DefinitionSubObject;
+export declare const parseNestedContentDataTypeToDefinitionNestedArray: (data: NestedContentDataType, internalPrecedingName?: string) => DefinitionNestedArray | DefinitionNestedGenerationObject;
+export declare const parseEnumEntryDataTypeToDefinitionNestedGenerationObject: (data: EnumEntryDataType, name: string, internalPrecedingName?: string) => DefinitionNestedGenerationObject;
+export declare const parseOptionalEntryDataTypeToDefinitionNestedGenerationObject: (data: OptionalEntryDataType, name: string, internalPrecedingName?: string) => DefinitionNestedGenerationObject;
+export declare const parseDataEntry: (d: DataEntry, internalPrecedingName?: string) => DataEntry;
 export declare const parseVersionArrayDefinitionTypeToVersionDefinitionObject: (v: VersionArrayDefinitionType) => VersionDefinitionObject;

package/dist/objectmap/versionReading.d.ts

@@ -1,6 +1,6 @@
-import { DataDescription } from '../types/dataEntry';
-import { SemanticlyNestedDataDescription, SemanticlyNestedDataEntry } from '../types/semanticlyNestedDataEntry';
-import { DefinitionArrayObject, ParserForVersion } from '../types/versionParser';
+import { DataEntry } from '../types/dataEntry';
+import { SemanticlyNestedDataEntry } from '../types/semanticlyNestedDataEntry';
+import { DefinitionArrayObject, ParsersForVersionObject } from '../types/versionParser';
 /**
  * Method for finding the names of the variable data entries in the DefinitionArrayObject
  * @param definitionArrayObject - DefinitionArrayObject
@@ -10,12 +10,17 @@ export declare const getVariableStrings: (definitionArrayObject: DefinitionArray
 /**
  * Method that translates a DefinitionArrayObject into a SemanticlyNestedDataEntry
  * @param definitionArrayObject [DataEntry | [string, DefinitionArrayObject]]
- * @param startIndex
  * @returns
  */
-export declare const nestedDataEntryArrayToObject: (definitionArrayObject: DefinitionArrayObject, startIndex: number) => SemanticlyNestedDataEntry;
-export declare const parseUrlMethod: (url: string, parserVersions: ParserForVersion[]) => SemanticlyNestedDataEntry;
-export declare const parseDownNestedDataDescription: (nestedDataDescription: SemanticlyNestedDataDescription) => DataDescription[];
+export declare const nestedDataEntryArrayToObject: (definitionArrayObject: DefinitionArrayObject) => SemanticlyNestedDataEntry;
+/**
+ * Method to parse a url into a SemanticlyNestedDataEntry.
+ * @param url - the url to parse
+ * @param parserVersions - the object containing the version parsers
+ * @returns the parsed SemanticlyNestedDataEntry
+ */
+export declare const parseUrlMethod: (url: string, parserVersions: ParsersForVersionObject) => SemanticlyNestedDataEntry;
+export declare const parseDownNestedDataDescription: (nestedDataDescription: SemanticlyNestedDataEntry) => DataEntry[];
 /**
  * Method to get an URL descriptor from a SemanticlyNestedDataEntry
  * @param data: SemanticlyNestedDataEntry

package/dist/objectmap/versionUpdate.d.ts

@@ -1,6 +1,6 @@
 import { DataEntry, DataEntryArray } from '../types/dataEntry';
 import { SemanticlyNestedDataEntry } from '../types/semanticlyNestedDataEntry';
-import { DefinitionArrayObject, ParserForVersion } from '../types/versionParser';
+import { DefinitionArrayObject, ParserForVersion, ParsersForVersionObject } from '../types/versionParser';
 /**
  * Method to parse a definitionArrayObject according to a given dataArray
  * @param definitionArrayObject
@@ -8,12 +8,19 @@ import { DefinitionArrayObject, ParserForVersion } from '../types/versionParser'
  * @returns - new SemanticlyNestedDataEntry
  */
 export declare const updateDataEntryObject: (definitionArrayObject: DefinitionArrayObject, dataArray: DataEntryArray) => SemanticlyNestedDataEntry;
-export declare const getDefaultObject: (versionObjects: ParserForVersion[], versionindex: number) => SemanticlyNestedDataEntry;
+/**
+ * Get the default object for a given version
+ * @param versionParser - The parsers for all versions
+ * @param versionindex - The index of the version for which to get the default object
+ * @returns - The default object for the given version
+ * @throws - Error if no parser for the given version index
+ */
+export declare const getDefaultObject: (versionParser: ParsersForVersionObject, versionindex: number) => SemanticlyNestedDataEntry;
 /**
  * Method that handles the updating of a single value in a SemanticlyNestedDataEntry object
  * @param data SemanticlyNestedDataEntry
  * @param newDataEntry updated DataEntry
- * @param versionObjects version object
+ * @param parsersForVersion version object
  * @returns a newly created object in case of a key data description, otherwise the same object with just the new Data Entry value updated
  */
-export declare const updateDataEntry: (data: SemanticlyNestedDataEntry, newDataEntry: DataEntry, versionObjects: ParserForVersion[]) => SemanticlyNestedDataEntry;
+export declare const updateDataEntry: (data: SemanticlyNestedDataEntry, newDataEntry: DataEntry, parsersForVersion: ParserForVersion[]) => SemanticlyNestedDataEntry;

package/dist/parsers/parsers.d.ts

@@ -1,14 +1,14 @@
-import { DataDescription, DataEntry, DataEntryArray, DataRangeDescription } from '../types/dataEntry';
-export declare const valueBitsParser: (bitString: string, mapData: DataRangeDescription) => number | boolean;
-export declare const dataBitsParser: (rawString: string, mapData: DataDescription) => DataEntry;
-export declare const getBitsCount: (mapData: DataRangeDescription) => number;
+import { DataEntryArray, DataEntry } from '../types/dataEntry';
+export declare const valueBitsParser: (bitString: string, mapData: DataEntry) => number | boolean;
+export declare const dataBitsParser: (rawString: string, mapData: DataEntry) => DataEntry;
+export declare const getBitsCount: (mapData: DataEntry) => number;
 /**
  * Method to convert a bitstring into an array of data entries
  * @param bitString bitstring to parse into bits and then data entries
  * @param mapDataArray Data descriptions to map the bits to data entries
  * @returns array of data entries
  */
-export declare const dataBitsArrayParser: (bitString: string, mapDataArray: DataDescription[]) => DataEntryArray;
+export declare const dataBitsArrayParser: (bitString: string, mapDataArray: DataEntry[]) => DataEntryArray;
 export declare const dataBitsStringifier: (data: DataEntry) => string;
 export declare const dataEntryCorrecting: (dataEntry: DataEntry) => DataEntry;
 export declare const parseBitsToBase64: (bits: string) => string;

package/dist/test/arrayDefinition.example.d.ts

@@ -1,4 +1,4 @@
-import { ParserForVersion } from '../types';
+import { ParsersForVersionObject } from '../types';
 import { NestedContentDataType, OptionalEntryDataType, EnumEntryDataType, VersionArrayDefinitionType, NestedContentType } from '../types/arrayDefinitions';
 export declare const nestedContentDataType: NestedContentDataType;
 export declare const validOptionalEntryType: OptionalEntryDataType;
@@ -11,4 +11,4 @@ export declare const footprintDefinition: EnumEntryDataType;
 export declare const heightParsingDefinition: NestedContentType;
 export declare const shapePreProcessingDefinition: EnumEntryDataType;
 export declare const lucernaeTurici: VersionArrayDefinitionType;
-export declare const lucernaeTuriciVersions: ParserForVersion[];
+export declare const lucernaeTuriciVersions: ParsersForVersionObject;

package/dist/test/realLifeExample.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/updating.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/arrayDefinitions.d.ts

@@ -1,4 +1,4 @@
-import { DataEntry, VersionDescriptionWithValueType } from './dataEntry';
+import { DataEntry, VersionDataEntry } from './dataEntry';
 export type SingleLevelContentType = DataEntry | NestedContentDataType;
 export type NestedContentDataType = [string, NestedContentType];
 export type NestedContentType = SingleLevelContentType[] | DoubleLevelContentType;
@@ -6,6 +6,6 @@ export type DoubleLevelContentType = OptionalEntryDataType | EnumEntryDataType;
 export type NonEmptyValidEntryArrayType = [SingleLevelContentType, ...SingleLevelContentType[]];
 export type OptionalEntryDataType = [boolean, NonEmptyValidEntryArrayType, []] | [boolean, [], NonEmptyValidEntryArrayType];
 export type EnumEntryDataType = [number, NonEmptyValidEntryArrayType, NonEmptyValidEntryArrayType, ...SingleLevelContentType[][]];
-export type VersionArrayDefinitionType = [VersionDescriptionWithValueType, ...SingleLevelContentType[]];
+export type VersionArrayDefinitionType = [VersionDataEntry, ...SingleLevelContentType[]];
 export declare const INDEX_DELIMETER = "$";
 export declare const NAME_DELIMETER = "_";

package/dist/types/booleanData.d.ts

@@ -1,4 +1,5 @@
 import { DataType } from '../enums/dataTypes';
-export interface BooleanData {
+export type BooleanData = {
     type: DataType.BOOLEAN;
-}
+    value: boolean;
+};

package/dist/types/dataEntry.d.ts

@@ -6,28 +6,16 @@ import { VersionData } from './versionData';
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 };
-export type DataRangeDescription = VersionData | BooleanData | IntData | EnumData | FloatData;
-interface DataNamingDescription {
+type DataDescription = {
     name: string;
+    internalName?: string;
     index: number;
-}
-export type BooleanDiscriptionType = Prettify<BooleanData & DataNamingDescription>;
-export type IntDiscriptionType = Prettify<IntData & DataNamingDescription>;
-export type EnumDiscriptionType = Prettify<EnumData & DataNamingDescription>;
-export type FloatDiscriptionType = Prettify<FloatData & DataNamingDescription>;
-export type VersionDiscriptionType = Prettify<VersionData & DataNamingDescription>;
-export type DataDescription = BooleanDiscriptionType | IntDiscriptionType | EnumDiscriptionType | FloatDiscriptionType | VersionDiscriptionType;
-interface DataEntryDescriptionBoolean {
-    value: boolean;
-}
-interface DataEntryDescriptionNumeric {
-    value: number;
-}
-export type BooleanDescriptionWithValueType = Prettify<BooleanData & DataNamingDescription & DataEntryDescriptionBoolean>;
-export type IntDescriptionWithValueType = Prettify<IntData & DataNamingDescription & DataEntryDescriptionNumeric>;
-export type EnumDescriptionWithValueType = Prettify<EnumData & DataNamingDescription & DataEntryDescriptionNumeric>;
-export type FloatDescriptionWithValueType = Prettify<FloatData & DataNamingDescription & DataEntryDescriptionNumeric>;
-export type VersionDescriptionWithValueType = Prettify<VersionData & DataNamingDescription & DataEntryDescriptionNumeric>;
-export type DataEntry = BooleanDescriptionWithValueType | IntDescriptionWithValueType | EnumDescriptionWithValueType | FloatDescriptionWithValueType | VersionDescriptionWithValueType;
+};
+export type BooleanDataEntry = Prettify<BooleanData & DataDescription>;
+export type IntDataEntry = Prettify<IntData & DataDescription>;
+export type EnumDataEntry = Prettify<EnumData & DataDescription>;
+export type FloatDataEntry = Prettify<FloatData & DataDescription>;
+export type VersionDataEntry = Prettify<VersionData & DataDescription>;
+export type DataEntry = BooleanDataEntry | IntDataEntry | EnumDataEntry | FloatDataEntry | VersionDataEntry;
 export type DataEntryArray = DataEntry[];
 export {};

package/dist/types/enumData.d.ts

@@ -1,7 +1,8 @@
 import { DataType } from '../enums/dataTypes';
 export declare const EnumMaxBits = 8;
-export interface EnumData {
+export type EnumData = {
     type: DataType.ENUM;
+    value: number;
     max: number;
     bits: number;
-}
+};

package/dist/types/floatData.d.ts

@@ -1,10 +1,11 @@
 import { DataType } from '../enums/dataTypes';
 export type PrecisionRangeType = -3 | -2 | -1 | 0 | 1 | 2 | 3;
 export declare const SignificandMaxBits = 20;
-export interface FloatData {
+export type FloatData = {
     type: DataType.FLOAT;
+    value: number;
     min: number;
     max: number;
     precision: PrecisionRangeType;
     significand: number;
-}
+};

package/dist/types/intData.d.ts

@@ -1,8 +1,9 @@
 import { DataType } from '../enums/dataTypes';
 export declare const IntegerMaxBits = 12;
-export interface IntData {
+export type IntData = {
     type: DataType.INT;
+    value: number;
     min: number;
     max: number;
     bits: number;
-}
+};

package/dist/types/semanticlyNestedDataEntry.d.ts

@@ -1,7 +1,4 @@
-import { DataDescription, DataEntry } from './dataEntry';
+import { DataEntry } from './dataEntry';
 export type SemanticlyNestedDataEntry = {
     [key: string]: SemanticlyNestedDataEntry | DataEntry;
 };
-export type SemanticlyNestedDataDescription = {
-    [key: string]: SemanticlyNestedDataDescription | DataDescription;
-};

package/dist/types/versionData.d.ts

@@ -1,10 +1,7 @@
 import { DataType } from '../enums/dataTypes';
 export type VersionRangeType = 4 | 6 | 8 | 10;
-export interface VersionData {
+export type VersionData = {
     type: DataType.VERSION;
+    value: number;
     bits: VersionRangeType;
-}
-export interface GlobalVersion {
-    type: DataType.VERSION;
-    bits: 8;
-}
+};

package/dist/types/versionParser.d.ts

@@ -1,7 +1,7 @@
 import { ObjectGenerationOutputStatus } from '../enums/objectGenerationTypes';
-import { DataEntry, VersionDiscriptionType } from './dataEntry';
+import { DataEntry, VersionDataEntry } from './dataEntry';
 import { SemanticlyNestedDataEntry } from './semanticlyNestedDataEntry';
-import { GlobalVersion, VersionRangeType } from './versionData';
+import { VersionRangeType } from './versionData';
 /**
  * A method that generates a nested object based on a set of values
  * @param s - url bit string (optional)
@@ -14,7 +14,7 @@ export type DefinitionNestedArray = [string, DefinitionArrayObject];
 export type DefinitionNestedGenerationObject = [string, DataEntry, DefinitionGenerationObject];
 export type DefinitionSubObject = DataEntry | DefinitionNestedArray | DefinitionNestedGenerationObject;
 export type DefinitionArrayObject = DefinitionSubObject[];
-export type VersionDefinitionObject = [VersionDiscriptionType, ...DefinitionArrayObject];
+export type VersionDefinitionObject = [VersionDataEntry, ...DefinitionArrayObject];
 export type VersionEnumSemantics = {
     [key: string]: {
         value: number;
@@ -22,13 +22,10 @@ export type VersionEnumSemantics = {
     }[];
 };
 export type ParserForVersion = {
-    version: number;
-    versionBitCount: VersionRangeType;
-    versionName: string;
     versionEnumSemantics?: VersionEnumSemantics;
     objectGeneratorParameters: VersionDefinitionObject;
 };
-export type VersionParsers = {
-    versionRange: GlobalVersion;
-    versionParsers: ParserForVersion[];
+export type ParsersForVersionObject = {
+    versionBitCount: VersionRangeType;
+    parsers: ParserForVersion[];
 };

package/dist/update/booleanUpdate.d.ts

@@ -1,2 +1,2 @@
-import { BooleanDescriptionWithValueType } from '../types/dataEntry';
-export declare const updateValue: (original: BooleanDescriptionWithValueType, update: BooleanDescriptionWithValueType) => BooleanDescriptionWithValueType;
+import { BooleanDataEntry } from '../types/dataEntry';
+export declare const updateValue: (original: BooleanDataEntry, update: BooleanDataEntry) => BooleanDataEntry;

package/dist/update/enumUpdate.d.ts

@@ -1,2 +1,2 @@
-import { EnumDescriptionWithValueType } from '../types/dataEntry';
-export declare const updateValue: (original: EnumDescriptionWithValueType, update: EnumDescriptionWithValueType) => EnumDescriptionWithValueType;
+import { EnumDataEntry } from '../types/dataEntry';
+export declare const updateValue: (original: EnumDataEntry, update: EnumDataEntry) => EnumDataEntry;

package/dist/update/floatUpdate.d.ts

@@ -1,2 +1,2 @@
-import { FloatDescriptionWithValueType } from '../types/dataEntry';
-export declare const updateValue: (original: FloatDescriptionWithValueType, update: FloatDescriptionWithValueType) => FloatDescriptionWithValueType;
+import { FloatDataEntry } from '../types/dataEntry';
+export declare const updateValue: (original: FloatDataEntry, update: FloatDataEntry) => FloatDataEntry;

package/dist/update/intUpdate.d.ts

@@ -1,2 +1,2 @@
-import { IntDescriptionWithValueType } from '../types/dataEntry';
-export declare const updateValue: (original: IntDescriptionWithValueType, update: IntDescriptionWithValueType) => IntDescriptionWithValueType;
+import { IntDataEntry } from '../types/dataEntry';
+export declare const updateValue: (original: IntDataEntry, update: IntDataEntry) => IntDataEntry;

package/dist/update/versionUpdate.d.ts

@@ -1,2 +1,2 @@
-import { VersionDescriptionWithValueType } from '../types/dataEntry';
-export declare const updateValue: (original: VersionDescriptionWithValueType, update: VersionDescriptionWithValueType) => VersionDescriptionWithValueType;
+import { VersionDataEntry } from '../types/dataEntry';
+export declare const updateValue: (original: VersionDataEntry, update: VersionDataEntry) => VersionDataEntry;

package/package.json

@@ -7,7 +7,7 @@
     "dist/*"
   ],
   "type": "module",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "author": "Jonas Ward",
   "description": "Library for creating web safe base64 objects with custom bith widths and dynamic values.",
   "scripts": {