tempmail-sdk 1.0.2 → 1.0.3

package/dist/index.d.ts

@@ -1,25 +1,118 @@
 import { Channel, EmailInfo, GetEmailsResult, GenerateEmailOptions, GetEmailsOptions } from './types';
 export { Channel, EmailInfo, Email, EmailAttachment, GetEmailsResult, GenerateEmailOptions, GetEmailsOptions } from './types';
 export { normalizeEmail } from './normalize';
+export { withRetry, fetchWithTimeout, RetryOptions } from './retry';
+export { LogLevel, LogHandler, setLogLevel, getLogLevel, setLogger, logger } from './logger';
+/**
+ * 渠道信息，包含渠道标识、显示名称和对应网站
+ */
 export interface ChannelInfo {
+    /** 渠道标识 */
     channel: Channel;
+    /** 渠道显示名称 */
     name: string;
+    /** 对应的临时邮箱服务网站 */
     website: string;
 }
 /**
  * 获取所有支持的渠道列表
+ *
+ * @returns 所有渠道的信息数组
+ *
+ * @example
+ * ```ts
+ * const channels = listChannels();
+ * channels.forEach(ch => console.log(`${ch.name} (${ch.website})`));
+ * ```
  */
 export declare function listChannels(): ChannelInfo[];
 /**
- * 获取指定渠道信息
+ * 获取指定渠道的详细信息
+ *
+ * @param channel - 渠道标识
+ * @returns 渠道信息，不存在时返回 undefined
  */
 export declare function getChannelInfo(channel: Channel): ChannelInfo | undefined;
+/**
+ * 创建临时邮箱
+ *
+ * 错误处理策略：
+ * - 网络错误、超时、服务端 5xx 错误 → 自动重试（默认 2 次，指数退避）
+ * - 4xx 客户端错误、参数错误 → 直接抛出异常
+ *
+ * @param options - 创建选项，可指定渠道、有效时长、域名等
+ * @returns 邮箱信息，包含地址、令牌等
+ * @throws 重试耗尽后仍失败时抛出异常
+ *
+ * @example
+ * ```ts
+ * const emailInfo = await generateEmail({ channel: 'temp-mail-io' });
+ * console.log(emailInfo.email); // 临时邮箱地址
+ * ```
+ */
 export declare function generateEmail(options?: GenerateEmailOptions): Promise<EmailInfo>;
+/**
+ * 获取邮件列表
+ *
+ * 错误处理策略：
+ * - 网络错误、超时、服务端 5xx 错误 → 自动重试（默认 2 次）
+ * - 重试耗尽后返回 { success: false, emails: [] }，不抛异常
+ * - 参数校验错误（缺少 channel / token）直接抛出
+ *
+ * 这种设计让调用方在轮询场景下不会因网络波动而中断整个流程，
+ * 只需检查 success 字段即可判断本次请求是否成功。
+ *
+ * @param options - 获取选项，包含渠道、邮箱地址、令牌
+ * @returns 邮件结果，包含 success 标记和邮件列表
+ *
+ * @example
+ * ```ts
+ * const result = await getEmails({
+ *   channel: emailInfo.channel,
+ *   email: emailInfo.email,
+ *   token: emailInfo.token,
+ * });
+ * if (result.success && result.emails.length > 0) {
+ *   console.log('收到邮件:', result.emails[0].subject);
+ * }
+ * ```
+ */
 export declare function getEmails(options: GetEmailsOptions): Promise<GetEmailsResult>;
+/**
+ * 临时邮箱客户端
+ * 封装了邮箱创建和邮件获取的完整流程，自动管理邮箱信息和认证令牌
+ *
+ * @example
+ * ```ts
+ * const client = new TempEmailClient();
+ * const emailInfo = await client.generate({ channel: 'mail-tm' });
+ * console.log('邮箱:', emailInfo.email);
+ *
+ * // 轮询获取邮件
+ * const result = await client.getEmails();
+ * if (result.success) {
+ *   console.log('邮件数:', result.emails.length);
+ * }
+ * ```
+ */
 export declare class TempEmailClient {
     private emailInfo;
+    /**
+     * 创建临时邮箱并缓存邮箱信息
+     * 后续调用 getEmails() 时自动使用此邮箱的渠道、地址和令牌
+     */
     generate(options?: GenerateEmailOptions): Promise<EmailInfo>;
+    /**
+     * 获取当前邮箱的邮件列表
+     * 必须先调用 generate() 创建邮箱
+     *
+     * @throws 未调用 generate() 时抛出异常
+     */
     getEmails(): Promise<GetEmailsResult>;
+    /**
+     * 获取当前缓存的邮箱信息
+     * 未调用 generate() 时返回 null
+     */
     getEmailInfo(): EmailInfo | null;
 }
 declare const _default: {

package/dist/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TempEmailClient = exports.normalizeEmail = void 0;
+exports.TempEmailClient = 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,20 @@ 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 retry_1 = require("./retry");
+const logger_1 = require("./logger");
 var normalize_1 = require("./normalize");
 Object.defineProperty(exports, "normalizeEmail", { enumerable: true, get: function () { return normalize_1.normalizeEmail; } });
+var retry_2 = require("./retry");
+Object.defineProperty(exports, "withRetry", { enumerable: true, get: function () { return retry_2.withRetry; } });
+Object.defineProperty(exports, "fetchWithTimeout", { enumerable: true, get: function () { return retry_2.fetchWithTimeout; } });
+var logger_2 = require("./logger");
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_2.LogLevel; } });
+Object.defineProperty(exports, "setLogLevel", { enumerable: true, get: function () { return logger_2.setLogLevel; } });
+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; } });
+/** 渠道名称到 provider 实现的映射表 */
 const providers = {
     'tempmail': tempmail,
     'linshi-email': linshiEmail,
@@ -60,7 +72,9 @@ const providers = {
     'mail-tm': mailTm,
     'dropmail': dropmail,
 };
+/** 所有支持的渠道列表，用于随机选择和遍历 */
 const allChannels = ['tempmail', 'linshi-email', 'tempmail-lol', 'chatgpt-org-uk', 'tempmail-la', 'temp-mail-io', 'awamail', 'mail-tm', 'dropmail'];
+/** 渠道信息映射表 */
 const channelInfoMap = {
     'tempmail': { channel: 'tempmail', name: 'TempMail', website: 'tempmail.ing' },
     'linshi-email': { channel: 'linshi-email', name: '临时邮箱', website: 'linshi-email.com' },
@@ -74,18 +88,56 @@ const channelInfoMap = {
 };
 /**
  * 获取所有支持的渠道列表
+ *
+ * @returns 所有渠道的信息数组
+ *
+ * @example
+ * ```ts
+ * const channels = listChannels();
+ * channels.forEach(ch => console.log(`${ch.name} (${ch.website})`));
+ * ```
  */
 function listChannels() {
     return allChannels.map(ch => channelInfoMap[ch]);
 }
 /**
- * 获取指定渠道信息
+ * 获取指定渠道的详细信息
+ *
+ * @param channel - 渠道标识
+ * @returns 渠道信息，不存在时返回 undefined
  */
 function getChannelInfo(channel) {
     return channelInfoMap[channel];
 }
+/**
+ * 创建临时邮箱
+ *
+ * 错误处理策略：
+ * - 网络错误、超时、服务端 5xx 错误 → 自动重试（默认 2 次，指数退避）
+ * - 4xx 客户端错误、参数错误 → 直接抛出异常
+ *
+ * @param options - 创建选项，可指定渠道、有效时长、域名等
+ * @returns 邮箱信息，包含地址、令牌等
+ * @throws 重试耗尽后仍失败时抛出异常
+ *
+ * @example
+ * ```ts
+ * const emailInfo = await generateEmail({ channel: 'temp-mail-io' });
+ * 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;
+}
+/**
+ * 单次创建邮箱（不含重试逻辑）
+ * 根据渠道类型分发到对应的 provider 实现
+ */
+async function generateEmailOnce(channel, options) {
     switch (channel) {
         case 'tempmail':
             return tempmail.generateEmail(options.duration || 30);
@@ -109,6 +161,32 @@ async function generateEmail(options = {}) {
             throw new Error(`Unknown channel: ${channel}`);
     }
 }
+/**
+ * 获取邮件列表
+ *
+ * 错误处理策略：
+ * - 网络错误、超时、服务端 5xx 错误 → 自动重试（默认 2 次）
+ * - 重试耗尽后返回 { success: false, emails: [] }，不抛异常
+ * - 参数校验错误（缺少 channel / token）直接抛出
+ *
+ * 这种设计让调用方在轮询场景下不会因网络波动而中断整个流程，
+ * 只需检查 success 字段即可判断本次请求是否成功。
+ *
+ * @param options - 获取选项，包含渠道、邮箱地址、令牌
+ * @returns 邮件结果，包含 success 标记和邮件列表
+ *
+ * @example
+ * ```ts
+ * const result = await getEmails({
+ *   channel: emailInfo.channel,
+ *   email: emailInfo.email,
+ *   token: emailInfo.token,
+ * });
+ * if (result.success && result.emails.length > 0) {
+ *   console.log('收到邮件:', result.emails[0].subject);
+ * }
+ * ```
+ */
 async function getEmails(options) {
     const { channel, email, token } = options;
     if (!channel) {
@@ -117,65 +195,97 @@ async function getEmails(options) {
     if (!email && channel !== 'tempmail-lol') {
         throw new Error('Email is required');
     }
-    let emails = [];
+    logger_1.logger.debug(`获取邮件, 渠道: ${channel}, 邮箱: ${email}`);
+    try {
+        const emails = await (0, retry_1.withRetry)(() => getEmailsOnce(channel, email, token), options.retry);
+        if (emails.length > 0) {
+            logger_1.logger.info(`获取到 ${emails.length} 封邮件, 渠道: ${channel}`);
+        }
+        else {
+            logger_1.logger.debug(`暂无邮件, 渠道: ${channel}`);
+        }
+        return { channel, email, emails, success: true };
+    }
+    catch (err) {
+        /*
+         * 重试耗尽后仍然失败 → 返回空结果而非抛异常
+         * 这样调用方在轮询场景下不会因为一次网络波动而中断整个流程
+         */
+        logger_1.logger.error(`获取邮件失败, 渠道: ${channel}, 错误: ${err.message || err}`);
+        return { channel, email, emails: [], success: false };
+    }
+}
+/**
+ * 单次获取邮件（不含重试逻辑）
+ * 根据渠道类型分发到对应的 provider 实现，并校验必需的 token 参数
+ */
+async function getEmailsOnce(channel, email, token) {
     switch (channel) {
         case 'tempmail':
-            emails = await tempmail.getEmails(email);
-            break;
+            return tempmail.getEmails(email);
         case 'linshi-email':
-            emails = await linshiEmail.getEmails(email);
-            break;
+            return linshiEmail.getEmails(email);
         case 'tempmail-lol':
-            if (!token) {
+            if (!token)
                 throw new Error('Token is required for tempmail-lol channel');
-            }
-            emails = await tempmailLol.getEmails(token, email);
-            break;
+            return tempmailLol.getEmails(token, email);
         case 'chatgpt-org-uk':
-            emails = await chatgptOrgUk.getEmails(email);
-            break;
+            return chatgptOrgUk.getEmails(email);
         case 'tempmail-la':
-            emails = await tempmailLa.getEmails(email);
-            break;
+            return tempmailLa.getEmails(email);
         case 'temp-mail-io':
-            emails = await tempMailIO.getEmails(email);
-            break;
+            return tempMailIO.getEmails(email);
         case 'awamail':
-            if (!token) {
+            if (!token)
                 throw new Error('Token is required for awamail channel');
-            }
-            emails = await awamail.getEmails(token, email);
-            break;
+            return awamail.getEmails(token, email);
         case 'mail-tm':
-            if (!token) {
+            if (!token)
                 throw new Error('Token is required for mail-tm channel');
-            }
-            emails = await mailTm.getEmails(token, email);
-            break;
+            return mailTm.getEmails(token, email);
         case 'dropmail':
-            if (!token) {
+            if (!token)
                 throw new Error('Token is required for dropmail channel');
-            }
-            emails = await dropmail.getEmails(token, email);
-            break;
+            return dropmail.getEmails(token, email);
         default:
             throw new Error(`Unknown channel: ${channel}`);
     }
-    return {
-        channel,
-        email,
-        emails,
-        success: true,
-    };
 }
+/**
+ * 临时邮箱客户端
+ * 封装了邮箱创建和邮件获取的完整流程，自动管理邮箱信息和认证令牌
+ *
+ * @example
+ * ```ts
+ * const client = new TempEmailClient();
+ * const emailInfo = await client.generate({ channel: 'mail-tm' });
+ * console.log('邮箱:', emailInfo.email);
+ *
+ * // 轮询获取邮件
+ * const result = await client.getEmails();
+ * if (result.success) {
+ *   console.log('邮件数:', result.emails.length);
+ * }
+ * ```
+ */
 class TempEmailClient {
     constructor() {
         this.emailInfo = null;
     }
+    /**
+     * 创建临时邮箱并缓存邮箱信息
+     * 后续调用 getEmails() 时自动使用此邮箱的渠道、地址和令牌
+     */
     async generate(options = {}) {
         this.emailInfo = await generateEmail(options);
         return this.emailInfo;
     }
+    /**
+     * 获取当前邮箱的邮件列表
+     * 必须先调用 generate() 创建邮箱
+     *
+     * @throws 未调用 generate() 时抛出异常
+     */
     async getEmails() {
         if (!this.emailInfo) {
             throw new Error('No email generated. Call generate() first.');
@@ -186,6 +296,10 @@ class TempEmailClient {
             token: this.emailInfo.token,
         });
     }
+    /**
+     * 获取当前缓存的邮箱信息
+     * 未调用 generate() 时返回 null
+     */
     getEmailInfo() {
         return this.emailInfo;
     }
@@ -198,4 +312,4 @@ exports.default = {
     getEmails,
     TempEmailClient,
 };
-//# 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';\n\nexport { Channel, EmailInfo, Email, EmailAttachment, GetEmailsResult, GenerateEmailOptions, GetEmailsOptions } from './types';\nexport { normalizeEmail } from './normalize';\n\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\nconst allChannels: Channel[] = ['tempmail', 'linshi-email', 'tempmail-lol', 'chatgpt-org-uk', 'tempmail-la', 'temp-mail-io', 'awamail', 'mail-tm', 'dropmail'];\n\nexport interface ChannelInfo {\n  channel: Channel;\n  name: string;\n  website: string;\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 */\nexport function listChannels(): ChannelInfo[] {\n  return allChannels.map(ch => channelInfoMap[ch]);\n}\n\n/**\n * 获取指定渠道信息\n */\nexport function getChannelInfo(channel: Channel): ChannelInfo | undefined {\n  return channelInfoMap[channel];\n}\n\nexport async function generateEmail(options: GenerateEmailOptions = {}): Promise<EmailInfo> {\n  const channel = options.channel || allChannels[Math.floor(Math.random() * allChannels.length)];\n  \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\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  let emails: Email[] = [];\n\n  switch (channel) {\n    case 'tempmail':\n      emails = await tempmail.getEmails(email);\n      break;\n    case 'linshi-email':\n      emails = await linshiEmail.getEmails(email);\n      break;\n    case 'tempmail-lol':\n      if (!token) {\n        throw new Error('Token is required for tempmail-lol channel');\n      }\n      emails = await tempmailLol.getEmails(token, email);\n      break;\n    case 'chatgpt-org-uk':\n      emails = await chatgptOrgUk.getEmails(email);\n      break;\n    case 'tempmail-la':\n      emails = await tempmailLa.getEmails(email);\n      break;\n    case 'temp-mail-io':\n      emails = await tempMailIO.getEmails(email);\n      break;\n    case 'awamail':\n      if (!token) {\n        throw new Error('Token is required for awamail channel');\n      }\n      emails = await awamail.getEmails(token, email);\n      break;\n    case 'mail-tm':\n      if (!token) {\n        throw new Error('Token is required for mail-tm channel');\n      }\n      emails = await mailTm.getEmails(token, email);\n      break;\n    case 'dropmail':\n      if (!token) {\n        throw new Error('Token is required for dropmail channel');\n      }\n      emails = await dropmail.getEmails(token, email);\n      break;\n    default:\n      throw new Error(`Unknown channel: ${channel}`);\n  }\n\n  return {\n    channel,\n    email,\n    emails,\n    success: true,\n  };\n}\n\nexport class TempEmailClient {\n  private emailInfo: EmailInfo | null = null;\n\n  async generate(options: GenerateEmailOptions = {}): Promise<EmailInfo> {\n    this.emailInfo = await generateEmail(options);\n    return this.emailInfo;\n  }\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  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 { 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"]}

package/dist/logger.d.ts

@@ -0,0 +1,73 @@
+/**
+ * SDK 日志模块
+ * 提供分级日志能力，支持自定义日志处理器
+ * 默认静默不输出，用户可通过 setLogLevel / setLogger 启用
+ */
+/**
+ * 日志级别枚举
+ * 数值越小级别越高，设置某级别后只输出该级别及以上的日志
+ */
+export declare enum LogLevel {
+    /** 关闭所有日志 */
+    SILENT = 0,
+    /** 错误日志：请求失败、重试耗尽等 */
+    ERROR = 1,
+    /** 警告日志：重试中、降级处理等 */
+    WARN = 2,
+    /** 信息日志：请求开始、完成等关键流程 */
+    INFO = 3,
+    /** 调试日志：请求详情、响应内容等 */
+    DEBUG = 4
+}
+/**
+ * 日志处理器接口
+ * 用户可实现此接口来自定义日志输出方式（如写文件、发送到远程等）
+ */
+export interface LogHandler {
+    error(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+}
+/**
+ * 设置日志级别
+ * 默认 SILENT（不输出任何日志）
+ *
+ * @example
+ * ```ts
+ * import { setLogLevel, LogLevel } from 'tempmail-sdk';
+ * setLogLevel(LogLevel.DEBUG); // 开启所有日志
+ * setLogLevel(LogLevel.INFO);  // 只输出 INFO 及以上
+ * ```
+ */
+export declare function setLogLevel(level: LogLevel): void;
+/**
+ * 获取当前日志级别
+ */
+export declare function getLogLevel(): LogLevel;
+/**
+ * 设置自定义日志处理器
+ * 替换默认的 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),
+ * });
+ * ```
+ */
+export declare function setLogger(handler: LogHandler): void;
+/**
+ * SDK 内部日志工具
+ * 根据当前日志级别过滤输出
+ */
+export declare const logger: {
+    error(msg: string, ...args: any[]): void;
+    warn(msg: string, ...args: any[]): void;
+    info(msg: string, ...args: any[]): void;
+    debug(msg: string, ...args: any[]): void;
+};

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;