@nnilky/structo 1.0.3 → 1.0.5

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

@@ -1,71 +1,73 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import { expectEncode, expectEncodeSnapshot, expectError, randint } from "../utils.test";
+import { expectEncode, expectEncodeSize, } from "../utils.test";
 import * as st from "../../index";
-function test_sint(options) {
-    const { name, range: [start, end], serializer, size, } = options;
+function test_float(options) {
+    const { name, serializer, size } = options;
+    const expectEncodeApproximately = (value) => {
+        const data = st.write(serializer, value);
+        const newValue = st.read(serializer, data);
+        if (isNaN(value) && isNaN(newValue))
+            return;
+        if (value === newValue)
+            return;
+        if (Math.abs(value - newValue) < 0.000001)
+            return;
+        expect(false, "Failed comparsion tests");
+    };
     describe(name, () => {
         it(`works in bounds`, () => {
-            expectEncode(serializer, start);
             for (let i = 0; i < 100; i++) {
-                expectEncode(serializer, randint(start, end));
+                expectEncodeApproximately(Math.random());
             }
-            expectEncode(serializer, end);
         });
-        it(`errors outside bounds`, () => {
-            expectError(() => st.write(serializer, start - 1));
-            expectError(() => st.write(serializer, end + 1));
+        it(`works on Infinty`, () => {
+            expectEncode(serializer, Infinity);
+            expectEncode(serializer, -Infinity);
         });
-        it(`errors on decimal`, () => {
-            expectError(() => st.write(serializer, 0.1));
+        it(`works on NaN`, () => {
+            expectEncode(serializer, NaN);
+        });
+        it(`works on 0`, () => {
+            expectEncode(serializer, 0);
+        });
+        it(`works on -0`, () => {
+            expectEncode(serializer, -0);
         });
         it(`is right size`, () => {
-            const expectValueSize = (value) => {
-                const data = st.write(serializer, value);
-                expect(data.byteLength).toBe(size);
-            };
             for (let i = 0; i < 100; i++) {
-                expectValueSize(randint(start, end));
+                expectEncodeSize(serializer, size, Math.random());
             }
-            expectValueSize(start);
-            expectValueSize(end);
-        });
-        it(`matches snapshots`, () => {
-            expectEncodeSnapshot(serializer, 0);
-            expectEncodeSnapshot(serializer, start);
-            expectEncodeSnapshot(serializer, start + 10);
-            expectEncodeSnapshot(serializer, end - 10);
-            expectEncodeSnapshot(serializer, end);
         });
     });
 }
-test_sint({
-    name: "st.s8",
-    serializer: st.s8(),
-    range: [-128, 127],
-    size: 1,
-});
-test_sint({
-    name: "st.s16(little)",
-    serializer: st.s16("little"),
-    range: [-32_768, 32_767],
+test_float({
+    name: "st.f16(little)",
+    serializer: st.f16("little"),
     size: 2,
 });
-test_sint({
-    name: "st.s16(big)",
-    serializer: st.s16("big"),
-    range: [-32_768, 32_767],
+test_float({
+    name: "st.f16(big)",
+    serializer: st.f16("big"),
     size: 2,
 });
-test_sint({
-    name: "st.s32(little)",
-    serializer: st.s32("little"),
-    range: [-2_147_483_648, 2_147_483_647],
+test_float({
+    name: "st.f32(little)",
+    serializer: st.f32("little"),
     size: 4,
 });
-test_sint({
-    name: "st.s32(big)",
-    serializer: st.s32("big"),
-    range: [-2_147_483_648, 2_147_483_647],
+test_float({
+    name: "st.f32(big)",
+    serializer: st.f32("big"),
     size: 4,
 });
+test_float({
+    name: "st.f64(little)",
+    serializer: st.f64("little"),
+    size: 8,
+});
+test_float({
+    name: "st.f64(big)",
+    serializer: st.f64("big"),
+    size: 8,
+});

package/dist/datatypes/numbers/sints.d.ts

@@ -1,5 +1,9 @@
 import type { Serializer } from "../../types";
+/** 8bit signed integer */
 export declare function s8(): Serializer<number>;
+/** 16bit signed integer */
 export declare function s16(endian?: "little" | "big"): Serializer<number>;
+/** 32bit signed integer */
 export declare function s32(endian?: "little" | "big"): Serializer<number>;
+/** 64bit signed integer */
 export declare function s64(endian?: "little" | "big"): Serializer<number>;

package/dist/datatypes/numbers/sints.js

@@ -6,6 +6,7 @@ const checkValue = (value, start, end) => {
         throw new Error("Out of Range");
     }
 };
+/** 8bit signed integer */
 export function s8() {
     return {
         size: 1,
@@ -22,6 +23,7 @@ export function s8() {
         },
     };
 }
+/** 16bit signed integer */
 export function s16(endian = "little") {
     return {
         size: 2,
@@ -38,6 +40,7 @@ export function s16(endian = "little") {
         },
     };
 }
+/** 32bit signed integer */
 export function s32(endian = "little") {
     return {
         size: 4,
@@ -54,6 +57,7 @@ export function s32(endian = "little") {
         },
     };
 }
+/** 64bit signed integer */
 export function s64(endian = "little") {
     return {
         size: 8,

package/dist/datatypes/numbers/uints.d.ts

@@ -1,5 +1,9 @@
 import type { Serializer } from "../../types";
+/** 8bit unsigned integer */
 export declare function u8(): Serializer<number>;
+/** 16bit unsigned integer */
 export declare function u16(endian?: "little" | "big"): Serializer<number>;
+/** 32bit unsigned integer */
 export declare function u32(endian?: "little" | "big"): Serializer<number>;
+/** 64bit unsigned integer */
 export declare function u64(endian?: "little" | "big"): Serializer<number>;

package/dist/datatypes/numbers/uints.js

@@ -1,3 +1,4 @@
+/** 8bit unsigned integer */
 export function u8() {
     return {
         size: 1,
@@ -17,6 +18,7 @@ export function u8() {
         },
     };
 }
+/** 16bit unsigned integer */
 export function u16(endian = "little") {
     return {
         size: 2,
@@ -36,6 +38,7 @@ export function u16(endian = "little") {
         },
     };
 }
+/** 32bit unsigned integer */
 export function u32(endian = "little") {
     return {
         size: 4,
@@ -55,6 +58,7 @@ export function u32(endian = "little") {
         },
     };
 }
+/** 64bit unsigned integer */
 export function u64(endian = "little") {
     return {
         size: 8,

package/dist/datatypes/transforms/encode.d.ts

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

package/dist/datatypes/transforms/encode.js

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

package/dist/datatypes/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/datatypes/transforms/{readOffset.js → fixedOffset.js}

@@ -1,4 +1,4 @@
-export function positionOffset(delta) {
+export function fixedOffset(delta) {
     return (type) => ({
         size: type.size,
         read: (ctx) => {

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

@@ -1,3 +1,15 @@
+/**
+ * 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/datatypes/utilities/remember.d.ts

@@ -1,5 +1,15 @@
 import type { Serializer } from "../../types";
+/**
+ * ```
+ * const length = st.createRememberedValue<number>()
+ * st.object({
+ *   length: length.save(st.u32()),
+ *   type: st.u8(),
+ *   data: st.sizedBytes(length.load())
+ * })
+ * ```
+ */
 export declare function createRememberedValue<T>(): {
     save: (serializer: Serializer<T>) => Serializer<T>;
-    load: () => Serializer<T>;
+    load: (serializer?: Serializer<T>) => Serializer<T>;
 };

package/dist/datatypes/utilities/remember.js

@@ -1,6 +1,16 @@
+/**
+ * ```
+ * const length = st.createRememberedValue<number>()
+ * st.object({
+ *   length: length.save(st.u32()),
+ *   type: st.u8(),
+ *   data: st.sizedBytes(length.load())
+ * })
+ * ```
+ */
 export function createRememberedValue() {
     const stack = [];
-    function store(serializer) {
+    function save(serializer) {
         return {
             size: serializer.size,
             read: (ctx) => {
@@ -15,12 +25,12 @@ export function createRememberedValue() {
             },
         };
     }
-    function load() {
+    function load(serializer) {
         return {
-            size: 0,
+            size: serializer?.size ?? 0,
             read: () => stack.pop(),
-            write: () => { },
+            write: (ctx) => serializer && serializer.write(ctx, stack.pop()),
         };
     }
-    return { save: store, load: load };
+    return { save: save, load: load };
 }

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

@@ -0,0 +1,44 @@
+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,7 +1,8 @@
 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: <T>(serializer: st.Serializer<T>, value: T) => void;
+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

@@ -10,10 +10,14 @@ export const randbigint = (start, end) => {
     const offset = BigInt(Math.floor(Number(range) * Math.random()));
     return start + offset;
 };
-export const expectEncode = (serializer, value) => {
+export const expectEncode = (serializer, value, expected) => {
     const data = st.write(serializer, value);
     const newValue = st.read(serializer, data);
-    expect(value).toEqual(newValue);
+    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);

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

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

package/dist/datatypes/values/byteliteral.js

@@ -1,4 +1,4 @@
-export function byteLiteral(bytes) {
+export function bytesLiteral(bytes) {
     const length = bytes.length;
     return {
         size: bytes.length,

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

@@ -0,0 +1,9 @@
+import type { Serializer } from "../../types";
+/**
+ * Fixed length bytes
+ *
+ * ```
+ * st.bytes(4)
+ * ```
+ */
+export declare function bytes(size: number): Serializer<ArrayBuffer>;

package/dist/datatypes/values/{buffer.js → bytes.js}

@@ -1,4 +1,11 @@
-export function buffer(size) {
+/**
+ * Fixed length bytes
+ *
+ * ```
+ * st.bytes(4)
+ * ```
+ */
+export function bytes(size) {
     return {
         size,
         write: (ctx, value) => {

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

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

package/dist/datatypes/values/{buffer.test.js → bytes.test.js}

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

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/read.d.ts

@@ -1,5 +1,5 @@
 import type { Serializer } from "./types";
-export declare function read<T>(serializer: Serializer<T>, buffer: ArrayBuffer): T;
+export declare function read<TIn, TOut>(serializer: Serializer<TIn, TOut>, buffer: ArrayBuffer): TOut;
 export declare function createReaderContext(buffer: ArrayBuffer): {
     offset: number;
     buffer: ArrayBuffer;

package/dist/write.d.ts

@@ -1,3 +1,3 @@
 import type { WriterContext, Serializer } from "./types";
-export declare function write<T>(serializer: Serializer<T>, value: T): ArrayBuffer;
+export declare function write<TIn, TOut>(serializer: Serializer<TIn, TOut>, value: TIn): ArrayBuffer;
 export declare function createdWriterContext(type: Serializer<any>): WriterContext;

package/dist/write.js

@@ -20,8 +20,8 @@ export function createdWriterContext(type) {
         };
     }
     else {
-        let bufferLength = 128;
-        let buffer = new ArrayBuffer(bufferLength, { maxByteLength: 1024 });
+        let bufferLength = 64;
+        let buffer = new ArrayBuffer(bufferLength);
         const view = new DataView(buffer);
         return {
             offset: 0,
@@ -30,11 +30,9 @@ export function createdWriterContext(type) {
             alloc(length) {
                 if (length < 0)
                     return;
-                if (buffer.resizable) {
-                }
-                while (this.offset + length > bufferLength) {
-                    bufferLength = bufferLength * 2;
-                    this.buffer.resize(bufferLength);
+                while (this.offset + length >= bufferLength) {
+                    bufferLength = this.buffer.byteLength * 2;
+                    this.buffer = this.buffer.transfer(bufferLength);
                     this.view = new DataView(this.buffer);
                 }
             },

package/package.json

@@ -3,7 +3,7 @@
   "description": "A library for serializing and deserializing binary content",
   "keywords": ["binary", "library", "utility", "web", "node"],
   "license": "ISC",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "author": "Ben Brady",
   "private": false,
   "publishConfig": {"access": "public"},

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

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

package/dist/datatypes/transforms/pipe.test.js

@@ -1,13 +0,0 @@
-import { describe, it } from "bun:test";
-import { bytes, expectEncode } from "../utils.test";
-import * as st from "../../index";
-describe("st.pipe", () => {
-    it("applies correctly", () => {
-        const buffer = st.sizedBuffer(st.u8());
-        expectEncode(buffer, bytes([1, 2]));
-    });
-    it("runs in correct order", () => {
-        const spec = st.sizedBuffer(st.u8());
-        expectEncode(spec, bytes([]));
-    });
-});

package/dist/datatypes/transforms/readOffset.d.ts

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

package/dist/datatypes/transforms/transform.d.ts

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

package/dist/datatypes/transforms/transform.js

@@ -1,13 +0,0 @@
-export function transform(callback) {
-    return (type) => ({
-        size: type.size,
-        read: (ctx) => {
-            const value = type.read(ctx);
-            return callback(value);
-        },
-        write: (ctx, value) => {
-            let outValue = callback(value);
-            type.write(ctx, outValue);
-        },
-    });
-}

package/dist/datatypes/utilities/constant.d.ts

@@ -1,2 +0,0 @@
-import type { Serializer } from "../../types";
-export declare function constant<T>(type: Serializer<T>, value: T): Serializer<any, T>;

package/dist/datatypes/utilities/constant.js

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

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

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