payload-plugin-newsletter 0.25.11 → 0.25.12

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.25.12] - 2026-01-02
+
+### Added
+- New exported utilities for external preview generation:
+  - `generateBroadcastPreviewHtml()` - Generate preview HTML from broadcast content
+  - `populateMediaFields()` - Resolve Media IDs to full media objects with URLs
+  - `convertToEmailSafeHtml()` - Convert Lexical content to email-safe HTML
+  - `PreviewOptions` and `PreviewResult` types for TypeScript support
+- Extracted media population logic to `src/utils/mediaPopulation.ts` for cleaner code organization
+- Created `src/utils/preview.ts` with high-level preview generation utility
+
+### Changed
+- Refactored `src/endpoints/broadcasts/preview.ts` to use new utility files
+- Improved TypeScript types for media population functions
+
 ## [0.25.11] - 2025-12-11
 
 ### Fixed

package/dist/collections.cjs

@@ -1758,25 +1758,28 @@ var createTestBroadcastEndpoint = (config, collectionSlug) => {
   };
 };
 
-// src/endpoints/broadcasts/preview.ts
+// src/utils/mediaPopulation.ts
 async function populateMediaFields(content, payload, config) {
   if (!content || typeof content !== "object") return content;
-  if (content.root?.children) {
-    for (const child of content.root.children) {
+  const typedContent = content;
+  if (typedContent.root?.children) {
+    for (const child of typedContent.root.children) {
       await populateBlockMediaFields(child, payload, config);
     }
   }
   return content;
 }
 async function populateBlockMediaFields(node, payload, config) {
-  if (node.type === "block" && node.fields) {
-    const blockType = node.fields.blockType || node.fields.blockName;
+  if (!node || typeof node !== "object") return;
+  const typedNode = node;
+  if (typedNode.type === "block" && typedNode.fields) {
+    const blockType = typedNode.fields.blockType || typedNode.fields.blockName;
     const customBlocks = config.customizations?.broadcasts?.customBlocks || [];
     const blockConfig = customBlocks.find((b) => b.slug === blockType);
     if (blockConfig && blockConfig.fields) {
       for (const field of blockConfig.fields) {
-        if (field.type === "upload" && field.relationTo && node.fields[field.name]) {
-          const fieldValue = node.fields[field.name];
+        if (field.type === "upload" && field.relationTo && typedNode.fields[field.name]) {
+          const fieldValue = typedNode.fields[field.name];
           const collectionName = Array.isArray(field.relationTo) ? field.relationTo[0] : field.relationTo;
           if (typeof fieldValue === "string" && fieldValue.match(/^[a-f0-9]{24}$/i)) {
             try {
@@ -1786,26 +1789,33 @@ async function populateBlockMediaFields(node, payload, config) {
                 depth: 0
               });
               if (media) {
-                node.fields[field.name] = media;
-                payload.logger?.info({
-                  mediaId: fieldValue,
-                  mediaUrl: media.url,
-                  filename: media.filename
-                }, `Populated ${field.name} for block ${blockType}`);
+                typedNode.fields[field.name] = media;
+                payload.logger?.info(
+                  {
+                    mediaId: fieldValue,
+                    mediaUrl: media.url,
+                    filename: media.filename
+                  },
+                  `Populated ${field.name} for block ${blockType}`
+                );
               }
             } catch (error) {
-              payload.logger?.error({ error: String(error) }, `Failed to populate ${field.name} for block ${blockType}`);
+              payload.logger?.error(
+                { error: String(error) },
+                `Failed to populate ${field.name} for block ${blockType}`
+              );
             }
           }
         }
         if (field.type === "array" && field.fields) {
-          const arrayValue = node.fields[field.name];
+          const arrayValue = typedNode.fields[field.name];
           if (Array.isArray(arrayValue)) {
             for (const arrayItem of arrayValue) {
               if (arrayItem && typeof arrayItem === "object") {
+                const typedArrayItem = arrayItem;
                 for (const arrayField of field.fields) {
-                  if (arrayField.type === "upload" && arrayField.relationTo && arrayItem[arrayField.name]) {
-                    const arrayFieldValue = arrayItem[arrayField.name];
+                  if (arrayField.type === "upload" && arrayField.relationTo && typedArrayItem[arrayField.name]) {
+                    const arrayFieldValue = typedArrayItem[arrayField.name];
                     const arrayCollectionName = Array.isArray(arrayField.relationTo) ? arrayField.relationTo[0] : arrayField.relationTo;
                     if (typeof arrayFieldValue === "string" && arrayFieldValue.match(/^[a-f0-9]{24}$/i)) {
                       try {
@@ -1815,15 +1825,21 @@ async function populateBlockMediaFields(node, payload, config) {
                           depth: 0
                         });
                         if (media) {
-                          arrayItem[arrayField.name] = media;
-                          payload.logger?.info({
-                            mediaId: arrayFieldValue,
-                            mediaUrl: media.url,
-                            filename: media.filename
-                          }, `Populated array ${arrayField.name} for block ${blockType}`);
+                          typedArrayItem[arrayField.name] = media;
+                          payload.logger?.info(
+                            {
+                              mediaId: arrayFieldValue,
+                              mediaUrl: media.url,
+                              filename: media.filename
+                            },
+                            `Populated array ${arrayField.name} for block ${blockType}`
+                          );
                         }
                       } catch (error) {
-                        payload.logger?.error({ error: String(error) }, `Failed to populate array ${arrayField.name} for block ${blockType}`);
+                        payload.logger?.error(
+                          { error: String(error) },
+                          `Failed to populate array ${arrayField.name} for block ${blockType}`
+                        );
                       }
                     }
                   }
@@ -1832,23 +1848,24 @@ async function populateBlockMediaFields(node, payload, config) {
             }
           }
         }
-        if (field.type === "richText" && node.fields[field.name]) {
-          await populateRichTextUploads(node.fields[field.name], payload);
+        if (field.type === "richText" && typedNode.fields[field.name]) {
+          await populateRichTextUploads(typedNode.fields[field.name], payload);
           payload.logger?.info(`Processed rich text field ${field.name} for upload nodes`);
         }
       }
     }
   }
-  if (node.children) {
-    for (const child of node.children) {
+  if (typedNode.children) {
+    for (const child of typedNode.children) {
       await populateBlockMediaFields(child, payload, config);
     }
   }
 }
 async function populateRichTextUploads(content, payload) {
   if (!content || typeof content !== "object") return;
-  if (content.root?.children) {
-    await processNodeArray(content.root.children);
+  const typedContent = content;
+  if (typedContent.root?.children) {
+    await processNodeArray(typedContent.root.children);
   }
   if (Array.isArray(content)) {
     await processNodeArray(content);
@@ -1858,33 +1875,42 @@ async function populateRichTextUploads(content, payload) {
   }
   async function processNode(node) {
     if (!node || typeof node !== "object") return;
-    if (node.type === "upload" && node.relationTo === "media" && typeof node.value === "string" && node.value.match(/^[a-f0-9]{24}$/i)) {
+    const typedNode = node;
+    if (typedNode.type === "upload" && typedNode.relationTo === "media" && typeof typedNode.value === "string" && typedNode.value.match(/^[a-f0-9]{24}$/i)) {
       try {
         const media = await payload.findByID({
           collection: "media",
-          id: node.value,
+          id: typedNode.value,
           depth: 0
         });
         if (media) {
-          node.value = media;
-          payload.logger?.info({
-            mediaId: node.value,
-            mediaUrl: media.url,
-            filename: media.filename
-          }, "Populated rich text upload node");
+          typedNode.value = media;
+          payload.logger?.info(
+            {
+              mediaId: typedNode.value,
+              mediaUrl: media.url,
+              filename: media.filename
+            },
+            "Populated rich text upload node"
+          );
         }
       } catch (error) {
-        payload.logger?.error({ error: String(error) }, `Failed to populate rich text upload ${node.value}`);
+        payload.logger?.error(
+          { error: String(error) },
+          `Failed to populate rich text upload ${typedNode.value}`
+        );
       }
     }
-    if (node.children && Array.isArray(node.children)) {
-      await processNodeArray(node.children);
+    if (typedNode.children && Array.isArray(typedNode.children)) {
+      await processNodeArray(typedNode.children);
     }
-    if (node.root?.children && Array.isArray(node.root.children)) {
-      await processNodeArray(node.root.children);
+    if (typedNode.root?.children && Array.isArray(typedNode.root.children)) {
+      await processNodeArray(typedNode.root.children);
     }
   }
 }
+
+// src/endpoints/broadcasts/preview.ts
 var createBroadcastPreviewEndpoint = (config, _collectionSlug) => {
   return {
     path: "/preview",