@nnilky/structo 1.0.7 → 1.0.9

package/dist/utilities/remember.d.ts

@@ -1,17 +1,18 @@
-import type { Serializer } from "../types";
+import type { Serializer } from "../types.js";
 /**
  * createRememberedValue lets you save and recall a value when serializing
  *
+ * This is useful for checksums and other values calculated from a writen value
+ *
  * ```
- * const length = st.createRememberedValue<number>()
+ * const data = st.createRememberedValue<ArrayBuffer>()
  * st.object({
- *   length: length.save(st.u32()),
- *   type: st.u8(),
- *   data: st.sizedBytes(length.load())
+ *   data: data.save(st.bytes(1024))
+ *   checksum: crc32(data.load())
  * })
  * ```
  */
 export declare function createRememberedValue<T>(): {
     save: (serializer: Serializer<T>) => Serializer<T>;
-    load: (serializer?: Serializer<T>) => Serializer<T>;
+    load: (behaviour?: "pop" | "retain") => Serializer<T>;
 };

package/dist/utilities/remember.js

@@ -1,17 +1,30 @@
 /**
  * createRememberedValue lets you save and recall a value when serializing
  *
+ * This is useful for checksums and other values calculated from a writen value
+ *
  * ```
- * const length = st.createRememberedValue<number>()
+ * const data = st.createRememberedValue<ArrayBuffer>()
  * st.object({
- *   length: length.save(st.u32()),
- *   type: st.u8(),
- *   data: st.sizedBytes(length.load())
+ *   data: data.save(st.bytes(1024))
+ *   checksum: crc32(data.load())
  * })
  * ```
  */
 export function createRememberedValue() {
     const stack = [];
+    /**
+     * Transparently writes/reads the underlying value but stores the value written.
+     *
+     * ---
+     * ```
+     * const data = st.createRememberedValue<ArrayBuffer>()
+     * st.object({
+     *   data: data.save(st.bytes(1024))
+     *   checksum: crc32(data.load())
+     * })
+     * ```
+     * */
     function save(serializer) {
         return {
             size: serializer.size,
@@ -27,11 +40,35 @@ export function createRememberedValue() {
             },
         };
     }
-    function load(serializer) {
+    /**
+     * Retrieves the last value written by `.save()`
+     *
+     * By default, the value is forgotten when written so that memory isn't leaked.
+     * It can be retained by setting `behaviour` to `"retain"`
+     *
+     * When writing this type does nothing
+     *
+     * ---
+     * ```
+     * const data = st.createRememberedValue<ArrayBuffer>()
+     * st.object({
+     *   data: data.save(st.bytes(1024))
+     *   checksum: crc32(data.load())
+     * })
+     * ```
+     */
+    function load(behaviour = "pop") {
         return {
-            size: serializer?.size ?? 0,
-            read: () => stack.pop(),
-            write: (ctx) => serializer && serializer.write(ctx, stack.pop()),
+            size: 0,
+            read: () => {
+                if (behaviour === "pop") {
+                    return stack.pop();
+                }
+                else {
+                    return stack.at(-1);
+                }
+            },
+            write: () => { },
         };
     }
     return { save: save, load: load };

package/dist/utilities/remember.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
-import { encodeTest, encodeSnapshotTest } from "../utils.test";
-import * as st from "../index";
+import { encodeTest, encodeSnapshotTest } from "../utils.test.js";
+import * as st from "../index.js";
 describe("st.remember", () => {
     it("encodes correctly", () => {
         const v = st.createRememberedValue();
@@ -37,7 +37,7 @@ describe("st.remember", () => {
         const v = st.createRememberedValue();
         const spec = st.object({
             a: v.save(st.u32()),
-            b: v.load(st.u8()),
+            b: v.load(),
         });
         encodeTest(spec, { a: 3, b: 0 }, { a: 3, b: 3 });
     });
@@ -68,9 +68,5 @@ describe("st.remember", () => {
             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,4 +1,4 @@
-import * as st from "./index";
+import * as st from "./index.js";
 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;

package/dist/utils.test.js

@@ -1,6 +1,6 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import * as st from "./index";
+import * as st from "./index.js";
 export const randint = (start, end) => {
     const range = end - start;
     return Math.floor(start + range * Math.random());

package/dist/write.d.ts

@@ -1,3 +1,3 @@
-import type { WriterContext, Serializer } from "./types";
+import type { WriterContext, Serializer } from "./types.js";
 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

@@ -1,6 +1,12 @@
 export function write(serializer, value) {
     const ctx = createdWriterContext(serializer);
-    serializer.write(ctx, value);
+    try {
+        serializer.write(ctx, value);
+    }
+    catch (e) {
+        const path = ctx.stack.join("") ?? "root";
+        throw new Error(`Serialization error at value${path}`, { cause: e });
+    }
     if (ctx.buffer.byteLength === ctx.offset) {
         return ctx.buffer;
     }
@@ -13,6 +19,7 @@ export function createdWriterContext(type) {
         let buffer = new ArrayBuffer(type.size);
         const view = new DataView(buffer);
         return {
+            stack: [],
             offset: 0,
             buffer,
             view,
@@ -24,6 +31,7 @@ export function createdWriterContext(type) {
         let buffer = new ArrayBuffer(bufferLength);
         const view = new DataView(buffer);
         return {
+            stack: [],
             offset: 0,
             buffer,
             view,

package/package.json

@@ -9,7 +9,7 @@
     "node"
   ],
   "license": "ISC",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "author": "Ben Brady",
   "private": false,
   "publishConfig": {
@@ -44,12 +44,6 @@
     "./dist/**/*.js.map",
     "./dist/**/*.js"
   ],
-  "scripts": {
-    "build": "tsc",
-    "prepublish": "tsc",
-    "check": "tsc --noEmit",
-    "test": "bun test src --only-failures --coverage"
-  },
   "devDependencies": {
     "@types/bun": "^1.3.14",
     "@types/node": "^25.9.2",
@@ -57,5 +51,11 @@
     "jest": "^30.4.2",
     "typescript": "^6.0.3"
   },
-  "packageManager": "pnpm@10.13.1"
-}
+  "scripts": {
+    "build": "tsc",
+    "prepublish": "tsc",
+    "check": "tsc --noEmit",
+    "test": "bun test src --only-failures",
+    "test:coverage": "bun test src --only-failures --coverage"
+  }
+}