@amodx/binary 0.0.11 → 0.0.12

package/Struct/Functions/CreateInstance.js

@@ -0,0 +1,323 @@
+import { InstantiatedStruct } from "../Classes/InstantiatedStruct";
+import { StructPropertyTypes } from "../Constants/StructPropertyTypes";
+import { BinaryUtil } from "../../Util/BinaryUtil";
+import { GetIndexData } from "./GetIndexData";
+import { TypedArrayClassMap } from "../../Util/TypedArrayMap";
+import { BinaryArrays } from "../../Util/BinaryArrays";
+import { BitArray } from "../../Arrays/BitArray";
+const vector2Indexes = { x: 0, y: 1 };
+const vector3Indexes = { x: 0, y: 1, z: 2 };
+const vector4Indexes = { x: 0, y: 1, z: 2, w: 3 };
+export function CreateInstance(data) {
+    const index = new DataView(data.indexBuffer);
+    const GeneratedClass = class extends InstantiatedStruct {
+        constructor() {
+            super();
+            this.structSize = data.structSize;
+            this.structArrayIndexes = data.structArrayIndexes;
+        }
+        _props = new Map();
+    };
+    const keys = [];
+    Object.defineProperty(GeneratedClass.prototype, "createClone", {
+        get() {
+            return () => {
+                const clone = new GeneratedClass();
+                if (this.structData?.buffer)
+                    clone.setBuffer(this.structData.buffer);
+                clone.setIndex(this.structArrayIndex);
+                return clone;
+            };
+        },
+    });
+    Object.defineProperty(GeneratedClass.prototype, "getKeys", {
+        get() {
+            return () => keys;
+        },
+    });
+    const seralize = (parent) => {
+        const object = {};
+        for (const [key, propertyByteIndex] of Object.entries(data.indexMap)) {
+            const [byteIndex, bitOffSet, bitSize, length, type] = GetIndexData(index, propertyByteIndex);
+            if (type == StructPropertyTypes.Boolean) {
+                object[key] = Boolean(parent[key]);
+            }
+            if (type == StructPropertyTypes.TypedNumber) {
+                object[key] = Number(parent[key]);
+            }
+            if (type == StructPropertyTypes.TypedNumberArray) {
+                const array = new TypedArrayClassMap[bitSize](length);
+                for (let i = 0; i < length; i++) {
+                    array[i] = parent[key][i];
+                }
+                object[key] = array;
+            }
+            if (type == StructPropertyTypes.BitArray) {
+                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]);
+                }
+                object[key] = array;
+            }
+            if (type == StructPropertyTypes.Vector2) {
+                object[key] = {
+                    x: parent[key].x,
+                    y: parent[key].y,
+                };
+            }
+            if (type == StructPropertyTypes.Vector3) {
+                object[key] = {
+                    x: parent[key].x,
+                    y: parent[key].y,
+                    z: parent[key].z,
+                };
+            }
+            if (type == StructPropertyTypes.Vector4) {
+                object[key] = {
+                    x: parent[key].x,
+                    y: parent[key].y,
+                    z: parent[key].z,
+                    w: parent[key].w,
+                };
+            }
+        }
+        return object;
+    };
+    const deserialize = (parent, seralized) => {
+        for (const [key, propertyByteIndex] of Object.entries(data.indexMap)) {
+            const [byteIndex, bitOffSet, bitSize, length, type] = GetIndexData(index, propertyByteIndex);
+            if (seralized[key] === undefined)
+                continue;
+            if (type == StructPropertyTypes.Boolean) {
+                parent[key] = seralized[key] ? 1 : 0;
+            }
+            if (type == StructPropertyTypes.TypedNumber) {
+                parent[key] = Number(seralized[key]);
+            }
+            if (type == StructPropertyTypes.TypedNumberArray) {
+                for (let i = 0; i < seralized[key].length; i++) {
+                    parent[key][i] = seralized[key][i];
+                }
+            }
+            if (type == StructPropertyTypes.BitArray) {
+                const bitArray = new BitArray(seralized[key]);
+                const t1 = [];
+                const t2 = [];
+                for (let i = 0; i < length; i++) {
+                    parent[key][i] = bitArray[i];
+                    t1[i] = parent[key][i];
+                    t2[i] = bitArray[i];
+                }
+            }
+            if (type == StructPropertyTypes.Vector2) {
+                parent[key].x = seralized[key].x;
+                parent[key].y = seralized[key].y;
+            }
+            if (type == StructPropertyTypes.Vector3) {
+                parent[key].x = seralized[key].x;
+                parent[key].y = seralized[key].y;
+                parent[key].z = seralized[key].z;
+            }
+            if (type == StructPropertyTypes.Vector4) {
+                parent[key].x = seralized[key].x;
+                parent[key].y = seralized[key].y;
+                parent[key].z = seralized[key].z;
+                parent[key].w = seralized[key].w;
+            }
+        }
+    };
+    Object.defineProperty(GeneratedClass.prototype, "serialize", {
+        get() {
+            return () => seralize(this);
+        },
+    });
+    Object.defineProperty(GeneratedClass.prototype, "deserialize", {
+        get() {
+            return (data) => deserialize(this, data);
+        },
+    });
+    Object.defineProperty(GeneratedClass.prototype, "setDefaults", {
+        get() {
+            return () => {
+                for (const [id, value] of Object.entries(data.propertyDefaults)) {
+                    const v = this[id];
+                    if (Array.isArray(v) && Array.isArray(value)) {
+                        for (let i = 0; i < value.length; i++) {
+                            v[i] = value[i];
+                        }
+                        continue;
+                    }
+                    if (typeof v == "object" && typeof value == "object") {
+                        for (const key of Object.keys(value)) {
+                            v[key] = value[key];
+                        }
+                        continue;
+                    }
+                    if (typeof v == "number" && typeof value == "number") {
+                        this[id] = value;
+                    }
+                }
+            };
+        },
+    });
+    for (const [key, propertyByteIndex] of Object.entries(data.indexMap)) {
+        keys.push(key);
+        const [byteIndex, bitOffSet, bitSize, length, type] = GetIndexData(index, propertyByteIndex);
+        if (type == StructPropertyTypes.Boolean) {
+            Object.defineProperty(GeneratedClass.prototype, key, {
+                get() {
+                    return BinaryUtil.getBitValue(this.structData.getUint8(byteIndex + this.structByteOffSet), bitOffSet, bitSize);
+                },
+                set(value) {
+                    this.structData.setUint8(byteIndex + this.structByteOffSet, BinaryUtil.setBitValue(this.structData.getUint8(byteIndex + this.structByteOffSet), bitOffSet, value, bitSize));
+                },
+            });
+        }
+        if (type == StructPropertyTypes.TypedNumber) {
+            Object.defineProperty(GeneratedClass.prototype, key, {
+                get() {
+                    return BinaryUtil.getTypedNumber(this.structData, byteIndex + this.structByteOffSet, bitSize);
+                },
+                set(value) {
+                    BinaryUtil.setTypedNumber(this.structData, byteIndex + this.structByteOffSet, bitSize, value);
+                },
+            });
+        }
+        if (type == StructPropertyTypes.BitArray) {
+            Object.defineProperty(GeneratedClass.prototype, key, {
+                get() {
+                    const self = this;
+                    if (!self._props.has(key)) {
+                        const proxy = new Proxy(new Array(length), {
+                            get(target, index) {
+                                return BinaryArrays.getBitArrayIndex(self.structData, byteIndex + self.structByteOffSet, +index);
+                            },
+                            set(target, index, value) {
+                                BinaryArrays.setBitArrayIndex(self.structData, byteIndex + self.structByteOffSet, +index, value);
+                                return true;
+                            },
+                        });
+                        self._props.set(key, proxy);
+                    }
+                    return self._props.get(key);
+                },
+            });
+        }
+        if (type == StructPropertyTypes.TypedNumberArray) {
+            const typedNumberSize = BinaryUtil.getTypedSize(bitSize);
+            Object.defineProperty(GeneratedClass.prototype, key, {
+                get() {
+                    if (!this._props)
+                        this._props = new Map();
+                    const self = this;
+                    if (!self._props.has(key)) {
+                        const proxy = new Proxy(new Array(length), {
+                            get(target, index) {
+                                return BinaryUtil.getTypedNumber(self.structData, byteIndex +
+                                    self.structByteOffSet +
+                                    +index * typedNumberSize, bitSize);
+                            },
+                            set(target, index, value) {
+                                BinaryUtil.setTypedNumber(self.structData, byteIndex +
+                                    self.structByteOffSet +
+                                    +index * typedNumberSize, bitSize, value);
+                                return true;
+                            },
+                        });
+                        self._props.set(key, proxy);
+                    }
+                    return self._props.get(key);
+                },
+            });
+        }
+        if (type == StructPropertyTypes.Vector2) {
+            const typedNumberSize = BinaryUtil.getTypedSize(bitSize);
+            Object.defineProperty(GeneratedClass.prototype, key, {
+                get() {
+                    if (!this._props)
+                        this._props = new Map();
+                    const self = this;
+                    if (!self._props.has(key)) {
+                        const proxy = new Proxy({}, {
+                            get(target, property) {
+                                return BinaryUtil.getTypedNumber(self.structData, byteIndex +
+                                    self.structByteOffSet +
+                                    vector2Indexes[property] *
+                                        typedNumberSize, bitSize);
+                            },
+                            set(target, property, value) {
+                                BinaryUtil.setTypedNumber(self.structData, byteIndex +
+                                    self.structByteOffSet +
+                                    vector2Indexes[property] *
+                                        typedNumberSize, bitSize, value);
+                                return true;
+                            },
+                        });
+                        self._props.set(key, proxy);
+                    }
+                    return self._props.get(key);
+                },
+            });
+        }
+        if (type == StructPropertyTypes.Vector3) {
+            const typedNumberSize = BinaryUtil.getTypedSize(bitSize);
+            Object.defineProperty(GeneratedClass.prototype, key, {
+                get() {
+                    if (!this._props)
+                        this._props = new Map();
+                    const self = this;
+                    if (!self._props.has(key)) {
+                        const proxy = new Proxy({}, {
+                            get(target, property) {
+                                return BinaryUtil.getTypedNumber(self.structData, byteIndex +
+                                    self.structByteOffSet +
+                                    vector3Indexes[property] *
+                                        typedNumberSize, bitSize);
+                            },
+                            set(target, property, value) {
+                                BinaryUtil.setTypedNumber(self.structData, byteIndex +
+                                    self.structByteOffSet +
+                                    vector3Indexes[property] *
+                                        typedNumberSize, bitSize, value);
+                                return true;
+                            },
+                        });
+                        self._props.set(key, proxy);
+                    }
+                    return self._props.get(key);
+                },
+            });
+        }
+        if (type == StructPropertyTypes.Vector4) {
+            const typedNumberSize = BinaryUtil.getTypedSize(bitSize);
+            Object.defineProperty(GeneratedClass.prototype, key, {
+                get() {
+                    if (!this._props)
+                        this._props = new Map();
+                    const self = this;
+                    if (!self._props.has(key)) {
+                        const proxy = new Proxy({}, {
+                            get(target, property) {
+                                return BinaryUtil.getTypedNumber(self.structData, byteIndex +
+                                    self.structByteOffSet +
+                                    vector4Indexes[property] *
+                                        typedNumberSize, bitSize);
+                            },
+                            set(target, property, value) {
+                                BinaryUtil.setTypedNumber(self.structData, byteIndex +
+                                    self.structByteOffSet +
+                                    vector4Indexes[property] *
+                                        typedNumberSize, bitSize, value);
+                                return true;
+                            },
+                        });
+                        self._props.set(key, proxy);
+                    }
+                    return self._props.get(key);
+                },
+            });
+        }
+    }
+    return new GeneratedClass();
+}

package/Struct/Functions/GetIndexData.d.ts

@@ -0,0 +1,2 @@
+export declare const GetIndexData: (data: DataView, indexBufferIndex: number) => [byteIndex: number, bitOffSet: number, bitSize: number, length: number, type: number];
+export declare const SetIndexData: (data: DataView, indexBufferIndex: number, byteIndex: number, bitOffSet: number, bitSize: number, length: number, type: number) => number;

package/Struct/Functions/GetIndexData.js

@@ -0,0 +1,29 @@
+import { BinaryNumberTypes, ByteCounts } from "../../Constants/BinaryTypes";
+import { BinaryUtil } from "../../Util/BinaryUtil";
+const StuctIndexData = [0, 0, 0, 0, 0];
+export 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.getUint32(indexBufferIndex);
+    indexBufferIndex += BinaryUtil.getTypedSize(BinaryNumberTypes.Uint32);
+    StuctIndexData[4] = data.getUint8(indexBufferIndex);
+    indexBufferIndex += BinaryUtil.getTypedSize(BinaryNumberTypes.Uint8);
+    return StuctIndexData;
+};
+export const SetIndexData = (data, indexBufferIndex, byteIndex, bitOffSet, bitSize, length, type) => {
+    data.setUint32(indexBufferIndex, byteIndex);
+    indexBufferIndex += ByteCounts.Uint32;
+    data.setUint8(indexBufferIndex, bitOffSet);
+    indexBufferIndex += ByteCounts.Uint8;
+    data.setUint8(indexBufferIndex, bitSize);
+    indexBufferIndex += ByteCounts.Uint8;
+    data.setUint32(indexBufferIndex, length);
+    indexBufferIndex += ByteCounts.Uint32;
+    data.setUint8(indexBufferIndex, type);
+    indexBufferIndex += ByteCounts.Uint8;
+    return indexBufferIndex;
+};

package/Struct/Types/{RemoveBinaryStructData.types.d.ts → BinaryStructData.types.d.ts}

@@ -1,9 +1,10 @@
 import { BufferTypes } from "../../Util/BufferTypes";
-export type RemoteBinaryStructData = {
+export type BinaryStructData = {
     buffer: BufferTypes;
     bufferSize: number;
     indexBuffer: BufferTypes;
-    indexMap: Map<string, number>;
-    structArrayLength: number;
+    indexMap: Record<string, number>;
+    propertyDefaults: Record<string, any>;
+    structArrayIndexes: number;
     structSize: number;
 };

package/Struct/Types/BinaryStructSchema.types.d.ts

@@ -3,32 +3,68 @@ export type BinaryPropertyValueTypes = "number" | "boolean";
 export type BinaryBooleanProperty = {
     id: string;
     type: "boolean";
+    default?: boolean;
 };
 export type BinaryNumberProperty = {
     id: string;
     type: "number";
     range: [min: number, max: number];
+    default?: number;
 };
 export type BinaryTypedNumberProperty = {
     id: string;
     type: "typed-number";
     numberType: BinaryNumberTypes;
+    default?: number;
+};
+export type BinaryTypedVector2Property = {
+    id: string;
+    type: "vector-2";
+    numberType: BinaryNumberTypes;
+    default?: {
+        x: number;
+        y: number;
+    };
+};
+export type BinaryTypedVector3Property = {
+    id: string;
+    type: "vector-3";
+    numberType: BinaryNumberTypes;
+    default?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+export type BinaryTypedVector4Property = {
+    id: string;
+    type: "vector-4";
+    numberType: BinaryNumberTypes;
+    default?: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
 };
 export type BinaryTypedNumberArrayProperty = {
     id: string;
     type: "typed-number-array";
     numberType: BinaryNumberTypes;
     length: number;
+    default?: number[];
 };
 export type BinaryBitArrayProperty = {
     id: string;
     type: "bit-array";
     length: number;
+    default?: boolean[];
 };
 export type BinaryHeaderProperty = {
     id: string;
     type: "header";
     numberType: BinaryNumberTypes;
+    default?: number;
 };
-export type BinaryPropertyNodes = BinaryBooleanProperty | BinaryNumberProperty | BinaryBitArrayProperty | BinaryTypedNumberProperty | BinaryTypedNumberArrayProperty | BinaryHeaderProperty;
+export type BinaryPropertyNodes = BinaryBooleanProperty | BinaryNumberProperty | BinaryBitArrayProperty | BinaryTypedNumberProperty | BinaryTypedNumberArrayProperty | BinaryHeaderProperty | BinaryTypedVector2Property | BinaryTypedVector3Property | BinaryTypedVector4Property;
 export type BinaryPropertySchema = Map<string, BinaryPropertyNodes>;

package/Struct/Types/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./BinaryStructSchema.types";
-export * from "./RemoveBinaryStructData.types";
+export * from "./BinaryStructData.types";

package/Struct/Types/index.js

@@ -1,2 +1,2 @@
 export * from "./BinaryStructSchema.types";
-export * from "./RemoveBinaryStructData.types";
+export * from "./BinaryStructData.types";

package/Util/BinaryArrays.d.ts

@@ -0,0 +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 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;
+    static setHalfNibbleArrayIndex(data: DataView, byteOffset: number, arrayIndex: number, value: number): void;
+}

package/Util/BinaryArrays.js

@@ -0,0 +1,39 @@
+import { BinaryUtil } from "./BinaryUtil";
+export class BinaryArrays {
+    static getBitArrayIndex(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) {
+        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 getNibbleArrayIndex(data, byteOffset, arrayIndex) {
+        const arrayByteIndex = (arrayIndex / 2) >> 0;
+        const isHighNibble = arrayIndex % 2 === 0;
+        const arrayByte = data.getUint8(arrayByteIndex + byteOffset);
+        return BinaryUtil.getBitValue(arrayByte, isHighNibble ? 4 : 0, 4);
+    }
+    static setNibbleArrayIndex(data, byteOffset, arrayIndex, value) {
+        const arrayByteIndex = (arrayIndex / 2) >> 0;
+        const isHighNibble = arrayIndex % 2 === 0;
+        const arrayByte = data.getUint8(arrayByteIndex + byteOffset);
+        data.setUint8(arrayByteIndex + byteOffset, BinaryUtil.setBitValue(arrayByte, isHighNibble ? 4 : 0, value, 4));
+    }
+    static getHalfNibbleArrayIndex(data, byteOffset, arrayIndex) {
+        const arrayByteIndex = (arrayIndex / 4) >> 0;
+        const nibbleIndex = arrayIndex % 4;
+        const arrayByte = data.getUint8(arrayByteIndex + byteOffset);
+        return BinaryUtil.getBitValue(arrayByte, nibbleIndex * 2, 2);
+    }
+    static setHalfNibbleArrayIndex(data, byteOffset, arrayIndex, value) {
+        const arrayByteIndex = (arrayIndex / 4) >> 0;
+        const nibbleIndex = arrayIndex % 4;
+        const arrayByte = data.getUint8(arrayByteIndex + byteOffset);
+        data.setUint8(arrayByteIndex + byteOffset, BinaryUtil.setBitValue(arrayByte, nibbleIndex * 2, value, 2));
+    }
+}

package/Util/BinaryUtil.d.ts

@@ -4,8 +4,6 @@ export declare class BinaryUtil {
     static getTypedNumber(data: DataView, index: number, numberType: BinaryNumberTypes): number;
     static calculateBitsNeeded(min: number, max: number): number;
     static getTypedSize(type: BinaryNumberTypes): import("../Constants/BinaryTypes").ByteCounts;
-    static getBitValue(data: number, index: number, bitSize: number): number;
-    static setBitValue(data: number, index: number, value: number, bitSize: number): number;
-    static getBitArrayIndex(data: DataView, byteIndex: number, arrayIndex: number): number;
-    static setBitArrayIndex(data: DataView, byteIndex: number, arrayIndex: number, value: number): void;
+    static getBitValue(data: number, bitIndex: number, bitSize: number): number;
+    static setBitValue(data: number, bitIndex: number, value: number, bitSize: number): number;
 }

package/Util/BinaryUtil.js

@@ -15,26 +15,12 @@ export class BinaryUtil {
     static getTypedSize(type) {
         return MappedByteCounts[type];
     }
-    static getBitValue(data, index, bitSize) {
-        index *= bitSize;
+    static getBitValue(data, bitIndex, bitSize) {
         const mask = 2 ** bitSize - 1;
-        return ((mask << index) & data) >>> index;
+        return ((mask << bitIndex) & data) >>> bitIndex;
     }
-    static setBitValue(data, index, value, bitSize) {
-        index *= bitSize;
+    static setBitValue(data, bitIndex, value, bitSize) {
         const mask = 2 ** bitSize - 1;
-        return (data & ~(mask << index)) | ((value & mask) << index);
-    }
-    static getBitArrayIndex(data, byteIndex, arrayIndex) {
-        const arrayByteIndex = (arrayIndex / 8) >> 0;
-        const arrayBitIndex = arrayIndex - arrayByteIndex * 8;
-        const arrayByte = data.getUint8(arrayByteIndex + byteIndex);
-        return this.getBitValue(arrayByte, arrayBitIndex, 1);
-    }
-    static setBitArrayIndex(data, byteIndex, arrayIndex, value) {
-        const arrayByteIndex = (arrayIndex / 8) >> 0;
-        const arrayBitIndex = arrayIndex - arrayByteIndex * 8;
-        const arrayByte = data.getUint8(arrayByteIndex + byteIndex);
-        data.setUint8(arrayByteIndex + byteIndex, this.setBitValue(arrayByte, arrayBitIndex, value, 1));
+        return (data & ~(mask << bitIndex)) | ((value & mask) << bitIndex);
     }
 }

package/package.json

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