@digiform/wizard 0.2.9 → 0.2.11

package/ui/src/lib/utils/templateDialogResolver.js

@@ -0,0 +1,85 @@
+"use client";
+function n(t) {
+  if (t.template?.typeId === "verify-dialog") {
+    const e = t.template.config;
+    return {
+      title: e.title,
+      content: e.description,
+      type: "modal",
+      buttons: [
+        {
+          id: "cancel-btn",
+          label: e.cancelButtonLabel,
+          variant: "secondary",
+          action: e.onCancelAction || { type: "close" }
+        },
+        {
+          id: "verify-btn",
+          label: e.verifyButtonLabel,
+          variant: "primary",
+          action: { type: "custom", handler: "verifyEmail" }
+        }
+      ],
+      dismissible: !0,
+      // Add template metadata for runtime behavior
+      templateMetadata: {
+        typeId: "verify-dialog",
+        codeLength: e.codeLength,
+        codeType: e.codeType,
+        enableAutoSubmit: e.enableAutoSubmit,
+        enableResend: e.enableResend,
+        resendTimer: e.resendTimer,
+        successTitle: e.successTitle,
+        successMessage: e.successMessage,
+        errorMessage: e.errorMessage,
+        continueButtonLabel: e.continueButtonLabel,
+        // Store configurable action for verification success
+        onVerifiedAction: e.onVerifiedAction || {
+          type: "navigate",
+          direction: "next"
+        }
+      }
+    };
+  }
+  if (t.template?.typeId === "confirmation-dialog") {
+    const e = t.template.config;
+    return {
+      title: e.title,
+      content: e.content,
+      type: "modal",
+      buttons: [
+        {
+          id: "cancel-btn",
+          label: e.cancelButtonLabel,
+          variant: "secondary",
+          action: e.onCancelAction || { type: "close" }
+        },
+        {
+          id: "confirm-btn",
+          label: e.confirmButtonLabel,
+          variant: e.confirmButtonVariant || "primary",
+          action: e.onConfirmAction || {
+            type: "navigate",
+            direction: "next"
+          }
+        }
+      ],
+      dismissible: !0,
+      // Add template metadata for runtime behavior
+      templateMetadata: {
+        typeId: "confirmation-dialog",
+        showIcon: e.showIcon,
+        iconType: e.iconType
+      }
+    };
+  }
+  return t.templateTypeId === "verify-dialog" && t.templateConfig ? n({
+    template: {
+      typeId: t.templateTypeId,
+      config: t.templateConfig
+    }
+  }) : t;
+}
+export {
+  n as resolveTemplateDialog
+};

package/ui/src/lib/utils/templateUtils.js

@@ -0,0 +1,52 @@
+"use client";
+import { isTemplateStep as l } from "../../../../core/src/types/guards.js";
+const r = {
+  GENERIC: "generic-",
+  TEAM: "team-"
+};
+function i(e) {
+  return e.startsWith(r.GENERIC) ? "generic" : e.startsWith(r.TEAM) ? "team" : null;
+}
+function p(e) {
+  return i(e) === "generic";
+}
+function m(e) {
+  return i(e) === "team";
+}
+function T(e) {
+  return {
+    /**
+     * Lists all available generic templates
+     */
+    getAvailableGenericTemplatesSync() {
+      return e.getAvailableGenericTemplates();
+    },
+    /**
+     * Gets metadata for a template without loading the full template
+     */
+    async getTemplateInfo(a) {
+      return await e.getTemplateMetadata(a);
+    },
+    /**
+     * Validates that all template references in a configuration are valid
+     */
+    async validateTemplateReferences(a) {
+      const n = [], s = await e.getAvailableTemplates();
+      for (const t of a.steps)
+        l(t) && (s.includes(t.templateId) || n.push(
+          `Template '${t.templateId}' referenced in step '${t.id}' does not exist`
+        ));
+      return {
+        isValid: n.length === 0,
+        errors: n
+      };
+    }
+  };
+}
+export {
+  r as TEMPLATE_PREFIXES,
+  T as createAsyncTemplateFunctions,
+  i as getTemplateTypeFromId,
+  p as isGenericTemplate,
+  m as isTeamTemplate
+};

package/ui/src/theme/ThemeProvider.js

@@ -0,0 +1,15 @@
+"use client";
+import { jsx as r } from "react/jsx-runtime";
+import { createContext as m } from "react";
+let e = null;
+const i = () => (e || (e = m(void 0)), e), l = ({ children: t }) => {
+  const o = { theme: "eva-light", setTheme: () => {
+  } }, n = i();
+  return /* @__PURE__ */ r(n.Provider, { value: o, children: t });
+}, u = () => ({
+  name: "eva-light"
+});
+export {
+  l as ThemeProvider,
+  u as useThemeConfig
+};

package/wizard/src/features/api-integration/components/EnhancedActionExecutor/EnhancedActionExecutor.js

@@ -0,0 +1,370 @@
+"use client";
+import { jsxs as k, Fragment as D, jsx as B } from "react/jsx-runtime";
+/* empty css                                  */
+import { logger as O } from "../../../../../../ui/src/lib/logger.js";
+import { useApiAction as z } from "../../../form-runtime/hooks/useApiActions.js";
+import { ActionValidator as q, ActionValidationError as R } from "../../../validation-system/validation/ActionValidation.js";
+import { memo as L, useState as N, useRef as I, useMemo as h, useEffect as m, useCallback as w } from "react";
+const F = L(
+  ({
+    actions: i,
+    trigger: r,
+    formData: e,
+    onComplete: s,
+    onError: o,
+    onFieldUpdate: c,
+    onShowDialog: v,
+    onNavigate: p,
+    machineRef: a
+  }) => {
+    const [f, g] = N({}), [d, x] = N(0), A = I(""), b = I(!1), l = h(() => i.filter((t) => t.trigger === r).sort((t, n) => t.order - n.order), [i, r]), E = h(() => l.reduce((t, n) => {
+      const u = q.validateAction(n);
+      return u.isValid || t.push(`Action '${n.id}': ${u.errors.join(", ")}`), t;
+    }, []), [l]), C = h(() => l.map((t) => t.id).sort().join(","), [l]);
+    m(() => {
+      if (b.current && A.current === C)
+        return;
+      if (l.length === 0) {
+        b.current = !0, A.current = C, a?.send({ type: "ACTIONS_COMPLETED", results: {} }), s({});
+        return;
+      }
+      if (E.length > 0) {
+        b.current = !0, A.current = C;
+        const n = new R(
+          "validation-error",
+          "validation",
+          `Action validation failed: ${E.join("; ")}`,
+          { validationErrors: E }
+        );
+        O.error(
+          "Action validation failed",
+          { errors: E },
+          n
+        ), a?.send({ type: "ACTIONS_COMPLETED", results: {} }), o(n);
+        return;
+      }
+      const t = {};
+      for (const n of l)
+        t[n.id] = {
+          action: n,
+          status: "pending"
+        };
+      g(t), b.current = !0, A.current = C;
+      for (const n of l)
+        a?.send({ type: "ACTION_START", actionId: n.id });
+      x(0);
+    }, [
+      C,
+      l,
+      E,
+      a,
+      s,
+      o
+    ]), m(() => () => {
+      b.current = !1, A.current = "";
+    }, []);
+    const y = l[d], S = y ? f[y.id] : null;
+    m(() => {
+      const t = Object.values(f);
+      if (t.length > 0 && t.every(
+        (u) => u.status === "completed" || u.status === "error"
+      )) {
+        const u = {};
+        for (const [$, T] of Object.entries(f))
+          u[$] = T.error ? { error: T.error.message } : T.result;
+        a?.send({ type: "ACTIONS_COMPLETED", results: u }), s(u);
+      }
+    }, [f, a, s]), m(() => {
+      if (S?.status === "completed" || S?.status === "error") {
+        const t = d + 1;
+        t < l.length && x(t);
+      }
+    }, [S?.status, d, l.length]);
+    const j = w(
+      (t, n) => {
+        g((u) => ({
+          ...u,
+          [t]: { ...u[t], ...n }
+        }));
+      },
+      []
+    ), _ = w(
+      (t, n) => {
+        a?.send({
+          type: "ACTION_SUCCESS",
+          actionId: t,
+          result: n
+        });
+      },
+      [a]
+    ), P = w(
+      (t, n) => {
+        a?.send({
+          type: "ACTION_ERROR",
+          actionId: t,
+          error: n
+        });
+      },
+      [a]
+    );
+    return /* @__PURE__ */ k(D, { children: [
+      process.env.NODE_ENV === "development" && !1,
+      l.filter((t) => t.type === "apiCall").map((t) => /* @__PURE__ */ B(
+        M,
+        {
+          action: t,
+          formData: e,
+          onFieldUpdate: c,
+          execution: f[t.id],
+          onExecutionUpdate: j,
+          onResult: _,
+          onError: P
+        },
+        t.id
+      )),
+      y && y.type !== "apiCall" && S?.status === "pending" && /* @__PURE__ */ B(
+        V,
+        {
+          action: y,
+          formData: e,
+          onComplete: (t) => {
+            g((n) => ({
+              ...n,
+              [y.id]: {
+                ...n[y.id],
+                status: "completed",
+                result: t
+              }
+            }));
+          },
+          onError: (t) => {
+            g((n) => ({
+              ...n,
+              [y.id]: {
+                ...n[y.id],
+                status: "error",
+                error: t
+              }
+            }));
+          },
+          onShowDialog: v,
+          onNavigate: p
+        }
+      )
+    ] });
+  }
+), M = L(
+  ({
+    action: i,
+    formData: r,
+    onFieldUpdate: e,
+    execution: s,
+    onExecutionUpdate: o,
+    onResult: c,
+    onError: v
+  }) => {
+    const p = i.config, a = I(!1), f = I(!1);
+    m(() => {
+      a.current = !1, f.current = !1;
+    }, []);
+    const { data: g, error: d, isSuccess: x, isError: A, execute: b } = z({
+      config: p,
+      formData: r,
+      onFieldUpdate: e,
+      enabled: !1
+      // We'll trigger manually
+    });
+    return m(() => {
+      s?.status === "pending" && !a.current && (a.current = !0, o(i.id, { status: "executing" }), b());
+    }, [s?.status, i.id, o, b]), m(() => {
+      x && g !== void 0 && s?.status === "executing" && !f.current && (f.current = !0, o(i.id, { status: "completed", result: g }), c(i.id, g));
+    }, [
+      x,
+      g,
+      s?.status,
+      i.id,
+      o,
+      c
+    ]), m(() => {
+      A && d && s?.status === "executing" && (O.error(
+        "API execution failed",
+        { actionId: i.id, error: d.message },
+        d
+      ), o(i.id, {
+        status: "error",
+        error: d
+      }), v(i.id, d));
+    }, [
+      A,
+      d,
+      s?.status,
+      i.id,
+      o,
+      v
+    ]), null;
+  }
+), V = L(
+  ({ action: i, formData: r, onComplete: e, onError: s, onShowDialog: o, onNavigate: c }) => (m(() => {
+    (async () => {
+      try {
+        let p = null;
+        switch (i.type) {
+          case "showDialog": {
+            p = await new K().execute(
+              i.config,
+              r,
+              o
+            );
+            break;
+          }
+          case "navigate": {
+            p = await new G().execute(
+              i.config,
+              c
+            );
+            break;
+          }
+          default:
+            throw new Error(`Unknown non-API action type: ${i.type}`);
+        }
+        e(p);
+      } catch (p) {
+        s(p);
+      }
+    })();
+  }, [i, r, e, s, o, c]), null)
+);
+class K {
+  async execute(r, e, s) {
+    let o;
+    if (r.template?.typeId)
+      o = this.resolveDialogTemplate(r.template);
+    else if (r.content && r.title)
+      o = r;
+    else
+      throw new Error(
+        "Invalid dialog configuration: missing required template or content properties"
+      );
+    const c = {
+      ...o,
+      content: this.interpolateTemplate(o.content, e)
+    };
+    return s(c), c;
+  }
+  resolveDialogTemplate(r) {
+    if (r.typeId === "verify-dialog") {
+      const e = r.config || {};
+      return {
+        title: String(e.title || "Verification Required"),
+        content: String(
+          e.description || "Please verify your information."
+        ),
+        type: "modal",
+        size: "medium",
+        dismissible: !0,
+        buttons: [
+          {
+            id: "cancel-btn",
+            label: String(e.cancelButtonLabel || "Cancel"),
+            variant: "secondary",
+            action: e.onCancelAction || {
+              type: "close"
+            }
+          },
+          {
+            id: "verify-btn",
+            label: String(e.verifyButtonLabel || "Verify"),
+            variant: "primary",
+            action: e.onVerifiedAction || {
+              type: "custom",
+              handler: "verifyEmail"
+            }
+          }
+        ],
+        // Add template metadata for runtime behavior
+        templateMetadata: {
+          typeId: "verify-dialog",
+          codeLength: e.codeLength,
+          codeType: e.codeType,
+          enableAutoSubmit: e.enableAutoSubmit,
+          enableResend: e.enableResend,
+          resendTimer: e.resendTimer,
+          successTitle: e.successTitle,
+          successMessage: e.successMessage,
+          errorMessage: e.errorMessage,
+          continueButtonLabel: e.continueButtonLabel,
+          cancelButtonLabel: e.cancelButtonLabel,
+          verifyButtonLabel: e.verifyButtonLabel,
+          resendButtonLabel: e.resendButtonLabel
+        }
+      };
+    }
+    if (r.typeId === "confirmation-dialog") {
+      const e = r.config || {};
+      return {
+        title: String(e.title || "Confirm Action"),
+        content: String(
+          e.message || e.content || "Are you sure you want to proceed?"
+        ),
+        type: "modal",
+        size: "medium",
+        dismissible: !0,
+        buttons: [
+          {
+            id: "cancel-btn",
+            label: String(e.cancelButtonLabel || "Cancel"),
+            variant: "secondary",
+            action: e.onCancelAction || {
+              type: "close"
+            }
+          },
+          {
+            id: "confirm-btn",
+            label: String(e.confirmButtonLabel || "Confirm"),
+            variant: this.mapButtonVariant(e.confirmButtonVariant),
+            action: e.onConfirmAction || {
+              type: "navigate",
+              direction: "next"
+            }
+          }
+        ],
+        // Add template metadata for runtime behavior
+        templateMetadata: {
+          typeId: "confirmation-dialog",
+          showIcon: e.showIcon,
+          iconType: e.iconType
+        }
+      };
+    }
+    throw new Error(`Unknown dialog template type: ${r.typeId}`);
+  }
+  interpolateTemplate(r, e) {
+    return r.replace(/\$\{data\.([^}]+)\}/g, (s, o) => {
+      const c = e[o];
+      return c != null ? String(c) : s;
+    });
+  }
+  mapButtonVariant(r) {
+    switch (String(r || "primary").toLowerCase()) {
+      case "secondary":
+        return "secondary";
+      case "danger":
+      case "destructive":
+        return "danger";
+      default:
+        return "primary";
+    }
+  }
+}
+class G {
+  async execute(r, e) {
+    return e(r), r;
+  }
+}
+F.displayName = "EnhancedActionExecutor";
+M.displayName = "ActionApiExecutor";
+V.displayName = "ActionNonApiExecutor";
+export {
+  F as EnhancedActionExecutor,
+  F as default
+};