@fuf-stack/uniform 1.13.0 → 1.15.0

package/dist/{index-DtWIiEFa.d.cts → index-BM5ClMN4.d.ts}

@@ -1,31 +1,29 @@
-import * as tailwind_variants0 from "tailwind-variants";
-import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { TVClassName, TVProps } from "@fuf-stack/pixel-utils";
 import { ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { Props } from "react-select";
+import * as tailwind_variants0 from "tailwind-variants";
 
 //#region src/Select/Select.d.ts
 declare const selectVariants: tailwind_variants0.TVReturnType<{
   [key: string]: {
     [key: string]: tailwind_variants0.ClassValue | {
-      label?: tailwind_variants0.ClassValue;
       base?: tailwind_variants0.ClassValue;
-      input?: tailwind_variants0.ClassValue;
-      menu?: tailwind_variants0.ClassValue;
-      option?: tailwind_variants0.ClassValue;
-      placeholder?: tailwind_variants0.ClassValue;
-      control?: tailwind_variants0.ClassValue;
-      group?: tailwind_variants0.ClassValue;
       clearIndicator?: tailwind_variants0.ClassValue;
+      control?: tailwind_variants0.ClassValue;
       control_focused?: tailwind_variants0.ClassValue;
       crossIcon?: tailwind_variants0.ClassValue;
       downChevron?: tailwind_variants0.ClassValue;
       dropdownIndicator?: tailwind_variants0.ClassValue;
+      group?: tailwind_variants0.ClassValue;
       groupHeading?: tailwind_variants0.ClassValue;
       indicatorsContainer?: tailwind_variants0.ClassValue;
       indicatorSeparator?: tailwind_variants0.ClassValue;
+      input?: tailwind_variants0.ClassValue;
+      label?: tailwind_variants0.ClassValue;
       loadingIndicator?: tailwind_variants0.ClassValue;
       loadingMessage?: tailwind_variants0.ClassValue;
+      menu?: tailwind_variants0.ClassValue;
       menuList?: tailwind_variants0.ClassValue;
       menuPortal?: tailwind_variants0.ClassValue;
       multiValue?: tailwind_variants0.ClassValue;
@@ -35,6 +33,8 @@ declare const selectVariants: tailwind_variants0.TVReturnType<{
       noOptionsMessage?: tailwind_variants0.ClassValue;
       option_focused?: tailwind_variants0.ClassValue;
       option_selected?: tailwind_variants0.ClassValue;
+      option?: tailwind_variants0.ClassValue;
+      placeholder?: tailwind_variants0.ClassValue;
       selectContainer?: tailwind_variants0.ClassValue;
       singleValue?: tailwind_variants0.ClassValue;
       valueContainer?: tailwind_variants0.ClassValue;
@@ -43,24 +43,22 @@ declare const selectVariants: tailwind_variants0.TVReturnType<{
 } | {
   [x: string]: {
     [x: string]: tailwind_variants0.ClassValue | {
-      label?: tailwind_variants0.ClassValue;
       base?: tailwind_variants0.ClassValue;
-      input?: tailwind_variants0.ClassValue;
-      menu?: tailwind_variants0.ClassValue;
-      option?: tailwind_variants0.ClassValue;
-      placeholder?: tailwind_variants0.ClassValue;
-      control?: tailwind_variants0.ClassValue;
-      group?: tailwind_variants0.ClassValue;
       clearIndicator?: tailwind_variants0.ClassValue;
+      control?: tailwind_variants0.ClassValue;
       control_focused?: tailwind_variants0.ClassValue;
       crossIcon?: tailwind_variants0.ClassValue;
       downChevron?: tailwind_variants0.ClassValue;
       dropdownIndicator?: tailwind_variants0.ClassValue;
+      group?: tailwind_variants0.ClassValue;
       groupHeading?: tailwind_variants0.ClassValue;
       indicatorsContainer?: tailwind_variants0.ClassValue;
       indicatorSeparator?: tailwind_variants0.ClassValue;
+      input?: tailwind_variants0.ClassValue;
+      label?: tailwind_variants0.ClassValue;
       loadingIndicator?: tailwind_variants0.ClassValue;
       loadingMessage?: tailwind_variants0.ClassValue;
+      menu?: tailwind_variants0.ClassValue;
       menuList?: tailwind_variants0.ClassValue;
       menuPortal?: tailwind_variants0.ClassValue;
       multiValue?: tailwind_variants0.ClassValue;
@@ -70,6 +68,8 @@ declare const selectVariants: tailwind_variants0.TVReturnType<{
       noOptionsMessage?: tailwind_variants0.ClassValue;
       option_focused?: tailwind_variants0.ClassValue;
       option_selected?: tailwind_variants0.ClassValue;
+      option?: tailwind_variants0.ClassValue;
+      placeholder?: tailwind_variants0.ClassValue;
       selectContainer?: tailwind_variants0.ClassValue;
       singleValue?: tailwind_variants0.ClassValue;
       valueContainer?: tailwind_variants0.ClassValue;
@@ -109,24 +109,22 @@ declare const selectVariants: tailwind_variants0.TVReturnType<{
 }, undefined, {
   [key: string]: {
     [key: string]: tailwind_variants0.ClassValue | {
-      label?: tailwind_variants0.ClassValue;
       base?: tailwind_variants0.ClassValue;
-      input?: tailwind_variants0.ClassValue;
-      menu?: tailwind_variants0.ClassValue;
-      option?: tailwind_variants0.ClassValue;
-      placeholder?: tailwind_variants0.ClassValue;
-      control?: tailwind_variants0.ClassValue;
-      group?: tailwind_variants0.ClassValue;
       clearIndicator?: tailwind_variants0.ClassValue;
+      control?: tailwind_variants0.ClassValue;
       control_focused?: tailwind_variants0.ClassValue;
       crossIcon?: tailwind_variants0.ClassValue;
       downChevron?: tailwind_variants0.ClassValue;
       dropdownIndicator?: tailwind_variants0.ClassValue;
+      group?: tailwind_variants0.ClassValue;
       groupHeading?: tailwind_variants0.ClassValue;
       indicatorsContainer?: tailwind_variants0.ClassValue;
       indicatorSeparator?: tailwind_variants0.ClassValue;
+      input?: tailwind_variants0.ClassValue;
+      label?: tailwind_variants0.ClassValue;
       loadingIndicator?: tailwind_variants0.ClassValue;
       loadingMessage?: tailwind_variants0.ClassValue;
+      menu?: tailwind_variants0.ClassValue;
       menuList?: tailwind_variants0.ClassValue;
       menuPortal?: tailwind_variants0.ClassValue;
       multiValue?: tailwind_variants0.ClassValue;
@@ -136,6 +134,8 @@ declare const selectVariants: tailwind_variants0.TVReturnType<{
       noOptionsMessage?: tailwind_variants0.ClassValue;
       option_focused?: tailwind_variants0.ClassValue;
       option_selected?: tailwind_variants0.ClassValue;
+      option?: tailwind_variants0.ClassValue;
+      placeholder?: tailwind_variants0.ClassValue;
       selectContainer?: tailwind_variants0.ClassValue;
       singleValue?: tailwind_variants0.ClassValue;
       valueContainer?: tailwind_variants0.ClassValue;
@@ -205,6 +205,11 @@ declare const selectVariants: tailwind_variants0.TVReturnType<{
   valueContainer: string;
 }, undefined, unknown, unknown, undefined>>;
 interface SelectOption {
+  /**
+   * True when option was auto-generated because the value wasn't found in options.
+   * Use in renderOptionLabel to render a component that fetches the real label.
+   */
+  isFallback?: boolean;
   /** option label */
   label?: ReactNode;
   /** option value */
@@ -241,6 +246,14 @@ interface SelectProps extends VariantProps {
   options: SelectOption[];
   /** Handle change events on the input */
   onInputChange?: Props['onInputChange'];
+  /**
+   * Fallback option(s) for async selects when value isn't in current options.
+   * Use when the selected value may not be in the options list (e.g., after
+   * search results change). Used only if value not found in options.
+   * For single select: pass the option object or undefined
+   * For multi-select: pass an array of option objects
+   */
+  selectedOptionFallback?: SelectOption | SelectOption[];
   /** HTML data-testid attribute used in e2e tests */
   testId?: string;
 }
@@ -257,8 +270,9 @@ declare const Select: ({
   onInputChange,
   options,
   placeholder,
+  selectedOptionFallback,
   ...uniformFieldProps
 }: SelectProps) => react_jsx_runtime0.JSX.Element;
 //#endregion
 export { SelectProps as n, Select as t };
-//# sourceMappingURL=index-DtWIiEFa.d.cts.map
+//# sourceMappingURL=index-BM5ClMN4.d.ts.map

package/dist/index-BM5ClMN4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BM5ClMN4.d.ts","names":[],"sources":["../src/Select/Select.tsx"],"sourcesContent":[],"mappings":";;;;;;;cAea,mCAAc;;mBA0CzB,kBAAA,CAAA,UAAA;;MA1CW,cA0CX,CAAA,+BAAA;MAAA,OAAA,CAAA,+BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA1CyB;EAAA,cAAA,EAAA,MAAA;AA0CxB,CAAA,EAAA,SAEO,EAAA;EAYL,CAAA,GAAA,EAAA,MAAA,CAAA,EAAY;IACZ,CAAA,GAAA,EAAA,MAAS,CAAA,kCAAc;MAEX,IAAA,CAAA,+BAAY;MAIf,cAAA,CAAA,+BAAA;MAQG,OAAA,CAAA,+BAAA;MAEiB,eAAA,CAAA,+BAAA;MAIxB,SAAA,CAAA,+BAAA;MAUC,WAAA,CAAA,+BAAA;MAEO,iBAAA,CAAA,+BAAA;MAQS,KAAA,CAAA,+BAAA;MAAe,YAAA,CAAA,+BAAA;MAtCL,mBAAA,CAAA,+BAAA;MAAY,kBAAA,CAAA,+BAAA;MA0F3C,KAuSL,CAAA,+BAAA;MAvSe,KAAA,CAAA,+BAAA;MAAA,gBAAA,CAAA,+BAAA;MAAA,cAAA,CAAA,+BAAA;MAAA,IAAA,CAAA,+BAAA;MAAA,QAAA,CAAA,+BAAA;MAAA,UAAA,CAAA,+BAAA;MAAA,UAAA,CAAA,+BAAA;MAAA,mBAAA,CAAA,+BAAA;MAAA,eAAA,CAAA,+BAAA;MAAA,gBAAA,CAAA,+BAAA;MAAA,gBAAA,CAAA,+BAAA;MAAA,cAAA,CAAA,+BAAA;MAcb,eAAA,CAAA,+BAAA;MAAW,MAAA,CAAA,+BAAA;MAyRb,WAAA,CAAA,+BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAhZS,YAAA;;;;;;;UAOA;;;;KAKL,YAAA,GAAe,eAAe;KAC9B,SAAA,GAAY,mBAAmB;UAEnB,WAAA,SAAoB;;;;cAIvB;;;;;;wCAQG;;kCAEiB;;;;UAIxB;;;;;;;;;;WAUC;;kBAEO;;;;;;;;2BAQS,eAAe;;;;;cAoDpC;;;;;;;;;;;;;;GAcH,gBAAW,kBAAA,CAAA,GAAA,CAAA"}

package/dist/index-BPjrrFuM.d.ts

@@ -0,0 +1,186 @@
+//#region src/helpers/createOptionValueConverter/createOptionValueConverter.d.ts
+/**
+ * Creates a converter function that preserves the original type (string, number, or boolean)
+ * of option values when converting from string keys back to their original type.
+ *
+ * This is useful for radio/select components where the underlying UI library
+ * uses string keys internally, but we want to preserve number/boolean values in the form state.
+ *
+ * @param options - Array of options with a value property that can be string, number, or boolean
+ * @returns An object with:
+ *   - `convertToOriginalType`: Function to convert a string key back to its original type
+ *   - `numberValueKeys`: Set of string representations of number values (for internal use)
+ *   - `booleanValueKeys`: Map of string representations to boolean values (for internal use)
+ */
+declare const createOptionValueConverter: <T extends {
+  value: string | number | boolean;
+}>(options: T[]) => {
+  booleanValueKeys: Map<string, boolean>;
+  convertToOriginalType: (key: string | number | boolean) => string | number | boolean;
+  numberValueKeys: Set<string>;
+};
+//#endregion
+//#region src/helpers/nullishFields/nullishFields.d.ts
+/** Key used to wrap flat array elements when converting to form format */
+declare const flatArrayKey = "__FLAT__";
+/**
+ * Checks if a value is considered "empty" for validation display purposes.
+ *
+ * Used by useUniformField to determine when to show validation errors.
+ * Empty values don't trigger immediate error display (user must interact first).
+ *
+ * Handles:
+ * - Primitives: null, undefined, ''
+ * - Marker strings: __NULL__, __FALSE__, __ZERO__ (converted via fromNullishString)
+ * - Empty arrays: []
+ * - Objects with all empty values: {a: null, b: ''}
+ * - Flat array wrappers: {__FLAT__: null} or {__FLAT__: ''}
+ *
+ * @param value - The value to check (will be converted via fromNullishString first)
+ * @returns true if the value is empty
+ *
+ * @example
+ * isValueEmpty(null)                    // true
+ * isValueEmpty('')                      // true
+ * isValueEmpty('__NULL__')              // true (marker string)
+ * isValueEmpty([])                      // true (empty array)
+ * isValueEmpty({a: null})               // true (object with all empty values)
+ * isValueEmpty({__FLAT__: null})        // true (flat array wrapper with empty value)
+ * isValueEmpty({__FLAT__: ''})          // true
+ * isValueEmpty('hello')                 // false
+ * isValueEmpty([1, 2])                  // false
+ * isValueEmpty({a: 'value'})            // false
+ * isValueEmpty({__FLAT__: 'value'})     // false
+ */
+declare const isValueEmpty: (value: unknown) => boolean;
+/**
+ * Converts marker strings back to their original values when processing arrays
+ */
+declare const fromNullishString: (value: unknown) => unknown;
+/**
+ * Converts null/falsy values to marker strings for JSON processing
+ */
+declare const toNullishString: (value: unknown) => unknown;
+/**
+ * Converts field values to a format suitable for forms by:
+ * - Wrapping arrays of primitives as objects using the flatArrayKey `__FLAT__`
+ *   to satisfy RHF's requirement that array fields contain objects
+ * - Removing empty strings and null values from objects
+ *
+ * This conversion is required because React Hook Form does not support arrays with
+ * flat values (string, number, boolean, null). Array fields must contain objects.
+ * We work around this by wrapping primitive entries: `{ __FLAT__: <value> }`.
+ *
+ * @example
+ * const fields = {
+ *   name: 'John',
+ *   scores: [0, null, 75, false],
+ *   scoresDetailed: [
+ *     { score: 1 },
+ *     { score: null },
+ *     { score: 0 },
+ *     { score: false },
+ *     { score: '' },
+ *   ],
+ *   contact: {
+ *     email: '',
+ *     phone: null,
+ *     address: '123 Main St'
+ *   }
+ * };
+ *
+ * // Result:
+ * {
+ *   name: 'John',
+ *   scores: [
+ *     { __FLAT__: 0 },
+ *     { __FLAT__: null },
+ *     { __FLAT__: 75 },
+ *     { __FLAT__: false }
+ *   ],
+ *   // Arrays of objects are left as objects; empty/null properties are removed
+ *   scoresDetailed: [
+ *     { score: 1 },
+ *     {}, // null score removed
+ *     { score: 0 },
+ *     { score: false },
+ *     {}, // empty string removed
+ *   ],
+ *   contact: {
+ *     address: '123 Main St'
+ *   }
+ * }
+ */
+declare const toFormFormat: (fields: Record<string, unknown>) => Record<string, unknown>;
+/**
+ * Converts form state to a format suitable for validation by:
+ * - Unwrapping flat array wrappers `{ __FLAT__: <value> }` back to primitives
+ * - Converting legacy string markers (__NULL__, __FALSE__, __ZERO__) back to their original values
+ * - Removing fields whose converted value is empty string or null
+ * - Removing empty arrays
+ *
+ * @example
+ * const formState = {
+ *   name: 'John',
+ *   scores: [
+ *     { __FLAT__: 75 },
+ *     { __FLAT__: 0 },
+ *     { __FLAT__: null },
+ *     { __FLAT__: false }
+ *   ],
+ *   emptyArray: [],
+ *   scoresDetailed: [
+ *     { score: 1 },
+ *     {},
+ *     { score: 0 },
+ *     { score: false },
+ *     {},
+ *   ],
+ *   contact: {
+ *     address: '123 Main St',
+ *     fax: null
+ *   }
+ * };
+ *
+ * // Result:
+ * {
+ *   name: 'John',
+ *   scores: [75, 0, null, false],
+ *   // emptyArray is removed
+ *   // Objects inside arrays remain objects; empty entries remain empty objects
+ *   scoresDetailed: [
+ *     { score: 1 },
+ *     {},
+ *     { score: 0 },
+ *     { score: false },
+ *     {},
+ *   ],
+ *   contact: {
+ *     address: '123 Main St'
+ *   }
+ * }
+ */
+declare const toValidationFormat: (formState: Record<string, unknown> | null | undefined) => Record<string, unknown> | null | undefined;
+/**
+ * Converts a field name to a testId by removing flat array key segments and slugifying.
+ * Removes all occurrences of `flatArrayKey` from the field name and applies slugify transformation.
+ *
+ * This is used to generate stable testIds for form fields that don't include
+ * the internal `__FLAT__` marker used for flat arrays.
+ *
+ * @param name - The field name as a string (e.g., 'tags.0.__FLAT__') or array path (e.g., ['tags', '0', '__FLAT__'])
+ * @returns The slugified field name with all flat array key segments removed (e.g., 'tags_0')
+ *
+ * @example
+ * ```ts
+ * nameToTestId('tags.0.__FLAT__') // => 'tags_0'
+ * nameToTestId('array.0.__FLAT__') // => 'array_0'
+ * nameToTestId('nested.array.0.__FLAT__.field') // => 'nested_array_0_field'
+ * nameToTestId('simple.field') // => 'simple_field'
+ * nameToTestId(['tags', '0', '__FLAT__']) // => 'tags_0'
+ * ```
+ */
+declare const nameToTestId: (name: string | readonly string[]) => string;
+//#endregion
+export { toFormFormat as a, createOptionValueConverter as c, nameToTestId as i, fromNullishString as n, toNullishString as o, isValueEmpty as r, toValidationFormat as s, flatArrayKey as t };
+//# sourceMappingURL=index-BPjrrFuM.d.ts.map

package/dist/index-BPjrrFuM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BPjrrFuM.d.ts","names":[],"sources":["../src/helpers/createOptionValueConverter/createOptionValueConverter.ts","../src/helpers/nullishFields/nullishFields.ts"],"sourcesContent":[],"mappings":";;AAeA;;;;;;;;ACZA;AAsCA;AA0BA;AAsCA;AA6Ea,cDvKA,0BC+LgC,EAAA,CAAA,UAAA;EAmDhC,KAAA,EAAA,MAAA,GAAA,MA6EZ,GAAA,OAAA;AAqBD,CAAA,CAAA,CAAA,OAAa,EDjVF,CCiVE,EAAA,EAAA,GAsBZ;;;;;;;;AD1WY,cCZA,YAAA,GD8DZ,UAAA;;;;;;;;AC9DD;AAsCA;AA0BA;AAsCA;AA6EA;AA2EA;AAkGA;;;;;;;;;;;;;;;;cA1Ta;;;;cA0BA;;;;cAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6EA,uBAAwB,4BAwBE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmD1B,gCACA,+CACV;;;;;;;;;;;;;;;;;;;;cAgGU"}

package/dist/{index-CXkSuHEL.d.ts → index-BQDEnYTq.d.ts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as react_jsx_runtime1 from "react/jsx-runtime";
 
 //#region src/partials/FieldCopyTestIdButton/FieldCopyTestIdButton.d.ts
 interface FieldCopyTestIdButtonProps {
@@ -10,7 +10,7 @@ interface FieldCopyTestIdButtonProps {
 declare const FieldCopyTestIdButton: ({
   className,
   testId
-}: FieldCopyTestIdButtonProps) => react_jsx_runtime0.JSX.Element;
+}: FieldCopyTestIdButtonProps) => react_jsx_runtime1.JSX.Element;
 //#endregion
 export { FieldCopyTestIdButtonProps as n, FieldCopyTestIdButton as t };
-//# sourceMappingURL=index-CXkSuHEL.d.ts.map
+//# sourceMappingURL=index-BQDEnYTq.d.ts.map

package/dist/{index-CXkSuHEL.d.ts.map → index-BQDEnYTq.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-CXkSuHEL.d.ts","names":[],"sources":["../src/partials/FieldCopyTestIdButton/FieldCopyTestIdButton.tsx"],"sourcesContent":[],"mappings":";;;UAKiB,0BAAA;;;EAAA;EAOX,MAAA,EAAA,MAAA;;cAAA,qBAAyB,EAAA,CAAA;EAAA,SAAA;EAAA;AAAA,CAAA,EAG5B,0BAH4B,EAAA,GAGF,kBAAA,CAAA,GAAA,CAAA,OAHE"}
+{"version":3,"file":"index-BQDEnYTq.d.ts","names":[],"sources":["../src/partials/FieldCopyTestIdButton/FieldCopyTestIdButton.tsx"],"sourcesContent":[],"mappings":";;;UAKiB,0BAAA;;;EAAA;EAOX,MAAA,EAAA,MAAA;;cAAA,qBAAyB,EAAA,CAAA;EAAA,SAAA;EAAA;AAAA,CAAA,EAG5B,0BAH4B,EAAA,GAGF,kBAAA,CAAA,GAAA,CAAA,OAHE"}

package/dist/{index-_njc33cQ.d.cts → index-BSZJQBCK.d.ts}

@@ -1,7 +1,7 @@
-import * as tailwind_variants227 from "tailwind-variants";
-import * as react_jsx_runtime7 from "react/jsx-runtime";
 import { TVClassName } from "@fuf-stack/pixel-utils";
 import { ReactNode } from "react";
+import * as react_jsx_runtime11 from "react/jsx-runtime";
+import * as tailwind_variants227 from "tailwind-variants";
 
 //#region src/FieldCard/FieldCard.d.ts
 declare const fieldCardVariants: tailwind_variants227.TVReturnType<{
@@ -98,7 +98,7 @@ declare const FieldCard: ({
   className: _className,
   name,
   ...uniformFieldProps
-}: FieldCardProps) => react_jsx_runtime7.JSX.Element;
+}: FieldCardProps) => react_jsx_runtime11.JSX.Element;
 //#endregion
 export { FieldCardProps as n, fieldCardVariants as r, FieldCard as t };
-//# sourceMappingURL=index-_njc33cQ.d.cts.map
+//# sourceMappingURL=index-BSZJQBCK.d.ts.map

package/dist/{index-rK5GxEPh.d.ts.map → index-BSZJQBCK.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-rK5GxEPh.d.ts","names":[],"sources":["../src/FieldCard/FieldCard.tsx"],"sourcesContent":[],"mappings":";;;;;;cAQa,mBA+CX,oBAAA,CA/C4B;;;;MAAjB,KAAA,EAAA,MA+CX;MAEG,WAAS,EAAA,MAAsB;IAEnB,CAAA;IAEL,KAAA,EAAA;MAEE,IAAA,EAAA,MAAA;MAEL,KAAA,EAAA,MAAA;MAAS,WAAA,EAAA,MAAA;IAgBZ,CAAA;EAAa,CAAA;CAAA,EAAA;EAAA;EAKhB,IAAA,EAAA,MAAA,EAAA;EAAc;EAkChB,KAAA,EAAA,MAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GAjEC,oBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;KAEG,SAAA,GAAY,mBAAmB;UAEnB,cAAA;;YAEL;;cAEE;;SAEL;;;;;;;;;;;;;;;cAgBH;;aAAa;;;GAKhB,mBAAc,kBAAA,CAAA,GAAA,CAAA"}
+{"version":3,"file":"index-BSZJQBCK.d.ts","names":[],"sources":["../src/FieldCard/FieldCard.tsx"],"sourcesContent":[],"mappings":";;;;;;cAQa,mBA+CX,oBAAA,CA/C4B;;;;MAAjB,KAAA,EAAA,MA+CX;MAEG,WAAS,EAAA,MAAsB;IAEnB,CAAA;IAEL,KAAA,EAAA;MAEE,IAAA,EAAA,MAAA;MAEL,KAAA,EAAA,MAAA;MAAS,WAAA,EAAA,MAAA;IAgBZ,CAAA;EAAa,CAAA;CAAA,EAAA;EAAA;EAKhB,IAAA,EAAA,MAAA,EAAA;EAAc;EAkChB,KAAA,EAAA,MAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GAjEC,oBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;KAEG,SAAA,GAAY,mBAAmB;UAEnB,cAAA;;YAEL;;cAEE;;SAEL;;;;;;;;;;;;;;;cAgBH;;aAAa;;;GAKhB,mBAAc,mBAAA,CAAA,GAAA,CAAA"}

package/dist/{index-Z0IxHoXS.d.ts → index-BTTo_ufh.d.ts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime14 from "react/jsx-runtime";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { FieldError } from "react-hook-form";
 
 //#region src/partials/FieldValidationError/FieldValidationError.d.ts
@@ -17,7 +17,7 @@ declare const FieldValidationError: ({
   className,
   error,
   testId
-}: FieldValidationErrorProps) => react_jsx_runtime14.JSX.Element;
+}: FieldValidationErrorProps) => react_jsx_runtime0.JSX.Element;
 //#endregion
 export { FieldValidationErrorProps as n, FieldValidationError as t };
-//# sourceMappingURL=index-Z0IxHoXS.d.ts.map
+//# sourceMappingURL=index-BTTo_ufh.d.ts.map

package/dist/{index-Z0IxHoXS.d.ts.map → index-BTTo_ufh.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-Z0IxHoXS.d.ts","names":[],"sources":["../src/partials/FieldValidationError/FieldValidationError.tsx"],"sourcesContent":[],"mappings":";;;;UASiB,yBAAA;;;EAAA;EAYX,KAAA,CAAA,EARI,UAQJ,EAAA;EAAwB;EAAA,MAAA,EAAA,MAAA;;;;;cAAxB;;;;GAIH,8BAAyB,mBAAA,CAAA,GAAA,CAAA"}
+{"version":3,"file":"index-BTTo_ufh.d.ts","names":[],"sources":["../src/partials/FieldValidationError/FieldValidationError.tsx"],"sourcesContent":[],"mappings":";;;;UASiB,yBAAA;;;EAAA;EAYX,KAAA,CAAA,EARI,UAQJ,EAAA;EAAwB;EAAA,MAAA,EAAA,MAAA;;;;;cAAxB;;;;GAIH,8BAAyB,kBAAA,CAAA,GAAA,CAAA"}

package/dist/index-BTr_gid3.d.cts

@@ -0,0 +1,186 @@
+//#region src/helpers/createOptionValueConverter/createOptionValueConverter.d.ts
+/**
+ * Creates a converter function that preserves the original type (string, number, or boolean)
+ * of option values when converting from string keys back to their original type.
+ *
+ * This is useful for radio/select components where the underlying UI library
+ * uses string keys internally, but we want to preserve number/boolean values in the form state.
+ *
+ * @param options - Array of options with a value property that can be string, number, or boolean
+ * @returns An object with:
+ *   - `convertToOriginalType`: Function to convert a string key back to its original type
+ *   - `numberValueKeys`: Set of string representations of number values (for internal use)
+ *   - `booleanValueKeys`: Map of string representations to boolean values (for internal use)
+ */
+declare const createOptionValueConverter: <T extends {
+  value: string | number | boolean;
+}>(options: T[]) => {
+  booleanValueKeys: Map<string, boolean>;
+  convertToOriginalType: (key: string | number | boolean) => string | number | boolean;
+  numberValueKeys: Set<string>;
+};
+//#endregion
+//#region src/helpers/nullishFields/nullishFields.d.ts
+/** Key used to wrap flat array elements when converting to form format */
+declare const flatArrayKey = "__FLAT__";
+/**
+ * Checks if a value is considered "empty" for validation display purposes.
+ *
+ * Used by useUniformField to determine when to show validation errors.
+ * Empty values don't trigger immediate error display (user must interact first).
+ *
+ * Handles:
+ * - Primitives: null, undefined, ''
+ * - Marker strings: __NULL__, __FALSE__, __ZERO__ (converted via fromNullishString)
+ * - Empty arrays: []
+ * - Objects with all empty values: {a: null, b: ''}
+ * - Flat array wrappers: {__FLAT__: null} or {__FLAT__: ''}
+ *
+ * @param value - The value to check (will be converted via fromNullishString first)
+ * @returns true if the value is empty
+ *
+ * @example
+ * isValueEmpty(null)                    // true
+ * isValueEmpty('')                      // true
+ * isValueEmpty('__NULL__')              // true (marker string)
+ * isValueEmpty([])                      // true (empty array)
+ * isValueEmpty({a: null})               // true (object with all empty values)
+ * isValueEmpty({__FLAT__: null})        // true (flat array wrapper with empty value)
+ * isValueEmpty({__FLAT__: ''})          // true
+ * isValueEmpty('hello')                 // false
+ * isValueEmpty([1, 2])                  // false
+ * isValueEmpty({a: 'value'})            // false
+ * isValueEmpty({__FLAT__: 'value'})     // false
+ */
+declare const isValueEmpty: (value: unknown) => boolean;
+/**
+ * Converts marker strings back to their original values when processing arrays
+ */
+declare const fromNullishString: (value: unknown) => unknown;
+/**
+ * Converts null/falsy values to marker strings for JSON processing
+ */
+declare const toNullishString: (value: unknown) => unknown;
+/**
+ * Converts field values to a format suitable for forms by:
+ * - Wrapping arrays of primitives as objects using the flatArrayKey `__FLAT__`
+ *   to satisfy RHF's requirement that array fields contain objects
+ * - Removing empty strings and null values from objects
+ *
+ * This conversion is required because React Hook Form does not support arrays with
+ * flat values (string, number, boolean, null). Array fields must contain objects.
+ * We work around this by wrapping primitive entries: `{ __FLAT__: <value> }`.
+ *
+ * @example
+ * const fields = {
+ *   name: 'John',
+ *   scores: [0, null, 75, false],
+ *   scoresDetailed: [
+ *     { score: 1 },
+ *     { score: null },
+ *     { score: 0 },
+ *     { score: false },
+ *     { score: '' },
+ *   ],
+ *   contact: {
+ *     email: '',
+ *     phone: null,
+ *     address: '123 Main St'
+ *   }
+ * };
+ *
+ * // Result:
+ * {
+ *   name: 'John',
+ *   scores: [
+ *     { __FLAT__: 0 },
+ *     { __FLAT__: null },
+ *     { __FLAT__: 75 },
+ *     { __FLAT__: false }
+ *   ],
+ *   // Arrays of objects are left as objects; empty/null properties are removed
+ *   scoresDetailed: [
+ *     { score: 1 },
+ *     {}, // null score removed
+ *     { score: 0 },
+ *     { score: false },
+ *     {}, // empty string removed
+ *   ],
+ *   contact: {
+ *     address: '123 Main St'
+ *   }
+ * }
+ */
+declare const toFormFormat: (fields: Record<string, unknown>) => Record<string, unknown>;
+/**
+ * Converts form state to a format suitable for validation by:
+ * - Unwrapping flat array wrappers `{ __FLAT__: <value> }` back to primitives
+ * - Converting legacy string markers (__NULL__, __FALSE__, __ZERO__) back to their original values
+ * - Removing fields whose converted value is empty string or null
+ * - Removing empty arrays
+ *
+ * @example
+ * const formState = {
+ *   name: 'John',
+ *   scores: [
+ *     { __FLAT__: 75 },
+ *     { __FLAT__: 0 },
+ *     { __FLAT__: null },
+ *     { __FLAT__: false }
+ *   ],
+ *   emptyArray: [],
+ *   scoresDetailed: [
+ *     { score: 1 },
+ *     {},
+ *     { score: 0 },
+ *     { score: false },
+ *     {},
+ *   ],
+ *   contact: {
+ *     address: '123 Main St',
+ *     fax: null
+ *   }
+ * };
+ *
+ * // Result:
+ * {
+ *   name: 'John',
+ *   scores: [75, 0, null, false],
+ *   // emptyArray is removed
+ *   // Objects inside arrays remain objects; empty entries remain empty objects
+ *   scoresDetailed: [
+ *     { score: 1 },
+ *     {},
+ *     { score: 0 },
+ *     { score: false },
+ *     {},
+ *   ],
+ *   contact: {
+ *     address: '123 Main St'
+ *   }
+ * }
+ */
+declare const toValidationFormat: (formState: Record<string, unknown> | null | undefined) => Record<string, unknown> | null | undefined;
+/**
+ * Converts a field name to a testId by removing flat array key segments and slugifying.
+ * Removes all occurrences of `flatArrayKey` from the field name and applies slugify transformation.
+ *
+ * This is used to generate stable testIds for form fields that don't include
+ * the internal `__FLAT__` marker used for flat arrays.
+ *
+ * @param name - The field name as a string (e.g., 'tags.0.__FLAT__') or array path (e.g., ['tags', '0', '__FLAT__'])
+ * @returns The slugified field name with all flat array key segments removed (e.g., 'tags_0')
+ *
+ * @example
+ * ```ts
+ * nameToTestId('tags.0.__FLAT__') // => 'tags_0'
+ * nameToTestId('array.0.__FLAT__') // => 'array_0'
+ * nameToTestId('nested.array.0.__FLAT__.field') // => 'nested_array_0_field'
+ * nameToTestId('simple.field') // => 'simple_field'
+ * nameToTestId(['tags', '0', '__FLAT__']) // => 'tags_0'
+ * ```
+ */
+declare const nameToTestId: (name: string | readonly string[]) => string;
+//#endregion
+export { toFormFormat as a, createOptionValueConverter as c, nameToTestId as i, fromNullishString as n, toNullishString as o, isValueEmpty as r, toValidationFormat as s, flatArrayKey as t };
+//# sourceMappingURL=index-BTr_gid3.d.cts.map

package/dist/index-BTr_gid3.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BTr_gid3.d.cts","names":[],"sources":["../src/helpers/createOptionValueConverter/createOptionValueConverter.ts","../src/helpers/nullishFields/nullishFields.ts"],"sourcesContent":[],"mappings":";;AAeA;;;;;;;;ACZA;AAsCA;AA0BA;AAsCA;AA6Ea,cDvKA,0BC+LgC,EAAA,CAAA,UAAA;EAmDhC,KAAA,EAAA,MAAA,GAAA,MA6EZ,GAAA,OAAA;AAqBD,CAAA,CAAA,CAAA,OAAa,EDjVF,CCiVE,EAAA,EAAA,GAsBZ;;;;;;;;AD1WY,cCZA,YAAA,GD8DZ,UAAA;;;;;;;;AC9DD;AAsCA;AA0BA;AAsCA;AA6EA;AA2EA;AAkGA;;;;;;;;;;;;;;;;cA1Ta;;;;cA0BA;;;;cAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6EA,uBAAwB,4BAwBE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmD1B,gCACA,+CACV;;;;;;;;;;;;;;;;;;;;cAgGU"}