@nnilky/structo 1.0.0 → 1.0.2

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/utils.test.ts

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

package/structo/datatypes/values/buffer.test.ts

@@ -1,52 +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.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/structo/datatypes/values/string.test.ts

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

@@ -1,11 +0,0 @@
-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";

package/structo/read.ts

@@ -1,14 +0,0 @@
-import type { Serializer, ReaderContext } from "./types";
-
-
-export function read<T>(serializer: Serializer<T>, buffer: ArrayBuffer): T {
-    return serializer.read(createReaderContext(buffer));
-}
-
-export function createReaderContext(buffer: ArrayBuffer) {
-    return {
-        offset: 0,
-        buffer,
-        view: new DataView(buffer),
-    };
-}