@nnilky/structo 1.0.9 → 1.1.0

package/README.md

@@ -20,14 +20,14 @@ const Entity = st.object({
 
 ```
 
+- Extremely Fast! [benchmarks](./benchmark) show equivelent performance to hand written serializers
+- Designed to be both Web & Node.js compatible
 - Lightweight, base size is <1KB and each datatype is a few hundred bytes
-- Fast![benchmarks](./benchmark) show only 1.5-5x slower than ideal implementaiton
-- Designed for both Web/Node.js compatible
-- Easily implement your own serializers
+- Easily extendable with your own datatypes
 
 Each serializer is completely seperate from the base library, meaning you only pay for what you use.
 
-## Implementing your own Serializer
+## Implementing your datatype
 
 Implementing your own serializer is incredibly simple, heres the `f64` serializer for example
 

package/dist/datatypes/containers/array.js

@@ -7,31 +7,28 @@
  *
  */
 export function array(size, type) {
-    const SHOW_ERRORS = size < 4096;
-    const { read: readType, write: writeType, size: typeSize } = type;
+    const SHOW_ERRORS = false;
     return {
         size: type.size ? size * type.size : undefined,
         write: (ctx, value) => {
             if (value.length !== size)
                 throw new Error("Invalid Size");
-            if (typeSize)
-                ctx.alloc(size * typeSize);
+            if (type.size)
+                ctx.reserve(size * type.size);
             for (let i = 0; i < size; i++) {
-                if (SHOW_ERRORS)
-                    ctx.stack.push(`[${i}]`);
-                writeType(ctx, value[i]);
-                if (SHOW_ERRORS)
-                    ctx.stack.pop();
+                // if (SHOW_ERRORS) ctx.path.push(`[${i}]`);
+                type.write(ctx, value[i]);
+                // if (SHOW_ERRORS) ctx.path.pop();
             }
         },
         read: (ctx) => {
             const arr = new Array(size);
             for (let i = 0; i < size; i++) {
                 if (SHOW_ERRORS)
-                    ctx.stack.push(`[${i}]`);
-                arr[i] = readType(ctx);
+                    ctx.path.push(`[${i}]`);
+                arr[i] = type.read(ctx);
                 if (SHOW_ERRORS)
-                    ctx.stack.pop();
+                    ctx.path.pop();
             }
             return arr;
         },

package/dist/datatypes/containers/exhuastiveArray.js

@@ -12,23 +12,23 @@ export function exhuastiveArray(type) {
             let arr = [];
             let i = 0;
             while (ctx.offset < ctx.view.byteLength) {
-                const TRACK_STACK = i++ < 4096;
+                const TRACK_STACK = i++ < 512;
                 if (TRACK_STACK)
-                    ctx.stack.push(`[${arr.length - 1}]`);
+                    ctx.path.push(`[${arr.length - 1}]`);
                 arr.push(type.read(ctx));
                 if (TRACK_STACK)
-                    ctx.stack.pop();
+                    ctx.path.pop();
             }
             return arr;
         },
         write(ctx, value) {
-            const TRACK_STACK = value.length < 4096;
+            const TRACK_STACK = value.length < 512;
             for (let i = 0; i < value.length; i++) {
                 if (TRACK_STACK)
-                    ctx.stack.push(`[${i}]`);
+                    ctx.path.push(`[${i}]`);
                 type.write(ctx, value[i]);
                 if (TRACK_STACK)
-                    ctx.stack.pop();
+                    ctx.path.pop();
             }
         },
     };

package/dist/datatypes/containers/list.js

@@ -12,29 +12,29 @@ export function list(length, type) {
     return {
         write: (ctx, value) => {
             length.write(ctx, value.length);
-            const TRACK_STACK = value.length < 4096;
+            const TRACK_STACK = value.length < 1000;
             if (type.size) {
-                ctx.alloc(value.length * type.size);
+                ctx.reserve(value.length * type.size);
             }
             for (let i = 0; i < value.length; i++) {
                 if (TRACK_STACK)
-                    ctx.stack.push(`[${i}]`);
+                    ctx.path.push(`[${i}]`);
                 const v = value[i];
                 type.write(ctx, v);
                 if (TRACK_STACK)
-                    ctx.stack.pop();
+                    ctx.path.pop();
             }
         },
         read: (ctx) => {
             const size = length.read(ctx);
-            const TRACK_STACK = size < 4096;
+            const TRACK_STACK = size < 1000;
             const arr = new Array(size);
             for (let i = 0; i < size; i++) {
                 if (TRACK_STACK)
-                    ctx.stack.push(`[${i}]`);
+                    ctx.path.push(`[${i}]`);
                 arr[i] = type.read(ctx);
                 if (TRACK_STACK)
-                    ctx.stack.pop();
+                    ctx.path.pop();
             }
             return arr;
         },

package/dist/datatypes/containers/object.js

@@ -19,23 +19,24 @@ export function object(definition) {
         size,
         write: (ctx, value) => {
             if (size)
-                ctx.alloc(size);
+                ctx.reserve(size);
             for (let i = 0; i < entires.length; i++) {
                 const [key, serializer] = entires[i];
-                ctx.stack.push(`.${key}`);
+                // ctx.path.push(`.${key}`);
                 serializer.write(ctx, value[key]);
-                ctx.stack.pop();
+                // ctx.path.pop();
             }
         },
         read: (ctx) => {
-            const output = new Array(entires.length);
+            const output = {};
             for (let i = 0; i < entires.length; i++) {
                 const [key, serializer] = entires[i];
-                ctx.stack.push(`.${key}`);
-                output[i] = [key, serializer.read(ctx)];
-                ctx.stack.pop();
+                // ctx.path.push(`.${key}`);
+                //@ts-expect-error
+                output[key] = serializer.read(ctx);
+                // ctx.path.pop();
             }
-            return Object.fromEntries(output);
+            return output;
         },
     };
 }

package/dist/datatypes/numbers/bigints.js

@@ -13,7 +13,7 @@ export function u64Bigint(endian = "little") {
         size: 8,
         write: (ctx, value) => {
             checkValue(value, 0n, 2n ** 64n);
-            ctx.alloc(8);
+            ctx.reserve(8);
             ctx.view.setBigUint64(ctx.offset, BigInt(value), endian === "little");
             ctx.offset += 8;
         },
@@ -34,7 +34,7 @@ export function s64Bigint(endian = "little") {
         size: 8,
         write: (ctx, value) => {
             checkValue(value, -(2n ** 63n), 2n ** 63n);
-            ctx.alloc(8);
+            ctx.reserve(8);
             ctx.view.setBigInt64(ctx.offset, BigInt(value), endian === "little");
             ctx.offset += 8;
         },

package/dist/datatypes/numbers/floats.js

@@ -1,14 +1,15 @@
 /** 16bit float */
 export function f16(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 2,
         write: (ctx, value) => {
-            ctx.alloc(2);
-            ctx.view.setFloat16(ctx.offset, value, endian === "little");
+            ctx.reserve(2);
+            ctx.view.setFloat16(ctx.offset, value, littleEndian);
             ctx.offset += 2;
         },
         read: (ctx) => {
-            const value = ctx.view.getFloat16(ctx.offset, endian === "little");
+            const value = ctx.view.getFloat16(ctx.offset, littleEndian);
             ctx.offset += 2;
             return value;
         },
@@ -16,15 +17,16 @@ export function f16(endian = "little") {
 }
 /** 32bit float */
 export function f32(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 4,
         write: (ctx, value) => {
-            ctx.alloc(4);
-            ctx.view.setFloat32(ctx.offset, value, endian === "little");
+            ctx.reserve(4);
+            ctx.view.setFloat32(ctx.offset, value, littleEndian);
             ctx.offset += 4;
         },
         read: (ctx) => {
-            const value = ctx.view.getFloat32(ctx.offset, endian === "little");
+            const value = ctx.view.getFloat32(ctx.offset, littleEndian);
             ctx.offset += 4;
             return value;
         },
@@ -32,15 +34,16 @@ export function f32(endian = "little") {
 }
 /** 64bit float */
 export function f64(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 8,
         write: (ctx, value) => {
-            ctx.alloc(8);
-            ctx.view.setFloat64(ctx.offset, value, endian === "little");
+            ctx.reserve(8);
+            ctx.view.setFloat64(ctx.offset, value, littleEndian);
             ctx.offset += 8;
         },
         read: (ctx) => {
-            const value = ctx.view.getFloat64(ctx.offset, endian === "little");
+            const value = ctx.view.getFloat64(ctx.offset, littleEndian);
             ctx.offset += 8;
             return value;
         },

package/dist/datatypes/numbers/sints.js

@@ -12,7 +12,7 @@ export function s8() {
         size: 1,
         write: (ctx, value) => {
             checkValue(value, -(2 ** 7), 2 ** 7);
-            ctx.alloc(1);
+            ctx.reserve(1);
             ctx.view.setInt8(ctx.offset, value);
             ctx.offset += 1;
         },
@@ -25,16 +25,17 @@ export function s8() {
 }
 /** 16bit signed integer */
 export function s16(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 2,
         write: (ctx, value) => {
             checkValue(value, -(2 ** 15), 2 ** 15);
-            ctx.alloc(2);
-            ctx.view.setInt16(ctx.offset, value, endian === "little");
+            ctx.reserve(2);
+            ctx.view.setInt16(ctx.offset, value, littleEndian);
             ctx.offset += 2;
         },
         read: (ctx) => {
-            const value = ctx.view.getInt16(ctx.offset, endian === "little");
+            const value = ctx.view.getInt16(ctx.offset, littleEndian);
             ctx.offset += 2;
             return value;
         },
@@ -42,16 +43,17 @@ export function s16(endian = "little") {
 }
 /** 32bit signed integer */
 export function s32(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 4,
         write: (ctx, value) => {
             checkValue(value, -(2 ** 31), 2 ** 31);
-            ctx.alloc(4);
-            ctx.view.setInt32(ctx.offset, value, endian === "little");
+            ctx.reserve(4);
+            ctx.view.setInt32(ctx.offset, value, littleEndian);
             ctx.offset += 4;
         },
         read: (ctx) => {
-            const value = ctx.view.getInt32(ctx.offset, endian === "little");
+            const value = ctx.view.getInt32(ctx.offset, littleEndian);
             ctx.offset += 4;
             return value;
         },
@@ -59,16 +61,17 @@ export function s32(endian = "little") {
 }
 /** 64bit signed integer */
 export function s64(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 8,
         write: (ctx, value) => {
             checkValue(value, -(2 ** 63), 2 ** 63);
-            ctx.alloc(8);
-            ctx.view.setBigInt64(ctx.offset, BigInt(value), endian === "little");
+            ctx.reserve(8);
+            ctx.view.setBigInt64(ctx.offset, BigInt(value), littleEndian);
             ctx.offset += 8;
         },
         read: (ctx) => {
-            const value = Number(ctx.view.getBigInt64(ctx.offset, endian === "little"));
+            const value = Number(ctx.view.getBigInt64(ctx.offset, littleEndian));
             ctx.offset += 8;
             return value;
         },

package/dist/datatypes/numbers/uints.js

@@ -7,7 +7,7 @@ export function u8() {
                 throw new Error("Not Integer");
             if (value < 0 || value >= 2 ** 8)
                 throw new Error("Out of Range");
-            ctx.alloc(1);
+            ctx.reserve(1);
             ctx.view.setUint8(ctx.offset, value);
             ctx.offset += 1;
         },
@@ -20,6 +20,7 @@ export function u8() {
 }
 /** 16bit unsigned integer */
 export function u16(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 2,
         write: (ctx, value) => {
@@ -27,12 +28,12 @@ export function u16(endian = "little") {
                 throw new Error("Not Integer");
             if (value < 0 || value >= 2 ** 16)
                 throw new Error("Out of Range");
-            ctx.alloc(2);
-            ctx.view.setUint16(ctx.offset, value, endian === "little");
+            ctx.reserve(2);
+            ctx.view.setUint16(ctx.offset, value, littleEndian);
             ctx.offset += 2;
         },
         read: (ctx) => {
-            const value = ctx.view.getUint16(ctx.offset, endian === "little");
+            const value = ctx.view.getUint16(ctx.offset, littleEndian);
             ctx.offset += 2;
             return value;
         },
@@ -40,6 +41,7 @@ export function u16(endian = "little") {
 }
 /** 32bit unsigned integer */
 export function u32(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 4,
         write: (ctx, value) => {
@@ -47,12 +49,12 @@ export function u32(endian = "little") {
                 throw new Error("Not Integer");
             if (value < 0 || value >= 2 ** 32)
                 throw new Error("Out of Range");
-            ctx.alloc(4);
-            ctx.view.setUint32(ctx.offset, value, endian === "little");
+            ctx.reserve(4);
+            ctx.view.setUint32(ctx.offset, value, littleEndian);
             ctx.offset += 4;
         },
         read: (ctx) => {
-            const value = ctx.view.getUint32(ctx.offset, endian === "little");
+            const value = ctx.view.getUint32(ctx.offset, littleEndian);
             ctx.offset += 4;
             return value;
         },
@@ -60,6 +62,7 @@ export function u32(endian = "little") {
 }
 /** 64bit unsigned integer */
 export function u64(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 8,
         write: (ctx, value) => {
@@ -67,12 +70,12 @@ export function u64(endian = "little") {
                 throw new Error("Not Integer");
             if (value < 0 || value >= 2 ** 64)
                 throw new Error("Out of Range");
-            ctx.alloc(8);
-            ctx.view.setBigUint64(ctx.offset, BigInt(value), endian === "little");
+            ctx.reserve(8);
+            ctx.view.setBigUint64(ctx.offset, BigInt(value), littleEndian);
             ctx.offset += 8;
         },
         read: (ctx) => {
-            const value = Number(ctx.view.getBigUint64(ctx.offset, endian === "little"));
+            const value = Number(ctx.view.getBigUint64(ctx.offset, littleEndian));
             ctx.offset += 8;
             return value;
         },

package/dist/datatypes/values/bytes.d.ts

@@ -1,4 +1,4 @@
-import type { Serializer } from "../../types.js";
+import * as st from "../../index.js";
 /**
  * Fixed length bytes
  *
@@ -6,4 +6,4 @@ import type { Serializer } from "../../types.js";
  * st.bytes(4)
  * ```
  */
-export declare function bytes(size: number): Serializer<ArrayBuffer>;
+export declare function bytes(size: number): st.Serializer<Uint8Array>;

package/dist/datatypes/values/bytes.js

@@ -1,3 +1,4 @@
+import * as st from "../../index.js";
 /**
  * Fixed length bytes
  *
@@ -9,17 +10,16 @@ export function bytes(size) {
     return {
         size,
         write: (ctx, value) => {
-            const bytes = new Uint8Array(value);
-            if (bytes.length !== size)
+            if (value.length !== size)
                 throw new Error("Invalid Length");
-            ctx.alloc(size);
-            new Uint8Array(ctx.buffer).set(bytes, ctx.offset);
+            ctx.reserve(size);
+            ctx.bytes.set(value, ctx.offset);
             ctx.offset += size;
         },
         read: (ctx) => {
-            const slice = ctx.buffer.slice(ctx.offset, ctx.offset + size);
+            const arr = ctx.bytes.subarray(ctx.offset, ctx.offset + size);
             ctx.offset += size;
-            return slice;
+            return arr.slice();
         },
     };
 }

package/dist/datatypes/values/bytes.test.js

@@ -16,7 +16,7 @@ describe("st.bytes", () => {
         const data = new Uint8Array(size);
         data.set([3, 4], 1000);
         data.set([3, 4], 2000);
-        encodeTest(spec, data.buffer);
+        encodeTest(spec, data);
     });
     it("large data writes work", () => {
         const size = 1024 * 1024 * 8; // 8MB
@@ -30,7 +30,7 @@ describe("st.bytes", () => {
         data.set([3, 4], 2000);
         encodeTest(spec, {
             before: 1,
-            data: data.buffer,
+            data,
             after: 2,
         });
     });

package/dist/datatypes/values/sizedbytes.d.ts

@@ -1,2 +1,2 @@
 import type { Serializer } from "../../types.js";
-export declare function sizedBytes(length: Serializer<number>): Serializer<ArrayBuffer>;
+export declare function sizedBytes(length: Serializer<number>): Serializer<Uint8Array>;

package/dist/datatypes/values/sizedbytes.js

@@ -2,14 +2,13 @@ export function sizedBytes(length) {
     return {
         write: (ctx, value) => {
             length.write(ctx, value.byteLength);
-            const bytes = new Uint8Array(value);
-            ctx.alloc(value.byteLength);
-            new Uint8Array(ctx.view.buffer).set(bytes, ctx.offset);
+            ctx.reserve(value.byteLength);
+            ctx.bytes.set(value, ctx.offset);
             ctx.offset += value.byteLength;
         },
         read: (ctx) => {
             const size = length.read(ctx);
-            const slice = ctx.buffer.slice(ctx.offset, ctx.offset + size);
+            const slice = ctx.bytes.subarray(ctx.offset, ctx.offset + size);
             ctx.offset += size;
             return slice;
         },

package/dist/datatypes/values/sizedbytes.test.js

@@ -16,7 +16,7 @@ describe("st.sizedBytes", () => {
         const data = new Uint8Array(size);
         data.set([3, 4], 1000);
         data.set([3, 4], 2000);
-        encodeTest(spec, data.buffer);
+        encodeTest(spec, data);
     });
     it("errors on invalid length", () => {
         encodeFailTest(st.sizedBytes(st.u8()), //

package/dist/datatypes/values/string.js

@@ -20,10 +20,9 @@ export function string(length) {
                 throw new Error("Expected String");
             const bytes = encoder.encode(value);
             const size = bytes.byteLength;
-            ctx.alloc(size + lengthSize);
+            ctx.reserve(size + lengthSize);
             length.write(ctx, size);
-            const arr = new Uint8Array(ctx.buffer, ctx.offset);
-            arr.set(bytes);
+            ctx.bytes.set(bytes, ctx.offset);
             ctx.offset += size;
         },
         read: (ctx) => {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export type { InferOutput as Infer, InferInput, InferOutput, ReaderContext, WriterContext, Serializer, } from "./types.js";
-export { read, createReaderContext } from "./read.js";
-export { write, createdWriterContext } from "./write.js";
+export { read } from "./read.js";
+export { write, writeInto } from "./write.js";
 export * from "./datatypes/index.js";
 export * from "./transforms/index.js";
 export * from "./utilities/index.js";

package/dist/index.js

@@ -1,5 +1,5 @@
-export { read, createReaderContext } from "./read.js";
-export { write, createdWriterContext } from "./write.js";
+export { read } from "./read.js";
+export { write, writeInto } from "./write.js";
 export * from "./datatypes/index.js";
 export * from "./transforms/index.js";
 export * from "./utilities/index.js";

package/dist/read.d.ts

@@ -1,3 +1,2 @@
-import type { Serializer, ReaderContext } from "./types.js";
-export declare function read<TIn, TOut>(serializer: Serializer<TIn, TOut>, buffer: ArrayBuffer): TOut;
-export declare function createReaderContext(buffer: ArrayBuffer): ReaderContext;
+import type { Serializer } from "./types.js";
+export declare function read<TIn, TOut>(serializer: Serializer<TIn, TOut>, buffer: ArrayBuffer | SharedArrayBuffer, offset?: number): TOut;

package/dist/read.js

@@ -1,18 +1,16 @@
-export function read(serializer, buffer) {
-    const ctx = createReaderContext(buffer);
+export function read(serializer, buffer, offset) {
+    const ctx = {
+        buffer: buffer,
+        view: new DataView(buffer),
+        bytes: new Uint8Array(buffer),
+        path: [],
+        offset: offset ?? 0,
+    };
     try {
         return serializer.read(ctx);
     }
     catch (e) {
-        const path = ctx.stack.join("") ?? "root";
-        throw new Error(`Deserialization error at serializer${path}`, { cause: e });
+        const path = ctx.path.join("") ?? "root";
+        throw new Error(`Deserialization error at serializer${path}\n${e}`, { cause: e });
     }
 }
-export function createReaderContext(buffer) {
-    return {
-        stack: [],
-        offset: 0,
-        buffer,
-        view: new DataView(buffer),
-    };
-}

package/dist/transforms/enum.d.ts

@@ -1,2 +1,2 @@
-export declare function enum_<const T>(values: T[]): import("./pipe.js").Transform<T, any>;
+export declare function enum_<const T>(values: T[]): import("./pipe.ts").Transform<T, any>;
 export { enum_ as enum };

package/dist/transforms/literal.d.ts

@@ -1 +1 @@
-export declare function literal<const T>(value: T): import("./pipe.js").Transform<T, any>;
+export declare function literal<const T>(value: T): import("./pipe.ts").Transform<T, any>;

package/dist/transforms/toAscii.d.ts

@@ -1 +1 @@
-export declare function toAscii(): import("./pipe.js").Transform<string, ArrayBuffer>;
+export declare function toAscii(): import("./pipe.ts").Transform<string, Uint8Array<ArrayBufferLike>>;

package/dist/transforms/toAscii.js

@@ -1,8 +1,8 @@
 import { encode } from "./encode.js";
 export function toAscii() {
     return encode({
-        encode: (v) => new Uint8Array(Array.from(v).map((char) => validateAscii(char.charCodeAt(0)))).buffer,
-        decode: (v) => Array.from(new Uint8Array(v))
+        encode: (v) => new Uint8Array(Array.from(v).map((char) => validateAscii(char.charCodeAt(0)))),
+        decode: (v) => Array.from(v)
             .map((v) => String.fromCharCode(v))
             .join(""),
     });

package/dist/transforms/toBase64.d.ts

@@ -1 +1 @@
-export declare function toBase64(): import("./pipe.js").Transform<string, ArrayBuffer>;
+export declare function toBase64(): import("./pipe.ts").Transform<string, Uint8Array<ArrayBufferLike>>;

package/dist/transforms/toBase64.js

@@ -1,7 +1,7 @@
 import { encode } from "./encode.js";
 export function toBase64() {
     return encode({
-        encode: (v) => Uint8Array.fromBase64(v).buffer,
-        decode: (v) => new Uint8Array(v).toBase64(),
+        encode: (v) => Uint8Array.fromBase64(v),
+        decode: (v) => v.toBase64(),
     });
 }

package/dist/transforms/toBytes.d.ts

@@ -10,4 +10,4 @@
  *
  * `ArrayBuffer([0, 255, c])` => `[0, 255, ArrayBuffer([0, 255, 0])]`
  */
-export declare function toBytes(): import("./pipe.js").Transform<number[], ArrayBuffer>;
+export declare function toBytes(): import("./pipe.ts").Transform<number[], Uint8Array<ArrayBufferLike>>;

package/dist/transforms/toBytes.js

@@ -13,8 +13,8 @@ import { encode } from "./encode.js";
  */
 export function toBytes() {
     return encode({
-        encode: (v) => new Uint8Array(v.map(validateByte)).buffer,
-        decode: (v) => Array.from(new Uint8Array(v)),
+        encode: (v) => new Uint8Array(v.map(validateByte)),
+        decode: (v) => Array.from(v),
     });
 }
 const validateByte = (v) => {

package/dist/transforms/toHex.d.ts

@@ -1,5 +1,5 @@
 /**
- * Converts an ArrayBuffer to uppercase hex
+ * Converts an Uint8Array to uppercase hex
  *
  * ```ts
  * st.pipe(
@@ -8,6 +8,6 @@
  * )
  * ```
  *
- * `ArrayBuffer([0, 255, 0])` => `00FF00`
+ * `Uint8Array([0, 255, 0])` => `00FF00`
  */
-export declare function toHex(): import("./pipe.js").Transform<string, ArrayBuffer>;
+export declare function toHex(): import("./pipe.ts").Transform<string, Uint8Array<ArrayBufferLike>>;