@homebound/form-state 2.19.0 → 2.20.1

package/dist/formStateDomain.js

@@ -13,7 +13,7 @@ var Color;
     Color["Red"] = "RED";
     Color["Blue"] = "BLUE";
     Color["Green"] = "GREEN";
-})(Color = exports.Color || (exports.Color = {}));
+})(Color || (exports.Color = Color = {}));
 class DateOnly {
     constructor(date) {
         this.date = date;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { ObjectConfig } from "./config";
 export { ListFieldState } from "./fields/listField";
-export { createObjectState, ObjectState } from "./fields/objectField";
-export { FieldState } from "./fields/valueField";
-export { required, Rule } from "./rules";
+export { ObjectState, createObjectState } from "./fields/objectField";
+export { FieldState, ValueAdapter } from "./fields/valueField";
+export { Rule, required } from "./rules";
 export { useFormState } from "./useFormState";
 export { useFormStates } from "./useFormStates";

package/dist/proxies.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Creates a new combined object with keys in `overrides` taking precedence, and then
+ * any other keys falling back to `delegate`.
+ */
+export declare function newDelegateProxy<T extends object, O extends object>(delegate: T, overrides: O): Omit<T, keyof O> & O;

package/dist/proxies.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newDelegateProxy = void 0;
+/**
+ * Creates a new combined object with keys in `overrides` taking precedence, and then
+ * any other keys falling back to `delegate`.
+ */
+function newDelegateProxy(delegate, overrides) {
+    function pickTarget(key) {
+        return Reflect.has(overrides, key) ? overrides : delegate;
+    }
+    return new Proxy(delegate, {
+        get(object, key) {
+            return Reflect.get(pickTarget(key), key);
+        },
+        set(object, key, value) {
+            return Reflect.set(pickTarget(key), key, value);
+        },
+    });
+}
+exports.newDelegateProxy = newDelegateProxy;

package/dist/rules.d.ts

@@ -1,5 +1,5 @@
 /** A validation rule, given the value and name, return the error string if valid, or undefined if valid. */
-export declare type Rule<V> = (opts: {
+export type Rule<V> = (opts: {
     value: V;
     key: string;
     originalValue: V;

package/dist/rules.js

@@ -5,7 +5,7 @@ const mobx_1 = require("mobx");
 /** A rule that validates `value` is not `undefined`, `null`, or empty string. */
 // We pre-emptively make this a mobx action so that it's identity doesn't change when proxied
 // and breaks our ability to do `rules.some(r => r === required)`.
-exports.required = mobx_1.action(({ value: v }) => {
+exports.required = (0, mobx_1.action)(({ value: v }) => {
     const isEmptyString = typeof v === "string" ? v.trim() === "" : false;
     return v !== undefined && v !== null && !isEmptyString ? undefined : "Required";
 });

package/dist/setupTests.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("@testing-library/jest-dom");
 const mobx_1 = require("mobx");
 // formState doesn't use actions
-mobx_1.configure({ enforceActions: "never" });
+(0, mobx_1.configure)({ enforceActions: "never" });
 beforeEach(() => {
-    jest.useFakeTimers("modern");
+    jest.useFakeTimers();
 });
 afterEach(() => {
     jest.runOnlyPendingTimers();

package/dist/useFormState.d.ts

@@ -1,21 +1,21 @@
 import { ObjectConfig } from "./config";
 import { ObjectState } from "./fields/objectField";
-export declare type Query<I> = {
+export type Query<I> = {
     data: I;
     loading: boolean;
     error?: any;
 };
-export declare type InputAndMap<T, I> = {
+export type InputAndMap<T, I> = {
     input: I;
     map: (input: Exclude<I, null | undefined>) => T;
     ifUndefined?: T;
 };
-export declare type QueryAndMap<T, I> = {
+export type QueryAndMap<T, I> = {
     query: Query<I>;
     map: (input: Exclude<I, null | undefined>) => T;
     ifUndefined?: T;
 };
-export declare type UseFormStateOpts<T, I> = {
+export type UseFormStateOpts<T, I> = {
     /** The form configuration, should be a module-level const or useMemo'd. */
     config: ObjectConfig<T>;
     /**

package/dist/useFormState.js

@@ -18,15 +18,15 @@ let pendingAutoSave = false;
 function useFormState(opts) {
     const { config, init, addRules, readOnly = false, loading, autoSave } = opts;
     // Use a ref so our memo'ized `onBlur` always see the latest value
-    const autoSaveRef = react_1.useRef(autoSave);
+    const autoSaveRef = (0, react_1.useRef)(autoSave);
     autoSaveRef.current = autoSave;
-    const firstRunRef = react_1.useRef(true);
+    const firstRunRef = (0, react_1.useRef)(true);
     // This is a little weird, but we need to know ahead of time, before the form useMemo, if we're working with classes/mobx proxies
-    const [firstInitValue] = react_1.useState(() => utils_1.initValue(config, init));
-    const isWrappingMobxProxy = !is_plain_object_1.isPlainObject(firstInitValue);
+    const [firstInitValue] = (0, react_1.useState)(() => (0, utils_1.initValue)(config, init));
+    const isWrappingMobxProxy = !(0, is_plain_object_1.isPlainObject)(firstInitValue);
     // If they're using init.input, useMemo on it (and it might be an array), otherwise allow the identity of init be unstable
-    const dep = utils_1.isInput(init) ? makeArray(init.input) : utils_1.isQuery(init) ? [init.query.data, init.query.loading] : [];
-    const form = react_1.useMemo(() => {
+    const dep = (0, utils_1.isInput)(init) ? makeArray(init.input) : (0, utils_1.isQuery)(init) ? [init.query.data, init.query.loading] : [];
+    const form = (0, react_1.useMemo)(() => {
         function maybeAutoSave() {
             if (isAutoSaving === "in-flight") {
                 pendingAutoSave = true;
@@ -64,8 +64,8 @@ function useFormState(opts) {
                 }, 0);
             }
         }
-        const value = firstRunRef.current ? firstInitValue : utils_1.initValue(config, init);
-        const form = objectField_1.createObjectState(config, value, { maybeAutoSave });
+        const value = firstRunRef.current ? firstInitValue : (0, utils_1.initValue)(config, init);
+        const form = (0, objectField_1.createObjectState)(config, value, { maybeAutoSave });
         form.readOnly = readOnly;
         setLoading(form, opts);
         // The identity of `addRules` is not stable, but assume that it is for better UX.
@@ -78,7 +78,7 @@ function useFormState(opts) {
     [config, ...(isWrappingMobxProxy ? dep : [])]);
     // We use useEffect so that any mutations to the proxies, which will call `setState`s on any observers to
     // queue their components' render), don't happen during our render, per https://fb.me/setstate-in-render.
-    react_1.useEffect(() => {
+    (0, react_1.useEffect)(() => {
         // Ignore the 1st run b/c our 1st useMemo already initialized `form` with the current `init` value.
         // Also for mobx proxies, we recreate a new form-state every time init changes, so that our
         // fields fundamentally pointing to the right proxy. So just defer to the ^ useMemo.
@@ -93,10 +93,10 @@ function useFormState(opts) {
         // rows in the table that our side panel's form has open/is focused on" (which ideally would
         // be treated as a full component remount by having an `key` field somewhere in the parent
         // component, but it's unlikely the user will always remember to do this).
-        form.set(utils_1.initValue(config, init), { refreshing: true });
+        form.set((0, utils_1.initValue)(config, init), { refreshing: true });
     }, [form, ...dep]);
     // Use useEffect so that we don't touch the form.init proxy during a render
-    react_1.useEffect(() => {
+    (0, react_1.useEffect)(() => {
         form.readOnly = readOnly;
         if (loading !== undefined) {
             form.loading = loading;
@@ -111,11 +111,11 @@ function setLoading(form, opts) {
         // Prefer the explicit/top-level opts.loading if it's set
         form.loading = loading;
     }
-    else if (utils_1.isInput(init) && !init.ifUndefined) {
+    else if ((0, utils_1.isInput)(init) && !init.ifUndefined) {
         // Otherwise, check for `init.input`
         form.loading = init.input === undefined;
     }
-    else if (utils_1.isQuery(init)) {
+    else if ((0, utils_1.isQuery)(init)) {
         // Or `query.loading`
         form.loading = init.query.loading;
     }