impact-nova 2.3.0 → 2.4.0

package/dist/form-react/utils/formValidationFeedback.utils.js

@@ -0,0 +1,153 @@
+import { getFieldTestId as F } from "./fieldTestIds.js";
+import { isRangeIncompleteValidationMessage as q } from "./fieldRangeValidation.utils.js";
+const E = /* @__PURE__ */ new Set([
+  "date_range",
+  "week_range",
+  "month_range"
+]);
+function h(e, s) {
+  return s === `${e} is required`;
+}
+function p(e) {
+  return q(e);
+}
+function b(e) {
+  switch (e) {
+    case "select":
+      return "select";
+    case "radio":
+    case "button_group":
+    case "chips":
+      return "choose";
+    case "text":
+    case "text_area":
+      return "enter";
+    case "date_range":
+    case "week_range":
+    case "month_range":
+      return "complete";
+    case "file_upload":
+    case "fill_form_by_file_upload":
+      return "upload";
+    case "fill_form_by_paste":
+    case "fill_form_by_multi_paste":
+      return "provide";
+    default:
+      return "complete";
+  }
+}
+function $(e) {
+  return e.length <= 1 ? e[0] ?? "" : e.length === 2 ? `${e[0]} and ${e[1]}` : `${e.slice(0, -1).join(", ")}, and ${e[e.length - 1]}`;
+}
+function T(e, s, o) {
+  if (!e?.fieldType)
+    return `${s} is required to ${o}.`;
+  const l = b(e.fieldType);
+  return `${l.charAt(0).toUpperCase()}${l.slice(1)} ${s} to ${o}.`;
+}
+function I(e, s, o = {}) {
+  const l = o.actionSuffix ?? "continue", n = o.entityNoun ?? "field", r = n.endsWith("s") ? n : `${n}s`, _ = new Map(s.map((t) => [t.id, t])), a = Object.entries(e).filter(([, t]) => !!t?.message).map(([t, c]) => {
+    const f = _.get(t), m = f?.label || t;
+    return {
+      fieldId: t,
+      label: m,
+      message: c.message,
+      field: f
+    };
+  });
+  if (a.length === 0)
+    return {
+      title: `Required ${r} missing`,
+      description: "Please fill in all required fields."
+    };
+  const d = a.filter(
+    (t) => p(t.message) || (t.field?.fieldType ? E.has(t.field.fieldType) : !1)
+  ), g = a.filter(
+    (t) => h(t.label, t.message)
+  ), u = a.filter(
+    (t) => !h(t.label, t.message) && !p(t.message)
+  ), i = g.map((t) => t.label);
+  if ((d.length > 0 || u.length > 0) && i.length > 0) {
+    const t = d.length > 0 ? `Fix ${d[0].label.toLowerCase()}` : u[0].message, c = g.length === 1 ? `${b(g[0].field?.fieldType)} ${i[0]}` : `complete ${$(i)}`;
+    return {
+      title: `${r.charAt(0).toUpperCase()}${r.slice(1)} need attention`,
+      description: `${t} and ${c}.`
+    };
+  }
+  if (d.length === 1 && i.length === 0 && u.length === 0)
+    return {
+      title: "Incomplete date range",
+      description: `${d[0].label} needs both start and end dates.`
+    };
+  if (i.length === 1 && d.length === 0 && u.length === 0)
+    return {
+      title: `Required ${n} missing`,
+      description: T(
+        g[0].field,
+        i[0],
+        l
+      )
+    };
+  if (i.length >= 2 && d.length === 0 && u.length === 0) {
+    const t = i.length, c = `${t} required ${r} missing`;
+    if (t <= 3)
+      return {
+        title: c,
+        description: `${$(i)} are required.`
+      };
+    const f = i.slice(0, t - 1), m = t - f.length;
+    return {
+      title: c,
+      description: `${t} required ${r} missing: ${f.join(", ")}, and ${m} more.`
+    };
+  }
+  return a.length === 1 ? {
+    title: `${r.charAt(0).toUpperCase()}${r.slice(1)} need attention`,
+    description: a[0].message
+  } : {
+    title: `${r.charAt(0).toUpperCase()}${r.slice(1)} need attention`,
+    description: a.map((t) => t.message).join(" ")
+  };
+}
+function y(e) {
+  const s = e.getFieldTestId ?? F, o = e.fieldsInOrder.find(
+    (n) => e.fieldErrors[n.id]?.message
+  );
+  if (!o)
+    return null;
+  const l = () => {
+    const n = document.querySelector(
+      `[data-testid="${s(o.id)}"]`
+    );
+    if (!n)
+      return !1;
+    n.scrollIntoView({ block: "nearest", behavior: "smooth" });
+    const r = n.querySelector(
+      'input:not([disabled]):not([type="hidden"]), textarea:not([disabled]), button:not([disabled]), [role="combobox"]:not([aria-disabled="true"])'
+    ) ?? n;
+    return typeof r.focus == "function" && r.focus({ preventScroll: !0 }), !0;
+  };
+  return requestAnimationFrame(() => {
+    requestAnimationFrame(() => {
+      l() || setTimeout(() => l(), 0);
+    });
+  }), o.id;
+}
+function R(e) {
+  y({
+    fieldErrors: e.fieldErrors,
+    fieldsInOrder: e.fieldsInOrder,
+    getFieldTestId: e.getFieldTestId
+  }), e.showToast(
+    I(
+      e.fieldErrors,
+      e.fieldsInOrder,
+      e.toastMessageOptions
+    )
+  );
+}
+export {
+  I as buildFormValidationToastMessage,
+  y as focusFirstFormValidationError,
+  R as showFormValidationFailureFeedback
+};

package/dist/form-react/utils/icons.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare function getAppIcon(iconName: string, iconProps?: {
+    className?: string;
+    size?: number | string;
+}): ReactNode;

package/dist/form-react/utils/icons.js

@@ -0,0 +1,10 @@
+import { jsx as c } from "react/jsx-runtime";
+import * as r from "impact-nova-icons";
+const s = r;
+function m(n, t) {
+  const o = s[n];
+  return o ? /* @__PURE__ */ c(o, { className: t?.className }) : null;
+}
+export {
+  m as getAppIcon
+};

package/dist/form-react/utils/optionFlag.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Reads a boolean flag from a form-state value that may be:
+ *  - an Array<Option> (how `SelectField` stores values, even in single-select mode), or
+ *  - a single option-like object.
+ *
+ * The flag is read from `option.metadata[flagKey]` when `metadata` is present;
+ * otherwise from `option[flagKey]` for backward compatibility.
+ *
+ * Returns `false` when the value is empty, null, or the flag is missing.
+ */
+export declare const readOptionFlag: (fieldValue: unknown, flagKey: string) => boolean;

package/dist/form-react/utils/optionFlag.js

@@ -0,0 +1,17 @@
+const o = (t, n) => {
+  const r = t.metadata;
+  return r && typeof r == "object" && n in r ? !!r[n] : n in t ? !!t[n] : !1;
+}, e = (t, n) => {
+  if (Array.isArray(t)) {
+    if (t.length === 0) return !1;
+    const r = t[0];
+    return r && typeof r == "object" ? o(r, n) : !1;
+  }
+  return t && typeof t == "object" ? o(
+    t,
+    n
+  ) : !1;
+};
+export {
+  e as readOptionFlag
+};

package/dist/form-react/utils/pastedValues.d.ts

@@ -0,0 +1 @@
+export declare function cleanPastedValues(values: string): string[];

package/dist/form-react/utils/resolveFormSubmittable.d.ts

@@ -0,0 +1,18 @@
+import { IField } from '../types/fields.types';
+import { FormContext } from '../types/reactHookForm.types';
+import { UseReactHookFormReturn } from '../hooks/useReactHookForm';
+interface ResolveFormSubmittableParams {
+    formConfigFields: IField[];
+    formHelpers: UseReactHookFormReturn;
+    formContext?: FormContext;
+}
+export declare function resolveFormSubmittable({ formConfigFields, formHelpers, formContext, }: ResolveFormSubmittableParams): boolean;
+export declare function mergeFormValidationFieldErrors(requiredFieldErrors: Record<string, {
+    type: string;
+    message: string;
+}>, customFieldErrors?: Record<string, {
+    message: string;
+}>): Record<string, {
+    message: string;
+}>;
+export {};

package/dist/form-react/utils/resolveFormSubmittable.js

@@ -0,0 +1,32 @@
+import { evaluateVisibleRequiredFormFields as r } from "./validateVisibleRequiredFormFields.js";
+function F({
+  formConfigFields: t,
+  formHelpers: i,
+  formContext: e
+}) {
+  const s = i.form.getValues(), l = t.filter(
+    (o) => i.isFieldVisible(o)
+  ), d = r(
+    s,
+    l,
+    {
+      isFieldDisabled: i.isFieldDisabled,
+      isFieldDisabledForValidation: i.isFieldDisabledForSubmitValidation,
+      formHelpers: i
+    }
+  ), a = e?.validateForm?.({
+    formValues: s,
+    visibleFields: l
+  });
+  return d.isValid && (a?.isValid ?? !0);
+}
+function u(t, i) {
+  const e = {};
+  for (const [s, l] of Object.entries(t))
+    e[s] = { message: l.message };
+  return i && Object.assign(e, i), e;
+}
+export {
+  u as mergeFormValidationFieldErrors,
+  F as resolveFormSubmittable
+};

package/dist/form-react/utils/select-option-filter-values.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Normalizes multi-select / cascaded form values into a string[] for filter payloads
+ * (label preferred, then value, then primitive; Dates → YMD).
+ */
+export declare function toCascadedFilterValues(raw: unknown): string[];

package/dist/form-react/utils/select-option-filter-values.js

@@ -0,0 +1,30 @@
+function r(n) {
+  if (n == null) return null;
+  if (typeof n == "string" || typeof n == "number" || typeof n == "boolean") {
+    const e = String(n).trim();
+    return e === "" ? null : e;
+  }
+  return null;
+}
+function o(n) {
+  const e = r(n);
+  if (e) return e;
+  if (n && typeof n == "object" && !Array.isArray(n)) {
+    const t = n, i = r(t.value);
+    if (i) return i;
+    const u = r(t.label);
+    if (u) return u;
+  }
+  return null;
+}
+function l(n) {
+  if (n == null || n === "") return [];
+  if (n instanceof Date) {
+    const t = n.toISOString().slice(0, 10);
+    return t ? [t] : [];
+  }
+  return (Array.isArray(n) ? n : [n]).map(o).filter((t) => t != null && t !== "");
+}
+export {
+  l as toCascadedFilterValues
+};

package/dist/form-react/utils/serializeFormStateForQueryKey.d.ts

@@ -0,0 +1 @@
+export declare function serializeFormStateForQueryKey(formState?: Record<string, unknown>): string;

package/dist/form-react/utils/serializeFormStateForQueryKey.js

@@ -0,0 +1,21 @@
+const s = (r) => {
+  if (Array.isArray(r)) {
+    if (r.length > 1e3) {
+      const t = r[0], n = r[r.length - 1], o = t && typeof t == "object" && "label" in t ? t.label : String(t), e = n && typeof n == "object" && "label" in n ? n.label : String(n);
+      return `${r.length}:${o}:${e}`;
+    }
+    return r.map((t) => typeof t == "string" ? t : t && typeof t == "object" && "label" in t ? t.label : t);
+  }
+  return r && typeof r == "object" && "label" in r ? r.label : r;
+};
+function l(r) {
+  if (!r || Object.keys(r).length === 0)
+    return "";
+  const t = Object.keys(r), n = {}, o = t.length <= 10 ? t.sort() : t;
+  for (const e of o)
+    n[e] = s(r[e]);
+  return JSON.stringify(n);
+}
+export {
+  l as serializeFormStateForQueryKey
+};

package/dist/form-react/utils/stableSerialize.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Deterministic JSON-like string for stable cache keys (e.g. TanStack Query) when
+ * objects have unordered keys or nested structures.
+ */
+export declare function stableSerialize(value: unknown): string;

package/dist/form-react/utils/stableSerialize.js

@@ -0,0 +1,11 @@
+function n(r) {
+  if (r === null || typeof r != "object")
+    return JSON.stringify(r);
+  if (Array.isArray(r))
+    return `[${r.map(n).join(",")}]`;
+  const t = r;
+  return `{${Object.keys(t).sort().map((i) => `${JSON.stringify(i)}:${n(t[i])}`).join(",")}}`;
+}
+export {
+  n as stableSerialize
+};

package/dist/form-react/utils/validateVisibleRequiredFormFields.d.ts

@@ -0,0 +1,21 @@
+import { UseFormReturn } from 'react-hook-form';
+import { FieldVisibilityBase } from '../../form-engine';
+import { EvaluateFieldValidationOptions } from './evaluateFieldValidation';
+import { UseReactHookFormReturn } from '../hooks/useReactHookForm';
+export type FormValidationValues = Record<string, unknown>;
+interface EvaluateVisibleRequiredFormFieldsOptions {
+    isFieldDisabled: (field: FieldVisibilityBase) => boolean;
+    isFieldDisabledForValidation?: (field: FieldVisibilityBase) => boolean;
+    formHelpers?: Pick<UseReactHookFormReturn, 'getPreviousFieldValue' | 'formContext'>;
+    fieldValidationEvaluationOptions?: EvaluateFieldValidationOptions;
+}
+export interface ValidateVisibleRequiredFormFieldsResult {
+    isValid: boolean;
+    fieldErrors: Record<string, {
+        type: string;
+        message: string;
+    }>;
+}
+export declare function evaluateVisibleRequiredFormFields(formValues: FormValidationValues, fields: FieldVisibilityBase[], options: EvaluateVisibleRequiredFormFieldsOptions): ValidateVisibleRequiredFormFieldsResult;
+export declare function validateVisibleRequiredFormFields(form: UseFormReturn<FormValidationValues>, fields: FieldVisibilityBase[], options: EvaluateVisibleRequiredFormFieldsOptions): ValidateVisibleRequiredFormFieldsResult;
+export {};

package/dist/form-react/utils/validateVisibleRequiredFormFields.js

@@ -0,0 +1,64 @@
+import { computeIsFieldVisible as n } from "../../form-engine/field-dependency-graph.js";
+import { evaluateFieldValidation as c, buildEvaluateFieldValidationOptions as F } from "./evaluateFieldValidation.js";
+const u = /* @__PURE__ */ new Set([
+  "label",
+  "divider",
+  "divider_with_label"
+]);
+function V(e, l) {
+  if (l.fieldValidationEvaluationOptions)
+    return l.fieldValidationEvaluationOptions;
+  if (l.formHelpers)
+    return F(l.formHelpers, e.id);
+}
+function E(e, l, r) {
+  return c(
+    e,
+    l,
+    V(e, r)
+  );
+}
+function b(e, l, r) {
+  let t = !0;
+  const a = {};
+  for (const i of l) {
+    if (u.has(i.fieldType))
+      continue;
+    const o = n(i, e), s = r.isFieldDisabledForValidation?.(i) ?? r.isFieldDisabled(i);
+    if (!o || s)
+      continue;
+    const d = E(
+      i,
+      e[i.id],
+      r
+    );
+    if (d) {
+      const f = { type: "validate", message: d };
+      a[i.id] = f, t = !1;
+    }
+  }
+  return { isValid: t, fieldErrors: a };
+}
+function m(e, l, r) {
+  const t = e.getValues(), a = b(
+    t,
+    l,
+    r
+  );
+  for (const i of l) {
+    if (u.has(i.fieldType))
+      continue;
+    const o = n(i, t), s = r.isFieldDisabledForValidation?.(i) ?? r.isFieldDisabled(i);
+    if (!o || s) {
+      e.clearErrors(i.id);
+      continue;
+    }
+    const d = a.fieldErrors[i.id];
+    d ? e.setError(i.id, d) : e.clearErrors(i.id);
+  }
+  return a;
+}
+export {
+  b as evaluateVisibleRequiredFormFields,
+  m as validateVisibleRequiredFormFields
+};

package/dist/form-react/utils/validationUtils.d.ts

@@ -0,0 +1,3 @@
+import { ValidationRule } from '../types/fields.types';
+import { FormContextFieldChangeParams, FormContextValidator } from '../types/reactHookForm.types';
+export declare function runFieldValidation(rules: ValidationRule[], fieldChangeParams: FormContextFieldChangeParams, contextValidators?: Record<string, FormContextValidator>): string | true;

package/dist/form-react/utils/validationUtils.js

@@ -0,0 +1,77 @@
+import { z as l } from "zod";
+const c = /* @__PURE__ */ new Set([
+  "email",
+  "url",
+  "uuid",
+  "cuid",
+  "cuid2",
+  "ulid",
+  "regex",
+  "min",
+  "max",
+  "length",
+  "startsWith",
+  "endsWith",
+  "includes",
+  "ip",
+  "emoji",
+  "nanoid",
+  "trim",
+  "toLowerCase",
+  "toUpperCase",
+  "datetime",
+  "date",
+  "time"
+]);
+function f(n) {
+  const t = n.filter((o) => o.zod);
+  if (t.length === 0) return null;
+  let i = l.string();
+  for (const o of t) {
+    const a = o.zod;
+    if (!c.has(a)) continue;
+    const e = i[a];
+    if (typeof e != "function") continue;
+    const s = o.zodArgs ?? [];
+    i = e.apply(
+      i,
+      s
+    );
+  }
+  return i;
+}
+function m(n, t) {
+  try {
+    return new RegExp(t).test(n);
+  } catch {
+    return !0;
+  }
+}
+function z(n, t, i) {
+  const o = t.newValue == null ? "" : String(t.newValue);
+  for (const e of n) {
+    if (e.regex && !m(o, e.regex))
+      return e.message || "Validation failed";
+    if (e.validatorName && i?.[e.validatorName]) {
+      const s = i[e.validatorName](t);
+      if (s !== !0)
+        return s || e.message || "Validation failed";
+    }
+  }
+  const a = f(n);
+  if (a) {
+    const e = a.safeParse(o);
+    if (!e.success) {
+      const s = n.filter((r) => r.zod), u = e.error.issues[0];
+      return s.find((r) => {
+        if (!u) return !1;
+        const d = u.code;
+        return d === "too_small" && (r.zod === "min" || r.zod === "length") || d === "too_big" && (r.zod === "max" || r.zod === "length") || d === "invalid_format" && "format" in u && r.zod === u.format;
+      })?.message || u?.message || "Validation failed";
+    }
+  }
+  return !0;
+}
+export {
+  z as runFieldValidation
+};