@mantine/form/esm/hooks/use-form-status/use-form-status.mjs

Mantine form management library

"use client";
import { clearListState } from "../../lists/clear-list-state.mjs";
import { getPath } from "../../paths/get-path.mjs";
import { getStatus } from "../../get-status/get-status.mjs";
import { useCallback, useRef, useState } from "react";
import isEqual from "fast-deep-equal";
//#region packages/@mantine/form/src/hooks/use-form-status/use-form-status.ts
function useFormStatus({ initialDirty, initialTouched, mode, $values }) {
	const [touchedState, setTouchedState] = useState(initialTouched);
	const [dirtyState, setDirtyState] = useState(initialDirty);
	const touchedRef = useRef(initialTouched);
	const dirtyRef = useRef(initialDirty);
	const setTouched = useCallback((values) => {
		const resolvedValues = typeof values === "function" ? values(touchedRef.current) : values;
		touchedRef.current = resolvedValues;
		if (mode === "controlled") setTouchedState(resolvedValues);
	}, []);
	const setDirty = useCallback((values, forceUpdate = false) => {
		const resolvedValues = typeof values === "function" ? values(dirtyRef.current) : values;
		dirtyRef.current = resolvedValues;
		if (mode === "controlled" || forceUpdate) setDirtyState(resolvedValues);
	}, []);
	const resetTouched = useCallback(() => setTouched({}), []);
	const resetDirty = useCallback((values) => {
		const newSnapshot = values ? {
			...$values.refValues.current,
			...values
		} : $values.refValues.current;
		$values.setValuesSnapshot(newSnapshot);
		setDirty({});
	}, []);
	const setFieldTouched = useCallback((path, touched) => {
		setTouched((currentTouched) => {
			if (getStatus(currentTouched, path) === touched) return currentTouched;
			return {
				...currentTouched,
				[path]: touched
			};
		});
	}, []);
	const setFieldDirty = useCallback((path, dirty, forceUpdate) => {
		setDirty((currentDirty) => {
			if (getStatus(currentDirty, path) === dirty) return currentDirty;
			return {
				...currentDirty,
				[path]: dirty
			};
		}, forceUpdate);
	}, []);
	const setCalculatedFieldDirty = useCallback((path, value) => {
		const currentDirty = getStatus(dirtyRef.current, path);
		const dirty = !isEqual(getPath(path, $values.getValuesSnapshot()), value);
		const clearedState = clearListState(path, dirtyRef.current);
		clearedState[path] = dirty;
		setDirty(clearedState, currentDirty !== dirty);
	}, []);
	return {
		touchedState,
		dirtyState,
		touchedRef,
		dirtyRef,
		setTouched,
		setDirty,
		resetDirty,
		resetTouched,
		isTouched: useCallback((path) => getStatus(touchedRef.current, path), []),
		setFieldTouched,
		setFieldDirty,
		setTouchedState,
		setDirtyState,
		clearFieldDirty: useCallback((path) => setDirty((current) => {
			if (typeof path !== "string") return current;
			const result = clearListState(path, current);
			delete result[path];
			if (isEqual(result, current)) return current;
			return result;
		}), []),
		isDirty: useCallback((path) => {
			if (path) {
				const overriddenValue = getPath(path, dirtyRef.current);
				if (typeof overriddenValue === "boolean") return overriddenValue;
				return !isEqual(getPath(path, $values.refValues.current), getPath(path, $values.valuesSnapshot.current));
			}
			if (Object.keys(dirtyRef.current).length > 0) return getStatus(dirtyRef.current);
			return !isEqual($values.refValues.current, $values.valuesSnapshot.current);
		}, []),
		getDirty: useCallback(() => dirtyRef.current, []),
		getTouched: useCallback(() => touchedRef.current, []),
		setCalculatedFieldDirty
	};
}
//#endregion
export { useFormStatus };

//# sourceMappingURL=use-form-status.mjs.map