@nsail/stack 0.1.966 → 0.1.977

package/dist/form.d.ts

@@ -9,7 +9,11 @@ export interface Form<T> {
     /** What the server last refused, kept until the field it is about changes. */
     readonly problem: Problem | null;
     set<K extends keyof T>(name: K, value: T[K]): void;
-    reset(value: T): void;
+    /** Replaces the value with another record or with what the server holds; `saved` is cleared unless
+     * `keepSaved` says the value is the re-read of what was just sent. */
+    reset(value: T, options?: {
+        keepSaved?: boolean;
+    }): void;
     issues(name: keyof T): Issue[];
     submit(action: (value: T) => Promise<void>): Promise<boolean>;
 }

package/dist/form.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) 2026 Leonardo Porro and Emmanuel Arias. https://github.com/nsail-ar/nsail-stack
-import { useCallback, useMemo, useState } from "react";
+import { useCallback, useMemo, useRef, useState } from "react";
 import { memberOf } from "./descriptors";
 import { validate, validateField } from "./validation";
 import { problemOf } from "./load";
@@ -12,17 +12,24 @@ export function useForm(message, initial) {
     const [problem, setProblem] = useState(null);
     const [submitting, setSubmitting] = useState(false);
     const [saved, setSaved] = useState(false);
+    const sending = useRef(false);
+    const edits = useRef(0);
     const set = useCallback((name, next) => {
         setValue((current) => ({ ...current, [name]: next }));
         setTouched((current) => new Set(current).add(name));
         setSaved(false);
+        edits.current++;
         const member = memberOf(message.fields[name]);
         setProblem((current) => (current ? { ...current, issues: current.issues.filter((issue) => issue.source !== member) } : current));
     }, [message]);
-    const reset = useCallback((next) => {
+    const reset = useCallback((next, options) => {
         setValue(next);
         setTouched(new Set());
         setProblem(null);
+        if (!options?.keepSaved) {
+            setSaved(false);
+        }
+        edits.current++;
     }, []);
     const issues = useCallback((name) => {
         const field = message.fields[name];
@@ -32,18 +39,27 @@ export function useForm(message, initial) {
         return [...local, ...remote.filter((r) => !local.some((l) => l.code === r.code))];
     }, [message, touched, value, problem]);
     const submit = useCallback(async (action) => {
+        // A ref, not `submitting`: two calls in one tick both see the state unchanged.
+        if (sending.current) {
+            return false;
+        }
         const refused = validate(message, value);
         if (refused) {
             setTouched(new Set(Object.keys(message.fields)));
             setProblem(refused);
             return false;
         }
+        sending.current = true;
+        // Counted in the handler, not in a state updater, which StrictMode runs twice.
+        const sentAt = edits.current;
         setSubmitting(true);
         setSaved(false);
         setProblem(null);
         try {
             await action(value);
-            setSaved(true);
+            if (edits.current === sentAt) {
+                setSaved(true);
+            }
             return true;
         }
         catch (error) {
@@ -51,6 +67,7 @@ export function useForm(message, initial) {
             return false;
         }
         finally {
+            sending.current = false;
             setSubmitting(false);
         }
     }, [message, value]);

package/dist/load.js

@@ -24,7 +24,11 @@ export function useLoad(message, request) {
         setLoad((current) => ({ state: "loading", data: current.data, problem: null }));
         mediator
             .send(message, latest.current, { signal: abort.signal })
-            .then((data) => setLoad({ state: "loaded", data, problem: null }))
+            .then((data) => {
+            if (!abort.signal.aborted) {
+                setLoad({ state: "loaded", data, problem: null });
+            }
+        })
             .catch((error) => {
             if (!abort.signal.aborted) {
                 setLoad((current) => ({ state: "failed", data: current.data, problem: problemOf(error) }));

package/dist/mediator.js

@@ -36,14 +36,28 @@ export class Mediator {
             }
             throw new BusinessError(requestFailed(null, null));
         }
-        const text = await response.text();
+        let text;
+        try {
+            text = await response.text();
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === "AbortError") {
+                throw error;
+            }
+            throw new BusinessError(requestFailed(response.status, "DeserializationFailed"));
+        }
         if (!response.ok) {
             throw new BusinessError(this.problemOf(response.status, text));
         }
         if (text.length === 0) {
             return undefined;
         }
-        return JSON.parse(text);
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw new BusinessError(requestFailed(response.status, "DeserializationFailed"));
+        }
     }
     url(message, request) {
         const values = request;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nsail/stack",
-  "version": "0.1.966",
+  "version": "0.1.977",
   "description": "NSail's vendor-free client half: sends messages from the descriptors an Sdk generates, speaks the catalog, and holds the hooks a page reads with.",
   "license": "MIT",
   "repository": {
@@ -30,6 +30,10 @@
     "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
-    "react": ">=19"
+    "react": ">=19",
+    "react-dom": ">=19"
+  },
+  "devDependencies": {
+    "happy-dom": "^21.0.4"
   }
 }