url-safe-bitpacking 0.1.14 → 0.2.0

package/dist/parsers/arrayParser.d.ts

@@ -0,0 +1,4 @@
+import { ArrayDataEntry } from '@/types';
+export declare const rawParser: (bitString: string, arrayData: ArrayDataEntry) => [ArrayDataEntry, string];
+export declare const rawStateStringifier: (arrayData: ArrayDataEntry) => string;
+export declare const rawStringifier: (arrayData: ArrayDataEntry) => string;

package/dist/parsers/enumArrayParser.d.ts

@@ -0,0 +1,4 @@
+import { EnumArrayData } from '../types/enumArrayData';
+export declare const getBitsCount: (enumArrayData: EnumArrayData, bitString: string) => number;
+export declare const rawParser: (bitString: string, enumArrayData: EnumArrayData) => number[];
+export declare const rawStringifier: (value: number[], enumArrayData: EnumArrayData) => string;

package/dist/parsers/enumOptionsFactory.d.ts

@@ -0,0 +1,4 @@
+import { EnumOptionsDataEntry } from '@/types';
+export declare const rawParser: (bitString: string, enumOptionsData: EnumOptionsDataEntry) => [EnumOptionsDataEntry, string];
+export declare const rawStateStringifier: (enumOptionsData: EnumOptionsDataEntry) => string;
+export declare const rawStringifier: (enumOptionsData: EnumOptionsDataEntry) => string;

package/dist/parsers/intParser.d.ts

@@ -1,5 +1,11 @@
 import { IntData } from '../types/intData';
 export declare const getBitsCount: (intData: IntData) => number;
+/**
+ * Method that parses a state bitstring into a raw positive int
+ * @param stateString - `string` 0 | 1
+ * @param bitCount - `number` amount of bits to consider
+ * @returns 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;

package/dist/parsers/optionalParser.d.ts

@@ -0,0 +1,4 @@
+import { OptionalDataEntry } from '@/types';
+export declare const rawParser: (bitString: string, optionalData: OptionalDataEntry) => [OptionalDataEntry, string];
+export declare const rawStateStringifier: (optionalData: OptionalDataEntry) => string;
+export declare const rawStringifier: (optionalData: OptionalDataEntry) => string;

package/dist/parsers/parsers.d.ts

@@ -1,22 +1,90 @@
-import { DataEntryArray, DataEntry } from '../types/dataEntry';
-export declare const valueBitsParser: (bitString: string, mapData: DataEntry) => number | boolean;
+import { DataEntry, ComplexDataEntry, NestedData } from '../types/dataEntry';
+/**
+ * Method that parses a bitstring into a value
+ * @param bitString - `string` of 0 | 1
+ * @param mapData - `DataEntry` that represents the data entry to parse
+ * @returns `number` | `boolean` that represents the parsed value
+ */
+export declare const valueBitsParser: (bitString: string, mapData: DataEntry) => number | boolean | number[];
+/**
+ * Method that parses a bitstring into a data entry
+ * @param rawString - `string` of 0 | 1
+ * @param mapData - `DataEntry` that represents the data entry to parse
+ * @returns `DataEntry` that represents the parsed data entry
+ */
 export declare const dataBitsParser: (rawString: string, mapData: DataEntry) => DataEntry;
-export declare const getBitsCount: (mapData: DataEntry) => number;
+/**
+ * Method that returns the amount of bits required for a given data entry
+ * @param mapData - `DataEntry` that represents the data entry to get the bits count for
+ * @param bitString - `string` 0 | 1
+ * @returns `number` that represents the bits count for the given data entry
+ */
+export declare const getBitsCount: (mapData: DataEntry, bitString: string) => number;
+/**
+ * Method that parses a bitstring into a data entry and returns the remaining bitstring
+ * @param bitstring - `string` of 0 | 1
+ * @param dataEntry - `DataEntry` that represents the data entry to parse
+ * @returns `[DataEntry, string]` that represents the data entry and the remaining bitstring
+ */
 export declare const dataEntryBitstringParser: (bitstring: string, dataEntry: DataEntry) => [DataEntry, string];
 /**
- * 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
+ * Method that parses a bitstring for a given nested data descriptor
+ * @param bitstring - `string` of 0 | 1
+ * @param descriptor - `NestedData` that represents the framework applicable to the bitstring
+ * @returns `[NestedData, string]` that represents the actual data and the remaining bitstring
  */
-export declare const dataBitsArrayParser: (bitString: string, mapDataArray: DataEntry[]) => DataEntryArray;
+export declare const nestedDataBitstringParser: (bitstring: string, descriptor: NestedData) => [NestedData, string];
+/**
+ * Method that parses a bitstring into its data for complex data entries
+ * @param bitstring - `string` of 0 | 1
+ * @param complexDataEntry - `DataEntry` that represents the data entry to parse
+ * @returns `[DataEntry, string]` that represents the data entry and the remaining bitstring
+ */
+export declare const complexDataEntryBitstringParser: <T extends ComplexDataEntry>(bitstring: string, complexDataEntry: T) => [T, string];
 export declare const dataBitsStringifier: (data: DataEntry) => string;
+export declare const complexDataStringifier: <T extends ComplexDataEntry>(complexDataEntry: T) => string;
+export declare const complexDataStateStringifier: <T extends ComplexDataEntry>(complexDataEntry: T) => string;
+export declare const nestedDataStringifier: (nestedData: NestedData) => string;
 export declare const dataEntryCorrecting: (dataEntry: DataEntry) => DataEntry;
+export declare const base64url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+/**
+ * Method that returns the bits required for a given amount of numners for a specific base
+ * @param count - `number` amount of numbers
+ * @param base - `number` max value of the numbers
+ */
+export declare const getBitsForEnumArrayCountOfBase: (count: number, base: number) => number;
+/**
+ * Method to convert an array of numbers to a bit string
+ * @param input - `number[]` the input array of numbers to convert to a bit string
+ * @param fromBase - `number` that represents the base of the input numbers
+ * @returns `string` that represents the bit string of the input numbers
+ * @returns 0 | 1 bit string
+ */
+export declare const convertArbitraryBaseToBitString: (input: number[], fromBase: number) => string;
+/**
+ * Method to convert a bit string to an array of numbers of a specific base
+ * @param input - `string` that represents the bit string to convert to an array of numbers
+ * @param toBase - `number` that represents the base of the output numbers
+ * @param expectedOutputLength - `number` that represents the expected length of the output array
+ */
+export declare const convertBitStringToArbitraryBase: (input: string, toBase: number, expectedOutputLength: number) => number[];
+/**
+ * Unused method to convert an array of numbers from an arbitrary base to an arbitrary base
+ * @param input - `number[]` the input array of numbers to convert to a bit string
+ * @param fromBase - `number` that represents the base of the input numbers
+ * @param toBase - `number` that represents the base of the output numbers
+ * @param expectedOutputLength - `number` | optional, should be given when you should find a specific amount of output numbers
+ */
+export declare const convertArbitraryBaseToArbitraryBase: (input: number[], fromBase: number, toBase: number, expectedOutputLength?: number) => number[];
+/**
+ * Method that convists a bitstring to a url safe base64 string
+ * @param bits - `string` of 0 | 1
+ * @returns `string` that represents the url safe base64 string
+ */
 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
+ * Method that convists a url safe base64 string to a bitstring
+ * @param base64 - `string` that represents the url safe base64 string
+ * @returns `string` of 0 | 1
  */
-export declare const dataArrayStringifier: (dataEntryArray: DataEntryArray) => string;
+export declare const parseBase64ToBits: (base64: string) => string;

package/dist/stateHandling/index.d.ts

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

package/dist/stateHandling/stateData.d.ts

@@ -0,0 +1,3 @@
+import { NestedData } from '@/types';
+import { StateDataObject } from '@/types/stateDataEntry';
+export declare const getStateData: (state: NestedData) => StateDataObject;

package/dist/stateHandling/stateDataObject.d.ts

@@ -0,0 +1,15 @@
+import { StateDescriptor, StateObject } from '@/types/stateDataEntry';
+/**
+ * Creates a state object from a state descriptor and updates the state object when the state changes.
+ * @param initialState - the initial state descriptor
+ * @param updateCallback - the callback that gets triggered when the state gets updated
+ * @returns the state object
+ */
+export declare const createStateDataObject: (initialState: StateDescriptor, updateCallback: (currentState: StateObject) => StateObject) => StateObject;
+/**
+ * Creates a state descriptor from a base64 string and a state descriptor
+ * @param base64 - the base64 string
+ * @param descriptor - the state descriptor
+ * @returns the state descriptor
+ */
+export declare const getInitialStateFromBase64: (base64: string, descriptor: StateDescriptor) => StateDescriptor;

package/dist/typeFactory/dataEntryTyping.d.ts

@@ -0,0 +1,6 @@
+import { DataEntry } from '../types';
+export declare const getDataEntryTypeString: (d: DataEntry, withLibraryInformation?: boolean, retainValue?: boolean) => string;
+export declare const getStateDataContentType: (d: DataEntry) => string;
+export declare const getStateValueContentType: (d: DataEntry) => string;
+export declare const getSafeName: (name: string) => string;
+export declare const getDateEntryTypeNamedString: (d: DataEntry, withLibraryInformation?: boolean) => string;

package/dist/typeFactory/index.d.ts

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

package/dist/typeFactory/stateDataTyping.d.ts

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

package/dist/types/arrayData.d.ts

@@ -0,0 +1,10 @@
+import { NestedData } from './dataEntry';
+export type ArrayData = {
+    type: 'ARRAY';
+    minCount: number;
+    maxCount: number;
+    stateBits: number;
+    state: number;
+    descriptor: NestedData;
+    value: NestedData[];
+};

package/dist/types/booleanData.d.ts

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

package/dist/types/dataEntry.d.ts

@@ -3,20 +3,78 @@ import { EnumData } from './enumData';
 import { FloatData } from './floatData';
 import { IntData } from './intData';
 import { VersionData } from './versionData';
+import { EnumArrayData } from './enumArrayData.ts';
+import { OptionalData } from './optionalData.ts';
+import { EnumOptionsData } from './enumOptionsData.ts';
+import { ArrayData } from './arrayData.ts';
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 };
 type DataDescription = {
     name: string;
-    internalName?: string;
-    index: number;
+    internalName?: number[];
+    index?: number;
 };
+/**
+ * Boolean object
+ *
+ * Boolean objects are a simple `true` or `false`, 1 or 0 - one bitwidth object.
+ */
 export type BooleanDataEntry = Prettify<BooleanData & DataDescription>;
-export type IntDataEntry = Prettify<IntData & DataDescription>;
+/**
+ * Enum object
+ *
+ * An enum object is a continious range of integer values, starting at 0 upto its max.
+ * The maximum acceptable value for the max is `255` (8 bits)
+ */
 export type EnumDataEntry = Prettify<EnumData & DataDescription>;
+/**
+ * Int object
+ *
+ * Int objects are a simple integer value, starting at its min upto its max.
+ * The maximum and minimum value can be any integar values represntabled as a double yet,
+ * the maximum acceptable delta between min and max is `4095` (12 bits).
+ */
+export type IntDataEntry = Prettify<IntData & DataDescription>;
+/**
+ * Float object
+ *
+ * Float objects are a fixed point extension of the int object, with a larger available precision range.
+ * Dispite a `min` and a `max` value, they also have a `precision` and a `significand` attribute.
+ * The precision defines where the point is located and can be an integer value between -3 and 3 (-3 meaning **divided** by 1e-3 -> multiplied by 1000, 3 meaning **divided** by 1e3 -> multiplied by 1e-3 -> multiplied by .001)
+ * The significand defines the amount of bits that are used to store the numeric value of the number and is derived from the `min` and `max` values in relationship to the precision.
+ * Maximum value for the significand is `20` bits, which allows for a maximum of 1048576 possible values.
+ */
 export type FloatDataEntry = Prettify<FloatData & DataDescription>;
+/**
+ * Version object
+ *
+ * Version objects are a special type of the enum object, which have a fixed amount of bits assigned to them (and therefore a fixed amount of optional values)
+ * They are only used as the beginning of a DataStateDefinition to be able to find out which version of the data is actually being used
+ *
+ * Acceptable bitwidths are: `4 | 6 | 8 | 10`, giving a total of respectively 16, 64, 256 and 1024 possible versions
+ * Choose wisely, as it is not possible to increase this value later on (that would require the inclusion of an additional version object)
+ */
 export type VersionDataEntry = Prettify<VersionData & DataDescription>;
-export type DataEntry = BooleanDataEntry | IntDataEntry | EnumDataEntry | FloatDataEntry | VersionDataEntry;
-export type ProtectedAttributeNames = Prettify<keyof BooleanDataEntry | keyof IntDataEntry | keyof EnumDataEntry | keyof FloatDataEntry | keyof VersionDataEntry>;
-export type DataEntryArray = DataEntry[];
+/**
+ * Enum Array object
+ *
+ * enum arrays are as the name implies an array of enums.
+ * This object interprets the enums as being a number of a specific base and translates them to base 2.
+ * Besides the base, which is derived from the min and max (integer) values (its delta)
+ * There is also a given min and max count of values.
+ * The count itself is stored as the first bits, like for an Int object.
+ * The value itself is implied by the length of the value array.
+ *
+ * Note: the partical maximum benefit of using this versus using a `ArrayEntryDataType` with only enums is only about 22% for base_5
+ */
+export type EnumArrayDataEntry = Prettify<EnumArrayData & DataDescription>;
+export type DataEntry = BooleanDataEntry | IntDataEntry | EnumDataEntry | FloatDataEntry | VersionDataEntry | EnumArrayDataEntry;
+export type OptionalDataEntry = Prettify<OptionalData & DataDescription>;
+export type EnumOptionsDataEntry = Prettify<EnumOptionsData & DataDescription>;
+export type ArrayDataEntry = Prettify<ArrayData & DataDescription>;
+export type ComplexDataEntry = OptionalDataEntry | EnumOptionsDataEntry | ArrayDataEntry;
+export type NestedData = (DataEntry | ComplexDataEntry)[];
+export type ProtectedAttributeNames = Prettify<keyof BooleanDataEntry | keyof IntDataEntry | keyof EnumDataEntry | keyof FloatDataEntry | keyof VersionDataEntry | keyof EnumArrayDataEntry | keyof OptionalDataEntry | keyof EnumOptionsDataEntry | keyof ArrayDataEntry>;
+export declare const PROTECTED_ATTRIBUTE_NAMES: readonly ["type", "value", "name", "internalName", "index", "min", "max", "bits", "precision", "significand", "minCount", "maxCount", "state", "stateBits", "descriptor", "mapping"];
 export {};

package/dist/types/enumArrayData.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Enum Array object
+ *
+ * enum arrays are as the name implies an array of enums.
+ * This object interprets the enums as being a number of a specific base and translates them to base 2.
+ * Besides the base, which is derived from the min and max (integer) values (its delta)
+ * There is also a given min and max count of values.
+ * The count itself is stored as the first bits, like for an Int object.
+ * The value itself is implied by the length of the value array.
+ *
+ * Note: the partical maximum benefit of using this versus using a `ArrayEntryDataType` with only enums is only about 22% for base_5
+ */
+export type EnumArrayData = {
+    type: 'ENUM_ARRAY';
+    minCount: number;
+    maxCount: number;
+    value: number[];
+    max: number;
+    mapping: any[];
+};

package/dist/types/enumData.d.ts

@@ -1,8 +1,14 @@
-import { DataType } from '../enums/dataTypes';
 export declare const EnumMaxBits = 8;
+/**
+ * Enum object
+ *
+ * An enum object is a continious range of integer values, starting at 0 upto its max.
+ * The maximum acceptable value for the max is `255` (8 bits)
+ */
 export type EnumData = {
-    type: DataType.ENUM;
+    type: 'ENUM';
     value: number;
     max: number;
     bits: number;
+    mapping: (string | number | object)[];
 };

package/dist/types/enumOptionsData.d.ts

@@ -0,0 +1,8 @@
+import { NestedData } from './dataEntry';
+export type EnumOptionsData = {
+    type: 'ENUM_OPTIONS';
+    stateBits: number;
+    state: number;
+    descriptor: NestedData[];
+    value: NestedData;
+};

package/dist/types/floatData.d.ts

@@ -1,8 +1,16 @@
-import { DataType } from '../enums/dataTypes';
 export type PrecisionRangeType = -3 | -2 | -1 | 0 | 1 | 2 | 3;
 export declare const SignificandMaxBits = 20;
+/**
+ * Float object
+ *
+ * Float objects are a fixed point extension of the int object, with a larger available precision range.
+ * Dispite a `min` and a `max` value, they also have a `precision` and a `significand` attribute.
+ * The precision defines where the point is located and can be an integer value between -3 and 3 (-3 meaning **divided** by 1e-3 -> multiplied by 1000, 3 meaning **divided** by 1e3 -> multiplied by 1e-3 -> multiplied by .001)
+ * The significand defines the amount of bits that are used to store the numeric value of the number and is derived from the `min` and `max` values in relationship to the precision.
+ * Maximum value for the significand is `20` bits, which allows for a maximum of 1048576 possible values.
+ */
 export type FloatData = {
-    type: DataType.FLOAT;
+    type: 'FLOAT';
     value: number;
     min: number;
     max: number;

package/dist/types/index.d.ts

@@ -1,9 +1,11 @@
-export * from './arrayDefinitions';
-export * from './booleanData';
-export * from './dataEntry';
+export * from './stateDataEntry';
+export * from './enumOptionsData';
+export * from './optionalData';
+export * from './arrayData';
+export * from './enumArrayData';
 export * from './enumData';
 export * from './floatData';
 export * from './intData';
-export * from './semanticMapping';
-export * from './stateValueModel';
 export * from './versionData';
+export * from './booleanData';
+export * from './dataEntry';

package/dist/types/intData.d.ts

@@ -1,7 +1,13 @@
-import { DataType } from '../enums/dataTypes';
 export declare const IntegerMaxBits = 12;
+/**
+ * Int object
+ *
+ * Int objects are a simple integer value, starting at its min upto its max.
+ * The maximum and minimum value can be any integar values represntabled as a double yet,
+ * the maximum acceptable delta between min and max is `4095` (12 bits).
+ */
 export type IntData = {
-    type: DataType.INT;
+    type: 'INT';
     value: number;
     min: number;
     max: number;

package/dist/types/optionalData.d.ts

@@ -0,0 +1,7 @@
+import { NestedData } from './dataEntry';
+export type OptionalData = {
+    type: 'OPTIONAL';
+    state: boolean;
+    descriptor: [NestedData, null] | [null, NestedData];
+    value: NestedData | null;
+};

package/dist/types/stateDataEntry.d.ts

@@ -0,0 +1,16 @@
+import { ComplexDataEntry, DataEntry, NestedData, VersionDataEntry } from './dataEntry';
+export type StateDataEntry<T extends DataEntry | ComplexDataEntry> = T & {
+    bitstring: string;
+    updateValue: (newEntry: T) => void;
+};
+export type State = [StateDataEntry<VersionDataEntry>, ...StateDataEntry<DataEntry | ComplexDataEntry>[]];
+export type StateDescriptor = [VersionDataEntry, ...NestedData];
+export type StateDataObject = {
+    [key: string]: object | string | boolean | number | (string | number | object)[] | null | StateDataObject | StateDataObject[];
+};
+export type StateObject = {
+    state: State;
+    bitstring: string;
+    base64: string;
+    data: StateDataObject;
+};

package/dist/types/versionData.d.ts

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

package/dist/update/arrayUpdate.d.ts

@@ -0,0 +1,2 @@
+import { ArrayDataEntry } from '@/types';
+export declare const updateComplexValue: (original: ArrayDataEntry, update: ArrayDataEntry) => ArrayDataEntry;

package/dist/update/enumArrayUpdate.d.ts

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

package/dist/update/enumOptionsUpdate.d.ts

@@ -0,0 +1,2 @@
+import { EnumOptionsDataEntry } from '@/types';
+export declare const updateComplexValue: (original: EnumOptionsDataEntry, update: EnumOptionsDataEntry) => EnumOptionsDataEntry;

package/dist/update/nestedDataMatching.d.ts

@@ -0,0 +1,2 @@
+import { NestedData } from '@/types';
+export declare const updateNestedData: (original: NestedData | undefined, descriptor: NestedData) => NestedData;

package/dist/update/optionalUpdate.d.ts

@@ -0,0 +1,2 @@
+import { OptionalDataEntry } from '@/types';
+export declare const updateComplexValue: (original: OptionalDataEntry, update: OptionalDataEntry) => OptionalDataEntry;

package/dist/update/updateValues.d.ts

@@ -1,2 +1,15 @@
-import { DataEntry } from '../types/dataEntry';
+import { DataEntry, ComplexDataEntry } from '../types/dataEntry';
+/**
+ * Method to update the value of a data entry
+ * @param original - the original data entry
+ * @param update - the update data entry
+ * @returns the updated data entry
+ */
 export declare const updateValue: (original: DataEntry, update: DataEntry) => DataEntry;
+/**
+ * Method to update the value of a data entry
+ * @param original - the original data entry
+ * @param update - the update data entry
+ * @returns the updated data entry
+ */
+export declare const updateComplexValue: (original: ComplexDataEntry, update: ComplexDataEntry) => ComplexDataEntry;

package/package.json

@@ -6,7 +6,7 @@
     "dist/*"
   ],
   "type": "module",
-  "version": "0.1.14",
+  "version": "0.2.0",
   "author": "Jonas Ward",
   "description": "Library for creating web safe base64 objects with custom bith widths and dynamic values.",
   "scripts": {
@@ -17,6 +17,7 @@
   "devDependencies": {
     "bun-types": "latest",
     "rimraf": "^6.0.1",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "@types/bun": "latest"
   }
 }

package/dist/objectmap/index.d.ts

@@ -1,4 +0,0 @@
-export * from './stateDataModel';
-export * from './userMethods';
-export * from './userMethods';
-export * from './stateValueHelperMethods';

package/dist/objectmap/stateDataModel.d.ts

@@ -1,19 +0,0 @@
-import { DataEntry, DataEntryArray, NestedContentType, SingleLevelContentType, DoubleLevelContentType, ArrayEntryDataType, EnumEntryDataType, OptionalEntryDataType, DataEntryParsingReturnType, DerivativeStateDataType, InternalStateDataGenerationMethod, StateDataGenerationMethod, StateDataType } from '../types';
-/**
- * Helper method for finding an existing data entry in case there was a previous object
- * @param dataEntry - new DataEntry
- * @param dataEntryArray - existing DataEntryArray
- */
-export declare const findExistingDataEntry: (dataEntry: DataEntry, dataEntryArray: DataEntryArray) => DataEntry | undefined;
-export declare const readDataEntry: (dataEntry: DataEntry, bitString: string) => DataEntryParsingReturnType;
-export declare const updateDataEntry: (dataEntry: DataEntry, existingData: DataEntryArray) => DataEntryParsingReturnType;
-export declare const internalGetDataEntry: (dataEntry: DataEntry, prefix: string, additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DataEntry]];
-export declare const getStateFromOptionalEntryDataType: (oedt: OptionalEntryDataType, prefix: string, attributeName: string) => InternalStateDataGenerationMethod;
-export declare const getStateFromEnumEntryDataType: (eedt: EnumEntryDataType, prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, StateDataType]];
-export declare const getStateFromArrayEntryDataType: (aedt: ArrayEntryDataType, prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DerivativeStateDataType]];
-export declare const getStateDataFromDoubleLevelContentType: (dct: DoubleLevelContentType, prefix: string, attributeName: string) => InternalStateDataGenerationMethod;
-export declare const getStateDateFromSingleLevelContentTypeArray: (slcta: SingleLevelContentType[], prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, StateDataType]];
-export declare const getStateDataFromNestedContentType: (nct: NestedContentType, prefix: string, attributeName: string) => InternalStateDataGenerationMethod;
-export declare const getStateDataFromSingleLevelContentType: (slct: SingleLevelContentType, prefix: string) => InternalStateDataGenerationMethod;
-export declare const getGenerationMethodForSingleLevelContentTypeArray: (slct: SingleLevelContentType[]) => StateDataGenerationMethod;
-export declare const testOnlyResetCurrentDataEntryIndex: () => number;

package/dist/objectmap/stateValueHelperMethods.d.ts

@@ -1,13 +0,0 @@
-import { DataEntryArray, NestedContentType, SingleLevelContentType } from '../types';
-import { StateDataType, StateValueType } from '../types/stateValueModel';
-export declare const getStateValue: (stateValue: StateDataType) => StateValueType;
-export declare const getDataEntryArray: (stateValue: StateDataType) => DataEntryArray;
-export declare const getBase64String: (stateValue: StateDataType) => string;
-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 doubleLevelContentTypeIsEnumEntryDataType: (data: NestedContentType) => boolean;
-export declare const doubleLevelContentTypeIsOptionalEntryDataType: (data: NestedContentType) => boolean;
-export declare const doubleLevelContentTypeIsArrayDefinitionType: (data: NestedContentType) => boolean;
-export declare const isDataEntry: (v: any) => boolean;

package/dist/objectmap/userMethods.d.ts

@@ -1,12 +0,0 @@
-import { EnumSemantics, VersionHandler, VersionContentDefinition } from '../types';
-/**
- * Method to create version definition objects
- * @param {VersionArrayDefinitionType[]} versionContent  - version definition array
- * @param {number} maximumExpectedVersions - maximum expected versions to define
- * @param {number} defaultVersion - number - optional, default it is the first,
- * @param {EnumSemantics[] | EnumSemantics} enumSemanticsMapping - optional - UI semantics mapping for enums. If not given, values will be numbers
- * @param {undefined | Record<string, string> | Record<string, string>[]} attributeSemanticsMapping - optional - UI semantics mapping, if nothing given no semantics will be mapped
- * @param {number[]} exposedVersions?: number[] - optional - UI semantics, masks which objects to show and hide
- * @returns ParsersForVersionObject
- */
-export declare const createParserObject: (versionContent: VersionContentDefinition, maximumExpectedVersions: number, defaultVersion?: number, enumSemanticsMapping?: EnumSemantics | EnumSemantics[], attributeSemanticsMapping?: Record<string, string> | Record<string, string>[], exposedVersions?: number[]) => VersionHandler;

package/dist/types/arrayDefinitions.d.ts

@@ -1,10 +0,0 @@
-import { DataEntry } from './dataEntry';
-export type SingleLevelContentType = DataEntry | NestedContentDataType;
-export type NestedContentDataType = [string, NestedContentType];
-export type NestedContentType = SingleLevelContentType[] | DoubleLevelContentType;
-export type DoubleLevelContentType = OptionalEntryDataType | EnumEntryDataType | ArrayEntryDataType;
-export type NonEmptyValidEntryArrayType = [SingleLevelContentType, ...SingleLevelContentType[]];
-export type OptionalEntryDataType = [boolean, NonEmptyValidEntryArrayType, []] | [boolean, [], NonEmptyValidEntryArrayType];
-export type EnumEntryDataType = [number, NonEmptyValidEntryArrayType, NonEmptyValidEntryArrayType, ...SingleLevelContentType[][]];
-export type ArrayEntryDataType = [[number, number], NonEmptyValidEntryArrayType];
-export declare const PREFIX_SEPERATOR_DELIMETER = "_";

package/dist/types/semanticMapping.d.ts

@@ -1,6 +0,0 @@
-export type EnumSemantics = {
-    [dataEntryName: string]: {
-        value: number;
-        label: string;
-    }[];
-};

package/dist/types/stateValueModel.d.ts

@@ -1,33 +0,0 @@
-import { SingleLevelContentType } from './arrayDefinitions';
-import { DataEntry, DataEntryArray } from './dataEntry';
-import { EnumSemantics } from './semanticMapping';
-export type StateDataType = {
-    [attribute: string]: DataEntry | StateDataType | DerivativeStateDataType;
-};
-export type DerivativeStateDataType = {
-    s: DataEntry;
-    v: StateDataType | StateDataType[];
-};
-export type StateValueType = {
-    [attribute: string]: boolean | number | string | StateValueType | DerivativeStateValueType;
-};
-export type DerivativeStateValueType = {
-    s: boolean | number | string;
-    v: StateValueType | StateValueType[];
-};
-export type StateDataGenerationMethod = (additionalData?: DataEntryArray | string) => StateDataType;
-export type DataEntryParsingReturnType = [DataEntryArray | string | undefined, [string, DataEntry]];
-export type InternalStateDataGenerationMethod = (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DataEntry | StateDataType | DerivativeStateDataType]];
-export type ExposedParserStateDataMethod = (additionalData?: StateDataType | DataEntryArray | string) => StateDataType;
-export type UpdateStateDataMethod = (state: StateDataType, entryToUpdate: DataEntry | DataEntry[]) => StateDataType;
-export type StringifyStateDataMethod = (data: StateDataType | DataEntryArray) => string;
-export type VersionContentDefinition = SingleLevelContentType[][];
-export type VersionHandler = {
-    versionBitCount: number;
-    exposedVersions?: number[];
-    enumSemanticsMapping?: EnumSemantics | EnumSemantics[];
-    attributeSemanticsMapping?: Record<string, string> | Record<string, string>[];
-    parser: ExposedParserStateDataMethod;
-    updater: UpdateStateDataMethod;
-    stringify: StringifyStateDataMethod;
-};