tempmail-sdk 1.0.3 → 1.1.1

package/dist/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TempEmailClient = exports.logger = exports.setLogger = exports.getLogLevel = exports.setLogLevel = exports.LogLevel = exports.fetchWithTimeout = exports.withRetry = exports.normalizeEmail = void 0;
+exports.TempEmailClient = exports.getConfig = exports.setConfig = exports.logger = exports.setLogger = exports.getLogLevel = exports.setLogLevel = exports.LogLevel = exports.fetchWithTimeout = exports.withRetry = exports.normalizeEmail = void 0;
 exports.listChannels = listChannels;
 exports.getChannelInfo = getChannelInfo;
 exports.generateEmail = generateEmail;
@@ -47,8 +47,18 @@ const tempMailIO = __importStar(require("./providers/temp-mail-io"));
 const awamail = __importStar(require("./providers/awamail"));
 const mailTm = __importStar(require("./providers/mail-tm"));
 const dropmail = __importStar(require("./providers/dropmail"));
+const guerrillamail = __importStar(require("./providers/guerrillamail"));
+const maildropProvider = __importStar(require("./providers/maildrop"));
 const retry_1 = require("./retry");
 const logger_1 = require("./logger");
+const config_1 = require("./config");
+/**
+ * SDK 内部 token 存储
+ * 使用 WeakMap 将 EmailInfo 对象映射到对应的 token
+ * 用户无法直接访问 token，由 SDK 自动管理
+ * @internal
+ */
+const tokenStore = new WeakMap();
 var normalize_1 = require("./normalize");
 Object.defineProperty(exports, "normalizeEmail", { enumerable: true, get: function () { return normalize_1.normalizeEmail; } });
 var retry_2 = require("./retry");
@@ -60,6 +70,9 @@ Object.defineProperty(exports, "setLogLevel", { enumerable: true, get: function
 Object.defineProperty(exports, "getLogLevel", { enumerable: true, get: function () { return logger_2.getLogLevel; } });
 Object.defineProperty(exports, "setLogger", { enumerable: true, get: function () { return logger_2.setLogger; } });
 Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_2.logger; } });
+var config_2 = require("./config");
+Object.defineProperty(exports, "setConfig", { enumerable: true, get: function () { return config_2.setConfig; } });
+Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_2.getConfig; } });
 /** 渠道名称到 provider 实现的映射表 */
 const providers = {
     'tempmail': tempmail,
@@ -71,9 +84,11 @@ const providers = {
     'awamail': awamail,
     'mail-tm': mailTm,
     'dropmail': dropmail,
+    'guerrillamail': guerrillamail,
+    'maildrop': maildropProvider,
 };
 /** 所有支持的渠道列表，用于随机选择和遍历 */
-const allChannels = ['tempmail', 'linshi-email', 'tempmail-lol', 'chatgpt-org-uk', 'tempmail-la', 'temp-mail-io', 'awamail', 'mail-tm', 'dropmail'];
+const allChannels = ['tempmail', 'linshi-email', 'tempmail-lol', 'chatgpt-org-uk', 'tempmail-la', 'temp-mail-io', 'awamail', 'mail-tm', 'dropmail', 'guerrillamail', 'maildrop'];
 /** 渠道信息映射表 */
 const channelInfoMap = {
     'tempmail': { channel: 'tempmail', name: 'TempMail', website: 'tempmail.ing' },
@@ -85,6 +100,8 @@ const channelInfoMap = {
     'awamail': { channel: 'awamail', name: 'AwaMail', website: 'awamail.com' },
     'mail-tm': { channel: 'mail-tm', name: 'Mail.tm', website: 'mail.tm' },
     'dropmail': { channel: 'dropmail', name: 'DropMail', website: 'dropmail.me' },
+    'guerrillamail': { channel: 'guerrillamail', name: 'Guerrilla Mail', website: 'guerrillamail.com' },
+    'maildrop': { channel: 'maildrop', name: 'Maildrop', website: 'maildrop.cc' },
 };
 /**
  * 获取所有支持的渠道列表
@@ -113,25 +130,61 @@ function getChannelInfo(channel) {
  * 创建临时邮箱
  *
  * 错误处理策略：
- * - 网络错误、超时、服务端 5xx 错误 → 自动重试（默认 2 次，指数退避）
- * - 4xx 客户端错误、参数错误 → 直接抛出异常
+ * - 指定渠道失败时，自动尝试其他可用渠道（打乱顺序逐个尝试）
+ * - 未指定渠道时，打乱全部渠道逐个尝试，直到成功
+ * - 所有渠道均不可用时返回 null（不抛出异常）
  *
  * @param options - 创建选项，可指定渠道、有效时长、域名等
- * @returns 邮箱信息，包含地址、令牌等
- * @throws 重试耗尽后仍失败时抛出异常
+ * @returns 邮箱信息，所有渠道均不可用时返回 null
  *
  * @example
  * ```ts
  * const emailInfo = await generateEmail({ channel: 'temp-mail-io' });
- * console.log(emailInfo.email); // 临时邮箱地址
+ * if (emailInfo) console.log(emailInfo.email);
  * ```
  */
 async function generateEmail(options = {}) {
-    const channel = options.channel || allChannels[Math.floor(Math.random() * allChannels.length)];
-    logger_1.logger.info(`创建临时邮箱, 渠道: ${channel}`);
-    const result = await (0, retry_1.withRetry)(() => generateEmailOnce(channel, options), options.retry);
-    logger_1.logger.info(`邮箱创建成功: ${result.email}`);
-    return result;
+    /*
+     * 构建尝试顺序：
+     * - 指定渠道 → 优先尝试该渠道，失败后随机尝试其他渠道
+     * - 未指定 → 打乱全部渠道逐个尝试
+     */
+    const tryOrder = buildChannelOrder(options.channel);
+    for (const ch of tryOrder) {
+        logger_1.logger.info(`创建临时邮箱, 渠道: ${ch}`);
+        try {
+            const internal = await (0, retry_1.withRetry)(() => generateEmailOnce(ch, options), options.retry);
+            logger_1.logger.info(`邮箱创建成功: ${internal.email} (渠道: ${ch})`);
+            /* 将 token 存入内部存储，不暴露给用户 */
+            const publicInfo = {
+                channel: internal.channel,
+                email: internal.email,
+                expiresAt: internal.expiresAt,
+                createdAt: internal.createdAt,
+            };
+            if (internal.token) {
+                tokenStore.set(publicInfo, internal.token);
+            }
+            return publicInfo;
+        }
+        catch (err) {
+            logger_1.logger.warn(`渠道 ${ch} 不可用: ${err.message || err}，尝试下一个渠道`);
+        }
+    }
+    logger_1.logger.error('所有渠道均不可用，创建邮箱失败');
+    return null;
+}
+/**
+ * 构建渠道尝试顺序
+ * 指定渠道时优先尝试该渠道，其余渠道打乱追加
+ * 未指定时打乱全部渠道
+ */
+function buildChannelOrder(preferred) {
+    const shuffled = [...allChannels].sort(() => Math.random() - 0.5);
+    if (!preferred)
+        return shuffled;
+    const rest = shuffled.filter(ch => ch !== preferred);
+    return [preferred, ...rest];
 }
 /**
  * 单次创建邮箱（不含重试逻辑）
@@ -157,38 +210,42 @@ async function generateEmailOnce(channel, options) {
             return mailTm.generateEmail();
         case 'dropmail':
             return dropmail.generateEmail();
+        case 'guerrillamail':
+            return guerrillamail.generateEmail();
+        case 'maildrop':
+            return maildropProvider.generateEmail();
         default:
             throw new Error(`Unknown channel: ${channel}`);
     }
 }
 /**
  * 获取邮件列表
+ * Channel/Email/Token 等由 SDK 从 EmailInfo 中自动获取，用户无需手动传递
  *
  * 错误处理策略：
- * - 网络错误、超时、服务端 5xx 错误 → 自动重试（默认 2 次）
+ * - 网络错误、超时、429、服务端 5xx 错误 → 自动重试（默认 2 次）
  * - 重试耗尽后返回 { success: false, emails: [] }，不抛异常
- * - 参数校验错误（缺少 channel / token）直接抛出
- *
- * 这种设计让调用方在轮询场景下不会因网络波动而中断整个流程，
- * 只需检查 success 字段即可判断本次请求是否成功。
+ * - 参数校验错误（缺少 EmailInfo）直接抛出
  *
- * @param options - 获取选项，包含渠道、邮箱地址、令牌
+ * @param info - GenerateEmail() 返回的邮箱信息
+ * @param options - 可选配置（重试等）
  * @returns 邮件结果，包含 success 标记和邮件列表
  *
  * @example
  * ```ts
- * const result = await getEmails({
- *   channel: emailInfo.channel,
- *   email: emailInfo.email,
- *   token: emailInfo.token,
- * });
+ * const info = await generateEmail({ channel: 'mail-tm' });
+ * const result = await getEmails(info);
  * if (result.success && result.emails.length > 0) {
  *   console.log('收到邮件:', result.emails[0].subject);
  * }
  * ```
  */
-async function getEmails(options) {
-    const { channel, email, token } = options;
+async function getEmails(info, options) {
+    if (!info) {
+        throw new Error('EmailInfo is required, call generateEmail() first');
+    }
+    const { channel, email } = info;
+    const token = tokenStore.get(info);
     if (!channel) {
         throw new Error('Channel is required');
     }
@@ -197,7 +254,7 @@ async function getEmails(options) {
     }
     logger_1.logger.debug(`获取邮件, 渠道: ${channel}, 邮箱: ${email}`);
     try {
-        const emails = await (0, retry_1.withRetry)(() => getEmailsOnce(channel, email, token), options.retry);
+        const emails = await (0, retry_1.withRetry)(() => getEmailsOnce(channel, email, token), options?.retry);
         if (emails.length > 0) {
             logger_1.logger.info(`获取到 ${emails.length} 封邮件, 渠道: ${channel}`);
         }
@@ -227,7 +284,7 @@ async function getEmailsOnce(channel, email, token) {
             return linshiEmail.getEmails(email);
         case 'tempmail-lol':
             if (!token)
-                throw new Error('Token is required for tempmail-lol channel');
+                throw new Error('internal error: token missing for tempmail-lol');
             return tempmailLol.getEmails(token, email);
         case 'chatgpt-org-uk':
             return chatgptOrgUk.getEmails(email);
@@ -237,16 +294,24 @@ async function getEmailsOnce(channel, email, token) {
             return tempMailIO.getEmails(email);
         case 'awamail':
             if (!token)
-                throw new Error('Token is required for awamail channel');
+                throw new Error('internal error: token missing for awamail');
             return awamail.getEmails(token, email);
         case 'mail-tm':
             if (!token)
-                throw new Error('Token is required for mail-tm channel');
+                throw new Error('internal error: token missing for mail-tm');
             return mailTm.getEmails(token, email);
         case 'dropmail':
             if (!token)
-                throw new Error('Token is required for dropmail channel');
+                throw new Error('internal error: token missing for dropmail');
             return dropmail.getEmails(token, email);
+        case 'guerrillamail':
+            if (!token)
+                throw new Error('internal error: token missing for guerrillamail');
+            return guerrillamail.getEmails(token, email);
+        case 'maildrop':
+            if (!token)
+                throw new Error('internal error: token missing for maildrop');
+            return maildropProvider.getEmails(token, email);
         default:
             throw new Error(`Unknown channel: ${channel}`);
     }
@@ -275,6 +340,7 @@ class TempEmailClient {
     /**
      * 创建临时邮箱并缓存邮箱信息
      * 后续调用 getEmails() 时自动使用此邮箱的渠道、地址和令牌
+     * 所有渠道均不可用时返回 null
      */
     async generate(options = {}) {
         this.emailInfo = await generateEmail(options);
@@ -286,15 +352,11 @@ class TempEmailClient {
      *
      * @throws 未调用 generate() 时抛出异常
      */
-    async getEmails() {
+    async getEmails(options) {
         if (!this.emailInfo) {
             throw new Error('No email generated. Call generate() first.');
         }
-        return getEmails({
-            channel: this.emailInfo.channel,
-            email: this.emailInfo.email,
-            token: this.emailInfo.token,
-        });
+        return getEmails(this.emailInfo, options);
     }
     /**
      * 获取当前缓存的邮箱信息
@@ -311,5 +373,7 @@ exports.default = {
     generateEmail,
     getEmails,
     TempEmailClient,
+    setConfig: config_1.setConfig,
+    getConfig: config_1.getConfig,
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as tempmail from './providers/tempmail';\nimport * as linshiEmail from './providers/linshi-email';\nimport * as tempmailLol from './providers/tempmail-lol';\nimport * as chatgptOrgUk from './providers/chatgpt-org-uk';\nimport * as tempmailLa from './providers/tempmail-la';\nimport * as tempMailIO from './providers/temp-mail-io';\nimport * as awamail from './providers/awamail';\nimport * as mailTm from './providers/mail-tm';\nimport * as dropmail from './providers/dropmail';\nimport { Channel, EmailInfo, Email, EmailAttachment, GetEmailsResult, GenerateEmailOptions, GetEmailsOptions } from './types';\nimport { withRetry, RetryOptions } from './retry';\nimport { logger } from './logger';\n\nexport { Channel, EmailInfo, Email, EmailAttachment, GetEmailsResult, GenerateEmailOptions, GetEmailsOptions } from './types';\nexport { normalizeEmail } from './normalize';\nexport { withRetry, fetchWithTimeout, RetryOptions } from './retry';\nexport { LogLevel, LogHandler, setLogLevel, getLogLevel, setLogger, logger } from './logger';\n\n/** 渠道名称到 provider 实现的映射表 */\nconst providers = {\n  'tempmail': tempmail,\n  'linshi-email': linshiEmail,\n  'tempmail-lol': tempmailLol,\n  'chatgpt-org-uk': chatgptOrgUk,\n  'tempmail-la': tempmailLa,\n  'temp-mail-io': tempMailIO,\n  'awamail': awamail,\n  'mail-tm': mailTm,\n  'dropmail': dropmail,\n};\n\n/** 所有支持的渠道列表，用于随机选择和遍历 */\nconst allChannels: Channel[] = ['tempmail', 'linshi-email', 'tempmail-lol', 'chatgpt-org-uk', 'tempmail-la', 'temp-mail-io', 'awamail', 'mail-tm', 'dropmail'];\n\n/**\n * 渠道信息，包含渠道标识、显示名称和对应网站\n */\nexport interface ChannelInfo {\n  /** 渠道标识 */\n  channel: Channel;\n  /** 渠道显示名称 */\n  name: string;\n  /** 对应的临时邮箱服务网站 */\n  website: string;\n}\n\n/** 渠道信息映射表 */\nconst channelInfoMap: Record<Channel, ChannelInfo> = {\n  'tempmail': { channel: 'tempmail', name: 'TempMail', website: 'tempmail.ing' },\n  'linshi-email': { channel: 'linshi-email', name: '临时邮箱', website: 'linshi-email.com' },\n  'tempmail-lol': { channel: 'tempmail-lol', name: 'TempMail LOL', website: 'tempmail.lol' },\n  'chatgpt-org-uk': { channel: 'chatgpt-org-uk', name: 'ChatGPT Mail', website: 'mail.chatgpt.org.uk' },\n  'tempmail-la': { channel: 'tempmail-la', name: 'TempMail LA', website: 'tempmail.la' },\n  'temp-mail-io': { channel: 'temp-mail-io', name: 'Temp Mail IO', website: 'temp-mail.io' },\n  'awamail': { channel: 'awamail', name: 'AwaMail', website: 'awamail.com' },\n  'mail-tm': { channel: 'mail-tm', name: 'Mail.tm', website: 'mail.tm' },\n  'dropmail': { channel: 'dropmail', name: 'DropMail', website: 'dropmail.me' },\n};\n\n/**\n * 获取所有支持的渠道列表\n *\n * @returns 所有渠道的信息数组\n *\n * @example\n * ```ts\n * const channels = listChannels();\n * channels.forEach(ch => console.log(`${ch.name} (${ch.website})`));\n * ```\n */\nexport function listChannels(): ChannelInfo[] {\n  return allChannels.map(ch => channelInfoMap[ch]);\n}\n\n/**\n * 获取指定渠道的详细信息\n *\n * @param channel - 渠道标识\n * @returns 渠道信息，不存在时返回 undefined\n */\nexport function getChannelInfo(channel: Channel): ChannelInfo | undefined {\n  return channelInfoMap[channel];\n}\n\n/**\n * 创建临时邮箱\n *\n * 错误处理策略：\n * - 网络错误、超时、服务端 5xx 错误 → 自动重试（默认 2 次，指数退避）\n * - 4xx 客户端错误、参数错误 → 直接抛出异常\n *\n * @param options - 创建选项，可指定渠道、有效时长、域名等\n * @returns 邮箱信息，包含地址、令牌等\n * @throws 重试耗尽后仍失败时抛出异常\n *\n * @example\n * ```ts\n * const emailInfo = await generateEmail({ channel: 'temp-mail-io' });\n * console.log(emailInfo.email); // 临时邮箱地址\n * ```\n */\nexport async function generateEmail(options: GenerateEmailOptions = {}): Promise<EmailInfo> {\n  const channel = options.channel || allChannels[Math.floor(Math.random() * allChannels.length)];\n\n  logger.info(`创建临时邮箱, 渠道: ${channel}`);\n  const result = await withRetry(() => generateEmailOnce(channel, options), options.retry);\n  logger.info(`邮箱创建成功: ${result.email}`);\n  return result;\n}\n\n/**\n * 单次创建邮箱（不含重试逻辑）\n * 根据渠道类型分发到对应的 provider 实现\n */\nasync function generateEmailOnce(channel: Channel, options: GenerateEmailOptions): Promise<EmailInfo> {\n  switch (channel) {\n    case 'tempmail':\n      return tempmail.generateEmail(options.duration || 30);\n    case 'linshi-email':\n      return linshiEmail.generateEmail();\n    case 'tempmail-lol':\n      return tempmailLol.generateEmail(options.domain || null);\n    case 'chatgpt-org-uk':\n      return chatgptOrgUk.generateEmail();\n    case 'tempmail-la':\n      return tempmailLa.generateEmail();\n    case 'temp-mail-io':\n      return tempMailIO.generateEmail();\n    case 'awamail':\n      return awamail.generateEmail();\n    case 'mail-tm':\n      return mailTm.generateEmail();\n    case 'dropmail':\n      return dropmail.generateEmail();\n    default:\n      throw new Error(`Unknown channel: ${channel}`);\n  }\n}\n\n/**\n * 获取邮件列表\n *\n * 错误处理策略：\n * - 网络错误、超时、服务端 5xx 错误 → 自动重试（默认 2 次）\n * - 重试耗尽后返回 { success: false, emails: [] }，不抛异常\n * - 参数校验错误（缺少 channel / token）直接抛出\n *\n * 这种设计让调用方在轮询场景下不会因网络波动而中断整个流程，\n * 只需检查 success 字段即可判断本次请求是否成功。\n *\n * @param options - 获取选项，包含渠道、邮箱地址、令牌\n * @returns 邮件结果，包含 success 标记和邮件列表\n *\n * @example\n * ```ts\n * const result = await getEmails({\n *   channel: emailInfo.channel,\n *   email: emailInfo.email,\n *   token: emailInfo.token,\n * });\n * if (result.success && result.emails.length > 0) {\n *   console.log('收到邮件:', result.emails[0].subject);\n * }\n * ```\n */\nexport async function getEmails(options: GetEmailsOptions): Promise<GetEmailsResult> {\n  const { channel, email, token } = options;\n\n  if (!channel) {\n    throw new Error('Channel is required');\n  }\n  if (!email && channel !== 'tempmail-lol') {\n    throw new Error('Email is required');\n  }\n\n  logger.debug(`获取邮件, 渠道: ${channel}, 邮箱: ${email}`);\n  try {\n    const emails = await withRetry(() => getEmailsOnce(channel, email, token), options.retry);\n    if (emails.length > 0) {\n      logger.info(`获取到 ${emails.length} 封邮件, 渠道: ${channel}`);\n    } else {\n      logger.debug(`暂无邮件, 渠道: ${channel}`);\n    }\n    return { channel, email, emails, success: true };\n  } catch (err: any) {\n    /*\n     * 重试耗尽后仍然失败 → 返回空结果而非抛异常\n     * 这样调用方在轮询场景下不会因为一次网络波动而中断整个流程\n     */\n    logger.error(`获取邮件失败, 渠道: ${channel}, 错误: ${err.message || err}`);\n    return { channel, email, emails: [], success: false };\n  }\n}\n\n/**\n * 单次获取邮件（不含重试逻辑）\n * 根据渠道类型分发到对应的 provider 实现，并校验必需的 token 参数\n */\nasync function getEmailsOnce(channel: Channel, email: string, token?: string): Promise<Email[]> {\n  switch (channel) {\n    case 'tempmail':\n      return tempmail.getEmails(email);\n    case 'linshi-email':\n      return linshiEmail.getEmails(email);\n    case 'tempmail-lol':\n      if (!token) throw new Error('Token is required for tempmail-lol channel');\n      return tempmailLol.getEmails(token, email);\n    case 'chatgpt-org-uk':\n      return chatgptOrgUk.getEmails(email);\n    case 'tempmail-la':\n      return tempmailLa.getEmails(email);\n    case 'temp-mail-io':\n      return tempMailIO.getEmails(email);\n    case 'awamail':\n      if (!token) throw new Error('Token is required for awamail channel');\n      return awamail.getEmails(token, email);\n    case 'mail-tm':\n      if (!token) throw new Error('Token is required for mail-tm channel');\n      return mailTm.getEmails(token, email);\n    case 'dropmail':\n      if (!token) throw new Error('Token is required for dropmail channel');\n      return dropmail.getEmails(token, email);\n    default:\n      throw new Error(`Unknown channel: ${channel}`);\n  }\n}\n\n/**\n * 临时邮箱客户端\n * 封装了邮箱创建和邮件获取的完整流程，自动管理邮箱信息和认证令牌\n *\n * @example\n * ```ts\n * const client = new TempEmailClient();\n * const emailInfo = await client.generate({ channel: 'mail-tm' });\n * console.log('邮箱:', emailInfo.email);\n *\n * // 轮询获取邮件\n * const result = await client.getEmails();\n * if (result.success) {\n *   console.log('邮件数:', result.emails.length);\n * }\n * ```\n */\nexport class TempEmailClient {\n  private emailInfo: EmailInfo | null = null;\n\n  /**\n   * 创建临时邮箱并缓存邮箱信息\n   * 后续调用 getEmails() 时自动使用此邮箱的渠道、地址和令牌\n   */\n  async generate(options: GenerateEmailOptions = {}): Promise<EmailInfo> {\n    this.emailInfo = await generateEmail(options);\n    return this.emailInfo;\n  }\n\n  /**\n   * 获取当前邮箱的邮件列表\n   * 必须先调用 generate() 创建邮箱\n   *\n   * @throws 未调用 generate() 时抛出异常\n   */\n  async getEmails(): Promise<GetEmailsResult> {\n    if (!this.emailInfo) {\n      throw new Error('No email generated. Call generate() first.');\n    }\n\n    return getEmails({\n      channel: this.emailInfo.channel,\n      email: this.emailInfo.email,\n      token: this.emailInfo.token,\n    });\n  }\n\n  /**\n   * 获取当前缓存的邮箱信息\n   * 未调用 generate() 时返回 null\n   */\n  getEmailInfo(): EmailInfo | null {\n    return this.emailInfo;\n  }\n}\n\nexport default {\n  listChannels,\n  getChannelInfo,\n  generateEmail,\n  getEmails,\n  TempEmailClient,\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as tempmail from './providers/tempmail';\nimport * as linshiEmail from './providers/linshi-email';\nimport * as tempmailLol from './providers/tempmail-lol';\nimport * as chatgptOrgUk from './providers/chatgpt-org-uk';\nimport * as tempmailLa from './providers/tempmail-la';\nimport * as tempMailIO from './providers/temp-mail-io';\nimport * as awamail from './providers/awamail';\nimport * as mailTm from './providers/mail-tm';\nimport * as dropmail from './providers/dropmail';\nimport * as guerrillamail from './providers/guerrillamail';\nimport * as maildropProvider from './providers/maildrop';\nimport { Channel, EmailInfo, InternalEmailInfo, Email, EmailAttachment, GetEmailsResult, GenerateEmailOptions, GetEmailsOptions } from './types';\nimport { withRetry, RetryOptions } from './retry';\nimport { logger } from './logger';\nimport { setConfig, getConfig } from './config';\n\nexport { Channel, EmailInfo, Email, EmailAttachment, GetEmailsResult, GenerateEmailOptions, GetEmailsOptions } from './types';\n\n/**\n * SDK 内部 token 存储\n * 使用 WeakMap 将 EmailInfo 对象映射到对应的 token\n * 用户无法直接访问 token，由 SDK 自动管理\n * @internal\n */\nconst tokenStore = new WeakMap<EmailInfo, string>();\nexport { normalizeEmail } from './normalize';\nexport { withRetry, fetchWithTimeout, RetryOptions } from './retry';\nexport { LogLevel, LogHandler, setLogLevel, getLogLevel, setLogger, logger } from './logger';\nexport { SDKConfig, setConfig, getConfig } from './config';\n\n/** 渠道名称到 provider 实现的映射表 */\nconst providers = {\n  'tempmail': tempmail,\n  'linshi-email': linshiEmail,\n  'tempmail-lol': tempmailLol,\n  'chatgpt-org-uk': chatgptOrgUk,\n  'tempmail-la': tempmailLa,\n  'temp-mail-io': tempMailIO,\n  'awamail': awamail,\n  'mail-tm': mailTm,\n  'dropmail': dropmail,\n  'guerrillamail': guerrillamail,\n  'maildrop': maildropProvider,\n};\n\n/** 所有支持的渠道列表，用于随机选择和遍历 */\nconst allChannels: Channel[] = ['tempmail', 'linshi-email', 'tempmail-lol', 'chatgpt-org-uk', 'tempmail-la', 'temp-mail-io', 'awamail', 'mail-tm', 'dropmail', 'guerrillamail', 'maildrop'];\n\n/**\n * 渠道信息，包含渠道标识、显示名称和对应网站\n */\nexport interface ChannelInfo {\n  /** 渠道标识 */\n  channel: Channel;\n  /** 渠道显示名称 */\n  name: string;\n  /** 对应的临时邮箱服务网站 */\n  website: string;\n}\n\n/** 渠道信息映射表 */\nconst channelInfoMap: Record<Channel, ChannelInfo> = {\n  'tempmail': { channel: 'tempmail', name: 'TempMail', website: 'tempmail.ing' },\n  'linshi-email': { channel: 'linshi-email', name: '临时邮箱', website: 'linshi-email.com' },\n  'tempmail-lol': { channel: 'tempmail-lol', name: 'TempMail LOL', website: 'tempmail.lol' },\n  'chatgpt-org-uk': { channel: 'chatgpt-org-uk', name: 'ChatGPT Mail', website: 'mail.chatgpt.org.uk' },\n  'tempmail-la': { channel: 'tempmail-la', name: 'TempMail LA', website: 'tempmail.la' },\n  'temp-mail-io': { channel: 'temp-mail-io', name: 'Temp Mail IO', website: 'temp-mail.io' },\n  'awamail': { channel: 'awamail', name: 'AwaMail', website: 'awamail.com' },\n  'mail-tm': { channel: 'mail-tm', name: 'Mail.tm', website: 'mail.tm' },\n  'dropmail': { channel: 'dropmail', name: 'DropMail', website: 'dropmail.me' },\n  'guerrillamail': { channel: 'guerrillamail', name: 'Guerrilla Mail', website: 'guerrillamail.com' },\n  'maildrop': { channel: 'maildrop', name: 'Maildrop', website: 'maildrop.cc' },\n};\n\n/**\n * 获取所有支持的渠道列表\n *\n * @returns 所有渠道的信息数组\n *\n * @example\n * ```ts\n * const channels = listChannels();\n * channels.forEach(ch => console.log(`${ch.name} (${ch.website})`));\n * ```\n */\nexport function listChannels(): ChannelInfo[] {\n  return allChannels.map(ch => channelInfoMap[ch]);\n}\n\n/**\n * 获取指定渠道的详细信息\n *\n * @param channel - 渠道标识\n * @returns 渠道信息，不存在时返回 undefined\n */\nexport function getChannelInfo(channel: Channel): ChannelInfo | undefined {\n  return channelInfoMap[channel];\n}\n\n/**\n * 创建临时邮箱\n *\n * 错误处理策略：\n * - 指定渠道失败时，自动尝试其他可用渠道（打乱顺序逐个尝试）\n * - 未指定渠道时，打乱全部渠道逐个尝试，直到成功\n * - 所有渠道均不可用时返回 null（不抛出异常）\n *\n * @param options - 创建选项，可指定渠道、有效时长、域名等\n * @returns 邮箱信息，所有渠道均不可用时返回 null\n *\n * @example\n * ```ts\n * const emailInfo = await generateEmail({ channel: 'temp-mail-io' });\n * if (emailInfo) console.log(emailInfo.email);\n * ```\n */\nexport async function generateEmail(options: GenerateEmailOptions = {}): Promise<EmailInfo | null> {\n  /*\n   * 构建尝试顺序：\n   * - 指定渠道 → 优先尝试该渠道，失败后随机尝试其他渠道\n   * - 未指定 → 打乱全部渠道逐个尝试\n   */\n  const tryOrder = buildChannelOrder(options.channel);\n\n  for (const ch of tryOrder) {\n    logger.info(`创建临时邮箱, 渠道: ${ch}`);\n    try {\n      const internal: InternalEmailInfo = await withRetry(() => generateEmailOnce(ch, options), options.retry);\n      logger.info(`邮箱创建成功: ${internal.email} (渠道: ${ch})`);\n\n      /* 将 token 存入内部存储，不暴露给用户 */\n      const publicInfo: EmailInfo = {\n        channel: internal.channel,\n        email: internal.email,\n        expiresAt: internal.expiresAt,\n        createdAt: internal.createdAt,\n      };\n      if (internal.token) {\n        tokenStore.set(publicInfo, internal.token);\n      }\n      return publicInfo;\n    } catch (err: any) {\n      logger.warn(`渠道 ${ch} 不可用: ${err.message || err}，尝试下一个渠道`);\n    }\n  }\n\n  logger.error('所有渠道均不可用，创建邮箱失败');\n  return null;\n}\n\n/**\n * 构建渠道尝试顺序\n * 指定渠道时优先尝试该渠道，其余渠道打乱追加\n * 未指定时打乱全部渠道\n */\nfunction buildChannelOrder(preferred?: Channel): Channel[] {\n  const shuffled = [...allChannels].sort(() => Math.random() - 0.5);\n  if (!preferred) return shuffled;\n  const rest = shuffled.filter(ch => ch !== preferred);\n  return [preferred, ...rest];\n}\n\n/**\n * 单次创建邮箱（不含重试逻辑）\n * 根据渠道类型分发到对应的 provider 实现\n */\nasync function generateEmailOnce(channel: Channel, options: GenerateEmailOptions): Promise<InternalEmailInfo> {\n  switch (channel) {\n    case 'tempmail':\n      return tempmail.generateEmail(options.duration || 30);\n    case 'linshi-email':\n      return linshiEmail.generateEmail();\n    case 'tempmail-lol':\n      return tempmailLol.generateEmail(options.domain || null);\n    case 'chatgpt-org-uk':\n      return chatgptOrgUk.generateEmail();\n    case 'tempmail-la':\n      return tempmailLa.generateEmail();\n    case 'temp-mail-io':\n      return tempMailIO.generateEmail();\n    case 'awamail':\n      return awamail.generateEmail();\n    case 'mail-tm':\n      return mailTm.generateEmail();\n    case 'dropmail':\n      return dropmail.generateEmail();\n    case 'guerrillamail':\n      return guerrillamail.generateEmail();\n    case 'maildrop':\n      return maildropProvider.generateEmail();\n    default:\n      throw new Error(`Unknown channel: ${channel}`);\n  }\n}\n\n/**\n * 获取邮件列表\n * Channel/Email/Token 等由 SDK 从 EmailInfo 中自动获取，用户无需手动传递\n *\n * 错误处理策略：\n * - 网络错误、超时、429、服务端 5xx 错误 → 自动重试（默认 2 次）\n * - 重试耗尽后返回 { success: false, emails: [] }，不抛异常\n * - 参数校验错误（缺少 EmailInfo）直接抛出\n *\n * @param info - GenerateEmail() 返回的邮箱信息\n * @param options - 可选配置（重试等）\n * @returns 邮件结果，包含 success 标记和邮件列表\n *\n * @example\n * ```ts\n * const info = await generateEmail({ channel: 'mail-tm' });\n * const result = await getEmails(info);\n * if (result.success && result.emails.length > 0) {\n *   console.log('收到邮件:', result.emails[0].subject);\n * }\n * ```\n */\nexport async function getEmails(info: EmailInfo, options?: GetEmailsOptions): Promise<GetEmailsResult> {\n  if (!info) {\n    throw new Error('EmailInfo is required, call generateEmail() first');\n  }\n\n  const { channel, email } = info;\n  const token = tokenStore.get(info);\n\n  if (!channel) {\n    throw new Error('Channel is required');\n  }\n  if (!email && channel !== 'tempmail-lol') {\n    throw new Error('Email is required');\n  }\n\n  logger.debug(`获取邮件, 渠道: ${channel}, 邮箱: ${email}`);\n  try {\n    const emails = await withRetry(() => getEmailsOnce(channel, email, token), options?.retry);\n    if (emails.length > 0) {\n      logger.info(`获取到 ${emails.length} 封邮件, 渠道: ${channel}`);\n    } else {\n      logger.debug(`暂无邮件, 渠道: ${channel}`);\n    }\n    return { channel, email, emails, success: true };\n  } catch (err: any) {\n    /*\n     * 重试耗尽后仍然失败 → 返回空结果而非抛异常\n     * 这样调用方在轮询场景下不会因为一次网络波动而中断整个流程\n     */\n    logger.error(`获取邮件失败, 渠道: ${channel}, 错误: ${err.message || err}`);\n    return { channel, email, emails: [], success: false };\n  }\n}\n\n/**\n * 单次获取邮件（不含重试逻辑）\n * 根据渠道类型分发到对应的 provider 实现，并校验必需的 token 参数\n */\nasync function getEmailsOnce(channel: Channel, email: string, token?: string): Promise<Email[]> {\n  switch (channel) {\n    case 'tempmail':\n      return tempmail.getEmails(email);\n    case 'linshi-email':\n      return linshiEmail.getEmails(email);\n    case 'tempmail-lol':\n      if (!token) throw new Error('internal error: token missing for tempmail-lol');\n      return tempmailLol.getEmails(token, email);\n    case 'chatgpt-org-uk':\n      return chatgptOrgUk.getEmails(email);\n    case 'tempmail-la':\n      return tempmailLa.getEmails(email);\n    case 'temp-mail-io':\n      return tempMailIO.getEmails(email);\n    case 'awamail':\n      if (!token) throw new Error('internal error: token missing for awamail');\n      return awamail.getEmails(token, email);\n    case 'mail-tm':\n      if (!token) throw new Error('internal error: token missing for mail-tm');\n      return mailTm.getEmails(token, email);\n    case 'dropmail':\n      if (!token) throw new Error('internal error: token missing for dropmail');\n      return dropmail.getEmails(token, email);\n    case 'guerrillamail':\n      if (!token) throw new Error('internal error: token missing for guerrillamail');\n      return guerrillamail.getEmails(token, email);\n    case 'maildrop':\n      if (!token) throw new Error('internal error: token missing for maildrop');\n      return maildropProvider.getEmails(token, email);\n    default:\n      throw new Error(`Unknown channel: ${channel}`);\n  }\n}\n\n/**\n * 临时邮箱客户端\n * 封装了邮箱创建和邮件获取的完整流程，自动管理邮箱信息和认证令牌\n *\n * @example\n * ```ts\n * const client = new TempEmailClient();\n * const emailInfo = await client.generate({ channel: 'mail-tm' });\n * console.log('邮箱:', emailInfo.email);\n *\n * // 轮询获取邮件\n * const result = await client.getEmails();\n * if (result.success) {\n *   console.log('邮件数:', result.emails.length);\n * }\n * ```\n */\nexport class TempEmailClient {\n  private emailInfo: EmailInfo | null = null;\n\n  /**\n   * 创建临时邮箱并缓存邮箱信息\n   * 后续调用 getEmails() 时自动使用此邮箱的渠道、地址和令牌\n   * 所有渠道均不可用时返回 null\n   */\n  async generate(options: GenerateEmailOptions = {}): Promise<EmailInfo | null> {\n    this.emailInfo = await generateEmail(options);\n    return this.emailInfo;\n  }\n\n  /**\n   * 获取当前邮箱的邮件列表\n   * 必须先调用 generate() 创建邮箱\n   *\n   * @throws 未调用 generate() 时抛出异常\n   */\n  async getEmails(options?: GetEmailsOptions): Promise<GetEmailsResult> {\n    if (!this.emailInfo) {\n      throw new Error('No email generated. Call generate() first.');\n    }\n\n    return getEmails(this.emailInfo, options);\n  }\n\n  /**\n   * 获取当前缓存的邮箱信息\n   * 未调用 generate() 时返回 null\n   */\n  getEmailInfo(): EmailInfo | null {\n    return this.emailInfo;\n  }\n}\n\nexport default {\n  listChannels,\n  getChannelInfo,\n  generateEmail,\n  getEmails,\n  TempEmailClient,\n  setConfig,\n  getConfig,\n};\n"]}

package/dist/normalize.js

@@ -12,18 +12,43 @@ exports.normalizeEmail = normalizeEmail;
  * @returns 标准化的 Email 对象
  */
 function normalizeEmail(raw, recipientEmail = '') {
+    let text = normalizeText(raw);
+    let html = normalizeHtml(raw);
+    /*
+     * 修正 text/html 错配：
+     * 部分渠道将 HTML 内容放在 body/text 等字段中，
+     * 导致 normalizeText 提取到 HTML 内容而 normalizeHtml 为空。
+     * 检测 text 中是否包含 HTML 标签，如果是则移动到 html 字段。
+     */
+    if (text && !html && isHtmlContent(text)) {
+        html = text;
+        text = '';
+    }
     return {
         id: normalizeId(raw),
         from: normalizeFrom(raw),
         to: normalizeTo(raw, recipientEmail),
         subject: normalizeSubject(raw),
-        text: normalizeText(raw),
-        html: normalizeHtml(raw),
+        text,
+        html,
         date: normalizeDate(raw),
         isRead: normalizeIsRead(raw),
         attachments: normalizeAttachments(raw.attachments),
     };
 }
+/**
+ * 检测内容是否为 HTML
+ * 通过检查是否包含常见的 HTML 标签来判断
+ */
+function isHtmlContent(content) {
+    const trimmed = content.trim().toLowerCase();
+    return trimmed.startsWith('<!doctype html') ||
+        trimmed.startsWith('<html') ||
+        trimmed.startsWith('<body') ||
+        (trimmed.includes('<div') && trimmed.includes('</div>')) ||
+        (trimmed.includes('<table') && trimmed.includes('</table>')) ||
+        (trimmed.includes('<p') && trimmed.includes('</p>') && trimmed.includes('<'));
+}
 /**
  * 提取邮件 ID
  * 候选字段: id, eid, _id, mailboxId, messageId, mail_id
@@ -129,4 +154,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 *\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"]}
+//# 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  let text = normalizeText(raw);\n  let html = normalizeHtml(raw);\n\n  /*\n   * 修正 text/html 错配：\n   * 部分渠道将 HTML 内容放在 body/text 等字段中，\n   * 导致 normalizeText 提取到 HTML 内容而 normalizeHtml 为空。\n   * 检测 text 中是否包含 HTML 标签，如果是则移动到 html 字段。\n   */\n  if (text && !html && isHtmlContent(text)) {\n    html = text;\n    text = '';\n  }\n\n  return {\n    id: normalizeId(raw),\n    from: normalizeFrom(raw),\n    to: normalizeTo(raw, recipientEmail),\n    subject: normalizeSubject(raw),\n    text,\n    html,\n    date: normalizeDate(raw),\n    isRead: normalizeIsRead(raw),\n    attachments: normalizeAttachments(raw.attachments),\n  };\n}\n\n/**\n * 检测内容是否为 HTML\n * 通过检查是否包含常见的 HTML 标签来判断\n */\nfunction isHtmlContent(content: string): boolean {\n  const trimmed = content.trim().toLowerCase();\n  return trimmed.startsWith('<!doctype html') ||\n    trimmed.startsWith('<html') ||\n    trimmed.startsWith('<body') ||\n    (trimmed.includes('<div') && trimmed.includes('</div>')) ||\n    (trimmed.includes('<table') && trimmed.includes('</table>')) ||\n    (trimmed.includes('<p') && trimmed.includes('</p>') && trimmed.includes('<'));\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/awamail.d.ts

@@ -1,11 +1,11 @@
-import { EmailInfo, Email } from '../types';
+import { InternalEmailInfo, Email } from '../types';
 /**
  * 创建临时邮箱
  * API: POST /welcome/change_mailbox (空 body)
  * 返回: { success, data: { email_address, expired_at, created_at, ... } }
  * 需要保存响应中的 Set-Cookie (awamail_session) 用于后续获取邮件
  */
-export declare function generateEmail(): Promise<EmailInfo>;
+export declare function generateEmail(): Promise<InternalEmailInfo>;
 /**
  * 获取邮件列表
  * API: GET /welcome/get_emails

package/dist/providers/awamail.js

@@ -88,4 +88,4 @@ async function getEmails(token, email) {
     const rawEmails = data.data.emails || [];
     return rawEmails.map((raw) => (0, normalize_1.normalizeEmail)(raw, email));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/chatgpt-org-uk.d.ts

@@ -1,3 +1,3 @@
-import { EmailInfo, Email } from '../types';
-export declare function generateEmail(): Promise<EmailInfo>;
+import { InternalEmailInfo, Email } from '../types';
+export declare function generateEmail(): Promise<InternalEmailInfo>;
 export declare function getEmails(email: string): Promise<Email[]>;

package/dist/providers/chatgpt-org-uk.js

@@ -48,4 +48,4 @@ async function getEmails(email) {
     const rawEmails = data.data?.emails || [];
     return rawEmails.map((raw) => (0, normalize_1.normalizeEmail)(raw, email));
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhdGdwdC1vcmctdWsuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmlkZXJzL2NoYXRncHQtb3JnLXVrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBaUJBLHNDQW9CQztBQUVELDhCQW1CQztBQXpERCw0Q0FBOEM7QUFFOUMsTUFBTSxPQUFPLEdBQVksZ0JBQWdCLENBQUM7QUFDMUMsTUFBTSxRQUFRLEdBQUcsaUNBQWlDLENBQUM7QUFFbkQsTUFBTSxlQUFlLEdBQUc7SUFDdEIsWUFBWSxFQUFFLGlIQUFpSDtJQUMvSCxjQUFjLEVBQUUsa0JBQWtCO0lBQ2xDLFFBQVEsRUFBRSxLQUFLO0lBQ2YsU0FBUyxFQUFFLDhCQUE4QjtJQUN6QyxXQUFXLEVBQUUsb0VBQW9FO0lBQ2pGLGtCQUFrQixFQUFFLElBQUk7SUFDeEIsb0JBQW9CLEVBQUUsV0FBVztJQUNqQyxLQUFLLEVBQUUsR0FBRztDQUNYLENBQUM7QUFFSyxLQUFLLFVBQVUsYUFBYTtJQUNqQyxNQUFNLFFBQVEsR0FBRyxNQUFNLEtBQUssQ0FBQyxHQUFHLFFBQVEsaUJBQWlCLEVBQUU7UUFDekQsTUFBTSxFQUFFLEtBQUs7UUFDYixPQUFPLEVBQUUsZUFBZTtLQUN6QixDQUFDLENBQUM7SUFFSCxJQUFJLENBQUMsUUFBUSxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQ2pCLE1BQU0sSUFBSSxLQUFLLENBQUMsNkJBQTZCLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQ2xFLENBQUM7SUFFRCxNQUFNLElBQUksR0FBRyxNQUFNLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUVuQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2xCLE1BQU0sSUFBSSxLQUFLLENBQUMsMEJBQTBCLENBQUMsQ0FBQztJQUM5QyxDQUFDO0lBRUQsT0FBTztRQUNMLE9BQU8sRUFBRSxPQUFPO1FBQ2hCLEtBQUssRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUs7S0FDdkIsQ0FBQztBQUNKLENBQUM7QUFFTSxLQUFLLFVBQVUsU0FBUyxDQUFDLEtBQWE7SUFDM0MsTUFBTSxZQUFZLEdBQUcsa0JBQWtCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDL0MsTUFBTSxRQUFRLEdBQUcsTUFBTSxLQUFLLENBQUMsR0FBRyxRQUFRLGlCQUFpQixZQUFZLEVBQUUsRUFBRTtRQUN2RSxNQUFNLEVBQUUsS0FBSztRQUNiLE9BQU8sRUFBRSxlQUFlO0tBQ3pCLENBQUMsQ0FBQztJQUVILElBQUksQ0FBQyxRQUFRLENBQUMsRUFBRSxFQUFFLENBQUM7UUFDakIsTUFBTSxJQUFJLEtBQUssQ0FBQyx5QkFBeUIsUUFBUSxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7SUFDOUQsQ0FBQztJQUVELE1BQU0sSUFBSSxHQUFHLE1BQU0sUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO0lBRW5DLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDbEIsTUFBTSxJQUFJLEtBQUssQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFFRCxNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsSUFBSSxFQUFFLE1BQU0sSUFBSSxFQUFFLENBQUM7SUFDMUMsT0FBTyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBUSxFQUFFLEVBQUUsQ0FBQyxJQUFBLDBCQUFjLEVBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUM7QUFDakUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVtYWlsSW5mbywgRW1haWwsIENoYW5uZWwgfSBmcm9tICcuLi90eXBlcyc7XG5pbXBvcnQgeyBub3JtYWxpemVFbWFpbCB9IGZyb20gJy4uL25vcm1hbGl6ZSc7XG5cbmNvbnN0IENIQU5ORUw6IENoYW5uZWwgPSAnY2hhdGdwdC1vcmctdWsnO1xuY29uc3QgQkFTRV9VUkwgPSAnaHR0cHM6Ly9tYWlsLmNoYXRncHQub3JnLnVrL2FwaSc7XG5cbmNvbnN0IERFRkFVTFRfSEVBREVSUyA9IHtcbiAgJ1VzZXItQWdlbnQnOiAnTW96aWxsYS81LjAgKFdpbmRvd3MgTlQgMTAuMDsgV2luNjQ7IHg2NCkgQXBwbGVXZWJLaXQvNTM3LjM2IChLSFRNTCwgbGlrZSBHZWNrbykgQ2hyb21lLzE0My4wLjAuMCBTYWZhcmkvNTM3LjM2JyxcbiAgJ0NvbnRlbnQtVHlwZSc6ICdhcHBsaWNhdGlvbi9qc29uJyxcbiAgJ0FjY2VwdCc6ICcqLyonLFxuICAnUmVmZXJlcic6ICdodHRwczovL21haWwuY2hhdGdwdC5vcmcudWsvJyxcbiAgJ3NlYy1jaC11YSc6ICdcIk1pY3Jvc29mdCBFZGdlXCI7dj1cIjE0M1wiLCBcIkNocm9taXVtXCI7dj1cIjE0M1wiLCBcIk5vdCBBKEJyYW5kXCI7dj1cIjI0XCInLFxuICAnc2VjLWNoLXVhLW1vYmlsZSc6ICc/MCcsXG4gICdzZWMtY2gtdWEtcGxhdGZvcm0nOiAnXCJXaW5kb3dzXCInLFxuICAnRE5UJzogJzEnLFxufTtcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGdlbmVyYXRlRW1haWwoKTogUHJvbWlzZTxFbWFpbEluZm8+IHtcbiAgY29uc3QgcmVzcG9uc2UgPSBhd2FpdCBmZXRjaChgJHtCQVNFX1VSTH0vZ2VuZXJhdGUtZW1haWxgLCB7XG4gICAgbWV0aG9kOiAnR0VUJyxcbiAgICBoZWFkZXJzOiBERUZBVUxUX0hFQURFUlMsXG4gIH0pO1xuXG4gIGlmICghcmVzcG9uc2Uub2spIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYEZhaWxlZCB0byBnZW5lcmF0ZSBlbWFpbDogJHtyZXNwb25zZS5zdGF0dXN9YCk7XG4gIH1cblxuICBjb25zdCBkYXRhID0gYXdhaXQgcmVzcG9uc2UuanNvbigpO1xuICBcbiAgaWYgKCFkYXRhLnN1Y2Nlc3MpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ0ZhaWxlZCB0byBnZW5lcmF0ZSBlbWFpbCcpO1xuICB9XG5cbiAgcmV0dXJuIHtcbiAgICBjaGFubmVsOiBDSEFOTkVMLFxuICAgIGVtYWlsOiBkYXRhLmRhdGEuZW1haWwsXG4gIH07XG59XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBnZXRFbWFpbHMoZW1haWw6IHN0cmluZyk6IFByb21pc2U8RW1haWxbXT4ge1xuICBjb25zdCBlbmNvZGVkRW1haWwgPSBlbmNvZGVVUklDb21wb25lbnQoZW1haWwpO1xuICBjb25zdCByZXNwb25zZSA9IGF3YWl0IGZldGNoKGAke0JBU0VfVVJMfS9lbWFpbHM/ZW1haWw9JHtlbmNvZGVkRW1haWx9YCwge1xuICAgIG1ldGhvZDogJ0dFVCcsXG4gICAgaGVhZGVyczogREVGQVVMVF9IRUFERVJTLFxuICB9KTtcblxuICBpZiAoIXJlc3BvbnNlLm9rKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKGBGYWlsZWQgdG8gZ2V0IGVtYWlsczogJHtyZXNwb25zZS5zdGF0dXN9YCk7XG4gIH1cblxuICBjb25zdCBkYXRhID0gYXdhaXQgcmVzcG9uc2UuanNvbigpO1xuICBcbiAgaWYgKCFkYXRhLnN1Y2Nlc3MpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ0ZhaWxlZCB0byBnZXQgZW1haWxzJyk7XG4gIH1cblxuICBjb25zdCByYXdFbWFpbHMgPSBkYXRhLmRhdGE/LmVtYWlscyB8fCBbXTtcbiAgcmV0dXJuIHJhd0VtYWlscy5tYXAoKHJhdzogYW55KSA9PiBub3JtYWxpemVFbWFpbChyYXcsIGVtYWlsKSk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/dropmail.d.ts

@@ -1,10 +1,10 @@
-import { EmailInfo, Email } from '../types';
+import { InternalEmailInfo, Email } from '../types';
 /**
  * 创建临时邮箱
  * GraphQL mutation: introduceSession
  * 返回 session ID (存入 token) 和邮箱地址
  */
-export declare function generateEmail(): Promise<EmailInfo>;
+export declare function generateEmail(): Promise<InternalEmailInfo>;
 /**
  * 获取邮件列表
  * GraphQL query: session(id) { mails {...} }

package/dist/providers/dropmail.js

@@ -83,4 +83,4 @@ async function getEmails(token, email) {
     const mails = data?.session?.mails || [];
     return mails.map((mail) => (0, normalize_1.normalizeEmail)(flattenMessage(mail, email), email));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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