@volchoklv/newsletter-kit 1.0.0

package/dist/index.js

@@ -0,0 +1,1762 @@
+"use client";
+
+// src/utils/crypto.ts
+import { randomBytes } from "crypto";
+function generateToken(length = 32) {
+  return randomBytes(length).toString("hex");
+}
+function generateUrlSafeToken(length = 32) {
+  return randomBytes(length).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+// src/utils/validation.ts
+function isValidEmail(email) {
+  if (!email || typeof email !== "string") return false;
+  const trimmed = email.trim();
+  if (trimmed.length === 0 || trimmed.length > 254) return false;
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(trimmed)) return false;
+  const [localPart, domain] = trimmed.split("@");
+  if (!localPart || localPart.length > 64) return false;
+  if (localPart.startsWith(".") || localPart.endsWith(".")) return false;
+  if (localPart.includes("..")) return false;
+  if (!domain || domain.length > 253) return false;
+  if (domain.startsWith(".") || domain.endsWith(".")) return false;
+  if (domain.startsWith("-") || domain.endsWith("-")) return false;
+  if (!domain.includes(".")) return false;
+  const tld = domain.split(".").pop();
+  if (!tld || tld.length < 2) return false;
+  return true;
+}
+function normalizeEmail(email, options = {}) {
+  let normalized = email.toLowerCase().trim();
+  if (options.normalizeGmail) {
+    const [localPart, domain] = normalized.split("@");
+    if (domain === "gmail.com" || domain === "googlemail.com") {
+      const cleanLocal = localPart.split("+")[0].replace(/\./g, "");
+      normalized = `${cleanLocal}@gmail.com`;
+    }
+  }
+  return normalized;
+}
+var DISPOSABLE_DOMAINS = /* @__PURE__ */ new Set([
+  "tempmail.com",
+  "throwaway.email",
+  "guerrillamail.com",
+  "sharklasers.com",
+  "mailinator.com",
+  "yopmail.com",
+  "10minutemail.com",
+  "temp-mail.org",
+  "fakeinbox.com",
+  "trashmail.com",
+  "getnada.com",
+  "maildrop.cc",
+  "dispostable.com",
+  "tempail.com",
+  "mohmal.com"
+]);
+function isDisposableEmail(email) {
+  const domain = email.toLowerCase().split("@")[1];
+  return DISPOSABLE_DOMAINS.has(domain);
+}
+function sanitizeString(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+}
+
+// src/utils/rate-limit.ts
+function createRateLimiter(config) {
+  const { max, windowSeconds, identifier } = config;
+  const store = /* @__PURE__ */ new Map();
+  setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of store.entries()) {
+      if (entry.resetAt < now) {
+        store.delete(key);
+      }
+    }
+  }, windowSeconds * 1e3);
+  return {
+    /**
+     * Check if request should be rate limited
+     * Returns true if request is allowed, false if rate limited
+     */
+    async check(req) {
+      const id = identifier ? identifier(req) : getClientIP(req);
+      const now = Date.now();
+      const windowMs = windowSeconds * 1e3;
+      let entry = store.get(id);
+      if (!entry || entry.resetAt < now) {
+        entry = {
+          count: 0,
+          resetAt: now + windowMs
+        };
+      }
+      entry.count++;
+      store.set(id, entry);
+      const allowed = entry.count <= max;
+      const remaining = Math.max(0, max - entry.count);
+      return {
+        allowed,
+        remaining,
+        resetAt: new Date(entry.resetAt)
+      };
+    },
+    /**
+     * Get current limit status without incrementing
+     */
+    async status(req) {
+      const id = identifier ? identifier(req) : getClientIP(req);
+      const entry = store.get(id);
+      if (!entry || entry.resetAt < Date.now()) {
+        return { remaining: max, resetAt: null };
+      }
+      return {
+        remaining: Math.max(0, max - entry.count),
+        resetAt: new Date(entry.resetAt)
+      };
+    },
+    /**
+     * Reset rate limit for an identifier
+     */
+    async reset(req) {
+      const id = identifier ? identifier(req) : getClientIP(req);
+      store.delete(id);
+    }
+  };
+}
+function getClientIP(req) {
+  const headers = req.headers;
+  const cfConnectingIP = headers.get("cf-connecting-ip");
+  if (cfConnectingIP) return cfConnectingIP;
+  const xForwardedFor = headers.get("x-forwarded-for");
+  if (xForwardedFor) {
+    return xForwardedFor.split(",")[0].trim();
+  }
+  const xRealIP = headers.get("x-real-ip");
+  if (xRealIP) return xRealIP;
+  const xVercelForwardedFor = headers.get("x-vercel-forwarded-for");
+  if (xVercelForwardedFor) return xVercelForwardedFor.split(",")[0].trim();
+  return "unknown";
+}
+function createRateLimitHeaders(limit, remaining, resetAt) {
+  const headers = new Headers();
+  headers.set("X-RateLimit-Limit", limit.toString());
+  headers.set("X-RateLimit-Remaining", remaining.toString());
+  headers.set("X-RateLimit-Reset", Math.floor(resetAt.getTime() / 1e3).toString());
+  return headers;
+}
+var defaultRateLimitConfig = {
+  max: 5,
+  windowSeconds: 60
+  // 5 requests per minute
+};
+
+// src/adapters/storage/memory.ts
+function createMemoryAdapter() {
+  const subscribers = /* @__PURE__ */ new Map();
+  const tokenIndex = /* @__PURE__ */ new Map();
+  return {
+    async createSubscriber(input, token) {
+      const email = input.email.toLowerCase();
+      const confirmToken = token || generateToken();
+      const now = /* @__PURE__ */ new Date();
+      const existing = subscribers.get(email);
+      if (existing?.id) {
+        for (const [t, e] of tokenIndex.entries()) {
+          if (e === email) {
+            tokenIndex.delete(t);
+            break;
+          }
+        }
+      }
+      const subscriber = {
+        id: existing?.id || crypto.randomUUID(),
+        email,
+        status: "pending",
+        source: input.source,
+        tags: input.tags || [],
+        metadata: input.metadata,
+        consentIp: input.ip,
+        consentAt: now,
+        confirmedAt: void 0,
+        unsubscribedAt: void 0,
+        createdAt: existing?.createdAt || now,
+        updatedAt: now
+      };
+      subscribers.set(email, subscriber);
+      tokenIndex.set(confirmToken, email);
+      return { ...subscriber, id: confirmToken };
+    },
+    async getSubscriberByEmail(email) {
+      return subscribers.get(email.toLowerCase()) || null;
+    },
+    async getSubscriberByToken(token) {
+      const email = tokenIndex.get(token);
+      if (!email) return null;
+      return subscribers.get(email) || null;
+    },
+    async confirmSubscriber(token) {
+      const email = tokenIndex.get(token);
+      if (!email) return null;
+      const subscriber = subscribers.get(email);
+      if (!subscriber) return null;
+      const updated = {
+        ...subscriber,
+        status: "confirmed",
+        confirmedAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      subscribers.set(email, updated);
+      tokenIndex.delete(token);
+      return updated;
+    },
+    async unsubscribe(email) {
+      const subscriber = subscribers.get(email.toLowerCase());
+      if (!subscriber) return false;
+      const updated = {
+        ...subscriber,
+        status: "unsubscribed",
+        unsubscribedAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      subscribers.set(email.toLowerCase(), updated);
+      return true;
+    },
+    async listSubscribers(options) {
+      let results = Array.from(subscribers.values());
+      if (options?.status) {
+        results = results.filter((s) => s.status === options.status);
+      }
+      if (options?.source) {
+        results = results.filter((s) => s.source === options.source);
+      }
+      if (options?.tags?.length) {
+        results = results.filter(
+          (s) => options.tags.some((tag) => s.tags?.includes(tag))
+        );
+      }
+      results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+      const total = results.length;
+      const offset = options?.offset || 0;
+      const limit = options?.limit || 100;
+      return {
+        subscribers: results.slice(offset, offset + limit),
+        total
+      };
+    },
+    async deleteSubscriber(email) {
+      const normalizedEmail = email.toLowerCase();
+      const existed = subscribers.has(normalizedEmail);
+      subscribers.delete(normalizedEmail);
+      for (const [token, e] of tokenIndex.entries()) {
+        if (e === normalizedEmail) {
+          tokenIndex.delete(token);
+          break;
+        }
+      }
+      return existed;
+    },
+    async updateSubscriber(email, data) {
+      const normalizedEmail = email.toLowerCase();
+      const subscriber = subscribers.get(normalizedEmail);
+      if (!subscriber) return null;
+      const updated = {
+        ...subscriber,
+        ...data.source !== void 0 && { source: data.source },
+        ...data.tags !== void 0 && { tags: data.tags },
+        ...data.metadata !== void 0 && { metadata: data.metadata },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      subscribers.set(normalizedEmail, updated);
+      return updated;
+    }
+  };
+}
+function createNoopAdapter() {
+  return {
+    async createSubscriber(input) {
+      return {
+        id: "noop",
+        email: input.email,
+        status: "pending",
+        source: input.source,
+        tags: input.tags,
+        metadata: input.metadata,
+        consentIp: input.ip,
+        consentAt: /* @__PURE__ */ new Date(),
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    },
+    async getSubscriberByEmail() {
+      return null;
+    },
+    async getSubscriberByToken() {
+      return null;
+    },
+    async confirmSubscriber() {
+      return null;
+    },
+    async unsubscribe() {
+      return true;
+    }
+  };
+}
+
+// src/server/handlers.ts
+function createNewsletterHandlers(config) {
+  const {
+    emailAdapter,
+    storageAdapter = createMemoryAdapter(),
+    doubleOptIn = true,
+    baseUrl,
+    confirmPath = "/api/newsletter/confirm",
+    unsubscribePath = "/api/newsletter/unsubscribe",
+    honeypotField = "website",
+    rateLimit = defaultRateLimitConfig,
+    validateEmail: customValidateEmail,
+    allowedSources,
+    defaultTags = [],
+    onSubscribe,
+    onConfirm,
+    onUnsubscribe,
+    onError
+  } = config;
+  const rateLimiter = rateLimit ? createRateLimiter(rateLimit) : null;
+  function jsonResponse(data, status = 200, headers) {
+    const responseHeaders = new Headers(headers);
+    responseHeaders.set("Content-Type", "application/json");
+    return new Response(JSON.stringify(data), {
+      status,
+      headers: responseHeaders
+    });
+  }
+  async function handleSubscribe(req) {
+    const body = await req.json();
+    const { email, source, tags = [], metadata } = body;
+    if (honeypotField && body[honeypotField]) {
+      return {
+        success: true,
+        message: doubleOptIn ? "Please check your email to confirm your subscription." : "You have been subscribed!"
+      };
+    }
+    if (!email || !isValidEmail(email)) {
+      return {
+        success: false,
+        message: "Please enter a valid email address."
+      };
+    }
+    if (customValidateEmail) {
+      const isValid = await customValidateEmail(email);
+      if (!isValid) {
+        return {
+          success: false,
+          message: "This email address is not allowed."
+        };
+      }
+    }
+    if (source && allowedSources && !allowedSources.includes(source)) {
+      return {
+        success: false,
+        message: "Invalid subscription source."
+      };
+    }
+    const normalizedEmail = normalizeEmail(email);
+    const ip = getClientIP(req);
+    try {
+      const existing = await storageAdapter.getSubscriberByEmail(normalizedEmail);
+      if (existing?.status === "confirmed") {
+        return {
+          success: true,
+          message: "You are already subscribed!",
+          subscriber: existing
+        };
+      }
+      const token = generateToken();
+      const subscriber = await storageAdapter.createSubscriber(
+        {
+          email: normalizedEmail,
+          source,
+          tags: [...defaultTags, ...tags],
+          metadata,
+          ip
+        },
+        token
+      );
+      if (doubleOptIn) {
+        const confirmUrl = `${baseUrl}${confirmPath}?token=${token}`;
+        await emailAdapter.sendConfirmation(normalizedEmail, token, confirmUrl);
+        if (emailAdapter.notifyAdmin) {
+          await emailAdapter.notifyAdmin(subscriber);
+        }
+        if (onSubscribe) {
+          await onSubscribe(subscriber);
+        }
+        return {
+          success: true,
+          message: "Please check your email to confirm your subscription.",
+          subscriber,
+          requiresConfirmation: true
+        };
+      } else {
+        const confirmed = await storageAdapter.confirmSubscriber(token);
+        await emailAdapter.sendWelcome(normalizedEmail);
+        if (emailAdapter.notifyAdmin && confirmed) {
+          await emailAdapter.notifyAdmin(confirmed);
+        }
+        if (onSubscribe && confirmed) {
+          await onSubscribe(confirmed);
+        }
+        return {
+          success: true,
+          message: "You have been subscribed!",
+          subscriber: confirmed || subscriber,
+          requiresConfirmation: false
+        };
+      }
+    } catch (error) {
+      if (onError) {
+        await onError(error, "subscribe");
+      }
+      console.error("[newsletter-kit] Subscribe error:", error);
+      return {
+        success: false,
+        message: "Something went wrong. Please try again."
+      };
+    }
+  }
+  async function handleConfirm(token) {
+    if (!token) {
+      return {
+        success: false,
+        message: "Invalid confirmation link."
+      };
+    }
+    try {
+      const subscriber = await storageAdapter.confirmSubscriber(token);
+      if (!subscriber) {
+        return {
+          success: false,
+          message: "This confirmation link is invalid or has expired."
+        };
+      }
+      await emailAdapter.sendWelcome(subscriber.email);
+      if (onConfirm) {
+        await onConfirm(subscriber);
+      }
+      return {
+        success: true,
+        message: "Your subscription has been confirmed!",
+        subscriber
+      };
+    } catch (error) {
+      if (onError) {
+        await onError(error, "confirm");
+      }
+      console.error("[newsletter-kit] Confirm error:", error);
+      return {
+        success: false,
+        message: "Something went wrong. Please try again."
+      };
+    }
+  }
+  async function handleUnsubscribe(email) {
+    if (!email || !isValidEmail(email)) {
+      return {
+        success: false,
+        message: "Invalid email address."
+      };
+    }
+    const normalizedEmail = normalizeEmail(email);
+    try {
+      const success = await storageAdapter.unsubscribe(normalizedEmail);
+      if (!success) {
+        return {
+          success: false,
+          message: "Email not found in our list."
+        };
+      }
+      if (emailAdapter.sendUnsubscribed) {
+        const resubscribeUrl = `${baseUrl}`;
+        await emailAdapter.sendUnsubscribed(normalizedEmail, resubscribeUrl);
+      }
+      if (onUnsubscribe) {
+        await onUnsubscribe(normalizedEmail);
+      }
+      return {
+        success: true,
+        message: "You have been unsubscribed."
+      };
+    } catch (error) {
+      if (onError) {
+        await onError(error, "unsubscribe");
+      }
+      console.error("[newsletter-kit] Unsubscribe error:", error);
+      return {
+        success: false,
+        message: "Something went wrong. Please try again."
+      };
+    }
+  }
+  return {
+    /**
+     * POST /api/newsletter/subscribe
+     */
+    subscribe: async (req) => {
+      if (rateLimiter) {
+        const { allowed, remaining, resetAt } = await rateLimiter.check(req);
+        const headers = createRateLimitHeaders(rateLimit.max, remaining, resetAt);
+        if (!allowed) {
+          return jsonResponse(
+            {
+              success: false,
+              message: "Too many requests. Please try again later."
+            },
+            429,
+            headers
+          );
+        }
+      }
+      const result = await handleSubscribe(req);
+      return jsonResponse(result, result.success ? 200 : 400);
+    },
+    /**
+     * GET /api/newsletter/confirm?token=xxx
+     * 
+     * Can also return a redirect for better UX
+     */
+    confirm: async (req) => {
+      const url = new URL(req.url);
+      const token = url.searchParams.get("token");
+      const result = await handleConfirm(token || "");
+      const acceptsJson = req.headers.get("accept")?.includes("application/json");
+      if (acceptsJson) {
+        return jsonResponse(result, result.success ? 200 : 400);
+      }
+      const redirectUrl = new URL(baseUrl);
+      redirectUrl.searchParams.set("confirmed", result.success ? "true" : "false");
+      if (!result.success) {
+        redirectUrl.searchParams.set("error", result.message);
+      }
+      return Response.redirect(redirectUrl.toString(), 302);
+    },
+    /**
+     * POST /api/newsletter/unsubscribe
+     * Also supports GET with email query param
+     */
+    unsubscribe: async (req) => {
+      let email;
+      if (req.method === "GET") {
+        const url = new URL(req.url);
+        email = url.searchParams.get("email") || "";
+      } else {
+        const body = await req.json();
+        email = body.email;
+      }
+      const result = await handleUnsubscribe(email);
+      return jsonResponse(result, result.success ? 200 : 400);
+    },
+    /**
+     * Internal handlers for custom implementations
+     */
+    handlers: {
+      subscribe: handleSubscribe,
+      confirm: handleConfirm,
+      unsubscribe: handleUnsubscribe
+    },
+    /**
+     * Access to storage adapter for admin features
+     */
+    storage: storageAdapter,
+    /**
+     * Get subscriber by email (for admin/API use)
+     */
+    getSubscriber: async (email) => {
+      return storageAdapter.getSubscriberByEmail(normalizeEmail(email));
+    },
+    /**
+     * List subscribers (for admin/export use)
+     */
+    listSubscribers: storageAdapter.listSubscribers
+  };
+}
+
+// src/components/newsletter-form.tsx
+import { useState, useCallback } from "react";
+
+// src/utils/cn.ts
+function cn(...inputs) {
+  return inputs.filter(Boolean).join(" ");
+}
+
+// src/components/newsletter-form.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function NewsletterForm({
+  endpoint = "/api/newsletter/subscribe",
+  source,
+  tags,
+  honeypotField = "website",
+  className,
+  formClassName,
+  inputClassName,
+  buttonClassName,
+  messageClassName,
+  placeholder = "Enter your email",
+  buttonText = "Subscribe",
+  loadingText = "Subscribing...",
+  successMessage,
+  errorMessage,
+  showMessage = true,
+  onSuccess,
+  onError,
+  onSubmit,
+  disabled = false,
+  metadata
+}) {
+  const [state, setState] = useState({
+    status: "idle",
+    message: "",
+    email: ""
+  });
+  const handleSubmit = useCallback(
+    async (e) => {
+      e.preventDefault();
+      const formData = new FormData(e.currentTarget);
+      const email = formData.get("email");
+      const honeypot = formData.get(honeypotField);
+      if (honeypot) {
+        setState({
+          status: "success",
+          message: successMessage || "Thanks for subscribing!",
+          email: ""
+        });
+        return;
+      }
+      if (!email || !email.includes("@")) {
+        setState({
+          status: "error",
+          message: "Please enter a valid email address.",
+          email
+        });
+        onError?.("Please enter a valid email address.");
+        return;
+      }
+      setState({ status: "loading", message: "", email });
+      onSubmit?.(email);
+      try {
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            email,
+            source,
+            tags,
+            metadata
+          })
+        });
+        const data = await response.json();
+        if (response.ok && data.success) {
+          const message = successMessage || data.message || "Thanks for subscribing!";
+          setState({
+            status: "success",
+            message,
+            email: ""
+          });
+          onSuccess?.(email, message);
+        } else {
+          const message = errorMessage || data.message || "Something went wrong. Please try again.";
+          setState({
+            status: "error",
+            message,
+            email
+          });
+          onError?.(message);
+        }
+      } catch (error) {
+        const message = errorMessage || "Network error. Please try again.";
+        setState({
+          status: "error",
+          message,
+          email
+        });
+        onError?.(message);
+      }
+    },
+    [endpoint, source, tags, metadata, honeypotField, successMessage, errorMessage, onSuccess, onError, onSubmit]
+  );
+  const isLoading = state.status === "loading";
+  const isDisabled = disabled || isLoading;
+  return /* @__PURE__ */ jsxs("div", { className: cn("w-full", className), children: [
+    /* @__PURE__ */ jsxs(
+      "form",
+      {
+        onSubmit: handleSubmit,
+        className: cn("flex flex-col sm:flex-row gap-2", formClassName),
+        children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "text",
+              name: honeypotField,
+              autoComplete: "off",
+              tabIndex: -1,
+              "aria-hidden": "true",
+              className: "absolute -left-[9999px] opacity-0 pointer-events-none"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "email",
+              name: "email",
+              placeholder,
+              required: true,
+              disabled: isDisabled,
+              defaultValue: state.email,
+              "aria-label": "Email address",
+              "aria-describedby": state.message ? "newsletter-message" : void 0,
+              className: cn(
+                "flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm",
+                "ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium",
+                "placeholder:text-muted-foreground",
+                "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+                "disabled:cursor-not-allowed disabled:opacity-50",
+                inputClassName
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "submit",
+              disabled: isDisabled,
+              className: cn(
+                "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium",
+                "ring-offset-background transition-colors",
+                "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+                "disabled:pointer-events-none disabled:opacity-50",
+                "bg-primary text-primary-foreground hover:bg-primary/90",
+                "h-10 px-4 py-2",
+                "min-w-[120px]",
+                buttonClassName
+              ),
+              children: isLoading ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsxs(
+                  "svg",
+                  {
+                    className: "mr-2 h-4 w-4 animate-spin",
+                    xmlns: "http://www.w3.org/2000/svg",
+                    fill: "none",
+                    viewBox: "0 0 24 24",
+                    children: [
+                      /* @__PURE__ */ jsx(
+                        "circle",
+                        {
+                          className: "opacity-25",
+                          cx: "12",
+                          cy: "12",
+                          r: "10",
+                          stroke: "currentColor",
+                          strokeWidth: "4"
+                        }
+                      ),
+                      /* @__PURE__ */ jsx(
+                        "path",
+                        {
+                          className: "opacity-75",
+                          fill: "currentColor",
+                          d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+                        }
+                      )
+                    ]
+                  }
+                ),
+                loadingText
+              ] }) : buttonText
+            }
+          )
+        ]
+      }
+    ),
+    showMessage && state.message && /* @__PURE__ */ jsx(
+      "p",
+      {
+        id: "newsletter-message",
+        role: state.status === "error" ? "alert" : "status",
+        className: cn(
+          "mt-2 text-sm",
+          state.status === "success" && "text-green-600 dark:text-green-400",
+          state.status === "error" && "text-red-600 dark:text-red-400",
+          messageClassName
+        ),
+        children: state.message
+      }
+    )
+  ] });
+}
+
+// src/components/newsletter-blocks.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function NewsletterBlock({
+  title = "Subscribe to our newsletter",
+  description = "Get the latest updates delivered directly to your inbox.",
+  containerClassName,
+  titleClassName,
+  descriptionClassName,
+  ...formProps
+}) {
+  return /* @__PURE__ */ jsx2(
+    "section",
+    {
+      className: cn(
+        "w-full py-12 md:py-16 lg:py-20",
+        "bg-muted/50",
+        containerClassName
+      ),
+      children: /* @__PURE__ */ jsx2("div", { className: "container mx-auto px-4 md:px-6", children: /* @__PURE__ */ jsxs2("div", { className: "flex flex-col items-center justify-center space-y-4 text-center", children: [
+        /* @__PURE__ */ jsxs2("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx2(
+            "h2",
+            {
+              className: cn(
+                "text-2xl font-bold tracking-tight sm:text-3xl md:text-4xl",
+                titleClassName
+              ),
+              children: title
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            "p",
+            {
+              className: cn(
+                "max-w-[600px] text-muted-foreground md:text-lg",
+                descriptionClassName
+              ),
+              children: description
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx2("div", { className: "w-full max-w-md", children: /* @__PURE__ */ jsx2(NewsletterForm, { ...formProps }) })
+      ] }) })
+    }
+  );
+}
+function NewsletterCard({
+  title = "Newsletter",
+  description = "Subscribe to get updates.",
+  cardClassName,
+  titleClassName,
+  descriptionClassName,
+  ...formProps
+}) {
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      className: cn(
+        "rounded-lg border bg-card text-card-foreground shadow-sm",
+        "p-6",
+        cardClassName
+      ),
+      children: /* @__PURE__ */ jsxs2("div", { className: "space-y-4", children: [
+        /* @__PURE__ */ jsxs2("div", { className: "space-y-1.5", children: [
+          /* @__PURE__ */ jsx2(
+            "h3",
+            {
+              className: cn(
+                "text-lg font-semibold leading-none tracking-tight",
+                titleClassName
+              ),
+              children: title
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            "p",
+            {
+              className: cn(
+                "text-sm text-muted-foreground",
+                descriptionClassName
+              ),
+              children: description
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx2(NewsletterForm, { ...formProps })
+      ] })
+    }
+  );
+}
+function NewsletterInline({
+  label,
+  labelClassName,
+  ...formProps
+}) {
+  return /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-2", children: [
+    label && /* @__PURE__ */ jsx2(
+      "label",
+      {
+        className: cn(
+          "text-sm font-medium leading-none",
+          labelClassName
+        ),
+        children: label
+      }
+    ),
+    /* @__PURE__ */ jsx2(NewsletterForm, { ...formProps })
+  ] });
+}
+function NewsletterModalContent({
+  title = "Subscribe to our newsletter",
+  description = "We'll send you the best content, no spam.",
+  titleClassName,
+  descriptionClassName,
+  ...formProps
+}) {
+  return /* @__PURE__ */ jsxs2("div", { className: "space-y-4", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "space-y-2 text-center", children: [
+      /* @__PURE__ */ jsx2(
+        "h2",
+        {
+          className: cn(
+            "text-lg font-semibold leading-none tracking-tight",
+            titleClassName
+          ),
+          children: title
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        "p",
+        {
+          className: cn(
+            "text-sm text-muted-foreground",
+            descriptionClassName
+          ),
+          children: description
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx2(
+      NewsletterForm,
+      {
+        ...formProps,
+        formClassName: "flex-col",
+        buttonClassName: "w-full"
+      }
+    )
+  ] });
+}
+function NewsletterFooter({
+  title = "Newsletter",
+  description,
+  containerClassName,
+  titleClassName,
+  descriptionClassName,
+  privacyText,
+  privacyLink,
+  ...formProps
+}) {
+  return /* @__PURE__ */ jsxs2("div", { className: cn("space-y-4", containerClassName), children: [
+    title && /* @__PURE__ */ jsx2(
+      "h3",
+      {
+        className: cn(
+          "text-sm font-semibold uppercase tracking-wider",
+          titleClassName
+        ),
+        children: title
+      }
+    ),
+    description && /* @__PURE__ */ jsx2(
+      "p",
+      {
+        className: cn(
+          "text-sm text-muted-foreground",
+          descriptionClassName
+        ),
+        children: description
+      }
+    ),
+    /* @__PURE__ */ jsx2(NewsletterForm, { ...formProps }),
+    privacyText && /* @__PURE__ */ jsx2("p", { className: "text-xs text-muted-foreground", children: privacyLink ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      privacyText.replace(/\.$/, ""),
+      ".",
+      " ",
+      /* @__PURE__ */ jsx2("a", { href: privacyLink, className: "underline hover:text-foreground", children: "Privacy Policy" })
+    ] }) : privacyText })
+  ] });
+}
+
+// src/hooks/use-newsletter.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+function useNewsletter(options = {}) {
+  const {
+    endpoint = "/api/newsletter/subscribe",
+    source,
+    tags,
+    metadata,
+    onSuccess,
+    onError
+  } = options;
+  const [state, setState] = useState2({
+    status: "idle",
+    message: "",
+    email: null
+  });
+  const subscribe = useCallback2(
+    async (email) => {
+      if (!email || !email.includes("@")) {
+        const errorMsg = "Please enter a valid email address.";
+        setState({
+          status: "error",
+          message: errorMsg,
+          email
+        });
+        onError?.(errorMsg);
+        return false;
+      }
+      setState({ status: "loading", message: "", email });
+      try {
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            email,
+            source,
+            tags,
+            metadata
+          })
+        });
+        const data = await response.json();
+        if (response.ok && data.success) {
+          const message = data.message || "Thanks for subscribing!";
+          setState({
+            status: "success",
+            message,
+            email
+          });
+          onSuccess?.(email, message);
+          return true;
+        } else {
+          const message = data.message || "Something went wrong. Please try again.";
+          setState({
+            status: "error",
+            message,
+            email
+          });
+          onError?.(message);
+          return false;
+        }
+      } catch (error) {
+        const message = "Network error. Please try again.";
+        setState({
+          status: "error",
+          message,
+          email
+        });
+        onError?.(message);
+        return false;
+      }
+    },
+    [endpoint, source, tags, metadata, onSuccess, onError]
+  );
+  const reset = useCallback2(() => {
+    setState({
+      status: "idle",
+      message: "",
+      email: null
+    });
+  }, []);
+  return {
+    ...state,
+    subscribe,
+    reset,
+    isLoading: state.status === "loading",
+    isSuccess: state.status === "success",
+    isError: state.status === "error"
+  };
+}
+
+// src/adapters/email/resend.ts
+function createResendAdapter(config) {
+  const { apiKey, from, replyTo, templates, adminEmail } = config;
+  async function sendEmail(params) {
+    const { Resend } = await import("resend");
+    const resend = new Resend(apiKey);
+    await resend.emails.send({
+      from,
+      replyTo,
+      to: params.to,
+      subject: params.subject,
+      html: params.html,
+      text: params.text
+    });
+  }
+  const defaultTemplates = {
+    confirmation: {
+      subject: "Confirm your subscription",
+      text: void 0,
+      html: ({ confirmUrl, email }) => `
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          </head>
+          <body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; max-width: 600px; margin: 0 auto; padding: 20px;">
+            <h1 style="color: #111; font-size: 24px; margin-bottom: 20px;">Confirm your subscription</h1>
+            <p>Thanks for subscribing! Please confirm your email address by clicking the button below:</p>
+            <a href="${confirmUrl}" style="display: inline-block; background-color: #000; color: #fff; padding: 12px 24px; text-decoration: none; border-radius: 6px; margin: 20px 0;">
+              Confirm Subscription
+            </a>
+            <p style="color: #666; font-size: 14px; margin-top: 30px;">
+              If you didn't subscribe to this newsletter, you can safely ignore this email.
+            </p>
+            <p style="color: #999; font-size: 12px; margin-top: 20px;">
+              This confirmation was requested for ${email}
+            </p>
+          </body>
+        </html>
+      `
+    },
+    welcome: {
+      subject: "Welcome to our newsletter!",
+      text: void 0,
+      html: ({ email }) => `
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          </head>
+          <body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; max-width: 600px; margin: 0 auto; padding: 20px;">
+            <h1 style="color: #111; font-size: 24px; margin-bottom: 20px;">You're subscribed! \u{1F389}</h1>
+            <p>Thanks for confirming your subscription. You'll now receive our updates at <strong>${email}</strong>.</p>
+            <p>We're excited to have you!</p>
+          </body>
+        </html>
+      `
+    },
+    unsubscribed: {
+      subject: "You have been unsubscribed",
+      text: void 0,
+      html: ({ email, resubscribeUrl }) => `
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          </head>
+          <body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; max-width: 600px; margin: 0 auto; padding: 20px;">
+            <h1 style="color: #111; font-size: 24px; margin-bottom: 20px;">Unsubscribed</h1>
+            <p>You have been unsubscribed from our newsletter. We're sorry to see you go!</p>
+            ${resubscribeUrl ? `<p><a href="${resubscribeUrl}">Changed your mind? Resubscribe here.</a></p>` : ""}
+            <p style="color: #999; font-size: 12px; margin-top: 20px;">
+              This email was sent to ${email}
+            </p>
+          </body>
+        </html>
+      `
+    }
+  };
+  return {
+    async sendConfirmation(email, token, confirmUrl) {
+      const template = templates?.confirmation ?? defaultTemplates.confirmation;
+      const subject = template.subject ?? defaultTemplates.confirmation.subject;
+      const html = template.html ?? defaultTemplates.confirmation.html;
+      await sendEmail({
+        to: email,
+        subject,
+        html: html({ confirmUrl, email }),
+        text: template.text?.({ confirmUrl, email })
+      });
+    },
+    async sendWelcome(email) {
+      const template = templates?.welcome ?? defaultTemplates.welcome;
+      const subject = template.subject ?? defaultTemplates.welcome.subject;
+      const html = template.html ?? defaultTemplates.welcome.html;
+      await sendEmail({
+        to: email,
+        subject,
+        html: html({ email }),
+        text: template.text?.({ email })
+      });
+    },
+    async sendUnsubscribed(email, resubscribeUrl) {
+      const template = templates?.unsubscribed ?? defaultTemplates.unsubscribed;
+      const subject = template.subject ?? defaultTemplates.unsubscribed.subject;
+      const html = template.html ?? defaultTemplates.unsubscribed.html;
+      await sendEmail({
+        to: email,
+        subject,
+        html: html({ email, resubscribeUrl }),
+        text: template.text?.({ email, resubscribeUrl })
+      });
+    },
+    async notifyAdmin(subscriber) {
+      if (!adminEmail) return;
+      await sendEmail({
+        to: adminEmail,
+        subject: `New newsletter subscriber: ${subscriber.email}`,
+        html: `
+          <!DOCTYPE html>
+          <html>
+            <body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; padding: 20px;">
+              <h2>New Newsletter Subscriber</h2>
+              <p><strong>Email:</strong> ${subscriber.email}</p>
+              <p><strong>Status:</strong> ${subscriber.status}</p>
+              ${subscriber.source ? `<p><strong>Source:</strong> ${subscriber.source}</p>` : ""}
+              ${subscriber.tags?.length ? `<p><strong>Tags:</strong> ${subscriber.tags.join(", ")}</p>` : ""}
+              <p><strong>Subscribed at:</strong> ${subscriber.createdAt.toISOString()}</p>
+            </body>
+          </html>
+        `
+      });
+    }
+  };
+}
+
+// src/adapters/email/nodemailer.ts
+function createNodemailerAdapter(config) {
+  const { smtp, from, replyTo, templates, adminEmail } = config;
+  async function sendEmail(params) {
+    const nodemailer = await import("nodemailer");
+    const transporter = nodemailer.createTransport(smtp);
+    await transporter.sendMail({
+      from,
+      replyTo,
+      to: params.to,
+      subject: params.subject,
+      html: params.html,
+      text: params.text
+    });
+  }
+  const defaultTemplates = {
+    confirmation: {
+      subject: "Confirm your subscription",
+      text: void 0,
+      html: ({ confirmUrl, email }) => `
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          </head>
+          <body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; max-width: 600px; margin: 0 auto; padding: 20px;">
+            <h1 style="color: #111; font-size: 24px; margin-bottom: 20px;">Confirm your subscription</h1>
+            <p>Thanks for subscribing! Please confirm your email address by clicking the button below:</p>
+            <a href="${confirmUrl}" style="display: inline-block; background-color: #000; color: #fff; padding: 12px 24px; text-decoration: none; border-radius: 6px; margin: 20px 0;">
+              Confirm Subscription
+            </a>
+            <p style="color: #666; font-size: 14px; margin-top: 30px;">
+              If you didn't subscribe to this newsletter, you can safely ignore this email.
+            </p>
+            <p style="color: #999; font-size: 12px; margin-top: 20px;">
+              This confirmation was requested for ${email}
+            </p>
+          </body>
+        </html>
+      `
+    },
+    welcome: {
+      subject: "Welcome to our newsletter!",
+      text: void 0,
+      html: ({ email }) => `
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          </head>
+          <body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; max-width: 600px; margin: 0 auto; padding: 20px;">
+            <h1 style="color: #111; font-size: 24px; margin-bottom: 20px;">You're subscribed! \u{1F389}</h1>
+            <p>Thanks for confirming your subscription. You'll now receive our updates at <strong>${email}</strong>.</p>
+            <p>We're excited to have you!</p>
+          </body>
+        </html>
+      `
+    },
+    unsubscribed: {
+      subject: "You have been unsubscribed",
+      text: void 0,
+      html: ({ email, resubscribeUrl }) => `
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          </head>
+          <body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; max-width: 600px; margin: 0 auto; padding: 20px;">
+            <h1 style="color: #111; font-size: 24px; margin-bottom: 20px;">Unsubscribed</h1>
+            <p>You have been unsubscribed from our newsletter. We're sorry to see you go!</p>
+            ${resubscribeUrl ? `<p><a href="${resubscribeUrl}">Changed your mind? Resubscribe here.</a></p>` : ""}
+            <p style="color: #999; font-size: 12px; margin-top: 20px;">
+              This email was sent to ${email}
+            </p>
+          </body>
+        </html>
+      `
+    }
+  };
+  return {
+    async sendConfirmation(email, token, confirmUrl) {
+      const template = templates?.confirmation ?? defaultTemplates.confirmation;
+      const subject = template.subject ?? defaultTemplates.confirmation.subject;
+      const html = template.html ?? defaultTemplates.confirmation.html;
+      await sendEmail({
+        to: email,
+        subject,
+        html: html({ confirmUrl, email }),
+        text: template.text?.({ confirmUrl, email })
+      });
+    },
+    async sendWelcome(email) {
+      const template = templates?.welcome ?? defaultTemplates.welcome;
+      const subject = template.subject ?? defaultTemplates.welcome.subject;
+      const html = template.html ?? defaultTemplates.welcome.html;
+      await sendEmail({
+        to: email,
+        subject,
+        html: html({ email }),
+        text: template.text?.({ email })
+      });
+    },
+    async sendUnsubscribed(email, resubscribeUrl) {
+      const template = templates?.unsubscribed ?? defaultTemplates.unsubscribed;
+      const subject = template.subject ?? defaultTemplates.unsubscribed.subject;
+      const html = template.html ?? defaultTemplates.unsubscribed.html;
+      await sendEmail({
+        to: email,
+        subject,
+        html: html({ email, resubscribeUrl }),
+        text: template.text?.({ email, resubscribeUrl })
+      });
+    },
+    async notifyAdmin(subscriber) {
+      if (!adminEmail) return;
+      await sendEmail({
+        to: adminEmail,
+        subject: `New newsletter subscriber: ${subscriber.email}`,
+        html: `
+          <!DOCTYPE html>
+          <html>
+            <body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; padding: 20px;">
+              <h2>New Newsletter Subscriber</h2>
+              <p><strong>Email:</strong> ${subscriber.email}</p>
+              <p><strong>Status:</strong> ${subscriber.status}</p>
+              ${subscriber.source ? `<p><strong>Source:</strong> ${subscriber.source}</p>` : ""}
+              ${subscriber.tags?.length ? `<p><strong>Tags:</strong> ${subscriber.tags.join(", ")}</p>` : ""}
+              <p><strong>Subscribed at:</strong> ${subscriber.createdAt.toISOString()}</p>
+            </body>
+          </html>
+        `
+      });
+    }
+  };
+}
+
+// src/adapters/email/mailchimp.ts
+function createMailchimpAdapter(config) {
+  const { apiKey, server, listId, from, adminEmail, useAsStorage } = config;
+  async function getClient() {
+    const mailchimp = await import("@mailchimp/mailchimp_marketing");
+    mailchimp.default.setConfig({
+      apiKey,
+      server
+    });
+    return mailchimp.default;
+  }
+  async function addOrUpdateMember(email, status) {
+    const client = await getClient();
+    const subscriberHash = await hashEmail(email);
+    try {
+      await client.lists.setListMember(listId, subscriberHash, {
+        email_address: email,
+        status_if_new: status
+      });
+    } catch (error) {
+      await client.lists.addListMember(listId, {
+        email_address: email,
+        status
+      });
+    }
+  }
+  async function hashEmail(email) {
+    const crypto2 = await import("crypto");
+    return crypto2.createHash("md5").update(email.toLowerCase()).digest("hex");
+  }
+  return {
+    async sendConfirmation(email, _token, _confirmUrl) {
+      if (useAsStorage) {
+        await addOrUpdateMember(email, "pending");
+      }
+    },
+    async sendWelcome(email) {
+      if (useAsStorage) {
+        await addOrUpdateMember(email, "subscribed");
+      }
+    },
+    async sendUnsubscribed(email) {
+      if (useAsStorage) {
+        const client = await getClient();
+        const subscriberHash = await hashEmail(email);
+        await client.lists.updateListMember(listId, subscriberHash, {
+          status: "unsubscribed"
+        });
+      }
+    },
+    async notifyAdmin(subscriber) {
+      if (!adminEmail) return;
+      console.warn(
+        `[newsletter-kit] Mailchimp adapter: Admin notification not implemented. Consider setting up a Mailchimp webhook or automation. New subscriber: ${subscriber.email}`
+      );
+    }
+  };
+}
+function createMailchimpStorageAdapter(config) {
+  const { apiKey, server, listId } = config;
+  async function getClient() {
+    const mailchimp = await import("@mailchimp/mailchimp_marketing");
+    mailchimp.default.setConfig({
+      apiKey,
+      server
+    });
+    return mailchimp.default;
+  }
+  async function hashEmail(email) {
+    const crypto2 = await import("crypto");
+    return crypto2.createHash("md5").update(email.toLowerCase()).digest("hex");
+  }
+  return {
+    async createSubscriber(input) {
+      const client = await getClient();
+      await client.lists.addListMember(listId, {
+        email_address: input.email,
+        status: "pending",
+        // Mailchimp handles double opt-in
+        tags: input.tags,
+        merge_fields: {
+          SOURCE: input.source || ""
+        }
+      });
+      return {
+        id: await hashEmail(input.email),
+        email: input.email,
+        status: "pending",
+        source: input.source,
+        tags: input.tags,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    },
+    async getSubscriberByEmail(email) {
+      const client = await getClient();
+      const hash = await hashEmail(email);
+      try {
+        const member = await client.lists.getListMember(listId, hash);
+        return {
+          id: hash,
+          email: member.email_address,
+          status: member.status === "subscribed" ? "confirmed" : member.status,
+          tags: member.tags?.map((t) => t.name),
+          createdAt: new Date(member.timestamp_signup || member.timestamp_opt || Date.now()),
+          updatedAt: new Date(member.last_changed || Date.now())
+        };
+      } catch {
+        return null;
+      }
+    },
+    // Note: Mailchimp doesn't use tokens - it has its own confirmation system
+    async getSubscriberByToken() {
+      console.warn("[newsletter-kit] Mailchimp uses its own confirmation system");
+      return null;
+    },
+    async confirmSubscriber(_token) {
+      console.warn("[newsletter-kit] Mailchimp handles confirmation automatically");
+      return null;
+    },
+    async unsubscribe(email) {
+      const client = await getClient();
+      const hash = await hashEmail(email);
+      await client.lists.updateListMember(listId, hash, {
+        status: "unsubscribed"
+      });
+      return true;
+    }
+  };
+}
+
+// src/adapters/storage/prisma.ts
+function mapToSubscriber(record) {
+  return {
+    id: record.id,
+    email: record.email,
+    status: record.status,
+    source: record.source,
+    tags: record.tags,
+    metadata: record.metadata,
+    consentIp: record.consentIp,
+    consentAt: record.consentAt ? new Date(record.consentAt) : void 0,
+    confirmedAt: record.confirmedAt ? new Date(record.confirmedAt) : void 0,
+    unsubscribedAt: record.unsubscribedAt ? new Date(record.unsubscribedAt) : void 0,
+    createdAt: new Date(record.createdAt),
+    updatedAt: new Date(record.updatedAt)
+  };
+}
+function createPrismaAdapter(config) {
+  const { prisma } = config;
+  const model = prisma.newsletterSubscriber;
+  return {
+    async createSubscriber(input, token) {
+      const confirmToken = token || generateToken();
+      const record = await model.upsert({
+        where: { email: input.email.toLowerCase() },
+        update: {
+          token: confirmToken,
+          source: input.source,
+          tags: input.tags || [],
+          metadata: input.metadata,
+          consentIp: input.ip,
+          consentAt: /* @__PURE__ */ new Date(),
+          // Reset to pending if resubscribing
+          status: "pending",
+          unsubscribedAt: null
+        },
+        create: {
+          email: input.email.toLowerCase(),
+          token: confirmToken,
+          status: "pending",
+          source: input.source,
+          tags: input.tags || [],
+          metadata: input.metadata,
+          consentIp: input.ip,
+          consentAt: /* @__PURE__ */ new Date()
+        }
+      });
+      return mapToSubscriber(record);
+    },
+    async getSubscriberByEmail(email) {
+      const record = await model.findUnique({
+        where: { email: email.toLowerCase() }
+      });
+      return record ? mapToSubscriber(record) : null;
+    },
+    async getSubscriberByToken(token) {
+      const record = await model.findFirst({
+        where: { token }
+      });
+      return record ? mapToSubscriber(record) : null;
+    },
+    async confirmSubscriber(token) {
+      try {
+        const record = await model.update({
+          where: { token },
+          data: {
+            status: "confirmed",
+            confirmedAt: /* @__PURE__ */ new Date(),
+            token: null
+            // Clear token after use
+          }
+        });
+        return mapToSubscriber(record);
+      } catch {
+        return null;
+      }
+    },
+    async unsubscribe(email) {
+      try {
+        await model.update({
+          where: { email: email.toLowerCase() },
+          data: {
+            status: "unsubscribed",
+            unsubscribedAt: /* @__PURE__ */ new Date()
+          }
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async listSubscribers(options) {
+      const where = {};
+      if (options?.status) {
+        where.status = options.status;
+      }
+      if (options?.source) {
+        where.source = options.source;
+      }
+      if (options?.tags?.length) {
+        where.tags = { hasSome: options.tags };
+      }
+      const [records, total] = await Promise.all([
+        model.findMany({
+          where,
+          take: options?.limit || 100,
+          skip: options?.offset || 0,
+          orderBy: { createdAt: "desc" }
+        }),
+        model.count({ where })
+      ]);
+      return {
+        subscribers: records.map((r) => mapToSubscriber(r)),
+        total
+      };
+    },
+    async deleteSubscriber(email) {
+      try {
+        await model.delete({
+          where: { email: email.toLowerCase() }
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async updateSubscriber(email, data) {
+      try {
+        const record = await model.update({
+          where: { email: email.toLowerCase() },
+          data: {
+            ...data.source !== void 0 && { source: data.source },
+            ...data.tags !== void 0 && { tags: data.tags },
+            ...data.metadata !== void 0 && { metadata: data.metadata }
+          }
+        });
+        return mapToSubscriber(record);
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+// src/adapters/storage/supabase.ts
+function mapToSubscriber2(record) {
+  return {
+    id: record.id,
+    email: record.email,
+    status: record.status,
+    source: record.source,
+    tags: record.tags,
+    metadata: record.metadata,
+    consentIp: record.consent_ip,
+    consentAt: record.consent_at ? new Date(record.consent_at) : void 0,
+    confirmedAt: record.confirmed_at ? new Date(record.confirmed_at) : void 0,
+    unsubscribedAt: record.unsubscribed_at ? new Date(record.unsubscribed_at) : void 0,
+    createdAt: new Date(record.created_at),
+    updatedAt: new Date(record.updated_at)
+  };
+}
+function createSupabaseAdapter(config) {
+  const { supabase, tableName = "newsletter_subscribers" } = config;
+  return {
+    async createSubscriber(input, token) {
+      const confirmToken = token || generateToken();
+      const email = input.email.toLowerCase();
+      const { data, error } = await supabase.from(tableName).upsert(
+        {
+          email,
+          token: confirmToken,
+          status: "pending",
+          source: input.source,
+          tags: input.tags || [],
+          metadata: input.metadata,
+          consent_ip: input.ip,
+          consent_at: (/* @__PURE__ */ new Date()).toISOString(),
+          unsubscribed_at: null
+        },
+        { onConflict: "email" }
+      );
+      if (error) throw error;
+      const { data: record } = await supabase.from(tableName).select().eq("email", email).single();
+      return mapToSubscriber2(record);
+    },
+    async getSubscriberByEmail(email) {
+      const { data, error } = await supabase.from(tableName).select().eq("email", email.toLowerCase()).single();
+      if (error || !data) return null;
+      return mapToSubscriber2(data);
+    },
+    async getSubscriberByToken(token) {
+      const { data, error } = await supabase.from(tableName).select().eq("token", token).single();
+      if (error || !data) return null;
+      return mapToSubscriber2(data);
+    },
+    async confirmSubscriber(token) {
+      const { error } = await supabase.from(tableName).update({
+        status: "confirmed",
+        confirmed_at: (/* @__PURE__ */ new Date()).toISOString(),
+        token: null
+      }).eq("token", token);
+      if (error) return null;
+      const { data } = await supabase.from(tableName).select().eq("token", null).single();
+      return data ? mapToSubscriber2(data) : null;
+    },
+    async unsubscribe(email) {
+      const { error } = await supabase.from(tableName).update({
+        status: "unsubscribed",
+        unsubscribed_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).eq("email", email.toLowerCase());
+      return !error;
+    },
+    async listSubscribers(options) {
+      const limit = options?.limit || 100;
+      const offset = options?.offset || 0;
+      let query = supabase.from(tableName).select();
+      if (options?.status) {
+        query = query.eq("status", options.status);
+      }
+      if (options?.source) {
+        query = query.eq("source", options.source);
+      }
+      if (options?.tags?.length) {
+        query = query.contains("tags", options.tags);
+      }
+      const { data, error } = await query.order("created_at", { ascending: false }).range(offset, offset + limit - 1);
+      if (error) throw error;
+      return {
+        subscribers: (data || []).map((r) => mapToSubscriber2(r)),
+        total: (data || []).length
+        // Note: Supabase doesn't return total count easily
+      };
+    },
+    async deleteSubscriber(email) {
+      const { error } = await supabase.from(tableName).delete().eq("email", email.toLowerCase());
+      return !error;
+    },
+    async updateSubscriber(email, data) {
+      const updateData = {};
+      if (data.source !== void 0) updateData.source = data.source;
+      if (data.tags !== void 0) updateData.tags = data.tags;
+      if (data.metadata !== void 0) updateData.metadata = data.metadata;
+      const { error } = await supabase.from(tableName).update(updateData).eq("email", email.toLowerCase());
+      if (error) return null;
+      return this.getSubscriberByEmail(email);
+    }
+  };
+}
+export {
+  NewsletterBlock,
+  NewsletterCard,
+  NewsletterFooter,
+  NewsletterForm,
+  NewsletterInline,
+  NewsletterModalContent,
+  createMailchimpAdapter,
+  createMailchimpStorageAdapter,
+  createMemoryAdapter,
+  createNewsletterHandlers,
+  createNodemailerAdapter,
+  createNoopAdapter,
+  createPrismaAdapter,
+  createRateLimiter,
+  createResendAdapter,
+  createSupabaseAdapter,
+  generateToken,
+  generateUrlSafeToken,
+  getClientIP,
+  isDisposableEmail,
+  isValidEmail,
+  normalizeEmail,
+  sanitizeString,
+  useNewsletter
+};
+//# sourceMappingURL=index.js.map