ynkap-payment
Version:
Module de paiement Y-Nkap pour Angular - Intégration simple des paiements mobiles (Orange Money, MTN Mobile Money)
1 lines • 158 kB
Source Map (JSON)
{"version":3,"file":"ynkap-payment.mjs","sources":["../../../projects/ynkap/src/lib/ynkap.service.ts","../../../projects/ynkap/src/lib/configuration/configuration.service.ts","../../../projects/ynkap/src/lib/ynkap.component.ts","../../../projects/ynkap/src/lib/error-handling/models/error.model.ts","../../../projects/ynkap/src/lib/error-handling/error-handling.service.ts","../../../projects/ynkap/src/lib/auth/auth.service.ts","../../../projects/ynkap/src/lib/payment/retry/retry.service.ts","../../../projects/ynkap/src/lib/shared/logos-base64.ts","../../../projects/ynkap/src/lib/shared/logo.service.ts","../../../projects/ynkap/src/lib/payment/payment.service.ts","../../../projects/ynkap/src/lib/configuration/configuration/configuration.component.ts","../../../projects/ynkap/src/lib/configuration/configuration/configuration.component.html","../../../projects/ynkap/src/lib/configuration/configuration.module.ts","../../../projects/ynkap/src/lib/payment/payment/payment.animations.ts","../../../projects/ynkap/src/lib/shared/pipes/fcfa.pipe.ts","../../../projects/ynkap/src/lib/payment/payment/payment.component.ts","../../../projects/ynkap/src/lib/payment/payment/payment.component.html","../../../projects/ynkap/src/lib/shared/shared.module.ts","../../../projects/ynkap/src/lib/payment/payment.module.ts","../../../projects/ynkap/src/lib/error-handling/error-handling/error-handling.component.ts","../../../projects/ynkap/src/lib/error-handling/error-handling/error-handling.component.html","../../../projects/ynkap/src/lib/error-handling/error-handling.module.ts","../../../projects/ynkap/src/lib/shared/modal-stability.service.ts","../../../projects/ynkap/src/lib/pay-button/pay-button.component.ts","../../../projects/ynkap/src/lib/pay-button/pay-button.component.html","../../../projects/ynkap/src/lib/pay-button/pay-button.module.ts","../../../projects/ynkap/src/lib/ynkap.module.ts","../../../projects/ynkap/src/public-api.ts","../../../projects/ynkap/src/ynkap-payment.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\n\n@Injectable({\n providedIn: 'root'\n})\nexport class YnkapService {\n\n constructor() { }\n}\n","import { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { ApiConfig } from './models/api-config.model';\n\n@Injectable({\n providedIn: 'root'\n})\nexport class ConfigurationService {\n private readonly defaultApiBaseUrl = 'https://api.ynkap.com/v1';\n private readonly sandboxApiBaseUrl = 'https://sandbox.api.ynkap.com/v1';\n \n private configSubject = new BehaviorSubject<ApiConfig | null>(null);\n private initialized = false;\n private _apiUrl = 'https://api.ynkap.com/v1';\n\n /**\n * Get the current API configuration\n */\n get config$(): Observable<ApiConfig | null> {\n return this.configSubject.asObservable();\n }\n\n /**\n * Get the current API configuration synchronously\n */\n get currentConfig(): ApiConfig | null {\n return this.configSubject.getValue();\n }\n\n get apiUrl(): string {\n return this._apiUrl;\n }\n\n set apiUrl(url: string) {\n this._apiUrl = url;\n }\n\n constructor() { }\n\n /**\n * Initialize the module with API configuration\n * @param config The API configuration\n * @returns True if initialization was successful, false otherwise\n */\n initialize(config: ApiConfig): boolean {\n if (!this.validateConfig(config)) {\n console.error('Y-Nkap: Invalid configuration provided');\n return false;\n }\n\n // Set defaults if not provided\n const completeConfig: ApiConfig = {\n ...config,\n environment: config.environment || 'production',\n apiBaseUrl: config.apiBaseUrl || (config.environment === 'sandbox' ? this.sandboxApiBaseUrl : this.defaultApiBaseUrl)\n };\n\n this.configSubject.next(completeConfig);\n this.initialized = true;\n return true;\n }\n\n /**\n * Check if the module has been initialized\n */\n isInitialized(): boolean {\n return this.initialized;\n }\n\n /**\n * Reset the configuration\n */\n reset(): void {\n this.configSubject.next(null);\n this.initialized = false;\n }\n\n /**\n * Update part of the configuration\n * @param partialConfig Partial configuration to update\n * @returns True if update was successful, false otherwise\n */\n updateConfig(partialConfig: Partial<ApiConfig>): boolean {\n const currentConfig = this.currentConfig;\n if (!currentConfig) {\n console.error('Y-Nkap: Cannot update config before initialization');\n return false;\n }\n\n const updatedConfig = { ...currentConfig, ...partialConfig };\n if (!this.validateConfig(updatedConfig)) {\n console.error('Y-Nkap: Invalid configuration update');\n return false;\n }\n\n this.configSubject.next(updatedConfig);\n return true;\n }\n\n /**\n * Validate API configuration\n * @param config The API configuration to validate\n * @returns True if configuration is valid, false otherwise\n */\n private validateConfig(config: ApiConfig): boolean {\n // Check if required fields are present and not empty\n if (!config.apiKey || config.apiKey.trim() === '') {\n console.error('Y-Nkap: API Key is required');\n return false;\n }\n\n if (!config.apiSecret || config.apiSecret.trim() === '') {\n console.error('Y-Nkap: API Secret is required');\n return false;\n }\n\n if (!config.merchantId || config.merchantId.trim() === '') {\n console.error('Y-Nkap: Merchant ID is required');\n return false;\n }\n\n // Validate environment if provided\n if (config.environment && !['production', 'sandbox'].includes(config.environment)) {\n console.error('Y-Nkap: Environment must be either \"production\" or \"sandbox\"');\n return false;\n }\n\n return true;\n }\n}\n","import { Component, Inject, Input, OnInit, Optional } from '@angular/core';\nimport { ConfigurationService } from './configuration/configuration.service';\nimport { ApiConfig } from './configuration/models/api-config.model';\n\n@Component({\n selector: 'lib-ynkap',\n template: `\n <div class=\"ynkap-container\">\n <!-- Message d'accueil ou d'erreur -->\n <div *ngIf=\"!isInitialized\" class=\"ynkap-error-message\">\n Y-Nkap n'est pas initialisé. Veuillez fournir une configuration valide avec vos clés d'API.\n </div>\n \n <!-- Message de bienvenue si initialisé -->\n <div *ngIf=\"isInitialized\" class=\"ynkap-welcome\">\n <div class=\"ynkap-logo\">\n <img src=\"https://placeholder-for-ynkap-logo.svg\" alt=\"Y-Nkap\" />\n </div>\n <h2 class=\"ynkap-title\">Y-Nkap - La passerelle de paiement sécurisée</h2>\n <p class=\"ynkap-description\">\n Intégrez facilement les paiements en ligne dans votre application avec Y-Nkap.\n Utilisez les composants spécifiques pour accéder aux fonctionnalités :\n </p>\n <ul class=\"ynkap-components-list\">\n <li><code><lib-ynkap-payment></code> - Module de paiement</li>\n <li><code><lib-configuration></code> - Configuration de l'API</li>\n </ul>\n <div class=\"ynkap-version\">Version: {{version}}</div>\n </div>\n </div>\n `,\n styles: [`\n .ynkap-container {\n font-family: 'Roboto', 'Segoe UI', Arial, sans-serif;\n padding: 20px;\n border-radius: 8px;\n background-color: #f9f9f9;\n color: #333;\n max-width: 600px;\n margin: 0 auto;\n }\n \n .ynkap-error-message {\n background-color: #ffeaea;\n border-left: 4px solid #f44336;\n padding: 12px 15px;\n border-radius: 4px;\n color: #d32f2f;\n font-size: 0.9rem;\n }\n \n .ynkap-welcome {\n text-align: center;\n }\n \n .ynkap-logo {\n margin: 0 auto 20px;\n width: 80px;\n height: 80px;\n background-color: #007bff;\n border-radius: 50%;\n display: flex;\n align-items: center;\n justify-content: center;\n color: white;\n font-weight: bold;\n font-size: 1.5rem;\n }\n \n .ynkap-title {\n font-size: 1.5rem;\n color: #2c3e50;\n margin-bottom: 15px;\n }\n \n .ynkap-description {\n font-size: 1rem;\n line-height: 1.5;\n color: #666;\n margin-bottom: 20px;\n }\n \n .ynkap-components-list {\n text-align: left;\n width: max-content;\n margin: 0 auto 20px;\n padding-left: 20px;\n }\n \n .ynkap-components-list li {\n margin-bottom: 8px;\n }\n \n .ynkap-components-list code {\n background-color: #e9ecef;\n padding: 2px 6px;\n border-radius: 4px;\n color: #007bff;\n font-family: monospace;\n }\n \n .ynkap-version {\n font-size: 0.8rem;\n color: #999;\n margin-top: 20px;\n }\n `]\n})\nexport class YnkapComponent implements OnInit {\n /**\n * Version actuelle du module Y-Nkap\n */\n version = '1.0.0-dev';\n \n /**\n * Indique si le module est correctement initialisé\n */\n isInitialized = false;\n \n /**\n * Configuration optionnelle fournie directement au composant\n */\n @Input() config?: ApiConfig;\n \n constructor(\n private configService: ConfigurationService,\n @Optional() @Inject('Y_NKAP_CONFIG') private moduleConfig?: ApiConfig\n ) {}\n \n ngOnInit(): void {\n // Vérifie si le service est déjà initialisé\n this.isInitialized = this.configService.isInitialized();\n \n // Si non initialisé mais config disponible, initialiser\n if (!this.isInitialized) {\n // Priorité à la config fournie par input, puis celle du module\n const config = this.config || this.moduleConfig;\n if (config) {\n this.isInitialized = this.configService.initialize(config);\n }\n }\n }\n \n /**\n * Initialise manuellement le module Y-Nkap avec une configuration\n * @param config Configuration de l'API Y-Nkap\n * @returns true si l'initialisation a réussi, false sinon\n */\n initialize(config: ApiConfig): boolean {\n this.isInitialized = this.configService.initialize(config);\n return this.isInitialized;\n }\n}\n","/**\n * Interface for Y-Nkap API Error\n */\nexport interface YnkapError {\n /**\n * Error code\n */\n code: string;\n \n /**\n * Human-readable error message\n */\n message: string;\n \n /**\n * Timestamp when the error occurred\n */\n timestamp: Date;\n \n /**\n * Detailed information about the error\n */\n details?: any;\n \n /**\n * Original error object if available\n */\n originalError?: any;\n \n /**\n * HTTP status code associated with the error\n */\n httpStatus?: number;\n \n /**\n * Indicates if the operation can be retried\n */\n retryable?: boolean;\n \n /**\n * Suggested wait time in milliseconds before retrying\n */\n retryAfterMs?: number;\n}\n\n/**\n * Enum for error categories\n */\nexport enum ErrorCategory {\n NETWORK = 'NETWORK',\n AUTHENTICATION = 'AUTHENTICATION',\n AUTHORIZATION = 'AUTHORIZATION',\n VALIDATION = 'VALIDATION',\n PAYMENT_PROCESSING = 'PAYMENT_PROCESSING',\n SERVER = 'SERVER',\n UNKNOWN = 'UNKNOWN'\n}\n\n/**\n * Interface for error retry options\n */\nexport interface RetryOptions {\n /**\n * Maximum number of retry attempts\n */\n maxRetries: number;\n \n /**\n * Base time in milliseconds to wait between retries (will be used with exponential backoff)\n */\n baseDelayMs: number;\n \n /**\n * Maximum time in milliseconds to wait between retries\n */\n maxDelayMs: number;\n \n /**\n * List of error codes or categories that should not be retried\n */\n nonRetryableErrors?: string[];\n \n /**\n * Callback function to execute before each retry attempt\n */\n onRetry?: (error: YnkapError, attemptNumber: number) => void;\n}\n\nexport class YnkapError extends Error {\n constructor(\n public code: string,\n public override message: string,\n public details?: any\n ) {\n super(message);\n this.name = 'YnkapError';\n Object.setPrototypeOf(this, YnkapError.prototype);\n }\n}\n","import { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable, throwError, timer } from 'rxjs';\nimport { mergeMap } from 'rxjs/operators';\nimport { ErrorCategory, RetryOptions, YnkapError } from './models/error.model';\n\n@Injectable({\n providedIn: 'root'\n})\nexport class ErrorHandlingService {\n private errorSubject = new BehaviorSubject<YnkapError | null>(null);\n \n // Default retry options\n private defaultRetryOptions: RetryOptions = {\n maxRetries: 3,\n baseDelayMs: 1000,\n maxDelayMs: 10000,\n nonRetryableErrors: [\n ErrorCategory.AUTHENTICATION,\n ErrorCategory.AUTHORIZATION,\n ErrorCategory.VALIDATION\n ]\n };\n\n constructor() {}\n\n handleError(error: any): void {\n let ynkapError: YnkapError;\n\n if (error instanceof YnkapError) {\n ynkapError = error;\n } else {\n ynkapError = new YnkapError(\n error.code || 'UNKNOWN_ERROR',\n error.message || 'Une erreur inattendue est survenue',\n error.details\n );\n }\n\n this.errorSubject.next(ynkapError);\n console.error('Y-Nkap Error:', ynkapError);\n }\n\n getError(): Observable<YnkapError | null> {\n return this.errorSubject.asObservable();\n }\n\n clearError(): void {\n this.errorSubject.next(null);\n }\n\n /**\n * Apply retry logic with exponential backoff for failed operations\n * @param error The error that occurred\n * @param retryFn Function to retry\n * @param options Retry options\n * @returns An observable that will retry the operation\n */\n retryWithBackoff<T>(error: YnkapError, retryFn: () => Observable<T>, options?: Partial<RetryOptions>): Observable<T> {\n const retryOpts: RetryOptions = { ...this.defaultRetryOptions, ...options };\n \n // Check if error is retryable\n if (!error.retryable) {\n return throwError(() => error);\n }\n \n // Check if the error type is in the non-retryable list\n if (retryOpts.nonRetryableErrors?.includes(error.code)) {\n return throwError(() => error);\n }\n \n // Check if we've exceeded max retries\n const attemptNumber = (error.details?.attemptNumber || 0) + 1;\n if (attemptNumber > retryOpts.maxRetries) {\n return throwError(() => error);\n }\n \n // Calculate backoff delay with exponential increase\n const delayMs = Math.min(\n retryOpts.baseDelayMs * Math.pow(2, attemptNumber - 1),\n retryOpts.maxDelayMs\n );\n \n // Call the onRetry callback if provided\n if (retryOpts.onRetry) {\n retryOpts.onRetry(error, attemptNumber);\n }\n \n // Update attempt number in error details\n error.details = { ...error.details, attemptNumber };\n \n // Wait for the delay then retry\n return timer(delayMs).pipe(\n mergeMap(() => retryFn())\n );\n }\n\n /**\n * Convert any error to a standardized YnkapError\n * @param error The error to convert\n * @param context Optional context information\n * @returns A standardized YnkapError\n */\n private convertToYnkapError(error: any, context?: string): YnkapError {\n const timestamp = new Date();\n // HTTP errors\n if (error && error.status) {\n const httpStatus = error.status;\n const errorBody = error.error || {};\n let category: ErrorCategory;\n let retryable = false;\n switch (true) {\n case httpStatus === 401:\n category = ErrorCategory.AUTHENTICATION;\n retryable = false;\n break;\n case httpStatus === 403:\n category = ErrorCategory.AUTHORIZATION;\n retryable = false;\n break;\n case httpStatus >= 400 && httpStatus < 500:\n category = ErrorCategory.VALIDATION;\n retryable = false;\n break;\n case httpStatus >= 500:\n category = ErrorCategory.SERVER;\n retryable = true;\n break;\n default:\n category = ErrorCategory.UNKNOWN;\n retryable = true;\n }\n return new YnkapError(\n errorBody.code || category,\n errorBody.message || `Error ${httpStatus}: ${error.statusText || 'Unknown HTTP error'}`,\n {\n details: errorBody.details || {},\n originalError: error,\n httpStatus,\n retryable,\n timestamp\n }\n );\n } \n // Network errors\n else if (error instanceof TypeError && error.message.includes('network')) {\n return new YnkapError(\n ErrorCategory.NETWORK,\n 'Network error: Could not connect to Y-Nkap API',\n {\n originalError: error,\n retryable: true,\n retryAfterMs: 3000,\n timestamp\n }\n );\n } \n // Other errors\n else {\n return new YnkapError(\n ErrorCategory.UNKNOWN,\n error?.message || 'An unknown error occurred',\n {\n originalError: error,\n retryable: true,\n details: { context },\n timestamp\n }\n );\n }\n }\n}\n","import { Injectable } from '@angular/core';\r\nimport { BehaviorSubject, Observable } from 'rxjs';\r\n\r\n@Injectable({\r\n providedIn: 'root'\r\n})\r\nexport class AuthService {\r\n private apiKeySubject = new BehaviorSubject<string | null>(null);\r\n private isAuthenticatedSubject = new BehaviorSubject<boolean>(false);\r\n\r\n constructor() {\r\n // Vérifier si une clé API existe dans le localStorage\r\n const savedApiKey = localStorage.getItem('ynkap_api_key');\r\n if (savedApiKey) {\r\n this.setApiKey(savedApiKey);\r\n }\r\n }\r\n\r\n /**\r\n * Définit la clé API Y-Nkap\r\n * @param apiKey La clé API à utiliser\r\n */\r\n setApiKey(apiKey: string): void {\r\n if (!this.validateApiKey(apiKey)) {\r\n throw new Error('Clé API invalide');\r\n }\r\n localStorage.setItem('ynkap_api_key', apiKey);\r\n this.apiKeySubject.next(apiKey);\r\n this.isAuthenticatedSubject.next(true);\r\n }\r\n\r\n /**\r\n * Récupère la clé API actuelle\r\n * @returns Observable de la clé API\r\n */\r\n getApiKey(): Observable<string | null> {\r\n return this.apiKeySubject.asObservable();\r\n }\r\n\r\n /**\r\n * Vérifie si l'utilisateur est authentifié\r\n * @returns Observable de l'état d'authentification\r\n */\r\n isAuthenticated(): Observable<boolean> {\r\n return this.isAuthenticatedSubject.asObservable();\r\n }\r\n\r\n /**\r\n * Déconnecte l'utilisateur\r\n */\r\n logout(): void {\r\n localStorage.removeItem('ynkap_api_key');\r\n this.apiKeySubject.next(null);\r\n this.isAuthenticatedSubject.next(false);\r\n }\r\n\r\n /**\r\n * Valide le format de la clé API\r\n * @param apiKey La clé API à valider\r\n * @returns true si la clé est valide\r\n */\r\n private validateApiKey(apiKey: string): boolean {\r\n // Format attendu : ykap_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\r\n const apiKeyRegex = /^ynkap_[a-zA-Z0-9]{32}$/;\r\n return apiKeyRegex.test(apiKey);\r\n }\r\n} ","import { Injectable } from '@angular/core';\nimport { Observable, timer, throwError, switchMap, tap } from 'rxjs';\nimport { YnkapError, RetryOptions, ErrorCategory } from '../../error-handling/models/error.model';\n\nexport interface RetryState {\n attemptNumber: number;\n maxRetries: number;\n nextRetryDelayMs: number;\n canRetry: boolean;\n lastError?: YnkapError;\n transactionId?: string;\n}\n\n@Injectable({\n providedIn: 'root'\n})\nexport class RetryService {\n private retryStates = new Map<string, RetryState>();\n \n private defaultRetryOptions: RetryOptions = {\n maxRetries: 3,\n baseDelayMs: 1000,\n maxDelayMs: 30000,\n nonRetryableErrors: [\n ErrorCategory.AUTHENTICATION,\n ErrorCategory.AUTHORIZATION,\n ErrorCategory.VALIDATION\n ]\n };\n\n /**\n * Initialize retry state for a transaction\n */\n initializeRetryState(transactionId: string, options?: Partial<RetryOptions>): RetryState {\n const retryOptions = { ...this.defaultRetryOptions, ...options };\n \n const state: RetryState = {\n attemptNumber: 0,\n maxRetries: retryOptions.maxRetries,\n nextRetryDelayMs: retryOptions.baseDelayMs,\n canRetry: true,\n transactionId\n };\n \n this.retryStates.set(transactionId, state);\n return state;\n }\n\n /**\n * Get retry state for a transaction\n */\n getRetryState(transactionId: string): RetryState | null {\n return this.retryStates.get(transactionId) || null;\n }\n\n /**\n * Check if an error is retryable\n */\n isRetryable(error: YnkapError, options?: Partial<RetryOptions>): boolean {\n const retryOptions = { ...this.defaultRetryOptions, ...options };\n\n // Check if error explicitly says it's not retryable\n if (error.retryable === false) {\n return false;\n }\n\n // Check if error category is in non-retryable list\n if (retryOptions.nonRetryableErrors?.includes(error.code as ErrorCategory)) {\n return false;\n }\n\n // Network errors are usually retryable\n if (error.code === ErrorCategory.NETWORK) {\n return true;\n }\n\n // Server errors (5xx) are retryable\n if (error.httpStatus && error.httpStatus >= 500) {\n return true;\n }\n\n // Payment processing errors might be retryable\n if (error.code === ErrorCategory.PAYMENT_PROCESSING) {\n return true;\n }\n\n // Default to retryable if not explicitly set to false\n return error.retryable === undefined || error.retryable === true;\n }\n\n /**\n * Calculate next retry delay with exponential backoff\n */\n calculateRetryDelay(attemptNumber: number, options?: Partial<RetryOptions>): number {\n const retryOptions = { ...this.defaultRetryOptions, ...options };\n \n // Exponential backoff: baseDelay * 2^(attempt-1)\n const delay = retryOptions.baseDelayMs * Math.pow(2, attemptNumber - 1);\n \n // Add some jitter to avoid thundering herd\n const jitter = Math.random() * 0.1 * delay;\n \n return Math.min(delay + jitter, retryOptions.maxDelayMs);\n }\n\n /**\n * Update retry state after an attempt\n */\n updateRetryState(transactionId: string, error: YnkapError): RetryState | null {\n const state = this.retryStates.get(transactionId);\n if (!state) return null;\n \n state.attemptNumber++;\n state.lastError = error;\n state.canRetry = state.attemptNumber < state.maxRetries && this.isRetryable(error);\n \n if (state.canRetry) {\n state.nextRetryDelayMs = this.calculateRetryDelay(state.attemptNumber);\n }\n \n return state;\n }\n\n /**\n * Execute retry with proper delay and state management\n */\n executeRetry<T>(\n transactionId: string, \n retryFn: () => Observable<T>,\n options?: Partial<RetryOptions>\n ): Observable<T> {\n const state = this.getRetryState(transactionId);\n \n if (!state || !state.canRetry) {\n return throwError(() => state?.lastError || new YnkapError(\n 'RETRY_EXHAUSTED',\n 'Maximum retry attempts reached'\n ));\n }\n \n const retryOptions = { ...this.defaultRetryOptions, ...options };\n \n // Call onRetry callback if provided\n if (retryOptions.onRetry && state.lastError) {\n retryOptions.onRetry(state.lastError, state.attemptNumber + 1);\n }\n \n // Wait for the calculated delay, then execute retry\n return timer(state.nextRetryDelayMs).pipe(\n switchMap(() => retryFn()),\n tap({\n error: (error) => {\n this.updateRetryState(transactionId, error);\n }\n })\n );\n }\n\n /**\n * Clear retry state for a transaction\n */\n clearRetryState(transactionId: string): void {\n this.retryStates.delete(transactionId);\n }\n\n /**\n * Get human-readable retry information\n */\n getRetryInfo(transactionId: string): string {\n const state = this.getRetryState(transactionId);\n if (!state) return '';\n \n if (!state.canRetry) {\n return 'Nombre maximum de tentatives atteint';\n }\n \n const remainingAttempts = state.maxRetries - state.attemptNumber;\n const nextRetrySeconds = Math.ceil(state.nextRetryDelayMs / 1000);\n \n return `${remainingAttempts} tentative(s) restante(s). Prochaine tentative dans ${nextRetrySeconds}s`;\n }\n\n /**\n * Check if automatic retry should be attempted\n */\n shouldAutoRetry(error: YnkapError): boolean {\n // Auto-retry only for network errors and server errors\n return error.code === ErrorCategory.NETWORK || \n (error.httpStatus !== undefined && error.httpStatus >= 500);\n }\n}\n","\n/**\n * Logos en base64 générés automatiquement\n * Générés le: 2025-06-27T14:26:54.389Z\n */\n\nexport const LOGOS_BASE64 = {\n ynkap: 'data:image/jpeg;base64,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',\n mtn: 'data:image/jpeg;base64,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