@el7ven/cookie-kit 0.2.15

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@el7ven/cookie-kit",
+  "version": "0.2.15",
+  "type": "module",
+  "main": "./src/index.js",
+  "module": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./styles": "./dist/styles/index.css",
+    "./src/styles": "./dist/styles/index.css",
+    "./dist/styles": "./dist/styles/index.css",
+    "./react": "./src/react/index.js",
+    "./vue": "./src/vue/index.js",
+    "./src/composables/useCookieConsent": "./src/vue/composables/useCookieConsent.js",
+    "./composables/useCookieConsent": "./src/vue/composables/useCookieConsent.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "echo \"@el7ven/cookie-consent: source-only package\"",
+    "test": "node --test src/**/*.test.js"
+  },
+  "keywords": [
+    "cookie",
+    "consent", 
+    "gdpr",
+    "privacy",
+    "compliance",
+    "react",
+    "vue",
+    "javascript",
+    "cookie-consent"
+  ],
+  "description": "Unified cookie consent management kit for GDPR compliance with React, Vue, and Vanilla JS support",
+  "author": {
+    "name": "Igor Semionov",
+    "email": "igsemionov@gmail.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/El7ven/cookie-kit.git"
+  },
+  "homepage": "https://github.com/El7ven/cookie-kit#readme",
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "vue": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/src/core/index.js

@@ -0,0 +1,232 @@
+import { VERSION, getVersion, getVersionInfo, logVersion } from './version.js'
+
+const DEFAULT_CONFIG = {
+  storageKey: 'cookie_consent',
+  consentExpireDays: 365,
+  categories: {
+    necessary: { required: true, enabled: true },
+    analytics: { required: false, enabled: false },
+    marketing: { required: false, enabled: false },
+    preferences: { required: false, enabled: false }
+  }
+}
+
+function isPromiseLike(value) {
+  return !!value && typeof value.then === 'function'
+}
+
+function createWebStorageAdapter(storageKey) {
+  if (typeof window === 'undefined' || !window.localStorage) {
+    const memory = new Map()
+    return {
+      getItem: key => memory.get(key) ?? null,
+      setItem: (key, value) => memory.set(key, value),
+      removeItem: key => memory.delete(key),
+      defaultKey: storageKey
+    }
+  }
+
+  return {
+    getItem: key => window.localStorage.getItem(key),
+    setItem: (key, value) => window.localStorage.setItem(key, value),
+    removeItem: key => window.localStorage.removeItem(key),
+    defaultKey: storageKey
+  }
+}
+
+function mergeConfig(base, extra) {
+  return {
+    ...base,
+    ...extra,
+    categories: {
+      ...base.categories,
+      ...(extra?.categories || {})
+    }
+  }
+}
+
+function normalizeCategories(categories) {
+  if (Array.isArray(categories)) {
+    return categories.reduce((acc, cat) => {
+      acc[cat.id] = cat
+      return acc
+    }, {})
+  }
+  return categories || {}
+}
+
+export class CookieKitCore {
+  constructor(userConfig = {}) {
+    this.config = mergeConfig(DEFAULT_CONFIG, userConfig)
+    this.config.categories = normalizeCategories(this.config.categories)
+    this.listeners = new Map()
+    this.storage = this.config.storageAdapter || createWebStorageAdapter(this.config.storageKey)
+  }
+
+  getStorageKey() {
+    return this.config.storageKey || this.storage.defaultKey || 'cookie_consent'
+  }
+
+  getConsent() {
+    try {
+      const raw = this.storage.getItem(this.getStorageKey())
+      if (isPromiseLike(raw)) return null
+      if (!raw) return null
+      const data = JSON.parse(raw)
+      if (!data || typeof data !== 'object') return null
+      if (data.expiresAt && Date.now() > new Date(data.expiresAt).getTime()) return null
+      return data
+    } catch {
+      return null
+    }
+  }
+
+  async getConsentAsync() {
+    try {
+      const raw = await this.storage.getItem(this.getStorageKey())
+      if (!raw) return null
+      const data = JSON.parse(raw)
+      if (!data || typeof data !== 'object') return null
+      if (data.expiresAt && Date.now() > new Date(data.expiresAt).getTime()) return null
+      return data
+    } catch {
+      return null
+    }
+  }
+
+  hasConsent() {
+    const consent = this.getConsent()
+    return !!consent?.hasConsented
+  }
+
+  async hasConsentAsync() {
+    const consent = await this.getConsentAsync()
+    return !!consent?.hasConsented
+  }
+
+  hasCategoryConsent(categoryId) {
+    const consent = this.getConsent()
+    return consent?.categories?.[categoryId] === true
+  }
+
+  async hasCategoryConsentAsync(categoryId) {
+    const consent = await this.getConsentAsync()
+    return consent?.categories?.[categoryId] === true
+  }
+
+  getDefaultCategoriesState() {
+    const next = {}
+    Object.keys(this.config.categories).forEach(id => {
+      const category = this.config.categories[id]
+      if (category?.enabled !== false) {
+        next[id] = !!category.required
+      }
+    })
+    return next
+  }
+
+  async saveConsent(categories, source = 'api') {
+    const now = new Date()
+    const expiresAt = new Date(now.getTime() + this.config.consentExpireDays * 24 * 60 * 60 * 1000)
+
+    const normalized = this.getDefaultCategoriesState()
+    Object.keys(categories || {}).forEach(id => {
+      if (Object.prototype.hasOwnProperty.call(normalized, id)) {
+        normalized[id] = !!categories[id] || !!this.config.categories[id]?.required
+      }
+    })
+
+    const optionalIds = Object.keys(normalized).filter(id => !this.config.categories[id]?.required)
+    const allOptionalAccepted = optionalIds.length > 0 && optionalIds.every(id => normalized[id] === true)
+    const allOptionalRejected = optionalIds.length > 0 && optionalIds.every(id => normalized[id] === false)
+
+    let status = 'custom'
+    if (optionalIds.length === 0 || allOptionalAccepted) status = 'accepted'
+    if (allOptionalRejected) status = 'rejected'
+
+    const consent = {
+      consentId: typeof crypto !== 'undefined' && crypto.randomUUID ? crypto.randomUUID() : `${Date.now()}-${Math.random()}`,
+      timestamp: now.toISOString(),
+      expiresAt: expiresAt.toISOString(),
+      status,
+      source,
+      hasConsented: true,
+      categories: normalized,
+      version: this.config.version || '0.1.0'
+    }
+
+    await this.storage.setItem(this.getStorageKey(), JSON.stringify(consent))
+    this.emit('consentChanged', { consent, categories: normalized })
+    return consent
+  }
+
+  acceptAll(source = 'banner') {
+    const categories = {}
+    Object.keys(this.config.categories).forEach(id => {
+      if (this.config.categories[id]?.enabled !== false) {
+        categories[id] = true
+      }
+    })
+    return this.saveConsent(categories, source)
+  }
+
+  rejectAll(source = 'banner') {
+    const categories = {}
+    Object.keys(this.config.categories).forEach(id => {
+      const category = this.config.categories[id]
+      if (category?.enabled !== false) {
+        categories[id] = !!category.required
+      }
+    })
+    return this.saveConsent(categories, source)
+  }
+
+  acceptSelected(selectedIds = [], source = 'settings') {
+    const selectedSet = new Set(selectedIds)
+    const categories = {}
+    Object.keys(this.config.categories).forEach(id => {
+      const category = this.config.categories[id]
+      if (category?.enabled !== false) {
+        categories[id] = selectedSet.has(id) || !!category.required
+      }
+    })
+    return this.saveConsent(categories, source)
+  }
+
+  clearConsent() {
+    this.storage.removeItem(this.getStorageKey())
+    this.emit('consentCleared', {})
+  }
+
+  async clearConsentAsync() {
+    await this.storage.removeItem(this.getStorageKey())
+    this.emit('consentCleared', {})
+  }
+
+  on(event, callback) {
+    const list = this.listeners.get(event) || []
+    list.push(callback)
+    this.listeners.set(event, list)
+    return () => this.off(event, callback)
+  }
+
+  off(event, callback) {
+    const list = this.listeners.get(event) || []
+    this.listeners.set(event, list.filter(cb => cb !== callback))
+  }
+
+  emit(event, payload) {
+    const list = this.listeners.get(event) || []
+    list.forEach(cb => cb(payload))
+
+    if (typeof window !== 'undefined') {
+      window.dispatchEvent(new CustomEvent(`cookie-consent:${event}`, { detail: payload }))
+    }
+  }
+}
+
+export function createCookieKit(config = {}) {
+  return new CookieKitCore(config)
+}
+
+export { DEFAULT_CONFIG, VERSION, getVersion, getVersionInfo, logVersion }

package/src/core/index.test.js

@@ -0,0 +1,90 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import { createCookieKit } from './index.js'
+
+function createMemoryStorageAdapter() {
+  const memory = new Map()
+
+  return {
+    getItem: key => memory.get(key) ?? null,
+    setItem: (key, value) => memory.set(key, value),
+    removeItem: key => memory.delete(key),
+    defaultKey: 'cookie_consent'
+  }
+}
+
+function createAsyncMemoryStorageAdapter() {
+  const memory = new Map()
+
+  return {
+    getItem: async key => memory.get(key) ?? null,
+    setItem: async (key, value) => memory.set(key, value),
+    removeItem: async key => memory.delete(key),
+    defaultKey: 'cookie_consent'
+  }
+}
+
+test('core: acceptSelected stores consent and required categories', async () => {
+  const kit = createCookieKit({
+    storageAdapter: createMemoryStorageAdapter(),
+    categories: {
+      necessary: { required: true, enabled: true },
+      analytics: { required: false, enabled: true },
+      marketing: { required: false, enabled: true }
+    }
+  })
+
+  const consent = await kit.acceptSelected(['analytics'])
+
+  assert.equal(consent.hasConsented, true)
+  assert.equal(consent.categories.necessary, true)
+  assert.equal(consent.categories.analytics, true)
+  assert.equal(consent.categories.marketing, false)
+  assert.equal(kit.hasCategoryConsent('analytics'), true)
+  assert.equal(kit.hasCategoryConsent('marketing'), false)
+})
+
+test('core: rejectAll and clearConsent flow', async () => {
+  const kit = createCookieKit({
+    storageAdapter: createMemoryStorageAdapter(),
+    categories: {
+      necessary: { required: true, enabled: true },
+      analytics: { required: false, enabled: true }
+    }
+  })
+
+  await kit.rejectAll()
+
+  assert.equal(kit.hasConsent(), true)
+  assert.equal(kit.hasCategoryConsent('necessary'), true)
+  assert.equal(kit.hasCategoryConsent('analytics'), false)
+
+  kit.clearConsent()
+
+  assert.equal(kit.getConsent(), null)
+  assert.equal(kit.hasConsent(), false)
+})
+
+test('core: async storage adapter works with async API', async () => {
+  const kit = createCookieKit({
+    storageAdapter: createAsyncMemoryStorageAdapter(),
+    categories: {
+      necessary: { required: true, enabled: true },
+      analytics: { required: false, enabled: true }
+    }
+  })
+
+  await kit.acceptSelected(['analytics'])
+
+  assert.equal(kit.getConsent(), null)
+  assert.equal(await kit.hasConsentAsync(), true)
+  assert.equal(await kit.hasCategoryConsentAsync('necessary'), true)
+  assert.equal(await kit.hasCategoryConsentAsync('analytics'), true)
+
+  const consent = await kit.getConsentAsync()
+  assert.equal(consent?.hasConsented, true)
+
+  await kit.clearConsentAsync()
+  assert.equal(await kit.getConsentAsync(), null)
+})

package/src/core/version.js

@@ -0,0 +1,29 @@
+/**
+ * Version metadata for package runtime.
+ */
+
+export const VERSION = '1.0.0-beta.0'
+export const PACKAGE_NAME = '@el7ven/cookie-consent/core'
+
+// Core version metadata.
+export const VERSION_INFO = {
+  version: VERSION,
+  name: PACKAGE_NAME,
+  buildDate: new Date().toISOString(),
+  environment: 'production'
+}
+
+// Return package version.
+export function getVersion() {
+  return VERSION
+}
+
+// Return full version metadata.
+export function getVersionInfo() {
+  return VERSION_INFO
+}
+
+// Print runtime version in debug-friendly format.
+export function logVersion() {
+  console.log(`🍪 ${PACKAGE_NAME} v${VERSION}`)
+}

package/src/index.js

@@ -0,0 +1,67 @@
+/**
+ * @el7ven/cookie-consent - Unified Cookie Consent Management
+ * GDPR compliant cookie consent with React and Vue support
+ * @version 1.0.0-beta.0
+ * @author Igor Semionov
+ */
+
+// Core functionality
+export { createCookieKit, CookieKitCore, DEFAULT_CONFIG } from './core/index.js'
+
+// Import for default export
+import { createCookieKit, CookieKitCore, DEFAULT_CONFIG } from './core/index.js'
+import { initCookieKit } from './js/index.js'
+import { VERSION } from './core/version.js'
+
+// Vanilla JS components
+export { initCookieKit, mountCookieConsent } from './js/index.js'
+
+// React components
+export * from './react/index.js'
+
+// Vue components  
+export * from './vue/index.js'
+
+// Version info
+export { VERSION, getVersion, getVersionInfo, logVersion } from './core/version.js'
+
+// Unified factory function
+export function createCookieConsent(config = {}) {
+  const { framework = 'js', ...restConfig } = config
+  
+  switch (framework) {
+    case 'react':
+      return import('./react/index.js').then(m => m.createCookieKit(restConfig))
+    case 'vue':
+      return import('./vue/index.js').then(m => m.createCookieKit(restConfig))
+    default:
+      return import('./js/index.js').then(m => m.initCookieKit(restConfig))
+  }
+}
+
+// Auto-detect framework and create appropriate instance
+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
+export default {
+  createCookieKit,
+  createCookieConsent,
+  autoCookieConsent,
+  initCookieKit,
+  CookieKitCore,
+  DEFAULT_CONFIG,
+  VERSION
+}