@mikkelscheike/email-provider-links 2.6.1 → 2.7.1

package/dist/api.js

@@ -30,13 +30,13 @@ const loader_1 = require("./loader");
  * ```typescript
  * // Consumer email
  * const gmail = await getEmailProvider('user@gmail.com');
- * console.log(gmail.provider?.name); // "Gmail"
- * console.log(gmail.loginUrl);       // "https://mail.google.com/mail/"
+ * console.log(gmail.provider?.companyProvider); // "Gmail"
+ * console.log(gmail.loginUrl);                  // "https://mail.google.com/mail/"
  *
  * // Business domain
  * const business = await getEmailProvider('user@mycompany.com');
- * console.log(business.provider?.name); // "Google Workspace" (if detected)
- * console.log(business.detectionMethod); // "mx_record"
+ * console.log(business.provider?.companyProvider); // "Google Workspace" (if detected)
+ * console.log(business.detectionMethod);          // "mx_record"
  *
  * // Error handling
  * const invalid = await getEmailProvider('invalid-email');
@@ -102,9 +102,11 @@ async function getEmailProvider(email, timeout) {
             provider: concurrentResult.provider,
             email,
             loginUrl: concurrentResult.provider?.loginUrl || null,
-            detectionMethod: concurrentResult.detectionMethod || undefined,
-            proxyService: concurrentResult.proxyService
+            detectionMethod: concurrentResult.detectionMethod || 'mx_record'
         };
+        if (concurrentResult.proxyService) {
+            result.proxyService = concurrentResult.proxyService;
+        }
         // Add error context for null results
         if (!result.provider && !result.proxyService) {
             result.error = {
@@ -118,7 +120,7 @@ async function getEmailProvider(email, timeout) {
         // Enhanced error handling
         if (error.message?.includes('Rate limit exceeded')) {
             const retryMatch = error.message.match(/Try again in (\d+) seconds/);
-            const retryAfter = retryMatch ? parseInt(retryMatch[1]) : undefined;
+            const retryAfter = retryMatch ? parseInt(retryMatch[1], 10) : undefined;
             return {
                 provider: null,
                 email,
@@ -126,7 +128,7 @@ async function getEmailProvider(email, timeout) {
                 error: {
                     type: 'RATE_LIMITED',
                     message: 'DNS query rate limit exceeded',
-                    retryAfter
+                    ...(retryAfter !== undefined ? { retryAfter } : {})
                 }
             };
         }
@@ -165,7 +167,7 @@ async function getEmailProvider(email, timeout) {
  * ```typescript
  * // Works for known domains
  * const gmail = getEmailProviderSync('user@gmail.com');
- * console.log(gmail.provider?.name); // "Gmail"
+ * console.log(gmail.provider?.companyProvider); // "Gmail"
  *
  * // Unknown domains return null
  * const unknown = getEmailProviderSync('user@mycompany.com');
@@ -322,7 +324,6 @@ function emailsMatch(email1, email2) {
     const normalized2 = normalizeEmail(email2);
     return normalized1 === normalized2;
 }
-// Note: EmailProvider type is defined above
 /**
  * Enhanced email provider detection with concurrent DNS for maximum performance.
  * This function uses parallel MX/TXT lookups for 2x faster business domain detection.
@@ -401,12 +402,11 @@ async function getEmailProviderFast(email, options = {}) {
             enableParallel,
             collectDebugInfo
         });
-        return {
+        const fastResult = {
             provider: concurrentResult.provider,
             email,
             loginUrl: concurrentResult.provider?.loginUrl || null,
-            detectionMethod: concurrentResult.detectionMethod || undefined,
-            proxyService: concurrentResult.proxyService,
+            detectionMethod: concurrentResult.detectionMethod || 'mx_record',
             timing: concurrentResult.timing,
             confidence: concurrentResult.confidence,
             debug: concurrentResult.debug,
@@ -415,6 +415,10 @@ async function getEmailProviderFast(email, options = {}) {
                 message: `No email provider found for domain: ${domain}`
             } : undefined
         };
+        if (concurrentResult.proxyService) {
+            fastResult.proxyService = concurrentResult.proxyService;
+        }
+        return fastResult;
     }
     catch (error) {
         return {
@@ -437,3 +441,4 @@ exports.Config = {
     SUPPORTED_PROVIDERS_COUNT: 93,
     SUPPORTED_DOMAINS_COUNT: 180
 };
+//# sourceMappingURL=api.js.map

package/dist/concurrent-dns.d.ts

@@ -62,7 +62,7 @@ export interface ConcurrentDNSResult {
         conflicts: boolean;
         queries: DNSQueryResult[];
         fallbackUsed: boolean;
-    };
+    } | undefined;
 }
 /**
  * Concurrent DNS Detection Engine
@@ -130,3 +130,4 @@ export declare function createConcurrentDNSDetector(providers: EmailProvider[],
  * Utility function for quick concurrent DNS detection
  */
 export declare function detectProviderConcurrent(domain: string, providers: EmailProvider[], config?: Partial<ConcurrentDNSConfig>): Promise<ConcurrentDNSResult>;
+//# sourceMappingURL=concurrent-dns.d.ts.map

package/dist/concurrent-dns.js

@@ -28,6 +28,8 @@ const DEFAULT_CONFIG = {
  * Concurrent DNS Detection Engine
  */
 class ConcurrentDNSDetector {
+    // Store active query states
+    activeQueries = new Set();
     // Cleanup method for tests
     cleanup() {
         // Cancel any in-progress timeouts
@@ -38,9 +40,9 @@ class ConcurrentDNSDetector {
         this.activeQueries.clear();
         return Promise.resolve();
     }
+    config;
+    providers;
     constructor(providers, config = {}) {
-        // Store active query states
-        this.activeQueries = new Set();
         this.config = { ...DEFAULT_CONFIG, ...config };
         this.providers = providers.filter(p => p.customDomainDetection &&
             (p.customDomainDetection.mxPatterns || p.customDomainDetection.txtPatterns));
@@ -154,13 +156,20 @@ class ConcurrentDNSDetector {
         // and potentially ignore TXT timing for performance reporting
         const mxResult = mappedResults[0];
         const txtResult = mappedResults[1];
-        if (mxResult.success && this.hasMXMatch(mxResult) && this.config.prioritizeMX) {
+        if (mxResult && mxResult.success && this.hasMXMatch(mxResult) && this.config.prioritizeMX) {
             // Create an optimized TXT result that indicates it wasn't needed
             const optimizedTxtResult = {
-                ...txtResult,
-                timing: 0, // Don't count TXT time if MX was sufficient
-                optimized: true
+                type: 'txt',
+                success: txtResult?.success || false,
+                records: txtResult?.records || [],
+                timing: 0 // Don't count TXT time if MX was sufficient
             };
+            if (txtResult?.error) {
+                optimizedTxtResult.error = txtResult.error;
+            }
+            if (txtResult?.rawResponse) {
+                optimizedTxtResult.rawResponse = txtResult.rawResponse;
+            }
             return [mxResult, optimizedTxtResult];
         }
         return mappedResults;
@@ -323,9 +332,9 @@ class ConcurrentDNSDetector {
         if (matches.length === 0)
             return null;
         if (matches.length === 1)
-            return matches[0];
+            return matches[0] ?? null;
         // Sort by confidence and preference for MX records
-        return matches.sort((a, b) => {
+        const sortedMatches = matches.sort((a, b) => {
             // Prioritize MX records if configured
             if (this.config.prioritizeMX) {
                 if (a.method === 'mx_record' && b.method !== 'mx_record')
@@ -335,7 +344,8 @@ class ConcurrentDNSDetector {
             }
             // Then by confidence
             return b.confidence - a.confidence;
-        })[0];
+        });
+        return sortedMatches.length > 0 ? (sortedMatches[0] ?? null) : null;
     }
     /**
      * Check if MX result has potential matches (for sequential optimization)
@@ -428,3 +438,4 @@ async function detectProviderConcurrent(domain, providers, config) {
     const detector = createConcurrentDNSDetector(providers, config);
     return detector.detectProvider(domain);
 }
+//# sourceMappingURL=concurrent-dns.js.map

package/dist/hash-verifier.d.ts

@@ -91,3 +91,4 @@ export declare function createProviderManifest(providers: any[]): {
     urlHashes: Record<string, string>;
     manifestHash: string;
 };
+//# sourceMappingURL=hash-verifier.d.ts.map

package/dist/hash-verifier.js

@@ -29,7 +29,7 @@ const KNOWN_GOOD_HASHES = {
     // SHA-256 hash of the legitimate emailproviders.json
     'emailproviders.json': 'f77814bf0537019c6f38bf2744ae21640f04a2d39cb67c5116f6e03160c9486f',
     // You can add hashes for other critical files
-    'package.json': '1057de7ce3b03211001dcc6e4533de5f5e64760a287418f994682ba2684cf53b'
+    'package.json': '67927e7e27636b55dc1fee5e34f16bbbf721a33103b0bc94c3c42923e2325cef'
 };
 /**
  * Calculates SHA-256 hash of a file or string content
@@ -281,3 +281,4 @@ function createProviderManifest(providers) {
         manifestHash
     };
 }
+//# sourceMappingURL=hash-verifier.js.map

package/dist/idn.d.ts

@@ -44,3 +44,4 @@ export declare function validateInternationalEmail(email: string): {
     code: IDNValidationError;
     message: string;
 } | undefined;
+//# sourceMappingURL=idn.d.ts.map

package/dist/idn.js

@@ -246,3 +246,4 @@ function validateInternationalEmail(email) {
     // If we get here, the email is valid
     return undefined;
 }
+//# sourceMappingURL=idn.js.map

package/dist/index.d.ts

@@ -1,59 +1,202 @@
 /**
  * Email Provider Links
  *
- * A clean, modern email provider detection library with:
+ * A modern, robust email provider detection library with:
  * - 93+ verified email providers covering 180+ domains
  * - Concurrent DNS detection for business domains
  * - Zero runtime dependencies
- * - Comprehensive error handling
- * - Email alias normalization
+ * - Comprehensive error handling with detailed context
+ * - International email validation (IDN support)
+ * - Email alias normalization and deduplication
+ * - Enterprise-grade security features
  *
  * @author Email Provider Links Team
  * @license MIT
+ * @version 2.7.0
  */
 export { getEmailProvider, getEmailProviderSync, getEmailProviderFast, normalizeEmail, emailsMatch, Config } from './api';
 export type { EmailProvider, EmailProviderResult } from './api';
 export { loadProviders } from './loader';
 export { detectProviderConcurrent } from './concurrent-dns';
+export { validateInternationalEmail, emailToPunycode, domainToPunycode } from './idn';
 export type { ConcurrentDNSConfig, ConcurrentDNSResult } from './concurrent-dns';
+/**
+ * Enhanced email validation with comprehensive error reporting
+ *
+ * @param email - Email address to validate
+ * @returns Validation result with detailed error information
+ *
+ * @example
+ * ```typescript
+ * const result = validateEmailAddress('user@example.com');
+ * if (result.isValid) {
+ *   console.log('Email is valid');
+ * } else {
+ *   console.log('Error:', result.error.message);
+ * }
+ * ```
+ */
+export declare function validateEmailAddress(email: string): {
+    isValid: boolean;
+    normalizedEmail?: string;
+    error?: {
+        type: string;
+        code: string;
+        message: string;
+    };
+};
+import { loadProviders } from './loader';
 import { getEmailProvider, getEmailProviderSync, getEmailProviderFast, normalizeEmail, emailsMatch } from './api';
+import { detectProviderConcurrent } from './concurrent-dns';
+import { validateInternationalEmail } from './idn';
 /**
- * Get list of all supported email providers
- * @returns Array of all email providers in the database
+ * Get comprehensive list of all supported email providers
+ *
+ * @returns Array of all email providers with metadata
+ *
+ * @example
+ * ```typescript
+ * const providers = getSupportedProviders();
+ * console.log(`Supports ${providers.length} providers`);
+ *
+ * const gmailProvider = providers.find(p => p.domains.includes('gmail.com'));
+ * console.log(gmailProvider?.companyProvider); // "Gmail"
+ * ```
  */
 export declare function getSupportedProviders(): import("./api").EmailProvider[];
 /**
- * Check if an email provider is supported
+ * Check if an email provider is supported (synchronous)
+ *
  * @param email - Email address to check
  * @returns true if the provider is supported
+ *
+ * @example
+ * ```typescript
+ * if (isEmailProviderSupported('user@gmail.com')) {
+ *   console.log('Gmail is supported');
+ * }
+ * ```
  */
 export declare function isEmailProviderSupported(email: string): boolean;
 /**
- * Extract domain from email address
+ * Extract and normalize domain from email address
+ *
  * @param email - Email address
- * @returns Domain portion or null if invalid
+ * @returns Normalized domain portion or null if invalid
+ *
+ * @example
+ * ```typescript
+ * const domain = extractDomain('USER@GMAIL.COM');
+ * console.log(domain); // "gmail.com"
+ *
+ * const invalid = extractDomain('invalid-email');
+ * console.log(invalid); // null
+ * ```
  */
 export declare function extractDomain(email: string): string | null;
 /**
- * Validate email format
+ * Validate email format using enhanced rules
+ *
  * @param email - Email address to validate
  * @returns true if valid format
+ *
+ * @example
+ * ```typescript
+ * if (isValidEmail('user@example.com')) {
+ *   console.log('Email format is valid');
+ * }
+ *
+ * if (isValidEmail('user@münchen.de')) {
+ *   console.log('International domain is valid');
+ * }
+ * ```
  */
 export declare function isValidEmail(email: string): boolean;
 /**
- * Library metadata
+ * Get library metadata and statistics
+ *
+ * @returns Object with current library statistics
+ *
+ * @example
+ * ```typescript
+ * const stats = getLibraryStats();
+ * console.log(`Supports ${stats.providerCount} providers across ${stats.domainCount} domains`);
+ * ```
+ */
+export declare function getLibraryStats(): {
+    providerCount: number;
+    domainCount: number;
+    version: string;
+    supportsAsync: boolean;
+    supportsIDN: boolean;
+    supportsAliasDetection: boolean;
+    supportsConcurrentDNS: boolean;
+};
+/**
+ * Batch process multiple email addresses efficiently
+ *
+ * @param emails - Array of email addresses to process
+ * @param options - Processing options
+ * @returns Array of results in the same order as input
+ *
+ * @example
+ * ```typescript
+ * const emails = ['user@gmail.com', 'test@yahoo.com', 'invalid-email'];
+ * const results = batchProcessEmails(emails);
+ *
+ * results.forEach((result, index) => {
+ *   console.log(`${emails[index]}: ${result.isValid ? 'Valid' : 'Invalid'}`);
+ * });
+ * ```
+ */
+export declare function batchProcessEmails(emails: string[], options?: {
+    includeProviderInfo?: boolean;
+    normalizeEmails?: boolean;
+    deduplicateAliases?: boolean;
+}): Array<{
+    email: string;
+    isValid: boolean;
+    provider?: string | null;
+    loginUrl?: string | null;
+    normalized?: string;
+    isDuplicate?: boolean;
+    error?: string;
+}>;
+/**
+ * @deprecated Use validateEmailAddress instead for better error handling
+ */
+export declare const isValidEmailAddress: typeof isValidEmail;
+/**
+ * Library metadata (legacy constants)
  */
 export declare const PROVIDER_COUNT = 93;
 export declare const DOMAIN_COUNT = 178;
 /**
  * Default export for convenience
+ *
+ * @example
+ * ```typescript
+ * import EmailProviderLinks from '@mikkelscheike/email-provider-links';
+ *
+ * const result = await EmailProviderLinks.getEmailProvider('user@gmail.com');
+ * ```
  */
 declare const _default: {
     getEmailProvider: typeof getEmailProvider;
     getEmailProviderSync: typeof getEmailProviderSync;
     getEmailProviderFast: typeof getEmailProviderFast;
+    validateEmailAddress: typeof validateEmailAddress;
+    isValidEmail: typeof isValidEmail;
     normalizeEmail: typeof normalizeEmail;
     emailsMatch: typeof emailsMatch;
+    getSupportedProviders: typeof getSupportedProviders;
+    isEmailProviderSupported: typeof isEmailProviderSupported;
+    extractDomain: typeof extractDomain;
+    getLibraryStats: typeof getLibraryStats;
+    batchProcessEmails: typeof batchProcessEmails;
+    loadProviders: typeof loadProviders;
+    detectProviderConcurrent: typeof detectProviderConcurrent;
+    validateInternationalEmail: typeof validateInternationalEmail;
     Config: {
         readonly DEFAULT_DNS_TIMEOUT: 5000;
         readonly MAX_DNS_REQUESTS_PER_MINUTE: 10;
@@ -64,3 +207,8 @@ declare const _default: {
     DOMAIN_COUNT: number;
 };
 export default _default;
+/**
+ * Version information
+ */
+export declare const VERSION = "2.7.0";
+//# sourceMappingURL=index.d.ts.map