tempmail-sdk 1.0.2 → 1.1.0

package/dist/logger.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * SDK 日志模块
+ * 提供分级日志能力，支持自定义日志处理器
+ * 默认静默不输出，用户可通过 setLogLevel / setLogger 启用
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.LogLevel = void 0;
+exports.setLogLevel = setLogLevel;
+exports.getLogLevel = getLogLevel;
+exports.setLogger = setLogger;
+/**
+ * 日志级别枚举
+ * 数值越小级别越高，设置某级别后只输出该级别及以上的日志
+ */
+var LogLevel;
+(function (LogLevel) {
+    /** 关闭所有日志 */
+    LogLevel[LogLevel["SILENT"] = 0] = "SILENT";
+    /** 错误日志：请求失败、重试耗尽等 */
+    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+    /** 警告日志：重试中、降级处理等 */
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    /** 信息日志：请求开始、完成等关键流程 */
+    LogLevel[LogLevel["INFO"] = 3] = "INFO";
+    /** 调试日志：请求详情、响应内容等 */
+    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * 默认日志处理器，直接输出到 console
+ */
+const defaultHandler = {
+    error: (msg, ...args) => console.error(msg, ...args),
+    warn: (msg, ...args) => console.warn(msg, ...args),
+    info: (msg, ...args) => console.info(msg, ...args),
+    debug: (msg, ...args) => console.debug(msg, ...args),
+};
+let currentLevel = LogLevel.SILENT;
+let currentHandler = defaultHandler;
+/**
+ * 设置日志级别
+ * 默认 SILENT（不输出任何日志）
+ *
+ * @example
+ * ```ts
+ * import { setLogLevel, LogLevel } from 'tempmail-sdk';
+ * setLogLevel(LogLevel.DEBUG); // 开启所有日志
+ * setLogLevel(LogLevel.INFO);  // 只输出 INFO 及以上
+ * ```
+ */
+function setLogLevel(level) {
+    currentLevel = level;
+}
+/**
+ * 获取当前日志级别
+ */
+function getLogLevel() {
+    return currentLevel;
+}
+/**
+ * 设置自定义日志处理器
+ * 替换默认的 console 输出
+ *
+ * @example
+ * ```ts
+ * import { setLogger } from 'tempmail-sdk';
+ * setLogger({
+ *   error: (msg, ...args) => myLogger.error(msg, ...args),
+ *   warn:  (msg, ...args) => myLogger.warn(msg, ...args),
+ *   info:  (msg, ...args) => myLogger.info(msg, ...args),
+ *   debug: (msg, ...args) => myLogger.debug(msg, ...args),
+ * });
+ * ```
+ */
+function setLogger(handler) {
+    currentHandler = handler;
+}
+/**
+ * SDK 内部日志工具
+ * 根据当前日志级别过滤输出
+ */
+exports.logger = {
+    error(msg, ...args) {
+        if (currentLevel >= LogLevel.ERROR)
+            currentHandler.error(msg, ...args);
+    },
+    warn(msg, ...args) {
+        if (currentLevel >= LogLevel.WARN)
+            currentHandler.warn(msg, ...args);
+    },
+    info(msg, ...args) {
+        if (currentLevel >= LogLevel.INFO)
+            currentHandler.info(msg, ...args);
+    },
+    debug(msg, ...args) {
+        if (currentLevel >= LogLevel.DEBUG)
+            currentHandler.debug(msg, ...args);
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/normalize.d.ts

@@ -1,5 +1,12 @@
 import { Email } from './types';
 /**
  * 将各提供商返回的原始邮件数据标准化为统一的 Email 格式
+ *
+ * 不同渠道的 API 返回字段名各不相同，此函数通过多字段候选策略
+ * 将它们统一映射为标准的 Email 结构，保证 SDK 输出一致性。
+ *
+ * @param raw - 原始邮件数据（来自不同提供商的 API 响应）
+ * @param recipientEmail - 收件人邮箱地址，当原始数据中无收件人字段时用作回退值
+ * @returns 标准化的 Email 对象
  */
 export declare function normalizeEmail(raw: any, recipientEmail?: string): Email;

package/dist/normalize.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeEmail = normalizeEmail;
 /**
  * 将各提供商返回的原始邮件数据标准化为统一的 Email 格式
+ *
+ * 不同渠道的 API 返回字段名各不相同，此函数通过多字段候选策略
+ * 将它们统一映射为标准的 Email 结构，保证 SDK 输出一致性。
+ *
+ * @param raw - 原始邮件数据（来自不同提供商的 API 响应）
+ * @param recipientEmail - 收件人邮箱地址，当原始数据中无收件人字段时用作回退值
+ * @returns 标准化的 Email 对象
  */
 function normalizeEmail(raw, recipientEmail = '') {
     return {
@@ -17,25 +24,54 @@ function normalizeEmail(raw, recipientEmail = '') {
         attachments: normalizeAttachments(raw.attachments),
     };
 }
+/**
+ * 提取邮件 ID
+ * 候选字段: id, eid, _id, mailboxId, messageId, mail_id
+ */
 function normalizeId(raw) {
     const id = raw.id ?? raw.eid ?? raw._id ?? raw.mailboxId ?? raw.messageId ?? raw.mail_id ?? '';
     return String(id);
 }
+/**
+ * 提取发件人地址
+ * 候选字段: from_address, address_from, from, messageFrom, sender
+ */
 function normalizeFrom(raw) {
     return raw.from_address || raw.address_from || raw.from || raw.messageFrom || raw.sender || '';
 }
+/**
+ * 提取收件人地址，无匹配字段时回退为 recipientEmail
+ * 候选字段: to, to_address, name_to, email_address, address
+ */
 function normalizeTo(raw, recipientEmail) {
     return raw.to || raw.to_address || raw.name_to || raw.email_address || raw.address || recipientEmail || '';
 }
+/**
+ * 提取邮件主题
+ * 候选字段: subject, e_subject
+ */
 function normalizeSubject(raw) {
     return raw.subject || raw.e_subject || '';
 }
+/**
+ * 提取纯文本内容
+ * 候选字段: text, body, content, body_text, text_content
+ */
 function normalizeText(raw) {
     return raw.text || raw.body || raw.content || raw.body_text || raw.text_content || '';
 }
+/**
+ * 提取 HTML 内容
+ * 候选字段: html, html_content, body_html
+ */
 function normalizeHtml(raw) {
     return raw.html || raw.html_content || raw.body_html || '';
 }
+/**
+ * 提取并统一日期格式为 ISO 8601
+ * 候选字段: received_at, created_at, createdAt, date, timestamp, e_date
+ * 其中 timestamp 为 Unix 秒级时间戳，需乘以 1000 转为毫秒
+ */
 function normalizeDate(raw) {
     try {
         if (raw.received_at)
@@ -55,10 +91,15 @@ function normalizeDate(raw) {
             return new Date(raw.e_date).toISOString();
     }
     catch {
-        // 日期解析失败，返回空字符串
+        /* 日期解析失败，返回空字符串 */
     }
     return '';
 }
+/**
+ * 提取已读状态
+ * 候选字段: seen, read, isRead, is_read
+ * 支持 boolean / number(0|1) / string('0'|'1') 多种类型
+ */
 function normalizeIsRead(raw) {
     if (typeof raw.seen === 'boolean')
         return raw.seen;
@@ -74,6 +115,10 @@ function normalizeIsRead(raw) {
         return raw.is_read;
     return false;
 }
+/**
+ * 提取并标准化附件列表
+ * 每个附件的字段也采用多候选策略映射
+ */
 function normalizeAttachments(attachments) {
     if (!attachments || !Array.isArray(attachments))
         return [];
@@ -84,4 +129,4 @@ function normalizeAttachments(attachments) {
         url: a.url || a.download_url || a.downloadUrl || undefined,
     }));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"normalize.js","sourceRoot":"","sources":["../src/normalize.ts"],"names":[],"mappings":"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","sourcesContent":["import { Email, EmailAttachment } from './types';\n\n/**\n * 将各提供商返回的原始邮件数据标准化为统一的 Email 格式\n */\nexport function normalizeEmail(raw: any, recipientEmail: string = ''): Email {\n  return {\n    id: normalizeId(raw),\n    from: normalizeFrom(raw),\n    to: normalizeTo(raw, recipientEmail),\n    subject: normalizeSubject(raw),\n    text: normalizeText(raw),\n    html: normalizeHtml(raw),\n    date: normalizeDate(raw),\n    isRead: normalizeIsRead(raw),\n    attachments: normalizeAttachments(raw.attachments),\n  };\n}\n\nfunction normalizeId(raw: any): string {\n  const id = raw.id ?? raw.eid ?? raw._id ?? raw.mailboxId ?? raw.messageId ?? raw.mail_id ?? '';\n  return String(id);\n}\n\nfunction normalizeFrom(raw: any): string {\n  return raw.from_address || raw.address_from || raw.from || raw.messageFrom || raw.sender || '';\n}\n\nfunction normalizeTo(raw: any, recipientEmail: string): string {\n  return raw.to || raw.to_address || raw.name_to || raw.email_address || raw.address || recipientEmail || '';\n}\n\nfunction normalizeSubject(raw: any): string {\n  return raw.subject || raw.e_subject || '';\n}\n\nfunction normalizeText(raw: any): string {\n  return raw.text || raw.body || raw.content || raw.body_text || raw.text_content || '';\n}\n\nfunction normalizeHtml(raw: any): string {\n  return raw.html || raw.html_content || raw.body_html || '';\n}\n\nfunction normalizeDate(raw: any): string {\n  try {\n    if (raw.received_at) return new Date(raw.received_at).toISOString();\n    if (raw.created_at) return new Date(raw.created_at).toISOString();\n    if (raw.createdAt) return new Date(raw.createdAt).toISOString();\n    if (raw.date) {\n      if (typeof raw.date === 'number') return new Date(raw.date).toISOString();\n      return new Date(raw.date).toISOString();\n    }\n    if (raw.timestamp) return new Date(raw.timestamp * 1000).toISOString();\n    if (raw.e_date) return new Date(raw.e_date).toISOString();\n  } catch {\n    // 日期解析失败，返回空字符串\n  }\n  return '';\n}\n\nfunction normalizeIsRead(raw: any): boolean {\n  if (typeof raw.seen === 'boolean') return raw.seen;\n  if (typeof raw.read === 'boolean') return raw.read;\n  if (typeof raw.isRead === 'boolean') return raw.isRead;\n  if (typeof raw.is_read === 'number') return raw.is_read === 1;\n  if (typeof raw.is_read === 'string') return raw.is_read === '1';\n  if (typeof raw.is_read === 'boolean') return raw.is_read;\n  return false;\n}\n\nfunction normalizeAttachments(attachments: any): EmailAttachment[] {\n  if (!attachments || !Array.isArray(attachments)) return [];\n  return attachments.map((a: any) => ({\n    filename: a.filename || a.name || '',\n    size: a.size || a.filesize || undefined,\n    contentType: a.contentType || a.content_type || a.mimeType || a.mime_type || undefined,\n    url: a.url || a.download_url || a.downloadUrl || undefined,\n  }));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"normalize.js","sourceRoot":"","sources":["../src/normalize.ts"],"names":[],"mappings":"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","sourcesContent":["import { Email, EmailAttachment } from './types';\n\n/**\n * 将各提供商返回的原始邮件数据标准化为统一的 Email 格式\n *\n * 不同渠道的 API 返回字段名各不相同，此函数通过多字段候选策略\n * 将它们统一映射为标准的 Email 结构，保证 SDK 输出一致性。\n *\n * @param raw - 原始邮件数据（来自不同提供商的 API 响应）\n * @param recipientEmail - 收件人邮箱地址，当原始数据中无收件人字段时用作回退值\n * @returns 标准化的 Email 对象\n */\nexport function normalizeEmail(raw: any, recipientEmail: string = ''): Email {\n  return {\n    id: normalizeId(raw),\n    from: normalizeFrom(raw),\n    to: normalizeTo(raw, recipientEmail),\n    subject: normalizeSubject(raw),\n    text: normalizeText(raw),\n    html: normalizeHtml(raw),\n    date: normalizeDate(raw),\n    isRead: normalizeIsRead(raw),\n    attachments: normalizeAttachments(raw.attachments),\n  };\n}\n\n/**\n * 提取邮件 ID\n * 候选字段: id, eid, _id, mailboxId, messageId, mail_id\n */\nfunction normalizeId(raw: any): string {\n  const id = raw.id ?? raw.eid ?? raw._id ?? raw.mailboxId ?? raw.messageId ?? raw.mail_id ?? '';\n  return String(id);\n}\n\n/**\n * 提取发件人地址\n * 候选字段: from_address, address_from, from, messageFrom, sender\n */\nfunction normalizeFrom(raw: any): string {\n  return raw.from_address || raw.address_from || raw.from || raw.messageFrom || raw.sender || '';\n}\n\n/**\n * 提取收件人地址，无匹配字段时回退为 recipientEmail\n * 候选字段: to, to_address, name_to, email_address, address\n */\nfunction normalizeTo(raw: any, recipientEmail: string): string {\n  return raw.to || raw.to_address || raw.name_to || raw.email_address || raw.address || recipientEmail || '';\n}\n\n/**\n * 提取邮件主题\n * 候选字段: subject, e_subject\n */\nfunction normalizeSubject(raw: any): string {\n  return raw.subject || raw.e_subject || '';\n}\n\n/**\n * 提取纯文本内容\n * 候选字段: text, body, content, body_text, text_content\n */\nfunction normalizeText(raw: any): string {\n  return raw.text || raw.body || raw.content || raw.body_text || raw.text_content || '';\n}\n\n/**\n * 提取 HTML 内容\n * 候选字段: html, html_content, body_html\n */\nfunction normalizeHtml(raw: any): string {\n  return raw.html || raw.html_content || raw.body_html || '';\n}\n\n/**\n * 提取并统一日期格式为 ISO 8601\n * 候选字段: received_at, created_at, createdAt, date, timestamp, e_date\n * 其中 timestamp 为 Unix 秒级时间戳，需乘以 1000 转为毫秒\n */\nfunction normalizeDate(raw: any): string {\n  try {\n    if (raw.received_at) return new Date(raw.received_at).toISOString();\n    if (raw.created_at) return new Date(raw.created_at).toISOString();\n    if (raw.createdAt) return new Date(raw.createdAt).toISOString();\n    if (raw.date) {\n      if (typeof raw.date === 'number') return new Date(raw.date).toISOString();\n      return new Date(raw.date).toISOString();\n    }\n    if (raw.timestamp) return new Date(raw.timestamp * 1000).toISOString();\n    if (raw.e_date) return new Date(raw.e_date).toISOString();\n  } catch {\n    /* 日期解析失败，返回空字符串 */\n  }\n  return '';\n}\n\n/**\n * 提取已读状态\n * 候选字段: seen, read, isRead, is_read\n * 支持 boolean / number(0|1) / string('0'|'1') 多种类型\n */\nfunction normalizeIsRead(raw: any): boolean {\n  if (typeof raw.seen === 'boolean') return raw.seen;\n  if (typeof raw.read === 'boolean') return raw.read;\n  if (typeof raw.isRead === 'boolean') return raw.isRead;\n  if (typeof raw.is_read === 'number') return raw.is_read === 1;\n  if (typeof raw.is_read === 'string') return raw.is_read === '1';\n  if (typeof raw.is_read === 'boolean') return raw.is_read;\n  return false;\n}\n\n/**\n * 提取并标准化附件列表\n * 每个附件的字段也采用多候选策略映射\n */\nfunction normalizeAttachments(attachments: any): EmailAttachment[] {\n  if (!attachments || !Array.isArray(attachments)) return [];\n  return attachments.map((a: any) => ({\n    filename: a.filename || a.name || '',\n    size: a.size || a.filesize || undefined,\n    contentType: a.contentType || a.content_type || a.mimeType || a.mime_type || undefined,\n    url: a.url || a.download_url || a.downloadUrl || undefined,\n  }));\n}\n"]}

package/dist/providers/guerrillamail.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Guerrilla Mail 渠道实现
+ * API 文档: https://www.guerrillamail.com/GuerrillaMailAPI.html
+ *
+ * 特点:
+ * - 无需认证，公开 JSON API
+ * - 通过 sid_token 维持会话
+ * - 邮箱有效期 60 分钟
+ */
+import { EmailInfo, Email } from '../types';
+/**
+ * 创建临时邮箱
+ * API: GET ajax.php?f=get_email_address
+ * 返回 email_addr + sid_token（用于后续获取邮件）
+ */
+export declare function generateEmail(): Promise<EmailInfo>;
+/**
+ * 获取邮件列表
+ * API: GET ajax.php?f=check_email&seq=0&sid_token=xxx
+ * 返回 list 数组，每个元素包含 mail_id, mail_from, mail_subject, mail_body 等
+ */
+export declare function getEmails(token: string, email: string): Promise<Email[]>;

package/dist/providers/guerrillamail.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Guerrilla Mail 渠道实现
+ * API 文档: https://www.guerrillamail.com/GuerrillaMailAPI.html
+ *
+ * 特点:
+ * - 无需认证，公开 JSON API
+ * - 通过 sid_token 维持会话
+ * - 邮箱有效期 60 分钟
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEmail = generateEmail;
+exports.getEmails = getEmails;
+const normalize_1 = require("../normalize");
+const CHANNEL = 'guerrillamail';
+const BASE_URL = 'https://api.guerrillamail.com/ajax.php';
+/**
+ * 创建临时邮箱
+ * API: GET ajax.php?f=get_email_address
+ * 返回 email_addr + sid_token（用于后续获取邮件）
+ */
+async function generateEmail() {
+    const response = await fetch(`${BASE_URL}?f=get_email_address&lang=en`, {
+        method: 'GET',
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to generate email: ${response.status}`);
+    }
+    const data = await response.json();
+    if (!data.email_addr || !data.sid_token) {
+        throw new Error('Failed to generate email: missing email_addr or sid_token');
+    }
+    return {
+        channel: CHANNEL,
+        email: data.email_addr,
+        token: data.sid_token,
+        expiresAt: data.email_timestamp ? (data.email_timestamp + 3600) * 1000 : undefined,
+    };
+}
+/**
+ * 获取邮件列表
+ * API: GET ajax.php?f=check_email&seq=0&sid_token=xxx
+ * 返回 list 数组，每个元素包含 mail_id, mail_from, mail_subject, mail_body 等
+ */
+async function getEmails(token, email) {
+    const response = await fetch(`${BASE_URL}?f=check_email&seq=0&sid_token=${encodeURIComponent(token)}`, {
+        method: 'GET',
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to get emails: ${response.status}`);
+    }
+    const data = await response.json();
+    const list = Array.isArray(data.list) ? data.list : [];
+    return list.map((item) => (0, normalize_1.normalizeEmail)({
+        id: item.mail_id,
+        from: item.mail_from,
+        to: email,
+        subject: item.mail_subject,
+        text: item.mail_body || item.mail_excerpt || '',
+        html: item.mail_body || '',
+        date: item.mail_date || '',
+        isRead: item.mail_read === 1,
+    }, email));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/mail-tm.js

@@ -33,7 +33,11 @@ async function getDomains() {
         throw new Error(`Failed to get domains: ${response.status}`);
     }
     const data = await response.json();
-    const members = data['hydra:member'] || [];
+    /* 兼容两种响应格式：
+     * - Accept: application/ld+json → Hydra 格式 { "hydra:member": [...] }
+     * - Accept: application/json   → 纯数组 [...]
+     */
+    const members = Array.isArray(data) ? data : (data['hydra:member'] || []);
     return members
         .filter((d) => d.isActive)
         .map((d) => d.domain);
@@ -135,7 +139,8 @@ async function getEmails(token, email) {
         throw new Error(`Failed to get emails: ${listResponse.status}`);
     }
     const listData = await listResponse.json();
-    const messages = listData['hydra:member'] || [];
+    /* 兼容 Hydra 格式和纯数组格式 */
+    const messages = Array.isArray(listData) ? listData : (listData['hydra:member'] || []);
     if (messages.length === 0) {
         return [];
     }
@@ -164,4 +169,4 @@ async function getEmails(token, email) {
     const flatMessages = await Promise.all(detailPromises);
     return flatMessages.map((raw) => (0, normalize_1.normalizeEmail)(raw, email));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mail-tm.js","sourceRoot":"","sources":["../../src/providers/mail-tm.ts"],"names":[],"mappings":"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","sourcesContent":["import { EmailInfo, Email, Channel } from '../types';\nimport { normalizeEmail } from '../normalize';\n\nconst CHANNEL: Channel = 'mail-tm';\nconst BASE_URL = 'https://api.mail.tm';\n\nconst DEFAULT_HEADERS: Record<string, string> = {\n  'Content-Type': 'application/json',\n  'Accept': 'application/json',\n};\n\n/**\n * 生成随机字符串\n */\nfunction randomString(length: number): string {\n  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';\n  let result = '';\n  for (let i = 0; i < length; i++) {\n    result += chars[Math.floor(Math.random() * chars.length)];\n  }\n  return result;\n}\n\n/**\n * 获取可用域名列表\n * API: GET /domains\n */\nasync function getDomains(): Promise<string[]> {\n  const response = await fetch(`${BASE_URL}/domains`, {\n    method: 'GET',\n    headers: DEFAULT_HEADERS,\n  });\n\n  if (!response.ok) {\n    throw new Error(`Failed to get domains: ${response.status}`);\n  }\n\n  const data = await response.json();\n  const members = data['hydra:member'] || [];\n  return members\n    .filter((d: any) => d.isActive)\n    .map((d: any) => d.domain);\n}\n\n/**\n * 创建账号\n * API: POST /accounts\n */\nasync function createAccount(address: string, password: string): Promise<any> {\n  const response = await fetch(`${BASE_URL}/accounts`, {\n    method: 'POST',\n    headers: { ...DEFAULT_HEADERS, 'Content-Type': 'application/ld+json' },\n    body: JSON.stringify({ address, password }),\n  });\n\n  if (!response.ok) {\n    const text = await response.text();\n    throw new Error(`Failed to create account: ${response.status} ${text}`);\n  }\n\n  return response.json();\n}\n\n/**\n * 获取 Bearer Token\n * API: POST /token\n */\nasync function getToken(address: string, password: string): Promise<string> {\n  const response = await fetch(`${BASE_URL}/token`, {\n    method: 'POST',\n    headers: DEFAULT_HEADERS,\n    body: JSON.stringify({ address, password }),\n  });\n\n  if (!response.ok) {\n    throw new Error(`Failed to get token: ${response.status}`);\n  }\n\n  const data = await response.json();\n  return data.token;\n}\n\n/**\n * 创建临时邮箱\n * 流程: 获取域名 → 生成随机邮箱/密码 → 创建账号 → 获取 Token\n */\nexport async function generateEmail(): Promise<EmailInfo> {\n  // 1. 获取可用域名\n  const domains = await getDomains();\n  if (domains.length === 0) {\n    throw new Error('No available domains');\n  }\n\n  // 2. 生成随机邮箱和密码\n  const domain = domains[Math.floor(Math.random() * domains.length)];\n  const username = randomString(12);\n  const address = `${username}@${domain}`;\n  const password = randomString(16);\n\n  // 3. 创建账号\n  const account = await createAccount(address, password);\n\n  // 4. 获取 Bearer Token\n  const token = await getToken(address, password);\n\n  return {\n    channel: CHANNEL,\n    email: address,\n    token: token,\n    createdAt: account.createdAt,\n  };\n}\n\n/**\n * 将 mail.tm 的消息格式扁平化为 normalizeEmail 可处理的格式\n * mail.tm 的 from 是 {name, address} 对象，to 是数组，html 是字符串数组\n */\nfunction flattenMessage(msg: any, recipientEmail: string): any {\n  return {\n    id: msg.id || '',\n    from: msg.from?.address || '',\n    to: msg.to?.[0]?.address || recipientEmail,\n    subject: msg.subject || '',\n    text: msg.text || '',\n    html: Array.isArray(msg.html) ? msg.html.join('') : (msg.html || ''),\n    createdAt: msg.createdAt || '',\n    seen: msg.seen ?? false,\n    attachments: (msg.attachments || []).map((a: any) => ({\n      filename: a.filename || '',\n      size: a.size || undefined,\n      contentType: a.contentType || undefined,\n      downloadUrl: a.downloadUrl ? `${BASE_URL}${a.downloadUrl}` : undefined,\n    })),\n  };\n}\n\n/**\n * 获取邮件列表\n * 流程: GET /messages 获取列表 → 对每封邮件 GET /messages/{id} 获取详情（含 text/html）\n */\nexport async function getEmails(token: string, email: string): Promise<Email[]> {\n  // 1. 获取邮件列表\n  const listResponse = await fetch(`${BASE_URL}/messages`, {\n    method: 'GET',\n    headers: {\n      ...DEFAULT_HEADERS,\n      'Authorization': `Bearer ${token}`,\n    },\n  });\n\n  if (!listResponse.ok) {\n    throw new Error(`Failed to get emails: ${listResponse.status}`);\n  }\n\n  const listData = await listResponse.json();\n  const messages = listData['hydra:member'] || [];\n\n  if (messages.length === 0) {\n    return [];\n  }\n\n  // 2. 并行获取每封邮件的详情（含 text/html/attachments）\n  const detailPromises = messages.map(async (msg: any) => {\n    try {\n      const detailResponse = await fetch(`${BASE_URL}/messages/${msg.id}`, {\n        method: 'GET',\n        headers: {\n          ...DEFAULT_HEADERS,\n          'Authorization': `Bearer ${token}`,\n        },\n      });\n\n      if (!detailResponse.ok) {\n        // 如果详情获取失败，退回使用列表数据\n        return flattenMessage(msg, email);\n      }\n\n      const detail = await detailResponse.json();\n      return flattenMessage(detail, email);\n    } catch {\n      // 出错时退回使用列表数据\n      return flattenMessage(msg, email);\n    }\n  });\n\n  const flatMessages = await Promise.all(detailPromises);\n  return flatMessages.map((raw: any) => normalizeEmail(raw, email));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mail-tm.js","sourceRoot":"","sources":["../../src/providers/mail-tm.ts"],"names":[],"mappings":"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","sourcesContent":["import { EmailInfo, Email, Channel } from '../types';\nimport { normalizeEmail } from '../normalize';\n\nconst CHANNEL: Channel = 'mail-tm';\nconst BASE_URL = 'https://api.mail.tm';\n\nconst DEFAULT_HEADERS: Record<string, string> = {\n  'Content-Type': 'application/json',\n  'Accept': 'application/json',\n};\n\n/**\n * 生成随机字符串\n */\nfunction randomString(length: number): string {\n  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';\n  let result = '';\n  for (let i = 0; i < length; i++) {\n    result += chars[Math.floor(Math.random() * chars.length)];\n  }\n  return result;\n}\n\n/**\n * 获取可用域名列表\n * API: GET /domains\n */\nasync function getDomains(): Promise<string[]> {\n  const response = await fetch(`${BASE_URL}/domains`, {\n    method: 'GET',\n    headers: DEFAULT_HEADERS,\n  });\n\n  if (!response.ok) {\n    throw new Error(`Failed to get domains: ${response.status}`);\n  }\n\n  const data = await response.json();\n  /* 兼容两种响应格式：\n   * - Accept: application/ld+json → Hydra 格式 { \"hydra:member\": [...] }\n   * - Accept: application/json   → 纯数组 [...]\n   */\n  const members = Array.isArray(data) ? data : (data['hydra:member'] || []);\n  return members\n    .filter((d: any) => d.isActive)\n    .map((d: any) => d.domain);\n}\n\n/**\n * 创建账号\n * API: POST /accounts\n */\nasync function createAccount(address: string, password: string): Promise<any> {\n  const response = await fetch(`${BASE_URL}/accounts`, {\n    method: 'POST',\n    headers: { ...DEFAULT_HEADERS, 'Content-Type': 'application/ld+json' },\n    body: JSON.stringify({ address, password }),\n  });\n\n  if (!response.ok) {\n    const text = await response.text();\n    throw new Error(`Failed to create account: ${response.status} ${text}`);\n  }\n\n  return response.json();\n}\n\n/**\n * 获取 Bearer Token\n * API: POST /token\n */\nasync function getToken(address: string, password: string): Promise<string> {\n  const response = await fetch(`${BASE_URL}/token`, {\n    method: 'POST',\n    headers: DEFAULT_HEADERS,\n    body: JSON.stringify({ address, password }),\n  });\n\n  if (!response.ok) {\n    throw new Error(`Failed to get token: ${response.status}`);\n  }\n\n  const data = await response.json();\n  return data.token;\n}\n\n/**\n * 创建临时邮箱\n * 流程: 获取域名 → 生成随机邮箱/密码 → 创建账号 → 获取 Token\n */\nexport async function generateEmail(): Promise<EmailInfo> {\n  // 1. 获取可用域名\n  const domains = await getDomains();\n  if (domains.length === 0) {\n    throw new Error('No available domains');\n  }\n\n  // 2. 生成随机邮箱和密码\n  const domain = domains[Math.floor(Math.random() * domains.length)];\n  const username = randomString(12);\n  const address = `${username}@${domain}`;\n  const password = randomString(16);\n\n  // 3. 创建账号\n  const account = await createAccount(address, password);\n\n  // 4. 获取 Bearer Token\n  const token = await getToken(address, password);\n\n  return {\n    channel: CHANNEL,\n    email: address,\n    token: token,\n    createdAt: account.createdAt,\n  };\n}\n\n/**\n * 将 mail.tm 的消息格式扁平化为 normalizeEmail 可处理的格式\n * mail.tm 的 from 是 {name, address} 对象，to 是数组，html 是字符串数组\n */\nfunction flattenMessage(msg: any, recipientEmail: string): any {\n  return {\n    id: msg.id || '',\n    from: msg.from?.address || '',\n    to: msg.to?.[0]?.address || recipientEmail,\n    subject: msg.subject || '',\n    text: msg.text || '',\n    html: Array.isArray(msg.html) ? msg.html.join('') : (msg.html || ''),\n    createdAt: msg.createdAt || '',\n    seen: msg.seen ?? false,\n    attachments: (msg.attachments || []).map((a: any) => ({\n      filename: a.filename || '',\n      size: a.size || undefined,\n      contentType: a.contentType || undefined,\n      downloadUrl: a.downloadUrl ? `${BASE_URL}${a.downloadUrl}` : undefined,\n    })),\n  };\n}\n\n/**\n * 获取邮件列表\n * 流程: GET /messages 获取列表 → 对每封邮件 GET /messages/{id} 获取详情（含 text/html）\n */\nexport async function getEmails(token: string, email: string): Promise<Email[]> {\n  // 1. 获取邮件列表\n  const listResponse = await fetch(`${BASE_URL}/messages`, {\n    method: 'GET',\n    headers: {\n      ...DEFAULT_HEADERS,\n      'Authorization': `Bearer ${token}`,\n    },\n  });\n\n  if (!listResponse.ok) {\n    throw new Error(`Failed to get emails: ${listResponse.status}`);\n  }\n\n  const listData = await listResponse.json();\n  /* 兼容 Hydra 格式和纯数组格式 */\n  const messages = Array.isArray(listData) ? listData : (listData['hydra:member'] || []);\n\n  if (messages.length === 0) {\n    return [];\n  }\n\n  // 2. 并行获取每封邮件的详情（含 text/html/attachments）\n  const detailPromises = messages.map(async (msg: any) => {\n    try {\n      const detailResponse = await fetch(`${BASE_URL}/messages/${msg.id}`, {\n        method: 'GET',\n        headers: {\n          ...DEFAULT_HEADERS,\n          'Authorization': `Bearer ${token}`,\n        },\n      });\n\n      if (!detailResponse.ok) {\n        // 如果详情获取失败，退回使用列表数据\n        return flattenMessage(msg, email);\n      }\n\n      const detail = await detailResponse.json();\n      return flattenMessage(detail, email);\n    } catch {\n      // 出错时退回使用列表数据\n      return flattenMessage(msg, email);\n    }\n  });\n\n  const flatMessages = await Promise.all(detailPromises);\n  return flatMessages.map((raw: any) => normalizeEmail(raw, email));\n}\n"]}

package/dist/providers/maildrop.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Maildrop 渠道实现
+ * API: GraphQL endpoint https://api.maildrop.cc/graphql
+ *
+ * 特点:
+ * - 无需认证，公开 GraphQL API
+ * - 自带反垃圾过滤
+ * - 邮箱名即用户名（任意字符串@maildrop.cc）
+ * - 无过期时间限制
+ */
+import { EmailInfo, Email } from '../types';
+/**
+ * 创建临时邮箱
+ * Maildrop 无需注册，任意用户名即可接收邮件
+ */
+export declare function generateEmail(): Promise<EmailInfo>;
+/**
+ * 获取邮件列表
+ * 先查 inbox 获取邮件 ID 列表，再逐封获取完整内容
+ */
+export declare function getEmails(token: string, email: string): Promise<Email[]>;