@nnilky/structo 1.0.9 → 1.1.0

package/dist/datatypes/utilities/remember.test.js

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { expectEncode, expectEncodeSnapshot } from "../utils.test";
-import * as st from "../../index";
-describe("st.remember", () => {
-    const v = st.createRememberedValue();
-    it("encodes correctly", () => {
-        const spec = st.object({
-            a: v.save(st.u32()),
-            b: st.list(v.load(), st.u8()),
-        });
-        expectEncode(spec, {
-            a: 3,
-            b: [1, 3, 4],
-        });
-    });
-    it("omitted serializer doesn't write data ", () => {
-        const spec = st.object({
-            a: v.save(st.u32()),
-            b: v.load(),
-        });
-        const output = st.write(spec, { a: 3, b: 0 });
-        expect(output.byteLength).toBe(4);
-    });
-    it("serializer is used write data ", () => {
-        const spec = st.object({
-            a: v.save(st.u32()),
-            b: v.load(st.u8()),
-        });
-        expectEncode(spec, { a: 3, b: 0 }, { a: 3, b: 3 });
-    });
-    it("snapshots are correct", () => {
-        expectEncodeSnapshot(st.object({
-            a: v.save(st.u32()),
-            b: st.list(v.load(), st.u8()),
-        }), {
-            a: 3,
-            b: [1, 3, 4],
-        });
-        expectEncodeSnapshot(st.object({
-            a: v.save(st.u32()),
-            b: v.load(st.u8()),
-        }), { a: 3, b: 0 });
-    });
-});

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

@@ -1,8 +0,0 @@
-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: <TIn, TOut>(serializer: st.Serializer<TIn, TOut>, value: TIn, expected?: TOut) => void;
-export declare const expectEncodeSize: <TIn, TOut>(serializer: st.Serializer<TIn, TOut>, size: number, value: TIn) => 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

@@ -1,37 +0,0 @@
-//@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, expected) => {
-    const data = st.write(serializer, value);
-    const newValue = st.read(serializer, data);
-    expect(newValue).toEqual((expected ?? value));
-};
-export const expectEncodeSize = (serializer, size, value) => {
-    const data = st.write(serializer, value);
-    expect(data.byteLength).toEqual(size);
-};
-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/byteliteral.d.ts

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

package/dist/datatypes/values/byteliteral.js

@@ -1,20 +0,0 @@
-export function bytesLiteral(bytes) {
-    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/dist/datatypes/values/json.d.ts

@@ -1,10 +0,0 @@
-import type { Serializer } from "../../types";
-/**
- * `st.json` stores JSON data using a string serializer
- *
- * ```
- * st.json(st.string(st.u32()))
- * ```
- *
- */
-export declare function json(type: Serializer<string>): Serializer<any>;

package/dist/datatypes/values/json.js

@@ -1,21 +0,0 @@
-/**
- * `st.json` stores JSON data using a string serializer
- *
- * ```
- * st.json(st.string(st.u32()))
- * ```
- *
- */
-export function json(type) {
-    return {
-        size: type.size,
-        write: (ctx, value) => {
-            const json = JSON.stringify(value);
-            type.write(ctx, json);
-        },
-        read: (ctx) => {
-            const value = type.read(ctx);
-            return JSON.parse(value);
-        },
-    };
-}

package/dist/transforms/fixedOffset.d.ts

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

package/dist/transforms/fixedOffset.js

@@ -1,18 +0,0 @@
-export function fixedOffset(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/transforms/noAdvance.d.ts

@@ -1,16 +0,0 @@
-import type { Serializer } from "../types";
-/**
- * Whilst reading this type, don't advance the offset after reading
- *
- * This can be useful for taggedUnions where they key is the first value in all the variants
- *
- * ```
- * st.object({
- *     stringLength: st.pipe(
- *         st.u16(),
- *         st.noAdvance(),
- *     ),
- *     text: st.string(st.u16()),
- * })
- */
-export declare function noAdvance<T>(): (type: Serializer<T>) => Serializer<T>;

package/dist/transforms/noAdvance.js

@@ -1,30 +0,0 @@
-/**
- * Whilst reading this type, don't advance the offset after reading
- *
- * This can be useful for taggedUnions where they key is the first value in all the variants
- *
- * ```
- * st.object({
- *     stringLength: st.pipe(
- *         st.u16(),
- *         st.noAdvance(),
- *     ),
- *     text: st.string(st.u16()),
- * })
- */
-export function noAdvance() {
-    return (type) => ({
-        size: type.size,
-        read: (ctx) => {
-            let start = ctx.offset;
-            const value = type.read(ctx);
-            ctx.offset = start;
-            return value;
-        },
-        write: (ctx, value) => {
-            let start = ctx.offset;
-            type.write(ctx, value);
-            ctx.offset = start;
-        },
-    });
-}

package/dist/transforms/noAdvance.test.d.ts

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

package/dist/transforms/noAdvance.test.js

@@ -1,17 +0,0 @@
-import { describe, it } from "node:test";
-import * as st from "../index";
-import { encodeTest } from "../utils.test";
-describe("st.noAdvance", () => {
-    it("encode correctly", () => {
-        encodeTest(st.object({
-            length: st.pipe(st.u8(), st.noAdvance()),
-            text: st.string(st.u8()),
-        }), //
-        { length: 3, text: "foo" });
-        encodeTest(st.object({
-            a: st.pipe(st.u16(), st.noAdvance()),
-            b: st.f16(),
-        }), //
-        { a: 0, b: 1 }, { a: 15360, b: 1 });
-    });
-});