@el7ven/cookie-kit 0.2.21 → 0.3.2

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'