@fuf-stack/uniform 1.22.1 → 1.22.3

package/dist/index-BvCTs-LU.d.ts

@@ -1,224 +0,0 @@
-//#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 form state to a format suitable for submission by:
- * - Applying all transformations from toValidationFormat
- * - Additionally removing empty objects from the result
- * - Filtering empty objects from arrays
- * - Recursively cleaning nested structures
- *
- * **Why separate from toValidationFormat?**
- *
- * Empty objects must be preserved during validation so that custom refinements
- * can run. For example, a FieldCard with "at least email or phone required"
- * validation needs the object to exist (even if empty) for the refine to execute.
- *
- * However, for submission, empty objects are meaningless and should be removed
- * to produce clean data for APIs.
- *
- * @example
- * const formState = {
- *   name: 'John',
- *   contact: {},           // Empty FieldCard - will be removed
- *   tags: [{}, {}, {}],    // All empty - array will be removed
- *   items: [
- *     { value: 'a' },
- *     {},                  // Empty entry - will be filtered out
- *     { value: 'b' }
- *   ],
- *   nested: {
- *     deep: {}             // Nested empty - will be removed recursively
- *   }
- * };
- *
- * // Result:
- * {
- *   name: 'John',
- *   items: [{ value: 'a' }, { value: 'b' }]
- * }
- */
-declare const toSubmitFormat: (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, toValidationFormat as c, nameToTestId as i, createOptionValueConverter as l, fromNullishString as n, toNullishString as o, isValueEmpty as r, toSubmitFormat as s, flatArrayKey as t };
-//# sourceMappingURL=index-BvCTs-LU.d.ts.map

package/dist/index-BvCTs-LU.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-BvCTs-LU.d.ts","names":[],"sources":["../src/helpers/createOptionValueConverter/createOptionValueConverter.ts","../src/helpers/nullishFields/nullishFields.ts"],"mappings":";;AAeA;;;;;;;;;;;;cAAa,0BAAA;EACC,KAAA;AAAA,GAEZ,OAAA,EAAS,CAAA;;;;;;;;cCfE,YAAA;;;;;;;;;;;;;;;;;;;;;;;AAAb;;;;AAAyB;AAsCzB;;cAAa,YAAA,GAAgB,KAAc;;AAAA;AA0B3C;cAAa,iBAAA,GAAqB,KAAc;;;AAAA;cAsCnC,eAAA,GAAmB,KAAc;;;;AAAA;AA6E9C;;;;;;;;AAwB6C;AAmD7C;;;;;;;;AAES;AAuKT;;;;;;;;AAES;AA2BT;;;;AAA6D;;;;;;;;;;;;;;;cAjRhD,YAAA,GAAgB,MAAA,EAAQ,MAAA,sBAwBE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDhC,kBAAA,GACX,SAAA,EAAW,MAAA,yCACV,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuKI,cAAA,GACX,SAAA,EAAW,MAAA,yCACV,MAAM;;;;;;;;;;;;;;;;;;;;cA2BI,YAAA,GAAgB,IAAgC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-D1m6qfLO2.d.ts","names":[],"sources":["../src/partials/FieldValidationError/FieldValidationError.tsx"],"mappings":";;;UASiB,yBAAA;;EAEf,SAAA;EAFwC;EAIxC,KAAA,GAAQ,UAAU;EAAA;EAElB,MAAA;AAAA;;;;cAMI,oBAAA;EAAwB,SAAA;EAAA,KAAA;EAAA;AAAA,GAI3B,yBAAA,iCAAyB,GAAA,CAAA,OAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"useFormContext-BSDtq3J5.d.cts","names":[],"sources":["../src/hooks/useFormContext/useFormContext.ts"],"mappings":";;;;;;cAYa,oBAAA,GACX,UAAA,EAAY,YAAY,EACxB,IAAA;;AAFF;;;;;;;;AAEgB;cAmEH,cAAA,wBACU,WAAA,GAAc,WAAA,uCAEd,YAAA;;wBAwBQ,IAAA,CAAK,YAAA,GAAa,MAAA;;;;;;;;;;;;;;;;sCAWf,kBAAA,KAAA,OAAA;;0BAAA,kBAAA;;;;mBAwB/B,YAAA;eAEoB,YAAA;aAAwE,kBAAA"}

package/dist/useFormContext-BbTP0PIW.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFormContext-BbTP0PIW.d.ts","names":[],"sources":["../src/hooks/useFormContext/useFormContext.ts"],"mappings":";;;;;;cAYa,oBAAA,GACX,UAAA,EAAY,YAAY,EACxB,IAAA;;AAFF;;;;;;;;AAEgB;cAmEH,gBAAA,wBACU,WAAA,GAAc,WAAA,uCAEd,YAAA;;wBAwBQ,IAAA,CAAK,YAAA,GAAa,MAAA;;;;;;;;;;;;;;;;sCAWf,kBAAA,KAAA,OAAA;;0BAAA,kBAAA;;;;mBAwB/B,YAAA;eAEoB,YAAA;aAAwE,kBAAA"}

package/dist/useFormContext-C_EQr8dV.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFormContext-C_EQr8dV.cjs","names":["flatArrayKey","UniformContext","nameToTestId","toValidationFormat"],"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,OAAA,aAAsB,KAAK,MAAM,GAAG,EAAE,IAAI;CAE/D,MAAM,iBAAiB,WAAgB;EAErC,IAAI,OAAO,SAAS,SAAS;GAE3B,IAAI,OAAO,cAAc,OAAO,YAC9B,OAAO;GAGT,OAAO;EACT;EAIA,OAAO,CAAC,OAAO,cAAc,CAAC,OAAO;CACvC;CAEA,OAAO,WAAW,gBAAgB,eAAe,SAAS;AAC5D;;;;;;;;;;;;;AAcA,MAAM,6BACJ,QACA,SACG;CAEH,MAAM,OAAO,KAAK,MAAM,GAAG,EAAE,QAAQ,MAAM;EACzC,OAAO,MAAMA,sBAAAA;CACf,CAAC;CACD,IAAI,UAAmB;CACvB,KAAK,SAAS,QAAQ;EACpB,IAAI,WAAW,OAAO,YAAY,UAChC,UAAW,QAAoC;OAE/C,UAAU,KAAA;CAEd,CAAC;CACD,OAAO;AACT;;;;;;;;;;;AAYA,MAAa,uBAIN;CACL,MAAM,EACJ,WAEA,eAAe,mBACf,WAAW,eACX,OAAO,WACP,WAAW,eAEX,GAAG,kBAAA,GAAA,gBAAA,gBAC8D;CAEnE,MAAM,kBAAA,GAAA,MAAA,YAA4BC,oBAAAA,cAAc;;;;;;;;;;CAWhD,MAAM,iBAAiB,MAA0B,WAAoB;EACnE,MAAM,YACJ,OAAO,SAAS,WAAW,KAAK,QAAQ,YAAY,EAAE,EAAE,MAAM,GAAG,IAAI;EAIvE,MAAM,qBACJ,gBAAgB,WAAW,gBAC3B,gBAAgB,WAAW;EAG7B,MAAM,WAAW,qBACb,qBAAqB,oBAAoB,SAAS,IAClD;EAEJ,MAAM,QAAQ,0BACZ,gBAAgB,WAAW,UAAU,CAAC,GACtC,IACF;EAKA,OAAO;GACL,GAHiB,kBAAkB,MAAM,SAG7B;GACZ;GACA,SAAS,CAAC,CAAC;GACX;GACA,QAAQC,sBAAAA,aAAa,UAAU,IAAI;EACrC;CACF;;;;;;;;;;;;CAaA,MAAM,cAAc,GAAG,SAAgB;EAErC,OAAOC,sBAAAA,mBADS,cAAsB,GAAG,IACV,CAAC;CAClC;CAEA,MAAM,UAAU,GAAG,SAAgB;EAEjC,OAAOA,sBAAAA,mBADS,UAAkB,GAAG,IACN,CAAC;CAClC;CAEA,MAAM,cAAc,GAAG,SAAgB;EAErC,MAAM,CAAC,WAAW;EAClB,IAAI,SAAS,UAAU;GACrB,MAAM,mBAAmB,QAAQ;GAejC,OAAO,cAAc;IAbnB,GAAG;IACH,WAAW,uBAA4B;KASrC,OAAO,iBAAiB;MANtB,GAAG;MACH,GAAI,mBAAmB,UAAU,EAC/B,QAAQA,sBAAAA,mBAAmB,mBAAmB,MAAM,EACtD;KAGuC,CAAC;IAC5C;GAEgC,CAAC;EACrC;EAEA,OAAQ,cAAsB,GAAG,IAAI;CACvC;CAEA,OAAO;EACL,GAAG;EACH,GAAG;EACH;EACA;EACA;EACA;EACA;CACF;AACF"}

package/dist/useFormContext-DJ-9hs8X.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFormContext-DJ-9hs8X.js","names":["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,OAAA,aAAsB,KAAK,MAAM,GAAG,EAAE,IAAI;CAE/D,MAAM,iBAAiB,WAAgB;EAErC,IAAI,OAAO,SAAS,SAAS;GAE3B,IAAI,OAAO,cAAc,OAAO,YAC9B,OAAO;GAGT,OAAO;EACT;EAIA,OAAO,CAAC,OAAO,cAAc,CAAC,OAAO;CACvC;CAEA,OAAO,WAAW,gBAAgB,eAAe,SAAS;AAC5D;;;;;;;;;;;;;AAcA,MAAM,6BACJ,QACA,SACG;CAEH,MAAM,OAAO,KAAK,MAAM,GAAG,EAAE,QAAQ,MAAM;EACzC,OAAO,MAAM;CACf,CAAC;CACD,IAAI,UAAmB;CACvB,KAAK,SAAS,QAAQ;EACpB,IAAI,WAAW,OAAO,YAAY,UAChC,UAAW,QAAoC;OAE/C,UAAU,KAAA;CAEd,CAAC;CACD,OAAO;AACT;;;;;;;;;;;AAYA,MAAaA,yBAIN;CACL,MAAM,EACJ,WAEA,eAAe,mBACf,WAAW,eACX,OAAO,WACP,WAAW,eAEX,GAAG,iBACDC,eAA+D;CAEnE,MAAM,iBAAiB,WAAW,cAAc;;;;;;;;;;CAWhD,MAAM,iBAAiB,MAA0B,WAAoB;EACnE,MAAM,YACJ,OAAO,SAAS,WAAW,KAAK,QAAQ,YAAY,EAAE,EAAE,MAAM,GAAG,IAAI;EAIvE,MAAM,qBACJ,gBAAgB,WAAW,gBAC3B,gBAAgB,WAAW;EAG7B,MAAM,WAAW,qBACb,qBAAqB,oBAAoB,SAAS,IAClD;EAEJ,MAAM,QAAQ,0BACZ,gBAAgB,WAAW,UAAU,CAAC,GACtC,IACF;EAKA,OAAO;GACL,GAHiB,kBAAkB,MAAM,SAG7B;GACZ;GACA,SAAS,CAAC,CAAC;GACX;GACA,QAAQ,aAAa,UAAU,IAAI;EACrC;CACF;;;;;;;;;;;;CAaA,MAAM,cAAc,GAAG,SAAgB;EAErC,OAAO,mBADS,cAAsB,GAAG,IACV,CAAC;CAClC;CAEA,MAAM,UAAU,GAAG,SAAgB;EAEjC,OAAO,mBADS,UAAkB,GAAG,IACN,CAAC;CAClC;CAEA,MAAM,cAAc,GAAG,SAAgB;EAErC,MAAM,CAAC,WAAW;EAClB,IAAI,SAAS,UAAU;GACrB,MAAM,mBAAmB,QAAQ;GAejC,OAAO,cAAc;IAbnB,GAAG;IACH,WAAW,uBAA4B;KASrC,OAAO,iBAAiB;MANtB,GAAG;MACH,GAAI,mBAAmB,UAAU,EAC/B,QAAQ,mBAAmB,mBAAmB,MAAM,EACtD;KAGuC,CAAC;IAC5C;GAEgC,CAAC;EACrC;EAEA,OAAQ,cAAsB,GAAG,IAAI;CACvC;CAEA,OAAO;EACL,GAAG;EACH,GAAG;EACH;EACA;EACA;EACA;EACA;CACF;AACF"}

package/dist/useUniformFieldArray-9kCb5G9q.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useUniformFieldArray-9kCb5G9q.d.ts","names":[],"sources":["../src/hooks/useUniformFieldArray/useUniformFieldArray.ts"],"mappings":";;;;;;UAYiB,yBAAA,sBACM,WAAA,GAAc,WAAA;;EAGnC,IAAA,EAAM,SAAA,CAAU,YAAA;;EAEhB,IAAA;;EAEA,mBAAA;;EAEA,uBAAA;;EAEA,QAAA;;EAEA,MAAA;;EAEA,KAAA,GAAQ,SAAA;AAAA;;;;;;;;;;;AAhBV;;cA+Ba,oBAAA,wBACU,WAAA,GAAc,WAAA;EACnC,IAAA;EAAA,IAAA;EAAA,mBAAA,EAAA,oBAAA;EAAA,uBAAA;EAAA,QAAA;EAAA,MAAA,EAAA,cAAA;EAAA;AAAA,GAQC,yBAAA,CAA0B,YAAA;;;;;;;;;kBAhC+B,KAAA;;;;;;;;;UAqExB,UAAA;YAEX,UAAA,QAFW,eAAA;OAKzB,UAAA,QAHc,eAAA"}

package/dist/useUniformFieldArray-Bx7v1U2d.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useUniformFieldArray-Bx7v1U2d.d.cts","names":[],"sources":["../src/hooks/useUniformFieldArray/useUniformFieldArray.ts"],"mappings":";;;;;;UAYiB,yBAAA,sBACM,WAAA,GAAc,WAAA;;EAGnC,IAAA,EAAM,SAAA,CAAU,YAAA;;EAEhB,IAAA;;EAEA,mBAAA;;EAEA,uBAAA;;EAEA,QAAA;;EAEA,MAAA;;EAEA,KAAA,GAAQ,SAAA;AAAA;;;;;;;;;;;AAhBV;;cA+Ba,oBAAA,wBACU,WAAA,GAAc,WAAA;EACnC,IAAA;EAAA,IAAA;EAAA,mBAAA,EAAA,oBAAA;EAAA,uBAAA;EAAA,QAAA;EAAA,MAAA,EAAA,cAAA;EAAA;AAAA,GAQC,yBAAA,CAA0B,YAAA;;;;;;;;;kBAhC+B,KAAA;;;;;;;;;UAqExB,UAAA;YAEX,UAAA,QAFW,aAAA;OAKzB,UAAA,QAHc,aAAA"}