@amodx/binary 0.0.0 → 0.0.12

package/Arrays/BitArray.d.ts

@@ -0,0 +1,13 @@
+export interface BitArray {
+    [index: number]: number;
+}
+export declare class BitArray {
+    buffer: ArrayBufferLike;
+    private data;
+    constructor(buffer: ArrayBufferLike);
+    get length(): number;
+    get(index: number): number;
+    set(index: number, value: number): void;
+    [Symbol.iterator](): Iterator<number>;
+    forEach(callback: (value: number, index: number, array: BitArray) => void): void;
+}

package/Arrays/BitArray.js

@@ -0,0 +1,63 @@
+import { BinaryArrays } from "../Util/BinaryArrays";
+export class BitArray {
+    buffer;
+    data;
+    constructor(buffer) {
+        this.buffer = buffer;
+        this.data = new DataView(ArrayBuffer.isView(buffer) ? buffer.buffer : buffer);
+        return new Proxy(this, {
+            get: (target, property) => {
+                if (typeof property === "string" && !isNaN(Number(property))) {
+                    const index = Number(property);
+                    return target.get(index);
+                }
+                return target[property];
+            },
+            set: (target, property, value) => {
+                if (typeof property === "string" && !isNaN(Number(property))) {
+                    const index = Number(property);
+                    target.set(index, value);
+                    return true;
+                }
+                target[property] = value;
+                return true;
+            },
+        });
+    }
+    get length() {
+        return this.buffer.byteLength * 8;
+    }
+    get(index) {
+        if (index < 0 || index >= this.length) {
+            throw new RangeError(`Index ${index} is out of bounds`);
+        }
+        return BinaryArrays.getBitArrayIndex(this.data, 0, index);
+    }
+    set(index, value) {
+        if (index < 0 || index >= this.length) {
+            throw new RangeError(`Index ${index} is out of bounds`);
+        }
+        if (value < 0 || value > 1) {
+            throw new RangeError(`Value ${value} is out of bounds for a bit`);
+        }
+        BinaryArrays.setBitArrayIndex(this.data, 0, index, value);
+    }
+    [Symbol.iterator]() {
+        let index = 0;
+        return {
+            next: () => {
+                if (index < this.length) {
+                    return { value: this.get(index++), done: false };
+                }
+                else {
+                    return { value: undefined, done: true };
+                }
+            },
+        };
+    }
+    forEach(callback) {
+        for (let i = 0; i < this.length; i++) {
+            callback(this.get(i), i, this);
+        }
+    }
+}

package/Arrays/HalfNibbleArray.d.ts

@@ -0,0 +1,13 @@
+export interface HalfNibbleArray {
+    [index: number]: number;
+}
+export declare class HalfNibbleArray {
+    buffer: ArrayBufferLike;
+    private data;
+    constructor(buffer: ArrayBufferLike);
+    get length(): number;
+    get(index: number): number;
+    set(index: number, value: number): void;
+    [Symbol.iterator](): Iterator<number>;
+    forEach(callback: (value: number, index: number, array: HalfNibbleArray) => void): void;
+}

package/Arrays/HalfNibbleArray.js

@@ -0,0 +1,63 @@
+import { BinaryArrays } from "../Util/BinaryArrays";
+export class HalfNibbleArray {
+    buffer;
+    data;
+    constructor(buffer) {
+        this.buffer = buffer;
+        this.data = new DataView(ArrayBuffer.isView(buffer) ? buffer.buffer : buffer);
+        return new Proxy(this, {
+            get: (target, property) => {
+                if (typeof property === "string" && !isNaN(Number(property))) {
+                    const index = Number(property);
+                    return target.get(index);
+                }
+                return target[property];
+            },
+            set: (target, property, value) => {
+                if (typeof property === "string" && !isNaN(Number(property))) {
+                    const index = Number(property);
+                    target.set(index, value);
+                    return true;
+                }
+                target[property] = value;
+                return true;
+            },
+        });
+    }
+    get length() {
+        return this.buffer.byteLength * 4;
+    }
+    get(index) {
+        if (index < 0 || index >= this.length) {
+            throw new RangeError(`Index ${index} is out of bounds`);
+        }
+        return BinaryArrays.getHalfNibbleArrayIndex(this.data, 0, index);
+    }
+    set(index, value) {
+        if (index < 0 || index >= this.length) {
+            throw new RangeError(`Index ${index} is out of bounds`);
+        }
+        if (value < 0 || value > 3) {
+            throw new RangeError(`Value ${value} is out of bounds for a half nibble`);
+        }
+        BinaryArrays.setHalfNibbleArrayIndex(this.data, 0, index, value);
+    }
+    [Symbol.iterator]() {
+        let index = 0;
+        return {
+            next: () => {
+                if (index < this.length) {
+                    return { value: this.get(index++), done: false };
+                }
+                else {
+                    return { value: undefined, done: true };
+                }
+            },
+        };
+    }
+    forEach(callback) {
+        for (let i = 0; i < this.length; i++) {
+            callback(this.get(i), i, this);
+        }
+    }
+}

package/Arrays/NibbleArray.d.ts

@@ -0,0 +1,13 @@
+export interface NibbleArray {
+    [index: number]: number;
+}
+export declare class NibbleArray {
+    buffer: ArrayBufferLike;
+    private data;
+    constructor(buffer: ArrayBufferLike);
+    get length(): number;
+    get(index: number): number;
+    set(index: number, value: number): void;
+    [Symbol.iterator](): Iterator<number>;
+    forEach(callback: (value: number, index: number, array: NibbleArray) => void): void;
+}

package/Arrays/NibbleArray.js

@@ -0,0 +1,63 @@
+import { BinaryArrays } from "../Util/BinaryArrays";
+export class NibbleArray {
+    buffer;
+    data;
+    constructor(buffer) {
+        this.buffer = buffer;
+        this.data = new DataView(ArrayBuffer.isView(buffer) ? buffer.buffer : buffer);
+        return new Proxy(this, {
+            get: (target, property) => {
+                if (typeof property === "string" && !isNaN(Number(property))) {
+                    const index = Number(property);
+                    return target.get(index);
+                }
+                return target[property];
+            },
+            set: (target, property, value) => {
+                if (typeof property === "string" && !isNaN(Number(property))) {
+                    const index = Number(property);
+                    target.set(index, value);
+                    return true;
+                }
+                target[property] = value;
+                return true;
+            },
+        });
+    }
+    get length() {
+        return this.buffer.byteLength * 2;
+    }
+    get(index) {
+        if (index < 0 || index >= this.length) {
+            throw new RangeError(`Index ${index} is out of bounds`);
+        }
+        return BinaryArrays.getNibbleArrayIndex(this.data, 0, index);
+    }
+    set(index, value) {
+        if (index < 0 || index >= this.length) {
+            throw new RangeError(`Index ${index} is out of bounds`);
+        }
+        if (value < 0 || value > 15) {
+            throw new RangeError(`Value ${value} is out of bounds for a nibble`);
+        }
+        BinaryArrays.setNibbleArrayIndex(this.data, 0, index, value);
+    }
+    [Symbol.iterator]() {
+        let index = 0;
+        return {
+            next: () => {
+                if (index < this.length) {
+                    return { value: this.get(index++), done: false };
+                }
+                else {
+                    return { value: undefined, done: true };
+                }
+            },
+        };
+    }
+    forEach(callback) {
+        for (let i = 0; i < this.length; i++) {
+            callback(this.get(i), i, this);
+        }
+    }
+}

package/Object/BinaryObject.d.ts

@@ -3,9 +3,9 @@ import { TypedNode } from "./Classes/TypedNode.js";
 export declare class BinaryObject {
     static nodes: typeof TypedNodes;
     static setUseSharedMemory(useSharedMemory: boolean): void;
-    static bufferToObject<T>(buffer: ArrayBuffer, byteOffSet?: number, byteLength?: number): T;
+    static bufferToObject<T>(buffer: ArrayBufferLike, byteOffSet?: number, byteLength?: number): T;
     static objectToBuffer(obj: any): ArrayBuffer;
     static objectToTypedNodes(object: any): TypedNode<any>;
     static typedNodeToBuffer(data: TypedNode<any>): ArrayBuffer;
-    static bufferToTypedNodes<T>(buffer: ArrayBuffer, byteOffSet?: number, byteLength?: number): TypedNode<T>;
+    static bufferToTypedNodes<T>(buffer: ArrayBufferLike, byteOffSet?: number, byteLength?: number): TypedNode<T>;
 }

package/Object/Functions/BufferToObject.d.ts

@@ -15,7 +15,7 @@ export declare class BufferToObject {
     static _assign(value: any): void;
     static markFunctions: Record<BinaryObjectMarkers, (dv: DataView, index: number) => number>;
     static setUseSharedMemory(useSharedMemory: boolean): void;
-    static toObject<T>(buffer: ArrayBuffer, byteOffSet?: number, byteOffSetEnd?: number): T;
-    static toJSON<T>(buffer: ArrayBuffer, byteOffSet?: number, byteOffSetEnd?: number): T;
-    static toTypedNodes<T>(buffer: ArrayBuffer, byteOffSet?: number, byteOffSetEnd?: number): T;
+    static toObject<T>(buffer: ArrayBufferLike, byteOffSet?: number, byteOffSetEnd?: number): T;
+    static toJSON<T>(buffer: ArrayBufferLike, byteOffSet?: number, byteOffSetEnd?: number): T;
+    static toTypedNodes<T>(buffer: ArrayBufferLike, byteOffSet?: number, byteOffSetEnd?: number): T;
 }

package/Object/Functions/BufferToObject.js

@@ -235,8 +235,8 @@ export class BufferToObject {
         },
         [BinaryObjectMarkers.TypedArray]: (dv, index) => {
             const type = ByteDataGet[BinaryNumberTypes.Uint8](dv, index + 1);
-            if (!type)
-                throw new Error();
+            if (type === undefined)
+                throw new Error(`Not a valid type for a typed array ${type}`);
             const length = ByteDataGet[BinaryNumberTypes.Uint32](dv, index + 2);
             index += ByteCounts.Uint8 * 2 + ByteCounts.Uint32;
             let array;

package/Object/Functions/ObjectToTypedNodes.js

@@ -21,7 +21,8 @@ export class ObjectToTypedNodes {
                 node.value[key] = this._addPrimitive(value);
                 continue;
             }
-            if (value instanceof Blob || value instanceof File) {
+            if (value instanceof Blob ||
+                (typeof File !== "undefined" && value instanceof File)) {
                 continue;
             }
             if (typeof value == "object" && !Array.isArray(value)) {

package/Struct/Classes/BinaryStruct.d.ts

@@ -1,5 +1,5 @@
-import type { BinaryPropertySchema, BinaryPropertyNodes } from "../Types/BinaryStructSchema.types";
-import type { RemoteBinaryStructData } from "../Types/RemoveBinaryStructData.types";
+import type { BinaryPropertyNodes } from "../Types/BinaryStructSchema.types";
+import type { BinaryStructData } from "../Types/BinaryStructData.types";
 import { BinraryStructBase } from "./BinraryStructBase";
 type PropertyManagerInitData = {
     indexBufferMode?: "normal" | "shared";
@@ -7,10 +7,9 @@ type PropertyManagerInitData = {
 };
 export declare class BinaryStruct extends BinraryStructBase {
     id: string;
-    schema: BinaryPropertySchema;
-    initData: RemoteBinaryStructData;
+    properties: BinaryPropertyNodes[];
     constructor(id: string);
     registerProperty(...PropertyData: BinaryPropertyNodes[]): void;
-    init(initData?: PropertyManagerInitData): RemoteBinaryStructData;
+    init(initData?: PropertyManagerInitData): BinaryStructData;
 }
 export {};

package/Struct/Classes/BinaryStruct.js

@@ -1,170 +1,23 @@
-import { BinaryUtil } from "../../Util/BinaryUtil.js";
 import { BinraryStructBase } from "./BinraryStructBase";
-import { ByteCounts } from "../../Constants/BinaryTypes";
-import { StructPropertyTypes } from "../Constants/StructPropertyTypes";
-const PropertyIndexSize = ByteCounts.Uint32 + ByteCounts.Uint8 * 3;
-const setIndexData = (data, indexBufferIndex, byteIndex, bitOffSet, bitSize, type) => {
-    data.setUint32(indexBufferIndex, byteIndex);
-    indexBufferIndex += ByteCounts.Uint32;
-    data.setUint8(indexBufferIndex, bitOffSet);
-    indexBufferIndex += ByteCounts.Uint8;
-    data.setUint8(indexBufferIndex, bitSize);
-    indexBufferIndex += ByteCounts.Uint8;
-    data.setUint8(indexBufferIndex, type);
-    indexBufferIndex += ByteCounts.Uint8;
-    return indexBufferIndex;
-};
+import { CreateIndex } from "../Functions/CreateIndex";
 export class BinaryStruct extends BinraryStructBase {
     id;
-    schema = new Map();
-    initData = {};
+    properties = [];
     constructor(id) {
         super(id);
         this.id = id;
     }
     registerProperty(...PropertyData) {
-        PropertyData.forEach((_) => this.schema.set(_.id, _));
+        PropertyData.forEach((_) => this.properties.push(_));
     }
     init(initData) {
-        /*
-    [Process Propertys]
-    */
-        const headers = new Map();
-        const booleans = [];
-        const numbers = [];
-        const typedNumbers = new Map();
-        const typedNumbersArrays = new Map();
-        const bitArrays = [];
-        this.schema.forEach((Property) => {
-            if (Property.type == "header") {
-                let Propertys = headers.get(Property.numberType);
-                if (!Propertys) {
-                    Propertys = [];
-                    headers.set(Property.numberType, Propertys);
-                }
-                Propertys.push(Property);
-            }
-            if (Property.type == "boolean") {
-                booleans.push(Property);
-            }
-            if (Property.type == "number") {
-                const range = Property.range;
-                const bitSize = BinaryUtil.calculateBitsNeeded(range[0], range[1]);
-                numbers[bitSize] ??= [];
-                numbers[bitSize].push(Property);
-            }
-            if (Property.type == "typed-number") {
-                let Propertys = typedNumbers.get(Property.numberType);
-                if (!Propertys) {
-                    Propertys = [];
-                    typedNumbers.set(Property.numberType, Propertys);
-                }
-                Propertys.push(Property);
-            }
-            if (Property.type == "typed-number-array") {
-                let arrayPropertys = typedNumbersArrays.get(Property.numberType);
-                if (!arrayPropertys) {
-                    arrayPropertys = [];
-                    typedNumbersArrays.set(Property.numberType, arrayPropertys);
-                }
-                arrayPropertys.push(Property);
-            }
-            if (Property.type == "bit-array") {
-                bitArrays.push(Property);
-            }
-        });
-        /*
-    [Build Index]
-    */
-        const indexSize = this.schema.size * PropertyIndexSize;
-        let indexBuffer = new ArrayBuffer(indexSize);
-        if (initData?.indexBufferMode == "shared") {
-            indexBuffer = new SharedArrayBuffer(indexSize);
-        }
-        const index = new DataView(indexBuffer);
-        this.index = index;
-        let indexBufferIndex = 0;
-        let byteIndex = 0;
-        let bitIndex = 0;
-        let bitSize = 1;
-        /*
-    [Headers]
-    */
-        headers.forEach((Propertys, type) => {
-            const byteSise = BinaryUtil.getTypedSize(type);
-            for (let i = 0; i < Propertys.length; i++) {
-                const Property = Propertys[i];
-                this.indexMap.set(Property.id, indexBufferIndex);
-                indexBufferIndex = setIndexData(index, indexBufferIndex, byteIndex, 0, Property.numberType, StructPropertyTypes.TypedNumber);
-                byteIndex += byteSise;
-            }
-        });
-        /*
-    [Booleans]
-    */
-        bitSize = 1;
-        for (let i = 0; i < booleans.length; i++) {
-            const bool = booleans[i];
-            this.indexMap.set(bool.id, indexBufferIndex);
-            indexBufferIndex = setIndexData(index, indexBufferIndex, byteIndex, bitIndex, bitSize, StructPropertyTypes.Boolean);
-            bitIndex++;
-            if (bitIndex >= 8) {
-                byteIndex++;
-                bitIndex = 0;
-            }
-        }
-        /*
-    [Typed Numbers]
-    */
-        bitIndex = 0;
-        byteIndex++;
-        typedNumbers.forEach((Propertys, type) => {
-            const byteSise = BinaryUtil.getTypedSize(type);
-            for (let i = 0; i < Propertys.length; i++) {
-                const Property = Propertys[i];
-                this.indexMap.set(Property.id, indexBufferIndex);
-                indexBufferIndex = setIndexData(index, indexBufferIndex, byteIndex, 0, Property.numberType, StructPropertyTypes.TypedNumber);
-                byteIndex += byteSise;
-            }
-        });
-        /*
-    [Typed Numbers Arrays]
-    */
-        byteIndex++;
-        typedNumbersArrays.forEach((Propertys, type) => {
-            const byteSise = BinaryUtil.getTypedSize(type);
-            for (let i = 0; i < Propertys.length; i++) {
-                const Property = Propertys[i];
-                this.indexMap.set(Property.id, indexBufferIndex);
-                indexBufferIndex = setIndexData(index, indexBufferIndex, byteIndex, 0, Property.numberType, StructPropertyTypes.TypedNumberArray);
-                byteIndex += byteSise * Property.length;
-            }
-        });
-        byteIndex++;
-        bitArrays.forEach((Property) => {
-            const byteSise = Math.ceil(Property.length / 8) + 1;
-            this.indexMap.set(Property.id, indexBufferIndex);
-            indexBufferIndex = setIndexData(index, indexBufferIndex, byteIndex, 0, byteSise, StructPropertyTypes.BitArray);
-            byteIndex += byteSise;
-        });
-        /*
-    [Create Remote Property Manager Data]
-    */
-        let numberOfIndexes = 1;
-        if (initData?.numberOfIndexes) {
-            numberOfIndexes = initData.numberOfIndexes;
-        }
-        this.structArrayIndexes = numberOfIndexes;
-        this.structSize = byteIndex;
-        const remoteData = {
-            bufferSize: byteIndex * numberOfIndexes,
-            buffer: new ArrayBuffer(0),
-            indexBuffer: indexBuffer,
-            indexMap: this.indexMap,
-            structSize: this.structSize,
-            structArrayLength: numberOfIndexes,
-        };
-        this.initData = remoteData;
-        return remoteData;
+        const data = CreateIndex(this.properties, initData?.numberOfIndexes, initData?.indexBufferMode == "shared");
+        this.structData = data;
+        this.data = new DataView(data.buffer);
+        this.index = new DataView(data.indexBuffer);
+        this.indexMap = data.indexMap;
+        this.structArrayIndexes = data.structArrayIndexes;
+        this.structSize = data.structSize;
+        return data;
     }
 }

package/Struct/Classes/BinraryStructBase.d.ts

@@ -1,13 +1,15 @@
 import { BufferTypes } from "../../Util/BufferTypes.js";
 import { InstantiatedStruct } from "./InstantiatedStruct.js";
+import { BinaryStructData } from "../Types/BinaryStructData.types.js";
 export declare class BinraryStructBase {
     id: string;
     byteOffSet: number;
     structSize: number;
     structArrayIndexes: number;
     structArrayIndex: number;
+    structData: BinaryStructData;
     data: DataView;
-    indexMap: Map<string, number>;
+    indexMap: Record<string, number>;
     index: DataView;
     constructor(id: string);
     setBuffer(data: BufferTypes | DataView): void;
@@ -24,9 +26,6 @@ export declare class BinraryStructBase {
      */
     getArrayPropertyByteIndex(id: string, index: number): number;
     setArrayPropertyValue(id: string, index: number, value: number): number | void;
-    loopThroughProperties(run: (id: string, value: number) => void): void;
-    loopThroughIndex(run: (data: number[]) => void): void;
-    loopThroughAllIndexAndProperties(run: (id: string, value: number, index: number) => void): void;
     /**## instantiate
      * Creates an object to read/write to the struct buffer.
      * @param structArrayIndex - Default is the current index.