@vantageos/mosaic 0.2.1 → 0.3.0-alpha.1

package/dist/react/forms.cjs

@@ -0,0 +1,1384 @@
+'use strict';
+
+var zod$1 = require('@hookform/resolvers/zod');
+var reactHookForm = require('react-hook-form');
+var zod = require('zod');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/runtimes/react/components/forms/useMosaicForm.tsx
+
+// src/components/forms/useMosaicForm.logic.ts
+function toRhfMode(mode) {
+  return mode;
+}
+var MosaicFormModeSchema = zod.z.enum(["onBlur", "onChange", "onSubmit"]);
+var UseMosaicFormOptionsSchema = zod.z.object({
+  mode: MosaicFormModeSchema.default("onBlur")
+});
+function validateOptions(raw) {
+  return UseMosaicFormOptionsSchema.parse(raw);
+}
+
+// src/runtimes/react/components/forms/useMosaicForm.tsx
+function useMosaicForm(options) {
+  const parsedOptions = validateOptions({ mode: options.mode });
+  const form = reactHookForm.useForm({
+    // biome-ignore lint/suspicious/noExplicitAny: zodResolver's generic shape forces a cast at this boundary
+    resolver: zod$1.zodResolver(options.schema),
+    defaultValues: options.defaultValues,
+    mode: toRhfMode(parsedOptions.mode)
+  });
+  const extended = form;
+  extended.mosaicSchema = options.schema;
+  extended.mosaicMode = parsedOptions.mode;
+  return extended;
+}
+
+// src/components/forms/FormProvider.logic.ts
+var FORM_PROVIDER_CONTEXT_MISSING = "useMosaicFormContext must be used inside <FormProvider>. Wrap your tree with <FormProvider form={...}> from @vantageos/mosaic/{react,preact}/forms.";
+var MosaicFormContext = react.createContext(null);
+function FormProvider({
+  form,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(MosaicFormContext.Provider, { value: form, children: /* @__PURE__ */ jsxRuntime.jsx(reactHookForm.FormProvider, { ...form, children }) });
+}
+function useMosaicFormContext() {
+  const ctx = react.useContext(MosaicFormContext);
+  if (!ctx) {
+    throw new Error(FORM_PROVIDER_CONTEXT_MISSING);
+  }
+  return ctx;
+}
+function FormField({
+  name,
+  children
+}) {
+  const form = useMosaicFormContext();
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactHookForm.Controller,
+    {
+      control: form.control,
+      name,
+      render: ({ field, fieldState, formState }) => children({
+        field,
+        fieldState,
+        formState
+      })
+    }
+  );
+}
+
+// src/components/forms/ErrorDisplay.logic.ts
+function formatErrorMessage(error, messageMap) {
+  if (!error) return void 0;
+  if (error.message && error.message.length > 0) return error.message;
+  const mapped = messageMap?.[error.type];
+  if (mapped && mapped.length > 0) return mapped;
+  return "Invalid value";
+}
+function ErrorDisplay({ error, messageMap, className }) {
+  const message = formatErrorMessage(error, messageMap);
+  if (!message) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { role: "alert", className: className ?? "mosaic-forms-error", children: message });
+}
+
+// src/components/forms/SubmitButton.logic.ts
+function computeSubmitButtonState(input) {
+  return {
+    disabled: input.isSubmitting || !input.isValid,
+    loading: input.isSubmitting
+  };
+}
+var SubmitButtonPropsSchema = zod.z.object({
+  label: zod.z.string().min(1).default("Submit"),
+  loadingLabel: zod.z.string().min(1).default("Submitting\u2026")
+});
+function validateSubmitButtonProps(raw) {
+  return SubmitButtonPropsSchema.parse(raw);
+}
+function SubmitButton(props) {
+  const { label, loadingLabel } = validateSubmitButtonProps({
+    label: props.label,
+    loadingLabel: props.loadingLabel
+  });
+  const form = useMosaicFormContext();
+  const { isValid, isSubmitting } = form.formState;
+  const { disabled, loading } = computeSubmitButtonState({ isValid, isSubmitting });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "submit",
+      disabled,
+      "aria-busy": loading || void 0,
+      className: props.className ?? "mosaic-forms-submit",
+      children: loading ? loadingLabel : label
+    }
+  );
+}
+
+// src/components/forms/Input.logic.ts
+function buildErrorDescribedBy(inputId, hasError) {
+  return hasError ? `${inputId}-error` : void 0;
+}
+function resolveHtmlType(type) {
+  return type ?? "text";
+}
+function Input({
+  name,
+  type,
+  label,
+  placeholder,
+  disabled,
+  autoComplete,
+  id,
+  messageMap,
+  className,
+  inputClassName,
+  errorClassName
+}) {
+  const form = useMosaicFormContext();
+  const reactId = react.useId();
+  const inputId = id ?? `mosaic-input-${reactId.replace(/[^a-zA-Z0-9_-]/g, "")}-${String(name)}`;
+  const htmlType = resolveHtmlType(type);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactHookForm.Controller,
+    {
+      control: form.control,
+      name,
+      render: ({ field, fieldState }) => {
+        const f = field;
+        const hasError = Boolean(fieldState.error);
+        const describedBy = buildErrorDescribedBy(inputId, hasError);
+        const message = formatErrorMessage(
+          fieldState.error ? { type: fieldState.error.type, message: fieldState.error.message } : void 0,
+          messageMap
+        );
+        const value = f.value ?? "";
+        return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: className ?? "mosaic-forms-input", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: inputId, children: label }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              id: inputId,
+              name: f.name,
+              type: htmlType,
+              value,
+              onChange: f.onChange,
+              onBlur: f.onBlur,
+              ref: f.ref,
+              placeholder,
+              disabled: disabled ?? false,
+              autoComplete,
+              "aria-invalid": hasError || void 0,
+              "aria-describedby": describedBy,
+              className: inputClassName
+            }
+          ),
+          hasError && message ? /* @__PURE__ */ jsxRuntime.jsx(
+            "span",
+            {
+              id: `${inputId}-error`,
+              role: "alert",
+              className: errorClassName ?? "mosaic-forms-error",
+              children: message
+            }
+          ) : null
+        ] });
+      }
+    }
+  );
+}
+
+// src/components/forms/Textarea.logic.ts
+var DEFAULT_TEXTAREA_ROWS = 3;
+function clampToMaxLength(value, maxLength) {
+  if (maxLength === void 0) return value;
+  if (value.length <= maxLength) return value;
+  return value.slice(0, maxLength);
+}
+function resolveRows(rows) {
+  if (rows === void 0) return DEFAULT_TEXTAREA_ROWS;
+  if (!Number.isFinite(rows) || rows < 1) return DEFAULT_TEXTAREA_ROWS;
+  return Math.floor(rows);
+}
+function computeAutoResizeHeight(scrollHeight, minHeightPx) {
+  if (!Number.isFinite(scrollHeight) || scrollHeight <= 0) return minHeightPx;
+  return Math.max(scrollHeight, minHeightPx);
+}
+function Textarea(props) {
+  const {
+    name,
+    rows,
+    maxLength,
+    autoResize = false,
+    placeholder,
+    disabled,
+    label,
+    className,
+    errorMessageMap
+  } = props;
+  const effectiveRows = resolveRows(rows);
+  const reactId = react.useId();
+  const fieldId = `mosaic-textarea-${reactId}`;
+  const errorId = `${fieldId}-error`;
+  return /* @__PURE__ */ jsxRuntime.jsx(FormField, { name, children: ({ field, fieldState }) => {
+    const hasError = Boolean(fieldState.error);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      TextareaInner,
+      {
+        id: fieldId,
+        errorId,
+        label,
+        value: field.value ?? "",
+        onChange: (next) => field.onChange(clampToMaxLength(next, maxLength)),
+        onBlur: field.onBlur,
+        rows: effectiveRows,
+        maxLength,
+        autoResize,
+        placeholder,
+        disabled,
+        hasError,
+        className,
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          ErrorDisplay,
+          {
+            error: fieldState.error ? {
+              type: fieldState.error.type ?? "validation",
+              message: fieldState.error.message
+            } : void 0,
+            messageMap: errorMessageMap,
+            className: "mosaic-forms-error"
+          }
+        )
+      }
+    );
+  } });
+}
+function TextareaInner(props) {
+  const {
+    id,
+    errorId,
+    label,
+    value,
+    onChange,
+    onBlur,
+    rows,
+    maxLength,
+    autoResize,
+    placeholder,
+    disabled,
+    hasError,
+    className,
+    children
+  } = props;
+  const ref = react.useRef(null);
+  const resize = react.useCallback(() => {
+    if (!autoResize) return;
+    const el = ref.current;
+    if (!el) return;
+    el.style.height = "auto";
+    const minPx = rows * 20;
+    const next = computeAutoResizeHeight(el.scrollHeight, minPx);
+    el.style.height = `${next}px`;
+  }, [autoResize, rows]);
+  react.useEffect(() => {
+    resize();
+  }, [resize]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: className ?? "mosaic-forms-textarea", children: [
+    label ? /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: id, className: "mosaic-forms-textarea-label", children: label }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "textarea",
+      {
+        ref,
+        id,
+        value,
+        rows,
+        maxLength,
+        placeholder,
+        disabled,
+        "aria-invalid": hasError || void 0,
+        "aria-describedby": hasError ? errorId : void 0,
+        onChange: (e) => {
+          onChange(e.target.value);
+          resize();
+        },
+        onBlur
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { id: errorId, children })
+  ] });
+}
+
+// src/components/forms/FieldArray.logic.ts
+function buildListAriaLabel(name) {
+  return `${name} items`;
+}
+function buildRemoveAriaLabel(name, index) {
+  return `Remove ${name} item ${index + 1}`;
+}
+function buildAddAriaLabel(name) {
+  return `Add ${name} item`;
+}
+function nextFocusIndexAfterRemove(previousLength, removedIndex) {
+  if (previousLength <= 1) return -1;
+  const newLength = previousLength - 1;
+  return Math.min(removedIndex, newLength - 1);
+}
+function useFieldArray({ name, control }) {
+  const ctx = useMosaicFormContext();
+  const resolvedControl = control ?? ctx.control;
+  return reactHookForm.useFieldArray({
+    // biome-ignore lint/suspicious/noExplicitAny: bridging erased generic
+    control: resolvedControl,
+    name
+  });
+}
+function FieldArray({ name, children, ariaLabel }) {
+  const ctx = useMosaicFormContext();
+  const { fields, append, remove, move, swap } = reactHookForm.useFieldArray({
+    // biome-ignore lint/suspicious/noExplicitAny: bridging erased generic
+    control: ctx.control,
+    name
+  });
+  const controls = {
+    fields,
+    append,
+    remove,
+    move,
+    swap
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "ul",
+    {
+      "aria-label": ariaLabel ?? buildListAriaLabel(name),
+      style: { listStyle: "none", padding: 0, margin: 0 },
+      children: fields.map((field, index) => /* @__PURE__ */ jsxRuntime.jsx(
+        "li",
+        {
+          "data-mosaic-fieldarray-item": true,
+          "data-mosaic-fieldarray-name": name,
+          "data-mosaic-fieldarray-index": index,
+          children: children(
+            {
+              field,
+              index
+            },
+            controls
+          )
+        },
+        field.id
+      ))
+    }
+  );
+}
+
+// src/components/forms/Checkbox.logic.ts
+function resolveAriaChecked(checked, indeterminate) {
+  if (indeterminate) return "mixed";
+  return checked;
+}
+function resolveDescribedBy(descriptionId, description, hasError, errorId) {
+  const parts = [];
+  if (description) parts.push(descriptionId);
+  if (hasError) parts.push(errorId);
+  return parts.length > 0 ? parts.join(" ") : void 0;
+}
+function Checkbox(props) {
+  const { name, label, disabled, indeterminate, description, className, errorMessageMap } = props;
+  const reactId = react.useId();
+  const fieldId = `mosaic-checkbox-${reactId}`;
+  const errorId = `${fieldId}-error`;
+  const descriptionId = `${fieldId}-description`;
+  return /* @__PURE__ */ jsxRuntime.jsx(FormField, { name, children: ({ field, fieldState }) => {
+    const hasError = Boolean(fieldState.error);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      CheckboxInner,
+      {
+        id: fieldId,
+        errorId,
+        descriptionId,
+        label,
+        checked: field.value ?? false,
+        onChange: (next) => field.onChange(next),
+        onBlur: field.onBlur,
+        disabled,
+        indeterminate,
+        description,
+        hasError,
+        className,
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          ErrorDisplay,
+          {
+            error: fieldState.error ? {
+              type: fieldState.error.type ?? "validation",
+              message: fieldState.error.message
+            } : void 0,
+            messageMap: errorMessageMap,
+            className: "mosaic-forms-error"
+          }
+        )
+      }
+    );
+  } });
+}
+function CheckboxInner(props) {
+  const {
+    id,
+    errorId,
+    descriptionId,
+    label,
+    checked,
+    onChange,
+    onBlur,
+    disabled,
+    indeterminate,
+    description,
+    hasError,
+    className,
+    children
+  } = props;
+  const ref = react.useRef(null);
+  react.useEffect(() => {
+    if (ref.current) {
+      ref.current.indeterminate = Boolean(indeterminate);
+    }
+  }, [indeterminate]);
+  const ariaChecked = resolveAriaChecked(checked, indeterminate);
+  const describedBy = resolveDescribedBy(descriptionId, description, hasError, errorId);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: className ?? "mosaic-forms-checkbox", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("label", { htmlFor: id, className: "mosaic-forms-checkbox-label", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          ref,
+          type: "checkbox",
+          id,
+          checked,
+          disabled,
+          "aria-checked": ariaChecked,
+          "aria-invalid": hasError || void 0,
+          "aria-describedby": describedBy,
+          onChange: (e) => onChange(e.target.checked),
+          onBlur
+        }
+      ),
+      label
+    ] }),
+    description ? /* @__PURE__ */ jsxRuntime.jsx("span", { id: descriptionId, className: "mosaic-forms-checkbox-description", children: description }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx("div", { id: errorId, children })
+  ] });
+}
+
+// src/components/forms/MultiSelect.logic.ts
+function getAvailableOptions(options, selected) {
+  const set = new Set(selected);
+  return options.filter((opt) => !set.has(opt.value));
+}
+function getSelectedOptions(options, selected) {
+  const byValue = new Map(options.map((opt) => [opt.value, opt]));
+  const out = [];
+  for (const value of selected) {
+    const opt = byValue.get(value);
+    if (opt) out.push(opt);
+  }
+  return out;
+}
+function filterBySearch(options, query) {
+  const q = query.trim().toLowerCase();
+  if (q.length === 0) return [...options];
+  return options.filter(
+    (opt) => opt.label.toLowerCase().includes(q) || opt.value.toLowerCase().includes(q)
+  );
+}
+function addValue(current, value, maxItems) {
+  if (current.includes(value)) return current;
+  if (typeof maxItems === "number" && current.length >= maxItems) return current;
+  return [...current, value];
+}
+function removeValue(current, value) {
+  return current.filter((v) => v !== value);
+}
+function isAtMaxItems(current, maxItems) {
+  return typeof maxItems === "number" && current.length >= maxItems;
+}
+var MultiSelectOptionSchema = zod.z.object({
+  value: zod.z.string().min(1),
+  label: zod.z.string().min(1)
+});
+var MultiSelectPropsSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  options: zod.z.array(MultiSelectOptionSchema).min(1),
+  placeholder: zod.z.string().optional(),
+  disabled: zod.z.boolean().optional(),
+  searchable: zod.z.boolean().optional(),
+  maxItems: zod.z.number().int().positive().optional()
+});
+function MultiSelect(props) {
+  const parsed = MultiSelectPropsSchema.parse({
+    name: props.name,
+    label: props.label,
+    options: props.options,
+    placeholder: props.placeholder,
+    disabled: props.disabled,
+    searchable: props.searchable,
+    maxItems: props.maxItems
+  });
+  const { name, label, options, placeholder, disabled, searchable, maxItems } = parsed;
+  const reactId = react.useId();
+  const triggerId = `${reactId}-trigger`;
+  const listboxId = `${reactId}-listbox`;
+  const labelId = `${reactId}-label`;
+  return /* @__PURE__ */ jsxRuntime.jsx(FormField, { name, children: ({ field }) => {
+    const value = Array.isArray(field.value) ? field.value : [];
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Inner,
+      {
+        triggerId,
+        listboxId,
+        labelId,
+        label,
+        options,
+        value,
+        disabled,
+        searchable,
+        maxItems,
+        placeholder,
+        onChange: (next) => field.onChange(next),
+        onBlur: () => field.onBlur(),
+        className: props.className
+      }
+    );
+  } });
+}
+function Inner(p) {
+  const [open, setOpen] = react.useState(false);
+  const [query, setQuery] = react.useState("");
+  const [activeIndex, setActiveIndex] = react.useState(0);
+  const triggerRef = react.useRef(null);
+  const selectedOptions = react.useMemo(
+    () => getSelectedOptions(p.options, p.value),
+    [p.options, p.value]
+  );
+  const availableAfterSelect = react.useMemo(
+    () => getAvailableOptions(p.options, p.value),
+    [p.options, p.value]
+  );
+  const visibleOptions = react.useMemo(
+    () => p.searchable ? filterBySearch(availableAfterSelect, query) : availableAfterSelect,
+    [availableAfterSelect, p.searchable, query]
+  );
+  const atMax = isAtMaxItems(p.value, p.maxItems);
+  const handleSelect = react.useCallback(
+    (val) => {
+      const next = addValue(p.value, val, p.maxItems);
+      if (next !== p.value) {
+        p.onChange(next);
+      }
+      setQuery("");
+    },
+    [p]
+  );
+  const handleRemove = react.useCallback(
+    (val) => {
+      p.onChange(removeValue(p.value, val));
+    },
+    [p]
+  );
+  const handleTriggerKeyDown = react.useCallback(
+    (e) => {
+      if (p.disabled) return;
+      if (e.key === "Backspace" || e.key === "Delete") {
+        const last = p.value[p.value.length - 1];
+        if (last !== void 0) {
+          e.preventDefault();
+          handleRemove(last);
+        }
+        return;
+      }
+      if (e.key === "ArrowDown" || e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        setOpen(true);
+        setActiveIndex(0);
+        return;
+      }
+      if (e.key === "Escape") {
+        setOpen(false);
+      }
+    },
+    [p.disabled, p.value, handleRemove]
+  );
+  const handleListKeyDown = react.useCallback(
+    (e) => {
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        setActiveIndex((i) => Math.min(i + 1, Math.max(visibleOptions.length - 1, 0)));
+        return;
+      }
+      if (e.key === "ArrowUp") {
+        e.preventDefault();
+        setActiveIndex((i) => Math.max(i - 1, 0));
+        return;
+      }
+      if (e.key === "Enter") {
+        e.preventDefault();
+        const opt = visibleOptions[activeIndex];
+        if (opt) handleSelect(opt.value);
+        return;
+      }
+      if (e.key === "Escape") {
+        e.preventDefault();
+        setOpen(false);
+        triggerRef.current?.focus();
+      }
+    },
+    [visibleOptions, activeIndex, handleSelect]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: p.className ?? "mosaic-multiselect", onBlur: p.onBlur, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("span", { id: p.labelId, className: "mosaic-multiselect-label", children: p.label }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mosaic-multiselect-chips", "data-testid": "multiselect-chips", children: selectedOptions.map((opt) => /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "mosaic-multiselect-chip", "data-chip-value": opt.value, children: [
+      opt.label,
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          "aria-label": `Remove ${opt.label}`,
+          "data-testid": `chip-remove-${opt.value}`,
+          className: "mosaic-multiselect-chip-remove",
+          disabled: p.disabled,
+          onClick: () => handleRemove(opt.value),
+          children: "\xD7"
+        }
+      )
+    ] }, opt.value)) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        ref: triggerRef,
+        id: p.triggerId,
+        type: "button",
+        role: "combobox",
+        "aria-multiselectable": true,
+        "aria-expanded": open,
+        "aria-controls": p.listboxId,
+        "aria-labelledby": p.labelId,
+        "aria-disabled": p.disabled || atMax || void 0,
+        disabled: p.disabled,
+        "data-testid": "multiselect-trigger",
+        className: "mosaic-multiselect-trigger",
+        onClick: () => !p.disabled && setOpen((o) => !o),
+        onKeyDown: handleTriggerKeyDown,
+        children: p.value.length === 0 ? p.placeholder ?? "Select\u2026" : `${p.value.length} selected`
+      }
+    ),
+    open ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mosaic-multiselect-panel", children: [
+      p.searchable ? /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "text",
+          "aria-label": "Search options",
+          "data-testid": "multiselect-search",
+          className: "mosaic-multiselect-search",
+          value: query,
+          onChange: (e) => {
+            setQuery(e.target.value);
+            setActiveIndex(0);
+          }
+        }
+      ) : null,
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "ul",
+        {
+          id: p.listboxId,
+          role: "listbox",
+          "aria-multiselectable": true,
+          "aria-labelledby": p.labelId,
+          tabIndex: -1,
+          className: "mosaic-multiselect-listbox",
+          onKeyDown: handleListKeyDown,
+          children: visibleOptions.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("li", { className: "mosaic-multiselect-empty", children: "No options" }) : visibleOptions.map((opt, i) => (
+            // biome-ignore lint/a11y/useFocusableInteractive: focus stays on the listbox; APG combobox active-descendant pattern.
+            // biome-ignore lint/a11y/useKeyWithClickEvents: keyboard handled at listbox level per APG.
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "li",
+              {
+                role: "option",
+                "aria-selected": false,
+                "data-testid": `option-${opt.value}`,
+                "data-active": i === activeIndex || void 0,
+                className: "mosaic-multiselect-option",
+                onClick: () => handleSelect(opt.value),
+                children: opt.label
+              },
+              opt.value
+            )
+          ))
+        }
+      )
+    ] }) : null
+  ] });
+}
+
+// src/components/forms/RadioGroup.logic.ts
+function getNavKeys(orientation) {
+  return orientation === "vertical" ? { prev: "ArrowUp", next: "ArrowDown" } : { prev: "ArrowLeft", next: "ArrowRight" };
+}
+function findNextEnabledIndex(options, currentIndex, direction) {
+  const len = options.length;
+  if (len === 0) return currentIndex;
+  let i = (currentIndex + direction + len) % len;
+  for (let tries = 0; tries < len; tries++) {
+    if (!options[i]?.disabled) return i;
+    i = (i + direction + len) % len;
+  }
+  return currentIndex;
+}
+function findFirstEnabledIndex(options) {
+  const idx = options.findIndex((o) => !o.disabled);
+  return idx === -1 ? 0 : idx;
+}
+function findLastEnabledIndex(options) {
+  for (let i = options.length - 1; i >= 0; i--) {
+    if (!options[i]?.disabled) return i;
+  }
+  return options.length - 1;
+}
+function findSelectedIndex(options, selectedValue) {
+  if (selectedValue === void 0 || selectedValue === "") return -1;
+  return options.findIndex((o) => o.value === selectedValue);
+}
+function getRovingTabIndex(options, selectedValue) {
+  const selectedIdx = findSelectedIndex(options, selectedValue);
+  if (selectedIdx >= 0) return selectedIdx;
+  return findFirstEnabledIndex(options);
+}
+function getGroupLabelId(instanceId, name) {
+  return `${instanceId}-${name}-label`;
+}
+function getOptionLabelId(instanceId, name, optionValue) {
+  return `${instanceId}-${name}-${optionValue}-label`;
+}
+function getOptionDescriptionId(instanceId, name, optionValue) {
+  return `${instanceId}-${name}-${optionValue}-desc`;
+}
+function getGroupClasses(orientation) {
+  return orientation === "vertical" ? "flex flex-col gap-2" : "flex flex-row flex-wrap gap-4";
+}
+function getOptionRowClasses(isDisabled, orientation) {
+  const base = "flex items-start gap-2";
+  const orient = orientation === "vertical" ? "flex-row" : "flex-row";
+  const state = isDisabled ? "opacity-50 cursor-not-allowed" : "cursor-pointer";
+  return [base, orient, state].join(" ");
+}
+function getRadioControlClasses(isSelected, isDisabled) {
+  const base = "inline-flex items-center justify-center w-4 h-4 mt-0.5 rounded-full border-2 transition-colors focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-600 shrink-0";
+  const state = isDisabled ? "border-slate-300 bg-slate-100" : isSelected ? "border-blue-600 bg-white" : "border-slate-400 bg-white hover:border-slate-600";
+  return [base, state].join(" ");
+}
+function isActivationKey(key) {
+  return key === " " || key === "Space" || key === "Enter";
+}
+var RadioGroupOptionSchema = zod.z.object({
+  value: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  description: zod.z.string().optional(),
+  disabled: zod.z.boolean().optional().default(false)
+});
+var RadioGroupPropsSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  options: zod.z.array(RadioGroupOptionSchema).min(1),
+  orientation: zod.z.enum(["vertical", "horizontal"]).default("vertical"),
+  disabled: zod.z.boolean().optional().default(false),
+  locale: zod.z.enum(["en", "fr"]).default("en")
+});
+function validateRadioGroupProps(raw) {
+  return RadioGroupPropsSchema.parse(raw);
+}
+function RadioGroup(props) {
+  const validated = validateRadioGroupProps({
+    name: props.name,
+    label: props.label,
+    options: props.options,
+    orientation: props.orientation,
+    disabled: props.disabled
+  });
+  const { name, label, options, orientation, disabled } = validated;
+  const instanceId = react.useId();
+  const groupLabelId = getGroupLabelId(instanceId, name);
+  const { prev: prevKey, next: nextKey } = getNavKeys(orientation);
+  const radioRefs = react.useRef([]);
+  const focusAndSelect = react.useCallback(
+    (index, onChange) => {
+      const el = radioRefs.current[index];
+      if (el) el.focus();
+      const opt = options[index];
+      if (opt && !opt.disabled) {
+        onChange(opt.value);
+      }
+    },
+    [options]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(FormField, { name, children: ({ field, fieldState }) => {
+    const selectedValue = field.value;
+    const rovingIdx = getRovingTabIndex(options, selectedValue);
+    const handleKeyDown = (e, currentIndex) => {
+      const { key } = e;
+      if (key === prevKey || key === nextKey) {
+        e.preventDefault();
+        const direction = key === nextKey ? 1 : -1;
+        const nextIdx = findNextEnabledIndex(options, currentIndex, direction);
+        focusAndSelect(nextIdx, field.onChange);
+        return;
+      }
+      if (key === "Home") {
+        e.preventDefault();
+        focusAndSelect(findFirstEnabledIndex(options), field.onChange);
+        return;
+      }
+      if (key === "End") {
+        e.preventDefault();
+        focusAndSelect(findLastEnabledIndex(options), field.onChange);
+        return;
+      }
+      if (isActivationKey(key)) {
+        e.preventDefault();
+        const opt = options[currentIndex];
+        if (opt && !opt.disabled) {
+          field.onChange(opt.value);
+        }
+      }
+    };
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: props.className ?? "mosaic-forms-radiogroup", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { id: groupLabelId, className: "mosaic-forms-radiogroup-label", children: label }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          role: "radiogroup",
+          "aria-labelledby": groupLabelId,
+          "aria-orientation": orientation,
+          "aria-disabled": disabled || void 0,
+          className: getGroupClasses(orientation),
+          children: options.map((option, index) => {
+            const isSelected = selectedValue === option.value;
+            const isDisabled = !!(disabled || option.disabled);
+            const optLabelId = getOptionLabelId(instanceId, name, option.value);
+            const optDescId = option.description ? getOptionDescriptionId(instanceId, name, option.value) : void 0;
+            const tabIdx = index === rovingIdx ? 0 : -1;
+            return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: getOptionRowClasses(isDisabled, orientation), children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "input",
+                {
+                  ref: (el) => {
+                    radioRefs.current[index] = el;
+                  },
+                  type: "radio",
+                  id: `${instanceId}-${name}-${option.value}`,
+                  name: field.name,
+                  value: option.value,
+                  checked: isSelected,
+                  disabled: isDisabled,
+                  "aria-labelledby": optLabelId,
+                  "aria-describedby": optDescId,
+                  tabIndex: isDisabled ? -1 : tabIdx,
+                  className: "mosaic-forms-radiogroup-input sr-only",
+                  onChange: () => {
+                    field.onChange(option.value);
+                  },
+                  onKeyDown: (e) => {
+                    if (!isDisabled) handleKeyDown(e, index);
+                  },
+                  onBlur: field.onBlur
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-0.5", children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { id: optLabelId, className: "mosaic-forms-radiogroup-option-label", children: option.label }),
+                option.description ? /* @__PURE__ */ jsxRuntime.jsx(
+                  "span",
+                  {
+                    id: optDescId,
+                    className: "mosaic-forms-radiogroup-option-description text-sm text-slate-500",
+                    children: option.description
+                  }
+                ) : null
+              ] })
+            ] }, option.value);
+          })
+        }
+      ),
+      fieldState.error ? /* @__PURE__ */ jsxRuntime.jsx("span", { role: "alert", className: "mosaic-forms-radiogroup-error text-sm text-red-600", children: fieldState.error.message }) : null
+    ] });
+  } });
+}
+
+// src/components/forms/Select.logic.ts
+function getTriggerId(instanceId) {
+  return `${instanceId}-trigger`;
+}
+function getListboxId(instanceId) {
+  return `${instanceId}-listbox`;
+}
+function getOptionId(instanceId, value) {
+  return `${instanceId}-opt-${value}`;
+}
+function filterOptions(options, query) {
+  const q = query.trim().toLowerCase();
+  if (q === "") return options;
+  return options.filter((o) => o.label.toLowerCase().includes(q));
+}
+function indexOfValue(options, value) {
+  if (value == null) return -1;
+  return options.findIndex((o) => o.value === value);
+}
+function findNextEnabledIndex2(options, startIndex, direction) {
+  const len = options.length;
+  if (len === 0) return -1;
+  let i = startIndex;
+  for (let tries = 0; tries < len; tries++) {
+    i = (i + direction + len) % len;
+    if (!options[i]?.disabled) return i;
+  }
+  return -1;
+}
+function findFirstEnabledIndex2(options) {
+  const idx = options.findIndex((o) => !o.disabled);
+  return idx === -1 ? -1 : idx;
+}
+function findLastEnabledIndex2(options) {
+  for (let i = options.length - 1; i >= 0; i--) {
+    if (!options[i]?.disabled) return i;
+  }
+  return -1;
+}
+function findByTypeAhead(options, buffer) {
+  if (buffer === "") return -1;
+  const needle = buffer.toLowerCase();
+  for (let i = 0; i < options.length; i++) {
+    const o = options[i];
+    if (!o || o.disabled) continue;
+    if (o.label.toLowerCase().startsWith(needle)) return i;
+  }
+  return -1;
+}
+function getTriggerClasses(isDisabled, isOpen) {
+  const base = "inline-flex items-center justify-between gap-2 w-full rounded-md border px-3 py-2 text-sm transition-colors focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-600";
+  const state = isDisabled ? "border-slate-200 text-slate-400 bg-slate-50 cursor-not-allowed" : isOpen ? "border-blue-600 bg-white text-slate-900" : "border-slate-300 bg-white text-slate-900 hover:border-slate-400";
+  return `${base} ${state}`;
+}
+function getListboxClasses() {
+  return "absolute z-50 mt-1 max-h-60 w-full overflow-auto rounded-md border border-slate-200 bg-white py-1 shadow-lg focus:outline-none";
+}
+function getOptionClasses(isActive, isSelected, isDisabled) {
+  const base = "flex items-center px-3 py-2 text-sm select-none";
+  if (isDisabled) return `${base} text-slate-400 cursor-not-allowed`;
+  const active = isActive ? "bg-blue-50 text-blue-900" : "text-slate-900";
+  const selected = isSelected ? "font-medium" : "";
+  return `${base} ${active} ${selected} cursor-pointer`;
+}
+function getSearchInputClasses() {
+  return "w-full px-3 py-2 text-sm border-b border-slate-200 focus:outline-none focus:border-blue-600";
+}
+function resolveSelectedLabel(options, value) {
+  if (value == null) return null;
+  const o = options.find((opt) => opt.value === value);
+  return o?.label ?? null;
+}
+function Select({
+  name,
+  label,
+  options,
+  placeholder,
+  disabled = false,
+  searchable = false,
+  className,
+  errorMessageMap
+}) {
+  const reactId = react.useId();
+  const instanceId = `mosaic-select-${reactId.replace(/[^a-zA-Z0-9-]/g, "")}`;
+  const triggerId = getTriggerId(instanceId);
+  const listboxId = getListboxId(instanceId);
+  const labelId = `${instanceId}-label`;
+  const errorId = `${instanceId}-error`;
+  return /* @__PURE__ */ jsxRuntime.jsx(FormField, { name, children: ({ field, fieldState }) => {
+    const hasError = Boolean(fieldState.error);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      SelectInner,
+      {
+        field,
+        label,
+        labelId,
+        triggerId,
+        listboxId,
+        errorId,
+        instanceId,
+        options,
+        placeholder,
+        disabled,
+        searchable,
+        className,
+        hasError,
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          ErrorDisplay,
+          {
+            error: fieldState.error ? {
+              type: fieldState.error.type ?? "validation",
+              message: fieldState.error.message
+            } : void 0,
+            messageMap: errorMessageMap,
+            className: "mosaic-forms-error"
+          }
+        )
+      }
+    );
+  } });
+}
+function SelectInner({
+  field,
+  label,
+  labelId,
+  triggerId,
+  listboxId,
+  errorId,
+  instanceId,
+  options,
+  placeholder,
+  disabled,
+  searchable,
+  className,
+  hasError,
+  children
+}) {
+  const [isOpen, setIsOpen] = react.useState(false);
+  const [query, setQuery] = react.useState("");
+  const [activeIndex, setActiveIndex] = react.useState(-1);
+  const triggerRef = react.useRef(null);
+  const searchRef = react.useRef(null);
+  const typeAheadRef = react.useRef({
+    buffer: "",
+    timer: null
+  });
+  const visibleOptions = react.useMemo(
+    () => searchable ? filterOptions(options, query) : options,
+    [options, query, searchable]
+  );
+  react.useEffect(() => {
+    if (!isOpen) return;
+    const selectedIdx = indexOfValue(visibleOptions, field.value);
+    if (selectedIdx >= 0 && !visibleOptions[selectedIdx]?.disabled) {
+      setActiveIndex(selectedIdx);
+    } else {
+      setActiveIndex(findFirstEnabledIndex2(visibleOptions));
+    }
+  }, [isOpen, visibleOptions, field.value]);
+  const closePopup = react.useCallback((restoreFocus = true) => {
+    setIsOpen(false);
+    setQuery("");
+    if (restoreFocus) triggerRef.current?.focus();
+  }, []);
+  const commitOption = react.useCallback(
+    (idx) => {
+      const opt = visibleOptions[idx];
+      if (!opt || opt.disabled) return;
+      field.onChange(opt.value);
+      closePopup(true);
+      field.onBlur();
+    },
+    [visibleOptions, field, closePopup]
+  );
+  const handleKeyDown = react.useCallback(
+    (e) => {
+      if (disabled) return;
+      if (!isOpen) {
+        if (e.key === "Enter" || e.key === " " || e.key === "ArrowDown" || e.key === "ArrowUp") {
+          e.preventDefault();
+          setIsOpen(true);
+        }
+        return;
+      }
+      switch (e.key) {
+        case "ArrowDown": {
+          e.preventDefault();
+          const start = activeIndex < 0 ? -1 : activeIndex;
+          const next = findNextEnabledIndex2(visibleOptions, start, 1);
+          if (next >= 0) setActiveIndex(next);
+          break;
+        }
+        case "ArrowUp": {
+          e.preventDefault();
+          const start = activeIndex < 0 ? visibleOptions.length : activeIndex;
+          const prev = findNextEnabledIndex2(visibleOptions, start, -1);
+          if (prev >= 0) setActiveIndex(prev);
+          break;
+        }
+        case "Home": {
+          e.preventDefault();
+          const first = findFirstEnabledIndex2(visibleOptions);
+          if (first >= 0) setActiveIndex(first);
+          break;
+        }
+        case "End": {
+          e.preventDefault();
+          const last = findLastEnabledIndex2(visibleOptions);
+          if (last >= 0) setActiveIndex(last);
+          break;
+        }
+        case "Enter": {
+          e.preventDefault();
+          if (activeIndex >= 0) commitOption(activeIndex);
+          break;
+        }
+        case "Escape": {
+          e.preventDefault();
+          closePopup(true);
+          break;
+        }
+        default: {
+          if (!searchable && e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
+            e.preventDefault();
+            const ta = typeAheadRef.current;
+            ta.buffer += e.key.toLowerCase();
+            if (ta.timer) clearTimeout(ta.timer);
+            ta.timer = setTimeout(() => {
+              ta.buffer = "";
+            }, 500);
+            const idx = findByTypeAhead(visibleOptions, ta.buffer);
+            if (idx >= 0) setActiveIndex(idx);
+          }
+          break;
+        }
+      }
+    },
+    [activeIndex, closePopup, commitOption, disabled, isOpen, searchable, visibleOptions]
+  );
+  const rootRef = react.useRef(null);
+  react.useEffect(() => {
+    if (!isOpen) return;
+    function onDocClick(e) {
+      if (!rootRef.current) return;
+      if (!rootRef.current.contains(e.target)) {
+        setIsOpen(false);
+        setQuery("");
+        field.onBlur();
+      }
+    }
+    document.addEventListener("mousedown", onDocClick);
+    return () => document.removeEventListener("mousedown", onDocClick);
+  }, [isOpen, field]);
+  const selectedLabel = resolveSelectedLabel(options, field.value);
+  const activeId = activeIndex >= 0 ? getOptionId(instanceId, visibleOptions[activeIndex]?.value ?? "") : void 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { ref: rootRef, className: className ?? "relative inline-block w-full", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "label",
+      {
+        id: labelId,
+        htmlFor: triggerId,
+        className: "block text-sm font-medium text-slate-700 mb-1",
+        children: label
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        id: triggerId,
+        ref: (el) => {
+          triggerRef.current = el;
+          field.ref(el);
+        },
+        role: "combobox",
+        "aria-haspopup": "listbox",
+        "aria-expanded": isOpen,
+        "aria-controls": listboxId,
+        "aria-labelledby": labelId,
+        "aria-activedescendant": isOpen ? activeId : void 0,
+        "aria-invalid": hasError || void 0,
+        "aria-describedby": hasError ? errorId : void 0,
+        disabled,
+        className: getTriggerClasses(disabled, isOpen),
+        onClick: () => !disabled && setIsOpen((o) => !o),
+        onKeyDown: handleKeyDown,
+        onBlur: (e) => {
+          if (rootRef.current?.contains(e.relatedTarget)) return;
+          if (!isOpen) field.onBlur();
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: selectedLabel ? "" : "text-slate-400", children: selectedLabel ?? placeholder ?? "" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", children: "\u25BE" })
+        ]
+      }
+    ),
+    isOpen ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: getListboxClasses(), children: [
+      searchable ? /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          ref: searchRef,
+          type: "text",
+          className: getSearchInputClasses(),
+          value: query,
+          onChange: (e) => setQuery(e.target.value),
+          onKeyDown: handleKeyDown,
+          placeholder: "Search\u2026",
+          autoFocus: true,
+          "aria-label": "Search options"
+        }
+      ) : null,
+      /* @__PURE__ */ jsxRuntime.jsx("ul", { id: listboxId, role: "listbox", "aria-labelledby": labelId, tabIndex: -1, children: visibleOptions.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("li", { className: "px-3 py-2 text-sm text-slate-500", role: "presentation", children: "No options" }) : visibleOptions.map((opt, idx) => {
+        const isSelected = opt.value === field.value;
+        const isActive = idx === activeIndex;
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          "li",
+          {
+            id: getOptionId(instanceId, opt.value),
+            role: "option",
+            "aria-selected": isSelected,
+            "aria-disabled": opt.disabled || void 0,
+            className: getOptionClasses(isActive, isSelected, !!opt.disabled),
+            onMouseDown: (e) => {
+              e.preventDefault();
+              if (!opt.disabled) commitOption(idx);
+            },
+            onMouseEnter: () => {
+              if (!opt.disabled) setActiveIndex(idx);
+            },
+            children: opt.label
+          },
+          opt.value
+        );
+      }) })
+    ] }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx("div", { id: errorId, children })
+  ] });
+}
+var FieldErrorShapeSchema = zod.z.object({
+  type: zod.z.string(),
+  message: zod.z.string().optional()
+});
+var ErrorDisplayPropsSchema = zod.z.object({
+  error: FieldErrorShapeSchema.optional(),
+  messageMap: zod.z.record(zod.z.string(), zod.z.string()).optional()
+});
+var FormFieldPropsSchema = zod.z.object({
+  name: zod.z.string().min(1)
+});
+var FormProviderPropsSchema = zod.z.object({
+  name: zod.z.string().optional()
+});
+var InputTypeSchema = zod.z.enum(["text", "email", "password", "number", "url"]);
+var InputPropsSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  type: InputTypeSchema.default("text").optional(),
+  placeholder: zod.z.string().optional(),
+  disabled: zod.z.boolean().optional(),
+  autoComplete: zod.z.string().optional(),
+  label: zod.z.string().min(1)
+});
+var TextareaPropsSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  rows: zod.z.number().int().min(1).default(3),
+  maxLength: zod.z.number().int().min(1).optional(),
+  autoResize: zod.z.boolean().default(false),
+  placeholder: zod.z.string().optional(),
+  disabled: zod.z.boolean().optional(),
+  label: zod.z.string().optional()
+});
+function validateTextareaProps(raw) {
+  return TextareaPropsSchema.parse(raw);
+}
+var FieldArrayPropsSchema = zod.z.object({
+  name: zod.z.string().min(1)
+});
+var UseFieldArrayOptionsSchema = zod.z.object({
+  name: zod.z.string().min(1)
+});
+var CheckboxPropsSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  disabled: zod.z.boolean().optional(),
+  indeterminate: zod.z.boolean().optional(),
+  description: zod.z.string().optional()
+});
+function validateCheckboxProps(raw) {
+  return CheckboxPropsSchema.parse(raw);
+}
+var SelectOptionSchema = zod.z.object({
+  value: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  disabled: zod.z.boolean().optional().default(false)
+});
+var SelectPropsSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  options: zod.z.array(SelectOptionSchema).min(1),
+  placeholder: zod.z.string().optional(),
+  disabled: zod.z.boolean().optional().default(false),
+  searchable: zod.z.boolean().optional().default(false),
+  locale: zod.z.enum(["en", "fr"]).default("en")
+});
+function validateSelectProps(raw) {
+  return SelectPropsSchema.parse(raw);
+}
+
+exports.Checkbox = Checkbox;
+exports.CheckboxPropsSchema = CheckboxPropsSchema;
+exports.DEFAULT_TEXTAREA_ROWS = DEFAULT_TEXTAREA_ROWS;
+exports.ErrorDisplay = ErrorDisplay;
+exports.ErrorDisplayPropsSchema = ErrorDisplayPropsSchema;
+exports.FieldArray = FieldArray;
+exports.FieldArrayPropsSchema = FieldArrayPropsSchema;
+exports.FieldErrorShapeSchema = FieldErrorShapeSchema;
+exports.FormField = FormField;
+exports.FormFieldPropsSchema = FormFieldPropsSchema;
+exports.FormProvider = FormProvider;
+exports.FormProviderPropsSchema = FormProviderPropsSchema;
+exports.Input = Input;
+exports.InputPropsSchema = InputPropsSchema;
+exports.InputTypeSchema = InputTypeSchema;
+exports.MosaicFormModeSchema = MosaicFormModeSchema;
+exports.MultiSelect = MultiSelect;
+exports.MultiSelectOptionSchema = MultiSelectOptionSchema;
+exports.MultiSelectPropsSchema = MultiSelectPropsSchema;
+exports.RadioGroup = RadioGroup;
+exports.RadioGroupOptionSchema = RadioGroupOptionSchema;
+exports.RadioGroupPropsSchema = RadioGroupPropsSchema;
+exports.Select = Select;
+exports.SelectOptionSchema = SelectOptionSchema;
+exports.SelectPropsSchema = SelectPropsSchema;
+exports.SubmitButton = SubmitButton;
+exports.SubmitButtonPropsSchema = SubmitButtonPropsSchema;
+exports.Textarea = Textarea;
+exports.TextareaPropsSchema = TextareaPropsSchema;
+exports.UseFieldArrayOptionsSchema = UseFieldArrayOptionsSchema;
+exports.UseMosaicFormOptionsSchema = UseMosaicFormOptionsSchema;
+exports.buildAddAriaLabel = buildAddAriaLabel;
+exports.buildListAriaLabel = buildListAriaLabel;
+exports.buildRemoveAriaLabel = buildRemoveAriaLabel;
+exports.clampToMaxLength = clampToMaxLength;
+exports.computeAutoResizeHeight = computeAutoResizeHeight;
+exports.findFirstEnabledIndex = findFirstEnabledIndex;
+exports.findLastEnabledIndex = findLastEnabledIndex;
+exports.findNextEnabledIndex = findNextEnabledIndex;
+exports.findSelectedIndex = findSelectedIndex;
+exports.getGroupClasses = getGroupClasses;
+exports.getGroupLabelId = getGroupLabelId;
+exports.getNavKeys = getNavKeys;
+exports.getOptionDescriptionId = getOptionDescriptionId;
+exports.getOptionLabelId = getOptionLabelId;
+exports.getOptionRowClasses = getOptionRowClasses;
+exports.getRadioControlClasses = getRadioControlClasses;
+exports.getRovingTabIndex = getRovingTabIndex;
+exports.isActivationKey = isActivationKey;
+exports.nextFocusIndexAfterRemove = nextFocusIndexAfterRemove;
+exports.resolveAriaChecked = resolveAriaChecked;
+exports.resolveDescribedBy = resolveDescribedBy;
+exports.resolveRows = resolveRows;
+exports.useFieldArray = useFieldArray;
+exports.useMosaicForm = useMosaicForm;
+exports.useMosaicFormContext = useMosaicFormContext;
+exports.validateCheckboxProps = validateCheckboxProps;
+exports.validateRadioGroupProps = validateRadioGroupProps;
+exports.validateSelectProps = validateSelectProps;
+exports.validateTextareaProps = validateTextareaProps;
+//# sourceMappingURL=forms.cjs.map
+//# sourceMappingURL=forms.cjs.map