@homebound/form-state 2.32.0 → 3.0.0

package/dist/fields/objectField.js

@@ -1,277 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fragment = fragment;
-exports.createObjectState = createObjectState;
-exports.newObjectState = newObjectState;
-const mobx_1 = require("mobx");
-const fragmentField_1 = require("./fragmentField");
-const listField_1 = require("./listField");
-const valueField_1 = require("./valueField");
-const utils_1 = require("../utils");
-const fragmentSym = Symbol("fragment");
-function fragment(value) {
-    return value;
-}
-/**
- * Creates a new `ObjectState` for a given form object `T` given config rules in `config`.
- *
- * The returned `ObjectState` can be used in a mobx `useLocalObservable` to drive an
- * interactive form that tracks the current valid/touched/etc. state of both each
- * individual fields as well as the top-level form/object itself.
- */
-function createObjectState(config, instance, opts = {}) {
-    const 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, 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.
-    let proxy = undefined;
-    function getObjectState() {
-        if (!proxy) {
-            throw new Error("Race condition");
-        }
-        return proxy;
-    }
-    // We directly mutate `instance` as the user edits the form, so keep a deep copy of the POJO.
-    // If the user passed us `instance` that was a mobx store/class, this originalValue won't really
-    // be a true match (i.e. pass instanceof), but it should be good enough
-    const originalCopy = (0, utils_1.deepClone)(instance);
-    const objectConfig = config.config;
-    const fieldStates = Object.entries(objectConfig).map(([_key, _config]) => {
-        var _a, _b, _c, _d;
-        const key = _key;
-        const config = _config;
-        let field;
-        if (config.type === "value") {
-            field = (0, valueField_1.newValueFieldState)(originalCopy, instance, getObjectState, key, config.rules || [], config.isIdKey ||
-                // 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, 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);
-        }
-        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, deepExhaustive);
-        }
-        else if (config.type === "object") {
-            // Because our objectField will fundamentally want to do `child.firstName.set(...)` or
-            // even `child.firstName !== undefined`, etc., we "simplify" things by always setting
-            // an empty object, for our child valueFields/listFields to use/read from, although
-            // we then have to "oh right ignore {}" in places like `dirty`.
-            if (!instance[key]) {
-                instance[key] = {};
-            }
-            field = newObjectState(config, getObjectState, instance, undefined, instance[key], key, maybeAutoSave, deepExhaustive);
-        }
-        else if (config.type === "fragment") {
-            field = (0, fragmentField_1.newFragmentField)(instance, key);
-        }
-        else {
-            throw new Error(`Invalid type value ${config.type}`);
-        }
-        return [key, field];
-    });
-    // We always return the same `instance` field from our `value` method, but
-    // we want to pretend that it's observable, so use a tick to force it.
-    const _tick = (0, mobx_1.observable)({ value: 1 });
-    const fieldNames = Object.keys(objectConfig);
-    function getFields(proxyThis) {
-        return fieldNames.map((name) => proxyThis[name]);
-    }
-    const obj = {
-        ...Object.fromEntries(fieldStates),
-        key,
-        get value() {
-            _tick.value > 0 || (0, utils_1.fail)();
-            return instance;
-        },
-        set value(value) {
-            this.set(value);
-        },
-        // private
-        _kind: "object",
-        _readOnly: false,
-        _loading: false,
-        _isAutoSaving: false,
-        _considerDeleted() {
-            const deleteField = getFields(this).find((f) => f._isDeleteKey);
-            return !!(deleteField === null || deleteField === void 0 ? void 0 : deleteField.value);
-        },
-        _considerReadOnly() {
-            const readOnlyField = getFields(this).find((f) => f._isReadOnlyKey);
-            return !!(readOnlyField === null || readOnlyField === void 0 ? void 0 : readOnlyField.value);
-        },
-        get focused() {
-            return getFields(this).some((f) => f.focused);
-        },
-        get touched() {
-            return getFields(this).some((f) => f.touched);
-        },
-        set touched(touched) {
-            getFields(this).forEach((f) => (f.touched = touched));
-        },
-        get readOnly() {
-            return (this._readOnly ||
-                this._considerReadOnly() ||
-                (parentState && parentState().readOnly) ||
-                !!(parentListState === null || parentListState === void 0 ? void 0 : parentListState.readOnly));
-        },
-        set readOnly(readOnly) {
-            this._readOnly = readOnly;
-        },
-        get loading() {
-            return this._loading || (parentState && parentState().loading) || !!(parentListState === null || parentListState === void 0 ? void 0 : parentListState.loading);
-        },
-        set loading(loading) {
-            this._loading = loading;
-        },
-        get valid() {
-            return getFields(this).every((f) => {
-                return f.valid;
-            });
-        },
-        get errors() {
-            return getFields(this).flatMap((f) => f.errors.map((e) => `${f.key}: ${e}`));
-        },
-        get 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, {})));
-        },
-        get isNewEntity() {
-            const idField = getFields(this).find((f) => f._isIdKey);
-            // If we're a line item w/o an immediate id field, look in our parent
-            if (!idField && parentState) {
-                return parentState().isNewEntity;
-            }
-            // If there is no id field, assume we're not new
-            return idField !== undefined && (idField.value === null || idField.value === undefined);
-        },
-        canSave() {
-            this.touched = true;
-            return this.valid;
-        },
-        // Accepts new values in bulk, i.e. when setting the form initial state from the backend.
-        set(value, opts = {}) {
-            if (this.readOnly && !opts.resetting && !opts.refreshing) {
-                throw new Error(`${String(key) || "formState"} is currently readOnly`);
-            }
-            // Restore our instance if we're being reset
-            if (value && this.isUnset())
-                parentInstance[key] = instance;
-            // Delete our instance if we're being unset
-            if (!value && parentInstance)
-                parentInstance[key] = undefined;
-            // Otherwise just copy over the fields
-            getFields(this).forEach((field) => {
-                if (value && typeof value === "object" && field.key in value) {
-                    field.set(value[field.key], opts);
-                }
-            });
-        },
-        // Resets all fields back to their original values
-        revertChanges() {
-            getFields(this).forEach((f) => f.revertChanges());
-        },
-        // Saves all current values into _originalValue.
-        // Deprecated: use formState.update(ackedServerValue) so saved changes are audited field-by-field.
-        commitChanges() {
-            if (this._isAutoSaving) {
-                // `commitChanges` will mark all WIP changes as committed, which might drop changes if there
-                // is an auto-save in-flight, and the user made more changes, that are waiting for their turn
-                // on the next auto-save request.
-                //
-                // Instead of doing a form-wide "all changes are committed", autosave forms should use
-                // formState.update(ackedServerValue), or init.map/input, to apply the server's latest results
-                // within the form. That selectively "un-dirty"/commits the just-saved data, but keeps the
-                // "still-dirty" WIP data alone.
-                throw new Error("When using autoSave, you should not manually call commitChanges, instead have init.map/input update the form state");
-            }
-            // asdf
-            getFields(this).forEach((f) => f.commitChanges());
-        },
-        // Create a result that is only populated with changed keys
-        get changedValue() {
-            const result = {};
-            // If we're a child, like `author.address` that was unset, return null
-            if (this.isUnset()) {
-                // If we're a reference, always return `{ id: ... }` for easy binding
-                const idField = getFields(this).find((f) => f._isIdKey);
-                if (idField && config.reference)
-                    return { id: null };
-                // Otherwise mark the whole child as gone
-                return null;
-            }
-            getFields(this).forEach((f) => {
-                var _a;
-                if (f._computed)
-                    return;
-                // 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.
-                    (this.isNewEntity && f._kind === "value" && f.value !== undefined) ||
-                    // ...or they're non-empty sub-objects
-                    (this.isNewEntity &&
-                        f._kind === "object" &&
-                        // Child objects that are unset will have `changedValue = null`
-                        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) ||
-                    // ...or the parent list is deep-exhaustive
-                    deepExhaustive) {
-                    result[f.key] = f.changedValue;
-                }
-            });
-            // Ensure we always have the id for updates to work
-            const idField = getFields(this).find((f) => f._isIdKey);
-            if (idField && idField.value !== undefined) {
-                result[idField.key] = idField.value;
-            }
-            return result;
-        },
-        get originalValue() {
-            getFields(proxy).map((f) => f.originalValue);
-            return originalCopy;
-        },
-        // An internal helper method to see if `other` is for "the same entity" as our current row
-        isSameEntity(other) {
-            const idField = getFields(this).find((f) => f._isIdKey);
-            if (!idField)
-                return false;
-            const ourIdValue = idField.value;
-            const otherIdValue = other[idField.key];
-            // If the otherIdValue is undefined, it's a new entity so can't be the same as us
-            return otherIdValue !== undefined && (0, utils_1.areEqual)(otherIdValue, ourIdValue);
-        },
-        isUnset() {
-            return !!parentInstance && parentInstance[key] === undefined;
-        },
-        get idKey() {
-            var _a;
-            return (_a = getFields(this).find((f) => f._isIdKey)) === null || _a === void 0 ? void 0 : _a.key;
-        },
-    };
-    proxy = (0, mobx_1.makeAutoObservable)(obj, {
-        // Use custom equality on `value` that is _never_ equals. This sounds weird, but
-        // because our `value` is always the same `instance` that was passed to `newObjectState`,
-        // to mobx this looks like the value never changes, and it will never invoke observers
-        // even with our tick-based hacks.
-        value: (0, mobx_1.computed)({ equals: () => false }),
-        originalValue: (0, mobx_1.computed)({ equals: () => false }),
-    });
-    // Any time a field changes, percolate that change up to us
-    (0, mobx_1.reaction)(() => getFields(proxy).map((f) => f.value), () => _tick.value++);
-    return proxy;
-}

package/dist/fields/valueField.d.ts

@@ -1,81 +0,0 @@
-import { ObjectState } from "./objectField";
-import { Rule } from "../rules";
-/**
- * Form state for a primitive field in the form, i.e. its value but also touched/validation/etc. state.
- *
- * This API also provides hooks for form elements to call into, i.e. `blur()` and `set(...)` that will
- * update the field state and re-render, i.e. when including in an `ObjectState`-typed literal that is
- * an mobx `useLocalObservable`/observable.
- *
- * 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<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;
-    readOnly: boolean;
-    loading: boolean;
-    readonly required: boolean;
-    readonly dirty: boolean;
-    readonly valid: boolean;
-    readonly focused: boolean;
-    readonly isNewEntity: boolean;
-    rules: Rule<V>[];
-    readonly errors: string[];
-    /** Returns a subset of V with only the changed values. Currently not observable. */
-    readonly changedValue: V;
-    /** Focuses the field. Disables changes from `ObjectState.set` calls. */
-    focus(): void;
-    /** Blur marks the field as touched and triggers an auto-save. */
-    blur(): void;
-    /** Triggers an auto-save; the caller (i.e. useFormState) should still dirty & valid check. */
-    maybeAutoSave(): void;
-    set(value: V, opts?: SetOpts): void;
-    /** Reverts back to the original value and resets dirty/touched. */
-    revertChanges(): void;
-    /**
-     * Accepts the current changed value (if any) as the original and resets dirty/touched.
-     *
-     * @deprecated Use `formState.update(ackedServerValue)` instead. `commitChanges` marks all current
-     * changes as saved, which risks discarding a user's in-flight edits. Updating from the server ack gives
-     * form-state a field-by-field audit of which changes were successfully saved.
-     */
-    commitChanges(): void;
-    /** Creates a new FieldState with a transformation of the value, i.e. string to int, or feet to inches. */
-    adapt<V2>(adapter: ValueAdapter<V, V2>): FieldState<V2>;
-}
-/**
- * Allows changing a type in the formState (like a string) to a different type in the UI (like a number).
- *
- * Or doing unit of measure conversions within the same type, like from meters to feet.
- */
-export interface ValueAdapter<V, V2 = V> {
-    /** Converts the original FieldState's value `V` into new `V2` type. */
-    toValue(value: V): V2;
-    /** Converts the adapted FieldState's value `V2` back into the original `V` type. */
-    fromValue(value: V2): V;
-}
-/** Public options for our `set` command. */
-export interface SetOpts {
-    /** Whether this `set` should trigger an auto-save; defaults to true. */
-    autoSave?: boolean;
-}
-/** Internal `.set` opts for conditionally that form-state internally percolates. */
-export interface InternalSetOpts extends SetOpts {
-    /** `resetting` is the code calling `.reset()` to revert to original values. */
-    resetting?: boolean;
-    /** `refreshing` is when `useFormState` sees a new value. */
-    refreshing?: boolean;
-}
-export interface FieldStateInternal<T, V> extends FieldState<V> {
-    set(value: V, opts?: InternalSetOpts): void;
-    _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, isLocalOnly: boolean, computed: boolean, readOnly: boolean, strictOrder: boolean, maybeAutoSave: () => void): FieldState<T[K] | null | undefined>;

package/dist/fields/valueField.js

@@ -1,244 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.newValueFieldState = newValueFieldState;
-const is_plain_object_1 = require("is-plain-object");
-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, 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 });
-    const _originalValueTick = (0, mobx_1.observable)({ value: 1 });
-    // Track "this is probably what we put into a mutation to the server" to allow
-    // use to better accept server acks/responses that change our initial submission.
-    //
-    // I.e. we submit `firstName: bob` and the server acks `firstName: Bob`, we should
-    // accept it if we can tell we haven't changed `bob` since our initial submission.
-    let hasInflightChangedValue = false;
-    let lastChangedValue = undefined;
-    const field = {
-        key: key,
-        touched: false,
-        /** Current readOnly value. */
-        _readOnly: readOnly || false,
-        _loading: false,
-        _kind: "value",
-        // Expose so computed can be skipped in changedValue
-        _computed: computed,
-        _focused: false,
-        _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]
-            const value = _tick.value > 0 ? parentInstance[key] : (0, utils_1.fail)();
-            // Re-create the `keepNull` logic on sets but for our initial read where our
-            // originalValue is null (empty) but we want to expose it as undefined for
-            // consistency of "empty-ness" to our UI components.
-            return value === null && (0, utils_1.isEmpty)(parentCopy[key]) ? undefined : value;
-        },
-        set value(v) {
-            this.set(v);
-        },
-        get focused() {
-            return this._focused;
-        },
-        get dirty() {
-            return !(0, utils_1.areEqual)(this.originalValue, this.value, strictOrder);
-        },
-        /** Returns whether this field is readOnly, although if our parent is readOnly then it trumps. */
-        get readOnly() {
-            return parentState().readOnly || this._readOnly;
-        },
-        /** Sets the field readOnly, but `loading` will still be or-d with the parent's readOnly state. */
-        set readOnly(readOnly) {
-            this._readOnly = readOnly;
-        },
-        /** Returns whether this field is loading, or if our parent is loading. */
-        get loading() {
-            return parentState().loading || this._loading;
-        },
-        /** Sets the field loading, but `loading` will still be or-d with the parent's loading state. */
-        set loading(loading) {
-            this._loading = loading;
-        },
-        // For primitive fields, the changed value is just the value.
-        get changedValue() {
-            // Add some hints to let `set(..., { refreshing: true })` accept server-driven changes to our value,
-            // if the user hasn't changed it yet-again while the changedValue was in in-flight.
-            hasInflightChangedValue = true;
-            lastChangedValue = this.value;
-            // Usually if we see a field being unset, we set `parent[key] = null`, but if we're wrapping
-            // a mobx observable object, it might have changed to `undefined` without us being able to
-            // tell it to be `null` (and potentially break the type contract of `string | undefined`).
-            // So detect un-set-ness here and return `null`.
-            if (this.value === undefined && this.originalValue !== undefined)
-                return null;
-            return this.value;
-        },
-        get valid() {
-            const opts = { value: this.value, key: key, originalValue: this.originalValue, object: parentState() };
-            return this.rules.every((r) => r(opts) === undefined);
-        },
-        get errors() {
-            const opts = { value: this.value, key: key, originalValue: this.originalValue, object: parentState() };
-            return this.rules.map((r) => r(opts)).filter(utils_1.isNotUndefined);
-        },
-        get required() {
-            return this.rules.some((rule) => rule === rules_1.required);
-        },
-        get isNewEntity() {
-            return parentState().isNewEntity;
-        },
-        focus() {
-            this._focused = true;
-        },
-        blur() {
-            this.maybeAutoSave();
-            this._focused = false;
-        },
-        maybeAutoSave() {
-            // Now that the user is done editing the field (note maybe w/o blurring, i.e. if they hit enter), we sneak in some trim logic
-            this.maybeTrim();
-            // touched is readonly, but we're allowed to change it
-            this.touched = true;
-            maybeAutoSave();
-        },
-        set(value, opts = {}) {
-            if (this.readOnly && !opts.resetting && !opts.refreshing) {
-                throw new Error(`${String(key)} is currently readOnly`);
-            }
-            if (opts.refreshing && this.dirty) {
-                // See if we should ignore the incoming server-side value, to avoid dropping local WIP changes
-                const isAckingUnset = this.value === null && (value === null || value === undefined);
-                const acceptServerAck = hasInflightChangedValue &&
-                    this.value === lastChangedValue &&
-                    // If value === originalValue, this is likely a cache refresh firing in-between "we put the new value
-                    // on the wire" and "the server acked our change". Granted, this heuristic means that if the server
-                    // really does reject/rollback our change, we'll ignore it, but atm we don't have a way of differentiating
-                    // "this refresh is from a pre-response cache refresh" vs. "post-response cache refresh".
-                    value !== this.originalValue;
-                // Ignore incoming values if we have changes (this.dirty) unless:
-                // - our latest change (this.value) matches the incoming value (value), i.e. the server
-                //   is exactly acking our change, or
-                // - the user hasn't made any changes since `.changedValue` was put on the wire, i.e. the
-                //   server received our value, but wanted to change it.
-                // Compare by content (not `!==`) so array/list-of-primitive values are treated as acked when
-                // the server returns the same contents in a new array instance (otherwise the field would
-                // stay dirty forever, since reference equality never holds for a fresh array).
-                const keepLocalWipChange = !(0, utils_1.areEqual)(this.value, value, strictOrder) && !isAckingUnset && !acceptServerAck;
-                if (keepLocalWipChange)
-                    return;
-            }
-            else if (computed && (opts.resetting || opts.refreshing)) {
-                // Computeds can't be either reset or refreshed
-                return;
-            }
-            // If the user has deleted/emptied a value that was originally set, keep it as `null`
-            // so that our partial update to the backend correctly unsets it.
-            const keepNull = !(0, utils_1.isEmpty)(this.originalValue) && (0, utils_1.isEmpty)(value) && !opts.refreshing;
-            // If a list of primitives was originally undefined, coerce `[]` to `undefined`
-            const coerceEmptyList = value && value instanceof Array && value.length === 0 && (0, utils_1.isEmpty)(this.originalValue);
-            const newValue = keepNull ? null : (0, utils_1.isEmpty)(value) || coerceEmptyList ? undefined : value;
-            hasInflightChangedValue = false;
-            // Set the value on our parent object
-            const changed = !(0, utils_1.areEqual)(newValue, this.value, strictOrder);
-            parentInstance[key] = newValue;
-            _tick.value++;
-            if (opts.refreshing) {
-                this.originalValue = newValue;
-            }
-            // If we're being set programmatically, i.e. we don't currently have focus,
-            // call blur to trigger any auto-saves.
-            if (!this._focused && !opts.refreshing && !opts.resetting && this.dirty && changed && opts.autoSave !== false) {
-                this.maybeAutoSave();
-            }
-        },
-        adapt(adapter) {
-            return adapt(this, adapter);
-        },
-        revertChanges() {
-            if (!computed) {
-                this.set(this.originalValue, { resetting: true });
-            }
-            this.touched = false;
-        },
-        commitChanges() {
-            if ((0, is_plain_object_1.isPlainObject)(this.originalValue)) {
-                this.originalValue = (0, mobx_1.toJS)(this.value);
-            }
-            else {
-                this.originalValue = this.value;
-            }
-            this.touched = false;
-        },
-        get originalValue() {
-            // A dummy check to for reactivity around our non-proxy value
-            const value = _originalValueTick.value > -1 ? parentCopy[key] : parentCopy[key];
-            // Re-create the `keepNull` logic so that `.value` === `.originalValue`
-            return value === null ? undefined : value;
-        },
-        set originalValue(v) {
-            const canSkip = v === undefined && !(key in parentCopy);
-            if (!canSkip)
-                parentCopy[key] = v;
-            _originalValueTick.value++;
-        },
-        maybeTrim() {
-            if (typeof this.value === "string") {
-                let newValue = this.value.trim();
-                if (newValue === "") {
-                    newValue = undefined;
-                }
-                if (newValue !== this.value) {
-                    this.set(newValue);
-                }
-            }
-        },
-    };
-    // If we're wrapping a mobx observer, watching for external mutations, i.e. from callers not
-    // going through our FieldState.set/FieldState.value setters.
-    if ((0, mobx_1.isObservable)(parentInstance)) {
-        (0, mobx_1.reaction)(() => parentInstance[key], () => {
-            // Don't auto-save on maybe-external mutation if our field, or another other field (potentially a computed),
-            // is currently focused, because then it's probably just us doing the writes through `Bound...Field` components.
-            if (!parentState().focused)
-                maybeAutoSave();
-        });
-    }
-    return field;
-}
-/**
- * Returns a proxy that looks exactly like the original `field`, in terms of valid/touched/errors/etc., but
- * has any methods that use `V` overridden to use be `V2`.
- *
- * Note that `V2` can be a new type, like string -> number, or just a transformation on the same
- * type, i.e. feet -> inches where both are `number`s.
- */
-function adapt(field, adapter) {
-    return (0, proxies_1.newDelegateProxy)(field, {
-        rules: [],
-        get value() {
-            return adapter.toValue(field.value);
-        },
-        set value(v) {
-            field.value = adapter.fromValue(v);
-        },
-        set: (v) => {
-            field.value = adapter.fromValue(v);
-        },
-        get changedValue() {
-            return this.value;
-        },
-        adapt(adapter) {
-            return adapt(this, adapter);
-        },
-        get originalValue() {
-            return adapter.toValue(field.originalValue);
-        },
-    });
-}

package/dist/formState.stories.d.ts

@@ -1,4 +0,0 @@
-import { Meta } from "@storybook/react";
-declare const _default: Meta;
-export default _default;
-export declare function AppExample(): import("react/jsx-runtime").JSX.Element;

package/dist/formState.stories.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppExample = AppExample;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const FormStateApp_1 = require("./FormStateApp");
-exports.default = {
-    component: FormStateApp_1.FormStateApp,
-    title: "Components/Form State",
-};
-function AppExample() {
-    return (0, jsx_runtime_1.jsx)(FormStateApp_1.FormStateApp, {});
-}

package/dist/formState.test.d.ts

@@ -1,11 +0,0 @@
-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;
-    };
-}