impact-nova 2.5.5 → 2.5.6

package/dist/form-engine/field-dependency-graph.d.ts

@@ -1,10 +1,7 @@
 import { FieldDependency, FieldVisibilityBase, FormValuesSnapshot } from './types';
 export declare function collectFieldDependencyIds(field: FieldVisibilityBase): string[];
 export declare function computeIsFieldVisible(field: FieldVisibilityBase, formValues: FormValuesSnapshot): boolean;
-export declare function computeIsFieldDisabled(field: FieldVisibilityBase, formValues: FormValuesSnapshot, options?: {
-    isCascadingDisabled?: (field: FieldVisibilityBase) => boolean;
-}): boolean;
-export declare function computeIsCascadingDisabled(field: FieldVisibilityBase, formValues: FormValuesSnapshot, isCascadingEnabled: boolean): boolean;
+export declare function computeIsFieldDisabled(field: FieldVisibilityBase, formValues: FormValuesSnapshot): boolean;
 export declare function getDependentFieldIds(allFields: FieldVisibilityBase[], changedFieldName: string): string[];
 export declare function buildCascadeParentFormState(cascadingDependency: FieldDependency[] | undefined, formValues: FormValuesSnapshot): Record<string, unknown> | null;
 export declare function collectFormWatchFieldIds(fields: FieldVisibilityBase[]): string[];

package/dist/form-engine/field-dependency-graph.js

@@ -1,90 +1,86 @@
 import { isEmptyValue as l } from "./is-empty-value.js";
-function a(e) {
+function u(n) {
   const t = /* @__PURE__ */ new Set();
-  return e.visibilityDependency?.forEach((n) => {
-    t.add(n.fieldId);
-  }), e.disableDependency?.forEach((n) => {
-    t.add(n.fieldId);
-  }), e.cascadingDependency?.forEach((n) => {
-    t.add(n.fieldId);
+  return n.visibilityDependency?.forEach((e) => {
+    t.add(e.fieldId);
+  }), n.disableDependency?.forEach((e) => {
+    t.add(e.fieldId);
+  }), n.cascadingDependency?.forEach((e) => {
+    t.add(e.fieldId);
   }), Array.from(t);
 }
-function d(e, t) {
-  return !e.visibilityDependency || e.visibilityDependency.length === 0 ? !0 : e.visibilityDependency.every((n) => t[n.fieldId] === n.value);
-}
-function u(e, t) {
-  const n = t[e.fieldId];
-  return e.value === null ? !l(n) : e.value === "__empty__" ? l(n) : typeof n == "boolean" ? n === (e.value === "true") : Array.isArray(n) ? n.some((r) => typeof r == "object" && r?.value === e.value ? !0 : typeof r == "string" && r === e.value) : typeof n == "object" && n !== null && "value" in n ? n.value === e.value : n === e.value;
+function d(n, t) {
+  return !n.visibilityDependency || n.visibilityDependency.length === 0 ? !0 : n.visibilityDependency.every((e) => {
+    const r = t[e.fieldId];
+    return e.value === "__empty__" ? l(r) : r === e.value;
+  });
 }
-function s(e, t, n) {
-  return !!(!d(e, t) || e.isDisabled || e.disableDependency && e.disableDependency.length > 0 && (e.disableDependencyMode === "every" ? e.disableDependency.every(
-    (i) => u(i, t)
-  ) : e.disableDependency.some(
-    (i) => u(i, t)
-  )) || n?.isCascadingDisabled?.(e));
+function o(n, t) {
+  const e = t[n.fieldId];
+  return n.value === null ? !l(e) : n.value === "__empty__" ? l(e) : typeof e == "boolean" ? e === (n.value === "true") : Array.isArray(e) ? e.some((r) => typeof r == "object" && r?.value === n.value ? !0 : typeof r == "string" && r === n.value) : typeof e == "object" && e !== null && "value" in e ? e.value === n.value : e === n.value;
 }
-function f(e, t, n) {
-  return !n || !e.cascadingDependency || e.cascadingDependency.length === 0 ? !1 : e.cascadingDependency.some((r) => {
-    const i = t[r.fieldId];
-    return r.value === null || r.value === void 0 ? l(i) : i === r.value;
-  });
+function s(n, t) {
+  return !!(!d(n, t) || n.isDisabled || n.disableDependency && n.disableDependency.length > 0 && (n.disableDependencyMode === "every" ? n.disableDependency.every(
+    (r) => o(r, t)
+  ) : n.disableDependency.some(
+    (r) => o(r, t)
+  )));
 }
-function y(e, t) {
-  return e.filter(
-    (n) => n.cascadingDependency?.some(
+function f(n, t) {
+  return n.filter(
+    (e) => e.cascadingDependency?.some(
       (r) => r.fieldId === t
     )
-  ).map((n) => n.id);
+  ).map((e) => e.id);
 }
-function p(e, t) {
-  if (!e || e.length === 0)
+function y(n, t) {
+  if (!n || n.length === 0)
     return null;
-  const n = {};
-  for (const r of e) {
+  const e = {};
+  for (const r of n) {
     const i = t[r.fieldId];
-    i == null || i === "" || Array.isArray(i) && i.length === 0 || (n[r.fieldId] = i);
+    i == null || i === "" || Array.isArray(i) && i.length === 0 || (e[r.fieldId] = i);
   }
-  return Object.keys(n).length > 0 ? n : null;
+  return Object.keys(e).length > 0 ? e : null;
 }
-function o(e) {
+function c(n) {
   const t = /* @__PURE__ */ new Set();
-  for (const n of e) {
-    n.doNotIncludeInSubmit || t.add(n.id);
-    for (const r of a(n))
+  for (const e of n) {
+    e.doNotIncludeInSubmit || t.add(e.id);
+    for (const r of u(e))
       t.add(r);
   }
   return Array.from(t);
 }
-function b(e) {
-  return o(e);
+function b(n) {
+  return c(n);
 }
-function v(e) {
+function p(n) {
   const t = /* @__PURE__ */ new Set();
-  for (const n of e) {
-    t.add(n.id);
-    for (const r of a(n))
+  for (const e of n) {
+    t.add(e.id);
+    for (const r of u(e))
       t.add(r);
   }
   return Array.from(t);
 }
-function D(e, t, n) {
-  return e.some(
-    (r) => !!t[r.id] && d(r, n)
+function I(n, t, e) {
+  return n.some(
+    (r) => !!t[r.id] && d(r, e)
   );
 }
-function I(e, t) {
-  return e.filter((n) => d(n, t)).map((n) => n.id);
+function v(n, t) {
+  return n.filter((e) => d(e, t)).map((e) => e.id);
 }
 export {
-  p as buildCascadeParentFormState,
-  a as collectFieldDependencyIds,
+  y as buildCascadeParentFormState,
+  u as collectFieldDependencyIds,
   b as collectFilterSidebarWatchFieldIds,
-  o as collectFormWatchFieldIds,
-  v as collectSectionWatchFieldIds,
-  I as collectVisibleFieldIds,
-  f as computeIsCascadingDisabled,
+  c as collectFormWatchFieldIds,
+  p as collectSectionWatchFieldIds,
+  v as collectVisibleFieldIds,
   s as computeIsFieldDisabled,
   d as computeIsFieldVisible,
-  y as getDependentFieldIds,
-  D as hasVisibleFieldErrors
+  f as getDependentFieldIds,
+  I as hasVisibleFieldErrors
 };

package/dist/form-engine/field-groups.d.ts

@@ -0,0 +1,15 @@
+import { FieldGroup, FieldVisibilityBase, FormStepConfig, FormValuesSnapshot } from './types';
+/**
+ * Group fields by `fieldGroup`, preserving declaration order.
+ * Fields without `fieldGroup` are collected into a `'_default'` group.
+ * When `stepConfigs` is provided, groups are ordered to match and enriched with title/description.
+ */
+export declare function buildFieldGroups(fields: FieldVisibilityBase[], stepConfigs?: FormStepConfig[]): FieldGroup[];
+/**
+ * Check if all visible required fields in a step have non-empty values and no errors.
+ */
+export declare function isStepComplete(stepFieldIds: string[], fields: FieldVisibilityBase[], formValues: FormValuesSnapshot, fieldErrors: Record<string, unknown>): boolean;
+/**
+ * Return the index of the first incomplete step, or -1 if all steps are complete.
+ */
+export declare function getFirstIncompleteStep(groups: FieldGroup[], fields: FieldVisibilityBase[], formValues: FormValuesSnapshot, fieldErrors: Record<string, unknown>): number;

package/dist/form-engine/field-groups.js

@@ -0,0 +1,60 @@
+import { isEmptyValue as s } from "./is-empty-value.js";
+import { computeIsFieldVisible as u } from "./field-dependency-graph.js";
+const l = "_default";
+function g(d, r) {
+  const i = /* @__PURE__ */ new Map(), n = [];
+  for (const t of d) {
+    const o = t.fieldGroup || l;
+    i.has(o) || (i.set(o, []), n.push(o)), i.get(o).push(t.id);
+  }
+  if (r && r.length > 0) {
+    const t = new Map(r.map((e) => [e.groupId, e])), o = [];
+    for (const e of r) {
+      const f = i.get(e.groupId);
+      f && (o.push({
+        groupId: e.groupId,
+        title: e.title,
+        description: e.description,
+        fieldIds: f,
+        validateBeforeNext: e.validateBeforeNext ?? !0
+      }), i.delete(e.groupId));
+    }
+    for (const e of n) {
+      if (!i.has(e)) continue;
+      const f = t.get(e);
+      o.push({
+        groupId: e,
+        title: f?.title,
+        description: f?.description,
+        fieldIds: i.get(e),
+        validateBeforeNext: f?.validateBeforeNext ?? !0
+      });
+    }
+    return o;
+  }
+  return n.map((t) => ({
+    groupId: t,
+    title: void 0,
+    description: void 0,
+    fieldIds: i.get(t),
+    validateBeforeNext: !0
+  }));
+}
+function p(d, r, i, n) {
+  const t = new Set(d), o = r.filter((e) => t.has(e.id));
+  for (const e of o)
+    if (u(e, i) && (n[e.id] || e.isRequired && s(i[e.id])))
+      return !1;
+  return !0;
+}
+function I(d, r, i, n) {
+  for (let t = 0; t < d.length; t++)
+    if (!p(d[t].fieldIds, r, i, n))
+      return t;
+  return -1;
+}
+export {
+  g as buildFieldGroups,
+  I as getFirstIncompleteStep,
+  p as isStepComplete
+};

package/dist/form-engine/index.d.ts

@@ -5,5 +5,6 @@
  * @packageDocumentation
  */
 export { isEmptyValue } from './is-empty-value';
-export type { FieldDependency, FieldVisibilityBase, FormValuesSnapshot, } from './types';
-export { buildCascadeParentFormState, collectFieldDependencyIds, collectFormWatchFieldIds, collectFilterSidebarWatchFieldIds, collectSectionWatchFieldIds, collectVisibleFieldIds, computeIsCascadingDisabled, computeIsFieldDisabled, computeIsFieldVisible, getDependentFieldIds, hasVisibleFieldErrors, } from './field-dependency-graph';
+export type { FieldDependency, FieldGroup, FieldVisibilityBase, FormStepConfig, FormValuesSnapshot, } from './types';
+export { buildCascadeParentFormState, collectFieldDependencyIds, collectFormWatchFieldIds, collectFilterSidebarWatchFieldIds, collectSectionWatchFieldIds, collectVisibleFieldIds, computeIsFieldDisabled, computeIsFieldVisible, getDependentFieldIds, hasVisibleFieldErrors, } from './field-dependency-graph';
+export { buildFieldGroups, isStepComplete, getFirstIncompleteStep, } from './field-groups';

package/dist/form-engine/index.js

@@ -1,16 +1,19 @@
-import { isEmptyValue as d } from "./is-empty-value.js";
-import { buildCascadeParentFormState as t, collectFieldDependencyIds as c, collectFilterSidebarWatchFieldIds as s, collectFormWatchFieldIds as o, collectSectionWatchFieldIds as a, collectVisibleFieldIds as r, computeIsCascadingDisabled as F, computeIsFieldDisabled as I, computeIsFieldVisible as m, getDependentFieldIds as p, hasVisibleFieldErrors as b } from "./field-dependency-graph.js";
+import { isEmptyValue as t } from "./is-empty-value.js";
+import { buildCascadeParentFormState as d, collectFieldDependencyIds as o, collectFilterSidebarWatchFieldIds as c, collectFormWatchFieldIds as s, collectSectionWatchFieldIds as r, collectVisibleFieldIds as F, computeIsFieldDisabled as p, computeIsFieldVisible as a, getDependentFieldIds as m, hasVisibleFieldErrors as I } from "./field-dependency-graph.js";
+import { buildFieldGroups as n, getFirstIncompleteStep as u, isStepComplete as S } from "./field-groups.js";
 export {
-  t as buildCascadeParentFormState,
-  c as collectFieldDependencyIds,
-  s as collectFilterSidebarWatchFieldIds,
-  o as collectFormWatchFieldIds,
-  a as collectSectionWatchFieldIds,
-  r as collectVisibleFieldIds,
-  F as computeIsCascadingDisabled,
-  I as computeIsFieldDisabled,
-  m as computeIsFieldVisible,
-  p as getDependentFieldIds,
-  b as hasVisibleFieldErrors,
-  d as isEmptyValue
+  d as buildCascadeParentFormState,
+  n as buildFieldGroups,
+  o as collectFieldDependencyIds,
+  c as collectFilterSidebarWatchFieldIds,
+  s as collectFormWatchFieldIds,
+  r as collectSectionWatchFieldIds,
+  F as collectVisibleFieldIds,
+  p as computeIsFieldDisabled,
+  a as computeIsFieldVisible,
+  m as getDependentFieldIds,
+  u as getFirstIncompleteStep,
+  I as hasVisibleFieldErrors,
+  t as isEmptyValue,
+  S as isStepComplete
 };

package/dist/form-engine/types.d.ts

@@ -14,4 +14,21 @@ export type FieldVisibilityBase = {
     cascadingDependency?: FieldDependency[];
     isDisabled?: boolean;
     doNotIncludeInSubmit?: boolean;
+    fieldGroup?: string;
+};
+/** Step/group metadata provided via `IFormConfig.steps`. */
+export type FormStepConfig = {
+    groupId: string;
+    title?: string;
+    description?: string;
+    /** When true, all required fields in this step must be valid before proceeding. Default: true. */
+    validateBeforeNext?: boolean;
+};
+/** Resolved field group produced by `buildFieldGroups`. */
+export type FieldGroup = {
+    groupId: string;
+    title?: string;
+    description?: string;
+    fieldIds: string[];
+    validateBeforeNext: boolean;
 };

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

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

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

@@ -0,0 +1,214 @@
+import { jsx as n, jsxs as u } from "react/jsx-runtime";
+import { useMemo as b, useCallback as T, useRef as v, useEffect as D } from "react";
+import { Controller as L } from "react-hook-form";
+import { LexicalComposer as O } from "@lexical/react/LexicalComposer";
+import { RichTextPlugin as M } from "@lexical/react/LexicalRichTextPlugin";
+import { ContentEditable as k } from "@lexical/react/LexicalContentEditable";
+import { HistoryPlugin as _ } from "@lexical/react/LexicalHistoryPlugin";
+import { OnChangePlugin as S } from "@lexical/react/LexicalOnChangePlugin";
+import { ListPlugin as y } from "@lexical/react/LexicalListPlugin";
+import { LinkPlugin as $ } from "@lexical/react/LexicalLinkPlugin";
+import { LexicalErrorBoundary as H } from "@lexical/react/LexicalErrorBoundary";
+import { useLexicalComposerContext as N } from "@lexical/react/LexicalComposerContext";
+import { $generateHtmlFromNodes as I, $generateNodesFromDOM as w } from "@lexical/html";
+import { ListNode as A, ListItemNode as B, INSERT_UNORDERED_LIST_COMMAND as P, INSERT_ORDERED_LIST_COMMAND as q } from "@lexical/list";
+import { LinkNode as U, $toggleLink as F } from "@lexical/link";
+import { HeadingNode as j, QuoteNode as Q, $createHeadingNode as z, $createQuoteNode as X } from "@lexical/rich-text";
+import { $getRoot as G, UNDO_COMMAND as J, REDO_COMMAND as K, FORMAT_TEXT_COMMAND as m, $getSelection as g, $isRangeSelection as f } from "lexical";
+import { $setBlocksType as x } from "@lexical/selection";
+const V = {
+  paragraph: "rt-paragraph",
+  heading: { h2: "rt-h2", h3: "rt-h3" },
+  text: {
+    bold: "rt-bold",
+    italic: "rt-italic",
+    underline: "rt-underline"
+  },
+  list: {
+    ul: "rt-ul",
+    ol: "rt-ol",
+    listitem: "rt-li"
+  },
+  link: "rt-link",
+  quote: "rt-quote"
+}, W = [
+  "undo",
+  "redo",
+  "bold",
+  "italic",
+  "underline",
+  "strikethrough",
+  "heading",
+  "quote",
+  "link",
+  "bulletedList",
+  "numberedList"
+], Y = [j, Q, A, B, U];
+function Z({ items: o }) {
+  const [e] = N(), i = b(() => new Set(o), [o]), r = (t, l, s, a) => i.has(l) ? /* @__PURE__ */ n(
+    "button",
+    {
+      type: "button",
+      className: "inline-flex h-7 w-7 items-center justify-center rounded text-xs hover:bg-muted",
+      title: a ?? t,
+      onMouseDown: (d) => {
+        d.preventDefault(), s();
+      },
+      children: t
+    },
+    l
+  ) : null;
+  return /* @__PURE__ */ u("div", { className: "flex flex-wrap items-center gap-0.5 border-b px-1 py-0.5", children: [
+    r("↩", "undo", () => e.dispatchCommand(J, void 0), "Undo"),
+    r("↪", "redo", () => e.dispatchCommand(K, void 0), "Redo"),
+    (i.has("undo") || i.has("redo")) && i.size > 2 && /* @__PURE__ */ n("span", { className: "mx-0.5 h-4 w-px bg-border" }),
+    r("B", "bold", () => e.dispatchCommand(m, "bold"), "Bold"),
+    r("I", "italic", () => e.dispatchCommand(m, "italic"), "Italic"),
+    r("U", "underline", () => e.dispatchCommand(m, "underline"), "Underline"),
+    r("S", "strikethrough", () => e.dispatchCommand(m, "strikethrough"), "Strikethrough"),
+    r("H", "heading", () => {
+      e.update(() => {
+        const t = g();
+        f(t) && x(t, () => z("h2"));
+      });
+    }, "Heading"),
+    r("❝", "quote", () => {
+      e.update(() => {
+        const t = g();
+        f(t) && x(t, () => X());
+      });
+    }, "Block quote"),
+    r("🔗", "link", () => {
+      const t = prompt("URL:");
+      t && e.update(() => {
+        F(t);
+      });
+    }, "Insert link"),
+    r("•", "bulletedList", () => e.dispatchCommand(P, void 0), "Bulleted list"),
+    r("1.", "numberedList", () => e.dispatchCommand(q, void 0), "Numbered list")
+  ] });
+}
+function ee({ html: o }) {
+  const [e] = N(), i = v(!1);
+  return D(() => {
+    i.current || !o || (i.current = !0, e.update(() => {
+      const t = new DOMParser().parseFromString(o, "text/html"), l = w(e, t), s = G();
+      s.clear(), s.append(...l);
+    }));
+  }, [e, o]), null;
+}
+const Ce = ({
+  field: o,
+  validationRules: e,
+  isDisabled: i,
+  formHelpers: r
+}) => {
+  const t = o.fieldType === "rich_text" ? o : null;
+  if (!t) return null;
+  const l = t.toolbar ?? W, s = t.minHeight ?? 150;
+  return /* @__PURE__ */ n(
+    L,
+    {
+      name: o.id,
+      control: r.form.control,
+      rules: e,
+      render: ({ field: a, fieldState: d }) => {
+        const c = !!d.error;
+        return /* @__PURE__ */ n(
+          te,
+          {
+            initialHtml: a.value ?? "",
+            onChange: a.onChange,
+            disabled: i,
+            toolbar: l,
+            minHeight: s,
+            label: o.label,
+            isRequired: o.isRequired,
+            helpText: o.helpText,
+            error: c ? d.error?.message : void 0,
+            fieldId: o.id
+          }
+        );
+      }
+    }
+  );
+};
+function te({
+  initialHtml: o,
+  onChange: e,
+  disabled: i,
+  toolbar: r,
+  minHeight: t,
+  label: l,
+  isRequired: s,
+  helpText: a,
+  error: d,
+  fieldId: c
+}) {
+  const C = b(
+    () => ({
+      namespace: `rich-text-${c}`,
+      nodes: Y,
+      theme: V,
+      editable: !i,
+      onError: (p) => console.error("[RichTextField]", p)
+    }),
+    // ponytail: intentionally only fieldId — LexicalComposer reads initialConfig once
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [c]
+  ), E = T(
+    (p, h) => {
+      h.read(() => {
+        const R = I(h);
+        e(R);
+      });
+    },
+    [e]
+  );
+  return /* @__PURE__ */ u("div", { children: [
+    l && /* @__PURE__ */ u("label", { className: "mb-2 block text-xs font-medium text-content-muted", children: [
+      l,
+      s && /* @__PURE__ */ n("span", { className: "ml-1 text-destructive", children: "*" })
+    ] }),
+    /* @__PURE__ */ n(
+      "div",
+      {
+        className: "overflow-hidden rounded-md border",
+        style: i ? { opacity: 0.5, pointerEvents: "none" } : void 0,
+        children: /* @__PURE__ */ u(O, { initialConfig: C, children: [
+          /* @__PURE__ */ n(Z, { items: r }),
+          /* @__PURE__ */ n(
+            M,
+            {
+              contentEditable: /* @__PURE__ */ n(
+                k,
+                {
+                  className: "outline-none px-3 py-2",
+                  style: { minHeight: t },
+                  "aria-placeholder": l ?? c,
+                  placeholder: /* @__PURE__ */ n("div", { className: "pointer-events-none absolute left-3 top-2 text-xs text-content-muted", children: "Start typing…" })
+                }
+              ),
+              ErrorBoundary: H
+            }
+          ),
+          /* @__PURE__ */ n(_, {}),
+          /* @__PURE__ */ n(y, {}),
+          /* @__PURE__ */ n($, {}),
+          /* @__PURE__ */ n(S, { onChange: E }),
+          o && /* @__PURE__ */ n(ee, { html: o })
+        ] })
+      }
+    ),
+    (d || a) && /* @__PURE__ */ n(
+      "p",
+      {
+        className: `mt-1 text-xs ${d ? "text-destructive" : "text-content-muted"}`,
+        children: d ?? a
+      }
+    )
+  ] });
+}
+export {
+  Ce as RichTextField
+};

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

@@ -1,38 +1,37 @@
 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 = ({
+import { useState as A } from "react";
+import { Controller as M } from "react-hook-form";
+import { Select as f } from "../../components/forms/select/select.js";
+import { useSelectOptions as x } from "../hooks/useSelectOptions.js";
+import { getFieldTestId as E } from "../utils/fieldTestIds.js";
+import { isEmptyValue as R } from "../../form-engine/is-empty-value.js";
+const $ = ({
   field: e,
   validationRules: p,
   isDisabled: m,
-  formHelpers: l,
-  formConfig: u,
-  supportedValues: d
+  formHelpers: s,
+  supportedValues: u
 }) => {
-  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({
+  const t = e.fieldType === "select" ? e : null, [d, n] = A(!1), S = s.form.control, h = u?.[e.id], { options: g, isLoading: b, error: y, refetch: O } = x({
     apiConfig: t?.apiConfig,
-    formHelpers: l,
-    formConfig: u,
+    formHelpers: s,
     initialOptions: t?.options,
     id: e.id,
-    isEnabled: S,
+    isEnabled: d,
     getSelectOptionsName: t?.getSelectOptionsName,
-    fieldSupportedValues: b
+    fieldSupportedValues: h,
+    cascadingDependency: e.cascadingDependency
   });
   return t ? /* @__PURE__ */ c(
-    f,
+    M,
     {
       name: e.id,
-      control: h,
+      control: S,
       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"}`;
+      render: ({ field: o, fieldState: l }) => {
+        const a = !!l.error, i = o.value, C = t?.isMultiSelect ? e.id : `${e.id}-${R(i) ? "empty" : "has-value"}`;
         return /* @__PURE__ */ c(
-          x,
+          f,
           {
             id: e.id,
             label: e.label,
@@ -56,21 +55,21 @@ const F = ({
             isSelectAllEnabled: !t?.disableSelectAll,
             labelOrientation: t?.labelOrientation || "top",
             error: a,
-            helperText: a ? n.error?.message : e.helpText,
+            helperText: a ? l.error?.message : e.helpText,
             ignoreAccents: !0,
-            isLoading: O,
+            isLoading: b,
             fetchError: y,
-            onRefetch: C,
-            onMenuOpen: () => s(!0),
-            onMenuClose: () => s(!1),
-            "data-testid": R(e.id)
+            onRefetch: O,
+            onMenuOpen: () => n(!0),
+            onMenuClose: () => n(!1),
+            "data-testid": E(e.id)
           },
-          A
+          C
         );
       }
     }
   ) : null;
 };
 export {
-  F as SelectField
+  $ as SelectField
 };

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

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