@rebasepro/forms 0.17.3 → 0.18.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Rebase
+Copyright (c) 2026 Rebase
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -8,6 +8,10 @@ Lightweight React form state management with undo/redo support.
 pnpm add @rebasepro/forms
 ```
 
+ESM-only: `"type": "module"` with no CommonJS build, so it is loaded with
+`import`. `require()` of it resolves only on Node 22.12+, which supports
+`require(esm)`.
+
 **Peer dependencies:** `react >= 19.0.0`, `react-dom >= 19.0.0`
 
 ## What This Package Does

package/package.json

@@ -1,11 +1,7 @@
 {
   "name": "@rebasepro/forms",
-  "type": "module",
-  "version": "0.17.3",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
+  "version": "0.18.1",
+  "description": "Schema-driven form components for Rebase collections.",
   "keywords": [
     "rebase",
     "forms",
@@ -13,21 +9,38 @@
     "react",
     "admin"
   ],
+  "homepage": "https://rebase.pro",
+  "bugs": {
+    "url": "https://github.com/rebasepro/rebase/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rebasepro/rebase.git",
+    "directory": "packages/forms"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.22.0"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "development": "./dist/index.es.js",
-      "import": "./dist/index.es.js"
+      "import": "./dist/index.es.js",
+      "default": "./dist/index.es.js"
     },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.es.js",
   "module": "./dist/index.es.js",
   "types": "dist/index.d.ts",
-  "source": "src/index.ts",
   "peerDependencies": {
-    "react": ">=19.0.0",
-    "react-dom": ">=19.0.0"
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7"
   },
   "dependencies": {
     "fast-equals": "6.0.2"
@@ -47,7 +60,6 @@
   },
   "files": [
     "dist",
-    "src",
     "bin"
   ],
   "jest": {
@@ -65,15 +77,11 @@
     ]
   },
   "gitHead": "d935eefa5aa8d1009a2398cfac2c1e4ee9aeb6b6",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/rebasepro/rebase.git",
-    "directory": "packages/forms"
-  },
   "scripts": {
     "dev": "vite",
     "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json && node ../../tooling/scripts/add-dts-extensions.mjs dist && node ../../tooling/scripts/assert-build-output.mjs",
     "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f",
-    "test": "jest --passWithNoTests"
+    "test": "jest --passWithNoTests",
+    "test:watch": "jest --watch"
   }
 }

package/src/Field.tsx

@@ -1,164 +0,0 @@
-import * as React from "react";
-import { useFormex } from "./Formex";
-import { getIn, isFunction, isObject } from "./utils";
-import { FormexController } from "./types";
-
-export interface FieldInputProps<Value> {
-    /** Value of the field */
-    value: Value;
-    /** Name of the field */
-    name: string;
-    /** Multiple select? */
-    multiple?: boolean;
-    /** Is the field checked? */
-    checked?: boolean;
-    /** Change event handler */
-    onChange: (event: React.SyntheticEvent) => void,
-    /** Blur event handler */
-    onBlur: (event: React.FocusEvent) => void,
-}
-
-export interface FormexFieldProps<Value = any, FormValues extends object = object> {
-    field: FieldInputProps<Value>;
-    form: FormexController<FormValues>;
-}
-
-export interface FieldConfig<Value, C extends React.ElementType | undefined = undefined> {
-
-    /**
-     * Component to render. Can either be a string e.g. 'select', 'input', or 'textarea', or a component.
-     */
-    as?:
-        | C
-        | string
-        | React.ForwardRefExoticComponent<Record<string, unknown>>;
-
-    /**
-     * Children render function <Field name>{props => ...}</Field>)
-     */
-    children?: ((props: FormexFieldProps<Value>) => React.ReactNode) | React.ReactNode;
-
-    /**
-     * Validate a single field value independently
-     */
-    // validate?: FieldValidator;
-
-    /**
-     * Used for 'select' and related input types.
-     */
-    multiple?: boolean;
-
-    /**
-     * Field name
-     */
-    name: string;
-
-    /** HTML input type */
-    type?: string;
-
-    /** Field value */
-    value?: unknown;
-
-    /** Inner ref */
-    innerRef?: (instance: unknown) => void;
-
-}
-
-export type FieldProps<T, C extends React.ElementType | undefined> = {
-    as?: C;
-} & (C extends React.ElementType ? (React.ComponentProps<C> & FieldConfig<T, C>) : FieldConfig<T, C>);
-
-export function Field<T, C extends React.ElementType | undefined = undefined>({
-                                                                                  validate,
-                                                                                  name,
-                                                                                  children,
-                                                                                  as: is, // `as` is reserved in typescript lol
-                                                                                  // component,
-                                                                                  className,
-                                                                                  ...props
-                                                                              }: FieldProps<T, C>) {
-    const formex = useFormex();
-
-    const field = getFieldProps({ name,
-...props }, formex);
-
-    if (isFunction(children)) {
-        return children({ field,
-form: formex });
-    }
-
-    // if (component) {
-    //     if (typeof component === "string") {
-    //         const { innerRef, ...rest } = props;
-    //         return React.createElement(
-    //             component,
-    //             { ref: innerRef, ...field, ...rest, className },
-    //             children
-    //         );
-    //     }
-    //     return React.createElement(
-    //         component,
-    //         { field, form: formex, ...props, className },
-    //         children
-    //     );
-    // }
-
-    // default to input here so we can check for both `as` and `children` above
-    const asElement = is || "input";
-
-    if (typeof asElement === "string") {
-        const { innerRef, ...rest } = props;
-        return React.createElement(
-            asElement,
-            { ref: innerRef,
-...field,
-...rest,
-className },
-            children
-        );
-    }
-
-    return React.createElement(asElement, { ...field,
-...props,
-className }, children);
-}
-
-const getFieldProps = (nameOrOptions: string | FieldConfig<unknown>, formex: FormexController<object>): FieldInputProps<unknown> => {
-    const name: string = typeof nameOrOptions === "string"
-        ? nameOrOptions
-        : nameOrOptions.name;
-    const valueState = getIn(formex.values as Record<string, unknown>, name);
-
-    const field: FieldInputProps<unknown> = {
-        name: name as string,
-        value: valueState,
-        onChange: formex.handleChange,
-        onBlur: formex.handleBlur
-    };
-    if (typeof nameOrOptions !== "string") {
-        const {
-            type,
-            value: valueProp, // value is special for checkboxes
-            as: is,
-            multiple
-        } = nameOrOptions as FieldConfig<unknown>;
-
-        if (type === "checkbox") {
-            if (valueProp === undefined) {
-                field.checked = !!valueState;
-            } else {
-                field.checked = !!(
-                    Array.isArray(valueState) && ~valueState.indexOf(valueProp)
-                );
-                field.value = valueProp;
-            }
-        } else if (type === "radio") {
-            field.checked = valueState === valueProp;
-            field.value = valueProp;
-        } else if (is === "select" && multiple) {
-            field.value = field.value || [];
-            field.multiple = true;
-        }
-    }
-    return field;
-};

package/src/Formex.tsx

@@ -1,15 +0,0 @@
-import React, { useContext } from "react";
-import { FormexController } from "./types";
-
-
-const FormexContext = React.createContext<FormexController<any> | null>(null);
-
-export const useFormex = <T = any>() => {
-    const ctx = useContext(FormexContext);
-    if (!ctx) throw new Error("useFormex must be used within a Formex provider");
-    return ctx as FormexController<T>;
-};
-
-export const Formex = <T = any>({ value, children }: { value: FormexController<T>, children: React.ReactNode }) => {
-    return <FormexContext.Provider value={value}>{children}</FormexContext.Provider>;
-};

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from "./Field";
-export * from "./Formex";
-export * from "./types";
-export * from "./utils";
-export * from "./useCreateFormex";

package/src/types.ts

@@ -1,58 +0,0 @@
-import React, { FormEvent } from "react";
-
-export type FormexController<T = any> = {
-    values: T;
-    initialValues: T;
-    setValues: (values: T) => void;
-    setFieldValue: (key: string, value: unknown, shouldValidate?: boolean) => void;
-    touched: Record<string, boolean>;
-    setFieldTouched: (key: string, touched: boolean, shouldValidate?: boolean) => void;
-    setTouched: (touched: Record<string, boolean>) => void;
-    dirty: boolean;
-    setDirty: (dirty: boolean) => void;
-    setSubmitCount: (submitCount: number) => void;
-    errors: Record<string, string>;
-    setFieldError: (key: string, error?: string) => void;
-    handleChange: (event: React.SyntheticEvent) => void,
-    handleBlur: (event: React.FocusEvent) => void,
-    handleSubmit: (event?: FormEvent<HTMLFormElement>) => void;
-    validate: () => void;
-    resetForm: (props?: FormexResetProps<T>) => void;
-    submitCount: number;
-    isSubmitting: boolean;
-    setSubmitting: (isSubmitting: boolean) => void;
-    isValidating: boolean;
-    /**
-     * The version of the form. This is incremented every time the form is reset
-     * or the form is submitted, and whenever the `initialValues` it was created
-     * with are replaced — a container reading `values` off the controller needs
-     * to hear about a re-seed the same way it hears about a reset.
-     */
-    version: number;
-
-    debugId?: string;
-
-    undo: () => void;
-    redo: () => void;
-
-    canUndo: boolean;
-    canRedo: boolean;
-}
-
-export type FormexResetProps<T = any> = {
-    values?: T;
-    submitCount?: number;
-    errors?: Record<string, string>;
-    touched?: Record<string, boolean>;
-    /**
-     * Leave what the reset replaced one step behind in the undo history, so
-     * {@link FormexController.undo} brings it back.
-     *
-     * For a reset the *user* asked for — a "Discard changes" or "Clear form"
-     * button — where the thing being thrown away is everything they typed, and
-     * a misclick is otherwise unrecoverable. The default clears the history,
-     * which is right for a reset the form performs on its own (a save, a new
-     * record): there is nothing there worth stepping back into.
-     */
-    undoable?: boolean;
-};

package/src/useCreateFormex.tsx

@@ -1,404 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { getIn, setIn } from "./utils";
-import { deepEqual as equal } from "fast-equals";
-
-import { FormexController, FormexResetProps } from "./types";
-
-/**
- * One step of the form's undo history.
- *
- * `touched` and `boundary` are set only on the pair of entries an undoable
- * reset writes — the state it replaced and the state it produced. A reset
- * clears the touched map and bumps `version`, so a step across that pair has to
- * put both back. Ordinary edits leave both unset on purpose: undoing a
- * keystroke should not re-seed every field in the form.
- */
-type FormexHistoryEntry<T> = {
-    values: T;
-    touched?: Record<string, boolean>;
-    boundary?: boolean;
-};
-
-export function useCreateFormex<T = any>({
-    initialValues,
-    initialModifiedValues,
-    initialErrors,
-    initialDirty,
-    initialTouched,
-    validation,
-    validateOnChange = false,
-    validateOnInitialRender = false,
-    onSubmit,
-    onReset,
-    onValuesChangeDeferred,
-    debugId
-}: {
-    /**
-     * The **baseline**: what the values are stored as. Everything the form
-     * calls "dirty" is a difference from this, so it has to be the stored
-     * record and nothing else. To open a form already carrying an edit, pass
-     * that edit as {@link initialModifiedValues} — folding it into
-     * `initialValues` instead makes the baseline agree with the edit, and then
-     * nothing can tell that the edit is unsaved.
-     */
-    initialValues: T;
-    /**
-     * What the form should *show* on its first render, when that is not the
-     * baseline — an edit handed over from somewhere else, a draft restored
-     * from a cache. Dirty is computed from the difference.
-     */
-    initialModifiedValues?: T;
-    initialErrors?: Record<string, string>;
-    /**
-     * Force the starting dirty state. Only for callers that know the form
-     * opens modified but cannot supply the modified values; prefer
-     * {@link initialModifiedValues}, which lets it be derived.
-     */
-    initialDirty?: boolean;
-    initialTouched?: Record<string, boolean>;
-    validateOnChange?: boolean;
-    validateOnInitialRender?: boolean;
-    validation?: (
-        values: T
-    ) =>
-        | Record<string, string>
-        | Promise<Record<string, string>>
-        | undefined
-        | void;
-    onValuesChangeDeferred?: (values: T, controller: FormexController<T>) => void;
-    onSubmit?: (values: T, controller: FormexController<T>) => void | Promise<void>;
-    onReset?: (controller: FormexController<T>) => void | Promise<void>;
-    debugId?: string;
-}): FormexController<T> {
-    // The baseline and the current values start apart when the form opens
-    // already carrying an edit. Keeping them separate is what lets the dirty
-    // flag be *derived* rather than asserted, and what lets the baseline be
-    // replaced later without touching what the user is looking at.
-    const startValues = initialModifiedValues ?? initialValues;
-
-    const initialValuesRef = useRef<T>(initialValues);
-    const valuesRef = useRef<T>(startValues);
-    const debugIdRef = useRef<string | undefined>(debugId);
-
-    const [values, setValuesInner] = useState<T>(startValues);
-    const [touchedState, setTouchedState] = useState<Record<string, boolean>>(initialTouched ?? {});
-    // Read by `resetForm`, which needs the map as it stands at the moment it is
-    // about to clear it. Assigned during render rather than from an effect, so
-    // an event handler can never read one render's worth of stale state.
-    const touchedRef = useRef<Record<string, boolean>>(touchedState);
-    touchedRef.current = touchedState;
-    const [errors, setErrors] = useState<Record<string, string>>(initialErrors ?? {});
-    const [dirty, setDirty] = useState(initialDirty ?? !equal(initialValues, startValues));
-    const [submitCount, setSubmitCount] = useState(0);
-    const [isSubmitting, setIsSubmitting] = useState(false);
-    const [isValidating, setIsValidating] = useState(false);
-    const [version, setVersion] = useState(0);
-
-    const onValuesChangeRef = useRef(onValuesChangeDeferred);
-    onValuesChangeRef.current = onValuesChangeDeferred;
-    const debounceTimeoutRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
-
-    const callDebouncedOnValuesChange = useCallback((values: T) => {
-        if (onValuesChangeRef.current) {
-            if (debounceTimeoutRef.current) {
-                clearTimeout(debounceTimeoutRef.current);
-            }
-            debounceTimeoutRef.current = setTimeout(() => {
-                onValuesChangeRef.current?.(values, controllerRef.current);
-            }, 300);
-        }
-    }, []);
-
-    // Replace state for history with refs
-    const historyRef = useRef<FormexHistoryEntry<T>[]>([{ values: startValues }]);
-    const historyIndexRef = useRef<number>(0);
-
-    /**
-     * Record a new state, dropping anything that had been undone past it.
-     */
-    const pushHistory = useCallback((entry: FormexHistoryEntry<T>) => {
-        const newHistory = historyRef.current.slice(0, historyIndexRef.current + 1);
-        newHistory.push(entry);
-        historyRef.current = newHistory;
-        historyIndexRef.current = newHistory.length - 1;
-    }, []);
-
-    useEffect(() => {
-        if (validateOnInitialRender) {
-            validate();
-        }
-    }, []);
-
-    const setValues = useCallback((newValues: T) => {
-        valuesRef.current = newValues;
-        setValuesInner(newValues);
-        setDirty(!equal(initialValuesRef.current, newValues));
-        pushHistory({ values: newValues });
-        callDebouncedOnValuesChange(newValues);
-    }, [callDebouncedOnValuesChange, pushHistory]);
-
-    const validate = useCallback(async () => {
-        setIsValidating(true);
-        const validationErrors = await validation?.(valuesRef.current);
-        setErrors(validationErrors ?? {});
-        setIsValidating(false);
-        return validationErrors;
-    }, [validation]);
-
-    const setFieldValue = useCallback(
-        (key: string, value: unknown, shouldValidate?: boolean) => {
-            const newValues = setIn(valuesRef.current as Record<string, unknown>, key, value) as T;
-            valuesRef.current = newValues;
-            setValuesInner(newValues);
-            if (!equal(getIn(initialValuesRef.current as Record<string, unknown>, key), value)) {
-                setDirty(true);
-            }
-            if (shouldValidate) {
-                validate();
-            }
-            pushHistory({ values: newValues });
-            callDebouncedOnValuesChange(newValues);
-        },
-        [validate, callDebouncedOnValuesChange, pushHistory]
-    );
-
-    const setFieldError = useCallback((key: string, error: string | undefined) => {
-        setErrors((prevErrors: Record<string, string>) => {
-            const newErrors = { ...prevErrors };
-            if (error) {
-                newErrors[key] = error;
-            } else {
-                delete newErrors[key];
-            }
-            return newErrors;
-        });
-    }, []);
-
-    const setFieldTouched = useCallback(
-        (key: string, touched: boolean, shouldValidate?: boolean) => {
-            setTouchedState((prev: Record<string, boolean>) => ({
-                ...prev,
-                [key]: touched
-            }));
-            if (shouldValidate) {
-                validate();
-            }
-        },
-        [validate]
-    );
-
-    const handleChange = useCallback(
-        (event: React.SyntheticEvent) => {
-            const target = event.target as HTMLInputElement;
-            let value;
-            if (target.type === "checkbox") {
-                value = target.checked;
-            } else if (target.type === "number") {
-                value = target.valueAsNumber;
-            } else {
-                value = target.value;
-            }
-            const name = target.name;
-            setFieldValue(name, value, validateOnChange);
-            setFieldTouched(name, true);
-        },
-        [setFieldValue, setFieldTouched, validateOnChange]
-    );
-
-    const handleBlur = useCallback((event: React.FocusEvent) => {
-        const target = event.target as HTMLInputElement;
-        const name = target.name;
-        setFieldTouched(name, true);
-    }, [setFieldTouched]);
-
-    const submit = useCallback(
-        async (e?: React.FormEvent<HTMLFormElement>) => {
-            e?.preventDefault();
-            e?.stopPropagation();
-            setIsSubmitting(true);
-            setSubmitCount((prev: number) => prev + 1);
-            const validationErrors = await validation?.(valuesRef.current);
-            if (validationErrors && Object.keys(validationErrors).length > 0) {
-                setErrors(validationErrors);
-            } else {
-                setErrors({});
-                await onSubmit?.(valuesRef.current, controllerRef.current);
-            }
-            setIsSubmitting(false);
-            setVersion((prev: number) => prev + 1);
-        },
-        [onSubmit, validation]
-    );
-
-    const resetForm = useCallback((props?: FormexResetProps<T>) => {
-        const {
-            submitCount: submitCountProp,
-            values: valuesProp,
-            errors: errorsProp,
-            touched: touchedProp,
-            undoable
-        } = props ?? {};
-        const priorValues = valuesRef.current;
-        const priorTouched = touchedRef.current;
-        const nextValues = valuesProp ?? initialValuesRef.current;
-        const nextTouched = touchedProp ?? initialTouched ?? {};
-        valuesRef.current = nextValues;
-        initialValuesRef.current = nextValues;
-        setValuesInner(nextValues);
-        setErrors(errorsProp ?? {});
-        setTouchedState(nextTouched);
-        setDirty(false);
-        setSubmitCount(submitCountProp ?? 0);
-        setVersion((prev: number) => prev + 1);
-        onReset?.(controllerRef.current);
-        if (undoable) {
-            // Keep what the user typed one step behind them. The entry stepped
-            // back into carries the touched map as well as the values: without
-            // it the values return but every field reads untouched, and a draft
-            // backup — which is extracted *through* the touched map — would come
-            // back empty.
-            const kept = historyRef.current.slice(0, historyIndexRef.current + 1);
-            kept[kept.length - 1] = { values: priorValues, touched: priorTouched };
-            kept.push({ values: nextValues, touched: nextTouched, boundary: true });
-            historyRef.current = kept;
-            historyIndexRef.current = kept.length - 1;
-        } else {
-            historyRef.current = [{ values: nextValues }];
-            historyIndexRef.current = 0;
-        }
-    }, [onReset, initialTouched]);
-
-    /**
-     * The `initialValues` prop moved: the record this form edits finished
-     * loading, or was replaced. That is a **re-baseline**, not a reset.
-     *
-     * It used to call `resetForm({ values: initialValues })`, which is a reset
-     * in both of the ways that matter, and both were wrong here:
-     *
-     * - it fired `onReset`, which callers reasonably read as "the user
-     *   discarded their changes". The admin clears the cache that seeds an
-     *   in-flight edit handed over from the side panel there, so a record's own
-     *   data arriving deleted the edit the form had just been opened with, and
-     *   the form then re-seeded itself from the server — an expanded record
-     *   silently lost whatever had been typed into it.
-     * - it overwrote `values`, so anything typed while the record was still
-     *   loading was thrown away without a word.
-     *
-     * So: move the baseline, leave the edit alone, and re-judge one against
-     * the other. Only an untouched form follows the baseline to its new value.
-     */
-    useEffect(() => {
-        if (equal(initialValuesRef.current, initialValues)) return;
-
-        const modified = !equal(initialValuesRef.current, valuesRef.current);
-        initialValuesRef.current = initialValues;
-
-        if (modified) {
-            setDirty(!equal(initialValues, valuesRef.current));
-        } else {
-            valuesRef.current = initialValues;
-            setValuesInner(initialValues);
-            historyRef.current = [{ values: initialValues }];
-            historyIndexRef.current = 0;
-            setDirty(false);
-        }
-        // Containers that read `values` off the controller key on `version`;
-        // a re-seed changes what they are holding just as a reset does.
-        setVersion((prev: number) => prev + 1);
-    }, [initialValues]);
-
-    const stepHistory = useCallback((newIndex: number) => {
-        const from = historyRef.current[historyIndexRef.current];
-        const entry = historyRef.current[newIndex];
-        const newValues = entry.values;
-        setValuesInner(newValues);
-        valuesRef.current = newValues;
-        historyIndexRef.current = newIndex;
-        setDirty(!equal(initialValuesRef.current, newValues));
-        if (entry.touched) {
-            setTouchedState(entry.touched);
-        }
-        // Stepping across a reset. The reset told everything reading `values`
-        // off the controller to re-read itself, so the way back has to say so
-        // too — otherwise a cleared markdown editor stays cleared while the
-        // value behind it is already back. Ordinary steps skip this.
-        if (from?.boundary || entry.boundary) {
-            setVersion((prev: number) => prev + 1);
-        }
-        callDebouncedOnValuesChange(newValues);
-    }, [callDebouncedOnValuesChange]);
-
-    const undo = useCallback(() => {
-        if (historyIndexRef.current > 0) {
-            stepHistory(historyIndexRef.current - 1);
-        }
-    }, [stepHistory]);
-
-    const redo = useCallback(() => {
-        if (historyIndexRef.current < historyRef.current.length - 1) {
-            stepHistory(historyIndexRef.current + 1);
-        }
-    }, [stepHistory]);
-
-    const controllerRef = useRef<FormexController<T>>({} as FormexController<T>);
-
-    const controller = useMemo<FormexController<T>>(
-        () => ({
-            values,
-            initialValues: initialValuesRef.current,
-            handleChange,
-            isSubmitting,
-            setSubmitting: setIsSubmitting,
-            setValues,
-            setFieldValue,
-            errors,
-            setFieldError,
-            touched: touchedState,
-            setFieldTouched,
-            setTouched: setTouchedState,
-            dirty,
-            setDirty,
-            handleSubmit: submit,
-            submitCount,
-            setSubmitCount,
-            handleBlur,
-            validate,
-            isValidating,
-            resetForm,
-            version,
-            debugId: debugIdRef.current,
-            undo,
-            redo,
-            canUndo: historyIndexRef.current > 0,
-            canRedo: historyIndexRef.current < historyRef.current.length - 1
-        }),
-        [
-            values,
-            errors,
-            touchedState,
-            dirty,
-            isSubmitting,
-            submitCount,
-            isValidating,
-            version,
-            handleChange,
-            handleBlur,
-            setValues,
-            setFieldValue,
-            setFieldTouched,
-            setTouchedState,
-            setFieldError,
-            validate,
-            submit,
-            resetForm,
-            undo,
-            redo
-        ]
-    );
-
-    useEffect(() => {
-        controllerRef.current = controller;
-    }, [controller]);
-
-    return controller;
-}

package/src/utils.ts

@@ -1,133 +0,0 @@
-/** @private is the value an empty array? */
-export const isEmptyArray = (value?: unknown) =>
-    Array.isArray(value) && value.length === 0;
-
-/** @private is the given object a Function? */
-
-export const isFunction = (obj: unknown): obj is Function =>
-    typeof obj === "function";
-
-/** @private is the given object an Object? */
-export const isObject = (obj: unknown): obj is Record<string, unknown> =>
-    obj !== null && typeof obj === "object";
-
-/** @private is the given object an integer? */
-export const isInteger = (obj: unknown): boolean =>
-    String(Math.floor(Number(obj))) === obj;
-
-/** @private is the given object a NaN? */
-
-export const isNaN = (obj: unknown): boolean => obj !== obj;
-
-/**
- * Deeply get a value from an object via its path.
- */
-export function getIn(
-    obj: unknown,
-    key: string | string[],
-    def?: unknown,
-    p = 0
-): unknown {
-    // The read counterpart. `getIn(values, "constructor.prototype")` handing
-    // back `Object.prototype` is how a polluted value gets read back out, and
-    // how a form comes to render one.
-    if (pathTraversesPrototype(key)) return def;
-
-    const path = toPath(key);
-    let current: unknown = obj;
-    while (current && p < path.length) {
-        current = (current as Record<string, unknown>)[path[p++]];
-    }
-
-    // check if path is not in the end
-    if (p !== path.length && !current) {
-        return def;
-    }
-
-    return current === undefined ? def : current;
-}
-
-export function setIn(obj: unknown, path: string, value: unknown): unknown {
-    // Refused rather than sanitised: there is no legitimate reading of a form
-    // field whose path names the prototype chain, and silently rewriting the
-    // path would write the value somewhere the caller did not ask for.
-    // Returning the original object is what every other no-op in this function
-    // does.
-    if (pathTraversesPrototype(path)) return obj;
-
-    const res = clone(obj) as Record<string, unknown>; // this keeps inheritance when obj is a class
-    let resVal: Record<string, unknown> = res;
-    let i = 0;
-    const pathArray = toPath(path);
-
-    for (; i < pathArray.length - 1; i++) {
-        const currentPath: string = pathArray[i];
-        const currentObj = getIn(obj, pathArray.slice(0, i + 1));
-
-        if (currentObj && (isObject(currentObj) || Array.isArray(currentObj))) {
-            resVal = resVal[currentPath] = clone(currentObj) as Record<string, unknown>;
-        } else {
-            const nextPath: string = pathArray[i + 1];
-            resVal = resVal[currentPath] =
-                (isInteger(nextPath) && Number(nextPath) >= 0 ? [] : {}) as Record<string, unknown>;
-        }
-    }
-
-    // Return original object if new value is the same as current
-    if ((i === 0 ? (obj as Record<string, unknown>) : resVal)[pathArray[i]] === value) {
-        return obj;
-    }
-
-    if (value === undefined) {
-        delete resVal[pathArray[i]];
-    } else {
-        resVal[pathArray[i]] = value;
-    }
-
-    // If the path array has a single element, the loop did not run.
-    // Deleting on `resVal` had no effect in this scenario, so we delete on the result instead.
-    if (i === 0 && value === undefined) {
-        delete res[pathArray[i]];
-    }
-
-    return res;
-}
-
-export function clone(value: unknown): unknown {
-    if (Array.isArray(value)) {
-        return [...value];
-    } else if (typeof value === "object" && value !== null) {
-        // Preserve class instances (EntityReference, GeoPoint, etc.) - don't spread them
-        if (Object.getPrototypeOf(value) !== Object.prototype) {
-            return value;
-        }
-        return { ...(value as Record<string, unknown>) };
-    } else {
-        return value; // This is for primitive types which do not need cloning.
-    }
-}
-
-/**
- * Segments that reach the prototype chain rather than a property of the object.
- *
- * `res["__proto__"] = x` is a setter for the object's prototype, not an own
- * property, so a path of `__proto__.polluted` wrote straight onto
- * `Object.prototype` and gave every object in the process a `polluted`
- * property. `constructor.prototype.x` arrived by a second route, and
- * `__proto__.0` did it to arrays.
- *
- * These are paths, and a path here is a property key — which for a map property
- * or a column mapped out of an imported CSV is data, not code.
- */
-const UNSAFE_PATH_SEGMENTS = new Set(["__proto__", "constructor", "prototype"]);
-
-/** Whether any segment of this path would traverse the prototype chain. */
-export function pathTraversesPrototype(path: string | string[]): boolean {
-    return toPath(path).some(segment => UNSAFE_PATH_SEGMENTS.has(segment));
-}
-
-function toPath(value: string | string[]) {
-    if (Array.isArray(value)) return value; // Already in path array form.
-    // Replace brackets with dots, remove leading/trailing dots, then split by dot.
-    return value.replace(/\[(\d+)]/g, ".$1").replace(/^\./, "").replace(/\.$/, "").split(".");
-}