url-safe-bitpacking 0.3.0 → 0.3.1

package/dist/factory/factory.d.ts

@@ -12,7 +12,7 @@ import { DataEntry, ObjectDataEntry, VersionDataEntry } from '../types';
 /**
  * Record containing all the factory methods for the different data entry objects
  */
-export declare const DescriptorFactory: {
+export declare const DataEntryFactory: {
     FLOAT: typeof createFloat;
     INT: typeof createInt;
     ENUM: typeof createEnum;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { DataType, ConstantBitWidthDataTypes, VariableBitWidthDataTypes } from './enums';
-export { PrecisionRangeType, SignificandMaxBits, FloatDataEntry, IntegerMaxBits, IntDataEntry, EnumDataEntry, EnumArrayDataEntry, VersionRangeType, VersionDataEntry, BooleanDataEntry, DataEntry, ProtectedAttributeNames, EnumOptionsType, EnumMappingType, PROTECTED_ATTRIBUTE_NAMES } from './types';
+export { PrecisionRangeType, SignificandMaxBits, FloatDataEntry, IntegerMaxBits, IntDataEntry, EnumDataEntry, EnumArrayDataEntry, VersionRangeType, VersionDataEntry, BooleanDataEntry, DataEntry, ProtectedAttributeNames, EnumOptionsType, EnumMappingType, PROTECTED_ATTRIBUTE_NAMES, StateDataObject, StateDataObjectValue } from './types';
 export { getBitsCount, dataEntryBitstringParser, dataEntryCorrecting, dataEntryBitsStringifier, parseBase64ToBits } from './parsers';
-export { SpecificTypeNode, NodeFactory, GetStateNodeTree, FromState, ArrayNode, BooleanNode, EnumNode, IntNode, FloatNode, EnumArrayNode, OptionalNode, EnumOptionsNode, ObjectNode, StateNode } from './stateHandling';
+export { SpecificTypeNode, NodeFactory, GetStateNodeTree, FromState, ArrayNode, BooleanNode, EnumNode, IntNode, FloatNode, EnumArrayNode, OptionalNode, EnumOptionsNode, ObjectNode, StateNode, getStateData } from './stateHandling';
 export { interpolateEntryAt, getRelativeValue } from './utils';
+export { DataEntryFactory } from './factory';
 export { getEnumMaxAndMappingFromOptions, getOptionsFromMaxAndMapping } from './factory/utils';

package/dist/index.js

@@ -2,6 +2,8 @@
 var ConstantBitWidthDataTypes = ["VERSION", "BOOLEAN", "ENUM", "INT", "FLOAT"];
 var VariableBitWidthDataTypes = ["ENUM_ARRAY", "OPTIONAL", "ENUM_OPTIONS", "ARRAY", "OBJECT"];
 var HasStateBitsDataTypes = ["ENUM_ARRAY", "OPTIONAL", "ENUM_OPTIONS", "ARRAY"];
+// src/types/enumData.ts
+var EnumMaxBits = 8;
 // src/types/floatData.ts
 var SignificandMaxBits = 20;
 // src/types/intData.ts
@@ -454,8 +456,59 @@ var updateStateEntry = (original, update) => {
   }
 };
 // src/factory/helperMethod.ts
+var getBitsForIntegerNumber = (number, maxBits) => {
+  const bitCount = Math.ceil(Math.log2(number));
+  if (bitCount > maxBits)
+    throw new Error(`Cannot get ${maxBits} bits for a number with ${bitCount} bits`);
+  return bitCount;
+};
 var getMinimumBitsForInteger = (v) => Math.ceil(Math.log2(v + 1));
 
+// src/factory/floatFactory.ts
+var create = (value, min = 0, max = 1, precision = 2, name = "a float") => {
+  const precisionMultiplier = 10 ** precision;
+  const roundedMin = Math.floor(min * precisionMultiplier);
+  const roundedMax = Math.ceil(max * precisionMultiplier);
+  const delta = roundedMax - roundedMin;
+  const significand = Math.max(1, getBitsForIntegerNumber(delta, SignificandMaxBits));
+  return {
+    value,
+    type: "FLOAT",
+    min: roundedMin / precisionMultiplier,
+    max: roundedMax / precisionMultiplier,
+    precision,
+    significand,
+    name
+  };
+};
+
+// src/factory/intFactory.ts
+var create2 = (value, min = 0, max = 10, name = "an int") => {
+  if (!Number.isInteger(min) || !Number.isInteger(max))
+    throw new Error("min and max must be integers");
+  if (max - min < 1)
+    throw new Error("max must be at least one");
+  if (Math.abs(max - min) > 2 ** IntegerMaxBits - 1)
+    throw new Error("max - min must be less than 1024");
+  const bits = getBitsForIntegerNumber(max - min + 1, IntegerMaxBits);
+  return { value, type: "INT", min, max, bits, name };
+};
+
+// src/factory/booleanFactory.ts
+var create3 = (value, name = "a boolean") => ({
+  value,
+  type: "BOOLEAN",
+  name
+});
+
+// src/factory/versionFactory.ts
+var create4 = (value, bits = 8, name = "a version") => ({
+  value,
+  type: "VERSION",
+  bits,
+  name
+});
+
 // src/factory/utils.ts
 var getEnumMaxAndMappingFromOptions = (options) => {
   if (typeof options === "string")
@@ -472,12 +525,134 @@ var getOptionsFromMaxAndMapping = (v) => {
   return v.mapping;
 };
 
+// src/factory/enumFactory.ts
+var create5 = (value, options, name = "an enum") => {
+  const { max, mapping } = getEnumMaxAndMappingFromOptions(options);
+  if (!Number.isInteger(max))
+    throw new Error(`max must be integers, you have given ${max}`);
+  if (max < 1)
+    throw new Error("max must be at least one");
+  if (max > 2 ** EnumMaxBits - 1)
+    throw new Error("max - min must be less than 256");
+  const bits = getBitsForIntegerNumber(max + 1, EnumMaxBits);
+  return { value, type: "ENUM", max, bits, name, mapping };
+};
+
+// src/factory/enumArrayFactory.ts
+var minEnumArrayCount = 0;
+var maxOptionsCount = 1024;
+var create6 = (value, options, minCount = minEnumArrayCount, maxCount = 10, name = "enum array") => {
+  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))
+    throw new Error("minCount and maxCount must be integers");
+  if (max < 1)
+    throw new Error("must have at least one option");
+  if (max > maxOptionsCount)
+    throw new Error(`maximum allowed options is 1024, you have given ${max + 1} options`);
+  minCount = Math.min(minCount, maxCount);
+  maxCount = Math.max(minCount, maxCount);
+  if (minCount < 0)
+    throw new Error("minCount can't be negative");
+  if (maxCount - minCount < 0)
+    throw new Error(`count range length must be positive, given count range length is ${Math.abs(maxCount - minCount)}`);
+  if (Math.abs(maxCount - minCount) > 2 ** IntegerMaxBits - 1)
+    throw new Error(`count range length must be less than 1024, given count range length is ${Math.abs(maxCount - minCount)}`);
+  value.forEach((v, i) => {
+    if (!Number.isInteger(v))
+      throw new Error(`all entries must be integers, index ${i} (${v}) is not`);
+    if (v > max)
+      throw new Error(`all entries must be within the range ${0} - ${max}, index ${i} (${v}) is not`);
+  });
+  if (value.length < minCount || value.length > maxCount)
+    throw new Error(`value length must be between minCount and maxCount, ${value.length} is not between ${minCount} and ${maxCount}`);
+  const stateBits = getBitsForIntegerNumber(maxCount - minCount + 1, IntegerMaxBits);
+  return {
+    type: "ENUM_ARRAY",
+    minCount,
+    maxCount,
+    value: JSON.parse(JSON.stringify(value)),
+    max,
+    name,
+    mapping,
+    stateBits
+  };
+};
+
+// src/factory/optionalFactory.ts
+var create7 = (descriptor, defaultState = false, name = "an optional") => {
+  if (descriptor[0] === null && descriptor[1] === null)
+    throw new Error("descriptor must have at least one non-null value");
+  if (descriptor[0] !== null && descriptor[1] !== null)
+    throw new Error("descriptor must have only one non-null value");
+  return {
+    type: "OPTIONAL",
+    state: defaultState,
+    descriptor,
+    value: JSON.parse(JSON.stringify(defaultState ? descriptor[1] : descriptor[0])),
+    name,
+    stateBits: 1
+  };
+};
+
 // src/factory/enumOptionsFactory.ts
 var maxEnumOptions = 64;
 var maxEnumOptionsBits = getMinimumBitsForInteger(maxEnumOptions);
+var create8 = (descriptor, defaultState = 0, name = "enum options", options) => {
+  if (descriptor.length < 2)
+    throw new Error("descriptor must have at least two entries");
+  if (descriptor.length - 1 < defaultState)
+    throw new Error("defaultState must be less than the length of the descriptor");
+  const mapping = [];
+  if (options) {
+    const { max, mapping: mapping2 } = getEnumMaxAndMappingFromOptions(options);
+    if (max !== descriptor.length - 1)
+      throw new Error("max must be equal to the length of the descriptor - 1");
+    mapping2.push(...mapping2);
+  } else
+    mapping.push(...descriptor.map((_, i) => i));
+  return {
+    value: JSON.parse(JSON.stringify(descriptor[defaultState])),
+    descriptor,
+    name,
+    mapping,
+    type: "ENUM_OPTIONS",
+    stateBits: getBitsForIntegerNumber(descriptor.length, maxEnumOptionsBits),
+    state: defaultState
+  };
+};
+
+// src/factory/arrayFactory.ts
+var maxArrayCount = 1024;
+var create9 = (descriptor, defaultState = 0, minCount = 0, maxCount = 10, name = "an array") => {
+  if (!Number.isInteger(minCount) || !Number.isInteger(maxCount))
+    throw new Error("minCount and maxCount must be integers");
+  if (minCount < 0)
+    throw new Error("minCount must be at least 0");
+  if (maxCount < 0)
+    throw new Error("maxCount must be at least 0");
+  if (maxCount - minCount < 0)
+    throw new Error("maxCount must be greater than or equal to minCount");
+  if (maxCount - minCount > maxArrayCount)
+    throw new Error(`maxCount (${maxCount}) - minCount (${minCount}) = ${maxCount - minCount} must be less than or equal to maxArrayCount (${maxArrayCount})`);
+  if (defaultState < minCount || defaultState > maxCount)
+    throw new Error(`defaultState must be between minCount (${minCount}) and maxCount (${maxCount}), given defaultState is ${defaultState}`);
+  const stateBits = getMinimumBitsForInteger(maxCount - minCount);
+  return {
+    value: [...Array(defaultState)].map(() => JSON.parse(JSON.stringify(descriptor))),
+    descriptor,
+    type: "ARRAY",
+    minCount,
+    maxCount,
+    stateBits,
+    state: defaultState,
+    name
+  };
+};
 
 // src/factory/objectFactory.ts
-var create = (descriptor, name = "an object") => {
+var create10 = (descriptor, name = "an object") => {
   return {
     type: "OBJECT",
     descriptor,
@@ -488,7 +663,19 @@ var create = (descriptor, name = "an object") => {
 };
 
 // src/factory/factory.ts
-var StateDescriptorFactoryMethod = create;
+var DataEntryFactory = {
+  FLOAT: create,
+  INT: create2,
+  ENUM: create5,
+  BOOLEAN: create3,
+  VERSION: create4,
+  ENUM_ARRAY: create6,
+  OPTIONAL: create7,
+  ENUM_OPTIONS: create8,
+  ARRAY: create9,
+  OBJECT: create10
+};
+var StateDescriptorFactoryMethod = create10;
 // src/stateHandling/stateNode.ts
 class StateNode {
   parent;
@@ -753,6 +940,47 @@ var FromState = (stateDescriptor, name, base64String) => {
   const [parsedObject] = dataEntryBitstringParser(dataObject, bitstring);
   return new ObjectNode(parsedObject, null);
 };
+// src/stateHandling/stateData.ts
+var getObjectForDataEntries = (entries) => {
+  const object = {};
+  entries.forEach((item) => {
+    object[item.name] = getStateData(item);
+  });
+  return object;
+};
+var getStateData = (entry) => {
+  switch (entry.type) {
+    case "BOOLEAN":
+    case "INT":
+    case "FLOAT":
+    case "VERSION":
+      return entry.value;
+    case "ENUM":
+      return entry.mapping[entry.value];
+    case "ENUM_ARRAY":
+      return entry.value.map((v) => entry.mapping[v]);
+    case "OPTIONAL":
+      return entry.value === null ? null : getStateData(entry.value);
+    case "ENUM_OPTIONS":
+      const state = entry.mapping[entry.state];
+      if (entry.value) {
+        switch (entry.value.type) {
+          case "OBJECT":
+            return {
+              ...getStateData(entry.value),
+              state
+            };
+          default:
+            return { state, value: getStateData(entry.value) };
+        }
+      } else
+        return { state };
+    case "OBJECT":
+      return getObjectForDataEntries(entry.value);
+    case "ARRAY":
+      return entry.value.map((v) => getStateData(v));
+  }
+};
 // src/utils/interpolateData.ts
 var interpolateEntryAt = (dataEntry2, t) => {
   const localT = Math.max(Math.min(1, t), 0);
@@ -788,6 +1016,7 @@ var getRelativeValue = (dataEntry2) => {
 export {
   parseBase64ToBits,
   interpolateEntryAt,
+  getStateData,
   getRelativeValue,
   getOptionsFromMaxAndMapping,
   getEnumMaxAndMappingFromOptions,
@@ -810,6 +1039,7 @@ export {
   EnumOptionsNode,
   EnumNode,
   EnumArrayNode,
+  DataEntryFactory,
   ConstantBitWidthDataTypes,
   BooleanNode,
   ArrayNode

package/dist/stateHandling/index.d.ts

@@ -1 +1,2 @@
 export * from './stateNode';
+export * from './stateData';

package/dist/stateHandling/stateData.d.ts

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

package/dist/types/index.d.ts

@@ -10,3 +10,4 @@ export * from './booleanData';
 export * from './dataEntry';
 export * from './objectData';
 export * from './updateType';
+export * from './stateData';

package/dist/types/stateData.d.ts

@@ -0,0 +1,4 @@
+export type StateDataObjectValue = object | string | number | number[] | boolean | null | StateDataObject;
+export type StateDataObject = {
+    [key: string]: StateDataObjectValue;
+};

package/package.json

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