@sonordev/site-kit 5.7.0 → 5.8.1

package/dist/{chunk-VFGEY6FJ.js → chunk-BY35X57A.js}

@@ -1,11 +1,102 @@
 'use client';
 'use strict';
 
-var chunkFEWWGEQF_js = require('./chunk-FEWWGEQF.js');
+var chunk5XFFUP6D_js = require('./chunk-5XFFUP6D.js');
+var chunkCWUYI6LI_js = require('./chunk-CWUYI6LI.js');
+var chunkP4Y75QSU_js = require('./chunk-P4Y75QSU.js');
 var chunkVJMPIRSD_js = require('./chunk-VJMPIRSD.js');
-var chunkH65OX263_js = require('./chunk-H65OX263.js');
+var chunk7DV7Y7BZ_js = require('./chunk-7DV7Y7BZ.js');
 var react = require('react');
 
+// src/forms/field-interactions.ts
+var MAX_TRACKED_FIELDS = 100;
+var MAX_FIELD_SLUG_LENGTH = 100;
+var FieldInteractionLog = class {
+  constructor() {
+    /**
+     * The field the visitor was on, reported as `abandonment_field` when they
+     * leave. The last FOCUSED field once the form reports focus; a headless form
+     * that never wires focus falls back to the last field whose value changed.
+     */
+    this.lastField = null;
+    this.entries = /* @__PURE__ */ new Map();
+    this.focusReported = false;
+    /** The one field holding focus, if any. Only one can, so this is a slot, not a flag per field. */
+    this.open = null;
+  }
+  /**
+   * Visitor moved focus into `slug`. Returns true when that's a new visit to
+   * the field; false for an untrackable slug or a field that already has focus.
+   */
+  focus(slug, now = Date.now()) {
+    if (this.open?.slug === slug) return false;
+    const entry = this.entry(slug);
+    if (!entry) return false;
+    this.close(now);
+    entry.focusCount++;
+    this.open = { slug, since: now };
+    this.focusReported = true;
+    this.lastField = slug;
+    return true;
+  }
+  /** Visitor moved focus out of `slug`. */
+  blur(slug, now = Date.now()) {
+    if (this.open?.slug === slug) this.close(now);
+  }
+  /**
+   * `slug`'s value changed. Counts as reaching the field even without a focus
+   * event: autofill, a custom renderer that doesn't report focus, a picker
+   * that sets the value from outside the input.
+   */
+  change(slug) {
+    if (!this.entry(slug)) return false;
+    if (!this.focusReported) this.lastField = slug;
+    return true;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  /**
+   * Every field reached so far. Time for a field that still has focus counts
+   * up to `now`, so a report built as the page hides includes the field the
+   * visitor was sitting in.
+   */
+  snapshot(isComplete, now = Date.now()) {
+    const out = {};
+    for (const [slug, entry] of this.entries) {
+      const openMs = this.open?.slug === slug ? Math.max(0, now - this.open.since) : 0;
+      out[slug] = {
+        completed: safeIsComplete(isComplete, slug),
+        focusCount: entry.focusCount,
+        timeMs: Math.round(entry.timeMs + openMs)
+      };
+    }
+    return out;
+  }
+  close(now) {
+    if (!this.open) return;
+    const entry = this.entries.get(this.open.slug);
+    if (entry) entry.timeMs += Math.max(0, now - this.open.since);
+    this.open = null;
+  }
+  entry(slug) {
+    if (typeof slug !== "string" || slug.length === 0 || slug.length > MAX_FIELD_SLUG_LENGTH) return null;
+    const existing = this.entries.get(slug);
+    if (existing) return existing;
+    if (this.entries.size >= MAX_TRACKED_FIELDS) return null;
+    const created = { focusCount: 0, timeMs: 0 };
+    this.entries.set(slug, created);
+    return created;
+  }
+};
+function safeIsComplete(isComplete, slug) {
+  try {
+    return isComplete(slug) === true;
+  } catch {
+    return false;
+  }
+}
+
 // src/forms/tracking-session.ts
 var SESSION_GRACE_MS = 2e3;
 var activeSessions = /* @__PURE__ */ new Map();
@@ -25,7 +116,11 @@ function acquireTrackingSession(formId, start) {
     startedAt: Date.now(),
     // Assigned below — declared here so the object shape is complete first.
     analyticsId: null,
+    fields: new FieldInteractionLog(),
+    interacted: false,
+    completed: false,
     abandonSent: false,
+    onEnd: null,
     refCount: 1,
     releaseTimer: null
   };
@@ -41,17 +136,38 @@ function releaseTrackingSession(formId, session) {
     session.releaseTimer = null;
     if (session.refCount <= 0 && activeSessions.get(formId) === session) {
       activeSessions.delete(formId);
+      const onEnd = session.onEnd;
+      session.onEnd = null;
+      try {
+        onEnd?.();
+      } catch {
+      }
     }
   }, SESSION_GRACE_MS);
   session.releaseTimer?.unref?.();
 }
+function noteActivity(session) {
+  if (session.completed) return;
+  session.interacted = true;
+  session.abandonSent = false;
+}
+function claimAbandon(session) {
+  if (session.completed || !session.interacted || session.abandonSent) return false;
+  session.abandonSent = true;
+  return true;
+}
+function markCompleted(session) {
+  session.completed = true;
+  session.abandonSent = true;
+}
 
 // src/forms/useFormTracking.ts
 function useFormTracking({
   formId,
   totalSteps,
   enabled = true,
-  debug = false
+  debug = false,
+  isFieldComplete: isFieldComplete2
 }) {
   const sessionRef = react.useRef(null);
   const sessionIdRef = react.useRef("");
@@ -61,6 +177,12 @@ function useFormTracking({
   const currentStepRef = react.useRef(1);
   const maxStepRef = react.useRef(1);
   const analyticsIdRef = react.useRef(null);
+  const isFieldCompleteRef = react.useRef(isFieldComplete2);
+  isFieldCompleteRef.current = isFieldComplete2;
+  const fieldReport = react.useCallback((session, now) => {
+    const check = isFieldCompleteRef.current;
+    return session.fields.snapshot((slug) => check ? check(slug) : false, now);
+  }, []);
   react.useEffect(() => {
     if (!enabled) return;
     if (!formId) {
@@ -75,7 +197,7 @@ function useFormTracking({
         return null;
       }
       try {
-        const response = await chunkH65OX263_js.sonorFetch(
+        const response = await chunk7DV7Y7BZ_js.sonorFetch(
           `${apiUrl}/api/public/forms/analytics/start`,
           {
             method: "POST",
@@ -108,37 +230,40 @@ function useFormTracking({
     void session.analyticsId.then((id) => {
       if (joined) analyticsIdRef.current = id;
     });
-    const handleBeforeUnload = () => {
-      if (!analyticsIdRef.current) return;
-      if (session.abandonSent) return;
+    const reportAbandon = (analyticsId) => {
+      if (!analyticsId) return;
       const apiUrl = window.__SITE_KIT_API_URL__;
       const apiKey = window.__SITE_KIT_API_KEY__;
       if (!apiUrl || !apiKey) return;
+      if (!claimAbandon(session)) return;
       const now = Date.now();
-      const currentStepTime = Math.floor((now - stepStartTimeRef.current) / 1e3);
-      stepTimesRef.current[currentStepRef.current] = currentStepTime;
-      session.abandonSent = true;
-      chunkH65OX263_js.sonorBeacon(
+      stepTimesRef.current[currentStepRef.current] = Math.floor((now - stepStartTimeRef.current) / 1e3);
+      chunk7DV7Y7BZ_js.sonorBeacon(
         `${apiUrl}/api/public/forms/analytics/abandon`,
         {
-          analyticsId: analyticsIdRef.current,
+          analyticsId,
           step: currentStepRef.current,
           maxStep: maxStepRef.current,
           stepTimes: stepTimesRef.current,
-          totalTimeSeconds: Math.floor((now - startTimeRef.current) / 1e3)
+          totalTimeSeconds: Math.floor((now - startTimeRef.current) / 1e3),
+          fieldInteractions: fieldReport(session, now),
+          abandonmentField: session.fields.lastField
         },
         apiKey
       );
-      if (debug) console.log("[Forms] Abandonment tracked");
+      if (debug) console.log("[Forms] Abandonment tracked:", session.fields.lastField);
+    };
+    const stopLeaveListener = chunkP4Y75QSU_js.onPageLeave(() => reportAbandon(analyticsIdRef.current));
+    session.onEnd = () => {
+      void session.analyticsId.then(reportAbandon);
     };
-    window.addEventListener("beforeunload", handleBeforeUnload);
     return () => {
       joined = false;
-      window.removeEventListener("beforeunload", handleBeforeUnload);
+      stopLeaveListener();
       releaseTrackingSession(formId, session);
       sessionRef.current = null;
     };
-  }, [formId, enabled, debug]);
+  }, [formId, enabled, debug, fieldReport]);
   const resolveAnalyticsId = react.useCallback(async () => {
     if (analyticsIdRef.current) return analyticsIdRef.current;
     const session = sessionRef.current;
@@ -147,6 +272,19 @@ function useFormTracking({
     if (id) analyticsIdRef.current = id;
     return id;
   }, []);
+  const trackFieldFocus = react.useCallback((slug) => {
+    const session = sessionRef.current;
+    if (!session || session.completed) return;
+    if (session.fields.focus(slug)) noteActivity(session);
+  }, []);
+  const trackFieldBlur = react.useCallback((slug) => {
+    sessionRef.current?.fields.blur(slug);
+  }, []);
+  const trackFieldChange = react.useCallback((slug) => {
+    const session = sessionRef.current;
+    if (!session || session.completed) return;
+    if (session.fields.change(slug)) noteActivity(session);
+  }, []);
   const trackStepChange = react.useCallback(async (step) => {
     if (!enabled) return;
     const apiUrl = window.__SITE_KIT_API_URL__;
@@ -161,10 +299,12 @@ function useFormTracking({
     currentStepRef.current = step;
     maxStepRef.current = Math.max(maxStepRef.current, step);
     stepStartTimeRef.current = now;
+    const session = sessionRef.current;
+    if (session) noteActivity(session);
     const analyticsId = await resolveAnalyticsId();
     if (!analyticsId) return;
     try {
-      const response = await chunkH65OX263_js.sonorFetch(
+      const response = await chunk7DV7Y7BZ_js.sonorFetch(
         `${apiUrl}/api/public/forms/analytics/step`,
         {
           method: "POST",
@@ -173,7 +313,8 @@ function useFormTracking({
             analyticsId,
             step,
             maxStep: maxStepRef.current,
-            stepTimes: stepTimesRef.current
+            stepTimes: stepTimesRef.current,
+            ...session ? { fieldInteractions: fieldReport(session, Date.now()) } : {}
           })
         },
         { apiKey, retries: 0 }
@@ -185,9 +326,11 @@ function useFormTracking({
     } catch (error) {
       if (debug) console.error("[Forms] Error updating step:", error);
     }
-  }, [enabled, debug, resolveAnalyticsId]);
+  }, [enabled, debug, resolveAnalyticsId, fieldReport]);
   const trackComplete = react.useCallback(async () => {
     if (!enabled) return;
+    const session = sessionRef.current;
+    if (session) markCompleted(session);
     const apiUrl = window.__SITE_KIT_API_URL__;
     const apiKey = window.__SITE_KIT_API_KEY__;
     if (!apiUrl || !apiKey) {
@@ -197,21 +340,26 @@ function useFormTracking({
     const now = Date.now();
     const finalStepTime = Math.floor((now - stepStartTimeRef.current) / 1e3);
     stepTimesRef.current[currentStepRef.current] = finalStepTime;
+    const fieldInteractions = session ? fieldReport(session, now) : void 0;
     const analyticsId = await resolveAnalyticsId();
     if (!analyticsId) return;
-    const session = sessionRef.current;
-    if (session) session.abandonSent = true;
     try {
-      const response = await chunkH65OX263_js.sonorFetch(
+      const response = await chunk7DV7Y7BZ_js.sonorFetch(
         `${apiUrl}/api/public/forms/analytics/complete`,
         {
           method: "POST",
+          // A form with a redirect_url navigates away right after submit, which
+          // cancels an ordinary in-flight fetch. And since completion now
+          // suppresses the abandon beacon, losing this would leave the row
+          // neither completed nor abandoned.
+          keepalive: true,
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({
             analyticsId,
             totalSteps,
             stepTimes: stepTimesRef.current,
-            totalTimeSeconds: Math.floor((now - startTimeRef.current) / 1e3)
+            totalTimeSeconds: Math.floor((now - startTimeRef.current) / 1e3),
+            ...fieldInteractions ? { fieldInteractions } : {}
           })
         },
         { apiKey, retries: 0 }
@@ -223,10 +371,13 @@ function useFormTracking({
     } catch (error) {
       if (debug) console.error("[Forms] Error completing tracking:", error);
     }
-  }, [enabled, totalSteps, formId, debug, resolveAnalyticsId]);
+  }, [enabled, totalSteps, debug, resolveAnalyticsId, fieldReport]);
   return {
     trackStepChange,
     trackComplete,
+    trackFieldFocus,
+    trackFieldBlur,
+    trackFieldChange,
     sessionId: sessionIdRef.current
   };
 }
@@ -249,7 +400,7 @@ function useForm(formIdOrSlug, options = {}) {
   } = options;
   const projectId = optionsProjectId || (typeof window !== "undefined" ? window.__SITE_KIT_PROJECT_ID__ : void 0);
   const [form, setForm] = react.useState(
-    () => initialForm ? chunkFEWWGEQF_js.normalizeFormConfig(initialForm) : null
+    () => initialForm ? chunkCWUYI6LI_js.normalizeFormConfig(initialForm) : null
   );
   const [isLoading, setIsLoading] = react.useState(!initialForm);
   const [fetchError, setFetchError] = react.useState(null);
@@ -272,11 +423,6 @@ function useForm(formIdOrSlug, options = {}) {
   const formLoadedAt = react.useRef(Date.now());
   const totalSteps = form?.total_steps || 1;
   const isMultiStep = form?.is_multi_step || false;
-  const { trackStepChange, trackComplete } = useFormTracking({
-    formId: form?.id || "",
-    totalSteps,
-    enabled: trackAnalytics
-  });
   react.useEffect(() => {
     const initialMatches = initialForm && (initialForm.slug === formIdOrSlug || initialForm.id === formIdOrSlug);
     if (initialMatches) {
@@ -310,7 +456,7 @@ function useForm(formIdOrSlug, options = {}) {
             formIdOrSlug
           })
         };
-        const response = await chunkH65OX263_js.sonorFetch(url, init, { apiKey, retries: 3, timeoutMs: 15e3 });
+        const response = await chunk7DV7Y7BZ_js.sonorFetch(url, init, { apiKey, retries: 3, timeoutMs: 15e3 });
         if (!response.ok) {
           throw new Error(`Failed to fetch form: ${response.statusText}`);
         }
@@ -320,7 +466,7 @@ function useForm(formIdOrSlug, options = {}) {
           ;
           window.__SITE_KIT_RECAPTCHA_SITE_KEY__ = data.recaptcha_site_key;
         }
-        setForm(chunkFEWWGEQF_js.normalizeFormConfig(data));
+        setForm(chunkCWUYI6LI_js.normalizeFormConfig(data));
         const defaults = {};
         for (const field of data.fields || []) {
           if (field.default_value !== void 0 && field.default_value !== null) {
@@ -343,102 +489,67 @@ function useForm(formIdOrSlug, options = {}) {
     if (!currentStepConfig) return allFields;
     return allFields.filter((f) => f.step_id === currentStepConfig.id);
   }, [form, step, allFields, isMultiStep]);
-  const isFieldVisible = react.useCallback((field) => {
-    if (!field.conditional?.show_when) return true;
-    const { field: condField, operator, value } = field.conditional.show_when;
-    const fieldValue = values[condField];
-    switch (operator) {
-      case "equals":
-        return fieldValue === value;
-      case "not_equals":
-        return fieldValue !== value;
-      case "contains":
-        return String(fieldValue || "").includes(String(value));
-      case "not_contains":
-        return !String(fieldValue || "").includes(String(value));
-      case "is_empty":
-        return !fieldValue || fieldValue === "";
-      case "not_empty":
-        return !!fieldValue && fieldValue !== "";
-      case "greater_than":
-        return Number(fieldValue) > Number(value);
-      case "less_than":
-        return Number(fieldValue) < Number(value);
-      default:
-        return true;
-    }
-  }, [values]);
+  const isFieldVisible2 = react.useCallback(
+    (field) => chunk5XFFUP6D_js.isFieldVisible(field, values),
+    [values]
+  );
   const visibleFields = react.useMemo(() => {
-    return fields.filter(isFieldVisible);
-  }, [fields, isFieldVisible]);
-  const validateField = react.useCallback((field) => {
-    if (!isFieldVisible(field)) return null;
-    if (["heading", "section_header", "paragraph", "hidden"].includes(field.field_type)) return null;
-    const value = values[field.slug];
-    const rules = field.validation || {};
-    if (field.is_required && (!value || value === "")) {
-      return rules.custom_error || `${field.label} is required`;
-    }
-    if (!value) return null;
-    const strValue = String(value);
-    if (rules.min_length && strValue.length < rules.min_length) {
-      return `${field.label} must be at least ${rules.min_length} characters`;
-    }
-    if (rules.max_length && strValue.length > rules.max_length) {
-      return `${field.label} must be no more than ${rules.max_length} characters`;
-    }
-    if (rules.min !== void 0 && Number(value) < rules.min) {
-      return `${field.label} must be at least ${rules.min}`;
-    }
-    if (rules.max !== void 0 && Number(value) > rules.max) {
-      return `${field.label} must be no more than ${rules.max}`;
-    }
-    if (rules.pattern) {
-      try {
-        if (!new RegExp(rules.pattern).test(strValue)) {
-          return rules.custom_error || `${field.label} is invalid`;
-        }
-      } catch {
-      }
-    }
-    if (field.field_type === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(strValue)) {
-      return "Please enter a valid email address";
-    }
-    if (field.field_type === "phone" && !/^[\d\s\-\+\(\)]+$/.test(strValue)) {
-      return "Please enter a valid phone number";
+    return fields.filter(isFieldVisible2);
+  }, [fields, isFieldVisible2]);
+  const validateField2 = react.useCallback(
+    (field) => chunk5XFFUP6D_js.validateField(field, values, isFieldVisible2),
+    [values, isFieldVisible2]
+  );
+  const fieldBySlug = react.useMemo(
+    () => new Map(allFields.map((f) => [f.slug, f])),
+    [allFields]
+  );
+  const {
+    trackStepChange,
+    trackComplete,
+    trackFieldFocus,
+    trackFieldBlur,
+    trackFieldChange
+  } = useFormTracking({
+    formId: form?.id || "",
+    totalSteps,
+    enabled: trackAnalytics,
+    isFieldComplete: (slug) => {
+      const field = fieldBySlug.get(slug);
+      return field ? chunk5XFFUP6D_js.isFieldComplete(field, values, isFieldVisible2) : false;
     }
-    return null;
-  }, [values, isFieldVisible]);
+  });
   const validate = react.useCallback(() => {
     const newErrors = {};
     for (const field of fields) {
-      const error = validateField(field);
+      const error = validateField2(field);
       if (error) {
         newErrors[field.slug] = error;
       }
     }
     setErrors(newErrors);
     return Object.keys(newErrors).length === 0;
-  }, [fields, validateField]);
+  }, [fields, validateField2]);
   const validateAll = react.useCallback(() => {
     const newErrors = {};
     for (const field of allFields) {
-      const error = validateField(field);
+      const error = validateField2(field);
       if (error) newErrors[field.slug] = error;
     }
     setErrors(newErrors);
     return Object.keys(newErrors).length === 0;
-  }, [allFields, validateField]);
+  }, [allFields, validateField2]);
   const buildVisibleValues = react.useCallback(() => {
     const out = {};
     for (const field of allFields) {
-      if (!isFieldVisible(field)) continue;
+      if (!isFieldVisible2(field)) continue;
       if (field.slug in values) out[field.slug] = values[field.slug];
     }
     return out;
-  }, [allFields, values, isFieldVisible]);
+  }, [allFields, values, isFieldVisible2]);
   const setFieldValue = react.useCallback((key, value) => {
     setValuesState((prev) => ({ ...prev, [key]: value }));
+    trackFieldChange(key);
     setErrors((prev) => {
       if (prev[key]) {
         const next = { ...prev };
@@ -447,7 +558,7 @@ function useForm(formIdOrSlug, options = {}) {
       }
       return prev;
     });
-  }, []);
+  }, [trackFieldChange]);
   const setValues = react.useCallback((newValues) => {
     setValuesState((prev) => ({ ...prev, ...newValues }));
   }, []);
@@ -489,7 +600,7 @@ function useForm(formIdOrSlug, options = {}) {
     setIsSubmitting(true);
     setSubmitError(null);
     try {
-      const data = await chunkFEWWGEQF_js.submitForm({
+      const data = await chunkCWUYI6LI_js.submitForm({
         config: form,
         values: buildVisibleValues(),
         honeypotValue: "",
@@ -542,16 +653,18 @@ function useForm(formIdOrSlug, options = {}) {
     canGoPrev,
     isLastStep,
     validate,
-    validateField,
-    isFieldVisible,
+    validateField: validateField2,
+    isFieldVisible: isFieldVisible2,
     submit,
     isSubmitting,
     isComplete,
-    reset
+    reset,
+    trackFieldFocus,
+    trackFieldBlur
   };
 }
 
 exports.useForm = useForm;
 exports.useFormTracking = useFormTracking;
-//# sourceMappingURL=chunk-VFGEY6FJ.js.map
-//# sourceMappingURL=chunk-VFGEY6FJ.js.map
+//# sourceMappingURL=chunk-BY35X57A.js.map
+//# sourceMappingURL=chunk-BY35X57A.js.map