nytra 0.0.6 → 0.0.8

package/dist/Nytra.js

@@ -1,7 +1,7 @@
 import { Reader } from "./Reader.js";
 import { Registry } from "./Registry.js";
 import { Writer } from "./Writer.js";
-import { TYPE_ARRAY, TYPE_BIGINT, TYPE_BOOLEAN, TYPE_EXTENSION, TYPE_FLOAT32, TYPE_FLOAT64, TYPE_INT16, TYPE_INT32, TYPE_INT64, TYPE_INT8, TYPE_JSON, TYPE_NULL, TYPE_OBJECT, TYPE_STRING, TYPE_STRING_16_INTERNAL, TYPE_STRING_32_INTERNAL, TYPE_TYPED_ARRAY, TYPE_UINT16, TYPE_UINT32, TYPE_UINT64, TYPE_UINT8 } from "./Types.js";
+import { TYPE_ARRAY, TYPE_BIGINT, TYPE_BOOLEAN, TYPE_FLOAT32, TYPE_FLOAT64, TYPE_INT16, TYPE_INT32, TYPE_INT64, TYPE_INT8, TYPE_JSON, TYPE_NULL, TYPE_OBJECT, TYPE_STRING, TYPE_STRING_16_INTERNAL, TYPE_STRING_32_INTERNAL, TYPE_TYPED_ARRAY, TYPE_UINT16, TYPE_UINT32, TYPE_UINT64, TYPE_UINT8 } from "./Types.js";
 const MAX_UINT_32 = 2 ** 32;
 const MAX_UINT_16 = 2 ** 16;
 const MAX_UINT_8 = 2 ** 8;
@@ -78,7 +78,7 @@ function createTypedArrayEncoder(targetType) {
         }
         const endIndex = writer.offset;
         writer.setOffset(startIndex);
-        writer.writeUint32(endIndex - startIndex - 4);
+        writer.writeUINT32(endIndex - startIndex - 4);
         writer.setOffset(endIndex);
         return writer.toUint8Array();
     };
@@ -274,8 +274,7 @@ export class Nytra {
                 throw new Error('Unknown type:' + type);
             }
             if (withType) {
-                writer.writeUint8(TYPE_EXTENSION);
-                writer.writeUint16(type);
+                writer.writeType(type);
             }
             encodeFunction(data, writer);
             return writer.toUint8Array();
@@ -285,24 +284,24 @@ export class Nytra {
             const bytes = this.#TEXT_ENCODER.encode(str);
             const len = bytes.length;
             if (len <= 127) {
-                writer.writeUint8(128 + len);
+                writer.writeUINT8(128 + len);
                 writer.writeBytes(bytes);
                 return writer.toUint8Array();
             }
             if (len <= 65535) {
-                writer.writeUint8(TYPE_STRING_16_INTERNAL);
-                writer.writeUint16(len);
+                writer.writeUINT8(TYPE_STRING_16_INTERNAL);
+                writer.writeUINT16(len);
                 writer.writeBytes(bytes);
                 return writer.toUint8Array();
             }
-            writer.writeUint8(TYPE_STRING_32_INTERNAL);
-            writer.writeUint32(len);
+            writer.writeUINT8(TYPE_STRING_32_INTERNAL);
+            writer.writeUINT32(len);
             writer.writeBytes(bytes);
             return writer.toUint8Array();
         }
         switch (type) {
             case TYPE_NULL:
-                writer.writeUint8(TYPE_NULL);
+                writer.writeUINT8(TYPE_NULL);
                 return writer.toUint8Array();
             case TYPE_ARRAY: {
                 if (!Array.isArray(data)) {
@@ -310,7 +309,7 @@ export class Nytra {
                 }
                 const arr = data;
                 if (withType)
-                    writer.writeUint8(TYPE_ARRAY);
+                    writer.writeType(TYPE_ARRAY);
                 const startIndex = writer.offset;
                 writer.setOffset(startIndex + 4); // reserve space for length
                 for (let value of arr) {
@@ -318,7 +317,7 @@ export class Nytra {
                 }
                 const endIndex = writer.offset;
                 writer.setOffset(startIndex);
-                writer.writeUint32(endIndex - startIndex - 4);
+                writer.writeUINT32(endIndex - startIndex - 4);
                 writer.setOffset(endIndex);
                 return writer.toUint8Array();
             }
@@ -328,7 +327,7 @@ export class Nytra {
                 }
                 const obj = data;
                 if (withType)
-                    writer.writeUint8(TYPE_OBJECT);
+                    writer.writeType(TYPE_OBJECT);
                 const startIndex = writer.offset;
                 writer.setOffset(startIndex + 4);
                 let keys = Object.keys(obj);
@@ -338,62 +337,62 @@ export class Nytra {
                 }
                 const endIndex = writer.offset;
                 writer.setOffset(startIndex);
-                writer.writeUint32(endIndex - startIndex - 4);
+                writer.writeUINT32(endIndex - startIndex - 4);
                 writer.setOffset(endIndex);
                 return writer.toUint8Array();
             }
             case TYPE_UINT8: {
                 if (withType)
-                    writer.writeUint8(TYPE_UINT8);
-                writer.writeUint8(data);
+                    writer.writeType(TYPE_UINT8);
+                writer.writeUINT8(data);
                 return writer.toUint8Array();
             }
             case TYPE_UINT16: {
                 if (withType)
-                    writer.writeUint8(TYPE_UINT16);
-                writer.writeUint16(data);
+                    writer.writeType(TYPE_UINT16);
+                writer.writeUINT16(data);
                 return writer.toUint8Array();
             }
             case TYPE_UINT32: {
                 if (withType)
-                    writer.writeUint8(TYPE_UINT32);
-                writer.writeUint32(data);
+                    writer.writeType(TYPE_UINT32);
+                writer.writeUINT32(data);
                 return writer.toUint8Array();
             }
             case TYPE_UINT64: {
                 if (withType)
-                    writer.writeUint8(TYPE_UINT64);
-                writer.writeUint64(BigInt(data));
+                    writer.writeType(TYPE_UINT64);
+                writer.writeUINT64(BigInt(data));
                 return writer.toUint8Array();
             }
             case TYPE_INT8: {
                 if (withType)
-                    writer.writeUint8(TYPE_INT8);
-                writer.writeInt8(data);
+                    writer.writeType(TYPE_INT8);
+                writer.writeINT8(data);
                 return writer.toUint8Array();
             }
             case TYPE_INT16: {
                 if (withType)
-                    writer.writeUint8(TYPE_INT16);
-                writer.writeInt16(data);
+                    writer.writeType(TYPE_INT16);
+                writer.writeINT16(data);
                 return writer.toUint8Array();
             }
             case TYPE_INT32: {
                 if (withType)
-                    writer.writeUint8(TYPE_INT32);
-                writer.writeInt32(data);
+                    writer.writeType(TYPE_INT32);
+                writer.writeINT32(data);
                 return writer.toUint8Array();
             }
             case TYPE_INT64: {
                 if (withType)
-                    writer.writeUint8(TYPE_INT64);
-                writer.writeInt64(BigInt(data));
+                    writer.writeType(TYPE_INT64);
+                writer.writeINT64(BigInt(data));
                 return writer.toUint8Array();
             }
             case TYPE_BOOLEAN: {
                 if (withType)
-                    writer.writeUint8(TYPE_BOOLEAN);
-                writer.writeUint8(data ? 1 : 0);
+                    writer.writeType(TYPE_BOOLEAN);
+                writer.writeUINT8(data ? 1 : 0);
                 return writer.toUint8Array();
             }
             case TYPE_JSON: {
@@ -401,19 +400,19 @@ export class Nytra {
             }
             case TYPE_FLOAT32: {
                 if (withType)
-                    writer.writeUint8(TYPE_FLOAT32);
-                writer.writeFloat32(data);
+                    writer.writeType(TYPE_FLOAT32);
+                writer.writeFLOAT32(data);
                 return writer.toUint8Array();
             }
             case TYPE_FLOAT64: {
                 if (withType)
-                    writer.writeUint8(TYPE_FLOAT64);
-                writer.writeFloat64(data);
+                    writer.writeType(TYPE_FLOAT64);
+                writer.writeFLOAT64(data);
                 return writer.toUint8Array();
             }
             case TYPE_BIGINT: {
                 if (withType)
-                    writer.writeUint8(TYPE_BIGINT);
+                    writer.writeType(TYPE_BIGINT);
                 writer.writeBigInt(BigInt(data));
                 return writer.toUint8Array();
             }
@@ -476,20 +475,10 @@ export class Nytra {
                 return bigintToSafeNumber(reader.readINT64());
             }
             case TYPE_FLOAT64: {
-                return reader.readFloat64();
+                return reader.readFLOAT64();
             }
             case TYPE_FLOAT32: {
-                return reader.readFloat32();
-            }
-            case TYPE_TYPED_ARRAY: {
-                const type = reader.readType();
-                const len = reader.readUINT32();
-                const end = reader.offset + len;
-                const targetArray = [];
-                while (reader.offset < end) {
-                    targetArray.push(this.decode(reader, type));
-                }
-                return targetArray;
+                return reader.readFLOAT32();
             }
             case TYPE_ARRAY: {
                 const len = reader.readUINT32();

package/dist/NytraExperimental.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+import { Nytra } from "./Nytra.ts";
+export declare class NytraExperimental {
+    private static getMetaData;
+    static registerClass(index: number): <T extends Function>(target: T) => void;
+    static registerField(position: Parameters<typeof Nytra.registerField>[0], targetTypeId?: Parameters<typeof Nytra.registerField>[1], options?: Parameters<typeof Nytra.registerField>[2]): <T extends object>(target: T, propertyKey: keyof T) => void;
+}

package/dist/NytraExperimental.js

@@ -0,0 +1,54 @@
+import "reflect-metadata";
+import { Nytra } from "./Nytra.js";
+const metaData = new Map();
+export class NytraExperimental {
+    static getMetaData(target) {
+        let ctx = metaData.get(target);
+        if (!ctx) {
+            ctx = {};
+            metaData.set(target, ctx);
+            return ctx;
+        }
+        return ctx;
+    }
+    static registerClass(index) {
+        const realDecorator = Nytra.registerClass(index);
+        return function (target) {
+            const meta = NytraExperimental.getMetaData(target);
+            realDecorator(target, {
+                addInitializer(initializer) {
+                }, kind: "class", metadata: meta, name: undefined
+            });
+        };
+    }
+    static registerField(position, targetTypeId, options) {
+        const realDecorator = Nytra.registerField(position, targetTypeId, options);
+        return function (target, propertyKey) {
+            let targetClass = target.constructor;
+            if (typeof propertyKey !== 'string') {
+                throw new Error('propertyKey must be a string');
+            }
+            const meta = NytraExperimental.getMetaData(targetClass);
+            realDecorator(undefined, {
+                addInitializer(initializer) {
+                },
+                kind: "field",
+                static: typeof targetClass === 'function',
+                name: propertyKey,
+                private: propertyKey.startsWith("#"),
+                metadata: meta,
+                access: {
+                    has(object) {
+                        return propertyKey in object;
+                    },
+                    set(object, value) {
+                        object[propertyKey] = value;
+                    },
+                    get(object) {
+                        return object[propertyKey];
+                    }
+                }
+            });
+        };
+    }
+}

package/dist/Reader.d.ts

@@ -18,8 +18,8 @@ export declare class Reader {
     readINT16(): number;
     readINT32(): number;
     readINT64(): bigint;
-    readFloat32(): number;
-    readFloat64(): number;
+    readFLOAT32(): number;
+    readFLOAT64(): number;
     readString(length: number): string;
     readBigInt(): bigint;
     readType(): number;

package/dist/Reader.js

@@ -65,12 +65,12 @@ export class Reader {
         this.#ind += 8;
         return this.#dataView.getBigInt64(offset, LITTLE_ENDIAN);
     }
-    readFloat32() {
+    readFLOAT32() {
         const offset = this.#ind;
         this.#ind += 4;
         return this.#dataView.getFloat32(offset, LITTLE_ENDIAN);
     }
-    readFloat64() {
+    readFLOAT64() {
         const offset = this.#ind;
         this.#ind += 8;
         return this.#dataView.getFloat64(offset, LITTLE_ENDIAN);

package/dist/Writer.d.ts

@@ -6,16 +6,16 @@ export declare class Writer {
     constructor(initialSize?: number);
     private ensureCapacity;
     writeType(type: number): this;
-    writeInt8(value: number): this;
-    writeInt16(value: number): this;
-    writeInt32(value: number): this;
-    writeInt64(value: bigint): this;
-    writeUint8(value: number): this;
-    writeUint16(value: number): this;
-    writeUint32(value: number): this;
-    writeUint64(value: bigint): this;
-    writeFloat32(value: number): this;
-    writeFloat64(value: number): this;
+    writeINT8(value: number): this;
+    writeINT16(value: number): this;
+    writeINT32(value: number): this;
+    writeINT64(value: bigint): this;
+    writeUINT8(value: number): this;
+    writeUINT16(value: number): this;
+    writeUINT32(value: number): this;
+    writeUINT64(value: bigint): this;
+    writeFLOAT32(value: number): this;
+    writeFLOAT64(value: number): this;
     writeBytes(bytes: Uint8Array): this;
     writeBigInt(value: bigint): this;
     toUint8Array(): Uint8Array;

package/dist/Writer.js

@@ -2,7 +2,6 @@ import { TYPE_EXTENSION } from "./Types.js";
 const LITTLE_ENDIAN = true;
 export class Writer {
     static DEFAULT_SIZE = 1024;
-    static #encoder = new TextEncoder();
     #buffer;
     #view;
     #offset = 0;
@@ -41,66 +40,66 @@ export class Writer {
     }
     writeType(type) {
         if (type <= 255) {
-            return this.writeUint8(type);
+            return this.writeUINT8(type);
         }
-        this.writeUint8(TYPE_EXTENSION);
-        return this.writeUint16(type);
+        this.writeUINT8(TYPE_EXTENSION);
+        return this.writeUINT16(type);
     }
-    writeInt8(value) {
+    writeINT8(value) {
         this.ensureCapacity(1);
         this.#view.setInt8(this.#offset, value);
         this.#offset += 1;
         return this;
     }
-    writeInt16(value) {
+    writeINT16(value) {
         this.ensureCapacity(2);
         this.#view.setInt16(this.#offset, value, LITTLE_ENDIAN);
         this.#offset += 2;
         return this;
     }
-    writeInt32(value) {
+    writeINT32(value) {
         this.ensureCapacity(4);
         this.#view.setInt32(this.#offset, value, LITTLE_ENDIAN);
         this.#offset += 4;
         return this;
     }
-    writeInt64(value) {
+    writeINT64(value) {
         this.ensureCapacity(8);
         this.#view.setBigInt64(this.#offset, value, LITTLE_ENDIAN);
         this.#offset += 8;
         return this;
     }
-    writeUint8(value) {
+    writeUINT8(value) {
         this.ensureCapacity(1);
         this.#view.setUint8(this.#offset, value);
         this.#offset += 1;
         return this;
     }
-    writeUint16(value) {
+    writeUINT16(value) {
         this.ensureCapacity(2);
         this.#view.setUint16(this.#offset, value, LITTLE_ENDIAN);
         this.#offset += 2;
         return this;
     }
-    writeUint32(value) {
+    writeUINT32(value) {
         this.ensureCapacity(4);
         this.#view.setUint32(this.#offset, value, LITTLE_ENDIAN);
         this.#offset += 4;
         return this;
     }
-    writeUint64(value) {
+    writeUINT64(value) {
         this.ensureCapacity(8);
         this.#view.setBigUint64(this.#offset, value, LITTLE_ENDIAN);
         this.#offset += 8;
         return this;
     }
-    writeFloat32(value) {
+    writeFLOAT32(value) {
         this.ensureCapacity(4);
         this.#view.setFloat32(this.#offset, value, LITTLE_ENDIAN);
         this.#offset += 4;
         return this;
     }
-    writeFloat64(value) {
+    writeFLOAT64(value) {
         this.ensureCapacity(8);
         this.#view.setFloat64(this.#offset, value, LITTLE_ENDIAN);
         this.#offset += 8;
@@ -113,8 +112,8 @@ export class Writer {
         return this;
     }
     writeBigInt(value) {
-        let bytes = bigintToUint8ArrayLE(value);
-        this.writeUint16(bytes.length);
+        const bytes = bigintToUint8ArrayLE(value);
+        this.writeUINT16(bytes.length);
         this.writeBytes(bytes);
         return this;
     }

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { Nytra } from "./Nytra.ts";
+export { NytraExperimental } from "./NytraExperimental.ts";
 export * as Types from "./Types.ts";

package/dist/index.js

@@ -1,2 +1,3 @@
 export { Nytra } from "./Nytra.js";
+export { NytraExperimental } from "./NytraExperimental.js";
 export * as Types from "./Types.js";

package/package.json

@@ -1,41 +1,42 @@
-{
-  "private": false,
-  "name": "nytra",
-  "version": "0.0.6",
-  "description": "A javascript ES6 Decorator driven library to encode/decode javascript objects to/from binary optimized buffers to reduce payload on network",
-  "license": "MIT",
-  "author": {
-    "name": "Kapsonfire",
-    "email": "kapsonfire@googlemail.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/nytra-lib/nytra-js.git"
-  },
-  "homepage": "https://github.com/nytra-lib/nytra-js#readme",
-  "bugs": {
-    "url": "https://github.com/nytra-lib/nytra-js/issues"
-  },
-  "type": "module",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "devDependencies": {
-    "@msgpack/msgpack": "^3.1.3",
-    "@types/bun": "^1.3.13",
-    "typescript": "^6.0.3"
-  },
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  }
-}
+{
+  "private": false,
+  "name": "nytra",
+  "version": "0.0.8",
+  "description": "A javascript ES6 Decorator driven library to encode/decode javascript objects to/from binary optimized buffers to reduce payload on network",
+  "license": "MIT",
+  "author": {
+    "name": "Kapsonfire",
+    "email": "kapsonfire@googlemail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nytra-lib/nytra-js.git"
+  },
+  "homepage": "https://github.com/nytra-lib/nytra-js#readme",
+  "bugs": {
+    "url": "https://github.com/nytra-lib/nytra-js/issues"
+  },
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@msgpack/msgpack": "^3.1.3",
+    "@types/bun": "^1.3.13",
+    "reflect-metadata": "^0.2.2",
+    "typescript": "^6.0.3"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  }
+}