@el7ven/cookie-kit 0.2.21 → 0.3.2

package/src/index.js

@@ -1,38 +1,80 @@
 /**
  * @el7ven/cookie-kit - Unified Cookie Consent Management
  * GDPR compliant cookie consent with React and Vue support
- * @version 1.0.0-beta.0
+ * @version 0.4.0
  * @author Igor Semionov
  */
 
-// Core functionality
+// ─── Core (lite) ───
 export { createCookieKit, CookieKitCore, DEFAULT_CONFIG } from './core/index.js'
 
-// Analytics integration
-export { createAnalyticsManager, initGoogleConsentMode, updateGoogleConsent, loadGTM, loadGA4, loadMetaPixel, loadYandexMetrica, manageScriptBlocking } from './core/analytics.js'
+// ─── Core (full) ───
+export { ConsentManager } from './core/ConsentManager.js'
+export { StorageAdapter } from './core/StorageAdapter.js'
+export { ConsentMode, CONSENT_MODE_DEFAULTS, CATEGORY_MAPPING } from './core/ConsentMode.js'
+export { FocusTrap } from './core/FocusTrap.js'
+export { ScriptLoader } from './core/ScriptLoader.js'
+export { AnalyticsManager, ANALYTICS_PROVIDERS } from './core/AnalyticsManager.js'
+export { GeoDetector as CoreGeoDetector } from './core/GeoDetector.js'
 
-// Import for default export
+// ─── Analytics helpers ───
+export { createAnalyticsManager, initGoogleConsentMode, updateGoogleConsent, loadGTM, loadGA4, loadMetaPixel, loadYandexMetrica, blockScriptsBeforeConsent, unblockConsentedScripts, manageScriptBlocking } from './core/analytics.js'
+
+// ─── Geo detection ───
+export { GeoDetector } from './geo/GeoDetector.js'
+export { REGION_RULES, isEU, isEEA, isUK, requiresGDPR, getRegion, requiresConsentBanner, getRegulation, isEssentialOnly } from './geo/RegionRules.js'
+
+// ─── Locales / i18n ───
+export { locales, getLocale } from './locales/index.js'
+
+// ─── Providers ───
+export { GoogleConsentModeProvider } from './providers/GoogleConsentModeProvider.js'
+
+// ─── Plugins ───
+export { CMPPlugin } from './plugins/CMPPlugin.js'
+export { PluginManager } from './plugins/PluginManager.js'
+
+// ─── Trackers ───
+export { TrackerDetector } from './trackers/TrackerDetector.js'
+export { TrackerRegistry } from './trackers/TrackerRegistry.js'
+
+// ─── Script rewriting ───
+export { ScriptRewriter } from './rewriting/ScriptRewriter.js'
+
+// ─── Scripts (advanced) ───
+export { ScriptLoader as AdvancedScriptLoader } from './scripts/ScriptLoader.js'
+export { ScriptManager } from './scripts/ScriptManager.js'
+export { ScriptRegistry } from './scripts/ScriptRegistry.js'
+export { ScriptScanner } from './scripts/ScriptScanner.js'
+
+// ─── Utils ───
+export { getCookie, setCookie, deleteCookie, getAllCookies } from './utils/cookies.js'
+export { getFocusableElements, trapFocus, lockBodyScroll, unlockBodyScroll, onEscape } from './utils/dom.js'
+export { generateUUID, debounce, throttle, deepMerge, isSSR, isMobile, getRegionFromTimezone } from './utils/helpers.js'
+
+// ─── Imports for default export ───
 import { createCookieKit, CookieKitCore, DEFAULT_CONFIG } from './core/index.js'
 import { createAnalyticsManager } from './core/analytics.js'
+import { ConsentManager } from './core/ConsentManager.js'
 import { initCookieKit } from './js/index.js'
 import { VERSION } from './core/version.js'
 
-// Vanilla JS components
+// ─── Vanilla JS components ───
 export { initCookieKit, mountCookieConsent } from './js/index.js'
 
-// React components
+// ─── React components ───
 export * from './react/index.js'
 
-// Vue components  
+// ─── Vue components ───
 export * from './vue/index.js'
 
-// Vue composable
+// ─── Vue composable ───
 export { useCookieConsent } from './vue/composables/useCookieConsent.js'
 
-// Version info
+// ─── Version info ───
 export { VERSION, getVersion, getVersionInfo, logVersion } from './core/version.js'
 
-// Unified factory function
+// ─── Unified factory ───
 export function createCookieConsent(config = {}) {
   const { framework = 'js', ...restConfig } = config
   
@@ -46,23 +88,18 @@ export function createCookieConsent(config = {}) {
   }
 }
 
-// Auto-detect framework and create appropriate instance
+// Auto-detect framework
 export function autoCookieConsent(config = {}) {
-  // Detect React
   if (typeof window !== 'undefined' && window.React) {
     return createCookieConsent({ ...config, framework: 'react' })
   }
-  
-  // Detect Vue
   if (typeof window !== 'undefined' && window.Vue) {
     return createCookieConsent({ ...config, framework: 'vue' })
   }
-  
-  // Default to vanilla JS
   return createCookieConsent({ ...config, framework: 'js' })
 }
 
-// Default export for convenience
+// Default export
 export default {
   createCookieKit,
   createCookieConsent,
@@ -70,6 +107,7 @@ export default {
   autoCookieConsent,
   initCookieKit,
   CookieKitCore,
+  ConsentManager,
   DEFAULT_CONFIG,
   VERSION
 }

package/src/js/CookieConsent.js

@@ -386,7 +386,6 @@ class CookieConsent extends HTMLElement {
       /* Header */
       .cookie-drawer__header {
         padding: 24px 24px 16px;
-        border-bottom: 1px solid var(--ck-border);
         display: flex;
         justify-content: space-between;
         align-items: flex-start;

package/src/locales/en.js

@@ -0,0 +1,54 @@
+/**
+ * English translations
+ */
+
+export default {
+  essential: {
+    title: 'Cookies',
+    message: 'We use cookies to improve your experience on our site.',
+    button: 'I understand'
+  },
+  gdpr: {
+    title: 'Cookie Preferences',
+    message: 'We use cookies to provide you with the best experience. Choose which types of cookies you accept.',
+    buttons: {
+      acceptAll: 'Accept all',
+      rejectAll: 'Reject all',
+      acceptSelection: 'Accept selection',
+      settings: 'Settings'
+    }
+  },
+  settings: {
+    title: 'Cookie Settings',
+    tabs: {
+      privacy: 'Privacy'
+    },
+    buttons: {
+      acceptAll: 'Accept all',
+      rejectAll: 'Reject all',
+      acceptSelection: 'Save selection'
+    },
+    links: {
+      moreInfo: 'More information',
+      cookieDetails: 'Cookie details'
+    }
+  },
+  categories: {
+    necessary: {
+      label: 'Necessary',
+      description: 'Essential cookies for site functionality'
+    },
+    analytics: {
+      label: 'Analytics',
+      description: 'Cookies for traffic and user behavior analysis'
+    },
+    marketing: {
+      label: 'Marketing',
+      description: 'Cookies for personalized advertising'
+    },
+    preferences: {
+      label: 'Preferences',
+      description: 'Cookies for saving user preferences'
+    }
+  }
+}

package/src/locales/index.js

@@ -0,0 +1,20 @@
+/**
+ * i18n support for cookie consent
+ */
+
+import en from './en.js'
+import ro from './ro.js'
+
+export const locales = {
+  en,
+  ro
+}
+
+export function getLocale(lang = 'ro') {
+  return locales[lang] || locales.ro
+}
+
+export default {
+  locales,
+  getLocale
+}

package/src/locales/ro.js

@@ -0,0 +1,54 @@
+/**
+ * Romanian translations
+ */
+
+export default {
+  essential: {
+    title: 'Cookie-uri',
+    message: 'Folosim cookie-uri pentru a îmbunătăți experiența ta pe site.',
+    button: 'Am înțeles'
+  },
+  gdpr: {
+    title: 'Preferințe Cookie-uri',
+    message: 'Folosim cookie-uri pentru a-ți oferi cea mai bună experiență. Alege ce tipuri de cookie-uri accepți.',
+    buttons: {
+      acceptAll: 'Acceptă toate',
+      rejectAll: 'Respinge toate',
+      acceptSelection: 'Acceptă selecția',
+      settings: 'Setări'
+    }
+  },
+  settings: {
+    title: 'Setări Cookie-uri',
+    tabs: {
+      privacy: 'Confidențialitate'
+    },
+    buttons: {
+      acceptAll: 'Acceptă toate',
+      rejectAll: 'Respinge toate',
+      acceptSelection: 'Salvează selecția'
+    },
+    links: {
+      moreInfo: 'Mai multe informații',
+      cookieDetails: 'Detalii cookie-uri'
+    }
+  },
+  categories: {
+    necessary: {
+      label: 'Necesare',
+      description: 'Cookie-uri esențiale pentru funcționarea site-ului'
+    },
+    analytics: {
+      label: 'Analiză',
+      description: 'Cookie-uri pentru analiza traficului și comportamentului utilizatorilor'
+    },
+    marketing: {
+      label: 'Marketing',
+      description: 'Cookie-uri pentru publicitate personalizată'
+    },
+    preferences: {
+      label: 'Preferințe',
+      description: 'Cookie-uri pentru salvarea preferințelor utilizatorului'
+    }
+  }
+}

package/src/plugins/CMPPlugin.js

@@ -0,0 +1,187 @@
+/**
+ * CMP Plugin Base Class
+ * @module CMPPlugin
+ * 
+ * Base class for all CMP plugins
+ * Plugins can extend CMP functionality without modifying core
+ */
+
+export class CMPPlugin {
+  constructor(config = {}) {
+    this.config = config
+    this.cmp = null
+    this.isInitialized = false
+  }
+
+  /**
+   * Get plugin name
+   * @returns {string}
+   */
+  get name() {
+    return this.constructor.name
+  }
+
+  /**
+   * Get plugin version
+   * @returns {string}
+   */
+  get version() {
+    return '1.0.0'
+  }
+
+  /**
+   * Initialize plugin
+   * Called when plugin is registered
+   * @param {Object} cmpInstance - CMP instance
+   */
+  init(cmpInstance) {
+    this.cmp = cmpInstance
+    this.isInitialized = true
+    this._debug('Plugin initialized')
+  }
+
+  /**
+   * Lifecycle: Before CMP initialization
+   */
+  beforeInit() {
+    // Override in subclass
+  }
+
+  /**
+   * Lifecycle: After CMP initialization
+   */
+  afterInit() {
+    // Override in subclass
+  }
+
+  /**
+   * Lifecycle: Before consent banner shown
+   */
+  beforeBannerShow() {
+    // Override in subclass
+  }
+
+  /**
+   * Lifecycle: After consent banner shown
+   */
+  afterBannerShow() {
+    // Override in subclass
+  }
+
+  /**
+   * Lifecycle: Before consent saved
+   * @param {Object} consent - Consent data
+   * @returns {Object} Modified consent (or original)
+   */
+  beforeConsentSave(consent) {
+    // Override in subclass
+    return consent
+  }
+
+  /**
+   * Lifecycle: After consent saved
+   * @param {Object} consent - Saved consent data
+   */
+  afterConsentSave(consent) {
+    // Override in subclass
+  }
+
+  /**
+   * Event: Consent changed
+   * @param {Object} data - { consent, categories }
+   */
+  onConsentChange(data) {
+    // Override in subclass
+  }
+
+  /**
+   * Event: Consent accepted
+   * @param {Object} data - { consent, categories }
+   */
+  onConsentAccepted(data) {
+    // Override in subclass
+  }
+
+  /**
+   * Event: Consent rejected
+   * @param {Object} data - { consent, categories }
+   */
+  onConsentRejected(data) {
+    // Override in subclass
+  }
+
+  /**
+   * Event: Consent expired
+   */
+  onConsentExpired() {
+    // Override in subclass
+  }
+
+  /**
+   * Event: Script loaded
+   * @param {Object} script - Script info
+   */
+  onScriptLoaded(script) {
+    // Override in subclass
+  }
+
+  /**
+   * Event: Tracker detected
+   * @param {Object} tracker - Tracker info
+   */
+  onTrackerDetected(tracker) {
+    // Override in subclass
+  }
+
+  /**
+   * Cleanup plugin
+   * Called when plugin is unregistered
+   */
+  destroy() {
+    this.isInitialized = false
+    this.cmp = null
+    this._debug('Plugin destroyed')
+  }
+
+  /**
+   * Get CMP API
+   * @returns {Object}
+   */
+  getAPI() {
+    return this.cmp?.api || {}
+  }
+
+  /**
+   * Get consent
+   * @returns {Object|null}
+   */
+  getConsent() {
+    return this.cmp?.getConsent() || null
+  }
+
+  /**
+   * Check category consent
+   * @param {string} category
+   * @returns {boolean}
+   */
+  hasCategoryConsent(category) {
+    return this.cmp?.hasCategoryConsent(category) || false
+  }
+
+  /**
+   * Emit custom event
+   * @param {string} eventName
+   * @param {Object} data
+   */
+  emit(eventName, data = {}) {
+    if (typeof window !== 'undefined') {
+      window.dispatchEvent(new CustomEvent(`cmp:plugin:${eventName}`, {
+        detail: { plugin: this.name, ...data }
+      }))
+    }
+  }
+
+  _debug(...args) {
+    // Debug disabled
+  }
+}

package/src/plugins/PluginManager.js

@@ -0,0 +1,234 @@
+/**
+ * Plugin Manager
+ * @module PluginManager
+ * 
+ * Manages CMP plugins lifecycle and events
+ */
+
+export class PluginManager {
+  constructor(cmpInstance) {
+    this.cmp = cmpInstance
+    this.plugins = new Map() // name -> plugin instance
+    this.hooks = {
+      beforeInit: [],
+      afterInit: [],
+      beforeBannerShow: [],
+      afterBannerShow: [],
+      beforeConsentSave: [],
+      afterConsentSave: []
+    }
+  }
+
+  /**
+   * Register plugin
+   * @param {CMPPlugin} plugin - Plugin instance
+   * @returns {boolean}
+   */
+  register(plugin) {
+    if (!plugin || !plugin.name) return false
+    if (this.plugins.has(plugin.name)) return false
+
+    // Initialize plugin
+    plugin.init(this.cmp)
+
+    // Store plugin
+    this.plugins.set(plugin.name, plugin)
+
+    // Register lifecycle hooks
+    this._registerHooks(plugin)
+
+    // Setup event listeners
+    this._setupEventListeners(plugin)
+
+    this._debug(`Plugin "${plugin.name}" registered`)
+    return true
+  }
+
+  /**
+   * Unregister plugin
+   * @param {string} pluginName
+   * @returns {boolean}
+   */
+  unregister(pluginName) {
+    const plugin = this.plugins.get(pluginName)
+    if (!plugin) {
+      return false
+    }
+
+    // Cleanup plugin
+    plugin.destroy()
+
+    // Remove from hooks
+    this._unregisterHooks(plugin)
+
+    // Remove plugin
+    this.plugins.delete(pluginName)
+
+    this._debug(`Plugin "${pluginName}" unregistered`)
+    return true
+  }
+
+  /**
+   * Get plugin by name
+   * @param {string} pluginName
+   * @returns {CMPPlugin|null}
+   */
+  get(pluginName) {
+    return this.plugins.get(pluginName) || null
+  }
+
+  /**
+   * Get all plugins
+   * @returns {Array}
+   */
+  getAll() {
+    return Array.from(this.plugins.values())
+  }
+
+  /**
+   * Check if plugin is registered
+   * @param {string} pluginName
+   * @returns {boolean}
+   */
+  has(pluginName) {
+    return this.plugins.has(pluginName)
+  }
+
+  /**
+   * Execute lifecycle hook
+   * @param {string} hookName
+   * @param {*} data
+   * @returns {*}
+   */
+  async executeHook(hookName, data = null) {
+    const hooks = this.hooks[hookName] || []
+    
+    let result = data
+
+    for (const hook of hooks) {
+      try {
+        const hookResult = await hook(result)
+        // For beforeConsentSave, allow modification
+        if (hookName === 'beforeConsentSave' && hookResult !== undefined) {
+          result = hookResult
+        }
+      } catch (error) {
+        // Silent error
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Register plugin hooks
+   * @private
+   */
+  _registerHooks(plugin) {
+    // beforeInit
+    if (typeof plugin.beforeInit === 'function') {
+      this.hooks.beforeInit.push(() => plugin.beforeInit())
+    }
+
+    // afterInit
+    if (typeof plugin.afterInit === 'function') {
+      this.hooks.afterInit.push(() => plugin.afterInit())
+    }
+
+    // beforeBannerShow
+    if (typeof plugin.beforeBannerShow === 'function') {
+      this.hooks.beforeBannerShow.push(() => plugin.beforeBannerShow())
+    }
+
+    // afterBannerShow
+    if (typeof plugin.afterBannerShow === 'function') {
+      this.hooks.afterBannerShow.push(() => plugin.afterBannerShow())
+    }
+
+    // beforeConsentSave
+    if (typeof plugin.beforeConsentSave === 'function') {
+      this.hooks.beforeConsentSave.push((consent) => plugin.beforeConsentSave(consent))
+    }
+
+    // afterConsentSave
+    if (typeof plugin.afterConsentSave === 'function') {
+      this.hooks.afterConsentSave.push((consent) => plugin.afterConsentSave(consent))
+    }
+  }
+
+  /**
+   * Unregister plugin hooks
+   * @private
+   */
+  _unregisterHooks(plugin) {
+    Object.keys(this.hooks).forEach(hookName => {
+      this.hooks[hookName] = this.hooks[hookName].filter(hook => {
+        // Remove hooks that belong to this plugin
+        return hook.toString().indexOf(plugin.name) === -1
+      })
+    })
+  }
+
+  /**
+   * Setup event listeners for plugin
+   * @private
+   */
+  _setupEventListeners(plugin) {
+    // Consent changed
+    if (typeof plugin.onConsentChange === 'function') {
+      this.cmp.on('consentChanged', (data) => plugin.onConsentChange(data))
+    }
+
+    // Consent accepted
+    if (typeof plugin.onConsentAccepted === 'function') {
+      this.cmp.on('consentAccepted', (data) => plugin.onConsentAccepted(data))
+    }
+
+    // Consent rejected
+    if (typeof plugin.onConsentRejected === 'function') {
+      this.cmp.on('consentRejected', (data) => plugin.onConsentRejected(data))
+    }
+
+    // Consent expired
+    if (typeof plugin.onConsentExpired === 'function') {
+      this.cmp.on('consentExpired', () => plugin.onConsentExpired())
+    }
+
+    // Script loaded
+    if (typeof plugin.onScriptLoaded === 'function') {
+      if (typeof window !== 'undefined') {
+        window.addEventListener('cookie-consent:script-loaded', (e) => {
+          plugin.onScriptLoaded(e.detail)
+        })
+      }
+    }
+
+    // Tracker detected
+    if (typeof plugin.onTrackerDetected === 'function') {
+      if (typeof window !== 'undefined') {
+        window.addEventListener('cookie-consent:tracker-detected', (e) => {
+          plugin.onTrackerDetected(e.detail)
+        })
+      }
+    }
+  }
+
+  /**
+   * Get plugin stats
+   * @returns {Object}
+   */
+  getStats() {
+    return {
+      total: this.plugins.size,
+      plugins: this.getAll().map(p => ({
+        name: p.name,
+        version: p.version,
+        initialized: p.isInitialized
+      }))
+    }
+  }
+
+  _debug(...args) {
+    // Debug disabled
+  }
+}

package/src/plugins/index.js

@@ -0,0 +1,7 @@
+/**
+ * Plugin System
+ * @module plugins
+ */
+
+export { CMPPlugin } from './CMPPlugin.js'
+export { PluginManager } from './PluginManager.js'