@nnilky/structo 1.0.0 → 1.0.1

package/structo/datatypes/numbers/bigints.ts

@@ -1,48 +0,0 @@
-//@ts-ignore TODO
-import type { Serializer } from "../../types";
-
-const checkValue = (value: number | bigint, start: bigint, end: bigint) => {
-    if (value < start || value >= end) {
-        throw new Error("Out of Range");
-    }
-};
-
-export function u64Bigint(
-    endian: "little" | "big" = "little",
-): Serializer<number | bigint, bigint> {
-    return {
-        size: 8,
-        write: (ctx, value) => {
-            checkValue(value, 0n, 2n ** 64n);
-
-            ctx.alloc(8);
-            ctx.view.setBigUint64(ctx.offset, BigInt(value), endian === "little");
-            ctx.offset += 8;
-        },
-        read: (ctx) => {
-            const value = ctx.view.getBigUint64(ctx.offset, endian === "little");
-            ctx.offset += 8;
-            return value;
-        },
-    };
-}
-
-export function s64Bigint(
-    endian: "little" | "big" = "little",
-): Serializer<number | bigint, bigint> {
-    return {
-        size: 8,
-        write: (ctx, value) => {
-            checkValue(value, -(2n ** 63n), 2n ** 63n);
-
-            ctx.alloc(8);
-            ctx.view.setBigInt64(ctx.offset, BigInt(value), endian === "little");
-            ctx.offset += 8;
-        },
-        read: (ctx) => {
-            const value = ctx.view.getBigInt64(ctx.offset, endian === "little");
-            ctx.offset += 8;
-            return value;
-        },
-    };
-}

package/structo/datatypes/numbers/floats.test.ts

@@ -1,91 +0,0 @@
-//@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: {
-    name: string;
-    serializer: st.Serializer<number>;
-    range: [number, number];
-    size: number;
-}) {
-    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: number) => {
-                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/structo/datatypes/numbers/floats.ts

@@ -1,33 +0,0 @@
-import type { Serializer } from "../../types";
-
-export function f32(endian: "little" | "big" = "little"): Serializer<number> {
-    return {
-        size: 4,
-        write: (ctx, value) => {
-            ctx.alloc(4);
-            ctx.view.setFloat32(ctx.offset, value, endian === "little");
-            ctx.offset += 4;
-        },
-        read: (ctx) => {
-            const value = ctx.view.getFloat32(ctx.offset, endian === "little");
-            ctx.offset += 4;
-            return value;
-        },
-    };
-}
-
-export function f64(endian: "little" | "big" = "little"): 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;
-        },
-    };
-}

package/structo/datatypes/numbers/sints.test.ts

@@ -1,109 +0,0 @@
-//@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: {
-    name: string;
-    serializer: st.Serializer<number>;
-    range: [number, number];
-    size: number;
-    disableRangeCheck?: boolean;
-}) {
-    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: number) => {
-                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/structo/datatypes/numbers/sints.ts

@@ -1,83 +0,0 @@
-import type { Serializer } from "../../types";
-
-const checkValue = (value: number, start: number, end: number) => {
-    if (!Number.isInteger(value)) {
-        throw new Error("Not Integer");
-    }
-
-    if (value < start || value >= end) {
-        throw new Error("Out of Range");
-    }
-};
-
-export function s8(): Serializer<number> {
-    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" | "big" = "little"): Serializer<number> {
-    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" | "big" = "little"): Serializer<number> {
-    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" | "big" = "little"): Serializer<number> {
-    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/structo/datatypes/numbers/uints.test.ts

@@ -1,110 +0,0 @@
-//@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: {
-    name: string;
-    serializer: st.Serializer<number>;
-    range: [number, number];
-    size: number;
-    disableMaxCheck?: boolean;
-}) {
-    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: number) => {
-                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/structo/datatypes/numbers/uints.ts

@@ -1,82 +0,0 @@
-import type { Serializer } from "../../types";
-
-const checkValue = (value: number, start: number, end: number) => {
-    if (!Number.isInteger(value)) throw new Error("Not Integer");
-    if (value < start || value >= end) throw new Error("Out of Range");
-};
-
-export function u8(): Serializer<number> {
-    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" | "big" = "little"): Serializer<number> {
-    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" | "big" = "little"): Serializer<number> {
-    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" | "big" = "little"): Serializer<number> {
-    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/structo/datatypes/transforms/pipe.test.ts

@@ -1,17 +0,0 @@
-//@ts-ignore TODO
-import { describe, it, expect } from "bun:test";
-import { bytes, expectEncode, expectError, randint } 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/structo/datatypes/transforms/pipe.ts

@@ -1,88 +0,0 @@
-import type { Serializer } from "../../types";
-
-export type Transform<T = any, TNext = T> = (type: Serializer<TNext>) => Serializer<T>;
-
-export function pipe<TStart, T1>(
-    type: Serializer<TStart>,
-    p1: Transform<T1, TStart>,
-): Serializer<T1>;
-
-export function pipe<TStart, T1, T2>(
-    type: Serializer<TStart>,
-    p1: Transform<T1, TStart>,
-    p2: Transform<T2, T1>,
-): Serializer<T2>;
-
-export function pipe<TStart, T1, T2, T3>(
-    type: Serializer<TStart>,
-    p1: Transform<T1, TStart>,
-    p2: Transform<T2, T1>,
-    p3: Transform<T3, T2>,
-): Serializer<T3>;
-
-export 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 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 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 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 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 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>;
-
-export function pipe<T, TPipeline extends Transform[]>(
-    type: Serializer<T>,
-    ...pipeline: TPipeline[]
-): any {
-    //@ts-ignore
-    return pipeline.reduce((v, func) => func(v), type);
-}

package/structo/datatypes/transforms/readOffset.ts

@@ -1,20 +0,0 @@
-import type { Serializer } from "../../types";
-
-export function positionOffset<T>(delta: number) {
-    return (type: Serializer<T>): Serializer<T> => ({
-        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/structo/datatypes/transforms/transform.ts

@@ -1,15 +0,0 @@
-import type { Serializer } from "../../types";
-
-export function transform<T>(callback: (value: T) => T) {
-    return (type: Serializer<T>): 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);
-        },
-    });
-}