url-safe-bitpacking 0.2.0 → 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/factory/enumArrayFactory.d.ts

@@ -1,2 +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;
+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, options: (string | number | object)[] | string | 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/factory.d.ts

@@ -10,16 +10,14 @@ 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;
+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/utils.d.ts

@@ -1,9 +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 getOptionsFromEnumOptions: (options: (string | number | object)[] | string | number) => {
+export declare const getEnumMaxAndMappingFromOptions: (options: EnumOptionsType) => {
     max: number;
-    mapping: (string | number | object)[];
+    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, 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 { 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';

package/dist/index.js

@@ -84,17 +84,24 @@ var create4 = (value, bits = 8, name = "", index = -1) => ({
 });
 
 // src/factory/utils.ts
-var getOptionsFromEnumOptions = (options) => {
+var getEnumMaxAndMappingFromOptions = (options) => {
   if (typeof options === "string")
-    return { max: options.length - 1, mapping: options.split(",").map(Number) };
+    return { max: options.length - 1, mapping: options.split("") };
   if (typeof options === "number")
     return { max: options, mapping: Array.from({ length: options + 1 }, (_, i) => i) };
   return { max: options.length - 1, mapping: options };
 };
+var getOptionsFromMaxAndMapping = (v) => {
+  if (v.mapping.every((option) => typeof option === "string" && option.length === 1))
+    return v.mapping.join("");
+  if (Array.from({ length: v.max + 1 }, (_, i) => i).every((option, i) => option === v.mapping[i]))
+    return v.max;
+  return v.mapping;
+};
 
 // src/factory/enumFactory.ts
 var create5 = (value, options, name = "", index = -1) => {
-  const { max, mapping } = getOptionsFromEnumOptions(options);
+  const { max, mapping } = getEnumMaxAndMappingFromOptions(options);
   if (!Number.isInteger(max))
     throw new Error(`max must be integers, you have given ${max}`);
   if (max < 1)
@@ -107,7 +114,7 @@ var create5 = (value, options, name = "", index = -1) => {
 
 // src/factory/enumArrayFactory.ts
 var create6 = (value, options, minCount = 1, maxCount = 10, name = "", index = -1) => {
-  const { max, mapping } = getOptionsFromEnumOptions(options);
+  const { max, mapping } = getEnumMaxAndMappingFromOptions(options);
   if (!Number.isInteger(max))
     throw new Error(`max must be integers, you have given ${max}`);
   if (!Number.isInteger(minCount) || !Number.isInteger(maxCount))
@@ -209,18 +216,16 @@ var create9 = (descriptor, defaultState = 0, minCount = 0, maxCount = 10, name =
 };
 
 // src/factory/factory.ts
-var DataEntryFactory = {
-  createFloat: create,
-  createInt: create2,
-  createEnum: create5,
-  createBoolean: create3,
-  createVersion: create4,
-  createEnumArray: create6
-};
-var ComplexDataEntryFactory = {
-  createOptional: create7,
-  createEnumOptions: create8,
-  createArray: create9
+var DescriptorFactory = {
+  FLOAT: create,
+  INT: create2,
+  ENUM: create5,
+  BOOLEAN: create3,
+  VERSION: create4,
+  ENUM_ARRAY: create6,
+  OPTIONAL: create7,
+  ENUM_OPTIONS: create8,
+  ARRAY: create9
 };
 // src/parsers/intParser.ts
 var getBitsCount = (intData2) => intData2.bits;
@@ -351,6 +356,9 @@ var rawParser7 = (bitString, arrayData2) => {
   return [{ ...arrayData2, value, state }, bitString];
 };
 var rawStateStringifier = (arrayData2) => arrayData2.stateBits ? rawIntStringifier(arrayData2.value.length - arrayData2.minCount, arrayData2.stateBits) : "";
+var rawStringifier7 = (arrayData2) => {
+  return rawStateStringifier(arrayData2) + arrayData2.value.map(nestedDataStringifier).join("");
+};
 
 // src/parsers/optionalParser.ts
 var getState = (bitString) => Number(bitString.slice(0, 1));
@@ -362,6 +370,7 @@ var rawParser8 = (bitString, optionalData2) => {
   return [{ ...optionalData2, value, state }, remainingBitstring];
 };
 var rawStateStringifier2 = (optionalData2) => optionalData2.state ? "1" : "0";
+var rawStringifier8 = (optionalData2) => optionalData2.value === null ? rawStateStringifier2(optionalData2) : rawStateStringifier2(optionalData2) + nestedDataStringifier(optionalData2.value);
 
 // src/parsers/enumOptionsFactory.ts
 var getStateIndex = (enumOptionsData2, bitString) => {
@@ -376,6 +385,7 @@ var rawParser9 = (bitString, enumOptionsData2) => {
   return [{ ...enumOptionsData2, value, state }, remainingBitstring];
 };
 var rawStateStringifier3 = (enumOptionsData2) => rawIntStringifier(enumOptionsData2.state, enumOptionsData2.stateBits);
+var rawStringifier9 = (enumOptionsData2) => rawStateStringifier3(enumOptionsData2) + nestedDataStringifier(enumOptionsData2.value);
 
 // src/parsers/parsers.ts
 var valueBitsParser = (bitString, mapData) => {
@@ -461,6 +471,16 @@ var dataBitsStringifier = (data) => {
       return rawStringifier6(data.value, data);
   }
 };
+var complexDataStringifier = (complexDataEntry) => {
+  switch (complexDataEntry.type) {
+    case "ARRAY":
+      return rawStringifier7(complexDataEntry);
+    case "OPTIONAL":
+      return rawStringifier8(complexDataEntry);
+    case "ENUM_OPTIONS":
+      return rawStringifier9(complexDataEntry);
+  }
+};
 var complexDataStateStringifier = (complexDataEntry) => {
   switch (complexDataEntry.type) {
     case "ARRAY":
@@ -471,6 +491,7 @@ var complexDataStateStringifier = (complexDataEntry) => {
       return rawStateStringifier3(complexDataEntry);
   }
 };
+var nestedDataStringifier = (nestedData) => nestedData.map((d) => ComplexDataValues.includes(d.type) ? complexDataStringifier(d) : dataBitsStringifier(d)).join("");
 var dataEntryCorrecting = (dataEntry2) => dataBitsParser(dataBitsStringifier(dataEntry2), dataEntry2);
 var base64url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 var getBitsForEnumArrayCountOfBase = (count, base) => Math.ceil(Math.log2(base) * count);
@@ -770,18 +791,21 @@ export {
   parseBase64ToBits,
   interpolateEntryAt,
   getRelativeValue,
+  getOptionsFromMaxAndMapping,
   getInitialStateFromBase64,
+  getEnumMaxAndMappingFromOptions,
   getBitsCount7 as getBitsCount,
   dataEntryCorrecting,
   dataEntryBitstringParser,
   dataBitsStringifier,
   dataBitsParser,
   createStateDataObject,
+  complexDataStringifier,
+  complexDataStateStringifier,
   SignificandMaxBits,
   PROTECTED_ATTRIBUTE_NAMES,
   IntegerMaxBits,
+  DescriptorFactory,
   DataTypeValues,
-  DataEntryFactory,
-  ComplexDataValues,
-  ComplexDataEntryFactory
+  ComplexDataValues
 };

package/dist/types/enumArrayData.d.ts

@@ -1,3 +1,4 @@
+import { EnumMappingType } from './enumData';
 /**
  * Enum Array object
  *
@@ -16,5 +17,5 @@ export type EnumArrayData = {
     maxCount: number;
     value: number[];
     max: number;
-    mapping: any[];
+    mapping: EnumMappingType;
 };

package/dist/types/enumData.d.ts

@@ -1,4 +1,6 @@
 export declare const EnumMaxBits = 8;
+export type EnumMappingType = (string | number | object)[];
+export type EnumOptionsType = string | number | EnumMappingType;
 /**
  * Enum object
  *
@@ -10,5 +12,5 @@ export type EnumData = {
     value: number;
     max: number;
     bits: number;
-    mapping: (string | number | object)[];
+    mapping: EnumMappingType;
 };

package/package.json

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