@homebound/form-state 2.20.1 → 2.21.0

package/README.md

@@ -5,7 +5,7 @@
 
 form-state is a headless form state management library, built on top of mobx.
 
-It acts as a buffer between the canonical data (i.e. the server-side data, or your app's GraphQL/Redux/etc. global store) and the user's WIP data that is being actively mutated in form fields (which is "too chatty"/WIP to store in the global store).
+It acts as a buffer between the canonical data (i.e. the server-side data, or your app's GraphQL/Redux/etc. global store) and the user's WIP data that is being actively mutated in form fields (which is "too chatty"/WIP to push back into global stores).
 
 It also keeps track of low-level form UX details like:
 
@@ -21,7 +21,7 @@ It also keeps track of low-level form UX details like:
 - Building a wire payload that has only changed fields
   - `form.changedValue` will return the entity `id` + only changed fields to faciliate doing partial update APIs
   - Supports collections of children, i.e. a `author: { books: [...} }` will include only changed books if necessary
-  - Child collections can be either exhausive (if any child changes, submit them all) or incremental (only include changed children), to match the backend endpoint's semantics
+  - Child collections can be either exhaustive (if any child changes, submit them all) or incremental (only include changed children), to match the backend endpoint's semantics
 
 # Main Features
 
@@ -37,16 +37,17 @@ The core abstraction that `form-state` provides is a `FieldState` interface that
 ```ts
 // Very simplified example
 interface FieldState {
-  value: V
-  errors: string[]
-  valid: boolean
-  touched: boolean
+  // Can be used to read & write the value bound into the form field
+  value: V;
+  errors: string[];
+  valid: boolean;
+  touched: boolean;
 }
 ```
 
 Which combines all the logical aspects of "a single form field" into a single object/prop.
 
-This facilitates the "gold standard" of form libraries, which is "one line per form field", i.e:
+This facilitates the "gold standard" of form DX, which is "one line per form field", i.e:
 
 ```tsx
 function AuthorEditorComponent() {
@@ -124,14 +125,14 @@ type AuthorFragment = { firstName: string; miscOtherData: {} };
 // For your page's form state, add-in the "extra data"
 type AuthorForm = AuthorInput & {
   // The `Fragment` type tells form-state this is not a regular form field
-  data: Fragment<AuthorFragment >
+  data: Fragment<AuthorFragment>;
 };
 
 // Tell the form config the "fragment" is not a real field
 const config: ObjectConfig<AuthorForm> = {
   firstName: { type: "value", rules: [require] },
   data: { type: "fragment" },
-}
+};
 
 // Now in the component...
 const data = useGraphQLQuery();
@@ -147,7 +148,6 @@ const form = useFormState({
 });
 ```
 
-
 # Internal Implementation Notes
 
 form-state keeps the "actual data" (basically a POJO of your form data) separate from the "mobx proxies that track reactivity" (the `ObjectState` interface with `.get` / `.set` / `.errors` other methods).

package/dist/FormStateApp.js

@@ -33,17 +33,15 @@ function FormStateApp() {
 }
 exports.FormStateApp = FormStateApp;
 // Configure the fields/behavior for AuthorInput's fields
-const formConfig = {
-    firstName: { type: "value", rules: [index_1.required] },
-    lastName: { type: "value", rules: [index_1.required], readOnly: true },
-    books: {
-        type: "list",
-        rules: [({ value: list }) => ((list || []).length === 0 ? "Empty" : undefined)],
-        config: {
-            title: { type: "value", rules: [index_1.required] },
-        },
-    },
-};
+const formConfig = index_1.f.config({
+    firstName: index_1.f.value().req(),
+    lastName: index_1.f.value().readOnly(),
+    books: index_1.f
+        .list({
+        title: index_1.f.value().req(),
+    })
+        .rule(({ value }) => (value.length === 0 ? "Empty" : undefined)),
+});
 function TextField(props) {
     const { field } = props;
     // Somewhat odd: input won't update unless we use <Observer>, even though our

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { Fragment, ObjectState } from "./fields/objectField";
 import { Rule } from "./rules";
-import { Builtin } from "./utils";
+import { Builtin, OmitIf } from "./utils";
 /**
  * Config rules for each field in `T` that we're editing in a form.
  *
@@ -8,17 +8,14 @@ import { Builtin } from "./utils";
  * the caller define field-specific behavior, i.e. validation rules.
  */
 export type ObjectConfig<T> = {
-    [P in keyof OmitIf<T, Function>]: T[P] extends Fragment<infer V> ? FragmentFieldConfig : T[P] extends Array<infer U> | null | undefined ? U extends Builtin ? ValueFieldConfig<T, T[P]> : ListFieldConfig<T, U> : ValueFieldConfig<T, T[P]> | ObjectFieldConfig<T[P]>;
+    [P in keyof OmitIf<T, Function>]: T[P] extends Fragment<infer V> ? FragmentFieldConfig : T[P] extends Array<infer U> | null | undefined ? U extends Builtin ? ValueFieldConfig<T[P]> : ListFieldConfig<U> : ValueFieldConfig<T[P]> | ObjectFieldConfig<T[P]>;
 };
-type OmitIf<Base, Condition> = Pick<Base, {
-    [Key in keyof Base]: Base[Key] extends Condition ? never : Key;
-}[keyof Base]>;
 /** Field configuration for an opaque value that we don't actually want to include. */
 export type FragmentFieldConfig = {
     type: "fragment";
 };
 /** Field configuration for primitive values, i.e. strings/numbers/Dates/user-defined types. */
-export type ValueFieldConfig<T, V> = {
+export type ValueFieldConfig<V> = {
     type: "value";
     rules?: Rule<V | null | undefined>[];
     /**
@@ -45,7 +42,7 @@ export type ValueFieldConfig<T, V> = {
     strictOrder?: false;
 };
 /** Field configuration for list values, i.e. `U` is `Book` in a form with `books: Book[]`. */
-export type ListFieldConfig<T, U> = {
+export type ListFieldConfig<U> = {
     type: "list";
     /** Rules that can run on the full list of children. */
     rules?: Rule<readonly ObjectState<U>[]>[];
@@ -71,4 +68,3 @@ export type ObjectFieldConfig<U> = {
     /** Config for the child's form state, i.e. each book. */
     config: ObjectConfig<U>;
 };
-export {};

package/dist/configBuilders.d.ts

@@ -0,0 +1,60 @@
+import { FragmentFieldConfig, ListFieldConfig, ObjectConfig, ValueFieldConfig } from "./config";
+import { Fragment, ObjectState } from "./fields/objectField";
+import { Rule } from "./rules";
+import { Builtin, OmitIf } from "./utils";
+/**
+ * Provides a Zod-ish API for building form configs.
+ */
+export declare const f: {
+    /** Creates the top-level config for a form, like an author or book. */
+    config<T>(fields: ObjectConfigBuilderFields<T>): ObjectConfig<T>;
+    /** Creates the config DSL for an object, like an author or book. */
+    object<T_1>(fields: ObjectConfigBuilderFields<T_1>): ObjectConfigBuilder<T_1>;
+    /** Creates the config DSL for an list of objects, like an author's list of books. */
+    list<U>(fields: ObjectConfigBuilderFields<U>): ListFieldConfigBuilder<U>;
+    /** Creates the config DSL for a primitive value, like a first name or phone number. */
+    value<V>(): ValueFieldConfigBuilder<V>;
+    /** A shorthand for creating a computed value. */
+    computed<V_1>(): ValueFieldConfigBuilder<V_1>;
+};
+/**
+ * Defines the fields that should be passed into `f.object({ ... })` for fhe form type `T`.
+ *
+ * This is basically a map of `key` in `T` to `f.value()`, `f.list()`, or `f.object()`
+ * DSL objects that define the runtime structure/fields of the form.
+ */
+export type ObjectConfigBuilderFields<T> = {
+    [P in keyof OmitIf<T, Function>]: T[P] extends Fragment<infer V> ? FragmentFieldConfigBuilder : T[P] extends Array<infer U> | null | undefined ? U extends Builtin ? ValueFieldConfigBuilder<T[P]> : ListFieldConfigBuilder<U> : ValueFieldConfigBuilder<T[P]> | ObjectConfigBuilder<T[P]>;
+};
+export interface FragmentFieldConfigBuilder {
+    build(): FragmentFieldConfig;
+}
+/** Provides a fluent DSL for building up an object's config. */
+export declare class ObjectConfigBuilder<T> {
+    private config;
+    constructor(fields: ObjectConfigBuilderFields<T>);
+    build(): ObjectConfig<T>;
+}
+/** Provides a fluent DSL for building up a value's config. */
+export declare class ValueFieldConfigBuilder<V> {
+    private config;
+    /** Marks the field as required. */
+    req(): this;
+    /** Marks the field as read only. */
+    readOnly(): this;
+    /** Appends `rules` to the field's validation rules. */
+    rules(rules: Rule<V | null | undefined>[]): this;
+    /** Marks the field as computed. */
+    computed(): this;
+    build(): ValueFieldConfig<V>;
+}
+/** Provides a fluent DSL for building up a list's config. */
+export declare class ListFieldConfigBuilder<U> {
+    private config;
+    constructor(fields: ObjectConfigBuilderFields<U>);
+    /** Appends `rule` to the field's validation rules. */
+    rule(rule: Rule<readonly ObjectState<U>[]>): this;
+    /** Appends `rules` to the field's validation rules. */
+    rules(rules: Rule<readonly ObjectState<U>[]>[]): this;
+    build(): ListFieldConfig<U>;
+}

package/dist/configBuilders.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListFieldConfigBuilder = exports.ValueFieldConfigBuilder = exports.ObjectConfigBuilder = exports.f = void 0;
+const rules_1 = require("./rules");
+/**
+ * Provides a Zod-ish API for building form configs.
+ */
+exports.f = {
+    /** Creates the top-level config for a form, like an author or book. */
+    config(fields) {
+        return new ObjectConfigBuilder(fields).build();
+    },
+    /** Creates the config DSL for an object, like an author or book. */
+    object(fields) {
+        return new ObjectConfigBuilder(fields);
+    },
+    /** Creates the config DSL for an list of objects, like an author's list of books. */
+    list(fields) {
+        return new ListFieldConfigBuilder(fields);
+    },
+    /** Creates the config DSL for a primitive value, like a first name or phone number. */
+    value() {
+        return new ValueFieldConfigBuilder();
+    },
+    /** A shorthand for creating a computed value. */
+    computed() {
+        return this.value().computed();
+    },
+};
+/** Provides a fluent DSL for building up an object's config. */
+class ObjectConfigBuilder {
+    constructor(fields) {
+        this.config = {};
+        for (const [key, value] of Object.entries(fields)) {
+            this.config[key] = value.build();
+        }
+    }
+    build() {
+        return this.config;
+    }
+}
+exports.ObjectConfigBuilder = ObjectConfigBuilder;
+/** Provides a fluent DSL for building up a value's config. */
+class ValueFieldConfigBuilder {
+    constructor() {
+        this.config = { type: "value", rules: [] };
+    }
+    /** Marks the field as required. */
+    req() {
+        this.config.rules = [rules_1.required];
+        return this;
+    }
+    /** Marks the field as read only. */
+    readOnly() {
+        this.config.readOnly = true;
+        return this;
+    }
+    /** Appends `rules` to the field's validation rules. */
+    rules(rules) {
+        var _a;
+        var _b;
+        ((_a = (_b = this.config).rules) !== null && _a !== void 0 ? _a : (_b.rules = [])).push(...rules);
+        return this;
+    }
+    /** Marks the field as computed. */
+    computed() {
+        this.config.computed = true;
+        return this;
+    }
+    build() {
+        return this.config;
+    }
+}
+exports.ValueFieldConfigBuilder = ValueFieldConfigBuilder;
+/** Provides a fluent DSL for building up a list's config. */
+class ListFieldConfigBuilder {
+    constructor(fields) {
+        const config = {};
+        for (const [key, value] of Object.entries(fields)) {
+            config[key] = value.build();
+        }
+        this.config = { type: "list", rules: [], config };
+    }
+    /** Appends `rule` to the field's validation rules. */
+    rule(rule) {
+        var _a;
+        var _b;
+        ((_a = (_b = this.config).rules) !== null && _a !== void 0 ? _a : (_b.rules = [])).push(rule);
+        return this;
+    }
+    /** Appends `rules` to the field's validation rules. */
+    rules(rules) {
+        var _a;
+        var _b;
+        ((_a = (_b = this.config).rules) !== null && _a !== void 0 ? _a : (_b.rules = [])).push(...rules);
+        return this;
+    }
+    build() {
+        return this.config;
+    }
+}
+exports.ListFieldConfigBuilder = ListFieldConfigBuilder;

package/dist/fields/listField.d.ts

@@ -8,4 +8,4 @@ export interface ListFieldState<U> extends Omit<FieldState<U[]>, "originalValue"
     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<readonly ObjectState<U>[]>[], listConfig: ListFieldConfig<T, U>, config: ObjectConfig<U>, strictOrder: boolean, maybeAutoSave: () => void): ListFieldState<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<U>, config: ObjectConfig<U>, strictOrder: boolean, maybeAutoSave: () => void): ListFieldState<U>;

package/dist/fields/valueField.d.ts

@@ -11,7 +11,9 @@ import { Rule } from "../rules";
  * i.e. text boxes, can always be cleared out/deleted.
  */
 export interface FieldState<V> {
+    /** The key in the parent object, i.e. `firstName` in `author: { firstName: string }`. */
     readonly key: string;
+    /** The current value of the field. */
     value: V;
     readonly originalValue: V;
     touched: boolean;

package/dist/formState.test.d.ts

@@ -1 +1,11 @@
-export {};
+export declare class ObservableObject {
+    firstName: string | undefined;
+    lastName: string | undefined;
+    age?: number | undefined;
+    constructor();
+    get fullName(): string;
+    set fullName(fullName: string);
+    toInput(): {
+        firstName: string | undefined;
+    };
+}

package/dist/formState.test.js

@@ -1,55 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableObject = void 0;
 const mobx_1 = require("mobx");
+const configBuilders_1 = require("./configBuilders");
 const objectField_1 = require("./fields/objectField");
 const formStateDomain_1 = require("./formStateDomain");
 const rules_1 = require("./rules");
-describe("mobx behavior", () => {
-    it("mobx batches if in actions", () => {
-        const a = (0, mobx_1.observable)({ name: "a1" });
-        const b = (0, mobx_1.observable)({ name: "b1" });
-        const map = new mobx_1.ObservableMap();
-        map.set("a", a);
-        map.set("b", b);
-        let runs = 0;
-        (0, mobx_1.autorun)(() => {
-            noop([...map.values()].filter((v) => v.name.includes("1")));
-            runs++;
-        });
-        expect(runs).toBe(1);
-        // When we change both a and b
-        (0, mobx_1.runInAction)(() => {
-            a.name = "a11";
-            b.name = "b2";
-        });
-        // Then the reaction waited and only ran once
-        expect(runs).toBe(2);
-    });
-    it("mobx can watch undefined keys", () => {
-        const a = new ObservableObject();
-        const b = new ObservableObject();
-        const map = new mobx_1.ObservableMap();
-        map.set("a", a);
-        map.set("b", b);
-        let runs = 0;
-        (0, mobx_1.autorun)(() => {
-            noop([...map.values()].map((a) => a.age));
-            runs++;
-        });
-        expect(runs).toBe(1);
-        b.age = 1;
-        expect(runs).toBe(2);
-    });
-    it("mobx lists maintain observable identity", () => {
-        // given a parent observable
-        const a = (0, mobx_1.observable)({ list: [] });
-        // if we observable-ize a value being pushing it on the list
-        const c1 = (0, mobx_1.observable)({});
-        a.list.push(c1);
-        // then we get identify equality on the list lookups
-        expect(a.list[0] === c1).toEqual(true);
-    });
-});
 describe("formState", () => {
     it("can create a simple object", () => {
         const a = (0, objectField_1.createObjectState)({ title: { type: "value", rules: [rules_1.required] } }, {});
@@ -968,6 +924,15 @@ describe("formState", () => {
         // Throw away assertion, test is making sure ^ line compiles
         expect(config).toBeDefined();
     });
+    it("supports observable objects with helper methods in the config DSL", () => {
+        const config = configBuilders_1.f.config({
+            firstName: configBuilders_1.f.value(),
+            lastName: configBuilders_1.f.value(),
+            fullName: configBuilders_1.f.computed(),
+        });
+        // Throw away assertion, test is making sure ^ line compiles
+        expect(config).toBeDefined();
+    });
     it("can reset observable objects with computeds", () => {
         const formState = (0, objectField_1.createObjectState)({
             firstName: { type: "value" },
@@ -1512,19 +1477,17 @@ class ObservableObject {
         return { firstName: this.firstName };
     }
 }
-const authorWithBooksConfig = {
-    id: { type: "value" },
-    firstName: { type: "value" },
-    lastName: { type: "value" },
-    books: {
-        type: "list",
-        config: {
-            id: { type: "value" },
-            title: { type: "value", rules: [rules_1.required] },
-            classification: { type: "value" },
-        },
-    },
-};
+exports.ObservableObject = ObservableObject;
+const authorWithBooksConfig = configBuilders_1.f.config({
+    id: configBuilders_1.f.value(),
+    firstName: configBuilders_1.f.value(),
+    lastName: configBuilders_1.f.value(),
+    books: configBuilders_1.f.list({
+        id: configBuilders_1.f.value(),
+        title: configBuilders_1.f.value().req(),
+        classification: configBuilders_1.f.value(),
+    }),
+});
 function createAuthorInputState(input, maybeAutoSave) {
     return (0, objectField_1.createObjectState)(authorWithBooksConfig, input, { maybeAutoSave });
 }
@@ -1540,27 +1503,42 @@ const authorWithAddressConfig = {
         },
     },
 };
-const authorWithAddressAndBooksConfig = {
-    id: { type: "value" },
-    firstName: { type: "value" },
-    lastName: { type: "value" },
-    address: {
-        type: "object",
-        config: {
-            id: { type: "value" },
-            street: { type: "value", rules: [rules_1.required] },
-            city: { type: "value" },
-        },
-    },
-    books: {
-        type: "list",
-        config: {
-            id: { type: "value" },
-            title: { type: "value", rules: [rules_1.required] },
-            classification: { type: "value" },
-        },
-    },
-};
+const authorWithAddressAndBooksConfig = configBuilders_1.f.config({
+    id: configBuilders_1.f.value(),
+    firstName: configBuilders_1.f.value(),
+    lastName: configBuilders_1.f.value(),
+    address: configBuilders_1.f.object({
+        id: configBuilders_1.f.value(),
+        street: configBuilders_1.f.value().rules([rules_1.required]),
+        city: configBuilders_1.f.value(),
+    }),
+    books: configBuilders_1.f.list({
+        id: configBuilders_1.f.value(),
+        title: configBuilders_1.f.value(),
+        classification: configBuilders_1.f.value(),
+    }),
+});
+// const authorWithAddressAndBooksConfig: ObjectConfig<AuthorInput> = {
+//   id: { type: "value" },
+//   firstName: { type: "value" },
+//   lastName: { type: "value" },
+//   address: {
+//     type: "object",
+//     config: {
+//       id: { type: "value" },
+//       street: { type: "value", rules: [required] },
+//       city: { type: "value" },
+//     },
+//   },
+//   books: {
+//     type: "list",
+//     config: {
+//       id: { type: "value" },
+//       title: { type: "value", rules: [required] },
+//       classification: { type: "value" },
+//     },
+//   },
+// };
 function createAuthorWithAddressInputState(input) {
     return (0, objectField_1.createObjectState)(authorWithAddressConfig, input);
 }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { ObjectConfig } from "./config";
+export { f } from "./configBuilders";
 export { ListFieldState } from "./fields/listField";
 export { ObjectState, createObjectState } from "./fields/objectField";
 export { FieldState, ValueAdapter } from "./fields/valueField";

package/dist/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useFormStates = exports.useFormState = exports.required = exports.createObjectState = void 0;
+exports.useFormStates = exports.useFormState = exports.required = exports.createObjectState = exports.f = void 0;
+var configBuilders_1 = require("./configBuilders");
+Object.defineProperty(exports, "f", { enumerable: true, get: function () { return configBuilders_1.f; } });
 var objectField_1 = require("./fields/objectField");
 Object.defineProperty(exports, "createObjectState", { enumerable: true, get: function () { return objectField_1.createObjectState; } });
 var rules_1 = require("./rules");

package/dist/mobx-behavior.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mobx-behavior.test.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mobx_1 = require("mobx");
+const formState_test_1 = require("./formState.test");
+describe("mobx behavior", () => {
+    it("mobx batches if in actions", () => {
+        const a = (0, mobx_1.observable)({ name: "a1" });
+        const b = (0, mobx_1.observable)({ name: "b1" });
+        const map = new mobx_1.ObservableMap();
+        map.set("a", a);
+        map.set("b", b);
+        let runs = 0;
+        (0, mobx_1.autorun)(() => {
+            noop([...map.values()].filter((v) => v.name.includes("1")));
+            runs++;
+        });
+        expect(runs).toBe(1);
+        // When we change both a and b
+        (0, mobx_1.runInAction)(() => {
+            a.name = "a11";
+            b.name = "b2";
+        });
+        // Then the reaction waited and only ran once
+        expect(runs).toBe(2);
+    });
+    it("mobx can watch undefined keys", () => {
+        const a = new formState_test_1.ObservableObject();
+        const b = new formState_test_1.ObservableObject();
+        const map = new mobx_1.ObservableMap();
+        map.set("a", a);
+        map.set("b", b);
+        let runs = 0;
+        (0, mobx_1.autorun)(() => {
+            noop([...map.values()].map((a) => a.age));
+            runs++;
+        });
+        expect(runs).toBe(1);
+        b.age = 1;
+        expect(runs).toBe(2);
+    });
+    it("mobx lists maintain observable identity", () => {
+        // given a parent observable
+        const a = (0, mobx_1.observable)({ list: [] });
+        // if we observable-ize a value being pushing it on the list
+        const c1 = (0, mobx_1.observable)({});
+        a.list.push(c1);
+        // then we get identify equality on the list lookups
+        expect(a.list[0] === c1).toEqual(true);
+    });
+});
+function noop(t) { }

package/dist/stackoverlfow.d.ts

@@ -0,0 +1,17 @@
+declare const c: {
+    value<V>(): ValueConfig<V>;
+};
+type Config<T> = {
+    [P in keyof T]: ValueConfig<T[P]>;
+};
+declare function config<T>(object: Config<T>): void;
+interface ValueConfig<V> {
+    req(): ValueConfig<V>;
+    readOnly(): ValueConfig<V>;
+    validate(fn: (value: V) => boolean): ValueConfig<V>;
+}
+type Author = {
+    name: string;
+    address: string;
+    city: string;
+};

package/dist/stackoverlfow.js

@@ -0,0 +1,17 @@
+"use strict";
+// Create a Zod-style fluent DSL for building config
+const c = {
+    value() {
+        return null;
+    },
+};
+function config(object) { }
+// Try and configure the author
+config({
+    // correctly inferred as c.value<string> --> ValueConfig<string>
+    name: c.value(),
+    // inferred only as c.value<unknown> --> ValueConfig<unknown>
+    address: c.value().req(),
+    // compile error, v is implicitly typed as any
+    city: c.value().validate((v) => v.length > 0),
+});

package/dist/utils.d.ts

@@ -8,6 +8,9 @@ export type Primitive = undefined | null | boolean | string | number | Function
 export type DeepRequired<T> = T extends Primitive ? T : {
     [P in keyof Required<T>]: T[P] extends Array<infer U> ? Array<DeepRequired<U>> : T[P] extends ReadonlyArray<infer U2> ? ReadonlyArray<DeepRequired<U2>> : DeepRequired<T[P]>;
 };
+export type OmitIf<Base, Condition> = Pick<Base, {
+    [Key in keyof Base]: Base[Key] extends Condition ? never : Key;
+}[keyof Base]>;
 export declare function fail(message?: string): never;
 export declare function assertNever(x: never): never;
 /** Introspects the `init` prop to see if has a `map` function/etc. and returns the form value. */

package/package.json

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