@povio/ui 3.4.0-rc.9 → 4.0.0-rc.2

package/dist/FileUploadContainer-CkBENy6n.d.ts

@@ -0,0 +1,5 @@
+import { i as FileUploadContainerProps } from "./fileUpload.types-xFzuCT_m.js";
+//#region src/components/inputs/File/FileUploadContainer.d.ts
+declare const FileUploadContainer: import("react").MemoExoticComponent<(props: FileUploadContainerProps) => import("react").JSX.Element>;
+//#endregion
+export { FileUploadContainer as t };

package/dist/FocusScope-CNjWJz3s.js

@@ -0,0 +1,343 @@
+import { a as $d447af545b77c9f1$export$b204af158042fbac, n as $23f2114a1b82827e$export$4282f70798064fe0, o as $d447af545b77c9f1$export$f21a1ffae260145a, r as $23f2114a1b82827e$export$cd4e5573fbe2b576 } from "./useLayoutEffect-DN7Dbrb9.js";
+import { f as $3b8b240c1bf84ab9$export$4c063cf1350e6fed, p as $3b8b240c1bf84ab9$export$bebd5a1431fec25d, t as $f192c2f16961cbe0$export$80f3e147d781571c } from "./focusSafely-BDIcvqPb.js";
+import "react";
+import { shadowDOM } from "react-stately/private/flags/flags";
+//#region ../../node_modules/.bun/react-aria@3.51.0+67f6792bdf102c28/node_modules/react-aria/dist/private/utils/shadowdom/ShadowTreeWalker.mjs
+var $654b97e09f2a30c1$export$63eb3ababa9c55c4 = class {
+	constructor(doc, root, whatToShow, filter) {
+		this._walkerStack = [];
+		this._currentSetFor = /* @__PURE__ */ new Set();
+		this._acceptNode = (node) => {
+			if (node.nodeType === Node.ELEMENT_NODE) {
+				const shadowRoot = node.shadowRoot;
+				if (shadowRoot) {
+					const walker = this._doc.createTreeWalker(shadowRoot, this.whatToShow, { acceptNode: this._acceptNode });
+					this._walkerStack.unshift(walker);
+					return NodeFilter.FILTER_ACCEPT;
+				} else if (typeof this.filter === "function") return this.filter(node);
+				else if (this.filter?.acceptNode) return this.filter.acceptNode(node);
+				else if (this.filter === null) return NodeFilter.FILTER_ACCEPT;
+			}
+			return NodeFilter.FILTER_SKIP;
+		};
+		this._doc = doc;
+		this.root = root;
+		this.filter = filter ?? null;
+		this.whatToShow = whatToShow ?? NodeFilter.SHOW_ALL;
+		this._currentNode = root;
+		this._walkerStack.unshift(doc.createTreeWalker(root, whatToShow, this._acceptNode));
+		const shadowRoot = root.shadowRoot;
+		if (shadowRoot) {
+			const walker = this._doc.createTreeWalker(shadowRoot, this.whatToShow, { acceptNode: this._acceptNode });
+			this._walkerStack.unshift(walker);
+		}
+	}
+	get currentNode() {
+		return this._currentNode;
+	}
+	set currentNode(node) {
+		if (!$23f2114a1b82827e$export$4282f70798064fe0(this.root, node)) throw new Error("Cannot set currentNode to a node that is not contained by the root node.");
+		const walkers = [];
+		let curNode = node;
+		let currentWalkerCurrentNode = node;
+		this._currentNode = node;
+		while (curNode && curNode !== this.root) if (curNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+			const shadowRoot = curNode;
+			const walker = this._doc.createTreeWalker(shadowRoot, this.whatToShow, { acceptNode: this._acceptNode });
+			walkers.push(walker);
+			walker.currentNode = currentWalkerCurrentNode;
+			this._currentSetFor.add(walker);
+			curNode = currentWalkerCurrentNode = shadowRoot.host;
+		} else curNode = curNode.parentNode;
+		const walker = this._doc.createTreeWalker(this.root, this.whatToShow, { acceptNode: this._acceptNode });
+		walkers.push(walker);
+		walker.currentNode = currentWalkerCurrentNode;
+		this._currentSetFor.add(walker);
+		this._walkerStack = walkers;
+	}
+	get doc() {
+		return this._doc;
+	}
+	firstChild() {
+		let currentNode = this.currentNode;
+		let newNode = this.nextNode();
+		if (!$23f2114a1b82827e$export$4282f70798064fe0(currentNode, newNode)) {
+			this.currentNode = currentNode;
+			return null;
+		}
+		if (newNode) this.currentNode = newNode;
+		return newNode;
+	}
+	lastChild() {
+		let newNode = this._walkerStack[0].lastChild();
+		if (newNode) this.currentNode = newNode;
+		return newNode;
+	}
+	nextNode() {
+		const nextNode = this._walkerStack[0].nextNode();
+		if (nextNode) {
+			if (nextNode.shadowRoot) {
+				let nodeResult;
+				if (typeof this.filter === "function") nodeResult = this.filter(nextNode);
+				else if (this.filter?.acceptNode) nodeResult = this.filter.acceptNode(nextNode);
+				if (nodeResult === NodeFilter.FILTER_ACCEPT) {
+					this.currentNode = nextNode;
+					return nextNode;
+				}
+				let newNode = this.nextNode();
+				if (newNode) this.currentNode = newNode;
+				return newNode;
+			}
+			if (nextNode) this.currentNode = nextNode;
+			return nextNode;
+		} else if (this._walkerStack.length > 1) {
+			this._walkerStack.shift();
+			let newNode = this.nextNode();
+			if (newNode) this.currentNode = newNode;
+			return newNode;
+		} else return null;
+	}
+	previousNode() {
+		const currentWalker = this._walkerStack[0];
+		if (currentWalker.currentNode === currentWalker.root) {
+			if (this._currentSetFor.has(currentWalker)) {
+				this._currentSetFor.delete(currentWalker);
+				if (this._walkerStack.length > 1) {
+					this._walkerStack.shift();
+					let newNode = this.previousNode();
+					if (newNode) this.currentNode = newNode;
+					return newNode;
+				} else return null;
+			}
+			return null;
+		}
+		const previousNode = currentWalker.previousNode();
+		if (previousNode) {
+			if (previousNode.shadowRoot) {
+				let nodeResult;
+				if (typeof this.filter === "function") nodeResult = this.filter(previousNode);
+				else if (this.filter?.acceptNode) nodeResult = this.filter.acceptNode(previousNode);
+				if (nodeResult === NodeFilter.FILTER_ACCEPT) {
+					if (previousNode) this.currentNode = previousNode;
+					return previousNode;
+				}
+				let newNode = this.lastChild();
+				if (newNode) this.currentNode = newNode;
+				return newNode;
+			}
+			if (previousNode) this.currentNode = previousNode;
+			return previousNode;
+		} else if (this._walkerStack.length > 1) {
+			this._walkerStack.shift();
+			let newNode = this.previousNode();
+			if (newNode) this.currentNode = newNode;
+			return newNode;
+		} else return null;
+	}
+	/**
+	* @deprecated
+	*/ nextSibling() {
+		return null;
+	}
+	/**
+	* @deprecated
+	*/ previousSibling() {
+		return null;
+	}
+	/**
+	* @deprecated
+	*/ parentNode() {
+		return null;
+	}
+};
+function $654b97e09f2a30c1$export$4d0f8be8b12a7ef6(doc, root, whatToShow, filter) {
+	if (shadowDOM()) return new $654b97e09f2a30c1$export$63eb3ababa9c55c4(doc, root, whatToShow, filter);
+	return doc.createTreeWalker(root, whatToShow, filter);
+}
+//#endregion
+//#region ../../node_modules/.bun/react-aria@3.51.0+67f6792bdf102c28/node_modules/react-aria/dist/private/focus/FocusScope.mjs
+function $535772f9d2c1f38d$var$getRadiosInGroup(element) {
+	if (!element.form) return Array.from($d447af545b77c9f1$export$b204af158042fbac(element).querySelectorAll(`input[type="radio"][name="${CSS.escape(element.name)}"]`)).filter((radio) => !radio.form);
+	const radioList = element.form.elements.namedItem(element.name);
+	let ownerWindow = $d447af545b77c9f1$export$f21a1ffae260145a(element);
+	if (radioList instanceof ownerWindow.RadioNodeList) return Array.from(radioList).filter((el) => el instanceof ownerWindow.HTMLInputElement);
+	if (radioList instanceof ownerWindow.HTMLInputElement) return [radioList];
+	return [];
+}
+function $535772f9d2c1f38d$var$isTabbableRadio(element) {
+	if (element.checked) return true;
+	const radios = $535772f9d2c1f38d$var$getRadiosInGroup(element);
+	return radios.length > 0 && !radios.some((radio) => radio.checked);
+}
+function $535772f9d2c1f38d$var$isElementInScope(element, scope) {
+	if (!element) return false;
+	if (!scope) return false;
+	return scope.some((node) => $23f2114a1b82827e$export$4282f70798064fe0(node, element));
+}
+function $535772f9d2c1f38d$var$focusElement(element, scroll = false) {
+	if (element != null && !scroll) try {
+		$f192c2f16961cbe0$export$80f3e147d781571c(element);
+	} catch {}
+	else if (element != null) try {
+		element.focus();
+	} catch {}
+}
+function $535772f9d2c1f38d$export$2d6ec8fc375ceafa(root, opts, scope) {
+	let filter = opts?.tabbable ? $3b8b240c1bf84ab9$export$bebd5a1431fec25d : $3b8b240c1bf84ab9$export$4c063cf1350e6fed;
+	let rootElement = root?.nodeType === Node.ELEMENT_NODE ? root : null;
+	let doc = $d447af545b77c9f1$export$b204af158042fbac(rootElement);
+	let walker = $654b97e09f2a30c1$export$4d0f8be8b12a7ef6(doc, root || doc, NodeFilter.SHOW_ELEMENT, { acceptNode(node) {
+		if ($23f2114a1b82827e$export$4282f70798064fe0(opts?.from, node)) return NodeFilter.FILTER_REJECT;
+		if (opts?.tabbable && node.tagName === "INPUT" && node.getAttribute("type") === "radio") {
+			if (!$535772f9d2c1f38d$var$isTabbableRadio(node)) return NodeFilter.FILTER_REJECT;
+			if (walker.currentNode.tagName === "INPUT" && walker.currentNode.type === "radio" && walker.currentNode.name === node.name) return NodeFilter.FILTER_REJECT;
+		}
+		if (filter(node) && (!scope || $535772f9d2c1f38d$var$isElementInScope(node, scope)) && (!opts?.accept || opts.accept(node))) return NodeFilter.FILTER_ACCEPT;
+		return NodeFilter.FILTER_SKIP;
+	} });
+	if (opts?.from) walker.currentNode = opts.from;
+	return walker;
+}
+function $535772f9d2c1f38d$export$c5251b9e124bf29(ref, defaultOptions = {}) {
+	return {
+		focusNext(opts = {}) {
+			let root = ref.current;
+			if (!root) return null;
+			let { from, tabbable = defaultOptions.tabbable, wrap = defaultOptions.wrap, accept = defaultOptions.accept } = opts;
+			let node = from || $23f2114a1b82827e$export$cd4e5573fbe2b576($d447af545b77c9f1$export$b204af158042fbac(root));
+			let walker = $535772f9d2c1f38d$export$2d6ec8fc375ceafa(root, {
+				tabbable,
+				accept
+			});
+			if ($23f2114a1b82827e$export$4282f70798064fe0(root, node)) walker.currentNode = node;
+			let nextNode = walker.nextNode();
+			if (!nextNode && wrap) {
+				walker.currentNode = root;
+				nextNode = walker.nextNode();
+			}
+			if (nextNode) $535772f9d2c1f38d$var$focusElement(nextNode, true);
+			return nextNode;
+		},
+		focusPrevious(opts = defaultOptions) {
+			let root = ref.current;
+			if (!root) return null;
+			let { from, tabbable = defaultOptions.tabbable, wrap = defaultOptions.wrap, accept = defaultOptions.accept } = opts;
+			let node = from || $23f2114a1b82827e$export$cd4e5573fbe2b576($d447af545b77c9f1$export$b204af158042fbac(root));
+			let walker = $535772f9d2c1f38d$export$2d6ec8fc375ceafa(root, {
+				tabbable,
+				accept
+			});
+			if ($23f2114a1b82827e$export$4282f70798064fe0(root, node)) walker.currentNode = node;
+			else {
+				let next = $535772f9d2c1f38d$var$last(walker);
+				if (next) $535772f9d2c1f38d$var$focusElement(next, true);
+				return next ?? null;
+			}
+			let previousNode = walker.previousNode();
+			if (!previousNode && wrap) {
+				walker.currentNode = root;
+				let lastNode = $535772f9d2c1f38d$var$last(walker);
+				if (!lastNode) return null;
+				previousNode = lastNode;
+			}
+			if (previousNode) $535772f9d2c1f38d$var$focusElement(previousNode, true);
+			return previousNode ?? null;
+		},
+		focusFirst(opts = defaultOptions) {
+			let root = ref.current;
+			if (!root) return null;
+			let { tabbable = defaultOptions.tabbable, accept = defaultOptions.accept } = opts;
+			let nextNode = $535772f9d2c1f38d$export$2d6ec8fc375ceafa(root, {
+				tabbable,
+				accept
+			}).nextNode();
+			if (nextNode) $535772f9d2c1f38d$var$focusElement(nextNode, true);
+			return nextNode;
+		},
+		focusLast(opts = defaultOptions) {
+			let root = ref.current;
+			if (!root) return null;
+			let { tabbable = defaultOptions.tabbable, accept = defaultOptions.accept } = opts;
+			let next = $535772f9d2c1f38d$var$last($535772f9d2c1f38d$export$2d6ec8fc375ceafa(root, {
+				tabbable,
+				accept
+			}));
+			if (next) $535772f9d2c1f38d$var$focusElement(next, true);
+			return next ?? null;
+		}
+	};
+}
+function $535772f9d2c1f38d$var$last(walker) {
+	let next = void 0;
+	let last;
+	do {
+		last = walker.lastChild();
+		if (last) next = last;
+	} while (last);
+	return next;
+}
+var $535772f9d2c1f38d$var$Tree = class $535772f9d2c1f38d$var$Tree {
+	constructor() {
+		this.fastMap = /* @__PURE__ */ new Map();
+		this.root = new $535772f9d2c1f38d$var$TreeNode({ scopeRef: null });
+		this.fastMap.set(null, this.root);
+	}
+	get size() {
+		return this.fastMap.size;
+	}
+	getTreeNode(data) {
+		return this.fastMap.get(data);
+	}
+	addTreeNode(scopeRef, parent, nodeToRestore) {
+		let parentNode = this.fastMap.get(parent ?? null);
+		if (!parentNode) return;
+		let node = new $535772f9d2c1f38d$var$TreeNode({ scopeRef });
+		parentNode.addChild(node);
+		node.parent = parentNode;
+		this.fastMap.set(scopeRef, node);
+		if (nodeToRestore) node.nodeToRestore = nodeToRestore;
+	}
+	addNode(node) {
+		this.fastMap.set(node.scopeRef, node);
+	}
+	removeTreeNode(scopeRef) {
+		if (scopeRef === null) return;
+		let node = this.fastMap.get(scopeRef);
+		if (!node) return;
+		let parentNode = node.parent;
+		for (let current of this.traverse()) if (current !== node && node.nodeToRestore && current.nodeToRestore && node.scopeRef && node.scopeRef.current && $535772f9d2c1f38d$var$isElementInScope(current.nodeToRestore, node.scopeRef.current)) current.nodeToRestore = node.nodeToRestore;
+		let children = node.children;
+		if (parentNode) {
+			parentNode.removeChild(node);
+			if (children.size > 0) children.forEach((child) => parentNode && parentNode.addChild(child));
+		}
+		this.fastMap.delete(node.scopeRef);
+	}
+	*traverse(node = this.root) {
+		if (node.scopeRef != null) yield node;
+		if (node.children.size > 0) for (let child of node.children) yield* this.traverse(child);
+	}
+	clone() {
+		let newTree = new $535772f9d2c1f38d$var$Tree();
+		for (let node of this.traverse()) newTree.addTreeNode(node.scopeRef, node.parent?.scopeRef ?? null, node.nodeToRestore);
+		return newTree;
+	}
+};
+var $535772f9d2c1f38d$var$TreeNode = class {
+	constructor(props) {
+		this.children = /* @__PURE__ */ new Set();
+		this.contain = false;
+		this.scopeRef = props.scopeRef;
+	}
+	addChild(node) {
+		this.children.add(node);
+		node.parent = this;
+	}
+	removeChild(node) {
+		this.children.delete(node);
+		node.parent = void 0;
+	}
+};
+new $535772f9d2c1f38d$var$Tree();
+//#endregion
+export { $535772f9d2c1f38d$export$c5251b9e124bf29 as n, $535772f9d2c1f38d$export$2d6ec8fc375ceafa as t };

package/dist/Form-Bam3kea-.js

@@ -0,0 +1,10 @@
+import { createContext } from "react";
+import "react-aria/filterDOMProps";
+import "react-stately/private/form/useFormValidationState";
+//#region ../../node_modules/.bun/react-aria-components@1.20.0+67f6792bdf102c28/node_modules/react-aria-components/dist/private/FieldError.mjs
+const $1f3c3b1a70cec653$export$ff05c3ac10437e03 = /*#__PURE__*/ createContext(null);
+//#endregion
+//#region ../../node_modules/.bun/react-aria-components@1.20.0+67f6792bdf102c28/node_modules/react-aria-components/dist/private/Form.mjs
+const $cdaed739b1139372$export$c24727297075ec6a = /*#__PURE__*/ createContext(null);
+//#endregion
+export { $1f3c3b1a70cec653$export$ff05c3ac10437e03 as n, $cdaed739b1139372$export$c24727297075ec6a as t };

package/dist/Form-NZGvsbuM.d.ts

@@ -0,0 +1,49 @@
+import { c as UIForm, l as UseFormProps, o as FormSubmitErrorHandler, s as FormSubmitHandler } from "./form.binding-DVJ5F0JE.js";
+import { c as InputComponentProps, i as DefaultComponentType, r as AllowedComponentType, u as InputDefBaseProps } from "./dynamicInputs-uIhp1Ly-.js";
+import { DependencyList, ReactNode } from "react";
+import { z } from "zod";
+//#region src/hooks/useAutosave.d.ts
+interface UseAutosaveProps<TFieldValues extends Record<string, unknown>, TTransformedValues = TFieldValues, TResponse = unknown> {
+  form: UIForm<TFieldValues>;
+  delay?: number;
+  enabled?: boolean;
+  trigger?: "change" | "blur";
+  onSave: (data: Partial<TTransformedValues>) => Promise<TResponse>;
+  onSaveSuccess?: () => void;
+}
+declare function useAutosave<TFieldValues extends Record<string, unknown>, TTransformedValues = TFieldValues, TResponse = unknown>({ form, delay, enabled, trigger, onSave, onSaveSuccess }: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>): void;
+//#endregion
+//#region src/hooks/useFormAutosave.d.ts
+type UseFormAutosaveProps<TFieldValues extends Record<string, unknown> = Record<string, unknown>, _TContext = any, TTransformedValues = TFieldValues, TResponse = unknown> = Omit<UseFormProps<TFieldValues, TTransformedValues>, "defaultValues"> & {
+  autosaveDelay?: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>["delay"];
+  enableAutosave?: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>["enabled"];
+  autosaveOn?: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>["trigger"];
+  normalizeAutosaveData?: (data: Partial<TTransformedValues>) => Partial<TTransformedValues> | undefined;
+  onAutosave: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>["onSave"];
+  getResetValues: () => UseFormProps<TFieldValues, TTransformedValues>["defaultValues"];
+  resetDeps: DependencyList;
+  resetTimeout?: number;
+};
+declare function useFormAutosave<TFieldValues extends Record<string, unknown> = Record<string, unknown>, TContext = any, TTransformedValues = TFieldValues, TResponse = any>({ autosaveDelay, enableAutosave, autosaveOn, normalizeAutosaveData, onAutosave, getResetValues, resetDeps, resetTimeout, ...props }: UseFormAutosaveProps<TFieldValues, TContext, TTransformedValues, TResponse>): UIForm<TFieldValues>;
+//#endregion
+//#region src/components/inputs/Inputs/Form.d.ts
+type Capitalize<T extends string> = T extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${Rest}` : T;
+type FieldProps<TProps = {}> = {
+  label: string;
+  placeholder?: string;
+} & TProps;
+type FieldComponentProps<TSchema extends z.ZodObject<any>, K extends keyof z.infer<TSchema>, T extends AllowedComponentType<TSchema["shape"][K]> | undefined = undefined> = FieldProps<InputDefBaseProps<InputComponentProps<T extends AllowedComponentType<TSchema["shape"][K]> ? T : DefaultComponentType<TSchema["shape"][K]>>>> & {
+  inputType?: T extends AllowedComponentType<TSchema["shape"][K]> ? T : never;
+};
+type FieldComponents<TSchema extends z.ZodObject<any>> = { [K in keyof Required<z.infer<TSchema>> as Capitalize<K & string>]: <T extends AllowedComponentType<TSchema["shape"][K]> | undefined = undefined>(props: FieldComponentProps<TSchema, K, T>) => ReactNode; };
+interface FormProps<TSchema extends z.ZodObject<any>, TSchemaType extends Record<string, any> = z.infer<TSchema>> {
+  form: UIForm<TSchemaType>;
+  schema: TSchema;
+  onSubmit: FormSubmitHandler<TSchemaType>;
+  onError?: FormSubmitErrorHandler<TSchemaType>;
+  className?: string;
+  children: (components: FieldComponents<TSchema>) => ReactNode;
+}
+declare function Form<TSchema extends z.ZodObject<any>>({ form, schema, onSubmit, onError, className, children }: FormProps<TSchema>): import("react").JSX.Element;
+//#endregion
+export { useAutosave as i, UseFormAutosaveProps as n, useFormAutosave as r, Form as t };

package/dist/FormField-BHPdCLEV.js

@@ -0,0 +1,211 @@
+import { t as clsx } from "./clsx-CnD0nOiA.js";
+import { n as $43a3b93638fe5db9$export$b04be29aa201d4f5 } from "./Label-C6BonuOp.js";
+import { t as UIOverrides } from "./uiOverrides.context-Bfm2n-n8.js";
+import { t as typographyDefinition } from "./typography.cva-BI0FyIqm.js";
+import { t as Typography } from "./Typography-AcUd9df8.js";
+import { t as compoundMapper } from "./compoundMapper-Di3SKZnS.js";
+import { t as FormFieldError } from "./FormFieldError-CFg0Wn3i.js";
+import { Suspense, lazy } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/inputs/FormField/formFieldHeader.cva.ts
+const formFieldHeaderDefinition = UIOverrides.defineConfig({
+	base: [""],
+	config: {
+		variants: { visible: {
+			true: "mb-1",
+			false: "sr-only"
+		} },
+		defaultVariants: { visible: true }
+	}
+});
+//#endregion
+//#region src/components/inputs/shared/label.cva.ts
+const labelDefinition = UIOverrides.defineConfig({
+	base: [""],
+	config: {
+		variants: { as: {
+			default: ["flex items-start gap-1 text-text-default-1 input-disabled:text-text-default-3"],
+			filter: ["text-text-default-1 input-disabled:text-text-default-3"],
+			inline: ["flex items-start gap-1 text-text-default-1"],
+			floating: [
+				"pointer-events-none",
+				"absolute transition-all duration-75",
+				"top-1/2 -translate-y-1/2",
+				"text-text-default-3",
+				"input-disabled:text-interactive-text-secondary-disabled!",
+				"input-filled:top-[calc(var(--spacing-floating-label-input-height-filled)+var(--spacing-floating-label-input-offset-top))]",
+				"input-filled:translate-y-0",
+				"input-filled:text-text-default-1",
+				"input-filled:font-semibold!",
+				"input-filled:text-label-3!",
+				"group-data-[text-area]/text-area:top-floating-label-input-height-empty group-data-[text-area]/text-area:translate-y-0",
+				"group-has-[textarea:not(:placeholder-shown)]/text-area:hidden",
+				"group-data-[text-editor]/text-editor:top-floating-label-input-height-empty group-data-[text-editor]/text-editor:left-input-side-default group-data-[text-editor]/text-editor:translate-y-0",
+				"group-data-[is-filled=true]/text-editor:hidden"
+			]
+		} },
+		defaultVariants: { as: "default" }
+	}
+});
+const labelTypography = compoundMapper({
+	compoundVariants: [
+		{
+			as: "default",
+			value: {
+				size: "label-2",
+				sizeMobile: "label-2",
+				variant: "prominent-1"
+			}
+		},
+		{
+			as: "filter",
+			value: {
+				size: "label-1",
+				sizeMobile: "label-1",
+				variant: "default"
+			}
+		},
+		{
+			as: "inline",
+			value: {
+				size: "label-2",
+				sizeMobile: "label-2",
+				variant: "prominent-1"
+			}
+		},
+		{
+			as: "floating",
+			value: {
+				size: "label-1",
+				sizeMobile: "label-1",
+				variant: "default"
+			}
+		}
+	],
+	default: {
+		size: "label-2",
+		sizeMobile: "label-2",
+		variant: "prominent-1"
+	},
+	defaultVariants: { as: "default" }
+});
+//#endregion
+//#region src/components/inputs/FormField/FormFieldLabel.tsx
+const FormFieldLabel = ({ ref, as, label, isRequired, isDisabled, labelProps, className }) => {
+	const typographyCva = UIOverrides.useCva("typography.cva", typographyDefinition);
+	const labelTypographyMap = UIOverrides.useMapper("label.typography", labelTypography);
+	const labelBaseCva = UIOverrides.useCva("label.cva", labelDefinition);
+	return /* @__PURE__ */ jsxs($43a3b93638fe5db9$export$b04be29aa201d4f5, {
+		...labelProps,
+		ref,
+		className: clsx(typographyCva({
+			size: "label-2",
+			sizeMobile: "label-2",
+			variant: "prominent-1",
+			...labelTypographyMap({ as })
+		}), labelBaseCva({ as }), className, labelProps?.className),
+		children: [label, isRequired && /* @__PURE__ */ jsx("span", {
+			className: clsx(!isDisabled && "text-text-error-1"),
+			children: "*"
+		})]
+	});
+};
+//#endregion
+//#region src/components/inputs/FormField/FormFieldHeader.tsx
+const FormFieldHeaderTooltip = lazy(() => import("./FormFieldHeaderTooltip-b-kY0DgB.js"));
+const FormFieldHeader = ({ label, tooltipText, helperText, isRequired, rightContent, isHeaderHidden, isDisabled, className, labelProps }) => {
+	const formFieldHeaderCva = UIOverrides.useCva("formField.headerCva", formFieldHeaderDefinition);
+	return /* @__PURE__ */ jsxs("div", {
+		className: clsx(formFieldHeaderCva({ visible: !isHeaderHidden }), className),
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "flex items-start justify-between",
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: "flex items-start gap-1",
+				children: [/* @__PURE__ */ jsx(FormFieldLabel, {
+					label,
+					isRequired,
+					isDisabled,
+					labelProps
+				}), tooltipText ? /* @__PURE__ */ jsx(Suspense, {
+					fallback: /* @__PURE__ */ jsx("span", { className: "size-6" }),
+					children: /* @__PURE__ */ jsx(FormFieldHeaderTooltip, {
+						text: tooltipText,
+						isDisabled
+					})
+				}) : null]
+			}), rightContent]
+		}), helperText && /* @__PURE__ */ jsx(Typography, {
+			slot: "description",
+			size: "label-2",
+			className: "text-text-default-2",
+			children: helperText
+		})]
+	});
+};
+//#endregion
+//#region src/components/inputs/FormField/formFieldHelper.cva.ts
+const formFieldHelperDefinition = UIOverrides.defineConfig({
+	base: ["text-label-3 text-text-default-2"],
+	config: {
+		variants: { visible: {
+			true: "mt-1-5",
+			false: "sr-only"
+		} },
+		defaultVariants: { visible: false }
+	}
+});
+//#endregion
+//#region src/components/inputs/FormField/FormFieldHelper.tsx
+const FormFieldHelper = ({ id, helperText, isDisabled, isHidden, hasError, className }) => {
+	const formFieldHelperCva = UIOverrides.useCva("formField.helperLabelCva", formFieldHelperDefinition);
+	return /* @__PURE__ */ jsx("p", {
+		id,
+		className: clsx(formFieldHelperCva({ visible: !!helperText && !isDisabled && !isHidden && !hasError }), className),
+		slot: "description",
+		children: helperText
+	});
+};
+//#endregion
+//#region src/components/inputs/FormField/FormField.tsx
+const FormField = ({ ref, as, label, tooltipText, helperText, helperTextId, isRequired, rightContent, isDisabled, error, errorMessageId, hideLabel, headerClassName, errorClassName, children, className, labelProps, isHeaderHidden, tabIndex, onMouseEnter, onFocusCapture }) => {
+	const headerProps = {
+		label,
+		tooltipText,
+		helperText,
+		isRequired,
+		rightContent,
+		isHeaderHidden: hideLabel || isHeaderHidden,
+		isDisabled,
+		className: headerClassName,
+		labelProps
+	};
+	const helperProps = {
+		id: helperTextId,
+		helperText,
+		isDisabled,
+		isHidden: !["filter", "floating"].includes(as ?? ""),
+		hasError: !!error
+	};
+	const errorProps = {
+		id: errorMessageId,
+		error,
+		isDisabled,
+		isHidden: ["filter", "inline"].includes(as ?? ""),
+		className: errorClassName
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		ref,
+		className,
+		tabIndex,
+		onMouseEnter,
+		onFocusCapture,
+		children: [
+			!["filter", "floating"].includes(as ?? "") && /* @__PURE__ */ jsx(FormFieldHeader, { ...headerProps }),
+			children,
+			/* @__PURE__ */ jsx(FormFieldHelper, { ...helperProps }),
+			/* @__PURE__ */ jsx(FormFieldError, { ...errorProps })
+		]
+	});
+};
+//#endregion
+export { formFieldHeaderDefinition as a, labelDefinition as i, formFieldHelperDefinition as n, FormFieldLabel as r, FormField as t };

package/dist/FormField-DTDj3F0A.d.ts

@@ -0,0 +1,37 @@
+import { t as FormFieldErrorProps } from "./FormFieldError-BT4uxbKY.js";
+import { n as InputVariantProps } from "./input.cva-ByFuAEIS.js";
+import { FocusEventHandler, LabelHTMLAttributes, MouseEventHandler, PropsWithChildren, ReactNode, Ref } from "react";
+import { DOMAttributes } from "@react-types/shared";
+//#region src/components/inputs/FormField/FormFieldHeader.d.ts
+interface FormFieldHeaderProps {
+  label: string;
+  tooltipText?: string;
+  helperText?: string;
+  isRequired?: boolean;
+  rightContent?: ReactNode;
+  isHeaderHidden?: boolean;
+  isDisabled?: boolean;
+  className?: string;
+  labelProps?: DOMAttributes<HTMLLabelElement> & LabelHTMLAttributes<HTMLLabelElement>;
+}
+//#endregion
+//#region src/components/inputs/FormField/FormField.d.ts
+interface FormFieldProps extends Omit<FormFieldHeaderProps, "className" | "labelProps">, Omit<FormFieldErrorProps, "className"> {
+  errorMessageId?: string;
+  helperTextId?: string;
+  hideLabel?: boolean;
+  headerClassName?: string;
+  errorClassName?: string;
+  className?: string;
+}
+interface FormFieldComponentProps extends PropsWithChildren<FormFieldProps> {
+  ref?: Ref<HTMLDivElement>;
+  labelProps?: FormFieldHeaderProps["labelProps"];
+  as?: InputVariantProps["as"];
+  tabIndex?: number;
+  onMouseEnter?: MouseEventHandler<HTMLDivElement>;
+  onFocusCapture?: FocusEventHandler<HTMLDivElement>;
+}
+declare const FormField: ({ ref, as, label, tooltipText, helperText, helperTextId, isRequired, rightContent, isDisabled, error, errorMessageId, hideLabel, headerClassName, errorClassName, children, className, labelProps, isHeaderHidden, tabIndex, onMouseEnter, onFocusCapture }: FormFieldComponentProps) => import("react").JSX.Element;
+//#endregion
+export { FormFieldProps as n, FormFieldHeaderProps as r, FormField as t };

package/dist/FormFieldError-BT4uxbKY.d.ts

@@ -0,0 +1,10 @@
+//#region src/components/inputs/FormField/FormFieldError.d.ts
+interface FormFieldErrorProps {
+  id?: string;
+  error?: string;
+  isDisabled?: boolean;
+  isHidden?: boolean;
+  className?: string;
+}
+//#endregion
+export { FormFieldErrorProps as t };