@digiform/wizard 0.2.10 → 0.2.11

package/wizard/src/features/state-management/machines/componentTriggerEngine.js

@@ -0,0 +1,598 @@
+"use client";
+const C = typeof process < "u" && process.env.NODE_ENV === "development", u = {
+  componentTriggers: /* @__PURE__ */ new Map(),
+  componentActions: /* @__PURE__ */ new Map(),
+  stepComponents: /* @__PURE__ */ new Map(),
+  lastConfigId: ""
+}, m = {
+  triggerResults: /* @__PURE__ */ new Map(),
+  executionPlans: /* @__PURE__ */ new Map()
+};
+function I(t, e, n, i) {
+  const o = `${t.id}-${e}-${n}-${JSON.stringify(i.data).slice(0, 100)}`, r = m.executionPlans.get(o);
+  if (r?.timestamp && Date.now() - r.timestamp < 1e3)
+    return r;
+  v(t);
+  const a = b(
+    t,
+    e,
+    n,
+    i
+  ), s = {
+    context: e,
+    executions: a,
+    totalActions: a.reduce(
+      (c, g) => c + g.actions.length,
+      0
+    ),
+    requiresUserInteraction: a.some(
+      (c) => c.actions.some(
+        (g) => g.type === "executeVerifyEmailDialog" || g.type === "executeVerifyDialog"
+      )
+    ),
+    timestamp: Date.now()
+  };
+  return m.executionPlans.set(o, s), m.executionPlans.size > 100 && S(), s;
+}
+function v(t) {
+  if (u.lastConfigId !== t.id) {
+    u.componentTriggers.clear(), u.componentActions.clear(), u.stepComponents.clear();
+    for (let e = 0; e < t.steps.length; e++) {
+      const n = t.steps[e];
+      if (!n || !("sections" in n)) continue;
+      const i = [];
+      for (const o of n.sections || [])
+        for (const r of o.components || []) {
+          i.push(r.id);
+          const a = r.triggerActions?.triggers || r.triggers || [];
+          if (a.length > 0) {
+            u.componentTriggers.set(r.id, a);
+            const s = [];
+            for (const c of a)
+              c.actions && s.push(...c.actions);
+            s.length > 0 && u.componentActions.set(r.id, s);
+          }
+        }
+      u.stepComponents.set(e, i);
+    }
+    u.lastConfigId = t.id;
+  }
+}
+function S() {
+  const t = Date.now();
+  for (const [e, n] of m.executionPlans)
+    n.timestamp && t - n.timestamp > 1e3 * 10 && m.executionPlans.delete(e);
+  for (const [e, n] of m.triggerResults)
+    t - n.timestamp > 1e3 && m.triggerResults.delete(e);
+}
+function b(t, e, n, i) {
+  const o = [], r = t.steps[n];
+  if (!r || !("sections" in r)) return o;
+  C && console.log(
+    `🔍 [ComponentTriggerEngine] findAllTriggersForContext for ${e}:`,
+    {
+      stepIndex: n,
+      sectionsCount: r.sections?.length || 0
+    }
+  );
+  const a = u.stepComponents.get(n) || [];
+  for (const s of a) {
+    const c = u.componentTriggers.get(s);
+    if (!c?.length) continue;
+    const g = c.filter(
+      (l) => !l.contexts || l.contexts.length === 0 || l.contexts.includes(e)
+    );
+    if (!g.length) continue;
+    const d = D(
+      t,
+      n,
+      s
+    );
+    if (!(e === "sectionSave" && d && !E(d)))
+      for (const l of g) {
+        const T = M(
+          s,
+          i,
+          e
+        );
+        if (C && console.log(
+          `🎯 [ComponentTriggerEngine] Evaluating trigger ${l.id} for ${s}:`,
+          {
+            triggerType: l.type,
+            triggerContexts: l.contexts,
+            currentContext: e,
+            originalValue: T.originalValue,
+            currentValue: T.currentValue
+          }
+        ), O(l, T)) {
+          const f = $(
+            l.actions,
+            e
+          );
+          C && console.log(
+            `✅ [ComponentTriggerEngine] Trigger ${l.id} should fire for ${s}:`,
+            {
+              allActionsCount: l.actions.length,
+              contextActionsCount: f.length,
+              contextActions: f.map((p) => ({
+                id: p.id,
+                type: p.type,
+                contexts: p.contexts
+              }))
+            }
+          ), f.length > 0 && o.push({
+            trigger: l,
+            componentId: s,
+            context: e,
+            actions: f,
+            timestamp: Date.now()
+          });
+        } else C && console.log(
+          `❌ [ComponentTriggerEngine] Trigger ${l.id} should NOT fire for ${s}`
+        );
+      }
+  }
+  return C && console.log(
+    `🎯 [ComponentTriggerEngine] Found ${o.length} executions for ${e}`,
+    {
+      executions: o.map((s) => ({
+        componentId: s.componentId,
+        triggerId: s.trigger.id,
+        actionsCount: s.actions.length
+      }))
+    }
+  ), o;
+}
+function D(t, e, n) {
+  const i = t.steps[e];
+  if (!i || !("sections" in i)) return null;
+  for (const o of i.sections || [])
+    if (o.components?.some((r) => r.id === n))
+      return o;
+  return null;
+}
+function w(t, e, n) {
+  const i = u.componentTriggers.get(n);
+  return i ? i.filter(
+    (o) => !o.contexts || o.contexts.length === 0 || o.contexts.includes(e)
+  ) : [];
+}
+function $(t, e) {
+  return t.filter((n) => {
+    if (n.contexts && n.contexts.length > 0) {
+      const i = P(e);
+      return n.contexts.some(
+        (o) => o === e || o === i || F(o, e)
+      );
+    }
+    return !0;
+  });
+}
+function P(t) {
+  switch (t) {
+    case "fieldChange":
+      return "fieldChange";
+    case "save":
+      return "sectionSave";
+    // Map "save" to "sectionSave" primarily
+    case "stepSave":
+      return "stepSave";
+    case "sectionSave":
+      return "sectionSave";
+    default:
+      return t;
+  }
+}
+function F(t, e) {
+  return e === "save" ? t === "sectionSave" || t === "stepSave" : !1;
+}
+function E(t) {
+  const e = t;
+  return e.triggerContexts?.supportsSectionSave || e.mode === "edit" || e.mode === "editable";
+}
+function M(t, e, n) {
+  let i = e.data[t];
+  const o = e.componentOriginalValues[t], r = o?.value;
+  return i === void 0 && o?.isPopulated && r !== void 0 && (console.log(
+    `🔧 [ComponentTriggerEngine] Field ${t} was API-populated but user hasn't touched it. Using original value as current value.`,
+    {
+      originalValue: r,
+      triggerContext: n,
+      isPopulated: o.isPopulated
+    }
+  ), i = r), console.log(
+    `🔥 [ComponentTriggerEngine] createEvaluationContext for ${t}:`,
+    {
+      componentId: t,
+      triggerContext: n,
+      currentValue: i,
+      currentValueType: typeof i,
+      originalValue: r,
+      originalValueType: typeof r,
+      originalValueInfo: o,
+      isDirty: o?.isPopulated && o.value !== i
+    }
+  ), {
+    componentId: t,
+    currentValue: i,
+    originalValue: r,
+    eventType: n === "stepSave" || n === "sectionSave" ? "navigationAttempt" : "valueChange",
+    triggerContext: n,
+    formData: e.data,
+    formContext: e
+  };
+}
+function O(t, e) {
+  const n = `${t.id}-${e.componentId}-${e.currentValue}-${e.originalValue}-${e.triggerContext}`, i = m.triggerResults.get(n);
+  if (i && Date.now() - i.timestamp < 1e3)
+    return i.result;
+  const o = h(t, e);
+  return m.triggerResults.set(n, {
+    result: o,
+    timestamp: Date.now()
+  }), C && console.log(
+    `🎆 [ComponentTriggerEngine] shouldTriggerFire result for ${e.componentId}:`,
+    {
+      triggerId: t.id,
+      triggerType: t.type,
+      result: o,
+      triggerContext: e.triggerContext
+    }
+  ), o;
+}
+function k(t, e) {
+  switch (t) {
+    case "valueChange":
+    case "focus":
+    case "blur":
+      return "fieldChange";
+    case "navigationAttempt":
+    case "stepNavigation":
+      return "stepSave";
+    case "sectionSave":
+      return "sectionSave";
+    case "immediate":
+      return "immediate";
+    default:
+      return "fieldChange";
+  }
+}
+function _(t, e) {
+  return y(t, e.componentId).map((i) => ({
+    trigger: i,
+    shouldFire: h(i, e)
+  }));
+}
+function y(t, e) {
+  return v(t), u.componentTriggers.get(e) || [];
+}
+function V(t, e) {
+  return v(t), u.componentActions.get(e) || [];
+}
+function h(t, e) {
+  let n = !1;
+  switch (t.type) {
+    case "isDirty": {
+      const o = e.formContext.componentOriginalValues[e.componentId];
+      if (console.log(
+        `🔥🔥🔥 [ComponentTriggerEngine] isDirty trigger evaluation STARTED for ${e.componentId}:`,
+        {
+          originalValueInfo: o,
+          currentValue: e.currentValue,
+          hasOriginalValueInfo: !!o,
+          isPopulated: o?.isPopulated,
+          triggerContext: e.triggerContext,
+          eventType: e.eventType,
+          allOriginalValues: Object.keys(
+            e.formContext.componentOriginalValues
+          ).map((r) => ({
+            key: r,
+            value: e.formContext.componentOriginalValues[r]?.value,
+            isPopulated: e.formContext.componentOriginalValues[r]?.isPopulated,
+            timestamp: e.formContext.componentOriginalValues[r]?.timestamp
+          }))
+        }
+      ), !o || !o.isPopulated)
+        n = !1, console.log(
+          `🎯 [ComponentTriggerEngine] isDirty evaluation for ${e.componentId}: Not populated from API, cannot be dirty`,
+          {
+            originalValueInfo: o,
+            currentValue: e.currentValue,
+            isPopulated: o?.isPopulated || !1,
+            baseTriggerMet: !1
+          }
+        );
+      else {
+        const r = o.value !== e.currentValue;
+        n = r, console.log(
+          `🎯 [ComponentTriggerEngine] isDirty evaluation for ${e.componentId}:`,
+          {
+            originalValue: o.value,
+            originalValueType: typeof o.value,
+            currentValue: e.currentValue,
+            currentValueType: typeof e.currentValue,
+            strictComparison: o.value === e.currentValue,
+            isDifferent: r,
+            baseTriggerMet: n,
+            triggerContext: e.triggerContext,
+            eventType: e.eventType,
+            isPopulated: !0,
+            timestamp: o.timestamp,
+            assignedBaseTriggerMet: n
+          }
+        );
+      }
+      break;
+    }
+    case "onValueChange":
+      n = e.eventType === "valueChange", console.log(
+        `🔥🔥🔥 [ComponentTriggerEngine] onValueChange case for ${e.componentId}:`,
+        {
+          eventType: e.eventType,
+          baseTriggerMet: n
+        }
+      );
+      break;
+    case "onFocus":
+      n = e.eventType === "focus", console.log(
+        `🔥🔥🔥 [ComponentTriggerEngine] onFocus case for ${e.componentId}:`,
+        {
+          eventType: e.eventType,
+          baseTriggerMet: n
+        }
+      );
+      break;
+    case "onBlur":
+      n = e.eventType === "blur", console.log(
+        `🔥🔥🔥 [ComponentTriggerEngine] onBlur case for ${e.componentId}:`,
+        {
+          eventType: e.eventType,
+          baseTriggerMet: n
+        }
+      );
+      break;
+    default:
+      n = !1, console.log(
+        `🔥🔥🔥 [ComponentTriggerEngine] DEFAULT case for ${e.componentId}:`,
+        {
+          triggerType: t.type,
+          baseTriggerMet: n,
+          note: "This should not happen for known trigger types"
+        }
+      );
+  }
+  if (console.log(
+    `🔥🔥🔥 [ComponentTriggerEngine] Base trigger evaluation complete for ${e.componentId}:`,
+    {
+      triggerType: t.type,
+      triggerContext: e.triggerContext,
+      baseTriggerMet: n,
+      baseTriggerMetType: typeof n,
+      baseTriggerMetValue: n,
+      triggerId: t.id,
+      aboutToCheckBaseTrigger: !0,
+      booleanCheck: !n,
+      willReturn: !n
+    }
+  ), !n)
+    return console.log(
+      `❌ [ComponentTriggerEngine] Base trigger not met for ${e.componentId}, returning false:`,
+      {
+        triggerType: t.type,
+        triggerContext: e.triggerContext,
+        baseTriggerMet: n,
+        baseTriggerMetType: typeof n,
+        baseTriggerMetValue: n,
+        triggerId: t.id
+      }
+    ), !1;
+  if (console.log(
+    `🔥🔥🔥 [ComponentTriggerEngine] Base trigger WAS met for ${e.componentId}, continuing:`,
+    {
+      triggerType: t.type,
+      triggerContext: e.triggerContext,
+      baseTriggerMet: n,
+      baseTriggerMetType: typeof n,
+      baseTriggerMetValue: n,
+      triggerId: t.id
+    }
+  ), !t.conditions || t.conditions.length === 0)
+    return console.log(
+      `✅ [ComponentTriggerEngine] Trigger fires (no conditions) for ${e.componentId}:`,
+      {
+        triggerType: t.type,
+        triggerContext: e.triggerContext
+      }
+    ), !0;
+  const i = B(t.conditions, e);
+  return console.log(
+    `🎯 [ComponentTriggerEngine] Conditions evaluation for ${e.componentId}:`,
+    {
+      triggerType: t.type,
+      triggerContext: e.triggerContext,
+      conditionsCount: t.conditions.length,
+      conditionsResult: i
+    }
+  ), i;
+}
+function B(t, e) {
+  return t.every((n) => R(n, e));
+}
+function R(t, e) {
+  let n;
+  switch (t.field ? n = e.formData[t.field] : n = e.currentValue, t.operator) {
+    case "equals":
+      return n === t.value;
+    case "notEquals":
+      return n !== t.value;
+    case "contains":
+      return typeof n == "string" && typeof t.value == "string" && n.includes(t.value);
+    case "empty":
+      return n == null || n === "" || Array.isArray(n) && n.length === 0;
+    case "notEmpty":
+      return n != null && n !== "" && !(Array.isArray(n) && n.length === 0);
+    case "greaterThan":
+      return typeof n == "number" && typeof t.value == "number" && n > t.value;
+    case "lessThan":
+      return typeof n == "number" && typeof t.value == "number" && n < t.value;
+    default:
+      return !1;
+  }
+}
+function N(t, e, n) {
+  return y(t, e);
+}
+function L(t, e) {
+  return y(t, e).length > 0;
+}
+function q(t, e) {
+  return V(t, e).length > 0;
+}
+function A(t, e, n, i = "stepSave") {
+  const o = [], r = t.steps[e];
+  if (!r || !("sections" in r))
+    return o;
+  console.log(
+    `🔍 [ComponentTriggerEngine] Checking step ${e} for dirty components with ${i} context`,
+    {
+      stepId: r.id,
+      sectionsCount: r.sections?.length || 0,
+      triggerContext: i
+    }
+  );
+  for (const a of r.sections || []) {
+    if (i === "sectionSave" && !E(a)) {
+      console.log(
+        `🔍 [ComponentTriggerEngine] Skipping section ${a.id} - doesn't support sectionSave`,
+        {
+          sectionMode: a.mode,
+          triggerContexts: a.triggerContexts
+        }
+      );
+      continue;
+    }
+    console.log(
+      `🔍 [ComponentTriggerEngine] Checking section ${a.id} with mode: ${a.mode}`,
+      {
+        componentsCount: a.components?.length || 0,
+        sectionMode: a.mode,
+        triggerContext: i
+      }
+    );
+    for (const s of a.components || []) {
+      const c = w(
+        t,
+        i,
+        s.id
+      );
+      console.log(
+        `🔍 [ComponentTriggerEngine] Component ${s.id} has ${c.length} triggers for ${i}`,
+        {
+          componentId: s.id,
+          triggersCount: c.length,
+          triggerContext: i
+        }
+      );
+      for (const g of c)
+        if (g.type === "isDirty" && g.actions) {
+          const d = n.componentOriginalValues[s.id]?.value, l = n.data[s.id], T = {
+            componentId: s.id,
+            currentValue: l,
+            eventType: "navigationAttempt",
+            triggerContext: i,
+            formData: n.data,
+            formContext: n
+          };
+          if (console.log(
+            `🎯 [ComponentTriggerEngine] Evaluating isDirty trigger for ${s.id}`,
+            {
+              originalValue: d,
+              currentValue: l,
+              isDirty: d !== void 0 && d !== l,
+              triggerContexts: g.contexts,
+              requiredContext: i
+            }
+          ), h(g, T)) {
+            const f = $(
+              g.actions,
+              i
+            );
+            f.length > 0 ? (console.log(
+              `🎯 [ComponentTriggerEngine] Found dirty component with ${i} triggers: ${s.id}`,
+              {
+                originalValue: d,
+                currentValue: l,
+                trigger: g.type,
+                triggerContext: i,
+                triggerContexts: g.contexts,
+                allActionsCount: g.actions.length,
+                contextActionsCount: f.length,
+                contextActions: f.map((p) => ({
+                  id: p.id,
+                  type: p.type,
+                  contexts: p.contexts
+                }))
+              }
+            ), o.push({
+              componentId: s.id,
+              trigger: g,
+              actions: f
+              // Use filtered actions
+            })) : console.log(
+              `🔍 [ComponentTriggerEngine] Component ${s.id} trigger has no actions for context ${i}`,
+              {
+                allActions: g.actions.map((p) => ({
+                  id: p.id,
+                  type: p.type,
+                  contexts: p.contexts
+                })),
+                requiredContext: i
+              }
+            );
+          }
+        }
+    }
+  }
+  return console.log(
+    `🎯 [ComponentTriggerEngine] Found ${o.length} dirty components with ${i} triggers`,
+    {
+      components: o.map((a) => ({
+        id: a.componentId,
+        actionsCount: a.actions.length
+      }))
+    }
+  ), o;
+}
+function H(t, e, n, i = "step") {
+  return A(
+    t,
+    e,
+    n,
+    i === "section" ? "sectionSave" : "stepSave"
+  );
+}
+const U = {
+  createExecutionPlan: I,
+  determineTriggerContext: k,
+  evaluateComponentTriggers: _,
+  findComponentTriggers: y,
+  findComponentActions: V,
+  getTriggersForAction: N,
+  hasComponentTriggers: L,
+  hasComponentActions: q,
+  findDirtyComponentsWithTriggers: A,
+  findDirtyComponentsForNavigation: H
+};
+export {
+  U as ComponentTriggerEngine,
+  I as createExecutionPlan,
+  k as determineTriggerContext,
+  _ as evaluateComponentTriggers,
+  V as findComponentActions,
+  y as findComponentTriggers,
+  H as findDirtyComponentsForNavigation,
+  A as findDirtyComponentsWithTriggers,
+  N as getTriggersForAction,
+  q as hasComponentActions,
+  L as hasComponentTriggers
+};