@fuf-stack/uniform 1.10.3 → 1.11.0

package/dist/helpers/index.d.ts

@@ -1,132 +1,2 @@
-/** Key used to wrap flat array elements when converting to form format */
-declare const flatArrayKey = "__FLAT__";
-/**
- * Converts marker strings back to their original values when processing arrays
- */
-declare const fromNullishString: (value: unknown) => unknown;
-/**
- * Converts null/falsy values to marker strings for JSON processing
- */
-declare const toNullishString: (value: unknown) => unknown;
-/**
- * Converts field values to a format suitable for forms by:
- * - Wrapping arrays of primitives as objects using the flatArrayKey `__FLAT__`
- *   to satisfy RHF's requirement that array fields contain objects
- * - Removing empty strings and null values from objects
- *
- * This conversion is required because React Hook Form does not support arrays with
- * flat values (string, number, boolean, null). Array fields must contain objects.
- * We work around this by wrapping primitive entries: `{ __FLAT__: <value> }`.
- *
- * @example
- * const fields = {
- *   name: 'John',
- *   scores: [0, null, 75, false],
- *   scoresDetailed: [
- *     { score: 1 },
- *     { score: null },
- *     { score: 0 },
- *     { score: false },
- *     { score: '' },
- *   ],
- *   contact: {
- *     email: '',
- *     phone: null,
- *     address: '123 Main St'
- *   }
- * };
- *
- * // Result:
- * {
- *   name: 'John',
- *   scores: [
- *     { __FLAT__: 0 },
- *     { __FLAT__: null },
- *     { __FLAT__: 75 },
- *     { __FLAT__: false }
- *   ],
- *   // Arrays of objects are left as objects; empty/null properties are removed
- *   scoresDetailed: [
- *     { score: 1 },
- *     {}, // null score removed
- *     { score: 0 },
- *     { score: false },
- *     {}, // empty string removed
- *   ],
- *   contact: {
- *     address: '123 Main St'
- *   }
- * }
- */
-declare const toFormFormat: (fields: Record<string, unknown>) => Record<string, unknown>;
-/**
- * Converts form state to a format suitable for validation by:
- * - Unwrapping flat array wrappers `{ __FLAT__: <value> }` back to primitives
- * - Converting legacy string markers (__NULL__, __FALSE__, __ZERO__) back to their original values
- * - Removing fields whose converted value is empty string or null
- * - Removing empty arrays
- *
- * @example
- * const formState = {
- *   name: 'John',
- *   scores: [
- *     { __FLAT__: 75 },
- *     { __FLAT__: 0 },
- *     { __FLAT__: null },
- *     { __FLAT__: false }
- *   ],
- *   emptyArray: [],
- *   scoresDetailed: [
- *     { score: 1 },
- *     {},
- *     { score: 0 },
- *     { score: false },
- *     {},
- *   ],
- *   contact: {
- *     address: '123 Main St',
- *     fax: null
- *   }
- * };
- *
- * // Result:
- * {
- *   name: 'John',
- *   scores: [75, 0, null, false],
- *   // emptyArray is removed
- *   // Objects inside arrays remain objects; empty entries remain empty objects
- *   scoresDetailed: [
- *     { score: 1 },
- *     {},
- *     { score: 0 },
- *     { score: false },
- *     {},
- *   ],
- *   contact: {
- *     address: '123 Main St'
- *   }
- * }
- */
-declare const toValidationFormat: (formState: Record<string, unknown> | null | undefined) => Record<string, unknown> | null | undefined;
-/**
- * Converts a field name to a testId by removing flat array key segments and slugifying.
- * Removes all occurrences of `flatArrayKey` from the field name and applies slugify transformation.
- *
- * This is used to generate stable testIds for form fields that don't include
- * the internal `__FLAT__` marker used for flat arrays.
- *
- * @param name - The field name as a string (e.g., 'tags.0.__FLAT__') or array path (e.g., ['tags', '0', '__FLAT__'])
- * @returns The slugified field name with all flat array key segments removed (e.g., 'tags_0')
- *
- * @example
- * ```ts
- * nameToTestId('tags.0.__FLAT__') // => 'tags_0'
- * nameToTestId('array.0.__FLAT__') // => 'array_0'
- * nameToTestId('nested.array.0.__FLAT__.field') // => 'nested_array_0_field'
- * nameToTestId('simple.field') // => 'simple_field'
- * nameToTestId(['tags', '0', '__FLAT__']) // => 'tags_0'
- * ```
- */
-declare const nameToTestId: (name: string | readonly string[]) => string;
-
-export { flatArrayKey, fromNullishString, nameToTestId, toFormFormat, toNullishString, toValidationFormat };
+import { a as toNullishString, i as toFormFormat, n as fromNullishString, o as toValidationFormat, r as nameToTestId, t as flatArrayKey } from "../index-UjKqRe-8.js";
+export { flatArrayKey, fromNullishString, nameToTestId, toFormFormat, toNullishString, toValidationFormat };

package/dist/helpers/index.js

@@ -1,18 +1,3 @@
-import {
-  flatArrayKey,
-  fromNullishString,
-  nameToTestId,
-  toFormFormat,
-  toNullishString,
-  toValidationFormat
-} from "../chunk-O2XJNQQK.js";
-import "../chunk-K2V4ULA2.js";
-export {
-  flatArrayKey,
-  fromNullishString,
-  nameToTestId,
-  toFormFormat,
-  toNullishString,
-  toValidationFormat
-};
-//# sourceMappingURL=index.js.map
+import { a as toNullishString, i as toFormFormat, n as fromNullishString, o as toValidationFormat, r as nameToTestId, t as flatArrayKey } from "../helpers-B-CJOBt3.js";
+
+export { flatArrayKey, fromNullishString, nameToTestId, toFormFormat, toNullishString, toValidationFormat };

package/dist/helpers-B-CJOBt3.js

@@ -0,0 +1,236 @@
+import { slugify } from "@fuf-stack/pixel-utils";
+
+//#region src/helpers/nullishFields/nullishFields.ts
+/** Key used to wrap flat array elements when converting to form format */
+const flatArrayKey = "__FLAT__";
+/**
+* String markers used to preserve null, false, and 0 values during JSON processing
+*/
+const nullString = "__NULL__";
+const falseString = "__FALSE__";
+const zeroString = "__ZERO__";
+/**
+* Converts marker strings back to their original values when processing arrays
+*/
+const fromNullishString = (value) => {
+	if (Array.isArray(value)) return value.map((entry) => {
+		if (entry && typeof entry === "object") {
+			const record = entry;
+			if (flatArrayKey in record) {
+				const inner = record[flatArrayKey];
+				if (inner === "") return null;
+				return fromNullishString(inner);
+			}
+		}
+		return fromNullishString(entry);
+	});
+	if (typeof value !== "string") return value;
+	switch (value) {
+		case nullString: return null;
+		case falseString: return false;
+		case zeroString: return 0;
+		default: return value;
+	}
+};
+/**
+* Converts null/falsy values to marker strings for JSON processing
+*/
+const toNullishString = (value) => {
+	if (Array.isArray(value)) {
+		const isPrimitive = (v) => {
+			return v === null || [
+				"string",
+				"number",
+				"boolean"
+			].includes(typeof v);
+		};
+		if (value.every(isPrimitive)) return value.map((v) => {
+			return { [flatArrayKey]: v };
+		});
+		return value;
+	}
+	if (value === null || value === "") return nullString;
+	if (value === false) return falseString;
+	if (value === 0) return zeroString;
+	return value;
+};
+/**
+* Converts field values to a format suitable for forms by:
+* - Wrapping arrays of primitives as objects using the flatArrayKey `__FLAT__`
+*   to satisfy RHF's requirement that array fields contain objects
+* - Removing empty strings and null values from objects
+*
+* This conversion is required because React Hook Form does not support arrays with
+* flat values (string, number, boolean, null). Array fields must contain objects.
+* We work around this by wrapping primitive entries: `{ __FLAT__: <value> }`.
+*
+* @example
+* const fields = {
+*   name: 'John',
+*   scores: [0, null, 75, false],
+*   scoresDetailed: [
+*     { score: 1 },
+*     { score: null },
+*     { score: 0 },
+*     { score: false },
+*     { score: '' },
+*   ],
+*   contact: {
+*     email: '',
+*     phone: null,
+*     address: '123 Main St'
+*   }
+* };
+*
+* // Result:
+* {
+*   name: 'John',
+*   scores: [
+*     { __FLAT__: 0 },
+*     { __FLAT__: null },
+*     { __FLAT__: 75 },
+*     { __FLAT__: false }
+*   ],
+*   // Arrays of objects are left as objects; empty/null properties are removed
+*   scoresDetailed: [
+*     { score: 1 },
+*     {}, // null score removed
+*     { score: 0 },
+*     { score: false },
+*     {}, // empty string removed
+*   ],
+*   contact: {
+*     address: '123 Main St'
+*   }
+* }
+*/
+const toFormFormat = (fields) => {
+	const formFormatJson = JSON.stringify(fields, (_, value) => {
+		if (Array.isArray(value)) return toNullishString(value);
+		if (value && typeof value === "object") {
+			if (flatArrayKey in value) return value;
+			return Object.fromEntries(Object.entries(value).filter(([_key, v]) => {
+				return v !== "" && v !== null;
+			}));
+		}
+		return value;
+	});
+	return JSON.parse(formFormatJson);
+};
+/**
+* Converts form state to a format suitable for validation by:
+* - Unwrapping flat array wrappers `{ __FLAT__: <value> }` back to primitives
+* - Converting legacy string markers (__NULL__, __FALSE__, __ZERO__) back to their original values
+* - Removing fields whose converted value is empty string or null
+* - Removing empty arrays
+*
+* @example
+* const formState = {
+*   name: 'John',
+*   scores: [
+*     { __FLAT__: 75 },
+*     { __FLAT__: 0 },
+*     { __FLAT__: null },
+*     { __FLAT__: false }
+*   ],
+*   emptyArray: [],
+*   scoresDetailed: [
+*     { score: 1 },
+*     {},
+*     { score: 0 },
+*     { score: false },
+*     {},
+*   ],
+*   contact: {
+*     address: '123 Main St',
+*     fax: null
+*   }
+* };
+*
+* // Result:
+* {
+*   name: 'John',
+*   scores: [75, 0, null, false],
+*   // emptyArray is removed
+*   // Objects inside arrays remain objects; empty entries remain empty objects
+*   scoresDetailed: [
+*     { score: 1 },
+*     {},
+*     { score: 0 },
+*     { score: false },
+*     {},
+*   ],
+*   contact: {
+*     address: '123 Main St'
+*   }
+* }
+*/
+const toValidationFormat = (formState) => {
+	if (formState === void 0 || formState === null) return formState;
+	const validationFormatJson = JSON.stringify(formState, (_, value) => {
+		if (Array.isArray(value)) return value.map((v) => {
+			if (v && typeof v === "object") {
+				const record = v;
+				if (flatArrayKey in record) {
+					const inner = record[flatArrayKey];
+					if (inner === "") return null;
+					return fromNullishString(inner);
+				}
+			}
+			return fromNullishString(v);
+		});
+		if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).filter(([_key, v]) => {
+			if (v && typeof v === "object") {
+				const record = v;
+				if (flatArrayKey in record) {
+					const convertedInner = fromNullishString(record[flatArrayKey]);
+					return convertedInner !== "" && convertedInner !== null;
+				}
+			}
+			if (Array.isArray(v) && v.length === 0) return false;
+			const converted = fromNullishString(v);
+			return converted !== "" && converted !== null;
+		}).map(([k, v]) => {
+			if (v && typeof v === "object") {
+				const record = v;
+				if (flatArrayKey in record) return [k, fromNullishString(record[flatArrayKey])];
+			}
+			return [k, fromNullishString(v)];
+		}));
+		return value;
+	});
+	return JSON.parse(validationFormatJson);
+};
+/**
+* Converts a field name to a testId by removing flat array key segments and slugifying.
+* Removes all occurrences of `flatArrayKey` from the field name and applies slugify transformation.
+*
+* This is used to generate stable testIds for form fields that don't include
+* the internal `__FLAT__` marker used for flat arrays.
+*
+* @param name - The field name as a string (e.g., 'tags.0.__FLAT__') or array path (e.g., ['tags', '0', '__FLAT__'])
+* @returns The slugified field name with all flat array key segments removed (e.g., 'tags_0')
+*
+* @example
+* ```ts
+* nameToTestId('tags.0.__FLAT__') // => 'tags_0'
+* nameToTestId('array.0.__FLAT__') // => 'array_0'
+* nameToTestId('nested.array.0.__FLAT__.field') // => 'nested_array_0_field'
+* nameToTestId('simple.field') // => 'simple_field'
+* nameToTestId(['tags', '0', '__FLAT__']) // => 'tags_0'
+* ```
+*/
+const nameToTestId = (name) => {
+	let cleanName;
+	if (Array.isArray(name)) cleanName = name.filter((segment) => {
+		return segment !== flatArrayKey;
+	}).join(".");
+	else cleanName = name.split(".").filter((segment) => {
+		return segment !== flatArrayKey;
+	}).join(".");
+	return slugify(cleanName, { replaceDots: true });
+};
+
+//#endregion
+export { toNullishString as a, toFormFormat as i, fromNullishString as n, toValidationFormat as o, nameToTestId as r, flatArrayKey as t };
+//# sourceMappingURL=helpers-B-CJOBt3.js.map

package/dist/helpers-B-CJOBt3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers-B-CJOBt3.js","names":["cleanName: string"],"sources":["../src/helpers/nullishFields/nullishFields.ts"],"sourcesContent":["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 * 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 * 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-KTgXi0lA.cjs

@@ -0,0 +1,272 @@
+const require_FormContext = require('./FormContext-C3GymQOA.cjs');
+let __fuf_stack_pixel_utils = require("@fuf-stack/pixel-utils");
+
+//#region src/helpers/nullishFields/nullishFields.ts
+/** Key used to wrap flat array elements when converting to form format */
+const flatArrayKey = "__FLAT__";
+/**
+* String markers used to preserve null, false, and 0 values during JSON processing
+*/
+const nullString = "__NULL__";
+const falseString = "__FALSE__";
+const zeroString = "__ZERO__";
+/**
+* Converts marker strings back to their original values when processing arrays
+*/
+const fromNullishString = (value) => {
+	if (Array.isArray(value)) return value.map((entry) => {
+		if (entry && typeof entry === "object") {
+			const record = entry;
+			if (flatArrayKey in record) {
+				const inner = record[flatArrayKey];
+				if (inner === "") return null;
+				return fromNullishString(inner);
+			}
+		}
+		return fromNullishString(entry);
+	});
+	if (typeof value !== "string") return value;
+	switch (value) {
+		case nullString: return null;
+		case falseString: return false;
+		case zeroString: return 0;
+		default: return value;
+	}
+};
+/**
+* Converts null/falsy values to marker strings for JSON processing
+*/
+const toNullishString = (value) => {
+	if (Array.isArray(value)) {
+		const isPrimitive = (v) => {
+			return v === null || [
+				"string",
+				"number",
+				"boolean"
+			].includes(typeof v);
+		};
+		if (value.every(isPrimitive)) return value.map((v) => {
+			return { [flatArrayKey]: v };
+		});
+		return value;
+	}
+	if (value === null || value === "") return nullString;
+	if (value === false) return falseString;
+	if (value === 0) return zeroString;
+	return value;
+};
+/**
+* Converts field values to a format suitable for forms by:
+* - Wrapping arrays of primitives as objects using the flatArrayKey `__FLAT__`
+*   to satisfy RHF's requirement that array fields contain objects
+* - Removing empty strings and null values from objects
+*
+* This conversion is required because React Hook Form does not support arrays with
+* flat values (string, number, boolean, null). Array fields must contain objects.
+* We work around this by wrapping primitive entries: `{ __FLAT__: <value> }`.
+*
+* @example
+* const fields = {
+*   name: 'John',
+*   scores: [0, null, 75, false],
+*   scoresDetailed: [
+*     { score: 1 },
+*     { score: null },
+*     { score: 0 },
+*     { score: false },
+*     { score: '' },
+*   ],
+*   contact: {
+*     email: '',
+*     phone: null,
+*     address: '123 Main St'
+*   }
+* };
+*
+* // Result:
+* {
+*   name: 'John',
+*   scores: [
+*     { __FLAT__: 0 },
+*     { __FLAT__: null },
+*     { __FLAT__: 75 },
+*     { __FLAT__: false }
+*   ],
+*   // Arrays of objects are left as objects; empty/null properties are removed
+*   scoresDetailed: [
+*     { score: 1 },
+*     {}, // null score removed
+*     { score: 0 },
+*     { score: false },
+*     {}, // empty string removed
+*   ],
+*   contact: {
+*     address: '123 Main St'
+*   }
+* }
+*/
+const toFormFormat = (fields) => {
+	const formFormatJson = JSON.stringify(fields, (_, value) => {
+		if (Array.isArray(value)) return toNullishString(value);
+		if (value && typeof value === "object") {
+			if (flatArrayKey in value) return value;
+			return Object.fromEntries(Object.entries(value).filter(([_key, v]) => {
+				return v !== "" && v !== null;
+			}));
+		}
+		return value;
+	});
+	return JSON.parse(formFormatJson);
+};
+/**
+* Converts form state to a format suitable for validation by:
+* - Unwrapping flat array wrappers `{ __FLAT__: <value> }` back to primitives
+* - Converting legacy string markers (__NULL__, __FALSE__, __ZERO__) back to their original values
+* - Removing fields whose converted value is empty string or null
+* - Removing empty arrays
+*
+* @example
+* const formState = {
+*   name: 'John',
+*   scores: [
+*     { __FLAT__: 75 },
+*     { __FLAT__: 0 },
+*     { __FLAT__: null },
+*     { __FLAT__: false }
+*   ],
+*   emptyArray: [],
+*   scoresDetailed: [
+*     { score: 1 },
+*     {},
+*     { score: 0 },
+*     { score: false },
+*     {},
+*   ],
+*   contact: {
+*     address: '123 Main St',
+*     fax: null
+*   }
+* };
+*
+* // Result:
+* {
+*   name: 'John',
+*   scores: [75, 0, null, false],
+*   // emptyArray is removed
+*   // Objects inside arrays remain objects; empty entries remain empty objects
+*   scoresDetailed: [
+*     { score: 1 },
+*     {},
+*     { score: 0 },
+*     { score: false },
+*     {},
+*   ],
+*   contact: {
+*     address: '123 Main St'
+*   }
+* }
+*/
+const toValidationFormat = (formState) => {
+	if (formState === void 0 || formState === null) return formState;
+	const validationFormatJson = JSON.stringify(formState, (_, value) => {
+		if (Array.isArray(value)) return value.map((v) => {
+			if (v && typeof v === "object") {
+				const record = v;
+				if (flatArrayKey in record) {
+					const inner = record[flatArrayKey];
+					if (inner === "") return null;
+					return fromNullishString(inner);
+				}
+			}
+			return fromNullishString(v);
+		});
+		if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).filter(([_key, v]) => {
+			if (v && typeof v === "object") {
+				const record = v;
+				if (flatArrayKey in record) {
+					const convertedInner = fromNullishString(record[flatArrayKey]);
+					return convertedInner !== "" && convertedInner !== null;
+				}
+			}
+			if (Array.isArray(v) && v.length === 0) return false;
+			const converted = fromNullishString(v);
+			return converted !== "" && converted !== null;
+		}).map(([k, v]) => {
+			if (v && typeof v === "object") {
+				const record = v;
+				if (flatArrayKey in record) return [k, fromNullishString(record[flatArrayKey])];
+			}
+			return [k, fromNullishString(v)];
+		}));
+		return value;
+	});
+	return JSON.parse(validationFormatJson);
+};
+/**
+* Converts a field name to a testId by removing flat array key segments and slugifying.
+* Removes all occurrences of `flatArrayKey` from the field name and applies slugify transformation.
+*
+* This is used to generate stable testIds for form fields that don't include
+* the internal `__FLAT__` marker used for flat arrays.
+*
+* @param name - The field name as a string (e.g., 'tags.0.__FLAT__') or array path (e.g., ['tags', '0', '__FLAT__'])
+* @returns The slugified field name with all flat array key segments removed (e.g., 'tags_0')
+*
+* @example
+* ```ts
+* nameToTestId('tags.0.__FLAT__') // => 'tags_0'
+* nameToTestId('array.0.__FLAT__') // => 'array_0'
+* nameToTestId('nested.array.0.__FLAT__.field') // => 'nested_array_0_field'
+* nameToTestId('simple.field') // => 'simple_field'
+* nameToTestId(['tags', '0', '__FLAT__']) // => 'tags_0'
+* ```
+*/
+const nameToTestId = (name) => {
+	let cleanName;
+	if (Array.isArray(name)) cleanName = name.filter((segment) => {
+		return segment !== flatArrayKey;
+	}).join(".");
+	else cleanName = name.split(".").filter((segment) => {
+		return segment !== flatArrayKey;
+	}).join(".");
+	return (0, __fuf_stack_pixel_utils.slugify)(cleanName, { replaceDots: true });
+};
+
+//#endregion
+Object.defineProperty(exports, 'flatArrayKey', {
+  enumerable: true,
+  get: function () {
+    return flatArrayKey;
+  }
+});
+Object.defineProperty(exports, 'fromNullishString', {
+  enumerable: true,
+  get: function () {
+    return fromNullishString;
+  }
+});
+Object.defineProperty(exports, 'nameToTestId', {
+  enumerable: true,
+  get: function () {
+    return nameToTestId;
+  }
+});
+Object.defineProperty(exports, 'toFormFormat', {
+  enumerable: true,
+  get: function () {
+    return toFormFormat;
+  }
+});
+Object.defineProperty(exports, 'toNullishString', {
+  enumerable: true,
+  get: function () {
+    return toNullishString;
+  }
+});
+Object.defineProperty(exports, 'toValidationFormat', {
+  enumerable: true,
+  get: function () {
+    return toValidationFormat;
+  }
+});
+//# sourceMappingURL=helpers-KTgXi0lA.cjs.map