url-safe-bitpacking 0.1.1 → 0.1.3

package/README.md

@@ -1,15 +1,71 @@
 # url-safe-bitpacking
 
-To install dependencies:
+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.
 
-```bash
-bun install
+## 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.
+
+The library heavily relies on the bitpacking of custom bitwidth numeric values. Because of that, the biggest trade-off for this library is legibility. Without the related object definition, it would be impossible to reconstruct the state.
+
+The big advantage though is the ability to store rather many variables in a very condensed URL, allowing to store all information in rather short urls which then can be used for qr code generation.
+
+## data types
+
+Currently, there are 4 data types implemented (+1 special case for safety). All data entries have a name that will behave as an attribute name in the object.
+
+### bool
+
+Bool type values are simple yes or no, 1 or 0s, nothing special
+
+```typescript
+DataEntryFactory.createBoolean(false, 'shapePreProcessingWarpabsolute');
 ```
 
-To run:
+### enum
 
-```bash
-bun run index.ts
+An enum in this context is a continuous array of integers. The Bitwidth of this data type is defined by the maximum entry. eg. in case you you would need 21 states, the larges value would be 20. The value 20 would require at least five bits (log2(20) ~ 4.32). The maximum bitwidth for enums is right now hardcoded to 8-bit (which would be the range [0, 255] ).
+
+```typescript
+DataEntryFactory.createEnum(0, 3, 'footprintType');
+```
+
+### int
+
+An int type is rather similar to the enum, except that it starts at a specific minimum value. The range that then needs to be able to be stored is: max - min. In case you would need values from -30 to 10, you would have to be able to store 10 - 30 + 1 = 51 states. This would require a bitwidth of 6 (log2(51) ~ 5.67). The max bitwidth is now hardcoded to be 12 (which would be the range [minimum, 4095 - minimum])
+
+```typescript
+DataEntryFactory.createInt(5, 3, 20, 'circleDivisions');
 ```
 
-This project was created using `bun init` in bun v1.0.7. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.
+### 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.
+
+```typescript
+DataEntryFactory.createFloat(20, 10, 200, -1, 'shapePreProcessingWarptotal');
+```
+
+### version
+
+There is also a Version object which is a special case of the enum data type and has a bitwidth of 4, 6, 8 or, 10 and always occupies the first bits of the bitarray.
+
+```typescript
+DataEntryFactory.createVersion(0, 8, 'version');
+```
+
+## attribute map
+
+On a macro level there are two types of data. Either Single Level array objects or Double Nested array objects.
+
+Single-level nested objects are arrays in which the entries it contains describe themselves. The Double Nested arrays describe objects that will have a variable size, that depends on the linked data entry that is selected is set in state.
+
+For the Double Nested arrays there are currently two variations: either an Optional type, which only accepts two values of which is an empty array and will be toggle on/off in relation to a certain boolean data entry.
+
+Install
+
+```bash
+npm install url-safe-bitpacking
+yarn install url-safe-bitpacking
+bun install url-safe-bitpacking
+```

package/dist/enums/dataTypes.d.ts

@@ -0,0 +1,7 @@
+export declare enum DataType {
+    VERSION = 0,
+    BOOLEAN = 1,
+    ENUM = 2,
+    INT = 3,
+    FLOAT = 4
+}

package/dist/enums/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dataTypes';
+export * from './objectGenerationTypes';

package/dist/enums/objectGenerationTypes.d.ts

@@ -0,0 +1,6 @@
+export declare enum ObjectGenerationOutputStatus {
+    DEFAULT = 0,// means that a default value was used to create the object
+    FROM_TYPE = 1,// means that the object was created from a type entry (non undefined input)
+    PARSED = 2,// means that the object was created by parsing a string
+    ERROR_PARSING = 3
+}

package/dist/factory/booleanFactory.d.ts

@@ -0,0 +1,2 @@
+import { BooleanData } from '../types/booleanData';
+export declare const create: () => BooleanData;

package/dist/factory/enumFactory.d.ts

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

package/dist/factory/factory.d.ts

@@ -0,0 +1,29 @@
+import { create as createFloat } from './floatFactory';
+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;
+}

package/dist/factory/floatFactory.d.ts

@@ -0,0 +1,2 @@
+import { FloatData, PrecisionRangeType } from '../types/floatData';
+export declare const create: (min: number, max: number, precision: PrecisionRangeType) => FloatData;

package/dist/factory/helperMethod.d.ts

@@ -0,0 +1 @@
+export declare const getBitsForIntegerNumber: (number: number, maxBits: number) => number;

package/dist/factory/index.d.ts

@@ -0,0 +1 @@
+export * from './factory';

package/dist/factory/intFactory.d.ts

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

package/dist/factory/versionFactory.d.ts

@@ -0,0 +1,2 @@
+import { VersionRangeType, VersionData } from '../types/versionData';
+export declare const create: (bits: VersionRangeType) => VersionData;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export * from './enums';
-export * from './factory';
-export * from './objectmap';
-export * from './parsers';
-export * from './types';
-export * from './update';
-export * from './utils';
+export { ObjectGenerationOutputStatus, DataType } from './enums';
+export { DataRangeDescriptionFactory, DataDescriptionFactory, 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 {} from './update';
+export { interpolateEntryAt, getRelativeValue } from './utils';

package/dist/index.js

@@ -310,18 +310,6 @@ var dataArrayStringifier = (dataEntryArray) => {
 
 // src/objectmap/versionReading.ts
 var parameterOffset = 100;
-var getVariableStrings = (definitionArrayObject) => {
-  const keys = [];
-  definitionArrayObject.forEach((value) => {
-    if (Array.isArray(value)) {
-      if (value.length === 2)
-        keys.push(...getVariableStrings(value[1]));
-      if (value.length === 3)
-        keys.push(value[1].name);
-    }
-  });
-  return keys;
-};
 var nestedDataEntryArrayToObject = (definitionArrayObject, startIndex) => {
   const baseIndex = startIndex * parameterOffset;
   return Object.fromEntries(definitionArrayObject.map((value, i) => {
@@ -334,60 +322,6 @@ var nestedDataEntryArrayToObject = (definitionArrayObject, startIndex) => {
     return [value.name, { ...value, index: baseIndex + i }];
   }));
 };
-var definitionArrayObjectParser = (bitString, v, orderIndex) => {
-  const [key, values] = v;
-  const [nestedSemanticObject, objectGenerationStatus, localEndIndex] = parsingDefinitionArrayObject(bitString, values, orderIndex);
-  return [[key, nestedSemanticObject], objectGenerationStatus, localEndIndex];
-};
-var methodParser = (bitString, v, orderIndex) => {
-  const [key, keyDataDescription, methodGenerator] = v;
-  const [keyDataEntry, status, bitWidth] = dataEntryParser(bitString, keyDataDescription, orderIndex);
-  const [result, localStatus, localEndIndex] = definitionArrayObjectParser(bitString, [key, methodGenerator(keyDataEntry)], orderIndex);
-  return [result, localStatus !== ObjectGenerationOutputStatus.PARSED ? localStatus : status, localEndIndex];
-};
-var dataEntryParser = (bitString, v, baseOrderIndex) => {
-  const bitWidth = getBitsCount6(v);
-  const value = dataBitsParser(bitString.slice(0, bitWidth), v);
-  return [{ ...value, index: baseOrderIndex }, ObjectGenerationOutputStatus.PARSED, bitWidth];
-};
-var parsingDefinitionArrayObject = (bitString, definitionArrayObject, orderIndex) => {
-  const baseOrderIndex = orderIndex * parameterOffset;
-  let startIndex = 0;
-  let objectGenerationStatus = ObjectGenerationOutputStatus.PARSED;
-  return [
-    Object.fromEntries(definitionArrayObject.map((value, i) => {
-      if (Array.isArray(value)) {
-        if (value.length === 2) {
-          const [[key, nestedSemanticObject], status, localEndIndex] = definitionArrayObjectParser(bitString.slice(startIndex), value, baseOrderIndex + i);
-          startIndex += localEndIndex;
-          ObjectGenerationOutputStatus.PARSED;
-          return [key, nestedSemanticObject];
-        } else {
-          const [[key, nestedSemanticObject], status, localEndIndex] = methodParser(bitString.slice(startIndex), value, baseOrderIndex + i);
-          startIndex += localEndIndex;
-          ObjectGenerationOutputStatus.PARSED;
-          return [key, nestedSemanticObject];
-        }
-      } else {
-        const [dataEntry, status, localEndIndex] = dataEntryParser(bitString.slice(startIndex), value, baseOrderIndex + i);
-        startIndex += localEndIndex;
-        ObjectGenerationOutputStatus.PARSED;
-        return [dataEntry.name, dataEntry];
-      }
-    })),
-    objectGenerationStatus,
-    startIndex
-  ];
-};
-var readingVersion = (bitstring) => dataBitsArrayParser(bitstring, [DataDescriptionFactory.createVersion(8)])[0];
-var parseUrlMethod = (url, parserVersions) => {
-  const bitString = parseBase64ToBits(url);
-  const version = readingVersion(bitString);
-  const versionParser = parserVersions[version.value];
-  if (!versionParser)
-    throw new Error(`No parser for version ${version.value}`);
-  return parsingDefinitionArrayObject(bitString, versionParser.objectGeneratorParameters, 0)[0];
-};
 var parseDownNestedDataDescription = (nestedDataDescription) => {
   const dataDescriptions = [];
   Object.values(nestedDataDescription).forEach((value) => {
@@ -398,28 +332,6 @@ var parseDownNestedDataDescription = (nestedDataDescription) => {
   });
   return dataDescriptions.sort();
 };
-var getURLForData = (data) => {
-  const dataEntryArray = parseDownNestedDataDescription(data);
-  const bitstring = dataArrayStringifier(dataEntryArray);
-  return parseBitsToBase64(bitstring);
-};
-var getTestStringValues = (data) => {
-  const dataEntryArray = parseDownNestedDataDescription(data);
-  const bitstring = dataArrayStringifier(dataEntryArray);
-  const url = parseBitsToBase64(bitstring);
-  const dataValueStrings = dataEntryArray.map((dataEntry) => dataBitsStringifier(dataEntry));
-  const singleString = dataValueStrings.join("");
-  const base64bitStringArray = singleString.match(/.{1,6}/g)?.map((c) => c.padEnd(6, "0")) ?? [];
-  const base64valueArray = url.split("").map((c) => c.padStart(6, "_"));
-  const raw = JSON.stringify(parseDownNestedDataDescription(data), undefined, 1);
-  return {
-    bitsString: dataValueStrings.join("-"),
-    base64BitString: base64bitStringArray.join("-"),
-    base64SplitString: base64valueArray.join("-"),
-    base64String: url,
-    raw
-  };
-};
 // src/update/floatUpdate.ts
 var updateValue = (original, update) => {
   const value = Math.max(Math.min(update.value, original.max), original.min);
@@ -565,18 +477,10 @@ var getRelativeValue = (dataEntry2) => {
 };
 export {
   valueBitsParser,
-  updateValue6 as updateValue,
-  updateDataEntryObject,
   updateDataEntry,
-  parseUrlMethod,
-  parseDownNestedDataDescription,
   parseBitsToBase64,
   parseBase64ToBits,
-  nestedDataEntryArrayToObject,
   interpolateEntryAt,
-  getVariableStrings,
-  getURLForData,
-  getTestStringValues,
   getRelativeValue,
   getDefaultObject,
   getBitsCount6 as getBitsCount,
@@ -588,7 +492,6 @@ export {
   SignificandMaxBits,
   ObjectGenerationOutputStatus,
   IntegerMaxBits,
-  EnumMaxBits,
   DataType,
   DataRangeDescriptionFactory,
   DataEntryFactory,

package/dist/objectmap/index.d.ts

@@ -0,0 +1,2 @@
+export * from './versionReading';
+export * from './versionUpdate';

package/dist/objectmap/versionArrayDefinitionToObjectDefintion.d.ts

@@ -0,0 +1,14 @@
+import { DataEntry, DefinitionNestedArray, DefinitionNestedGenerationObject, DefinitionSubObject, VersionDefinitionObject } from '../types';
+import { EnumEntryDataType, OptionalEntryDataType, NestedContentType, NestedContentDataType, SingleLevelContentType, VersionArrayDefinitionType } from '../types/arrayDefinitions';
+export declare const isSingleLevelContentType: (data: NestedContentType) => boolean;
+export declare const isDoubleLevelContentType: (data: NestedContentType) => boolean;
+export declare const singleLevelContentTypeIsDataEntry: (data: SingleLevelContentType) => boolean;
+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 parseVersionArrayDefinitionTypeToVersionDefinitionObject: (v: VersionArrayDefinitionType) => VersionDefinitionObject;

package/dist/objectmap/versionReading.d.ts

@@ -0,0 +1,31 @@
+import { DataDescription } from '../types/dataEntry';
+import { SemanticlyNestedDataDescription, SemanticlyNestedDataEntry } from '../types/semanticlyNestedDataEntry';
+import { DefinitionArrayObject, ParserForVersion } from '../types/versionParser';
+/**
+ * Method for finding the names of the variable data entries in the DefinitionArrayObject
+ * @param definitionArrayObject - DefinitionArrayObject
+ * @returns string[] - the key strings
+ */
+export declare const getVariableStrings: (definitionArrayObject: DefinitionArrayObject) => string[];
+/**
+ * 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[];
+/**
+ * Method to get an URL descriptor from a SemanticlyNestedDataEntry
+ * @param data: SemanticlyNestedDataEntry
+ * @returns base64 string
+ */
+export declare const getURLForData: (data: SemanticlyNestedDataEntry) => string;
+export declare const getTestStringValues: (data: SemanticlyNestedDataEntry) => {
+    bitsString: string;
+    base64BitString: string;
+    base64SplitString: string;
+    base64String: string;
+    raw: string;
+};

package/dist/objectmap/versionUpdate.d.ts

@@ -0,0 +1,19 @@
+import { DataEntry, DataEntryArray } from '../types/dataEntry';
+import { SemanticlyNestedDataEntry } from '../types/semanticlyNestedDataEntry';
+import { DefinitionArrayObject, ParserForVersion } from '../types/versionParser';
+/**
+ * Method to parse a definitionArrayObject according to a given dataArray
+ * @param definitionArrayObject
+ * @param dataArray
+ * @returns - new SemanticlyNestedDataEntry
+ */
+export declare const updateDataEntryObject: (definitionArrayObject: DefinitionArrayObject, dataArray: DataEntryArray) => SemanticlyNestedDataEntry;
+export declare const getDefaultObject: (versionObjects: ParserForVersion[], 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
+ * @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;

package/dist/parsers/booleanParser.d.ts

@@ -0,0 +1,4 @@
+export declare const getBitsCount: () => number;
+export declare const rawValueParser: (stateString: string) => boolean;
+export declare const rawParser: (stateString: string) => boolean;
+export declare const rawStringifier: (value: boolean) => string;

package/dist/parsers/enumParser.d.ts

@@ -0,0 +1,4 @@
+import { EnumData } from '../types/enumData';
+export declare const getBitsCount: (versionData: EnumData) => number;
+export declare const rawParser: (rawString: string, versionData: EnumData) => number;
+export declare const rawStringifier: (value: number, versionData: EnumData) => string;

package/dist/parsers/floatParser.d.ts

@@ -0,0 +1,5 @@
+import { FloatData, PrecisionRangeType } from '../types/floatData';
+export declare const getBitsCount: (floatData: FloatData) => number;
+export declare const rawValueParser: (stateString: string, significandBits: number, precision: PrecisionRangeType) => number;
+export declare const rawParser: (stateString: string, floatData: FloatData) => number;
+export declare const rawStringifier: (value: number, floatData: FloatData) => string;

package/dist/parsers/index.d.ts

@@ -0,0 +1 @@
+export * from './parsers';

package/dist/parsers/intParser.d.ts

@@ -0,0 +1,6 @@
+import { IntData } from '../types/intData';
+export declare const getBitsCount: (intData: IntData) => number;
+export declare const rawValueParser: (stateString: string, bitCount: number) => number;
+export declare const rawParser: (stateString: string, intData: IntData) => number;
+export declare const rawIntStringifier: (value: number, bitCount: number) => string;
+export declare const rawStringifier: (value: number, intData: IntData) => string;

package/dist/parsers/parsers.d.ts

@@ -0,0 +1,21 @@
+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;
+/**
+ * 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 dataBitsStringifier: (data: DataEntry) => string;
+export declare const dataEntryCorrecting: (dataEntry: DataEntry) => DataEntry;
+export declare const parseBitsToBase64: (bits: string) => string;
+export declare const parseBase64ToBits: (base64: string) => string;
+/**
+ * Method to convert an array of data entries into a base64 string
+ * @param dataArray Data Entries to read to parse into bits and then a base64 string
+ * @returns bitstring representation of the data entries
+ */
+export declare const dataArrayStringifier: (dataEntryArray: DataEntryArray) => string;

package/dist/parsers/versionParser.d.ts

@@ -0,0 +1,4 @@
+import { VersionData } from '../types/versionData';
+export declare const getBitsCount: (versionData: VersionData) => number;
+export declare const rawParser: (rawString: string, versionData: VersionData) => number;
+export declare const rawStringifier: (value: number, versionData: VersionData) => string;

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

@@ -0,0 +1,12 @@
+import { NestedContentDataType, OptionalEntryDataType, EnumEntryDataType, VersionArrayDefinitionType, NestedContentType } from '../types/arrayDefinitions';
+export declare const nestedContentDataType: NestedContentDataType;
+export declare const validOptionalEntryType: OptionalEntryDataType;
+export declare const anotherValidOptionalEntryType: OptionalEntryDataType;
+export declare const validEnumEntryType: EnumEntryDataType;
+export declare const generalNestedContentDataType: NestedContentDataType;
+export declare const exampleVersion: VersionArrayDefinitionType;
+export declare const lucernaeTuricumArcExamples: EnumEntryDataType;
+export declare const footprintDefinition: EnumEntryDataType;
+export declare const heightParsingDefinition: NestedContentType;
+export declare const shapePreProcessingDefinition: EnumEntryDataType;
+export declare const lucernaeTurici: VersionArrayDefinitionType;

package/dist/test/boolean.test.d.ts

@@ -0,0 +1 @@
+export declare const values: [boolean, string][];

package/dist/test/dataParser.test.d.ts

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

package/dist/test/enum.test.d.ts

@@ -0,0 +1 @@
+export declare const values: [number, number, string][];

package/dist/test/float.test.d.ts

@@ -0,0 +1,2 @@
+import { PrecisionRangeType } from '../types';
+export declare const values: [number, number, number, PrecisionRangeType, string][];

package/dist/test/int.test.d.ts

@@ -0,0 +1 @@
+export declare const values: [number, number, number, string][];

package/dist/test/parsingArrayDefinition.test.d.ts

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

package/dist/test/version.test.d.ts

@@ -0,0 +1,2 @@
+import { VersionRangeType } from '../types';
+export declare const values: [number, VersionRangeType, string][];

package/dist/types/arrayDefinitions.d.ts

@@ -0,0 +1,11 @@
+import { DataEntry, VersionDescriptionWithValueType } from './dataEntry';
+export type SingleLevelContentType = DataEntry | NestedContentDataType;
+export type NestedContentDataType = [string, NestedContentType];
+export type NestedContentType = SingleLevelContentType[] | DoubleLevelContentType;
+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 declare const INDEX_DELIMETER = "$";
+export declare const NAME_DELIMETER = "_";

package/dist/types/booleanData.d.ts

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

package/dist/types/dataEntry.d.ts

@@ -0,0 +1,33 @@
+import { BooleanData } from './booleanData';
+import { EnumData } from './enumData';
+import { FloatData } from './floatData';
+import { IntData } from './intData';
+import { VersionData } from './versionData';
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+};
+export type DataRangeDescription = VersionData | BooleanData | IntData | EnumData | FloatData;
+interface DataNamingDescription {
+    name: 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 DataEntryArray = DataEntry[];
+export {};

package/dist/types/enumData.d.ts

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

package/dist/types/floatData.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from './booleanData';
+export * from './dataEntry';
+export * from './enumData';
+export * from './floatData';
+export * from './intData';
+export * from './semanticlyNestedDataEntry';
+export * from './versionData';
+export * from './versionParser';
+export * from './arrayDefinitions';

package/dist/types/intData.d.ts

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

package/dist/types/semanticlyNestedDataEntry.d.ts

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

package/dist/types/versionData.d.ts

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

package/dist/types/versionParser.d.ts

@@ -0,0 +1,33 @@
+import { ObjectGenerationOutputStatus } from '../enums/objectGenerationTypes';
+import { DataEntry, VersionDiscriptionType } from './dataEntry';
+import { SemanticlyNestedDataEntry } from './semanticlyNestedDataEntry';
+import { GlobalVersion } from './versionData';
+/**
+ * A method that generates a nested object based on a set of values
+ * @param s - url bit string (optional)
+ * @param v - The values to be used to generate the object, can be either a valid value for a dataentry, a bitstring (only 0 or 1 chars) or undefined (default value)
+ * @returns [The generated object, the generation status, the index end bit of the bit url (-1 if)]
+ */
+export type ObjectGeneratorMethod = (s?: string, ...v: (DataEntry | undefined)[]) => [SemanticlyNestedDataEntry, ObjectGenerationOutputStatus, number];
+export type DefinitionGenerationObject = (v: DataEntry) => DefinitionArrayObject;
+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 VersionEnumSemantics = {
+    [key: string]: {
+        value: number;
+        label: string;
+    }[];
+};
+export type ParserForVersion = {
+    version: number;
+    versionName: string;
+    versionEnumSemantics?: VersionEnumSemantics;
+    objectGeneratorParameters: VersionDefinitionObject;
+};
+export type VersionParsers = {
+    versionRange: GlobalVersion;
+    versionParsers: ParserForVersion[];
+};