@el7ven/cookie-kit 0.3.1 → 0.3.3

package/src/scripts/ScriptLoader.js

@@ -0,0 +1,310 @@
+/**
+ * ScriptLoader — safely injects scripts into DOM
+ * @module ScriptLoader
+ */
+
+export class ScriptLoader {
+  constructor(config = {}) {
+    this.config = {
+      timeout: 10000, // 10 seconds
+      retryAttempts: 3,
+      retryDelay: 1000,
+      ...config
+    }
+    this.loadedScripts = new Set() // Track by src
+    this.loadedHashes = new Set()  // Track by content hash
+    this.loadedIds = new Set()     // Track by id
+  }
+
+  /**
+   * Load external script
+   * @param {Object} scriptDescriptor - Script descriptor from registry
+   * @returns {Promise<boolean>}
+   */
+  async loadExternal(scriptDescriptor) {
+    const { src, cookieSrc, attributes, id } = scriptDescriptor
+    const actualSrc = cookieSrc || src
+
+    if (!actualSrc) {
+      console.warn('[ScriptLoader] No src provided for external script')
+      return false
+    }
+
+    // Deduplication: check if already loaded
+    if (this.loadedScripts.has(actualSrc) || this.loadedIds.has(id)) {
+      console.log('[ScriptLoader] Script already loaded:', actualSrc)
+      return true
+    }
+
+    return new Promise((resolve) => {
+      const script = document.createElement('script')
+      
+      // Set src from data-cookie-src (pre-blocking)
+      script.src = actualSrc
+      
+      // Apply attributes
+      Object.entries(attributes || {}).forEach(([key, value]) => {
+        if (key !== 'src') {
+          script.setAttribute(key, value)
+        }
+      })
+
+      // Set proper type
+      script.type = 'text/javascript'
+      
+      // Add data attribute for tracking
+      script.setAttribute('data-cookie-loaded', 'true')
+      script.setAttribute('data-cookie-id', id)
+
+      let timeoutId = null
+
+      const cleanup = () => {
+        if (timeoutId) clearTimeout(timeoutId)
+        script.removeEventListener('load', onLoad)
+        script.removeEventListener('error', onError)
+      }
+
+      const onLoad = () => {
+        cleanup()
+        this.loadedScripts.add(actualSrc)
+        this.loadedIds.add(id)
+        resolve(true)
+      }
+
+      const onError = (error) => {
+        cleanup()
+        console.error('[ScriptLoader] Failed to load script:', actualSrc, error)
+        resolve(false)
+      }
+
+      // Timeout
+      timeoutId = setTimeout(() => {
+        cleanup()
+        console.warn('[ScriptLoader] Script load timeout:', actualSrc)
+        resolve(false)
+      }, this.config.timeout)
+
+      script.addEventListener('load', onLoad)
+      script.addEventListener('error', onError)
+
+      // Inject into DOM
+      const target = document.head || document.documentElement
+      target.appendChild(script)
+    })
+  }
+
+  /**
+   * Load inline script
+   * @param {Object} scriptDescriptor - Script descriptor from registry
+   * @returns {Promise<boolean>}
+   */
+  async loadInline(scriptDescriptor) {
+    const { content, attributes, id } = scriptDescriptor
+
+    if (!content) {
+      console.warn('[ScriptLoader] No content provided for inline script')
+      return false
+    }
+
+    // Deduplication: check by content hash
+    const contentHash = this._hashContent(content)
+    if (this.loadedHashes.has(contentHash) || this.loadedIds.has(id)) {
+      console.log('[ScriptLoader] Inline script already loaded')
+      return true
+    }
+
+    try {
+      const script = document.createElement('script')
+      
+      // Set content
+      script.textContent = content
+      
+      // Apply attributes
+      Object.entries(attributes || {}).forEach(([key, value]) => {
+        script.setAttribute(key, value)
+      })
+
+      // Set proper type
+      script.type = 'text/javascript'
+      
+      // Add data attribute for tracking
+      script.setAttribute('data-cookie-loaded', 'true')
+      script.setAttribute('data-cookie-id', id)
+
+      // Inject into DOM
+      const target = document.head || document.documentElement
+      target.appendChild(script)
+
+      // Mark as loaded
+      this.loadedHashes.add(contentHash)
+      this.loadedIds.add(id)
+
+      return true
+    } catch (error) {
+      console.error('[ScriptLoader] Failed to load inline script:', error)
+      return false
+    }
+  }
+
+  /**
+   * Load script (auto-detect inline vs external)
+   * @param {Object} scriptDescriptor - Script descriptor
+   * @returns {Promise<boolean>}
+   */
+  async load(scriptDescriptor) {
+    const { elementType } = scriptDescriptor
+
+    // Handle iframes
+    if (elementType === 'iframe') {
+      return this.loadIframe(scriptDescriptor)
+    }
+
+    // Handle scripts
+    if (scriptDescriptor.inline) {
+      return this.loadInline(scriptDescriptor)
+    } else {
+      return this.loadExternal(scriptDescriptor)
+    }
+  }
+
+  /**
+   * Load iframe (YouTube, Maps, etc)
+   * @param {Object} iframeDescriptor - Iframe descriptor
+   * @returns {Promise<boolean>}
+   */
+  async loadIframe(iframeDescriptor) {
+    const { src, cookieSrc, attributes, id, element } = iframeDescriptor
+    const actualSrc = cookieSrc || src
+
+    if (!actualSrc) {
+      console.warn('[ScriptLoader] No src provided for iframe')
+      return false
+    }
+
+    // Deduplication
+    if (this.loadedScripts.has(actualSrc) || this.loadedIds.has(id)) {
+      console.log('[ScriptLoader] Iframe already loaded:', actualSrc)
+      return true
+    }
+
+    try {
+      // Update existing iframe or create new one
+      if (element && element.parentNode) {
+        // Update src on existing element
+        element.src = actualSrc
+        
+        // Remove data-cookie-src attribute
+        element.removeAttribute('data-cookie-src')
+        
+        this.loadedScripts.add(actualSrc)
+        this.loadedIds.add(id)
+        return true
+      } else {
+        // Create new iframe
+        const iframe = document.createElement('iframe')
+        iframe.src = actualSrc
+        
+        // Apply attributes
+        Object.entries(attributes || {}).forEach(([key, value]) => {
+          iframe.setAttribute(key, value)
+        })
+        
+        iframe.setAttribute('data-cookie-loaded', 'true')
+        iframe.setAttribute('data-cookie-id', id)
+        
+        // Find parent or append to body
+        const target = element?.parentNode || document.body
+        target.appendChild(iframe)
+        
+        this.loadedScripts.add(actualSrc)
+        this.loadedIds.add(id)
+        return true
+      }
+    } catch (error) {
+      console.error('[ScriptLoader] Failed to load iframe:', error)
+      return false
+    }
+  }
+
+  /**
+   * Load multiple scripts sequentially
+   * @param {Array} scriptDescriptors - Array of script descriptors
+   * @returns {Promise<Object>} Results object
+   */
+  async loadMany(scriptDescriptors) {
+    const results = {
+      total: scriptDescriptors.length,
+      loaded: 0,
+      failed: 0,
+      scripts: []
+    }
+
+    for (const script of scriptDescriptors) {
+      const success = await this.load(script)
+      
+      results.scripts.push({
+        id: script.id,
+        category: script.category,
+        success
+      })
+
+      if (success) {
+        results.loaded++
+      } else {
+        results.failed++
+      }
+    }
+
+    return results
+  }
+
+  /**
+   * Remove original blocked script element
+   * @param {HTMLScriptElement} element - Original script element
+   */
+  removeBlockedScript(element) {
+    if (element && element.parentNode) {
+      element.parentNode.removeChild(element)
+    }
+  }
+
+  /**
+   * Check if script is already loaded
+   * @param {string} src - Script src
+   * @returns {boolean}
+   */
+  isLoaded(src) {
+    return this.loadedScripts.has(src)
+  }
+
+  /**
+   * Clear loaded scripts cache
+   */
+  clear() {
+    this.loadedScripts.clear()
+    this.loadedHashes.clear()
+    this.loadedIds.clear()
+  }
+
+  /**
+   * Get loaded scripts count
+   * @returns {number}
+   */
+  getLoadedCount() {
+    return this.loadedScripts.size
+  }
+
+  /**
+   * Simple hash function for content deduplication
+   * @private
+   */
+  _hashContent(content) {
+    let hash = 0
+    for (let i = 0; i < content.length; i++) {
+      const char = content.charCodeAt(i)
+      hash = ((hash << 5) - hash) + char
+      hash = hash & hash
+    }
+    return hash.toString(36)
+  }
+}

package/src/scripts/ScriptManager.js

@@ -0,0 +1,278 @@
+/**
+ * ScriptManager — main controller for consent-based script activation
+ * @module ScriptManager
+ */
+
+import { ScriptScanner } from './ScriptScanner.js'
+import { ScriptRegistry } from './ScriptRegistry.js'
+import { ScriptLoader } from './ScriptLoader.js'
+
+export class ScriptManager {
+  constructor(consentManager, config = {}) {
+    this.consentManager = consentManager
+    this.config = {
+      autoScan: true,
+      observeDOM: true,
+      removeBlockedScripts: true,
+      debug: false,
+      ...config
+    }
+
+    this.scanner = new ScriptScanner({
+      observeDOM: this.config.observeDOM
+    })
+    
+    this.registry = new ScriptRegistry()
+    this.loader = new ScriptLoader()
+    
+    this.isInitialized = false
+    this._debug('ScriptManager initialized')
+  }
+
+  /**
+   * Initialize script management system
+   */
+  async initialize() {
+    if (this.isInitialized) {
+      this._debug('Already initialized')
+      return
+    }
+
+    // Wait for DOM ready
+    if (document.readyState === 'loading') {
+      await new Promise(resolve => {
+        document.addEventListener('DOMContentLoaded', resolve, { once: true })
+      })
+    }
+
+    // Initial scan
+    if (this.config.autoScan) {
+      await this.scanAndRegister()
+    }
+
+    // Apply current consent
+    const consent = this.consentManager.getConsent()
+    if (consent) {
+      await this.applyConsent(consent.categories)
+    }
+
+    // Listen for consent changes
+    this.consentManager.on('consentChanged', async ({ categories }) => {
+      await this.applyConsent(categories)
+    })
+
+    // Observe DOM for new scripts
+    if (this.config.observeDOM) {
+      this.scanner.observe((newScripts) => {
+        this._debug('New scripts detected:', newScripts.length)
+        this.registry.addMany(newScripts)
+        
+        // Auto-activate if consent already given
+        const consent = this.consentManager.getConsent()
+        if (consent) {
+          this.activateScriptsByConsent(newScripts, consent.categories)
+        }
+      })
+    }
+
+    this.isInitialized = true
+    this._debug('ScriptManager ready')
+    this._emitEvent('scripts:ready', { stats: this.registry.getStats() })
+  }
+
+  /**
+   * Scan DOM and register all scripts
+   */
+  async scanAndRegister() {
+    this._debug('Scanning DOM for scripts...')
+    const scripts = this.scanner.scan()
+    this._debug(`Found ${scripts.length} scripts`)
+    
+    this.registry.addMany(scripts)
+    
+    this._emitEvent('scripts:scanned', {
+      total: scripts.length,
+      stats: this.registry.getStats()
+    })
+
+    return scripts
+  }
+
+  /**
+   * Apply consent to scripts
+   * @param {Object} categories - Consent categories
+   */
+  async applyConsent(categories) {
+    this._debug('Applying consent:', categories)
+
+    const results = {
+      activated: [],
+      blocked: [],
+      failed: []
+    }
+
+    // Get all blocked scripts
+    const blockedScripts = this.registry.getBlocked()
+    
+    for (const script of blockedScripts) {
+      const hasConsent = categories[script.category] === true
+      
+      if (hasConsent) {
+        // Activate script
+        const success = await this.activateScript(script)
+        
+        if (success) {
+          results.activated.push(script)
+        } else {
+          results.failed.push(script)
+        }
+      } else {
+        results.blocked.push(script)
+      }
+    }
+
+    this._debug('Consent applied:', {
+      activated: results.activated.length,
+      blocked: results.blocked.length,
+      failed: results.failed.length
+    })
+
+    this._emitEvent('scripts:consent-applied', results)
+
+    return results
+  }
+
+  /**
+   * Activate single script
+   * @param {Object} script - Script descriptor
+   * @returns {Promise<boolean>}
+   */
+  async activateScript(script) {
+    if (script.isActivated) {
+      this._debug('Script already activated:', script.id)
+      return true
+    }
+
+    this._debug('Activating script:', script.id, script.category)
+
+    try {
+      // Load script
+      const success = await this.loader.load(script)
+      
+      if (success) {
+        // Mark as activated
+        this.registry.markActivated(script.id)
+        
+        // Remove original blocked element
+        if (this.config.removeBlockedScripts && script.element) {
+          this.loader.removeBlockedScript(script.element)
+        }
+
+        this._emitEvent('script:activated', {
+          id: script.id,
+          category: script.category,
+          src: script.src || 'inline'
+        })
+
+        return true
+      }
+
+      return false
+    } catch (error) {
+      return false
+    }
+  }
+
+  /**
+   * Activate scripts by consent (helper for new scripts)
+   * @param {Array} scripts - Scripts to check
+   * @param {Object} categories - Consent categories
+   */
+  async activateScriptsByConsent(scripts, categories) {
+    const results = []
+
+    for (const script of scripts) {
+      if (script.isBlocked && !script.isActivated) {
+        const hasConsent = categories[script.category] === true
+        
+        if (hasConsent) {
+          const success = await this.activateScript(script)
+          results.push({ script, success })
+        }
+      }
+    }
+
+    return results
+  }
+
+  /**
+   * Get scripts by category
+   * @param {string} category - Category name
+   * @returns {Array}
+   */
+  getScriptsByCategory(category) {
+    return this.registry.getByCategory(category)
+  }
+
+  /**
+   * Get all registered scripts
+   * @returns {Array}
+   */
+  getAllScripts() {
+    return this.registry.getAll()
+  }
+
+  /**
+   * Get registry stats
+   * @returns {Object}
+   */
+  getStats() {
+    return this.registry.getStats()
+  }
+
+  /**
+   * Get blocked scripts count
+   * @returns {number}
+   */
+  getBlockedCount() {
+    return this.registry.getBlocked().length
+  }
+
+  /**
+   * Get activated scripts count
+   * @returns {number}
+   */
+  getActivatedCount() {
+    return this.registry.getActivated().length
+  }
+
+  /**
+   * Manually trigger rescan
+   */
+  async rescan() {
+    return this.scanAndRegister()
+  }
+
+  /**
+   * Destroy script manager
+   */
+  destroy() {
+    this.scanner.disconnect()
+    this.registry.clear()
+    this.loader.clear()
+    this.isInitialized = false
+    this._debug('ScriptManager destroyed')
+  }
+
+  // --- Internal helpers ---
+
+  _emitEvent(eventName, detail) {
+    if (typeof window !== 'undefined') {
+      window.dispatchEvent(new CustomEvent(`cookie-consent:${eventName}`, { detail }))
+    }
+  }
+
+  _debug(...args) {
+    // Debug disabled
+  }
+}