@consentify/core 1.0.0 → 2.0.0

package/dist/index.js

@@ -15,11 +15,8 @@ function fnv1a(str) {
     return ('00000000' + h.toString(16)).slice(-8);
 }
 function hashPolicy(categories, identifier) {
-    // Deterministic identity for the policy. If you provide `identifier`, it is folded into the hash,
-    // but consider using `identifier` itself as the canonical version key for clarity.
     return fnv1a(stableStringify({ categories: [...categories].sort(), identifier: identifier ?? null }));
 }
-// --- Internals ---
 const DEFAULT_COOKIE = 'consentify';
 const enc = (o) => encodeURIComponent(JSON.stringify(o));
 const dec = (s) => { try {
@@ -29,6 +26,28 @@ catch {
     return null;
 } };
 const toISO = () => new Date().toISOString();
+function isValidSnapshot(s) {
+    if (typeof s !== 'object' || s === null ||
+        typeof s.policy !== 'string' || s.policy === '' ||
+        typeof s.givenAt !== 'string' ||
+        typeof s.choices !== 'object' || s.choices === null)
+        return false;
+    if (isNaN(new Date(s.givenAt).getTime()))
+        return false;
+    for (const v of Object.values(s.choices)) {
+        if (typeof v !== 'boolean')
+            return false;
+    }
+    return true;
+}
+function buildSetCookieHeader(name, value, opt) {
+    let h = `${name}=${value}; Path=${opt.path}; Max-Age=${opt.maxAgeSec}; SameSite=${opt.sameSite}`;
+    if (opt.domain)
+        h += `; Domain=${opt.domain}`;
+    if (opt.secure)
+        h += `; Secure`;
+    return h;
+}
 function readCookie(name, cookieStr) {
     const src = cookieStr ?? (typeof document !== 'undefined' ? document.cookie : '');
     if (!src)
@@ -39,14 +58,8 @@ function readCookie(name, cookieStr) {
 function writeCookie(name, value, opt) {
     if (typeof document === 'undefined')
         return;
-    let c = `${name}=${value}; Path=${opt.path}; Max-Age=${opt.maxAgeSec}; SameSite=${opt.sameSite}`;
-    if (opt.domain)
-        c += `; Domain=${opt.domain}`;
-    if (opt.secure)
-        c += `; Secure`;
-    document.cookie = c;
+    document.cookie = buildSetCookieHeader(name, value, opt);
 }
-// --- Unified Factory (single entry point) ---
 export function createConsentify(init) {
     const policyHash = init.policy.identifier ?? hashPolicy(init.policy.categories);
     const cookieName = init.cookie?.name ?? DEFAULT_COOKIE;
@@ -59,6 +72,16 @@ export function createConsentify(init) {
         domain: init.cookie?.domain,
     };
     const storageOrder = (init.storage && init.storage.length > 0) ? init.storage : ['cookie'];
+    const consentMaxAgeDays = init.consentMaxAgeDays;
+    const isExpired = (givenAt) => {
+        if (!consentMaxAgeDays)
+            return false;
+        const givenTime = new Date(givenAt).getTime();
+        if (isNaN(givenTime))
+            return true;
+        const maxAgeMs = consentMaxAgeDays * 24 * 60 * 60 * 1000;
+        return Date.now() - givenTime > maxAgeMs;
+    };
     const allowed = new Set(['necessary', ...init.policy.categories]);
     const normalize = (choices) => {
         const base = { necessary: true };
@@ -73,7 +96,6 @@ export function createConsentify(init) {
         base.necessary = true;
         return base;
     };
-    // --- client-side storage helpers ---
     const isBrowser = () => typeof window !== 'undefined' && typeof document !== 'undefined';
     const canLocal = () => { try {
         return isBrowser() && !!window.localStorage;
@@ -84,7 +106,13 @@ export function createConsentify(init) {
     const readFromStore = (kind) => {
         switch (kind) {
             case 'cookie': return readCookie(cookieName);
-            case 'localStorage': return canLocal() ? window.localStorage.getItem(cookieName) : null;
+            case 'localStorage': try {
+                return canLocal() ? window.localStorage.getItem(cookieName) : null;
+            }
+            catch (err) {
+                console.warn('[consentify] localStorage read failed:', err);
+                return null;
+            }
             default: return null;
         }
     };
@@ -94,20 +122,31 @@ export function createConsentify(init) {
                 writeCookie(cookieName, value, cookieCfg);
                 break;
             case 'localStorage':
-                if (canLocal())
-                    window.localStorage.setItem(cookieName, value);
+                try {
+                    if (canLocal())
+                        window.localStorage.setItem(cookieName, value);
+                }
+                catch (err) {
+                    console.warn('[consentify] localStorage write failed:', err);
+                }
                 break;
         }
     };
+    const clearCookieHeader = () => buildSetCookieHeader(cookieName, '', { ...cookieCfg, maxAgeSec: 0 });
     const clearStore = (kind) => {
         switch (kind) {
             case 'cookie':
                 if (isBrowser())
-                    document.cookie = `${cookieName}=; Path=${cookieCfg.path}; Max-Age=0; SameSite=${cookieCfg.sameSite}${cookieCfg.domain ? `; Domain=${cookieCfg.domain}` : ''}${cookieCfg.secure ? '; Secure' : ''}`;
+                    document.cookie = clearCookieHeader();
                 break;
             case 'localStorage':
-                if (canLocal())
-                    window.localStorage.removeItem(cookieName);
+                try {
+                    if (canLocal())
+                        window.localStorage.removeItem(cookieName);
+                }
+                catch (err) {
+                    console.warn('[consentify] localStorage clear failed:', err);
+                }
                 break;
         }
     };
@@ -134,14 +173,15 @@ export function createConsentify(init) {
         if (primary !== 'cookie' && storageOrder.includes('cookie'))
             writeToStore('cookie', value);
     };
-    // --- read helpers ---
     const readClient = () => {
         const raw = readClientRaw();
         const s = raw ? dec(raw) : null;
-        if (!s)
+        if (!s || !isValidSnapshot(s))
             return null;
         if (s.policy !== policyHash)
             return null;
+        if (isExpired(s.givenAt))
+            return null;
         return s;
     };
     const writeClientIfChanged = (next) => {
@@ -151,23 +191,16 @@ export function createConsentify(init) {
             writeClientRaw(enc(next));
         return !same;
     };
-    function buildSetCookieHeader(name, value, opt) {
-        let header = `${name}=${value}; Path=${opt.path}; Max-Age=${opt.maxAgeSec}; SameSite=${opt.sameSite}`;
-        if (opt.domain)
-            header += `; Domain=${opt.domain}`;
-        if (opt.secure)
-            header += `; Secure`;
-        return header;
-    }
-    // ---- server API
     const server = {
         get: (cookieHeader) => {
             const raw = cookieHeader ? readCookie(cookieName, cookieHeader) : null;
             const s = raw ? dec(raw) : null;
-            if (!s)
+            if (!s || !isValidSnapshot(s))
                 return { decision: 'unset' };
             if (s.policy !== policyHash)
                 return { decision: 'unset' };
+            if (isExpired(s.givenAt))
+                return { decision: 'unset' };
             return { decision: 'decided', snapshot: s };
         },
         set: (choices, currentCookieHeader) => {
@@ -180,16 +213,8 @@ export function createConsentify(init) {
             };
             return buildSetCookieHeader(cookieName, enc(snapshot), cookieCfg);
         },
-        clear: () => {
-            let h = `${cookieName}=; Path=${cookieCfg.path}; Max-Age=0; SameSite=${cookieCfg.sameSite}`;
-            if (cookieCfg.domain)
-                h += `; Domain=${cookieCfg.domain}`;
-            if (cookieCfg.secure)
-                h += `; Secure`;
-            return h;
-        }
+        clear: () => clearCookieHeader()
     };
-    // ========== NEW: Subscribe pattern for React ==========
     const listeners = new Set();
     const unsetState = { decision: 'unset' };
     let cachedState = unsetState;
@@ -203,14 +228,19 @@ export function createConsentify(init) {
         }
     };
     const notifyListeners = () => {
-        listeners.forEach(cb => cb());
+        listeners.forEach(cb => {
+            try {
+                cb();
+            }
+            catch (err) {
+                console.error('[consentify] Listener callback threw:', err);
+            }
+        });
     };
-    // Init cache on browser
     if (isBrowser()) {
         syncState();
     }
     function clientGet(category) {
-        // Return cached state for React compatibility
         if (typeof category === 'undefined')
             return cachedState;
         if (category === 'necessary')
@@ -222,8 +252,8 @@ export function createConsentify(init) {
     const client = {
         get: clientGet,
         set: (choices) => {
-            const prev = client.get();
-            const base = prev.decision === 'decided' ? prev.snapshot.choices : normalize();
+            const fresh = readClient();
+            const base = fresh ? fresh.choices : normalize();
             const next = {
                 policy: policyHash,
                 givenAt: toISO(),
@@ -241,14 +271,47 @@ export function createConsentify(init) {
             syncState();
             notifyListeners();
         },
-        // NEW: Subscribe for React useSyncExternalStore
         subscribe: (callback) => {
             listeners.add(callback);
             return () => listeners.delete(callback);
         },
-        // NEW: Server snapshot for SSR (always unset)
         getServerSnapshot: () => unsetState,
+        guard: (category, onGrant, onRevoke) => {
+            let phase = 'waiting';
+            const check = () => clientGet(category) === true;
+            const tick = () => {
+                if (phase === 'waiting' && check()) {
+                    onGrant();
+                    phase = onRevoke ? 'granted' : 'done';
+                    if (phase === 'done')
+                        unsub();
+                }
+                else if (phase === 'granted' && !check()) {
+                    onRevoke();
+                    phase = 'done';
+                    unsub();
+                }
+            };
+            const unsub = client.subscribe(tick);
+            tick();
+            return () => { phase = 'done'; unsub(); };
+        },
     };
+    function flatGet(cookieHeader) {
+        return typeof cookieHeader === 'string'
+            ? server.get(cookieHeader)
+            : client.get();
+    }
+    function flatSet(choices, cookieHeader) {
+        if (typeof cookieHeader === 'string')
+            return server.set(choices, cookieHeader);
+        client.set(choices);
+    }
+    function flatClear(serverMode) {
+        if (typeof serverMode === 'string')
+            return server.clear();
+        client.clear();
+    }
     return {
         policy: {
             categories: init.policy.categories,
@@ -256,7 +319,74 @@ export function createConsentify(init) {
         },
         server,
         client,
+        get: flatGet,
+        isGranted: (category) => {
+            return clientGet(category);
+        },
+        set: flatSet,
+        clear: flatClear,
+        subscribe: client.subscribe,
+        getServerSnapshot: client.getServerSnapshot,
+        guard: client.guard,
     };
 }
-// Common predefined category names you can reuse in your policy.
 export const defaultCategories = ['preferences', 'analytics', 'marketing', 'functional', 'unclassified'];
+export const defaultConsentModeMapping = {
+    necessary: ['security_storage'],
+    analytics: ['analytics_storage'],
+    marketing: ['ad_storage', 'ad_user_data', 'ad_personalization'],
+    preferences: ['functionality_storage', 'personalization_storage'],
+};
+function safeGtag(...args) {
+    try {
+        window.gtag(...args);
+    }
+    catch (err) {
+        console.error('[consentify] gtag call failed:', err);
+    }
+}
+export function enableConsentMode(instance, options) {
+    if (typeof window === 'undefined')
+        return () => { };
+    window.dataLayer = window.dataLayer || [];
+    if (typeof window.gtag !== 'function') {
+        window.gtag = function gtag() {
+            window.dataLayer.push(arguments);
+        };
+    }
+    const resolve = () => {
+        const state = instance.get();
+        const result = {};
+        for (const [category, gTypes] of Object.entries(options.mapping)) {
+            if (!gTypes)
+                continue;
+            let granted = false;
+            if (category === 'necessary') {
+                granted = true;
+            }
+            else if (state.decision === 'decided') {
+                granted = !!state.snapshot.choices[category];
+            }
+            for (const gType of gTypes) {
+                result[gType] = granted ? 'granted' : 'denied';
+            }
+        }
+        return result;
+    };
+    const defaultPayload = { ...resolve() };
+    if (options.waitForUpdate != null) {
+        defaultPayload.wait_for_update = options.waitForUpdate;
+    }
+    safeGtag('consent', 'default', defaultPayload);
+    const state = instance.get();
+    if (state.decision === 'decided') {
+        safeGtag('consent', 'update', resolve());
+    }
+    const unsubscribe = instance.subscribe(() => {
+        const current = instance.get();
+        if (current.decision === 'decided') {
+            safeGtag('consent', 'update', resolve());
+        }
+    });
+    return unsubscribe;
+}

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};