@vipros-org/sdk 3.0.0

package/vipros-sdk.js

@@ -0,0 +1,4190 @@
+/**
+ * VIPros SDK v3.0.0-unified - Production Build
+ * Generated: 2026-02-10T11:29:53.281Z
+ * Environment: Production
+ */
+var ViprosSDK = (function () {
+  'use strict';
+
+  /**
+   * TemplateLoader - Gestionnaire de templates HTML modulaires
+   * 
+   * Charge et met en cache les templates HTML externes pour le composant ViprosOfferCard.
+   * Utilise un système de templating simple avec remplacement de variables {{variable}}.
+   */
+  class TemplateLoader {
+    constructor(debug = false) {
+      this.debug = debug;
+      this.templates = new Map();
+      this.baseUrl = this.detectBaseUrl();
+    }
+
+    /**
+     * Détecte l'URL de base pour les templates
+     */
+    detectBaseUrl() {
+      // Toujours utiliser l'URL API pour les templates
+      const baseUrl = window.location.origin;
+
+      if (window.location.hostname.includes('ddev.site')) {
+        return baseUrl + '/api/sdk/components/templates'
+      }
+
+      // Pour production, adapter selon le domaine
+      return baseUrl + '/api/sdk/components/templates'
+    }
+
+    /**
+     * Charge un template depuis le serveur
+     */
+    async loadTemplate(templateName) {
+      if (this.templates.has(templateName)) {
+        return this.templates.get(templateName)
+      }
+
+      try {
+        const response = await fetch(`${this.baseUrl}/${templateName}.html`);
+        if (!response.ok) {
+          throw new Error(`Template ${templateName} not found: ${response.status}`)
+        }
+        
+        const html = await response.text();
+        this.templates.set(templateName, html);
+        return html
+      } catch (error) {
+        console.error(`[TemplateLoader] Error loading template ${templateName}:`, error);
+        return this.getFallbackTemplate(templateName)
+      }
+    }
+
+    /**
+     * Rend un template avec des données
+     */
+    async render(templateName, data = {}) {
+      const template = await this.loadTemplate(templateName);
+      return this.interpolate(template, data)
+    }
+
+    /**
+     * Système de templating amélioré - gère {{#if}}, {{else}}, {{/if}}, {{#unless}}
+     */
+    interpolate(template, data) {
+      // D'abord traiter les blocs conditionnels
+      let processed = this.processConditionalBlocks(template, data);
+      
+      // Puis remplacer les variables simples
+      processed = processed.replace(/\{\{([^}#/][^}]*)\}\}/g, (match, key) => {
+        const value = this.resolveNestedKey(data, key.trim());
+        return value !== null ? value : ''
+      });
+      
+      return processed
+    }
+
+    /**
+     * Résout les clés imbriquées comme "cashback.value"
+     */
+    resolveNestedKey(obj, key) {
+      // Les conditions sont maintenant gérées par processConditionalBlocks
+      // Ignorer les tokens de condition restants
+      if (key.startsWith('#') || key.startsWith('/')) {
+        return ''
+      }
+
+      // Résolution de clé normale
+      return key.split('.').reduce((current, prop) => {
+        return current && current[prop] !== undefined ? current[prop] : null
+      }, obj)
+    }
+
+    /**
+     * Traite les blocs conditionnels {{#if}}...{{else}}...{{/if}} et {{#unless}}...{{/unless}}
+     * Gère les conditions imbriquées de façon récursive
+     */
+    processConditionalBlocks(template, data) {
+      let processed = template;
+      let iterations = 0;
+      const maxIterations = 10; // Protection contre les boucles infinies
+      
+      // Traiter récursivement jusqu'à ce qu'il n'y ait plus de conditions
+      while (processed.includes('{{#if') || processed.includes('{{#unless')) {
+        iterations++;
+        if (iterations > maxIterations) {
+          console.warn('[TemplateLoader] Too many iterations in conditional processing');
+          break
+        }
+        
+        const before = processed;
+        
+        // Traiter les blocs {{#if}}...{{/if}} (de l'intérieur vers l'extérieur)
+        processed = this.processIfBlocks(processed, data);
+        
+        // Traiter les blocs {{#unless}}...{{/unless}}
+        processed = this.processUnlessBlocks(processed, data);
+        
+        // Si rien n'a changé, arrêter pour éviter une boucle infinie
+        if (processed === before) {
+          break
+        }
+      }
+      
+      return processed
+    }
+
+    /**
+     * Traite les blocs {{#if}}...{{/if}} en gérant les conditions imbriquées
+     */
+    processIfBlocks(template, data) {
+      // Trouver le {{#if}} le plus imbriqué (sans autres {{#if}} à l'intérieur)
+      const ifPattern = /\{\{#if\s+([^}]+)\}\}((?:(?!\{\{#if)[\s\S])*?)\{\{\/if\}\}/g;
+      
+      return template.replace(ifPattern, (match, condition, content) => {
+        const value = this.resolveNestedKey(data, condition.trim());
+        const isTrue = Boolean(value);
+        
+        // Chercher {{else}} dans le contenu (mais pas dans des sous-conditions)
+        const elseParts = content.split(/\{\{else\}\}/);
+        
+        if (elseParts.length === 2) {
+          // Il y a un {{else}}
+          return isTrue ? elseParts[0] : elseParts[1]
+        } else {
+          // Pas de {{else}}, juste la condition
+          return isTrue ? content : ''
+        }
+      })
+    }
+
+    /**
+     * Traite les blocs {{#unless}}...{{/unless}}
+     */
+    processUnlessBlocks(template, data) {
+      const unlessPattern = /\{\{#unless\s+([^}]+)\}\}((?:(?!\{\{#unless)[\s\S])*?)\{\{\/unless\}\}/g;
+      
+      return template.replace(unlessPattern, (match, condition, content) => {
+        const value = this.resolveNestedKey(data, condition.trim());
+        const isFalse = !Boolean(value);
+        
+        return isFalse ? content : ''
+      })
+    }
+
+    /**
+     * Gestion basique des conditions {{#if}} et {{#unless}} (déprécié - utiliser processConditionalBlocks)
+     */
+    handleConditional(data, key, isIf) {
+      const conditionKey = key.split(' ')[1];
+      const value = this.resolveNestedKey(data, conditionKey);
+      const condition = Boolean(value);
+      
+      return (isIf ? condition : !condition) ? '' : '<!-- condition-false -->'
+    }
+
+    /**
+     * Templates de fallback en cas d'erreur de chargement
+     */
+    getFallbackTemplate(templateName) {
+      const fallbacks = {
+        'CashbackTemplate': `
+        <div class="vipros-offer-card cashback-mode">
+          <div class="offer-content">
+            <div class="main-value">
+              <span class="amount">{{cashback.value}}</span>
+              <span class="currency">€</span>
+              <span class="label">remboursés</span>
+            </div>
+          </div>
+        </div>
+      `,
+        'VIPointsTemplate': `
+        <div class="vipros-offer-card vipoints-mode">
+          <div class="offer-content">
+            <div class="main-value">
+              <span class="amount">{{vipoints.perTenEuros}}</span>
+              <span class="label">VIPoints</span>
+            </div>
+          </div>
+        </div>
+      `,
+        'LoadingTemplate': `
+        <div class="vipros-offer-card loading-state">
+          <div class="loading-text">Recherche...</div>
+        </div>
+      `,
+        'ErrorTemplate': `
+        <div class="vipros-offer-card error-state">
+          <div class="error-text">{{message}}</div>
+          <div class="debug-notice">Erreur affichée car le mode debug est activé</div>
+        </div>
+      `
+      };
+
+      return fallbacks[templateName] || '<div class="vipros-offer-card">Template not found</div>'
+    }
+
+    /**
+     * Précharge tous les templates pour de meilleures performances
+     */
+    async preloadTemplates() {
+      const templateNames = ['CashbackTemplate', 'VIPointsTemplate', 'LoadingTemplate', 'ErrorTemplate'];
+      
+      const promises = templateNames.map(name =>
+        this.loadTemplate(name).catch(error => {
+          if (this.debug) console.warn(`[TemplateLoader] Failed to preload ${name}:`, error.message);
+          return null
+        })
+      );
+
+      await Promise.all(promises);
+      if (this.debug) console.log('[TemplateLoader] Templates preloaded');
+    }
+
+    /**
+     * Nettoie le cache des templates
+     */
+    clearCache() {
+      this.templates.clear();
+    }
+  }
+
+  /**
+   * ProductDataTransformer - Transformation des données API vers format composant
+   * 
+   * Centralise toute la logique de transformation des données API
+   * vers le format attendu par les templates.
+   */
+  class ProductDataTransformer {
+    
+    /**
+     * Transforme les données API vers le format template
+     */
+    static transform(apiProduct, price = null) {
+      if (!apiProduct) {
+        return null
+      }
+
+      const hasCashback = Boolean(apiProduct.cashback?.value > 0);
+      const generosityRate = apiProduct.brand?.generosity_rate || 0;
+
+      // Calculer les VIPoints selon le contexte
+      const vipointsData = this.calculateVIPoints(generosityRate, price);
+
+      return {
+        id: apiProduct.id || 'not_found',
+        ean: apiProduct.ean,
+        name: apiProduct.name || 'Produit inconnu',
+        price: price,
+        
+        brand: this.transformBrandData(apiProduct.brand),
+        cashback: this.transformCashbackData(apiProduct.cashback),
+        vipoints: vipointsData,
+        
+        hasCashback,
+        viprosLink: this.buildViprosLink(apiProduct),
+        
+        // URL de l'image VIPoints calculée dynamiquement
+        vipointsImageUrl: null // Sera définie par le composant
+      }
+    }
+
+    /**
+     * Transforme les données de marque
+     */
+    static transformBrandData(brandData) {
+      if (!brandData) {
+        return {
+          name: 'Marque inconnue',
+          displayName: null,
+          logoUrl: null,
+          generosityRate: 0
+        }
+      }
+
+      const displayName = brandData.name && brandData.name !== 'Marque inconnue' 
+        ? brandData.name 
+        : null;
+
+      return {
+        name: brandData.name || 'Marque inconnue',
+        displayName,
+        logoUrl: brandData.logo_url || null,
+        generosityRate: brandData.generosity_rate || 0
+      }
+    }
+
+    /**
+     * Transforme les données de cashback
+     */
+    static transformCashbackData(cashbackData) {
+      if (!cashbackData) {
+        return {
+          value: 0,
+          name: null,
+          imageUrl: null,
+          startDate: null,
+          endDate: null
+        }
+      }
+
+      return {
+        value: cashbackData.value || 0,
+        name: cashbackData.name || null,
+        imageUrl: cashbackData.image_url || null,
+        startDate: cashbackData.start_date || null,
+        endDate: cashbackData.end_date || null
+      }
+    }
+
+    /**
+     * Calcule les données VIPoints selon le contexte
+     */
+    static calculateVIPoints(generosityRate, price) {
+      let perTenEuros = 0;
+      let hasBonus = false;
+      let showExact = false;
+
+      if (generosityRate > 0) {
+        hasBonus = true;
+        
+        if (price && price > 0) {
+          // Prix renseigné : calculer le nombre exact de VIPoints
+          perTenEuros = Math.floor((generosityRate * price) / 10);
+          showExact = true;
+        } else {
+          // Pas de prix : affichage générique "1 VIPoint tous les 10€"
+          perTenEuros = 1;
+          showExact = false;
+        }
+      }
+
+      return {
+        perTenEuros,
+        generosityRate,
+        hasBonus,
+        showExact
+      }
+    }
+
+    /**
+     * Détermine le mode d'affichage selon les données
+     */
+    static determineDisplayMode(transformedData) {
+      if (!transformedData) {
+        return 'empty'
+      }
+
+      if (transformedData.hasCashback) {
+        return 'cashback'
+      }
+
+      if (transformedData.vipoints.hasBonus) {
+        return 'vipoints'
+      }
+
+      return 'empty'
+    }
+
+    /**
+     * Valide les données transformées
+     */
+    static validate(transformedData) {
+      if (!transformedData) {
+        return { isValid: false, errors: ['No data provided'] }
+      }
+
+      const errors = [];
+
+      if (!transformedData.ean) {
+        errors.push('EAN is required');
+      }
+
+      if (transformedData.hasCashback && !transformedData.cashback.value) {
+        errors.push('Cashback value is required when hasCashback is true');
+      }
+
+      if (transformedData.vipoints.hasBonus && !transformedData.vipoints.generosityRate) {
+        errors.push('Generosity rate is required when VIPoints bonus is available');
+      }
+
+      return {
+        isValid: errors.length === 0,
+        errors
+      }
+    }
+
+    /**
+     * Prépare les données pour le template
+     */
+    static prepareTemplateData(transformedData, vipointsImageUrl = null) {
+      if (!transformedData) {
+        return null
+      }
+
+      return {
+        ...transformedData,
+        vipointsImageUrl: vipointsImageUrl || this.getDefaultVIPointsImageUrl()
+      }
+    }
+
+    /**
+     * Construit l'URL VIPros complète avec les paramètres origin
+     */
+    static buildViprosLink(apiProduct) {
+      const baseUrl = apiProduct.vipros_link || 'https://vipros.fr';
+      
+      // Récupérer le nom du point de vente depuis les données API
+      const origin = this.getSalesPointName(apiProduct);
+      
+      // URL de la page actuelle
+      const originUrl = typeof window !== 'undefined' ? window.location.href : '';
+      
+      // Construire l'URL avec les paramètres
+      const url = new URL(baseUrl);
+      if (origin) {
+        url.searchParams.set('origin', origin);
+      }
+      if (originUrl) {
+        url.searchParams.set('origin_url', originUrl);
+      }
+      
+      return url.toString()
+    }
+
+    /**
+     * Extrait le nom du point de vente depuis les données API
+     */
+    static getSalesPointName(apiProduct) {
+      // Chercher dans les sales_points nested
+      if (apiProduct.sales_points && Array.isArray(apiProduct.sales_points)) {
+        const salesPoint = apiProduct.sales_points.find(sp => sp.name);
+        if (salesPoint) {
+          return salesPoint.name
+        }
+      }
+      
+      // Fallback : utiliser le domaine actuel comme nom du point de vente
+      if (typeof window !== 'undefined') {
+        const hostname = window.location.hostname;
+        // Transformer le domaine en nom plus lisible
+        return hostname.replace(/^www\./, '').replace(/\./g, ' ').split(' ')[0]
+      }
+      
+      return null
+    }
+
+    /**
+     * URL par défaut de l'image VIPoints
+     */
+    static getDefaultVIPointsImageUrl() {
+      // Sera définie dynamiquement par le composant selon son contexte
+      return '/api/sdk/assets/image-vipoints.jpg'
+    }
+  }
+
+  /**
+   * DisplayModeResolver - Résolution du mode d'affichage
+   * 
+   * Détermine comment afficher le composant selon les données produit
+   * et les options de configuration utilisateur.
+   */
+  class DisplayModeResolver {
+    
+    /**
+     * Résout le mode d'affichage principal
+     */
+    static resolveDisplayMode(productData) {
+      if (!productData) {
+        return 'empty'
+      }
+
+      // Mode cashback prioritaire
+      if (productData.hasCashback) {
+        return 'cashback'
+      }
+
+      // Mode VIPoints si disponible
+      if (productData.vipoints.hasBonus) {
+        return 'vipoints'
+      }
+
+      // Aucune offre disponible
+      return 'empty'
+    }
+
+    /**
+     * Résout le template à utiliser selon le mode
+     */
+    static resolveTemplateName(displayMode) {
+      const templateMap = {
+        'cashback': 'CashbackTemplate',
+        'vipoints': 'VIPointsTemplate', 
+        'loading': 'LoadingTemplate',
+        'error': 'ErrorTemplate',
+        'empty': null,
+        'hidden': null
+      };
+
+      return templateMap[displayMode] || null
+    }
+
+    /**
+     * Détermine si le composant doit être visible
+     */
+    static shouldDisplay(displayMode) {
+      return !['empty', 'hidden'].includes(displayMode)
+    }
+
+    /**
+     * Résout la classe CSS du conteneur
+     */
+    static resolveContainerClass(displayMode) {
+      const classMap = {
+        'cashback': 'cashback-mode',
+        'vipoints': 'vipoints-mode',
+        'loading': 'loading-state',
+        'error': 'error-state',
+        'empty': 'empty-state',
+        'hidden': 'hidden-state'
+      };
+
+      return `vipros-offer-card ${classMap[displayMode] || ''}`
+    }
+
+    /**
+     * Validation du mode d'affichage
+     */
+    static validateDisplayMode(displayMode) {
+      const validModes = ['cashback', 'vipoints', 'loading', 'error', 'empty', 'hidden'];
+      
+      if (!validModes.includes(displayMode)) {
+        console.warn(`[DisplayModeResolver] Invalid display mode: ${displayMode}`);
+        return 'error'
+      }
+
+      return displayMode
+    }
+
+    /**
+     * Analyse complète pour déterminer l'affichage
+     */
+    static analyze(productData, options = {}) {
+      const {
+        isLoading = false,
+        error = null,
+        debug = false
+      } = options;
+
+      // États d'erreur et de chargement prioritaires
+      if (error) {
+        // Afficher les erreurs seulement si debug est activé
+        if (debug) {
+          return {
+            mode: 'error',
+            template: 'ErrorTemplate',
+            shouldDisplay: true,
+            containerClass: this.resolveContainerClass('error'),
+            data: {
+              message: error.message || 'Une erreur est survenue',
+              debugMode: true
+            }
+          }
+        } else {
+          // En mode non-debug, ne pas afficher les erreurs (masquer complètement)
+          return {
+            mode: 'hidden',
+            template: null,
+            shouldDisplay: false,
+            containerClass: this.resolveContainerClass('hidden'),
+            data: {}
+          }
+        }
+      }
+
+      if (isLoading) {
+        return {
+          mode: 'loading',
+          template: 'LoadingTemplate', 
+          shouldDisplay: true,
+          containerClass: this.resolveContainerClass('loading'),
+          data: {}
+        }
+      }
+
+      // Résolution normale
+      const mode = this.resolveDisplayMode(productData);
+      const template = this.resolveTemplateName(mode);
+      const shouldDisplay = this.shouldDisplay(mode);
+      const containerClass = this.resolveContainerClass(mode);
+
+      return {
+        mode: this.validateDisplayMode(mode),
+        template,
+        shouldDisplay,
+        containerClass,
+        data: shouldDisplay ? productData : {}
+      }
+    }
+
+    /**
+     * Vérifie si les données sont suffisantes pour l'affichage
+     */
+    static hasMinimumRequiredData(productData) {
+      if (!productData) {
+        return false
+      }
+
+      // Au minimum besoin d'un EAN
+      if (!productData.ean) {
+        return false
+      }
+
+      // Doit avoir soit cashback soit VIPoints
+      return productData.hasCashback || productData.vipoints.hasBonus
+    }
+
+    /**
+     * Suggestions d'amélioration des données
+     */
+    static suggestDataImprovements(productData) {
+      if (!productData) {
+        return ['Product data is required']
+      }
+
+      const suggestions = [];
+
+      if (!productData.name || productData.name === 'Produit inconnu') {
+        suggestions.push('Product name could be improved');
+      }
+
+      if (productData.hasCashback && !productData.cashback.imageUrl) {
+        suggestions.push('Cashback image would improve visual appeal');
+      }
+
+      if (!productData.price && productData.vipoints.hasBonus) {
+        suggestions.push('Price would enable exact VIPoints calculation');
+      }
+
+      if (!productData.brand.displayName) {
+        suggestions.push('Brand name would improve VIPoints messaging');
+      }
+
+      return suggestions
+    }
+  }
+
+  /**
+   * EventManager - Gestionnaire d'événements pour ViprosOfferCard
+   * 
+   * Centralise la gestion des événements du composant Web Component.
+   * Simplifie l'émission et l'écoute d'événements personnalisés.
+   */
+  class EventManager {
+    constructor(element) {
+      this.element = element;
+      this.listeners = new Map();
+    }
+
+    /**
+     * Émet un événement personnalisé
+     */
+    emit(eventName, detail = {}) {
+      const event = new CustomEvent(eventName, {
+        detail,
+        bubbles: true,
+        cancelable: true
+      });
+      
+      this.element.dispatchEvent(event);
+      
+      // Log pour debugging
+      if (this.element.getAttribute('debug') === 'true') {
+        console.log(`[ViprosOfferCard] Event emitted: ${eventName}`, detail);
+      }
+    }
+
+    /**
+     * Émet l'événement d'offre chargée
+     */
+    emitOfferLoaded(productData, ean) {
+      this.emit('vipros-offer-loaded', {
+        product: productData,
+        ean: ean,
+        timestamp: Date.now()
+      });
+    }
+
+    /**
+     * Émet l'événement d'erreur
+     */
+    emitError(error, ean) {
+      this.emit('vipros-offer-error', {
+        error: {
+          message: error.message || 'Unknown error',
+          type: error.constructor.name,
+          stack: error.stack
+        },
+        ean: ean,
+        timestamp: Date.now()
+      });
+    }
+
+    /**
+     * Émet l'événement de clic sur offre
+     */
+    emitOfferClick(url, productData, ean) {
+      this.emit('vipros-offer-click', {
+        url,
+        product: productData,
+        ean: ean,
+        timestamp: Date.now()
+      });
+    }
+
+    /**
+     * Émet l'événement de synchronisation démarrée
+     */
+    emitSyncStarted(ean, url) {
+      this.emit('vipros-sync-started', {
+        ean,
+        url,
+        timestamp: Date.now()
+      });
+    }
+
+    /**
+     * Émet l'événement de synchronisation réussie
+     */
+    emitSyncSuccess(ean, result) {
+      this.emit('vipros-sync-success', {
+        ean,
+        result,
+        timestamp: Date.now()
+      });
+    }
+
+    /**
+     * Émet l'événement d'erreur de synchronisation
+     */
+    emitSyncError(ean, error) {
+      this.emit('vipros-sync-error', {
+        ean,
+        error: {
+          message: error.message || 'Sync error',
+          type: error.constructor.name
+        },
+        timestamp: Date.now()
+      });
+    }
+
+    /**
+     * Ajoute des listeners pour les clics sur les liens
+     */
+    attachLinkListeners(shadowRoot, productData, ean) {
+      const links = shadowRoot.querySelectorAll('a[href]');
+      
+      links.forEach(link => {
+        const clickHandler = (event) => {
+          this.emitOfferClick(link.href, productData, ean);
+          
+          // Optionnel : tracking analytics
+          if (window.gtag) {
+            window.gtag('event', 'vipros_offer_click', {
+              ean: ean,
+              url: link.href,
+              product_name: productData?.name
+            });
+          }
+        };
+
+        link.addEventListener('click', clickHandler);
+        
+        // Stocker la référence pour cleanup
+        if (!this.listeners.has('linkClicks')) {
+          this.listeners.set('linkClicks', []);
+        }
+        this.listeners.get('linkClicks').push({ link, handler: clickHandler });
+      });
+    }
+
+    /**
+     * Supprime tous les listeners attachés
+     */
+    cleanup() {
+      // Nettoyer les listeners de liens
+      if (this.listeners.has('linkClicks')) {
+        this.listeners.get('linkClicks').forEach(({ link, handler }) => {
+          link.removeEventListener('click', handler);
+        });
+      }
+
+      this.listeners.clear();
+    }
+
+    /**
+     * Configuration des événements globaux pour debugging
+     */
+    enableGlobalDebugging() {
+      const events = [
+        'vipros-offer-loaded',
+        'vipros-offer-error', 
+        'vipros-offer-click',
+        'vipros-sync-started',
+        'vipros-sync-success',
+        'vipros-sync-error'
+      ];
+
+      events.forEach(eventName => {
+        document.addEventListener(eventName, (event) => {
+          console.log(`[ViprosOfferCard] Global event: ${eventName}`, event.detail);
+        });
+      });
+    }
+
+    /**
+     * Méthodes statiques pour les composants sans instance
+     */
+    static emit(element, eventName, detail = {}) {
+      const manager = new EventManager(element);
+      manager.emit(eventName, detail);
+    }
+
+    static emitOfferLoaded(element, productData, ean) {
+      const manager = new EventManager(element);
+      manager.emitOfferLoaded(productData, ean);
+    }
+
+    static emitError(element, error, ean) {
+      const manager = new EventManager(element);
+      manager.emitError(error, ean);
+    }
+  }
+
+  /**
+   * ViprosOfferCard - Web Component for displaying VIPros offers
+   */
+
+
+  class ViprosOfferCard extends HTMLElement {
+    constructor() {
+      super();
+      
+      // Shadow DOM for component isolation
+      this.attachShadow({ mode: 'open' });
+      
+      this.templateLoader = new TemplateLoader();
+      this.eventManager = new EventManager(this);
+      
+      // Component state
+      this.state = {
+        isLoading: false,
+        productData: null,
+        error: null,
+        apiClient: null
+      };
+
+      // Bind methods
+      this.init = this.init.bind(this);
+      this.loadProduct = this.loadProduct.bind(this);
+      this.render = this.render.bind(this);
+    }
+
+    // Observed attributes
+    static get observedAttributes() {
+      return [
+        'ean', 'price', 'api-base-url', 'api-key',
+        'primary-color', 'text-color', 'background-color',
+        'card-bonus-bg', 'card-bonus-color'
+      ]
+    }
+
+    // Attribute getters
+    get ean() { 
+      return this.getAttribute('ean') || this.getConfigValue('ean')
+    }
+    get price() { 
+      const attrPrice = parseFloat(this.getAttribute('price')) || 0;
+      if (attrPrice > 0) return attrPrice
+      
+      const configPrice = this.getConfigValue('price');
+      if (configPrice && parseFloat(configPrice) > 0) return parseFloat(configPrice)
+      
+      return null
+    }
+    get apiBaseUrl() {
+      return this.getConfigValue('apiBaseUrl') || this.getAttribute('api-base-url') || this.detectFallbackApiBaseUrl()
+    }
+    get apiKey() { 
+      return this.getConfigValue('apiKey') || this.getAttribute('api-key')
+    }
+    get primaryColor() {
+      return this.getAttribute('primary-color') || this.getConfigValue('primaryColor')
+    }
+    get textColor() {
+      return this.getAttribute('text-color') || this.getConfigValue('textColor')
+    }
+    get backgroundColor() {
+      return this.getAttribute('background-color') || this.getConfigValue('backgroundColor')
+    }
+    get cardBonusBg() {
+      return this.getAttribute('card-bonus-bg') || this.getConfigValue('cardBonusBg')
+    }
+    get cardBonusColor() {
+      return this.getAttribute('card-bonus-color') || this.getConfigValue('cardBonusColor')
+    }
+
+    // SDK configuration helpers
+    getConfigValue(key) {
+      const sdk = this.getSDKInstance();
+      return sdk?.config?.[key] || null
+    }
+
+    getSDKInstance() {
+      return typeof window !== 'undefined' ? window.ViprosSDK : null
+    }
+
+    detectFallbackApiBaseUrl() {
+      // Edge case: No window object (SSR or Node.js environment)
+      if (typeof window === 'undefined') {
+        this.log('[ViprosOfferCard] No window object - defaulting to production API');
+        return 'https://msys.vipros.fr/api'
+      }
+
+      try {
+        // Edge case: window.location is not available or corrupted
+        if (!window.location || typeof window.location.hostname !== 'string') {
+          this.log('[ViprosOfferCard] Invalid window.location - defaulting to production API');
+          return 'https://msys.vipros.fr/api'
+        }
+
+        const protocol = window.location.protocol || 'https:';
+        const hostname = window.location.hostname.toLowerCase();
+
+        // Edge case: Empty or invalid hostname
+        if (!hostname || hostname.length === 0) {
+          this.log('[ViprosOfferCard] Empty hostname - defaulting to production API');
+          return 'https://msys.vipros.fr/api'
+        }
+
+        // Edge case: Local development or non-standard protocols
+        if (protocol === 'file:' || hostname === 'localhost' || hostname.startsWith('127.0.0.1') || hostname.startsWith('0.0.0.0')) {
+          this.log('[ViprosOfferCard] Local development detected - using DDEV fallback');
+          return 'https://vipros-connect.ddev.site/api'
+        }
+
+        // Correspondance directe des domaines (même logique que ConfigManager)
+        if (hostname === 'vipros-connect.ddev.site') {
+          return `${protocol}//${hostname}/api`
+        }
+
+        if (hostname === 'msys.preprod.vipros.fr') {
+          return `${protocol}//msys.preprod.vipros.fr/api`
+        }
+
+        // Edge case: Subdomain detection for enterprise customers
+        if (hostname.endsWith('.vipros.fr')) {
+          this.log(`[ViprosOfferCard] VIPros subdomain detected: ${hostname}`);
+          return `${protocol}//${hostname}/api`
+        }
+
+        // Par défaut : production (toujours HTTPS pour la sécurité)
+        this.log(`[ViprosOfferCard] Unknown domain: ${hostname} - defaulting to production API`);
+        return 'https://msys.vipros.fr/api'
+
+      } catch (error) {
+        // Edge case: Exception during detection
+        this.log(`[ViprosOfferCard] Error detecting API base URL: ${error.message} - defaulting to production`);
+        return 'https://msys.vipros.fr/api'
+      }
+    }
+
+    // Lifecycle methods
+    connectedCallback() {
+      this.log('[ViprosOfferCard] Component connected');
+      this.init();
+    }
+
+    attributeChangedCallback(name, oldValue, newValue) {
+      if (oldValue !== newValue && this.isConnected) {
+        if (name === 'ean') {
+          this.log(`[ViprosOfferCard] EAN changed: ${oldValue} → ${newValue}`);
+          this.loadProduct();
+        } else if ([
+          'primary-color', 'text-color', 'background-color',
+          'gift-icon-color', 'gift-card-bonus-bg', 'gift-card-bonus-color',
+          'vipoints-bonus-bg', 'vipoints-bonus-color'
+        ].includes(name)) {
+          this.log(`[ViprosOfferCard] Color changed: ${name} = ${newValue}`);
+          this.updateCustomColors();
+        }
+      }
+    }
+
+    disconnectedCallback() {
+      this.log('[ViprosOfferCard] Component disconnected');
+      this.cleanup();
+    }
+
+    // Initialization
+    async init() {
+      try {
+        // Load Google Fonts in document head
+        this.loadGoogleFonts();
+        
+        // Load CSS styles
+        await this.loadStyles();
+        
+        // Apply custom colors if provided
+        this.updateCustomColors();
+        
+        // Initialize API client
+        await this.initApiClient();
+        
+        // Preload templates
+        await this.templateLoader.preloadTemplates();
+        
+        // Load product data
+        if (this.ean) {
+          await this.loadProduct();
+        } else {
+          this.setError(new Error('EAN requis pour afficher une offre VIPros'));
+        }
+      } catch (error) {
+        this.logError('[ViprosOfferCard] Init error:', error);
+        this.setError(error);
+      }
+    }
+
+    // Load Google Fonts in document head
+    loadGoogleFonts() {
+      const fontsToLoad = [
+        'https://fonts.googleapis.com/css2?family=Open+Sans:wght@400;500;600;700&display=swap',
+        'https://fonts.googleapis.com/css2?family=Encode+Sans+Condensed:wght@100;200;300;400;500;600;700;800;900&display=swap'
+      ];
+
+      fontsToLoad.forEach(fontUrl => {
+        // Check if font link already exists
+        const existingLink = document.querySelector(`link[href="${fontUrl}"]`);
+        if (!existingLink) {
+          const linkElement = document.createElement('link');
+          linkElement.rel = 'stylesheet';
+          linkElement.href = fontUrl;
+          linkElement.crossOrigin = 'anonymous';
+          document.head.appendChild(linkElement);
+        }
+      });
+    }
+
+    // Load CSS styles
+    async loadStyles() {
+      try {
+        const styleUrl = this.templateLoader.baseUrl.replace('/components/templates', '/components/styles/offer-card.css');
+        const response = await fetch(styleUrl);
+        
+        if (response.ok) {
+          const css = await response.text();
+          const styleElement = document.createElement('style');
+          styleElement.textContent = css;
+          this.shadowRoot.appendChild(styleElement);
+        } else {
+          // Fallback avec styles minimaux
+          this.injectFallbackStyles();
+        }
+      } catch (error) {
+        this.logError('[ViprosOfferCard] CSS loading failed, using fallback');
+        this.injectFallbackStyles();
+      }
+    }
+
+    // Update custom colors via CSS variables
+    updateCustomColors() {
+      if (!this.shadowRoot) return
+
+      const host = this.shadowRoot.host;
+      const customColors = {};
+
+      // Map attributes to CSS variables
+      if (this.primaryColor) {
+        customColors['--vipros-primary'] = this.primaryColor;
+        customColors['--vipros-text-accent'] = this.primaryColor;
+      }
+      if (this.textColor) {
+        customColors['--vipros-text-main'] = this.textColor;
+      }
+      if (this.backgroundColor) {
+        customColors['--vipros-background'] = this.backgroundColor;
+      }
+      if (this.cardBonusBg) {
+        customColors['--card-bonus-bg'] = this.cardBonusBg;
+      }
+      if (this.cardBonusColor) {
+        customColors['--card-bonus-color'] = this.cardBonusColor;
+      }
+
+      // Apply custom colors to the host element
+      Object.entries(customColors).forEach(([property, value]) => {
+        host.style.setProperty(property, value);
+      });
+
+      this.log('[ViprosOfferCard] Custom colors applied:', customColors);
+    }
+
+    injectFallbackStyles() {
+      const fallbackCSS = `
+      .vipros-offer-card { 
+        display: block; 
+        padding: 20px; 
+        background: #e8ecf8; 
+        border-radius: 12px; 
+        font-family: sans-serif; 
+      }
+      .loading-content, .error-content { 
+        text-align: center; 
+        padding: 40px; 
+      }
+    `;
+      const styleElement = document.createElement('style');
+      styleElement.textContent = fallbackCSS;
+      this.shadowRoot.appendChild(styleElement);
+    }
+
+    // Méthodes de logging respectant le mode debug
+    log(message, ...args) {
+      const sdk = this.getSDKInstance();
+      if (sdk && sdk.config && sdk.config.debug === true) {
+        console.log(message, ...args);
+      }
+    }
+
+    logError(message, ...args) {
+      const sdk = this.getSDKInstance();
+      if (sdk && sdk.config && sdk.config.debug === true) {
+        console.error(message, ...args);
+      }
+    }
+
+    // Initialisation API client
+    async initApiClient() {
+      const sdk = this.getSDKInstance();
+      
+      if (sdk && sdk.getApiClient) {
+        this.state.apiClient = sdk.getApiClient();
+        this.log('[ViprosOfferCard] Using shared SDK ApiClient');
+      } else {
+        // Fallback : créer son propre ApiClient
+        const { default: ApiClient } = await Promise.resolve().then(function () { return ApiClient$1; });
+        this.state.apiClient = new ApiClient({
+          apiBaseUrl: this.apiBaseUrl,
+          apiKey: this.apiKey
+        });
+        this.log('[ViprosOfferCard] Created local ApiClient');
+      }
+    }
+
+    // Chargement des données produit
+    async loadProduct() {
+      if (!this.ean || this.state.isLoading) return
+
+      // Attendre que l'apiClient soit prêt
+      if (!this.state.apiClient) {
+        setTimeout(() => this.loadProduct(), 100);
+        return
+      }
+
+      this.setLoading(true);
+
+      try {
+        this.log(`[ViprosOfferCard] Loading product: ${this.ean}`);
+
+        // NOUVEAU Phase 8: Préparer les options pour la sync inline si activée
+        const sdk = this.getSDKInstance();
+        const apiOptions = {
+          timeout: 5000  // 5 secondes pour éviter les timeouts longs sur rate limit
+        };
+
+        // Activer la sync inline si configuré dans le SDK
+        if (sdk?.config?.inlineSyncEnabled) {
+          apiOptions.enableInlineSync = true;
+          apiOptions.productUrl = window.location.href;
+          this.log(`[ViprosOfferCard] Inline sync enabled for EAN ${this.ean}`);
+        }
+
+        // Appel API avec options de sync inline
+        const response = await this.state.apiClient.get('/catalog/items', {
+          ean: this.ean,
+          items_per_page: 1
+        }, apiOptions);
+
+        const bloomMetadata = response?.metadata?.bloomFilter;
+        const debugEnabled = Boolean(this.getConfigValue('debug') || this.getAttribute('debug') === 'true');
+
+        if (bloomMetadata?.skipped) {
+          this.log(`[ViprosOfferCard] Bloom filter skipped API call for EAN ${this.ean}`);
+
+          if (debugEnabled) {
+            const bloomError = new Error('404 | Produit introuvable (Bloom filter)');
+            bloomError.status = 404;
+            bloomError.type = 'BLOOM_FILTER_NOT_FOUND';
+            bloomError.data = {
+              ean: this.ean,
+              reason: bloomMetadata.reason || 'NOT_IN_FILTER'
+            };
+            this.setError(bloomError);
+          } else {
+            this.setProductData(null);
+          }
+
+          return
+        }
+
+        // Log sync metadata if present (Phase 8)
+        const syncMetadata = response?.sdk_metadata?.sync;
+        if (syncMetadata && this.getConfigValue('debug')) {
+          this.log(`[ViprosOfferCard] Sync metadata:`, syncMetadata);
+        }
+
+        if (response.items && response.items.length > 0) {
+          // Transformer les données
+          const productData = ProductDataTransformer.transform(response.items[0], this.price);
+          productData.vipointsImageUrl = this.getVIPointsImageUrl();
+
+          this.setProductData(productData);
+          this.log(`[ViprosOfferCard] Product loaded: ${productData.name}`);
+
+          // Synchronisation en arrière-plan (seulement si inline sync n'a pas été tentée)
+          // On vérifie si sync metadata existe, peu importe si triggered=true ou cooldown
+          const inlineSyncWasAttempted = syncMetadata !== undefined && syncMetadata !== null;
+          if (!inlineSyncWasAttempted) {
+            this.triggerBackgroundSync();
+          } else {
+            this.log(`[ViprosOfferCard] Skipping background sync (inline sync was attempted, status: ${syncMetadata.reason || 'unknown'})`);
+          }
+
+          // Émettre événement
+          this.eventManager.emitOfferLoaded(productData, this.ean);
+        } else {
+          this.log(`[ViprosOfferCard] No product found for EAN: ${this.ean}`);
+          this.setProductData(null);
+        }
+      } catch (error) {
+        this.logError(`[ViprosOfferCard] Error loading EAN ${this.ean}:`, error);
+
+        // Gestion spécifique des erreurs rate limit
+        if (error.status === 429 || error.type === 'RATE_LIMIT_ERROR') {
+          const rateLimitError = new Error('API rate limit exceeded - Trop de requêtes simultanées');
+          rateLimitError.status = 429;
+          rateLimitError.type = 'RATE_LIMIT_ERROR';
+          this.setError(rateLimitError);
+        } else {
+          this.setError(error);
+        }
+      } finally {
+        this.setLoading(false);
+      }
+    }
+
+    // Gestion d'état
+    setLoading(isLoading) {
+      this.state.isLoading = isLoading;
+      // Un seul render() - il gère lui-même l'état loading
+      this.render();
+    }
+
+    setProductData(productData) {
+      this.state.productData = productData;
+      this.state.error = null;
+      // Ne pas render ici, sera fait par setLoading(false)
+    }
+
+    setError(error) {
+      this.state.error = error;
+      this.state.productData = null;
+      this.render();
+      this.eventManager.emitError(error, this.ean);
+    }
+
+    // Rendu principal
+    async render() {
+      // Toujours analyser l'état actuel pour déterminer le template
+      const analysis = DisplayModeResolver.analyze(this.state.productData, {
+        isLoading: this.state.isLoading,
+        error: this.state.error,
+        debug: this.getConfigValue('debug') || false
+      });
+
+      if (!analysis.shouldDisplay) {
+        this.updateShadowContent('<div class="vipros-offer-card hidden"></div>');
+        return
+      }
+
+      if (analysis.template) {
+        const html = await this.templateLoader.render(analysis.template, analysis.data);
+        
+        // Mettre à jour le contenu en préservant les styles
+        this.updateShadowContent(html);
+
+        // Attacher les event listeners seulement si pas en loading
+        if (!this.state.isLoading) {
+          this.attachEventListeners();
+        }
+      }
+    }
+
+    // Rendus spécialisés (déprécié - utiliser render() directement)  
+    async renderLoading() {
+      // Cette méthode est dépréciée - render() gère maintenant le loading
+      await this.render();
+    }
+
+    // Utilitaire pour mettre à jour le contenu en préservant les styles
+    updateShadowContent(html) {
+      // Collecter tous les styles existants
+      const styles = Array.from(this.shadowRoot.querySelectorAll('style'));
+      const styleTexts = styles.map(style => style.textContent);
+      
+      // Destruction complète du contenu
+      this.shadowRoot.replaceChildren();
+      
+      // Parser le nouveau HTML et l'ajouter
+      const tempDiv = document.createElement('div');
+      tempDiv.innerHTML = html;
+      
+      // Transférer tous les enfants du div temporaire vers shadowRoot
+      while (tempDiv.firstChild) {
+        this.shadowRoot.appendChild(tempDiv.firstChild);
+      }
+      
+      // Recréer les styles
+      styleTexts.forEach(styleText => {
+        const styleElement = document.createElement('style');
+        styleElement.textContent = styleText;
+        this.shadowRoot.appendChild(styleElement);
+      });
+    }
+
+    // Event listeners
+    attachEventListeners() {
+      if (this.state.productData) {
+        this.eventManager.attachLinkListeners(
+          this.shadowRoot, 
+          this.state.productData, 
+          this.ean
+        );
+      }
+    }
+
+    // Utilitaires
+    getVIPointsImageUrl() {
+      const baseUrl = (this.apiBaseUrl || '').replace('/api', '');
+      return `${baseUrl}/api/sdk/assets/image-vipoints.jpg`
+    }
+
+    triggerBackgroundSync() {
+      const sdk = this.getSDKInstance();
+      if (sdk?.syncService) {
+        setTimeout(() => {
+          this.log(`[ViprosOfferCard] Background sync for EAN ${this.ean}`);
+          sdk.syncProductInBackground(this.ean, window.location.href);
+        }, 100);
+      }
+    }
+
+    // Nettoyage
+    cleanup() {
+      this.eventManager.cleanup();
+      this.state.apiClient = null;
+      this.state.productData = null;
+    }
+  }
+
+  // Référence SDK (méthodes statiques de l'ancien composant)
+  ViprosOfferCard.setSDKInstance = function(sdk) {
+    if (sdk?.config?.debug) {
+      console.log('[ViprosOfferCard] SDK instance connected');
+    }
+  };
+
+  class ConfigManager {
+    static create (userConfig = {}) {
+      const defaultConfig = ConfigManager.getDefaultConfig();
+      const mergedConfig = ConfigManager.mergeConfig(defaultConfig, userConfig);
+      const validatedConfig = ConfigManager.validateConfig(mergedConfig);
+      
+      return validatedConfig
+    }
+
+    static getDefaultConfig () {
+      return {
+        // API Configuration
+        apiBaseUrl: ConfigManager.detectApiBaseUrl(),
+        apiKey: null, // Clé API obligatoire - doit être fournie explicitement
+        timeout: 10000,
+        
+        // EAN Configuration
+        ean: null, // EAN par défaut pour les composants sans attribut ean
+        
+        // Global Component Defaults
+        price: null, // Prix par défaut pour les composants sans attribut price
+        primaryColor: null, // Couleur principale par défaut pour les composants sans attribut primary-color
+        textColor: null, // Couleur de texte par défaut pour les composants sans attribut text-color
+        backgroundColor: null, // Couleur de fond par défaut pour les composants sans attribut background-color
+        cardBonusBg: null, // Couleur de fond des badges bonus par défaut pour les composants sans attribut card-bonus-bg
+        cardBonusColor: null, // Couleur de texte/icône des badges bonus par défaut pour les composants sans attribut card-bonus-color
+        
+        // Cache Configuration  
+        cacheTimeout: 300000, // 5 minutes
+        cachePrefix: 'vipros_sdk_',
+        maxCacheSize: 100,
+        
+        // Container Configuration
+        containerSelector: '[data-ean]',
+        eanAttribute: 'data-ean',
+        
+        // Rendering Configuration
+        renderPosition: 'replace', // 'before', 'after', 'prepend', 'append', 'replace'
+        excludeSelectors: ['.vipros-offer', '[data-vipros-exclude]'],
+        
+        // Template Configuration - Templates par défaut seront utilisés par TemplateEngine
+        templates: {
+          // Ne pas spécifier de valeurs par défaut - TemplateEngine a ses propres templates intégrés
+        },
+        
+        // Styling Configuration
+        styling: {
+          theme: 'minimal', // 'minimal', 'branded', 'custom'
+          customCSS: {},
+          inlineStyles: true,
+          cssPrefix: 'vipros-',
+          responsive: true
+        },
+        
+        // Performance Configuration
+        batchRequests: true,
+        lazyLoad: true,
+        maxConcurrentRequests: 3,
+        debounceDelay: 300,
+        
+        // Behavior Configuration
+        hideOnError: false,
+        retryOnError: true,
+        gracefulDegradetion: true,
+
+        // Sync Configuration
+        syncEnabled: true,
+        syncOptions: {
+          cooldownTime: 24 * 60 * 60 * 1000, // 24 heures - une sync par jour par produit
+          syncDelay: 100, // Délai avant sync en ms
+          maxRetries: 3,
+          retryDelay: 1000 // Délai entre retry en ms
+        },
+        
+        // Debug Configuration
+        debug: false,
+        verbose: false,
+        logLevel: 'warn', // 'error', 'warn', 'info', 'debug'
+        
+        // Event Callbacks
+        onReady: null,
+        onOfferFound: null,
+        onOfferRendered: null,
+        onOfferLoaded: null, // Nouveau callback quand une offre est complètement chargée et affichée
+        onError: null,
+        
+        // Feature Flags
+        features: {
+          analyticsTracking: false,
+          performanceMonitoring: false,
+          a11yEnhancements: true,
+          seoOptimizations: true
+        },
+        
+        // Internationalization
+        locale: 'fr-FR',
+        currency: 'EUR',
+        dateFormat: 'DD/MM/YYYY',
+        
+        // Version
+        version: '1.0.0'
+      }
+    }
+
+    static mergeConfig (defaultConfig, userConfig) {
+      return ConfigManager.deepMerge(defaultConfig, userConfig)
+    }
+
+    static deepMerge (target, source) {
+      const result = { ...target };
+      
+      for (const [key, value] of Object.entries(source)) {
+        if (value === null || value === undefined) {
+          continue
+        }
+        
+        if (ConfigManager.isObject(value) && ConfigManager.isObject(result[key])) {
+          result[key] = ConfigManager.deepMerge(result[key], value);
+        } else {
+          result[key] = value;
+        }
+      }
+      
+      return result
+    }
+
+    static isObject (item) {
+      return item && typeof item === 'object' && !Array.isArray(item)
+    }
+
+    static validateConfig (config) {
+      const errors = [];
+      
+      // Validate API Configuration
+      if (!config.apiBaseUrl || typeof config.apiBaseUrl !== 'string') {
+        errors.push('apiBaseUrl must be a valid string');
+      } else {
+        try {
+          new URL(config.apiBaseUrl);
+        } catch (e) {
+          errors.push('apiBaseUrl must be a valid URL');
+        }
+      }
+
+      if (!config.apiKey) {
+        errors.push('apiKey is required');
+      }
+
+      if (config.apiKey && typeof config.apiKey !== 'string') {
+        errors.push('apiKey must be a string');
+      }
+
+      if (config.timeout && (typeof config.timeout !== 'number' || config.timeout <= 0)) {
+        errors.push('timeout must be a positive number');
+      }
+
+      // Validate Cache Configuration
+      if (config.cacheTimeout && (typeof config.cacheTimeout !== 'number' || config.cacheTimeout < 0)) {
+        errors.push('cacheTimeout must be a non-negative number');
+      }
+
+      if (config.maxCacheSize && (typeof config.maxCacheSize !== 'number' || config.maxCacheSize <= 0)) {
+        errors.push('maxCacheSize must be a positive number');
+      }
+
+      // Validate Container Configuration
+      if (config.containerSelector && typeof config.containerSelector !== 'string') {
+        errors.push('containerSelector must be a string');
+      }
+
+      if (config.eanAttribute && typeof config.eanAttribute !== 'string') {
+        errors.push('eanAttribute must be a string');
+      }
+
+      // Validate Styling
+      if (config.styling) {
+        const validThemes = ['minimal', 'branded', 'custom'];
+        if (config.styling.theme && !validThemes.includes(config.styling.theme)) {
+          errors.push(`styling.theme must be one of: ${validThemes.join(', ')}`);
+        }
+
+        if (config.styling.customCSS && !ConfigManager.isObject(config.styling.customCSS)) {
+          errors.push('styling.customCSS must be an object');
+        }
+      }
+
+      // Validate Performance Configuration
+      if (config.maxConcurrentRequests && (typeof config.maxConcurrentRequests !== 'number' || config.maxConcurrentRequests <= 0)) {
+        errors.push('maxConcurrentRequests must be a positive number');
+      }
+
+      if (config.debounceDelay && (typeof config.debounceDelay !== 'number' || config.debounceDelay < 0)) {
+        errors.push('debounceDelay must be a non-negative number');
+      }
+
+
+      // Validate Log Level
+      const validLogLevels = ['error', 'warn', 'info', 'debug'];
+      if (config.logLevel && !validLogLevels.includes(config.logLevel)) {
+        errors.push(`logLevel must be one of: ${validLogLevels.join(', ')}`);
+      }
+
+      // Validate Event Callbacks
+      const eventCallbacks = ['onReady', 'onOfferFound', 'onOfferRendered', 'onOfferLoaded', 'onError'];
+      for (const callback of eventCallbacks) {
+        if (config[callback] && typeof config[callback] !== 'function') {
+          errors.push(`${callback} must be a function`);
+        }
+      }
+
+      // Validate Locale
+      if (config.locale && typeof config.locale !== 'string') {
+        errors.push('locale must be a string');
+      }
+
+      // Validate Currency
+      if (config.currency && typeof config.currency !== 'string') {
+        errors.push('currency must be a string');
+      }
+
+      if (errors.length > 0) {
+        const error = new Error(`Configuration validation failed:\n${errors.join('\n')}`);
+        error.validationErrors = errors;
+        throw error
+      }
+
+      // Apply post-validation processing
+      return ConfigManager.processConfig(config)
+    }
+
+    static processConfig (config) {
+      const processed = { ...config };
+
+      // Normalize API Base URL
+      processed.apiBaseUrl = processed.apiBaseUrl.replace(/\/$/, '');
+      
+      // Ensure containerSelector is properly formatted
+      if (!processed.containerSelector.startsWith('[') && !processed.containerSelector.startsWith('.') && !processed.containerSelector.startsWith('#')) {
+        processed.containerSelector = `[${processed.eanAttribute}]`;
+      }
+
+      // Set debug flags based on logLevel
+      if (processed.logLevel === 'debug') {
+        processed.debug = true;
+        processed.verbose = true;
+      } else if (processed.logLevel === 'info') {
+        processed.debug = true;
+      }
+
+      // Validate and normalize CSS custom properties
+      if (processed.styling.customCSS) {
+        const normalizedCSS = {};
+        for (const [key, value] of Object.entries(processed.styling.customCSS)) {
+          const cssProperty = key.startsWith('--') ? key : `--vipros-${key}`;
+          normalizedCSS[cssProperty] = value;
+        }
+        processed.styling.customCSS = normalizedCSS;
+      }
+
+      // Set cache prefix with version
+      processed.cachePrefix = `${processed.cachePrefix}v${processed.version.replace(/\./g, '_')}_`;
+
+      // Calculate derived values
+      processed.derived = {
+        isProduction: !processed.debug,
+        shouldCache: processed.cacheTimeout > 0,
+        shouldBatch: processed.batchRequests && processed.maxConcurrentRequests > 1,
+        shouldLazyLoad: processed.lazyLoad,
+        hasCustomStyling: processed.styling.theme === 'custom' || Object.keys(processed.styling.customCSS || {}).length > 0
+      };
+
+      return processed
+    }
+
+
+    static createSecureConfig (userConfig, serverConfig = {}) {
+      const clientSafeServerConfig = {
+        apiBaseUrl: serverConfig.apiBaseUrl,
+        allowedFeatures: serverConfig.allowedFeatures,
+        rateLimits: serverConfig.rateLimits,
+        version: serverConfig.version
+      };
+      
+      return ConfigManager.create({
+        ...clientSafeServerConfig,
+        ...userConfig
+      })
+    }
+
+    static validateRuntimeConfig (config) {
+      if (!config) {
+        throw new Error('Configuration is required')
+      }
+
+      if (!config.derived) {
+        throw new Error('Configuration has not been processed')
+      }
+
+      return true
+    }
+
+    static getConfigSummary (config) {
+      return {
+        version: config.version,
+        apiBaseUrl: config.apiBaseUrl,
+        theme: config.styling.theme,
+        cacheEnabled: config.derived.shouldCache,
+        debugMode: config.debug,
+        features: Object.keys(config.features).filter(key => config.features[key])
+      }
+    }
+
+    /**
+     * Auto-détection de l'URL d'API selon le domaine
+     * SINGLE SOURCE OF TRUTH pour la détection d'environnement
+     * Enhanced with robust error handling for edge cases
+     */
+    static detectApiBaseUrl(debug = false) {
+      try {
+        // Edge case: No window object (SSR, Node.js, service worker)
+        if (typeof window === 'undefined') {
+          if (debug) console.warn('[ConfigManager] No window object - defaulting to production API');
+          return 'https://msys.vipros.fr/api'
+        }
+
+        // Edge case: window.location is not available or corrupted
+        if (!window.location || typeof window.location.hostname !== 'string') {
+          if (debug) console.warn('[ConfigManager] Invalid window.location - defaulting to production API');
+          return 'https://msys.vipros.fr/api'
+        }
+
+        const protocol = window.location.protocol || 'https:';
+        const hostname = window.location.hostname.toLowerCase();
+
+        // Edge case: Empty or invalid hostname
+        if (!hostname || hostname.length === 0) {
+          if (debug) console.warn('[ConfigManager] Empty hostname - defaulting to production API');
+          return 'https://msys.vipros.fr/api'
+        }
+
+        // Edge case: Local development environments
+        if (protocol === 'file:' || hostname === 'localhost' || hostname.startsWith('127.0.0.1') || hostname.startsWith('0.0.0.0')) {
+          if (debug) console.log('[ConfigManager] Local development detected - using DDEV fallback');
+          return 'https://vipros-connect.ddev.site/api'
+        }
+
+        // Edge case: Non-standard ports for development
+        if (hostname.includes(':') && (hostname.includes('localhost') || hostname.includes('127.0.0.1'))) {
+          if (debug) console.log('[ConfigManager] Local development with port detected - using DDEV fallback');
+          return 'https://vipros-connect.ddev.site/api'
+        }
+
+        // Correspondance directe des domaines
+        if (hostname === 'vipros-connect.ddev.site') {
+          return `${protocol}//${hostname}/api`
+        }
+
+        if (hostname === 'msys.preprod.vipros.fr') {
+          return `${protocol}//msys.preprod.vipros.fr/api`
+        }
+
+        // Edge case: Enterprise subdomains or custom VIPros domains
+        if (hostname.endsWith('.vipros.fr')) {
+          if (debug) console.log(`[ConfigManager] VIPros subdomain detected: ${hostname}`);
+          return `${protocol}//${hostname}/api`
+        }
+
+        // Edge case: IP addresses (development/staging environments)
+        if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname)) {
+          if (debug) console.log(`[ConfigManager] IP address detected: ${hostname} - using production API`);
+          return 'https://msys.vipros.fr/api'
+        }
+
+        // Par défaut : production (toujours HTTPS pour la sécurité)
+        if (debug) console.log(`[ConfigManager] Unknown domain: ${hostname} - defaulting to production API`);
+        return 'https://msys.vipros.fr/api'
+
+      } catch (error) {
+        // Edge case: Unexpected error during detection
+        if (debug) console.error(`[ConfigManager] Error during API base URL detection: ${error.message} - defaulting to production`);
+        return 'https://msys.vipros.fr/api'
+      }
+    }
+  }
+
+  class EventEmitter {
+    constructor () {
+      this.events = new Map();
+      this.maxListeners = 10;
+    }
+
+    on (event, callback) {
+      if (typeof callback !== 'function') {
+        throw new TypeError('Callback must be a function')
+      }
+
+      if (!this.events.has(event)) {
+        this.events.set(event, []);
+      }
+
+      const listeners = this.events.get(event);
+      
+      if (listeners.length >= this.maxListeners) {
+        console.warn(`Max listeners (${this.maxListeners}) exceeded for event: ${event}`);
+      }
+
+      listeners.push(callback);
+      return this
+    }
+
+    once (event, callback) {
+      if (typeof callback !== 'function') {
+        throw new TypeError('Callback must be a function')
+      }
+
+      const onceWrapper = (...args) => {
+        this.off(event, onceWrapper);
+        callback.apply(this, args);
+      };
+
+      return this.on(event, onceWrapper)
+    }
+
+    off (event, callback) {
+      if (!this.events.has(event)) {
+        return this
+      }
+
+      if (!callback) {
+        this.events.delete(event);
+        return this
+      }
+
+      const listeners = this.events.get(event);
+      const index = listeners.indexOf(callback);
+      
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+
+      if (listeners.length === 0) {
+        this.events.delete(event);
+      }
+
+      return this
+    }
+
+    emit (event, ...args) {
+      if (!this.events.has(event)) {
+        return false
+      }
+
+      const listeners = this.events.get(event).slice();
+      
+      for (const callback of listeners) {
+        try {
+          callback.apply(this, args);
+        } catch (error) {
+          console.error(`Error in event listener for '${event}':`, error);
+          this.emit('error', error);
+        }
+      }
+
+      return true
+    }
+
+    removeAllListeners (event = null) {
+      if (event) {
+        this.events.delete(event);
+      } else {
+        this.events.clear();
+      }
+      return this
+    }
+
+    listenerCount (event) {
+      return this.events.has(event) ? this.events.get(event).length : 0
+    }
+
+    getMaxListeners () {
+      return this.maxListeners
+    }
+
+    setMaxListeners (max) {
+      if (typeof max !== 'number' || max < 0) {
+        throw new TypeError('Max listeners must be a non-negative number')
+      }
+      this.maxListeners = max;
+      return this
+    }
+
+    eventNames () {
+      return Array.from(this.events.keys())
+    }
+
+    listeners (event) {
+      return this.events.has(event) ? this.events.get(event).slice() : []
+    }
+  }
+
+  // DEFLATE is a complex format; to read this code, you should probably check the RFC first:
+  // https://tools.ietf.org/html/rfc1951
+  // You may also wish to take a look at the guide I made about this program:
+  // https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad
+  // Some of the following code is similar to that of UZIP.js:
+  // https://github.com/photopea/UZIP.js
+  // However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.
+  // Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint
+  // is better for memory in most engines (I *think*).
+
+  // aliases for shorter compressed code (most minifers don't do this)
+  var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
+  // fixed length extra bits
+  var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
+  // fixed distance extra bits
+  var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
+  // code length index map
+  var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+  // get base, reverse index map from extra bits
+  var freb = function (eb, start) {
+      var b = new u16(31);
+      for (var i = 0; i < 31; ++i) {
+          b[i] = start += 1 << eb[i - 1];
+      }
+      // numbers here are at max 18 bits
+      var r = new i32(b[30]);
+      for (var i = 1; i < 30; ++i) {
+          for (var j = b[i]; j < b[i + 1]; ++j) {
+              r[j] = ((j - b[i]) << 5) | i;
+          }
+      }
+      return { b: b, r: r };
+  };
+  var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
+  // we can ignore the fact that the other numbers are wrong; they never happen anyway
+  fl[28] = 258, revfl[258] = 28;
+  var _b = freb(fdeb, 0), fd = _b.b;
+  // map of value to reverse (assuming 16 bits)
+  var rev = new u16(32768);
+  for (var i = 0; i < 32768; ++i) {
+      // reverse table algorithm from SO
+      var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);
+      x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);
+      x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);
+      rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;
+  }
+  // create huffman tree from u8 "map": index -> code length for code index
+  // mb (max bits) must be at most 15
+  // TODO: optimize/split up?
+  var hMap = (function (cd, mb, r) {
+      var s = cd.length;
+      // index
+      var i = 0;
+      // u16 "map": index -> # of codes with bit length = index
+      var l = new u16(mb);
+      // length of cd must be 288 (total # of codes)
+      for (; i < s; ++i) {
+          if (cd[i])
+              ++l[cd[i] - 1];
+      }
+      // u16 "map": index -> minimum code for bit length = index
+      var le = new u16(mb);
+      for (i = 1; i < mb; ++i) {
+          le[i] = (le[i - 1] + l[i - 1]) << 1;
+      }
+      var co;
+      if (r) {
+          // u16 "map": index -> number of actual bits, symbol for code
+          co = new u16(1 << mb);
+          // bits to remove for reverser
+          var rvb = 15 - mb;
+          for (i = 0; i < s; ++i) {
+              // ignore 0 lengths
+              if (cd[i]) {
+                  // num encoding both symbol and bits read
+                  var sv = (i << 4) | cd[i];
+                  // free bits
+                  var r_1 = mb - cd[i];
+                  // start value
+                  var v = le[cd[i] - 1]++ << r_1;
+                  // m is end value
+                  for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
+                      // every 16 bit value starting with the code yields the same result
+                      co[rev[v] >> rvb] = sv;
+                  }
+              }
+          }
+      }
+      else {
+          co = new u16(s);
+          for (i = 0; i < s; ++i) {
+              if (cd[i]) {
+                  co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);
+              }
+          }
+      }
+      return co;
+  });
+  // fixed length tree
+  var flt = new u8(288);
+  for (var i = 0; i < 144; ++i)
+      flt[i] = 8;
+  for (var i = 144; i < 256; ++i)
+      flt[i] = 9;
+  for (var i = 256; i < 280; ++i)
+      flt[i] = 7;
+  for (var i = 280; i < 288; ++i)
+      flt[i] = 8;
+  // fixed distance tree
+  var fdt = new u8(32);
+  for (var i = 0; i < 32; ++i)
+      fdt[i] = 5;
+  // fixed length map
+  var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
+  // fixed distance map
+  var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
+  // find max of array
+  var max = function (a) {
+      var m = a[0];
+      for (var i = 1; i < a.length; ++i) {
+          if (a[i] > m)
+              m = a[i];
+      }
+      return m;
+  };
+  // read d, starting at bit p and mask with m
+  var bits = function (d, p, m) {
+      var o = (p / 8) | 0;
+      return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;
+  };
+  // read d, starting at bit p continuing for at least 16 bits
+  var bits16 = function (d, p) {
+      var o = (p / 8) | 0;
+      return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));
+  };
+  // get end of byte
+  var shft = function (p) { return ((p + 7) / 8) | 0; };
+  // typed array slice - allows garbage collector to free original reference,
+  // while being more compatible than .slice
+  var slc = function (v, s, e) {
+      if (e == null || e > v.length)
+          e = v.length;
+      // can't use .constructor in case user-supplied
+      return new u8(v.subarray(s, e));
+  };
+  // error codes
+  var ec = [
+      'unexpected EOF',
+      'invalid block type',
+      'invalid length/literal',
+      'invalid distance',
+      'stream finished',
+      'no stream handler',
+      ,
+      'no callback',
+      'invalid UTF-8 data',
+      'extra field too long',
+      'date not in range 1980-2099',
+      'filename too long',
+      'stream finishing',
+      'invalid zip data'
+      // determined by unknown compression method
+  ];
+  var err = function (ind, msg, nt) {
+      var e = new Error(msg || ec[ind]);
+      e.code = ind;
+      if (Error.captureStackTrace)
+          Error.captureStackTrace(e, err);
+      if (!nt)
+          throw e;
+      return e;
+  };
+  // expands raw DEFLATE data
+  var inflt = function (dat, st, buf, dict) {
+      // source length       dict length
+      var sl = dat.length, dl = 0;
+      if (!sl || st.f && !st.l)
+          return buf || new u8(0);
+      var noBuf = !buf;
+      // have to estimate size
+      var resize = noBuf || st.i != 2;
+      // no state
+      var noSt = st.i;
+      // Assumes roughly 33% compression ratio average
+      if (noBuf)
+          buf = new u8(sl * 3);
+      // ensure buffer can fit at least l elements
+      var cbuf = function (l) {
+          var bl = buf.length;
+          // need to increase size to fit
+          if (l > bl) {
+              // Double or set to necessary, whichever is greater
+              var nbuf = new u8(Math.max(bl * 2, l));
+              nbuf.set(buf);
+              buf = nbuf;
+          }
+      };
+      //  last chunk         bitpos           bytes
+      var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+      // total bits
+      var tbts = sl * 8;
+      do {
+          if (!lm) {
+              // BFINAL - this is only 1 when last chunk is next
+              final = bits(dat, pos, 1);
+              // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman
+              var type = bits(dat, pos + 1, 3);
+              pos += 3;
+              if (!type) {
+                  // go to end of byte boundary
+                  var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
+                  if (t > sl) {
+                      if (noSt)
+                          err(0);
+                      break;
+                  }
+                  // ensure size
+                  if (resize)
+                      cbuf(bt + l);
+                  // Copy over uncompressed data
+                  buf.set(dat.subarray(s, t), bt);
+                  // Get new bitpos, update byte count
+                  st.b = bt += l, st.p = pos = t * 8, st.f = final;
+                  continue;
+              }
+              else if (type == 1)
+                  lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+              else if (type == 2) {
+                  //  literal                            lengths
+                  var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+                  var tl = hLit + bits(dat, pos + 5, 31) + 1;
+                  pos += 14;
+                  // length+distance tree
+                  var ldt = new u8(tl);
+                  // code length tree
+                  var clt = new u8(19);
+                  for (var i = 0; i < hcLen; ++i) {
+                      // use index map to get real code
+                      clt[clim[i]] = bits(dat, pos + i * 3, 7);
+                  }
+                  pos += hcLen * 3;
+                  // code lengths bits
+                  var clb = max(clt), clbmsk = (1 << clb) - 1;
+                  // code lengths map
+                  var clm = hMap(clt, clb, 1);
+                  for (var i = 0; i < tl;) {
+                      var r = clm[bits(dat, pos, clbmsk)];
+                      // bits read
+                      pos += r & 15;
+                      // symbol
+                      var s = r >> 4;
+                      // code length to copy
+                      if (s < 16) {
+                          ldt[i++] = s;
+                      }
+                      else {
+                          //  copy   count
+                          var c = 0, n = 0;
+                          if (s == 16)
+                              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                          else if (s == 17)
+                              n = 3 + bits(dat, pos, 7), pos += 3;
+                          else if (s == 18)
+                              n = 11 + bits(dat, pos, 127), pos += 7;
+                          while (n--)
+                              ldt[i++] = c;
+                      }
+                  }
+                  //    length tree                 distance tree
+                  var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+                  // max length bits
+                  lbt = max(lt);
+                  // max dist bits
+                  dbt = max(dt);
+                  lm = hMap(lt, lbt, 1);
+                  dm = hMap(dt, dbt, 1);
+              }
+              else
+                  err(1);
+              if (pos > tbts) {
+                  if (noSt)
+                      err(0);
+                  break;
+              }
+          }
+          // Make sure the buffer can hold this + the largest possible addition
+          // Maximum chunk size (practically, theoretically infinite) is 2^17
+          if (resize)
+              cbuf(bt + 131072);
+          var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+          var lpos = pos;
+          for (;; lpos = pos) {
+              // bits read, code
+              var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+              pos += c & 15;
+              if (pos > tbts) {
+                  if (noSt)
+                      err(0);
+                  break;
+              }
+              if (!c)
+                  err(2);
+              if (sym < 256)
+                  buf[bt++] = sym;
+              else if (sym == 256) {
+                  lpos = pos, lm = null;
+                  break;
+              }
+              else {
+                  var add = sym - 254;
+                  // no extra bits needed if less
+                  if (sym > 264) {
+                      // index
+                      var i = sym - 257, b = fleb[i];
+                      add = bits(dat, pos, (1 << b) - 1) + fl[i];
+                      pos += b;
+                  }
+                  // dist
+                  var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+                  if (!d)
+                      err(3);
+                  pos += d & 15;
+                  var dt = fd[dsym];
+                  if (dsym > 3) {
+                      var b = fdeb[dsym];
+                      dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+                  }
+                  if (pos > tbts) {
+                      if (noSt)
+                          err(0);
+                      break;
+                  }
+                  if (resize)
+                      cbuf(bt + 131072);
+                  var end = bt + add;
+                  if (bt < dt) {
+                      var shift = dl - dt, dend = Math.min(dt, end);
+                      if (shift + bt < 0)
+                          err(3);
+                      for (; bt < dend; ++bt)
+                          buf[bt] = dict[shift + bt];
+                  }
+                  for (; bt < end; ++bt)
+                      buf[bt] = buf[bt - dt];
+              }
+          }
+          st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+          if (lm)
+              final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+      } while (!final);
+      // don't reallocate for streams or user buffers
+      return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+  };
+  // empty
+  var et = /*#__PURE__*/ new u8(0);
+  // gzip footer: -8 to -4 = CRC, -4 to -0 is length
+  // gzip start
+  var gzs = function (d) {
+      if (d[0] != 31 || d[1] != 139 || d[2] != 8)
+          err(6, 'invalid gzip data');
+      var flg = d[3];
+      var st = 10;
+      if (flg & 4)
+          st += (d[10] | d[11] << 8) + 2;
+      for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
+          ;
+      return st + (flg & 2);
+  };
+  // gzip length
+  var gzl = function (d) {
+      var l = d.length;
+      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+  };
+  // zlib start
+  var zls = function (d, dict) {
+      if ((d[0] & 15) != 8 || (d[0] >> 4) > 7 || ((d[0] << 8 | d[1]) % 31))
+          err(6, 'invalid zlib data');
+      if ((d[1] >> 5 & 1) == 1)
+          err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary');
+      return (d[1] >> 3 & 4) + 2;
+  };
+  /**
+   * Expands GZIP data
+   * @param data The data to decompress
+   * @param opts The decompression options
+   * @returns The decompressed version of the data
+   */
+  function gunzipSync(data, opts) {
+      var st = gzs(data);
+      if (st + 8 > data.length)
+          err(6, 'invalid gzip data');
+      return inflt(data.subarray(st, -8), { i: 2 }, new u8(gzl(data)), opts);
+  }
+  /**
+   * Expands Zlib data
+   * @param data The data to decompress
+   * @param opts The decompression options
+   * @returns The decompressed version of the data
+   */
+  function unzlibSync(data, opts) {
+      return inflt(data.subarray(zls(data), -4), { i: 2 }, opts, opts);
+  }
+  // text decoder
+  var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();
+  // text decoder stream
+  var tds = 0;
+  try {
+      td.decode(et, { stream: true });
+      tds = 1;
+  }
+  catch (e) { }
+
+  /**
+   * Implémentation simple du Bloom Filter pour SDK VIPros
+   * Compatible avec le générateur PHP côté serveur
+   */
+  class SimpleBloomFilter {
+    constructor(compressedData, options = {}) {
+      this.debugEnabled = Boolean(options.debug);
+      try {
+        // Décompresser les données gzip (simulation simple)
+        this.bits = this.decompress(compressedData);
+        this.size = this.bits.length * 8;
+        this.k = 7; // Nombre de fonctions de hachage (même que côté serveur)
+      } catch (error) {
+        console.warn('[BloomFilter] Decompression failed, using raw data', error);
+        this.bits = compressedData;
+        this.size = this.bits.length * 8;
+        this.k = 7;
+      }
+    }
+
+    /**
+     * Teste si un EAN pourrait être présent dans le filtre
+     * @param {string} ean - Code EAN à tester
+     * @returns {boolean} true si l'EAN pourrait être présent, false s'il est définitivement absent
+     */
+    test(ean) {
+      if (!this.isValidEan(ean)) {
+        this.debug('[BloomFilter] Invalid EAN format:', ean);
+        return false
+      }
+
+      this.debug('[BloomFilter] Testing EAN:', ean, 'Size:', this.size, 'Bits length:', this.bits.length);
+
+      for (let i = 0; i < this.k; i++) {
+        const fullHash = this.hash(ean + i);
+        const hash = fullHash % this.size;
+        const byte = Math.floor(hash / 8);
+        const bit = hash % 8;
+        const bitValue = !!(this.bits[byte] & (1 << bit));
+
+        this.debug(`[BloomFilter] Hash ${i}: ${fullHash} % ${this.size} = ${hash}, byte=${byte}, bit=${bit}, value=${bitValue}`);
+
+        if (!bitValue) {
+          this.debug(`[BloomFilter] EAN ${ean} NOT found (hash ${i} failed)`);
+          return false // Définitivement absent
+        }
+      }
+      this.debug(`[BloomFilter] EAN ${ean} FOUND (all ${this.k} hashes passed)`);
+      return true // Peut-être présent
+    }
+
+    /**
+     * Fonction de hachage CRC32 compatible avec PHP
+     * @param {string} str - Chaîne à hacher
+     * @returns {number} Hash absolu
+     */
+    hash(str) {
+      // Implémentation CRC32 compatible avec PHP
+      const crcTable = this.getCrc32Table();
+      let crc = 0xFFFFFFFF;
+
+      for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        crc = (crc >>> 8) ^ crcTable[(crc ^ char) & 0xFF];
+      }
+
+      return Math.abs((crc ^ 0xFFFFFFFF) >>> 0)
+    }
+
+    /**
+     * Génère la table CRC32
+     * @returns {Uint32Array} Table CRC32
+     */
+    getCrc32Table() {
+      if (this.crc32Table) {
+        return this.crc32Table
+      }
+
+      // Utiliser une table CRC32 pré-calculée pour éviter les problèmes de stack
+      this.crc32Table = new Uint32Array([
+        0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+        0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+        0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+        0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+        0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+        0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+        0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+        0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+        0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+        0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+        0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+        0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+        0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+        0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+        0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+        0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+        0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+        0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+        0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+        0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+        0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+        0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+        0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+        0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+        0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+        0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+        0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+        0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+        0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+        0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+        0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+        0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+        0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+        0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+        0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+        0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+        0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+        0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+        0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+        0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+        0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+        0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+        0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+      ]);
+
+      return this.crc32Table
+    }
+
+    /**
+     * Valide le format d'un EAN
+     * @param {string} ean - EAN à valider
+     * @returns {boolean} true si valide
+     */
+    isValidEan(ean) {
+      return typeof ean === 'string' && /^\d{8}$|^\d{12}$|^\d{13}$/.test(ean)
+    }
+
+    /**
+     * Décompresse les données zlib/gzcompress
+     * @param {Uint8Array} data - Données compressées
+     * @returns {Uint8Array} Données décompressées
+     */
+    decompress(data) {
+      try {
+        let buffer = data instanceof Uint8Array ? data : new Uint8Array(data);
+
+        if (buffer.length === 0) {
+          return buffer
+        }
+
+        if (buffer[0] === 0x78) {
+          this.debug('[BloomFilter] Detected zlib/gzcompress data, inflating');
+          try {
+            return unzlibSync(buffer)
+          } catch (inflateError) {
+            this.debug('[BloomFilter] unzlibSync failed, fallback to raw:', inflateError.message);
+          }
+        }
+
+        if (buffer[0] === 0x1f && buffer[1] === 0x8b) {
+          this.debug('[BloomFilter] Detected gzip data, inflating');
+          try {
+            return gunzipSync(buffer)
+          } catch (gunzipError) {
+            this.debug('[BloomFilter] gunzipSync failed, fallback to raw:', gunzipError.message);
+          }
+        }
+      } catch (error) {
+        this.debug('[BloomFilter] Decompression failed:', error.message);
+      }
+
+      const fallbackBuffer = data instanceof Uint8Array ? data : new Uint8Array(data);
+      this.debug('[BloomFilter] Using raw data, size:', fallbackBuffer.length);
+      return fallbackBuffer
+    }
+
+    /**
+     * Retourne les statistiques du filtre
+     * @returns {Object} Statistiques
+     */
+    getStats() {
+      return {
+        size: this.size,
+        bytes: this.bits.length,
+        hashFunctions: this.k,
+        loaded: true
+      }
+    }
+
+    debug(...args) {
+      if (this.debugEnabled) {
+        console.debug(...args);
+      }
+    }
+  }
+
+  class ApiClient extends EventEmitter {
+    constructor (config) {
+      super();
+      this.config = config;
+      this.baseUrl = this.config.apiBaseUrl;
+      this.defaultHeaders = this.buildDefaultHeaders();
+      this.retryConfig = {
+        maxRetries: 3,
+        baseDelay: 1000,
+        maxDelay: 10000
+      };
+      this.requestQueue = [];
+      this.isProcessingQueue = false;
+      this.rateLimitInfo = {
+        remaining: null,
+        resetTime: null,
+        limit: null
+      };
+      // Bloom Filter pour optimisation invisible
+      this.bloomFilter = null;
+      this.bloomLoaded = false;
+      this.bloomLoadPromise = null;
+    }
+
+    buildDefaultHeaders () {
+      const sdkVersion = this.config.version || '3.0.0-unified';
+      const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'User-Agent': `ViprosSDK/${sdkVersion} (JavaScript)`,
+        'X-SDK-Version': sdkVersion,
+        'X-SDK-Client': 'JavaScript'
+      };
+
+      if (this.config.apiKey) {
+        headers['x-api-key'] = this.config.apiKey;
+      }
+
+      if (typeof window !== 'undefined' && window.location) {
+        headers['Referer'] = window.location.href;
+        headers['Origin'] = window.location.origin;
+      }
+
+      return headers
+    }
+
+    async getCatalogItems (filters = {}, options = {}) {
+      this.debug('[ViprosSDK] getCatalogItems() called with filters:', filters, 'options:', options);
+
+      const params = new URLSearchParams();
+
+      Object.entries(filters).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          params.append(key, value.toString());
+        }
+      });
+
+      // Support pour la sync inline (nouveau en Phase 8)
+      if (options.enableInlineSync) {
+        params.append('sync', 'auto');
+
+        // Passer l'URL du produit pour la sync
+        if (options.productUrl) {
+          params.append('product_url', options.productUrl);
+        }
+
+        // Force sync si demandé
+        if (options.forceSync) {
+          params.append('force_sync', '1');
+        }
+
+        // Activer debug mode pour obtenir les métadonnées de sync
+        params.append('debug', 'true');
+      }
+
+      // Utiliser l'endpoint SDK sécurisé
+      const url = `${this.baseUrl}/sdk/catalog/items${params.toString() ? '?' + params.toString() : ''}`;
+
+      // Headers additionnels pour la sync inline
+      const headers = {};
+      if (options.enableInlineSync && options.productUrl) {
+        headers['X-Product-Url'] = options.productUrl;
+      }
+
+      return this.request('GET', url, null, { headers })
+    }
+
+    /**
+     * Récupère un produit unique par son EAN (route optimisée)
+     * Plus performante que getCatalogItems() car évite la pagination et le count ES
+     *
+     * @param {string} ean - Code EAN du produit (8-14 chiffres)
+     * @param {Object} options - Options de requête
+     * @param {boolean} options.enableInlineSync - Activer la sync inline
+     * @param {string} options.productUrl - URL du produit pour la sync
+     * @param {boolean} options.forceSync - Forcer la sync même si cooldown actif
+     * @returns {Promise<Object|null>} Produit ou null si non trouvé
+     */
+    async getCatalogItemByEan (ean, options = {}) {
+      this.debug('[ViprosSDK] getCatalogItemByEan() called with ean:', ean, 'options:', options);
+
+      // Vérification Bloom Filter invisible
+      const shouldSkip = await this.shouldSkipEan(ean);
+      if (shouldSkip) {
+        this.debug('[ViprosSDK] getCatalogItemByEan() - EAN not in bloom filter, skipping API call');
+        return null
+      }
+
+      // Construire les paramètres de requête
+      const params = new URLSearchParams();
+
+      // Support pour la sync inline
+      if (options.enableInlineSync) {
+        params.append('sync', 'auto');
+
+        if (options.productUrl) {
+          params.append('product_url', options.productUrl);
+        }
+
+        if (options.forceSync) {
+          params.append('force_sync', '1');
+        }
+
+        params.append('debug', 'true');
+      }
+
+      // Utiliser l'endpoint SDK optimisé avec EAN dans le path
+      const queryString = params.toString();
+      const url = `${this.baseUrl}/sdk/catalog/items/${encodeURIComponent(ean)}${queryString ? '?' + queryString : ''}`;
+
+      // Headers additionnels pour la sync inline
+      const headers = {};
+      if (options.enableInlineSync && options.productUrl) {
+        headers['X-Product-Url'] = options.productUrl;
+      }
+
+      try {
+        const response = await this.request('GET', url, null, { headers });
+
+        // Gérer le cas 404 (produit non trouvé)
+        if (response.code === 404 || !response.item) {
+          this.debug('[ViprosSDK] getCatalogItemByEan() - Product not found for EAN:', ean);
+          return null
+        }
+
+        this.debug('[ViprosSDK] getCatalogItemByEan() - Product found:', response.item?.name);
+        return response.item
+      } catch (error) {
+        this.debug('[ViprosSDK] getCatalogItemByEan() - Error:', error?.message || error);
+        // Graceful degradation - return null instead of throwing
+        return null
+      }
+    }
+
+    async updateProductUrls (updates) {
+      if (!Array.isArray(updates) || updates.length === 0) {
+        throw new Error('Updates must be a non-empty array')
+      }
+
+      const url = `${this.baseUrl}/catalog/stores/update_urls`;
+      return this.request('POST', url, { updates })
+    }
+
+    async getProductUpdates () {
+      const url = `${this.baseUrl}/catalog/stores/get_updates`;
+      return this.request('GET', url)
+    }
+
+    async healthCheck () {
+      const url = `${this.baseUrl}/sdk/health`;
+      return this.request('GET', url)
+    }
+
+    async syncProduct (ean, productUrl, forceSync = false) {
+      if (!ean || !productUrl) {
+        throw new Error('EAN and product URL are required for synchronization')
+      }
+
+      const url = `${this.config.apiBaseUrl}/partners-stores/sync`;
+      
+      const headers = {};
+      
+      const payload = { 
+        ean: ean.toString(),
+        url: productUrl 
+      };
+      
+      // Ajouter le paramètre force_sync si nécessaire
+      if (forceSync) {
+        payload.force_sync = true;
+      }
+      
+      return this.request('POST', url, payload, { headers })
+    }
+
+    /**
+     * Méthode GET simple pour Web Components
+     * @param {string} endpoint - Endpoint (ex: '/catalog/items')
+     * @param {Object} params - Paramètres de requête
+     * @param {Object} options - Options additionnelles (enableInlineSync, productUrl, forceSync)
+     * @returns {Promise<Object>}
+     */
+    async get(endpoint, params = {}, options = {}) {
+      // Rediriger les appels SDK vers les endpoints optimisés
+      if (endpoint === '/catalog/items') {
+        // Si un seul EAN est demandé, utiliser la route optimisée
+        if (params.ean && !params.ean.includes(',')) {
+          this.debug('[ViprosSDK] get() method - using optimized single EAN route');
+          const item = await this.getCatalogItemByEan(params.ean, options);
+
+          // Retourner au format compatible avec l'ancien format items[]
+          if (item) {
+            return {
+              items: [item],
+              code: 200
+            }
+          } else {
+            return {
+              items: [],
+              code: 404,
+              metadata: {
+                ean: params.ean,
+                optimizedRoute: true
+              }
+            }
+          }
+        }
+
+        // Pour les autres cas (pas d'EAN ou plusieurs EANs), utiliser l'ancienne route
+        // Vérification Bloom Filter invisible
+        if (params.ean) {
+          const shouldSkip = await this.shouldSkipEan(params.ean);
+          this.debug(`[ViprosSDK] get() method - shouldSkip: ${shouldSkip}`);
+          if (shouldSkip) {
+            // Retourner réponse vide sans appel API, indiquer le court-circuit Bloom
+            this.debug('[ViprosSDK] get() method - returning empty items, API call skipped (bloom filter)');
+            return {
+              items: [],
+              metadata: {
+                bloomFilter: {
+                  skipped: true,
+                  reason: 'NOT_IN_FILTER',
+                  ean: params.ean
+                }
+              }
+            }
+          }
+        }
+
+        this.debug('[ViprosSDK] get() method - calling getCatalogItems() with options:', options);
+        return this.getCatalogItems(params, options)
+      }
+
+      // Pour les autres endpoints, construire l'URL et faire la requête
+      const url = `${this.baseUrl}${endpoint}`;
+      const searchParams = new URLSearchParams();
+
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          searchParams.append(key, value.toString());
+        }
+      });
+
+      const fullUrl = searchParams.toString() ? `${url}?${searchParams.toString()}` : url;
+      return this.request('GET', fullUrl)
+    }
+
+    async request (method, url, data = null, options = {}) {
+      return new Promise((resolve, reject) => {
+        const requestConfig = {
+          method,
+          url,
+          data,
+          options: {
+            retry: true,
+            ...options
+          },
+          resolve,
+          reject,
+          attempts: 0
+        };
+
+        this.requestQueue.push(requestConfig);
+        this.processQueue();
+      })
+    }
+
+    async processQueue () {
+      if (this.isProcessingQueue || this.requestQueue.length === 0) {
+        return
+      }
+
+      this.isProcessingQueue = true;
+
+      while (this.requestQueue.length > 0) {
+        const requestConfig = this.requestQueue.shift();
+        
+        try {
+          const result = await this.executeRequest(requestConfig);
+          requestConfig.resolve(result);
+        } catch (error) {
+          if (requestConfig.options.retry && this.shouldRetry(error, requestConfig)) {
+            await this.scheduleRetry(requestConfig);
+          } else {
+            requestConfig.reject(error);
+          }
+        }
+
+        if (this.rateLimitInfo.remaining !== null && this.rateLimitInfo.remaining <= 1) {
+          const delay = this.calculateRateLimitDelay();
+          if (delay > 0) {
+            await this.sleep(delay);
+          }
+        }
+      }
+
+      this.isProcessingQueue = false;
+    }
+
+    async executeRequest (requestConfig) {
+      const { method, url, data, options } = requestConfig;
+      requestConfig.attempts++;
+
+
+      const requestOptions = {
+        method,
+        headers: { ...this.defaultHeaders, ...options.headers },
+        credentials: 'omit'
+      };
+
+      if (data && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+        requestOptions.body = JSON.stringify(data);
+      }
+
+      if (options.timeout) {
+        const controller = new AbortController();
+        requestOptions.signal = controller.signal;
+        setTimeout(() => controller.abort(), options.timeout);
+      }
+
+      const startTime = Date.now();
+      
+      try {
+        const response = await fetch(url, requestOptions);
+        const responseTime = Date.now() - startTime;
+        
+        this.updateRateLimitInfo(response);
+        
+        if (!response.ok) {
+          const error = await this.handleErrorResponse(response);
+          this.emit('error', error);
+          throw error
+        }
+
+        const result = await response.json();
+
+        this.emit('response', {
+          url,
+          method,
+          status: response.status,
+          responseTime,
+          data: result
+        });
+
+        return result
+      } catch (error) {
+        
+        if (error.name === 'AbortError') {
+          throw this.createNetworkError('TIMEOUT', `Request timeout after ${options.timeout}ms`, url, method)
+        }
+
+        if (error.name === 'TypeError' && error.message.includes('fetch')) {
+          throw this.createNetworkError('NETWORK_ERROR', 'Network error - please check your connection', url, method, error)
+        }
+
+        throw error
+      }
+    }
+
+    async handleErrorResponse (response) {
+      const contentType = response.headers.get('content-type');
+      let errorData;
+
+      try {
+        if (contentType && contentType.includes('application/json')) {
+          errorData = await response.json();
+        } else {
+          errorData = { message: await response.text() };
+        }
+      } catch (parseError) {
+        errorData = { message: `HTTP ${response.status}` };
+      }
+
+      const error = new Error(errorData.message || `HTTP ${response.status}`);
+      error.status = response.status;
+      error.code = errorData.code || response.status;
+      error.url = response.url;
+      error.data = errorData;
+
+      switch (response.status) {
+        case 400:
+          error.type = 'VALIDATION_ERROR';
+          break
+        case 401:
+          error.type = 'AUTHENTICATION_ERROR';
+          break
+        case 403:
+          error.type = 'AUTHORIZATION_ERROR';
+          break
+        case 404:
+          error.type = 'NOT_FOUND';
+          break
+        case 429:
+          error.type = 'RATE_LIMIT_ERROR';
+          error.retryAfter = parseInt(response.headers.get('Retry-After')) || 60;
+          break
+        case 500:
+          error.type = 'SERVER_ERROR';
+          break
+        case 502:
+        case 503:
+        case 504:
+          error.type = 'SERVICE_UNAVAILABLE';
+          break
+        default:
+          error.type = 'UNKNOWN_ERROR';
+      }
+
+      return error
+    }
+
+    shouldRetry (error, requestConfig) {
+      if (requestConfig.attempts >= this.retryConfig.maxRetries) {
+        return false
+      }
+
+      if (!requestConfig.options.retry) {
+        return false
+      }
+
+      // ❌ NE PAS retry les erreurs rate limit - les faire remonter immédiatement pour affichage
+      if (error.status === 429 || error.type === 'RATE_LIMIT_ERROR') {
+        return false
+      }
+
+      const retryableStatuses = [500, 502, 503, 504];
+      const retryableTypes = ['SERVER_ERROR', 'SERVICE_UNAVAILABLE', 'TIMEOUT', 'NETWORK_ERROR'];
+
+      return retryableStatuses.includes(error.status) ||
+             retryableTypes.includes(error.type) ||
+             retryableTypes.includes(error.code)
+    }
+
+    async scheduleRetry (requestConfig) {
+      const delay = this.calculateRetryDelay(requestConfig);
+      
+      await this.sleep(delay);
+      this.requestQueue.unshift(requestConfig);
+    }
+
+    calculateRetryDelay (requestConfig) {
+      const baseDelay = this.retryConfig.baseDelay;
+      const exponentialDelay = baseDelay * Math.pow(2, requestConfig.attempts - 1);
+      const jitter = Math.random() * 1000;
+      
+      return Math.min(exponentialDelay + jitter, this.retryConfig.maxDelay)
+    }
+
+    calculateRateLimitDelay () {
+      if (!this.rateLimitInfo.resetTime) {
+        return 0
+      }
+
+      const now = Date.now();
+      const resetTime = this.rateLimitInfo.resetTime * 1000;
+      
+      return Math.max(0, resetTime - now + 1000)
+    }
+
+    updateRateLimitInfo (response) {
+      const limit = response.headers.get('X-RateLimit-Limit');
+      const remaining = response.headers.get('X-RateLimit-Remaining');
+      const reset = response.headers.get('X-RateLimit-Reset');
+
+      if (limit) this.rateLimitInfo.limit = parseInt(limit);
+      if (remaining) this.rateLimitInfo.remaining = parseInt(remaining);
+      if (reset) this.rateLimitInfo.resetTime = parseInt(reset);
+    }
+
+    sleep (ms) {
+      return new Promise(resolve => setTimeout(resolve, ms))
+    }
+
+    getRateLimitInfo () {
+      return { ...this.rateLimitInfo }
+    }
+
+    getQueueStatus () {
+      return {
+        queueLength: this.requestQueue.length,
+        isProcessing: this.isProcessingQueue
+      }
+    }
+
+    clearQueue () {
+      this.requestQueue.forEach(req => {
+        req.reject(new Error('Request queue cleared'));
+      });
+      this.requestQueue = [];
+      this.isProcessingQueue = false;
+    }
+
+    createNetworkError (code, message, url, method, originalError = null) {
+      const error = new Error(message);
+      error.code = code;
+      error.url = url;
+      error.method = method;
+      if (originalError) {
+        error.originalError = originalError;
+      }
+      return error
+    }
+
+    destroy () {
+      this.clearQueue();
+      this.removeAllListeners();
+    }
+
+    // Méthodes Bloom Filter pour optimisation invisible
+    async shouldSkipEan(ean) {
+      try {
+        this.debug('[ViprosSDK] Bloom filter check for EAN:', ean);
+
+        await this.loadBloomFilter();
+
+        if (!this.bloomFilter) {
+          this.debug('[ViprosSDK] No bloom filter available, allowing API call');
+          return false
+        }
+
+        const isPresent = this.bloomFilter.test(ean);
+        const shouldSkip = !isPresent;
+        this.debug(`[ViprosSDK] Bloom filter test for ${ean}: ${isPresent}, shouldSkip: ${shouldSkip}`);
+
+        return shouldSkip
+      } catch (error) {
+        this.debug('[ViprosSDK] Bloom filter error:', error?.message || error);
+        return false
+      }
+    }
+
+    async loadBloomFilter() {
+      if (this.bloomLoaded) {
+        return this.bloomFilter
+      }
+
+      if (this.bloomLoadPromise) {
+        return this.bloomLoadPromise
+      }
+
+      this.bloomLoadPromise = (async () => {
+        try {
+          const storage = this.getStorage();
+          if (storage) {
+            const cached = storage.getItem('vipros_bloom');
+            const cacheTime = storage.getItem('vipros_bloom_time');
+
+            if (cached && cacheTime && (Date.now() - parseInt(cacheTime, 10)) < 86400000) {
+              this.bloomFilter = new SimpleBloomFilter(this.base64ToUint8Array(cached), { debug: this.isDebugEnabled() });
+              this.debug('[ViprosSDK] Bloom filter loaded from cache');
+              this.bloomLoaded = true;
+              return this.bloomFilter
+            }
+          }
+
+          const response = await fetch(`${this.baseUrl}/sdk/bloom`, {
+            headers: {
+              'Accept': 'application/octet-stream',
+              'x-api-key': this.config.apiKey
+            }
+          });
+
+          if (!response.ok) {
+            this.debug('[ViprosSDK] Unable to download bloom filter, status:', response.status);
+            this.bloomFilter = null;
+            this.bloomLoaded = true;
+            return this.bloomFilter
+          }
+
+          const buffer = await response.arrayBuffer();
+          const data = new Uint8Array(buffer);
+
+          this.bloomFilter = new SimpleBloomFilter(data, { debug: this.isDebugEnabled() });
+
+          if (storage) {
+            storage.setItem('vipros_bloom', this.uint8ArrayToBase64(data));
+            storage.setItem('vipros_bloom_time', Date.now().toString());
+          }
+
+          this.debug('[ViprosSDK] Bloom filter downloaded and cached');
+          this.bloomLoaded = true;
+          return this.bloomFilter
+        } catch (error) {
+          this.debug('[ViprosSDK] Bloom filter unavailable:', error?.message || error);
+          this.bloomFilter = null;
+          this.bloomLoaded = true;
+          return this.bloomFilter
+        } finally {
+          this.bloomLoadPromise = null;
+        }
+      })();
+
+      return this.bloomLoadPromise
+    }
+
+    uint8ArrayToBase64(uint8Array) {
+      if (typeof globalThis !== 'undefined' && globalThis.Buffer) {
+        return globalThis.Buffer.from(uint8Array).toString('base64')
+      }
+
+      let binary = '';
+      const chunkSize = 0x8000;
+
+      for (let i = 0; i < uint8Array.length; i += chunkSize) {
+        const chunk = uint8Array.subarray(i, i + chunkSize);
+        let chunkText = '';
+        for (let j = 0; j < chunk.length; j++) {
+          chunkText += String.fromCharCode(chunk[j]);
+        }
+        binary += chunkText;
+      }
+
+      return btoa(binary)
+    }
+
+    base64ToUint8Array(base64) {
+      if (typeof globalThis !== 'undefined' && globalThis.Buffer) {
+        return new Uint8Array(globalThis.Buffer.from(base64, 'base64'))
+      }
+
+      const binary = atob(base64);
+      const length = binary.length;
+      const bytes = new Uint8Array(length);
+
+      for (let i = 0; i < length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+      }
+
+      return bytes
+    }
+
+    getStorage () {
+      if (typeof window === 'undefined' || !window.localStorage) {
+        return null
+      }
+
+      try {
+        // Accessing localStorage can throw in some browsers (privacy mode)
+        const testKey = '__vipros_storage_test__';
+        window.localStorage.setItem(testKey, '1');
+        window.localStorage.removeItem(testKey);
+        return window.localStorage
+      } catch (error) {
+        this.debug('[ViprosSDK] localStorage unavailable:', error?.message || error);
+        return null
+      }
+    }
+
+    debug(...args) {
+      if (this.isDebugEnabled()) {
+        console.debug(...args);
+      }
+    }
+
+    isDebugEnabled () {
+      return Boolean(this.config && this.config.debug)
+    }
+  }
+
+  var ApiClient$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: ApiClient
+  });
+
+  /**
+   * CacheService Simplifié - Cache Mémoire Uniquement
+   *
+   * Version optimisée qui utilise uniquement la mémoire.
+   * La persistance est gérée côté serveur avec cooldown 24h.
+   */
+  class CacheService extends EventEmitter {
+    constructor (cacheTimeout = 300000) {
+      super();
+      // Validation: s'assurer que cacheTimeout est un nombre
+      if (typeof cacheTimeout !== 'number' || isNaN(cacheTimeout) || cacheTimeout < 0) {
+        console.warn('[CacheService] Invalid cacheTimeout, using default 300000ms');
+        cacheTimeout = 300000;
+      }
+      this.cacheTimeout = cacheTimeout;
+      this.memoryCache = new Map();
+
+      this.setupCleanupInterval();
+    }
+
+    get (key, useStorage = true) {
+      const fullKey = this.buildKey(key);
+
+      let cached = this.memoryCache.get(fullKey);
+      if (cached && this.isValidCacheEntry(cached)) {
+        cached.hits = (cached.hits || 0) + 1;
+        cached.lastAccessTime = Date.now();
+        this.emit('hit', { key, source: 'memory' });
+        return cached.data
+      }
+
+      this.emit('miss', { key });
+      return null
+    }
+
+    set (key, data, options = {}) {
+      const fullKey = this.buildKey(key);
+      const entry = this.createCacheEntry(data, options);
+
+      this.memoryCache.set(fullKey, entry);
+
+      this.emit('set', { key, size: this.estimateSize(data) });
+      this.enforceCacheLimits();
+    }
+
+    createCacheEntry (data, options = {}) {
+      const now = Date.now();
+      const ttl = options.ttl || this.cacheTimeout;
+
+      return {
+        data,
+        timestamp: now,
+        expires: ttl > 0 ? now + ttl : null,
+        hits: 0,
+        lastAccessTime: now,
+        size: this.estimateSize(data),
+        tags: options.tags || [],
+        version: options.version || '3.0.0'
+      }
+    }
+
+    isValidCacheEntry (entry) {
+      if (!entry || typeof entry !== 'object') {
+        return false
+      }
+
+      if (!entry.timestamp || !entry.data) {
+        return false
+      }
+
+      if (entry.expires && Date.now() > entry.expires) {
+        return false
+      }
+
+      return true
+    }
+
+    estimateSize (data) {
+      try {
+        return JSON.stringify(data).length
+      } catch (error) {
+        return 0
+      }
+    }
+
+    buildKey (key) {
+      return `vipros_sdk_${key}`
+    }
+
+    has (key) {
+      const fullKey = this.buildKey(key);
+
+      if (this.memoryCache.has(fullKey)) {
+        const entry = this.memoryCache.get(fullKey);
+        return this.isValidCacheEntry(entry)
+      }
+
+      return false
+    }
+
+    delete (key) {
+      const fullKey = this.buildKey(key);
+      const deleted = this.memoryCache.delete(fullKey);
+
+      if (deleted) {
+        this.emit('delete', { key });
+      }
+
+      return deleted
+    }
+
+    clear () {
+      const memorySize = this.memoryCache.size;
+      this.memoryCache.clear();
+
+      this.emit('clear', { memorySize });
+    }
+
+    size () {
+      return this.memoryCache.size
+    }
+
+    getStats () {
+      const memoryStats = {
+        entries: this.memoryCache.size,
+        totalSize: 0,
+        avgSize: 0
+      };
+
+      for (const [, entry] of this.memoryCache) {
+        memoryStats.totalSize += entry.size || 0;
+      }
+
+      if (memoryStats.entries > 0) {
+        memoryStats.avgSize = Math.round(memoryStats.totalSize / memoryStats.entries);
+      }
+
+      return { memory: memoryStats }
+    }
+
+    enforceCacheLimits () {
+      const maxMemoryEntries = 100;
+      const maxMemorySize = 10 * 1024 * 1024; // 10MB
+
+      if (this.memoryCache.size > maxMemoryEntries) {
+        this.evictLeastRecentlyUsed(this.memoryCache.size - maxMemoryEntries);
+      }
+
+      let totalSize = 0;
+      for (const [, entry] of this.memoryCache) {
+        totalSize += entry.size || 0;
+      }
+
+      if (totalSize > maxMemorySize) {
+        this.evictLargestEntries(totalSize - maxMemorySize);
+      }
+    }
+
+    evictLeastRecentlyUsed (count) {
+      const entries = Array.from(this.memoryCache.entries())
+        .map(([key, entry]) => ({ key, lastAccess: entry.lastAccessTime || 0 }))
+        .sort((a, b) => a.lastAccess - b.lastAccess)
+        .slice(0, count);
+
+      entries.forEach(({ key }) => {
+        this.memoryCache.delete(key);
+      });
+
+      this.emit('lru_eviction', { count });
+    }
+
+    evictLargestEntries (targetSize) {
+      const entries = Array.from(this.memoryCache.entries())
+        .map(([key, entry]) => ({ key, entry }))
+        .sort((a, b) => (b.entry.size || 0) - (a.entry.size || 0));
+
+      let freedSize = 0;
+      let evicted = 0;
+
+      for (const { key, entry } of entries) {
+        if (freedSize >= targetSize) {
+          break
+        }
+
+        this.memoryCache.delete(key);
+        freedSize += entry.size || 0;
+        evicted++;
+      }
+
+      this.emit('size_eviction', { evicted, freedSize });
+    }
+
+    setupCleanupInterval () {
+      if (typeof window !== 'undefined') {
+        setInterval(() => {
+          this.cleanupExpiredEntries();
+        }, 60000);
+      }
+    }
+
+    cleanupExpiredEntries () {
+      let cleaned = 0;
+      const now = Date.now();
+
+      for (const [key, entry] of this.memoryCache) {
+        if (entry.expires && now > entry.expires) {
+          this.memoryCache.delete(key);
+          cleaned++;
+        }
+      }
+
+      if (cleaned > 0) {
+        this.emit('cleanup', { cleaned });
+      }
+    }
+
+    destroy () {
+      this.clear();
+      this.removeAllListeners();
+    }
+  }
+
+  /**
+   * Service de synchronisation EAN avec l'API VIPros (version simplifiée)
+   *
+   * La logique de cooldown est maintenant gérée côté serveur Laravel.
+   * Ce service se contente d'appeler l'API et de gérer les réponses.
+   */
+  class EanSyncService extends EventEmitter {
+    constructor (apiClient, cacheService, config = {}) {
+      super();
+      this.apiClient = apiClient;
+      this.cacheService = cacheService;
+
+      // Configuration simplifiée
+      this.config = {
+        debug: config.debug || false,
+        retryDelayMs: 5000, // 5 secondes pour retry réseau
+        maxRetries: 2, // Retry limité aux erreurs réseau uniquement
+        ...config
+      };
+
+      // Statistiques simplifiées
+      this.stats = {
+        attempted: 0,
+        successful: 0,
+        failed: 0,
+        skipped: 0, // Skipped par le serveur (cooldown 202)
+        rateLimited: 0,
+        errors: []
+      };
+    }
+
+    /**
+     * Lance une synchronisation en arrière-plan (fire & forget)
+     * Version simplifiée - délègue la logique de cooldown au serveur
+     * @param {string} ean - Code EAN du produit
+     * @param {string} productUrl - URL de la page produit (généralement window.location.href)
+     * @returns {void} - Ne retourne rien (fire & forget)
+     */
+    syncProductInBackground (ean, productUrl) {
+      if (!ean || !productUrl) {
+        if (this.config.debug) {
+          console.debug('[ViprosSDK] Sync skipped: missing EAN or URL');
+        }
+        return
+      }
+
+      // Exécution simple - Fire & forget
+      this.performSync(ean, productUrl).catch(error => {
+        // Log silencieux en mode debug uniquement
+        if (this.config.debug) {
+          console.debug(`[ViprosSDK] Sync error for ${ean}:`, error.message);
+        }
+      });
+    }
+
+    /**
+     * Effectue la synchronisation réelle avec l'API (version simplifiée)
+     * @private
+     */
+    async performSync (ean, productUrl, retryCount = 0) {
+      // Démarrer la synchronisation
+      this.stats.attempted++;
+
+      try {
+        // Appel API de synchronisation - délègue toute la logique au serveur
+        const result = await this.apiClient.syncProduct(ean, productUrl);
+
+        // Traiter la réponse en fonction du code de statut
+        if (result.code === 200) {
+          // Succès - synchronisation effectuée
+          this.stats.successful++;
+          this.emit('syncSuccess', {
+            ean,
+            productUrl,
+            result,
+            timestamp: new Date()
+          });
+
+          if (this.config.debug) {
+            console.debug(`[ViprosSDK] Sync successful for ${ean}`);
+          }
+
+          return { status: 'success', result }
+
+        } else if (result.code === 202) {
+          // Cooldown actif côté serveur
+          this.stats.skipped++;
+          this.emit('syncSkipped', {
+            ean,
+            reason: 'server_cooldown',
+            remaining_hours: result.remaining_hours,
+            next_sync_at: result.next_sync_at
+          });
+
+          if (this.config.debug) {
+            console.debug(`[ViprosSDK] Sync skipped for ${ean}: server cooldown (${result.remaining_hours}h remaining)`);
+          }
+
+          return { status: 'skipped', reason: 'server_cooldown' }
+
+        } else {
+          // Autre code de statut - traiter comme erreur
+          throw new Error(`API returned status ${result.code}: ${result.message || 'Unknown error'}`)
+        }
+
+      } catch (error) {
+        return this.handleSyncError(ean, productUrl, error, retryCount)
+      } finally {
+        // Cleanup if needed
+      }
+    }
+
+
+    /**
+     * Gère les erreurs de synchronisation (version simplifiée)
+     * @private
+     */
+    handleSyncError (ean, productUrl, error, retryCount) {
+      this.stats.failed++;
+
+      // Analyser le type d'erreur
+      const errorType = this.categorizeError(error);
+
+      // Gestion spéciale du rate limiting
+      if (errorType === 'RATE_LIMIT') {
+        this.stats.rateLimited++;
+        this.emit('syncRateLimited', {
+          ean,
+          productUrl,
+          error,
+          retryAfter: error.retryAfter || 60
+        });
+
+        if (this.config.debug) {
+          console.debug(`[ViprosSDK] Sync rate limited for ${ean}`);
+        }
+
+        return { status: 'rate_limited', error: error.message }
+      }
+
+      // Pour les erreurs réseau, on peut retry une fois
+      if (errorType === 'NETWORK_ERROR' && retryCount < this.config.maxRetries) {
+        if (this.config.debug) {
+          console.debug(`[ViprosSDK] Retrying sync for ${ean} (attempt ${retryCount + 1})`);
+        }
+
+        // Retry après délai
+        setTimeout(() => {
+          this.performSync(ean, productUrl, retryCount + 1).catch(() => {
+            // Ignore retry errors - already handled
+          });
+        }, this.config.retryDelayMs);
+
+        return { status: 'retrying', attempt: retryCount + 1 }
+      }
+
+      // Enregistrer l'erreur
+      this.logError(ean, error, errorType);
+
+      // Émettre l'événement d'erreur
+      this.emit('syncError', {
+        ean,
+        productUrl,
+        error,
+        errorType,
+        retryCount
+      });
+
+      // Log pour debug
+      if (this.config.debug) {
+        console.error(`[ViprosSDK] Sync failed for ${ean}:`, error);
+      }
+
+      return { status: 'error', error: error.message, errorType }
+    }
+
+    /**
+     * Catégorise une erreur pour déterminer l'action appropriée
+     * @private
+     */
+    categorizeError (error) {
+      if (error.status === 429 || error.type === 'RATE_LIMIT_ERROR') {
+        return 'RATE_LIMIT'
+      }
+      if (error.status >= 500 || error.type === 'SERVER_ERROR') {
+        return 'SERVER_ERROR'
+      }
+      if (error.code === 'NETWORK_ERROR' || error.name === 'NetworkError') {
+        return 'NETWORK_ERROR'
+      }
+      if (error.status === 400 || error.type === 'VALIDATION_ERROR') {
+        return 'VALIDATION_ERROR'
+      }
+      return 'UNKNOWN'
+    }
+
+
+    /**
+     * Enregistre une erreur pour analyse
+     * @private
+     */
+    logError (ean, error, type) {
+      this.stats.errors.push({
+        ean,
+        error: error.message,
+        type,
+        timestamp: Date.now()
+      });
+      
+      // Limiter la taille du log d'erreurs
+      if (this.stats.errors.length > 100) {
+        this.stats.errors = this.stats.errors.slice(-50);
+      }
+    }
+
+    /**
+     * Retourne les statistiques de synchronisation (simplifiées)
+     */
+    getSyncStats () {
+      return {
+        ...this.stats,
+        successRate: this.stats.attempted > 0
+          ? (this.stats.successful / this.stats.attempted * 100).toFixed(2) + '%'
+          : '0%'
+      }
+    }
+
+    /**
+     * Réinitialise les statistiques de synchronisation
+     */
+    clearSyncStats () {
+      this.stats = {
+        attempted: 0,
+        successful: 0,
+        failed: 0,
+        skipped: 0,
+        rateLimited: 0,
+        errors: []
+      };
+    }
+
+    /**
+     * Force une synchronisation immédiate (version simplifiée)
+     * Utilise le paramètre force_sync côté serveur
+     */
+    async forceSyncNow (ean, productUrl) {
+      // Effectuer la sync avec force_sync = true
+      return this.performSyncWithForce(ean, productUrl)
+    }
+
+    /**
+     * Effectue une synchronisation forcée
+     * @private
+     */
+    async performSyncWithForce(ean, productUrl) {
+      this.stats.attempted++;
+
+      try {
+        // Appel API avec force_sync = true
+        const result = await this.apiClient.syncProduct(ean, productUrl, true);
+
+        if (result.code === 200) {
+          this.stats.successful++;
+          this.emit('syncSuccess', {
+            ean,
+            productUrl,
+            result,
+            forced: true,
+            timestamp: new Date()
+          });
+
+          return { status: 'success', result, forced: true }
+        } else {
+          throw new Error(`API returned status ${result.code}: ${result.message || 'Unknown error'}`)
+        }
+
+      } catch (error) {
+        this.stats.failed++;
+        this.logError(ean, error, 'forced_sync');
+
+        this.emit('syncError', {
+          ean,
+          productUrl,
+          error,
+          forced: true
+        });
+
+        return { status: 'error', error: error.message, forced: true }
+      } finally {
+        // Cleanup if needed
+      }
+    }
+
+    /**
+     * Nettoie et détruit le service (version simplifiée)
+     */
+    destroy () {
+      // Nettoyer les statistiques
+      this.clearSyncStats();
+
+      // Retirer tous les listeners
+      this.removeAllListeners();
+    }
+  }
+
+  /**
+   * VIPros SDK Unifié
+   * 
+   * SDK moderne basé sur les Web Components avec rétrocompatibilité pour l'ancien système.
+   * Combine les meilleures fonctionnalités des deux approches précédentes.
+   * 
+   * Utilisation moderne (recommandée):
+   * <vipros-offer-card ean="4007123684731"></vipros-offer-card>
+   * 
+   * Utilisation legacy (rétrocompatibilité):
+   * <div data-ean="4007123684731"></div> + ViprosSDK.init()
+   */
+  class ViprosSDK extends EventEmitter {
+    constructor() {
+      super();
+      this.version = '3.0.0-unified';
+      this.isInitialized = false;
+      
+      // Configuration par défaut non validée - sera validée au moment de init()
+      this.config = {
+        apiKey: null,
+        debug: false,
+        syncEnabled: true,
+        inlineSyncEnabled: true, // Phase 8: Active la sync inline par défaut (workflow à 1 seul appel)
+        disableBackgroundSync: true, // Phase 8: Désactive les appels POST /sync explicites par défaut
+        containerSelector: '[data-ean]',
+        autoScan: true
+      };
+      
+      // Services principaux - Lazy initialization for better performance
+      this._apiClient = null;
+      this._cacheService = null;
+      this._syncService = null; // Service de synchronisation
+      this._servicesInitialized = false;
+      
+      // Statistiques globales
+      this.stats = {
+        version: this.version,
+        componentsRegistered: 0,
+        componentsActive: 0,
+        offersLoaded: 0,
+        errors: 0,
+        cacheHits: 0,
+        apiCalls: 0,
+        syncAttempts: 0,
+        syncSuccess: 0
+      };
+
+      // Cache mémoire simple (rétrocompatibilité)
+      this.cache = new Map();
+
+      // Event listeners pour les événements DOM personnalisés
+      this.eventListeners = new Map();
+
+      // Singleton pattern
+      if (ViprosSDK.instance) {
+        return ViprosSDK.instance
+      }
+      ViprosSDK.instance = this;
+    }
+
+    /**
+     * Méthode statique pour obtenir l'instance singleton
+     */
+    static getInstance() {
+      if (!ViprosSDK.instance) {
+        ViprosSDK.instance = new ViprosSDK();
+      }
+      return ViprosSDK.instance
+    }
+
+
+    /**
+     * Initialise le SDK avec configuration optionnelle
+     */
+    init(userConfig = {}) {
+      if (this.isInitialized) {
+        this.debugLog('SDK déjà initialisé');
+        return this
+      }
+
+      // Fusionner avec la nouvelle configuration via ConfigManager
+      this.config = ConfigManager.create({
+        ...this.config,
+        ...userConfig
+      });
+      
+      this.debugLog(`🚀 Initialisation VIPros SDK v${this.version}`);
+      this.debugLog('Configuration:', this.config);
+
+      // Enregistrer le composant Web Components immédiatement
+      this.registerWebComponents();
+
+      // Auto-scan pour rétrocompatibilité si demandé
+      if (this.config.autoScan) {
+        this.scanAndConvert();
+      }
+
+      this.isInitialized = true;
+      this.emitEvent('sdk-ready', { version: this.version, config: this.config });
+
+      this.debugLog('🎯 SDK initialisé avec lazy loading - services créés à la demande');
+      
+      return this
+    }
+
+    /**
+     * Lazy getter for ApiClient - created on first access
+     */
+    get apiClient() {
+      if (!this._apiClient) {
+        this.debugLog('📡 Création lazy d\'ApiClient');
+        this._apiClient = new ApiClient(this.config);
+      }
+      return this._apiClient
+    }
+
+    /**
+     * Lazy getter for CacheService - created on first access
+     */
+    get cacheService() {
+      if (!this._cacheService) {
+        this.debugLog('💾 Création lazy de CacheService');
+        this._cacheService = new CacheService(this.config.cacheTimeout || 300000);
+      }
+      return this._cacheService
+    }
+
+    /**
+     * Lazy getter for SyncService - created on first access
+     */
+    get syncService() {
+      if (!this._syncService && this.config.syncEnabled) {
+        this.debugLog('🔄 Création lazy d\'EanSyncService');
+        this._syncService = new EanSyncService(this.apiClient, this.cacheService, this.config);
+
+        // Connecter les événements de synchronisation lors de la première création
+        this.setupSyncEvents();
+      }
+      return this._syncService
+    }
+
+    /**
+     * Initialize all services immediately (for cases requiring eager loading)
+     */
+    initializeServicesEager() {
+      this.debugLog('🚀 Initialisation eager de tous les services...');
+
+      // Access getters to trigger lazy initialization
+      const api = this.apiClient;
+      const cache = this.cacheService;
+      const sync = this.syncService;
+
+      this._servicesInitialized = true;
+      this.debugLog('✅ Tous les services initialisés (eager)');
+
+      return { api, cache, sync }
+    }
+
+    /**
+     * Configure les événements de synchronisation
+     */
+    setupSyncEvents() {
+      if (!this.syncService) return
+      
+      // Rediriger les événements du syncService vers le SDK principal
+      this.syncService.on('syncSuccess', (data) => {
+        this.stats.syncSuccess++;
+        this.emit('syncSuccess', data);
+      });
+      
+      this.syncService.on('syncSkipped', (data) => {
+        this.emit('syncSkipped', data);
+      });
+      
+      this.syncService.on('syncError', (data) => {
+        this.emit('syncError', data);
+      });
+      
+      this.syncService.on('syncRateLimited', (data) => {
+        this.emit('syncRateLimited', data);
+      });
+      
+      this.debugLog('Événements de synchronisation connectés');
+    }
+
+    /**
+     * Accès à CacheService pour les Web Components
+     */
+    getCacheService() {
+      return this.cacheService
+    }
+
+    /**
+     * Déclenche une synchronisation en arrière-plan
+     * Peut être désactivé via config.disableBackgroundSync (Phase 8)
+     */
+    syncProductInBackground(ean, productUrl) {
+      // Vérifier si la sync en arrière-plan est désactivée (Phase 8)
+      if (this.config.disableBackgroundSync) {
+        this.debugLog('Sync en arrière-plan désactivée (disableBackgroundSync=true)');
+        return
+      }
+
+      if (!this.syncService) {
+        this.debugLog('Sync demandée mais service non disponible');
+        return
+      }
+
+      this.stats.syncAttempts++;
+      this.debugLog(`Déclenchement sync pour EAN ${ean}`);
+      this.syncService.syncProductInBackground(ean, productUrl);
+    }
+
+    /**
+     * Enregistre les Web Components
+     */
+    registerWebComponents() {
+      if (!customElements.get('vipros-offer-card')) {
+        // Passer le SDK aux composants pour qu'ils puissent accéder à la config et au cache
+        ViprosOfferCard.setSDKInstance(this);
+        customElements.define('vipros-offer-card', ViprosOfferCard);
+        this.stats.componentsRegistered++;
+        this.debugLog('✅ vipros-offer-card registered');
+      }
+    }
+
+    /**
+     * Scanne et convertit les anciens containers data-ean (rétrocompatibilité)
+     */
+    scanAndConvert() {
+      const containers = document.querySelectorAll(this.config.containerSelector);
+      this.debugLog(`🔍 Scan: ${containers.length} containers data-ean trouvés`);
+      
+      containers.forEach(container => {
+        const ean = container.getAttribute('data-ean');
+        const price = container.getAttribute('data-price');
+        
+        if (ean) {
+          // Créer un Web Component à la place
+          const offerCard = document.createElement('vipros-offer-card');
+          offerCard.setAttribute('ean', ean);
+          if (price) offerCard.setAttribute('price', price);
+          
+          // Remplacer le container
+          container.parentNode.replaceChild(offerCard, container);
+          this.debugLog(`🔄 Converti data-ean="${ean}" vers Web Component`);
+        }
+      });
+    }
+
+    /**
+     * Obtenir l'ApiClient partagé (lazy initialization)
+     * Now uses lazy getter for better performance
+     */
+    getApiClient() {
+      return this.apiClient // Uses lazy getter
+    }
+
+    /**
+     * Check if services are initialized (performance monitoring)
+     */
+    getServicesStatus() {
+      return {
+        apiClientInitialized: !!this._apiClient,
+        cacheServiceInitialized: !!this._cacheService,
+        syncServiceInitialized: !!this._syncService,
+        allServicesEager: this._servicesInitialized
+      }
+    }
+
+    /**
+     * API publique pour récupérer des données produit
+     * Utilise la route optimisée /catalog/items/{ean} via ApiClient
+     */
+    async getProductData(ean) {
+      const cacheKey = `product_${ean}`;
+
+      // Vérifier le cache mémoire local
+      if (this.cache.has(cacheKey)) {
+        const cached = this.cache.get(cacheKey);
+        if (Date.now() - cached.timestamp < this.config.cacheTimeout) {
+          this.stats.cacheHits++;
+          this.debugLog(`💾 Cache hit for EAN ${ean}`);
+          return cached.data
+        }
+      }
+
+      try {
+        this.stats.apiCalls++;
+
+        // Utiliser ApiClient avec la route optimisée /sdk/catalog/items/{ean}
+        // Cela bénéficie du Bloom Filter, rate limiting, et route optimisée
+        const item = await this.apiClient.getCatalogItemByEan(ean);
+
+        // Construire la réponse
+        const data = item ? {
+          code: 200,
+          item: item
+        } : {
+          code: 404,
+          item: null
+        };
+
+        // Mise en cache (seulement si produit trouvé)
+        if (item) {
+          this.cache.set(cacheKey, {
+            data: data,
+            timestamp: Date.now()
+          });
+        }
+
+        this.debugLog(`📡 API data loaded for EAN ${ean} (optimized route)`);
+        return data
+
+      } catch (error) {
+        this.stats.errors++;
+        this.debugLog(`❌ Erreur API pour EAN ${ean}:`, error);
+        throw error
+      }
+    }
+
+    /**
+     * Émet un événement personnalisé
+     */
+    emitEvent(type, detail = {}) {
+      const eventName = `vipros-${type}`;
+      const event = new CustomEvent(eventName, { 
+        detail: detail,
+        bubbles: true,
+        cancelable: true 
+      });
+      document.dispatchEvent(event);
+      this.debugLog(`📤 Event: ${eventName}`, detail);
+    }
+
+    /**
+     * Écoute un événement SDK
+     */
+    on(eventType, callback) {
+      const eventName = `vipros-${eventType}`;
+      document.addEventListener(eventName, callback);
+      
+      if (!this.eventListeners.has(eventName)) {
+        this.eventListeners.set(eventName, []);
+      }
+      this.eventListeners.get(eventName).push(callback);
+    }
+
+    /**
+     * Supprime un listener d'événement
+     */
+    off(eventType, callback) {
+      const eventName = `vipros-${eventType}`;
+      document.removeEventListener(eventName, callback);
+      
+      if (this.eventListeners.has(eventName)) {
+        const listeners = this.eventListeners.get(eventName);
+        const index = listeners.indexOf(callback);
+        if (index > -1) {
+          listeners.splice(index, 1);
+        }
+      }
+    }
+
+    /**
+     * Vide le cache
+     */
+    clearCache() {
+      this.cache.clear();
+      this.debugLog('🗑️ Cache vidé');
+    }
+
+    /**
+     * Force le rechargement de tous les composants
+     */
+    refreshAll() {
+      const components = document.querySelectorAll('vipros-offer-card');
+      components.forEach(comp => {
+        if (comp.refresh && typeof comp.refresh === 'function') {
+          comp.refresh();
+        }
+      });
+      this.debugLog(`🔄 Refresh de ${components.length} composants`);
+    }
+
+    /**
+     * Récupère les statistiques
+     */
+    getStats() {
+      this.stats.componentsActive = document.querySelectorAll('vipros-offer-card').length;
+      return { ...this.stats }
+    }
+
+    /**
+     * Log de debug conditionnel
+     */
+    debugLog(message, data = null) {
+      if (this.config.debug) {
+        if (data) {
+          console.log(`[ViprosSDK] ${message}`, data);
+        } else {
+          console.log(`[ViprosSDK] ${message}`);
+        }
+      }
+    }
+
+    /**
+     * Détruit l'instance SDK (cleanup)
+     * Enhanced to handle lazy-loaded services
+     */
+    destroy() {
+      // Supprimer tous les event listeners
+      this.eventListeners.forEach((listeners, eventName) => {
+        listeners.forEach(callback => {
+          document.removeEventListener(eventName, callback);
+        });
+      });
+
+      this.eventListeners.clear();
+      this.cache.clear();
+
+      // Cleanup lazy-loaded services
+      if (this._apiClient) {
+        this.debugLog('🧹 Nettoyage ApiClient');
+        this._apiClient = null;
+      }
+
+      if (this._cacheService) {
+        this.debugLog('🧹 Nettoyage CacheService');
+        this._cacheService = null;
+      }
+
+      if (this._syncService) {
+        this.debugLog('🧹 Nettoyage SyncService');
+        this._syncService = null;
+      }
+
+      this._servicesInitialized = false;
+      this.isInitialized = false;
+
+      this.debugLog('🔥 SDK détruit avec nettoyage des services lazy');
+    }
+  }
+
+  /**
+   * VIPros SDK - Point d'entrée principal
+   *
+   * Version unifiée remplaçant ViprosSDK.js et ViprosWebComponents.js
+   * Compatible avec les deux modes d'utilisation
+   */
+
+
+  // Create and return an instance directly
+  const ViprosSDKInstance = new ViprosSDK();
+
+  // Pour les builds navigateur : exposer directement l'instance
+  if (typeof window !== 'undefined') {
+    // Assigner l'instance directement à window
+    // Note: Pour les builds minifiés, cette assignation est aussi gérée par le footer du rollup
+    window.ViprosSDK = ViprosSDKInstance;
+  }
+
+  return ViprosSDKInstance;
+
+})();