@fuf-stack/uniform 1.22.5 → 1.22.6

package/dist/Time/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/Time/Time.tsx"],"mappings":";;;;cAgBa,YAAA,IAAY,KAAA;EAAA;;;gbAoBvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gbApBuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sbAsBsB;EAAA;IAAA;;;kbACC;;;;sbAErB;EAAA;IAAA;;;kbAAoB;;;;sbAIjC;EAAA;kbAIZ;;;;sbAQA;EAAA;;;;;kbAWS;;;;sbAgHV;EAAA;IAAA;;;kbA1Ga;;;;sbAUX;EAAA;IAAA;;;kbAVW;;;;sbAAA;EAAA;IAAA;;;kbAAA;;;;sbAAA;EAAA;IAAA;;;kbA0Gb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA9II,YAAA,GAAe,OAAO,QAAQ,YAAA;AAAA,KAC9B,SAAA,GAAY,WAAW,QAAQ,YAAA;AAAA,UAEnB,SAAA,SAAkB,YAAA;;EAEjC,SAAA;;EAEA,SAAA,GAAY,SAAA;;EAEZ,QAAA;;EAEA,WAAA;;EAEA,YAAA;;EAEA,YAAA;;EAEA,SAAA;;EAEA,KAAA,GAAQ,SAAA;;EAER,IAAA;;EAEA,MAAA;;;;;EAKA,QAAA;;EAEA,SAAA;AAAA;;;;cAMI,IAAA;EAAQ,SAAA,EAAA,UAAA;EAAA,WAAA;EAAA,YAAA;EAAA,YAAA;EAAA,SAAA;EAAA,IAAA;EAAA,QAAA;EAAA,SAAA;EAAA,GAAA;AAAA,GAUX,SAAA,iCAAS,GAAA,CAAA,OAAA"}

package/dist/Time/index.js

@@ -1,2 +1,216 @@
-import { n as Time, r as timeVariants, t as Time_default } from "../Time-B_SXrKWK.js";
-export { Time, Time_default as default, timeVariants };
+import { useUniformField } from "../hooks/useUniformField/index.js";
+import { tv, variantsToClassNames } from "@fuf-stack/pixel-utils";
+import { jsx } from "react/jsx-runtime";
+import { getLocalTimeZone, parseAbsolute, parseAbsoluteToLocal, parseDateTime, parseZonedDateTime } from "@internationalized/date";
+import { TimeInput } from "@heroui/date-input";
+//#region src/Time/timeHelpers.ts
+/** Cast unknown input to the TimeInput value union type. */
+const asTimeValue = (value) => {
+	return value;
+};
+/** Check whether a value already looks like an @internationalized/date value. */
+const isTimeValueLike = (value) => {
+	if (!value || typeof value !== "object") return false;
+	return "hour" in value || "calendar" in value;
+};
+/** Check if the incoming string represents a plain time (e.g. 09:30 or 09:30:45). */
+const isTimeOnlyString = (value) => {
+	return /^\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?$/.test(value);
+};
+/** Check if the incoming string is a UTC time-only value (e.g. 09:30Z). */
+const isUtcTimeOnlyString = (value) => {
+	return /^\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?Z$/.test(value);
+};
+/** Zero-pad integer segments for time serialization. */
+const pad = (value) => {
+	return String(value).padStart(2, "0");
+};
+/** Convert an absolute ISO string into UTC time-only store format. */
+const toUtcTimeString = (absoluteIsoString, granularity) => {
+	const utcDate = new Date(absoluteIsoString);
+	if (Number.isNaN(utcDate.getTime())) return null;
+	const hour = pad(utcDate.getUTCHours());
+	if (granularity === "hour") return `${hour}:00Z`;
+	return `${hour}:${pad(utcDate.getUTCMinutes())}Z`;
+};
+/** True when an input already carries timezone/offset information. */
+const hasExplicitTimeZone = (value) => {
+	if (value.includes("[") && value.includes("]")) return true;
+	return /(?:[zZ]|[+-]\d{2}:\d{2})$/.test(value);
+};
+/** True for date-time strings without timezone/offset. */
+const isNaiveDateTimeString = (value) => {
+	return /^\d{4}-\d{2}-\d{2}T/.test(value) && !hasExplicitTimeZone(value);
+};
+/** Safely run a parser and return `null` on parsing errors. */
+const tryParse = (parser) => {
+	try {
+		return asTimeValue(parser());
+	} catch {
+		return null;
+	}
+};
+/**
+* Parse a form value into a HeroUI TimeInput compatible `TimeValue`.
+*
+* Supports existing `TimeValue` objects, native `Date` instances, plain time
+* strings (`HH:mm[:ss]`), absolute ISO date-time strings, zoned date-time
+* strings, and local date-time strings.
+*
+* Time-only strings are interpreted in the active timezone and normalized to a
+* `ZonedDateTime` (using a fixed reference date) so timezone abbreviations can
+* remain visible in the UI.
+*/
+const parseTimeValue = (value, timeZone) => {
+	if (value == null || value === "") return null;
+	if (isTimeValueLike(value)) return asTimeValue(value);
+	if (value instanceof Date) return asTimeValue(timeZone ? parseAbsolute(value.toISOString(), timeZone) : parseAbsoluteToLocal(value.toISOString()));
+	if (typeof value !== "string") return null;
+	const normalizedValue = value.trim();
+	if (normalizedValue === "") return null;
+	if (isTimeOnlyString(normalizedValue)) return tryParse(() => {
+		const [hourValue, minuteValue, secondValue] = normalizedValue.split(":").map(Number);
+		const resolvedTimeZone = resolveTimeFieldTimeZone(timeZone);
+		return parseZonedDateTime(`1970-01-01T${pad(hourValue)}:${pad(minuteValue)}:${pad(secondValue ?? 0)}[${resolvedTimeZone}]`);
+	});
+	if (isUtcTimeOnlyString(normalizedValue)) return tryParse(() => {
+		const resolvedTimeZone = resolveTimeFieldTimeZone(timeZone);
+		return parseAbsolute(`1970-01-01T${normalizedValue}`, resolvedTimeZone);
+	});
+	return [
+		...timeZone && isNaiveDateTimeString(normalizedValue) ? [() => {
+			return parseZonedDateTime(`${normalizedValue}[${timeZone}]`);
+		}] : [],
+		() => {
+			return timeZone ? parseAbsolute(normalizedValue, timeZone) : parseAbsoluteToLocal(normalizedValue);
+		},
+		() => {
+			return parseZonedDateTime(normalizedValue);
+		},
+		() => {
+			return parseDateTime(normalizedValue);
+		}
+	].map((parser) => {
+		return tryParse(parser);
+	}).find((parsedValue) => {
+		return parsedValue != null;
+	}) ?? null;
+};
+/** Resolve the timezone used for parsing and string conversion. */
+const resolveTimeFieldTimeZone = (timeZone) => {
+	return timeZone ?? getLocalTimeZone();
+};
+/**
+* Build default placeholder value for TimeInput.
+*
+* Uses a fixed reference time to keep snapshots deterministic.
+*/
+const getTimeFieldPlaceholderValue = (timeZone) => {
+	return asTimeValue(parseZonedDateTime(`1970-01-01T00:00:00[${resolveTimeFieldTimeZone(timeZone)}]`));
+};
+/**
+* Convert a TimeValue into a UTC time-only string for form state.
+*
+* The stored format is `HH:mmZ` (or `HH:00Z` when granularity is `hour`).
+*/
+const timeValueToString = (value, timeZone, granularity = "minute") => {
+	if (value == null) return null;
+	const maybeWithAbsoluteString = value;
+	if (typeof maybeWithAbsoluteString.toAbsoluteString === "function") return toUtcTimeString(maybeWithAbsoluteString.toAbsoluteString(), granularity);
+	const maybeWithToDate = value;
+	if (typeof maybeWithToDate.toDate === "function") return toUtcTimeString(maybeWithToDate.toDate(timeZone).toISOString(), granularity);
+	const maybeTime = value;
+	if (typeof maybeTime.hour === "number" && typeof maybeTime.minute === "number") return toUtcTimeString(parseZonedDateTime(`1970-01-01T${pad(maybeTime.hour)}:${pad(maybeTime.minute)}:${pad(maybeTime.second ?? 0)}[${timeZone}]`).toAbsoluteString(), granularity);
+	return null;
+};
+//#endregion
+//#region src/Time/Time.tsx
+const timeVariants = tv({ slots: {
+	/** wrapper around the whole time input */
+	base: "",
+	/** helper wrapper for error/description */
+	helperWrapper: ["p-0"],
+	/** the segmented input element */
+	input: "",
+	/** inner wrapper around segments and optional content */
+	innerWrapper: "",
+	/** outer input wrapper */
+	inputWrapper: "bg-content1 focus-within:border-focus",
+	/** field label */
+	label: "",
+	/** individual segment */
+	segment: ""
+} });
+/**
+* Time component based on [HeroUI TimeInput](https://v2.heroui.com/docs/components/time-input)
+*/
+const Time = ({ className: _className = void 0, granularity = "minute", hideTimeZone = false, hourAsNumber = false, hourCycle = void 0, name, timeZone = void 0, valueType = "string", ...uniformFieldProps }) => {
+	const { ariaLabel, disabled, errorMessage, field: { onBlur, onChange, value }, invalid, label, required, testId } = useUniformField({
+		name,
+		...uniformFieldProps
+	});
+	const classNames = variantsToClassNames(timeVariants(), _className, "base");
+	const resolvedTimeZone = resolveTimeFieldTimeZone(timeZone);
+	const effectiveGranularity = hourAsNumber ? "hour" : granularity;
+	const parsedValue = parseTimeValue(hourAsNumber && typeof value === "number" ? `${String(Math.max(0, Math.min(23, value))).padStart(2, "0")}:00Z` : value, timeZone);
+	const placeholderValue = getTimeFieldPlaceholderValue(timeZone);
+	const handleChange = (nextValue) => {
+		if (nextValue == null) {
+			onChange(null);
+			return;
+		}
+		if (hourAsNumber) {
+			const serializedValue = timeValueToString(nextValue, resolvedTimeZone, "hour");
+			if (!serializedValue) {
+				onChange(null);
+				return;
+			}
+			const [hoursSegment] = serializedValue.split(":");
+			const parsedHours = Number(hoursSegment);
+			onChange(Number.isNaN(parsedHours) ? null : parsedHours);
+			return;
+		}
+		if (valueType === "timeValue") {
+			onChange(nextValue);
+			return;
+		}
+		onChange(timeValueToString(nextValue, resolvedTimeZone, effectiveGranularity) ?? String(nextValue));
+	};
+	return /* @__PURE__ */ jsx(TimeInput, {
+		"aria-label": label ? void 0 : ariaLabel,
+		classNames: {
+			base: classNames.base,
+			helperWrapper: classNames.helperWrapper,
+			innerWrapper: classNames.innerWrapper,
+			input: classNames.input,
+			inputWrapper: classNames.inputWrapper,
+			label: classNames.label,
+			segment: classNames.segment
+		},
+		"data-testid": testId,
+		errorMessage,
+		granularity: effectiveGranularity,
+		hideTimeZone,
+		hourCycle,
+		id: testId,
+		isDisabled: disabled,
+		isInvalid: invalid,
+		isRequired: required,
+		label,
+		labelPlacement: "outside",
+		name,
+		onBlur,
+		onChange: handleChange,
+		placeholderValue: placeholderValue ?? void 0,
+		radius: "sm",
+		value: parsedValue ?? void 0,
+		variant: "bordered"
+	});
+};
+//#endregion
+//#region src/Time/index.ts
+var Time_default = Time;
+//#endregion
+export { Time_default as default, timeVariants };
+
+//# sourceMappingURL=index.js.map

package/dist/Time/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["HeroTimeInput"],"sources":["../../src/Time/timeHelpers.ts","../../src/Time/Time.tsx","../../src/Time/index.ts"],"sourcesContent":["import type { TimeInput as HeroTimeInput } from '@heroui/date-input';\nimport type { ComponentProps } from 'react';\n\nimport {\n  getLocalTimeZone,\n  parseAbsolute,\n  parseAbsoluteToLocal,\n  parseDateTime,\n  parseZonedDateTime,\n} from '@internationalized/date';\n\n/** Value type accepted by HeroUI TimeInput */\nexport type TimeValue = ComponentProps<typeof HeroTimeInput>['value'];\n\n/** Cast unknown input to the TimeInput value union type. */\nconst asTimeValue = (value: unknown): TimeValue => {\n  return value as TimeValue;\n};\n\n/** Check whether a value already looks like an @internationalized/date value. */\nconst isTimeValueLike = (value: unknown): value is object => {\n  if (!value || typeof value !== 'object') {\n    return false;\n  }\n\n  return 'hour' in value || 'calendar' in value;\n};\n\n/** Check if the incoming string represents a plain time (e.g. 09:30 or 09:30:45). */\nconst isTimeOnlyString = (value: string): boolean => {\n  return /^\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{1,3})?)?$/.test(value);\n};\n\n/** Check if the incoming string is a UTC time-only value (e.g. 09:30Z). */\nconst isUtcTimeOnlyString = (value: string): boolean => {\n  return /^\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{1,3})?)?Z$/.test(value);\n};\n\n/** Zero-pad integer segments for time serialization. */\nconst pad = (value: number): string => {\n  return String(value).padStart(2, '0');\n};\n\n/** Convert an absolute ISO string into UTC time-only store format. */\nconst toUtcTimeString = (\n  absoluteIsoString: string,\n  granularity: 'hour' | 'minute',\n): string | null => {\n  const utcDate = new Date(absoluteIsoString);\n  if (Number.isNaN(utcDate.getTime())) {\n    return null;\n  }\n\n  const hour = pad(utcDate.getUTCHours());\n  if (granularity === 'hour') {\n    return `${hour}:00Z`;\n  }\n\n  return `${hour}:${pad(utcDate.getUTCMinutes())}Z`;\n};\n\n/** True when an input already carries timezone/offset information. */\nconst hasExplicitTimeZone = (value: string): boolean => {\n  if (value.includes('[') && value.includes(']')) {\n    return true;\n  }\n\n  return /(?:[zZ]|[+-]\\d{2}:\\d{2})$/.test(value);\n};\n\n/** True for date-time strings without timezone/offset. */\nconst isNaiveDateTimeString = (value: string): boolean => {\n  return /^\\d{4}-\\d{2}-\\d{2}T/.test(value) && !hasExplicitTimeZone(value);\n};\n\n/** Safely run a parser and return `null` on parsing errors. */\nconst tryParse = (parser: () => unknown): TimeValue => {\n  try {\n    return asTimeValue(parser());\n  } catch {\n    return null;\n  }\n};\n\n/**\n * Parse a form value into a HeroUI TimeInput compatible `TimeValue`.\n *\n * Supports existing `TimeValue` objects, native `Date` instances, plain time\n * strings (`HH:mm[:ss]`), absolute ISO date-time strings, zoned date-time\n * strings, and local date-time strings.\n *\n * Time-only strings are interpreted in the active timezone and normalized to a\n * `ZonedDateTime` (using a fixed reference date) so timezone abbreviations can\n * remain visible in the UI.\n */\nexport const parseTimeValue = (\n  value: unknown,\n  timeZone?: string,\n): TimeValue => {\n  if (value == null || value === '') {\n    return null;\n  }\n\n  if (isTimeValueLike(value)) {\n    return asTimeValue(value);\n  }\n\n  if (value instanceof Date) {\n    return asTimeValue(\n      timeZone\n        ? parseAbsolute(value.toISOString(), timeZone)\n        : parseAbsoluteToLocal(value.toISOString()),\n    );\n  }\n\n  if (typeof value !== 'string') {\n    return null;\n  }\n\n  const normalizedValue = value.trim();\n  if (normalizedValue === '') {\n    return null;\n  }\n\n  if (isTimeOnlyString(normalizedValue)) {\n    return tryParse(() => {\n      const [hourValue, minuteValue, secondValue] = normalizedValue\n        .split(':')\n        .map(Number);\n      const resolvedTimeZone = resolveTimeFieldTimeZone(timeZone);\n      const hour = pad(hourValue);\n      const minute = pad(minuteValue);\n      const second = pad(secondValue ?? 0);\n\n      return parseZonedDateTime(\n        `1970-01-01T${hour}:${minute}:${second}[${resolvedTimeZone}]`,\n      );\n    });\n  }\n\n  if (isUtcTimeOnlyString(normalizedValue)) {\n    return tryParse(() => {\n      const resolvedTimeZone = resolveTimeFieldTimeZone(timeZone);\n      return parseAbsolute(`1970-01-01T${normalizedValue}`, resolvedTimeZone);\n    });\n  }\n\n  const parsers: (() => unknown)[] = [\n    ...(timeZone && isNaiveDateTimeString(normalizedValue)\n      ? [\n          () => {\n            return parseZonedDateTime(`${normalizedValue}[${timeZone}]`);\n          },\n        ]\n      : []),\n    () => {\n      return timeZone\n        ? parseAbsolute(normalizedValue, timeZone)\n        : parseAbsoluteToLocal(normalizedValue);\n    },\n    () => {\n      return parseZonedDateTime(normalizedValue);\n    },\n    () => {\n      return parseDateTime(normalizedValue);\n    },\n  ];\n\n  return (\n    parsers\n      .map((parser) => {\n        return tryParse(parser);\n      })\n      .find((parsedValue) => {\n        return parsedValue != null;\n      }) ?? null\n  );\n};\n\n/** Resolve the timezone used for parsing and string conversion. */\nexport const resolveTimeFieldTimeZone = (timeZone?: string): string => {\n  return timeZone ?? getLocalTimeZone();\n};\n\n/**\n * Build default placeholder value for TimeInput.\n *\n * Uses a fixed reference time to keep snapshots deterministic.\n */\nexport const getTimeFieldPlaceholderValue = (timeZone?: string): TimeValue => {\n  const resolvedTimeZone = resolveTimeFieldTimeZone(timeZone);\n  return asTimeValue(\n    parseZonedDateTime(`1970-01-01T00:00:00[${resolvedTimeZone}]`),\n  );\n};\n\n/**\n * Convert a TimeValue into a UTC time-only string for form state.\n *\n * The stored format is `HH:mmZ` (or `HH:00Z` when granularity is `hour`).\n */\nexport const timeValueToString = (\n  value: TimeValue,\n  timeZone: string,\n  granularity: 'hour' | 'minute' = 'minute',\n): string | null => {\n  if (value == null) {\n    return null;\n  }\n\n  const maybeWithAbsoluteString = value as { toAbsoluteString?: () => string };\n  if (typeof maybeWithAbsoluteString.toAbsoluteString === 'function') {\n    return toUtcTimeString(\n      maybeWithAbsoluteString.toAbsoluteString(),\n      granularity,\n    );\n  }\n\n  const maybeWithToDate = value as { toDate?: (zone: string) => Date };\n  if (typeof maybeWithToDate.toDate === 'function') {\n    return toUtcTimeString(\n      maybeWithToDate.toDate(timeZone).toISOString(),\n      granularity,\n    );\n  }\n\n  const maybeTime = value as {\n    hour?: number;\n    minute?: number;\n    second?: number;\n  };\n  if (\n    typeof maybeTime.hour === 'number' &&\n    typeof maybeTime.minute === 'number'\n  ) {\n    const hour = pad(maybeTime.hour);\n    const minute = pad(maybeTime.minute);\n    const second = pad(maybeTime.second ?? 0);\n    return toUtcTimeString(\n      parseZonedDateTime(\n        `1970-01-01T${hour}:${minute}:${second}[${timeZone}]`,\n      ).toAbsoluteString(),\n      granularity,\n    );\n  }\n\n  return null;\n};\n","import type { TVClassName, TVProps } from '@fuf-stack/pixel-utils';\nimport type { ReactNode } from 'react';\nimport type { TimeValue } from './timeHelpers';\n\nimport { TimeInput as HeroTimeInput } from '@heroui/date-input';\n\nimport { tv, variantsToClassNames } from '@fuf-stack/pixel-utils';\n\nimport { useUniformField } from '../hooks/useUniformField';\nimport {\n  getTimeFieldPlaceholderValue,\n  parseTimeValue,\n  resolveTimeFieldTimeZone,\n  timeValueToString,\n} from './timeHelpers';\n\nexport const timeVariants = tv({\n  slots: {\n    /** wrapper around the whole time input */\n    base: '',\n    /** helper wrapper for error/description */\n    helperWrapper: [\n      // set padding to 0 for error message exit animation\n      'p-0',\n    ],\n    /** the segmented input element */\n    input: '',\n    /** inner wrapper around segments and optional content */\n    innerWrapper: '',\n    /** outer input wrapper */\n    inputWrapper: 'bg-content1 focus-within:border-focus',\n    /** field label */\n    label: '',\n    /** individual segment */\n    segment: '',\n  },\n});\n\ntype VariantProps = TVProps<typeof timeVariants>;\ntype ClassName = TVClassName<typeof timeVariants>;\n\nexport interface TimeProps extends VariantProps {\n  /** Custom aria-label for accessibility. If not provided, falls back to field name when no visible label exists */\n  ariaLabel?: string;\n  /** CSS class name */\n  className?: ClassName;\n  /** input is disabled */\n  disabled?: boolean;\n  /** smallest visible unit in the segmented time input */\n  granularity?: 'hour' | 'minute';\n  /** hide timezone abbreviation for zoned values */\n  hideTimeZone?: boolean;\n  /** force hour granularity and store UTC hour as number (0-23) */\n  hourAsNumber?: boolean;\n  /** hour cycle formatting */\n  hourCycle?: 12 | 24;\n  /** form field label */\n  label?: ReactNode;\n  /** form field name */\n  name: string;\n  /** HTML data-testid attribute used in e2e tests */\n  testId?: string;\n  /**\n   * Optional timezone used for parsing date-time strings and serializing values.\n   * When omitted, local timezone is used.\n   */\n  timeZone?: string;\n  /** value format stored in form state (`string` stores UTC minute values, e.g. `10:15Z`) */\n  valueType?: 'string' | 'timeValue';\n}\n\n/**\n * Time component based on [HeroUI TimeInput](https://v2.heroui.com/docs/components/time-input)\n */\nconst Time = ({\n  className: _className = undefined,\n  granularity = 'minute',\n  hideTimeZone = false,\n  hourAsNumber = false,\n  hourCycle = undefined,\n  name,\n  timeZone = undefined,\n  valueType = 'string',\n  ...uniformFieldProps\n}: TimeProps) => {\n  const {\n    ariaLabel,\n    disabled,\n    errorMessage,\n    field: { onBlur, onChange, value },\n    invalid,\n    label,\n    required,\n    testId,\n  } = useUniformField({ name, ...uniformFieldProps });\n\n  // classNames from slots\n  const variants = timeVariants();\n  const classNames = variantsToClassNames(variants, _className, 'base');\n  const resolvedTimeZone = resolveTimeFieldTimeZone(timeZone);\n  const effectiveGranularity = hourAsNumber ? 'hour' : granularity;\n\n  // `hourAsNumber` stores 0-23; convert this into a parseable UTC time for display.\n  const normalizedFieldValue =\n    hourAsNumber && typeof value === 'number'\n      ? `${String(Math.max(0, Math.min(23, value))).padStart(2, '0')}:00Z`\n      : value;\n\n  // Normalize incoming form value into HeroUI TimeInput value shape.\n  const parsedValue = parseTimeValue(normalizedFieldValue, timeZone);\n  const placeholderValue = getTimeFieldPlaceholderValue(timeZone);\n\n  // Normalize TimeInput output into the configured storage format.\n  const handleChange = (nextValue: TimeValue) => {\n    if (nextValue == null) {\n      onChange(null);\n      return;\n    }\n\n    if (hourAsNumber) {\n      const serializedValue = timeValueToString(\n        nextValue,\n        resolvedTimeZone,\n        'hour',\n      );\n\n      if (!serializedValue) {\n        onChange(null);\n        return;\n      }\n\n      const [hoursSegment] = serializedValue.split(':');\n      const parsedHours = Number(hoursSegment);\n      onChange(Number.isNaN(parsedHours) ? null : parsedHours);\n      return;\n    }\n\n    if (valueType === 'timeValue') {\n      onChange(nextValue);\n      return;\n    }\n\n    onChange(\n      timeValueToString(nextValue, resolvedTimeZone, effectiveGranularity) ??\n        String(nextValue),\n    );\n  };\n\n  return (\n    <HeroTimeInput\n      aria-label={label ? undefined : ariaLabel}\n      classNames={{\n        base: classNames.base,\n        helperWrapper: classNames.helperWrapper,\n        innerWrapper: classNames.innerWrapper,\n        input: classNames.input,\n        inputWrapper: classNames.inputWrapper,\n        label: classNames.label,\n        segment: classNames.segment,\n      }}\n      data-testid={testId}\n      errorMessage={errorMessage}\n      granularity={effectiveGranularity}\n      hideTimeZone={hideTimeZone}\n      hourCycle={hourCycle}\n      id={testId}\n      isDisabled={disabled}\n      isInvalid={invalid}\n      isRequired={required}\n      label={label}\n      labelPlacement=\"outside\"\n      name={name}\n      onBlur={onBlur}\n      onChange={handleChange}\n      placeholderValue={placeholderValue ?? undefined}\n      radius=\"sm\"\n      value={parsedValue ?? undefined}\n      variant=\"bordered\"\n    />\n  );\n};\n\nexport default Time;\n","import Time from './Time';\n\nexport type { TimeProps } from './Time';\n\nexport { timeVariants } from './Time';\n\nexport default Time;\n"],"mappings":"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"}

package/dist/helpers/index.cjs

@@ -1,5 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("../FormContext-DsmS_mkO.cjs");
 let _fuf_stack_pixel_utils = require("@fuf-stack/pixel-utils");
 //#region src/helpers/createOptionValueConverter/createOptionValueConverter.ts
 /**

package/dist/helpers/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["record"],"sources":["../../src/helpers/createOptionValueConverter/createOptionValueConverter.ts","../../src/helpers/nullishFields/nullishFields.ts"],"sourcesContent":["/* eslint-disable import-x/prefer-default-export */\n\n/**\n * Creates a converter function that preserves the original type (string, number, or boolean)\n * of option values when converting from string keys back to their original type.\n *\n * This is useful for radio/select components where the underlying UI library\n * uses string keys internally, but we want to preserve number/boolean values in the form state.\n *\n * @param options - Array of options with a value property that can be string, number, or boolean\n * @returns An object with:\n *   - `convertToOriginalType`: Function to convert a string key back to its original type\n *   - `numberValueKeys`: Set of string representations of number values (for internal use)\n *   - `booleanValueKeys`: Map of string representations to boolean values (for internal use)\n */\nexport const createOptionValueConverter = <\n  T extends { value: string | number | boolean },\n>(\n  options: T[],\n) => {\n  // Create a set of string keys that represent number values\n  const numberValueKeys = new Set(\n    options\n      .filter((option) => {\n        return typeof option.value === 'number';\n      })\n      .map((option) => {\n        return String(option.value);\n      }),\n  );\n\n  // Create a map of string keys to boolean values\n  const booleanValueKeys = new Map(\n    options\n      .filter((option) => {\n        return typeof option.value === 'boolean';\n      })\n      .map((option) => {\n        return [String(option.value), option.value as boolean];\n      }),\n  );\n\n  /**\n   * Converts a string key back to its original type (string, number, or boolean)\n   * based on whether the original option value was a number or boolean\n   */\n  const convertToOriginalType = (\n    key: string | number | boolean,\n  ): string | number | boolean => {\n    const keyStr = String(key);\n    const booleanValue = booleanValueKeys.get(keyStr);\n    if (booleanValue !== undefined) {\n      return booleanValue;\n    }\n    if (numberValueKeys.has(keyStr)) {\n      return Number(keyStr);\n    }\n    return keyStr;\n  };\n\n  return {\n    booleanValueKeys,\n    convertToOriginalType,\n    numberValueKeys,\n  };\n};\n","import { slugify } from '@fuf-stack/pixel-utils';\n\n/** Key used to wrap flat array elements when converting to form format */\nexport const flatArrayKey = '__FLAT__';\n\n/**\n * String markers used to preserve null, false, and 0 values during JSON processing\n */\nconst nullString = '__NULL__';\nconst falseString = '__FALSE__';\nconst zeroString = '__ZERO__';\n\n/**\n * Checks if a value is considered \"empty\" for validation display purposes.\n *\n * Used by useUniformField to determine when to show validation errors.\n * Empty values don't trigger immediate error display (user must interact first).\n *\n * Handles:\n * - Primitives: null, undefined, ''\n * - Marker strings: __NULL__, __FALSE__, __ZERO__ (converted via fromNullishString)\n * - Empty arrays: []\n * - Objects with all empty values: {a: null, b: ''}\n * - Flat array wrappers: {__FLAT__: null} or {__FLAT__: ''}\n *\n * @param value - The value to check (will be converted via fromNullishString first)\n * @returns true if the value is empty\n *\n * @example\n * isValueEmpty(null)                    // true\n * isValueEmpty('')                      // true\n * isValueEmpty('__NULL__')              // true (marker string)\n * isValueEmpty([])                      // true (empty array)\n * isValueEmpty({a: null})               // true (object with all empty values)\n * isValueEmpty({__FLAT__: null})        // true (flat array wrapper with empty value)\n * isValueEmpty({__FLAT__: ''})          // true\n * isValueEmpty('hello')                 // false\n * isValueEmpty([1, 2])                  // false\n * isValueEmpty({a: 'value'})            // false\n * isValueEmpty({__FLAT__: 'value'})     // false\n */\nexport const isValueEmpty = (value: unknown): boolean => {\n  // Convert marker strings first\n  const converted = fromNullishString(value);\n\n  if (converted === undefined || converted === null || converted === '') {\n    return true;\n  }\n  if (Array.isArray(converted)) {\n    return converted.length === 0;\n  }\n  if (typeof converted === 'object' && converted !== null) {\n    const record = converted as Record<string, unknown>;\n    // Handle flat array wrapper: { __FLAT__: innerValue }\n    if (flatArrayKey in record) {\n      return isValueEmpty(record[flatArrayKey]);\n    }\n    // For objects (e.g., FieldCard), check if all values are null/undefined/empty\n    const values = Object.values(record);\n    return values.length === 0 || values.every(isValueEmpty);\n  }\n  return false;\n};\n\n/**\n * Converts marker strings back to their original values when processing arrays\n */\nexport const fromNullishString = (value: unknown): unknown => {\n  // Support arrays: unwrap flat wrappers and convert marker strings per entry\n  if (Array.isArray(value)) {\n    return (value as unknown[]).map((entry) => {\n      if (entry && typeof entry === 'object') {\n        const record = entry as Record<string, unknown>;\n        if (flatArrayKey in record) {\n          const inner = record[flatArrayKey];\n          // For arrays, treat empty string as null (placeholder input)\n          if (inner === '') {\n            return null;\n          }\n          return fromNullishString(inner);\n        }\n      }\n      return fromNullishString(entry);\n    });\n  }\n\n  if (typeof value !== 'string') {\n    return value;\n  }\n\n  switch (value) {\n    case nullString:\n      return null;\n    case falseString:\n      return false;\n    case zeroString:\n      return 0;\n    default:\n      return value;\n  }\n};\n\n/**\n * Converts null/falsy values to marker strings for JSON processing\n */\nexport const toNullishString = (value: unknown): unknown => {\n  if (Array.isArray(value)) {\n    // Only wrap arrays of primitives; leave arrays of objects as-is\n    const isPrimitive = (v: unknown) => {\n      return v === null || ['string', 'number', 'boolean'].includes(typeof v);\n    };\n    const isPrimitiveArray = (value as unknown[]).every(isPrimitive);\n    if (isPrimitiveArray) {\n      return (value as unknown[]).map((v) => {\n        // Store raw primitive; do not convert to marker strings inside the wrapper\n        return { [flatArrayKey]: v } as Record<string, unknown>;\n      });\n    }\n    return value;\n  }\n  if (value === null || value === '') {\n    return nullString;\n  }\n  if (value === false) {\n    return falseString;\n  }\n  if (value === 0) {\n    return zeroString;\n  }\n  return value;\n};\n\n/**\n * Converts field values to a format suitable for forms by:\n * - Wrapping arrays of primitives as objects using the flatArrayKey `__FLAT__`\n *   to satisfy RHF's requirement that array fields contain objects\n * - Removing empty strings and null values from objects\n *\n * This conversion is required because React Hook Form does not support arrays with\n * flat values (string, number, boolean, null). Array fields must contain objects.\n * We work around this by wrapping primitive entries: `{ __FLAT__: <value> }`.\n *\n * @example\n * const fields = {\n *   name: 'John',\n *   scores: [0, null, 75, false],\n *   scoresDetailed: [\n *     { score: 1 },\n *     { score: null },\n *     { score: 0 },\n *     { score: false },\n *     { score: '' },\n *   ],\n *   contact: {\n *     email: '',\n *     phone: null,\n *     address: '123 Main St'\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   scores: [\n *     { __FLAT__: 0 },\n *     { __FLAT__: null },\n *     { __FLAT__: 75 },\n *     { __FLAT__: false }\n *   ],\n *   // Arrays of objects are left as objects; empty/null properties are removed\n *   scoresDetailed: [\n *     { score: 1 },\n *     {}, // null score removed\n *     { score: 0 },\n *     { score: false },\n *     {}, // empty string removed\n *   ],\n *   contact: {\n *     address: '123 Main St'\n *   }\n * }\n */\nexport const toFormFormat = (fields: Record<string, unknown>) => {\n  const formFormatJson = JSON.stringify(fields, (_, value) => {\n    if (Array.isArray(value)) {\n      // Delegate to toNullishString to ensure consistent handling\n      return toNullishString(value);\n    }\n\n    if (value && typeof value === 'object') {\n      // Preserve flat-array wrappers as-is (do not filter their inner values here)\n      const record = value as Record<string, unknown>;\n      if (flatArrayKey in record) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return value;\n      }\n      return Object.fromEntries(\n        Object.entries(value).filter(([_key, v]) => {\n          return v !== '' && v !== null;\n        }),\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return value;\n  });\n\n  return JSON.parse(formFormatJson) as Record<string, unknown>;\n};\n\n/**\n * Converts form state to a format suitable for validation by:\n * - Unwrapping flat array wrappers `{ __FLAT__: <value> }` back to primitives\n * - Converting legacy string markers (__NULL__, __FALSE__, __ZERO__) back to their original values\n * - Removing fields whose converted value is empty string or null\n * - Removing empty arrays\n *\n * @example\n * const formState = {\n *   name: 'John',\n *   scores: [\n *     { __FLAT__: 75 },\n *     { __FLAT__: 0 },\n *     { __FLAT__: null },\n *     { __FLAT__: false }\n *   ],\n *   emptyArray: [],\n *   scoresDetailed: [\n *     { score: 1 },\n *     {},\n *     { score: 0 },\n *     { score: false },\n *     {},\n *   ],\n *   contact: {\n *     address: '123 Main St',\n *     fax: null\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   scores: [75, 0, null, false],\n *   // emptyArray is removed\n *   // Objects inside arrays remain objects; empty entries remain empty objects\n *   scoresDetailed: [\n *     { score: 1 },\n *     {},\n *     { score: 0 },\n *     { score: false },\n *     {},\n *   ],\n *   contact: {\n *     address: '123 Main St'\n *   }\n * }\n */\nexport const toValidationFormat = (\n  formState: Record<string, unknown> | null | undefined,\n): Record<string, unknown> | null | undefined => {\n  // Handle null or undefined input\n  if (formState === undefined || formState === null) {\n    return formState;\n  }\n\n  const validationFormatJson = JSON.stringify(formState, (_, value) => {\n    if (Array.isArray(value)) {\n      return value.map((v) => {\n        // Unwrap new wrapper format { __FLAT__: <value> }\n        if (v && typeof v === 'object') {\n          const record = v as Record<string, unknown>;\n          if (flatArrayKey in record) {\n            const inner = record[flatArrayKey];\n            // Treat empty string from forms as null in validation format\n            if (inner === '') {\n              return null;\n            }\n            return fromNullishString(inner);\n          }\n        }\n        // Backward compatibility for string markers\n        return fromNullishString(v);\n      });\n    }\n\n    if (value && typeof value === 'object') {\n      // Object branch: remove keys that resolve to empty/null after marker conversion\n      // and unwrap flat-array wrappers if present.\n      //\n      // Why this shape?\n      // - Forms may contain objects with placeholder/empty values that should not\n      //   be part of the validation payload (e.g. \"\" or __NULL__ markers).\n      // - Arrays of primitives are stored as wrapper objects { __FLAT__: <value> }\n      //   to satisfy RHF structure constraints. When converting back for\n      //   validation, we need to treat wrappers whose inner value resolves to\n      //   empty/null as removable, and unwrap non-empty wrappers to the primitive.\n      return Object.fromEntries(\n        Object.entries(value)\n          .filter(([_key, v]) => {\n            // If this is a flat-array wrapper, convert the inner value first and\n            // drop the key when the inner resolves to empty string or null.\n            if (v && typeof v === 'object') {\n              const record = v as Record<string, unknown>;\n              if (flatArrayKey in record) {\n                const convertedInner = fromNullishString(record[flatArrayKey]);\n                return convertedInner !== '' && convertedInner !== null;\n              }\n            }\n            // Drop empty arrays\n            if (Array.isArray(v) && v.length === 0) {\n              return false;\n            }\n            // For regular values, convert markers and drop when empty/null.\n            const converted = fromNullishString(v);\n            return converted !== '' && converted !== null;\n          })\n          .map(([k, v]) => {\n            // Unwrap flat-array wrappers to raw primitives after conversion.\n            if (v && typeof v === 'object') {\n              const record = v as Record<string, unknown>;\n              if (flatArrayKey in record) {\n                return [k, fromNullishString(record[flatArrayKey])];\n              }\n            }\n            // For other values, just convert markers.\n            return [k, fromNullishString(v)];\n          }),\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return value;\n  });\n\n  return JSON.parse(validationFormatJson) as Record<string, unknown>;\n};\n\n/**\n * Helper function to check if a value is an empty object (not an array).\n */\nconst isEmptyObject = (value: unknown): boolean => {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    !Array.isArray(value) &&\n    Object.keys(value as Record<string, unknown>).length === 0\n  );\n};\n\n/**\n * Recursively removes empty objects from a data structure.\n * - Filters empty objects from arrays\n * - Removes properties with empty object values\n * - Removes arrays that become empty after filtering\n */\nconst removeEmptyObjects = (obj: unknown): unknown => {\n  if (Array.isArray(obj)) {\n    // Filter out empty objects from arrays, then recursively process remaining items\n    return obj\n      .filter((item) => {\n        return !isEmptyObject(item);\n      })\n      .map((item) => {\n        return removeEmptyObjects(item);\n      });\n  }\n\n  if (obj !== null && typeof obj === 'object') {\n    return Object.fromEntries(\n      Object.entries(obj)\n        .map(([key, value]) => {\n          return [key, removeEmptyObjects(value)] as [string, unknown];\n        })\n        .filter(([_, processed]) => {\n          // Skip empty objects\n          if (isEmptyObject(processed)) {\n            return false;\n          }\n          // Skip arrays that are now empty after filtering\n          if (Array.isArray(processed) && processed.length === 0) {\n            return false;\n          }\n          return true;\n        }),\n    );\n  }\n\n  return obj;\n};\n\n/**\n * Converts form state to a format suitable for submission by:\n * - Applying all transformations from toValidationFormat\n * - Additionally removing empty objects from the result\n * - Filtering empty objects from arrays\n * - Recursively cleaning nested structures\n *\n * **Why separate from toValidationFormat?**\n *\n * Empty objects must be preserved during validation so that custom refinements\n * can run. For example, a FieldCard with \"at least email or phone required\"\n * validation needs the object to exist (even if empty) for the refine to execute.\n *\n * However, for submission, empty objects are meaningless and should be removed\n * to produce clean data for APIs.\n *\n * @example\n * const formState = {\n *   name: 'John',\n *   contact: {},           // Empty FieldCard - will be removed\n *   tags: [{}, {}, {}],    // All empty - array will be removed\n *   items: [\n *     { value: 'a' },\n *     {},                  // Empty entry - will be filtered out\n *     { value: 'b' }\n *   ],\n *   nested: {\n *     deep: {}             // Nested empty - will be removed recursively\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   items: [{ value: 'a' }, { value: 'b' }]\n * }\n */\nexport const toSubmitFormat = (\n  formState: Record<string, unknown> | null | undefined,\n): Record<string, unknown> | null | undefined => {\n  const validated = toValidationFormat(formState);\n  if (!validated) {\n    return validated;\n  }\n  return removeEmptyObjects(validated) as Record<string, unknown>;\n};\n\n/**\n * Converts a field name to a testId by removing flat array key segments and slugifying.\n * Removes all occurrences of `flatArrayKey` from the field name and applies slugify transformation.\n *\n * This is used to generate stable testIds for form fields that don't include\n * the internal `__FLAT__` marker used for flat arrays.\n *\n * @param name - The field name as a string (e.g., 'tags.0.__FLAT__') or array path (e.g., ['tags', '0', '__FLAT__'])\n * @returns The slugified field name with all flat array key segments removed (e.g., 'tags_0')\n *\n * @example\n * ```ts\n * nameToTestId('tags.0.__FLAT__') // => 'tags_0'\n * nameToTestId('array.0.__FLAT__') // => 'array_0'\n * nameToTestId('nested.array.0.__FLAT__.field') // => 'nested_array_0_field'\n * nameToTestId('simple.field') // => 'simple_field'\n * nameToTestId(['tags', '0', '__FLAT__']) // => 'tags_0'\n * ```\n */\nexport const nameToTestId = (name: string | readonly string[]): string => {\n  let cleanName: string;\n\n  // Handle array paths - filter out flatArrayKey and join with dots\n  if (Array.isArray(name)) {\n    cleanName = name\n      .filter((segment: string) => {\n        return segment !== flatArrayKey;\n      })\n      .join('.');\n  } else {\n    // Handle string paths - split by dots and filter out flatArrayKey segments\n    const segments = (name as string).split('.');\n    cleanName = segments\n      .filter((segment: string) => {\n        return segment !== flatArrayKey;\n      })\n      .join('.');\n  }\n\n  // Apply slugify transformation\n  return slugify(cleanName, { replaceDots: true });\n};\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":["record"],"sources":["../../src/helpers/createOptionValueConverter/createOptionValueConverter.ts","../../src/helpers/nullishFields/nullishFields.ts"],"sourcesContent":["/* eslint-disable import-x/prefer-default-export */\n\n/**\n * Creates a converter function that preserves the original type (string, number, or boolean)\n * of option values when converting from string keys back to their original type.\n *\n * This is useful for radio/select components where the underlying UI library\n * uses string keys internally, but we want to preserve number/boolean values in the form state.\n *\n * @param options - Array of options with a value property that can be string, number, or boolean\n * @returns An object with:\n *   - `convertToOriginalType`: Function to convert a string key back to its original type\n *   - `numberValueKeys`: Set of string representations of number values (for internal use)\n *   - `booleanValueKeys`: Map of string representations to boolean values (for internal use)\n */\nexport const createOptionValueConverter = <\n  T extends { value: string | number | boolean },\n>(\n  options: T[],\n) => {\n  // Create a set of string keys that represent number values\n  const numberValueKeys = new Set(\n    options\n      .filter((option) => {\n        return typeof option.value === 'number';\n      })\n      .map((option) => {\n        return String(option.value);\n      }),\n  );\n\n  // Create a map of string keys to boolean values\n  const booleanValueKeys = new Map(\n    options\n      .filter((option) => {\n        return typeof option.value === 'boolean';\n      })\n      .map((option) => {\n        return [String(option.value), option.value as boolean];\n      }),\n  );\n\n  /**\n   * Converts a string key back to its original type (string, number, or boolean)\n   * based on whether the original option value was a number or boolean\n   */\n  const convertToOriginalType = (\n    key: string | number | boolean,\n  ): string | number | boolean => {\n    const keyStr = String(key);\n    const booleanValue = booleanValueKeys.get(keyStr);\n    if (booleanValue !== undefined) {\n      return booleanValue;\n    }\n    if (numberValueKeys.has(keyStr)) {\n      return Number(keyStr);\n    }\n    return keyStr;\n  };\n\n  return {\n    booleanValueKeys,\n    convertToOriginalType,\n    numberValueKeys,\n  };\n};\n","import { slugify } from '@fuf-stack/pixel-utils';\n\n/** Key used to wrap flat array elements when converting to form format */\nexport const flatArrayKey = '__FLAT__';\n\n/**\n * String markers used to preserve null, false, and 0 values during JSON processing\n */\nconst nullString = '__NULL__';\nconst falseString = '__FALSE__';\nconst zeroString = '__ZERO__';\n\n/**\n * Checks if a value is considered \"empty\" for validation display purposes.\n *\n * Used by useUniformField to determine when to show validation errors.\n * Empty values don't trigger immediate error display (user must interact first).\n *\n * Handles:\n * - Primitives: null, undefined, ''\n * - Marker strings: __NULL__, __FALSE__, __ZERO__ (converted via fromNullishString)\n * - Empty arrays: []\n * - Objects with all empty values: {a: null, b: ''}\n * - Flat array wrappers: {__FLAT__: null} or {__FLAT__: ''}\n *\n * @param value - The value to check (will be converted via fromNullishString first)\n * @returns true if the value is empty\n *\n * @example\n * isValueEmpty(null)                    // true\n * isValueEmpty('')                      // true\n * isValueEmpty('__NULL__')              // true (marker string)\n * isValueEmpty([])                      // true (empty array)\n * isValueEmpty({a: null})               // true (object with all empty values)\n * isValueEmpty({__FLAT__: null})        // true (flat array wrapper with empty value)\n * isValueEmpty({__FLAT__: ''})          // true\n * isValueEmpty('hello')                 // false\n * isValueEmpty([1, 2])                  // false\n * isValueEmpty({a: 'value'})            // false\n * isValueEmpty({__FLAT__: 'value'})     // false\n */\nexport const isValueEmpty = (value: unknown): boolean => {\n  // Convert marker strings first\n  const converted = fromNullishString(value);\n\n  if (converted === undefined || converted === null || converted === '') {\n    return true;\n  }\n  if (Array.isArray(converted)) {\n    return converted.length === 0;\n  }\n  if (typeof converted === 'object' && converted !== null) {\n    const record = converted as Record<string, unknown>;\n    // Handle flat array wrapper: { __FLAT__: innerValue }\n    if (flatArrayKey in record) {\n      return isValueEmpty(record[flatArrayKey]);\n    }\n    // For objects (e.g., FieldCard), check if all values are null/undefined/empty\n    const values = Object.values(record);\n    return values.length === 0 || values.every(isValueEmpty);\n  }\n  return false;\n};\n\n/**\n * Converts marker strings back to their original values when processing arrays\n */\nexport const fromNullishString = (value: unknown): unknown => {\n  // Support arrays: unwrap flat wrappers and convert marker strings per entry\n  if (Array.isArray(value)) {\n    return (value as unknown[]).map((entry) => {\n      if (entry && typeof entry === 'object') {\n        const record = entry as Record<string, unknown>;\n        if (flatArrayKey in record) {\n          const inner = record[flatArrayKey];\n          // For arrays, treat empty string as null (placeholder input)\n          if (inner === '') {\n            return null;\n          }\n          return fromNullishString(inner);\n        }\n      }\n      return fromNullishString(entry);\n    });\n  }\n\n  if (typeof value !== 'string') {\n    return value;\n  }\n\n  switch (value) {\n    case nullString:\n      return null;\n    case falseString:\n      return false;\n    case zeroString:\n      return 0;\n    default:\n      return value;\n  }\n};\n\n/**\n * Converts null/falsy values to marker strings for JSON processing\n */\nexport const toNullishString = (value: unknown): unknown => {\n  if (Array.isArray(value)) {\n    // Only wrap arrays of primitives; leave arrays of objects as-is\n    const isPrimitive = (v: unknown) => {\n      return v === null || ['string', 'number', 'boolean'].includes(typeof v);\n    };\n    const isPrimitiveArray = (value as unknown[]).every(isPrimitive);\n    if (isPrimitiveArray) {\n      return (value as unknown[]).map((v) => {\n        // Store raw primitive; do not convert to marker strings inside the wrapper\n        return { [flatArrayKey]: v };\n      });\n    }\n    return value;\n  }\n  if (value === null || value === '') {\n    return nullString;\n  }\n  if (value === false) {\n    return falseString;\n  }\n  if (value === 0) {\n    return zeroString;\n  }\n  return value;\n};\n\n/**\n * Converts field values to a format suitable for forms by:\n * - Wrapping arrays of primitives as objects using the flatArrayKey `__FLAT__`\n *   to satisfy RHF's requirement that array fields contain objects\n * - Removing empty strings and null values from objects\n *\n * This conversion is required because React Hook Form does not support arrays with\n * flat values (string, number, boolean, null). Array fields must contain objects.\n * We work around this by wrapping primitive entries: `{ __FLAT__: <value> }`.\n *\n * @example\n * const fields = {\n *   name: 'John',\n *   scores: [0, null, 75, false],\n *   scoresDetailed: [\n *     { score: 1 },\n *     { score: null },\n *     { score: 0 },\n *     { score: false },\n *     { score: '' },\n *   ],\n *   contact: {\n *     email: '',\n *     phone: null,\n *     address: '123 Main St'\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   scores: [\n *     { __FLAT__: 0 },\n *     { __FLAT__: null },\n *     { __FLAT__: 75 },\n *     { __FLAT__: false }\n *   ],\n *   // Arrays of objects are left as objects; empty/null properties are removed\n *   scoresDetailed: [\n *     { score: 1 },\n *     {}, // null score removed\n *     { score: 0 },\n *     { score: false },\n *     {}, // empty string removed\n *   ],\n *   contact: {\n *     address: '123 Main St'\n *   }\n * }\n */\nexport const toFormFormat = (fields: Record<string, unknown>) => {\n  const formFormatJson = JSON.stringify(fields, (_, value) => {\n    if (Array.isArray(value)) {\n      // Delegate to toNullishString to ensure consistent handling\n      return toNullishString(value);\n    }\n\n    if (value && typeof value === 'object') {\n      // Preserve flat-array wrappers as-is (do not filter their inner values here)\n      const record = value as Record<string, unknown>;\n      if (flatArrayKey in record) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return value;\n      }\n      return Object.fromEntries(\n        Object.entries(value).filter(([_key, v]) => {\n          return v !== '' && v !== null;\n        }),\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return value;\n  });\n\n  return JSON.parse(formFormatJson) as Record<string, unknown>;\n};\n\n/**\n * Converts form state to a format suitable for validation by:\n * - Unwrapping flat array wrappers `{ __FLAT__: <value> }` back to primitives\n * - Converting legacy string markers (__NULL__, __FALSE__, __ZERO__) back to their original values\n * - Removing fields whose converted value is empty string or null\n * - Removing empty arrays\n *\n * @example\n * const formState = {\n *   name: 'John',\n *   scores: [\n *     { __FLAT__: 75 },\n *     { __FLAT__: 0 },\n *     { __FLAT__: null },\n *     { __FLAT__: false }\n *   ],\n *   emptyArray: [],\n *   scoresDetailed: [\n *     { score: 1 },\n *     {},\n *     { score: 0 },\n *     { score: false },\n *     {},\n *   ],\n *   contact: {\n *     address: '123 Main St',\n *     fax: null\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   scores: [75, 0, null, false],\n *   // emptyArray is removed\n *   // Objects inside arrays remain objects; empty entries remain empty objects\n *   scoresDetailed: [\n *     { score: 1 },\n *     {},\n *     { score: 0 },\n *     { score: false },\n *     {},\n *   ],\n *   contact: {\n *     address: '123 Main St'\n *   }\n * }\n */\nexport const toValidationFormat = (\n  formState: Record<string, unknown> | null | undefined,\n): Record<string, unknown> | null | undefined => {\n  // Handle null or undefined input\n  if (formState === undefined || formState === null) {\n    return formState;\n  }\n\n  const validationFormatJson = JSON.stringify(formState, (_, value) => {\n    if (Array.isArray(value)) {\n      return value.map((v) => {\n        // Unwrap new wrapper format { __FLAT__: <value> }\n        if (v && typeof v === 'object') {\n          const record = v as Record<string, unknown>;\n          if (flatArrayKey in record) {\n            const inner = record[flatArrayKey];\n            // Treat empty string from forms as null in validation format\n            if (inner === '') {\n              return null;\n            }\n            return fromNullishString(inner);\n          }\n        }\n        // Backward compatibility for string markers\n        return fromNullishString(v);\n      });\n    }\n\n    if (value && typeof value === 'object') {\n      // Object branch: remove keys that resolve to empty/null after marker conversion\n      // and unwrap flat-array wrappers if present.\n      //\n      // Why this shape?\n      // - Forms may contain objects with placeholder/empty values that should not\n      //   be part of the validation payload (e.g. \"\" or __NULL__ markers).\n      // - Arrays of primitives are stored as wrapper objects { __FLAT__: <value> }\n      //   to satisfy RHF structure constraints. When converting back for\n      //   validation, we need to treat wrappers whose inner value resolves to\n      //   empty/null as removable, and unwrap non-empty wrappers to the primitive.\n      return Object.fromEntries(\n        Object.entries(value)\n          .filter(([_key, v]) => {\n            // If this is a flat-array wrapper, convert the inner value first and\n            // drop the key when the inner resolves to empty string or null.\n            if (v && typeof v === 'object') {\n              const record = v as Record<string, unknown>;\n              if (flatArrayKey in record) {\n                const convertedInner = fromNullishString(record[flatArrayKey]);\n                return convertedInner !== '' && convertedInner !== null;\n              }\n            }\n            // Drop empty arrays\n            if (Array.isArray(v) && v.length === 0) {\n              return false;\n            }\n            // For regular values, convert markers and drop when empty/null.\n            const converted = fromNullishString(v);\n            return converted !== '' && converted !== null;\n          })\n          .map(([k, v]) => {\n            // Unwrap flat-array wrappers to raw primitives after conversion.\n            if (v && typeof v === 'object') {\n              const record = v as Record<string, unknown>;\n              if (flatArrayKey in record) {\n                return [k, fromNullishString(record[flatArrayKey])];\n              }\n            }\n            // For other values, just convert markers.\n            return [k, fromNullishString(v)];\n          }),\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return value;\n  });\n\n  return JSON.parse(validationFormatJson) as Record<string, unknown>;\n};\n\n/**\n * Helper function to check if a value is an empty object (not an array).\n */\nconst isEmptyObject = (value: unknown): boolean => {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    !Array.isArray(value) &&\n    Object.keys(value).length === 0\n  );\n};\n\n/**\n * Recursively removes empty objects from a data structure.\n * - Filters empty objects from arrays\n * - Removes properties with empty object values\n * - Removes arrays that become empty after filtering\n */\nconst removeEmptyObjects = (obj: unknown): unknown => {\n  if (Array.isArray(obj)) {\n    // Filter out empty objects from arrays, then recursively process remaining items\n    return obj\n      .filter((item) => {\n        return !isEmptyObject(item);\n      })\n      .map((item) => {\n        return removeEmptyObjects(item);\n      });\n  }\n\n  if (obj !== null && typeof obj === 'object') {\n    return Object.fromEntries(\n      Object.entries(obj)\n        .map(([key, value]) => {\n          return [key, removeEmptyObjects(value)] as [string, unknown];\n        })\n        .filter(([_, processed]) => {\n          // Skip empty objects\n          if (isEmptyObject(processed)) {\n            return false;\n          }\n          // Skip arrays that are now empty after filtering\n          if (Array.isArray(processed) && processed.length === 0) {\n            return false;\n          }\n          return true;\n        }),\n    );\n  }\n\n  return obj;\n};\n\n/**\n * Converts form state to a format suitable for submission by:\n * - Applying all transformations from toValidationFormat\n * - Additionally removing empty objects from the result\n * - Filtering empty objects from arrays\n * - Recursively cleaning nested structures\n *\n * **Why separate from toValidationFormat?**\n *\n * Empty objects must be preserved during validation so that custom refinements\n * can run. For example, a FieldCard with \"at least email or phone required\"\n * validation needs the object to exist (even if empty) for the refine to execute.\n *\n * However, for submission, empty objects are meaningless and should be removed\n * to produce clean data for APIs.\n *\n * @example\n * const formState = {\n *   name: 'John',\n *   contact: {},           // Empty FieldCard - will be removed\n *   tags: [{}, {}, {}],    // All empty - array will be removed\n *   items: [\n *     { value: 'a' },\n *     {},                  // Empty entry - will be filtered out\n *     { value: 'b' }\n *   ],\n *   nested: {\n *     deep: {}             // Nested empty - will be removed recursively\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   items: [{ value: 'a' }, { value: 'b' }]\n * }\n */\nexport const toSubmitFormat = (\n  formState: Record<string, unknown> | null | undefined,\n): Record<string, unknown> | null | undefined => {\n  const validated = toValidationFormat(formState);\n  if (!validated) {\n    return validated;\n  }\n  return removeEmptyObjects(validated) as Record<string, unknown>;\n};\n\n/**\n * Converts a field name to a testId by removing flat array key segments and slugifying.\n * Removes all occurrences of `flatArrayKey` from the field name and applies slugify transformation.\n *\n * This is used to generate stable testIds for form fields that don't include\n * the internal `__FLAT__` marker used for flat arrays.\n *\n * @param name - The field name as a string (e.g., 'tags.0.__FLAT__') or array path (e.g., ['tags', '0', '__FLAT__'])\n * @returns The slugified field name with all flat array key segments removed (e.g., 'tags_0')\n *\n * @example\n * ```ts\n * nameToTestId('tags.0.__FLAT__') // => 'tags_0'\n * nameToTestId('array.0.__FLAT__') // => 'array_0'\n * nameToTestId('nested.array.0.__FLAT__.field') // => 'nested_array_0_field'\n * nameToTestId('simple.field') // => 'simple_field'\n * nameToTestId(['tags', '0', '__FLAT__']) // => 'tags_0'\n * ```\n */\nexport const nameToTestId = (name: string | readonly string[]): string => {\n  let cleanName: string;\n\n  // Handle array paths - filter out flatArrayKey and join with dots\n  if (Array.isArray(name)) {\n    cleanName = name\n      .filter((segment: string) => {\n        return segment !== flatArrayKey;\n      })\n      .join('.');\n  } else {\n    // Handle string paths - split by dots and filter out flatArrayKey segments\n    const segments = (name as string).split('.');\n    cleanName = segments\n      .filter((segment: string) => {\n        return segment !== flatArrayKey;\n      })\n      .join('.');\n  }\n\n  // Apply slugify transformation\n  return slugify(cleanName, { replaceDots: true });\n};\n"],"mappings":"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"}

package/dist/helpers/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["record"],"sources":["../../src/helpers/createOptionValueConverter/createOptionValueConverter.ts","../../src/helpers/nullishFields/nullishFields.ts"],"sourcesContent":["/* eslint-disable import-x/prefer-default-export */\n\n/**\n * Creates a converter function that preserves the original type (string, number, or boolean)\n * of option values when converting from string keys back to their original type.\n *\n * This is useful for radio/select components where the underlying UI library\n * uses string keys internally, but we want to preserve number/boolean values in the form state.\n *\n * @param options - Array of options with a value property that can be string, number, or boolean\n * @returns An object with:\n *   - `convertToOriginalType`: Function to convert a string key back to its original type\n *   - `numberValueKeys`: Set of string representations of number values (for internal use)\n *   - `booleanValueKeys`: Map of string representations to boolean values (for internal use)\n */\nexport const createOptionValueConverter = <\n  T extends { value: string | number | boolean },\n>(\n  options: T[],\n) => {\n  // Create a set of string keys that represent number values\n  const numberValueKeys = new Set(\n    options\n      .filter((option) => {\n        return typeof option.value === 'number';\n      })\n      .map((option) => {\n        return String(option.value);\n      }),\n  );\n\n  // Create a map of string keys to boolean values\n  const booleanValueKeys = new Map(\n    options\n      .filter((option) => {\n        return typeof option.value === 'boolean';\n      })\n      .map((option) => {\n        return [String(option.value), option.value as boolean];\n      }),\n  );\n\n  /**\n   * Converts a string key back to its original type (string, number, or boolean)\n   * based on whether the original option value was a number or boolean\n   */\n  const convertToOriginalType = (\n    key: string | number | boolean,\n  ): string | number | boolean => {\n    const keyStr = String(key);\n    const booleanValue = booleanValueKeys.get(keyStr);\n    if (booleanValue !== undefined) {\n      return booleanValue;\n    }\n    if (numberValueKeys.has(keyStr)) {\n      return Number(keyStr);\n    }\n    return keyStr;\n  };\n\n  return {\n    booleanValueKeys,\n    convertToOriginalType,\n    numberValueKeys,\n  };\n};\n","import { slugify } from '@fuf-stack/pixel-utils';\n\n/** Key used to wrap flat array elements when converting to form format */\nexport const flatArrayKey = '__FLAT__';\n\n/**\n * String markers used to preserve null, false, and 0 values during JSON processing\n */\nconst nullString = '__NULL__';\nconst falseString = '__FALSE__';\nconst zeroString = '__ZERO__';\n\n/**\n * Checks if a value is considered \"empty\" for validation display purposes.\n *\n * Used by useUniformField to determine when to show validation errors.\n * Empty values don't trigger immediate error display (user must interact first).\n *\n * Handles:\n * - Primitives: null, undefined, ''\n * - Marker strings: __NULL__, __FALSE__, __ZERO__ (converted via fromNullishString)\n * - Empty arrays: []\n * - Objects with all empty values: {a: null, b: ''}\n * - Flat array wrappers: {__FLAT__: null} or {__FLAT__: ''}\n *\n * @param value - The value to check (will be converted via fromNullishString first)\n * @returns true if the value is empty\n *\n * @example\n * isValueEmpty(null)                    // true\n * isValueEmpty('')                      // true\n * isValueEmpty('__NULL__')              // true (marker string)\n * isValueEmpty([])                      // true (empty array)\n * isValueEmpty({a: null})               // true (object with all empty values)\n * isValueEmpty({__FLAT__: null})        // true (flat array wrapper with empty value)\n * isValueEmpty({__FLAT__: ''})          // true\n * isValueEmpty('hello')                 // false\n * isValueEmpty([1, 2])                  // false\n * isValueEmpty({a: 'value'})            // false\n * isValueEmpty({__FLAT__: 'value'})     // false\n */\nexport const isValueEmpty = (value: unknown): boolean => {\n  // Convert marker strings first\n  const converted = fromNullishString(value);\n\n  if (converted === undefined || converted === null || converted === '') {\n    return true;\n  }\n  if (Array.isArray(converted)) {\n    return converted.length === 0;\n  }\n  if (typeof converted === 'object' && converted !== null) {\n    const record = converted as Record<string, unknown>;\n    // Handle flat array wrapper: { __FLAT__: innerValue }\n    if (flatArrayKey in record) {\n      return isValueEmpty(record[flatArrayKey]);\n    }\n    // For objects (e.g., FieldCard), check if all values are null/undefined/empty\n    const values = Object.values(record);\n    return values.length === 0 || values.every(isValueEmpty);\n  }\n  return false;\n};\n\n/**\n * Converts marker strings back to their original values when processing arrays\n */\nexport const fromNullishString = (value: unknown): unknown => {\n  // Support arrays: unwrap flat wrappers and convert marker strings per entry\n  if (Array.isArray(value)) {\n    return (value as unknown[]).map((entry) => {\n      if (entry && typeof entry === 'object') {\n        const record = entry as Record<string, unknown>;\n        if (flatArrayKey in record) {\n          const inner = record[flatArrayKey];\n          // For arrays, treat empty string as null (placeholder input)\n          if (inner === '') {\n            return null;\n          }\n          return fromNullishString(inner);\n        }\n      }\n      return fromNullishString(entry);\n    });\n  }\n\n  if (typeof value !== 'string') {\n    return value;\n  }\n\n  switch (value) {\n    case nullString:\n      return null;\n    case falseString:\n      return false;\n    case zeroString:\n      return 0;\n    default:\n      return value;\n  }\n};\n\n/**\n * Converts null/falsy values to marker strings for JSON processing\n */\nexport const toNullishString = (value: unknown): unknown => {\n  if (Array.isArray(value)) {\n    // Only wrap arrays of primitives; leave arrays of objects as-is\n    const isPrimitive = (v: unknown) => {\n      return v === null || ['string', 'number', 'boolean'].includes(typeof v);\n    };\n    const isPrimitiveArray = (value as unknown[]).every(isPrimitive);\n    if (isPrimitiveArray) {\n      return (value as unknown[]).map((v) => {\n        // Store raw primitive; do not convert to marker strings inside the wrapper\n        return { [flatArrayKey]: v } as Record<string, unknown>;\n      });\n    }\n    return value;\n  }\n  if (value === null || value === '') {\n    return nullString;\n  }\n  if (value === false) {\n    return falseString;\n  }\n  if (value === 0) {\n    return zeroString;\n  }\n  return value;\n};\n\n/**\n * Converts field values to a format suitable for forms by:\n * - Wrapping arrays of primitives as objects using the flatArrayKey `__FLAT__`\n *   to satisfy RHF's requirement that array fields contain objects\n * - Removing empty strings and null values from objects\n *\n * This conversion is required because React Hook Form does not support arrays with\n * flat values (string, number, boolean, null). Array fields must contain objects.\n * We work around this by wrapping primitive entries: `{ __FLAT__: <value> }`.\n *\n * @example\n * const fields = {\n *   name: 'John',\n *   scores: [0, null, 75, false],\n *   scoresDetailed: [\n *     { score: 1 },\n *     { score: null },\n *     { score: 0 },\n *     { score: false },\n *     { score: '' },\n *   ],\n *   contact: {\n *     email: '',\n *     phone: null,\n *     address: '123 Main St'\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   scores: [\n *     { __FLAT__: 0 },\n *     { __FLAT__: null },\n *     { __FLAT__: 75 },\n *     { __FLAT__: false }\n *   ],\n *   // Arrays of objects are left as objects; empty/null properties are removed\n *   scoresDetailed: [\n *     { score: 1 },\n *     {}, // null score removed\n *     { score: 0 },\n *     { score: false },\n *     {}, // empty string removed\n *   ],\n *   contact: {\n *     address: '123 Main St'\n *   }\n * }\n */\nexport const toFormFormat = (fields: Record<string, unknown>) => {\n  const formFormatJson = JSON.stringify(fields, (_, value) => {\n    if (Array.isArray(value)) {\n      // Delegate to toNullishString to ensure consistent handling\n      return toNullishString(value);\n    }\n\n    if (value && typeof value === 'object') {\n      // Preserve flat-array wrappers as-is (do not filter their inner values here)\n      const record = value as Record<string, unknown>;\n      if (flatArrayKey in record) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return value;\n      }\n      return Object.fromEntries(\n        Object.entries(value).filter(([_key, v]) => {\n          return v !== '' && v !== null;\n        }),\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return value;\n  });\n\n  return JSON.parse(formFormatJson) as Record<string, unknown>;\n};\n\n/**\n * Converts form state to a format suitable for validation by:\n * - Unwrapping flat array wrappers `{ __FLAT__: <value> }` back to primitives\n * - Converting legacy string markers (__NULL__, __FALSE__, __ZERO__) back to their original values\n * - Removing fields whose converted value is empty string or null\n * - Removing empty arrays\n *\n * @example\n * const formState = {\n *   name: 'John',\n *   scores: [\n *     { __FLAT__: 75 },\n *     { __FLAT__: 0 },\n *     { __FLAT__: null },\n *     { __FLAT__: false }\n *   ],\n *   emptyArray: [],\n *   scoresDetailed: [\n *     { score: 1 },\n *     {},\n *     { score: 0 },\n *     { score: false },\n *     {},\n *   ],\n *   contact: {\n *     address: '123 Main St',\n *     fax: null\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   scores: [75, 0, null, false],\n *   // emptyArray is removed\n *   // Objects inside arrays remain objects; empty entries remain empty objects\n *   scoresDetailed: [\n *     { score: 1 },\n *     {},\n *     { score: 0 },\n *     { score: false },\n *     {},\n *   ],\n *   contact: {\n *     address: '123 Main St'\n *   }\n * }\n */\nexport const toValidationFormat = (\n  formState: Record<string, unknown> | null | undefined,\n): Record<string, unknown> | null | undefined => {\n  // Handle null or undefined input\n  if (formState === undefined || formState === null) {\n    return formState;\n  }\n\n  const validationFormatJson = JSON.stringify(formState, (_, value) => {\n    if (Array.isArray(value)) {\n      return value.map((v) => {\n        // Unwrap new wrapper format { __FLAT__: <value> }\n        if (v && typeof v === 'object') {\n          const record = v as Record<string, unknown>;\n          if (flatArrayKey in record) {\n            const inner = record[flatArrayKey];\n            // Treat empty string from forms as null in validation format\n            if (inner === '') {\n              return null;\n            }\n            return fromNullishString(inner);\n          }\n        }\n        // Backward compatibility for string markers\n        return fromNullishString(v);\n      });\n    }\n\n    if (value && typeof value === 'object') {\n      // Object branch: remove keys that resolve to empty/null after marker conversion\n      // and unwrap flat-array wrappers if present.\n      //\n      // Why this shape?\n      // - Forms may contain objects with placeholder/empty values that should not\n      //   be part of the validation payload (e.g. \"\" or __NULL__ markers).\n      // - Arrays of primitives are stored as wrapper objects { __FLAT__: <value> }\n      //   to satisfy RHF structure constraints. When converting back for\n      //   validation, we need to treat wrappers whose inner value resolves to\n      //   empty/null as removable, and unwrap non-empty wrappers to the primitive.\n      return Object.fromEntries(\n        Object.entries(value)\n          .filter(([_key, v]) => {\n            // If this is a flat-array wrapper, convert the inner value first and\n            // drop the key when the inner resolves to empty string or null.\n            if (v && typeof v === 'object') {\n              const record = v as Record<string, unknown>;\n              if (flatArrayKey in record) {\n                const convertedInner = fromNullishString(record[flatArrayKey]);\n                return convertedInner !== '' && convertedInner !== null;\n              }\n            }\n            // Drop empty arrays\n            if (Array.isArray(v) && v.length === 0) {\n              return false;\n            }\n            // For regular values, convert markers and drop when empty/null.\n            const converted = fromNullishString(v);\n            return converted !== '' && converted !== null;\n          })\n          .map(([k, v]) => {\n            // Unwrap flat-array wrappers to raw primitives after conversion.\n            if (v && typeof v === 'object') {\n              const record = v as Record<string, unknown>;\n              if (flatArrayKey in record) {\n                return [k, fromNullishString(record[flatArrayKey])];\n              }\n            }\n            // For other values, just convert markers.\n            return [k, fromNullishString(v)];\n          }),\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return value;\n  });\n\n  return JSON.parse(validationFormatJson) as Record<string, unknown>;\n};\n\n/**\n * Helper function to check if a value is an empty object (not an array).\n */\nconst isEmptyObject = (value: unknown): boolean => {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    !Array.isArray(value) &&\n    Object.keys(value as Record<string, unknown>).length === 0\n  );\n};\n\n/**\n * Recursively removes empty objects from a data structure.\n * - Filters empty objects from arrays\n * - Removes properties with empty object values\n * - Removes arrays that become empty after filtering\n */\nconst removeEmptyObjects = (obj: unknown): unknown => {\n  if (Array.isArray(obj)) {\n    // Filter out empty objects from arrays, then recursively process remaining items\n    return obj\n      .filter((item) => {\n        return !isEmptyObject(item);\n      })\n      .map((item) => {\n        return removeEmptyObjects(item);\n      });\n  }\n\n  if (obj !== null && typeof obj === 'object') {\n    return Object.fromEntries(\n      Object.entries(obj)\n        .map(([key, value]) => {\n          return [key, removeEmptyObjects(value)] as [string, unknown];\n        })\n        .filter(([_, processed]) => {\n          // Skip empty objects\n          if (isEmptyObject(processed)) {\n            return false;\n          }\n          // Skip arrays that are now empty after filtering\n          if (Array.isArray(processed) && processed.length === 0) {\n            return false;\n          }\n          return true;\n        }),\n    );\n  }\n\n  return obj;\n};\n\n/**\n * Converts form state to a format suitable for submission by:\n * - Applying all transformations from toValidationFormat\n * - Additionally removing empty objects from the result\n * - Filtering empty objects from arrays\n * - Recursively cleaning nested structures\n *\n * **Why separate from toValidationFormat?**\n *\n * Empty objects must be preserved during validation so that custom refinements\n * can run. For example, a FieldCard with \"at least email or phone required\"\n * validation needs the object to exist (even if empty) for the refine to execute.\n *\n * However, for submission, empty objects are meaningless and should be removed\n * to produce clean data for APIs.\n *\n * @example\n * const formState = {\n *   name: 'John',\n *   contact: {},           // Empty FieldCard - will be removed\n *   tags: [{}, {}, {}],    // All empty - array will be removed\n *   items: [\n *     { value: 'a' },\n *     {},                  // Empty entry - will be filtered out\n *     { value: 'b' }\n *   ],\n *   nested: {\n *     deep: {}             // Nested empty - will be removed recursively\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   items: [{ value: 'a' }, { value: 'b' }]\n * }\n */\nexport const toSubmitFormat = (\n  formState: Record<string, unknown> | null | undefined,\n): Record<string, unknown> | null | undefined => {\n  const validated = toValidationFormat(formState);\n  if (!validated) {\n    return validated;\n  }\n  return removeEmptyObjects(validated) as Record<string, unknown>;\n};\n\n/**\n * Converts a field name to a testId by removing flat array key segments and slugifying.\n * Removes all occurrences of `flatArrayKey` from the field name and applies slugify transformation.\n *\n * This is used to generate stable testIds for form fields that don't include\n * the internal `__FLAT__` marker used for flat arrays.\n *\n * @param name - The field name as a string (e.g., 'tags.0.__FLAT__') or array path (e.g., ['tags', '0', '__FLAT__'])\n * @returns The slugified field name with all flat array key segments removed (e.g., 'tags_0')\n *\n * @example\n * ```ts\n * nameToTestId('tags.0.__FLAT__') // => 'tags_0'\n * nameToTestId('array.0.__FLAT__') // => 'array_0'\n * nameToTestId('nested.array.0.__FLAT__.field') // => 'nested_array_0_field'\n * nameToTestId('simple.field') // => 'simple_field'\n * nameToTestId(['tags', '0', '__FLAT__']) // => 'tags_0'\n * ```\n */\nexport const nameToTestId = (name: string | readonly string[]): string => {\n  let cleanName: string;\n\n  // Handle array paths - filter out flatArrayKey and join with dots\n  if (Array.isArray(name)) {\n    cleanName = name\n      .filter((segment: string) => {\n        return segment !== flatArrayKey;\n      })\n      .join('.');\n  } else {\n    // Handle string paths - split by dots and filter out flatArrayKey segments\n    const segments = (name as string).split('.');\n    cleanName = segments\n      .filter((segment: string) => {\n        return segment !== flatArrayKey;\n      })\n      .join('.');\n  }\n\n  // Apply slugify transformation\n  return slugify(cleanName, { replaceDots: true });\n};\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["record"],"sources":["../../src/helpers/createOptionValueConverter/createOptionValueConverter.ts","../../src/helpers/nullishFields/nullishFields.ts"],"sourcesContent":["/* eslint-disable import-x/prefer-default-export */\n\n/**\n * Creates a converter function that preserves the original type (string, number, or boolean)\n * of option values when converting from string keys back to their original type.\n *\n * This is useful for radio/select components where the underlying UI library\n * uses string keys internally, but we want to preserve number/boolean values in the form state.\n *\n * @param options - Array of options with a value property that can be string, number, or boolean\n * @returns An object with:\n *   - `convertToOriginalType`: Function to convert a string key back to its original type\n *   - `numberValueKeys`: Set of string representations of number values (for internal use)\n *   - `booleanValueKeys`: Map of string representations to boolean values (for internal use)\n */\nexport const createOptionValueConverter = <\n  T extends { value: string | number | boolean },\n>(\n  options: T[],\n) => {\n  // Create a set of string keys that represent number values\n  const numberValueKeys = new Set(\n    options\n      .filter((option) => {\n        return typeof option.value === 'number';\n      })\n      .map((option) => {\n        return String(option.value);\n      }),\n  );\n\n  // Create a map of string keys to boolean values\n  const booleanValueKeys = new Map(\n    options\n      .filter((option) => {\n        return typeof option.value === 'boolean';\n      })\n      .map((option) => {\n        return [String(option.value), option.value as boolean];\n      }),\n  );\n\n  /**\n   * Converts a string key back to its original type (string, number, or boolean)\n   * based on whether the original option value was a number or boolean\n   */\n  const convertToOriginalType = (\n    key: string | number | boolean,\n  ): string | number | boolean => {\n    const keyStr = String(key);\n    const booleanValue = booleanValueKeys.get(keyStr);\n    if (booleanValue !== undefined) {\n      return booleanValue;\n    }\n    if (numberValueKeys.has(keyStr)) {\n      return Number(keyStr);\n    }\n    return keyStr;\n  };\n\n  return {\n    booleanValueKeys,\n    convertToOriginalType,\n    numberValueKeys,\n  };\n};\n","import { slugify } from '@fuf-stack/pixel-utils';\n\n/** Key used to wrap flat array elements when converting to form format */\nexport const flatArrayKey = '__FLAT__';\n\n/**\n * String markers used to preserve null, false, and 0 values during JSON processing\n */\nconst nullString = '__NULL__';\nconst falseString = '__FALSE__';\nconst zeroString = '__ZERO__';\n\n/**\n * Checks if a value is considered \"empty\" for validation display purposes.\n *\n * Used by useUniformField to determine when to show validation errors.\n * Empty values don't trigger immediate error display (user must interact first).\n *\n * Handles:\n * - Primitives: null, undefined, ''\n * - Marker strings: __NULL__, __FALSE__, __ZERO__ (converted via fromNullishString)\n * - Empty arrays: []\n * - Objects with all empty values: {a: null, b: ''}\n * - Flat array wrappers: {__FLAT__: null} or {__FLAT__: ''}\n *\n * @param value - The value to check (will be converted via fromNullishString first)\n * @returns true if the value is empty\n *\n * @example\n * isValueEmpty(null)                    // true\n * isValueEmpty('')                      // true\n * isValueEmpty('__NULL__')              // true (marker string)\n * isValueEmpty([])                      // true (empty array)\n * isValueEmpty({a: null})               // true (object with all empty values)\n * isValueEmpty({__FLAT__: null})        // true (flat array wrapper with empty value)\n * isValueEmpty({__FLAT__: ''})          // true\n * isValueEmpty('hello')                 // false\n * isValueEmpty([1, 2])                  // false\n * isValueEmpty({a: 'value'})            // false\n * isValueEmpty({__FLAT__: 'value'})     // false\n */\nexport const isValueEmpty = (value: unknown): boolean => {\n  // Convert marker strings first\n  const converted = fromNullishString(value);\n\n  if (converted === undefined || converted === null || converted === '') {\n    return true;\n  }\n  if (Array.isArray(converted)) {\n    return converted.length === 0;\n  }\n  if (typeof converted === 'object' && converted !== null) {\n    const record = converted as Record<string, unknown>;\n    // Handle flat array wrapper: { __FLAT__: innerValue }\n    if (flatArrayKey in record) {\n      return isValueEmpty(record[flatArrayKey]);\n    }\n    // For objects (e.g., FieldCard), check if all values are null/undefined/empty\n    const values = Object.values(record);\n    return values.length === 0 || values.every(isValueEmpty);\n  }\n  return false;\n};\n\n/**\n * Converts marker strings back to their original values when processing arrays\n */\nexport const fromNullishString = (value: unknown): unknown => {\n  // Support arrays: unwrap flat wrappers and convert marker strings per entry\n  if (Array.isArray(value)) {\n    return (value as unknown[]).map((entry) => {\n      if (entry && typeof entry === 'object') {\n        const record = entry as Record<string, unknown>;\n        if (flatArrayKey in record) {\n          const inner = record[flatArrayKey];\n          // For arrays, treat empty string as null (placeholder input)\n          if (inner === '') {\n            return null;\n          }\n          return fromNullishString(inner);\n        }\n      }\n      return fromNullishString(entry);\n    });\n  }\n\n  if (typeof value !== 'string') {\n    return value;\n  }\n\n  switch (value) {\n    case nullString:\n      return null;\n    case falseString:\n      return false;\n    case zeroString:\n      return 0;\n    default:\n      return value;\n  }\n};\n\n/**\n * Converts null/falsy values to marker strings for JSON processing\n */\nexport const toNullishString = (value: unknown): unknown => {\n  if (Array.isArray(value)) {\n    // Only wrap arrays of primitives; leave arrays of objects as-is\n    const isPrimitive = (v: unknown) => {\n      return v === null || ['string', 'number', 'boolean'].includes(typeof v);\n    };\n    const isPrimitiveArray = (value as unknown[]).every(isPrimitive);\n    if (isPrimitiveArray) {\n      return (value as unknown[]).map((v) => {\n        // Store raw primitive; do not convert to marker strings inside the wrapper\n        return { [flatArrayKey]: v };\n      });\n    }\n    return value;\n  }\n  if (value === null || value === '') {\n    return nullString;\n  }\n  if (value === false) {\n    return falseString;\n  }\n  if (value === 0) {\n    return zeroString;\n  }\n  return value;\n};\n\n/**\n * Converts field values to a format suitable for forms by:\n * - Wrapping arrays of primitives as objects using the flatArrayKey `__FLAT__`\n *   to satisfy RHF's requirement that array fields contain objects\n * - Removing empty strings and null values from objects\n *\n * This conversion is required because React Hook Form does not support arrays with\n * flat values (string, number, boolean, null). Array fields must contain objects.\n * We work around this by wrapping primitive entries: `{ __FLAT__: <value> }`.\n *\n * @example\n * const fields = {\n *   name: 'John',\n *   scores: [0, null, 75, false],\n *   scoresDetailed: [\n *     { score: 1 },\n *     { score: null },\n *     { score: 0 },\n *     { score: false },\n *     { score: '' },\n *   ],\n *   contact: {\n *     email: '',\n *     phone: null,\n *     address: '123 Main St'\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   scores: [\n *     { __FLAT__: 0 },\n *     { __FLAT__: null },\n *     { __FLAT__: 75 },\n *     { __FLAT__: false }\n *   ],\n *   // Arrays of objects are left as objects; empty/null properties are removed\n *   scoresDetailed: [\n *     { score: 1 },\n *     {}, // null score removed\n *     { score: 0 },\n *     { score: false },\n *     {}, // empty string removed\n *   ],\n *   contact: {\n *     address: '123 Main St'\n *   }\n * }\n */\nexport const toFormFormat = (fields: Record<string, unknown>) => {\n  const formFormatJson = JSON.stringify(fields, (_, value) => {\n    if (Array.isArray(value)) {\n      // Delegate to toNullishString to ensure consistent handling\n      return toNullishString(value);\n    }\n\n    if (value && typeof value === 'object') {\n      // Preserve flat-array wrappers as-is (do not filter their inner values here)\n      const record = value as Record<string, unknown>;\n      if (flatArrayKey in record) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return value;\n      }\n      return Object.fromEntries(\n        Object.entries(value).filter(([_key, v]) => {\n          return v !== '' && v !== null;\n        }),\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return value;\n  });\n\n  return JSON.parse(formFormatJson) as Record<string, unknown>;\n};\n\n/**\n * Converts form state to a format suitable for validation by:\n * - Unwrapping flat array wrappers `{ __FLAT__: <value> }` back to primitives\n * - Converting legacy string markers (__NULL__, __FALSE__, __ZERO__) back to their original values\n * - Removing fields whose converted value is empty string or null\n * - Removing empty arrays\n *\n * @example\n * const formState = {\n *   name: 'John',\n *   scores: [\n *     { __FLAT__: 75 },\n *     { __FLAT__: 0 },\n *     { __FLAT__: null },\n *     { __FLAT__: false }\n *   ],\n *   emptyArray: [],\n *   scoresDetailed: [\n *     { score: 1 },\n *     {},\n *     { score: 0 },\n *     { score: false },\n *     {},\n *   ],\n *   contact: {\n *     address: '123 Main St',\n *     fax: null\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   scores: [75, 0, null, false],\n *   // emptyArray is removed\n *   // Objects inside arrays remain objects; empty entries remain empty objects\n *   scoresDetailed: [\n *     { score: 1 },\n *     {},\n *     { score: 0 },\n *     { score: false },\n *     {},\n *   ],\n *   contact: {\n *     address: '123 Main St'\n *   }\n * }\n */\nexport const toValidationFormat = (\n  formState: Record<string, unknown> | null | undefined,\n): Record<string, unknown> | null | undefined => {\n  // Handle null or undefined input\n  if (formState === undefined || formState === null) {\n    return formState;\n  }\n\n  const validationFormatJson = JSON.stringify(formState, (_, value) => {\n    if (Array.isArray(value)) {\n      return value.map((v) => {\n        // Unwrap new wrapper format { __FLAT__: <value> }\n        if (v && typeof v === 'object') {\n          const record = v as Record<string, unknown>;\n          if (flatArrayKey in record) {\n            const inner = record[flatArrayKey];\n            // Treat empty string from forms as null in validation format\n            if (inner === '') {\n              return null;\n            }\n            return fromNullishString(inner);\n          }\n        }\n        // Backward compatibility for string markers\n        return fromNullishString(v);\n      });\n    }\n\n    if (value && typeof value === 'object') {\n      // Object branch: remove keys that resolve to empty/null after marker conversion\n      // and unwrap flat-array wrappers if present.\n      //\n      // Why this shape?\n      // - Forms may contain objects with placeholder/empty values that should not\n      //   be part of the validation payload (e.g. \"\" or __NULL__ markers).\n      // - Arrays of primitives are stored as wrapper objects { __FLAT__: <value> }\n      //   to satisfy RHF structure constraints. When converting back for\n      //   validation, we need to treat wrappers whose inner value resolves to\n      //   empty/null as removable, and unwrap non-empty wrappers to the primitive.\n      return Object.fromEntries(\n        Object.entries(value)\n          .filter(([_key, v]) => {\n            // If this is a flat-array wrapper, convert the inner value first and\n            // drop the key when the inner resolves to empty string or null.\n            if (v && typeof v === 'object') {\n              const record = v as Record<string, unknown>;\n              if (flatArrayKey in record) {\n                const convertedInner = fromNullishString(record[flatArrayKey]);\n                return convertedInner !== '' && convertedInner !== null;\n              }\n            }\n            // Drop empty arrays\n            if (Array.isArray(v) && v.length === 0) {\n              return false;\n            }\n            // For regular values, convert markers and drop when empty/null.\n            const converted = fromNullishString(v);\n            return converted !== '' && converted !== null;\n          })\n          .map(([k, v]) => {\n            // Unwrap flat-array wrappers to raw primitives after conversion.\n            if (v && typeof v === 'object') {\n              const record = v as Record<string, unknown>;\n              if (flatArrayKey in record) {\n                return [k, fromNullishString(record[flatArrayKey])];\n              }\n            }\n            // For other values, just convert markers.\n            return [k, fromNullishString(v)];\n          }),\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return value;\n  });\n\n  return JSON.parse(validationFormatJson) as Record<string, unknown>;\n};\n\n/**\n * Helper function to check if a value is an empty object (not an array).\n */\nconst isEmptyObject = (value: unknown): boolean => {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    !Array.isArray(value) &&\n    Object.keys(value).length === 0\n  );\n};\n\n/**\n * Recursively removes empty objects from a data structure.\n * - Filters empty objects from arrays\n * - Removes properties with empty object values\n * - Removes arrays that become empty after filtering\n */\nconst removeEmptyObjects = (obj: unknown): unknown => {\n  if (Array.isArray(obj)) {\n    // Filter out empty objects from arrays, then recursively process remaining items\n    return obj\n      .filter((item) => {\n        return !isEmptyObject(item);\n      })\n      .map((item) => {\n        return removeEmptyObjects(item);\n      });\n  }\n\n  if (obj !== null && typeof obj === 'object') {\n    return Object.fromEntries(\n      Object.entries(obj)\n        .map(([key, value]) => {\n          return [key, removeEmptyObjects(value)] as [string, unknown];\n        })\n        .filter(([_, processed]) => {\n          // Skip empty objects\n          if (isEmptyObject(processed)) {\n            return false;\n          }\n          // Skip arrays that are now empty after filtering\n          if (Array.isArray(processed) && processed.length === 0) {\n            return false;\n          }\n          return true;\n        }),\n    );\n  }\n\n  return obj;\n};\n\n/**\n * Converts form state to a format suitable for submission by:\n * - Applying all transformations from toValidationFormat\n * - Additionally removing empty objects from the result\n * - Filtering empty objects from arrays\n * - Recursively cleaning nested structures\n *\n * **Why separate from toValidationFormat?**\n *\n * Empty objects must be preserved during validation so that custom refinements\n * can run. For example, a FieldCard with \"at least email or phone required\"\n * validation needs the object to exist (even if empty) for the refine to execute.\n *\n * However, for submission, empty objects are meaningless and should be removed\n * to produce clean data for APIs.\n *\n * @example\n * const formState = {\n *   name: 'John',\n *   contact: {},           // Empty FieldCard - will be removed\n *   tags: [{}, {}, {}],    // All empty - array will be removed\n *   items: [\n *     { value: 'a' },\n *     {},                  // Empty entry - will be filtered out\n *     { value: 'b' }\n *   ],\n *   nested: {\n *     deep: {}             // Nested empty - will be removed recursively\n *   }\n * };\n *\n * // Result:\n * {\n *   name: 'John',\n *   items: [{ value: 'a' }, { value: 'b' }]\n * }\n */\nexport const toSubmitFormat = (\n  formState: Record<string, unknown> | null | undefined,\n): Record<string, unknown> | null | undefined => {\n  const validated = toValidationFormat(formState);\n  if (!validated) {\n    return validated;\n  }\n  return removeEmptyObjects(validated) as Record<string, unknown>;\n};\n\n/**\n * Converts a field name to a testId by removing flat array key segments and slugifying.\n * Removes all occurrences of `flatArrayKey` from the field name and applies slugify transformation.\n *\n * This is used to generate stable testIds for form fields that don't include\n * the internal `__FLAT__` marker used for flat arrays.\n *\n * @param name - The field name as a string (e.g., 'tags.0.__FLAT__') or array path (e.g., ['tags', '0', '__FLAT__'])\n * @returns The slugified field name with all flat array key segments removed (e.g., 'tags_0')\n *\n * @example\n * ```ts\n * nameToTestId('tags.0.__FLAT__') // => 'tags_0'\n * nameToTestId('array.0.__FLAT__') // => 'array_0'\n * nameToTestId('nested.array.0.__FLAT__.field') // => 'nested_array_0_field'\n * nameToTestId('simple.field') // => 'simple_field'\n * nameToTestId(['tags', '0', '__FLAT__']) // => 'tags_0'\n * ```\n */\nexport const nameToTestId = (name: string | readonly string[]): string => {\n  let cleanName: string;\n\n  // Handle array paths - filter out flatArrayKey and join with dots\n  if (Array.isArray(name)) {\n    cleanName = name\n      .filter((segment: string) => {\n        return segment !== flatArrayKey;\n      })\n      .join('.');\n  } else {\n    // Handle string paths - split by dots and filter out flatArrayKey segments\n    const segments = (name as string).split('.');\n    cleanName = segments\n      .filter((segment: string) => {\n        return segment !== flatArrayKey;\n      })\n      .join('.');\n  }\n\n  // Apply slugify transformation\n  return slugify(cleanName, { replaceDots: true });\n};\n"],"mappings":"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"}