impact-nova 2.3.0 → 2.4.0

package/dist/form-react/components/ArrayFieldRenderer.js

@@ -0,0 +1,90 @@
+import { jsxs as s, jsx as r } from "react/jsx-runtime";
+import { useFieldArray as C } from "react-hook-form";
+import { Button as a } from "../../components/primitives/button/button.js";
+import { FormFieldRow as F } from "./FormFieldRow.js";
+import { buildFieldPath as M } from "../utils/fieldPath.utils.js";
+import { GRID_COLS_MAP as _, GAP_X_MAP as k, GAP_Y_MAP as x } from "../utils/fieldRendererUtils.js";
+const z = ({
+  field: e,
+  fieldPathPrefix: p,
+  formHelpers: m,
+  formConfig: n,
+  supportedValues: u
+}) => {
+  const i = M(e.id, p), { fields: o, append: v, remove: b, move: c } = C({
+    control: m.form.control,
+    // RHF FieldArrayPath resolves to `never` for Record<string, unknown>
+    name: i
+  }), h = e.itemColumns ?? n.columns ?? 1, l = n.gapBetweenFields ?? 6, y = `grid ${_[h]} ${k[l] ?? "gap-x-6"} ${x[l] ?? "gap-y-6"}`, A = !e.maxItems || o.length < e.maxItems, P = !e.minItems || o.length > e.minItems;
+  return /* @__PURE__ */ s("div", { className: e.className, children: [
+    e.label && /* @__PURE__ */ r("div", { className: "mb-2 text-sm font-medium text-content-primary", children: e.label }),
+    o.map((g, t) => {
+      const N = `${i}.${t}`;
+      return /* @__PURE__ */ s(
+        "div",
+        {
+          className: "relative mb-4 rounded-md border border-stroke-secondary p-4",
+          children: [
+            /* @__PURE__ */ r("div", { className: y, children: e.itemFields.map((d) => /* @__PURE__ */ r(
+              F,
+              {
+                field: d,
+                fieldPathPrefix: N,
+                forcedDisabled: e.isDisabled,
+                formHelpers: m,
+                formConfig: n,
+                supportedValues: u
+              },
+              d.id
+            )) }),
+            /* @__PURE__ */ s("div", { className: "mt-2 flex items-center gap-2", children: [
+              e.orderable && t > 0 && /* @__PURE__ */ r(
+                a,
+                {
+                  type: "button",
+                  variant: "outline",
+                  size: "sm",
+                  onClick: () => c(t, t - 1),
+                  children: "Move Up"
+                }
+              ),
+              e.orderable && t < o.length - 1 && /* @__PURE__ */ r(
+                a,
+                {
+                  type: "button",
+                  variant: "outline",
+                  size: "sm",
+                  onClick: () => c(t, t + 1),
+                  children: "Move Down"
+                }
+              ),
+              P && /* @__PURE__ */ r(
+                a,
+                {
+                  type: "button",
+                  variant: "destructive",
+                  size: "sm",
+                  onClick: () => b(t),
+                  children: e.removeButtonLabel || "Remove"
+                }
+              )
+            ] })
+          ]
+        },
+        g.id
+      );
+    }),
+    A && /* @__PURE__ */ r(
+      a,
+      {
+        type: "button",
+        variant: "outline",
+        onClick: () => v(e.defaultItemValue ?? {}),
+        children: e.addButtonLabel || "Add"
+      }
+    )
+  ] });
+};
+export {
+  z as ArrayFieldRenderer
+};

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

@@ -0,0 +1,16 @@
+import { FC } from 'react';
+import { IFormConfig, SupportedValuesMap } from '../types/reactHookForm.types';
+import { UseReactHookFormReturn } from '../hooks/useReactHookForm';
+import { IField } from '../types/fields.types';
+export interface FieldRendererProps {
+    field: IField;
+    formHelpers: UseReactHookFormReturn;
+    isVisible: boolean;
+    disabled: boolean;
+    formConfig: IFormConfig;
+    supportedValues?: SupportedValuesMap;
+    fieldPathPrefix?: string;
+}
+/** @deprecated Use {@link FieldRendererProps}. */
+export type FilterFieldComponentProps = FieldRendererProps;
+export declare const FieldRenderer: FC<FieldRendererProps>;

package/dist/form-react/components/FieldRenderer.js

@@ -0,0 +1,68 @@
+import { jsx as r } from "react/jsx-runtime";
+import { useMemo as c } from "react";
+import { SetToEmptyWrapper as u } from "./SetToEmptyWrapper.js";
+import { ObjectFieldRenderer as T } from "./ObjectFieldRenderer.js";
+import { ArrayFieldRenderer as b } from "./ArrayFieldRenderer.js";
+import { buildFieldPath as v } from "../utils/fieldPath.utils.js";
+import { renderRegisteredField as E } from "../registry/resolveFieldComponent.js";
+import { registerDefaultFieldTypes as R } from "../registry/defaultFieldRegistrations.js";
+import { buildFieldValidationRules as S } from "../utils/buildFieldValidationRules.js";
+import { buildEvaluateFieldValidationOptions as j } from "../utils/evaluateFieldValidation.js";
+R();
+const g = ({
+  field: e,
+  formHelpers: o,
+  isVisible: s,
+  disabled: p,
+  formConfig: d,
+  supportedValues: n,
+  fieldPathPrefix: i
+}) => {
+  const t = c(
+    () => i ? { ...e, id: v(e.id, i) } : e,
+    [e, i]
+  ), a = c(() => S(
+    t,
+    j(o, t.id)
+  ), [t, o]);
+  if (!s)
+    return null;
+  if (e.fieldType === "object")
+    return /* @__PURE__ */ r(
+      T,
+      {
+        field: e,
+        fieldPathPrefix: i,
+        formHelpers: o,
+        formConfig: d,
+        supportedValues: n
+      }
+    );
+  if (e.fieldType === "array")
+    return /* @__PURE__ */ r(
+      b,
+      {
+        field: e,
+        fieldPathPrefix: i,
+        formHelpers: o,
+        formConfig: d,
+        supportedValues: n
+      }
+    );
+  const l = !!t.allowSetToEmpty && o.setToEmptyFields.has(t.id), y = p || l, F = {
+    field: l ? { ...t, placeholder: "Set to empty" } : t,
+    formHelpers: o,
+    validationRules: a,
+    isDisabled: y,
+    formConfig: d,
+    supportedValues: n
+  }, m = E(
+    e.fieldType,
+    F,
+    o.formContext?.customFieldTypes
+  );
+  return /* @__PURE__ */ r("div", { className: `col-span-${t.colSpan || 1}`, children: t.allowSetToEmpty ? /* @__PURE__ */ r(u, { fieldId: t.id, formHelpers: o, children: m }) : m });
+};
+export {
+  g as FieldRenderer
+};

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

@@ -0,0 +1,13 @@
+import { FC } from 'react';
+import { IField } from '../types/fields.types';
+import { IFormConfig, SupportedValuesMap, UseReactHookFormReturn } from '../types/reactHookForm.types';
+interface FormFieldRowProps {
+    field: IField;
+    formHelpers: UseReactHookFormReturn;
+    formConfig: IFormConfig;
+    supportedValues?: SupportedValuesMap;
+    fieldPathPrefix?: string;
+    forcedDisabled?: boolean;
+}
+export declare const FormFieldRow: FC<FormFieldRowProps>;
+export {};

package/dist/form-react/components/FormFieldRow.js

@@ -0,0 +1,47 @@
+import { jsx as e } from "react/jsx-runtime";
+import { useMemo as d } from "react";
+import { useWatch as p } from "react-hook-form";
+import { FieldRenderer as F } from "./FieldRenderer.js";
+import { collectFieldDependencyIds as u } from "../../form-engine/field-dependency-graph.js";
+import { getFieldTestId as b } from "../utils/fieldTestIds.js";
+const w = ({
+  field: o,
+  formHelpers: n,
+  formConfig: c,
+  supportedValues: i,
+  fieldPathPrefix: r,
+  forcedDisabled: a = !1
+}) => {
+  const t = d(
+    () => u(o),
+    [o]
+  ), l = t.length > 0 ? t : [o.id];
+  p({
+    control: n.form.control,
+    name: l
+  });
+  const s = n.isFieldVisible(o), m = a || n.isFieldDisabled(o);
+  return s ? /* @__PURE__ */ e(
+    "div",
+    {
+      className: `col-span-${o.colSpan || 1}`,
+      "data-testid": b(o.id),
+      style: o.colSpan ? { gridColumn: `span ${o.colSpan} / span ${o.colSpan}` } : {},
+      children: /* @__PURE__ */ e(
+        F,
+        {
+          field: o,
+          fieldPathPrefix: r,
+          isVisible: s,
+          disabled: m,
+          formHelpers: n,
+          formConfig: c,
+          supportedValues: i
+        }
+      )
+    }
+  ) : null;
+};
+export {
+  w as FormFieldRow
+};

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

@@ -0,0 +1,22 @@
+import { FC } from 'react';
+interface FormFileUploadWrapperProps {
+    label?: string;
+    isRequired?: boolean;
+    fileList?: File[];
+    isDisabled?: boolean;
+    onChange: (fileList: File[]) => void;
+    onBlur: () => void;
+    numberOfFiles: number;
+    validFileTypes: Array<{
+        fileType: string;
+        templateUrl: string;
+        typeOverride: boolean;
+    }>;
+    maxFileSize?: number;
+    shouldShowError?: boolean;
+    errorMessage?: string;
+    helperText?: string;
+    disableDefaultTemplateFetch?: boolean;
+}
+export declare const FormFileUploadWrapper: FC<FormFileUploadWrapperProps>;
+export {};

package/dist/form-react/components/FormFileUploadWrapper.js

@@ -0,0 +1,88 @@
+import { jsxs as a, jsx as t } from "react/jsx-runtime";
+import { FileUpload as g, FileUploadContent as v, FileUploadDropZone as w, FileUploadList as y, FileUploadItem as z } from "../../components/forms/file-upload/file-upload.js";
+import { Button as E } from "../../components/primitives/button/button.js";
+import { useState as k, useCallback as S } from "react";
+const _ = 10 * 1024 * 1024, A = ({
+  label: r,
+  isRequired: f,
+  fileList: l,
+  isDisabled: n,
+  shouldShowError: m,
+  helperText: c,
+  numberOfFiles: N,
+  validFileTypes: d,
+  maxFileSize: o,
+  onChange: p,
+  onBlur: x
+}) => {
+  const [s, u] = k(null), h = d.map((e) => e.fileType), F = d.find(
+    (e) => e.templateUrl
+  )?.templateUrl, $ = (e) => {
+    if (o && e.length > 0 && e.filter((i) => i.size > o).length > 0) {
+      const i = (o / _).toFixed(2);
+      u(`File size exceeds ${i}MB limit`), p([]), x();
+      return;
+    }
+    u(null), p(e), x();
+  }, b = S((e) => {
+    window?.open?.(e, "_blank");
+  }, []);
+  return /* @__PURE__ */ a("div", { children: [
+    r && /* @__PURE__ */ a(
+      "label",
+      {
+        className: `text-sm font-medium leading-[18px] mb-2 block ${n ? "opacity-70" : ""} ${m ? "text-destructive" : ""}`,
+        children: [
+          r,
+          " ",
+          f && /* @__PURE__ */ t("span", { className: "text-destructive", children: "*" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ t(
+      g,
+      {
+        value: l || [],
+        onFilesChange: $,
+        maxFiles: N,
+        accept: h,
+        disabled: n,
+        className: "w-full max-w-full",
+        children: /* @__PURE__ */ a(v, { className: "min-h-[200px]", children: [
+          /* @__PURE__ */ t(
+            w,
+            {
+              subLabel: `Supported formats: ${h.join(", ")}`
+            }
+          ),
+          l && l.length > 0 && /* @__PURE__ */ t(y, { children: l.map((e, U) => /* @__PURE__ */ t(
+            z,
+            {
+              file: e
+            },
+            `${e.name}-${e.size}-${e.lastModified}-${U}`
+          )) }),
+          F && /* @__PURE__ */ a("p", { className: "text-sm text-gray-600 mt-3", children: [
+            "Simplify your upload!",
+            " ",
+            /* @__PURE__ */ t(
+              E,
+              {
+                variant: "link",
+                onClick: () => b(F),
+                disabled: n,
+                className: "text-sm p-0 h-auto inline",
+                children: "Download template"
+              }
+            )
+          ] })
+        ] })
+      }
+    ),
+    s && /* @__PURE__ */ t("p", { className: "text-destructive text-sm mt-1", children: s }),
+    c && !m && !s && /* @__PURE__ */ t("p", { className: "text-content-secondary text-sm mt-1", children: c })
+  ] });
+};
+export {
+  A as FormFileUploadWrapper
+};

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

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

package/dist/form-react/components/ObjectFieldRenderer.js

@@ -0,0 +1,46 @@
+import { jsx as t, jsxs as l } from "react/jsx-runtime";
+import { useState as P } from "react";
+import { FormFieldRow as N } from "./FormFieldRow.js";
+import { buildFieldPath as h } from "../utils/fieldPath.utils.js";
+import { GRID_COLS_MAP as g, GAP_X_MAP as _, GAP_Y_MAP as A } from "../utils/fieldRendererUtils.js";
+const $ = ({
+  field: e,
+  fieldPathPrefix: n,
+  formHelpers: c,
+  formConfig: a,
+  supportedValues: m
+}) => {
+  const d = h(e.id, n), [o, i] = P(e.defaultCollapsed ?? !1), p = e.columns ?? a.columns ?? 1, r = a.gapBetweenFields ?? 6, b = `grid ${g[p]} ${_[r] ?? "gap-x-6"} ${A[r] ?? "gap-y-6"}`, u = [
+    e.bordered ? "rounded-md border border-stroke-secondary p-4" : "",
+    e.className ?? ""
+  ].filter(Boolean).join(" "), x = /* @__PURE__ */ t("div", { className: b, children: e.fields.map((s) => /* @__PURE__ */ t(
+    N,
+    {
+      field: s,
+      fieldPathPrefix: d,
+      forcedDisabled: e.isDisabled,
+      formHelpers: c,
+      formConfig: a,
+      supportedValues: m
+    },
+    s.id
+  )) });
+  return /* @__PURE__ */ l("fieldset", { className: u, children: [
+    e.label && /* @__PURE__ */ t("legend", { className: "mb-2 text-sm font-medium text-content-primary", children: e.collapsible ? /* @__PURE__ */ l(
+      "button",
+      {
+        type: "button",
+        className: "flex items-center gap-1",
+        onClick: () => i((s) => !s),
+        children: [
+          /* @__PURE__ */ t("span", { className: `transition-transform ${o ? "-rotate-90" : ""}`, children: "▾" }),
+          e.label
+        ]
+      }
+    ) : e.label }),
+    !o && x
+  ] });
+};
+export {
+  $ as ObjectFieldRenderer
+};

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

@@ -0,0 +1,16 @@
+import { FC, ReactNode } from 'react';
+import { UseReactHookFormReturn } from '../hooks/useReactHookForm';
+interface SetToEmptyWrapperProps {
+    fieldId: string;
+    formHelpers: UseReactHookFormReturn;
+    children: ReactNode;
+}
+/**
+ * Wraps a form field to add a "Set To Empty" / "Undo" action link.
+ *
+ * - Normal state: renders a "Set To Empty" link (right-aligned above the field).
+ * - Empty state: field is disabled, link reads "Undo", and an info message is shown below.
+ * - When the user clicks the disabled field, the "Undo" button flashes once (AG Grid style).
+ */
+export declare const SetToEmptyWrapper: FC<SetToEmptyWrapperProps>;
+export {};

package/dist/form-react/components/SetToEmptyWrapper.js

@@ -0,0 +1,49 @@
+import { jsxs as i, jsx as e } from "react/jsx-runtime";
+import { useState as m, useCallback as c } from "react";
+import { Button as u } from "../../components/primitives/button/button.js";
+import { Info as d } from "impact-nova-icons";
+const b = ({
+  fieldId: o,
+  formHelpers: a,
+  children: n
+}) => {
+  const t = a.setToEmptyFields.has(o), [s, r] = m(0), p = c(() => {
+    t && r((l) => l + 1);
+  }, [t]);
+  return /* @__PURE__ */ i("div", { className: "relative pb-5 mb-0", children: [
+    /* @__PURE__ */ e(
+      u,
+      {
+        variant: "link",
+        type: "button",
+        className: `absolute top-0 right-0 text-xs font-medium p-0 h-auto leading-[18px] z-[1] whitespace-nowrap rounded px-1 -mr-1 ${s > 0 ? "animate-flash-undo" : ""}`,
+        onClick: () => {
+          t ? a.undoSetToEmpty(o) : a.markFieldAsEmpty(o);
+        },
+        children: t ? "Undo" : "Set To Empty"
+      },
+      s
+    ),
+    /* @__PURE__ */ e(
+      "div",
+      {
+        className: "[&_label:first-of-type]:pr-[90px]",
+        onClickCapture: t ? p : void 0,
+        children: n
+      }
+    ),
+    /* @__PURE__ */ i(
+      "div",
+      {
+        className: `absolute bottom-0 left-0 flex items-center gap-1 text-[12px] text-[#60697d] transition-opacity duration-150 ${t ? "opacity-100" : "opacity-0 pointer-events-none"}`,
+        children: [
+          /* @__PURE__ */ e(d, { size: 12, className: "shrink-0" }),
+          /* @__PURE__ */ e("span", { children: "The value is set to empty" })
+        ]
+      }
+    )
+  ] });
+};
+export {
+  b as SetToEmptyWrapper
+};

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

@@ -0,0 +1,23 @@
+/**
+ * Field component value exports — use this subpath when importing React field components.
+ * Config types (`WeekRangeField`, `TextField`, etc.) live on `impact-nova/form-react`.
+ */
+export { TextField } from './Fields/TextField';
+export { TextAreaField } from './Fields/TextAreaField';
+export { ButtonsGroupField } from './Fields/ButtonsGroupField';
+export { RadioField } from './Fields/RadioField';
+export { DateRangeField } from './Fields/DateRangeField';
+export { WeekRangeField } from './Fields/WeekRangePicker';
+export { MonthRangeField } from './Fields/MonthRangeField';
+export { FileUploadField } from './Fields/FileUploadField';
+export { SelectField } from './Fields/SelectField';
+export { CheckboxField } from './Fields/CheckboxField';
+export { SwitchField } from './Fields/SwitchField';
+export { ChipsField } from './Fields/ChipsField';
+export { DateInputField } from './Fields/DateInputField';
+export { FillFormByPasteField } from './Fields/FillFormByPasteField';
+export { FillFormByFileUploadField } from './Fields/FillFormByFileUploadField';
+export { NumericComboboxField } from './Fields/NumericComboboxField';
+export { MultiMonthPickerField } from './Fields/MultiMonthPickerField';
+export { MultiWeekPickerField } from './Fields/MultiWeekPickerField';
+export { TextFieldWithBackendValidation } from './Fields/TextFieldWithBackendValidation';

package/dist/form-react/fields.js

@@ -0,0 +1,40 @@
+import { TextField as r } from "./Fields/TextField.js";
+import { TextAreaField as i } from "./Fields/TextAreaField.js";
+import { ButtonsGroupField as F } from "./Fields/ButtonsGroupField.js";
+import { RadioField as p } from "./Fields/RadioField.js";
+import { DateRangeField as m } from "./Fields/DateRangeField.js";
+import { WeekRangeField as a } from "./Fields/WeekRangePicker.js";
+import { MonthRangeField as c } from "./Fields/MonthRangeField.js";
+import { FileUploadField as k } from "./Fields/FileUploadField.js";
+import { SelectField as B } from "./Fields/SelectField.js";
+import { CheckboxField as R } from "./Fields/CheckboxField.js";
+import { SwitchField as g } from "./Fields/SwitchField.js";
+import { ChipsField as C } from "./Fields/ChipsField.js";
+import { DateInputField as T } from "./Fields/DateInputField.js";
+import { FillFormByPasteField as y } from "./Fields/FillFormByPasteField.js";
+import { FillFormByFileUploadField as S } from "./Fields/FillFormByFileUploadField.js";
+import { NumericComboboxField as w } from "./Fields/NumericComboboxField.js";
+import { MultiMonthPickerField as G } from "./Fields/MultiMonthPickerField.js";
+import { MultiWeekPickerField as N } from "./Fields/MultiWeekPickerField.js";
+import { TextFieldWithBackendValidation as j } from "./Fields/TextFieldWithBackendValidation.js";
+export {
+  F as ButtonsGroupField,
+  R as CheckboxField,
+  C as ChipsField,
+  T as DateInputField,
+  m as DateRangeField,
+  k as FileUploadField,
+  S as FillFormByFileUploadField,
+  y as FillFormByPasteField,
+  c as MonthRangeField,
+  G as MultiMonthPickerField,
+  N as MultiWeekPickerField,
+  w as NumericComboboxField,
+  p as RadioField,
+  B as SelectField,
+  g as SwitchField,
+  i as TextAreaField,
+  r as TextField,
+  j as TextFieldWithBackendValidation,
+  a as WeekRangeField
+};

package/dist/form-react/hooks/useCascadingForm.d.ts

@@ -0,0 +1,17 @@
+import { UseFormReturn } from 'react-hook-form';
+import { IField } from '../types/fields.types';
+import { IFormConfig, FieldVisibilityBase } from '../types/reactHookForm.types';
+import { ReactHookFormState } from './useReactHookForm';
+import { EvaluateFieldValidationOptions } from '../utils/evaluateFieldValidation';
+export interface UseCascadingFormConfig {
+    getFieldDefaultValue: (field: IField) => unknown;
+    resolveFieldValidationEvaluationOptions?: (fieldId: string) => EvaluateFieldValidationOptions | undefined;
+}
+export interface UseCascadingFormReturn {
+    areEarlierMandatoryFieldsFilled: (field: IField) => boolean;
+    clearSubsequentFields: (fieldName: string) => void;
+    getEarlierFieldsIds: (currentFieldId: string, onlyMandatory?: boolean) => string[];
+    setValueWithCascading: (fieldName: string, value: unknown) => void;
+    isCascadingDisabled: (field: FieldVisibilityBase) => boolean;
+}
+export declare const useCascadingForm: (form: UseFormReturn<ReactHookFormState>, formConfig: IFormConfig, cascadingFormConfig: UseCascadingFormConfig) => UseCascadingFormReturn;

package/dist/form-react/hooks/useCascadingForm.js

@@ -0,0 +1,122 @@
+import { useCallback as r, useEffect as g } from "react";
+import { isEmptyValue as V } from "../../form-engine/is-empty-value.js";
+import { getDependentFieldIds as v, computeIsCascadingDisabled as x } from "../../form-engine/field-dependency-graph.js";
+import { batchSetFormFieldValues as D } from "../utils/batchFormFieldUpdates.js";
+import { isFieldValueValid as S } from "../utils/buildFieldValidationRules.js";
+import { findFieldByPath as T } from "../utils/fieldPath.utils.js";
+const B = (a, s, h) => {
+  const { getFieldDefaultValue: c, resolveFieldValidationEvaluationOptions: F } = h, p = r(
+    () => s.fields.filter((e) => e.isRequired),
+    [s.fields]
+  ), y = r(
+    (e) => {
+      if (!s.isCascading)
+        return !0;
+      const n = a.getValues(), d = p(), i = d.findIndex(
+        (t) => t.id === e.id
+      );
+      if (i === -1)
+        return d.every(
+          (t) => !V(n[t.id])
+        );
+      for (let t = 0; t < i; t += 1) {
+        const l = d[t];
+        if (V(n[l.id]))
+          return !1;
+      }
+      return !0;
+    },
+    [a, s.isCascading, p]
+  ), I = r(
+    (e, n = !1) => {
+      let i = s.fields.filter(
+        (l) => l.fieldType !== "label" && l.fieldType !== "divider"
+      );
+      n && (i = i.filter((l) => l.isRequired));
+      const t = i.findIndex(
+        (l) => l.id === e
+      );
+      return t === -1 ? [] : i.slice(0, t).map((l) => l.id);
+    },
+    [s.fields]
+  ), o = r(
+    (e) => {
+      const n = v(
+        s.fields,
+        e
+      ), d = new Set(n);
+      return s.fields.filter(
+        (i) => d.has(i.id)
+      );
+    },
+    [s.fields]
+  ), u = r(
+    (e) => {
+      if (!s.isCascading)
+        return;
+      const n = o(e), d = a.getValues(), i = n.map((t) => {
+        const l = c(t);
+        return d[t.id] === l ? null : {
+          fieldName: t.id,
+          value: l
+        };
+      }).filter(
+        (t) => t !== null
+      );
+      D(a, i, {
+        shouldDirty: !0,
+        shouldValidate: !1
+      });
+    },
+    [a, s.isCascading, o, c]
+  );
+  g(() => {
+    if (!s.isCascading)
+      return;
+    const e = a.watch((n, { name: d, type: i }) => {
+      d && i === "change" && u(d);
+    });
+    return () => e.unsubscribe();
+  }, [a, s.isCascading, u]);
+  const b = r(
+    (e, n) => {
+      a.setValue(e, n, {
+        shouldValidate: !0,
+        shouldDirty: !0
+      });
+      const d = T(s.fields, e);
+      if (d) {
+        const i = F?.(e);
+        S(
+          d,
+          n,
+          i
+        ) && a.clearErrors(e);
+      }
+      u(e);
+    },
+    [
+      a,
+      s.fields,
+      u,
+      F
+    ]
+  ), E = r(
+    (e) => x(
+      e,
+      a.getValues(),
+      !!s.isCascading
+    ),
+    [a, s.isCascading]
+  );
+  return {
+    areEarlierMandatoryFieldsFilled: y,
+    clearSubsequentFields: u,
+    getEarlierFieldsIds: I,
+    setValueWithCascading: b,
+    isCascadingDisabled: E
+  };
+};
+export {
+  B as useCascadingForm
+};