url-safe-bitpacking 0.1.15 → 0.2.1

package/README.md

@@ -28,7 +28,7 @@ Currently, there are 4 data types implemented (+1 special case for safety). All
 Bool type values are simple yes or no, 1 or 0s, nothing special
 
 ```typescript
-DataEntryFactory.createBoolean(false, 'shapePreProcessingWarpabsolute');
+DescriptorFactory.BOOLEAN(false, 'shapePreProcessingWarpabsolute');
 ```
 
 ### enum
@@ -36,7 +36,7 @@ DataEntryFactory.createBoolean(false, 'shapePreProcessingWarpabsolute');
 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');
+DescriptorFactory.ENUM(0, 3, 'footprintType');
 ```
 
 ### int
@@ -44,7 +44,7 @@ DataEntryFactory.createEnum(0, 3, 'footprintType');
 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');
+DescriptorFactory.INT(5, 3, 20, 'circleDivisions');
 ```
 
 ### float
@@ -52,7 +52,7 @@ DataEntryFactory.createInt(5, 3, 20, 'circleDivisions');
 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');
+DescriptorFactory.FLOAT(20, 10, 200, -1, 'shapePreProcessingWarptotal');
 ```
 
 ### enum array
@@ -60,7 +60,7 @@ DataEntryFactory.createFloat(20, 10, 200, -1, 'shapePreProcessingWarptotal');
 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')    
+DescriptorFactory.ENUM_ARRAY([0, 1, 2], 0, 10, 3, 5, 'enumArrayA')    
 ```
 
 ### version
@@ -68,7 +68,7 @@ DataEntryFactory.createEnumArray([0, 1, 2], 0, 10, 3, 5, 'enumArrayA')
 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');
+DescriptorFactory.VERSION(0, 8, 'version');
 ```
 
 ## nested attribute definitions

package/dist/enums/dataTypes.d.ts

@@ -1,9 +1,4 @@
-export declare enum DataType {
-    VERSION = 0,
-    BOOLEAN = 1,
-    ENUM = 2,
-    INT = 3,
-    FLOAT = 4,
-    ENUM_ARRAY = 5
-}
-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

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

package/dist/factory/enumFactory.d.ts

@@ -1,2 +1,3 @@
 import { EnumDataEntry } from '../types';
-export declare const create: (value: number, max?: number, name?: string, index?: number) => EnumDataEntry;
+import { EnumOptionsType } from '../types/enumData';
+export declare const create: (value: number, options: EnumOptionsType, 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

@@ -4,14 +4,20 @@ 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 DescriptorFactory: {
+    readonly FLOAT: typeof createFloat;
+    readonly INT: typeof createInt;
+    readonly ENUM: typeof createEnum;
+    readonly BOOLEAN: typeof createBoolean;
+    readonly VERSION: typeof createVersion;
+    readonly ENUM_ARRAY: typeof createEnumArray;
+    readonly OPTIONAL: typeof createOptional;
+    readonly ENUM_OPTIONS: typeof createEnumOptions;
+    readonly ARRAY: typeof createArray;
 };

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,19 @@
+import { EnumMappingType, EnumOptionsType } from '@/types';
+/**
+ * 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 getEnumMaxAndMappingFromOptions: (options: EnumOptionsType) => {
+    max: number;
+    mapping: EnumMappingType;
+};
+/**
+ * Method to get the options from the max and mapping of an ENUM & ENUM_ARRAY type
+ * @param v - `{ max: number; mapping: EnumMappingType }` the max and mapping to get the options from
+ * @returns `EnumOptionsType` the options
+ */
+export declare const getOptionsFromMaxAndMapping: (v: {
+    max: number;
+    mapping: EnumMappingType;
+}) => EnumOptionsType;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-export { DataType } from './enums';
-export { DataEntryFactory } from './factory';
-export { SingleLevelContentType, NestedContentDataType, NestedContentType, DoubleLevelContentType, NonEmptyValidEntryArrayType, ArrayEntryDataType, OptionalEntryDataType, EnumEntryDataType, PrecisionRangeType, SignificandMaxBits, FloatDataEntry, IntegerMaxBits, IntDataEntry, EnumDataEntry, EnumArrayDataEntry, VersionRangeType, VersionDataEntry, BooleanDataEntry, DataEntry, DataEntryArray, StateDataType, StateValueType, EnumSemantics, DerivativeStateDataType, VersionContentDefinition, PREFIX_SEPERATOR_DELIMETER, PROTECTED_ATTRIBUTE_NAMES } from './types';
-export { createParserObject, getStateValue, getBase64String, getDataEntryArray, isDataEntry, isDoubleLevelContentType, isSingleLevelContentType, doubleLevelContentTypeIsEnumEntryDataType, doubleLevelContentTypeIsOptionalEntryDataType, doubleLevelContentTypeIsArrayDefinitionType } from './objectmap';
-export { parseBase64ToBits, getBitsCount, valueBitsParser, dataBitsParser, dataEntryBitstringParser, dataBitsStringifier, dataEntryCorrecting } from './parsers';
+export { DataType, DataTypeValues, ComplexDataType, ComplexDataValues } from './enums';
+export { DescriptorFactory } from './factory';
+export { PrecisionRangeType, SignificandMaxBits, FloatDataEntry, IntegerMaxBits, IntDataEntry, EnumDataEntry, EnumArrayDataEntry, VersionRangeType, VersionDataEntry, BooleanDataEntry, DataEntry, ComplexDataEntry, NestedData, ProtectedAttributeNames, StateDescriptor, StateObject, StateDataObject, StateDataEntry, State, EnumOptionsType, EnumMappingType, PROTECTED_ATTRIBUTE_NAMES } from './types';
+export { parseBase64ToBits, getBitsCount, valueBitsParser, dataBitsParser, dataEntryBitstringParser, dataEntryCorrecting, dataBitsStringifier, complexDataStringifier, complexDataStateStringifier } from './parsers';
+export { createStateDataObject, getInitialStateFromBase64 } from './stateHandling';
 export { interpolateEntryAt, getRelativeValue } from './utils';
+export { getEnumMaxAndMappingFromOptions, getOptionsFromMaxAndMapping } from './factory/utils';