@nnilky/structo 1.0.5 → 1.0.7

package/dist/datatypes/containers/array.test.js

@@ -1,22 +1,18 @@
 import { describe, it } from "bun:test";
-import { expectEncode, expectError } from "../utils.test";
+import { encodeTest, encodeFailTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.array", () => {
     it("encode correctly", () => {
-        const spec = st.array(4, st.u16());
-        expectEncode(spec, [1, 2, 3, 4]);
+        encodeTest(st.array(4, st.u16()), [1, 2, 3, 4]);
     });
     it("works on empty lists", () => {
-        const spec = st.array(0, st.u16());
-        expectEncode(spec, []);
+        encodeTest(st.array(0, st.u16()), []);
     });
     it("throws error on invalid size", () => {
-        const spec = st.array(2, st.u16());
-        expectError(() => st.write(spec, [1]));
+        encodeFailTest(st.array(2, st.u16()), [1]);
     });
     it("throws error on invalid value", () => {
-        const spec = st.array(2, st.u16());
-        expectError(() => st.write(spec, [1, -1]));
-        expectError(() => st.write(spec, [2 ** 16 + 1, 0]));
+        encodeFailTest(st.array(2, st.u16()), [1, -1]);
+        encodeFailTest(st.array(2, st.u16()), [2 ** 16 + 1, 0]);
     });
 });

package/dist/datatypes/containers/exhuastiveArray.test.js

@@ -1,18 +1,18 @@
 import { describe, it } from "bun:test";
-import { expectEncode, expectEncodeSnapshot, expectError } from "../utils.test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.exhuastiveArray", () => {
     it("encode correctly", () => {
         const spec = st.exhuastiveArray(st.u32());
-        expectEncode(spec, [1, 2, 3, 4]);
+        encodeTest(spec, [1, 2, 3, 4]);
     });
     it("works on empty arrays", () => {
         const spec = st.exhuastiveArray(st.u32());
-        expectEncode(spec, []);
+        encodeTest(spec, []);
     });
     it("accepts large array", () => {
         const spec = st.exhuastiveArray(st.u32());
-        expectEncode(spec, Array.from({ length: 10000 }, (_, i) => i));
+        encodeTest(spec, Array.from({ length: 10000 }, (_, i) => i));
     });
     it("works composed", () => {
         const spec = st.object({
@@ -20,22 +20,19 @@ describe("st.exhuastiveArray", () => {
             b: st.u8(),
             c: st.exhuastiveArray(st.u32()),
         });
-        expectEncode(spec, { a: 1, b: 2, c: [3, 4, 5, 6, 7] });
+        encodeTest(spec, { a: 1, b: 2, c: [3, 4, 5, 6, 7] });
     });
     it("throws error on invalid value", () => {
-        const spec = st.exhuastiveArray(st.u16());
-        expectError(() => {
-            st.write(spec, [-1]);
-        });
+        encodeFailTest(st.exhuastiveArray(st.u16()), [-1]);
     });
     it("nested arrays encode correctly", () => {
-        expectEncode(st.exhuastiveArray(st.exhuastiveArray(st.u16())), //
+        encodeTest(st.exhuastiveArray(st.exhuastiveArray(st.u16())), //
         [[1, 2]]);
     });
     it(`matches snapshots`, () => {
-        expectEncodeSnapshot(st.exhuastiveArray(st.string(st.u16())), //
+        encodeSnapshotTest(st.exhuastiveArray(st.string(st.u16())), //
         ["foo", "bar", "baz"]);
-        expectEncodeSnapshot(st.exhuastiveArray(st.u8()), //
+        encodeSnapshotTest(st.exhuastiveArray(st.u8()), //
         [0, 1, 2, 3]);
     });
 });

package/dist/datatypes/containers/fastObject.d.ts

@@ -14,6 +14,8 @@ type InferObject<T> = T extends Record<string, Serializer<any>> ? {
  *     createdAt: st.f64(),
  * })
  * ```
+ *
+ * Note: Using st.lazy affects the performance of fastObject as it prevents discovery of subobjects, avoid when performance is a requirement
  */
 export declare function fastObject<T extends Record<string, Serializer<any>>>(definition: T): Serializer<InferObject<T>>;
 export {};

package/dist/datatypes/containers/fastObject.js

@@ -11,6 +11,8 @@ const definitionSymbol = Symbol();
  *     createdAt: st.f64(),
  * })
  * ```
+ *
+ * Note: Using st.lazy affects the performance of fastObject as it prevents discovery of subobjects, avoid when performance is a requirement
  */
 export function fastObject(definition) {
     let serializers = [];

package/dist/datatypes/containers/fastObject.test.js

@@ -1,26 +1,38 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import { bytes, expectEncode, expectEncodeSnapshot } from "../utils.test";
+import { bytes, encodeTest, encodeSnapshotTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.fastObject", () => {
-    const test = st.fastObject({
+    const spec = st.fastObject({
         a: st.u8(),
         b: st.u8(),
     });
     it("encodes correctly", () => {
-        st.write(test, { b: 2, a: 1 });
+        st.write(spec, { b: 2, a: 1 });
+    });
+    it("encodes nest correctly", () => {
+        st.write(st.fastObject({
+            a: st.fastObject({
+                cat: st.u8(),
+                puppy: st.string(st.u8()),
+            }),
+            b: st.u8(),
+        }), {
+            a: { cat: 1, puppy: "woof" },
+            b: 3,
+        });
     });
     it("encode in correct order", () => {
-        const data = st.write(test, { b: 2, a: 1 });
+        const data = st.write(spec, { b: 2, a: 1 });
         const arr = new Uint8Array(data);
         expect(arr[0]).toBe(1);
         expect(arr[1]).toBe(2);
     });
     it("encodes empty", () => {
-        expectEncode(st.fastObject({}), {});
+        encodeTest(st.fastObject({}), {});
     });
     it(`matches snapshots`, () => {
-        expectEncodeSnapshot(st.fastObject({
+        encodeSnapshotTest(st.fastObject({
             number: st.u32(),
             puppy: st.string(st.s32()),
             buffer: st.bytes(4),

package/dist/datatypes/containers/list.test.js

@@ -1,29 +1,23 @@
 import { describe, it } from "bun:test";
-import { expectEncode, expectEncodeSnapshot, expectError } from "../utils.test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.list", () => {
     it("encode correctly", () => {
         const spec = st.list(st.u8(), st.u32());
-        expectEncode(spec, [1, 2, 3, 4]);
+        encodeTest(spec, [1, 2, 3, 4]);
     });
     it("works on empty lists", () => {
         const spec = st.list(st.u8(), st.u32());
-        expectEncode(spec, []);
+        encodeTest(spec, []);
     });
     it("throws error on too large array", () => {
-        const spec = st.list(st.u8(), st.u32());
-        expectError(() => {
-            st.write(spec, Array.from({ length: 10000 }, () => 0));
-        });
+        encodeFailTest(st.list(st.u8(), st.u32()), Array.from({ length: 10000 }, () => 0));
     });
     it("throws error on invalid value", () => {
-        const spec = st.list(st.u8(), st.u16());
-        expectError(() => {
-            st.write(spec, [-1]);
-        });
+        encodeFailTest(st.list(st.u8(), st.u16()), [-1]);
     });
     it(`matches snapshots`, () => {
-        expectEncodeSnapshot(st.list(st.s32(), st.string(st.u16())), //
+        encodeSnapshotTest(st.list(st.s32(), st.string(st.u16())), //
         ["foo", "bar", "baz"]);
     });
 });

package/dist/datatypes/containers/object.js

@@ -21,7 +21,13 @@ export function object(definition) {
             if (size)
                 ctx.alloc(size);
             for (let i = 0; i < entires.length; i++) {
-                entires[i][1].write(ctx, value[entires[i][0]]);
+                const key = entires[i][0];
+                try {
+                    entires[i][1].write(ctx, value[key]);
+                }
+                catch (e) {
+                    throw new Error(`Failed to encode key '${key}'`, { cause: e });
+                }
             }
         },
         read: (ctx) => {

package/dist/datatypes/containers/object.test.js

@@ -1,26 +1,33 @@
 //@ts-ignore TODO
-import { describe, it, expect } from "bun:test";
-import { bytes, expectEncode, expectEncodeSnapshot } from "../utils.test";
+import { describe, it, expect, expectTypeOf } from "bun:test";
+import { bytes, encodeTest, encodeSnapshotTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.object", () => {
-    const test = st.object({
-        a: st.u8(),
-        b: st.u8(),
-    });
     it("encodes correctly", () => {
-        st.write(test, { b: 2, a: 1 });
+        encodeTest(st.object({ a: st.u8(), b: st.u8() }), //
+        { b: 2, a: 1 });
+    });
+    it("encodes nested correctly", () => {
+        encodeTest(st.object({
+            a: st.object({ a: st.u8() }),
+            b: st.u8(),
+        }), //
+        { a: { a: 2 }, b: 1 });
     });
     it("encode in correct order", () => {
-        const data = st.write(test, { b: 2, a: 1 });
+        const data = st.write(st.object({
+            a: st.u8(),
+            b: st.u8(),
+        }), { b: 2, a: 1 });
         const arr = new Uint8Array(data);
         expect(arr[0]).toBe(1);
         expect(arr[1]).toBe(2);
     });
     it("encodes empty", () => {
-        expectEncode(st.object({}), {});
+        encodeTest(st.object({}), {});
     });
     it(`matches snapshots`, () => {
-        expectEncodeSnapshot(st.object({
+        encodeSnapshotTest(st.object({
             number: st.u32(),
             puppy: st.string(st.s32()),
             buffer: st.bytes(4),
@@ -30,4 +37,9 @@ describe("st.object", () => {
             buffer: bytes([19, 87, 19, 83]),
         });
     });
+    // Type Tests
+    expectTypeOf(st.object({
+        number: st.u32(),
+        string: st.string(st.u32()),
+    })).toEqualTypeOf();
 });

package/dist/datatypes/containers/taggedUnion.d.ts

@@ -11,12 +11,16 @@ import type { InferInput, InferOutput, Serializer } from "../../types";
  *     2: MouseMovePacket,
  * })
  * ```
- *
  */
-export declare function taggedUnion<TTag extends string | number, TType extends Serializer<any>>(tag: Serializer<TTag>, variants: Record<TTag, TType>): Serializer<{
-    type: TTag;
-    value: InferInput<TType>;
-}, {
-    type: TTag;
-    value: InferOutput<TType>;
-}>;
+export declare function taggedUnion<Tag extends PropertyKey, //
+Variants extends Record<Tag, Serializer<any>>>(tag: Serializer<Tag>, variants: Variants & Record<Exclude<keyof Variants, Tag>, never>): Serializer<{
+    [K in keyof Variants]: {
+        type: K;
+        value: InferInput<Variants[K]>;
+    };
+}[keyof Variants], {
+    [K in keyof Variants]: {
+        type: K;
+        value: InferOutput<Variants[K]>;
+    };
+}[keyof Variants]>;

package/dist/datatypes/containers/taggedUnion.js

@@ -10,15 +10,16 @@
  *     2: MouseMovePacket,
  * })
  * ```
- *
  */
 export function taggedUnion(tag, variants) {
     return {
         write: (ctx, value) => {
             if (!(value.type in variants))
-                throw new Error(`Unknown type ${value.type}`);
+                throw new Error(`Unknown type ${String(value.type)}`);
+            //@ts-expect-error
             tag.write(ctx, value.type);
             const variant = variants[value.type];
+            //@ts-expect-error
             variant.write(ctx, value.value);
         },
         read: (ctx) => {
@@ -26,6 +27,7 @@ export function taggedUnion(tag, variants) {
             if (!(type in variants))
                 throw new Error(`Unknown type ${tag}`);
             const variant = variants[type];
+            //@ts-expect-error
             const value = variant.read(ctx);
             return { type, value };
         },

package/dist/datatypes/containers/taggedUnion.test.js

@@ -1,5 +1,5 @@
-import { describe, it } from "bun:test";
-import { expectEncode, expectEncodeSize, expectEncodeSnapshot, expectError } from "../utils.test";
+import { describe, expectTypeOf, it } from "bun:test";
+import { encodeTest, expectEncodeSize, encodeSnapshotTest, encodeFailTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.taggedUnion", () => {
     it("encode correctly", () => {
@@ -7,57 +7,61 @@ describe("st.taggedUnion", () => {
             1: st.string(st.u8()),
             2: st.u8(),
         });
-        expectEncode(spec, { type: 1, value: "s" });
-        expectEncode(spec, { type: 2, value: 52 });
+        encodeTest(spec, { type: 1, value: "s" });
+        encodeTest(spec, { type: 2, value: 52 });
     });
     it("encode with string tag", () => {
         const spec = st.taggedUnion(st.string(st.u8()), {
             foo: st.string(st.u8()),
             bar: st.u8(),
         });
-        expectEncode(spec, { type: "foo", value: "woof" });
-        expectEncode(spec, { type: "bar", value: 52 });
+        encodeTest(spec, { type: "foo", value: "woof" });
+        encodeTest(spec, { type: "bar", value: 52 });
     });
     it("throws error on invalid tag", () => {
         const spec = st.taggedUnion(st.string(st.u8()), {
             foo: st.string(st.u8()),
             bar: st.u8(),
         });
-        expectError(() => {
-            st.write(spec, { type: "unknown", value: "woof" });
-        });
+        //@ts-expect-error, intended
+        encodeFailTest(spec, { type: "unknown", value: "woof" });
     });
     it("throws error on invalid type", () => {
         const spec = st.taggedUnion(st.string(st.u8()), {
             foo: st.string(st.u8()),
             bar: st.u8(),
         });
-        expectError(() => {
-            st.write(spec, { type: "unknown", value: "woof" });
-        });
+        //@ts-expect-error, intended
+        encodeFailTest(spec, { type: "unknown", value: "woof" });
     });
     it("throws error on invalid value", () => {
         const spec = st.taggedUnion(st.string(st.u8()), {
             foo: st.string(st.u8()),
         });
-        expectError(() => {
-            //@ts-expect-error
-            st.write(spec, { type: "foo", value: 0 });
-        });
+        //@ts-expect-error, intended
+        encodeFailTest(spec, { type: "foo", value: 0 });
     });
     it("encodes varying sizes", () => {
         const spec = st.taggedUnion(st.u8(), {
             1: st.string(st.u8()),
             2: st.u8(),
         });
-        expectEncode(spec, { type: 1, value: "s" });
+        encodeTest(spec, { type: 1, value: "s" });
         expectEncodeSize(spec, 5, { type: 1, value: "foo" });
         expectEncodeSize(spec, 2, { type: 2, value: 52 });
     });
     it("encodes snapshots", () => {
-        expectEncodeSnapshot(st.taggedUnion(st.u32(), {
+        encodeSnapshotTest(st.taggedUnion(st.u32(), {
             0: st.list(st.u8(), st.f64()),
             3: st.u32(),
         }), { type: 0, value: [1] });
     });
+    expectTypeOf(st.taggedUnion(st.u32(), {
+        0: st.u8(),
+        1: st.string(st.u32()),
+    })).toEqualTypeOf();
+    () => {
+        //@ts-expect-error, must be same type as tags
+        st.taggedUnion(st.string(st.u8()), { 0: st.u8(), 1: st.string(st.u32()) });
+    };
 });

package/dist/datatypes/index.d.ts

@@ -6,15 +6,8 @@ export { array } from "./containers/array";
 export { fastObject } from "./containers/fastObject";
 export { object } from "./containers/object";
 export { list } from "./containers/list";
-export { sizedBytes } from "./containers/sizedbytes";
 export { taggedUnion } from "./containers/taggedUnion";
 export { exhuastiveArray } from "./containers/exhuastiveArray";
-export { string } from "./containers/string";
 export { bytes } from "./values/bytes";
-export { bytesLiteral } from "./values/byteliteral";
-export { type Transform as Pipeline, pipe } from "./transforms/pipe";
-export { fixedOffset } from "./transforms/fixedOffset";
-export { modify } from "./transforms/modify";
-export { encode } from "./transforms/encode";
-export { noAdvance } from "./transforms/noAdvance";
-export { createRememberedValue } from "./utilities/remember";
+export { sizedBytes } from "./values/sizedbytes";
+export { string } from "./values/string";

package/dist/datatypes/index.js

@@ -6,15 +6,8 @@ export { array } from "./containers/array";
 export { fastObject } from "./containers/fastObject";
 export { object } from "./containers/object";
 export { list } from "./containers/list";
-export { sizedBytes } from "./containers/sizedbytes";
 export { taggedUnion } from "./containers/taggedUnion";
 export { exhuastiveArray } from "./containers/exhuastiveArray";
-export { string } from "./containers/string";
 export { bytes } from "./values/bytes";
-export { bytesLiteral } from "./values/byteliteral";
-export { pipe } from "./transforms/pipe";
-export { fixedOffset } from "./transforms/fixedOffset";
-export { modify } from "./transforms/modify";
-export { encode } from "./transforms/encode";
-export { noAdvance } from "./transforms/noAdvance";
-export { createRememberedValue } from "./utilities/remember";
+export { sizedBytes } from "./values/sizedbytes";
+export { string } from "./values/string";

package/dist/datatypes/numbers/bigints.test.js

@@ -1,19 +1,19 @@
 import { describe, it, expect } from "bun:test";
-import { expectEncode, expectEncodeSnapshot, expectError, randbigint } from "../utils.test";
+import { encodeTest, encodeSnapshotTest, randbigint, encodeFailTest } from "../../utils.test";
 import * as st from "../../index";
 function test_bigint(options) {
     const { name, range: [start, end], serializer, size, } = options;
     describe(name, () => {
         it("works in bounds", () => {
-            expectEncode(serializer, start);
+            encodeTest(serializer, start);
             for (let i = 0; i < 100; i++) {
-                expectEncode(serializer, randbigint(start, end));
+                encodeTest(serializer, randbigint(start, end));
             }
-            expectEncode(serializer, end);
+            encodeTest(serializer, end);
         });
         it("outside bounds", () => {
-            expectError(() => st.write(serializer, start - 1n));
-            expectError(() => st.write(serializer, end + 1n));
+            encodeFailTest(serializer, start - 1n);
+            encodeFailTest(serializer, end + 1n);
         });
         it(`is right size`, () => {
             const expectValueSize = (value) => {
@@ -27,11 +27,11 @@ function test_bigint(options) {
             expectValueSize(end);
         });
         it(`matches snapshots`, () => {
-            expectEncodeSnapshot(serializer, 0n);
-            expectEncodeSnapshot(serializer, start);
-            expectEncodeSnapshot(serializer, start + 10n);
-            expectEncodeSnapshot(serializer, end - 10n);
-            expectEncodeSnapshot(serializer, end);
+            encodeSnapshotTest(serializer, 0n);
+            encodeSnapshotTest(serializer, start);
+            encodeSnapshotTest(serializer, start + 10n);
+            encodeSnapshotTest(serializer, end - 10n);
+            encodeSnapshotTest(serializer, end);
         });
     });
 }

package/dist/datatypes/numbers/floats.test.js

@@ -1,6 +1,6 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import { expectEncode, expectEncodeSize, } from "../utils.test";
+import { encodeTest, expectEncodeSize } from "../../utils.test";
 import * as st from "../../index";
 function test_float(options) {
     const { name, serializer, size } = options;
@@ -22,17 +22,17 @@ function test_float(options) {
             }
         });
         it(`works on Infinty`, () => {
-            expectEncode(serializer, Infinity);
-            expectEncode(serializer, -Infinity);
+            encodeTest(serializer, Infinity);
+            encodeTest(serializer, -Infinity);
         });
         it(`works on NaN`, () => {
-            expectEncode(serializer, NaN);
+            encodeTest(serializer, NaN);
         });
         it(`works on 0`, () => {
-            expectEncode(serializer, 0);
+            encodeTest(serializer, 0);
         });
         it(`works on -0`, () => {
-            expectEncode(serializer, -0);
+            encodeTest(serializer, -0);
         });
         it(`is right size`, () => {
             for (let i = 0; i < 100; i++) {

package/dist/datatypes/numbers/sints.test.js

@@ -1,21 +1,21 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import { expectEncode, expectEncodeSnapshot, expectError, randint } from "../utils.test";
+import { encodeTest, encodeSnapshotTest, expectError, randint, encodeFailTest, } from "../../utils.test";
 import * as st from "../../index";
 function test_sint(options) {
     const { name, range: [start, end], serializer, size, disableRangeCheck, } = options;
     describe(name, () => {
         it(`works in bounds`, () => {
-            expectEncode(serializer, start);
+            encodeTest(serializer, start);
             for (let i = 0; i < 100; i++) {
-                expectEncode(serializer, randint(start, end));
+                encodeTest(serializer, randint(start, end));
             }
-            expectEncode(serializer, end);
+            encodeTest(serializer, end);
         });
         if (!disableRangeCheck) {
             it(`errors outside bounds`, () => {
-                expectError(() => st.write(serializer, start - 1));
-                expectError(() => st.write(serializer, end + 1));
+                encodeFailTest(serializer, start - 1);
+                encodeFailTest(serializer, end + 1);
             });
         }
         it(`errors on decimal`, () => {
@@ -33,11 +33,11 @@ function test_sint(options) {
             expectValueSize(end);
         });
         it(`matches snapshots`, () => {
-            expectEncodeSnapshot(serializer, 0);
-            expectEncodeSnapshot(serializer, start);
-            expectEncodeSnapshot(serializer, start + 10);
-            expectEncodeSnapshot(serializer, end - 10);
-            expectEncodeSnapshot(serializer, end);
+            encodeSnapshotTest(serializer, 0);
+            encodeSnapshotTest(serializer, start);
+            encodeSnapshotTest(serializer, start + 10);
+            encodeSnapshotTest(serializer, end - 10);
+            encodeSnapshotTest(serializer, end);
         });
     });
 }

package/dist/datatypes/numbers/uints.test.js

@@ -1,21 +1,21 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import { expectEncode, expectEncodeSnapshot, expectError, randint } from "../utils.test";
+import { encodeTest, encodeSnapshotTest, expectError, randint, encodeFailTest, } from "../../utils.test";
 import * as st from "../../index";
 function test_uint(options) {
     const { name, range: [start, end], serializer, size, disableMaxCheck, } = options;
     describe(name, () => {
         it(`works in bounds`, () => {
-            expectEncode(serializer, start);
+            encodeTest(serializer, start);
             for (let i = 0; i < 100; i++) {
-                expectEncode(serializer, randint(start, end));
+                encodeTest(serializer, randint(start, end));
             }
-            expectEncode(serializer, end);
+            encodeTest(serializer, end);
         });
         it(`errors outside bounds`, () => {
-            expectError(() => st.write(serializer, start - 1));
+            encodeFailTest(serializer, start - 1);
             if (!disableMaxCheck) {
-                expectError(() => st.write(serializer, end + 1));
+                encodeFailTest(serializer, end + 1);
             }
         });
         it(`errors on decimal`, () => {
@@ -33,11 +33,11 @@ function test_uint(options) {
             expectValueSize(end);
         });
         it(`matches snapshots`, () => {
-            expectEncodeSnapshot(serializer, 0);
-            expectEncodeSnapshot(serializer, start);
-            expectEncodeSnapshot(serializer, start + 10);
-            expectEncodeSnapshot(serializer, end - 10);
-            expectEncodeSnapshot(serializer, end);
+            encodeSnapshotTest(serializer, 0);
+            encodeSnapshotTest(serializer, start);
+            encodeSnapshotTest(serializer, start + 10);
+            encodeSnapshotTest(serializer, end - 10);
+            encodeSnapshotTest(serializer, end);
         });
     });
 }

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

@@ -1,14 +1,14 @@
 import { describe, it } from "bun:test";
-import { bytes, expectEncode, expectError } from "../utils.test";
+import { bytes, encodeFailTest, encodeTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.bytes", () => {
     const buffer = st.bytes(2);
     it("encode correctly", () => {
-        expectEncode(buffer, bytes([1, 2]));
+        encodeTest(buffer, bytes([1, 2]));
     });
     it("encodes empty correctly", () => {
         const spec = st.bytes(0);
-        expectEncode(spec, bytes([]));
+        encodeTest(spec, bytes([]));
     });
     it("holds large data", () => {
         const size = 1024 * 1024 * 8; // 8MB
@@ -16,7 +16,7 @@ describe("st.bytes", () => {
         const data = new Uint8Array(size);
         data.set([3, 4], 1000);
         data.set([3, 4], 2000);
-        expectEncode(spec, data.buffer);
+        encodeTest(spec, data.buffer);
     });
     it("large data writes work", () => {
         const size = 1024 * 1024 * 8; // 8MB
@@ -28,7 +28,7 @@ describe("st.bytes", () => {
         const data = new Uint8Array(size);
         data.set([3, 4], 1000);
         data.set([3, 4], 2000);
-        expectEncode(spec, {
+        encodeTest(spec, {
             before: 1,
             data: data.buffer,
             after: 2,
@@ -36,8 +36,6 @@ describe("st.bytes", () => {
     });
     it("errors on invalid length", () => {
         const spec = st.bytes(5);
-        expectError(() => {
-            st.write(spec, bytes([1, 2, 3, 4]));
-        });
+        encodeFailTest(spec, bytes([1, 2, 3, 4]));
     });
 });

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

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