@el7ven/cookie-kit 0.3.1 → 0.3.2

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
+  }
+}

package/src/scripts/ScriptRegistry.js

@@ -0,0 +1,175 @@
+/**
+ * ScriptRegistry — stores and manages discovered scripts
+ * @module ScriptRegistry
+ */
+
+export class ScriptRegistry {
+  constructor() {
+    this.scripts = new Map() // id -> script descriptor
+    this.categorizedScripts = new Map() // category -> [scripts]
+  }
+
+  /**
+   * Add script to registry
+   * @param {Object} script - Script descriptor
+   */
+  add(script) {
+    if (!script.id) return
+
+    // Store by id
+    this.scripts.set(script.id, script)
+
+    // Store by category
+    if (script.category) {
+      if (!this.categorizedScripts.has(script.category)) {
+        this.categorizedScripts.set(script.category, [])
+      }
+      
+      const categoryScripts = this.categorizedScripts.get(script.category)
+      if (!categoryScripts.find(s => s.id === script.id)) {
+        categoryScripts.push(script)
+      }
+    }
+  }
+
+  /**
+   * Add multiple scripts
+   * @param {Array} scripts - Array of script descriptors
+   */
+  addMany(scripts) {
+    scripts.forEach(script => this.add(script))
+  }
+
+  /**
+   * Get script by id
+   * @param {string} id - Script id
+   * @returns {Object|null}
+   */
+  get(id) {
+    return this.scripts.get(id) || null
+  }
+
+  /**
+   * Get all scripts
+   * @returns {Array}
+   */
+  getAll() {
+    return Array.from(this.scripts.values())
+  }
+
+  /**
+   * Get scripts by category
+   * @param {string} category - Category name
+   * @returns {Array}
+   */
+  getByCategory(category) {
+    return this.categorizedScripts.get(category) || []
+  }
+
+  /**
+   * Get all categories
+   * @returns {Array}
+   */
+  getCategories() {
+    return Array.from(this.categorizedScripts.keys())
+  }
+
+  /**
+   * Get blocked scripts (not yet activated)
+   * @returns {Array}
+   */
+  getBlocked() {
+    return this.getAll().filter(script => script.isBlocked && !script.isActivated)
+  }
+
+  /**
+   * Get activated scripts
+   * @returns {Array}
+   */
+  getActivated() {
+    return this.getAll().filter(script => script.isActivated)
+  }
+
+  /**
+   * Mark script as activated
+   * @param {string} id - Script id
+   */
+  markActivated(id) {
+    const script = this.scripts.get(id)
+    if (script) {
+      script.isActivated = true
+      script.activatedAt = new Date().toISOString()
+    }
+  }
+
+  /**
+   * Remove script from registry
+   * @param {string} id - Script id
+   */
+  remove(id) {
+    const script = this.scripts.get(id)
+    if (!script) return
+
+    // Remove from main map
+    this.scripts.delete(id)
+
+    // Remove from category map
+    if (script.category) {
+      const categoryScripts = this.categorizedScripts.get(script.category)
+      if (categoryScripts) {
+        const index = categoryScripts.findIndex(s => s.id === id)
+        if (index !== -1) {
+          categoryScripts.splice(index, 1)
+        }
+      }
+    }
+  }
+
+  /**
+   * Clear all scripts
+   */
+  clear() {
+    this.scripts.clear()
+    this.categorizedScripts.clear()
+  }
+
+  /**
+   * Get registry stats
+   * @returns {Object}
+   */
+  getStats() {
+    const all = this.getAll()
+    return {
+      total: all.length,
+      blocked: all.filter(s => s.isBlocked && !s.isActivated).length,
+      activated: all.filter(s => s.isActivated).length,
+      byCategory: Object.fromEntries(
+        Array.from(this.categorizedScripts.entries()).map(([cat, scripts]) => [
+          cat,
+          {
+            total: scripts.length,
+            blocked: scripts.filter(s => s.isBlocked && !s.isActivated).length,
+            activated: scripts.filter(s => s.isActivated).length
+          }
+        ])
+      )
+    }
+  }
+
+  /**
+   * Check if script exists
+   * @param {string} id - Script id
+   * @returns {boolean}
+   */
+  has(id) {
+    return this.scripts.has(id)
+  }
+
+  /**
+   * Get count of scripts
+   * @returns {number}
+   */
+  count() {
+    return this.scripts.size
+  }
+}

package/src/scripts/ScriptScanner.js

@@ -0,0 +1,178 @@
+/**
+ * ScriptScanner — scans DOM for blocked scripts with data-cookie-category
+ * @module ScriptScanner
+ */
+
+export class ScriptScanner {
+  constructor(config = {}) {
+    this.config = {
+      attributeName: 'data-cookie-category',
+      srcAttributeName: 'data-cookie-src',
+      blockedTypes: ['text/plain', 'text/blocked'],
+      scanOnInit: true,
+      observeDOM: true,
+      scanIframes: true,
+      ...config
+    }
+    this.observer = null
+  }
+
+  /**
+   * Scan DOM for blocked scripts
+   * @returns {Array} Array of script descriptors
+   */
+  scan() {
+    const items = []
+    
+    // Find all script tags with data-cookie-category
+    const scriptElements = document.querySelectorAll(`script[${this.config.attributeName}]`)
+    
+    scriptElements.forEach((element, index) => {
+      const category = element.getAttribute(this.config.attributeName)
+      const type = element.getAttribute('type')
+      const isBlocked = this.config.blockedTypes.includes(type)
+      
+      // Pre-blocking: use data-cookie-src instead of src
+      const cookieSrc = element.getAttribute(this.config.srcAttributeName)
+      const regularSrc = element.getAttribute('src')
+      const actualSrc = cookieSrc || regularSrc
+      
+      const descriptor = {
+        id: `script-${index}-${Date.now()}`,
+        elementType: 'script',
+        element,
+        category,
+        type: type || 'text/javascript',
+        src: actualSrc || null,
+        cookieSrc: cookieSrc || null,
+        inline: !actualSrc,
+        content: !actualSrc ? element.textContent : null,
+        isBlocked,
+        isActivated: false,
+        attributes: this._getAttributes(element)
+      }
+      
+      items.push(descriptor)
+    })
+    
+    // Scan iframes if enabled
+    if (this.config.scanIframes) {
+      const iframeElements = document.querySelectorAll(`iframe[${this.config.attributeName}]`)
+      
+      iframeElements.forEach((element, index) => {
+        const category = element.getAttribute(this.config.attributeName)
+        const cookieSrc = element.getAttribute(this.config.srcAttributeName)
+        const regularSrc = element.getAttribute('src')
+        const actualSrc = cookieSrc || regularSrc
+        
+        const descriptor = {
+          id: `iframe-${index}-${Date.now()}`,
+          elementType: 'iframe',
+          element,
+          category,
+          src: actualSrc || null,
+          cookieSrc: cookieSrc || null,
+          isBlocked: true, // iframes always blocked until consent
+          isActivated: false,
+          attributes: this._getAttributes(element)
+        }
+        
+        items.push(descriptor)
+      })
+    }
+    
+    return items
+  }
+
+  /**
+   * Start observing DOM for new scripts
+   * @param {Function} callback - Called when new scripts detected
+   */
+  observe(callback) {
+    if (!this.config.observeDOM || typeof MutationObserver === 'undefined') {
+      return
+    }
+
+    this.observer = new MutationObserver((mutations) => {
+      let hasNewScripts = false
+      
+      mutations.forEach((mutation) => {
+        mutation.addedNodes.forEach((node) => {
+          if (node.nodeType === 1) { // Element node
+            // Check if added node is a script
+            if (node.tagName === 'SCRIPT' && node.hasAttribute(this.config.attributeName)) {
+              hasNewScripts = true
+            }
+            
+            // Check if added node contains scripts
+            const scripts = node.querySelectorAll?.(`script[${this.config.attributeName}]`)
+            if (scripts?.length > 0) {
+              hasNewScripts = true
+            }
+          }
+        })
+      })
+      
+      if (hasNewScripts) {
+        const newScripts = this.scan()
+        callback(newScripts)
+      }
+    })
+
+    this.observer.observe(document.documentElement, {
+      childList: true,
+      subtree: true
+    })
+  }
+
+  /**
+   * Stop observing DOM
+   */
+  disconnect() {
+    if (this.observer) {
+      this.observer.disconnect()
+      this.observer = null
+    }
+  }
+
+  /**
+   * Get all attributes from element (except data-cookie-category)
+   * @private
+   */
+  _getAttributes(element) {
+    const attributes = {}
+    const excludeAttrs = [
+      this.config.attributeName,
+      this.config.srcAttributeName,
+      'type',
+      'src' // Exclude src to prevent early execution
+    ]
+    
+    Array.from(element.attributes).forEach((attr) => {
+      if (!excludeAttrs.includes(attr.name)) {
+        attributes[attr.name] = attr.value
+      }
+    })
+    
+    return attributes
+  }
+
+  /**
+   * Find scripts by category
+   * @param {string} category - Category name
+   * @returns {Array} Filtered scripts
+   */
+  findByCategory(category) {
+    return this.scan().filter(script => script.category === category)
+  }
+
+  /**
+   * Check if script should be blocked
+   * @param {HTMLScriptElement} element - Script element
+   * @returns {boolean}
+   */
+  isBlocked(element) {
+    const type = element.getAttribute('type')
+    return this.config.blockedTypes.includes(type)
+  }
+}

package/src/scripts/index.js

@@ -0,0 +1,9 @@
+/**
+ * Script Management System — Auto-blocking scripts (Cookiebot-style)
+ * @module scripts
+ */
+
+export { ScriptScanner } from './ScriptScanner.js'
+export { ScriptRegistry } from './ScriptRegistry.js'
+export { ScriptLoader } from './ScriptLoader.js'
+export { ScriptManager } from './ScriptManager.js'