payload-plugin-newsletter 0.14.3 → 0.15.1

package/dist/collections.cjs

@@ -0,0 +1,2124 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types/newsletter.ts
+var init_newsletter = __esm({
+  "src/types/newsletter.ts"() {
+    "use strict";
+  }
+});
+
+// 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 response = await fetch(`${this.apiUrl}/api/v1/broadcasts`, {
+            method: "POST",
+            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,
+                html_body: true,
+                track_opens: data.trackOpens ?? true,
+                track_clicks: data.trackClicks ?? true,
+                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 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.status)) {
+            throw new BroadcastProviderError(
+              `Cannot update broadcast in status: ${existing.status}`,
+              "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.status)) {
+            throw new BroadcastProviderError(
+              `Cannot delete broadcast in status: ${existing.status}`,
+              "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,
+          status: 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 */;
+      }
+    };
+  }
+});
+
+// src/exports/collections.ts
+var collections_exports = {};
+__export(collections_exports, {
+  createBroadcastsCollection: () => createBroadcastsCollection,
+  createSubscribersCollection: () => createSubscribersCollection
+});
+module.exports = __toCommonJS(collections_exports);
+
+// src/collections/Broadcasts.ts
+init_types();
+
+// src/fields/emailContent.ts
+var import_richtext_lexical = require("@payloadcms/richtext-lexical");
+
+// src/utils/blockValidation.ts
+var EMAIL_INCOMPATIBLE_TYPES = [
+  "chart",
+  "dataTable",
+  "interactive",
+  "streamable",
+  "video",
+  "iframe",
+  "form",
+  "carousel",
+  "tabs",
+  "accordion",
+  "map"
+];
+var validateEmailBlocks = (blocks) => {
+  blocks.forEach((block) => {
+    if (EMAIL_INCOMPATIBLE_TYPES.includes(block.slug)) {
+      console.warn(`\u26A0\uFE0F  Block "${block.slug}" may not be email-compatible. Consider creating an email-specific version.`);
+    }
+    const hasComplexFields = block.fields?.some((field) => {
+      const complexTypes = ["code", "json", "richText", "blocks", "array"];
+      return complexTypes.includes(field.type);
+    });
+    if (hasComplexFields) {
+      console.warn(`\u26A0\uFE0F  Block "${block.slug}" contains complex field types that may not render consistently in email clients.`);
+    }
+  });
+};
+var createEmailSafeBlocks = (customBlocks = []) => {
+  validateEmailBlocks(customBlocks);
+  const baseBlocks = [
+    {
+      slug: "button",
+      fields: [
+        {
+          name: "text",
+          type: "text",
+          label: "Button Text",
+          required: true
+        },
+        {
+          name: "url",
+          type: "text",
+          label: "Button URL",
+          required: true,
+          admin: {
+            description: "Enter the full URL (including https://)"
+          }
+        },
+        {
+          name: "style",
+          type: "select",
+          label: "Button Style",
+          defaultValue: "primary",
+          options: [
+            { label: "Primary", value: "primary" },
+            { label: "Secondary", value: "secondary" },
+            { label: "Outline", value: "outline" }
+          ]
+        }
+      ],
+      interfaceName: "EmailButton",
+      labels: {
+        singular: "Button",
+        plural: "Buttons"
+      }
+    },
+    {
+      slug: "divider",
+      fields: [
+        {
+          name: "style",
+          type: "select",
+          label: "Divider Style",
+          defaultValue: "solid",
+          options: [
+            { label: "Solid", value: "solid" },
+            { label: "Dashed", value: "dashed" },
+            { label: "Dotted", value: "dotted" }
+          ]
+        }
+      ],
+      interfaceName: "EmailDivider",
+      labels: {
+        singular: "Divider",
+        plural: "Dividers"
+      }
+    }
+  ];
+  return [
+    ...baseBlocks,
+    ...customBlocks
+  ];
+};
+
+// src/fields/emailContent.ts
+var createEmailSafeFeatures = (additionalBlocks) => {
+  const baseBlocks = [
+    {
+      slug: "button",
+      fields: [
+        {
+          name: "text",
+          type: "text",
+          label: "Button Text",
+          required: true
+        },
+        {
+          name: "url",
+          type: "text",
+          label: "Button URL",
+          required: true,
+          admin: {
+            description: "Enter the full URL (including https://)"
+          }
+        },
+        {
+          name: "style",
+          type: "select",
+          label: "Button Style",
+          defaultValue: "primary",
+          options: [
+            { label: "Primary", value: "primary" },
+            { label: "Secondary", value: "secondary" },
+            { label: "Outline", value: "outline" }
+          ]
+        }
+      ],
+      interfaceName: "EmailButton",
+      labels: {
+        singular: "Button",
+        plural: "Buttons"
+      }
+    },
+    {
+      slug: "divider",
+      fields: [
+        {
+          name: "style",
+          type: "select",
+          label: "Divider Style",
+          defaultValue: "solid",
+          options: [
+            { label: "Solid", value: "solid" },
+            { label: "Dashed", value: "dashed" },
+            { label: "Dotted", value: "dotted" }
+          ]
+        }
+      ],
+      interfaceName: "EmailDivider",
+      labels: {
+        singular: "Divider",
+        plural: "Dividers"
+      }
+    }
+  ];
+  const allBlocks = [
+    ...baseBlocks,
+    ...additionalBlocks || []
+  ];
+  return [
+    // Toolbars
+    (0, import_richtext_lexical.FixedToolbarFeature)(),
+    // Fixed toolbar at the top
+    (0, import_richtext_lexical.InlineToolbarFeature)(),
+    // Floating toolbar when text is selected
+    // Basic text formatting
+    (0, import_richtext_lexical.BoldFeature)(),
+    (0, import_richtext_lexical.ItalicFeature)(),
+    (0, import_richtext_lexical.UnderlineFeature)(),
+    (0, import_richtext_lexical.StrikethroughFeature)(),
+    // Links with enhanced configuration
+    (0, import_richtext_lexical.LinkFeature)({
+      fields: [
+        {
+          name: "url",
+          type: "text",
+          required: true,
+          admin: {
+            description: "Enter the full URL (including https://)"
+          }
+        },
+        {
+          name: "newTab",
+          type: "checkbox",
+          label: "Open in new tab",
+          defaultValue: false
+        }
+      ]
+    }),
+    // Lists
+    (0, import_richtext_lexical.OrderedListFeature)(),
+    (0, import_richtext_lexical.UnorderedListFeature)(),
+    // Headings - limited to h1, h2, h3 for email compatibility
+    (0, import_richtext_lexical.HeadingFeature)({
+      enabledHeadingSizes: ["h1", "h2", "h3"]
+    }),
+    // Basic paragraph and alignment
+    (0, import_richtext_lexical.ParagraphFeature)(),
+    (0, import_richtext_lexical.AlignFeature)(),
+    // Blockquotes
+    (0, import_richtext_lexical.BlockquoteFeature)(),
+    // Upload feature for images
+    (0, import_richtext_lexical.UploadFeature)({
+      collections: {
+        media: {
+          fields: [
+            {
+              name: "caption",
+              type: "text",
+              admin: {
+                description: "Optional caption for the image"
+              }
+            },
+            {
+              name: "altText",
+              type: "text",
+              label: "Alt Text",
+              required: true,
+              admin: {
+                description: "Alternative text for accessibility and when image cannot be displayed"
+              }
+            }
+          ]
+        }
+      }
+    }),
+    // Custom blocks for email-specific content
+    (0, import_richtext_lexical.BlocksFeature)({
+      blocks: allBlocks
+    })
+  ];
+};
+var createEmailLexicalEditor = (customBlocks = []) => {
+  const emailSafeBlocks = createEmailSafeBlocks(customBlocks);
+  return (0, import_richtext_lexical.lexicalEditor)({
+    features: [
+      // Toolbars
+      (0, import_richtext_lexical.FixedToolbarFeature)(),
+      (0, import_richtext_lexical.InlineToolbarFeature)(),
+      // Basic text formatting
+      (0, import_richtext_lexical.BoldFeature)(),
+      (0, import_richtext_lexical.ItalicFeature)(),
+      (0, import_richtext_lexical.UnderlineFeature)(),
+      (0, import_richtext_lexical.StrikethroughFeature)(),
+      // Links with enhanced configuration
+      (0, import_richtext_lexical.LinkFeature)({
+        fields: [
+          {
+            name: "url",
+            type: "text",
+            required: true,
+            admin: {
+              description: "Enter the full URL (including https://)"
+            }
+          },
+          {
+            name: "newTab",
+            type: "checkbox",
+            label: "Open in new tab",
+            defaultValue: false
+          }
+        ]
+      }),
+      // Lists
+      (0, import_richtext_lexical.OrderedListFeature)(),
+      (0, import_richtext_lexical.UnorderedListFeature)(),
+      // Headings - limited to h1, h2, h3 for email compatibility
+      (0, import_richtext_lexical.HeadingFeature)({
+        enabledHeadingSizes: ["h1", "h2", "h3"]
+      }),
+      // Basic paragraph and alignment
+      (0, import_richtext_lexical.ParagraphFeature)(),
+      (0, import_richtext_lexical.AlignFeature)(),
+      // Blockquotes
+      (0, import_richtext_lexical.BlockquoteFeature)(),
+      // Upload feature for images
+      (0, import_richtext_lexical.UploadFeature)({
+        collections: {
+          media: {
+            fields: [
+              {
+                name: "caption",
+                type: "text",
+                admin: {
+                  description: "Optional caption for the image"
+                }
+              },
+              {
+                name: "altText",
+                type: "text",
+                label: "Alt Text",
+                required: true,
+                admin: {
+                  description: "Alternative text for accessibility and when image cannot be displayed"
+                }
+              }
+            ]
+          }
+        }
+      }),
+      // Email-safe blocks (processed server-side)
+      (0, import_richtext_lexical.BlocksFeature)({
+        blocks: emailSafeBlocks
+      })
+    ]
+  });
+};
+var emailSafeFeatures = createEmailSafeFeatures();
+var createEmailContentField = (overrides) => {
+  const editor = overrides?.editor || createEmailLexicalEditor(overrides?.additionalBlocks);
+  return {
+    name: "content",
+    type: "richText",
+    required: true,
+    editor,
+    admin: {
+      description: "Email content with limited formatting for compatibility",
+      ...overrides?.admin
+    },
+    ...overrides
+  };
+};
+
+// src/fields/broadcastInlinePreview.ts
+var createBroadcastInlinePreviewField = () => {
+  return {
+    name: "broadcastInlinePreview",
+    type: "ui",
+    admin: {
+      components: {
+        Field: "payload-plugin-newsletter/components#BroadcastInlinePreview"
+      }
+    }
+  };
+};
+
+// src/utils/emailSafeHtml.ts
+var import_isomorphic_dompurify = __toESM(require("isomorphic-dompurify"), 1);
+var EMAIL_SAFE_CONFIG = {
+  ALLOWED_TAGS: [
+    "p",
+    "br",
+    "strong",
+    "b",
+    "em",
+    "i",
+    "u",
+    "strike",
+    "s",
+    "span",
+    "a",
+    "h1",
+    "h2",
+    "h3",
+    "ul",
+    "ol",
+    "li",
+    "blockquote",
+    "hr",
+    "img",
+    "div",
+    "table",
+    "tr",
+    "td",
+    "th",
+    "tbody",
+    "thead"
+  ],
+  ALLOWED_ATTR: ["href", "style", "target", "rel", "align", "src", "alt", "width", "height", "border", "cellpadding", "cellspacing"],
+  ALLOWED_STYLES: {
+    "*": [
+      "color",
+      "background-color",
+      "font-size",
+      "font-weight",
+      "font-style",
+      "text-decoration",
+      "text-align",
+      "margin",
+      "margin-top",
+      "margin-right",
+      "margin-bottom",
+      "margin-left",
+      "padding",
+      "padding-top",
+      "padding-right",
+      "padding-bottom",
+      "padding-left",
+      "line-height",
+      "border-left",
+      "border-left-width",
+      "border-left-style",
+      "border-left-color"
+    ]
+  },
+  FORBID_TAGS: ["script", "style", "iframe", "object", "embed", "form", "input"],
+  FORBID_ATTR: ["class", "id", "onclick", "onload", "onerror"]
+};
+async function convertToEmailSafeHtml(editorState, options) {
+  const rawHtml = await lexicalToEmailHtml(editorState, options?.mediaUrl);
+  const sanitizedHtml = import_isomorphic_dompurify.default.sanitize(rawHtml, EMAIL_SAFE_CONFIG);
+  if (options?.wrapInTemplate) {
+    return wrapInEmailTemplate(sanitizedHtml, options.preheader);
+  }
+  return sanitizedHtml;
+}
+async function lexicalToEmailHtml(editorState, mediaUrl) {
+  const { root } = editorState;
+  if (!root || !root.children) {
+    return "";
+  }
+  const html = root.children.map((node) => convertNode(node, mediaUrl)).join("");
+  return html;
+}
+function convertNode(node, mediaUrl) {
+  switch (node.type) {
+    case "paragraph":
+      return convertParagraph(node, mediaUrl);
+    case "heading":
+      return convertHeading(node, mediaUrl);
+    case "list":
+      return convertList(node, mediaUrl);
+    case "listitem":
+      return convertListItem(node, mediaUrl);
+    case "blockquote":
+      return convertBlockquote(node, mediaUrl);
+    case "text":
+      return convertText(node);
+    case "link":
+      return convertLink(node, mediaUrl);
+    case "linebreak":
+      return "<br>";
+    case "upload":
+      return convertUpload(node, mediaUrl);
+    case "block":
+      return convertBlock(node, mediaUrl);
+    default:
+      if (node.children) {
+        return node.children.map((child) => convertNode(child, mediaUrl)).join("");
+      }
+      return "";
+  }
+}
+function convertParagraph(node, mediaUrl) {
+  const align = getAlignment(node.format);
+  const children = node.children?.map((child) => convertNode(child, mediaUrl)).join("") || "";
+  if (!children.trim()) {
+    return '<p style="margin: 0 0 16px 0; min-height: 1em;">&nbsp;</p>';
+  }
+  return `<p style="margin: 0 0 16px 0; text-align: ${align};">${children}</p>`;
+}
+function convertHeading(node, mediaUrl) {
+  const tag = node.tag || "h1";
+  const align = getAlignment(node.format);
+  const children = node.children?.map((child) => convertNode(child, mediaUrl)).join("") || "";
+  const styles2 = {
+    h1: "font-size: 32px; font-weight: 700; margin: 0 0 24px 0; line-height: 1.2;",
+    h2: "font-size: 24px; font-weight: 600; margin: 0 0 16px 0; line-height: 1.3;",
+    h3: "font-size: 20px; font-weight: 600; margin: 0 0 12px 0; line-height: 1.4;"
+  };
+  const style = `${styles2[tag] || styles2.h3} text-align: ${align};`;
+  return `<${tag} style="${style}">${children}</${tag}>`;
+}
+function convertList(node, mediaUrl) {
+  const tag = node.listType === "number" ? "ol" : "ul";
+  const children = node.children?.map((child) => convertNode(child, mediaUrl)).join("") || "";
+  const style = tag === "ul" ? "margin: 0 0 16px 0; padding-left: 24px; list-style-type: disc;" : "margin: 0 0 16px 0; padding-left: 24px; list-style-type: decimal;";
+  return `<${tag} style="${style}">${children}</${tag}>`;
+}
+function convertListItem(node, mediaUrl) {
+  const children = node.children?.map((child) => convertNode(child, mediaUrl)).join("") || "";
+  return `<li style="margin: 0 0 8px 0;">${children}</li>`;
+}
+function convertBlockquote(node, mediaUrl) {
+  const children = node.children?.map((child) => convertNode(child, mediaUrl)).join("") || "";
+  const style = "margin: 0 0 16px 0; padding-left: 16px; border-left: 4px solid #e5e7eb; color: #6b7280;";
+  return `<blockquote style="${style}">${children}</blockquote>`;
+}
+function convertText(node) {
+  let text = escapeHtml(node.text || "");
+  if (node.format & 1) {
+    text = `<strong>${text}</strong>`;
+  }
+  if (node.format & 2) {
+    text = `<em>${text}</em>`;
+  }
+  if (node.format & 8) {
+    text = `<u>${text}</u>`;
+  }
+  if (node.format & 4) {
+    text = `<strike>${text}</strike>`;
+  }
+  return text;
+}
+function convertLink(node, mediaUrl) {
+  const children = node.children?.map((child) => convertNode(child, mediaUrl)).join("") || "";
+  const url = node.fields?.url || "#";
+  const newTab = node.fields?.newTab ?? false;
+  const targetAttr = newTab ? ' target="_blank"' : "";
+  const relAttr = newTab ? ' rel="noopener noreferrer"' : "";
+  return `<a href="${escapeHtml(url)}"${targetAttr}${relAttr} style="color: #2563eb; text-decoration: underline;">${children}</a>`;
+}
+function convertUpload(node, mediaUrl) {
+  const upload = node.value;
+  if (!upload) return "";
+  let src = "";
+  if (typeof upload === "string") {
+    src = upload;
+  } else if (upload.url) {
+    src = upload.url;
+  } else if (upload.filename && mediaUrl) {
+    src = `${mediaUrl}/${upload.filename}`;
+  }
+  const alt = node.fields?.altText || upload.alt || "";
+  const caption = node.fields?.caption || "";
+  const imgHtml = `<img src="${escapeHtml(src)}" alt="${escapeHtml(alt)}" style="max-width: 100%; height: auto; display: block; margin: 0 auto;" />`;
+  if (caption) {
+    return `
+      <div style="margin: 0 0 16px 0; text-align: center;">
+        ${imgHtml}
+        <p style="margin: 8px 0 0 0; font-size: 14px; color: #6b7280; font-style: italic;">${escapeHtml(caption)}</p>
+      </div>
+    `;
+  }
+  return `<div style="margin: 0 0 16px 0; text-align: center;">${imgHtml}</div>`;
+}
+function convertBlock(node, mediaUrl) {
+  const blockType = node.fields?.blockName;
+  switch (blockType) {
+    case "button":
+      return convertButtonBlock(node.fields);
+    case "divider":
+      return convertDividerBlock(node.fields);
+    default:
+      if (node.children) {
+        return node.children.map((child) => convertNode(child, mediaUrl)).join("");
+      }
+      return "";
+  }
+}
+function convertButtonBlock(fields) {
+  const text = fields?.text || "Click here";
+  const url = fields?.url || "#";
+  const style = fields?.style || "primary";
+  const styles2 = {
+    primary: "background-color: #2563eb; color: #ffffff; border: 2px solid #2563eb;",
+    secondary: "background-color: #6b7280; color: #ffffff; border: 2px solid #6b7280;",
+    outline: "background-color: transparent; color: #2563eb; border: 2px solid #2563eb;"
+  };
+  const buttonStyle = `${styles2[style] || styles2.primary} display: inline-block; padding: 12px 24px; font-size: 16px; font-weight: 600; text-decoration: none; border-radius: 6px; text-align: center;`;
+  return `
+    <div style="margin: 0 0 16px 0; text-align: center;">
+      <a href="${escapeHtml(url)}" target="_blank" rel="noopener noreferrer" style="${buttonStyle}">${escapeHtml(text)}</a>
+    </div>
+  `;
+}
+function convertDividerBlock(fields) {
+  const style = fields?.style || "solid";
+  const styles2 = {
+    solid: "border-top: 1px solid #e5e7eb;",
+    dashed: "border-top: 1px dashed #e5e7eb;",
+    dotted: "border-top: 1px dotted #e5e7eb;"
+  };
+  return `<hr style="${styles2[style] || styles2.solid} margin: 24px 0; border-bottom: none; border-left: none; border-right: none;" />`;
+}
+function getAlignment(format) {
+  if (!format) return "left";
+  if (format & 2) return "center";
+  if (format & 3) return "right";
+  if (format & 4) return "justify";
+  return "left";
+}
+function escapeHtml(text) {
+  const map = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#039;"
+  };
+  return text.replace(/[&<>"']/g, (m) => map[m]);
+}
+function wrapInEmailTemplate(content, preheader) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Email</title>
+  <!--[if mso]>
+  <noscript>
+    <xml>
+      <o:OfficeDocumentSettings>
+        <o:PixelsPerInch>96</o:PixelsPerInch>
+      </o:OfficeDocumentSettings>
+    </xml>
+  </noscript>
+  <![endif]-->
+</head>
+<body style="margin: 0; padding: 0; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Arial, sans-serif; font-size: 16px; line-height: 1.5; color: #333333; background-color: #f3f4f6;">
+  ${preheader ? `<div style="display: none; max-height: 0; overflow: hidden;">${escapeHtml(preheader)}</div>` : ""}
+  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="margin: 0; padding: 0;">
+    <tr>
+      <td align="center" style="padding: 20px 0;">
+        <table role="presentation" cellpadding="0" cellspacing="0" width="600" style="margin: 0 auto; background-color: #ffffff; border-radius: 8px; overflow: hidden;">
+          <tr>
+            <td style="padding: 40px 30px;">
+              ${content}
+            </td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+  </table>
+</body>
+</html>`;
+}
+
+// src/collections/Broadcasts.ts
+var createBroadcastsCollection = (pluginConfig) => {
+  const hasProviders = !!(pluginConfig.providers?.broadcast || pluginConfig.providers?.resend);
+  const customizations = pluginConfig.customizations?.broadcasts;
+  return {
+    slug: "broadcasts",
+    labels: {
+      singular: "Broadcast",
+      plural: "Broadcasts"
+    },
+    admin: {
+      useAsTitle: "subject",
+      description: "Individual email campaigns sent to subscribers",
+      defaultColumns: ["subject", "status", "sentAt", "recipientCount", "actions"]
+    },
+    fields: [
+      {
+        name: "subject",
+        type: "text",
+        required: true,
+        admin: {
+          description: "Email subject line"
+        }
+      },
+      // Add any additional fields from customizations after subject
+      ...customizations?.additionalFields || [],
+      {
+        type: "row",
+        fields: [
+          {
+            name: "contentSection",
+            type: "group",
+            label: false,
+            admin: {
+              width: "50%",
+              style: {
+                paddingRight: "1rem"
+              }
+            },
+            fields: [
+              {
+                name: "preheader",
+                type: "text",
+                admin: {
+                  description: "Preview text shown in email clients"
+                }
+              },
+              // Apply content field customization if provided
+              // Process blocks server-side to avoid client serialization issues
+              (() => {
+                const emailEditor = createEmailLexicalEditor(customizations?.customBlocks);
+                const baseField = createEmailContentField({
+                  admin: { description: "Email content" },
+                  editor: emailEditor
+                });
+                return customizations?.fieldOverrides?.content ? customizations.fieldOverrides.content(baseField) : baseField;
+              })()
+            ]
+          },
+          {
+            name: "previewSection",
+            type: "group",
+            label: false,
+            admin: {
+              width: "50%"
+            },
+            fields: [
+              createBroadcastInlinePreviewField()
+            ]
+          }
+        ]
+      },
+      {
+        name: "status",
+        type: "select",
+        required: true,
+        defaultValue: "draft" /* DRAFT */,
+        options: [
+          { label: "Draft", value: "draft" /* DRAFT */ },
+          { label: "Scheduled", value: "scheduled" /* SCHEDULED */ },
+          { label: "Sending", value: "sending" /* SENDING */ },
+          { label: "Sent", value: "sent" /* SENT */ },
+          { label: "Failed", value: "failed" /* FAILED */ },
+          { label: "Paused", value: "paused" /* PAUSED */ },
+          { label: "Canceled", value: "canceled" /* CANCELED */ }
+        ],
+        admin: {
+          readOnly: true,
+          components: {
+            Cell: "payload-plugin-newsletter/components#StatusBadge"
+          }
+        }
+      },
+      {
+        name: "settings",
+        type: "group",
+        fields: [
+          {
+            name: "trackOpens",
+            type: "checkbox",
+            defaultValue: true,
+            admin: {
+              description: "Track when recipients open this email"
+            }
+          },
+          {
+            name: "trackClicks",
+            type: "checkbox",
+            defaultValue: true,
+            admin: {
+              description: "Track when recipients click links"
+            }
+          },
+          {
+            name: "replyTo",
+            type: "email",
+            admin: {
+              description: "Override the channel reply-to address for this broadcast"
+            }
+          }
+        ]
+      },
+      {
+        name: "audienceIds",
+        type: "array",
+        fields: [
+          {
+            name: "audienceId",
+            type: "text",
+            required: true
+          }
+        ],
+        admin: {
+          description: "Target specific audience segments",
+          condition: () => {
+            return hasProviders;
+          }
+        }
+      },
+      {
+        name: "analytics",
+        type: "group",
+        admin: {
+          readOnly: true,
+          condition: (data) => data?.status === "sent" /* SENT */
+        },
+        fields: [
+          {
+            name: "recipientCount",
+            type: "number",
+            defaultValue: 0
+          },
+          {
+            name: "sent",
+            type: "number",
+            defaultValue: 0
+          },
+          {
+            name: "delivered",
+            type: "number",
+            defaultValue: 0
+          },
+          {
+            name: "opened",
+            type: "number",
+            defaultValue: 0
+          },
+          {
+            name: "clicked",
+            type: "number",
+            defaultValue: 0
+          },
+          {
+            name: "bounced",
+            type: "number",
+            defaultValue: 0
+          },
+          {
+            name: "complained",
+            type: "number",
+            defaultValue: 0
+          },
+          {
+            name: "unsubscribed",
+            type: "number",
+            defaultValue: 0
+          }
+        ]
+      },
+      {
+        name: "sentAt",
+        type: "date",
+        admin: {
+          readOnly: true,
+          date: {
+            displayFormat: "MMM d, yyyy h:mm a"
+          }
+        }
+      },
+      {
+        name: "scheduledAt",
+        type: "date",
+        admin: {
+          condition: (data) => data?.status === "scheduled" /* SCHEDULED */,
+          date: {
+            displayFormat: "MMM d, yyyy h:mm a"
+          }
+        }
+      },
+      {
+        name: "providerId",
+        type: "text",
+        admin: {
+          readOnly: true,
+          description: "ID from the email provider",
+          condition: (data) => hasProviders && data?.providerId
+        }
+      },
+      {
+        name: "providerData",
+        type: "json",
+        admin: {
+          readOnly: true,
+          condition: () => false
+          // Hidden by default
+        }
+      },
+      // UI Field for custom actions in list view
+      {
+        name: "actions",
+        type: "ui",
+        admin: {
+          components: {
+            Cell: "payload-plugin-newsletter/components#ActionsCell",
+            Field: "payload-plugin-newsletter/components#EmptyField"
+          },
+          disableListColumn: false
+        }
+      }
+    ],
+    hooks: {
+      // Sync with provider on create
+      afterChange: [
+        async ({ doc, operation, req }) => {
+          if (!hasProviders || operation !== "create") return doc;
+          try {
+            const providerConfig = pluginConfig.providers?.broadcast;
+            if (!providerConfig) {
+              req.payload.logger.error("Broadcast provider not configured");
+              return doc;
+            }
+            const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+            const provider = new BroadcastApiProvider2(providerConfig);
+            const htmlContent = await convertToEmailSafeHtml(doc.contentSection?.content);
+            const providerBroadcast = await provider.create({
+              name: doc.subject,
+              // Use subject as name since we removed the name field
+              subject: doc.subject,
+              preheader: doc.contentSection?.preheader,
+              content: htmlContent,
+              trackOpens: doc.settings?.trackOpens,
+              trackClicks: doc.settings?.trackClicks,
+              replyTo: doc.settings?.replyTo || providerConfig.replyTo,
+              audienceIds: doc.audienceIds?.map((a) => a.audienceId)
+            });
+            await req.payload.update({
+              collection: "broadcasts",
+              id: doc.id,
+              data: {
+                providerId: providerBroadcast.id,
+                providerData: providerBroadcast.providerData
+              },
+              req
+            });
+            return {
+              ...doc,
+              providerId: providerBroadcast.id,
+              providerData: providerBroadcast.providerData
+            };
+          } catch (error) {
+            req.payload.logger.error("Failed to create broadcast in provider:", error);
+            return doc;
+          }
+        }
+      ],
+      // Sync updates with provider
+      beforeChange: [
+        async ({ data, originalDoc, operation, req }) => {
+          if (!hasProviders || !originalDoc?.providerId || operation !== "update") return data;
+          try {
+            const providerConfig = pluginConfig.providers?.broadcast;
+            if (!providerConfig) {
+              req.payload.logger.error("Broadcast provider not configured");
+              return data;
+            }
+            const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+            const provider = new BroadcastApiProvider2(providerConfig);
+            const capabilities = provider.getCapabilities();
+            if (!capabilities.editableStatuses.includes(originalDoc.status)) {
+              return data;
+            }
+            const updates = {};
+            if (data.subject !== originalDoc.subject) {
+              updates.name = data.subject;
+              updates.subject = data.subject;
+            }
+            if (data.contentSection?.preheader !== originalDoc.contentSection?.preheader) updates.preheader = data.contentSection?.preheader;
+            if (data.contentSection?.content !== originalDoc.contentSection?.content) {
+              updates.content = await convertToEmailSafeHtml(data.contentSection?.content);
+            }
+            if (data.settings?.trackOpens !== originalDoc.settings?.trackOpens) {
+              updates.trackOpens = data.settings.trackOpens;
+            }
+            if (data.settings?.trackClicks !== originalDoc.settings?.trackClicks) {
+              updates.trackClicks = data.settings.trackClicks;
+            }
+            if (data.settings?.replyTo !== originalDoc.settings?.replyTo) {
+              updates.replyTo = data.settings.replyTo || providerConfig.replyTo;
+            }
+            if (JSON.stringify(data.audienceIds) !== JSON.stringify(originalDoc.audienceIds)) {
+              updates.audienceIds = data.audienceIds?.map((a) => a.audienceId);
+            }
+            if (Object.keys(updates).length > 0) {
+              await provider.update(originalDoc.providerId, updates);
+            }
+          } catch (error) {
+            req.payload.logger.error("Failed to update broadcast in provider:", error);
+          }
+          return data;
+        }
+      ],
+      // Handle deletion
+      afterDelete: [
+        async ({ doc, req }) => {
+          if (!hasProviders || !doc?.providerId) return doc;
+          try {
+            const providerConfig = pluginConfig.providers?.broadcast;
+            if (!providerConfig) {
+              req.payload.logger.error("Broadcast provider not configured");
+              return doc;
+            }
+            const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+            const provider = new BroadcastApiProvider2(providerConfig);
+            const capabilities = provider.getCapabilities();
+            if (capabilities.editableStatuses.includes(doc.status)) {
+              await provider.delete(doc.providerId);
+            }
+          } catch (error) {
+            req.payload.logger.error("Failed to delete broadcast from provider:", error);
+          }
+          return doc;
+        }
+      ]
+    }
+  };
+};
+
+// src/utils/access.ts
+var isAdmin = (user, config) => {
+  if (!user || user.collection !== "users") {
+    return false;
+  }
+  if (config?.access?.isAdmin) {
+    return config.access.isAdmin(user);
+  }
+  if (user.roles?.includes("admin")) {
+    return true;
+  }
+  if (user.isAdmin === true) {
+    return true;
+  }
+  if (user.role === "admin") {
+    return true;
+  }
+  if (user.admin === true) {
+    return true;
+  }
+  return false;
+};
+var adminOnly = (config) => ({ req }) => {
+  const user = req.user;
+  return isAdmin(user, config);
+};
+var adminOrSelf = (config) => ({ req, id }) => {
+  const user = req.user;
+  if (!user) {
+    if (!id) {
+      return {
+        id: {
+          equals: "unauthorized-no-access"
+        }
+      };
+    }
+    return false;
+  }
+  if (isAdmin(user, config)) {
+    return true;
+  }
+  if (user.collection === "subscribers") {
+    if (!id) {
+      return {
+        id: {
+          equals: user.id
+        }
+      };
+    }
+    return id === user.id;
+  }
+  if (!id) {
+    return {
+      id: {
+        equals: "unauthorized-no-access"
+      }
+    };
+  }
+  return false;
+};
+
+// src/emails/render.tsx
+var import_render = require("@react-email/render");
+
+// src/emails/MagicLink.tsx
+var import_components = require("@react-email/components");
+
+// src/emails/styles.ts
+var styles = {
+  main: {
+    backgroundColor: "#f6f9fc",
+    fontFamily: '-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Ubuntu,sans-serif'
+  },
+  container: {
+    backgroundColor: "#ffffff",
+    border: "1px solid #f0f0f0",
+    borderRadius: "5px",
+    margin: "0 auto",
+    padding: "45px",
+    marginBottom: "64px",
+    maxWidth: "500px"
+  },
+  heading: {
+    fontSize: "24px",
+    letterSpacing: "-0.5px",
+    lineHeight: "1.3",
+    fontWeight: "600",
+    color: "#484848",
+    margin: "0 0 20px",
+    padding: "0"
+  },
+  text: {
+    fontSize: "16px",
+    lineHeight: "26px",
+    fontWeight: "400",
+    color: "#484848",
+    margin: "16px 0"
+  },
+  button: {
+    backgroundColor: "#000000",
+    borderRadius: "5px",
+    color: "#fff",
+    fontSize: "16px",
+    fontWeight: "bold",
+    textDecoration: "none",
+    textAlign: "center",
+    display: "block",
+    width: "100%",
+    padding: "14px 20px",
+    margin: "30px 0"
+  },
+  link: {
+    color: "#2754C5",
+    fontSize: "14px",
+    textDecoration: "underline",
+    wordBreak: "break-all"
+  },
+  hr: {
+    borderColor: "#e6ebf1",
+    margin: "30px 0"
+  },
+  footer: {
+    fontSize: "14px",
+    lineHeight: "24px",
+    color: "#9ca2ac",
+    textAlign: "center",
+    margin: "0"
+  },
+  code: {
+    display: "inline-block",
+    padding: "16px",
+    width: "100%",
+    backgroundColor: "#f4f4f4",
+    borderRadius: "5px",
+    border: "1px solid #eee",
+    fontSize: "14px",
+    fontFamily: "monospace",
+    textAlign: "center",
+    margin: "24px 0"
+  }
+};
+
+// src/emails/MagicLink.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var MagicLinkEmail = ({
+  magicLink,
+  email,
+  siteName = "Newsletter",
+  expiresIn = "24 hours"
+}) => {
+  const previewText = `Sign in to ${siteName}`;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_components.Html, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_components.Head, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_components.Preview, { children: previewText }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_components.Body, { style: styles.main, children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_components.Container, { style: styles.container, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_components.Text, { style: styles.heading, children: [
+        "Sign in to ",
+        siteName
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_components.Text, { style: styles.text, children: [
+        "Hi ",
+        email.split("@")[0],
+        ","
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_components.Text, { style: styles.text, children: [
+        "We received a request to sign in to your ",
+        siteName,
+        " account. Click the button below to complete your sign in:"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_components.Button, { href: magicLink, style: styles.button, children: [
+        "Sign in to ",
+        siteName
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_components.Text, { style: styles.text, children: "Or copy and paste this URL into your browser:" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { style: styles.code, children: magicLink }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_components.Hr, { style: styles.hr }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_components.Text, { style: styles.footer, children: [
+        "This link will expire in ",
+        expiresIn,
+        ". If you didn't request this email, you can safely ignore it."
+      ] })
+    ] }) })
+  ] });
+};
+
+// src/emails/Welcome.tsx
+var import_components2 = require("@react-email/components");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var WelcomeEmail = ({
+  email,
+  siteName = "Newsletter",
+  preferencesUrl
+}) => {
+  const previewText = `Welcome to ${siteName}!`;
+  const firstName = email.split("@")[0];
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_components2.Html, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_components2.Head, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_components2.Preview, { children: previewText }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_components2.Body, { style: styles.main, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_components2.Container, { style: styles.container, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_components2.Text, { style: styles.heading, children: [
+        "Welcome to ",
+        siteName,
+        "! \u{1F389}"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_components2.Text, { style: styles.text, children: [
+        "Hi ",
+        firstName,
+        ","
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_components2.Text, { style: styles.text, children: [
+        "Thanks for subscribing to ",
+        siteName,
+        "! We're excited to have you as part of our community."
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_components2.Text, { style: styles.text, children: "You'll receive our newsletter based on your preferences. Speaking of which, you can update your preferences anytime:" }),
+      preferencesUrl && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_components2.Button, { href: preferencesUrl, style: styles.button, children: "Manage Preferences" }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_components2.Text, { style: styles.text, children: "Here's what you can expect from us:" }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_components2.Text, { style: styles.text, children: [
+        "\u2022 Regular updates based on your chosen frequency",
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("br", {}),
+        "\u2022 Content tailored to your interests",
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("br", {}),
+        "\u2022 Easy unsubscribe options in every email",
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("br", {}),
+        "\u2022 Your privacy respected always"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_components2.Hr, { style: styles.hr }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_components2.Text, { style: styles.footer, children: "If you have any questions, feel free to reply to this email. We're here to help!" })
+    ] }) })
+  ] });
+};
+
+// src/emails/SignIn.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var SignInEmail = (props) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(MagicLinkEmail, { ...props });
+};
+
+// src/emails/render.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+async function renderEmail(template, data, config) {
+  try {
+    if (config?.customTemplates) {
+      const customTemplate = config.customTemplates[template];
+      if (customTemplate) {
+        const CustomComponent = customTemplate;
+        return (0, import_render.render)(/* @__PURE__ */ (0, import_jsx_runtime4.jsx)(CustomComponent, { ...data }));
+      }
+    }
+    switch (template) {
+      case "magic-link": {
+        const magicLinkData = data;
+        return (0, import_render.render)(
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            MagicLinkEmail,
+            {
+              magicLink: magicLinkData.magicLink || magicLinkData.verificationUrl || magicLinkData.magicLinkUrl || "",
+              email: magicLinkData.email || "",
+              siteName: magicLinkData.siteName,
+              expiresIn: magicLinkData.expiresIn
+            }
+          )
+        );
+      }
+      case "signin": {
+        const signinData = data;
+        return (0, import_render.render)(
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            SignInEmail,
+            {
+              magicLink: signinData.magicLink || signinData.verificationUrl || signinData.magicLinkUrl || "",
+              email: signinData.email || "",
+              siteName: signinData.siteName,
+              expiresIn: signinData.expiresIn
+            }
+          )
+        );
+      }
+      case "welcome": {
+        const welcomeData = data;
+        return (0, import_render.render)(
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            WelcomeEmail,
+            {
+              email: welcomeData.email || "",
+              siteName: welcomeData.siteName,
+              preferencesUrl: welcomeData.preferencesUrl
+            }
+          )
+        );
+      }
+      default:
+        throw new Error(`Unknown email template: ${template}`);
+    }
+  } catch (error) {
+    console.error(`Failed to render email template ${template}:`, error);
+    throw error;
+  }
+}
+
+// src/collections/Subscribers.ts
+var createSubscribersCollection = (pluginConfig) => {
+  const slug = pluginConfig.subscribersSlug || "subscribers";
+  const defaultFields = [
+    // Core fields
+    {
+      name: "email",
+      type: "email",
+      required: true,
+      unique: true,
+      admin: {
+        description: "Subscriber email address"
+      }
+    },
+    {
+      name: "name",
+      type: "text",
+      admin: {
+        description: "Subscriber full name"
+      }
+    },
+    {
+      name: "locale",
+      type: "select",
+      options: pluginConfig.i18n?.locales?.map((locale) => ({
+        label: locale.toUpperCase(),
+        value: locale
+      })) || [
+        { label: "EN", value: "en" }
+      ],
+      defaultValue: pluginConfig.i18n?.defaultLocale || "en",
+      admin: {
+        description: "Preferred language for communications"
+      }
+    },
+    // Authentication fields (hidden from admin UI)
+    {
+      name: "magicLinkToken",
+      type: "text",
+      hidden: true
+    },
+    {
+      name: "magicLinkTokenExpiry",
+      type: "date",
+      hidden: true
+    },
+    // Subscription status
+    {
+      name: "subscriptionStatus",
+      type: "select",
+      options: [
+        { label: "Active", value: "active" },
+        { label: "Unsubscribed", value: "unsubscribed" },
+        { label: "Pending", value: "pending" }
+      ],
+      defaultValue: "pending",
+      required: true,
+      admin: {
+        description: "Current subscription status"
+      }
+    },
+    {
+      name: "unsubscribedAt",
+      type: "date",
+      admin: {
+        condition: (data) => data?.subscriptionStatus === "unsubscribed",
+        description: "When the user unsubscribed",
+        readOnly: true
+      }
+    },
+    // Email preferences
+    {
+      name: "emailPreferences",
+      type: "group",
+      fields: [
+        {
+          name: "newsletter",
+          type: "checkbox",
+          defaultValue: true,
+          label: "Newsletter",
+          admin: {
+            description: "Receive regular newsletter updates"
+          }
+        },
+        {
+          name: "announcements",
+          type: "checkbox",
+          defaultValue: true,
+          label: "Announcements",
+          admin: {
+            description: "Receive important announcements"
+          }
+        }
+      ],
+      admin: {
+        description: "Email communication preferences"
+      }
+    },
+    // Source tracking
+    {
+      name: "source",
+      type: "text",
+      admin: {
+        description: "Where the subscriber signed up from"
+      }
+    }
+  ];
+  if (pluginConfig.features?.utmTracking?.enabled) {
+    const utmFields = pluginConfig.features.utmTracking.fields || [
+      "source",
+      "medium",
+      "campaign",
+      "content",
+      "term"
+    ];
+    defaultFields.push({
+      name: "utmParameters",
+      type: "group",
+      fields: utmFields.map((field) => ({
+        name: field,
+        type: "text",
+        admin: {
+          description: `UTM ${field} parameter`
+        }
+      })),
+      admin: {
+        description: "UTM tracking parameters"
+      }
+    });
+  }
+  defaultFields.push({
+    name: "signupMetadata",
+    type: "group",
+    fields: [
+      {
+        name: "ipAddress",
+        type: "text",
+        admin: {
+          readOnly: true
+        }
+      },
+      {
+        name: "userAgent",
+        type: "text",
+        admin: {
+          readOnly: true
+        }
+      },
+      {
+        name: "referrer",
+        type: "text",
+        admin: {
+          readOnly: true
+        }
+      },
+      {
+        name: "signupPage",
+        type: "text",
+        admin: {
+          readOnly: true
+        }
+      }
+    ],
+    admin: {
+      description: "Technical information about signup"
+    }
+  });
+  if (pluginConfig.features?.leadMagnets?.enabled) {
+    defaultFields.push({
+      name: "leadMagnet",
+      type: "relationship",
+      relationTo: pluginConfig.features.leadMagnets.collection || "media",
+      admin: {
+        description: "Lead magnet downloaded at signup"
+      }
+    });
+  }
+  let fields = defaultFields;
+  if (pluginConfig.fields?.overrides) {
+    fields = pluginConfig.fields.overrides({ defaultFields });
+  }
+  if (pluginConfig.fields?.additional) {
+    fields = [...fields, ...pluginConfig.fields.additional];
+  }
+  const subscribersCollection = {
+    slug,
+    labels: {
+      singular: "Subscriber",
+      plural: "Subscribers"
+    },
+    admin: {
+      useAsTitle: "email",
+      defaultColumns: ["email", "name", "subscriptionStatus", "createdAt"],
+      group: "Newsletter"
+    },
+    fields,
+    hooks: {
+      afterChange: [
+        async ({ doc, req, operation, previousDoc }) => {
+          if (operation === "create") {
+            const emailService = req.payload.newsletterEmailService;
+            console.log("[Newsletter Plugin] Creating subscriber:", {
+              email: doc.email,
+              hasEmailService: !!emailService
+            });
+            if (emailService) {
+              try {
+                await emailService.addContact(doc);
+                console.log("[Newsletter Plugin] Successfully added contact to email service");
+              } catch (error) {
+                console.error("[Newsletter Plugin] Failed to add contact to email service:", error);
+              }
+            } else {
+              console.warn("[Newsletter Plugin] No email service configured for subscriber creation");
+            }
+            if (doc.subscriptionStatus === "active" && emailService) {
+              try {
+                const settings = await req.payload.findGlobal({
+                  slug: pluginConfig.settingsSlug || "newsletter-settings"
+                });
+                const serverURL = req.payload.config.serverURL || process.env.PAYLOAD_PUBLIC_SERVER_URL || "";
+                const html = await renderEmail("welcome", {
+                  email: doc.email,
+                  siteName: settings?.brandSettings?.siteName || "Newsletter",
+                  preferencesUrl: `${serverURL}/account/preferences`
+                  // This could be customized
+                }, pluginConfig);
+                await emailService.send({
+                  to: doc.email,
+                  subject: settings?.brandSettings?.siteName ? `Welcome to ${settings.brandSettings.siteName}!` : "Welcome!",
+                  html
+                });
+                console.warn(`Welcome email sent to: ${doc.email}`);
+              } catch (error) {
+                console.error("Failed to send welcome email:", error);
+              }
+            }
+            if (pluginConfig.hooks?.afterSubscribe) {
+              await pluginConfig.hooks.afterSubscribe({ doc, req });
+            }
+          }
+          if (operation === "update" && previousDoc) {
+            const emailService = req.payload.newsletterEmailService;
+            if (doc.subscriptionStatus !== previousDoc.subscriptionStatus) {
+              console.log("[Newsletter Plugin] Subscription status changed:", {
+                email: doc.email,
+                from: previousDoc.subscriptionStatus,
+                to: doc.subscriptionStatus,
+                hasEmailService: !!emailService
+              });
+              if (emailService) {
+                try {
+                  await emailService.updateContact(doc);
+                  console.log("[Newsletter Plugin] Successfully updated contact in email service");
+                } catch (error) {
+                  console.error("[Newsletter Plugin] Failed to update contact in email service:", error);
+                }
+              } else {
+                console.warn("[Newsletter Plugin] No email service configured");
+              }
+            }
+            if (doc.subscriptionStatus === "unsubscribed" && previousDoc.subscriptionStatus !== "unsubscribed") {
+              doc.unsubscribedAt = (/* @__PURE__ */ new Date()).toISOString();
+              if (pluginConfig.hooks?.afterUnsubscribe) {
+                await pluginConfig.hooks.afterUnsubscribe({ doc, req });
+              }
+            }
+          }
+        }
+      ],
+      beforeDelete: [
+        async ({ id, req }) => {
+          const emailService = req.payload.newsletterEmailService;
+          if (emailService) {
+            try {
+              const doc = await req.payload.findByID({
+                collection: slug,
+                id
+              });
+              await emailService.removeContact(doc.email);
+            } catch {
+            }
+          }
+        }
+      ]
+    },
+    access: {
+      create: () => true,
+      // Public can subscribe
+      read: adminOrSelf(pluginConfig),
+      update: adminOrSelf(pluginConfig),
+      delete: adminOnly(pluginConfig)
+    },
+    timestamps: true
+  };
+  return subscribersCollection;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBroadcastsCollection,
+  createSubscribersCollection
+});
+//# sourceMappingURL=collections.cjs.map