@digiform/wizard 0.2.10 → 0.2.16

package/wizard/src/features/form-runtime/utils/visibilityUtils.js

@@ -0,0 +1,77 @@
+"use client";
+function d(e, s) {
+  if (!e || !e.conditions.length)
+    return !0;
+  const { action: u, logicalOperator: a, conditions: n } = e, r = n.map(
+    (i) => f(i, s)
+  );
+  let t;
+  return a === "and" ? t = r.every((i) => i) : t = r.some((i) => i), u === "show" ? t : !t;
+}
+function f(e, s) {
+  const { fieldId: u, operator: a, value: n, caseSensitive: r = !0 } = e, t = s[u];
+  switch (a) {
+    case "equals":
+      return o(t, n, r, "equals");
+    case "notEquals":
+      return !o(t, n, r, "equals");
+    case "contains":
+      return o(t, n, r, "contains");
+    case "notContains":
+      return !o(t, n, r, "contains");
+    case "isEmpty":
+      return l(t);
+    case "isNotEmpty":
+      return !l(t);
+    case "greaterThan":
+      return c(t, n, "greaterThan");
+    case "lessThan":
+      return c(t, n, "lessThan");
+    case "in":
+      return Array.isArray(n) && n.some((i) => o(t, i, r, "equals"));
+    case "notIn":
+      return !Array.isArray(n) || !n.some(
+        (i) => o(t, i, r, "equals")
+      );
+    default:
+      return console.warn(`Unknown visibility condition operator: ${a}`), !1;
+  }
+}
+function o(e, s, u, a) {
+  if (e == null && s == null)
+    return a === "equals";
+  if (e == null || s == null)
+    return !1;
+  let n = String(e), r = String(s);
+  switch (u || (n = n.toLowerCase(), r = r.toLowerCase()), a) {
+    case "equals":
+      return n === r;
+    case "contains":
+      return n.includes(r);
+    default:
+      return !1;
+  }
+}
+function c(e, s, u) {
+  const a = Number(e), n = Number(s);
+  if (isNaN(a) || isNaN(n))
+    return !1;
+  switch (u) {
+    case "greaterThan":
+      return a > n;
+    case "lessThan":
+      return a < n;
+    default:
+      return !1;
+  }
+}
+function l(e) {
+  return e == null ? !0 : typeof e == "string" ? e.trim() === "" : Array.isArray(e) ? e.length === 0 : typeof e == "object" ? Object.keys(e).length === 0 : !1;
+}
+function m(e) {
+  return e ? e.conditions.map((s) => s.fieldId) : [];
+}
+export {
+  d as evaluateVisibility,
+  m as getVisibilityDependencies
+};

package/wizard/src/features/state-management/machines/actions/componentActions.js

@@ -0,0 +1,215 @@
+"use client";
+import { findComponentActions as g } from "../helpers/triggerHelpers.js";
+const C = ({
+  context: c,
+  event: l,
+  self: n
+}) => {
+  if (l.type !== "TRIGGER_COMPONENT_ACTION") return;
+  const { componentId: e, actionId: s } = l, r = g(c.config, e).find((t) => t.id === s);
+  if (r) {
+    n.send({
+      type: "COMPONENT_ACTION_START",
+      componentId: e,
+      actionId: s
+    });
+    try {
+      switch (r.type) {
+        case "showAlert": {
+          const t = r.config, o = `${e}-${s}`, a = {
+            id: o,
+            componentId: e,
+            message: t.message,
+            type: t.type,
+            position: t.position,
+            dismissible: t.dismissible,
+            timestamp: Date.now(),
+            autoHide: t.autoHide,
+            autoHideDelay: t.autoHideDelay
+          };
+          n.send({
+            type: "SHOW_COMPONENT_ALERT",
+            componentId: e,
+            alert: a
+          }), t.autoHide && t.autoHideDelay && setTimeout(() => {
+            n.send({
+              type: "DISMISS_COMPONENT_ALERT",
+              componentId: e,
+              alertId: o
+            });
+          }, t.autoHideDelay), n.send({
+            type: "COMPONENT_ACTION_COMPLETE",
+            componentId: e,
+            actionId: s,
+            result: { alertId: o }
+          });
+          break;
+        }
+        case "executeVerifyDialog": {
+          const o = r.config.postAction || {
+            type: "close"
+          };
+          let a;
+          switch (o.type) {
+            case "close":
+            case "saveSection":
+              a = {
+                type: "custom",
+                handler: "updateOriginalValue",
+                componentId: e
+              };
+              break;
+            case "nextStep":
+              a = {
+                type: "navigate",
+                direction: "next",
+                updateOriginalValue: !0,
+                componentId: e
+              };
+              break;
+            case "navigate":
+              a = {
+                type: "navigate",
+                direction: o.direction,
+                targetStep: o.targetStep,
+                updateOriginalValue: !0,
+                componentId: e
+              };
+              break;
+            default:
+              a = {
+                type: "custom",
+                handler: "updateOriginalValue",
+                componentId: e
+              };
+          }
+          const d = {
+            title: "Verify Changes",
+            content: "Please verify your changes before continuing.",
+            type: "modal",
+            size: "small",
+            buttons: [
+              {
+                id: "cancel-btn",
+                label: "Cancel",
+                variant: "secondary",
+                action: { type: "close" }
+              },
+              {
+                id: "verify-btn",
+                label: "Verify",
+                variant: "primary",
+                action: { type: "close" }
+                // Will be overridden by onVerifiedAction
+              }
+            ],
+            dismissible: !0,
+            templateMetadata: {
+              typeId: "verify-dialog",
+              isGeneric: !0,
+              componentId: e,
+              onVerifiedAction: a
+              // This will be used by EmailVerificationDialog
+            }
+          };
+          n.send({
+            type: "SHOW_DIALOG",
+            dialog: d
+          }), n.send({
+            type: "COMPONENT_ACTION_COMPLETE",
+            componentId: e,
+            actionId: s,
+            result: { dialogConfig: d }
+          });
+          break;
+        }
+        case "executeVerifyEmailDialog": {
+          const t = r.config;
+          let o = {
+            ...t.templateConfig.onVerifiedAction,
+            componentId: e
+            // Set the current component ID
+          };
+          const a = c.config.steps[c.currentStepIndex];
+          ("sections" in a ? a.sections?.find(
+            (u) => u.components?.some(
+              (y) => y.id === e
+            )
+          ) : void 0)?.mode === "editable" && (o = {
+            type: "custom",
+            handler: "updateOriginalValue",
+            componentId: e
+          });
+          const i = {
+            ...t.templateConfig,
+            onVerifiedAction: o
+          }, p = {
+            title: i.title,
+            content: i.description,
+            type: "modal",
+            buttons: [
+              {
+                id: "cancel-btn",
+                label: i.cancelButtonLabel,
+                variant: "secondary",
+                action: i.onCancelAction || {
+                  type: "close"
+                }
+              },
+              {
+                id: "verify-btn",
+                label: i.verifyButtonLabel,
+                variant: "primary",
+                action: { type: "custom", handler: "verifyEmail" }
+              }
+            ],
+            dismissible: !0,
+            templateMetadata: {
+              typeId: "verify-dialog",
+              codeLength: i.codeLength,
+              codeType: i.codeType,
+              enableAutoSubmit: i.enableAutoSubmit,
+              enableResend: i.enableResend,
+              resendTimer: i.resendTimer,
+              successTitle: i.successTitle,
+              successMessage: i.successMessage,
+              errorMessage: i.errorMessage,
+              continueButtonLabel: i.continueButtonLabel,
+              onVerifiedAction: i.onVerifiedAction || {
+                type: "navigate",
+                direction: "next"
+              }
+            }
+          };
+          n.send({
+            type: "SHOW_ACTION_DIALOG",
+            dialogConfig: p
+          }), n.send({
+            type: "COMPONENT_ACTION_COMPLETE",
+            componentId: e,
+            actionId: s,
+            result: { dialogShown: !0 }
+          });
+          break;
+        }
+        default:
+          n.send({
+            type: "COMPONENT_ACTION_FAILED",
+            componentId: e,
+            actionId: s,
+            error: new Error(`Unsupported action type: ${r.type}`)
+          });
+      }
+    } catch (t) {
+      n.send({
+        type: "COMPONENT_ACTION_FAILED",
+        componentId: e,
+        actionId: s,
+        error: t instanceof Error ? t : new Error(String(t))
+      });
+    }
+  }
+};
+export {
+  C as executeComponentAction
+};

package/wizard/src/features/state-management/machines/actions/navigationActions.js

@@ -0,0 +1,122 @@
+"use client";
+import { assign as t } from "xstate";
+t({
+  currentStepIndex: ({ context: e }) => Math.min(
+    e.currentStepIndex + 1,
+    e.config.steps.length - 1
+  ),
+  currentStepId: ({ context: e }) => {
+    const n = Math.min(
+      e.currentStepIndex + 1,
+      e.config.steps.length - 1
+    );
+    return e.config.steps[n]?.id || "";
+  },
+  pendingNavigation: null
+});
+t({
+  currentStepIndex: ({ context: e }) => Math.max(e.currentStepIndex - 1, 0),
+  currentStepId: ({ context: e }) => {
+    const n = Math.max(e.currentStepIndex - 1, 0);
+    return e.config.steps[n]?.id || "";
+  },
+  pendingNavigation: null
+});
+t({
+  currentStepIndex: ({ context: e, event: n }) => {
+    if (n.type !== "GO_TO_STEP") return e.currentStepIndex;
+    const i = e.config.steps.findIndex(
+      (r) => r.id === n.stepId
+    );
+    return i >= 0 ? i : e.currentStepIndex;
+  },
+  currentStepId: ({ context: e, event: n }) => n.type !== "GO_TO_STEP" ? e.currentStepId : n.stepId,
+  pendingNavigation: null
+});
+t({
+  currentStepIndex: ({ context: e }) => {
+    const n = e.config.steps.findIndex(
+      (i) => i.id === e.pendingNavigation?.stepId
+    );
+    return n >= 0 ? n : e.currentStepIndex;
+  },
+  currentStepId: ({ context: e }) => e.pendingNavigation?.stepId || e.currentStepId,
+  pendingNavigation: null,
+  canNavigate: !0
+});
+t({
+  pendingNavigation: { type: "next" }
+});
+t({
+  pendingNavigation: { type: "previous" }
+});
+t({
+  pendingNavigation: ({ event: e }) => e.type !== "GO_TO_STEP" ? null : {
+    type: "step",
+    stepId: e.stepId
+  }
+});
+t({
+  pendingNavigation: ({ event: e }) => {
+    if (e.type !== "REQUEST_NAVIGATION") return null;
+    const n = {
+      type: e.navigationType
+    };
+    return e.stepId !== void 0 && (n.stepId = e.stepId), n;
+  }
+});
+t({
+  pendingNavigation: null,
+  canNavigate: !0
+});
+t({
+  pendingNavigation: null,
+  canNavigate: !1
+});
+t({
+  currentStepIndex: 0,
+  currentStepId: ({ context: e }) => e.config.steps[0]?.id || "",
+  data: {},
+  errors: {},
+  dirtyFields: {},
+  touchedFields: {},
+  componentTriggerState: {},
+  activeComponentActions: {},
+  componentAlerts: {},
+  activeActions: {},
+  executingTrigger: null,
+  waitingForActions: !1,
+  canNavigate: !0,
+  pendingNavigation: null,
+  activeDialog: null,
+  componentOriginalValues: {},
+  fieldChangeState: {},
+  fieldValidationState: {
+    activeWarnings: [],
+    pendingVerifications: [],
+    verificationResults: {}
+  }
+});
+const p = ({
+  context: e,
+  self: n
+}) => {
+  if (e.pendingNavigation)
+    switch (e.pendingNavigation.type) {
+      case "next":
+        n.send({ type: "NEXT" });
+        break;
+      case "previous":
+        n.send({ type: "PREVIOUS" });
+        break;
+      case "step":
+        n.send({
+          type: "GO_TO_STEP",
+          stepId: e.pendingNavigation.stepId
+        });
+        break;
+    }
+};
+export {
+  p as executePendingNavigation
+};

package/wizard/src/features/state-management/machines/actions/saveActions.js

@@ -0,0 +1,101 @@
+"use client";
+import { assign as t } from "xstate";
+import { ComponentTriggerEngine as r } from "../componentTriggerEngine.js";
+t({
+  saveState: ({
+    context: e,
+    event: a
+  }) => a.type !== "START_SAVE" ? e.saveState : {
+    ...e.saveState,
+    saveInProgress: !0,
+    saveInitiator: a.initiator,
+    savingSection: a.sectionId,
+    saveStartTimestamp: Date.now(),
+    pendingVerifications: [],
+    completedVerifications: [],
+    validationErrors: {}
+  }
+});
+t({
+  saveState: ({
+    context: e,
+    event: a
+  }) => a.type !== "SAVE_DIALOG_SHOWN" ? e.saveState : {
+    ...e.saveState,
+    pendingVerifications: [
+      ...e.saveState.pendingVerifications,
+      a.dialogId
+    ]
+  }
+});
+t({
+  saveState: ({ context: e }) => {
+    const a = r.createExecutionPlan(
+      e.config,
+      "save",
+      e.currentStepIndex,
+      e
+    );
+    return {
+      ...e.saveState,
+      executionPlan: a
+    };
+  }
+});
+const c = ({
+  context: e,
+  self: a
+}) => {
+  const i = e.saveState.executionPlan;
+  i && (i.executions.forEach((n) => {
+    n.actions.forEach((s) => {
+      a.send({
+        type: "EXECUTE_CONTEXT_ACTION",
+        execution: n,
+        action: s
+      });
+    });
+  }), i.totalActions === 0 && a.send({
+    type: "SAVE_ACTIONS_COMPLETE",
+    sectionId: e.saveState.savingSection || "",
+    results: {}
+  }));
+};
+t({
+  activeDialog: null,
+  saveState: ({ context: e }) => ({
+    ...e.saveState,
+    completedVerifications: [
+      ...e.saveState.completedVerifications,
+      `${e.activeDialog?.templateMetadata?.componentId || "unknown"}`
+    ]
+  })
+});
+t({
+  activeDialog: null,
+  saveState: ({ context: e }) => ({
+    ...e.saveState,
+    saveInProgress: !1,
+    saveInitiator: null,
+    savingSection: null,
+    pendingVerifications: [],
+    completedVerifications: [],
+    validationErrors: {},
+    executionPlan: null
+  })
+});
+t({
+  saveState: ({ context: e }) => ({
+    ...e.saveState,
+    saveInProgress: !1,
+    saveInitiator: null,
+    savingSection: null,
+    pendingVerifications: [],
+    completedVerifications: [],
+    validationErrors: {},
+    executionPlan: null
+  })
+});
+export {
+  c as executeSaveActions
+};