@carlonicora/nextjs-jsonapi 5.2.0 → 5.3.0

package/dist/email-automations/index.mjs

@@ -0,0 +1,1705 @@
+"use client";
+import {
+  AdministrationProvider,
+  Badge,
+  Button,
+  ConfirmDialog,
+  ContentListTable,
+  ContextMenu,
+  ContextMenuContent,
+  ContextMenuItem,
+  EditorSheet,
+  EmptyState,
+  FormInput,
+  FormSelect,
+  FormSwitch,
+  FormTextarea,
+  Link,
+  RoundPageContainer,
+  SectionHeader,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  SharedProvider,
+  Switch,
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+  errorToast,
+  registerTableGenerator,
+  useDataListRetriever,
+  usePageUrlGenerator,
+  useSidebar
+} from "../chunk-MIZTWBPX.mjs";
+import "../chunk-6WU74VFU.mjs";
+import "../chunk-PW42LRSL.mjs";
+import {
+  EmailAutomationEnrollmentService,
+  EmailAutomationService,
+  EmailAutomationStepService,
+  Modules,
+  dateFormatLocale,
+  formatDate,
+  showError,
+  useI18nRouter,
+  useIsMobile
+} from "../chunk-JQWI62NV.mjs";
+import "../chunk-AUXK7QSA.mjs";
+import "../chunk-PI56A4DG.mjs";
+import "../chunk-V5MI7RNB.mjs";
+import "../chunk-VOXD3ZLY.mjs";
+import {
+  __name
+} from "../chunk-PAWJFY3S.mjs";
+
+// src/features/email-automation/components/lists/EmailAutomationsList.tsx
+import { MailIcon } from "lucide-react";
+import { useTranslations as useTranslations2 } from "next-intl";
+import { useEffect as useEffect2, useMemo as useMemo2, useState as useState2 } from "react";
+
+// src/features/email-automation/components/forms/EmailAutomationEditor.tsx
+import { zodResolver } from "@hookform/resolvers/zod";
+import { useTranslations } from "next-intl";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useForm } from "react-hook-form";
+import { v4 } from "uuid";
+import { z } from "zod";
+import { jsx, jsxs } from "react/jsx-runtime";
+function EmailAutomationEditorInternal({
+  automation,
+  propagateChanges,
+  onSuccess,
+  trigger,
+  forceShow,
+  onClose,
+  dialogOpen,
+  onDialogOpenChange
+}) {
+  const t = useTranslations();
+  const router = useI18nRouter();
+  const isEdit = !!automation;
+  const [triggers, setTriggers] = useState([]);
+  useEffect(() => {
+    let active = true;
+    EmailAutomationService.findTriggers().then((list) => {
+      if (active) setTriggers(list);
+    }).catch(() => {
+    });
+    return () => {
+      active = false;
+    };
+  }, []);
+  const triggerValues = useMemo(() => triggers.map((entry) => ({ id: entry.key, text: entry.label })), [triggers]);
+  const formSchema = useMemo(
+    () => z.object({
+      id: z.uuidv4(),
+      name: z.string().min(1, { message: t("emailAutomations.fields.name.error") }),
+      trigger: z.string().optional(),
+      exitTrigger: z.string().optional(),
+      replyTo: z.string().refine((value) => value === "" || z.email().safeParse(value).success, {
+        message: t("emailAutomations.fields.replyTo.error")
+      }),
+      isActive: z.boolean()
+    }),
+    [t]
+  );
+  const getDefaultValues = useCallback(
+    () => ({
+      id: automation?.id ?? v4(),
+      name: automation?.name ?? "",
+      trigger: automation?.trigger ?? "",
+      exitTrigger: automation?.exitTrigger ?? "",
+      replyTo: automation?.replyTo ?? "",
+      isActive: automation?.isActive ?? false
+    }),
+    [automation]
+  );
+  const form = useForm({
+    resolver: zodResolver(formSchema),
+    defaultValues: getDefaultValues()
+  });
+  return /* @__PURE__ */ jsx(
+    EditorSheet,
+    {
+      form,
+      entityType: t("emailAutomations.admin.title"),
+      entityName: automation?.name,
+      title: isEdit ? t("emailAutomations.admin.editAutomation") : t("emailAutomations.admin.newAutomation"),
+      isEdit,
+      module: Modules.EmailAutomation,
+      size: "md",
+      propagateChanges,
+      onSuccess,
+      onNavigate: (url) => router.push(url),
+      onSubmit: async (values) => {
+        const payload = {
+          id: values.id,
+          name: values.name,
+          trigger: values.trigger || void 0,
+          exitTrigger: values.exitTrigger || void 0,
+          replyTo: values.replyTo || void 0,
+          isActive: values.isActive
+        };
+        return isEdit ? await EmailAutomationService.update(payload) : await EmailAutomationService.create(payload);
+      },
+      onReset: getDefaultValues,
+      trigger,
+      forceShow,
+      onClose,
+      dialogOpen,
+      onDialogOpenChange,
+      children: /* @__PURE__ */ jsxs("div", { className: "flex w-full flex-col gap-y-4", children: [
+        /* @__PURE__ */ jsx(FormInput, { form, id: "name", name: t("emailAutomations.fields.name.label"), isRequired: true }),
+        /* @__PURE__ */ jsx(
+          FormSelect,
+          {
+            form,
+            id: "trigger",
+            name: t("emailAutomations.fields.trigger.label"),
+            placeholder: t("emailAutomations.fields.trigger.none"),
+            values: triggerValues,
+            allowEmpty: true
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          FormSelect,
+          {
+            form,
+            id: "exitTrigger",
+            name: t("emailAutomations.fields.exitTrigger.label"),
+            placeholder: t("emailAutomations.fields.trigger.none"),
+            values: triggerValues,
+            allowEmpty: true
+          }
+        ),
+        /* @__PURE__ */ jsx(FormInput, { form, id: "replyTo", name: t("emailAutomations.fields.replyTo.label") }),
+        /* @__PURE__ */ jsx(
+          FormSwitch,
+          {
+            form,
+            id: "isActive",
+            name: t("emailAutomations.fields.isActive.label"),
+            description: t("emailAutomations.fields.isActive.help")
+          }
+        )
+      ] })
+    }
+  );
+}
+__name(EmailAutomationEditorInternal, "EmailAutomationEditorInternal");
+function EmailAutomationEditor(props) {
+  return /* @__PURE__ */ jsx(EmailAutomationEditorInternal, { ...props });
+}
+__name(EmailAutomationEditor, "EmailAutomationEditor");
+var EmailAutomationEditor_default = EmailAutomationEditor;
+
+// src/features/email-automation/components/lists/EmailAutomationsList.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function EmailAutomationsList({ fullWidth } = {}) {
+  const t = useTranslations2();
+  const [triggers, setTriggers] = useState2([]);
+  const data = useDataListRetriever({
+    retriever: /* @__PURE__ */ __name((params) => EmailAutomationService.findMany(params), "retriever"),
+    retrieverParams: {},
+    module: Modules.EmailAutomation
+  });
+  useEffect2(() => {
+    let active = true;
+    EmailAutomationService.findTriggers().then((list) => {
+      if (active) setTriggers(list);
+    }).catch(() => {
+    });
+    return () => {
+      active = false;
+    };
+  }, []);
+  const triggerLabels = useMemo2(
+    () => Object.fromEntries(triggers.map((trigger) => [trigger.key, trigger.label])),
+    [triggers]
+  );
+  const functions = [/* @__PURE__ */ jsx2(EmailAutomationEditor_default, {}, "create-email-automation")];
+  return /* @__PURE__ */ jsx2(
+    ContentListTable,
+    {
+      data,
+      fields: [
+        "name" /* name */,
+        "trigger" /* trigger */,
+        "status" /* status */,
+        "steps" /* steps */,
+        "active" /* active */,
+        "completed" /* completed */,
+        "unsubscribed" /* unsubscribed */
+      ],
+      tableGeneratorType: Modules.EmailAutomation,
+      functions,
+      fullWidth,
+      title: t("emailAutomations.admin.title"),
+      context: { triggerLabels },
+      emptyState: /* @__PURE__ */ jsx2(EmptyState, { icon: MailIcon, title: t("emailAutomations.admin.empty") })
+    }
+  );
+}
+__name(EmailAutomationsList, "EmailAutomationsList");
+
+// src/features/email-automation/components/containers/EmailAutomationsListContainer.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function EmailAutomationsListContainer() {
+  return /* @__PURE__ */ jsx3(AdministrationProvider, { children: /* @__PURE__ */ jsx3(RoundPageContainer, { module: Modules.EmailAutomation, fullWidth: true, children: /* @__PURE__ */ jsx3(EmailAutomationsList, { fullWidth: true }) }) });
+}
+__name(EmailAutomationsListContainer, "EmailAutomationsListContainer");
+
+// src/features/email-automation/components/containers/EmailAutomationContainer.tsx
+import { useTranslations as useTranslations9 } from "next-intl";
+
+// src/features/email-automation/contexts/EmailAutomationContext.tsx
+import { createContext, useCallback as useCallback2, useContext, useEffect as useEffect3, useMemo as useMemo3, useState as useState3 } from "react";
+import { v4 as v42 } from "uuid";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var EmailAutomationContext = createContext(void 0);
+var EmailAutomationProvider = /* @__PURE__ */ __name(({ automationId, children }) => {
+  const [automation, setAutomation] = useState3(void 0);
+  const [steps, setSteps] = useState3([]);
+  const [triggers, setTriggers] = useState3([]);
+  const [selectedStepId, setSelectedStepId] = useState3(null);
+  const reload = useCallback2(async () => {
+    const [loadedAutomation, loadedSteps] = await Promise.all([
+      EmailAutomationService.findOne({ id: automationId }),
+      EmailAutomationStepService.findByAutomation({ automationId })
+    ]);
+    setAutomation(loadedAutomation);
+    setSteps(loadedSteps);
+  }, [automationId]);
+  useEffect3(() => {
+    void reload();
+  }, [reload]);
+  useEffect3(() => {
+    let active = true;
+    EmailAutomationService.findTriggers().then((list) => {
+      if (active) setTriggers(list);
+    }).catch(() => {
+    });
+    return () => {
+      active = false;
+    };
+  }, []);
+  const select = useCallback2((id) => setSelectedStepId(id), []);
+  const createStep = useCallback2(
+    async (input) => {
+      const saved = await EmailAutomationStepService.create({ ...input, id: input.id ?? v42(), automationId });
+      await reload();
+      return saved;
+    },
+    [automationId, reload]
+  );
+  const updateStep = useCallback2(
+    async (input) => {
+      const saved = await EmailAutomationStepService.update({ ...input, automationId });
+      await reload();
+      return saved;
+    },
+    [automationId, reload]
+  );
+  const deleteStep = useCallback2(
+    async (id) => {
+      await EmailAutomationStepService.delete({ id });
+      if (selectedStepId === id) setSelectedStepId(null);
+      await reload();
+    },
+    [reload, selectedStepId]
+  );
+  const setNext = useCallback2(
+    async (stepId, nextStepId) => {
+      if (nextStepId) await EmailAutomationStepService.setNext({ stepId, nextStepId });
+      else await EmailAutomationStepService.clearNext({ stepId });
+      await reload();
+    },
+    [reload]
+  );
+  const updatePosition = useCallback2(
+    async (stepId, x, y) => {
+      const step = steps.find((candidate) => candidate.id === stepId);
+      if (!step) return;
+      await EmailAutomationStepService.update({
+        id: step.id,
+        automationId,
+        subject: step.subject,
+        body: step.body,
+        delayHours: step.delayHours,
+        positionX: x,
+        positionY: y
+      });
+      await reload();
+    },
+    [automationId, reload, steps]
+  );
+  const tidy = useCallback2(async () => {
+    await EmailAutomationService.tidy({ id: automationId });
+    await reload();
+  }, [automationId, reload]);
+  const value = useMemo3(
+    () => ({
+      automation,
+      steps,
+      reload,
+      selectedStepId,
+      select,
+      createStep,
+      updateStep,
+      deleteStep,
+      setNext,
+      updatePosition,
+      tidy,
+      triggers
+    }),
+    [
+      automation,
+      steps,
+      reload,
+      selectedStepId,
+      select,
+      createStep,
+      updateStep,
+      deleteStep,
+      setNext,
+      updatePosition,
+      tidy,
+      triggers
+    ]
+  );
+  return /* @__PURE__ */ jsx4(EmailAutomationContext.Provider, { value, children });
+}, "EmailAutomationProvider");
+var useEmailAutomation = /* @__PURE__ */ __name(() => {
+  const context = useContext(EmailAutomationContext);
+  if (context === void 0) {
+    throw new Error("useEmailAutomation must be used within an EmailAutomationProvider");
+  }
+  return context;
+}, "useEmailAutomation");
+
+// src/features/email-automation/components/canvas/EmailAutomationActiveSwitch.tsx
+import { useTranslations as useTranslations3 } from "next-intl";
+import { useState as useState4 } from "react";
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+function EmailAutomationActiveSwitch() {
+  const t = useTranslations3();
+  const { automation, reload } = useEmailAutomation();
+  const [saving, setSaving] = useState4(false);
+  if (!automation) return null;
+  const toggle = /* @__PURE__ */ __name(async (checked) => {
+    setSaving(true);
+    try {
+      await EmailAutomationService.update({
+        id: automation.id,
+        name: automation.name,
+        trigger: automation.trigger,
+        exitTrigger: automation.exitTrigger,
+        replyTo: automation.replyTo,
+        isActive: checked
+      });
+      await reload();
+    } catch (error) {
+      errorToast({ title: t("common.errors.error"), error });
+    } finally {
+      setSaving(false);
+    }
+  }, "toggle");
+  return /* @__PURE__ */ jsxs2(Tooltip, { children: [
+    /* @__PURE__ */ jsxs2(TooltipTrigger, { render: /* @__PURE__ */ jsx5("label", { className: "flex items-center gap-x-2" }), children: [
+      /* @__PURE__ */ jsx5(Switch, { checked: automation.isActive, onCheckedChange: (checked) => void toggle(checked), disabled: saving }),
+      /* @__PURE__ */ jsx5("span", { className: "text-xs", children: t("emailAutomations.fields.isActive.label") })
+    ] }),
+    /* @__PURE__ */ jsx5(TooltipContent, { className: "max-w-xs", children: t("emailAutomations.fields.isActive.help") })
+  ] });
+}
+__name(EmailAutomationActiveSwitch, "EmailAutomationActiveSwitch");
+
+// src/features/email-automation/components/canvas/EmailAutomationCanvasTab.tsx
+import { ReactFlowProvider } from "@xyflow/react";
+import { useEffect as useEffect5 } from "react";
+
+// src/features/email-automation/components/canvas/EmailAutomationCanvas.tsx
+import {
+  Background,
+  ReactFlow,
+  applyEdgeChanges,
+  applyNodeChanges,
+  useReactFlow as useReactFlow2
+} from "@xyflow/react";
+import "@xyflow/react/dist/style.css";
+import { PlusIcon as PlusIcon2, Trash2Icon } from "lucide-react";
+import { useTranslations as useTranslations7 } from "next-intl";
+import { useCallback as useCallback5, useEffect as useEffect4, useMemo as useMemo6, useRef as useRef2, useState as useState5 } from "react";
+import { v4 as uuidv4 } from "uuid";
+
+// src/features/email-automation/components/canvas/shared/CanvasToolbar.tsx
+import { useReactFlow } from "@xyflow/react";
+import { ListRestartIcon, MaximizeIcon, MinusIcon, PlusIcon } from "lucide-react";
+import { useTranslations as useTranslations4 } from "next-intl";
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+function CanvasToolbar({ onTidy }) {
+  const t = useTranslations4();
+  const { zoomIn, zoomOut, fitView } = useReactFlow();
+  return /* @__PURE__ */ jsxs3("div", { "data-help": "canvas.toolbar", className: "absolute end-2 top-2 z-10 flex flex-col gap-1 max-md:top-14", children: [
+    /* @__PURE__ */ jsx6(
+      Button,
+      {
+        type: "button",
+        variant: "outline",
+        size: "icon",
+        onClick: () => zoomIn(),
+        "aria-label": t("canvas.toolbar.zoomIn"),
+        children: /* @__PURE__ */ jsx6(PlusIcon, { className: "h-4 w-4" })
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      Button,
+      {
+        type: "button",
+        variant: "outline",
+        size: "icon",
+        onClick: () => zoomOut(),
+        "aria-label": t("canvas.toolbar.zoomOut"),
+        children: /* @__PURE__ */ jsx6(MinusIcon, { className: "h-4 w-4" })
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      Button,
+      {
+        type: "button",
+        variant: "outline",
+        size: "icon",
+        onClick: () => fitView({ duration: 300 }),
+        "aria-label": t("canvas.toolbar.fitView"),
+        children: /* @__PURE__ */ jsx6(MaximizeIcon, { className: "h-4 w-4" })
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      Button,
+      {
+        type: "button",
+        variant: "outline",
+        size: "icon",
+        onClick: () => void onTidy(),
+        title: t("canvas.toolbar.tidyTooltip"),
+        "aria-label": t("canvas.toolbar.tidy"),
+        children: /* @__PURE__ */ jsx6(ListRestartIcon, { className: "h-4 w-4" })
+      }
+    )
+  ] });
+}
+__name(CanvasToolbar, "CanvasToolbar");
+
+// src/features/email-automation/components/canvas/shared/EmptyCanvas.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function EmptyCanvas({ children }) {
+  return /* @__PURE__ */ jsx7("div", { className: "text-muted-foreground flex h-full w-full items-center justify-center px-6 text-center text-sm", children });
+}
+__name(EmptyCanvas, "EmptyCanvas");
+
+// src/features/email-automation/components/canvas/shared/autoLayout.ts
+import dagre from "dagre";
+function autoLayout(nodes, edges) {
+  const g = new dagre.graphlib.Graph();
+  g.setGraph({ rankdir: "LR", nodesep: 60, ranksep: 100, marginx: 24, marginy: 24 });
+  g.setDefaultEdgeLabel(() => ({}));
+  for (const n of nodes) {
+    g.setNode(n.id, { width: n.width, height: n.height });
+  }
+  for (const e of edges) {
+    if (g.hasNode(e.source) && g.hasNode(e.target)) {
+      g.setEdge(e.source, e.target);
+    }
+  }
+  dagre.layout(g);
+  const result = {};
+  for (const n of nodes) {
+    if (n.manuallyPositioned && typeof n.x === "number" && typeof n.y === "number") {
+      result[n.id] = { x: n.x, y: n.y };
+    } else {
+      const laid = g.node(n.id);
+      result[n.id] = {
+        x: laid.x - n.width / 2,
+        y: laid.y - n.height / 2
+      };
+    }
+  }
+  return result;
+}
+__name(autoLayout, "autoLayout");
+
+// src/features/email-automation/components/canvas/shared/longPress.ts
+var LONG_PRESS_MS = 500;
+var LONG_PRESS_MOVE_TOLERANCE_PX = 10;
+function createLongPressTracker(params) {
+  const delay = params.delayMs ?? LONG_PRESS_MS;
+  const tolerance = params.moveTolerancePx ?? LONG_PRESS_MOVE_TOLERANCE_PX;
+  const setTimer = params.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearTimer = params.clearTimer ?? ((handle) => clearTimeout(handle));
+  let timer = null;
+  let start = null;
+  let fired = false;
+  const cancel = /* @__PURE__ */ __name(() => {
+    if (timer !== null) clearTimer(timer);
+    timer = null;
+    start = null;
+  }, "cancel");
+  return {
+    down(target, clientX, clientY) {
+      cancel();
+      fired = false;
+      start = { x: clientX, y: clientY };
+      timer = setTimer(() => {
+        timer = null;
+        start = null;
+        fired = true;
+        params.onLongPress({ target, clientX, clientY });
+      }, delay);
+    },
+    move(clientX, clientY) {
+      if (!start) return;
+      if (Math.hypot(clientX - start.x, clientY - start.y) > tolerance) cancel();
+    },
+    up: cancel,
+    cancel,
+    consumeClick() {
+      const wasFired = fired;
+      fired = false;
+      return wasFired;
+    }
+  };
+}
+__name(createLongPressTracker, "createLongPressTracker");
+
+// src/features/email-automation/components/canvas/buildCanvasGraph.ts
+var TRIGGER_NODE_ID = "trigger";
+var TRIGGER_SOURCE_HANDLE = "trigger-source";
+var STEP_NODE_PREFIX = "step:";
+var STEP_SOURCE_HANDLE_PREFIX = "step-source-";
+var STEP_TARGET_HANDLE_PREFIX = "step-target-";
+var TRIGGER_NODE_WIDTH = 200;
+var TRIGGER_NODE_HEIGHT = 56;
+var STEP_NODE_WIDTH = 200;
+var STEP_NODE_HEIGHT = 72;
+function findHeadStepId(steps) {
+  const pointedAt = new Set(steps.map((s) => s.next?.id).filter((id) => !!id));
+  return steps.find((s) => !pointedAt.has(s.id))?.id ?? null;
+}
+__name(findHeadStepId, "findHeadStepId");
+var stepNodeId = /* @__PURE__ */ __name((stepId) => `${STEP_NODE_PREFIX}${stepId}`, "stepNodeId");
+function buildCanvasGraph(steps, triggerLabel) {
+  const byId = new Map(steps.map((s) => [s.id, s]));
+  const headId = findHeadStepId(steps);
+  const chain = /* @__PURE__ */ new Set();
+  let cursor = headId ? byId.get(headId) : void 0;
+  while (cursor && !chain.has(cursor.id)) {
+    chain.add(cursor.id);
+    cursor = cursor.next ? byId.get(cursor.next.id) : void 0;
+  }
+  const orphanIds = steps.filter((s) => !chain.has(s.id)).map((s) => s.id);
+  const layoutNodes = [
+    { id: TRIGGER_NODE_ID, width: TRIGGER_NODE_WIDTH, height: TRIGGER_NODE_HEIGHT, manuallyPositioned: false },
+    ...steps.map((s) => ({
+      id: stepNodeId(s.id),
+      width: STEP_NODE_WIDTH,
+      height: STEP_NODE_HEIGHT,
+      manuallyPositioned: typeof s.positionX === "number" && typeof s.positionY === "number",
+      x: s.positionX,
+      y: s.positionY
+    }))
+  ];
+  const edges = [];
+  const layoutEdges = [];
+  const pushEdge = /* @__PURE__ */ __name((source, sourceHandle, target) => {
+    const data = { targetStepId: target.id, delayHours: target.delayHours };
+    edges.push({
+      id: `next:${source}->${target.id}`,
+      source,
+      sourceHandle,
+      target: stepNodeId(target.id),
+      targetHandle: `${STEP_TARGET_HANDLE_PREFIX}${target.id}`,
+      type: "delayEdge",
+      label: `${target.delayHours}h`,
+      data
+    });
+    layoutEdges.push({ source, target: stepNodeId(target.id) });
+  }, "pushEdge");
+  const head = headId ? byId.get(headId) : void 0;
+  if (head) pushEdge(TRIGGER_NODE_ID, TRIGGER_SOURCE_HANDLE, head);
+  for (const s of steps) {
+    const next = s.next ? byId.get(s.next.id) : void 0;
+    if (next) pushEdge(stepNodeId(s.id), `${STEP_SOURCE_HANDLE_PREFIX}${s.id}`, next);
+  }
+  const positions = autoLayout(layoutNodes, layoutEdges);
+  const nodes = [
+    {
+      id: TRIGGER_NODE_ID,
+      type: "triggerNode",
+      position: positions[TRIGGER_NODE_ID],
+      deletable: false,
+      data: { data: { label: triggerLabel } }
+    },
+    ...steps.map((s) => {
+      const id = stepNodeId(s.id);
+      return {
+        id,
+        type: "emailStepNode",
+        position: positions[id],
+        data: {
+          data: {
+            stepId: s.id,
+            subject: s.subject,
+            sentCount: s.sentCount,
+            orphan: !chain.has(s.id),
+            manuallyPositioned: typeof s.positionX === "number" && typeof s.positionY === "number"
+          }
+        }
+      };
+    })
+  ];
+  return { nodes, edges, orphanIds };
+}
+__name(buildCanvasGraph, "buildCanvasGraph");
+
+// src/features/email-automation/components/canvas/edges/DelayEdge.tsx
+import { BaseEdge, EdgeLabelRenderer, getBezierPath } from "@xyflow/react";
+import { Fragment, jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+function DelayEdge({
+  id,
+  sourceX,
+  sourceY,
+  targetX,
+  targetY,
+  sourcePosition,
+  targetPosition,
+  label,
+  data
+}) {
+  const { select } = useEmailAutomation();
+  const [edgePath, labelX, labelY] = getBezierPath({
+    sourceX,
+    sourceY,
+    sourcePosition,
+    targetX,
+    targetY,
+    targetPosition
+  });
+  const targetStepId = data?.targetStepId;
+  return /* @__PURE__ */ jsxs4(Fragment, { children: [
+    /* @__PURE__ */ jsx8(BaseEdge, { id, path: edgePath, className: "stroke-foreground/60", interactionWidth: 24 }),
+    /* @__PURE__ */ jsx8(EdgeLabelRenderer, { children: /* @__PURE__ */ jsx8(
+      "div",
+      {
+        className: "nodrag nopan nowheel",
+        style: {
+          position: "absolute",
+          transform: `translate(-50%, -50%) translate(${labelX}px, ${labelY}px)`,
+          pointerEvents: "all",
+          zIndex: 1e3
+        },
+        onMouseDown: (e) => e.stopPropagation(),
+        children: /* @__PURE__ */ jsx8(
+          "button",
+          {
+            type: "button",
+            className: "nodrag nopan bg-background hover:bg-accent text-foreground border-border h-auto rounded border px-2 py-1 text-xs tabular-nums shadow-sm",
+            onClick: (e) => {
+              e.stopPropagation();
+              if (targetStepId) select(targetStepId);
+            },
+            children: label
+          }
+        )
+      }
+    ) })
+  ] });
+}
+__name(DelayEdge, "DelayEdge");
+
+// src/features/email-automation/components/canvas/EmailAutomationCanvasInspector.tsx
+import { useCallback as useCallback4, useMemo as useMemo5, useRef } from "react";
+
+// src/features/email-automation/components/forms/EmailStepEditor.tsx
+import { zodResolver as zodResolver2 } from "@hookform/resolvers/zod";
+import { useTranslations as useTranslations5 } from "next-intl";
+import { useCallback as useCallback3, useMemo as useMemo4 } from "react";
+import { useForm as useForm2 } from "react-hook-form";
+import { v4 as v43 } from "uuid";
+import { z as z2 } from "zod";
+import { Fragment as Fragment2, jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+var TEMPLATE_VARIABLES = ["{{name}}", "{{email}}", "{{url}}", "{{unsubscribeUrl}}", "{{unsubscribeAllUrl}}"];
+function EmailStepEditorInternal({
+  step,
+  automationId,
+  initialPosition,
+  isHead,
+  trigger,
+  forceShow,
+  onClose,
+  dialogOpen,
+  onDialogOpenChange,
+  onSuccess
+}) {
+  const t = useTranslations5();
+  const { reload } = useEmailAutomation();
+  const isEdit = !!step;
+  const formSchema = useMemo4(
+    () => z2.object({
+      id: z2.uuidv4(),
+      subject: z2.string().min(1, { message: t("emailAutomations.step.fields.subject.error") }),
+      delayHours: z2.number().int().min(0),
+      body: z2.string().min(1, { message: t("emailAutomations.step.fields.body.error") })
+    }),
+    [t]
+  );
+  const getDefaultValues = useCallback3(
+    () => ({
+      id: step?.id ?? v43(),
+      subject: step?.subject ?? "",
+      delayHours: step?.delayHours ?? 24,
+      body: step?.body ?? ""
+    }),
+    [step]
+  );
+  const form = useForm2({
+    resolver: zodResolver2(formSchema),
+    defaultValues: getDefaultValues()
+  });
+  return /* @__PURE__ */ jsx9(
+    EditorSheet,
+    {
+      form,
+      entityType: t("emailAutomations.step.title"),
+      entityName: step?.subject,
+      title: isEdit ? t("emailAutomations.step.editTitle") : t("emailAutomations.step.title"),
+      isEdit,
+      module: Modules.EmailAutomationStep,
+      size: "lg",
+      onSubmit: async (values) => {
+        const payload = {
+          id: values.id,
+          automationId,
+          subject: values.subject,
+          body: values.body,
+          delayHours: values.delayHours,
+          positionX: step ? step.positionX : initialPosition?.x,
+          positionY: step ? step.positionY : initialPosition?.y
+        };
+        return isEdit ? await EmailAutomationStepService.update(payload) : await EmailAutomationStepService.create(payload);
+      },
+      onSuccess: async () => {
+        await reload();
+        await onSuccess?.();
+      },
+      onReset: getDefaultValues,
+      trigger,
+      forceShow,
+      onClose,
+      dialogOpen,
+      onDialogOpenChange,
+      children: /* @__PURE__ */ jsxs5("div", { className: "flex w-full flex-col gap-y-4", children: [
+        /* @__PURE__ */ jsx9(FormInput, { form, id: "subject", name: t("emailAutomations.step.fields.subject.label"), isRequired: true }),
+        /* @__PURE__ */ jsx9(
+          FormInput,
+          {
+            form,
+            id: "delayHours",
+            type: "number",
+            name: t("emailAutomations.step.fields.delayHours.label"),
+            description: isHead ? t("emailAutomations.canvas.hoursAfterEntering") : t("emailAutomations.canvas.hoursAfterPrevious")
+          }
+        ),
+        /* @__PURE__ */ jsx9(
+          FormTextarea,
+          {
+            form,
+            id: "body",
+            name: t("emailAutomations.step.fields.body.label"),
+            className: "min-h-72",
+            isRequired: true,
+            description: /* @__PURE__ */ jsxs5(Fragment2, { children: [
+              /* @__PURE__ */ jsxs5("span", { className: "block", children: [
+                t("emailAutomations.step.variablesHint"),
+                " ",
+                TEMPLATE_VARIABLES.map((variable) => /* @__PURE__ */ jsx9("span", { className: "me-2 text-foreground", children: variable }, variable))
+              ] }),
+              /* @__PURE__ */ jsx9("span", { className: "mt-1 block", children: t("emailAutomations.step.unsubscribeHint") })
+            ] })
+          }
+        )
+      ] })
+    }
+  );
+}
+__name(EmailStepEditorInternal, "EmailStepEditorInternal");
+function EmailStepEditor(props) {
+  return /* @__PURE__ */ jsx9(EmailStepEditorInternal, { ...props });
+}
+__name(EmailStepEditor, "EmailStepEditor");
+
+// src/features/email-automation/components/canvas/EmailAutomationCanvasInspector.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+function EmailAutomationCanvasInspector() {
+  const { automation, steps, selectedStepId, select, reload } = useEmailAutomation();
+  const close = useCallback4(() => select(null), [select]);
+  const onSaved = useCallback4(async () => {
+    await reload();
+  }, [reload]);
+  const headStepId = useMemo5(() => findHeadStepId(steps), [steps]);
+  const step = useMemo5(() => steps.find((s) => s.id === selectedStepId) ?? null, [steps, selectedStepId]);
+  if (!automation || !selectedStepId || !step) return null;
+  return /* @__PURE__ */ jsx10(
+    StepEditor,
+    {
+      step,
+      automationId: automation.id,
+      isHead: step.id === headStepId,
+      onSaved,
+      onClose: close
+    },
+    step.id
+  );
+}
+__name(EmailAutomationCanvasInspector, "EmailAutomationCanvasInspector");
+function useUserClosedGuard(onClose) {
+  const wasOpenRef = useRef(false);
+  return useCallback4(
+    (open) => {
+      if (open) {
+        wasOpenRef.current = true;
+        return;
+      }
+      if (wasOpenRef.current) onClose();
+    },
+    [onClose]
+  );
+}
+__name(useUserClosedGuard, "useUserClosedGuard");
+function StepEditor(props) {
+  const onDialogOpenChange = useUserClosedGuard(props.onClose);
+  return /* @__PURE__ */ jsx10(
+    EmailStepEditor,
+    {
+      step: props.step,
+      automationId: props.automationId,
+      isHead: props.isHead,
+      forceShow: true,
+      dialogOpen: true,
+      onDialogOpenChange,
+      onSuccess: async () => {
+        await props.onSaved();
+        props.onClose();
+      }
+    }
+  );
+}
+__name(StepEditor, "StepEditor");
+
+// src/features/email-automation/components/canvas/nodes/EmailStepNode.tsx
+import { Handle, Position } from "@xyflow/react";
+import { MailIcon as MailIcon2 } from "lucide-react";
+import { useTranslations as useTranslations6 } from "next-intl";
+import { jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
+function EmailStepNode({ data }) {
+  const d = data.data;
+  const t = useTranslations6();
+  const shellClass = d.orphan ? "border border-dashed border-foreground/30 bg-muted/40 opacity-60" : "border bg-background border-foreground/25 text-foreground";
+  return /* @__PURE__ */ jsxs6("div", { className: `w-[200px] cursor-pointer rounded-md p-2 shadow-sm ${shellClass}`, children: [
+    /* @__PURE__ */ jsx11(Handle, { type: "target", position: Position.Left, id: `${STEP_TARGET_HANDLE_PREFIX}${d.stepId}` }),
+    /* @__PURE__ */ jsx11(Handle, { type: "source", position: Position.Right, id: `${STEP_SOURCE_HANDLE_PREFIX}${d.stepId}` }),
+    /* @__PURE__ */ jsxs6("div", { className: "flex items-center gap-1 text-sm font-medium", children: [
+      /* @__PURE__ */ jsx11(MailIcon2, { className: "size-3 shrink-0" }),
+      /* @__PURE__ */ jsx11("span", { className: "truncate", children: d.subject })
+    ] }),
+    /* @__PURE__ */ jsx11("div", { className: "text-muted-foreground mt-1 text-xs tabular-nums", children: t("emailAutomations.canvas.sent", { count: d.sentCount }) }),
+    d.orphan && /* @__PURE__ */ jsx11("div", { className: "text-muted-foreground mt-1 text-xs italic", children: t("emailAutomations.canvas.orphan") })
+  ] });
+}
+__name(EmailStepNode, "EmailStepNode");
+
+// src/features/email-automation/components/canvas/nodes/TriggerNode.tsx
+import { Handle as Handle2, Position as Position2 } from "@xyflow/react";
+import { ZapIcon } from "lucide-react";
+import { jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
+function TriggerNode({ data }) {
+  return /* @__PURE__ */ jsxs7("div", { className: "bg-foreground text-background flex w-[200px] cursor-pointer items-center justify-center gap-1 rounded-full px-4 py-2 text-center shadow-md", children: [
+    /* @__PURE__ */ jsx12(ZapIcon, { className: "size-3 shrink-0 opacity-60" }),
+    /* @__PURE__ */ jsx12("div", { className: "truncate text-sm font-medium", children: data.data.label }),
+    /* @__PURE__ */ jsx12(Handle2, { type: "source", position: Position2.Right, id: TRIGGER_SOURCE_HANDLE })
+  ] });
+}
+__name(TriggerNode, "TriggerNode");
+
+// src/features/email-automation/components/canvas/EmailAutomationCanvas.tsx
+import { Fragment as Fragment3, jsx as jsx13, jsxs as jsxs8 } from "react/jsx-runtime";
+var DEFAULT_DELAY_HOURS = 24;
+var pointAnchor = /* @__PURE__ */ __name((screenX, screenY) => ({
+  getBoundingClientRect: /* @__PURE__ */ __name(() => ({
+    x: screenX,
+    y: screenY,
+    top: screenY,
+    left: screenX,
+    right: screenX,
+    bottom: screenY,
+    width: 0,
+    height: 0,
+    toJSON: /* @__PURE__ */ __name(() => ({}), "toJSON")
+  }), "getBoundingClientRect")
+}), "pointAnchor");
+var stepIdOf = /* @__PURE__ */ __name((nodeId) => nodeId?.startsWith(STEP_NODE_PREFIX) ? nodeId.slice(STEP_NODE_PREFIX.length) : null, "stepIdOf");
+function EmailAutomationCanvas() {
+  const { automation, steps, triggers, select, reload, createStep, deleteStep, setNext, updatePosition, tidy } = useEmailAutomation();
+  const t = useTranslations7();
+  const isMobile = useIsMobile();
+  const [nodes, setNodes] = useState5([]);
+  const [edges, setEdges] = useState5([]);
+  const { screenToFlowPosition } = useReactFlow2();
+  const connectingFromRef = useRef2(null);
+  const [paneMenu, setPaneMenu] = useState5(null);
+  const [nodeMenu, setNodeMenu] = useState5(null);
+  const [pendingDeleteStepId, setPendingDeleteStepId] = useState5(null);
+  const [automationEditorOpen, setAutomationEditorOpen] = useState5(false);
+  const triggerLabel = useMemo6(
+    () => triggers.find((trigger) => trigger.key === automation?.trigger)?.label ?? t("emailAutomations.canvas.noTrigger"),
+    [triggers, automation?.trigger, t]
+  );
+  const { laidNodes, laidEdges } = useMemo6(() => {
+    const graph = buildCanvasGraph(steps, triggerLabel);
+    return { laidNodes: graph.nodes, laidEdges: graph.edges };
+  }, [steps, triggerLabel]);
+  useEffect4(() => {
+    setNodes(laidNodes);
+    setEdges(laidEdges);
+  }, [laidNodes, laidEdges]);
+  const onNodesChange = useCallback5((changes) => setNodes((nds) => applyNodeChanges(changes, nds)), []);
+  const onEdgesChange = useCallback5((changes) => setEdges((eds) => applyEdgeChanges(changes, eds)), []);
+  const onNodeDragStop = useCallback5(
+    (_e, node) => {
+      const stepId = stepIdOf(node.id);
+      if (!stepId) return;
+      void updatePosition(stepId, node.position.x, node.position.y);
+    },
+    [updatePosition]
+  );
+  const onConnectStart = useCallback5((_e, params) => {
+    connectingFromRef.current = { nodeId: params.nodeId ?? null, handleId: params.handleId ?? null };
+  }, []);
+  const linkSteps = useCallback5(
+    async (stepId, nextStepId) => {
+      try {
+        await setNext(stepId, nextStepId);
+      } catch (error) {
+        errorToast({ title: t("emailAutomations.canvas.chainError"), error });
+        await reload();
+      }
+    },
+    [setNext, reload, t]
+  );
+  const onConnect = useCallback5(
+    async (conn) => {
+      const from = connectingFromRef.current;
+      connectingFromRef.current = null;
+      if (!from || !from.handleId) return;
+      if (!conn.targetHandle?.startsWith(STEP_TARGET_HANDLE_PREFIX)) return;
+      const targetStepId = conn.targetHandle.slice(STEP_TARGET_HANDLE_PREFIX.length);
+      if (from.handleId === TRIGGER_SOURCE_HANDLE) {
+        showError(t("emailAutomations.canvas.chainError"));
+        return;
+      }
+      if (!from.handleId.startsWith(STEP_SOURCE_HANDLE_PREFIX)) return;
+      const sourceStepId = from.handleId.slice(STEP_SOURCE_HANDLE_PREFIX.length);
+      await linkSteps(sourceStepId, targetStepId);
+    },
+    [linkSteps, t]
+  );
+  const createStepAt = useCallback5(
+    async (flowX, flowY) => {
+      if (!automation) return null;
+      const id = uuidv4();
+      await createStep({
+        id,
+        automationId: automation.id,
+        subject: t("emailAutomations.step.title"),
+        body: "",
+        delayHours: DEFAULT_DELAY_HOURS,
+        positionX: flowX - STEP_NODE_WIDTH / 2,
+        positionY: flowY - STEP_NODE_HEIGHT / 2
+      });
+      return id;
+    },
+    [automation, createStep, t]
+  );
+  const onConnectEnd = useCallback5(
+    async (event, connectionState) => {
+      const from = connectingFromRef.current;
+      if (!from || !from.handleId || !automation) return;
+      connectingFromRef.current = null;
+      if (connectionState.toNode) return;
+      const clientX = "clientX" in event ? event.clientX : event.changedTouches[0]?.clientX ?? 0;
+      const clientY = "clientY" in event ? event.clientY : event.changedTouches[0]?.clientY ?? 0;
+      const flowPos = screenToFlowPosition({ x: clientX, y: clientY });
+      const sourceStepId = from.handleId.startsWith(STEP_SOURCE_HANDLE_PREFIX) ? from.handleId.slice(STEP_SOURCE_HANDLE_PREFIX.length) : null;
+      if (!sourceStepId && from.handleId !== TRIGGER_SOURCE_HANDLE) return;
+      const newStepId = await createStepAt(flowPos.x, flowPos.y);
+      if (!newStepId) return;
+      if (sourceStepId) await linkSteps(sourceStepId, newStepId);
+      select(newStepId);
+    },
+    [automation, screenToFlowPosition, createStepAt, linkSteps, select]
+  );
+  const handlePaneContextMenu = useCallback5(
+    (event) => {
+      if (!automation) return;
+      event.preventDefault();
+      const clientX = event.clientX;
+      const clientY = event.clientY;
+      const flowPos = screenToFlowPosition({ x: clientX, y: clientY });
+      setPaneMenu({
+        flowX: flowPos.x,
+        flowY: flowPos.y,
+        screenX: clientX,
+        screenY: clientY
+      });
+    },
+    [automation, screenToFlowPosition]
+  );
+  const handleCreateStepFromPane = useCallback5(async () => {
+    const menu = paneMenu;
+    if (!menu) return;
+    setPaneMenu(null);
+    const newStepId = await createStepAt(menu.flowX, menu.flowY);
+    if (newStepId) select(newStepId);
+  }, [paneMenu, createStepAt, select]);
+  const openNodeMenu = useCallback5((nodeId, screenX, screenY) => {
+    const stepId = stepIdOf(nodeId);
+    if (!stepId) return;
+    setNodeMenu({ stepId, screenX, screenY });
+  }, []);
+  const handleNodeContextMenu = useCallback5(
+    (event, node) => {
+      event.preventDefault();
+      openNodeMenu(node.id, event.clientX, event.clientY);
+    },
+    [openNodeMenu]
+  );
+  const openNodeMenuRef = useRef2(openNodeMenu);
+  openNodeMenuRef.current = openNodeMenu;
+  const longPress = useMemo6(
+    () => createLongPressTracker({
+      onLongPress: /* @__PURE__ */ __name(({ target, clientX, clientY }) => {
+        openNodeMenuRef.current(target, clientX, clientY);
+      }, "onLongPress")
+    }),
+    []
+  );
+  useEffect4(() => () => longPress.cancel(), [longPress]);
+  const handleTouchPointerDown = useCallback5(
+    (event) => {
+      if (event.pointerType !== "touch") return;
+      const el = event.target;
+      if (!el || el.closest(".react-flow__handle")) return;
+      const nodeId = el.closest(".react-flow__node")?.getAttribute("data-id");
+      if (!stepIdOf(nodeId)) return;
+      longPress.down(nodeId, event.clientX, event.clientY);
+    },
+    [longPress]
+  );
+  const handleNodeClick = useCallback5(
+    (_event, node) => {
+      if (node.id === TRIGGER_NODE_ID) {
+        setAutomationEditorOpen(true);
+        return;
+      }
+      const stepId = stepIdOf(node.id);
+      if (stepId) select(stepId);
+    },
+    [select]
+  );
+  const handleDeleteStep = useCallback5(async () => {
+    const stepId = pendingDeleteStepId;
+    if (!stepId) return;
+    try {
+      await deleteStep(stepId);
+    } catch (error) {
+      errorToast({ title: t("emailAutomations.canvas.deleteEmail"), error });
+      throw error;
+    }
+  }, [pendingDeleteStepId, deleteStep, t]);
+  const nodeTypes = useMemo6(() => ({ triggerNode: TriggerNode, emailStepNode: EmailStepNode }), []);
+  const edgeTypes = useMemo6(() => ({ delayEdge: DelayEdge }), []);
+  return /* @__PURE__ */ jsxs8(Fragment3, { children: [
+    /* @__PURE__ */ jsx13(
+      ReactFlow,
+      {
+        nodes,
+        edges,
+        onNodesChange,
+        onEdgesChange,
+        onNodeDragStop,
+        onConnectStart,
+        onConnect,
+        onConnectEnd,
+        onPaneContextMenu: handlePaneContextMenu,
+        onNodeContextMenu: handleNodeContextMenu,
+        onNodeClick: handleNodeClick,
+        nodeTypes,
+        edgeTypes,
+        onEdgeClick: (_event, edge) => {
+          const targetStepId = edge.data?.targetStepId;
+          if (targetStepId) select(targetStepId);
+        },
+        fitView: true,
+        fitViewOptions: { maxZoom: 1 },
+        minZoom: isMobile ? 0.15 : void 0,
+        onPointerDownCapture: handleTouchPointerDown,
+        onPointerMoveCapture: (event) => {
+          if (event.pointerType === "touch") longPress.move(event.clientX, event.clientY);
+        },
+        onPointerUpCapture: () => longPress.up(),
+        onPointerCancelCapture: () => longPress.cancel(),
+        onClickCapture: (event) => {
+          if (!longPress.consumeClick()) return;
+          event.preventDefault();
+          event.stopPropagation();
+        },
+        proOptions: { hideAttribution: true },
+        children: /* @__PURE__ */ jsx13(Background, { gap: 16, size: 1 })
+      }
+    ),
+    steps.length === 0 && // The canvas stays mounted under the empty state: the first email is
+    // added by right-clicking it or dragging from the trigger.
+    // Lower half only, so the text sits below the centred trigger node.
+    /* @__PURE__ */ jsx13("div", { className: "pointer-events-none absolute inset-x-0 bottom-0 h-1/2", children: /* @__PURE__ */ jsx13(EmptyCanvas, { children: /* @__PURE__ */ jsxs8("div", { className: "flex flex-col gap-1", children: [
+      /* @__PURE__ */ jsx13("span", { className: "font-medium", children: t("emailAutomations.canvas.emptyTitle") }),
+      /* @__PURE__ */ jsx13("span", { className: "text-xs/relaxed", children: t("emailAutomations.canvas.emptyBody") })
+    ] }) }) }),
+    /* @__PURE__ */ jsx13(CanvasToolbar, { onTidy: tidy }),
+    /* @__PURE__ */ jsx13(EmailAutomationCanvasInspector, {}),
+    automationEditorOpen && automation && /* @__PURE__ */ jsx13(
+      TriggerAutomationEditor,
+      {
+        automation,
+        onSaved: reload,
+        onClose: () => setAutomationEditorOpen(false)
+      }
+    ),
+    /* @__PURE__ */ jsx13(
+      ConfirmDialog,
+      {
+        open: pendingDeleteStepId !== null,
+        onOpenChange: (open) => {
+          if (!open) setPendingDeleteStepId(null);
+        },
+        title: t("emailAutomations.canvas.deleteEmail"),
+        description: t("emailAutomations.canvas.deleteEmailConfirm"),
+        confirmLabel: t("emailAutomations.canvas.deleteEmail"),
+        cancelLabel: t("ui.buttons.cancel"),
+        destructive: true,
+        onConfirm: handleDeleteStep
+      }
+    ),
+    paneMenu && /* @__PURE__ */ jsx13(
+      ContextMenu,
+      {
+        open: true,
+        onOpenChange: (open) => {
+          if (!open) setPaneMenu(null);
+        },
+        children: /* @__PURE__ */ jsx13(
+          ContextMenuContent,
+          {
+            anchor: pointAnchor(paneMenu.screenX, paneMenu.screenY),
+            side: "bottom",
+            align: "start",
+            sideOffset: 4,
+            children: /* @__PURE__ */ jsxs8(ContextMenuItem, { onClick: handleCreateStepFromPane, children: [
+              /* @__PURE__ */ jsx13(PlusIcon2, {}),
+              t("emailAutomations.canvas.addEmail")
+            ] })
+          }
+        )
+      }
+    ),
+    nodeMenu && /* @__PURE__ */ jsx13(
+      ContextMenu,
+      {
+        open: true,
+        onOpenChange: (open) => {
+          if (!open) setNodeMenu(null);
+        },
+        children: /* @__PURE__ */ jsx13(
+          ContextMenuContent,
+          {
+            anchor: pointAnchor(nodeMenu.screenX, nodeMenu.screenY),
+            side: "bottom",
+            align: "start",
+            sideOffset: 4,
+            children: /* @__PURE__ */ jsxs8(
+              ContextMenuItem,
+              {
+                onClick: () => {
+                  const menu = nodeMenu;
+                  setNodeMenu(null);
+                  if (menu) setPendingDeleteStepId(menu.stepId);
+                },
+                children: [
+                  /* @__PURE__ */ jsx13(Trash2Icon, {}),
+                  t("emailAutomations.canvas.deleteEmail")
+                ]
+              }
+            )
+          }
+        )
+      }
+    )
+  ] });
+}
+__name(EmailAutomationCanvas, "EmailAutomationCanvas");
+function TriggerAutomationEditor(props) {
+  const onDialogOpenChange = useUserClosedGuard(props.onClose);
+  return /* @__PURE__ */ jsx13(
+    EmailAutomationEditor,
+    {
+      automation: props.automation,
+      forceShow: true,
+      dialogOpen: true,
+      onDialogOpenChange,
+      onSuccess: async () => {
+        await props.onSaved();
+        props.onClose();
+      }
+    }
+  );
+}
+__name(TriggerAutomationEditor, "TriggerAutomationEditor");
+
+// src/features/email-automation/components/canvas/EmailAutomationCanvasTab.tsx
+import { jsx as jsx14 } from "react/jsx-runtime";
+function EmailAutomationCanvasTab() {
+  const { open, setOpen } = useSidebar();
+  useEffect5(() => {
+    const prev = open;
+    if (prev) setOpen(false);
+    return () => {
+      if (prev) setOpen(true);
+    };
+  }, []);
+  return /* @__PURE__ */ jsx14("main", { className: "flex h-full w-full overflow-hidden", children: /* @__PURE__ */ jsx14("div", { className: "relative h-full min-w-0 flex-1", children: /* @__PURE__ */ jsx14(ReactFlowProvider, { children: /* @__PURE__ */ jsx14(EmailAutomationCanvas, {}) }) }) });
+}
+__name(EmailAutomationCanvasTab, "EmailAutomationCanvasTab");
+
+// src/features/email-automation/components/lists/EmailAutomationRecipientsList.tsx
+import { RefreshCw } from "lucide-react";
+import { useTranslations as useTranslations8 } from "next-intl";
+import { useMemo as useMemo7, useState as useState6 } from "react";
+import { jsx as jsx15, jsxs as jsxs9 } from "react/jsx-runtime";
+function EmailAutomationRecipientsList() {
+  const t = useTranslations8();
+  const { automation } = useEmailAutomation();
+  const [statusFilter, setStatusFilter] = useState6("all");
+  const data = useDataListRetriever({
+    retriever: /* @__PURE__ */ __name((params) => EmailAutomationService.findEnrollments(params), "retriever"),
+    retrieverParams: { automationId: automation?.id },
+    module: Modules.EmailAutomationEnrollment
+  });
+  const handleStatusChange = /* @__PURE__ */ __name((value) => {
+    const status = value ?? "all";
+    setStatusFilter(status);
+    data.addAdditionalParameter("status", status === "all" ? null : status);
+  }, "handleStatusChange");
+  const statusItems = useMemo7(
+    () => ({
+      all: t("emailAutomations.recipients.status.all"),
+      active: t("emailAutomations.recipients.status.active"),
+      completed: t("emailAutomations.recipients.status.completed"),
+      unsubscribed: t("emailAutomations.recipients.status.unsubscribed"),
+      exited: t("emailAutomations.recipients.status.exited"),
+      failed: t("emailAutomations.recipients.status.failed")
+    }),
+    [t]
+  );
+  const filters = /* @__PURE__ */ jsxs9("div", { className: "flex items-center gap-4", children: [
+    /* @__PURE__ */ jsxs9(Select, { items: statusItems, value: statusFilter, onValueChange: handleStatusChange, children: [
+      /* @__PURE__ */ jsx15(SelectTrigger, { className: "w-40", children: /* @__PURE__ */ jsx15(SelectValue, {}) }),
+      /* @__PURE__ */ jsxs9(SelectContent, { children: [
+        /* @__PURE__ */ jsx15(SelectItem, { value: "all", children: t("emailAutomations.recipients.status.all") }),
+        /* @__PURE__ */ jsx15(SelectItem, { value: "active", children: t("emailAutomations.recipients.status.active") }),
+        /* @__PURE__ */ jsx15(SelectItem, { value: "completed", children: t("emailAutomations.recipients.status.completed") }),
+        /* @__PURE__ */ jsx15(SelectItem, { value: "unsubscribed", children: t("emailAutomations.recipients.status.unsubscribed") }),
+        /* @__PURE__ */ jsx15(SelectItem, { value: "exited", children: t("emailAutomations.recipients.status.exited") }),
+        /* @__PURE__ */ jsx15(SelectItem, { value: "failed", children: t("emailAutomations.recipients.status.failed") })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx15(Button, { variant: "outline", size: "icon", onClick: () => void data.refresh(), disabled: !data.isLoaded, children: /* @__PURE__ */ jsx15(RefreshCw, { className: `h-4 w-4 ${!data.isLoaded ? "animate-spin" : ""}` }) })
+  ] });
+  return /* @__PURE__ */ jsx15(
+    ContentListTable,
+    {
+      data,
+      fields: [
+        "email" /* email */,
+        "name" /* name */,
+        "status" /* status */,
+        "currentStep" /* currentStep */,
+        "nextSendAt" /* nextSendAt */,
+        "sentCount" /* sentCount */
+      ],
+      tableGeneratorType: Modules.EmailAutomationEnrollment,
+      filters,
+      allowSearch: false,
+      emptyState: t("emailAutomations.recipients.empty")
+    }
+  );
+}
+__name(EmailAutomationRecipientsList, "EmailAutomationRecipientsList");
+
+// src/features/email-automation/components/containers/EmailAutomationContainer.tsx
+import { jsx as jsx16 } from "react/jsx-runtime";
+function EmailAutomationContainer({ automationId }) {
+  return /* @__PURE__ */ jsx16(EmailAutomationProvider, { automationId, children: /* @__PURE__ */ jsx16(EmailAutomationShell, {}) });
+}
+__name(EmailAutomationContainer, "EmailAutomationContainer");
+function EmailAutomationShell() {
+  const t = useTranslations9();
+  const generateUrl = usePageUrlGenerator();
+  const { automation, reload } = useEmailAutomation();
+  if (!automation) return null;
+  const breadcrumbs = [
+    { name: t("emailAutomations.admin.title"), href: generateUrl({ page: Modules.EmailAutomation }) },
+    { name: automation.name }
+  ];
+  return /* @__PURE__ */ jsx16(
+    SharedProvider,
+    {
+      value: {
+        breadcrumbs,
+        title: {
+          type: t("emailAutomations.admin.title"),
+          element: automation.name,
+          functions: [
+            /* @__PURE__ */ jsx16(EmailAutomationActiveSwitch, {}, "emailAutomationActiveSwitch"),
+            /* @__PURE__ */ jsx16(EmailAutomationEditor, { automation, onSuccess: reload }, "emailAutomationEditor")
+          ]
+        }
+      },
+      children: /* @__PURE__ */ jsx16(
+        RoundPageContainer,
+        {
+          module: Modules.EmailAutomation,
+          id: automation.id,
+          fullWidth: true,
+          forceHeader: true,
+          scroll: "fixed",
+          tabs: [
+            {
+              sectionKey: "canvas",
+              label: t("emailAutomations.tabs.canvas"),
+              content: /* @__PURE__ */ jsx16(EmailAutomationCanvasTab, {}),
+              fillHeight: true
+            },
+            {
+              sectionKey: "recipients",
+              label: t("emailAutomations.tabs.recipients"),
+              content: /* @__PURE__ */ jsx16(EmailAutomationRecipientsList, {})
+            }
+          ]
+        }
+      )
+    }
+  );
+}
+__name(EmailAutomationShell, "EmailAutomationShell");
+
+// src/features/email-automation/components/unsubscribe/EmailUnsubscribe.tsx
+import { CheckCircle, Loader2, XCircle } from "lucide-react";
+import { useTranslations as useTranslations10 } from "next-intl";
+import { useEffect as useEffect6, useState as useState7 } from "react";
+import { Fragment as Fragment4, jsx as jsx17, jsxs as jsxs10 } from "react/jsx-runtime";
+function EmailUnsubscribe({ token, scope }) {
+  const t = useTranslations10();
+  const [state, setState] = useState7("loading");
+  const [stoppedScope, setStoppedScope] = useState7(scope);
+  const [automationName, setAutomationName] = useState7("");
+  const [isStoppingAll, setIsStoppingAll] = useState7(false);
+  useEffect6(() => {
+    async function unsubscribe() {
+      try {
+        const enrollment = await EmailAutomationEnrollmentService.unsubscribe({ token, scope });
+        setAutomationName(enrollment?.automation?.name ?? "");
+        setStoppedScope(scope);
+        setState("success");
+      } catch {
+        setState("error");
+      }
+    }
+    __name(unsubscribe, "unsubscribe");
+    unsubscribe();
+  }, [token, scope]);
+  const stopAll = /* @__PURE__ */ __name(async () => {
+    setIsStoppingAll(true);
+    try {
+      await EmailAutomationEnrollmentService.unsubscribe({ token, scope: "all" });
+      setStoppedScope("all");
+    } catch {
+      setState("error");
+    } finally {
+      setIsStoppingAll(false);
+    }
+  }, "stopAll");
+  if (state === "loading") {
+    return /* @__PURE__ */ jsxs10("div", { className: "flex flex-col items-center justify-center space-y-4 py-16 text-center", children: [
+      /* @__PURE__ */ jsx17(Loader2, { className: "text-primary h-12 w-12 animate-spin" }),
+      /* @__PURE__ */ jsx17("p", { className: "text-muted-foreground text-sm", children: t("emailAutomations.unsubscribe.loading") })
+    ] });
+  }
+  if (state === "error") {
+    return /* @__PURE__ */ jsxs10("div", { className: "flex flex-col items-center justify-center space-y-4 py-16 text-center", children: [
+      /* @__PURE__ */ jsx17("div", { className: "bg-destructive/10 rounded-full p-4", children: /* @__PURE__ */ jsx17(XCircle, { className: "text-destructive h-12 w-12" }) }),
+      /* @__PURE__ */ jsx17(SectionHeader, { level: 2, children: t("emailAutomations.unsubscribe.invalidTitle") }),
+      /* @__PURE__ */ jsx17("p", { className: "text-muted-foreground max-w-md text-sm leading-relaxed", children: t("emailAutomations.unsubscribe.invalidBody") })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs10("div", { className: "flex flex-col items-center justify-center space-y-4 py-16 text-center", children: [
+    /* @__PURE__ */ jsx17("div", { className: "bg-primary/10 rounded-full p-4", children: /* @__PURE__ */ jsx17(CheckCircle, { className: "text-primary h-12 w-12" }) }),
+    /* @__PURE__ */ jsx17(SectionHeader, { level: 2, children: t("emailAutomations.unsubscribe.title") }),
+    stoppedScope === "all" ? /* @__PURE__ */ jsx17("p", { className: "text-muted-foreground max-w-md text-sm leading-relaxed", children: t("emailAutomations.unsubscribe.stoppedAll") }) : /* @__PURE__ */ jsxs10(Fragment4, { children: [
+      /* @__PURE__ */ jsx17("p", { className: "text-muted-foreground max-w-md text-sm leading-relaxed", children: t("emailAutomations.unsubscribe.stoppedAutomation", { name: automationName }) }),
+      /* @__PURE__ */ jsxs10(Button, { variant: "secondary", onClick: stopAll, disabled: isStoppingAll, children: [
+        isStoppingAll && /* @__PURE__ */ jsx17(Loader2, { className: "h-4 w-4 animate-spin" }),
+        t("emailAutomations.unsubscribe.alsoStopAll")
+      ] })
+    ] })
+  ] });
+}
+__name(EmailUnsubscribe, "EmailUnsubscribe");
+
+// src/features/email-automation/hooks/useEmailAutomationTableStructure.tsx
+import { useTranslations as useTranslations11 } from "next-intl";
+import { useMemo as useMemo8 } from "react";
+import { jsx as jsx18 } from "react/jsx-runtime";
+var useEmailAutomationTableStructure = /* @__PURE__ */ __name((params) => {
+  const t = useTranslations11();
+  const generateUrl = usePageUrlGenerator();
+  const triggerLabels = params.context?.triggerLabels ?? {};
+  const tableData = useMemo8(() => {
+    return params.data.map((automation) => {
+      const entry = { jsonApiData: automation };
+      params.fields.forEach((field) => {
+        entry[field] = automation[field];
+      });
+      return entry;
+    });
+  }, [params.data, params.fields]);
+  const numericColumn = /* @__PURE__ */ __name((field, header, read) => ({
+    id: field,
+    accessorKey: field,
+    header,
+    cell: /* @__PURE__ */ __name(({ row }) => {
+      const automation = row.original.jsonApiData;
+      return /* @__PURE__ */ jsx18("span", { className: "block text-xs tabular-nums text-end", children: read(automation) ?? 0 });
+    }, "cell"),
+    enableSorting: false,
+    enableHiding: false
+  }), "numericColumn");
+  const fieldColumnMap = {
+    ["name" /* name */]: () => ({
+      id: "name",
+      accessorKey: "name",
+      header: t("emailAutomations.list.columns.name"),
+      cell: /* @__PURE__ */ __name(({ row }) => {
+        const automation = row.original.jsonApiData;
+        return /* @__PURE__ */ jsx18(Link, { href: generateUrl({ page: Modules.EmailAutomation, id: automation.id }), children: automation.name });
+      }, "cell"),
+      enableSorting: false,
+      enableHiding: false
+    }),
+    ["trigger" /* trigger */]: () => ({
+      id: "trigger",
+      accessorKey: "trigger",
+      header: t("emailAutomations.list.columns.trigger"),
+      cell: /* @__PURE__ */ __name(({ row }) => {
+        const automation = row.original.jsonApiData;
+        if (!automation.trigger) return /* @__PURE__ */ jsx18("span", { className: "text-muted-foreground text-xs", children: "\u2014" });
+        return /* @__PURE__ */ jsx18("span", { className: "text-sm", children: triggerLabels[automation.trigger] ?? automation.trigger });
+      }, "cell"),
+      enableSorting: false,
+      enableHiding: false
+    }),
+    ["status" /* status */]: () => ({
+      id: "status",
+      accessorKey: "status",
+      header: t("emailAutomations.list.columns.status"),
+      cell: /* @__PURE__ */ __name(({ row }) => {
+        const automation = row.original.jsonApiData;
+        return automation.isActive ? /* @__PURE__ */ jsx18(Badge, { variant: "softGreen", children: t("emailAutomations.list.status.on") }) : /* @__PURE__ */ jsx18(Badge, { variant: "softGray", children: t("emailAutomations.list.status.off") });
+      }, "cell"),
+      enableSorting: false,
+      enableHiding: false
+    }),
+    ["steps" /* steps */]: () => numericColumn("steps" /* steps */, t("emailAutomations.list.columns.steps"), (a) => a.stepCount),
+    ["active" /* active */]: () => numericColumn("active" /* active */, t("emailAutomations.list.columns.active"), (a) => a.activeCount),
+    ["completed" /* completed */]: () => numericColumn(
+      "completed" /* completed */,
+      t("emailAutomations.list.columns.completed"),
+      (a) => a.completedCount
+    ),
+    ["unsubscribed" /* unsubscribed */]: () => numericColumn(
+      "unsubscribed" /* unsubscribed */,
+      t("emailAutomations.list.columns.unsubscribed"),
+      (a) => a.unsubscribedCount
+    )
+  };
+  const columns = useMemo8(() => {
+    return params.fields.map((field) => fieldColumnMap[field]?.()).filter((col) => col !== void 0);
+  }, [params.fields, fieldColumnMap, t, generateUrl]);
+  return useMemo8(() => ({ data: tableData, columns }), [tableData, columns]);
+}, "useEmailAutomationTableStructure");
+registerTableGenerator("email-automations", useEmailAutomationTableStructure);
+
+// src/features/email-automation/hooks/useEmailAutomationEnrollmentTableStructure.tsx
+import { useLocale, useTranslations as useTranslations12 } from "next-intl";
+import { useMemo as useMemo9 } from "react";
+import { jsx as jsx19 } from "react/jsx-runtime";
+var STATUS_VARIANTS = {
+  active: "softGreen",
+  completed: "softBlue",
+  unsubscribed: "softGray",
+  exited: "softGray",
+  failed: "softRed"
+};
+var useEmailAutomationEnrollmentTableStructure = /* @__PURE__ */ __name((params) => {
+  const t = useTranslations12();
+  const locale = dateFormatLocale(useLocale());
+  const tableData = useMemo9(() => {
+    return params.data.map((enrollment) => {
+      const entry = { jsonApiData: enrollment };
+      params.fields.forEach((field) => {
+        entry[field] = enrollment[field];
+      });
+      return entry;
+    });
+  }, [params.data, params.fields]);
+  const empty = /* @__PURE__ */ jsx19("span", { className: "text-muted-foreground text-xs", children: "\u2014" });
+  const fieldColumnMap = {
+    ["email" /* email */]: () => ({
+      id: "email",
+      accessorKey: "email",
+      header: t("emailAutomations.recipients.columns.email"),
+      cell: /* @__PURE__ */ __name(({ row }) => {
+        const enrollment = row.original.jsonApiData;
+        return /* @__PURE__ */ jsx19("span", { className: "text-sm", children: enrollment.email });
+      }, "cell"),
+      enableSorting: false,
+      enableHiding: false
+    }),
+    ["name" /* name */]: () => ({
+      id: "name",
+      accessorKey: "name",
+      header: t("emailAutomations.recipients.columns.name"),
+      cell: /* @__PURE__ */ __name(({ row }) => {
+        const enrollment = row.original.jsonApiData;
+        return enrollment.name ? /* @__PURE__ */ jsx19("span", { className: "text-sm", children: enrollment.name }) : empty;
+      }, "cell"),
+      enableSorting: false,
+      enableHiding: false
+    }),
+    ["status" /* status */]: () => ({
+      id: "status",
+      accessorKey: "status",
+      header: t("emailAutomations.recipients.columns.status"),
+      cell: /* @__PURE__ */ __name(({ row }) => {
+        const enrollment = row.original.jsonApiData;
+        return /* @__PURE__ */ jsx19(
+          Badge,
+          {
+            variant: STATUS_VARIANTS[enrollment.status] ?? "softGray",
+            title: enrollment.status === "failed" ? enrollment.lastError : void 0,
+            children: t(`emailAutomations.recipients.status.${enrollment.status}`)
+          }
+        );
+      }, "cell"),
+      enableSorting: false,
+      enableHiding: false
+    }),
+    ["currentStep" /* currentStep */]: () => ({
+      id: "currentStep",
+      accessorKey: "currentStep",
+      header: t("emailAutomations.recipients.columns.currentStep"),
+      cell: /* @__PURE__ */ __name(({ row }) => {
+        const enrollment = row.original.jsonApiData;
+        return enrollment.currentStepSubject ? /* @__PURE__ */ jsx19("span", { className: "text-sm", children: enrollment.currentStepSubject }) : empty;
+      }, "cell"),
+      enableSorting: false,
+      enableHiding: false
+    }),
+    ["nextSendAt" /* nextSendAt */]: () => ({
+      id: "nextSendAt",
+      accessorKey: "nextSendAt",
+      header: t("emailAutomations.recipients.columns.nextSendAt"),
+      cell: /* @__PURE__ */ __name(({ row }) => {
+        const enrollment = row.original.jsonApiData;
+        if (!enrollment.nextSendAt) return empty;
+        return /* @__PURE__ */ jsx19("span", { className: "text-xs tabular-nums", children: formatDate(enrollment.nextSendAt, "dateTime", locale) });
+      }, "cell"),
+      enableSorting: false,
+      enableHiding: false
+    }),
+    ["sentCount" /* sentCount */]: () => ({
+      id: "sentCount",
+      accessorKey: "sentCount",
+      header: t("emailAutomations.recipients.columns.sentCount"),
+      cell: /* @__PURE__ */ __name(({ row }) => {
+        const enrollment = row.original.jsonApiData;
+        return /* @__PURE__ */ jsx19("span", { className: "block text-xs tabular-nums text-end", children: enrollment.sentCount ?? 0 });
+      }, "cell"),
+      enableSorting: false,
+      enableHiding: false
+    })
+  };
+  const columns = useMemo9(() => {
+    return params.fields.map((field) => fieldColumnMap[field]?.()).filter((col) => col !== void 0);
+  }, [params.fields, fieldColumnMap, t, locale]);
+  return useMemo9(() => ({ data: tableData, columns }), [tableData, columns]);
+}, "useEmailAutomationEnrollmentTableStructure");
+registerTableGenerator("email-automation-enrollments", useEmailAutomationEnrollmentTableStructure);
+export {
+  CanvasToolbar,
+  DelayEdge,
+  EmailAutomationActiveSwitch,
+  EmailAutomationCanvas,
+  EmailAutomationCanvasInspector,
+  EmailAutomationCanvasTab,
+  EmailAutomationContainer,
+  EmailAutomationEditor,
+  EmailAutomationProvider,
+  EmailAutomationRecipientsList,
+  EmailAutomationsList,
+  EmailAutomationsListContainer,
+  EmailStepEditor,
+  EmailStepNode,
+  EmailUnsubscribe,
+  EmptyCanvas,
+  LONG_PRESS_MOVE_TOLERANCE_PX,
+  LONG_PRESS_MS,
+  STEP_NODE_HEIGHT,
+  STEP_NODE_PREFIX,
+  STEP_NODE_WIDTH,
+  STEP_SOURCE_HANDLE_PREFIX,
+  STEP_TARGET_HANDLE_PREFIX,
+  TRIGGER_NODE_HEIGHT,
+  TRIGGER_NODE_ID,
+  TRIGGER_NODE_WIDTH,
+  TRIGGER_SOURCE_HANDLE,
+  TriggerNode,
+  autoLayout,
+  buildCanvasGraph,
+  createLongPressTracker,
+  findHeadStepId,
+  useEmailAutomation,
+  useEmailAutomationEnrollmentTableStructure,
+  useEmailAutomationTableStructure,
+  useUserClosedGuard
+};
+//# sourceMappingURL=index.mjs.map