@nnilky/structo 1.0.1 → 1.0.3

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.d.ts

@@ -0,0 +1,5 @@
+import type { Serializer } from "../../types";
+export declare function s8(): Serializer<number>;
+export declare function s16(endian?: "little" | "big"): Serializer<number>;
+export declare function s32(endian?: "little" | "big"): Serializer<number>;
+export declare function s64(endian?: "little" | "big"): Serializer<number>;

package/dist/datatypes/numbers/sints.js

@@ -0,0 +1,72 @@
+const checkValue = (value, start, end) => {
+    if (!Number.isInteger(value)) {
+        throw new Error("Not Integer");
+    }
+    if (value < start || value >= end) {
+        throw new Error("Out of Range");
+    }
+};
+export function s8() {
+    return {
+        size: 1,
+        write: (ctx, value) => {
+            checkValue(value, -(2 ** 7), 2 ** 7);
+            ctx.alloc(1);
+            ctx.view.setInt8(ctx.offset, value);
+            ctx.offset += 1;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getInt8(ctx.offset);
+            ctx.offset += 1;
+            return value;
+        },
+    };
+}
+export function s16(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.offset += 2;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getInt16(ctx.offset, endian === "little");
+            ctx.offset += 2;
+            return value;
+        },
+    };
+}
+export function s32(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.offset += 4;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getInt32(ctx.offset, endian === "little");
+            ctx.offset += 4;
+            return value;
+        },
+    };
+}
+export function s64(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.offset += 8;
+        },
+        read: (ctx) => {
+            const value = Number(ctx.view.getBigInt64(ctx.offset, endian === "little"));
+            ctx.offset += 8;
+            return value;
+        },
+    };
+}

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.d.ts

@@ -0,0 +1,5 @@
+import type { Serializer } from "../../types";
+export declare function u8(): Serializer<number>;
+export declare function u16(endian?: "little" | "big"): Serializer<number>;
+export declare function u32(endian?: "little" | "big"): Serializer<number>;
+export declare function u64(endian?: "little" | "big"): Serializer<number>;

package/dist/datatypes/numbers/uints.js

@@ -0,0 +1,76 @@
+export function u8() {
+    return {
+        size: 1,
+        write: (ctx, value) => {
+            if (!Number.isInteger(value))
+                throw new Error("Not Integer");
+            if (value < 0 || value >= 2 ** 8)
+                throw new Error("Out of Range");
+            ctx.alloc(1);
+            ctx.view.setUint8(ctx.offset, value);
+            ctx.offset += 1;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getUint8(ctx.offset);
+            ctx.offset += 1;
+            return value;
+        },
+    };
+}
+export function u16(endian = "little") {
+    return {
+        size: 2,
+        write: (ctx, value) => {
+            if (!Number.isInteger(value))
+                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.offset += 2;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getUint16(ctx.offset, endian === "little");
+            ctx.offset += 2;
+            return value;
+        },
+    };
+}
+export function u32(endian = "little") {
+    return {
+        size: 4,
+        write: (ctx, value) => {
+            if (!Number.isInteger(value))
+                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.offset += 4;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getUint32(ctx.offset, endian === "little");
+            ctx.offset += 4;
+            return value;
+        },
+    };
+}
+export function u64(endian = "little") {
+    return {
+        size: 8,
+        write: (ctx, value) => {
+            if (!Number.isInteger(value))
+                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.offset += 8;
+        },
+        read: (ctx) => {
+            const value = Number(ctx.view.getBigUint64(ctx.offset, endian === "little"));
+            ctx.offset += 8;
+            return value;
+        },
+    };
+}

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.d.ts

@@ -0,0 +1,11 @@
+import type { Serializer } from "../../types";
+export type Transform<T = any, TNext = T> = (type: Serializer<TNext>) => Serializer<T>;
+export declare function pipe<TStart, T1>(type: Serializer<TStart>, p1: Transform<T1, TStart>): Serializer<T1>;
+export declare function pipe<TStart, T1, T2>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>): Serializer<T2>;
+export declare function pipe<TStart, T1, T2, T3>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>): Serializer<T3>;
+export declare function pipe<TStart, T1, T2, T3, T4>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>): Serializer<T4>;
+export declare function pipe<TStart, T1, T2, T3, T4, T5>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T4>): Serializer<T5>;
+export declare function pipe<TStart, T1, T2, T3, T4, T5, T6>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>): Serializer<T6>;
+export declare function pipe<TStart, T1, T2, T3, T4, T5, T6, T7>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>, p6: Transform<T6, T7>): Serializer<T7>;
+export declare function pipe<TStart, T1, T2, T3, T4, T5, T6, T7, T8>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>, p6: Transform<T6, T7>, p7: Transform<T7, T8>): Serializer<T8>;
+export declare function pipe<TStart, T1, T2, T3, T4, T5, T6, T7, T8, T9>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>, p6: Transform<T6, T7>, p7: Transform<T7, T8>, p8: Transform<T8, T9>): Serializer<T9>;

package/dist/datatypes/transforms/pipe.js

@@ -0,0 +1,4 @@
+export function pipe(type, ...pipeline) {
+    //@ts-ignore
+    return pipeline.reduce((v, func) => func(v), type);
+}

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/transforms/readOffset.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function positionOffset<T>(delta: number): (type: Serializer<T>) => Serializer<T>;

package/dist/datatypes/transforms/readOffset.js

@@ -0,0 +1,18 @@
+export function positionOffset(delta) {
+    return (type) => ({
+        size: type.size,
+        read: (ctx) => {
+            let start = ctx.offset;
+            ctx.offset += delta;
+            const value = type.read(ctx);
+            ctx.offset = start;
+            return value;
+        },
+        write: (ctx, value) => {
+            let start = ctx.offset;
+            ctx.offset += delta;
+            type.write(ctx, value);
+            ctx.offset = start;
+        },
+    });
+}

package/dist/datatypes/transforms/transform.d.ts

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

package/dist/datatypes/transforms/transform.js

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

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.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function buffer(size: number): Serializer<ArrayBuffer>;

package/dist/datatypes/values/buffer.js

@@ -0,0 +1,18 @@
+export function buffer(size) {
+    return {
+        size,
+        write: (ctx, value) => {
+            const bytes = new Uint8Array(value);
+            if (bytes.length !== size)
+                throw new Error("Invalid Length");
+            ctx.alloc(size);
+            new Uint8Array(ctx.buffer).set(bytes, ctx.offset);
+            ctx.offset += size;
+        },
+        read: (ctx) => {
+            const slice = ctx.buffer.slice(ctx.offset, ctx.offset + size);
+            ctx.offset += size;
+            return slice;
+        },
+    };
+}

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/datatypes/values/byteliteral.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function byteLiteral(bytes: number[]): Serializer<number[]>;