strapi-plugin-magic-mail 3.0.4 → 4.0.0

package/dist/admin/analyticsLogs-BCY0Zv3Y.mjs

@@ -0,0 +1,685 @@
+import { useRBAC, Page } from "@strapi/strapi/admin";
+import { p as pluginPermissions, g as getTranslation } from "./index-qvFJ-a0Q.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useCallback, forwardRef, useRef, useLayoutEffect, useState, useEffect } from "react";
+import { Button, Tooltip, Dialog, Flex, Typography } from "@strapi/design-system";
+import { ExclamationTriangleIcon } from "@heroicons/react/24/outline";
+import styled, { css } from "styled-components";
+import { useBlocker } from "react-router-dom";
+import { useIntl } from "react-intl";
+const ROUTE_CAPABILITIES = [
+  ...pluginPermissions.read,
+  ...pluginPermissions.manage,
+  ...pluginPermissions.testSend
+];
+const useMagicMailRBAC = () => {
+  const { allowedActions = {}, isLoading = false, error } = useRBAC(ROUTE_CAPABILITIES) ?? {};
+  const settled = !isLoading && !error;
+  const allowed = (key) => settled && allowedActions?.[key] === true;
+  const canRead = allowed("canRead");
+  const canManage = allowed("canManage");
+  return {
+    canRead,
+    canManage,
+    canTestSend: allowed("canTestSend"),
+    isReadOnly: canRead && !canManage,
+    isLoading: Boolean(isLoading),
+    error,
+    permissions: pluginPermissions
+  };
+};
+const useMagicMailIntl = () => {
+  const intl = useIntl();
+  const t = useCallback(
+    (key, defaultMessage, values) => intl.formatMessage({ id: getTranslation(key), defaultMessage }, values),
+    [intl]
+  );
+  return { t, formatMessage: intl.formatMessage, locale: intl.locale };
+};
+const LIGHT_FALLBACK_COLORS = Object.freeze({
+  alternative100: "#f6ecfc",
+  alternative200: "#e0c1f4",
+  alternative500: "#ac73e6",
+  alternative600: "#9736e8",
+  alternative700: "#8312d1",
+  neutral0: "#ffffff",
+  neutral100: "#f6f6f9",
+  neutral150: "#eaeaef",
+  neutral200: "#dcdce4",
+  neutral300: "#c0c0cf",
+  neutral400: "#a5a5ba",
+  neutral500: "#8e8ea9",
+  neutral600: "#666687",
+  neutral700: "#4a4a6a",
+  neutral800: "#32324d",
+  neutral900: "#212134",
+  neutral1000: "#181826",
+  primary100: "#f0f0ff",
+  primary200: "#d9d8ff",
+  primary500: "#7b79ff",
+  primary600: "#4945ff",
+  primary700: "#271fe0",
+  secondary100: "#eaf5ff",
+  secondary200: "#b8e1ff",
+  secondary500: "#66b7f1",
+  secondary600: "#0c75af",
+  secondary700: "#006096",
+  success100: "#eafbe7",
+  success200: "#c6f0c2",
+  success500: "#5cb176",
+  success600: "#328048",
+  success700: "#2f6846",
+  warning100: "#fdf4dc",
+  warning200: "#fae7b9",
+  warning500: "#f29d41",
+  warning600: "#d9822f",
+  warning700: "#be5d01",
+  danger100: "#fcecea",
+  danger200: "#f5c0b8",
+  danger500: "#ee5e52",
+  danger600: "#d02b20",
+  danger700: "#b72b1a"
+});
+const FONT_SIZE_FALLBACK = Object.freeze([
+  "1.1rem",
+  // 0 -> 11px
+  "1.2rem",
+  // 1 -> 12px
+  "1.4rem",
+  // 2 -> 14px
+  "1.6rem",
+  // 3 -> 16px
+  "1.8rem",
+  // 4 -> 18px
+  "2rem",
+  //   5 -> 20px
+  "2.8rem",
+  // 6 -> 28px
+  "3.2rem"
+  // 7 -> 32px
+]);
+const color = (token) => (props) => props?.theme?.colors?.[token] ?? LIGHT_FALLBACK_COLORS[token];
+const fontSize = (step) => (props) => props?.theme?.fontSizes?.[step] ?? FONT_SIZE_FALLBACK[step];
+const isDarkTheme = (themeObject) => themeObject?.colorScheme === "dark";
+const byScheme = (light, dark) => (props) => isDarkTheme(props?.theme) ? dark : light;
+const brand = Object.freeze({
+  primary: "#0369A1",
+  primaryHover: "#075985",
+  secondary: "#9333EA",
+  secondaryHover: "#7E22CE",
+  success: "#15803D",
+  successHover: "#166534",
+  warning: "#B45309",
+  warningHover: "#92400E",
+  danger: "#DC2626",
+  dangerHover: "#B91C1C",
+  gradient: "linear-gradient(135deg, #0369A1 0%, #9333EA 100%)",
+  gradientHover: "linear-gradient(135deg, #075985 0%, #7E22CE 100%)"
+});
+const ACCENT_VALUES = Object.freeze({
+  primary: ["#0369A1", "#7DD3FC"],
+  secondary: ["#7E22CE", "#D8B4FE"],
+  success: ["#15803D", "#86EFAC"],
+  warning: ["#B45309", "#FCD34D"],
+  danger: ["#B91C1C", "#FCA5A5"]
+});
+const accent = Object.freeze(
+  Object.fromEntries(
+    Object.entries(ACCENT_VALUES).map(([name, [light, dark]]) => [name, byScheme(light, dark)])
+  )
+);
+const theme = {
+  shadows: {
+    sm: "0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px -1px rgba(0, 0, 0, 0.1)",
+    md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
+    lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1)",
+    xl: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1)"
+  },
+  transitions: {
+    fast: "150ms cubic-bezier(0.4, 0, 0.2, 1)",
+    normal: "300ms cubic-bezier(0.4, 0, 0.2, 1)",
+    slow: "500ms cubic-bezier(0.4, 0, 0.2, 1)"
+  },
+  spacing: {
+    xs: "4px",
+    sm: "8px",
+    md: "16px",
+    lg: "24px",
+    xl: "32px",
+    "2xl": "48px"
+  },
+  borderRadius: {
+    md: "8px",
+    lg: "12px",
+    xl: "16px"
+  }
+};
+const reducedMotion = css`
+  @media (prefers-reduced-motion: reduce) {
+    animation: none !important;
+    transition: none !important;
+
+    &::before,
+    &::after {
+      animation: none !important;
+      transition: none !important;
+    }
+
+    &:hover,
+    &:active,
+    &:focus-visible {
+      transform: none !important;
+    }
+  }
+`;
+const motionSafe = (block) => css`
+  @media (prefers-reduced-motion: no-preference) {
+    ${block}
+  }
+`;
+const CONTROL_HEIGHT = "36px";
+const CTA_HEIGHT = "52px";
+const disabledState = css`
+  &:disabled,
+  &[aria-disabled='true'] {
+    opacity: 0.6;
+    cursor: not-allowed;
+  }
+`;
+const textButtonBase = css`
+  font-weight: 600;
+  padding: 8px 16px;
+  min-height: ${CONTROL_HEIGHT};
+  transition: all 0.2s ease;
+  ${disabledState}
+  ${reducedMotion}
+`;
+const GradientButton = styled(Button)`
+  && {
+    ${textButtonBase}
+    background: ${brand.gradient};
+    color: #ffffff;
+    border: none;
+
+    &:hover:not(:disabled) {
+      background: ${brand.gradientHover};
+      transform: translateY(-1px);
+      box-shadow: 0 4px 12px rgba(3, 105, 161, 0.3);
+    }
+
+    &:active:not(:disabled) {
+      transform: translateY(0);
+    }
+  }
+`;
+const SecondaryButton = styled(Button)`
+  && {
+    ${textButtonBase}
+    background: ${color("neutral0")};
+    color: ${accent.secondary};
+    border: 2px solid transparent;
+    background-image:
+      linear-gradient(${color("neutral0")}, ${color("neutral0")}), ${brand.gradient};
+    background-origin: border-box;
+    background-clip: padding-box, border-box;
+
+    &:hover:not(:disabled) {
+      background: ${brand.gradient};
+      background-clip: padding-box;
+      color: #ffffff;
+      transform: translateY(-1px);
+      box-shadow: 0 4px 12px rgba(147, 51, 234, 0.3);
+    }
+
+    &:active:not(:disabled) {
+      transform: translateY(0);
+    }
+  }
+`;
+const TertiaryButton = styled(Button)`
+  && {
+    ${textButtonBase}
+    font-weight: 500;
+    background: transparent;
+    color: ${color("neutral700")};
+    border: 1px solid ${color("neutral200")};
+
+    &:hover:not(:disabled) {
+      background: ${color("neutral100")};
+      border-color: ${color("neutral300")};
+      color: ${color("neutral800")};
+    }
+  }
+`;
+const DangerButton = styled(Button)`
+  && {
+    ${textButtonBase}
+    background: rgba(220, 38, 38, 0.12);
+    color: ${accent.danger};
+    border: 1px solid rgba(220, 38, 38, 0.3);
+
+    &:hover:not(:disabled) {
+      background: ${brand.danger};
+      color: #ffffff;
+      border-color: ${brand.danger};
+    }
+  }
+`;
+const iconButtonBase = css`
+  padding: 8px;
+  min-width: ${CONTROL_HEIGHT};
+  min-height: ${CONTROL_HEIGHT};
+  width: ${CONTROL_HEIGHT};
+  height: ${CONTROL_HEIGHT};
+  border-radius: 10px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: all 0.2s ease;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.04);
+
+  svg {
+    width: 18px;
+    height: 18px;
+  }
+
+  &:hover:not(:disabled) {
+    color: #ffffff;
+    transform: translateY(-1px);
+  }
+
+  ${disabledState}
+  ${reducedMotion}
+`;
+const createIconButton = ({ tint, fg, hover, hoverBorder }) => {
+  const StyledIconButton = styled(Button)`
+    && {
+      ${iconButtonBase}
+      background: linear-gradient(135deg, rgba(${tint}, 0.06) 0%, rgba(${tint}, 0.14) 100%);
+      color: ${fg};
+      border: 1px solid rgba(${tint}, 0.32);
+
+      &:hover:not(:disabled) {
+        background: ${hover};
+        border-color: ${hoverBorder};
+        box-shadow: 0 4px 12px rgba(${tint}, 0.3);
+      }
+    }
+  `;
+  const IconOnlyButton = forwardRef(({ title, ...props }, ref) => {
+    const label = props["aria-label"] ?? title;
+    const button = /* @__PURE__ */ jsx(StyledIconButton, { ref, "aria-label": label, ...props });
+    return label ? /* @__PURE__ */ jsx(Tooltip, { label, children: button }) : button;
+  });
+  return IconOnlyButton;
+};
+const IconButton = createIconButton({
+  tint: "128, 128, 128",
+  fg: color("neutral600"),
+  hover: `linear-gradient(135deg, ${brand.primary} 0%, ${brand.primaryHover} 100%)`,
+  hoverBorder: brand.primary
+});
+IconButton.displayName = "IconButton";
+const IconButtonDanger = createIconButton({
+  tint: "220, 38, 38",
+  fg: accent.danger,
+  hover: `linear-gradient(135deg, ${brand.danger} 0%, ${brand.dangerHover} 100%)`,
+  hoverBorder: brand.danger
+});
+IconButtonDanger.displayName = "IconButtonDanger";
+const IconButtonPrimary = createIconButton({
+  tint: "3, 105, 161",
+  fg: accent.primary,
+  hover: `linear-gradient(135deg, ${brand.primary} 0%, ${brand.primaryHover} 100%)`,
+  hoverBorder: brand.primary
+});
+IconButtonPrimary.displayName = "IconButtonPrimary";
+const IconButtonSuccess = createIconButton({
+  tint: "21, 128, 61",
+  fg: accent.success,
+  hover: `linear-gradient(135deg, ${brand.success} 0%, ${brand.successHover} 100%)`,
+  hoverBorder: brand.success
+});
+IconButtonSuccess.displayName = "IconButtonSuccess";
+const IconButtonWarning = createIconButton({
+  tint: "180, 83, 9",
+  fg: accent.warning,
+  hover: `linear-gradient(135deg, ${brand.warning} 0%, ${brand.warningHover} 100%)`,
+  hoverBorder: brand.warning
+});
+IconButtonWarning.displayName = "IconButtonWarning";
+const IconButtonPurple = createIconButton({
+  tint: "147, 51, 234",
+  fg: accent.secondary,
+  hover: `linear-gradient(135deg, ${brand.secondary} 0%, ${brand.secondaryHover} 100%)`,
+  hoverBorder: brand.secondary
+});
+IconButtonPurple.displayName = "IconButtonPurple";
+const CTAButton = styled(Button)`
+  && {
+    background: ${brand.gradient};
+    color: #ffffff;
+    font-weight: 700;
+    font-size: ${fontSize(3)};
+    border: none;
+    padding: 14px 28px;
+    min-height: ${CTA_HEIGHT};
+    border-radius: 12px;
+    transition: all 0.2s ease;
+    box-shadow: 0 4px 14px rgba(3, 105, 161, 0.25);
+
+    &:hover:not(:disabled) {
+      background: ${brand.gradientHover};
+      transform: translateY(-2px);
+      box-shadow: 0 6px 20px rgba(3, 105, 161, 0.35);
+    }
+
+    &:active:not(:disabled) {
+      transform: translateY(0);
+    }
+
+    ${disabledState}
+    ${reducedMotion}
+  }
+`;
+const useReturnFocus = (isOpen, getFallback) => {
+  const openerRef = useRef(null);
+  const fallbackRef = useRef(getFallback);
+  useLayoutEffect(() => {
+    fallbackRef.current = getFallback;
+  }, [getFallback]);
+  useLayoutEffect(() => {
+    if (!isOpen) return void 0;
+    const active = document.activeElement;
+    const opener = active && active !== document.body ? active : null;
+    openerRef.current = opener;
+    return () => {
+      window.setTimeout(() => {
+        const current = document.activeElement;
+        if (current && current !== document.body) return;
+        const target = opener?.isConnected ? opener : fallbackRef.current?.();
+        target?.focus?.();
+      }, 0);
+    };
+  }, [isOpen]);
+  return useCallback((event) => {
+    const opener = openerRef.current;
+    openerRef.current = null;
+    const target = opener?.isConnected ? opener : fallbackRef.current?.();
+    if (!target || typeof target.focus !== "function") return;
+    event.preventDefault();
+    target.focus();
+  }, []);
+};
+const WarningIcon = styled(ExclamationTriangleIcon)`
+  width: 24px;
+  height: 24px;
+  color: ${(p) => p.$danger ? accent.danger(p) : accent.warning(p)};
+`;
+const ConfirmDialog = ({
+  isOpen,
+  onClose,
+  onConfirm,
+  title,
+  description,
+  children,
+  confirmLabel,
+  cancelLabel,
+  variant = "danger",
+  isLoading = false,
+  confirmIcon,
+  getReturnFocusFallback
+}) => {
+  const { t } = useMagicMailIntl();
+  const [isPending, setIsPending] = useState(false);
+  const mounted = useRef(true);
+  const returnFocus = useReturnFocus(Boolean(isOpen), getReturnFocusFallback);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const busy = isLoading || isPending;
+  const danger = variant === "danger";
+  const ConfirmButton = danger ? DangerButton : GradientButton;
+  const handleConfirm = async () => {
+    if (busy) return;
+    const result = onConfirm?.();
+    if (result && typeof result.then === "function") {
+      setIsPending(true);
+      try {
+        await result;
+      } catch {
+      } finally {
+        if (mounted.current) setIsPending(false);
+      }
+    }
+  };
+  const handleOpenChange = (open) => {
+    if (!open && !busy) onClose?.();
+  };
+  return /* @__PURE__ */ jsx(Dialog.Root, { open: Boolean(isOpen), onOpenChange: handleOpenChange, children: /* @__PURE__ */ jsxs(Dialog.Content, { onCloseAutoFocus: returnFocus, children: [
+    /* @__PURE__ */ jsx(Dialog.Header, { textAlign: "center", children: title }),
+    /* @__PURE__ */ jsx(Dialog.Body, { icon: /* @__PURE__ */ jsx(WarningIcon, { "aria-hidden": "true", $danger: danger }), children: /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 2, width: "100%", alignItems: "stretch", children: [
+      description ? /* @__PURE__ */ jsx(Dialog.Description, { textAlign: "center", children: description }) : null,
+      typeof children === "string" ? /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral600", textAlign: "center", children }) : children
+    ] }) }),
+    /* @__PURE__ */ jsxs(Dialog.Footer, { children: [
+      /* @__PURE__ */ jsx(Dialog.Cancel, { children: /* @__PURE__ */ jsx(TertiaryButton, { fullWidth: true, disabled: busy, children: cancelLabel ?? t("common.cancel", "Cancel") }) }),
+      /* @__PURE__ */ jsx(
+        ConfirmButton,
+        {
+          fullWidth: true,
+          onClick: handleConfirm,
+          loading: busy,
+          startIcon: busy ? void 0 : confirmIcon,
+          children: confirmLabel ?? (danger ? t("common.delete", "Delete") : t("common.confirm", "Confirm"))
+        }
+      )
+    ] })
+  ] }) });
+};
+const UnsavedChangesDialog = ({ guard, title, description, confirmLabel }) => {
+  const { t } = useMagicMailIntl();
+  return /* @__PURE__ */ jsx(
+    ConfirmDialog,
+    {
+      isOpen: guard.isOpen,
+      onClose: guard.cancel,
+      onConfirm: guard.confirm,
+      title: title ?? t("common.unsaved.title", "Discard unsaved changes?"),
+      description: description ?? t(
+        "common.unsaved.description",
+        "You have unsaved changes. If you continue, they will be lost."
+      ),
+      confirmLabel: confirmLabel ?? t("common.unsaved.confirm", "Discard changes"),
+      cancelLabel: t("common.unsaved.cancel", "Keep editing")
+    }
+  );
+};
+const shouldBlockNavigation = (isDirty, transition = {}) => {
+  if (!isDirty) return false;
+  const { currentLocation, nextLocation } = transition;
+  if (!nextLocation) return false;
+  return currentLocation?.pathname !== nextLocation.pathname || (currentLocation?.search ?? "") !== (nextLocation.search ?? "");
+};
+const attachBeforeUnload = (active, win = typeof window === "undefined" ? void 0 : window) => {
+  if (!active || typeof win?.addEventListener !== "function") return () => {
+  };
+  const handler = (event) => {
+    event.preventDefault();
+    event.returnValue = "";
+    return "";
+  };
+  win.addEventListener("beforeunload", handler);
+  return () => win.removeEventListener("beforeunload", handler);
+};
+const useDiscardState = (isDirty) => {
+  const dirtyRef = useRef(Boolean(isDirty));
+  useLayoutEffect(() => {
+    dirtyRef.current = Boolean(isDirty);
+  }, [isDirty]);
+  const [pendingAction, setPendingAction] = useState(null);
+  const runGuarded = useCallback((action) => {
+    if (typeof action !== "function") return;
+    if (dirtyRef.current) {
+      setPendingAction(() => action);
+    } else {
+      action();
+    }
+  }, []);
+  return { dirtyRef, pendingAction, setPendingAction, runGuarded };
+};
+const useDiscardGuard = (isDirty) => {
+  const { pendingAction, setPendingAction, runGuarded } = useDiscardState(isDirty);
+  const confirm = useCallback(() => {
+    const action = pendingAction;
+    setPendingAction(null);
+    if (action) action();
+  }, [pendingAction, setPendingAction]);
+  const cancel = useCallback(() => setPendingAction(null), [setPendingAction]);
+  return { isDirty: Boolean(isDirty), isOpen: pendingAction !== null, confirm, cancel, runGuarded };
+};
+const useUnsavedChangesGuard = (isDirty) => {
+  const { dirtyRef, pendingAction, setPendingAction, runGuarded } = useDiscardState(isDirty);
+  const bypassRef = useRef(false);
+  const blocker = useBlocker(
+    useCallback(
+      (transition) => !bypassRef.current && shouldBlockNavigation(dirtyRef.current, transition),
+      [dirtyRef]
+    )
+  );
+  useEffect(() => attachBeforeUnload(Boolean(isDirty)), [isDirty]);
+  useEffect(() => {
+    if (blocker.state === "blocked" && !isDirty) blocker.proceed();
+  }, [blocker, isDirty]);
+  const confirm = useCallback(() => {
+    if (blocker.state === "blocked") blocker.proceed();
+    const action = pendingAction;
+    setPendingAction(null);
+    if (action) action();
+  }, [blocker, pendingAction, setPendingAction]);
+  const cancel = useCallback(() => {
+    if (blocker.state === "blocked") blocker.reset();
+    setPendingAction(null);
+  }, [blocker, setPendingAction]);
+  const bypass = useCallback((action) => {
+    bypassRef.current = true;
+    try {
+      return action();
+    } finally {
+      bypassRef.current = false;
+    }
+  }, []);
+  return {
+    isDirty: Boolean(isDirty),
+    isOpen: blocker.state === "blocked" || pendingAction !== null,
+    confirm,
+    cancel,
+    runGuarded,
+    bypass
+  };
+};
+const MAX_EMAIL_LENGTH = 254;
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function isValidEmailAddress(value) {
+  return typeof value === "string" && value.length <= MAX_EMAIL_LENGTH && value === value.trim() && EMAIL_PATTERN.test(value);
+}
+function isOptionalEmailAddressValid(value) {
+  return typeof value === "string" && (value.trim() === "" || isValidEmailAddress(value));
+}
+const PluginPageTitle = ({ children }) => {
+  const { t } = useMagicMailIntl();
+  return /* @__PURE__ */ jsx(Page.Title, { children: t("common.pageTitle", "{page} | MagicMail", { page: children }) });
+};
+const SectionHeading = styled(Typography).attrs((props) => ({
+  tag: props.tag ?? "h2",
+  variant: props.variant ?? "delta",
+  textColor: props.textColor ?? "neutral700"
+}))`
+  && {
+    font-size: 1.5rem;
+    font-weight: 600;
+  }
+`;
+styled(Typography).attrs((props) => ({
+  tag: props.tag ?? "h3",
+  variant: props.variant ?? "delta",
+  textColor: props.textColor ?? "neutral800"
+}))``;
+const LOGS_PAGE_SIZE = 25;
+const MAX_SEARCH_LENGTH = 500;
+const MAX_CLEAR_ROUNDS = 100;
+const normalizeSearch = (value) => typeof value === "string" ? value.trim().slice(0, MAX_SEARCH_LENGTH) : "";
+const buildEmailLogsUrl = ({ page = 1, pageSize = LOGS_PAGE_SIZE, search = "" } = {}) => {
+  const params = new URLSearchParams();
+  const safePage = Number.isInteger(page) && page > 0 ? page : 1;
+  const safeSize = Number.isInteger(pageSize) && pageSize > 0 ? Math.min(pageSize, 100) : LOGS_PAGE_SIZE;
+  params.set("page", String(safePage));
+  params.set("pageSize", String(safeSize));
+  const term = normalizeSearch(search);
+  if (term) params.set("search", term);
+  return `/magic-mail/analytics/emails?${params.toString()}`;
+};
+const clampPage = (page, pageCount) => {
+  const max = Number.isInteger(pageCount) && pageCount > 0 ? pageCount : 1;
+  if (!Number.isInteger(page) || page < 1) return 1;
+  return Math.min(page, max);
+};
+const clearAllEmailLogsInBatches = async (del, { maxRounds = MAX_CLEAR_ROUNDS } = {}) => {
+  let deletedCount = 0;
+  for (let round = 0; round < maxRounds; round += 1) {
+    const response = await del("/magic-mail/analytics/emails");
+    const data = response?.data ?? {};
+    const deleted = Number.isFinite(Number(data.deletedCount)) ? Number(data.deletedCount) : 0;
+    deletedCount += deleted;
+    if (data.hasMore !== true) return { deletedCount, complete: true };
+    if (deleted <= 0) return { deletedCount, complete: false };
+  }
+  return { deletedCount, complete: false };
+};
+const apiErrorMessage = (error) => {
+  const message = error?.response?.data?.error?.message ?? error?.response?.data?.message;
+  return typeof message === "string" && message.trim() ? message.trim() : null;
+};
+export {
+  clampPage as A,
+  apiErrorMessage as B,
+  ConfirmDialog as C,
+  DangerButton as D,
+  clearAllEmailLogsInBatches as E,
+  GradientButton as G,
+  IconButton as I,
+  LOGS_PAGE_SIZE as L,
+  PluginPageTitle as P,
+  SectionHeading as S,
+  TertiaryButton as T,
+  UnsavedChangesDialog as U,
+  isValidEmailAddress as a,
+  byScheme as b,
+  color as c,
+  useReturnFocus as d,
+  useDiscardGuard as e,
+  fontSize as f,
+  brand as g,
+  accent as h,
+  isOptionalEmailAddressValid as i,
+  useMagicMailRBAC as j,
+  CTAButton as k,
+  IconButtonPrimary as l,
+  motionSafe as m,
+  IconButtonDanger as n,
+  CTA_HEIGHT as o,
+  SecondaryButton as p,
+  IconButtonPurple as q,
+  reducedMotion as r,
+  IconButtonSuccess as s,
+  theme as t,
+  useMagicMailIntl as u,
+  CONTROL_HEIGHT as v,
+  useUnsavedChangesGuard as w,
+  isDarkTheme as x,
+  normalizeSearch as y,
+  buildEmailLogsUrl as z
+};