impact-nova 2.3.0 → 2.4.0

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

@@ -0,0 +1,14 @@
+import { UseFormReturn } from 'react-hook-form';
+import { IFormConfig, FieldVisibilityBase, ReactHookFormState } from '../types/reactHookForm.types';
+interface UseFieldVisibilityParams {
+    form: UseFormReturn<ReactHookFormState>;
+    formConfig: IFormConfig;
+    isCascadingDisabled: (field: FieldVisibilityBase) => boolean;
+}
+export interface UseFieldVisibilityReturn {
+    isFieldVisible: (field: FieldVisibilityBase) => boolean;
+    isFieldDisabled: (field: FieldVisibilityBase) => boolean;
+    isFieldDisabledForSubmitValidation: (field: FieldVisibilityBase) => boolean;
+}
+export declare function useFieldVisibility({ form, formConfig, isCascadingDisabled, }: UseFieldVisibilityParams): UseFieldVisibilityReturn;
+export {};

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

@@ -0,0 +1,60 @@
+import { useCallback as c, useRef as y, useEffect as I } from "react";
+import { getFieldDefaultValue as g } from "../utils/fieldDefaults.utils.js";
+import { computeIsFieldVisible as w, computeIsFieldDisabled as a } from "../../form-engine/field-dependency-graph.js";
+function R({
+  form: e,
+  formConfig: u,
+  isCascadingDisabled: n
+}) {
+  const p = c(
+    (t) => w(t, e.getValues()),
+    [e]
+  ), D = c(
+    (t) => a(t, e.getValues(), {
+      isCascadingDisabled: n
+    }),
+    [e, n]
+  ), F = c(
+    (t) => a(t, e.getValues(), {
+      isCascadingDisabled: () => !1
+    }),
+    [e]
+  ), r = y(/* @__PURE__ */ new Set());
+  return I(() => {
+    const t = u.fields.filter(
+      (i) => i.disableDependency && i.disableDependency.length > 0
+    );
+    if (t.length === 0)
+      return;
+    const o = (i) => {
+      const d = /* @__PURE__ */ new Set();
+      for (const l of t)
+        a(l, i ?? e.getValues(), {
+          isCascadingDisabled: n
+        }) && d.add(l.id);
+      return d;
+    };
+    r.current = o(void 0);
+    const V = e.watch((i, d) => {
+      if (!d.name)
+        return;
+      const l = o(i), f = [];
+      for (const s of l)
+        r.current.has(s) || f.push(s);
+      r.current = l;
+      for (const s of f) {
+        const b = u.fields.find(
+          (h) => h.id === s
+        );
+        b && (e.setValue(s, g(b), {
+          shouldValidate: !1,
+          shouldDirty: !0
+        }), e.clearErrors(s));
+      }
+    });
+    return () => V.unsubscribe();
+  }, [e, u.fields, n]), { isFieldVisible: p, isFieldDisabled: D, isFieldDisabledForSubmitValidation: F };
+}
+export {
+  R as useFieldVisibility
+};

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

@@ -0,0 +1,33 @@
+import { UseReactHookFormReturn } from './useReactHookForm';
+import { IField, FillFormByFileUploadField } from '../types/fields.types';
+import { IFormConfig, UploadedFileValidationResult } from '../types/reactHookForm.types';
+interface UseFillFormByFileUploadProps {
+    field: IField;
+    formHelpers: UseReactHookFormReturn;
+    formConfig: IFormConfig;
+    /** Callbacks for this field, already narrowed by the caller. */
+    fieldSupportedValues?: FillFormByFileUploadSupportedValues;
+}
+interface ValidationResult {
+    message: string;
+    hasValidValues: boolean;
+    validCount: number;
+    invalidCount: number;
+}
+export interface FillFormByFileUploadSupportedValues {
+    onValidationStart?: () => void;
+    onValidationComplete?: (response: UploadedFileValidationResult) => void;
+    disableDefaultTemplateFetch?: boolean;
+}
+interface UseFillFormByFileUploadReturn {
+    fileList: File[];
+    isValidating: boolean;
+    validationResult: ValidationResult | null;
+    fillFormField: FillFormByFileUploadField | null;
+    handleFileChange: (newFileList: File[]) => void;
+}
+/**
+ * Custom hook for managing fill form by file upload field state and logic
+ */
+export declare const useFillFormByFileUpload: ({ field, formHelpers, formConfig, fieldSupportedValues, }: UseFillFormByFileUploadProps) => UseFillFormByFileUploadReturn;
+export {};

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

@@ -0,0 +1,199 @@
+import { useState as w, useCallback as g } from "react";
+import { isEmptyValue as R } from "../../form-engine/is-empty-value.js";
+const U = (c) => c.map((l) => ({
+  label: String(l.label),
+  value: l.value
+})), N = (c) => c.map((l) => {
+  if (typeof l == "object" && l !== null && "value" in l)
+    return l;
+  const d = String(l);
+  return { label: d, value: d };
+}), m = (c, l) => {
+  const d = c.options || [], v = new Set(d.map((h) => h.value)), a = l.filter(
+    (h) => !v.has(h.value)
+  );
+  a.length > 0 && (c.options = [...d, ...a]);
+}, q = ({
+  field: c,
+  formHelpers: l,
+  formConfig: d,
+  fieldSupportedValues: v
+}) => {
+  const a = c.fieldType === "fill_form_by_file_upload" ? c : null, [h, x] = w([]), [A, _] = w(!1), [$, f] = w(null), S = g(
+    (t, e) => {
+      const n = l.getValues()[t] || [], i = new Set(n.map((s) => s.value)), o = e.filter(
+        (s) => !i.has(s.value)
+      );
+      o.length > 0 && l.setValue(t, [...n, ...o]);
+    },
+    [l]
+  ), y = g(
+    (t, e) => {
+      e.length > 0 && l.setValue(t, [e[0]]);
+    },
+    [l]
+  ), C = g(
+    (t, e, n) => {
+      const i = U(n);
+      m(e, i), e.isMultiSelect ?? !1 ? S(t, i) : y(t, i);
+    },
+    [S, y]
+  ), F = g(
+    (t, e, n) => {
+      const i = N(n);
+      m(e, i), e.isMultiSelect ?? !1 ? S(t, i) : y(t, i);
+    },
+    [S, y]
+  ), b = g(
+    (t, e, n) => {
+      const i = e.options || [], o = i.find(
+        (s) => s.value === n || s.label === n
+      );
+      if (o)
+        if (e.isMultiSelect ?? !1) {
+          const r = l.getValues()[t] || [];
+          r.some(
+            (V) => V.value === o.value
+          ) || l.setValue(t, [
+            ...r,
+            o
+          ]);
+        } else
+          l.setValue(t, [o]);
+      else {
+        const s = { label: n, value: n };
+        if (e.options = [...i, s], e.isMultiSelect ?? !1) {
+          const u = l.getValues()[t] || [];
+          l.setValue(t, [...u, s]);
+        } else
+          l.setValue(t, [s]);
+      }
+    },
+    [l]
+  ), M = g(
+    (t, e) => {
+      if (R(e))
+        return;
+      const n = d.fields.find(
+        (i) => i.id === t
+      );
+      if (n)
+        if (n.fieldType === "select") {
+          const i = n;
+          if (Array.isArray(e) && e.length > 0 && typeof e[0] == "object" && e[0] !== null && "value" in e[0] && "label" in e[0] && "label" in e[0]) {
+            C(
+              t,
+              i,
+              e
+            );
+            return;
+          }
+          Array.isArray(e) ? F(t, i, e) : typeof e == "string" && b(t, i, e);
+        } else
+          l.setValue(t, e);
+    },
+    [
+      l,
+      d.fields,
+      C,
+      F,
+      b
+    ]
+  ), O = g(
+    async (t) => {
+      if (!(!t || !a)) {
+        _(!0), f(null), v?.onValidationStart?.();
+        try {
+          const e = a.handlerName ? l.formContext?.functions?.[a.handlerName] : void 0, n = a.validationConfig?.apiEndpoint;
+          if (!e && !n) {
+            f({
+              message: "API endpoint not configured",
+              hasValidValues: !1,
+              validCount: 0,
+              invalidCount: 0
+            });
+            return;
+          }
+          const i = e ? await e({
+            formHelpers: l,
+            fieldId: a.id,
+            newValue: l.form.getValues(a.id),
+            oldValue: l.getPreviousFieldValue(a.id),
+            payload: { file: t }
+          }) : await l.formContext?.transport?.validateUploadedFile?.({
+            apiEndpoint: n,
+            file: t
+          });
+          if (!i)
+            throw new Error(
+              "formContext.transport.validateUploadedFile is required for fill_form_by_file_upload fields"
+            );
+          v?.onValidationComplete?.(i);
+          const o = i && i.filtered_values && Object.keys(i.filtered_values).length > 0, s = !!i.session_id, r = i.valid_rows_count || 0, u = i.invalid_rows_count || 0;
+          if (o) {
+            Object.entries(i.filtered_values).forEach(
+              ([j, p]) => {
+                p && p.length > 0 && M(j, p);
+              }
+            );
+            const V = Object.keys(
+              i.filtered_values
+            ).length, T = i.message || `Successfully updated ${V} field(s) with ${r} valid row(s).${u > 0 ? ` ${u} row(s) were invalid.` : ""}`;
+            f({
+              message: T,
+              hasValidValues: r > 0,
+              validCount: r,
+              invalidCount: u
+            });
+          } else if (s) {
+            const V = i.message || `Successfully validated ${r} row(s).${u > 0 ? ` ${u} row(s) were invalid.` : ""}`;
+            f({
+              message: V,
+              hasValidValues: !0,
+              validCount: r,
+              invalidCount: u
+            });
+          } else {
+            const V = i?.message || "No valid values found in the uploaded file.";
+            f({
+              message: V,
+              hasValidValues: !1,
+              validCount: 0,
+              invalidCount: u
+            });
+          }
+        } catch (e) {
+          console.error("File validation error:", e);
+          const n = e instanceof Error ? e.message : "Failed to validate file. Please try again.";
+          f({
+            message: n,
+            hasValidValues: !1,
+            validCount: 0,
+            invalidCount: 0
+          });
+        } finally {
+          _(!1);
+        }
+      }
+    },
+    [a, l, M, v]
+  ), E = g(
+    (t) => {
+      if (x(t), f(null), t.length > 0) {
+        const e = t[0];
+        e instanceof File && O(e);
+      } else t.length === 0 && f(null);
+    },
+    [O]
+  );
+  return {
+    fileList: h,
+    isValidating: A,
+    validationResult: $,
+    fillFormField: a,
+    handleFileChange: E
+  };
+};
+export {
+  q as useFillFormByFileUpload
+};

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

@@ -0,0 +1,33 @@
+import { UseReactHookFormReturn } from './useReactHookForm';
+import { IField, CopyPasteField } from '../types/fields.types';
+import { IFormConfig } from '../types/reactHookForm.types';
+import { Option, ActionMeta } from '../../components/forms/select';
+interface UseFillFormByPasteProps {
+    field: IField;
+    formHelpers: UseReactHookFormReturn;
+    formConfig: IFormConfig;
+}
+interface ValidationResult {
+    message: string;
+    hasValidValues: boolean;
+    validCount: number;
+    invalidCount: number;
+}
+interface UseFillFormByPasteReturn {
+    selectedOption: Option[] | null;
+    textareaValue: string;
+    isValidating: boolean;
+    validationResult: ValidationResult | null;
+    copyPasteField: CopyPasteField | null;
+    handleSelectionChange: (newValue: Option[] | null, actionMeta?: ActionMeta<Option>) => void;
+    handleClearAll: () => void;
+    handleTextareaChange: (value: string) => void;
+    handleValidate: () => void;
+    canValidate: boolean;
+}
+/**
+ * Custom hook for managing fill form by paste field state and logic
+ * Handles validation, target field updates, and form state management
+ */
+export declare const useFillFormByPaste: ({ field, formHelpers, formConfig, }: UseFillFormByPasteProps) => UseFillFormByPasteReturn;
+export {};

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

@@ -0,0 +1,104 @@
+import { useState as V, useCallback as d } from "react";
+const F = ({
+  field: g,
+  formHelpers: a,
+  formConfig: C
+}) => {
+  const t = g.fieldType === "fill_form_by_paste" ? g : null, [c, m] = V(null), [r, f] = V(""), [y, v] = V(!1), [T, i] = V(null), x = d(
+    (e, u) => {
+      const s = C.fields.find(
+        (n) => n.id === e
+      );
+      if (!s || s.fieldType !== "select") return;
+      const l = u.map((n) => ({
+        label: n.label,
+        value: n.value
+      }));
+      if (s.isMultiSelect ?? !1) {
+        const n = a.getValues()?.[e] || [], h = new Set(n.map((p) => p.value)), S = l.filter(
+          (p) => !h.has(p.value)
+        );
+        S.length > 0 && a.setValue(e, [
+          ...n,
+          ...S
+        ]);
+      } else
+        l.length > 0 && a.setValue(e, [l[0]]);
+    },
+    [a, C]
+  ), _ = d(
+    async (e, u) => {
+      if (!e.trim() || !u || !t) return;
+      v(!0), i(null);
+      const s = t.handlerName ? a.formContext?.functions?.[t.handlerName] : void 0;
+      if (!s && !t.validationConfig?.apiEndpoint) {
+        i({
+          message: "Validation endpoint is not configured.",
+          hasValidValues: !1,
+          validCount: 0,
+          invalidCount: 0
+        }), v(!1);
+        return;
+      }
+      try {
+        const l = s ? await s({
+          formHelpers: a,
+          fieldId: t.id,
+          newValue: a.form.getValues(t.id),
+          oldValue: a.getPreviousFieldValue(t.id),
+          payload: { pastedText: e, targetFieldId: u }
+        }) : await a.formContext?.transport?.validatePastedValues?.({
+          apiEndpoint: t.validationConfig.apiEndpoint,
+          values: e,
+          targetFieldId: u
+        });
+        if (!l)
+          throw new Error(
+            "formContext.transport.validatePastedValues is required for fill_form_by_paste fields"
+          );
+        const { valid_values: o, invalid_values: n, message: h } = l;
+        o.length > 0 && x(u, o), i({
+          message: h || "Validation completed",
+          hasValidValues: o.length > 0,
+          validCount: o.length,
+          invalidCount: n.length
+        });
+      } catch (l) {
+        const o = l instanceof Error ? l.message : "Failed to validate pasted values. Please try again.";
+        i({
+          message: o,
+          hasValidValues: !1,
+          validCount: 0,
+          invalidCount: 0
+        });
+      } finally {
+        v(!1);
+      }
+    },
+    [t, a, x]
+  ), w = d((e) => {
+    m(e), f(""), i(null);
+  }, []), P = d(() => {
+    m(null), f(""), i(null);
+  }, []), b = d((e) => {
+    f(e), i(null);
+  }, []), E = d(() => {
+    const e = c?.[0]?.value;
+    e && _(r, e);
+  }, [c, r, _]), M = !!c?.[0]?.value && !!r && !y;
+  return {
+    selectedOption: c,
+    textareaValue: r,
+    isValidating: y,
+    validationResult: T,
+    copyPasteField: t,
+    handleSelectionChange: w,
+    handleClearAll: P,
+    handleTextareaChange: b,
+    handleValidate: E,
+    canValidate: M
+  };
+};
+export {
+  F as useFillFormByPaste
+};

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

@@ -0,0 +1,13 @@
+import { RefObject } from 'react';
+import { UseFormReturn } from 'react-hook-form';
+import { FormContext, IFormConfig, ReactHookFormState, UseReactHookFormReturn } from '../types/reactHookForm.types';
+interface UseFormFieldChangeSubscriptionOptions {
+    form: UseFormReturn<ReactHookFormState>;
+    formConfig: IFormConfig;
+    formContext?: FormContext;
+    previousValuesRef: RefObject<ReactHookFormState>;
+    formHelpersRef: RefObject<UseReactHookFormReturn | null>;
+}
+/** Subscribes to RHF value changes for onFieldChange + named handlers. */
+export declare function useFormFieldChangeSubscription({ form, formConfig, formContext, previousValuesRef, formHelpersRef, }: UseFormFieldChangeSubscriptionOptions): void;
+export {};

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

@@ -0,0 +1,42 @@
+import { useEffect as h } from "react";
+import { findFieldByPath as p } from "../utils/fieldPath.utils.js";
+import { isFieldValueValid as F } from "../utils/buildFieldValidationRules.js";
+import { buildEvaluateFieldValidationOptions as b } from "../utils/evaluateFieldValidation.js";
+function N({
+  form: n,
+  formConfig: l,
+  formContext: t,
+  previousValuesRef: a,
+  formHelpersRef: d
+}) {
+  h(() => {
+    const m = n.watch((g, s) => {
+      if (!s.name)
+        return;
+      const e = s.name, c = n.getValues(e), f = a.current[e];
+      a.current = n.getValues();
+      const r = d.current;
+      if (!r)
+        return;
+      const u = {
+        formHelpers: r,
+        fieldId: e,
+        newValue: c,
+        oldValue: f
+      };
+      t?.onFieldChange?.(u);
+      const i = p(l.fields, e);
+      i && F(
+        i,
+        c,
+        b(r, e)
+      ) && n.clearErrors(e);
+      const o = i?.handlerName ? t?.functions?.[i.handlerName] : void 0;
+      o && o(u);
+    });
+    return () => m.unsubscribe();
+  }, [n, l.fields, t, d, a]);
+}
+export {
+  N as useFormFieldChangeSubscription
+};

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

@@ -0,0 +1,3 @@
+import { FormContext, IFormConfig, ReactHookFormState, UseReactHookFormReturn } from '../types/reactHookForm.types';
+export type { ReactHookFormState, UseReactHookFormReturn, } from '../types/reactHookForm.types';
+export declare const useReactHookForm: (formConfig: IFormConfig, formInitialState?: Record<string, unknown>, externalOnSubmitCallback?: (data: ReactHookFormState) => void, externalOnCancelCallback?: (data: ReactHookFormState) => void, externalOnResetCallback?: (data: ReactHookFormState) => void, formContext?: FormContext) => UseReactHookFormReturn;

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

@@ -0,0 +1,161 @@
+import { useCallback as l, useMemo as P, useRef as c, useEffect as b, useState as z } from "react";
+import { useForm as X } from "react-hook-form";
+import { isEmptyValue as A } from "../../form-engine/is-empty-value.js";
+import { useCascadingForm as Y } from "./useCascadingForm.js";
+import { useFieldVisibility as Z } from "./useFieldVisibility.js";
+import { useFormFieldChangeSubscription as _ } from "./useFormFieldChangeSubscription.js";
+import { getFieldDefaultValue as m } from "../utils/fieldDefaults.utils.js";
+import { focusFirstFormValidationError as $ } from "../utils/formValidationFeedback.utils.js";
+import { getFieldTestId as k } from "../utils/fieldTestIds.js";
+import { buildEvaluateFieldValidationOptions as x } from "../utils/evaluateFieldValidation.js";
+const de = (i, u, a, f, S, v) => {
+  const y = l(() => {
+    const e = {};
+    return i.fields.forEach((t) => {
+      e[t.id] = m(t);
+    }), e;
+  }, [i]), T = l(() => {
+    const e = {};
+    return Object.entries(u ?? {}).forEach(([t, s]) => {
+      e[t] = s;
+    }), e;
+  }, [u]), D = P(() => {
+    const e = new Set(i.fields.map((t) => t.id));
+    return Object.keys(u ?? {}).filter(
+      (t) => !e.has(t)
+    );
+  }, [i.fields, u]), d = P(() => {
+    const e = y(), t = T();
+    return { ...e, ...t };
+  }, [y, T]), r = X({
+    defaultValues: d,
+    mode: "onTouched",
+    reValidateMode: "onChange"
+  }), I = c(d), R = c(null), w = c(() => {
+  }), K = l((e) => I.current[e], []), H = c(
+    new Set(i.fields.map((e) => e.id))
+  );
+  b(() => {
+    const e = new Set(i.fields.map((s) => s.id)), t = r.getValues();
+    for (const s of i.fields)
+      !H.current.has(s.id) && t[s.id] === void 0 && r.setValue(s.id, m(s));
+    H.current = e;
+  }, [i.fields, r]);
+  const [F, j] = z(!1), [V, M] = z(/* @__PURE__ */ new Set()), N = l(
+    (e) => {
+      r.setValue(e, null), r.clearErrors(e), M((t) => new Set(t).add(e));
+    },
+    [r]
+  ), O = l(
+    (e) => {
+      r.setValue(e, m(
+        i.fields.find((t) => t.id === e)
+      )), M((t) => {
+        const s = new Set(t);
+        return s.delete(e), s;
+      });
+    },
+    [r, i.fields]
+  ), p = l(() => {
+    $({
+      fieldErrors: r.formState.errors,
+      fieldsInOrder: i.fields,
+      getFieldTestId: k
+    });
+  }, [r.formState.errors, i.fields]);
+  b(() => {
+    F && p();
+  }, [F, p]);
+  const { isCascadingDisabled: W, getEarlierFieldsIds: g, setValueWithCascading: q } = Y(r, i, {
+    getFieldDefaultValue: m,
+    resolveFieldValidationEvaluationOptions: (e) => w.current(e)
+  }), { isFieldVisible: E, isFieldDisabled: B, isFieldDisabledForSubmitValidation: G } = Z({
+    form: r,
+    formConfig: i,
+    isCascadingDisabled: W
+  });
+  _({
+    form: r,
+    formConfig: i,
+    formContext: v,
+    previousValuesRef: I,
+    formHelpersRef: R
+  });
+  const n = l(
+    (e) => {
+      const t = {};
+      return i.fields.forEach((s) => {
+        if (V.has(s.id)) {
+          t[s.id] = null;
+          return;
+        }
+        const o = e[s.id];
+        if (!s.doNotIncludeInSubmit) {
+          if (s.fieldType === "object" || s.fieldType === "array") {
+            A(o) || (t[s.id] = o);
+            return;
+          }
+          A(o) || i.includeOnlyVisibleFieldsInSubmit && !E(s) || (t[s.id] = o);
+        }
+      }), D.forEach((s) => {
+        const o = e[s];
+        o !== void 0 && (t[s] = o);
+      }), t;
+    },
+    [i, E, D, V]
+  ), J = l(
+    (e) => r.handleSubmit(
+      (t) => {
+        j(!1);
+        const s = n(t);
+        e?.(s), a?.(s);
+      },
+      () => {
+        j(!0);
+      }
+    ),
+    [r, n, a]
+  ), L = l(
+    (e) => {
+      const t = e || d;
+      r.reset(t), S?.(t);
+    },
+    [r, d, S]
+  ), Q = l(() => {
+    const e = r.getValues();
+    f?.(e);
+  }, [r, f]), U = l(
+    (e) => {
+      const t = r.getValues(), s = n(t);
+      e?.(s), a?.(s);
+    },
+    [r, n, a]
+  ), h = {
+    formId: i.formId,
+    formConfig: i,
+    highlightFirstError: F,
+    form: r,
+    getValues: r.getValues,
+    setValue: q,
+    resetForm: L,
+    handleSubmit: J,
+    handleCancel: Q,
+    isFieldVisible: E,
+    isFieldDisabled: B,
+    isFieldDisabledForSubmitValidation: G,
+    submitValidatedForm: U,
+    getEarlierFieldsIds: g,
+    scrollToFirstError: p,
+    setToEmptyFields: V,
+    markFieldAsEmpty: N,
+    undoSetToEmpty: O,
+    getPreviousFieldValue: K,
+    formContext: v
+  };
+  return b(() => {
+    R.current = h, w.current = (e) => x(h, e);
+  }), h;
+};
+export {
+  de as useReactHookForm
+};

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

@@ -0,0 +1,8 @@
+import { Option } from '../../components/forms/select';
+import { UseSelectOptionsProps } from '../types/reactHookForm.types';
+export declare const useSelectOptions: ({ apiConfig, formHelpers, formConfig, initialOptions, id, isEnabled, getSelectOptionsName, fieldSupportedValues, }: UseSelectOptionsProps) => {
+    options: Option[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<Option[]>;
+};