@wirekyt/react 0.0.1 → 0.0.2

package/dist/field-x8H5uXB9.cjs

@@ -0,0 +1,438 @@
+const require_rolldown_runtime = require("./rolldown-runtime-DakpK96I.cjs");
+const require_utils = require("./utils-Cfwm9WW1.cjs");
+const require_environment = require("./environment-B6IaCAuQ.cjs");
+require("./core-CBFAnVIP.cjs");
+const require_factory = require("./factory-CFFufs5e.cjs");
+require("./providers-DrJEJcrE.cjs");
+const require_use_context = require("./use-context-38DKWHsx.cjs");
+let react = require("react");
+let _wirekyt_dom = require("@wirekyt/dom");
+let react_jsx_runtime = require("react/jsx-runtime");
+let _wirekyt_dom_dom_query = require("@wirekyt/dom/dom-query");
+let _wirekyt_dom_anatomy = require("@wirekyt/dom/anatomy");
+let _wirekyt_dom_auto_resize = require("@wirekyt/dom/auto-resize");
+//#region src/components/field/use-context.ts
+const [FieldProvider, useFieldContext] = require_utils.createContext({
+	name: "FieldContext",
+	hookName: "useFieldContext",
+	providerName: "<FieldProvider />",
+	strict: false
+});
+//#endregion
+//#region src/components/field/context.tsx
+const FieldContext = (props) => props.children(useFieldContext());
+//#endregion
+//#region src/components/field/error-text.tsx
+const FieldErrorText = (0, react.forwardRef)((props, ref) => {
+	const field = useFieldContext();
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(field.getErrorTextProps(), props);
+	if (field?.invalid) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.span, {
+		...mergedProps,
+		ref
+	});
+	return null;
+});
+FieldErrorText.displayName = "FieldErrorText";
+//#endregion
+//#region src/components/field/helper-text.tsx
+const FieldHelperText = (0, react.forwardRef)((props, ref) => {
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(useFieldContext()?.getHelperTextProps(), props);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.span, {
+		...mergedProps,
+		ref
+	});
+});
+FieldHelperText.displayName = "FieldHelperText";
+//#endregion
+//#region src/components/field/input.tsx
+const FieldInput = (0, react.forwardRef)((props, ref) => {
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(useFieldContext()?.getInputProps(), props);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.input, {
+		...mergedProps,
+		ref
+	});
+});
+FieldInput.displayName = "FieldInput";
+//#endregion
+//#region src/components/field/anatomy.ts
+const fieldAnatomy = (0, _wirekyt_dom_anatomy.createAnatomy)("field").parts("root", "errorText", "helperText", "input", "label", "select", "textarea", "requiredIndicator");
+const parts = fieldAnatomy.build();
+//#endregion
+//#region src/components/field/item.tsx
+const FieldItem = (props) => {
+	const { value, children } = props;
+	const parentField = useFieldContext();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FieldProvider, {
+		value: (0, react.useMemo)(() => {
+			if (!parentField) throw new Error("Field.Item must be used within Field.Root");
+			const controlId = `field::${parentField.ids.control}::item::${value}`;
+			const labelId = `${controlId}::label`;
+			const getControlProps = () => ({
+				...parentField.getInputProps(),
+				id: controlId
+			});
+			return {
+				...parentField,
+				ids: {
+					...parentField.ids,
+					control: controlId,
+					label: labelId
+				},
+				getLabelProps: () => ({
+					...parentField.getLabelProps(),
+					id: labelId,
+					htmlFor: controlId
+				}),
+				getInputProps: () => ({
+					...getControlProps(),
+					...parts.input.attrs
+				}),
+				getSelectProps: () => ({
+					...getControlProps(),
+					...parts.select.attrs
+				}),
+				getTextareaProps: () => ({
+					...getControlProps(),
+					...parts.textarea.attrs
+				})
+			};
+		}, [parentField, value]),
+		children
+	});
+};
+FieldItem.displayName = "FieldItem";
+//#endregion
+//#region src/components/field/label.tsx
+const FieldLabel = (0, react.forwardRef)((props, ref) => {
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(useFieldContext()?.getLabelProps(), props);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.label, {
+		...mergedProps,
+		ref
+	});
+});
+FieldLabel.displayName = "FieldLabel";
+//#endregion
+//#region src/components/field/required-indicator.tsx
+const FieldRequiredIndicator = (0, react.forwardRef)(({ fallback, ...props }, ref) => {
+	const field = useFieldContext();
+	if (!field.required) return fallback;
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(field.getRequiredIndicatorProps(), props);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.span, {
+		...mergedProps,
+		ref,
+		children: props.children ?? "*"
+	});
+});
+FieldRequiredIndicator.displayName = "FieldRequiredIndicator";
+//#endregion
+//#region src/components/field/use.ts
+const useField = (props = {}) => {
+	const fieldset = require_use_context.useFieldsetContext();
+	const env = require_environment.useEnvironmentContext();
+	const { ids, target, disabled = Boolean(fieldset?.disabled), invalid = false, readOnly = false, required = false } = props;
+	const [hasErrorText, setHasErrorText] = (0, react.useState)(false);
+	const [hasHelperText, setHasHelperText] = (0, react.useState)(false);
+	const uid = (0, react.useId)();
+	const id = props.id ?? uid;
+	const rootRef = (0, react.useRef)(null);
+	const rootId = ids?.control ?? `field::${id}`;
+	const errorTextId = ids?.errorText ?? `field::${id}::error-text`;
+	const helperTextId = ids?.helperText ?? `field::${id}::helper-text`;
+	const labelId = ids?.label ?? `field::${id}::label`;
+	require_utils.useSafeLayoutEffect(() => {
+		const rootNode = rootRef.current;
+		if (!rootNode) return;
+		const checkTextElements = () => {
+			const docOrShadowRoot = env.getRootNode();
+			setHasErrorText(!!docOrShadowRoot.getElementById(errorTextId));
+			setHasHelperText(!!docOrShadowRoot.getElementById(helperTextId));
+		};
+		checkTextElements();
+		const observer = new (env.getWindow()).MutationObserver(checkTextElements);
+		observer.observe(rootNode, {
+			childList: true,
+			subtree: true
+		});
+		return () => observer.disconnect();
+	}, [
+		env,
+		errorTextId,
+		helperTextId
+	]);
+	const getRootProps = (0, react.useMemo)(() => () => ({
+		...parts.root.attrs,
+		id: rootId,
+		ref: rootRef,
+		role: "group",
+		"data-disabled": (0, _wirekyt_dom_dom_query.dataAttr)(disabled),
+		"data-invalid": (0, _wirekyt_dom_dom_query.dataAttr)(invalid),
+		"data-readonly": (0, _wirekyt_dom_dom_query.dataAttr)(readOnly)
+	}), [
+		disabled,
+		invalid,
+		readOnly,
+		rootId
+	]);
+	const targetControlId = target ? `field::${id}::item::${target}` : void 0;
+	const getLabelProps = (0, react.useMemo)(() => () => ({
+		...parts.label.attrs,
+		id: labelId,
+		"data-disabled": (0, _wirekyt_dom_dom_query.dataAttr)(disabled),
+		"data-invalid": (0, _wirekyt_dom_dom_query.dataAttr)(invalid),
+		"data-readonly": (0, _wirekyt_dom_dom_query.dataAttr)(readOnly),
+		"data-required": (0, _wirekyt_dom_dom_query.dataAttr)(required),
+		htmlFor: targetControlId ?? id
+	}), [
+		disabled,
+		invalid,
+		readOnly,
+		required,
+		id,
+		labelId,
+		targetControlId
+	]);
+	const errorMessageId = hasErrorText && invalid ? errorTextId : void 0;
+	const getControlProps = (0, react.useMemo)(() => () => ({
+		"aria-describedby": hasHelperText ? helperTextId : void 0,
+		"aria-errormessage": errorMessageId,
+		"aria-invalid": (0, _wirekyt_dom_dom_query.ariaAttr)(invalid),
+		"data-invalid": (0, _wirekyt_dom_dom_query.dataAttr)(invalid),
+		"data-required": (0, _wirekyt_dom_dom_query.dataAttr)(required),
+		"data-readonly": (0, _wirekyt_dom_dom_query.dataAttr)(readOnly),
+		id,
+		required,
+		disabled,
+		readOnly
+	}), [
+		hasHelperText,
+		helperTextId,
+		invalid,
+		required,
+		readOnly,
+		id,
+		errorMessageId,
+		disabled
+	]);
+	const getInputProps = (0, react.useMemo)(() => () => ({
+		...getControlProps(),
+		...parts.input.attrs
+	}), [getControlProps]);
+	const getTextareaProps = (0, react.useMemo)(() => () => ({
+		...getControlProps(),
+		...parts.textarea.attrs
+	}), [getControlProps]);
+	const getSelectProps = (0, react.useMemo)(() => () => ({
+		...getControlProps(),
+		...parts.select.attrs
+	}), [getControlProps]);
+	const getHelperTextProps = (0, react.useMemo)(() => () => ({
+		id: helperTextId,
+		...parts.helperText.attrs,
+		"data-disabled": (0, _wirekyt_dom_dom_query.dataAttr)(disabled)
+	}), [disabled, helperTextId]);
+	const getErrorTextProps = (0, react.useMemo)(() => () => ({
+		id: errorTextId,
+		...parts.errorText.attrs,
+		"aria-live": "polite"
+	}), [errorTextId]);
+	const getRequiredIndicatorProps = (0, react.useMemo)(() => () => ({
+		"aria-hidden": true,
+		...parts.requiredIndicator.attrs
+	}), []);
+	return {
+		ariaDescribedby: hasHelperText ? helperTextId : void 0,
+		ids: {
+			root: rootId,
+			control: id,
+			label: labelId,
+			errorText: errorTextId,
+			helperText: helperTextId
+		},
+		refs: { rootRef },
+		disabled,
+		invalid,
+		readOnly,
+		required,
+		getLabelProps,
+		getRootProps,
+		getInputProps,
+		getTextareaProps,
+		getSelectProps,
+		getHelperTextProps,
+		getErrorTextProps,
+		getRequiredIndicatorProps
+	};
+};
+//#endregion
+//#region src/components/field/root.tsx
+const splitRootProps = require_utils.createSplitProps();
+const FieldRoot = (0, react.forwardRef)((props, ref) => {
+	const [useFieldProps, localProps] = splitRootProps(props, [
+		"id",
+		"ids",
+		"disabled",
+		"invalid",
+		"readOnly",
+		"required",
+		"target"
+	]);
+	const field = useField(useFieldProps);
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(field.getRootProps(), localProps);
+	const composedRefs = require_utils.useComposedRefs(ref, field.refs.rootRef);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FieldProvider, {
+		value: field,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.div, {
+			...mergedProps,
+			ref: composedRefs
+		})
+	});
+});
+FieldRoot.displayName = "FieldRoot";
+//#endregion
+//#region src/components/field/root-provider.tsx
+const splitRootProviderProps = require_utils.createSplitProps();
+const FieldRootProvider = (0, react.forwardRef)((props, ref) => {
+	const [{ value: field }, localProps] = splitRootProviderProps(props, ["value"]);
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(field.getRootProps(), localProps);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FieldProvider, {
+		value: field,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.div, {
+			...mergedProps,
+			ref
+		})
+	});
+});
+FieldRootProvider.displayName = "FieldRootProvider";
+//#endregion
+//#region src/components/field/select.tsx
+const FieldSelect = (0, react.forwardRef)((props, ref) => {
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(useFieldContext()?.getSelectProps(), props);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.select, {
+		...mergedProps,
+		ref
+	});
+});
+FieldSelect.displayName = "FieldSelect";
+//#endregion
+//#region src/components/field/textarea.tsx
+const FieldTextarea = (0, react.forwardRef)((props, ref) => {
+	const { autoresize, ...textareaProps } = props;
+	const textareaRef = (0, react.useRef)(null);
+	const mergedProps = (0, _wirekyt_dom.mergeProps)(useFieldContext()?.getTextareaProps(), { style: { resize: autoresize ? "none" : void 0 } }, textareaProps);
+	const composedRefs = require_utils.useComposedRefs(ref, textareaRef);
+	(0, react.useEffect)(() => {
+		if (!autoresize) return;
+		return (0, _wirekyt_dom_auto_resize.autoresizeTextarea)(textareaRef.current);
+	}, [autoresize]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_factory.wire.textarea, {
+		...mergedProps,
+		ref: composedRefs
+	});
+});
+FieldTextarea.displayName = "FieldTextarea";
+//#endregion
+//#region src/components/field/field.ts
+var field_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	Context: () => FieldContext,
+	ErrorText: () => FieldErrorText,
+	HelperText: () => FieldHelperText,
+	Input: () => FieldInput,
+	Item: () => FieldItem,
+	Label: () => FieldLabel,
+	RequiredIndicator: () => FieldRequiredIndicator,
+	Root: () => FieldRoot,
+	RootProvider: () => FieldRootProvider,
+	Select: () => FieldSelect,
+	Textarea: () => FieldTextarea
+});
+//#endregion
+Object.defineProperty(exports, "FieldContext", {
+	enumerable: true,
+	get: function() {
+		return FieldContext;
+	}
+});
+Object.defineProperty(exports, "FieldErrorText", {
+	enumerable: true,
+	get: function() {
+		return FieldErrorText;
+	}
+});
+Object.defineProperty(exports, "FieldHelperText", {
+	enumerable: true,
+	get: function() {
+		return FieldHelperText;
+	}
+});
+Object.defineProperty(exports, "FieldInput", {
+	enumerable: true,
+	get: function() {
+		return FieldInput;
+	}
+});
+Object.defineProperty(exports, "FieldItem", {
+	enumerable: true,
+	get: function() {
+		return FieldItem;
+	}
+});
+Object.defineProperty(exports, "FieldLabel", {
+	enumerable: true,
+	get: function() {
+		return FieldLabel;
+	}
+});
+Object.defineProperty(exports, "FieldRequiredIndicator", {
+	enumerable: true,
+	get: function() {
+		return FieldRequiredIndicator;
+	}
+});
+Object.defineProperty(exports, "FieldRoot", {
+	enumerable: true,
+	get: function() {
+		return FieldRoot;
+	}
+});
+Object.defineProperty(exports, "FieldRootProvider", {
+	enumerable: true,
+	get: function() {
+		return FieldRootProvider;
+	}
+});
+Object.defineProperty(exports, "FieldSelect", {
+	enumerable: true,
+	get: function() {
+		return FieldSelect;
+	}
+});
+Object.defineProperty(exports, "FieldTextarea", {
+	enumerable: true,
+	get: function() {
+		return FieldTextarea;
+	}
+});
+Object.defineProperty(exports, "fieldAnatomy", {
+	enumerable: true,
+	get: function() {
+		return fieldAnatomy;
+	}
+});
+Object.defineProperty(exports, "field_exports", {
+	enumerable: true,
+	get: function() {
+		return field_exports;
+	}
+});
+Object.defineProperty(exports, "useField", {
+	enumerable: true,
+	get: function() {
+		return useField;
+	}
+});
+Object.defineProperty(exports, "useFieldContext", {
+	enumerable: true,
+	get: function() {
+		return useFieldContext;
+	}
+});

package/dist/field.cjs

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_field = require("./field-x8H5uXB9.cjs");
+Object.defineProperty(exports, "Field", {
+	enumerable: true,
+	get: function() {
+		return require_field.field_exports;
+	}
+});
+exports.FieldContext = require_field.FieldContext;
+exports.FieldErrorText = require_field.FieldErrorText;
+exports.FieldHelperText = require_field.FieldHelperText;
+exports.FieldInput = require_field.FieldInput;
+exports.FieldItem = require_field.FieldItem;
+exports.FieldLabel = require_field.FieldLabel;
+exports.FieldRequiredIndicator = require_field.FieldRequiredIndicator;
+exports.FieldRoot = require_field.FieldRoot;
+exports.FieldRootProvider = require_field.FieldRootProvider;
+exports.FieldSelect = require_field.FieldSelect;
+exports.FieldTextarea = require_field.FieldTextarea;
+exports.fieldAnatomy = require_field.fieldAnatomy;
+exports.useField = require_field.useField;
+exports.useFieldContext = require_field.useFieldContext;

package/dist/field.d.cts

@@ -0,0 +1,129 @@
+import { r as PolymorphicProps, t as HTMLProps } from "./factory--dkoVnFK.cjs";
+import { PropsWithChildren, ReactNode } from "react";
+//#region src/components/field/use.d.ts
+interface ElementIds {
+  root?: string | undefined;
+  control?: string | undefined;
+  label?: string | undefined;
+  errorText?: string | undefined;
+  helperText?: string | undefined;
+}
+interface UseFieldProps {
+  id?: string | undefined;
+  ids?: ElementIds | undefined;
+  required?: boolean | undefined;
+  disabled?: boolean | undefined;
+  invalid?: boolean | undefined;
+  readOnly?: boolean | undefined;
+  target?: string | undefined;
+}
+type UseFieldReturn = ReturnType<typeof useField>;
+declare const useField: (props?: UseFieldProps) => {
+  ariaDescribedby: string | undefined;
+  ids: {
+    root: string;
+    control: string;
+    label: string;
+    errorText: string;
+    helperText: string;
+  };
+  refs: {
+    rootRef: import("react").RefObject<HTMLDivElement | null>;
+  };
+  disabled: boolean;
+  invalid: boolean;
+  readOnly: boolean;
+  required: boolean;
+  getLabelProps: () => HTMLProps<"label">;
+  getRootProps: () => HTMLProps<"div">;
+  getInputProps: () => HTMLProps<"input">;
+  getTextareaProps: () => HTMLProps<"textarea">;
+  getSelectProps: () => HTMLProps<"select">;
+  getHelperTextProps: () => HTMLProps<"span">;
+  getErrorTextProps: () => HTMLProps<"span">;
+  getRequiredIndicatorProps: () => HTMLProps<"span">;
+};
+//#endregion
+//#region src/components/field/use-context.d.ts
+interface UseFieldContext extends UseFieldReturn {}
+declare const FieldProvider: import("react").Provider<UseFieldContext>, useFieldContext: () => UseFieldContext;
+//#endregion
+//#region src/components/field/context.d.ts
+interface FieldContextProps {
+  children: (context: UseFieldContext) => ReactNode;
+}
+declare const FieldContext: (props: FieldContextProps) => ReactNode;
+//#endregion
+//#region src/components/field/error-text.d.ts
+interface FieldErrorTextBaseProps extends PolymorphicProps {}
+interface FieldErrorTextProps extends HTMLProps<"span">, FieldErrorTextBaseProps {}
+declare const FieldErrorText: import("react").ForwardRefExoticComponent<FieldErrorTextProps & import("react").RefAttributes<HTMLSpanElement>>;
+//#endregion
+//#region src/components/field/helper-text.d.ts
+interface FieldHelperTextBaseProps extends PolymorphicProps {}
+interface FieldHelperTextProps extends HTMLProps<"span">, FieldHelperTextBaseProps {}
+declare const FieldHelperText: import("react").ForwardRefExoticComponent<FieldHelperTextProps & import("react").RefAttributes<HTMLSpanElement>>;
+//#endregion
+//#region src/components/field/input.d.ts
+interface FieldInputBaseProps extends PolymorphicProps {}
+interface FieldInputProps extends HTMLProps<"input">, FieldInputBaseProps {}
+declare const FieldInput: import("react").ForwardRefExoticComponent<FieldInputProps & import("react").RefAttributes<HTMLInputElement>>;
+//#endregion
+//#region src/components/field/item.d.ts
+interface FieldItemBaseProps {
+  value: string;
+}
+interface FieldItemProps extends PropsWithChildren<FieldItemBaseProps> {}
+declare const FieldItem: {
+  (props: FieldItemProps): import("react").JSX.Element;
+  displayName: string;
+};
+//#endregion
+//#region src/components/field/label.d.ts
+interface FieldLabelBaseProps extends PolymorphicProps {}
+interface FieldLabelProps extends HTMLProps<"label">, FieldLabelBaseProps {}
+declare const FieldLabel: import("react").ForwardRefExoticComponent<FieldLabelProps & import("react").RefAttributes<HTMLLabelElement>>;
+//#endregion
+//#region src/components/field/required-indicator.d.ts
+interface FieldRequiredIndicatorBaseProps extends PolymorphicProps {
+  fallback?: React.ReactNode | undefined;
+}
+interface FieldRequiredIndicatorProps extends HTMLProps<"span">, FieldRequiredIndicatorBaseProps {}
+declare const FieldRequiredIndicator: import("react").ForwardRefExoticComponent<FieldRequiredIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;
+//#endregion
+//#region src/components/field/root.d.ts
+interface FieldRootBaseProps extends UseFieldProps, PolymorphicProps {}
+interface FieldRootProps extends HTMLProps<"div">, FieldRootBaseProps {}
+declare const FieldRoot: import("react").ForwardRefExoticComponent<FieldRootProps & import("react").RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/field/root-provider.d.ts
+interface RootProviderProps {
+  value: UseFieldReturn;
+}
+interface FieldRootProviderBaseProps extends RootProviderProps, PolymorphicProps {}
+interface FieldRootProviderProps extends HTMLProps<"div">, FieldRootProviderBaseProps {}
+declare const FieldRootProvider: import("react").ForwardRefExoticComponent<FieldRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/field/select.d.ts
+interface FieldSelectBaseProps extends PolymorphicProps {}
+interface FieldSelectProps extends HTMLProps<"select">, FieldSelectBaseProps {}
+declare const FieldSelect: import("react").ForwardRefExoticComponent<FieldSelectProps & import("react").RefAttributes<HTMLSelectElement>>;
+//#endregion
+//#region src/components/field/textarea.d.ts
+interface FieldTextareaBaseProps extends PolymorphicProps {
+  /**
+   * Whether the textarea should autoresize
+   * @default false
+   */
+  autoresize?: boolean | undefined;
+}
+interface FieldTextareaProps extends HTMLProps<"textarea">, FieldTextareaBaseProps {}
+declare const FieldTextarea: import("react").ForwardRefExoticComponent<FieldTextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;
+//#endregion
+//#region src/components/field/anatomy.d.ts
+declare const fieldAnatomy: import("@wirekyt/dom/anatomy").AnatomyInstance<"input" | "label" | "select" | "textarea" | "root" | "errorText" | "helperText" | "requiredIndicator">;
+declare namespace field_d_exports {
+  export { FieldContext as Context, FieldContextProps as ContextProps, FieldErrorText as ErrorText, FieldErrorTextBaseProps as ErrorTextBaseProps, FieldErrorTextProps as ErrorTextProps, FieldHelperText as HelperText, FieldHelperTextBaseProps as HelperTextBaseProps, FieldHelperTextProps as HelperTextProps, FieldInput as Input, FieldInputBaseProps as InputBaseProps, FieldInputProps as InputProps, FieldItem as Item, FieldItemBaseProps as ItemBaseProps, FieldItemProps as ItemProps, FieldLabel as Label, FieldLabelBaseProps as LabelBaseProps, FieldLabelProps as LabelProps, FieldRequiredIndicator as RequiredIndicator, FieldRequiredIndicatorBaseProps as RequiredIndicatorBaseProps, FieldRequiredIndicatorProps as RequiredIndicatorProps, FieldRoot as Root, FieldRootBaseProps as RootBaseProps, FieldRootProps as RootProps, FieldRootProvider as RootProvider, FieldRootProviderBaseProps as RootProviderBaseProps, FieldRootProviderProps as RootProviderProps, FieldSelect as Select, FieldSelectBaseProps as SelectBaseProps, FieldSelectProps as SelectProps, FieldTextarea as Textarea, FieldTextareaBaseProps as TextareaBaseProps, FieldTextareaProps as TextareaProps };
+}
+//#endregion
+export { field_d_exports as Field, FieldContext, type FieldContextProps, FieldErrorText, type FieldErrorTextBaseProps, type FieldErrorTextProps, FieldHelperText, type FieldHelperTextBaseProps, type FieldHelperTextProps, FieldInput, type FieldInputBaseProps, type FieldInputProps, FieldItem, type FieldItemBaseProps, type FieldItemProps, FieldLabel, type FieldLabelBaseProps, type FieldLabelProps, FieldRequiredIndicator, type FieldRequiredIndicatorBaseProps, type FieldRequiredIndicatorProps, FieldRoot, type FieldRootBaseProps, type FieldRootProps, FieldRootProvider, type FieldRootProviderBaseProps, type FieldRootProviderProps, FieldSelect, type FieldSelectBaseProps, type FieldSelectProps, FieldTextarea, type FieldTextareaBaseProps, type FieldTextareaProps, type UseFieldContext, type UseFieldProps, type UseFieldReturn, fieldAnatomy, useField, useFieldContext };