@homebound/form-state 2.27.3 → 2.28.0

package/dist/config.d.ts

@@ -28,6 +28,8 @@ export type ValueFieldConfig<V> = {
     isDeleteKey?: boolean;
     /** If true, the entity that contains this value will be treated as read only. */
     isReadOnlyKey?: boolean;
+    /** If true, we ignore field in dirty checks. */
+    isLocalOnly?: boolean;
     /**
      * Marks a field as being backed by a mobx class computed field.
      *

package/dist/configBuilders.d.ts

@@ -47,6 +47,8 @@ export declare class ValueFieldConfigBuilder<V> {
     req(): this;
     /** Marks the field as read only. */
     readOnly(): this;
+    /** Marks the field as local only. */
+    localOnly(): this;
     /** Appends `rules` to the field's validation rules. */
     rules(rules: Rule<V | null | undefined>[]): this;
     /** Marks the field as computed. */

package/dist/configBuilders.js

@@ -63,6 +63,11 @@ class ValueFieldConfigBuilder {
         this.config.readOnly = true;
         return this;
     }
+    /** Marks the field as local only. */
+    localOnly() {
+        this.config.isLocalOnly = true;
+        return this;
+    }
     /** Appends `rules` to the field's validation rules. */
     rules(rules) {
         var _a;

package/dist/fields/fragmentField.js

@@ -16,6 +16,7 @@ function newFragmentField(parentInstance, key) {
         _isIdKey: false,
         _isDeleteKey: false,
         _isReadOnlyKey: false,
+        _isLocalOnly: false,
         touched: false,
         valid: true,
         readOnly: true,

package/dist/fields/objectField.js

@@ -50,7 +50,7 @@ function newObjectState(config, parentState, parentInstance, parentListState, in
                 // Default the id key to "id" unless some other field has isIdKey set
                 (key === "id" &&
                     !("isIdKey" in config) && // Allow setting `isIdKey=false`
-                    !Object.entries(objectConfig).some(([other, c]) => other !== key && c.isIdKey)), config.isDeleteKey || false, config.isReadOnlyKey || false, (_a = config.computed) !== null && _a !== void 0 ? _a : 
+                    !Object.entries(objectConfig).some(([other, c]) => other !== key && c.isIdKey)), config.isDeleteKey || false, config.isReadOnlyKey || false, config.isLocalOnly || false, (_a = config.computed) !== null && _a !== void 0 ? _a : 
             // If instance is a mobx class, we can detect computeds as they won't be enumerable
             ((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);
         }
@@ -138,7 +138,7 @@ 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) ||
+            return (getFields(this).some((f) => f.dirty && !f._isLocalOnly) ||
                 // `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, {})));
@@ -212,6 +212,9 @@ function newObjectState(config, parentState, parentInstance, parentListState, in
                 // References only include the id key below
                 if (config.reference)
                     return;
+                // Ignore local-only fields
+                if (f._isLocalOnly)
+                    return;
                 if (f.dirty ||
                     // If the caller used useFormState.ifUndefined to provide some default values, then those keys may not
                     // look dirty, but if we're new we should include them anyway.

package/dist/fields/valueField.d.ts

@@ -70,5 +70,6 @@ export interface FieldStateInternal<T, V> extends FieldState<V> {
     _isIdKey: boolean;
     _isDeleteKey: boolean;
     _isReadOnlyKey: boolean;
+    _isLocalOnly: boolean;
 }
-export declare function newValueFieldState<T, K extends keyof T>(parentCopy: T, parentInstance: T, parentState: () => ObjectState<T>, key: K, rules: Rule<T[K] | null | undefined>[], isIdKey: boolean, isDeleteKey: boolean, isReadOnlyKey: boolean, computed: boolean, readOnly: boolean, strictOrder: boolean, maybeAutoSave: () => void): FieldState<T[K] | null | undefined>;
+export declare function newValueFieldState<T, K extends keyof T>(parentCopy: T, parentInstance: T, parentState: () => ObjectState<T>, key: K, rules: Rule<T[K] | null | undefined>[], isIdKey: boolean, isDeleteKey: boolean, isReadOnlyKey: boolean, isLocalOnly: boolean, computed: boolean, readOnly: boolean, strictOrder: boolean, maybeAutoSave: () => void): FieldState<T[K] | null | undefined>;

package/dist/fields/valueField.js

@@ -6,7 +6,7 @@ const mobx_1 = require("mobx");
 const proxies_1 = require("../proxies");
 const rules_1 = require("../rules");
 const utils_1 = require("../utils");
-function newValueFieldState(parentCopy, parentInstance, parentState, key, rules, isIdKey, isDeleteKey, isReadOnlyKey, computed, readOnly, strictOrder, maybeAutoSave) {
+function newValueFieldState(parentCopy, parentInstance, parentState, key, rules, isIdKey, isDeleteKey, isReadOnlyKey, isLocalOnly, computed, readOnly, strictOrder, maybeAutoSave) {
     // Because we read/write the value directly back into parentInstance[key],
     // which itself is not a proxy, we use this as our "value changed" trigger.
     const _tick = (0, mobx_1.observable)({ value: 1 });
@@ -31,6 +31,7 @@ function newValueFieldState(parentCopy, parentInstance, parentState, key, rules,
         _isIdKey: isIdKey,
         _isDeleteKey: isDeleteKey,
         _isReadOnlyKey: isReadOnlyKey,
+        _isLocalOnly: isLocalOnly,
         rules,
         get value() {
             // If we're wrapping a mobx store, then we'll get reactivity from parentInstance[key]

package/dist/formState.test.js

@@ -640,6 +640,33 @@ describe("formState", () => {
         a1.books.remove(0);
         expect(a1.dirty).toBeFalsy();
     });
+    it("can ignore isLocalOnly fields as not dirty", () => {
+        // Given we have an `isPublished` field that is marked as local only
+        const config = {
+            id: { type: "value" },
+            books: {
+                type: "list",
+                config: {
+                    id: { type: "value" },
+                    isPublished: { type: "value", isLocalOnly: true },
+                },
+            },
+        };
+        // And it starts out true
+        const a1 = (0, objectField_1.createObjectState)(config, {
+            id: "a:1",
+            books: [{ id: "b:1", isPublished: true }],
+        });
+        // When we change the value to false
+        a1.books.rows[0].isPublished.value = false;
+        // Then the field itself is dirty
+        expect(a1.books.rows[0].isPublished.dirty).toBe(true);
+        // But object is not
+        expect(a1.dirty).toBe(false);
+        expect(a1.books.dirty).toBe(false);
+        // And we don't include it in changedValue
+        expect(a1.changedValue).toEqual({ id: "a:1" });
+    });
     it("handles list fields with duplicate ids", () => {
         // Given an author that incorrectly has duplicate books
         const a1 = createAuthorInputState({

package/package.json

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