@el7ven/cookie-kit 0.3.1 → 0.3.3

package/src/trackers/TrackerPatterns.js

@@ -0,0 +1,307 @@
+/**
+ * Tracker Patterns — extensible detection patterns for popular trackers
+ * @module TrackerPatterns
+ */
+
+class TrackerPatternRegistry {
+  constructor() {
+    this.patterns = new Map()
+    this._registerDefaultPatterns()
+  }
+
+  /**
+   * Register default tracker patterns
+   * @private
+   */
+  _registerDefaultPatterns() {
+    const defaultPatterns = [
+      // Google Analytics
+      {
+        id: 'google-analytics',
+        name: 'Google Analytics',
+        category: 'analytics',
+        scripts: [
+          'google-analytics.com/analytics.js',
+          'google-analytics.com/ga.js',
+          'googletagmanager.com/gtag/js'
+        ],
+        globals: ['ga', 'gtag', '_gaq'],
+        cookies: ['_ga', '_gid', '_gat'],
+        dataLayer: ['gtag'],
+        network: ['google-analytics.com', 'analytics.google.com']
+      },
+
+      // Google Tag Manager
+      {
+        id: 'google-tag-manager',
+        name: 'Google Tag Manager',
+        category: 'analytics',
+        scripts: ['googletagmanager.com/gtm.js'],
+        globals: ['google_tag_manager', 'dataLayer'],
+        cookies: ['_ga', '_gid'],
+        dataLayer: ['gtm.start', 'gtm.js'],
+        network: ['googletagmanager.com']
+      },
+
+      // Facebook Pixel
+      {
+        id: 'facebook-pixel',
+        name: 'Facebook Pixel',
+        category: 'marketing',
+        scripts: ['connect.facebook.net/en_US/fbevents.js', 'connect.facebook.net'],
+        globals: ['fbq', '_fbq'],
+        cookies: ['_fbp', 'fr'],
+        dataLayer: [],
+        network: ['connect.facebook.net', 'facebook.com/tr']
+      },
+
+      // Hotjar
+      {
+        id: 'hotjar',
+        name: 'Hotjar',
+        category: 'analytics',
+        scripts: ['static.hotjar.com/c/hotjar-', 'script.hotjar.com'],
+        globals: ['hj', '_hjSettings'],
+        cookies: ['_hjid', '_hjIncludedInSample'],
+        dataLayer: [],
+        network: ['static.hotjar.com', 'script.hotjar.com']
+      },
+
+      // Microsoft Clarity
+      {
+        id: 'microsoft-clarity',
+        name: 'Microsoft Clarity',
+        category: 'analytics',
+        scripts: ['clarity.ms/tag/', 'www.clarity.ms'],
+        globals: ['clarity'],
+        cookies: ['_clck', '_clsk'],
+        dataLayer: [],
+        network: ['clarity.ms']
+      },
+
+      // TikTok Pixel
+      {
+        id: 'tiktok-pixel',
+        name: 'TikTok Pixel',
+        category: 'marketing',
+        scripts: ['analytics.tiktok.com/i18n/pixel/events.js'],
+        globals: ['ttq'],
+        cookies: ['_ttp'],
+        dataLayer: [],
+        network: ['analytics.tiktok.com']
+      },
+
+      // LinkedIn Insight
+      {
+        id: 'linkedin-insight',
+        name: 'LinkedIn Insight Tag',
+        category: 'marketing',
+        scripts: ['snap.licdn.com/li.lms-analytics/insight.min.js'],
+        globals: ['_linkedin_data_partner_ids'],
+        cookies: ['li_sugr', 'lidc'],
+        dataLayer: [],
+        network: ['snap.licdn.com']
+      },
+
+      // Google Ads
+      {
+        id: 'google-ads',
+        name: 'Google Ads',
+        category: 'marketing',
+        scripts: ['googleadservices.com/pagead/conversion', 'www.googleadservices.com'],
+        globals: ['google_trackConversion'],
+        cookies: ['_gcl_au', '_gcl_aw'],
+        dataLayer: [],
+        network: ['googleadservices.com']
+      },
+
+      // Yandex Metrica
+      {
+        id: 'yandex-metrica',
+        name: 'Yandex Metrica',
+        category: 'analytics',
+        scripts: ['mc.yandex.ru/metrika/watch.js', 'mc.yandex.ru/metrika/tag.js'],
+        globals: ['ym', 'Ya'],
+        cookies: ['_ym_uid', '_ym_d'],
+        dataLayer: [],
+        network: ['mc.yandex.ru']
+      },
+
+      // Mixpanel
+      {
+        id: 'mixpanel',
+        name: 'Mixpanel',
+        category: 'analytics',
+        scripts: ['cdn.mxpnl.com/libs/mixpanel'],
+        globals: ['mixpanel'],
+        cookies: ['mp_'],
+        dataLayer: [],
+        network: ['cdn.mxpnl.com', 'api.mixpanel.com']
+      },
+
+      // Segment
+      {
+        id: 'segment',
+        name: 'Segment',
+        category: 'analytics',
+        scripts: ['cdn.segment.com/analytics.js'],
+        globals: ['analytics'],
+        cookies: ['ajs_'],
+        dataLayer: [],
+        network: ['cdn.segment.com', 'api.segment.io']
+      },
+
+      // Intercom
+      {
+        id: 'intercom',
+        name: 'Intercom',
+        category: 'preferences',
+        scripts: ['widget.intercom.io'],
+        globals: ['Intercom'],
+        cookies: ['intercom-'],
+        dataLayer: [],
+        network: ['widget.intercom.io', 'api.intercom.io']
+      },
+
+      // Drift
+      {
+        id: 'drift',
+        name: 'Drift',
+        category: 'preferences',
+        scripts: ['js.driftt.com/include/'],
+        globals: ['drift'],
+        cookies: ['driftt_aid'],
+        dataLayer: [],
+        network: ['js.driftt.com']
+      },
+
+      // Amplitude
+      {
+        id: 'amplitude',
+        name: 'Amplitude',
+        category: 'analytics',
+        scripts: ['cdn.amplitude.com'],
+        globals: ['amplitude'],
+        cookies: ['amplitude_'],
+        dataLayer: [],
+        network: ['cdn.amplitude.com', 'api.amplitude.com']
+      },
+
+      // Heap Analytics
+      {
+        id: 'heap',
+        name: 'Heap Analytics',
+        category: 'analytics',
+        scripts: ['cdn.heapanalytics.com'],
+        globals: ['heap'],
+        cookies: ['_hp2_'],
+        dataLayer: [],
+        network: ['cdn.heapanalytics.com', 'heapanalytics.com']
+      }
+    ]
+
+    defaultPatterns.forEach(pattern => this.register(pattern))
+  }
+
+  /**
+   * Register new tracker pattern (extensible!)
+   * @param {Object} pattern - Tracker pattern
+   */
+  register(pattern) {
+    if (!pattern.id || !pattern.name) return
+
+    // Set defaults
+    const fullPattern = {
+      scripts: [],
+      globals: [],
+      cookies: [],
+      dataLayer: [],
+      network: [],
+      ...pattern
+    }
+
+    this.patterns.set(pattern.id, fullPattern)
+  }
+
+  /**
+   * Get pattern by ID
+   * @param {string} id - Pattern ID
+   * @returns {Object|null}
+   */
+  get(id) {
+    return this.patterns.get(id) || null
+  }
+
+  /**
+   * Get all patterns
+   * @returns {Array}
+   */
+  getAll() {
+    return Array.from(this.patterns.values())
+  }
+
+  /**
+   * Get patterns by category
+   * @param {string} category - Category name
+   * @returns {Array}
+   */
+  getByCategory(category) {
+    return this.getAll().filter(p => p.category === category)
+  }
+
+  /**
+   * Check if pattern exists
+   * @param {string} id - Pattern ID
+   * @returns {boolean}
+   */
+  has(id) {
+    return this.patterns.has(id)
+  }
+
+  /**
+   * Remove pattern
+   * @param {string} id - Pattern ID
+   */
+  remove(id) {
+    this.patterns.delete(id)
+  }
+
+  /**
+   * Clear all patterns
+   */
+  clear() {
+    this.patterns.clear()
+  }
+
+  /**
+   * Get count
+   * @returns {number}
+   */
+  count() {
+    return this.patterns.size
+  }
+}
+
+// Singleton instance
+const patternRegistry = new TrackerPatternRegistry()
+
+// Export registry and patterns
+export const TRACKER_PATTERNS = patternRegistry.getAll()
+
+export function getTrackerPattern(id) {
+  return patternRegistry.get(id)
+}
+
+export function getTrackerPatternsByCategory(category) {
+  return patternRegistry.getByCategory(category)
+}
+
+export function registerTrackerPattern(pattern) {
+  return patternRegistry.register(pattern)
+}
+
+export function getAllTrackerPatterns() {
+  return patternRegistry.getAll()
+}
+
+export { patternRegistry as TrackerPatternRegistry }

package/src/trackers/TrackerRegistry.js

@@ -0,0 +1,172 @@
+/**
+ * TrackerRegistry — stores and manages detected trackers
+ * @module TrackerRegistry
+ */
+
+export class TrackerRegistry {
+  constructor() {
+    this.trackers = new Map() // id -> tracker
+    this.categories = new Map() // category -> [trackers]
+  }
+
+  /**
+   * Add tracker to registry
+   * @param {Object} tracker - Tracker info
+   */
+  add(tracker) {
+    if (!tracker.id) return
+
+    // Store by id
+    this.trackers.set(tracker.id, tracker)
+
+    // Store by category
+    if (tracker.category) {
+      if (!this.categories.has(tracker.category)) {
+        this.categories.set(tracker.category, [])
+      }
+      
+      const categoryTrackers = this.categories.get(tracker.category)
+      if (!categoryTrackers.find(t => t.id === tracker.id)) {
+        categoryTrackers.push(tracker)
+      }
+    }
+  }
+
+  /**
+   * Add multiple trackers
+   * @param {Array} trackers - Array of trackers
+   */
+  addMany(trackers) {
+    trackers.forEach(tracker => this.add(tracker))
+  }
+
+  /**
+   * Get tracker by id
+   * @param {string} id - Tracker id
+   * @returns {Object|null}
+   */
+  get(id) {
+    return this.trackers.get(id) || null
+  }
+
+  /**
+   * Get all trackers
+   * @returns {Array}
+   */
+  getAll() {
+    return Array.from(this.trackers.values())
+  }
+
+  /**
+   * Get trackers by category
+   * @param {string} category - Category name
+   * @returns {Array}
+   */
+  getByCategory(category) {
+    return this.categories.get(category) || []
+  }
+
+  /**
+   * Get all categories
+   * @returns {Array}
+   */
+  getCategories() {
+    return Array.from(this.categories.keys())
+  }
+
+  /**
+   * Check if tracker exists
+   * @param {string} id - Tracker id
+   * @returns {boolean}
+   */
+  has(id) {
+    return this.trackers.has(id)
+  }
+
+  /**
+   * Remove tracker
+   * @param {string} id - Tracker id
+   */
+  remove(id) {
+    const tracker = this.trackers.get(id)
+    if (!tracker) return
+
+    // Remove from main map
+    this.trackers.delete(id)
+
+    // Remove from category map
+    if (tracker.category) {
+      const categoryTrackers = this.categories.get(tracker.category)
+      if (categoryTrackers) {
+        const index = categoryTrackers.findIndex(t => t.id === id)
+        if (index !== -1) {
+          categoryTrackers.splice(index, 1)
+        }
+      }
+    }
+  }
+
+  /**
+   * Clear all trackers
+   */
+  clear() {
+    this.trackers.clear()
+    this.categories.clear()
+  }
+
+  /**
+   * Get registry stats
+   * @returns {Object}
+   */
+  getStats() {
+    const all = this.getAll()
+    return {
+      total: all.length,
+      byCategory: Object.fromEntries(
+        Array.from(this.categories.entries()).map(([cat, trackers]) => [
+          cat,
+          {
+            count: trackers.length,
+            trackers: trackers.map(t => t.name)
+          }
+        ])
+      )
+    }
+  }
+
+  /**
+   * Get count of trackers
+   * @returns {number}
+   */
+  count() {
+    return this.trackers.size
+  }
+
+  /**
+   * Export trackers as array
+   * @returns {Array}
+   */
+  toArray() {
+    return this.getAll()
+  }
+
+  /**
+   * Get suggested consent categories based on detected trackers
+   * @returns {Object}
+   */
+  getSuggestedCategories() {
+    const suggestions = {}
+    
+    this.getAll().forEach(tracker => {
+      if (!suggestions[tracker.category]) {
+        suggestions[tracker.category] = {
+          required: tracker.category === 'necessary',
+          trackers: []
+        }
+      }
+      suggestions[tracker.category].trackers.push(tracker.name)
+    })
+
+    return suggestions
+  }
+}

package/src/trackers/index.js

@@ -0,0 +1,15 @@
+/**
+ * Tracker Detection System — Auto-detect trackers on the page
+ * @module trackers
+ */
+
+export { TrackerDetector } from './TrackerDetector.js'
+export { TrackerRegistry } from './TrackerRegistry.js'
+export { 
+  TRACKER_PATTERNS, 
+  getTrackerPattern, 
+  getTrackerPatternsByCategory,
+  registerTrackerPattern,
+  getAllTrackerPatterns,
+  TrackerPatternRegistry
+} from './TrackerPatterns.js'

package/src/utils/cookies.js

@@ -0,0 +1,37 @@
+/**
+ * Cookie utilities
+ */
+
+export function getCookie(name) {
+  if (typeof document === 'undefined') return null
+  const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'))
+  return match ? decodeURIComponent(match[2]) : null
+}
+
+export function setCookie(name, value, days, options = {}) {
+  if (typeof document === 'undefined') return
+  
+  const expires = new Date(Date.now() + days * 864e5).toUTCString()
+  const path = options.path || '/'
+  const sameSite = options.sameSite || 'Lax'
+  const secure = options.secure ? '; Secure' : ''
+  const domain = options.domain ? `; Domain=${options.domain}` : ''
+  
+  document.cookie = `${name}=${encodeURIComponent(value)}; expires=${expires}; path=${path}; SameSite=${sameSite}${secure}${domain}`
+}
+
+export function deleteCookie(name, options = {}) {
+  setCookie(name, '', -1, options)
+}
+
+export function getAllCookies() {
+  if (typeof document === 'undefined') return {}
+  
+  return document.cookie.split(';').reduce((acc, cookie) => {
+    const [name, value] = cookie.trim().split('=')
+    if (name) {
+      acc[name] = decodeURIComponent(value || '')
+    }
+    return acc
+  }, {})
+}

package/src/utils/dom.js

@@ -0,0 +1,58 @@
+/**
+ * DOM utilities
+ */
+
+export function getFocusableElements(container) {
+  if (!container) return []
+  
+  const selector = [
+    'a[href]',
+    'button:not([disabled])',
+    'textarea:not([disabled])',
+    'input:not([disabled])',
+    'select:not([disabled])',
+    '[tabindex]:not([tabindex="-1"])'
+  ].join(',')
+  
+  return Array.from(container.querySelectorAll(selector))
+}
+
+export function trapFocus(container, event) {
+  const focusableElements = getFocusableElements(container)
+  if (focusableElements.length === 0) return
+  
+  const firstElement = focusableElements[0]
+  const lastElement = focusableElements[focusableElements.length - 1]
+  
+  if (event.key === 'Tab') {
+    if (event.shiftKey && document.activeElement === firstElement) {
+      event.preventDefault()
+      lastElement.focus()
+    } else if (!event.shiftKey && document.activeElement === lastElement) {
+      event.preventDefault()
+      firstElement.focus()
+    }
+  }
+}
+
+export function lockBodyScroll() {
+  if (typeof document === 'undefined') return
+  document.body.style.overflow = 'hidden'
+}
+
+export function unlockBodyScroll() {
+  if (typeof document === 'undefined') return
+  document.body.style.overflow = ''
+}
+
+export function onEscape(callback) {
+  const handler = (event) => {
+    if (event.key === 'Escape' || event.keyCode === 27) {
+      callback(event)
+    }
+  }
+  
+  document.addEventListener('keydown', handler)
+  
+  return () => document.removeEventListener('keydown', handler)
+}

package/src/utils/helpers.js

@@ -0,0 +1,89 @@
+/**
+ * General helper utilities
+ */
+
+export function generateUUID() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0
+    const v = c === 'x' ? r : (r & 0x3 | 0x8)
+    return v.toString(16)
+  })
+}
+
+export function debounce(fn, delay) {
+  let timeoutId
+  return function (...args) {
+    clearTimeout(timeoutId)
+    timeoutId = setTimeout(() => fn.apply(this, args), delay)
+  }
+}
+
+export function throttle(fn, limit) {
+  let inThrottle
+  return function (...args) {
+    if (!inThrottle) {
+      fn.apply(this, args)
+      inThrottle = true
+      setTimeout(() => inThrottle = false, limit)
+    }
+  }
+}
+
+export function deepMerge(target, source) {
+  const output = { ...target }
+  
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach(key => {
+      if (isObject(source[key])) {
+        if (!(key in target)) {
+          output[key] = source[key]
+        } else {
+          output[key] = deepMerge(target[key], source[key])
+        }
+      } else {
+        output[key] = source[key]
+      }
+    })
+  }
+  
+  return output
+}
+
+function isObject(item) {
+  return item && typeof item === 'object' && !Array.isArray(item)
+}
+
+export function isSSR() {
+  return typeof window === 'undefined'
+}
+
+export function isMobile() {
+  if (isSSR()) return false
+  return window.innerWidth <= 768
+}
+
+export function getRegionFromTimezone() {
+  if (isSSR()) return null
+  
+  try {
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone
+    
+    // EU timezones
+    const euTimezones = [
+      'Europe/London', 'Europe/Paris', 'Europe/Berlin', 'Europe/Madrid',
+      'Europe/Rome', 'Europe/Amsterdam', 'Europe/Brussels', 'Europe/Vienna',
+      'Europe/Stockholm', 'Europe/Copenhagen', 'Europe/Helsinki', 'Europe/Athens',
+      'Europe/Prague', 'Europe/Warsaw', 'Europe/Budapest', 'Europe/Bucharest'
+    ]
+    
+    if (euTimezones.some(tz => timezone.startsWith(tz.split('/')[0]))) {
+      return 'EU'
+    }
+    
+    if (timezone.startsWith('America/')) return 'US'
+    
+    return 'OTHER'
+  } catch (e) {
+    return null
+  }
+}