@homebound/form-state 2.26.11 → 2.27.0

package/dist/config.d.ts

@@ -56,10 +56,14 @@ export type ListFieldConfig<U> = {
      *
      * When incremental, we only include changed rows in `changedValue`.
      *
+     * When deep-exhaustive, we include all rows in `changedValue` and also
+     * all fields in the child entities, i.e. not just placeholder `{ id: "b:1" }`
+     * values for otherwise-unchanged children.
+     *
      * Defaults to `exhaustive` b/c that is the safest and also Joist's
      * default behavior.
      */
-    update?: "exhaustive" | "incremental";
+    update?: "exhaustive" | "incremental" | "deep-exhaustive";
     /** Set to not consider the order of the list when evaluating changed/dirty states, defaults true. */
     strictOrder?: false;
 };

package/dist/fields/listField.d.ts

@@ -8,4 +8,4 @@ export interface ListFieldState<U> extends FieldState<U[]> {
     add(value: U, index?: number): void;
     remove(indexOrValue: number | U): void;
 }
-export declare function newListFieldState<T, K extends keyof T, U>(parentCopy: T, parentInstance: T, parentState: () => ObjectState<T>, key: K, rules: Rule<readonly ObjectState<U>[]>[], listConfig: ListFieldConfig<U>, config: ObjectFieldConfig<U>, strictOrder: boolean, maybeAutoSave: () => void): ListFieldState<U>;
+export declare function newListFieldState<T, K extends keyof T, U>(parentCopy: T, parentInstance: T, parentState: () => ObjectState<T>, key: K, rules: Rule<readonly ObjectState<U>[]>[], listConfig: ListFieldConfig<U>, config: ObjectFieldConfig<U>, strictOrder: boolean, maybeAutoSave: () => void, deepExhaustive: boolean): ListFieldState<U>;

package/dist/fields/listField.js

@@ -13,7 +13,7 @@ function newListFieldState(
 // parentCopy is objectField's deepClone-d `originalCopy` that it/we use for `dirty` checking
 parentCopy, 
 // parentInstance is objectField's `instance`, that we're currently mutating
-parentInstance, parentState, key, rules, listConfig, config, strictOrder, maybeAutoSave) {
+parentInstance, parentState, key, rules, listConfig, config, strictOrder, maybeAutoSave, deepExhaustive) {
     var _a;
     // Keep a map of "item in the parentInstance list" -> "that item's ObjectState"
     const rowMap = new Map();
@@ -30,6 +30,7 @@ parentInstance, parentState, key, rules, listConfig, config, strictOrder, maybeA
     });
     // Given a child POJO (or a copy/clone of a child POJO), return its ObjectState wrapper.
     function getOrCreateChildState(child, opts) {
+        var _a;
         let childState = rowMap.get(child);
         // If we're being reverted to our originalValue, i.e. values is actually
         // a list of copies, use the copyMap to recover the non-copy original value
@@ -50,7 +51,7 @@ parentInstance, parentState, key, rules, listConfig, config, strictOrder, maybeA
         }
         // If we didn't have an existing child, just make a new object state
         if (!childState) {
-            childState = (0, objectField_1.newObjectState)(config, parentState, undefined, list, child, undefined, maybeAutoSave);
+            childState = (0, objectField_1.newObjectState)(config, parentState, undefined, list, child, undefined, maybeAutoSave, (_a = listConfig.update === "deep-exhaustive") !== null && _a !== void 0 ? _a : deepExhaustive);
             rowMap.set(child, childState);
         }
         return childState;
@@ -223,17 +224,20 @@ parentInstance, parentState, key, rules, listConfig, config, strictOrder, maybeA
                         // Once matched, we don't this to be an addedRow anymore
                         addedRows.delete(currentItem);
                     }
-                    else if (childState.dirty || addedRows.has(currentItem)) {
-                        // If no incoming, but we're dirty (...and not deleted), keep the WIP change
-                        if (hasOpKey && currentItem.op === "delete") {
-                            // delete
-                        }
-                        else {
-                            mergedItems.push(currentItem);
-                        }
+                    else if (!childState.dirty && !addedRows.has(currentItem)) {
+                        // Local is not dirty/added, and it's not upstream, so let it get removed
+                    }
+                    else if (hasOpKey && currentItem.op === "delete") {
+                        // We were locally marked as deleted, and not finding a match is the server acking that we're gone
+                    }
+                    else if (currentItems.length === incomingItems.length &&
+                        !!idKey &&
+                        currentItem[idKey] === undefined) {
+                        // Assume our newly-assigned id is coming back
                     }
                     else {
-                        // Local is not dirty, and it's not upstream, so remove it
+                        // If no incoming, but we're dirty (see above) and not deleted (see above), keep the WIP change
+                        mergedItems.push(currentItem);
                     }
                 }
                 // Then, add any incoming items that don't exist in current

package/dist/fields/objectField.d.ts

@@ -59,5 +59,5 @@ export declare function createObjectState<T>(config: ObjectConfig<T>, instance:
     maybeAutoSave?: () => void;
 }): ObjectState<T>;
 /** A more internal version of `createObjectState`. */
-export declare function newObjectState<T, P = any>(config: ObjectFieldConfig<T>, parentState: (() => ObjectState<P>) | undefined, parentInstance: P | undefined, parentListState: FieldState<any> | undefined, instance: T, key: keyof T | undefined, maybeAutoSave: () => void): ObjectState<T>;
+export declare function newObjectState<T, P = any>(config: ObjectFieldConfig<T>, parentState: (() => ObjectState<P>) | undefined, parentInstance: P | undefined, parentListState: FieldState<any> | undefined, instance: T, key: keyof T | undefined, maybeAutoSave: () => void, deepExhaustive: boolean): ObjectState<T>;
 export {};

package/dist/fields/objectField.js

@@ -21,10 +21,10 @@ function fragment(value) {
  */
 function createObjectState(config, instance, opts = {}) {
     const noop = () => { };
-    return newObjectState({ type: "object", config }, undefined, undefined, undefined, instance, undefined, opts.maybeAutoSave || noop);
+    return newObjectState({ type: "object", config }, undefined, undefined, undefined, instance, undefined, opts.maybeAutoSave || noop, false);
 }
 /** A more internal version of `createObjectState`. */
-function newObjectState(config, parentState, parentInstance, parentListState, instance, key, maybeAutoSave) {
+function newObjectState(config, parentState, parentInstance, parentListState, instance, key, maybeAutoSave, deepExhaustive) {
     // This is what we return, but we only know it's value until we call `observable`, so
     // we create a mutable variable to capture it so that we can create fields/call their
     // constructors and give them a way to access it later.
@@ -55,7 +55,7 @@ function newObjectState(config, parentState, parentInstance, parentListState, in
             ((0, mobx_1.isObservable)(instance) ? !(key in originalCopy) : false), (_b = config.readOnly) !== null && _b !== void 0 ? _b : false, (_c = config.strictOrder) !== null && _c !== void 0 ? _c : true, maybeAutoSave);
         }
         else if (config.type === "list") {
-            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);
+            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, deepExhaustive);
         }
         else if (config.type === "object") {
             // Because our objectField will fundamentally want to do `child.firstName.set(...)` or
@@ -65,7 +65,7 @@ function newObjectState(config, parentState, parentInstance, parentListState, in
             if (!instance[key]) {
                 instance[key] = {};
             }
-            field = newObjectState(config, getObjectState, instance, undefined, instance[key], key, maybeAutoSave);
+            field = newObjectState(config, getObjectState, instance, undefined, instance[key], key, maybeAutoSave, deepExhaustive);
         }
         else if (config.type === "fragment") {
             field = (0, fragmentField_1.newFragmentField)(instance, key);
@@ -223,7 +223,9 @@ function newObjectState(config, parentState, parentInstance, parentListState, in
                         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)) {
+                    (this.isNewEntity && f._kind === "list" && ((_a = f.value) === null || _a === void 0 ? void 0 : _a.length) > 0) ||
+                    // ...or the parent list is deep-exhaustive
+                    deepExhaustive) {
                     result[f.key] = f.changedValue;
                 }
             });

package/dist/formState.test.js

@@ -258,6 +258,27 @@ describe("formState", () => {
         // And we're not dirty
         expect(state.books.dirty).toBe(false);
     });
+    it("list value can refresh and merge children that were added", () => {
+        // Given a list field that is currently populated with 1 child
+        const a1 = { id: "a:1", books: [{ id: "b:1", title: "b1" }] };
+        const state = createAuthorInputState(a1);
+        // When we add a new book
+        state.books.add({ title: "b2" });
+        // When we refresh it with both books, and the 2nd book now has its id assigned
+        state.set({
+            books: [
+                { id: "b:1", title: "b1" },
+                { id: "b:2", title: "b2" },
+            ],
+        }, { refreshing: true });
+        // Then wes till have two books
+        expect(state.books.value).toEqual([
+            { id: "b:1", title: "b1" },
+            { id: "b:2", title: "b2" },
+        ]);
+        // And we're not dirty
+        expect(state.books.dirty).toBe(false);
+    });
     it("list value can observe changes", () => {
         const b1 = { title: "t1" };
         const a1 = { firstName: "a1", books: [b1] };
@@ -1318,7 +1339,7 @@ describe("formState", () => {
         // And we don't include it in the changedValue
         expect(formState.changedValue).toEqual({ firstName: "First" });
     });
-    it("can return only changed list fields", () => {
+    it("can return only changed and exhaustive list fields", () => {
         // Given an author with some books
         const formState = (0, objectField_1.createObjectState)(authorWithBooksConfig, {
             id: "a:1",
@@ -1409,6 +1430,40 @@ describe("formState", () => {
             books: [{ id: "b:1", title: "t1b" }],
         });
     });
+    it("can return only changed but deep exhaustive list fields", () => {
+        // Given an author
+        const formState = (0, objectField_1.createObjectState)({
+            id: { type: "value" },
+            // And the books collection is marked as deep-exhaustive
+            books: {
+                type: "list",
+                update: "deep-exhaustive",
+                config: {
+                    id: { type: "value" },
+                    title: { type: "value", rules: [rules_1.required] },
+                },
+            },
+        }, {
+            id: "a:1",
+            firstName: "f",
+            books: [
+                { id: "b:1", title: "t1" },
+                { id: "b:2", title: "t2" },
+            ],
+        });
+        // And initially nothing is changed
+        expect(formState.changedValue).toEqual({ id: "a:1" });
+        // When we change the 1st book
+        formState.books.rows[0].title.value = "t1b";
+        // Then we see all books & all attributes
+        expect(formState.changedValue).toEqual({
+            id: "a:1",
+            books: [
+                { id: "b:1", title: "t1b" },
+                { id: "b:2", title: "t2" },
+            ],
+        });
+    });
     it("uses the op key as a hint to use incremental list behavior", () => {
         // Given an author
         const formState = (0, objectField_1.createObjectState)({

package/package.json

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