@nnilky/structo 1.0.0 → 1.0.1

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/buffer.ts

@@ -1,20 +0,0 @@
-import type { Serializer } from "../../types";
-
-export function buffer(size: number): Serializer<ArrayBuffer> {
-    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/structo/datatypes/values/byteliteral.ts

@@ -1,24 +0,0 @@
-import type { Serializer } from "../../types";
-
-export function byteLiteral(bytes: number[]): Serializer<number[]> {
-    const length = bytes.length;
-
-    return {
-        size: bytes.length,
-        read: (ctx) => {
-            const arr = new Uint8Array(ctx.view.buffer);
-
-            for (let i = 0; i < length; i++) {
-                if (arr[ctx.offset + i] !== bytes[i]) {
-                    throw new Error("Invalid Value");
-                }
-            }
-            ctx.offset += length;
-            return bytes;
-        },
-        write(ctx) {
-            new Uint8Array(ctx.view.buffer).set(bytes, ctx.offset);
-            ctx.offset += length;
-        },
-    };
-}

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

@@ -1,28 +0,0 @@
-import type { Serializer } from "../../types";
-
-export function string(length: Serializer<number>): Serializer<string> {
-    const { read: readLength, write: writeLength } = 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;
-        },
-        read: (ctx) => {
-            const length = readLength(ctx);
-            const section = ctx.buffer.slice(ctx.offset, ctx.offset + length);
-            ctx.offset += length;
-            return decoder.decode(section);
-        },
-    };
-}

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),
-    };
-}

package/structo/types.ts

@@ -1,21 +0,0 @@
-export type Serializer<TIn, TOut = TIn> = {
-    size?: number | undefined;
-    write: (ctx: WriterContext, value: TIn) => void;
-    read: (ctx: ReaderContext) => TOut;
-};
-
-export interface WriterContext {
-    buffer: ArrayBuffer;
-    view: DataView;
-    offset: number;
-    alloc: (length: number) => void;
-}
-
-export interface ReaderContext {
-    buffer: ArrayBuffer;
-    view: DataView;
-    offset: number;
-}
-
-export type InferInput<T> = T extends Serializer<infer V> ? V : never;
-export type InferOutput<T> = T extends Serializer<any, infer V> ? V : never;

package/structo/write.ts

@@ -1,43 +0,0 @@
-import type { WriterContext, Serializer } from "./types";
-
-export function write<T>(serializer: Serializer<T>, value: T): ArrayBuffer {
-    const ctx = createdWriterContext(serializer);
-    serializer.write(ctx, value);
-
-    if (ctx.buffer.byteLength === ctx.offset) {
-        return ctx.buffer;
-    } else {
-        return ctx.buffer.transfer(ctx.offset);
-    }
-}
-
-export function createdWriterContext(type: Serializer<any>): WriterContext {
-    if (type.size) {
-        let buffer = new ArrayBuffer(type.size);
-        const view = new DataView(buffer);
-        return {
-            offset: 0,
-            buffer,
-            view,
-            alloc: Function.prototype as () => void,
-        };
-    } else {
-        let bufferLength = 64;
-        let buffer = new ArrayBuffer(bufferLength);
-        const view = new DataView(buffer);
-        return {
-            offset: 0,
-            buffer,
-            view,
-            alloc(length) {
-                if (length < 0) return;
-
-                while (this.offset + length >= bufferLength) {
-                    bufferLength = this.buffer.byteLength * 2;
-                    this.buffer = this.buffer.transfer(bufferLength);
-                    this.view = new DataView(this.buffer);
-                }
-            },
-        };
-    }
-}