@nnilky/structo 1.0.5 → 1.0.7

package/dist/datatypes/values/json.js

@@ -0,0 +1,21 @@
+/**
+ * `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/datatypes/values/sizedbytes.d.ts

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

package/dist/datatypes/values/sizedbytes.js

@@ -0,0 +1,17 @@
+export function sizedBytes(length) {
+    return {
+        write: (ctx, value) => {
+            length.write(ctx, value.byteLength);
+            const bytes = new Uint8Array(value);
+            ctx.alloc(value.byteLength);
+            new Uint8Array(ctx.view.buffer).set(bytes, ctx.offset);
+            ctx.offset += value.byteLength;
+        },
+        read: (ctx) => {
+            const size = length.read(ctx);
+            const slice = ctx.buffer.slice(ctx.offset, ctx.offset + size);
+            ctx.offset += size;
+            return slice;
+        },
+    };
+}

package/dist/datatypes/values/sizedbytes.test.d.ts

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

package/dist/datatypes/values/sizedbytes.test.js

@@ -0,0 +1,25 @@
+import { describe, it } from "bun:test";
+import { bytes, encodeFailTest, encodeTest } from "../../utils.test";
+import * as st from "../../index";
+describe("st.sizedBytes", () => {
+    it("encode correctly", () => {
+        const buffer = st.sizedBytes(st.u8());
+        encodeTest(buffer, bytes([1, 2]));
+    });
+    it("encodes empty correctly", () => {
+        const spec = st.sizedBytes(st.u8());
+        encodeTest(spec, bytes([]));
+    });
+    it("holds large data", () => {
+        const size = 1024 * 1024 * 8; // 8MB
+        const spec = st.sizedBytes(st.u32());
+        const data = new Uint8Array(size);
+        data.set([3, 4], 1000);
+        data.set([3, 4], 2000);
+        encodeTest(spec, data.buffer);
+    });
+    it("errors on invalid length", () => {
+        encodeFailTest(st.sizedBytes(st.u8()), //
+        bytes(Array.from({ length: 256 }, () => 0)));
+    });
+});

package/dist/datatypes/values/string.d.ts

@@ -0,0 +1,14 @@
+import type { Serializer } from "../../types";
+/**
+ * `st.json` stores string data by writing/reading the length and then reading that many bytes
+ *
+ * The type passed in is the type used to store it's length
+ *
+ * Note: The length stored is the byte length, not string length
+ *
+ * ```
+ * st.string(st.u32())
+ * ```
+ *
+ */
+export declare function string(length: Serializer<number>): Serializer<string>;

package/dist/datatypes/values/string.js

@@ -0,0 +1,36 @@
+/**
+ * `st.json` stores string data by writing/reading the length and then reading that many bytes
+ *
+ * The type passed in is the type used to store it's length
+ *
+ * Note: The length stored is the byte length, not string length
+ *
+ * ```
+ * st.string(st.u32())
+ * ```
+ *
+ */
+export function string(length) {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    const lengthSize = length.size ?? 0;
+    return {
+        write: (ctx, value) => {
+            if (typeof value !== "string")
+                throw new Error("Expected String");
+            const bytes = encoder.encode(value);
+            const size = bytes.byteLength;
+            ctx.alloc(size + lengthSize);
+            length.write(ctx, size);
+            const arr = new Uint8Array(ctx.buffer, ctx.offset);
+            arr.set(bytes);
+            ctx.offset += size;
+        },
+        read: (ctx) => {
+            const size = length.read(ctx);
+            const section = ctx.buffer.slice(ctx.offset, ctx.offset + size);
+            ctx.offset += size;
+            return decoder.decode(section);
+        },
+    };
+}

package/dist/datatypes/values/string.test.d.ts

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

package/dist/datatypes/values/string.test.js

@@ -0,0 +1,18 @@
+import { describe, it } from "bun:test";
+import { encodeFailTest, encodeTest } from "../../utils.test";
+import * as st from "../../index";
+describe("st.string", () => {
+    it("encode correctly", () => {
+        encodeTest(st.string(st.u8()), "foo");
+    });
+    it("works on empty strings", () => {
+        encodeTest(st.string(st.u32()), "");
+    });
+    it("errors on numbers", () => {
+        //@ts-expect-error, intentional mistake
+        encodeFailTest(st.string(st.u8()), 8);
+    });
+    it("errors on too long strings", () => {
+        encodeFailTest(st.string(st.u8()), "A".repeat(256));
+    });
+});

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export type { InferInput as Infer, InferInput, InferOutput, ReaderContext, WriterContext, Serializer, } from "./types";
-export * from "./datatypes/index";
 export { read, createReaderContext } from "./read";
 export { write, createdWriterContext } from "./write";
+export * from "./datatypes/index";
+export * from "./transforms/index";
+export * from "./utilities/index";

package/dist/index.js

@@ -1,3 +1,5 @@
-export * from "./datatypes/index";
 export { read, createReaderContext } from "./read";
 export { write, createdWriterContext } from "./write";
+export * from "./datatypes/index";
+export * from "./transforms/index";
+export * from "./utilities/index";

package/dist/transforms/encode.d.ts

@@ -0,0 +1,2 @@
+import type { Transform } from "./pipe";
+export declare function encode<TIn, TOut>(encode: (value: TOut) => TIn, decode: (value: TIn) => TOut): Transform<TOut, TIn>;

package/dist/transforms/encode.js

@@ -0,0 +1,7 @@
+export function encode(encode, decode) {
+    return (type) => ({
+        size: type.size,
+        read: (ctx) => decode(type.read(ctx)),
+        write: (ctx, value) => type.write(ctx, encode(value)),
+    });
+}

package/dist/transforms/enum.d.ts

@@ -0,0 +1,2 @@
+export declare function enum_<const T>(values: T[]): import("./pipe").Transform<T, any>;
+export { enum_ as enum };

package/dist/transforms/enum.js

@@ -0,0 +1,13 @@
+import { encode } from "./encode";
+export function enum_(values) {
+    return encode((v) => {
+        if (!values.includes(v))
+            throw new Error(`Invalid enum variant: ${v}`);
+        return v;
+    }, (v) => {
+        if (!values.includes(v))
+            throw new Error(`Invalid enum variant: ${v}`);
+        return v;
+    });
+}
+export { enum_ as enum };

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

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

package/dist/transforms/enum.test.js

@@ -0,0 +1,21 @@
+import { describe, it } from "node:test";
+import * as st from "../index";
+import { encodeTest, encodeFailTest } from "../utils.test";
+describe("st.enum", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.u8(), st.enum([0, 1, 2])), //
+        1);
+        encodeTest(st.pipe(st.string(st.u8()), st.enum(["foo", "bar", "woof"])), //
+        "foo");
+    });
+    it("invalid union variants error", () => {
+        //@ts-expect-error
+        encodeFailTest(st.pipe(st.u8(), st.enum([0, 1, 2])), 4);
+        //@ts-expect-error
+        encodeFailTest(st.pipe(st.string(st.u8()), st.enum(["A", "B", "C"])), "D");
+    });
+    () => {
+        //@ts-expect-error, invalid union variant
+        st.write(st.pipe(st.u8(), st.enum([0, 1, 2])), 4);
+    };
+});

package/dist/transforms/fixedOffset.d.ts

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

package/dist/transforms/fixedOffset.js

@@ -0,0 +1,18 @@
+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/index.d.ts

@@ -0,0 +1,12 @@
+export { type Transform as Pipeline, pipe } from "./pipe";
+export { encode } from "./encode";
+export { modify } from "./modify";
+export { literal } from "./literal";
+export { enum } from "./enum";
+export { fixedOffset } from "./fixedOffset";
+export { noAdvance } from "./noAdvance";
+export { toAscii } from "./toAscii";
+export { toBytes } from "./toBytes";
+export { toHex } from "./toHex";
+export { toBase64 } from "./toBase64";
+export { toTypedArray } from "./toTypedArray";

package/dist/transforms/index.js

@@ -0,0 +1,12 @@
+export { pipe } from "./pipe";
+export { encode } from "./encode";
+export { modify } from "./modify";
+export { literal } from "./literal";
+export { enum } from "./enum";
+export { fixedOffset } from "./fixedOffset";
+export { noAdvance } from "./noAdvance";
+export { toAscii } from "./toAscii";
+export { toBytes } from "./toBytes";
+export { toHex } from "./toHex";
+export { toBase64 } from "./toBase64";
+export { toTypedArray } from "./toTypedArray";

package/dist/transforms/literal.d.ts

@@ -0,0 +1 @@
+export declare function literal<const T>(value: T): import("./pipe").Transform<T, any>;

package/dist/transforms/literal.js

@@ -0,0 +1,12 @@
+import { encode } from "./encode";
+export function literal(value) {
+    return encode((v) => {
+        if (v !== value)
+            throw new Error(`Invalid literal variant: ${v}`);
+        return v;
+    }, (v) => {
+        if (v !== value)
+            throw new Error(`Invalid literal variant: ${v}`);
+        return v;
+    });
+}

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

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

package/dist/transforms/literal.test.js

@@ -0,0 +1,23 @@
+import { describe, it } from "node:test";
+import * as st from "../index";
+import { encodeTest, encodeFailTest } from "../utils.test";
+describe("st.literal", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.u8(), st.literal(0)), //
+        0);
+        encodeTest(st.pipe(st.string(st.u8()), st.literal("foo")), //
+        "foo");
+    });
+    it("invalid literal errors", () => {
+        //@ts-expect-error
+        encodeFailTest(st.pipe(st.u8(), st.literal(0)), 2);
+        //@ts-expect-error
+        encodeFailTest(st.pipe(st.string(st.u8()), st.literal("A")), "B");
+    });
+    () => {
+        //@ts-expect-error, invalid union variant
+        st.write(st.pipe(st.u8(), st.literal(0)), 1);
+        //@ts-expect-error, invalid union variant
+        st.write(st.pipe(st.u8(), st.literal("foo")), "bar");
+    };
+});

package/dist/transforms/modify.d.ts

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

package/dist/transforms/modify.js

@@ -0,0 +1,7 @@
+export function modify(callback) {
+    return (type) => ({
+        size: type.size,
+        read: (ctx) => callback(type.read(ctx)),
+        write: (ctx, value) => type.write(ctx, callback(value)),
+    });
+}

package/dist/transforms/noAdvance.d.ts

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,30 @@
+/**
+ * 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

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

package/dist/transforms/noAdvance.test.js

@@ -0,0 +1,17 @@
+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 });
+    });
+});

package/dist/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/transforms/pipe.js

@@ -0,0 +1,16 @@
+/**
+ * Pipe lets you chain modification functions together
+ * ```
+ * st.object({
+ *   age: st.u32(),
+ *   ageInMonths: st.pipe(
+ *     st.u32(),
+ *     st.modify(v => v * 12),
+ *     st.offset(-8),
+ *   )})
+ * ```
+ */
+export function pipe(type, ...pipeline) {
+    //@ts-ignore
+    return pipeline.reduce((v, func) => func(v), type);
+}

package/dist/transforms/toAscii.d.ts

@@ -0,0 +1 @@
+export declare function toAscii(): import("./pipe").Transform<string, ArrayBuffer>;

package/dist/transforms/toAscii.js

@@ -0,0 +1,11 @@
+import { encode } from "./encode";
+export function toAscii() {
+    return encode((v) => new Uint8Array(Array.from(v).map((char) => validateAscii(char.charCodeAt(0)))).buffer, (v) => Array.from(new Uint8Array(v))
+        .map((v) => String.fromCharCode(v))
+        .join(""));
+}
+const validateAscii = (v) => {
+    if (v >= 0 && v <= 127)
+        return v;
+    throw new Error(`Invalid value: ${v}`);
+};

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

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

package/dist/transforms/toAscii.test.js

@@ -0,0 +1,25 @@
+import { describe, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
+import * as st from "../index";
+describe("st.toAscii", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.bytes(5), st.toAscii()), //
+        "a6534");
+        encodeTest(st.pipe(st.bytes(3), st.toAscii()), //
+        "-as");
+    });
+    it("invalid length throws error", () => {
+        encodeFailTest(st.pipe(st.bytes(4), st.toAscii()), //
+        "asd");
+    });
+    it("invalid character throws error", () => {
+        encodeFailTest(st.pipe(st.bytes(4), st.toAscii()), //
+        "asdé");
+    });
+    it("snapshots", () => {
+        encodeSnapshotTest(st.pipe(st.bytes(4), st.toAscii()), //
+        "634f");
+        encodeSnapshotTest(st.pipe(st.bytes(6), st.toAscii()), //
+        "hdjdp_");
+    });
+});

package/dist/transforms/toBase64.d.ts

@@ -0,0 +1 @@
+export declare function toBase64(): import("./pipe").Transform<string, ArrayBuffer>;

package/dist/transforms/toBase64.js

@@ -0,0 +1,4 @@
+import { encode } from "./encode";
+export function toBase64() {
+    return encode((v) => Uint8Array.fromBase64(v).buffer, (v) => new Uint8Array(v).toBase64());
+}

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

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

package/dist/transforms/toBase64.test.js

@@ -0,0 +1,27 @@
+import { describe, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
+import * as st from "../index";
+describe("st.toBase64", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.bytes(1), st.toBase64()), //
+        "rw==");
+        encodeTest(st.pipe(st.bytes(2), st.toBase64()), //
+        "rx8=");
+        encodeTest(st.pipe(st.bytes(3), st.toBase64()), //
+        "rx9K");
+    });
+    it("invalid character error", () => {
+        encodeFailTest(st.pipe(st.bytes(3), st.toBase64()), //
+        "rx9-");
+    });
+    it("invalid length error", () => {
+        encodeFailTest(st.pipe(st.bytes(4), st.toBase64()), //
+        "rx9L");
+    });
+    it("snapshots", () => {
+        encodeSnapshotTest(st.pipe(st.bytes(3), st.toBase64()), //
+        "rx9K");
+        encodeSnapshotTest(st.pipe(st.bytes(6), st.toBase64()), //
+        "fR9KIj8V");
+    });
+});

package/dist/transforms/toBytes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts an ArrayBuffer to the byte digits
+ *
+ * ```ts
+ * st.pipe(
+ *     st.bytes(3),
+ *     st.toBytes()
+ * )
+ * ```
+ *
+ * `ArrayBuffer([0, 255, c])` => `[0, 255, ArrayBuffer([0, 255, 0])]`
+ */
+export declare function toBytes(): import("./pipe").Transform<number[], ArrayBuffer>;

package/dist/transforms/toBytes.js

@@ -0,0 +1,21 @@
+import { encode } from "./encode";
+/**
+ * Converts an ArrayBuffer to the byte digits
+ *
+ * ```ts
+ * st.pipe(
+ *     st.bytes(3),
+ *     st.toBytes()
+ * )
+ * ```
+ *
+ * `ArrayBuffer([0, 255, c])` => `[0, 255, ArrayBuffer([0, 255, 0])]`
+ */
+export function toBytes() {
+    return encode((v) => new Uint8Array(v.map(validateByte)).buffer, (v) => Array.from(new Uint8Array(v)));
+}
+const validateByte = (v) => {
+    if (v >= 0 && v <= 255)
+        return v;
+    throw new Error(`Invalid value: ${v}`);
+};

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

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

package/dist/transforms/toBytes.test.js

@@ -0,0 +1,27 @@
+import { describe, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
+import * as st from "../index";
+describe("st.toBytes", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [0, 1, 2]);
+        encodeTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [255, 0, 127]);
+    });
+    it("invalid length throws error", () => {
+        encodeFailTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [0, 1]);
+    });
+    it("invalid values throws error", () => {
+        encodeFailTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [256, 1, 1]);
+        encodeFailTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [-1, 1, 1]);
+    });
+    it("snapshots", () => {
+        encodeSnapshotTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [73, 12, 3]);
+        encodeSnapshotTest(st.pipe(st.bytes(6), st.toBytes()), //
+        [34, 10, 0, 74, 31, 23]);
+    });
+});

package/dist/transforms/toHex.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts an ArrayBuffer to uppercase hex
+ *
+ * ```ts
+ * st.pipe(
+ *     st.bytes(3),
+ *     st.toHex()
+ * )
+ * ```
+ *
+ * `ArrayBuffer([0, 255, 0])` => `00FF00`
+ */
+export declare function toHex(): import("./pipe").Transform<string, ArrayBuffer>;

package/dist/transforms/toHex.js

@@ -0,0 +1,16 @@
+import { encode } from "./encode";
+/**
+ * Converts an ArrayBuffer to uppercase hex
+ *
+ * ```ts
+ * st.pipe(
+ *     st.bytes(3),
+ *     st.toHex()
+ * )
+ * ```
+ *
+ * `ArrayBuffer([0, 255, 0])` => `00FF00`
+ */
+export function toHex() {
+    return encode((v) => Uint8Array.fromHex(v).buffer, (v) => new Uint8Array(v).toHex().toUpperCase());
+}

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

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

package/dist/transforms/toHex.test.js

@@ -0,0 +1,23 @@
+import { describe, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
+import * as st from "../index";
+describe("st.toHex", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.bytes(3), st.toHex()), //
+        "FFAB01");
+    });
+    it("invalid digits error", () => {
+        encodeFailTest(st.pipe(st.bytes(3), st.toHex()), //
+        "00000G");
+    });
+    it("invalid length error", () => {
+        encodeFailTest(st.pipe(st.bytes(3), st.toHex()), //
+        "0000");
+    });
+    it("snapshots", () => {
+        encodeSnapshotTest(st.pipe(st.bytes(3), st.toHex()), //
+        "FFAB01");
+        encodeSnapshotTest(st.pipe(st.bytes(5), st.toHex()), //
+        "0000000000");
+    });
+});