payload-plugin-newsletter 0.20.0 → 0.20.2

package/dist/{index.js → server.js}

@@ -1,538 +1,9 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/types/newsletter.ts
-var NewsletterProviderError;
-var init_newsletter = __esm({
-  "src/types/newsletter.ts"() {
-    "use strict";
-    NewsletterProviderError = class extends Error {
-      constructor(message, code, provider, details) {
-        super(message);
-        this.code = code;
-        this.provider = provider;
-        this.details = details;
-        this.name = "NewsletterProviderError";
-      }
-    };
-  }
-});
-
-// src/types/broadcast.ts
-var BroadcastProviderError;
-var init_broadcast = __esm({
-  "src/types/broadcast.ts"() {
-    "use strict";
-    init_newsletter();
-    BroadcastProviderError = class extends Error {
-      constructor(message, code, provider, details) {
-        super(message);
-        this.code = code;
-        this.provider = provider;
-        this.details = details;
-        this.name = "BroadcastProviderError";
-      }
-    };
-  }
-});
-
-// src/types/providers.ts
-var BaseBroadcastProvider;
-var init_providers = __esm({
-  "src/types/providers.ts"() {
-    "use strict";
-    init_broadcast();
-    init_newsletter();
-    BaseBroadcastProvider = class {
-      constructor(config) {
-        this.config = config;
-      }
-      /**
-       * Schedule a broadcast - default implementation throws not supported
-       */
-      async schedule(_id, _scheduledAt) {
-        const capabilities = this.getCapabilities();
-        if (!capabilities.supportsScheduling) {
-          throw new BroadcastProviderError(
-            "Scheduling is not supported by this provider",
-            "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-            this.name
-          );
-        }
-        throw new Error("Method not implemented");
-      }
-      /**
-       * Cancel scheduled broadcast - default implementation throws not supported
-       */
-      async cancelSchedule(_id) {
-        const capabilities = this.getCapabilities();
-        if (!capabilities.supportsScheduling) {
-          throw new BroadcastProviderError(
-            "Scheduling is not supported by this provider",
-            "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-            this.name
-          );
-        }
-        throw new Error("Method not implemented");
-      }
-      /**
-       * Get analytics - default implementation returns zeros
-       */
-      async getAnalytics(_id) {
-        const capabilities = this.getCapabilities();
-        if (!capabilities.supportsAnalytics) {
-          throw new BroadcastProviderError(
-            "Analytics are not supported by this provider",
-            "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-            this.name
-          );
-        }
-        return {
-          sent: 0,
-          delivered: 0,
-          opened: 0,
-          clicked: 0,
-          bounced: 0,
-          complained: 0,
-          unsubscribed: 0
-        };
-      }
-      /**
-       * Helper method to validate required fields
-       */
-      validateRequiredFields(data, fields) {
-        const missing = fields.filter((field) => !data[field]);
-        if (missing.length > 0) {
-          throw new BroadcastProviderError(
-            `Missing required fields: ${missing.join(", ")}`,
-            "VALIDATION_ERROR" /* VALIDATION_ERROR */,
-            this.name
-          );
-        }
-      }
-      /**
-       * Helper method to check if a status transition is allowed
-       */
-      canEditInStatus(status) {
-        const capabilities = this.getCapabilities();
-        return capabilities.editableStatuses.includes(status);
-      }
-      /**
-       * Helper to build pagination response
-       */
-      buildListResponse(items, total, options = {}) {
-        const limit = options.limit || 20;
-        const offset = options.offset || 0;
-        return {
-          items,
-          total,
-          limit,
-          offset,
-          hasMore: offset + items.length < total
-        };
-      }
-    };
-  }
-});
-
-// src/types/index.ts
-var init_types = __esm({
-  "src/types/index.ts"() {
-    "use strict";
-    init_broadcast();
-    init_providers();
-    init_newsletter();
-  }
-});
-
-// src/providers/broadcast/broadcast.ts
-var broadcast_exports = {};
-__export(broadcast_exports, {
-  BroadcastApiProvider: () => BroadcastApiProvider
-});
-var BroadcastApiProvider;
-var init_broadcast2 = __esm({
-  "src/providers/broadcast/broadcast.ts"() {
-    "use strict";
-    init_types();
-    BroadcastApiProvider = class extends BaseBroadcastProvider {
-      constructor(config) {
-        super(config);
-        this.name = "broadcast";
-        this.apiUrl = config.apiUrl.replace(/\/$/, "");
-        this.token = config.token;
-        if (!this.token) {
-          throw new BroadcastProviderError(
-            "Broadcast API token is required",
-            "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
-            this.name
-          );
-        }
-      }
-      // Broadcast Management Methods
-      async list(options) {
-        try {
-          const params = new URLSearchParams();
-          if (options?.limit) params.append("limit", options.limit.toString());
-          if (options?.offset) params.append("offset", options.offset.toString());
-          const response = await fetch(`${this.apiUrl}/api/v1/broadcasts?${params}`, {
-            method: "GET",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            }
-          });
-          if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-          const data = await response.json();
-          const broadcasts = data.data.map((broadcast) => this.transformBroadcastFromApi(broadcast));
-          return this.buildListResponse(broadcasts, data.total, options);
-        } catch (error) {
-          throw new BroadcastProviderError(
-            `Failed to list broadcasts: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async get(id) {
-        try {
-          const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${id}`, {
-            method: "GET",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            }
-          });
-          if (!response.ok) {
-            if (response.status === 404) {
-              throw new BroadcastProviderError(
-                `Broadcast not found: ${id}`,
-                "NOT_FOUND" /* NOT_FOUND */,
-                this.name
-              );
-            }
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-          const broadcast = await response.json();
-          return this.transformBroadcastFromApi(broadcast);
-        } catch (error) {
-          if (error instanceof BroadcastProviderError) throw error;
-          throw new BroadcastProviderError(
-            `Failed to get broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async create(data) {
-        try {
-          this.validateRequiredFields(data, ["name", "subject", "content"]);
-          const requestBody = {
-            broadcast: {
-              name: data.name,
-              subject: data.subject,
-              preheader: data.preheader,
-              body: data.content,
-              html_body: true,
-              track_opens: data.trackOpens ?? true,
-              track_clicks: data.trackClicks ?? true,
-              reply_to: data.replyTo,
-              segment_ids: data.audienceIds
-            }
-          };
-          console.log("[BroadcastApiProvider] Creating broadcast:", {
-            url: `${this.apiUrl}/api/v1/broadcasts`,
-            method: "POST",
-            hasToken: !!this.token,
-            tokenLength: this.token?.length,
-            body: JSON.stringify(requestBody, null, 2)
-          });
-          const response = await fetch(`${this.apiUrl}/api/v1/broadcasts`, {
-            method: "POST",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify(requestBody)
-          });
-          console.log("[BroadcastApiProvider] Response status:", response.status);
-          console.log("[BroadcastApiProvider] Response headers:", Object.fromEntries(response.headers.entries()));
-          if (!response.ok) {
-            const errorText = await response.text();
-            console.error("[BroadcastApiProvider] Error response body:", errorText);
-            let errorDetails;
-            try {
-              errorDetails = JSON.parse(errorText);
-              console.error("[BroadcastApiProvider] Parsed error:", errorDetails);
-            } catch {
-            }
-            throw new Error(`Broadcast API error: ${response.status} - ${errorText}`);
-          }
-          const result = await response.json();
-          return this.get(result.id.toString());
-        } catch (error) {
-          if (error instanceof BroadcastProviderError) throw error;
-          throw new BroadcastProviderError(
-            `Failed to create broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async update(id, data) {
-        try {
-          const existing = await this.get(id);
-          if (!this.canEditInStatus(existing.sendStatus)) {
-            throw new BroadcastProviderError(
-              `Cannot update broadcast in status: ${existing.sendStatus}`,
-              "INVALID_STATUS" /* INVALID_STATUS */,
-              this.name
-            );
-          }
-          const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${id}`, {
-            method: "PATCH",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              broadcast: {
-                name: data.name,
-                subject: data.subject,
-                preheader: data.preheader,
-                body: data.content,
-                track_opens: data.trackOpens,
-                track_clicks: data.trackClicks,
-                reply_to: data.replyTo,
-                segment_ids: data.audienceIds
-              }
-            })
-          });
-          if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-          const broadcast = await response.json();
-          return this.transformBroadcastFromApi(broadcast);
-        } catch (error) {
-          if (error instanceof BroadcastProviderError) throw error;
-          throw new BroadcastProviderError(
-            `Failed to update broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async delete(id) {
-        try {
-          const existing = await this.get(id);
-          if (!this.canEditInStatus(existing.sendStatus)) {
-            throw new BroadcastProviderError(
-              `Cannot delete broadcast in status: ${existing.sendStatus}`,
-              "INVALID_STATUS" /* INVALID_STATUS */,
-              this.name
-            );
-          }
-          const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${id}`, {
-            method: "DELETE",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            }
-          });
-          if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-        } catch (error) {
-          if (error instanceof BroadcastProviderError) throw error;
-          throw new BroadcastProviderError(
-            `Failed to delete broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async send(id, options) {
-        try {
-          if (options?.testMode && options.testRecipients?.length) {
-            throw new BroadcastProviderError(
-              "Test send is not yet implemented for Broadcast provider",
-              "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-              this.name
-            );
-          }
-          const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${id}/send_broadcast`, {
-            method: "POST",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              segment_ids: options?.audienceIds
-            })
-          });
-          if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-          const result = await response.json();
-          return this.get(result.id.toString());
-        } catch (error) {
-          if (error instanceof BroadcastProviderError) throw error;
-          throw new BroadcastProviderError(
-            `Failed to send broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async schedule(id, scheduledAt) {
-        try {
-          const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${id}`, {
-            method: "PATCH",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              broadcast: {
-                scheduled_send_at: scheduledAt.toISOString(),
-                // TODO: Handle timezone properly
-                scheduled_timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
-              }
-            })
-          });
-          if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-          const broadcast = await response.json();
-          return this.transformBroadcastFromApi(broadcast);
-        } catch (error) {
-          throw new BroadcastProviderError(
-            `Failed to schedule broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async cancelSchedule(id) {
-        try {
-          const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${id}`, {
-            method: "PATCH",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              broadcast: {
-                scheduled_send_at: null,
-                scheduled_timezone: null
-              }
-            })
-          });
-          if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-          const broadcast = await response.json();
-          return this.transformBroadcastFromApi(broadcast);
-        } catch (error) {
-          throw new BroadcastProviderError(
-            `Failed to cancel scheduled broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async getAnalytics(_id) {
-        throw new BroadcastProviderError(
-          "Analytics API not yet implemented for Broadcast provider",
-          "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-          this.name
-        );
-      }
-      getCapabilities() {
-        return {
-          supportsScheduling: true,
-          supportsSegmentation: true,
-          supportsAnalytics: false,
-          // Not documented yet
-          supportsABTesting: false,
-          supportsTemplates: false,
-          supportsPersonalization: true,
-          supportsMultipleChannels: false,
-          supportsChannelSegmentation: false,
-          editableStatuses: ["draft" /* DRAFT */, "scheduled" /* SCHEDULED */],
-          supportedContentTypes: ["html", "text"]
-        };
-      }
-      async validateConfiguration() {
-        try {
-          await this.list({ limit: 1 });
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      transformBroadcastFromApi(broadcast) {
-        return {
-          id: broadcast.id.toString(),
-          name: broadcast.name,
-          subject: broadcast.subject,
-          preheader: broadcast.preheader,
-          content: broadcast.body,
-          sendStatus: this.mapBroadcastStatus(broadcast.status),
-          trackOpens: broadcast.track_opens,
-          trackClicks: broadcast.track_clicks,
-          replyTo: broadcast.reply_to,
-          recipientCount: broadcast.total_recipients,
-          sentAt: broadcast.sent_at ? new Date(broadcast.sent_at) : void 0,
-          scheduledAt: broadcast.scheduled_send_at ? new Date(broadcast.scheduled_send_at) : void 0,
-          createdAt: new Date(broadcast.created_at),
-          updatedAt: new Date(broadcast.updated_at),
-          providerData: { broadcast },
-          providerId: broadcast.id.toString(),
-          providerType: "broadcast"
-        };
-      }
-      mapBroadcastStatus(status) {
-        const statusMap = {
-          "draft": "draft" /* DRAFT */,
-          "scheduled": "scheduled" /* SCHEDULED */,
-          "queueing": "sending" /* SENDING */,
-          "sending": "sending" /* SENDING */,
-          "sent": "sent" /* SENT */,
-          "failed": "failed" /* FAILED */,
-          "partial_failure": "failed" /* FAILED */,
-          "paused": "paused" /* PAUSED */,
-          "aborted": "canceled" /* CANCELED */
-        };
-        return statusMap[status] || "draft" /* DRAFT */;
-      }
-    };
-  }
-});
+import {
+  BaseBroadcastProvider,
+  BroadcastApiProvider,
+  BroadcastProviderError,
+  NewsletterProviderError
+} from "./chunk-XVMYJQRQ.js";
 
 // src/utils/access.ts
 var isAdmin = (user, config) => {
@@ -3155,9 +2626,6 @@ var createUnsubscribeSyncJob = (pluginConfig) => {
   };
 };
 
-// src/collections/Broadcasts.ts
-init_types();
-
 // src/fields/emailContent.ts
 import {
   BoldFeature,
@@ -4013,9 +3481,6 @@ async function getBroadcastConfig(req, pluginConfig) {
   }
 }
 
-// src/endpoints/broadcasts/send.ts
-init_types();
-
 // src/utils/auth.ts
 async function getAuthenticatedUser(req) {
   try {
@@ -4103,7 +3568,7 @@ var createSendBroadcastEndpoint = (config, collectionSlug) => {
             error: "Broadcast provider not configured in Newsletter Settings or environment variables"
           }, { status: 500 });
         }
-        const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+        const { BroadcastApiProvider: BroadcastApiProvider2 } = await import("./broadcast-VMCYSZRY.js");
         const provider = new BroadcastApiProvider2(providerConfig);
         const broadcast = await provider.send(broadcastDoc.providerId, data);
         await req.payload.update({
@@ -4139,7 +3604,6 @@ var createSendBroadcastEndpoint = (config, collectionSlug) => {
 };
 
 // src/endpoints/broadcasts/schedule.ts
-init_types();
 var createScheduleBroadcastEndpoint = (config, collectionSlug) => {
   return {
     path: "/:id/schedule",
@@ -4207,7 +3671,7 @@ var createScheduleBroadcastEndpoint = (config, collectionSlug) => {
             error: "Broadcast provider not configured"
           }, { status: 500 });
         }
-        const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+        const { BroadcastApiProvider: BroadcastApiProvider2 } = await import("./broadcast-VMCYSZRY.js");
         const provider = new BroadcastApiProvider2(providerConfig);
         const broadcast = await provider.schedule(broadcastDoc.providerId, scheduledDate);
         await req.payload.update({
@@ -4723,7 +4187,7 @@ var createBroadcastsCollection = (pluginConfig) => {
                 req.payload.logger.error("Broadcast provider not configured in Newsletter Settings or environment variables");
                 return doc;
               }
-              const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+              const { BroadcastApiProvider: BroadcastApiProvider2 } = await import("./broadcast-VMCYSZRY.js");
               const provider = new BroadcastApiProvider2(providerConfig);
               req.payload.logger.info("Populating media fields and converting content to HTML...");
               const populatedContent = await populateMediaFields(doc.contentSection?.content, req.payload, pluginConfig);
@@ -4818,7 +4282,7 @@ var createBroadcastsCollection = (pluginConfig) => {
                 req.payload.logger.error("Broadcast provider not configured in Newsletter Settings or environment variables");
                 return doc;
               }
-              const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+              const { BroadcastApiProvider: BroadcastApiProvider2 } = await import("./broadcast-VMCYSZRY.js");
               const provider = new BroadcastApiProvider2(providerConfig);
               if (!doc.providerId) {
                 if (!doc.subject || !doc.contentSection?.content) {
@@ -4963,7 +4427,7 @@ var createBroadcastsCollection = (pluginConfig) => {
                 return doc;
               }
               if (broadcastConfig && broadcastConfig.token) {
-                const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+                const { BroadcastApiProvider: BroadcastApiProvider2 } = await import("./broadcast-VMCYSZRY.js");
                 const provider = new BroadcastApiProvider2(broadcastConfig);
                 await provider.send(doc.providerId);
               }
@@ -5014,7 +4478,7 @@ var createBroadcastsCollection = (pluginConfig) => {
               req.payload.logger.error("Broadcast provider not configured in Newsletter Settings or environment variables");
               return doc;
             }
-            const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+            const { BroadcastApiProvider: BroadcastApiProvider2 } = await import("./broadcast-VMCYSZRY.js");
             const provider = new BroadcastApiProvider2(providerConfig);
             const capabilities = provider.getCapabilities();
             if (capabilities.editableStatuses.includes(doc.sendStatus)) {
@@ -5040,11 +4504,7 @@ var createBroadcastsCollection = (pluginConfig) => {
   };
 };
 
-// src/index.ts
-init_broadcast2();
-
 // src/providers/resend/broadcast.ts
-init_types();
 import { Resend as Resend2 } from "resend";
 var ResendBroadcastProvider = class extends BaseBroadcastProvider {
   constructor(config) {
@@ -5257,100 +4717,16 @@ var ResendBroadcastProvider = class extends BaseBroadcastProvider {
   }
 };
 
-// src/utilities/session.ts
-import jwt2 from "jsonwebtoken";
-var getTokenFromRequest = (req) => {
-  const cookies = req.cookies || req.headers?.cookie;
-  if (!cookies) return null;
-  if (typeof cookies === "string") {
-    const parsed = cookies.split(";").reduce((acc, cookie) => {
-      const [key, value] = cookie.trim().split("=");
-      acc[key] = value;
-      return acc;
-    }, {});
-    return parsed["newsletter-auth"] || null;
-  }
-  return cookies["newsletter-auth"] || null;
-};
-var verifyToken = (token, secret) => {
-  try {
-    const decoded = jwt2.verify(token, secret);
-    return decoded;
-  } catch {
-    return null;
-  }
-};
-var getServerSideAuth = async (context, secret) => {
-  const token = getTokenFromRequest(context.req);
-  if (!token) {
-    return { subscriber: null, isAuthenticated: false };
-  }
-  const payloadSecret = secret || process.env.PAYLOAD_SECRET;
-  if (!payloadSecret) {
-    console.error("No secret provided for token verification");
-    return { subscriber: null, isAuthenticated: false };
-  }
-  const decoded = verifyToken(token, payloadSecret);
-  if (!decoded) {
-    return { subscriber: null, isAuthenticated: false };
-  }
-  return {
-    subscriber: decoded,
-    isAuthenticated: true
-  };
+// src/contexts/ServerContext.ts
+var configStore = {
+  config: null
 };
-var requireAuth = (gssp) => {
-  return async (context) => {
-    const { isAuthenticated: isAuthenticated2, subscriber } = await getServerSideAuth(context);
-    if (!isAuthenticated2) {
-      return {
-        redirect: {
-          destination: "/auth/signin",
-          permanent: false
-        }
-      };
-    }
-    if (gssp) {
-      const result = await gssp(context);
-      return {
-        ...result,
-        props: {
-          ...result.props,
-          subscriber
-        }
-      };
-    }
-    return {
-      props: {
-        subscriber
-      }
-    };
-  };
-};
-var isAuthenticated = (req, secret) => {
-  const token = getTokenFromRequest(req);
-  if (!token) return false;
-  const decoded = verifyToken(token, secret);
-  return !!decoded;
+var setPluginConfig = (config) => {
+  configStore.config = config;
 };
 
-// src/contexts/PluginConfigContext.tsx
-import { createContext, useContext } from "react";
-import { jsx as jsx5 } from "react/jsx-runtime";
-var PluginConfigContext = createContext(null);
-var PluginConfigProvider = ({ config, children }) => {
-  return /* @__PURE__ */ jsx5(PluginConfigContext.Provider, { value: config, children });
-};
-var usePluginConfig = () => {
-  const config = useContext(PluginConfigContext);
-  if (!config) {
-    throw new Error("usePluginConfig must be used within PluginConfigProvider");
-  }
-  return config;
-};
-var usePluginConfigOptional = () => {
-  return useContext(PluginConfigContext);
-};
+// src/utilities/session.ts
+import jwt2 from "jsonwebtoken";
 
 // src/index.ts
 var newsletterPlugin = (pluginConfig) => (incomingConfig) => {
@@ -5366,6 +4742,7 @@ var newsletterPlugin = (pluginConfig) => (incomingConfig) => {
     },
     ...pluginConfig
   };
+  setPluginConfig(config);
   if (!config.enabled) {
     return incomingConfig;
   }
@@ -5528,15 +4905,14 @@ var newsletterPlugin = (pluginConfig) => (incomingConfig) => {
   return modifiedConfig;
 };
 export {
-  PluginConfigProvider,
-  newsletterPlugin as default,
-  getServerSideAuth,
-  getTokenFromRequest,
-  isAuthenticated,
-  newsletterPlugin,
-  requireAuth,
-  usePluginConfig,
-  usePluginConfigOptional,
-  verifyToken
+  BroadcastProvider,
+  ResendProvider,
+  createBroadcastsCollection,
+  createNewsletterSettingsGlobal,
+  createPreferencesEndpoint,
+  createSubscribeEndpoint,
+  createSubscribersCollection,
+  createUnsubscribeEndpoint,
+  createVerifyMagicLinkEndpoint,
+  newsletterPlugin
 };
-//# sourceMappingURL=index.js.map