@fuf-stack/uniform 1.10.3 → 1.11.0

package/dist/useFormContext-CZh7pv8f.d.cts

@@ -0,0 +1,64 @@
+import { n as UserChangeListener, t as DebugModeSettings } from "./FormContext-Dl7KL_wl.cjs";
+import * as react0 from "react";
+import * as _fuf_stack_veto0 from "@fuf-stack/veto";
+import { VetoFormattedError, VetoInstance } from "@fuf-stack/veto";
+import * as react_hook_form9 from "react-hook-form";
+import { FieldError, FieldValues, Path } from "react-hook-form";
+
+//#region src/hooks/useFormContext/useFormContext.d.ts
+/** Schema check whether a field is required or optional */
+declare const checkFieldIsRequired: (validation: VetoInstance, path: string[]) => boolean;
+/**
+ * Custom hook that extends react-hook-form's useFormContext to add validation and state management.
+ *
+ * Key features:
+ * - Enhanced `getFieldState` that includes validation schema-based "required" status and testId generation
+ * - Automatic conversion of form values via `getValues`, `watch`, and `subscribe`:
+ *   - Unwraps flat array wrappers (`{ __FLAT__: value }` → `value`)
+ *   - Converts nullish string markers (`__NULL__` → `null`, `__FALSE__` → `false`, `__ZERO__` → `0`)
+ *   - Filters out empty/null values
+ */
+declare const useFormContext: <TFieldValues extends FieldValues = FieldValues, TContext = any, TTransformedValues = TFieldValues>() => {
+  formState: react_hook_form9.FormState<TFieldValues>;
+  getFieldState: (name: Path<TFieldValues>, testId?: string) => {
+    error: FieldError[] | undefined;
+    invalid: boolean;
+    required: boolean;
+    testId: string;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+  };
+  getValues: react_hook_form9.UseFormGetValues<TFieldValues>;
+  subscribe: react_hook_form9.UseFormSubscribe<TFieldValues>;
+  watch: react_hook_form9.UseFormWatch<TFieldValues>;
+  debugMode: "disabled" | "debug" | "debug-testids" | "off";
+  debugModeSettings?: DebugModeSettings;
+  preventSubmit: (prevent: boolean) => void;
+  setDebugMode: (debugMode: "disabled" | "debug" | "debug-testids" | "off") => void;
+  triggerSubmit: (e?: react0.BaseSyntheticEvent) => Promise<void> | void;
+  userChange: {
+    subscribe: (listener: UserChangeListener) => () => void;
+    notify: (fieldName: string, value: unknown) => void;
+  };
+  validation: {
+    baseInstance?: VetoInstance;
+    instance?: VetoInstance;
+    errors?: VetoFormattedError;
+    setClientValidationSchema: (key: string, schema: _fuf_stack_veto0.VetoTypeAny | null) => void;
+  };
+  setError: react_hook_form9.UseFormSetError<TFieldValues>;
+  clearErrors: react_hook_form9.UseFormClearErrors<TFieldValues>;
+  setValue: react_hook_form9.UseFormSetValue<TFieldValues>;
+  trigger: react_hook_form9.UseFormTrigger<TFieldValues>;
+  resetField: react_hook_form9.UseFormResetField<TFieldValues>;
+  reset: react_hook_form9.UseFormReset<TFieldValues>;
+  handleSubmit: react_hook_form9.UseFormHandleSubmit<TFieldValues, TTransformedValues>;
+  unregister: react_hook_form9.UseFormUnregister<TFieldValues>;
+  control: react_hook_form9.Control<TFieldValues, TContext, TTransformedValues>;
+  register: react_hook_form9.UseFormRegister<TFieldValues>;
+  setFocus: react_hook_form9.UseFormSetFocus<TFieldValues>;
+};
+//#endregion
+export { useFormContext as n, checkFieldIsRequired as t };
+//# sourceMappingURL=useFormContext-CZh7pv8f.d.cts.map

package/dist/useFormContext-CZh7pv8f.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormContext-CZh7pv8f.d.cts","names":[],"sources":["../src/hooks/useFormContext/useFormContext.ts"],"sourcesContent":[],"mappings":";;;;;;;;;cAYa,mCACC;;;;;AADd;AAqEA;;;;;cAAa,sCACU,cAAc,kDAEd;EAwBa,SAAA,4BAAA,aAAA,CAAA;EAAL,aAAA,EAAA,CAAA,IAAA,EAAA,IAAA,CAAK,YAAL,CAAA,EAAA,MAAA,CAAA,EAAA,MAAA,EAAA,GAAA;;;;;;;;;WAWO,mCAAA,aAAA,CAAA;EAAA,SAAA,mCAAA,aAAA,CAAA;EAAA,KAAA,+BAAA,aAAA,CAAA;EAyBpC,SAAA,EAAA,UAAA,GAAA,OAAA,GAAA,eAAA,GAAA,KAAA;EACyB,iBAAA,CAAA,mBAAA;EAAwE,aAAA,EAAA,CAAA,OAAA,EAAA,OAAA,EAAA,GAAA,IAAA;EAAA,YAAA,EAAA,CAAA,SAAA,EAAA,UAAA,GAAA,OAAA,GAAA,eAAA,GAAA,KAAA,EAAA,GAAA,IAAA;6BA1B7D,uBAAA;;0BAAA;;;;mBAyBpC;eACyB;aAAwE;qDAAA,gBAAA,CAAA,WAAA"}

package/dist/useFormContext-CkeSOfWD.cjs

@@ -0,0 +1,6 @@
+
+//#region src/hooks/useFormContext/index.ts
+/* v8 ignore stop */
+
+//#endregion
+//# sourceMappingURL=useFormContext-CkeSOfWD.cjs.map

package/dist/useFormContext-CkeSOfWD.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormContext-CkeSOfWD.cjs","names":[],"sources":["../src/hooks/useFormContext/index.ts"],"sourcesContent":["/* v8 ignore start */\n\nexport * from './useFormContext';\n\n/* v8 ignore stop */\n"],"mappings":""}

package/dist/useFormContext-JCm1UR_e.js

@@ -0,0 +1,123 @@
+import { o as toValidationFormat, r as nameToTestId, t as flatArrayKey } from "./helpers-B-CJOBt3.js";
+import { n as UniformContext } from "./FormContext-CN9n_KdE.js";
+import { useContext } from "react";
+import { useFormContext } from "react-hook-form";
+
+//#region src/hooks/useFormContext/useFormContext.ts
+/** Schema check whether a field is required or optional */
+const checkFieldIsRequired = (validation, path) => {
+	const checkPath = path[path.length - 1] === flatArrayKey ? path.slice(0, -1) : path;
+	const checkRequired = (schema) => {
+		if (schema.type === "array") {
+			if (schema.isOptional || schema.isNullable) return false;
+			return true;
+		}
+		return !schema.isOptional && !schema.isNullable;
+	};
+	return validation.checkSchemaPath(checkRequired, checkPath);
+};
+/**
+* Resolve validation errors for a given field path.
+*
+* Traverses a nested `VetoFormattedError` structure using a dotted path
+* (for example: "user.address.0.street") and returns the matching
+* `FieldError[]` if present. If no error exists at the path, returns
+* `undefined`.
+*
+* @param errors - The formatted validation errors from Uniform's context
+* @param name - The dotted field path to resolve
+* @returns An array of `FieldError` entries for the field, or `undefined`
+*/
+const getValidationErrorsByName = (errors, name) => {
+	const keys = name.split(".").filter((k) => {
+		return k !== flatArrayKey;
+	});
+	let current = errors;
+	keys.forEach((key) => {
+		if (current && typeof current === "object") current = current[key];
+		else current = void 0;
+	});
+	return current;
+};
+/**
+* Custom hook that extends react-hook-form's useFormContext to add validation and state management.
+*
+* Key features:
+* - Enhanced `getFieldState` that includes validation schema-based "required" status and testId generation
+* - Automatic conversion of form values via `getValues`, `watch`, and `subscribe`:
+*   - Unwraps flat array wrappers (`{ __FLAT__: value }` → `value`)
+*   - Converts nullish string markers (`__NULL__` → `null`, `__FALSE__` → `false`, `__ZERO__` → `0`)
+*   - Filters out empty/null values
+*/
+const useFormContext$1 = () => {
+	const { formState, getFieldState: getFieldStateOrig, getValues: getValuesOrig, watch: watchOrig, subscribe: subscribeOrig, ...otherMethods } = useFormContext();
+	const uniformContext = useContext(UniformContext);
+	/**
+	* Updated getFieldState method which returns:
+	* - Whether the field is required by checking the validation schema
+	* - Existing field state information (errors, etc.)
+	* - A testId generated from the field name (with flat array keys removed and slugified)
+	*
+	* @param name - The field path (string or array)
+	* @param testId - Optional explicit testId. If provided, will be slugified. If not provided, generated from name.
+	*/
+	const getFieldState = (name, testId) => {
+		const fieldPath = typeof name === "string" ? name.replace(/\[\d+\]/g, "").split(".") : name;
+		const validationInstance = uniformContext?.validation.baseInstance ?? uniformContext?.validation.instance;
+		const required = validationInstance ? checkFieldIsRequired(validationInstance, fieldPath) : false;
+		const error = getValidationErrorsByName(uniformContext?.validation.errors ?? {}, name);
+		return {
+			...getFieldStateOrig(name, formState),
+			error,
+			invalid: !!error,
+			required,
+			testId: nameToTestId(testId ?? name)
+		};
+	};
+	/**
+	* Wrap form value accessor methods to automatically convert from internal storage format
+	* to component-friendly format:
+	*
+	* - Unwrap flat array wrappers: `{ __FLAT__: value }` → `value`
+	* - Convert nullish string markers: `__NULL__` → `null`, `__FALSE__` → `false`, `__ZERO__` → `0`
+	* - Filter out empty/null values: fields with converted null/empty values are removed entirely
+	*
+	* This ensures components receive clean, predictable data without needing to handle
+	* the internal nullish string conversion system or flat array wrapping manually.
+	*/
+	const getValues = ((...args) => {
+		return toValidationFormat(getValuesOrig(...args));
+	});
+	const watch = ((...args) => {
+		return toValidationFormat(watchOrig(...args));
+	});
+	const subscribe = ((...args) => {
+		const [options] = args;
+		if (options?.callback) {
+			const originalCallback = options.callback;
+			return subscribeOrig({
+				...options,
+				callback: (subscribeFormState) => {
+					return originalCallback({
+						...subscribeFormState,
+						...subscribeFormState.values && { values: toValidationFormat(subscribeFormState.values) }
+					});
+				}
+			});
+		}
+		return subscribeOrig(...args);
+	});
+	return {
+		...otherMethods,
+		...uniformContext,
+		formState,
+		getFieldState,
+		getValues,
+		subscribe,
+		watch
+	};
+};
+
+//#endregion
+export { useFormContext$1 as n, checkFieldIsRequired as t };
+//# sourceMappingURL=useFormContext-JCm1UR_e.js.map

package/dist/useFormContext-JCm1UR_e.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormContext-JCm1UR_e.js","names":["current: unknown","useFormContext","useHookFormContext"],"sources":["../src/hooks/useFormContext/useFormContext.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { VetoFormattedError, VetoInstance } from '@fuf-stack/veto';\nimport type { FieldError, FieldValues, Path } from 'react-hook-form';\n\nimport { useContext } from 'react';\nimport { useFormContext as useHookFormContext } from 'react-hook-form';\n\nimport { UniformContext } from '../../Form/subcomponents/FormContext';\nimport { flatArrayKey, nameToTestId, toValidationFormat } from '../../helpers';\n\n/** Schema check whether a field is required or optional */\nexport const checkFieldIsRequired = (\n  validation: VetoInstance,\n  path: string[],\n): boolean => {\n  // Handle flat array paths: strip the flatArrayKey to check the array element schema\n  // e.g., ['arrayField', '0', '__FLAT__'] -> check schema at ['arrayField', '0']\n  const checkPath =\n    path[path.length - 1] === flatArrayKey ? path.slice(0, -1) : path;\n\n  const checkRequired = (schema: any) => {\n    // arrays ...\n    if (schema.type === 'array') {\n      // ... if array is optional or nullable it is not required\n      if (schema.isOptional || schema.isNullable) {\n        return false;\n      }\n      // ... otherwise arrays are required (display logic wise -> no asterisk in the label)\n      return true;\n    }\n\n    // all other fields are required if they are\n    // not optional and not nullable\n    return !schema.isOptional && !schema.isNullable;\n  };\n\n  return validation.checkSchemaPath(checkRequired, checkPath);\n};\n\n/**\n * Resolve validation errors for a given field path.\n *\n * Traverses a nested `VetoFormattedError` structure using a dotted path\n * (for example: \"user.address.0.street\") and returns the matching\n * `FieldError[]` if present. If no error exists at the path, returns\n * `undefined`.\n *\n * @param errors - The formatted validation errors from Uniform's context\n * @param name - The dotted field path to resolve\n * @returns An array of `FieldError` entries for the field, or `undefined`\n */\nconst getValidationErrorsByName = (\n  errors: VetoFormattedError,\n  name: string,\n) => {\n  // Traverse nested error structure; ignore flat array wrapper key\n  const keys = name.split('.').filter((k) => {\n    return k !== flatArrayKey;\n  });\n  let current: unknown = errors as unknown;\n  keys.forEach((key) => {\n    if (current && typeof current === 'object') {\n      current = (current as Record<string, unknown>)[key];\n    } else {\n      current = undefined;\n    }\n  });\n  return current as FieldError[] | undefined;\n};\n\n/**\n * Custom hook that extends react-hook-form's useFormContext to add validation and state management.\n *\n * Key features:\n * - Enhanced `getFieldState` that includes validation schema-based \"required\" status and testId generation\n * - Automatic conversion of form values via `getValues`, `watch`, and `subscribe`:\n *   - Unwraps flat array wrappers (`{ __FLAT__: value }` → `value`)\n *   - Converts nullish string markers (`__NULL__` → `null`, `__FALSE__` → `false`, `__ZERO__` → `0`)\n *   - Filters out empty/null values\n */\nexport const useFormContext = <\n  TFieldValues extends FieldValues = FieldValues,\n  TContext = any,\n  TTransformedValues = TFieldValues,\n>() => {\n  const {\n    formState,\n    // some methods that will be enhanced below\n    getFieldState: getFieldStateOrig,\n    getValues: getValuesOrig,\n    watch: watchOrig,\n    subscribe: subscribeOrig,\n    // the rest of the methods pass through unchanged\n    ...otherMethods\n  } = useHookFormContext<TFieldValues, TContext, TTransformedValues>();\n\n  const uniformContext = useContext(UniformContext);\n\n  /**\n   * Updated getFieldState method which returns:\n   * - Whether the field is required by checking the validation schema\n   * - Existing field state information (errors, etc.)\n   * - A testId generated from the field name (with flat array keys removed and slugified)\n   *\n   * @param name - The field path (string or array)\n   * @param testId - Optional explicit testId. If provided, will be slugified. If not provided, generated from name.\n   */\n  const getFieldState = (name: Path<TFieldValues>, testId?: string) => {\n    const fieldPath =\n      typeof name === 'string' ? name.replace(/\\[\\d+\\]/g, '').split('.') : name;\n\n    // Use base validation instance for checking \"required\" status\n    // Client validation often uses .nullish() which would incorrectly mark fields as optional\n    const validationInstance =\n      uniformContext?.validation.baseInstance ??\n      uniformContext?.validation.instance;\n\n    // Check if the field is required using the validation schema\n    const required = validationInstance\n      ? checkFieldIsRequired(validationInstance, fieldPath)\n      : false;\n\n    const error = getValidationErrorsByName(\n      uniformContext?.validation.errors ?? {},\n      name,\n    ) as unknown as FieldError[] | undefined;\n\n    // Get everything but the error from the original field state\n    const fieldState = getFieldStateOrig(name, formState);\n\n    return {\n      ...fieldState,\n      error,\n      invalid: !!error,\n      required,\n      testId: nameToTestId(testId ?? name),\n    };\n  };\n\n  /**\n   * Wrap form value accessor methods to automatically convert from internal storage format\n   * to component-friendly format:\n   *\n   * - Unwrap flat array wrappers: `{ __FLAT__: value }` → `value`\n   * - Convert nullish string markers: `__NULL__` → `null`, `__FALSE__` → `false`, `__ZERO__` → `0`\n   * - Filter out empty/null values: fields with converted null/empty values are removed entirely\n   *\n   * This ensures components receive clean, predictable data without needing to handle\n   * the internal nullish string conversion system or flat array wrapping manually.\n   */\n  const getValues = ((...args: any[]) => {\n    const result = (getValuesOrig as any)(...args);\n    return toValidationFormat(result);\n  }) as typeof getValuesOrig;\n\n  const watch = ((...args: any[]) => {\n    const result = (watchOrig as any)(...args);\n    return toValidationFormat(result);\n  }) as typeof watchOrig;\n\n  const subscribe = ((...args: any[]) => {\n    // For subscribe, we need to wrap the callback to convert the values property\n    const [options] = args;\n    if (options?.callback) {\n      const originalCallback = options.callback;\n      const wrappedOptions = {\n        ...options,\n        callback: (subscribeFormState: any) => {\n          // Convert the values property if it exists\n          const convertedFormState = {\n            ...subscribeFormState,\n            ...(subscribeFormState.values && {\n              values: toValidationFormat(subscribeFormState.values),\n            }),\n          };\n          // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n          return originalCallback(convertedFormState);\n        },\n      };\n      return subscribeOrig(wrappedOptions);\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return (subscribeOrig as any)(...args);\n  }) as typeof subscribeOrig;\n\n  return {\n    ...otherMethods,\n    ...uniformContext,\n    formState,\n    getFieldState,\n    getValues,\n    subscribe,\n    watch,\n  };\n};\n"],"mappings":";;;;;;;AAYA,MAAa,wBACX,YACA,SACY;CAGZ,MAAM,YACJ,KAAK,KAAK,SAAS,OAAO,eAAe,KAAK,MAAM,GAAG,GAAG,GAAG;CAE/D,MAAM,iBAAiB,WAAgB;AAErC,MAAI,OAAO,SAAS,SAAS;AAE3B,OAAI,OAAO,cAAc,OAAO,WAC9B,QAAO;AAGT,UAAO;;AAKT,SAAO,CAAC,OAAO,cAAc,CAAC,OAAO;;AAGvC,QAAO,WAAW,gBAAgB,eAAe,UAAU;;;;;;;;;;;;;;AAe7D,MAAM,6BACJ,QACA,SACG;CAEH,MAAM,OAAO,KAAK,MAAM,IAAI,CAAC,QAAQ,MAAM;AACzC,SAAO,MAAM;GACb;CACF,IAAIA,UAAmB;AACvB,MAAK,SAAS,QAAQ;AACpB,MAAI,WAAW,OAAO,YAAY,SAChC,WAAW,QAAoC;MAE/C,WAAU;GAEZ;AACF,QAAO;;;;;;;;;;;;AAaT,MAAaC,yBAIN;CACL,MAAM,EACJ,WAEA,eAAe,mBACf,WAAW,eACX,OAAO,WACP,WAAW,eAEX,GAAG,iBACDC,gBAAgE;CAEpE,MAAM,iBAAiB,WAAW,eAAe;;;;;;;;;;CAWjD,MAAM,iBAAiB,MAA0B,WAAoB;EACnE,MAAM,YACJ,OAAO,SAAS,WAAW,KAAK,QAAQ,YAAY,GAAG,CAAC,MAAM,IAAI,GAAG;EAIvE,MAAM,qBACJ,gBAAgB,WAAW,gBAC3B,gBAAgB,WAAW;EAG7B,MAAM,WAAW,qBACb,qBAAqB,oBAAoB,UAAU,GACnD;EAEJ,MAAM,QAAQ,0BACZ,gBAAgB,WAAW,UAAU,EAAE,EACvC,KACD;AAKD,SAAO;GACL,GAHiB,kBAAkB,MAAM,UAAU;GAInD;GACA,SAAS,CAAC,CAAC;GACX;GACA,QAAQ,aAAa,UAAU,KAAK;GACrC;;;;;;;;;;;;;CAcH,MAAM,cAAc,GAAG,SAAgB;AAErC,SAAO,mBADS,cAAsB,GAAG,KAAK,CACb;;CAGnC,MAAM,UAAU,GAAG,SAAgB;AAEjC,SAAO,mBADS,UAAkB,GAAG,KAAK,CACT;;CAGnC,MAAM,cAAc,GAAG,SAAgB;EAErC,MAAM,CAAC,WAAW;AAClB,MAAI,SAAS,UAAU;GACrB,MAAM,mBAAmB,QAAQ;AAejC,UAAO,cAdgB;IACrB,GAAG;IACH,WAAW,uBAA4B;AASrC,YAAO,iBAPoB;MACzB,GAAG;MACH,GAAI,mBAAmB,UAAU,EAC/B,QAAQ,mBAAmB,mBAAmB,OAAO,EACtD;MACF,CAE0C;;IAE9C,CACmC;;AAGtC,SAAQ,cAAsB,GAAG,KAAK;;AAGxC,QAAO;EACL,GAAG;EACH,GAAG;EACH;EACA;EACA;EACA;EACA;EACD"}

package/dist/useInput-DZ6KGBxw.js

@@ -0,0 +1,3 @@
+import { useInput } from "@heroui/input";
+
+export { useInput as t };

package/dist/useInput-IGJqJ2tR.d.ts

@@ -0,0 +1,2 @@
+import { useInput } from "@heroui/input";
+export { useInput as t };

package/dist/useInput-NMHJNZ5A.d.cts

@@ -0,0 +1,2 @@
+import { useInput } from "@heroui/input";
+export { useInput as t };

package/dist/useInputValueDebounce-B2RzCWty.d.cts

@@ -0,0 +1,62 @@
+//#region src/hooks/useInputValueDebounce/useInputValueDebounce.d.ts
+interface UseInputValueDebounceOptions<TValue = unknown> {
+  /** Debounce delay in milliseconds (default: 300) */
+  debounceDelay?: number;
+  /** The onBlur function to call after flushing debounced value */
+  onBlur: () => void;
+  /** The onChange function to call with debounced value */
+  onChange: (...event: any[]) => void;
+  /** The field value */
+  value: TValue;
+}
+interface UseInputValueDebounceReturn<TValue = unknown> {
+  /** Enhanced onChange function with debouncing */
+  onChange: (...event: any[]) => void;
+  /** Enhanced onBlur function that flushes current value immediately */
+  onBlur: () => void;
+  /** The field value that is displayed - updates immediately */
+  value: TValue;
+}
+/**
+ * Custom hook for debouncing value changes with immediate blur support.
+ *
+ * Provides immediate visual feedback by updating the value instantly,
+ * while debouncing the actual onChange calls. When focus is lost,
+ * any pending debounced changes are immediately flushed.
+ *
+ * **Key Features:**
+ * - **Debouncing**: Delays onChange calls until user stops typing
+ * - **Generic type support**: Works with any data type (strings, numbers, arrays, objects)
+ * - **Immediate value updates**: UI stays responsive during debouncing
+ * - **Blur flushing**: Immediately applies pending changes on blur
+ *
+ * **Note:** Value transformations should be handled at the `useUniformField` level,
+ * not in this hook. This hook only handles debouncing timing.
+ *
+ * @param options Configuration for debounced value handling
+ * @param options.debounceDelay Delay in milliseconds (default: 300)
+ * @param options.onBlur Function to call after flushing debounced value
+ * @param options.onChange Function to call with debounced value
+ * @param options.value The field value
+ * @returns Object containing enhanced onChange, onBlur, and immediate value
+ *
+ * @example
+ * Basic usage with debouncing:
+ * ```tsx
+ * const { onChange, onBlur, value } = useInputValueDebounce({
+ *   debounceDelay: 300,
+ *   onBlur: field.onBlur,
+ *   onChange: field.onChange,
+ *   value: field.value,
+ * });
+ * ```
+ */
+declare const useInputValueDebounce: <TValue = unknown>({
+  debounceDelay,
+  onBlur,
+  onChange,
+  value
+}: UseInputValueDebounceOptions<TValue>) => UseInputValueDebounceReturn<TValue>;
+//#endregion
+export { UseInputValueDebounceReturn as n, useInputValueDebounce as r, UseInputValueDebounceOptions as t };
+//# sourceMappingURL=useInputValueDebounce-B2RzCWty.d.cts.map

package/dist/useInputValueDebounce-B2RzCWty.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInputValueDebounce-B2RzCWty.d.cts","names":[],"sources":["../src/hooks/useInputValueDebounce/useInputValueDebounce.ts"],"sourcesContent":[],"mappings":";UAEiB;EAAA;EAYA,aAAA,CAAA,EAAA,MAAA;EA4CJ;EAA2C,MAAA,EAAA,GAAA,GAAA,IAAA;EAAA;EAAA,QAAA,EAAA,CAAA,GAAA,KAAA,EAAA,GAAA,EAAA,EAAA,GAAA,IAAA;EAAA;EAKxB,KAAA,EApDvB,MAoDuB;;AAAsC,UAjDrD,2BAiDqD,CAAA,SAAA,OAAA,CAAA,CAAA;EAA5B;EAA2B,QAAA,EAAA,CAAA,GAAA,KAAA,EAAA,GAAA,EAAA,EAAA,GAAA,IAAA;;;;SA1C5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCI;;;;;GAKV,6BAA6B,YAAU,4BAA4B"}

package/dist/useInputValueDebounce-C7_bvNGH.d.ts

@@ -0,0 +1,62 @@
+//#region src/hooks/useInputValueDebounce/useInputValueDebounce.d.ts
+interface UseInputValueDebounceOptions<TValue = unknown> {
+  /** Debounce delay in milliseconds (default: 300) */
+  debounceDelay?: number;
+  /** The onBlur function to call after flushing debounced value */
+  onBlur: () => void;
+  /** The onChange function to call with debounced value */
+  onChange: (...event: any[]) => void;
+  /** The field value */
+  value: TValue;
+}
+interface UseInputValueDebounceReturn<TValue = unknown> {
+  /** Enhanced onChange function with debouncing */
+  onChange: (...event: any[]) => void;
+  /** Enhanced onBlur function that flushes current value immediately */
+  onBlur: () => void;
+  /** The field value that is displayed - updates immediately */
+  value: TValue;
+}
+/**
+ * Custom hook for debouncing value changes with immediate blur support.
+ *
+ * Provides immediate visual feedback by updating the value instantly,
+ * while debouncing the actual onChange calls. When focus is lost,
+ * any pending debounced changes are immediately flushed.
+ *
+ * **Key Features:**
+ * - **Debouncing**: Delays onChange calls until user stops typing
+ * - **Generic type support**: Works with any data type (strings, numbers, arrays, objects)
+ * - **Immediate value updates**: UI stays responsive during debouncing
+ * - **Blur flushing**: Immediately applies pending changes on blur
+ *
+ * **Note:** Value transformations should be handled at the `useUniformField` level,
+ * not in this hook. This hook only handles debouncing timing.
+ *
+ * @param options Configuration for debounced value handling
+ * @param options.debounceDelay Delay in milliseconds (default: 300)
+ * @param options.onBlur Function to call after flushing debounced value
+ * @param options.onChange Function to call with debounced value
+ * @param options.value The field value
+ * @returns Object containing enhanced onChange, onBlur, and immediate value
+ *
+ * @example
+ * Basic usage with debouncing:
+ * ```tsx
+ * const { onChange, onBlur, value } = useInputValueDebounce({
+ *   debounceDelay: 300,
+ *   onBlur: field.onBlur,
+ *   onChange: field.onChange,
+ *   value: field.value,
+ * });
+ * ```
+ */
+declare const useInputValueDebounce: <TValue = unknown>({
+  debounceDelay,
+  onBlur,
+  onChange,
+  value
+}: UseInputValueDebounceOptions<TValue>) => UseInputValueDebounceReturn<TValue>;
+//#endregion
+export { UseInputValueDebounceReturn as n, useInputValueDebounce as r, UseInputValueDebounceOptions as t };
+//# sourceMappingURL=useInputValueDebounce-C7_bvNGH.d.ts.map

package/dist/useInputValueDebounce-C7_bvNGH.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInputValueDebounce-C7_bvNGH.d.ts","names":[],"sources":["../src/hooks/useInputValueDebounce/useInputValueDebounce.ts"],"sourcesContent":[],"mappings":";UAEiB;EAAA;EAYA,aAAA,CAAA,EAAA,MAAA;EA4CJ;EAA2C,MAAA,EAAA,GAAA,GAAA,IAAA;EAAA;EAAA,QAAA,EAAA,CAAA,GAAA,KAAA,EAAA,GAAA,EAAA,EAAA,GAAA,IAAA;EAAA;EAKxB,KAAA,EApDvB,MAoDuB;;AAAsC,UAjDrD,2BAiDqD,CAAA,SAAA,OAAA,CAAA,CAAA;EAA5B;EAA2B,QAAA,EAAA,CAAA,GAAA,KAAA,EAAA,GAAA,EAAA,EAAA,GAAA,IAAA;;;;SA1C5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCI;;;;;GAKV,6BAA6B,YAAU,4BAA4B"}

package/dist/useInputValueDebounce-DaH5ONlQ.js

@@ -0,0 +1,84 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+//#region src/hooks/useInputValueDebounce/useInputValueDebounce.ts
+/**
+* Custom hook for debouncing value changes with immediate blur support.
+*
+* Provides immediate visual feedback by updating the value instantly,
+* while debouncing the actual onChange calls. When focus is lost,
+* any pending debounced changes are immediately flushed.
+*
+* **Key Features:**
+* - **Debouncing**: Delays onChange calls until user stops typing
+* - **Generic type support**: Works with any data type (strings, numbers, arrays, objects)
+* - **Immediate value updates**: UI stays responsive during debouncing
+* - **Blur flushing**: Immediately applies pending changes on blur
+*
+* **Note:** Value transformations should be handled at the `useUniformField` level,
+* not in this hook. This hook only handles debouncing timing.
+*
+* @param options Configuration for debounced value handling
+* @param options.debounceDelay Delay in milliseconds (default: 300)
+* @param options.onBlur Function to call after flushing debounced value
+* @param options.onChange Function to call with debounced value
+* @param options.value The field value
+* @returns Object containing enhanced onChange, onBlur, and immediate value
+*
+* @example
+* Basic usage with debouncing:
+* ```tsx
+* const { onChange, onBlur, value } = useInputValueDebounce({
+*   debounceDelay: 300,
+*   onBlur: field.onBlur,
+*   onChange: field.onChange,
+*   value: field.value,
+* });
+* ```
+*/
+const useInputValueDebounce = ({ debounceDelay = 300, onBlur, onChange, value }) => {
+	const [currentValue, setCurrentValue] = useState(value);
+	const timeoutRef = useRef(null);
+	useEffect(() => {
+		setCurrentValue(value);
+	}, [value]);
+	return {
+		onChange: useCallback((...event) => {
+			const newValue = event[0]?.target?.value ?? event[0];
+			setCurrentValue(newValue);
+			if (timeoutRef.current) clearTimeout(timeoutRef.current);
+			const executeOnChange = () => {
+				if (event[0]?.target) onChange({
+					...event[0],
+					target: {
+						...event[0].target,
+						value: newValue
+					}
+				}, ...event.slice(1));
+				else onChange(newValue);
+			};
+			if (debounceDelay <= 0) executeOnChange();
+			else timeoutRef.current = setTimeout(executeOnChange, debounceDelay);
+		}, [onChange, debounceDelay]),
+		onBlur: useCallback(() => {
+			if (timeoutRef.current) {
+				clearTimeout(timeoutRef.current);
+				timeoutRef.current = null;
+				onChange(currentValue);
+			}
+			onBlur();
+		}, [
+			onChange,
+			onBlur,
+			currentValue
+		]),
+		value: currentValue
+	};
+};
+
+//#endregion
+//#region src/hooks/useInputValueDebounce/index.ts
+/* v8 ignore stop */
+
+//#endregion
+export { useInputValueDebounce as t };
+//# sourceMappingURL=useInputValueDebounce-DaH5ONlQ.js.map

package/dist/useInputValueDebounce-DaH5ONlQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInputValueDebounce-DaH5ONlQ.js","names":[],"sources":["../src/hooks/useInputValueDebounce/useInputValueDebounce.ts","../src/hooks/useInputValueDebounce/index.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\n\nexport interface UseInputValueDebounceOptions<TValue = unknown> {\n  /** Debounce delay in milliseconds (default: 300) */\n  debounceDelay?: number;\n  /** The onBlur function to call after flushing debounced value */\n  onBlur: () => void;\n  /** The onChange function to call with debounced value */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  onChange: (...event: any[]) => void;\n  /** The field value */\n  value: TValue;\n}\n\nexport interface UseInputValueDebounceReturn<TValue = unknown> {\n  /** Enhanced onChange function with debouncing */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  onChange: (...event: any[]) => void;\n  /** Enhanced onBlur function that flushes current value immediately */\n  onBlur: () => void;\n  /** The field value that is displayed - updates immediately */\n  value: TValue;\n}\n\n/**\n * Custom hook for debouncing value changes with immediate blur support.\n *\n * Provides immediate visual feedback by updating the value instantly,\n * while debouncing the actual onChange calls. When focus is lost,\n * any pending debounced changes are immediately flushed.\n *\n * **Key Features:**\n * - **Debouncing**: Delays onChange calls until user stops typing\n * - **Generic type support**: Works with any data type (strings, numbers, arrays, objects)\n * - **Immediate value updates**: UI stays responsive during debouncing\n * - **Blur flushing**: Immediately applies pending changes on blur\n *\n * **Note:** Value transformations should be handled at the `useUniformField` level,\n * not in this hook. This hook only handles debouncing timing.\n *\n * @param options Configuration for debounced value handling\n * @param options.debounceDelay Delay in milliseconds (default: 300)\n * @param options.onBlur Function to call after flushing debounced value\n * @param options.onChange Function to call with debounced value\n * @param options.value The field value\n * @returns Object containing enhanced onChange, onBlur, and immediate value\n *\n * @example\n * Basic usage with debouncing:\n * ```tsx\n * const { onChange, onBlur, value } = useInputValueDebounce({\n *   debounceDelay: 300,\n *   onBlur: field.onBlur,\n *   onChange: field.onChange,\n *   value: field.value,\n * });\n * ```\n */\nexport const useInputValueDebounce = <TValue = unknown>({\n  debounceDelay = 300,\n  onBlur,\n  onChange,\n  value,\n}: UseInputValueDebounceOptions<TValue>): UseInputValueDebounceReturn<TValue> => {\n  // Track value for synchronous updates\n  const [currentValue, setCurrentValue] = useState<TValue>(value);\n\n  const timeoutRef = useRef<NodeJS.Timeout | null>(null);\n\n  // Sync with external value changes\n  useEffect(() => {\n    setCurrentValue(value);\n  }, [value]);\n\n  // Enhanced onChange handler with debouncing\n  const handleChange = useCallback(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (...event: any[]) => {\n      // Extract the raw value\n      const newValue = (event[0]?.target?.value ?? event[0]) as TValue;\n      setCurrentValue(newValue);\n\n      // Clear existing timeout\n      if (timeoutRef.current) {\n        clearTimeout(timeoutRef.current);\n      }\n\n      const executeOnChange = () => {\n        // Preserve event structure if original was an event\n        if (event[0]?.target) {\n          const convertedEvent = {\n            ...event[0],\n            target: {\n              ...event[0].target,\n              value: newValue,\n            },\n          };\n          onChange(convertedEvent, ...event.slice(1));\n        } else {\n          onChange(newValue);\n        }\n      };\n\n      // Execute immediately or after delay\n      if (debounceDelay <= 0) {\n        executeOnChange();\n      } else {\n        timeoutRef.current = setTimeout(executeOnChange, debounceDelay);\n      }\n    },\n    [onChange, debounceDelay],\n  );\n\n  // Enhanced blur handler\n  const handleBlur = useCallback(() => {\n    // Flush pending changes\n    if (timeoutRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = null;\n      onChange(currentValue);\n    }\n    onBlur();\n  }, [onChange, onBlur, currentValue]);\n\n  return {\n    onChange: handleChange,\n    onBlur: handleBlur,\n    value: currentValue,\n  };\n};\n","/* v8 ignore start */\n\nexport * from './useInputValueDebounce';\n\n/* v8 ignore stop */\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,MAAa,yBAA2C,EACtD,gBAAgB,KAChB,QACA,UACA,YAC+E;CAE/E,MAAM,CAAC,cAAc,mBAAmB,SAAiB,MAAM;CAE/D,MAAM,aAAa,OAA8B,KAAK;AAGtD,iBAAgB;AACd,kBAAgB,MAAM;IACrB,CAAC,MAAM,CAAC;AAoDX,QAAO;EACL,UAlDmB,aAElB,GAAG,UAAiB;GAEnB,MAAM,WAAY,MAAM,IAAI,QAAQ,SAAS,MAAM;AACnD,mBAAgB,SAAS;AAGzB,OAAI,WAAW,QACb,cAAa,WAAW,QAAQ;GAGlC,MAAM,wBAAwB;AAE5B,QAAI,MAAM,IAAI,OAQZ,UAPuB;KACrB,GAAG,MAAM;KACT,QAAQ;MACN,GAAG,MAAM,GAAG;MACZ,OAAO;MACR;KACF,EACwB,GAAG,MAAM,MAAM,EAAE,CAAC;QAE3C,UAAS,SAAS;;AAKtB,OAAI,iBAAiB,EACnB,kBAAiB;OAEjB,YAAW,UAAU,WAAW,iBAAiB,cAAc;KAGnE,CAAC,UAAU,cAAc,CAC1B;EAeC,QAZiB,kBAAkB;AAEnC,OAAI,WAAW,SAAS;AACtB,iBAAa,WAAW,QAAQ;AAChC,eAAW,UAAU;AACrB,aAAS,aAAa;;AAExB,WAAQ;KACP;GAAC;GAAU;GAAQ;GAAa,CAAC;EAKlC,OAAO;EACR"}

package/dist/useInputValueDebounce-tL8maIp8.cjs

@@ -0,0 +1,90 @@
+const require_FormContext = require('./FormContext-C3GymQOA.cjs');
+let react = require("react");
+
+//#region src/hooks/useInputValueDebounce/useInputValueDebounce.ts
+/**
+* Custom hook for debouncing value changes with immediate blur support.
+*
+* Provides immediate visual feedback by updating the value instantly,
+* while debouncing the actual onChange calls. When focus is lost,
+* any pending debounced changes are immediately flushed.
+*
+* **Key Features:**
+* - **Debouncing**: Delays onChange calls until user stops typing
+* - **Generic type support**: Works with any data type (strings, numbers, arrays, objects)
+* - **Immediate value updates**: UI stays responsive during debouncing
+* - **Blur flushing**: Immediately applies pending changes on blur
+*
+* **Note:** Value transformations should be handled at the `useUniformField` level,
+* not in this hook. This hook only handles debouncing timing.
+*
+* @param options Configuration for debounced value handling
+* @param options.debounceDelay Delay in milliseconds (default: 300)
+* @param options.onBlur Function to call after flushing debounced value
+* @param options.onChange Function to call with debounced value
+* @param options.value The field value
+* @returns Object containing enhanced onChange, onBlur, and immediate value
+*
+* @example
+* Basic usage with debouncing:
+* ```tsx
+* const { onChange, onBlur, value } = useInputValueDebounce({
+*   debounceDelay: 300,
+*   onBlur: field.onBlur,
+*   onChange: field.onChange,
+*   value: field.value,
+* });
+* ```
+*/
+const useInputValueDebounce = ({ debounceDelay = 300, onBlur, onChange, value }) => {
+	const [currentValue, setCurrentValue] = (0, react.useState)(value);
+	const timeoutRef = (0, react.useRef)(null);
+	(0, react.useEffect)(() => {
+		setCurrentValue(value);
+	}, [value]);
+	return {
+		onChange: (0, react.useCallback)((...event) => {
+			const newValue = event[0]?.target?.value ?? event[0];
+			setCurrentValue(newValue);
+			if (timeoutRef.current) clearTimeout(timeoutRef.current);
+			const executeOnChange = () => {
+				if (event[0]?.target) onChange({
+					...event[0],
+					target: {
+						...event[0].target,
+						value: newValue
+					}
+				}, ...event.slice(1));
+				else onChange(newValue);
+			};
+			if (debounceDelay <= 0) executeOnChange();
+			else timeoutRef.current = setTimeout(executeOnChange, debounceDelay);
+		}, [onChange, debounceDelay]),
+		onBlur: (0, react.useCallback)(() => {
+			if (timeoutRef.current) {
+				clearTimeout(timeoutRef.current);
+				timeoutRef.current = null;
+				onChange(currentValue);
+			}
+			onBlur();
+		}, [
+			onChange,
+			onBlur,
+			currentValue
+		]),
+		value: currentValue
+	};
+};
+
+//#endregion
+//#region src/hooks/useInputValueDebounce/index.ts
+/* v8 ignore stop */
+
+//#endregion
+Object.defineProperty(exports, 'useInputValueDebounce', {
+  enumerable: true,
+  get: function () {
+    return useInputValueDebounce;
+  }
+});
+//# sourceMappingURL=useInputValueDebounce-tL8maIp8.cjs.map

package/dist/useInputValueDebounce-tL8maIp8.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInputValueDebounce-tL8maIp8.cjs","names":[],"sources":["../src/hooks/useInputValueDebounce/useInputValueDebounce.ts","../src/hooks/useInputValueDebounce/index.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\n\nexport interface UseInputValueDebounceOptions<TValue = unknown> {\n  /** Debounce delay in milliseconds (default: 300) */\n  debounceDelay?: number;\n  /** The onBlur function to call after flushing debounced value */\n  onBlur: () => void;\n  /** The onChange function to call with debounced value */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  onChange: (...event: any[]) => void;\n  /** The field value */\n  value: TValue;\n}\n\nexport interface UseInputValueDebounceReturn<TValue = unknown> {\n  /** Enhanced onChange function with debouncing */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  onChange: (...event: any[]) => void;\n  /** Enhanced onBlur function that flushes current value immediately */\n  onBlur: () => void;\n  /** The field value that is displayed - updates immediately */\n  value: TValue;\n}\n\n/**\n * Custom hook for debouncing value changes with immediate blur support.\n *\n * Provides immediate visual feedback by updating the value instantly,\n * while debouncing the actual onChange calls. When focus is lost,\n * any pending debounced changes are immediately flushed.\n *\n * **Key Features:**\n * - **Debouncing**: Delays onChange calls until user stops typing\n * - **Generic type support**: Works with any data type (strings, numbers, arrays, objects)\n * - **Immediate value updates**: UI stays responsive during debouncing\n * - **Blur flushing**: Immediately applies pending changes on blur\n *\n * **Note:** Value transformations should be handled at the `useUniformField` level,\n * not in this hook. This hook only handles debouncing timing.\n *\n * @param options Configuration for debounced value handling\n * @param options.debounceDelay Delay in milliseconds (default: 300)\n * @param options.onBlur Function to call after flushing debounced value\n * @param options.onChange Function to call with debounced value\n * @param options.value The field value\n * @returns Object containing enhanced onChange, onBlur, and immediate value\n *\n * @example\n * Basic usage with debouncing:\n * ```tsx\n * const { onChange, onBlur, value } = useInputValueDebounce({\n *   debounceDelay: 300,\n *   onBlur: field.onBlur,\n *   onChange: field.onChange,\n *   value: field.value,\n * });\n * ```\n */\nexport const useInputValueDebounce = <TValue = unknown>({\n  debounceDelay = 300,\n  onBlur,\n  onChange,\n  value,\n}: UseInputValueDebounceOptions<TValue>): UseInputValueDebounceReturn<TValue> => {\n  // Track value for synchronous updates\n  const [currentValue, setCurrentValue] = useState<TValue>(value);\n\n  const timeoutRef = useRef<NodeJS.Timeout | null>(null);\n\n  // Sync with external value changes\n  useEffect(() => {\n    setCurrentValue(value);\n  }, [value]);\n\n  // Enhanced onChange handler with debouncing\n  const handleChange = useCallback(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (...event: any[]) => {\n      // Extract the raw value\n      const newValue = (event[0]?.target?.value ?? event[0]) as TValue;\n      setCurrentValue(newValue);\n\n      // Clear existing timeout\n      if (timeoutRef.current) {\n        clearTimeout(timeoutRef.current);\n      }\n\n      const executeOnChange = () => {\n        // Preserve event structure if original was an event\n        if (event[0]?.target) {\n          const convertedEvent = {\n            ...event[0],\n            target: {\n              ...event[0].target,\n              value: newValue,\n            },\n          };\n          onChange(convertedEvent, ...event.slice(1));\n        } else {\n          onChange(newValue);\n        }\n      };\n\n      // Execute immediately or after delay\n      if (debounceDelay <= 0) {\n        executeOnChange();\n      } else {\n        timeoutRef.current = setTimeout(executeOnChange, debounceDelay);\n      }\n    },\n    [onChange, debounceDelay],\n  );\n\n  // Enhanced blur handler\n  const handleBlur = useCallback(() => {\n    // Flush pending changes\n    if (timeoutRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = null;\n      onChange(currentValue);\n    }\n    onBlur();\n  }, [onChange, onBlur, currentValue]);\n\n  return {\n    onChange: handleChange,\n    onBlur: handleBlur,\n    value: currentValue,\n  };\n};\n","/* v8 ignore start */\n\nexport * from './useInputValueDebounce';\n\n/* v8 ignore stop */\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,MAAa,yBAA2C,EACtD,gBAAgB,KAChB,QACA,UACA,YAC+E;CAE/E,MAAM,CAAC,cAAc,uCAAoC,MAAM;CAE/D,MAAM,+BAA2C,KAAK;AAGtD,4BAAgB;AACd,kBAAgB,MAAM;IACrB,CAAC,MAAM,CAAC;AAoDX,QAAO;EACL,kCAhDC,GAAG,UAAiB;GAEnB,MAAM,WAAY,MAAM,IAAI,QAAQ,SAAS,MAAM;AACnD,mBAAgB,SAAS;AAGzB,OAAI,WAAW,QACb,cAAa,WAAW,QAAQ;GAGlC,MAAM,wBAAwB;AAE5B,QAAI,MAAM,IAAI,OAQZ,UAPuB;KACrB,GAAG,MAAM;KACT,QAAQ;MACN,GAAG,MAAM,GAAG;MACZ,OAAO;MACR;KACF,EACwB,GAAG,MAAM,MAAM,EAAE,CAAC;QAE3C,UAAS,SAAS;;AAKtB,OAAI,iBAAiB,EACnB,kBAAiB;OAEjB,YAAW,UAAU,WAAW,iBAAiB,cAAc;KAGnE,CAAC,UAAU,cAAc,CAC1B;EAeC,qCAZmC;AAEnC,OAAI,WAAW,SAAS;AACtB,iBAAa,WAAW,QAAQ;AAChC,eAAW,UAAU;AACrB,aAAS,aAAa;;AAExB,WAAQ;KACP;GAAC;GAAU;GAAQ;GAAa,CAAC;EAKlC,OAAO;EACR"}