@amodx/binary 0.0.11 → 0.0.12

package/Struct/Classes/BinraryStructBase.js

@@ -1,27 +1,17 @@
 import { BinaryUtil } from "../../Util/BinaryUtil.js";
-import { BinaryNumberTypes } from "../../Constants/BinaryTypes.js";
 import { StructPropertyTypes } from "../Constants/StructPropertyTypes.js";
-import { InstantiatedStruct } from "./InstantiatedStruct.js";
-const StuctIndexData = [0, 0, 0, 0];
-const getIndexData = (data, indexBufferIndex) => {
-    StuctIndexData[0] = data.getUint32(indexBufferIndex);
-    indexBufferIndex += BinaryUtil.getTypedSize(BinaryNumberTypes.Uint32);
-    StuctIndexData[1] = data.getUint8(indexBufferIndex);
-    indexBufferIndex += BinaryUtil.getTypedSize(BinaryNumberTypes.Uint8);
-    StuctIndexData[2] = data.getUint8(indexBufferIndex);
-    indexBufferIndex += BinaryUtil.getTypedSize(BinaryNumberTypes.Uint8);
-    StuctIndexData[3] = data.getUint8(indexBufferIndex);
-    indexBufferIndex += BinaryUtil.getTypedSize(BinaryNumberTypes.Uint8);
-    return StuctIndexData;
-};
+import { GetIndexData } from "../../Struct/Functions/GetIndexData.js";
+import { CreateInstance } from "../Functions/CreateInstance.js";
+import { BinaryArrays } from "../../Util/BinaryArrays.js";
 export class BinraryStructBase {
     id;
     byteOffSet = 0;
     structSize = 0;
     structArrayIndexes = 0;
     structArrayIndex = 0;
+    structData;
     data = new DataView(new ArrayBuffer(0));
-    indexMap = new Map();
+    indexMap = {};
     index = new DataView(new ArrayBuffer(0));
     constructor(id) {
         this.id = id;
@@ -44,48 +34,48 @@ export class BinraryStructBase {
         this.byteOffSet = index * this.structSize;
     }
     getProperty(id) {
-        const byteIndex = this.indexMap.get(id);
+        const byteIndex = this.indexMap[id];
         if (byteIndex === undefined) {
             throw new Error(`Tag with id: ${id} does not exist.`);
         }
-        const indexData = getIndexData(this.index, byteIndex);
-        if (indexData[3] == StructPropertyTypes.Boolean) {
+        const indexData = GetIndexData(this.index, byteIndex);
+        if (indexData[4] == StructPropertyTypes.Boolean) {
             return BinaryUtil.getBitValue(this.data.getUint8(indexData[0] + this.byteOffSet), indexData[1], indexData[2]);
         }
-        if (indexData[3] == StructPropertyTypes.TypedNumber) {
+        if (indexData[4] == StructPropertyTypes.TypedNumber) {
             return BinaryUtil.getTypedNumber(this.data, indexData[0] + this.byteOffSet, indexData[2]);
         }
         return -Infinity;
     }
     setProperty(id, value) {
-        const byteIndex = this.indexMap.get(id);
+        const byteIndex = this.indexMap[id];
         if (byteIndex === undefined) {
             throw new Error(`Tag with id: ${id} does not exist.`);
         }
-        const indexData = getIndexData(this.index, byteIndex);
-        if (indexData[3] == StructPropertyTypes.Boolean) {
+        const indexData = GetIndexData(this.index, byteIndex);
+        if (indexData[4] == StructPropertyTypes.Boolean) {
             this.data.setUint8(indexData[0] + this.byteOffSet, BinaryUtil.setBitValue(this.data.getUint8(indexData[0] + this.byteOffSet), indexData[1], value, indexData[2]));
             return true;
         }
-        if (indexData[3] == StructPropertyTypes.TypedNumber) {
+        if (indexData[4] == StructPropertyTypes.TypedNumber) {
             BinaryUtil.setTypedNumber(this.data, indexData[0] + this.byteOffSet, indexData[2], value);
             return true;
         }
         return false;
     }
     getArrayPropertyValue(id, index) {
-        const byteIndex = this.indexMap.get(id);
+        const byteIndex = this.indexMap[id];
         if (byteIndex === undefined) {
             throw new Error(`Tag with id: ${id} does not exist.`);
         }
-        const indexData = getIndexData(this.index, byteIndex);
-        if (indexData[3] == StructPropertyTypes.TypedNumberArray) {
+        const indexData = GetIndexData(this.index, byteIndex);
+        if (indexData[4] == StructPropertyTypes.TypedNumberArray) {
             return BinaryUtil.getTypedNumber(this.data, indexData[0] +
                 this.byteOffSet +
                 index * BinaryUtil.getTypedSize(indexData[2]), indexData[2]);
         }
-        if (indexData[3] == StructPropertyTypes.BitArray) {
-            return BinaryUtil.getBitArrayIndex(this.data, indexData[0] + this.byteOffSet, index);
+        if (indexData[4] == StructPropertyTypes.BitArray) {
+            return BinaryArrays.getBitArrayIndex(this.data, indexData[0] + this.byteOffSet, index);
         }
         throw new Error(`Tag with id: ${id} is not an array.`);
     }
@@ -96,12 +86,12 @@ export class BinraryStructBase {
      * @returns
      */
     getArrayPropertyByteIndex(id, index) {
-        const byteIndex = this.indexMap.get(id);
+        const byteIndex = this.indexMap[id];
         if (byteIndex === undefined) {
             throw new Error(`Tag with id: ${id} does not exist.`);
         }
-        const indexData = getIndexData(this.index, byteIndex);
-        if (indexData[3] == StructPropertyTypes.TypedNumberArray) {
+        const indexData = GetIndexData(this.index, byteIndex);
+        if (indexData[4] == StructPropertyTypes.TypedNumberArray) {
             return (indexData[0] +
                 this.byteOffSet +
                 index * BinaryUtil.getTypedSize(indexData[2]));
@@ -109,134 +99,30 @@ export class BinraryStructBase {
         return -Infinity;
     }
     setArrayPropertyValue(id, index, value) {
-        const byteIndex = this.indexMap.get(id);
+        const byteIndex = this.indexMap[id];
         if (byteIndex === undefined) {
             throw new Error(`Tag with id: ${id} does not exist.`);
         }
-        const indexData = getIndexData(this.index, byteIndex);
-        if (indexData[3] == StructPropertyTypes.TypedNumberArray) {
+        const indexData = GetIndexData(this.index, byteIndex);
+        if (indexData[4] == StructPropertyTypes.TypedNumberArray) {
             return BinaryUtil.setTypedNumber(this.data, indexData[0] +
                 this.byteOffSet +
                 index * BinaryUtil.getTypedSize(indexData[2]), indexData[2], value);
         }
-        if (indexData[3] == StructPropertyTypes.BitArray) {
-            return BinaryUtil.setBitArrayIndex(this.data, indexData[0] + this.byteOffSet, index, value);
+        if (indexData[4] == StructPropertyTypes.BitArray) {
+            return BinaryArrays.setBitArrayIndex(this.data, indexData[0] + this.byteOffSet, index, value);
         }
         return -Infinity;
     }
-    loopThroughProperties(run) {
-        this.indexMap.forEach((i, id) => {
-            run(id, this.getProperty(id));
-        });
-    }
-    loopThroughIndex(run) {
-        this.indexMap.forEach((index, id) => {
-            const indexData = getIndexData(this.index, index);
-            run(indexData);
-        });
-    }
-    loopThroughAllIndexAndProperties(run) {
-        for (let index = 0; index < this.structArrayIndexes; index++) {
-            this.setStructArrayIndex(index);
-            this.indexMap.forEach((i, id) => {
-                run(id, this.getProperty(id), index);
-            });
-        }
-    }
     /**## instantiate
      * Creates an object to read/write to the struct buffer.
      * @param structArrayIndex - Default is the current index.
      * @returns
      */
     instantiate() {
-        const self = this;
-        const GeneratedClass = class extends InstantiatedStruct {
-            constructor() {
-                super();
-                this.setBuffer(self.getBuffer());
-                this.setIndex(self.structArrayIndex);
-                this.structSize = self.structSize;
-                this.structArrayIndexes = self.structArrayIndexes;
-            }
-            _bitArrays = new Map();
-            _typedArrays = new Map();
-        };
-        const cloneClass = () => {
-            return new GeneratedClass();
-        };
-        Object.defineProperty(GeneratedClass.prototype, "clone", {
-            get() {
-                return cloneClass;
-            },
-        });
-        for (const [key, propertyByteIndex] of this.indexMap) {
-            const [byteIndex, bitOffSet, bitSize, type] = getIndexData(this.index, propertyByteIndex);
-            if (type == StructPropertyTypes.Boolean) {
-                Object.defineProperty(GeneratedClass.prototype, key, {
-                    get() {
-                        return BinaryUtil.getBitValue(this.data.getUint8(byteIndex + this.byteOffSet), bitOffSet, bitSize);
-                    },
-                    set(value) {
-                        this.data.setUint8(byteIndex + this.byteOffSet, BinaryUtil.setBitValue(this.data.getUint8(byteIndex + this.byteOffSet), bitOffSet, value, bitSize));
-                    },
-                });
-            }
-            if (type == StructPropertyTypes.TypedNumber) {
-                Object.defineProperty(GeneratedClass.prototype, key, {
-                    get() {
-                        return BinaryUtil.getTypedNumber(this.data, byteIndex + this.byteOffSet, bitSize);
-                    },
-                    set(value) {
-                        BinaryUtil.setTypedNumber(this.data, byteIndex + this.byteOffSet, bitSize, value);
-                    },
-                });
-            }
-            if (type == StructPropertyTypes.BitArray) {
-                Object.defineProperty(GeneratedClass.prototype, key, {
-                    get() {
-                        const self = this;
-                        if (!self._bitArrays.has(key)) {
-                            const proxy = new Proxy([], {
-                                get(target, index) {
-                                    return BinaryUtil.getBitArrayIndex(self.data, byteIndex + self.byteOffSet, +index);
-                                },
-                                set(target, index, value) {
-                                    BinaryUtil.setBitArrayIndex(self.data, byteIndex + self.byteOffSet, +index, value);
-                                    return true;
-                                },
-                            });
-                            self._bitArrays.set(key, proxy);
-                        }
-                        return self._bitArrays.get(key);
-                    },
-                });
-            }
-            if (type == StructPropertyTypes.TypedNumberArray) {
-                const typedNumberSize = BinaryUtil.getTypedSize(bitSize);
-                Object.defineProperty(GeneratedClass.prototype, key, {
-                    get() {
-                        const self = this;
-                        if (!self._typedArrays.has(key)) {
-                            const proxy = new Proxy([], {
-                                get(target, index) {
-                                    return BinaryUtil.getTypedNumber(self.data, byteIndex +
-                                        self.byteOffSet +
-                                        +index * typedNumberSize, bitSize);
-                                },
-                                set(target, index, value) {
-                                    BinaryUtil.setTypedNumber(self.data, byteIndex +
-                                        self.byteOffSet +
-                                        +index * typedNumberSize, bitSize, value);
-                                    return true;
-                                },
-                            });
-                            self._typedArrays.set(key, proxy);
-                        }
-                        return self._typedArrays.get(key);
-                    },
-                });
-            }
-        }
-        return new GeneratedClass();
+        const instance = CreateInstance(this.structData);
+        instance.setBuffer(this.getBuffer());
+        instance.setIndex(this.structArrayIndex);
+        return instance;
     }
 }

package/Struct/Classes/InstantiatedStruct.d.ts

@@ -1,13 +1,17 @@
 export interface InstantiatedStruct<Properties> {
 }
 export declare class InstantiatedStruct<Properties> {
-    byteOffSet: number;
+    structByteOffSet: number;
     structSize: number;
     structArrayIndexes: number;
     structArrayIndex: number;
-    data: DataView;
+    structData: DataView;
     setData(view: DataView): void;
     setBuffer(buffer: ArrayBuffer | SharedArrayBuffer): void;
     setIndex(index: number): void;
-    clone(): InstantiatedStruct<Properties> & Properties;
+    serialize(): Properties;
+    deserialize(data: Properties): void;
+    createClone(): InstantiatedStruct<Properties> & Properties;
+    setDefaults(): void;
+    getKeys(): string[];
 }

package/Struct/Classes/InstantiatedStruct.js

@@ -1,20 +1,32 @@
 export class InstantiatedStruct {
-    byteOffSet = 0;
+    structByteOffSet = 0;
     structSize = 0;
     structArrayIndexes = 0;
     structArrayIndex = 0;
-    data;
+    structData;
     setData(view) {
-        this.data = view;
+        this.structData = view;
     }
     setBuffer(buffer) {
-        this.data = new DataView(buffer);
+        this.structData = new DataView(buffer);
     }
     setIndex(index) {
         this.structArrayIndex = index;
-        this.byteOffSet = index * this.structSize;
+        this.structByteOffSet = index * this.structSize;
     }
-    clone() {
+    serialize() {
+        throw new Error("Not implemented");
+    }
+    deserialize(data) {
+        throw new Error("Not implemented");
+    }
+    createClone() {
+        throw new Error("Not implemented");
+    }
+    setDefaults() {
+        throw new Error("Not implemented");
+    }
+    getKeys() {
         throw new Error("Not implemented");
     }
 }

package/Struct/Classes/RemoteBinaryStruct.d.ts

@@ -1,8 +1,7 @@
-import type { RemoteBinaryStructData } from "../Types/RemoveBinaryStructData.types.js";
+import type { BinaryStructData } from "../Types/BinaryStructData.types.js";
 import { BinraryStructBase } from "./BinraryStructBase.js";
 export declare class RemoteBinaryStruct extends BinraryStructBase {
     id: string;
-    initData: RemoteBinaryStructData;
     constructor(id: string);
-    init(data: RemoteBinaryStructData): void;
+    init(data: BinaryStructData): void;
 }

package/Struct/Classes/RemoteBinaryStruct.js

@@ -1,17 +1,16 @@
 import { BinraryStructBase } from "./BinraryStructBase.js";
 export class RemoteBinaryStruct extends BinraryStructBase {
     id;
-    initData;
     constructor(id) {
         super(id);
         this.id = id;
     }
     init(data) {
+        this.structData = data;
         this.data = new DataView(data.buffer);
         this.index = new DataView(data.indexBuffer);
         this.indexMap = data.indexMap;
-        this.structArrayIndexes = data.structArrayLength;
+        this.structArrayIndexes = data.structArrayIndexes;
         this.structSize = data.structSize;
-        this.initData = data;
     }
 }

package/Struct/Constants/StructPropertyTypes.d.ts

@@ -2,5 +2,8 @@ export declare enum StructPropertyTypes {
     Boolean = 0,
     TypedNumber = 1,
     TypedNumberArray = 2,
-    BitArray = 3
+    BitArray = 3,
+    Vector2 = 4,
+    Vector3 = 5,
+    Vector4 = 6
 }

package/Struct/Constants/StructPropertyTypes.js

@@ -4,4 +4,7 @@ export var StructPropertyTypes;
     StructPropertyTypes[StructPropertyTypes["TypedNumber"] = 1] = "TypedNumber";
     StructPropertyTypes[StructPropertyTypes["TypedNumberArray"] = 2] = "TypedNumberArray";
     StructPropertyTypes[StructPropertyTypes["BitArray"] = 3] = "BitArray";
+    StructPropertyTypes[StructPropertyTypes["Vector2"] = 4] = "Vector2";
+    StructPropertyTypes[StructPropertyTypes["Vector3"] = 5] = "Vector3";
+    StructPropertyTypes[StructPropertyTypes["Vector4"] = 6] = "Vector4";
 })(StructPropertyTypes || (StructPropertyTypes = {}));

package/Struct/Functions/CreateIndex.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryPropertyNodes } from "../Types/BinaryStructSchema.types";
+import { BinaryStructData } from "../Types";
+export declare function CreateIndex(schemaNodes: BinaryPropertyNodes[], structArrayIndexes?: number, shared?: boolean): BinaryStructData;

package/Struct/Functions/CreateIndex.js

@@ -0,0 +1,217 @@
+import { BinaryUtil } from "../../Util/BinaryUtil.js";
+import { ByteCounts } from "../../Constants/BinaryTypes";
+import { StructPropertyTypes } from "../Constants/StructPropertyTypes";
+import { SetIndexData } from "./GetIndexData";
+const PropertyIndexSize = ByteCounts.Uint32 * 2 + ByteCounts.Uint8 * 3;
+export function CreateIndex(schemaNodes, structArrayIndexes = 1, shared = false) {
+    const schema = new Map();
+    for (const node of schemaNodes) {
+        schema.set(node.id, node);
+    }
+    const propertyDefaults = {};
+    /*
+  [Process properties]
+  */
+    const headers = new Map();
+    const booleans = [];
+    const numbers = [];
+    const typedNumbers = new Map();
+    const typedNumbersArrays = new Map();
+    const vector2s = new Map();
+    const vector3s = new Map();
+    const vector4s = new Map();
+    const bitArrays = [];
+    schema.forEach((property) => {
+        if (property.default)
+            propertyDefaults[property.id] = property.default;
+        if (property.type == "header") {
+            let properties = headers.get(property.numberType);
+            if (!properties) {
+                properties = [];
+                headers.set(property.numberType, properties);
+            }
+            properties.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 properties = typedNumbers.get(property.numberType);
+            if (!properties) {
+                properties = [];
+                typedNumbers.set(property.numberType, properties);
+            }
+            properties.push(property);
+        }
+        if (property.type == "typed-number-array") {
+            let arrayproperties = typedNumbersArrays.get(property.numberType);
+            if (!arrayproperties) {
+                arrayproperties = [];
+                typedNumbersArrays.set(property.numberType, arrayproperties);
+            }
+            arrayproperties.push(property);
+        }
+        if (property.type == "vector-2") {
+            let vectorProperties = vector2s.get(property.numberType);
+            if (!vectorProperties) {
+                vectorProperties = [];
+                vector2s.set(property.numberType, vectorProperties);
+            }
+            vectorProperties.push(property);
+        }
+        if (property.type == "vector-3") {
+            let vectorProperties = vector3s.get(property.numberType);
+            if (!vectorProperties) {
+                vectorProperties = [];
+                vector3s.set(property.numberType, vectorProperties);
+            }
+            vectorProperties.push(property);
+        }
+        if (property.type == "vector-4") {
+            let vectorProperties = vector4s.get(property.numberType);
+            if (!vectorProperties) {
+                vectorProperties = [];
+                vector4s.set(property.numberType, vectorProperties);
+            }
+            vectorProperties.push(property);
+        }
+        if (property.type == "bit-array") {
+            bitArrays.push(property);
+        }
+    });
+    /*
+  [Build Index]
+  */
+    const indexSize = schema.size * PropertyIndexSize;
+    let indexBuffer = new ArrayBuffer(indexSize);
+    if (shared) {
+        indexBuffer = new SharedArrayBuffer(indexSize);
+    }
+    const indexMap = {};
+    const index = new DataView(indexBuffer);
+    let indexBufferIndex = 0;
+    let structSize = 0;
+    let bitIndex = 0;
+    let bitSize = 1;
+    /*
+  [Headers]
+  */
+    headers.forEach((structProperties, type) => {
+        const byteSise = BinaryUtil.getTypedSize(type);
+        for (let i = 0; i < structProperties.length; i++) {
+            const headerProperties = structProperties[i];
+            indexMap[headerProperties.id] = indexBufferIndex;
+            indexBufferIndex = SetIndexData(index, indexBufferIndex, structSize, 0, headerProperties.numberType, 0, StructPropertyTypes.TypedNumber);
+            structSize += byteSise;
+        }
+    });
+    /*
+  [Booleans]
+  */
+    bitSize = 1;
+    for (let i = 0; i < booleans.length; i++) {
+        const booleanProperty = booleans[i];
+        indexMap[booleanProperty.id] = indexBufferIndex;
+        indexBufferIndex = SetIndexData(index, indexBufferIndex, structSize, bitIndex, bitSize, 0, StructPropertyTypes.Boolean);
+        bitIndex++;
+        if (bitIndex >= 8) {
+            structSize++;
+            bitIndex = 0;
+        }
+    }
+    /*
+  [Typed Numbers]
+  */
+    bitIndex = 0;
+    structSize++;
+    typedNumbers.forEach((properties, type) => {
+        const byteSise = BinaryUtil.getTypedSize(type);
+        for (let i = 0; i < properties.length; i++) {
+            const typedNumberProperty = properties[i];
+            indexMap[typedNumberProperty.id] = indexBufferIndex;
+            indexBufferIndex = SetIndexData(index, indexBufferIndex, structSize, 0, typedNumberProperty.numberType, 0, StructPropertyTypes.TypedNumber);
+            structSize += byteSise;
+        }
+    });
+    /*
+  [Typed Numbers Arrays]
+  */
+    structSize++;
+    typedNumbersArrays.forEach((properties, type) => {
+        const byteSise = BinaryUtil.getTypedSize(type);
+        for (let i = 0; i < properties.length; i++) {
+            const typedNumberArrayProperty = properties[i];
+            indexMap[typedNumberArrayProperty.id] = indexBufferIndex;
+            indexBufferIndex = SetIndexData(index, indexBufferIndex, structSize, 0, typedNumberArrayProperty.numberType, typedNumberArrayProperty.length, StructPropertyTypes.TypedNumberArray);
+            structSize += byteSise * typedNumberArrayProperty.length;
+        }
+    });
+    /*
+  [vector 2s]
+  */
+    structSize++;
+    vector2s.forEach((properties, type) => {
+        const byteSise = BinaryUtil.getTypedSize(type);
+        for (let i = 0; i < properties.length; i++) {
+            const vector2Propeerty = properties[i];
+            indexMap[vector2Propeerty.id] = indexBufferIndex;
+            indexBufferIndex = SetIndexData(index, indexBufferIndex, structSize, 0, vector2Propeerty.numberType, 2, StructPropertyTypes.Vector2);
+            structSize += byteSise * 2;
+        }
+    });
+    /*
+  [vector 3s]
+  */
+    structSize++;
+    vector3s.forEach((properties, type) => {
+        const byteSise = BinaryUtil.getTypedSize(type);
+        for (let i = 0; i < properties.length; i++) {
+            const Property = properties[i];
+            indexMap[Property.id] = indexBufferIndex;
+            indexBufferIndex = SetIndexData(index, indexBufferIndex, structSize, 0, Property.numberType, 3, StructPropertyTypes.Vector3);
+            structSize += byteSise * 3;
+        }
+    });
+    /*
+  [vector 4s]
+  */
+    structSize++;
+    vector4s.forEach((properties, type) => {
+        const byteSise = BinaryUtil.getTypedSize(type);
+        for (let i = 0; i < properties.length; i++) {
+            const Property = properties[i];
+            indexMap[Property.id] = indexBufferIndex;
+            indexBufferIndex = SetIndexData(index, indexBufferIndex, structSize, 0, Property.numberType, 4, StructPropertyTypes.Vector4);
+            structSize += byteSise * 4;
+        }
+    });
+    /*
+  [bit arrays]
+  */
+    structSize++;
+    bitArrays.forEach((properties) => {
+        const byteSise = Math.ceil(properties.length / 8) + 1;
+        indexMap[properties.id] = indexBufferIndex;
+        indexBufferIndex = SetIndexData(index, indexBufferIndex, structSize, 0, byteSise, properties.length, StructPropertyTypes.BitArray);
+        structSize += byteSise;
+    });
+    /*
+  [Create Remote Property Manager Data]
+  */
+    const remoteData = {
+        bufferSize: structSize * structArrayIndexes,
+        buffer: new ArrayBuffer(0),
+        indexBuffer,
+        indexMap,
+        propertyDefaults,
+        structSize,
+        structArrayIndexes,
+    };
+    return remoteData;
+}

package/Struct/Functions/CreateInstance.d.ts

@@ -0,0 +1,3 @@
+import { InstantiatedStruct } from "../Classes/InstantiatedStruct";
+import { BinaryStructData } from "../Types";
+export declare function CreateInstance<T extends any>(data: BinaryStructData): T & InstantiatedStruct<T>;