@amodx/binary 0.0.12 → 0.0.14

package/Arrays/BitArray.js

@@ -31,7 +31,7 @@ export class BitArray {
         if (index < 0 || index >= this.length) {
             throw new RangeError(`Index ${index} is out of bounds`);
         }
-        return BinaryArrays.getBitArrayIndex(this.data, 0, index);
+        return BinaryArrays.getBitArrayIndexView(this.data, 0, index);
     }
     set(index, value) {
         if (index < 0 || index >= this.length) {
@@ -40,7 +40,7 @@ export class BitArray {
         if (value < 0 || value > 1) {
             throw new RangeError(`Value ${value} is out of bounds for a bit`);
         }
-        BinaryArrays.setBitArrayIndex(this.data, 0, index, value);
+        BinaryArrays.setBitArrayIndexView(this.data, 0, index, value);
     }
     [Symbol.iterator]() {
         let index = 0;

package/Struct/Classes/BinraryStructBase.d.ts

@@ -8,11 +8,12 @@ export declare class BinraryStructBase {
     structArrayIndexes: number;
     structArrayIndex: number;
     structData: BinaryStructData;
-    data: DataView;
+    data: DataView<ArrayBuffer>;
     indexMap: Record<string, number>;
-    index: DataView;
+    index: DataView<ArrayBuffer>;
     constructor(id: string);
-    setBuffer(data: BufferTypes | DataView): void;
+    setData(data: DataView): void;
+    setBuffer(data: BufferTypes): void;
     getBuffer(): ArrayBuffer;
     setStructArrayIndex(index: number): void;
     getProperty(id: string): number;

package/Struct/Classes/BinraryStructBase.js

@@ -16,11 +16,10 @@ export class BinraryStructBase {
     constructor(id) {
         this.id = id;
     }
+    setData(data) {
+        this.data = data;
+    }
     setBuffer(data) {
-        if (data instanceof DataView) {
-            this.data = data;
-            return;
-        }
         this.data = new DataView(data);
     }
     getBuffer() {
@@ -75,7 +74,7 @@ export class BinraryStructBase {
                 index * BinaryUtil.getTypedSize(indexData[2]), indexData[2]);
         }
         if (indexData[4] == StructPropertyTypes.BitArray) {
-            return BinaryArrays.getBitArrayIndex(this.data, indexData[0] + this.byteOffSet, index);
+            return BinaryArrays.getBitArrayIndexView(this.data, indexData[0] + this.byteOffSet, index);
         }
         throw new Error(`Tag with id: ${id} is not an array.`);
     }
@@ -110,7 +109,7 @@ export class BinraryStructBase {
                 index * BinaryUtil.getTypedSize(indexData[2]), indexData[2], value);
         }
         if (indexData[4] == StructPropertyTypes.BitArray) {
-            return BinaryArrays.setBitArrayIndex(this.data, indexData[0] + this.byteOffSet, index, value);
+            return BinaryArrays.setBitArrayIndexView(this.data, indexData[0] + this.byteOffSet, index, value);
         }
         return -Infinity;
     }

package/Struct/Functions/CreateInstance.js

@@ -56,7 +56,7 @@ export function CreateInstance(data) {
                 const array = new Uint8Array(Math.ceil(length / 8));
                 const view = new DataView(array.buffer);
                 for (let i = 0; i < length; i++) {
-                    BinaryArrays.setBitArrayIndex(view, 0, i, parent[key][i]);
+                    BinaryArrays.setBitArrayIndexView(view, 0, i, parent[key][i]);
                 }
                 object[key] = array;
             }
@@ -191,10 +191,10 @@ export function CreateInstance(data) {
                     if (!self._props.has(key)) {
                         const proxy = new Proxy(new Array(length), {
                             get(target, index) {
-                                return BinaryArrays.getBitArrayIndex(self.structData, byteIndex + self.structByteOffSet, +index);
+                                return BinaryArrays.getBitArrayIndexView(self.structData, byteIndex + self.structByteOffSet, +index);
                             },
                             set(target, index, value) {
-                                BinaryArrays.setBitArrayIndex(self.structData, byteIndex + self.structByteOffSet, +index, value);
+                                BinaryArrays.setBitArrayIndexView(self.structData, byteIndex + self.structByteOffSet, +index, value);
                                 return true;
                             },
                         });

package/Util/BinaryArrays.d.ts

@@ -1,6 +1,8 @@
 export declare class BinaryArrays {
-    static getBitArrayIndex(data: DataView, byteOffset: number, arrayIndex: number): number;
-    static setBitArrayIndex(data: DataView, byteOffset: number, arrayIndex: number, value: number): void;
+    static getBitArrayIndexView(data: DataView, byteOffset: number, arrayIndex: number): number;
+    static setBitArrayIndexView(data: DataView, byteOffset: number, arrayIndex: number, value: number): void;
+    static getBitArrayIndex(data: Uint8Array, byteOffset: number, arrayIndex: number): number;
+    static setBitArrayIndex(data: Uint8Array, byteOffset: number, arrayIndex: number, value: number): void;
     static getNibbleArrayIndex(data: DataView, byteOffset: number, arrayIndex: number): number;
     static setNibbleArrayIndex(data: DataView, byteOffset: number, arrayIndex: number, value: number): void;
     static getHalfNibbleArrayIndex(data: DataView, byteOffset: number, arrayIndex: number): number;

package/Util/BinaryArrays.js

@@ -1,17 +1,29 @@
 import { BinaryUtil } from "./BinaryUtil";
 export class BinaryArrays {
-    static getBitArrayIndex(data, byteOffset, arrayIndex) {
+    static getBitArrayIndexView(data, byteOffset, arrayIndex) {
         const arrayByteIndex = (arrayIndex / 8) >> 0;
         const arrayBitIndex = arrayIndex - arrayByteIndex * 8;
         const arrayByte = data.getUint8(arrayByteIndex + byteOffset);
         return BinaryUtil.getBitValue(arrayByte, arrayBitIndex, 1);
     }
-    static setBitArrayIndex(data, byteOffset, arrayIndex, value) {
+    static setBitArrayIndexView(data, byteOffset, arrayIndex, value) {
         const arrayByteIndex = (arrayIndex / 8) >> 0;
         const arrayBitIndex = arrayIndex - arrayByteIndex * 8;
         const arrayByte = data.getUint8(arrayByteIndex + byteOffset);
         data.setUint8(arrayByteIndex + byteOffset, BinaryUtil.setBitValue(arrayByte, arrayBitIndex, value, 1));
     }
+    static getBitArrayIndex(data, byteOffset, arrayIndex) {
+        const arrayByteIndex = (arrayIndex / 8) >> 0;
+        const arrayBitIndex = arrayIndex - arrayByteIndex * 8;
+        const arrayByte = data[arrayByteIndex + byteOffset];
+        return BinaryUtil.getBitValue(arrayByte, arrayBitIndex, 1);
+    }
+    static setBitArrayIndex(data, byteOffset, arrayIndex, value) {
+        const arrayByteIndex = (arrayIndex / 8) >> 0;
+        const arrayBitIndex = arrayIndex - arrayByteIndex * 8;
+        const arrayByte = data[arrayByteIndex + byteOffset];
+        data[arrayByteIndex + byteOffset] = BinaryUtil.setBitValue(arrayByte, arrayBitIndex, value, 1);
+    }
     static getNibbleArrayIndex(data, byteOffset, arrayIndex) {
         const arrayByteIndex = (arrayIndex / 2) >> 0;
         const isHighNibble = arrayIndex % 2 === 0;

package/Util/ByteEncoder.d.ts

@@ -1,6 +1,6 @@
 import { BinaryNumberTypes } from "../Constants/BinaryTypes";
 export declare class ByteEncoder {
-    static view: DataView;
+    static view: DataView<ArrayBuffer>;
     static count: number;
     static value: number;
     static setValue(type: BinaryNumberTypes, value: number): typeof ByteEncoder;

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "@amodx/binary",
- "version": "0.0.12",
+ "version": "0.0.14",
  "module": "index.js",
  "types": "index.d.ts",
  "type": "module",