@nnilky/structo 1.0.2 → 1.0.4

package/README.md

@@ -1 +1,131 @@
 # Structo
+
+Define binary objects in zod style schemas
+
+```ts
+import * as st from "@nnilky/structo";
+
+type Vec3 = st.InferOutput<typeof Vec3>
+const Vec3 = st.object({
+    x: st.f64(),
+    y: st.f64(),
+    z: st.f64(),
+});
+
+type Entity = st.InferOutput<typeof Entity>
+const Entity = st.object({
+    id: st.u64(),
+    position: Vec3,
+});
+
+```
+
+- Lightweight, base size is <1KB and each datatype is a few hundred bytes
+- Fast, from [benchmarks](./benchmark) only 2-
+- Supports Web/Node.js compatible
+- Easily implemented
+
+Each serializer is completely seperate from the base library, meaning you only pay for what you use.
+
+## Implementing your own Serializer
+
+Implementing your own serializer is incredibly simple, heres the `f64` serializer for example
+
+```ts
+export function f64(endian: "little" | "big" = "little"): st.Serializer<number> {
+    return {
+        size: 8,
+        write: (ctx, value) => {
+            ctx.alloc(8);
+            ctx.view.setFloat64(ctx.offset, value, endian === "little");
+            ctx.offset += 8;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getFloat64(ctx.offset, endian === "little");
+            ctx.offset += 8;
+            return value;
+        },
+    };
+}
+```
+
+The `alloc()` in the write function is a utility provided to you to ensure you have enough space ahead of you in the buffer to write to.
+
+When reading and writing, you must increment the `ctx.offset` so the next value can be read from. However,
+
+The `size` attribute is optional, but if included can be used to do allocations in advance.
+
+> Important: You must modify the ctx object, do not spread over it since this will break the reference
+
+### Container Example
+
+Here is the list serializer
+
+```ts
+export function list<T>(options: {
+    type: st.Serializer<T>;
+    length: st.Serializer<number>;
+}): st.Serializer<T[]> {
+    const lengthType = options.length;
+    const valueType = options.type;
+
+    return {
+        write: (ctx, value) => {
+            lengthType.write(ctx, value.length);
+            for (const v of value) {
+                lengthType.write(ctx, v);
+            }
+        },
+        read: (ctx) => {
+            const size = lengthType.read(ctx);
+
+            const arr = []
+            for (let i = 0; i < size; i++) {
+                arr.push(valueType.read(ctx))
+            }
+            return arr;
+        },
+    };
+}
+```
+
+## Transforms
+
+```ts
+const Bits = st.pipe(
+    st.u32()
+    st.transform(v => v * 8)
+)
+```
+
+Transforms are utility that let you modify a read/written value. They allow you to processing declaratively.
+
+### Writing your Own
+
+Here is the `transform` transformation function, a `transform` just a function that takes a type and returns a serializer.
+
+```ts
+export function transform<T>(callback: (value: T) => T) {
+    return (type: st.Serializer<T>): st.Serializer<T> => ({
+        size: type.size,
+        read: (ctx) => {
+            const value = type.read(ctx);
+            return callback(value);
+        },
+        write: (ctx, value) => {
+            let outValue = callback(value);
+            type.write(ctx, outValue);
+        },
+    });
+}
+```
+
+## FaQ
+
+- Why do I have to do `import * as st from "@nnilky/structo"`?
+  - By using an `* as` import, bundles can erase the names as runtime without having to worry about runtime effects
+  - additionally, by putting it under a namespace it reduces con
+- Will data streaming be implemented?
+  - Sadly this library isn't built for data streaming, the exposed API for serializers need the full array to be accessible
+  - If you want data streaming, your going to have to fork this and re-implement the standard types
+- What's the difference`

package/dist/datatypes/containers/array.test.js

@@ -0,0 +1,22 @@
+import { describe, it } from "bun:test";
+import { expectEncode, expectError } from "../utils.test";
+import * as st from "../../index";
+describe("st.array", () => {
+    it("encode correctly", () => {
+        const spec = st.array(4, st.u16());
+        expectEncode(spec, [1, 2, 3, 4]);
+    });
+    it("works on empty lists", () => {
+        const spec = st.array(0, st.u16());
+        expectEncode(spec, []);
+    });
+    it("throws error on invalid size", () => {
+        const spec = st.array(2, st.u16());
+        expectError(() => st.write(spec, [1]));
+    });
+    it("throws error on invalid value", () => {
+        const spec = st.array(2, st.u16());
+        expectError(() => st.write(spec, [1, -1]));
+        expectError(() => st.write(spec, [2 ** 16 + 1, 0]));
+    });
+});

package/dist/datatypes/containers/fastObject.d.ts

@@ -0,0 +1,19 @@
+import type { InferInput, Serializer } from "../../types";
+type InferObject<T> = T extends Record<string, Serializer<any>> ? {
+    [Key in keyof T]: InferInput<T[Key]>;
+} : never;
+/**
+ * `fastObject` is equivelent to object but it uses eval to improve performance
+ *
+ * This means that is should be avoided in scenarios where CSP is required (so can't be the default), but should be fine for all other cases
+ *
+ * ```ts
+ * st.fastObject({
+ *     name: st.string(st.u32()),
+ *     age: st.u8(),
+ *     createdAt: st.f64(),
+ * })
+ * ```
+ */
+export declare function fastObject<T extends Record<string, Serializer<any>>>(definition: T): Serializer<InferObject<T>>;
+export {};

package/dist/{structo/datatypes → datatypes}/containers/fastObject.js

@@ -1,4 +1,17 @@
 const definitionSymbol = Symbol();
+/**
+ * `fastObject` is equivelent to object but it uses eval to improve performance
+ *
+ * This means that is should be avoided in scenarios where CSP is required (so can't be the default), but should be fine for all other cases
+ *
+ * ```ts
+ * st.fastObject({
+ *     name: st.string(st.u32()),
+ *     age: st.u8(),
+ *     createdAt: st.f64(),
+ * })
+ * ```
+ */
 export function fastObject(definition) {
     let serializers = [];
     let writeBody = "";

package/dist/datatypes/containers/list.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datatypes/containers/list.test.js

@@ -0,0 +1,31 @@
+import { describe, it } from "bun:test";
+import { expectEncode, expectEncodeSnapshot, expectError } from "../utils.test";
+import * as st from "../../index";
+describe("st.list", () => {
+    it("encode correctly", () => {
+        const spec = st.list({ type: st.u16(), length: st.u8() });
+        expectEncode(spec, [1, 2, 3, 4]);
+    });
+    it("works on empty lists", () => {
+        const spec = st.list({ type: st.u16(), length: st.u8() });
+        expectEncode(spec, []);
+    });
+    it("throws error on too large array", () => {
+        const spec = st.list({ type: st.u16(), length: st.u8() });
+        expectError(() => {
+            st.write(spec, Array.from({ length: 10000 }, () => 0));
+        });
+    });
+    it("throws error on invalid value", () => {
+        const spec = st.list({ type: st.u16(), length: st.u8() });
+        expectError(() => {
+            st.write(spec, [-1]);
+        });
+    });
+    it(`matches snapshots`, () => {
+        expectEncodeSnapshot(st.list({
+            type: st.string(st.u16()),
+            length: st.s32(),
+        }), ["foo", "bar", "baz"]);
+    });
+});

package/dist/{structo/datatypes → datatypes}/containers/object.d.ts

@@ -5,5 +5,16 @@ type InferObjectInfer<T> = T extends Record<string, Serializer<any>> ? {
 type InferObjectOutput<T> = T extends Record<string, Serializer<any>> ? {
     [Key in keyof T]: InferOutput<T[Key]>;
 } : never;
+/**
+ * `object` is equivelent to a C struct, values are stored in the order defined
+ *
+ * ```ts
+ * st.object({
+ *     name: st.string(st.u32()),
+ *     age: st.u8(),
+ *     createdAt: st.f64(),
+ * })
+ * ```
+ */
 export declare function object<T extends Record<string, Serializer<any>>>(definition: T): Serializer<InferObjectInfer<T>, InferObjectOutput<T>>;
 export {};

package/dist/{structo/datatypes → datatypes}/containers/object.js

@@ -1,3 +1,14 @@
+/**
+ * `object` is equivelent to a C struct, values are stored in the order defined
+ *
+ * ```ts
+ * st.object({
+ *     name: st.string(st.u32()),
+ *     age: st.u8(),
+ *     createdAt: st.f64(),
+ * })
+ * ```
+ */
 export function object(definition) {
     const entires = Object.entries(definition);
     // Use the fact: number + undefined = NaN

package/dist/datatypes/containers/object.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datatypes/containers/object.test.js

@@ -0,0 +1,33 @@
+//@ts-ignore TODO
+import { describe, it, expect } from "bun:test";
+import { bytes, expectEncode, expectEncodeSnapshot } from "../utils.test";
+import * as st from "../../index";
+describe("st.object", () => {
+    const test = st.object({
+        a: st.u8(),
+        b: st.u8(),
+    });
+    it("encodes correctly", () => {
+        st.write(test, { b: 2, a: 1 });
+    });
+    it("encode in correct order", () => {
+        const data = st.write(test, { b: 2, a: 1 });
+        const arr = new Uint8Array(data);
+        expect(arr[0]).toBe(1);
+        expect(arr[1]).toBe(2);
+    });
+    it("encodes empty", () => {
+        expectEncode(st.object({}), {});
+    });
+    it(`matches snapshots`, () => {
+        expectEncodeSnapshot(st.object({
+            number: st.u32(),
+            puppy: st.string(st.s32()),
+            buffer: st.buffer(4),
+        }), {
+            number: 1,
+            puppy: "woof woof bark bark",
+            buffer: bytes([19, 87, 19, 83]),
+        });
+    });
+});

package/dist/datatypes/containers/sizedbuffer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datatypes/containers/sizedbuffer.test.js

@@ -0,0 +1,27 @@
+import { describe, it } from "bun:test";
+import { bytes, expectEncode, expectError } from "../utils.test";
+import * as st from "../../index";
+describe("st.buffer", () => {
+    it("encode correctly", () => {
+        const buffer = st.sizedBuffer(st.u8());
+        expectEncode(buffer, bytes([1, 2]));
+    });
+    it("encodes empty correctly", () => {
+        const spec = st.sizedBuffer(st.u8());
+        expectEncode(spec, bytes([]));
+    });
+    it("holds large data", () => {
+        const size = 1024 * 1024 * 8; // 8MB
+        const spec = st.sizedBuffer(st.u32());
+        const data = new Uint8Array(size);
+        data.set([3, 4], 1000);
+        data.set([3, 4], 2000);
+        expectEncode(spec, data.buffer);
+    });
+    it("errors on invalid length", () => {
+        const spec = st.sizedBuffer(st.u8());
+        expectError(() => {
+            st.write(spec, bytes(Array.from({ length: 256 }, () => 0)));
+        });
+    });
+});

package/dist/{structo/datatypes → datatypes}/index.d.ts

@@ -10,6 +10,7 @@ export { sizedBuffer } from "./containers/sizedbuffer";
 export { string } from "./values/string";
 export { buffer } from "./values/buffer";
 export { byteLiteral } from "./values/byteliteral";
+export { createRememberedValue } from "./utilities/remember";
 export { type Transform as Pipeline, pipe } from "./transforms/pipe";
 export { positionOffset } from "./transforms/readOffset";
 export { transform } from "./transforms/transform";

package/dist/{structo/datatypes → datatypes}/index.js

@@ -10,6 +10,7 @@ export { sizedBuffer } from "./containers/sizedbuffer";
 export { string } from "./values/string";
 export { buffer } from "./values/buffer";
 export { byteLiteral } from "./values/byteliteral";
+export { createRememberedValue } from "./utilities/remember";
 export { pipe } from "./transforms/pipe";
 export { positionOffset } from "./transforms/readOffset";
 export { transform } from "./transforms/transform";

package/dist/datatypes/lazy.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datatypes/lazy.js

@@ -0,0 +1 @@
+export {};

package/dist/datatypes/numbers/bigints.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datatypes/numbers/bigints.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "bun:test";
+import { expectEncode, expectEncodeSnapshot, expectError, randbigint } from "../utils.test";
+import * as st from "../../index";
+function test_bigint(options) {
+    const { name, range: [start, end], serializer, size, } = options;
+    describe(name, () => {
+        it("works in bounds", () => {
+            expectEncode(serializer, start);
+            for (let i = 0; i < 100; i++) {
+                expectEncode(serializer, randbigint(start, end));
+            }
+            expectEncode(serializer, end);
+        });
+        it("outside bounds", () => {
+            expectError(() => st.write(serializer, start - 1n));
+            expectError(() => st.write(serializer, end + 1n));
+        });
+        it(`is right size`, () => {
+            const expectValueSize = (value) => {
+                const data = st.write(serializer, value);
+                expect(data.byteLength).toBe(size);
+            };
+            for (let i = 0; i < 100; i++) {
+                expectValueSize(randbigint(start, end));
+            }
+            expectValueSize(start);
+            expectValueSize(end);
+        });
+        it(`matches snapshots`, () => {
+            expectEncodeSnapshot(serializer, 0n);
+            expectEncodeSnapshot(serializer, start);
+            expectEncodeSnapshot(serializer, start + 10n);
+            expectEncodeSnapshot(serializer, end - 10n);
+            expectEncodeSnapshot(serializer, end);
+        });
+    });
+}
+test_bigint({
+    name: "st.u64(little)",
+    serializer: st.u64Bigint("little"),
+    range: [0n, 18446744073709551615n],
+    size: 8,
+});
+test_bigint({
+    name: "st.u64(big)",
+    serializer: st.u64Bigint("big"),
+    range: [0n, 18446744073709551615n],
+    size: 8,
+});
+test_bigint({
+    name: "st.s64(little)",
+    serializer: st.s64Bigint("little"),
+    range: [-9223372036854775808n, 9223372036854775807n],
+    size: 8,
+});
+test_bigint({
+    name: "st.s64(big)",
+    serializer: st.s64Bigint("big"),
+    range: [-9223372036854775808n, 9223372036854775807n],
+    size: 8,
+});

package/dist/datatypes/numbers/floats.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datatypes/numbers/floats.test.js

@@ -0,0 +1,71 @@
+//@ts-ignore TODO
+import { describe, it, expect } from "bun:test";
+import { expectEncode, expectEncodeSnapshot, expectError, randint } from "../utils.test";
+import * as st from "../../index";
+function test_sint(options) {
+    const { name, range: [start, end], serializer, size, } = options;
+    describe(name, () => {
+        it(`works in bounds`, () => {
+            expectEncode(serializer, start);
+            for (let i = 0; i < 100; i++) {
+                expectEncode(serializer, randint(start, end));
+            }
+            expectEncode(serializer, end);
+        });
+        it(`errors outside bounds`, () => {
+            expectError(() => st.write(serializer, start - 1));
+            expectError(() => st.write(serializer, end + 1));
+        });
+        it(`errors on decimal`, () => {
+            expectError(() => st.write(serializer, 0.1));
+        });
+        it(`is right size`, () => {
+            const expectValueSize = (value) => {
+                const data = st.write(serializer, value);
+                expect(data.byteLength).toBe(size);
+            };
+            for (let i = 0; i < 100; i++) {
+                expectValueSize(randint(start, end));
+            }
+            expectValueSize(start);
+            expectValueSize(end);
+        });
+        it(`matches snapshots`, () => {
+            expectEncodeSnapshot(serializer, 0);
+            expectEncodeSnapshot(serializer, start);
+            expectEncodeSnapshot(serializer, start + 10);
+            expectEncodeSnapshot(serializer, end - 10);
+            expectEncodeSnapshot(serializer, end);
+        });
+    });
+}
+test_sint({
+    name: "st.s8",
+    serializer: st.s8(),
+    range: [-128, 127],
+    size: 1,
+});
+test_sint({
+    name: "st.s16(little)",
+    serializer: st.s16("little"),
+    range: [-32_768, 32_767],
+    size: 2,
+});
+test_sint({
+    name: "st.s16(big)",
+    serializer: st.s16("big"),
+    range: [-32_768, 32_767],
+    size: 2,
+});
+test_sint({
+    name: "st.s32(little)",
+    serializer: st.s32("little"),
+    range: [-2_147_483_648, 2_147_483_647],
+    size: 4,
+});
+test_sint({
+    name: "st.s32(big)",
+    serializer: st.s32("big"),
+    range: [-2_147_483_648, 2_147_483_647],
+    size: 4,
+});

package/dist/datatypes/numbers/sints.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datatypes/numbers/sints.test.js

@@ -0,0 +1,87 @@
+//@ts-ignore TODO
+import { describe, it, expect } from "bun:test";
+import { expectEncode, expectEncodeSnapshot, expectError, randint } from "../utils.test";
+import * as st from "../../index";
+function test_sint(options) {
+    const { name, range: [start, end], serializer, size, disableRangeCheck, } = options;
+    describe(name, () => {
+        it(`works in bounds`, () => {
+            expectEncode(serializer, start);
+            for (let i = 0; i < 100; i++) {
+                expectEncode(serializer, randint(start, end));
+            }
+            expectEncode(serializer, end);
+        });
+        if (!disableRangeCheck) {
+            it(`errors outside bounds`, () => {
+                expectError(() => st.write(serializer, start - 1));
+                expectError(() => st.write(serializer, end + 1));
+            });
+        }
+        it(`errors on decimal`, () => {
+            expectError(() => st.write(serializer, 0.1));
+        });
+        it(`is right size`, () => {
+            const expectValueSize = (value) => {
+                const data = st.write(serializer, value);
+                expect(data.byteLength).toBe(size);
+            };
+            for (let i = 0; i < 100; i++) {
+                expectValueSize(randint(start, end));
+            }
+            expectValueSize(start);
+            expectValueSize(end);
+        });
+        it(`matches snapshots`, () => {
+            expectEncodeSnapshot(serializer, 0);
+            expectEncodeSnapshot(serializer, start);
+            expectEncodeSnapshot(serializer, start + 10);
+            expectEncodeSnapshot(serializer, end - 10);
+            expectEncodeSnapshot(serializer, end);
+        });
+    });
+}
+test_sint({
+    name: "st.s8",
+    serializer: st.s8(),
+    range: [-128, 127],
+    size: 1,
+});
+test_sint({
+    name: "st.s16(little)",
+    serializer: st.s16("little"),
+    range: [-32_768, 32_767],
+    size: 2,
+});
+test_sint({
+    name: "st.s16(big)",
+    serializer: st.s16("big"),
+    range: [-32_768, 32_767],
+    size: 2,
+});
+test_sint({
+    name: "st.s32(little)",
+    serializer: st.s32("little"),
+    range: [-2_147_483_648, 2_147_483_647],
+    size: 4,
+});
+test_sint({
+    name: "st.s32(big)",
+    serializer: st.s32("big"),
+    range: [-2_147_483_648, 2_147_483_647],
+    size: 4,
+});
+test_sint({
+    name: "st.s64(little)",
+    serializer: st.s64("little"),
+    range: [-(2 ** 62), 2 ** 62],
+    size: 8,
+    disableRangeCheck: true,
+});
+test_sint({
+    name: "st.s64(big)",
+    serializer: st.s64("big"),
+    range: [-(2 ** 62), 2 ** 62],
+    size: 8,
+    disableRangeCheck: true,
+});

package/dist/datatypes/numbers/uints.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datatypes/numbers/uints.test.js

@@ -0,0 +1,87 @@
+//@ts-ignore TODO
+import { describe, it, expect } from "bun:test";
+import { expectEncode, expectEncodeSnapshot, expectError, randint } from "../utils.test";
+import * as st from "../../index";
+function test_uint(options) {
+    const { name, range: [start, end], serializer, size, disableMaxCheck, } = options;
+    describe(name, () => {
+        it(`works in bounds`, () => {
+            expectEncode(serializer, start);
+            for (let i = 0; i < 100; i++) {
+                expectEncode(serializer, randint(start, end));
+            }
+            expectEncode(serializer, end);
+        });
+        it(`errors outside bounds`, () => {
+            expectError(() => st.write(serializer, start - 1));
+            if (!disableMaxCheck) {
+                expectError(() => st.write(serializer, end + 1));
+            }
+        });
+        it(`errors on decimal`, () => {
+            expectError(() => st.write(serializer, 0.1));
+        });
+        it(`is right size`, () => {
+            const expectValueSize = (value) => {
+                const data = st.write(serializer, value);
+                expect(data.byteLength).toBe(size);
+            };
+            for (let i = 0; i < 100; i++) {
+                expectValueSize(randint(start, end));
+            }
+            expectValueSize(start);
+            expectValueSize(end);
+        });
+        it(`matches snapshots`, () => {
+            expectEncodeSnapshot(serializer, 0);
+            expectEncodeSnapshot(serializer, start);
+            expectEncodeSnapshot(serializer, start + 10);
+            expectEncodeSnapshot(serializer, end - 10);
+            expectEncodeSnapshot(serializer, end);
+        });
+    });
+}
+test_uint({
+    name: "st.u8",
+    serializer: st.u8(),
+    range: [0, 255],
+    size: 1,
+});
+test_uint({
+    name: "st.u16(little)",
+    serializer: st.u16("little"),
+    range: [0, 65_535],
+    size: 2,
+});
+test_uint({
+    name: "st.u16(big)",
+    serializer: st.u16("big"),
+    range: [0, 65_535],
+    size: 2,
+});
+test_uint({
+    name: "st.u32(little)",
+    serializer: st.u32("little"),
+    range: [0, 4_294_967_295],
+    size: 4,
+});
+test_uint({
+    name: "st.u32(big)",
+    serializer: st.u32("big"),
+    range: [0, 4_294_967_295],
+    size: 4,
+});
+test_uint({
+    name: "st.u64(little)",
+    serializer: st.u64("little"),
+    range: [0, 2 ** 63],
+    size: 8,
+    disableMaxCheck: true,
+});
+test_uint({
+    name: "st.u64(big)",
+    serializer: st.u64("big"),
+    range: [0, 2 ** 63],
+    size: 8,
+    disableMaxCheck: true,
+});

package/dist/datatypes/transforms/pipe.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datatypes/transforms/pipe.test.js

@@ -0,0 +1,13 @@
+import { describe, it } from "bun:test";
+import { bytes, expectEncode } from "../utils.test";
+import * as st from "../../index";
+describe("st.pipe", () => {
+    it("applies correctly", () => {
+        const buffer = st.sizedBuffer(st.u8());
+        expectEncode(buffer, bytes([1, 2]));
+    });
+    it("runs in correct order", () => {
+        const spec = st.sizedBuffer(st.u8());
+        expectEncode(spec, bytes([]));
+    });
+});

package/dist/datatypes/utilities/constant.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function constant<T>(type: Serializer<T>, value: T): Serializer<any, T>;

package/dist/datatypes/utilities/constant.js

@@ -0,0 +1,13 @@
+export function constant(type, value) {
+    return {
+        size: type.size,
+        read: (ctx) => {
+            type.read(ctx);
+            return value;
+        },
+        write: (ctx) => {
+            type.write(ctx, value);
+            return value;
+        },
+    };
+}

package/dist/datatypes/utilities/remember.d.ts

@@ -0,0 +1,5 @@
+import type { Serializer } from "../../types";
+export declare function createRememberedValue<T>(): {
+    save: (serializer: Serializer<T>) => Serializer<T>;
+    load: () => Serializer<T>;
+};

package/dist/datatypes/utilities/remember.js

@@ -0,0 +1,26 @@
+export function createRememberedValue() {
+    const stack = [];
+    function store(serializer) {
+        return {
+            size: serializer.size,
+            read: (ctx) => {
+                const value = serializer.read(ctx);
+                stack.push(value);
+                return value;
+            },
+            write: (ctx, value) => {
+                serializer.write(ctx, value);
+                stack.push(value);
+                return value;
+            },
+        };
+    }
+    function load() {
+        return {
+            size: 0,
+            read: () => stack.pop(),
+            write: () => { },
+        };
+    }
+    return { save: store, load: load };
+}

package/dist/datatypes/utils.test.d.ts

@@ -0,0 +1,7 @@
+import * as st from "../index";
+export declare const randint: (start: number, end: number) => number;
+export declare const randbigint: (start: bigint, end: bigint) => bigint;
+export declare const expectEncode: <T>(serializer: st.Serializer<T>, value: T) => void;
+export declare const expectEncodeSnapshot: <T>(serializer: st.Serializer<T>, value: T) => void;
+export declare const expectError: (callback: () => void) => void;
+export declare const bytes: (bytes: number[]) => ArrayBuffer;

package/dist/datatypes/utils.test.js

@@ -0,0 +1,33 @@
+//@ts-ignore TODO
+import { describe, it, expect } from "bun:test";
+import * as st from "../index";
+export const randint = (start, end) => {
+    const range = end - start;
+    return Math.floor(start + range * Math.random());
+};
+export const randbigint = (start, end) => {
+    const range = end - start;
+    const offset = BigInt(Math.floor(Number(range) * Math.random()));
+    return start + offset;
+};
+export const expectEncode = (serializer, value) => {
+    const data = st.write(serializer, value);
+    const newValue = st.read(serializer, data);
+    expect(value).toEqual(newValue);
+};
+export const expectEncodeSnapshot = (serializer, value) => {
+    const data = st.write(serializer, value);
+    expect(data).toMatchSnapshot();
+};
+export const expectError = (callback) => {
+    try {
+        callback();
+    }
+    catch {
+        return;
+    }
+    throw new Error("Expected Error");
+};
+export const bytes = (bytes) => {
+    return new Uint8Array(bytes).buffer;
+};

package/dist/datatypes/values/buffer.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,43 @@
+import { describe, it } from "bun:test";
+import { bytes, expectEncode, expectError } from "../utils.test";
+import * as st from "../../index";
+describe("st.buffer", () => {
+    const buffer = st.buffer(2);
+    it("encode correctly", () => {
+        expectEncode(buffer, bytes([1, 2]));
+    });
+    it("encodes empty correctly", () => {
+        const spec = st.buffer(0);
+        expectEncode(spec, bytes([]));
+    });
+    it("holds large data", () => {
+        const size = 1024 * 1024 * 8; // 8MB
+        const spec = st.buffer(size);
+        const data = new Uint8Array(size);
+        data.set([3, 4], 1000);
+        data.set([3, 4], 2000);
+        expectEncode(spec, data.buffer);
+    });
+    it("large data writes work", () => {
+        const size = 1024 * 1024 * 8; // 8MB
+        const spec = st.object({
+            before: st.u8(),
+            data: st.buffer(size),
+            after: st.u8(),
+        });
+        const data = new Uint8Array(size);
+        data.set([3, 4], 1000);
+        data.set([3, 4], 2000);
+        expectEncode(spec, {
+            before: 1,
+            data: data.buffer,
+            after: 2,
+        });
+    });
+    it("errors on invalid length", () => {
+        const spec = st.buffer(5);
+        expectError(() => {
+            st.write(spec, bytes([1, 2, 3, 4]));
+        });
+    });
+});

package/dist/{structo/datatypes → datatypes}/values/string.js

@@ -1,15 +1,16 @@
 export function string(length) {
-    const { read: readLength, write: writeLength } = length;
+    const { read: readLength, write: writeLength, size: lengthSize = 0 } = length;
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
     return {
         write: (ctx, value) => {
             const bytes = encoder.encode(value);
-            writeLength(ctx, bytes.byteLength);
-            ctx.alloc(bytes.byteLength);
-            const arr = new Uint8Array(ctx.view.buffer);
-            arr.set(bytes, ctx.offset);
-            ctx.offset += bytes.byteLength;
+            const length = bytes.byteLength;
+            ctx.alloc(length + lengthSize);
+            writeLength(ctx, length);
+            const arr = new Uint8Array(ctx.buffer, ctx.offset);
+            arr.set(bytes);
+            ctx.offset += length;
         },
         read: (ctx) => {
             const length = readLength(ctx);

package/dist/datatypes/values/string.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+import { describe, it } from "bun:test";
+import { expectEncode, expectError } from "../utils.test";
+import * as st from "../../index";
+describe("st.string", () => {
+    const string_u8 = st.string(st.u8());
+    const string_u32 = st.string(st.u32());
+    it("encode correctly", () => {
+        expectEncode(string_u8, "foo");
+    });
+    it("works on empty strings", () => {
+        expectEncode(string_u32, "");
+    });
+    it("errors on too long strings", () => {
+        expectError(() => {
+            st.write(string_u8, "A".repeat(256));
+        });
+    });
+});

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils.test.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -3,7 +3,7 @@
   "description": "A library for serializing and deserializing binary content",
   "keywords": ["binary", "library", "utility", "web", "node"],
   "license": "ISC",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "author": "Ben Brady",
   "private": false,
   "publishConfig": {"access": "public"},

package/dist/structo/datatypes/containers/fastObject.d.ts

@@ -1,6 +0,0 @@
-import type { InferInput, Serializer } from "../../types";
-type InferObject<T> = T extends Record<string, Serializer<any>> ? {
-    [Key in keyof T]: InferInput<T[Key]>;
-} : never;
-export declare function fastObject<T extends Record<string, Serializer<any>>>(definition: T): Serializer<InferObject<T>>;
-export {};

package/dist/{structo/index.d.ts → index.d.ts}

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

package/dist/{structo/index.js → index.js}

@@ -1,3 +1,3 @@
 export * from "./datatypes";
-export { write, createdWriterContext } from "./write";
 export { read, createReaderContext } from "./read";
+export { write, createdWriterContext } from "./write";