cookiecraft 1.0.0

package/dist/types/blocking/CategoryManager.d.ts

@@ -0,0 +1,24 @@
+/**
+ * CategoryManager - Maps scripts to consent categories and manages patterns
+ */
+import { ConsentCategories } from '../types';
+export declare class CategoryManager {
+    private categories;
+    constructor();
+    /**
+     * Register a category with URL patterns
+     */
+    registerCategory(name: string, patterns: string[]): void;
+    /**
+     * Get category for a script element
+     */
+    getCategoryForScript(script: HTMLScriptElement): string | null;
+    /**
+     * Check if a category is allowed based on consent
+     */
+    isAllowed(category: string, consent: ConsentCategories): boolean;
+    /**
+     * Initialize default URL patterns for common tracking services
+     */
+    private initializeDefaultPatterns;
+}

package/dist/types/blocking/ScriptBlocker.d.ts

@@ -0,0 +1,54 @@
+/**
+ * ScriptBlocker - Prevents scripts from executing before consent using MutationObserver
+ */
+import { ConsentCategories } from '../types';
+import { CategoryManager } from './CategoryManager';
+import { EventEmitter } from '../core/EventEmitter';
+export declare class ScriptBlocker {
+    private observer;
+    private blockedScripts;
+    private categoryManager;
+    private eventEmitter;
+    private currentConsent;
+    constructor(categoryManager: CategoryManager, eventEmitter: EventEmitter);
+    /**
+     * Initialize script blocking
+     */
+    init(): void;
+    /**
+     * Block all scripts (reset consent)
+     */
+    block(): void;
+    /**
+     * Unblock scripts based on consent categories
+     */
+    unblock(categories: ConsentCategories): void;
+    /**
+     * Destroy the blocker and stop observing
+     */
+    destroy(): void;
+    /**
+     * Block all existing scripts with data-cookieconsent attribute
+     */
+    private blockExistingScripts;
+    /**
+     * Observe DOM for dynamically added scripts
+     */
+    private observeDOM;
+    /**
+     * Process a script element - block or allow based on consent
+     */
+    private processScript;
+    /**
+     * Reactivate a blocked script by creating a new one with correct type
+     */
+    private reactivateScript;
+    /**
+     * Generate a stable, deterministic ID for a script element
+     */
+    private generateScriptId;
+    /**
+     * Simple hash function for content-based script identification
+     */
+    private simpleHash;
+}

package/dist/types/core/ConsentManager.d.ts

@@ -0,0 +1,33 @@
+/**
+ * ConsentManager - Handles consent logic and validation
+ */
+import { ConsentConfig, ConsentCategories, ConsentRecord } from '../types';
+export declare class ConsentManager {
+    private consent;
+    private config;
+    constructor(config: ConsentConfig);
+    /**
+     * Validate consent categories
+     */
+    validateConsent(categories: ConsentCategories): boolean;
+    /**
+     * Update consent with new categories
+     */
+    updateConsent(categories: ConsentCategories): ConsentRecord;
+    /**
+     * Check if user needs to give consent
+     */
+    needsConsent(): boolean;
+    /**
+     * Check if stored consent needs update due to policy change
+     */
+    needsUpdate(storedConsent: ConsentRecord): boolean;
+    /**
+     * Get current consent record
+     */
+    getCurrentConsent(): ConsentRecord;
+    /**
+     * Create a new consent record
+     */
+    private createConsentRecord;
+}

package/dist/types/core/CookieConsent.d.ts

@@ -0,0 +1,76 @@
+/**
+ * CookieConsent - Main orchestrator class
+ */
+import { ConsentConfig, ConsentCategories } from '../types';
+import '../styles/banner.css';
+import '../styles/animations.css';
+import '../styles/preferences.css';
+import '../styles/widget.css';
+export declare class CookieConsent {
+    private config;
+    private consentManager;
+    private storageManager;
+    private scriptBlocker;
+    private eventEmitter;
+    private banner;
+    private preferenceCenter;
+    private floatingWidget;
+    private gtmIntegration;
+    constructor(config: ConsentConfig);
+    /**
+     * Initialize the cookie consent system
+     */
+    init(): void;
+    /**
+     * Show the banner
+     */
+    show(): void;
+    /**
+     * Hide the banner
+     */
+    hide(): void;
+    /**
+     * Show preferences modal
+     */
+    showPreferences(): void;
+    /**
+     * Update consent with new categories
+     */
+    updateConsent(categories: ConsentCategories): void;
+    /**
+     * Get current consent
+     */
+    getConsent(): import("../types").ConsentRecord | null;
+    /**
+     * Reset consent (clear stored data and show banner)
+     */
+    reset(): void;
+    /**
+     * Register event handler
+     */
+    on(event: string, callback: Function): void;
+    /**
+     * Unregister event handler
+     */
+    off(event: string, callback: Function): void;
+    /**
+     * Destroy and cleanup all UI elements
+     */
+    destroy(): void;
+    /**
+     * Show the banner
+     */
+    private showBanner;
+    /**
+     * Show the floating widget
+     */
+    private showFloatingWidget;
+    /**
+     * Apply consent by unblocking allowed scripts and clearing denied cookies
+     */
+    private applyConsent;
+    /**
+     * Validate and set default config values
+     */
+    private validateConfig;
+}

package/dist/types/core/EventEmitter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * EventEmitter - Simple pub/sub pattern for internal and external events
+ */
+export declare class EventEmitter {
+    private events;
+    /**
+     * Register an event handler
+     */
+    on(event: string, callback: Function): void;
+    /**
+     * Unregister an event handler
+     */
+    off(event: string, callback: Function): void;
+    /**
+     * Emit an event with optional data
+     */
+    emit(event: string, data?: any): void;
+    /**
+     * Clear all event handlers
+     */
+    clear(): void;
+    /**
+     * Clear handlers for a specific event
+     */
+    clearEvent(event: string): void;
+}

package/dist/types/core/StorageManager.d.ts

@@ -0,0 +1,33 @@
+/**
+ * StorageManager - Manages localStorage persistence for consent records
+ */
+import { ConsentRecord } from '../types';
+export declare class StorageManager {
+    private static readonly STORAGE_KEY;
+    static readonly EXPIRY_MONTHS = 13;
+    /**
+     * Save consent record to localStorage
+     */
+    save(consent: ConsentRecord): void;
+    /**
+     * Load consent record from localStorage
+     */
+    load(): ConsentRecord | null;
+    /**
+     * Clear consent record from localStorage
+     */
+    clear(): void;
+    /**
+     * Check if consent record has expired
+     */
+    isExpired(consent: ConsentRecord): boolean;
+    /**
+     * Validate consent record schema
+     */
+    private validateSchema;
+    /**
+     * Migrate old consent format to new format
+     * Returns null if migration fails
+     */
+    private migrate;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * CookieCraft
+ * Lightweight GDPR-compliant cookie consent library
+ */
+export { CookieConsent } from './core/CookieConsent';
+export type { ConsentConfig, ConsentCategories, CategoryConfig, ConsentRecord, Translation, GTMConsent, ConsentEvent, } from './types';

package/dist/types/integrations/DataLayerManager.d.ts

@@ -0,0 +1,21 @@
+/**
+ * DataLayerManager - Manages Google Tag Manager dataLayer communication
+ * Implements Google Consent Mode v2 correctly via gtag() API
+ */
+export declare class DataLayerManager {
+    /**
+     * Initialize gtag function if not already present
+     * This must be called before GTM loads for consent defaults to work
+     */
+    private ensureGtag;
+    /**
+     * Push consent command via gtag (correct format for Google Consent Mode v2)
+     * Usage: pushConsent('default', {...}) or pushConsent('update', {...})
+     */
+    pushConsent(action: string, params: Record<string, string | number>): void;
+    /**
+     * Push a 'set' command via gtag for advanced features
+     * Usage: pushSet('url_passthrough', true) or pushSet('ads_data_redaction', true)
+     */
+    pushSet(key: string, value: boolean | string | number): void;
+}

package/dist/types/integrations/GTMConsentMode.d.ts

@@ -0,0 +1,29 @@
+/**
+ * GTMConsentMode - Full integration with Google Consent Mode v2
+ *
+ * Implements all required signals:
+ * - ad_storage, ad_user_data, ad_personalization, analytics_storage (core GCM v2)
+ * - functionality_storage, personalization_storage, security_storage (non-core)
+ * - wait_for_update, url_passthrough, ads_data_redaction (advanced features)
+ */
+import { ConsentCategories, ConsentConfig } from '../types';
+import { DataLayerManager } from './DataLayerManager';
+export declare class GTMConsentMode {
+    private dataLayerManager;
+    private config;
+    constructor(dataLayerManager: DataLayerManager, config: ConsentConfig);
+    /**
+     * Set default consent state (MUST be called BEFORE GTM loads)
+     * All non-essential consent types default to 'denied' per GDPR
+     */
+    setDefaultConsent(): void;
+    /**
+     * Update consent state based on user choices
+     * Called both on new consent and on page load for returning visitors
+     */
+    updateConsent(categories: ConsentCategories): void;
+    /**
+     * Map consent categories to GTM Consent Mode v2 format
+     */
+    private mapCategoriesToGTM;
+}

package/dist/types/types/index.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Type definitions for CookieCraft
+ */
+export interface ConsentCategories {
+    necessary: boolean;
+    analytics: boolean;
+    marketing: boolean;
+    preferences?: boolean;
+}
+export interface CategoryConfig {
+    enabled: boolean;
+    readOnly: boolean;
+    label: string;
+    description: string;
+}
+export interface Translation {
+    title?: string;
+    description?: string;
+    acceptAll?: string;
+    rejectAll?: string;
+    essentialsOnly?: string;
+    customize?: string;
+    savePreferences?: string;
+    necessary?: string;
+    analytics?: string;
+    marketing?: string;
+    preferences?: string;
+    cookieSettings?: string;
+    cookies?: string;
+    privacyPolicyUrl?: string;
+    privacyPolicyLabel?: string;
+    preferencesTitle?: string;
+}
+export interface ConsentConfig {
+    mode: 'opt-in' | 'opt-out';
+    autoShow: boolean;
+    revision: number;
+    categories: {
+        necessary: CategoryConfig;
+        analytics: CategoryConfig;
+        marketing: CategoryConfig;
+        preferences?: CategoryConfig;
+    };
+    theme?: 'light' | 'dark' | 'auto';
+    position?: 'bottom' | 'top' | 'center' | 'bottom-left' | 'bottom-right';
+    layout?: 'bar' | 'box' | 'floating';
+    primaryColor?: string;
+    backdropBlur?: boolean;
+    animationStyle?: 'smooth' | 'minimal';
+    preferencesPosition?: 'center' | 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
+    showWidget?: boolean;
+    widgetPosition?: 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
+    widgetStyle?: 'compact' | 'full';
+    language?: string;
+    translations?: Translation;
+    gtmConsentMode?: boolean;
+    gtmWaitForUpdate?: number;
+    gtmUrlPassthrough?: boolean;
+    gtmAdsDataRedaction?: boolean;
+    cookieDomain?: string;
+    disablePageInteraction?: boolean;
+    onAccept?: (categories: ConsentCategories) => void;
+    onReject?: () => void;
+    onChange?: (categories: ConsentCategories) => void;
+}
+export interface ConsentRecord {
+    version: number;
+    timestamp: string;
+    categories: ConsentCategories;
+    userAgent: string;
+    expiresAt: string;
+}
+export interface GTMConsent {
+    [key: string]: 'granted' | 'denied';
+    ad_storage: 'granted' | 'denied';
+    ad_user_data: 'granted' | 'denied';
+    ad_personalization: 'granted' | 'denied';
+    analytics_storage: 'granted' | 'denied';
+    functionality_storage: 'granted' | 'denied';
+    personalization_storage: 'granted' | 'denied';
+    security_storage: 'granted' | 'denied';
+}
+export type ConsentEvent = 'consent:init' | 'consent:show' | 'consent:hide' | 'consent:accept' | 'consent:reject' | 'consent:update' | 'consent:load' | 'consent:expire' | 'preferences:show' | 'preferences:hide' | 'script:activated';
+declare global {
+    interface Window {
+        dataLayer?: any[];
+        gtag?: (...args: any[]) => void;
+        cookieConsent?: any;
+    }
+}

package/dist/types/ui/Banner.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Banner - Cookie consent banner component
+ */
+import { ConsentConfig } from '../types';
+import { EventEmitter } from '../core/EventEmitter';
+export declare class Banner {
+    private config;
+    private element;
+    private eventEmitter;
+    constructor(config: ConsentConfig, eventEmitter: EventEmitter);
+    /**
+     * Show the banner
+     */
+    show(): void;
+    /**
+     * Hide the banner
+     */
+    hide(): void;
+    /**
+     * Destroy the banner
+     */
+    destroy(): void;
+    /**
+     * Create DOM structure for banner
+     */
+    private createDOM;
+    /**
+     * Attach event listeners
+     */
+    private attachListeners;
+    /**
+     * Handle accept all action
+     */
+    private handleAcceptAll;
+    /**
+     * Handle reject all action
+     */
+    private handleRejectAll;
+    /**
+     * Handle customize action
+     */
+    private handleCustomize;
+    /**
+     * Generate description HTML with privacy policy link
+     */
+    private getDescriptionHTML;
+}

package/dist/types/ui/FloatingWidget.d.ts

@@ -0,0 +1,41 @@
+/**
+ * FloatingWidget - Permanent cookie settings button
+ * Stays visible at all times for easy access to preferences
+ */
+import { ConsentConfig } from '../types';
+import { EventEmitter } from '../core/EventEmitter';
+export declare class FloatingWidget {
+    private config;
+    private element;
+    private eventEmitter;
+    private isVisible;
+    constructor(config: ConsentConfig, eventEmitter: EventEmitter);
+    /**
+     * Show the floating widget
+     */
+    show(): void;
+    /**
+     * Hide the floating widget
+     */
+    hide(): void;
+    /**
+     * Destroy the widget
+     */
+    destroy(): void;
+    /**
+     * Check if widget is visible
+     */
+    getIsVisible(): boolean;
+    /**
+     * Create DOM structure for floating widget
+     */
+    private createDOM;
+    /**
+     * Attach event listeners
+     */
+    private attachListeners;
+    /**
+     * Handle widget click
+     */
+    private handleClick;
+}

package/dist/types/ui/PreferenceCenter.d.ts

@@ -0,0 +1,52 @@
+/**
+ * PreferenceCenter - Modal for granular cookie preferences
+ */
+import { ConsentConfig, ConsentCategories } from '../types';
+import { EventEmitter } from '../core/EventEmitter';
+export declare class PreferenceCenter {
+    private config;
+    private element;
+    private eventEmitter;
+    private currentConsent;
+    constructor(config: ConsentConfig, eventEmitter: EventEmitter, currentConsent: ConsentCategories);
+    /**
+     * Show the preference center
+     */
+    show(): void;
+    /**
+     * Hide the preference center
+     */
+    hide(): void;
+    /**
+     * Destroy the preference center
+     */
+    destroy(): void;
+    /**
+     * Create DOM structure for preference center
+     */
+    private createDOM;
+    /**
+     * Render category toggles
+     */
+    private renderCategories;
+    /**
+     * Attach event listeners
+     */
+    private attachListeners;
+    /**
+     * Handle save preferences
+     */
+    private handleSave;
+    /**
+     * Handle reject all
+     */
+    private handleRejectAll;
+    /**
+     * Trap focus within modal
+     */
+    private trapFocus;
+    /**
+     * Adjust color brightness for hover effect
+     */
+    private adjustColorBrightness;
+}

package/dist/types/utils/cookies.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cookie utilities for clearing non-essential cookies on rejection/withdrawal
+ */
+/**
+ * Clear cookies matching patterns for denied categories
+ */
+export declare function clearCookiesForCategory(category: string): void;
+/**
+ * Clear all non-essential cookies based on consent categories
+ */
+export declare function clearDeniedCookies(categories: Record<string, boolean>): void;

package/dist/types/utils/sanitize.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Sanitization utilities to prevent XSS in HTML templates
+ */
+/**
+ * Escape HTML entities in a string to prevent XSS
+ */
+export declare function escapeHtml(str: string): string;
+/**
+ * Sanitize a URL - only allow http(s) and relative URLs
+ */
+export declare function sanitizeUrl(url: string): string;
+/**
+ * Sanitize a CSS color value - only allow valid hex, rgb, hsl, named colors
+ */
+export declare function sanitizeColor(color: string): string;
+/**
+ * Sanitize a CSS property value to prevent injection
+ */
+export declare function sanitizeCssValue(value: string): string;

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "cookiecraft",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Lightweight GDPR-compliant cookie consent library for any website",
+  "main": "dist/cookiecraft.js",
+  "module": "dist/cookiecraft.esm.js",
+  "types": "dist/types/index.d.ts",
+  "jsdelivr": "dist/cookiecraft.min.js",
+  "unpkg": "dist/cookiecraft.min.js",
+  "files": [
+    "dist",
+    "README.md",
+    "WEBFLOW_GUIDE.md"
+  ],
+  "scripts": {
+    "dev": "rollup -c -w",
+    "build": "rollup -c && npm run size",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:a11y": "jest --testMatch='**/accessibility/**/*.test.ts'",
+    "lint": "eslint src/**/*.ts",
+    "type-check": "tsc --noEmit",
+    "size": "size-limit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cookie",
+    "consent",
+    "gdpr",
+    "rgpd",
+    "privacy",
+    "compliance",
+    "eprivacy",
+    "gtm",
+    "google-consent-mode",
+    "typescript",
+    "vanilla-js",
+    "cookie-banner",
+    "consent-management",
+    "webflow",
+    "wordpress",
+    "shopify"
+  ],
+  "author": "Fawsy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Fz3dev/cookiecraft"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@size-limit/preset-small-lib": "^11.0.2",
+    "@types/jest": "^29.5.12",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
+    "@typescript-eslint/parser": "^7.1.0",
+    "autoprefixer": "^10.4.18",
+    "cssnano": "^6.1.0",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "jest-axe": "^8.0.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "postcss": "^8.4.35",
+    "rollup": "^4.13.0",
+    "rollup-plugin-postcss": "^4.0.2",
+    "rollup-plugin-visualizer": "^5.12.0",
+    "size-limit": "^11.0.2",
+    "ts-jest": "^29.1.2",
+    "tslib": "^2.8.1",
+    "typescript": "^5.4.2"
+  },
+  "size-limit": [
+    {
+      "path": "dist/cookiecraft.min.js",
+      "limit": "12 KB"
+    },
+    {
+      "path": "dist/cookiecraft.css",
+      "limit": "3 KB"
+    }
+  ]
+}