@homebound/form-state 2.16.0 → 2.17.1

package/dist/FormStateApp.d.ts

@@ -2,5 +2,5 @@
 import { FieldState } from "./index";
 export declare function FormStateApp(): JSX.Element;
 export declare function TextField(props: {
-    field: FieldState<any, string | null | undefined>;
+    field: FieldState<string | null | undefined>;
 }): JSX.Element;

package/dist/config.d.ts

@@ -20,7 +20,7 @@ export declare type FragmentFieldConfig = {
 /** Field configuration for primitive values, i.e. strings/numbers/Dates/user-defined types. */
 export declare type ValueFieldConfig<T, V> = {
     type: "value";
-    rules?: Rule<T, V | null | undefined>[];
+    rules?: Rule<V | null | undefined>[];
     /**
      * If true, marks this field as the id, which will be used for things like "always include in changedValue".
      *
@@ -48,7 +48,7 @@ export declare type ValueFieldConfig<T, V> = {
 export declare type ListFieldConfig<T, U> = {
     type: "list";
     /** Rules that can run on the full list of children. */
-    rules?: Rule<T, readonly ObjectState<U>[]>[];
+    rules?: Rule<readonly ObjectState<U>[]>[];
     /** Config for each child's form state, i.e. each book. */
     config: ObjectConfig<U>;
     /**

package/dist/fields/listField.d.ts

@@ -3,9 +3,9 @@ import { ObjectState } from "./objectField";
 import { FieldState } from "./valueField";
 import { Rule } from "../rules";
 /** Form state for list of children, i.e. `U` is a `Book` in a form with a `books: Book[]`. */
-export interface ListFieldState<T, U> extends Omit<FieldState<T, U[]>, "originalValue"> {
+export interface ListFieldState<U> extends Omit<FieldState<U[]>, "originalValue"> {
     readonly rows: ReadonlyArray<ObjectState<U>>;
     add(value: U, index?: number): void;
     remove(indexOrValue: number | U): void;
 }
-export declare function newListFieldState<T, K extends keyof T, U>(parentInstance: T, parentState: () => ObjectState<T>, key: K, rules: Rule<T, readonly ObjectState<U>[]>[], listConfig: ListFieldConfig<T, U>, config: ObjectConfig<U>, maybeAutoSave: () => void): ListFieldState<T, U>;
+export declare function newListFieldState<T, K extends keyof T, U>(parentInstance: T, parentState: () => ObjectState<T>, key: K, rules: Rule<readonly ObjectState<U>[]>[], listConfig: ListFieldConfig<T, U>, config: ObjectConfig<U>, maybeAutoSave: () => void): ListFieldState<U>;

package/dist/fields/objectField.d.ts

@@ -14,7 +14,7 @@ import { Builtin } from "../utils";
  * have exactly the on-the-wire type `T` that they need to submit to the backend, without doing the
  * manual mapping of "data that was in the form controls" into "data that the backend wants".
  *
- * Note that this can be hierarchical by having by having a field of `ListFieldState` that
+ * Note that this can be hierarchical by having a field of `ListFieldState` that
  * themselves each wrap an `ObjectState`, i.e.:
  *
  * ```
@@ -28,14 +28,14 @@ import { Builtin } from "../utils";
  *       - title: FieldState
  * ```
  */
-export declare type ObjectState<T, P = any> = FieldStates<T> & FieldState<P, T> & {
+export declare type ObjectState<T> = FieldStates<T> & FieldState<T> & {
     /** Sets the state of fields in `state`. */
     set(state: Partial<T>, opts?: SetOpts): void;
     /** Returns whether the object can be saved, i.e. is valid, but also as a side-effect marks touched. */
     canSave(): boolean;
 };
-export declare type ObjectStateInternal<T, P = any> = ObjectState<T, P> & {
-    set(value: P, opts?: InternalSetOpts): void;
+export declare type ObjectStateInternal<T> = ObjectState<T> & {
+    set(value: T, opts?: InternalSetOpts): void;
 };
 declare const fragmentSym: unique symbol;
 export declare type Fragment<V> = V & {
@@ -44,7 +44,7 @@ export declare type Fragment<V> = V & {
 export declare function fragment<V>(value: V): Fragment<V>;
 /** For a given input type `T`, decorate each field into the "field state" type that holds our form-relevant state, i.e. valid/touched/etc. */
 declare type FieldStates<T> = {
-    [K in keyof T]-?: T[K] extends Fragment<infer V> ? FragmentField<V> : T[K] extends Array<infer U> | null | undefined ? [U] extends [Builtin] ? FieldState<T, T[K]> : ListFieldState<T, U> : T[K] extends Builtin | null | undefined ? FieldState<T, T[K]> : ObjectState<T[K], T>;
+    [K in keyof T]-?: T[K] extends Fragment<infer V> ? FragmentField<V> : T[K] extends Array<infer U> | null | undefined ? [U] extends [Builtin] ? FieldState<T[K]> : ListFieldState<U> : T[K] extends Builtin | null | undefined ? FieldState<T[K]> : ObjectState<T[K]>;
 };
 /**
  * Creates a new `ObjectState` for a given form object `T` given config rules in `config`.
@@ -56,5 +56,5 @@ declare type FieldStates<T> = {
 export declare function createObjectState<T>(config: ObjectConfig<T>, instance: T, opts?: {
     maybeAutoSave?: () => void;
 }): ObjectState<T>;
-export declare function newObjectState<T, P = any>(config: ObjectConfig<T>, parentState: (() => ObjectState<P>) | undefined, parentListState: FieldState<any, any> | undefined, instance: T, key: keyof T | undefined, maybeAutoSave: () => void): ObjectState<T, P>;
+export declare function newObjectState<T, P = any>(config: ObjectConfig<T>, parentState: (() => ObjectState<P>) | undefined, parentListState: FieldState<any> | undefined, instance: T, key: keyof T | undefined, maybeAutoSave: () => void): ObjectState<T>;
 export {};

package/dist/fields/valueField.d.ts

@@ -10,7 +10,7 @@ import { Rule } from "../rules";
  * Note that `V` will always have `null | undefined` added to it by `FieldStates`, b/c most form fields
  * i.e. text boxes, can always be cleared out/deleted.
  */
-export interface FieldState<T, V> {
+export interface FieldState<V> {
     readonly key: string;
     value: V;
     readonly originalValue: V;
@@ -21,7 +21,7 @@ export interface FieldState<T, V> {
     readonly dirty: boolean;
     readonly valid: boolean;
     readonly isNewEntity: boolean;
-    rules: Rule<T, V>[];
+    rules: Rule<V>[];
     readonly errors: string[];
     /** Returns a subset of V with only the changed values. Currently not observable. */
     readonly changedValue: V;
@@ -49,11 +49,11 @@ export interface InternalSetOpts extends SetOpts {
     /** `refreshing` is when `useFormState` sees a new value. */
     refreshing?: boolean;
 }
-export interface FieldStateInternal<T, V> extends FieldState<T, V> {
+export interface FieldStateInternal<T, V> extends FieldState<V> {
     set(value: V, opts?: InternalSetOpts): void;
     _isIdKey: boolean;
     _isDeleteKey: boolean;
     _isReadOnlyKey: boolean;
     _focused: boolean;
 }
-export declare function newValueFieldState<T, K extends keyof T>(parentInstance: T, parentState: () => ObjectState<T>, key: K, rules: Rule<T, T[K] | null | undefined>[], isIdKey: boolean, isDeleteKey: boolean, isReadOnlyKey: boolean, computed: boolean, readOnly: boolean, strictOrder: boolean, maybeAutoSave: () => void): FieldState<T, T[K] | null | undefined>;
+export declare function newValueFieldState<T, K extends keyof 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>;

package/dist/formState.test.js

@@ -941,24 +941,6 @@ describe("formState", () => {
         formState.revertChanges();
         expect(formState.firstName.value).toEqual("first");
     });
-    it("lets rules validate against other fields", () => {
-        const formState = objectField_1.createObjectState({
-            firstName: { type: "value", rules: [] },
-            lastName: {
-                type: "value",
-                rules: [
-                    ({ object }) => {
-                        if (object.firstName.value === object.lastName.value) {
-                            return "Must not match first name";
-                        }
-                    },
-                ],
-            },
-        }, {});
-        formState.firstName.value = "bob";
-        formState.lastName.value = "bob";
-        expect(formState.lastName.errors).toEqual(["Must not match first name"]);
-    });
     it("can return only changed primitive fields", () => {
         // Given an author
         const formState = objectField_1.createObjectState(authorWithBooksConfig, {

package/dist/rules.d.ts

@@ -1,14 +1,10 @@
-import { ObjectState } from "./fields/objectField";
-declare type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
 /** A validation rule, given the value and name, return the error string if valid, or undefined if valid. */
-export declare type Rule<T, V> = (opts: {
+export declare type Rule<V> = (opts: {
     value: V;
     key: string;
     originalValue: V;
-    object: IfAny<T, any, ObjectState<T>>;
 }) => string | undefined;
 /** A rule that validates `value` is not `undefined`, `null`, or empty string. */
 export declare const required: <V>({ value: v }: {
     value: V;
 }) => string | undefined;
-export {};

package/dist/useFormState.test.js

@@ -261,17 +261,17 @@ describe("useFormState", () => {
     });
     it("useFormState can accept new data with computed fields", async () => {
         // Given a component
-        function TestComponent() {
-            // And it's using a class/mobx proxy as the basis for the data
-            class AuthorRow {
-                constructor(firstName, lastName) {
-                    this.firstName = firstName;
-                    this.lastName = lastName;
-                }
-                get fullName() {
-                    return this.firstName + " " + this.lastName;
-                }
+        // And it's using a class/mobx proxy as the basis for the data
+        class AuthorRow {
+            constructor(firstName, lastName) {
+                this.firstName = firstName;
+                this.lastName = lastName;
+            }
+            get fullName() {
+                return this.firstName + " " + this.lastName;
             }
+        }
+        function TestComponent() {
             // And we have two sets of data
             const data1 = { firstName: "f1", lastName: "l1" };
             const data2 = { firstName: "f2", lastName: "l2" };

package/dist/useFormStates.test.js

@@ -39,7 +39,7 @@ describe("useFormStates", () => {
             const [apiData, setApiData] = react_1.useState({ id: "a:1", firstName: "Brandon" });
             const { getFormState } = useFormStates_1.useFormStates({ config, autoSave, getId: (o) => o.id });
             // Memoize an original for comparing the update against.
-            const originalState = react_1.useMemo(() => getFormState(apiData), []);
+            const originalState = react_1.useMemo(() => getFormState(apiData), [getFormState]);
             const state = getFormState(apiData);
             return (jsx_runtime_1.jsxs("div", { children: [jsx_runtime_1.jsx("div", Object.assign({ "data-testid": "firstName" }, { children: state.firstName.value }), void 0),
                     jsx_runtime_1.jsx("div", Object.assign({ "data-testid": "statesEqual" }, { children: JSON.stringify(state === originalState) }), void 0),
@@ -124,6 +124,7 @@ describe("useFormStates", () => {
             const [config, setConfig] = react_1.useState(originalConfig);
             const { getFormState } = useFormStates_1.useFormStates({ config, autoSave, getId: (o) => o.id });
             // Memoize an original for comparing the update against.
+            // eslint-disable-next-line react-hooks/exhaustive-deps
             const originalState = react_1.useMemo(() => getFormState(apiData), []);
             const state = getFormState(apiData);
             return (jsx_runtime_1.jsxs("div", { children: [jsx_runtime_1.jsx("div", Object.assign({ "data-testid": "statesEqual" }, { children: JSON.stringify(state === originalState) }), void 0),

package/package.json

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