impact-nova 2.3.0 → 2.4.0

package/dist/form-react/Fields/RadioField.js

@@ -0,0 +1,68 @@
+import { jsx as a, jsxs as s } from "react/jsx-runtime";
+import { useMemo as b } from "react";
+import { Controller as h } from "react-hook-form";
+import { RadioGroup as p, RadioGroupItem as v } from "../../components/forms/radio-group/radio-group.js";
+import { getTestId as d, getFieldTestId as g } from "../utils/fieldTestIds.js";
+const R = ({
+  field: e,
+  formHelpers: n,
+  validationRules: m,
+  isDisabled: c
+}) => {
+  const l = e.fieldType === "radio" ? e : null, u = b(() => l ? l.options?.map((r) => ({
+    label: r.label,
+    value: r.value,
+    disabled: r.isDisabled ?? !1
+  })) || [] : [], [l]);
+  return l ? /* @__PURE__ */ a(
+    h,
+    {
+      name: e.id,
+      control: n.form.control,
+      rules: m,
+      render: ({ field: r, fieldState: i }) => {
+        const o = !!i.error, x = r.value;
+        return /* @__PURE__ */ s("div", { className: "flex flex-col gap-1", "data-testid": g(e.id), children: [
+          e.label && /* @__PURE__ */ s("label", { className: "block text-xs font-medium mb-2 text-[#60697d]", "data-testid": d("field-label", e.id), children: [
+            e.label,
+            e.isRequired && /* @__PURE__ */ a("span", { className: "text-destructive ml-1", children: "*" })
+          ] }),
+          /* @__PURE__ */ a("div", { "data-testid": d("radio-group", e.id), children: /* @__PURE__ */ a(
+            p,
+            {
+              orientation: l?.orientation === "row" ? "horizontal" : "vertical",
+              value: x,
+              onValueChange: (t) => {
+                r.onChange(t), r.onBlur();
+              },
+              disabled: c,
+              children: u.map((t) => /* @__PURE__ */ s("div", { className: "flex items-center gap-2", children: [
+                /* @__PURE__ */ a(
+                  v,
+                  {
+                    value: t.value,
+                    id: `${e.id}-${t.value}`,
+                    disabled: t.disabled
+                  }
+                ),
+                /* @__PURE__ */ a(
+                  "label",
+                  {
+                    htmlFor: `${e.id}-${t.value}`,
+                    className: `text-sm font-medium leading-[14px] cursor-pointer text-[#60697D] peer-data-[state=checked]:text-[#0D152C] ${t.disabled ? "text-disabled-text cursor-not-allowed peer-disabled:opacity-100" : ""}`,
+                    children: t.label
+                  }
+                )
+              ] }, t.value))
+            }
+          ) }),
+          o && /* @__PURE__ */ a("p", { className: "text-destructive text-sm mt-1", children: i?.error?.message }),
+          e.helpText && !o && /* @__PURE__ */ a("p", { className: "text-content-secondary text-sm mt-1", children: e.helpText })
+        ] });
+      }
+    }
+  ) : null;
+};
+export {
+  R as RadioField
+};

package/dist/form-react/Fields/SelectField.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { FormFieldProps } from '../types/reactHookForm.types';
+export declare const SelectField: FC<FormFieldProps>;

package/dist/form-react/Fields/SelectField.js

@@ -0,0 +1,76 @@
+import { jsx as c } from "react/jsx-runtime";
+import { useState as M } from "react";
+import { Controller as f } from "react-hook-form";
+import { Select as x } from "../../components/forms/select/select.js";
+import { useSelectOptions as E } from "../hooks/useSelectOptions.js";
+import { getFieldTestId as R } from "../utils/fieldTestIds.js";
+import { isEmptyValue as T } from "../../form-engine/is-empty-value.js";
+const F = ({
+  field: e,
+  validationRules: p,
+  isDisabled: m,
+  formHelpers: l,
+  formConfig: u,
+  supportedValues: d
+}) => {
+  const t = e.fieldType === "select" ? e : null, [S, s] = M(!1), h = l.form.control, b = d?.[e.id], { options: g, isLoading: O, error: y, refetch: C } = E({
+    apiConfig: t?.apiConfig,
+    formHelpers: l,
+    formConfig: u,
+    initialOptions: t?.options,
+    id: e.id,
+    isEnabled: S,
+    getSelectOptionsName: t?.getSelectOptionsName,
+    fieldSupportedValues: b
+  });
+  return t ? /* @__PURE__ */ c(
+    f,
+    {
+      name: e.id,
+      control: h,
+      rules: p,
+      render: ({ field: o, fieldState: n }) => {
+        const a = !!n.error, i = o.value, A = t?.isMultiSelect ? e.id : `${e.id}-${T(i) ? "empty" : "has-value"}`;
+        return /* @__PURE__ */ c(
+          x,
+          {
+            id: e.id,
+            label: e.label,
+            placeholder: e?.placeholder,
+            required: e.isRequired,
+            isReadOnly: e.isFieldReadonly,
+            disabled: m,
+            options: g,
+            maxSelectableOptions: t?.maxSelectLimit,
+            value: t?.isMultiSelect ? i ?? [] : i?.[0],
+            onChange: (r) => {
+              t?.isMultiSelect ? o.onChange(
+                Array.isArray(r) ? r : []
+              ) : r == null ? o.onChange([]) : o.onChange(
+                Array.isArray(r) ? r : [r]
+              );
+            },
+            isSearchable: !t?.disableOptionSearch,
+            isClearable: !t?.disableClearAll,
+            multiple: t?.isMultiSelect,
+            isSelectAllEnabled: !t?.disableSelectAll,
+            labelOrientation: t?.labelOrientation || "top",
+            error: a,
+            helperText: a ? n.error?.message : e.helpText,
+            ignoreAccents: !0,
+            isLoading: O,
+            fetchError: y,
+            onRefetch: C,
+            onMenuOpen: () => s(!0),
+            onMenuClose: () => s(!1),
+            "data-testid": R(e.id)
+          },
+          A
+        );
+      }
+    }
+  ) : null;
+};
+export {
+  F as SelectField
+};

package/dist/form-react/Fields/SwitchField.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { FormFieldProps } from '../types/reactHookForm.types';
+export declare const SwitchField: FC<FormFieldProps>;

package/dist/form-react/Fields/SwitchField.js

@@ -0,0 +1,47 @@
+import { jsx as l, jsxs as a } from "react/jsx-runtime";
+import "react";
+import { Controller as h } from "react-hook-form";
+import { Switch as d } from "../../components/forms/switch/switch.js";
+const f = ({
+  field: e,
+  validationRules: r,
+  isDisabled: c,
+  formHelpers: n
+}) => {
+  const t = e.fieldType === "switch" ? e : null;
+  return t ? /* @__PURE__ */ l(
+    h,
+    {
+      name: e.id,
+      control: n.form.control,
+      rules: r,
+      render: ({ field: s }) => {
+        const i = !!(s.value ?? !1), m = e.label ?? t.rightLabel ?? t.leftLabel ?? e.id;
+        return /* @__PURE__ */ a("div", { className: e.className || "", children: [
+          e.label ? /* @__PURE__ */ a("label", { className: "block text-xs font-medium mb-2 text-[#60697d]", children: [
+            e.label,
+            e.isRequired && /* @__PURE__ */ l("span", { className: "text-destructive ml-1", children: "*" })
+          ] }) : null,
+          /* @__PURE__ */ a("div", { className: "flex items-center gap-2", children: [
+            t.leftLabel && /* @__PURE__ */ l("span", { className: "text-sm font-medium text-[#111827]", children: t.leftLabel }),
+            /* @__PURE__ */ l(
+              d,
+              {
+                "aria-label": m,
+                checked: i,
+                onCheckedChange: (o) => {
+                  s.onChange(o);
+                },
+                disabled: c
+              }
+            ),
+            t.rightLabel && /* @__PURE__ */ l("span", { className: "text-sm font-medium text-[#111827]", children: t.rightLabel })
+          ] })
+        ] });
+      }
+    }
+  ) : null;
+};
+export {
+  f as SwitchField
+};

package/dist/form-react/Fields/TextAreaField.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { FormFieldProps } from '../types/reactHookForm.types';
+export declare const TextAreaField: FC<FormFieldProps>;

package/dist/form-react/Fields/TextAreaField.js

@@ -0,0 +1,41 @@
+import { jsx as e } from "react/jsx-runtime";
+import "react";
+import { Controller as h } from "react-hook-form";
+import { Textarea as p } from "../../components/forms/textarea/textarea.js";
+const T = ({
+  field: r,
+  formHelpers: n,
+  validationRules: m,
+  isDisabled: o
+}) => {
+  const t = r.fieldType === "text_area" ? r : null;
+  return t ? /* @__PURE__ */ e(
+    h,
+    {
+      name: r.id,
+      control: n.form.control,
+      disabled: o,
+      rules: m,
+      render: ({ field: a, fieldState: l }) => {
+        const u = !!l.error, c = a.value;
+        return /* @__PURE__ */ e("div", { children: /* @__PURE__ */ e(
+          p,
+          {
+            label: r.label,
+            value: c ?? void 0,
+            onChange: (i) => a.onChange(i.target.value),
+            placeholder: r.placeholder,
+            characterLimit: t.characterLimit,
+            disabled: o,
+            required: r.isRequired,
+            error: u,
+            helperText: l.error?.message || r.helpText
+          }
+        ) });
+      }
+    }
+  ) : null;
+};
+export {
+  T as TextAreaField
+};

package/dist/form-react/Fields/TextField.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { FormFieldProps } from '../types/reactHookForm.types';
+export declare const TextField: FC<FormFieldProps>;

package/dist/form-react/Fields/TextField.js

@@ -0,0 +1,75 @@
+import { jsx as m } from "react/jsx-runtime";
+import { useRef as y, useEffect as b } from "react";
+import { useWatch as V, Controller as w } from "react-hook-form";
+import { SmartInput as x } from "../../components/forms/smart-input/smart-input.js";
+import { readOptionFlag as d } from "../utils/optionFlag.js";
+const T = ({
+  field: e,
+  validationRules: u,
+  isDisabled: i,
+  formHelpers: r
+}) => {
+  const a = e.fieldType === "text" ? e : null, n = a?.allowNegativeDependency, l = !!n, c = !!a?.nonNegative, p = V({
+    control: r.form.control,
+    name: n?.fieldId ?? "",
+    disabled: !l
+  }), f = !c || l && d(
+    r.form.getValues(n.fieldId),
+    n.optionFlag
+  ), s = y(!0);
+  return b(() => {
+    if (!l) return;
+    if (s.current) {
+      s.current = !1;
+      return;
+    }
+    const t = r.form.getValues(e.id);
+    t != null && String(t).trim() !== "" && r.form.trigger(e.id);
+  }, [l, p, e.id, r.form]), a ? /* @__PURE__ */ m(
+    w,
+    {
+      name: e.id,
+      control: r.form.control,
+      rules: {
+        ...u,
+        validate: (t) => {
+          if (typeof u.validate == "function") {
+            const o = u.validate(
+              t,
+              r.form.getValues()
+            );
+            if (o !== !0) return o;
+          }
+          return c && l && !d(
+            r.form.getValues(n.fieldId),
+            n.optionFlag
+          ) && typeof t == "string" && Number(t) < 0 ? `${e.label || "Value"} must be a non-negative number` : !0;
+        }
+      },
+      render: ({ field: t, fieldState: o }) => {
+        const g = !!o.error, h = t.value;
+        return /* @__PURE__ */ m(
+          x,
+          {
+            name: e.id,
+            label: e.label,
+            type: a.type,
+            value: h ?? void 0,
+            onChange: (v) => t.onChange(v),
+            onBlur: t.onBlur,
+            placeholder: e.placeholder,
+            required: e.isRequired && !i,
+            disabled: i,
+            error: g,
+            helperText: g ? o?.error?.message : e?.helpText,
+            allowNegative: f,
+            allowDecimal: a.allowDecimal ?? !0
+          }
+        );
+      }
+    }
+  ) : null;
+};
+export {
+  T as TextField
+};

package/dist/form-react/Fields/TextFieldWithBackendValidation.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { FormFieldProps } from '../types/reactHookForm.types';
+export declare const TextFieldWithBackendValidation: FC<FormFieldProps>;

package/dist/form-react/Fields/TextFieldWithBackendValidation.js

@@ -0,0 +1,117 @@
+import { jsx as m, jsxs as T } from "react/jsx-runtime";
+import { useRef as p, useState as C } from "react";
+import { Controller as k } from "react-hook-form";
+import { SmartInput as I } from "../../components/forms/smart-input/smart-input.js";
+const B = ({
+  field: e,
+  validationRules: g,
+  isDisabled: x,
+  formHelpers: t
+}) => {
+  const i = e.fieldType === "text_with_backend_validation" ? e : null, o = p(!1), l = p(null), [h, f] = C(!1), v = async (r) => {
+    if (i?.validationConfig?.omitValidation?.includes(
+      e.id
+    )) {
+      o.current = !1, l.current = null, await t.form.trigger(e.id);
+      return;
+    }
+    if (!(!r || r.trim() === "")) {
+      f(!0);
+      try {
+        const n = e.handlerName ? t.formContext?.functions?.[e.handlerName] : void 0;
+        let a;
+        if (n) {
+          const d = i?.validationConfig?.fieldValuesToIncludeInApiRequest || [], s = d.length > 0 ? d.reduce(
+            (u, c) => (u[c] = t.form.getValues(c), u),
+            {}
+          ) : {};
+          a = await n({
+            formHelpers: t,
+            fieldId: e.id,
+            newValue: r,
+            oldValue: t.getPreviousFieldValue(e.id),
+            payload: { includedFieldValues: s }
+          });
+        } else {
+          if (!i?.validationConfig)
+            throw new Error("Validation config is required");
+          const d = i.validationConfig.method || "POST", s = i.validationConfig.fieldValuesToIncludeInApiRequest || [], u = s.length > 0 ? s.reduce(
+            (V, w) => (V[w] = t.form.getValues(w), V),
+            {}
+          ) : {}, c = i.validationConfig.apiEndpoint;
+          if (!c)
+            throw new Error("API endpoint is required");
+          if (a = await t.formContext?.transport?.validateTextFieldWithBackend?.(
+            {
+              formHelpers: t,
+              apiEndpoint: c,
+              value: r,
+              method: d,
+              fieldValuesToIncludeInApiRequest: u
+            }
+          ), !a)
+            throw new Error(
+              "formContext.transport.validateTextFieldWithBackend is required"
+            );
+        }
+        a?.is_valid ? (o.current = !1, l.current = null, await t.form.trigger(e.id)) : (o.current = !0, l.current = a?.message?.trim() || `This ${e.label} is already taken`, await t.form.trigger(e.id));
+      } catch (n) {
+        o.current = !0, l.current = n instanceof Error ? n.message : `This ${e.label} is already taken`, await t.form.trigger(e.id), t.formContext?.transport?.showFormErrorToast?.({
+          title: "Error",
+          description: n instanceof Error ? n.message : "Something went wrong"
+        });
+      } finally {
+        f(!1);
+      }
+    }
+  };
+  return i ? /* @__PURE__ */ m(
+    k,
+    {
+      name: e.id,
+      control: t.form.control,
+      rules: {
+        ...g,
+        validate: {
+          ...typeof g?.validate == "object" ? g.validate : {},
+          backendValidation: () => o.current ? l.current || "Validation pending" : !0
+        }
+      },
+      render: ({ field: r, fieldState: n }) => {
+        const a = !!n.error && n.error.message !== "Validation pending", d = r.value, s = a && !h ? n.error?.message : void 0;
+        return /* @__PURE__ */ T("div", { className: "w-full min-w-0", children: [
+          /* @__PURE__ */ m(
+            I,
+            {
+              label: e.label,
+              type: "text",
+              value: d ?? void 0,
+              onChange: (u) => {
+                u ? (o.current = !0, l.current = null) : (o.current = !1, l.current = null), r.onChange(u);
+              },
+              onBlur: () => {
+                r.onBlur(), v(d ?? "");
+              },
+              placeholder: e.placeholder,
+              required: e.isRequired,
+              disabled: x,
+              error: a && !h,
+              helperText: h ? "Validating…" : a ? void 0 : e.helpText
+            }
+          ),
+          s ? /* @__PURE__ */ m(
+            "p",
+            {
+              className: "mt-2 text-sm leading-snug text-[#DC2626] break-words",
+              role: "alert",
+              children: s
+            }
+          ) : null
+        ] });
+      }
+    }
+  ) : null;
+};
+export {
+  B as TextFieldWithBackendValidation
+};

package/dist/form-react/Fields/WeekRangePicker.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+import { FormFieldProps } from '../types/reactHookForm.types';
+import { UseReactHookFormReturn } from '../hooks/useReactHookForm';
+interface WeekRangeFieldProps extends FormFieldProps {
+    formHelpers: UseReactHookFormReturn;
+}
+export declare const WeekRangeField: FC<WeekRangeFieldProps>;
+export {};

package/dist/form-react/Fields/WeekRangePicker.js

@@ -0,0 +1,71 @@
+import { jsx as D } from "react/jsx-runtime";
+import { Controller as F } from "react-hook-form";
+import { WeekRangePicker as O } from "../../components/forms/date-picker/week-range-picker.js";
+import { toLocalDate as M } from "../utils/calendar-boundary.js";
+import { resolveWeekRangeMinMax as x } from "../utils/date.utils.js";
+const p = (e) => {
+  const r = e.getFullYear(), n = e.getMonth(), t = new Date(r, n, 1).getDay(), a = e.getDate(), l = Math.ceil((a + t) / 7), s = new Date(e), h = new Date(s);
+  return {
+    year: r,
+    month: n,
+    weekOfMonth: l,
+    startDate: s,
+    endDate: h
+  };
+}, b = ({
+  field: e,
+  validationRules: r,
+  isDisabled: n,
+  formHelpers: i
+}) => {
+  const t = e.fieldType === "week_range" ? e : null;
+  if (!t) return null;
+  const { minDate: a, maxDate: l, startMonth: s, endMonth: h } = x(t), g = i.form.control;
+  return /* @__PURE__ */ D(
+    F,
+    {
+      name: e.id,
+      control: g,
+      rules: r,
+      render: ({ field: S, fieldState: m }) => {
+        const d = !!m.error, c = S.value, f = c?.start ? M(c.start) ?? null : null, u = c?.end ? M(c.end) ?? null : null, k = f && u;
+        return /* @__PURE__ */ D("div", { children: /* @__PURE__ */ D(
+          O,
+          {
+            label: e.label,
+            ...k && {
+              value: {
+                from: p(f),
+                to: p(u)
+              }
+            },
+            onChange: (o) => {
+              const w = o?.from?.startDate ? `${o.from.startDate.getFullYear()}-${String(o.from.startDate.getMonth() + 1).padStart(2, "0")}-${String(o.from.startDate.getDate()).padStart(2, "0")}` : null, y = o?.to?.endDate ? `${o.to.endDate.getFullYear()}-${String(o.to.endDate.getMonth() + 1).padStart(2, "0")}-${String(o.to.endDate.getDate()).padStart(2, "0")}` : null;
+              i.setValue(e.id, { start: w, end: y });
+            },
+            placeholder: t.placeholder,
+            startMonth: a ?? s,
+            endMonth: l ?? h,
+            required: e.isRequired,
+            disabled: n,
+            error: d,
+            helperText: d ? m.error?.message : e.helpText,
+            calendarType: t.calendarType,
+            fiscalMode: t.fiscalMode,
+            weekStartsOn: t.weekStartsOn,
+            minDate: a,
+            maxDate: l,
+            selectionMode: t.selectionMode,
+            fiscalMonthPattern: t.fiscalMonthPattern,
+            fiscalYearStartMonth: t.fiscalYearStartMonth,
+            showFooter: t.showFooter,
+            format: t.dateFormat
+          }
+        ) });
+      }
+    }
+  );
+};
+export {
+  b as WeekRangeField
+};

package/dist/form-react/ReactHooksForm.d.ts

@@ -0,0 +1,3 @@
+import { ReactHooksFormProps, ReactHooksFormRef } from './types/reactHookForm.types';
+export type { ReactHooksFormRef } from './types/reactHookForm.types';
+export declare const ReactHooksForm: import('react').ForwardRefExoticComponent<ReactHooksFormProps & import('react').RefAttributes<ReactHooksFormRef>>;

package/dist/form-react/ReactHooksForm.js

@@ -0,0 +1,132 @@
+import { jsx as c } from "react/jsx-runtime";
+import { forwardRef as O, useRef as m, useEffect as n, useCallback as j, useImperativeHandle as x } from "react";
+import { useReactHookForm as G } from "./hooks/useReactHookForm.js";
+import { GRID_COLS_MAP as M, GAP_X_MAP as $, GAP_Y_MAP as N } from "./utils/fieldRendererUtils.js";
+import { FormFieldRow as P } from "./components/FormFieldRow.js";
+import { showFormValidationFailureFeedback as q } from "./utils/formValidationFeedback.utils.js";
+import { resolveFormSubmittable as B, mergeFormValidationFieldErrors as L } from "./utils/resolveFormSubmittable.js";
+import { validateVisibleRequiredFormFields as X } from "./utils/validateVisibleRequiredFormFields.js";
+const C = O(
+  ({
+    formId: R,
+    formConfig: i,
+    formInitialState: E,
+    onSubmit: h,
+    onCancel: v,
+    onReset: S,
+    sendFormStateToParent: t,
+    supportedValues: g,
+    formContext: o
+  }, k) => {
+    const r = G(
+      i,
+      E,
+      h,
+      v,
+      S,
+      o
+    ), { errors: w, isValid: H, isDirty: y, isValidating: D } = r.form.formState, u = m(r), f = m(t), b = m(o), F = m(i.fields);
+    n(() => {
+      u.current = r, f.current = t, b.current = o, F.current = i.fields;
+    });
+    const l = j(() => {
+      const e = f.current;
+      if (!e)
+        return;
+      const s = u.current;
+      e(
+        s.form.formState,
+        s.form.getValues(),
+        {
+          isSubmittable: B({
+            formConfigFields: F.current,
+            formHelpers: s,
+            formContext: b.current
+          })
+        }
+      );
+    }, []);
+    n(() => {
+      if (!t)
+        return;
+      l();
+      const e = r.form.watch(() => {
+        l();
+      });
+      return () => e.unsubscribe();
+    }, [t, l, r.form]), n(() => {
+      t && l();
+    }, [
+      t,
+      l,
+      w,
+      H,
+      y,
+      D
+    ]), x(
+      k,
+      () => ({
+        submitForm: async () => {
+          const e = i.fields.filter(
+            (a) => r.isFieldVisible(a)
+          ), s = X(
+            r.form,
+            e,
+            {
+              isFieldDisabled: r.isFieldDisabled,
+              isFieldDisabledForValidation: r.isFieldDisabledForSubmitValidation,
+              formHelpers: r
+            }
+          ), d = o?.validateForm?.({
+            formValues: r.form.getValues(),
+            visibleFields: e
+          }), A = L(
+            s.fieldErrors,
+            d?.fieldErrors
+          );
+          return s.isValid && (d?.isValid ?? !0) ? (r.submitValidatedForm(void 0), !0) : (d?.fieldErrors && Object.entries(d.fieldErrors).forEach(
+            ([a, I]) => {
+              r.form.setError(a, {
+                type: "validate",
+                message: I.message
+              });
+            }
+          ), q({
+            fieldErrors: A,
+            fieldsInOrder: e,
+            showToast: (a) => {
+              r.formContext?.transport?.showFormErrorToast?.(
+                a
+              );
+            }
+          }), !1);
+        },
+        hasErrors: Object.keys(r.form.formState?.errors || {}).length > 0,
+        errors: r.form.formState?.errors,
+        isValid: r.form.formState?.isValid
+      }),
+      [i.fields, r, o]
+    );
+    const p = i.gapBetweenFields ?? 6, _ = `grid ${M[i.columns || 1]} ${$[p] ?? "gap-x-6"} ${N[p] ?? "gap-y-6"}`, V = (e) => /* @__PURE__ */ c(
+      P,
+      {
+        field: e,
+        formHelpers: r,
+        formConfig: i,
+        supportedValues: g
+      },
+      e.id
+    );
+    return /* @__PURE__ */ c(
+      "form",
+      {
+        id: R || "react-hooks-form",
+        onSubmit: r.handleSubmit(void 0),
+        children: /* @__PURE__ */ c("div", { className: _, children: i?.enableFieldOrdering ? i?.fields?.sort((e, s) => (e?.order ?? 0) - (s?.order ?? 0)).map(V) : i?.fields?.map(V) })
+      }
+    );
+  }
+);
+export {
+  C as ReactHooksForm
+};

package/dist/form-react/components/ArrayFieldRenderer.d.ts

@@ -0,0 +1,13 @@
+import { FC } from 'react';
+import { ArrayFieldConfig } from '../types/fields.types';
+import { IFormConfig } from '../types/reactHookForm.types';
+import { UseReactHookFormReturn } from '../hooks/useReactHookForm';
+interface ArrayFieldRendererProps {
+    field: ArrayFieldConfig;
+    fieldPathPrefix?: string;
+    formHelpers: UseReactHookFormReturn;
+    formConfig: IFormConfig;
+    supportedValues?: Record<string, unknown>;
+}
+export declare const ArrayFieldRenderer: FC<ArrayFieldRendererProps>;
+export {};