npm - @contentgrowth/content-emailing - Versions diffs - 0.4.1 → 0.5.0 - Mend

@contentgrowth/content-emailing 0.4.1 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/dist/backend/EmailService.cjs +728 -0
package/dist/backend/EmailService.cjs.map +1 -0
package/dist/backend/EmailService.js +694 -0
package/dist/backend/EmailService.js.map +1 -0
package/dist/backend/EmailingCacheDO.cjs +390 -0
package/dist/backend/EmailingCacheDO.cjs.map +1 -0
package/dist/backend/EmailingCacheDO.js +365 -0
package/dist/backend/EmailingCacheDO.js.map +1 -0
package/dist/backend/routes/index.cjs +992 -0
package/dist/backend/routes/index.cjs.map +1 -0
package/dist/backend/routes/index.js +956 -0
package/dist/backend/routes/index.js.map +1 -0
package/dist/cli.cjs +53 -0
package/dist/cli.cjs.map +1 -0
package/dist/cli.js +53 -0
package/dist/cli.js.map +1 -0
package/dist/common/index.cjs +267 -0
package/dist/common/index.cjs.map +1 -0
package/{src/common/htmlWrapper.js → dist/common/index.js} +75 -18
package/dist/common/index.js.map +1 -0
package/dist/index.cjs +1537 -0
package/dist/index.cjs.map +1 -0
package/dist/index.js +1488 -0
package/dist/index.js.map +1 -0
package/package.json +27 -12
package/examples/.env.example +0 -16
package/examples/README.md +0 -55
package/examples/mocks/MockD1.js +0 -311
package/examples/mocks/MockEmailSender.js +0 -64
package/examples/mocks/index.js +0 -5
package/examples/package-lock.json +0 -73
package/examples/package.json +0 -18
package/examples/portal/index.html +0 -919
package/examples/server.js +0 -314
package/release.sh +0 -56
package/src/backend/EmailService.js +0 -537
package/src/backend/EmailingCacheDO.js +0 -466
package/src/backend/routes/index.js +0 -30
package/src/backend/routes/templates.js +0 -98
package/src/backend/routes/tracking.js +0 -215
package/src/backend/routes.js +0 -98
package/src/common/index.js +0 -11
package/src/common/utils.js +0 -141
package/src/frontend/TemplateEditor.jsx +0 -117
package/src/frontend/TemplateManager.jsx +0 -117
package/src/index.js +0 -24

package/dist/index.cjs ADDED Viewed

@@ -0,0 +1,1537 @@
+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 __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/index.js
+var index_exports = {};
+__export(index_exports, {
+  EmailService: () => EmailService,
+  EmailingCacheDO: () => EmailingCacheDO,
+  TemplateEditor: () => TemplateEditor,
+  TemplateManager: () => TemplateManager,
+  createDOCacheProvider: () => createDOCacheProvider,
+  createEmailRoutes: () => createEmailRoutes,
+  createTemplateRoutes: () => createTemplateRoutes,
+  createTrackingRoutes: () => createTrackingRoutes,
+  encodeTrackingLinks: () => encodeTrackingLinks,
+  extractVariables: () => extractVariables,
+  getWebsiteUrl: () => getWebsiteUrl,
+  markdownToPlainText: () => markdownToPlainText,
+  resetWebsiteUrlCache: () => resetWebsiteUrlCache,
+  wrapInEmailTemplate: () => wrapInEmailTemplate
+});
+module.exports = __toCommonJS(index_exports);
+// src/backend/EmailService.js
+var import_marked = require("marked");
+var import_mustache = __toESM(require("mustache"), 1);
+// src/common/htmlWrapper.js
+function wrapInEmailTemplate(contentHtml, subject, data = {}) {
+  const portalUrl = data.portalUrl || "https://app.x0start.com";
+  const unsubscribeUrl = data.unsubscribeUrl || "{{unsubscribe_url}}";
+  const brandName = data.brandName || "X0 Start";
+  return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${subject}</title>
+  <style>
+    body {
+      margin: 0;
+      padding: 0;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+      background-color: #f5f5f5;
+      line-height: 1.6;
+    }
+    .email-wrapper {
+      background-color: #f5f5f5;
+      padding: 40px 20px;
+    }
+    .email-container {
+      max-width: 600px;
+      margin: 0 auto;
+      background-color: #ffffff;
+      border-radius: 8px;
+      overflow: hidden;
+      box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+    }
+    .email-header {
+      padding: 40px 40px 20px;
+      text-align: center;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: #ffffff;
+    }
+    .email-header h1 {
+      margin: 0;
+      font-size: 28px;
+      font-weight: 600;
+    }
+    .email-content {
+      padding: 30px 40px;
+      color: #333333;
+    }
+    .email-content h1 {
+      font-size: 24px;
+      margin-top: 0;
+      margin-bottom: 20px;
+      color: #333333;
+    }
+    .email-content h2 {
+      font-size: 20px;
+      margin-top: 30px;
+      margin-bottom: 15px;
+      color: #333333;
+    }
+    .email-content h3 {
+      font-size: 16px;
+      margin-top: 20px;
+      margin-bottom: 10px;
+      color: #333333;
+    }
+    .email-content p {
+      margin: 0 0 15px;
+      color: #666666;
+    }
+    .email-content a {
+      color: #667eea;
+      text-decoration: none;
+    }
+    .email-content ul, .email-content ol {
+      margin: 0 0 15px;
+      padding-left: 25px;
+    }
+    .email-content li {
+      margin-bottom: 8px;
+      color: #666666;
+    }
+    .email-content blockquote {
+      margin: 20px 0;
+      padding: 15px 20px;
+      background-color: #f8f9fa;
+      border-left: 4px solid #667eea;
+      color: #666666;
+    }
+    .email-content code {
+      padding: 2px 6px;
+      background-color: #f8f9fa;
+      border-radius: 3px;
+      font-family: 'Courier New', monospace;
+      font-size: 14px;
+    }
+    .email-content pre {
+      padding: 15px;
+      background-color: #f8f9fa;
+      border-radius: 6px;
+      overflow-x: auto;
+    }
+    .email-content pre code {
+      padding: 0;
+      background: none;
+    }
+    .btn {
+      display: inline-block;
+      padding: 12px 24px;
+      background-color: #667eea;
+      color: #ffffff !important;
+      text-decoration: none;
+      border-radius: 6px;
+      font-weight: 600;
+      margin: 10px 0;
+    }
+    .btn:hover {
+      background-color: #5568d3;
+    }
+    .email-footer {
+      padding: 20px 40px;
+      background-color: #f8f9fa;
+      text-align: center;
+      font-size: 12px;
+      color: #666666;
+    }
+    .email-footer a {
+      color: #667eea;
+      text-decoration: none;
+    }
+    hr {
+      border: none;
+      border-top: 1px solid #e0e0e0;
+      margin: 30px 0;
+    }
+  </style>
+</head>
+<body>
+  <div class="email-wrapper">
+    <div class="email-container">
+      <div class="email-content">
+        ${contentHtml}
+      </div>
+      <div class="email-footer">
+        <p style="margin: 0 0 10px;">
+          You're receiving this email from ${brandName}.
+        </p>
+        <p style="margin: 0;">
+          <a href="${unsubscribeUrl}">Unsubscribe</a> |
+          <a href="${portalUrl}/settings/notifications">Manage Preferences</a>
+        </p>
+      </div>
+    </div>
+  </div>
+</body>
+</html>
+  `.trim();
+}
+// src/backend/EmailingCacheDO.js
+var EmailingCacheDO = class {
+  constructor(state, env) {
+    this.state = state;
+    this.env = env;
+    this.cache = /* @__PURE__ */ new Map();
+    this.settingsCache = /* @__PURE__ */ new Map();
+    this.cacheTTL = 36e5;
+    this.emailTablePrefix = env.EMAIL_TABLE_PREFIX || "system_email_";
+    this.settingsTableName = env.EMAIL_SETTINGS_TABLE || "system_settings";
+    this.settingsKeyPrefix = env.EMAIL_SETTINGS_KEY_PREFIX || "";
+  }
+  /**
+   * Handle HTTP requests to this Durable Object
+   */
+  async fetch(request) {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    try {
+      if (path === "/get" && request.method === "GET") {
+        return this.handleGet(request);
+      } else if (path === "/invalidate" && request.method === "POST") {
+        return this.handleInvalidate(request);
+      } else if (path === "/clear" && request.method === "POST") {
+        return this.handleClear(request);
+      } else if (path === "/stats" && request.method === "GET") {
+        return this.handleStats(request);
+      } else if (path === "/settings/get" && request.method === "GET") {
+        return this.handleGetSettings(request);
+      } else if (path === "/settings/put" && request.method === "POST") {
+        return this.handlePutSettings(request);
+      } else if (path === "/settings/invalidate" && request.method === "POST") {
+        return this.handleInvalidateSettings(request);
+      } else {
+        return new Response("Not Found", { status: 404 });
+      }
+    } catch (error) {
+      console.error("[EmailingCacheDO] Error:", error);
+      return new Response(JSON.stringify({ error: error.message }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  }
+  /**
+   * Get template (from cache or D1)
+   */
+  async handleGet(request) {
+    const url = new URL(request.url);
+    const templateId = url.searchParams.get("templateId");
+    const forceRefresh = url.searchParams.get("refresh") === "true";
+    if (!templateId) {
+      return new Response(JSON.stringify({ error: "templateId is required" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (!forceRefresh) {
+      const cached = this.cache.get(templateId);
+      if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
+        console.log("[EmailingCacheDO] Cache HIT:", templateId);
+        return new Response(JSON.stringify({
+          template: cached.data,
+          cached: true,
+          age: Date.now() - cached.timestamp
+        }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    console.log("[EmailingCacheDO] Cache MISS - fetching from D1:", templateId);
+    const template = await this.fetchTemplateFromD1(templateId);
+    if (!template) {
+      return new Response(JSON.stringify({
+        error: "Template not found",
+        templateId
+      }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    this.cache.set(templateId, {
+      data: template,
+      timestamp: Date.now()
+    });
+    return new Response(JSON.stringify({
+      template,
+      cached: false
+    }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  // --- Settings Cache Handlers ---
+  async handleGetSettings(request) {
+    const url = new URL(request.url);
+    const key = url.searchParams.get("key");
+    if (!key) return new Response("Key required", { status: 400 });
+    const cached = this.settingsCache.get(key);
+    if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
+      console.log("[EmailingCacheDO] Settings Cache HIT:", key);
+      return new Response(JSON.stringify({ settings: cached.data }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (key.startsWith("system")) {
+      console.log("[EmailingCacheDO] Settings Cache MISS - fetching from D1:", key);
+      const settings = await this.fetchSettingsFromD1(key);
+      if (settings) {
+        this.settingsCache.set(key, {
+          data: settings,
+          timestamp: Date.now()
+        });
+        return new Response(JSON.stringify({ settings }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    return new Response(JSON.stringify({ settings: null }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  async handlePutSettings(request) {
+    try {
+      const body = await request.json();
+      const { key, settings } = body;
+      if (!key || !settings) return new Response("Key and settings required", { status: 400 });
+      this.settingsCache.set(key, {
+        data: settings,
+        timestamp: Date.now()
+      });
+      if (key.startsWith("system")) {
+        await this.saveSettingsToD1(settings);
+      }
+      return new Response(JSON.stringify({ success: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (e) {
+      console.error("[EmailingCacheDO] PutSettings error:", e);
+      return new Response("Error parsing body/saving", { status: 400 });
+    }
+  }
+  async handleInvalidateSettings(request) {
+    try {
+      const body = await request.json();
+      const { key } = body;
+      if (!key) return new Response("Key required", { status: 400 });
+      const existed = this.settingsCache.has(key);
+      this.settingsCache.delete(key);
+      console.log("[EmailingCacheDO] Invalidated settings:", key, existed ? "(existed)" : "(not in cache)");
+      return new Response(JSON.stringify({ success: true, existed }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (e) {
+      console.error("[EmailingCacheDO] InvalidateSettings error:", e);
+      return new Response("Error invalidated settings", { status: 400 });
+    }
+  }
+  /**
+   * Invalidate specific template(s) from cache
+   * Body: { templateId: 'template_id' } or { templateId: '*' } for all
+   */
+  async handleInvalidate(request) {
+    const body = await request.json();
+    const { templateId } = body;
+    if (!templateId) {
+      return new Response(JSON.stringify({ error: "templateId is required" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (templateId === "*") {
+      const count = this.cache.size;
+      this.cache.clear();
+      console.log("[EmailingCacheDO] Invalidated ALL templates:", count);
+      return new Response(JSON.stringify({
+        success: true,
+        message: `Invalidated ${count} templates`
+      }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const existed = this.cache.has(templateId);
+    this.cache.delete(templateId);
+    console.log("[EmailingCacheDO] Invalidated template:", templateId, existed ? "(existed)" : "(not in cache)");
+    return new Response(JSON.stringify({
+      success: true,
+      message: existed ? "Template invalidated" : "Template was not in cache",
+      templateId
+    }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Clear entire cache (admin operation)
+   */
+  async handleClear(request) {
+    const count = this.cache.size + this.settingsCache.size;
+    this.cache.clear();
+    this.settingsCache.clear();
+    console.log("[EmailingCacheDO] Cache cleared:", count, "entries (templates + settings)");
+    return new Response(JSON.stringify({
+      success: true,
+      message: `Cleared ${count} cached items`
+    }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Get cache statistics
+   */
+  async handleStats(request) {
+    const stats = {
+      templates: this.cache.size,
+      settings: this.settingsCache.size,
+      cacheTTL: this.cacheTTL
+    };
+    return new Response(JSON.stringify(stats), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Fetch template from D1
+   */
+  async fetchTemplateFromD1(templateId) {
+    const db = this.env.DB;
+    const tableName = `${this.emailTablePrefix}templates`;
+    try {
+      const template = await db.prepare(`SELECT * FROM ${tableName} WHERE template_id = ? AND is_active = 1`).bind(templateId).first();
+      return template;
+    } catch (e) {
+      console.error(`[EmailingCacheDO] DB Error (${tableName}):`, e);
+      return null;
+    }
+  }
+  /**
+   * Fetch settings from D1
+   * Only supports default table (e.g. system_settings) for now
+   */
+  async fetchSettingsFromD1(key) {
+    const db = this.env.DB;
+    const tableName = this.settingsTableName;
+    const prefix = this.settingsKeyPrefix;
+    try {
+      let results;
+      if (prefix) {
+        try {
+          results = await db.prepare(`SELECT * FROM ${tableName} WHERE setting_key LIKE ?`).bind(`${prefix}%`).all();
+        } catch (e) {
+          results = await db.prepare(`SELECT * FROM ${tableName} WHERE key LIKE ?`).bind(`${prefix}%`).all();
+        }
+      } else {
+        results = await db.prepare(`SELECT * FROM ${tableName}`).all();
+      }
+      if (!results.results || results.results.length === 0) return null;
+      const settings = {};
+      results.results.forEach((row) => {
+        const k = row.setting_key || row.key;
+        const v = row.setting_value || row.value;
+        if (k) settings[k] = v;
+      });
+      return settings;
+    } catch (e) {
+      console.warn(`[EmailingCacheDO] Failed to load settings from ${tableName}:`, e);
+      return null;
+    }
+  }
+  async saveSettingsToD1(settings) {
+    const db = this.env.DB;
+    const tableName = this.settingsTableName;
+    const entries = Object.entries(settings);
+    for (const [k, v] of entries) {
+      try {
+        try {
+          const res = await db.prepare(`UPDATE ${tableName} SET setting_value = ? WHERE setting_key = ?`).bind(v, k).run();
+          if (res.meta.changes === 0) {
+            await db.prepare(`INSERT INTO ${tableName} (setting_key, setting_value) VALUES (?, ?)`).bind(k, v).run();
+          }
+        } catch (e) {
+          await db.prepare(`INSERT OR REPLACE INTO ${tableName} (key, value) VALUES (?, ?)`).bind(k, v).run();
+        }
+      } catch (e) {
+        console.warn("[EmailingCacheDO] Failed to save setting to D1:", k);
+      }
+    }
+  }
+};
+function createDOCacheProvider(doStub, instanceName = "global") {
+  if (!doStub) {
+    return null;
+  }
+  const stub = doStub.get(doStub.idFromName(instanceName));
+  return {
+    async getTemplate(templateId) {
+      try {
+        const response = await stub.fetch(`http://do/get?templateId=${templateId}`);
+        const data = await response.json();
+        return data.template || null;
+      } catch (e) {
+        console.warn("[DOCacheProvider] Failed to get template:", e);
+        return null;
+      }
+    },
+    async getSettings(profile, tenantId) {
+      const key = `${profile}:${tenantId || ""}`;
+      try {
+        const response = await stub.fetch(`http://do/settings/get?key=${encodeURIComponent(key)}`);
+        const data = await response.json();
+        return data.settings || null;
+      } catch (e) {
+        return null;
+      }
+    },
+    async putSettings(profile, tenantId, settings) {
+      const key = `${profile}:${tenantId || ""}`;
+      try {
+        await stub.fetch("http://do/settings/put", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ key, settings })
+        });
+      } catch (e) {
+        console.warn("[DOCacheProvider] Failed to cache settings:", e);
+      }
+    },
+    async putTemplate(template) {
+      try {
+        await stub.fetch("http://do/invalidate", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ templateId: template.template_id })
+        });
+      } catch (e) {
+        console.warn("[DOCacheProvider] Failed to invalidate template:", e);
+      }
+    },
+    async deleteTemplate(templateId) {
+      try {
+        await stub.fetch("http://do/invalidate", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ templateId })
+        });
+      } catch (e) {
+        console.warn("[DOCacheProvider] Failed to invalidate template:", e);
+      }
+    },
+    async invalidateSettings(profile, tenantId) {
+      const key = `${profile}:${tenantId || ""}`;
+      try {
+        await stub.fetch("http://do/settings/invalidate", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ key })
+        });
+      } catch (e) {
+        console.warn("[DOCacheProvider] Failed to invalidate settings:", e);
+      }
+    }
+  };
+}
+// src/backend/EmailService.js
+var EmailService = class {
+  /**
+   * @param {Object} env - Cloudflare environment bindings (DB, etc.)
+   * @param {Object} config - Configuration options
+   * @param {string} [config.emailTablePrefix='system_email_'] - Prefix for D1 tables
+   * @param {Object} [config.defaults] - Default settings (fromName, fromAddress)
+   * @param {Object} [cacheProvider] - Optional cache interface (DO stub or KV wrapper)
+   */
+  constructor(env, config = {}, cacheProvider = null) {
+    var _a, _b, _c;
+    this.env = env;
+    this.db = env.DB;
+    this.config = {
+      emailTablePrefix: config.emailTablePrefix || config.tableNamePrefix || "system_email_",
+      defaults: config.defaults || {
+        fromName: "System",
+        fromAddress: "noreply@example.com",
+        provider: "mailchannels"
+      },
+      // Loader function to fetch settings from backend (DB, KV, etc.)
+      // Signature: async (profile, tenantId) => SettingsObject
+      settingsLoader: config.settingsLoader || null,
+      // Updater function to save settings to backend
+      // Signature: async (profile, tenantId, settings) => void
+      settingsUpdater: config.settingsUpdater || null,
+      // Branding configuration for email templates
+      branding: {
+        brandName: ((_a = config.branding) == null ? void 0 : _a.brandName) || "Your App",
+        portalUrl: ((_b = config.branding) == null ? void 0 : _b.portalUrl) || "https://app.example.com",
+        primaryColor: ((_c = config.branding) == null ? void 0 : _c.primaryColor) || "#667eea",
+        ...config.branding
+      },
+      ...config
+    };
+    if (!cacheProvider && env.EMAIL_TEMPLATE_CACHE) {
+      this.cache = createDOCacheProvider(env.EMAIL_TEMPLATE_CACHE);
+    } else {
+      this.cache = cacheProvider;
+    }
+  }
+  // --- Configuration & Settings ---
+  /**
+   * Load email configuration
+   * @param {string} profile - 'system' or 'tenant' (or custom profile string)
+   * @param {string} tenantId - Context ID (optional)
+   * @returns {Promise<Object>} Email configuration
+   */
+  async loadSettings(profile = "system", tenantId = null) {
+    if (this.cache && this.cache.getSettings) {
+      try {
+        const cached = await this.cache.getSettings(profile, tenantId);
+        if (cached) return this._normalizeConfig(cached);
+      } catch (e) {
+      }
+    }
+    let settings = null;
+    if (this.config.settingsLoader) {
+      try {
+        settings = await this.config.settingsLoader(profile, tenantId);
+      } catch (e) {
+        console.warn("[EmailService] settingsLoader failed:", e);
+      }
+    }
+    if (settings) {
+      if (this.cache && this.cache.putSettings) {
+        try {
+          this.cache.putSettings(profile, tenantId, settings);
+        } catch (e) {
+        }
+      }
+      return this._normalizeConfig(settings);
+    }
+    return {
+      ...this.config.defaults
+    };
+  }
+  /**
+   * Normalize config keys to standard format
+   * Handles both snake_case (DB) and camelCase inputs
+   */
+  _normalizeConfig(config) {
+    return {
+      provider: config.email_provider || config.provider || this.config.defaults.provider,
+      fromAddress: config.email_from_address || config.fromAddress || this.config.defaults.fromAddress,
+      fromName: config.email_from_name || config.fromName || this.config.defaults.fromName,
+      // Provider-specific settings (normalize DB keys to service keys)
+      sendgridApiKey: config.sendgrid_api_key || config.sendgridApiKey,
+      resendApiKey: config.resend_api_key || config.resendApiKey,
+      sendpulseClientId: config.sendpulse_client_id || config.sendpulseClientId,
+      sendpulseClientSecret: config.sendpulse_client_secret || config.sendpulseClientSecret,
+      // SMTP
+      smtpHost: config.smtp_host || config.smtpHost,
+      smtpPort: config.smtp_port || config.smtpPort,
+      smtpUsername: config.smtp_username || config.smtpUsername,
+      smtpPassword: config.smtp_password || config.smtpPassword,
+      // Tracking
+      trackingUrl: config.tracking_url || config.trackingUrl,
+      // Pass through others
+      // Pass through others
+      ...config,
+      smtpSecure: config.smtp_secure === "true"
+    };
+  }
+  // --- Template Management ---
+  async getTemplate(templateId) {
+    if (this.cache) {
+      try {
+        const cached = await this.cache.getTemplate(templateId);
+        if (cached) return cached;
+      } catch (e) {
+        console.warn("[EmailService] Template cache lookup failed:", e);
+      }
+    }
+    const table = `${this.config.emailTablePrefix}templates`;
+    return await this.db.prepare(`SELECT * FROM ${table} WHERE template_id = ?`).bind(templateId).first();
+  }
+  async getAllTemplates() {
+    const table = `${this.config.emailTablePrefix}templates`;
+    const result = await this.db.prepare(`SELECT * FROM ${table} ORDER BY template_name`).all();
+    return result.results || [];
+  }
+  /**
+   * Save email configuration
+   * @param {Object} settings - Config object
+   * @param {string} profile - 'system' or 'tenant'
+   * @param {string} tenantId - Context ID
+   */
+  async saveSettings(settings, profile = "system", tenantId = null) {
+    if (this.config.settingsUpdater) {
+      try {
+        await this.config.settingsUpdater(profile, tenantId, settings);
+      } catch (e) {
+        console.error("[EmailService] settingsUpdater failed:", e);
+        throw e;
+      }
+    } else if (profile === "system" && this.db) {
+    }
+    if (this.cache && this.cache.invalidateSettings) {
+      try {
+        await this.cache.invalidateSettings(profile, tenantId);
+      } catch (e) {
+        console.warn("[EmailService] Failed to invalidate settings cache:", e);
+      }
+    }
+  }
+  async saveTemplate(template, userId = "system") {
+    const table = `${this.config.emailTablePrefix}templates`;
+    const now = Math.floor(Date.now() / 1e3);
+    const existing = await this.getTemplate(template.template_id);
+    if (existing) {
+      await this.db.prepare(`
+        UPDATE ${table} SET
+          template_name = ?, template_type = ?, subject_template = ?,
+          body_markdown = ?, variables = ?, description = ?, is_active = ?,
+          updated_at = ?, updated_by = ?
+        WHERE template_id = ?
+      `).bind(
+        template.template_name,
+        template.template_type,
+        template.subject_template,
+        template.body_markdown,
+        template.variables,
+        template.description,
+        template.is_active,
+        now,
+        userId,
+        template.template_id
+      ).run();
+    } else {
+      await this.db.prepare(`
+        INSERT INTO ${table} (
+          template_id, template_name, template_type, subject_template,
+          body_markdown, variables, description, is_active, created_at, updated_at, updated_by
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).bind(
+        template.template_id,
+        template.template_name,
+        template.template_type,
+        template.subject_template,
+        template.body_markdown,
+        template.variables || "[]",
+        template.description,
+        template.is_active || 1,
+        now,
+        now,
+        userId
+      ).run();
+    }
+    if (this.cache) {
+      await this.cache.putTemplate(template);
+    }
+  }
+  async deleteTemplate(templateId) {
+    const table = `${this.config.emailTablePrefix}templates`;
+    await this.db.prepare(`DELETE FROM ${table} WHERE template_id = ?`).bind(templateId).run();
+    if (this.cache) {
+      await this.cache.deleteTemplate(templateId);
+    }
+  }
+  // --- Rendering ---
+  async renderTemplate(templateId, data) {
+    const template = await this.getTemplate(templateId);
+    if (!template) throw new Error(`Template not found: ${templateId}`);
+    const subject = import_mustache.default.render(template.subject_template, data);
+    const markdown = import_mustache.default.render(template.body_markdown, data);
+    import_marked.marked.use({ mangle: false, headerIds: false });
+    const htmlContent = import_marked.marked.parse(markdown);
+    const html = this.wrapInBaseTemplate(htmlContent, subject, data);
+    const plainText = markdown.replace(/<[^>]*>/g, "");
+    return { subject, html, plainText };
+  }
+  wrapInBaseTemplate(content, subject, data = {}) {
+    const templateData = {
+      ...data,
+      brandName: data.brandName || this.config.branding.brandName,
+      portalUrl: data.portalUrl || this.config.branding.portalUrl,
+      unsubscribeUrl: data.unsubscribeUrl || "{{unsubscribe_url}}"
+    };
+    return wrapInEmailTemplate(content, subject, templateData);
+  }
+  // --- Delivery ---
+  /**
+   * Send a single email
+   * @param {Object} params - Email parameters
+   * @param {string} params.to - Recipient email
+   * @param {string} params.subject - Email subject
+   * @param {string} params.html - HTML body
+   * @param {string} params.text - Plain text body
+   * @param {string} [params.provider] - Override provider
+   * @param {string} [params.profile='system'] - 'system' or 'tenant'
+   * @param {string} [params.tenantId] - Required if profile is 'tenant'
+   * @param {Object} [params.metadata] - Additional metadata
+   * @returns {Promise<Object>} Delivery result
+   */
+  async sendEmail({ to, subject, html, htmlBody, text, textBody, provider, profile = "system", tenantId = null, metadata = {} }) {
+    const htmlContent = html || htmlBody;
+    const textContent = text || textBody;
+    try {
+      const settings = await this.loadSettings(profile, tenantId);
+      const useProvider = provider || settings.provider || "mailchannels";
+      let result;
+      switch (useProvider) {
+        case "mailchannels":
+          result = await this.sendViaMailChannels(to, subject, htmlContent, textContent, settings, metadata);
+          break;
+        case "sendgrid":
+          result = await this.sendViaSendGrid(to, subject, htmlContent, textContent, settings, metadata);
+          break;
+        case "resend":
+          result = await this.sendViaResend(to, subject, htmlContent, textContent, settings, metadata);
+          break;
+        case "sendpulse":
+          result = await this.sendViaSendPulse(to, subject, htmlContent, textContent, settings, metadata);
+          break;
+        default:
+          console.error(`[EmailService] Unknown provider: ${useProvider}`);
+          return { success: false, error: `Unknown email provider: ${useProvider}` };
+      }
+      if (result) {
+        return { success: true, messageId: crypto.randomUUID() };
+      } else {
+        console.error("[EmailService] Failed to send email to:", to);
+        return { success: false, error: "Failed to send email" };
+      }
+    } catch (error) {
+      console.error("[EmailService] Error sending email:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Send multiple emails in batch
+   * @param {Array} emails - Array of email objects
+   * @returns {Promise<Array>} Array of delivery results
+   */
+  async sendBatch(emails) {
+    console.log("[EmailService] Sending batch of", emails.length, "emails");
+    const results = await Promise.all(
+      emails.map((email) => this.sendEmail(email))
+    );
+    return results;
+  }
+  /**
+   * Send email via MailChannels HTTP API
+   * MailChannels is specifically designed for Cloudflare Workers
+   */
+  async sendViaMailChannels(to, subject, html, text, settings, metadata) {
+    try {
+      const response = await fetch("https://api.mailchannels.net/tx/v1/send", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          personalizations: [{ to: [{ email: to, name: metadata.recipientName || "" }] }],
+          from: { email: settings.fromAddress, name: settings.fromName },
+          subject,
+          content: [
+            { type: "text/plain", value: text || html.replace(/<[^>]*>/g, "") },
+            { type: "text/html", value: html }
+          ]
+        })
+      });
+      if (response.status === 202) {
+        return true;
+      } else {
+        const contentType = response.headers.get("content-type");
+        const errorBody = (contentType == null ? void 0 : contentType.includes("application/json")) ? await response.json() : await response.text();
+        console.error("[EmailService] MailChannels error:", response.status, errorBody);
+        return false;
+      }
+    } catch (error) {
+      console.error("[EmailService] MailChannels exception:", error.message);
+      return false;
+    }
+  }
+  /**
+   * Send email via SendGrid HTTP API
+   */
+  async sendViaSendGrid(to, subject, html, text, settings, metadata) {
+    try {
+      if (!settings.sendgridApiKey) {
+        console.error("[EmailService] SendGrid API key missing");
+        return false;
+      }
+      const response = await fetch("https://api.sendgrid.com/v3/mail/send", {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${settings.sendgridApiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          personalizations: [{ to: [{ email: to, name: metadata.recipientName || "" }] }],
+          from: { email: settings.fromAddress, name: settings.fromName },
+          subject,
+          content: [
+            { type: "text/html", value: html },
+            { type: "text/plain", value: text || html.replace(/<[^>]*>/g, "") }
+          ]
+        })
+      });
+      if (response.status === 202) {
+        return true;
+      } else {
+        const errorText = await response.text();
+        console.error("[EmailService] SendGrid error:", response.status, errorText);
+        return false;
+      }
+    } catch (error) {
+      console.error("[EmailService] SendGrid exception:", error.message);
+      return false;
+    }
+  }
+  /**
+   * Send email via Resend HTTP API
+   */
+  async sendViaResend(to, subject, html, text, settings, metadata) {
+    try {
+      if (!settings.resendApiKey) {
+        console.error("[EmailService] Resend API key missing");
+        return false;
+      }
+      const response = await fetch("https://api.resend.com/emails", {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${settings.resendApiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          from: `${settings.fromName} <${settings.fromAddress}>`,
+          to: [to],
+          subject,
+          html,
+          text: text || html.replace(/<[^>]*>/g, "")
+        })
+      });
+      if (response.ok) {
+        return true;
+      } else {
+        const errorText = await response.text();
+        console.error("[EmailService] Resend error:", response.status, errorText);
+        return false;
+      }
+    } catch (error) {
+      console.error("[EmailService] Resend exception:", error.message);
+      return false;
+    }
+  }
+  /**
+   * Send email via SendPulse HTTP API
+   * SendPulse offers 15,000 free emails/month
+   */
+  async sendViaSendPulse(to, subject, html, text, settings, metadata) {
+    try {
+      if (!settings.sendpulseClientId || !settings.sendpulseClientSecret) {
+        console.error("[EmailService] SendPulse credentials missing");
+        return false;
+      }
+      const tokenParams = new URLSearchParams({
+        grant_type: "client_credentials",
+        client_id: settings.sendpulseClientId,
+        client_secret: settings.sendpulseClientSecret
+      });
+      const tokenResponse = await fetch("https://api.sendpulse.com/oauth/access_token", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: tokenParams.toString()
+      });
+      if (!tokenResponse.ok) {
+        const error = await tokenResponse.text();
+        console.error("[EmailService] SendPulse auth error:", error);
+        return false;
+      }
+      const tokenData = await tokenResponse.json();
+      if (!tokenData.access_token) {
+        console.error("[EmailService] SendPulse: No access token in response");
+        return false;
+      }
+      const { access_token } = tokenData;
+      const toBase64 = (str) => {
+        if (!str) return "";
+        return Buffer.from(String(str)).toString("base64");
+      };
+      const htmlSafe = html || "";
+      const textSafe = text || (htmlSafe ? htmlSafe.replace(/<[^>]*>/g, "") : "");
+      const response = await fetch("https://api.sendpulse.com/smtp/emails", {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${access_token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          email: {
+            html: toBase64(htmlSafe),
+            text: toBase64(textSafe),
+            subject,
+            from: { name: settings.fromName, email: settings.fromAddress },
+            to: [{ name: metadata.recipientName || "", email: to }]
+          }
+        })
+      });
+      if (response.ok) {
+        return true;
+      } else {
+        const errorText = await response.text();
+        console.error("[EmailService] SendPulse send error:", response.status, errorText);
+        return false;
+      }
+    } catch (error) {
+      console.error("[EmailService] SendPulse exception:", error.message);
+      return false;
+    }
+  }
+};
+// src/backend/routes/index.js
+var import_hono3 = require("hono");
+// src/backend/routes/templates.js
+var import_hono = require("hono");
+function createTemplateRoutes(env, config = {}, cacheProvider = null) {
+  const app = new import_hono.Hono();
+  const emailService = new EmailService(env, config, cacheProvider);
+  app.get("/templates", async (c) => {
+    try {
+      const templates = await emailService.getAllTemplates();
+      return c.json({ success: true, templates });
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  app.get("/templates/:id", async (c) => {
+    try {
+      const template = await emailService.getTemplate(c.req.param("id"));
+      if (!template) return c.json({ success: false, error: "Template not found" }, 404);
+      return c.json({ success: true, template });
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  app.post("/templates", async (c) => {
+    try {
+      const data = await c.req.json();
+      await emailService.saveTemplate(data, "admin");
+      return c.json({ success: true, message: "Template saved" });
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  app.delete("/templates/:id", async (c) => {
+    try {
+      await emailService.deleteTemplate(c.req.param("id"));
+      return c.json({ success: true, message: "Template deleted" });
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  app.post("/templates/:id/preview", async (c) => {
+    try {
+      const id = c.req.param("id");
+      const data = await c.req.json();
+      const result = await emailService.renderTemplate(id, data);
+      return c.json({ success: true, preview: result });
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  app.post("/templates/:id/test", async (c) => {
+    try {
+      const id = c.req.param("id");
+      const { to, data } = await c.req.json();
+      const { subject, html, plainText } = await emailService.renderTemplate(id, data);
+      const result = await emailService.sendEmail({
+        to,
+        subject: `[TEST] ${subject}`,
+        html,
+        text: plainText
+      });
+      if (result.success) {
+        return c.json({ success: true, message: "Test email sent" });
+      } else {
+        return c.json({ success: false, error: result.error }, 500);
+      }
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  return app;
+}
+// src/backend/routes/tracking.js
+var import_hono2 = require("hono");
+var TRACKING_PIXEL = new Uint8Array([
+  71,
+  73,
+  70,
+  56,
+  57,
+  97,
+  1,
+  0,
+  1,
+  0,
+  128,
+  0,
+  0,
+  0,
+  0,
+  0,
+  255,
+  255,
+  255,
+  33,
+  249,
+  4,
+  1,
+  0,
+  0,
+  0,
+  0,
+  44,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  1,
+  0,
+  0,
+  2,
+  1,
+  68,
+  0,
+  59
+]);
+function createTrackingRoutes(env, config = {}) {
+  const app = new import_hono2.Hono();
+  const db = env.DB;
+  const tablePrefix = config.emailTablePrefix || config.tableNamePrefix || "system_email_";
+  app.get("/track/open/:token", async (c) => {
+    const token = c.req.param("token");
+    try {
+      const sendId = token;
+      const send = await db.prepare(`SELECT * FROM ${tablePrefix}sends WHERE send_id = ?`).bind(sendId).first();
+      if (send) {
+        const eventId = crypto.randomUUID();
+        const now = Math.floor(Date.now() / 1e3);
+        await db.prepare(
+          `INSERT INTO ${tablePrefix}events (
+              event_id, send_id, user_id, tenant_id, email_kind, event_type, metadata, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).bind(
+          eventId,
+          sendId,
+          send.user_id,
+          send.tenant_id,
+          send.email_kind,
+          "opened",
+          JSON.stringify({
+            user_agent: c.req.header("user-agent"),
+            referer: c.req.header("referer")
+          }),
+          now
+        ).run();
+      }
+    } catch (error) {
+      console.error("[EmailTracking] Error tracking email open:", error);
+    }
+    return new Response(TRACKING_PIXEL, {
+      headers: {
+        "Content-Type": "image/gif",
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        "Pragma": "no-cache",
+        "Expires": "0"
+      }
+    });
+  });
+  app.post("/track/click/:token", async (c) => {
+    const token = c.req.param("token");
+    let url;
+    try {
+      const body = await c.req.json();
+      url = body.url;
+    } catch {
+      return c.json({ success: false, error: "Invalid request body" }, 400);
+    }
+    if (!url) {
+      return c.json({ success: false, error: "Missing URL" }, 400);
+    }
+    try {
+      const sendId = token;
+      const send = await db.prepare(`SELECT * FROM ${tablePrefix}sends WHERE send_id = ?`).bind(sendId).first();
+      if (send) {
+        const eventId = crypto.randomUUID();
+        const now = Math.floor(Date.now() / 1e3);
+        await db.prepare(
+          `INSERT INTO ${tablePrefix}events (
+              event_id, send_id, user_id, tenant_id, email_kind, event_type, metadata, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).bind(
+          eventId,
+          sendId,
+          send.user_id,
+          send.tenant_id,
+          send.email_kind,
+          "clicked",
+          JSON.stringify({
+            url,
+            user_agent: c.req.header("user-agent"),
+            referer: c.req.header("referer")
+          }),
+          now
+        ).run();
+      }
+      return c.json({ success: true, tracked: !!send });
+    } catch (error) {
+      console.error("[EmailTracking] Error tracking email click:", error);
+      return c.json({ success: false, error: "Failed to track click" }, 500);
+    }
+  });
+  app.get("/unsubscribe/:token", async (c) => {
+    const unsubToken = c.req.param("token");
+    try {
+      const prefs = await db.prepare(`SELECT * FROM ${tablePrefix}preferences WHERE unsub_token = ?`).bind(unsubToken).first();
+      if (!prefs) {
+        return c.json({ success: false, error: "Invalid unsubscribe link" }, 404);
+      }
+      const currentSettings = JSON.parse(prefs.email_settings || "{}");
+      const alreadyUnsubscribed = Object.keys(currentSettings).length === 0;
+      if (!alreadyUnsubscribed) {
+        const now = Math.floor(Date.now() / 1e3);
+        await db.prepare(
+          `UPDATE ${tablePrefix}preferences
+             SET email_settings = '{}',
+                 updated_at = ?
+             WHERE unsub_token = ?`
+        ).bind(now, unsubToken).run();
+        const eventId = crypto.randomUUID();
+        await db.prepare(
+          `INSERT INTO ${tablePrefix}events (
+              event_id, send_id, user_id, tenant_id, email_kind, event_type, metadata, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).bind(
+          eventId,
+          "unsubscribe",
+          prefs.user_id,
+          prefs.tenant_id,
+          "all",
+          "unsubscribed",
+          JSON.stringify({
+            user_agent: c.req.header("user-agent")
+          }),
+          now
+        ).run();
+      }
+      return c.json({ success: true, alreadyUnsubscribed });
+    } catch (error) {
+      console.error("[EmailTracking] Error processing unsubscribe:", error);
+      return c.json({ success: false, error: "An error occurred" }, 500);
+    }
+  });
+  return app;
+}
+// src/backend/routes/index.js
+function createEmailRoutes(env, config = {}, cacheProvider = null) {
+  const app = new import_hono3.Hono();
+  app.route("/api/email", createTemplateRoutes(env, config, cacheProvider));
+  app.route("/email", createTrackingRoutes(env, config));
+  return app;
+}
+// src/common/utils.js
+var import_mustache2 = __toESM(require("mustache"), 1);
+var cachedWebsiteUrl = null;
+function getWebsiteUrl(env) {
+  if (cachedWebsiteUrl) {
+    return cachedWebsiteUrl;
+  }
+  const domain = env.DOMAIN || "x0start.com";
+  const isDev = env.ENVIRONMENT === "development" || !env.ENVIRONMENT;
+  const protocol = isDev ? "http" : "https";
+  cachedWebsiteUrl = `${protocol}://www.${domain}`;
+  return cachedWebsiteUrl;
+}
+function resetWebsiteUrlCache() {
+  cachedWebsiteUrl = null;
+}
+function encodeTrackingLinks(html, sendId, env = null, websiteUrl = null) {
+  const baseUrl = websiteUrl || (env ? getWebsiteUrl(env) : "https://www.x0start.com");
+  const decodeHtmlEntities = (text) => {
+    return text.replace(/&#x2F;/g, "/").replace(/&#x3A;/g, ":").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+  };
+  return html.replace(/href="([^"]+)"/g, (match, url) => {
+    if (url.startsWith("mailto:") || url.startsWith("tel:") || url.startsWith("#") || url.includes("{{") || // Skip template variables
+    url.includes("/email/unsubscribe/") || url.includes("/email/track/")) {
+      return match;
+    }
+    const decodedUrl = decodeHtmlEntities(url);
+    const encodedUrl = Buffer.from(decodedUrl).toString("base64");
+    const trackingUrl = `${baseUrl}/r/${sendId}?url=${encodedUrl}`;
+    return `href="${trackingUrl}"`;
+  });
+}
+function markdownToPlainText(markdown) {
+  return markdown.replace(/#{1,6}\s+/g, "").replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/\[(.+?)\]\((.+?)\)/g, "$1: $2").replace(/`(.+?)`/g, "$1").replace(/>\s+/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function extractVariables(templateString) {
+  if (!templateString) return [];
+  try {
+    const tokens = import_mustache2.default.parse(templateString);
+    const variables = /* @__PURE__ */ new Set();
+    const collectVariables = (tokenList) => {
+      tokenList.forEach((token) => {
+        const type = token[0];
+        const value = token[1];
+        if (type === "name" || type === "#" || type === "^" || type === "&") {
+          variables.add(value);
+        }
+        if ((type === "#" || type === "^") && token[4]) {
+          collectVariables(token[4]);
+        }
+      });
+    };
+    collectVariables(tokens);
+    return Array.from(variables);
+  } catch (error) {
+    console.error("Error parsing template variables:", error);
+    return [];
+  }
+}
+// src/frontend/TemplateManager.jsx
+var import_react2 = __toESM(require("react"), 1);
+var import_lucide_react2 = require("lucide-react");
+// src/frontend/TemplateEditor.jsx
+var import_react = __toESM(require("react"), 1);
+var import_lucide_react = require("lucide-react");
+var TemplateEditor = ({
+  initialData,
+  onSave,
+  onCancel,
+  onPreview,
+  variablesHelpText = "Supports {{variable}}"
+}) => {
+  const [formData, setFormData] = (0, import_react.useState)({
+    template_id: "",
+    template_name: "",
+    template_type: "daily_reminder",
+    subject_template: "",
+    body_markdown: "",
+    variables: "[]",
+    description: "",
+    is_active: 1,
+    ...initialData
+  });
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    onSave(formData);
+  };
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: "fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 p-4" }, /* @__PURE__ */ import_react.default.createElement("div", { className: "bg-white rounded-lg shadow-xl max-w-4xl w-full max-h-[90vh] overflow-hidden flex flex-col" }, /* @__PURE__ */ import_react.default.createElement("div", { className: "p-6 border-b border-gray-200 flex justify-between items-center" }, /* @__PURE__ */ import_react.default.createElement("h2", { className: "text-xl font-bold text-gray-900" }, initialData ? "Edit Template" : "New Template"), /* @__PURE__ */ import_react.default.createElement("button", { onClick: onCancel, className: "p-2 hover:bg-gray-100 rounded-lg" }, /* @__PURE__ */ import_react.default.createElement(import_lucide_react.X, { className: "h-5 w-5" }))), /* @__PURE__ */ import_react.default.createElement("form", { onSubmit: handleSubmit, className: "flex-1 overflow-y-auto p-6 space-y-4" }, /* @__PURE__ */ import_react.default.createElement("div", { className: "grid grid-cols-2 gap-4" }, /* @__PURE__ */ import_react.default.createElement("div", null, /* @__PURE__ */ import_react.default.createElement("label", { className: "block text-sm font-medium text-gray-700 mb-1" }, "Template ID *"), /* @__PURE__ */ import_react.default.createElement(
+    "input",
+    {
+      type: "text",
+      required: true,
+      disabled: !!initialData,
+      value: formData.template_id,
+      onChange: (e) => setFormData({ ...formData, template_id: e.target.value }),
+      className: "w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 disabled:bg-gray-100"
+    }
+  )), /* @__PURE__ */ import_react.default.createElement("div", null, /* @__PURE__ */ import_react.default.createElement("label", { className: "block text-sm font-medium text-gray-700 mb-1" }, "Name *"), /* @__PURE__ */ import_react.default.createElement(
+    "input",
+    {
+      type: "text",
+      required: true,
+      value: formData.template_name,
+      onChange: (e) => setFormData({ ...formData, template_name: e.target.value }),
+      className: "w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500"
+    }
+  ))), /* @__PURE__ */ import_react.default.createElement("div", null, /* @__PURE__ */ import_react.default.createElement("label", { className: "block text-sm font-medium text-gray-700 mb-1" }, "Subject *"), /* @__PURE__ */ import_react.default.createElement(
+    "input",
+    {
+      type: "text",
+      required: true,
+      value: formData.subject_template,
+      onChange: (e) => setFormData({ ...formData, subject_template: e.target.value }),
+      className: "w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500"
+    }
+  ), /* @__PURE__ */ import_react.default.createElement("p", { className: "text-xs text-gray-500 mt-1" }, variablesHelpText)), /* @__PURE__ */ import_react.default.createElement("div", null, /* @__PURE__ */ import_react.default.createElement("label", { className: "block text-sm font-medium text-gray-700 mb-1" }, "Body (Markdown) *"), /* @__PURE__ */ import_react.default.createElement(
+    "textarea",
+    {
+      required: true,
+      rows: 12,
+      value: formData.body_markdown,
+      onChange: (e) => setFormData({ ...formData, body_markdown: e.target.value }),
+      className: "w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 font-mono text-sm"
+    }
+  )), /* @__PURE__ */ import_react.default.createElement("div", { className: "flex justify-between pt-4" }, /* @__PURE__ */ import_react.default.createElement(
+    "button",
+    {
+      type: "button",
+      onClick: () => onPreview && onPreview(formData),
+      className: "flex items-center gap-2 px-4 py-2 bg-gray-100 text-gray-700 rounded-lg hover:bg-gray-200"
+    },
+    /* @__PURE__ */ import_react.default.createElement(import_lucide_react.Eye, { className: "h-4 w-4" }),
+    " Preview"
+  ), /* @__PURE__ */ import_react.default.createElement("div", { className: "flex gap-2" }, /* @__PURE__ */ import_react.default.createElement(
+    "button",
+    {
+      type: "button",
+      onClick: onCancel,
+      className: "px-4 py-2 border border-gray-300 text-gray-700 rounded-lg hover:bg-gray-50"
+    },
+    "Cancel"
+  ), /* @__PURE__ */ import_react.default.createElement(
+    "button",
+    {
+      type: "submit",
+      className: "flex items-center gap-2 px-4 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700"
+    },
+    /* @__PURE__ */ import_react.default.createElement(import_lucide_react.Save, { className: "h-4 w-4" }),
+    " Save"
+  ))))));
+};
+// src/frontend/TemplateManager.jsx
+var TemplateManager = ({
+  apiClient,
+  title = "Email Templates",
+  description = "Manage your email templates"
+}) => {
+  const [templates, setTemplates] = (0, import_react2.useState)([]);
+  const [loading, setLoading] = (0, import_react2.useState)(true);
+  const [showEditor, setShowEditor] = (0, import_react2.useState)(false);
+  const [editingTemplate, setEditingTemplate] = (0, import_react2.useState)(null);
+  (0, import_react2.useEffect)(() => {
+    loadTemplates();
+  }, []);
+  const loadTemplates = async () => {
+    try {
+      setLoading(true);
+      const res = await apiClient.get("/templates");
+      if (res.data.success) {
+        setTemplates(res.data.templates);
+      }
+    } catch (err) {
+      console.error("Failed to load templates:", err);
+    } finally {
+      setLoading(false);
+    }
+  };
+  const handleSave = async (formData) => {
+    try {
+      await apiClient.post("/templates", formData);
+      setShowEditor(false);
+      loadTemplates();
+    } catch (err) {
+      console.error("Failed to save template:", err);
+      alert("Failed to save template");
+    }
+  };
+  const handleDelete = async (id) => {
+    if (!confirm("Delete this template?")) return;
+    try {
+      await apiClient.delete(`/templates/${id}`);
+      loadTemplates();
+    } catch (err) {
+      console.error("Failed to delete:", err);
+      alert("Failed to delete template");
+    }
+  };
+  return /* @__PURE__ */ import_react2.default.createElement("div", { className: "email-template-manager" }, /* @__PURE__ */ import_react2.default.createElement("div", { className: "flex justify-between items-center mb-6" }, /* @__PURE__ */ import_react2.default.createElement("div", null, /* @__PURE__ */ import_react2.default.createElement("h1", { className: "text-2xl font-bold text-gray-900" }, title), /* @__PURE__ */ import_react2.default.createElement("p", { className: "text-gray-600 mt-1" }, description)), /* @__PURE__ */ import_react2.default.createElement(
+    "button",
+    {
+      onClick: () => {
+        setEditingTemplate(null);
+        setShowEditor(true);
+      },
+      className: "flex items-center gap-2 px-4 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700"
+    },
+    /* @__PURE__ */ import_react2.default.createElement(import_lucide_react2.Plus, { className: "h-4 w-4" }),
+    " New Template"
+  )), loading ? /* @__PURE__ */ import_react2.default.createElement("div", { className: "flex justify-center p-12" }, /* @__PURE__ */ import_react2.default.createElement(import_lucide_react2.Loader, { className: "animate-spin text-gray-500" })) : /* @__PURE__ */ import_react2.default.createElement("div", { className: "grid gap-4" }, templates.map((t) => /* @__PURE__ */ import_react2.default.createElement("div", { key: t.template_id, className: "bg-white border rounded-lg p-6 flex justify-between items-start hover:shadow-md transition" }, /* @__PURE__ */ import_react2.default.createElement("div", null, /* @__PURE__ */ import_react2.default.createElement("div", { className: "flex items-center gap-3 mb-2" }, /* @__PURE__ */ import_react2.default.createElement(import_lucide_react2.Mail, { className: "h-5 w-5 text-blue-600" }), /* @__PURE__ */ import_react2.default.createElement("h3", { className: "text-lg font-semibold" }, t.template_name), /* @__PURE__ */ import_react2.default.createElement("span", { className: "px-2 py-1 text-xs bg-gray-100 rounded" }, t.template_type)), /* @__PURE__ */ import_react2.default.createElement("p", { className: "text-sm text-gray-600" }, t.description)), /* @__PURE__ */ import_react2.default.createElement("div", { className: "flex gap-2" }, /* @__PURE__ */ import_react2.default.createElement(
+    "button",
+    {
+      onClick: () => {
+        setEditingTemplate(t);
+        setShowEditor(true);
+      },
+      className: "p-2 text-blue-600 hover:bg-blue-50 rounded"
+    },
+    /* @__PURE__ */ import_react2.default.createElement(import_lucide_react2.Edit2, { className: "h-4 w-4" })
+  ), /* @__PURE__ */ import_react2.default.createElement(
+    "button",
+    {
+      onClick: () => handleDelete(t.template_id),
+      className: "p-2 text-red-600 hover:bg-red-50 rounded"
+    },
+    /* @__PURE__ */ import_react2.default.createElement(import_lucide_react2.Trash2, { className: "h-4 w-4" })
+  )))), templates.length === 0 && /* @__PURE__ */ import_react2.default.createElement("div", { className: "text-center py-12 text-gray-500 bg-gray-50 rounded border-dashed border-2" }, "No templates found. Create one to get started.")), showEditor && /* @__PURE__ */ import_react2.default.createElement(
+    TemplateEditor,
+    {
+      initialData: editingTemplate,
+      onSave: handleSave,
+      onCancel: () => setShowEditor(false)
+    }
+  ));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EmailService,
+  EmailingCacheDO,
+  TemplateEditor,
+  TemplateManager,
+  createDOCacheProvider,
+  createEmailRoutes,
+  createTemplateRoutes,
+  createTrackingRoutes,
+  encodeTrackingLinks,
+  extractVariables,
+  getWebsiteUrl,
+  markdownToPlainText,
+  resetWebsiteUrlCache,
+  wrapInEmailTemplate
+});
+//# sourceMappingURL=index.cjs.map