@homebound/form-state 2.26.2 → 2.26.3

package/dist/fields/objectField.js

@@ -57,6 +57,10 @@ function newObjectState(config, parentState, parentInstance, parentListState, in
             field = (0, listField_1.newListFieldState)(originalCopy, instance, getObjectState, key, config.rules || [], config, { type: "object", config: config.config }, (_d = config.strictOrder) !== null && _d !== void 0 ? _d : true, maybeAutoSave);
         }
         else if (config.type === "object") {
+            // Because our objectField will fundamentally want to do `child.firstName.set(...)` or
+            // even `child.firstName !== undefined`, etc., we "simplify" things by always setting
+            // an empty object, for our child valueFields/listFields to use/read from, although
+            // we then have to "oh right ignore {}" in places like `dirty`.
             if (!instance[key]) {
                 instance[key] = {};
             }
@@ -131,7 +135,10 @@ function newObjectState(config, parentState, parentInstance, parentListState, in
             return getFields(this).flatMap((f) => f.errors.map((e) => `${f.key}: ${e}`));
         },
         get dirty() {
-            return getFields(this).some((f) => f.dirty) || this.isUnset();
+            return (getFields(this).some((f) => f.dirty) ||
+                // `isUnset` checks if our `parent[key] === undefined`, which can mean "surely we're dirty",
+                // but as long as we've got some keys actually set
+                (this.isUnset() && !(0, utils_1.areEqual)(this.value, {})));
         },
         get isNewEntity() {
             const idField = getFields(this).find((f) => f._isIdKey);
@@ -207,7 +214,11 @@ function newObjectState(config, parentState, parentInstance, parentListState, in
                     // look dirty, but if we're new we should include them anyway.
                     (this.isNewEntity && f._kind === "value" && f.value !== undefined) ||
                     // ...or they're non-empty sub-objects
-                    (this.isNewEntity && f._kind === "object" && Object.entries(f.changedValue).length > 0) ||
+                    (this.isNewEntity &&
+                        f._kind === "object" &&
+                        // Child objects that are unset will have `changedValue = null`
+                        f.changedValue &&
+                        Object.entries(f.changedValue).length > 0) ||
                     // ...or they're non-empty sub-lists
                     (this.isNewEntity && f._kind === "list" && ((_a = f.value) === null || _a === void 0 ? void 0 : _a.length) > 0)) {
                     result[f.key] = f.changedValue;

package/dist/formState.test.js

@@ -595,6 +595,19 @@ describe("formState", () => {
         a1.firstName.set("a1");
         expect(a1.dirty).toBeFalsy();
     });
+    it("realizes object fields set to null aren't actually dirty", () => {
+        // Given we started off with a `object: undefined`
+        const a1 = createAuthorWithAddressInputState({ address: undefined });
+        expect(a1.address.dirty).toBe(false);
+        expect(a1.address.value).toEqual({});
+        // And it's later set to null, i.e. from a mutation returning `{ address: null }`
+        a1.set({ firstName: "a1", address: null });
+        // Then we convert it to `{}` to potentially hold data
+        expect(a1.address.value).toEqual({});
+        // But we don't consider the address dirty
+        expect(a1.address.dirty).toBe(false);
+        expect(a1.changedValue).toEqual({ firstName: "a1" });
+    });
     it("knows an object's field of type object is dirty", () => {
         const a1 = createAuthorInputState({
             books: [{ title: "b1", classification: formStateDomain_1.dd100 }],

package/package.json

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