@homebound/form-state 2.27.1 → 2.27.2

package/dist/fields/valueField.js

@@ -114,12 +114,18 @@ function newValueFieldState(parentCopy, parentInstance, parentState, key, rules,
             if (opts.refreshing && this.dirty) {
                 // See if we should ignore the incoming server-side value, to avoid dropping local WIP changes
                 const isAckingUnset = this.value === null && (value === null || value === undefined);
-                const acceptServerAck = hasInflightChangedValue && this.value === lastChangedValue;
+                const acceptServerAck = hasInflightChangedValue &&
+                    this.value === lastChangedValue &&
+                    // If value === originalValue, this is likely a cache refresh firing in-between "we put the new value
+                    // on the wire" and "the server acked our change". Granted, this heuristic means that if the server
+                    // really does reject/rollback our change, we'll ignore it, but atm we don't have a way of differentiating
+                    // "this refresh is from a pre-response cache refresh" vs. "post-response cache refresh".
+                    value !== this.originalValue;
                 // Ignore incoming values if we have changes (this.dirty) unless:
                 // - our latest change (this.value) matches the incoming value (value), i.e. the server
                 //   is exactly acking our change, or
                 // - the user hasn't made any changes since `.changedValue` was put on the wire, i.e. the
-                //   server received our value, but wanted to to change it.
+                //   server received our value, but wanted to change it.
                 const keepLocalWipChange = this.value !== value && !isAckingUnset && !acceptServerAck;
                 if (keepLocalWipChange)
                     return;

package/dist/formState.test.js

@@ -1592,6 +1592,18 @@ describe("formState", () => {
         expect(formState.firstName.value).toEqual("FF");
         expect(formState.firstName.dirty).toEqual(false);
     });
+    it("ignores cache refresh of our original value", () => {
+        const formState = (0, objectField_1.createObjectState)(authorWithBooksConfig, { id: "a:1", firstName: "f" });
+        // Given first name has wip edits
+        formState.firstName.set("ff");
+        // And we've called changedValue to put it on the wire
+        expect(formState.changedValue).toEqual({ id: "a:1", firstName: "ff" });
+        // But then a cache refresh fires with our original `f`
+        formState.set({ firstName: "f" }, { refreshing: true });
+        // Then we keep our WIP value
+        expect(formState.firstName.value).toEqual("ff");
+        expect(formState.firstName.dirty).toEqual(true);
+    });
     it("rejects server result if we have further changes", () => {
         const formState = (0, objectField_1.createObjectState)(authorWithBooksConfig, { id: "a:1", firstName: "f" });
         // Given first name has wip edits

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homebound/form-state",
-  "version": "2.27.1",
+  "version": "2.27.2",
   "author": "Homebound",
   "license": "MIT",
   "main": "dist/index.js",