@nnilky/structo 1.0.5 → 1.0.7

package/dist/transforms/toTypedArray.d.ts

@@ -0,0 +1,16 @@
+type TypedArray = {
+    buffer: ArrayBuffer;
+};
+type TypedArrayConstructor<T extends TypedArray> = new (array: ArrayBuffer) => T;
+/**
+ * Converts an `ArrayBuffer` to a `TypedArray`
+ *
+ * ```
+ * st.pipe(
+ *     st.bytes(16),
+ *     toTypedArray(Uint8Array),
+ * )
+ * ```
+ */
+export declare function toTypedArray<T extends TypedArray>(arrayType: TypedArrayConstructor<T>): import("./pipe").Transform<T, ArrayBuffer>;
+export {};

package/dist/transforms/toTypedArray.js

@@ -0,0 +1,14 @@
+import { encode } from "./encode";
+/**
+ * Converts an `ArrayBuffer` to a `TypedArray`
+ *
+ * ```
+ * st.pipe(
+ *     st.bytes(16),
+ *     toTypedArray(Uint8Array),
+ * )
+ * ```
+ */
+export function toTypedArray(arrayType) {
+    return encode((v) => v.buffer, (v) => new arrayType(v));
+}

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

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

package/dist/transforms/toTypedArray.test.js

@@ -0,0 +1,29 @@
+import { describe, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest, expectError } from "../utils.test";
+import * as st from "../index";
+describe("st.toArrayBuffer", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.bytes(6), //
+        st.toTypedArray(Uint8Array)), new Uint8Array([1, 2, 3, 4, 5, 6]));
+    });
+    it("encode different types correctly", () => {
+        encodeTest(st.pipe(st.bytes(3), //
+        st.toTypedArray(Uint8Array)), new Uint8Array([1, 2, 3]));
+        encodeTest(st.pipe(st.bytes(5 * 2), //
+        st.toTypedArray(Uint16Array)), new Uint16Array([1, 2, 3, 63, 74]));
+        encodeTest(st.pipe(st.bytes(3 * 8), //
+        st.toTypedArray(Float64Array)), new Float64Array([Math.random(), Math.random(), Math.random()]));
+    });
+    it("errors on different types", () => {
+        expectError(() => {
+            st.write(st.pipe(st.bytes(3), //
+            st.toTypedArray(Uint16Array)), new Uint16Array([1]));
+        });
+    });
+    it("snapshot tests", () => {
+        encodeSnapshotTest(st.pipe(st.bytes(4 * 2), //
+        st.toTypedArray(Uint16Array)), new Uint16Array([1, 6, 3, 12]));
+        encodeSnapshotTest(st.pipe(st.bytes(3 * 8), //
+        st.toTypedArray(Float64Array)), new Float64Array([1.52, 0.3523, 0.152]));
+    });
+});

package/dist/utilities/index.d.ts

@@ -0,0 +1,2 @@
+export { lazy } from "./lazy";
+export { createRememberedValue } from "./remember";

package/dist/utilities/index.js

@@ -0,0 +1,2 @@
+export { lazy } from "./lazy";
+export { createRememberedValue } from "./remember";

package/dist/utilities/lazy.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../types";
+export declare function lazy<TIn, TOut = TIn>(type: () => Serializer<TIn, TOut>): Serializer<TIn, TOut>;

package/dist/utilities/lazy.js

@@ -0,0 +1,25 @@
+export function lazy(type) {
+    let _size;
+    let resolve = () => {
+        const t = type();
+        _size = t.size ?? undefined;
+        serializer.read = t.read;
+        serializer.write = t.write;
+        resolve = () => { };
+    };
+    const serializer = {
+        get size() {
+            resolve();
+            return _size;
+        },
+        read(ctx) {
+            resolve();
+            return this.read(ctx);
+        },
+        write(ctx, value) {
+            resolve();
+            return this.write(ctx, value);
+        },
+    };
+    return serializer;
+}

package/dist/utilities/lazy.test.d.ts

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

package/dist/utilities/lazy.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "bun:test";
+import { encodeTest } from "../utils.test";
+import * as st from "../index";
+describe("st.lazy", () => {
+    it("encodes correctly", () => {
+        const spec = st.lazy(() => st.object({
+            a: st.array(4, st.u8()),
+            b: st.u16(),
+        }));
+        encodeTest(spec, {
+            a: [1, 2, 3, 4],
+            b: 2,
+        });
+    });
+    it("nested objects function", () => {
+        const spec = st.object({
+            a: st.array(4, st.u8()),
+            b: st.lazy(() => st.object({
+                a: st.lazy(() => st.u16()),
+            })),
+        });
+        encodeTest(spec, {
+            a: [1, 2, 3, 4],
+            b: { a: 1 },
+        });
+    });
+    it("size is calculated correctly", () => {
+        const spec = st.lazy(() => st.object({
+            b: st.lazy(() => st.object({
+                a: st.u32(),
+                b: st.u8(),
+            })),
+        }));
+        expect(spec.size).toBe(5);
+    });
+});

package/dist/utilities/remember.d.ts

@@ -0,0 +1,17 @@
+import type { Serializer } from "../types";
+/**
+ * createRememberedValue lets you save and recall a value when serializing
+ *
+ * ```
+ * 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?: Serializer<T>) => Serializer<T>;
+};

package/dist/utilities/remember.js

@@ -0,0 +1,38 @@
+/**
+ * createRememberedValue lets you save and recall a value when serializing
+ *
+ * ```
+ * 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 save(serializer) {
+        return {
+            size: serializer.size,
+            read: (ctx) => {
+                const value = serializer.read(ctx);
+                stack.push(value);
+                return value;
+            },
+            write: (ctx, value) => {
+                serializer.write(ctx, value);
+                stack.push(value);
+                return value;
+            },
+        };
+    }
+    function load(serializer) {
+        return {
+            size: serializer?.size ?? 0,
+            read: () => stack.pop(),
+            write: (ctx) => serializer && serializer.write(ctx, stack.pop()),
+        };
+    }
+    return { save: save, load: load };
+}

package/dist/utilities/remember.test.d.ts

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

package/dist/utilities/remember.test.js

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest } from "../utils.test";
+import * as st from "../index";
+describe("st.remember", () => {
+    it("encodes correctly", () => {
+        const v = st.createRememberedValue();
+        const spec = st.object({
+            a: v.save(st.u32()),
+            b: st.list(v.load(), st.u8()),
+        });
+        encodeTest(spec, {
+            a: 3,
+            b: [1, 3, 4],
+        });
+    });
+    it("multiple runs function", () => {
+        const v = st.createRememberedValue();
+        const spec = st.object({
+            a: v.save(st.u32()),
+            b: st.list(v.load(), st.u8()),
+        });
+        encodeTest(spec, { a: 3, b: [1, 3, 4] });
+        encodeTest(spec, { a: 3, b: [1, 3, 4] });
+        encodeTest(spec, { a: 3, b: [1, 3, 4] });
+    });
+    it("omitted serializer doesn't write data ", () => {
+        const v = st.createRememberedValue();
+        const spec = st.object({
+            a: v.save(st.u32()),
+            b: v.load(),
+        });
+        const output = st.write(spec, { a: 3, b: 0 });
+        expect(spec.size).toBe(4);
+        expect(output.byteLength).toBe(4);
+    });
+    it("serializer is used write data ", () => {
+        const v = st.createRememberedValue();
+        const spec = st.object({
+            a: v.save(st.u32()),
+            b: v.load(st.u8()),
+        });
+        encodeTest(spec, { a: 3, b: 0 }, { a: 3, b: 3 });
+    });
+    it("handles recursive objects", () => {
+        const size = st.createRememberedValue();
+        //@ts-expect-error, recursive types
+        const Node = st.lazy(() => st.object({
+            size: size.save(st.u32()),
+            children: st.list(size.load(), Node),
+        }));
+        encodeTest(Node, {
+            size: 2,
+            children: [
+                { size: 0, children: [] },
+                {
+                    size: 1,
+                    children: [{ size: 0, children: [] }],
+                },
+            ],
+        });
+    });
+    it("snapshots are correct", () => {
+        const v = st.createRememberedValue();
+        encodeSnapshotTest(st.object({
+            a: v.save(st.u32()),
+            b: st.list(v.load(), st.u8()),
+        }), {
+            a: 3,
+            b: [1, 3, 4],
+        });
+        encodeSnapshotTest(st.object({
+            a: v.save(st.u32()),
+            b: v.load(st.u8()),
+        }), { a: 3, b: 0 });
+    });
+});

package/dist/utils.test.d.ts

@@ -1 +1,9 @@
-export {};
+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 encodeTest: <TIn, TOut>(serializer: st.Serializer<TIn, TOut>, value: TIn, expected?: TOut) => void;
+export declare const encodeFailTest: <TIn, TOut>(serializer: st.Serializer<TIn, TOut>, value: TIn) => void;
+export declare const expectEncodeSize: <TIn, TOut>(serializer: st.Serializer<TIn, TOut>, size: number, value: TIn) => void;
+export declare const encodeSnapshotTest: <T>(serializer: st.Serializer<T>, value: T) => void;
+export declare const expectError: (callback: () => void) => void;
+export declare const bytes: (bytes: number[]) => ArrayBuffer;

package/dist/utils.test.js

@@ -1 +1,42 @@
-export {};
+//@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 encodeTest = (serializer, value, expected) => {
+    const data = st.write(serializer, value);
+    const newValue = st.read(serializer, data);
+    expect(newValue).toEqual((expected ?? value));
+};
+export const encodeFailTest = (serializer, value) => {
+    expectError(() => {
+        st.write(serializer, value);
+    });
+};
+export const expectEncodeSize = (serializer, size, value) => {
+    const data = st.write(serializer, value);
+    expect(data.byteLength).toEqual(size);
+};
+export const encodeSnapshotTest = (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/package.json

@@ -1,18 +1,24 @@
 {
   "name": "@nnilky/structo",
   "description": "A library for serializing and deserializing binary content",
-  "keywords": ["binary", "library", "utility", "web", "node"],
+  "keywords": [
+    "binary",
+    "library",
+    "utility",
+    "web",
+    "node"
+  ],
   "license": "ISC",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "author": "Ben Brady",
   "private": false,
-  "publishConfig": {"access": "public"},
-
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Ben-Brady/structo-ts.git"
   },
-
   "readme": "README.md",
   "type": "module",
   "main": "./dist/index.js",
@@ -38,12 +44,11 @@
     "./dist/**/*.js.map",
     "./dist/**/*.js"
   ],
-
   "scripts": {
     "build": "tsc",
     "prepublish": "tsc",
     "check": "tsc --noEmit",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "bun test src --only-failures --coverage"
   },
   "devDependencies": {
     "@types/bun": "^1.3.14",