url-safe-bitpacking 0.1.14 → 0.2.0

package/README.md

@@ -13,6 +13,7 @@ Package for creating definitions of parametric models that can be stored as comp
 | flattening and reading of the objects                | ✓  | ✓  | ¿ |
 | arrays (both bit-level as arrays of objects)         | ½ | ½ |          |
 | utility to create StateValueType                     |          |          |          |
+| ability to migrate one version to another            |          |          |          |
 
 ## concept
 
@@ -54,6 +55,14 @@ Floating points work very much like the integer type, with the main difference t
 DataEntryFactory.createFloat(20, 10, 200, -1, 'shapePreProcessingWarptotal');
 ```
 
+### enum array
+
+Enum arrays are a special type of arrays where integer values are intepreted as being values of a **specific base** to then be transformed to base 2. The base is derived from the delta of the max `and` the `min` value of the enums. Besides that, there is also a `minCount` and `maxCount` value (which can be the same value, but `minCount` is at least 1). This only offers a compression rate of upto 22% vis-a-vis an array of `IntDataEntry` (worst case its 0% percent, it never takes up more space), so sometimes questionable whether it makese sense to use ^^.
+
+```typescript
+DataEntryFactory.createEnumArray([0, 1, 2], 0, 10, 3, 5, 'enumArrayA')    
+```
+
 ### 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.

package/dist/enums/dataTypes.d.ts

@@ -1,8 +1,4 @@
-export declare enum DataType {
-    VERSION = 0,
-    BOOLEAN = 1,
-    ENUM = 2,
-    INT = 3,
-    FLOAT = 4
-}
-export declare const getDataTypeName: (type: DataType) => string;
+export declare const DataTypeValues: readonly ["VERSION", "BOOLEAN", "ENUM", "INT", "FLOAT", "ENUM_ARRAY"];
+export declare const ComplexDataValues: readonly ["OPTIONAL", "ENUM_OPTIONS", "ARRAY"];
+export type DataType = (typeof DataTypeValues)[number];
+export type ComplexDataType = (typeof ComplexDataValues)[number];

package/dist/factory/arrayFactory.d.ts

@@ -0,0 +1,2 @@
+import { ArrayDataEntry, NestedData } from '@/types';
+export declare const create: (descriptor: NestedData, defaultState?: number, minCount?: number, maxCount?: number, name?: string, index?: number) => ArrayDataEntry;

package/dist/factory/enumArrayFactory.d.ts

@@ -0,0 +1,2 @@
+import { EnumArrayDataEntry } from '@/types';
+export declare const create: (value: number[], options: (string | number | object)[] | string | number, minCount?: number, maxCount?: number, name?: string, index?: number) => EnumArrayDataEntry;

package/dist/factory/enumFactory.d.ts

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

package/dist/factory/enumOptionsFactory.d.ts

@@ -0,0 +1,2 @@
+import { EnumOptionsDataEntry, NestedData } from '@/types';
+export declare const create: (descriptor: NestedData[], defaultState?: number, name?: string, index?: number) => EnumOptionsDataEntry;

package/dist/factory/factory.d.ts

@@ -3,10 +3,23 @@ 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 { create as createEnumArray } from './enumArrayFactory';
+import { create as createOptional } from './optionalFactory';
+import { create as createEnumOptions } from './enumOptionsFactory';
+import { create as createArray } from './arrayFactory';
+/**
+ * Record containing all the factory methods for the different data entry objects
+ */
 export declare const DataEntryFactory: {
     createFloat: typeof createFloat;
     createInt: typeof createInt;
     createEnum: typeof createEnum;
     createBoolean: typeof createBoolean;
     createVersion: typeof createVersion;
+    createEnumArray: typeof createEnumArray;
+};
+export declare const ComplexDataEntryFactory: {
+    createOptional: typeof createOptional;
+    createEnumOptions: typeof createEnumOptions;
+    createArray: typeof createArray;
 };

package/dist/factory/floatFactory.d.ts

@@ -1,3 +1,12 @@
 import { FloatDataEntry } from '../types';
 import { PrecisionRangeType } from '../types/floatData';
+/**
+ * Method to create a float data entry
+ * @param value - `number` default value, should be between `min` and `max`
+ * @param min - `number` (default: 0), should be smaller than `max`
+ * @param max - `number` (default: 1), should be larger than `min`
+ * @param precision - `PrecisionRangeType` (default: 2 -> .01),
+ * @param name - `string`
+ * @param index - `number`
+ */
 export declare const create: (value: number, min?: number, max?: number, precision?: PrecisionRangeType, name?: string, index?: number) => FloatDataEntry;

package/dist/factory/helperMethod.d.ts

@@ -1,5 +1,24 @@
 import { VersionRangeType } from '../types';
+/**
+ * Helper method to get the minimum bits required to store a given integer value
+ * @param number - `number` value to get the minimum bits for
+ * @param maxBits - `number` maximum bits allowed
+ */
 export declare const getBitsForIntegerNumber: (number: number, maxBits: number) => number;
+/**
+ * Helper method to get the minimum bits required to store a given integer value
+ * @param v - `number` value to get the minimum bits for
+ */
 export declare const getMinimumBitsForInteger: (v: number) => number;
+/**
+ * Helper method to get the version value range value for a given number
+ * @param v - `number` value to get the version value range value for
+ * @returns `VersionRangeType` the version value range value
+ */
 export declare const getVersionValueRangeValueForNumber: (v: number) => VersionRangeType;
+/**
+ * Helper method to get the maximum integer value for a given bit count
+ * @param bitCount - `number` bit width to get the maximum integer value for
+ * @returns `number` the maximum integer value
+ */
 export declare const getMaxIntegerValueForGivenBitWidth: (bitCount: number) => number;

package/dist/factory/optionalFactory.d.ts

@@ -0,0 +1,2 @@
+import { NestedData, OptionalDataEntry } from '@/types';
+export declare const create: (descriptor: [null, NestedData] | [NestedData, null], defaultState?: boolean, name?: string, index?: number) => OptionalDataEntry;

package/dist/factory/utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Method to get the max and mapping from the options
+ * @param options - `any[] | string | number` the options to get the max and mapping from
+ * @returns `{ max: number; mapping: any[] }` the max and mapping
+ */
+export declare const getOptionsFromEnumOptions: (options: (string | number | object)[] | string | number) => {
+    max: number;
+    mapping: (string | number | object)[];
+};

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { DataType } from './enums';
-export { DataEntryFactory } from './factory';
-export { SingleLevelContentType, NestedContentDataType, NestedContentType, DoubleLevelContentType, NonEmptyValidEntryArrayType, OptionalEntryDataType, EnumEntryDataType, PrecisionRangeType, SignificandMaxBits, FloatData, IntegerMaxBits, IntData, VersionRangeType, VersionData, BooleanData, DataEntry, DataEntryArray, StateDataType, StateValueType, EnumSemantics, DerivativeStateDataType, } from './types';
-export { createParserObject, getStateValue, getBase64String, getDataEntryArray } from './objectmap';
-export { parseBase64ToBits } from './parsers';
+export { DataType, DataTypeValues, ComplexDataType, ComplexDataValues } from './enums';
+export { DataEntryFactory, ComplexDataEntryFactory } from './factory';
+export { PrecisionRangeType, SignificandMaxBits, FloatDataEntry, IntegerMaxBits, IntDataEntry, EnumDataEntry, EnumArrayDataEntry, VersionRangeType, VersionDataEntry, BooleanDataEntry, DataEntry, ComplexDataEntry, NestedData, ProtectedAttributeNames, StateDescriptor, StateObject, StateDataObject, StateDataEntry, State, PROTECTED_ATTRIBUTE_NAMES } from './types';
+export { parseBase64ToBits, getBitsCount, valueBitsParser, dataBitsParser, dataEntryBitstringParser, dataBitsStringifier, dataEntryCorrecting } from './parsers';
+export { createStateDataObject, getInitialStateFromBase64 } from './stateHandling';
 export { interpolateEntryAt, getRelativeValue } from './utils';