url-safe-bitpacking 0.3.0 → 0.3.2

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
@@ -116,12 +118,12 @@ var rawStringifier2 = (value, intData2) => {
 };
 
 // src/parsers/enumParser.ts
-var getBitsCount3 = (versionData2) => versionData2.bits;
-var rawParser3 = (rawString, versionData2) => rawValueParser(rawString, versionData2.bits);
-var rawStringifier3 = (value, versionData2) => {
-  if (value > versionData2.max)
+var getBitsCount3 = (enumData2) => enumData2.bits;
+var rawParser3 = (rawString, enumData2) => rawValueParser(rawString, enumData2.bits);
+var rawStringifier3 = (value, enumData2) => {
+  if (value > enumData2.max)
     throw new Error("Version exceeds max");
-  return rawIntStringifier(value, versionData2.bits);
+  return rawIntStringifier(value, enumData2.bits);
 };
 
 // src/parsers/versionParser.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;
@@ -504,8 +691,11 @@ class StateNode {
   }
   updateUpstream = () => {
     const newBitstring = this.getBitString();
-    if (newBitstring !== this.bitstring)
-      this.bitstring = newBitstring, this.parent && this.parent.updateUpstream();
+    if (newBitstring !== this.bitstring) {
+      this.bitstring = newBitstring;
+      if (this.parent)
+        this.parent.updateUpstream();
+    }
   };
   getStateBits = () => {
     throw new Error("not implemented for " + this.type);
@@ -565,10 +755,8 @@ class SimpleStateNodes extends StateNode {
   }
   getChildren = () => [];
   getDescription = () => `${this.name}: ${this.value}`;
-  updateValue = (value) => {
-    this.value = constrainValue7(this.descriptor, value);
-    this.updateUpstream();
-  };
+  updateValue = (value) => (this.value = constrainValue7(this.descriptor, value), this.updateUpstream());
+  updateDescriptor = (entry) => (this.descriptor = entry, this.updateValue(this.value));
   toDataEntry = () => ({
     ...this.descriptor,
     name: this.name,
@@ -596,121 +784,118 @@ class EnumArrayNode extends SimpleStateNodes {
   getDescription = () => `${this.name}: [${this.value.map((v) => this.descriptor.mapping[v]).join(", ")}]`;
 }
 
-class OptionalNode extends StateNode {
+class ComplexStateNodes extends StateNode {
   state;
-  stateBits;
   descriptor;
-  child = null;
   constructor(entry, parent) {
     super(entry, parent);
     this.state = entry.state;
-    this.stateBits = entry.stateBits;
-    this.descriptor = entry["descriptor"];
+    this.descriptor = entry;
+  }
+}
+
+class OptionalNode extends ComplexStateNodes {
+  child = null;
+  constructor(entry, parent) {
+    super(entry, parent);
+    this.child = this.initializedChild();
     this.bitstring = this.getBitString();
   }
   getChildren = () => [this.child];
   getStateBits = () => rawStateStringifier3(this.state);
   getValueBits = () => this.child ? this.child.bitstring : "";
+  initializedChild = () => this.descriptor.descriptor[this.state ? 1 : 0] ? NodeFactory(this.descriptor.descriptor[this.state ? 1 : 0], this) : null;
   updateState = (newState) => {
-    this.state = constrainState(newState);
-    if (this.state === this.state)
+    const constrainedNewState = constrainState(newState);
+    if (this.state === constrainedNewState)
       return;
-    this.child = this.descriptor[this.state ? 1 : 0] ? NodeFactory(this.descriptor[this.state ? 1 : 0], this) : null;
+    this.state = constrainedNewState;
+    this.child = this.descriptor.descriptor[this.state ? 1 : 0] ? NodeFactory(this.descriptor.descriptor[this.state ? 1 : 0], this) : null;
+    this.updateUpstream();
+  };
+  updateDescriptor = (entry) => {
+    this.descriptor = entry;
+    this.child = this.initializedChild();
     this.updateUpstream();
   };
   toDataEntry = () => ({
-    type: "OPTIONAL",
+    ...this.descriptor,
     name: this.name,
     state: this.state,
-    stateBits: this.stateBits,
-    descriptor: this.descriptor,
     value: this.child ? this.child.toDataEntry() : null
   });
   getDescription = () => `${this.name}: ${this.state}`;
 }
 
-class EnumOptionsNode extends StateNode {
-  state;
-  stateBits;
-  descriptor;
-  mapping;
+class EnumOptionsNode extends ComplexStateNodes {
   child = null;
   constructor(entry, parent) {
     super(entry, parent);
-    this.state = entry.state;
-    this.stateBits = entry.stateBits;
-    this.descriptor = entry["descriptor"];
-    this.mapping = entry["mapping"];
-    this.child = entry["value"] ? NodeFactory(entry["value"], this) : null;
+    this.child = this.initializedChild();
     this.bitstring = this.getBitString();
   }
   getChildren = () => [this.child];
-  getStateBits = () => rawStateStringifier4(this.state, this.stateBits);
+  getStateBits = () => rawStateStringifier4(this.state, this.descriptor.stateBits);
   getValueBits = () => this.child ? this.child.bitstring : "";
+  initializedChild = () => this.descriptor.descriptor[this.state] ? NodeFactory(this.descriptor.descriptor[this.state], this) : null;
   updateState = (newState) => {
-    const constrainedNewState = constrainState2(this.descriptor.length, newState);
+    const constrainedNewState = constrainState2(this.descriptor.descriptor.length, newState);
     if (constrainedNewState === this.state)
       return;
-    const validationResult = validateDataEntry(this.descriptor[constrainedNewState], this.child ? this.child.toDataEntry() : null);
+    const validationResult = validateDataEntry(this.descriptor.descriptor[constrainedNewState], this.child ? this.child.toDataEntry() : null);
     this.child = validationResult ? NodeFactory(validationResult, this) : null;
     this.state = constrainedNewState;
     this.updateUpstream();
   };
+  updateDescriptor = (entry) => {
+    this.descriptor = entry;
+    this.child = this.initializedChild();
+    this.updateUpstream();
+  };
   toDataEntry = () => ({
-    type: "ENUM_OPTIONS",
+    ...this.descriptor,
     name: this.name,
     state: this.state,
-    stateBits: this.stateBits,
-    descriptor: this.descriptor,
-    mapping: this.mapping,
     value: this.child ? this.child.toDataEntry() : null
   });
-  getDescription = () => `${this.name}: ${this.state} of ${this.mapping.length} options`;
+  getDescription = () => `${this.name}: ${this.state} of ${this.descriptor.mapping.length} options`;
 }
 
-class ArrayNode extends StateNode {
-  descriptor;
+class ArrayNode extends ComplexStateNodes {
   children;
-  minCount;
-  maxCount;
-  stateBits;
-  state;
   constructor(entry, parent) {
     super(entry, parent);
-    this.descriptor = entry["descriptor"];
-    this.children = entry["value"].map((child) => NodeFactory(child, this));
-    this.minCount = entry["minCount"];
-    this.maxCount = entry["maxCount"];
-    this.stateBits = entry["stateBits"];
-    this.state = entry["state"];
+    this.children = this.initializedChildren();
     this.bitstring = this.getBitString();
   }
+  initializedChildren = () => this.descriptor.value.map((child) => NodeFactory(child, this));
   getChildren = () => this.children;
-  getStateBits = () => rawStateStringifier2(this.state, this.minCount, this.stateBits);
+  getStateBits = () => rawStateStringifier2(this.state, this.descriptor.minCount, this.descriptor.stateBits);
   getValueBits = () => this.children.map((child) => child.bitstring).join("");
+  updateDescriptor = (entry) => {
+    this.descriptor = entry;
+    this.children = this.initializedChildren();
+    this.updateUpstream();
+  };
   updateState = (newState) => {
-    const constrainedNewState = constrainState3(newState, this.minCount, this.maxCount);
+    const constrainedNewState = constrainState3(newState, this.descriptor.minCount, this.descriptor.maxCount);
     if (constrainedNewState === this.state)
       return;
     if (constrainedNewState < this.state)
       this.children = this.children.slice(0, constrainedNewState);
     else
       for (let i = this.state;i < constrainedNewState; i++)
-        this.children.push(NodeFactory(this.descriptor, this));
+        this.children.push(NodeFactory(this.descriptor.descriptor, this));
     this.state = constrainedNewState;
     this.updateUpstream();
   };
   toDataEntry = () => ({
-    type: "ARRAY",
+    ...this.descriptor,
     name: this.name,
     value: this.children.map((child) => child.toDataEntry()),
-    minCount: this.minCount,
-    maxCount: this.maxCount,
-    stateBits: this.stateBits,
-    state: this.state,
-    descriptor: this.descriptor
+    state: this.state
   });
-  getDescription = () => `${this.name}: ${this.state} of (${this.minCount}, ${this.maxCount})`;
+  getDescription = () => `${this.name}: ${this.state} of (${this.descriptor.minCount}, ${this.descriptor.maxCount})`;
 }
 
 class ObjectNode extends StateNode {
@@ -718,18 +903,23 @@ class ObjectNode extends StateNode {
   children;
   constructor(entry, parent) {
     super(entry, parent);
-    this.descriptor = entry["descriptor"];
-    this.children = entry["value"].map((child) => NodeFactory(child, this));
+    this.descriptor = entry;
+    this.children = this.initializedChild();
     this.bitstring = this.getBitString();
   }
+  initializedChild = () => this.descriptor.value.map((child) => NodeFactory(child, this));
+  updateDescriptor = (entry) => {
+    this.descriptor = entry;
+    this.children = this.initializedChild();
+    this.updateUpstream();
+  };
   getChildren = () => this.children;
   getStateBits = () => "";
   getValueBits = () => this.children.map((child) => child.bitstring).join("");
   toDataEntry = () => ({
-    type: "OBJECT",
+    ...this.descriptor,
     name: this.name,
     value: this.children.map((child) => child.toDataEntry()),
-    descriptor: this.descriptor,
     stateBits: 0
   });
 }
@@ -753,6 +943,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 +1019,7 @@ var getRelativeValue = (dataEntry2) => {
 export {
   parseBase64ToBits,
   interpolateEntryAt,
+  getStateData,
   getRelativeValue,
   getOptionsFromMaxAndMapping,
   getEnumMaxAndMappingFromOptions,
@@ -810,6 +1042,7 @@ export {
   EnumOptionsNode,
   EnumNode,
   EnumArrayNode,
+  DataEntryFactory,
   ConstantBitWidthDataTypes,
   BooleanNode,
   ArrayNode

package/dist/parsers/enumParser.d.ts

@@ -1,4 +1,4 @@
 import { EnumData } from '../types/enumData';
-export declare const getBitsCount: (versionData: EnumData) => number;
-export declare const rawParser: (rawString: string, versionData: EnumData) => number;
-export declare const rawStringifier: (value: number, versionData: EnumData) => string;
+export declare const getBitsCount: (enumData: EnumData) => number;
+export declare const rawParser: (rawString: string, enumData: EnumData) => number;
+export declare const rawStringifier: (value: number, enumData: EnumData) => string;

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/stateHandling/stateNode.d.ts

@@ -1,5 +1,5 @@
 import { DataType } from '../enums';
-import { ArrayDataEntry, BooleanDataEntry, DataEntry, EnumArrayDataEntry, EnumDataEntry, EnumOptionsDataEntry, FloatDataEntry, IntDataEntry, ObjectDataEntry, OptionalDataEntry, VersionDataEntry, UpdateWithValidationTypes } from '../types';
+import { ArrayDataEntry, BooleanDataEntry, DataEntry, EnumArrayDataEntry, EnumDataEntry, EnumOptionsDataEntry, FloatDataEntry, IntDataEntry, ObjectDataEntry, OptionalDataEntry, VersionDataEntry, UpdateWithValidationTypes, UpdateWithStateEntries } from '../types';
 export declare class StateNode {
     protected parent: StateNode | null;
     protected root: StateNode;
@@ -35,6 +35,7 @@ declare class SimpleStateNodes<T extends UpdateWithValidationTypes> extends Stat
     getChildren: () => SpecificTypeNode[];
     getDescription: () => string;
     updateValue: (value: T["value"]) => void;
+    updateDescriptor: (entry: T) => void;
     toDataEntry: () => T;
 }
 export declare class VersionNode extends SimpleStateNodes<VersionDataEntry> {
@@ -51,44 +52,43 @@ export declare class EnumArrayNode extends SimpleStateNodes<EnumArrayDataEntry>
     getStateBits: () => string;
     getDescription: () => string;
 }
-export declare class OptionalNode extends StateNode {
-    private state;
-    private stateBits;
-    private descriptor;
+declare class ComplexStateNodes<T extends UpdateWithStateEntries> extends StateNode {
+    state: T['state'];
+    descriptor: T;
+    constructor(entry: T, parent: SpecificTypeNode | null);
+}
+export declare class OptionalNode extends ComplexStateNodes<OptionalDataEntry> {
     private child;
     constructor(entry: OptionalDataEntry, parent: SpecificTypeNode | null);
     getChildren: () => (SpecificTypeNode | null)[];
     getStateBits: () => string;
     getValueBits: () => string;
+    private initializedChild;
     updateState: (newState: OptionalDataEntry["state"]) => void;
+    updateDescriptor: (entry: OptionalDataEntry) => void;
     toDataEntry: () => OptionalDataEntry;
     getDescription: () => string;
 }
-export declare class EnumOptionsNode extends StateNode {
-    private state;
-    private stateBits;
-    private descriptor;
-    private mapping;
+export declare class EnumOptionsNode extends ComplexStateNodes<EnumOptionsDataEntry> {
     private child;
     constructor(entry: EnumOptionsDataEntry, parent: SpecificTypeNode | null);
     getChildren: () => (SpecificTypeNode | null)[];
     getStateBits: () => string;
     getValueBits: () => string;
+    private initializedChild;
     updateState: (newState: EnumOptionsDataEntry["state"]) => void;
+    updateDescriptor: (entry: EnumOptionsDataEntry) => void;
     toDataEntry: () => EnumOptionsDataEntry;
     getDescription: () => string;
 }
-export declare class ArrayNode extends StateNode {
-    private descriptor;
+export declare class ArrayNode extends ComplexStateNodes<ArrayDataEntry> {
     private children;
-    private minCount;
-    private maxCount;
-    private stateBits;
-    private state;
     constructor(entry: ArrayDataEntry, parent: SpecificTypeNode | null);
+    private initializedChildren;
     getChildren: () => SpecificTypeNode[];
     getStateBits: () => string;
     getValueBits: () => string;
+    updateDescriptor: (entry: ArrayDataEntry) => void;
     updateState: (newState: ArrayDataEntry["state"]) => void;
     toDataEntry: () => ArrayDataEntry;
     getDescription: () => string;
@@ -97,6 +97,8 @@ export declare class ObjectNode extends StateNode {
     private descriptor;
     private children;
     constructor(entry: ObjectDataEntry, parent: SpecificTypeNode | null);
+    private initializedChild;
+    updateDescriptor: (entry: ObjectDataEntry) => void;
     getChildren: () => SpecificTypeNode[];
     getStateBits: () => string;
     getValueBits: () => string;

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.2",
   "author": "Jonas Ward",
   "description": "Library for creating web safe base64 objects with custom bith widths and dynamic values.",
   "scripts": {