@mikkelscheike/email-provider-links 1.6.0 → 1.8.0

package/dist/loader.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Provider Data Loader
+ *
+ * Handles loading email provider data with performance optimizations.
+ */
+import { EmailProvider } from './index';
+/**
+ * Loading statistics for performance monitoring
+ */
+interface LoadingStats {
+    fileSize: number;
+    loadTime: number;
+    providerCount: number;
+    domainCount: number;
+}
+/**
+ * Build optimized domain-to-provider lookup map
+ */
+export declare function buildDomainMap(providers: EmailProvider[]): Map<string, EmailProvider>;
+/**
+ * Clear all caches (useful for testing or hot reloading)
+ */
+export declare function clearCache(): void;
+/**
+ * Get loading statistics from the last load operation
+ */
+export declare function getLoadingStats(): LoadingStats | null;
+/**
+ * Load all providers with optimized domain map for production
+ */
+export declare function loadProviders(): {
+    providers: EmailProvider[];
+    domainMap: Map<string, EmailProvider>;
+    stats: LoadingStats;
+};
+/**
+ * Load providers with debug information
+ */
+export declare function loadProvidersDebug(): {
+    providers: EmailProvider[];
+    domainMap: Map<string, EmailProvider>;
+    stats: LoadingStats;
+};
+export {};

package/dist/loader.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * Provider Data Loader
+ *
+ * Handles loading email provider data with performance optimizations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDomainMap = buildDomainMap;
+exports.clearCache = clearCache;
+exports.getLoadingStats = getLoadingStats;
+exports.loadProviders = loadProviders;
+exports.loadProvidersDebug = loadProvidersDebug;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const schema_1 = require("./schema");
+/**
+ * Internal cached data
+ */
+let cachedProviders = null;
+let cachedDomainMap = null;
+let loadingStats = null;
+/**
+ * Default loader configuration
+ */
+const DEFAULT_CONFIG = {
+    debug: false
+};
+/**
+ * Convert compressed provider to EmailProvider format
+ */
+function convertProviderToEmailProvider(compressedProvider) {
+    const provider = {
+        companyProvider: compressedProvider.name,
+        loginUrl: compressedProvider.url,
+        domains: compressedProvider.domains || []
+    };
+    // Convert DNS detection patterns
+    if (compressedProvider.mx?.length || compressedProvider.txt?.length) {
+        provider.customDomainDetection = {};
+        if (compressedProvider.mx?.length) {
+            provider.customDomainDetection.mxPatterns = compressedProvider.mx;
+        }
+        if (compressedProvider.txt?.length) {
+            // Decompress TXT patterns
+            provider.customDomainDetection.txtPatterns = compressedProvider.txt.map(schema_1.decompressTxtPattern);
+        }
+    }
+    return provider;
+}
+/**
+ * Internal provider data loader with configuration
+ */
+function loadProvidersInternal(config = {}) {
+    const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+    const startTime = Date.now();
+    // Return cached data if available
+    if (cachedProviders && !mergedConfig.debug) {
+        return {
+            providers: cachedProviders,
+            stats: loadingStats
+        };
+    }
+    try {
+        // Determine file path
+        const basePath = (0, path_1.join)(__dirname, '..', 'providers');
+        const dataPath = mergedConfig.path || (0, path_1.join)(basePath, 'emailproviders.json');
+        if (mergedConfig.debug)
+            console.log('🔄 Loading provider data...');
+        const content = (0, fs_1.readFileSync)(dataPath, 'utf8');
+        const data = JSON.parse(content);
+        // Validate format
+        if (!data.version || !data.providers || !Array.isArray(data.providers)) {
+            throw new Error('Invalid provider data format');
+        }
+        const providers = data.providers.map(convertProviderToEmailProvider);
+        const fileSize = content.length;
+        if (mergedConfig.debug) {
+            console.log(`✅ Loaded ${providers.length} providers`);
+            console.log(`📊 File size: ${(fileSize / 1024).toFixed(1)} KB`);
+        }
+        const loadTime = Date.now() - startTime;
+        const domainCount = providers.reduce((sum, p) => sum + p.domains.length, 0);
+        // Cache the results
+        cachedProviders = providers;
+        loadingStats = {
+            fileSize,
+            loadTime,
+            providerCount: providers.length,
+            domainCount
+        };
+        if (mergedConfig.debug) {
+            console.log(`⚡ Loading completed in ${loadTime}ms`);
+            console.log(`📊 Stats: ${providers.length} providers, ${domainCount} domains`);
+        }
+        return {
+            providers,
+            stats: loadingStats
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to load provider data: ${errorMessage}`);
+    }
+}
+/**
+ * Build optimized domain-to-provider lookup map
+ */
+function buildDomainMap(providers) {
+    if (cachedDomainMap) {
+        return cachedDomainMap;
+    }
+    const startTime = Date.now();
+    const domainMap = new Map();
+    for (const provider of providers) {
+        for (const domain of provider.domains) {
+            domainMap.set(domain.toLowerCase(), provider);
+        }
+    }
+    cachedDomainMap = domainMap;
+    if (loadingStats) {
+        console.log(`🗺️  Domain map built in ${Date.now() - startTime}ms (${domainMap.size} entries)`);
+    }
+    return domainMap;
+}
+/**
+ * Clear all caches (useful for testing or hot reloading)
+ */
+function clearCache() {
+    cachedProviders = null;
+    cachedDomainMap = null;
+    loadingStats = null;
+}
+/**
+ * Get loading statistics from the last load operation
+ */
+function getLoadingStats() {
+    return loadingStats;
+}
+/**
+ * Load all providers with optimized domain map for production
+ */
+function loadProviders() {
+    const { providers, stats } = loadProvidersInternal({ debug: false });
+    const domainMap = buildDomainMap(providers);
+    return { providers, domainMap, stats };
+}
+/**
+ * Load providers with debug information
+ */
+function loadProvidersDebug() {
+    clearCache(); // Always reload in debug mode
+    const { providers, stats } = loadProvidersInternal({ debug: true });
+    const domainMap = buildDomainMap(providers);
+    return { providers, domainMap, stats };
+}

package/dist/schema.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Provider Data Schema
+ *
+ * This represents the compressed format for provider data
+ * designed to reduce file size and improve parsing performance.
+ */
+/**
+ * Provider interface
+ * Uses compact field names for smaller JSON size
+ */
+export interface Provider {
+    /** Provider ID (short identifier) */
+    id: string;
+    /** Provider display name */
+    name: string;
+    /** Login/webmail URL */
+    url: string;
+    /** Email domains (omitted if empty) */
+    domains?: string[];
+    /** DNS detection patterns (flattened) */
+    mx?: string[];
+    txt?: string[];
+    /** Alias capabilities */
+    alias?: {
+        dots?: boolean;
+        plus?: boolean;
+    };
+}
+/**
+ * Providers file structure
+ */
+export interface ProvidersData {
+    /** Schema version for future migrations */
+    version: string;
+    /** Compressed providers array */
+    providers: Provider[];
+    /** Metadata */
+    meta: {
+        count: number;
+        domains: number;
+        generated: string;
+    };
+}
+/**
+ * Common TXT pattern prefixes that can be compressed
+ */
+export declare const TXT_PATTERN_COMPRESSION: {
+    readonly 'v=spf1 include:': "spf:";
+    readonly 'v=spf1 ': "spf1:";
+    readonly 'google-site-verification=': "gsv:";
+    readonly 'MS=ms': "ms";
+    readonly 'zoho-verification=': "zv:";
+    readonly 'mailgun-verification=': "mv:";
+};
+/**
+ * Compress TXT patterns by removing common prefixes
+ */
+export declare function compressTxtPattern(pattern: string): string;
+/**
+ * Decompress TXT patterns by restoring prefixes
+ */
+export declare function decompressTxtPattern(compressed: string): string;
+/**
+ * Validation schema for providers
+ */
+export declare function validateProvider(provider: Provider): string[];

package/dist/schema.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Provider Data Schema
+ *
+ * This represents the compressed format for provider data
+ * designed to reduce file size and improve parsing performance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TXT_PATTERN_COMPRESSION = void 0;
+exports.compressTxtPattern = compressTxtPattern;
+exports.decompressTxtPattern = decompressTxtPattern;
+exports.validateProvider = validateProvider;
+/**
+ * Common TXT pattern prefixes that can be compressed
+ */
+exports.TXT_PATTERN_COMPRESSION = {
+    'v=spf1 include:': 'spf:',
+    'v=spf1 ': 'spf1:',
+    'google-site-verification=': 'gsv:',
+    'MS=ms': 'ms',
+    'zoho-verification=': 'zv:',
+    'mailgun-verification=': 'mv:'
+};
+/**
+ * Compress TXT patterns by removing common prefixes
+ */
+function compressTxtPattern(pattern) {
+    for (const [prefix, compressed] of Object.entries(exports.TXT_PATTERN_COMPRESSION)) {
+        if (pattern.startsWith(prefix)) {
+            return compressed + pattern.substring(prefix.length);
+        }
+    }
+    return pattern;
+}
+/**
+ * Decompress TXT patterns by restoring prefixes
+ */
+function decompressTxtPattern(compressed) {
+    for (const [prefix, compressedPrefix] of Object.entries(exports.TXT_PATTERN_COMPRESSION)) {
+        if (compressed.startsWith(compressedPrefix)) {
+            return prefix + compressed.substring(compressedPrefix.length);
+        }
+    }
+    return compressed;
+}
+/**
+ * Validation schema for providers
+ */
+function validateProvider(provider) {
+    const errors = [];
+    if (!provider.id || typeof provider.id !== 'string') {
+        errors.push('Provider ID is required and must be a string');
+    }
+    if (!provider.name || typeof provider.name !== 'string') {
+        errors.push('Provider name is required and must be a string');
+    }
+    if (!provider.url || typeof provider.url !== 'string') {
+        errors.push('Provider URL is required and must be a string');
+    }
+    else if (!provider.url.startsWith('https://')) {
+        errors.push('Provider URL must use HTTPS');
+    }
+    if (provider.domains && !Array.isArray(provider.domains)) {
+        errors.push('Domains must be an array');
+    }
+    if (provider.mx && !Array.isArray(provider.mx)) {
+        errors.push('MX patterns must be an array');
+    }
+    if (provider.txt && !Array.isArray(provider.txt)) {
+        errors.push('TXT patterns must be an array');
+    }
+    return errors;
+}

package/dist/security/hash-verifier.js

@@ -27,9 +27,9 @@ const path_1 = require("path");
  */
 const KNOWN_GOOD_HASHES = {
     // SHA-256 hash of the legitimate emailproviders.json
-    'emailproviders.json': '1c7925d02cc66b487046afdce81f744bd7a42f5a489e16e53a1a979575e4473b',
+    'emailproviders.json': 'f77814bf0537019c6f38bf2744ae21640f04a2d39cb67c5116f6e03160c9486f',
     // You can add hashes for other critical files
-    'package.json': 'ba2810fd51f2d044890119e6f49926b80d822a4cafedaff25e3f91ba8ec65c2f'
+    'package.json': '874ac6e2398fcc48e373bd2f7d06a7bd861725c5a299d5d1b6beac92490d037d'
 };
 /**
  * Calculates SHA-256 hash of a file or string content

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikkelscheike/email-provider-links",
-  "version": "1.6.0",
-  "description": "A TypeScript package providing direct links to 74 email providers (147+ domains) with enterprise security features, rate limiting, and comprehensive international coverage for login and password reset flows",
+  "version": "1.8.0",
+  "description": "TypeScript library for email provider detection with 93 providers (178 domains), concurrent DNS resolution, optimized performance, 91.75% test coverage, and enterprise security for login and password reset flows",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -30,6 +30,11 @@
     "gmail",
     "outlook",
     "yahoo",
+    "alias-detection",
+    "email-normalization",
+    "plus-addressing",
+    "fraud-prevention",
+    "deduplication",
     "typescript",
     "npm",
     "utility"