@structured-world/vue-privacy 0.0.0-development

package/dist/core/types.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Consent categories that can be managed
+ */
+export interface ConsentCategories {
+    /** Analytics cookies (e.g., Google Analytics) */
+    analytics: boolean;
+    /** Marketing/advertising cookies */
+    marketing: boolean;
+    /** Functional cookies (preferences, etc.) */
+    functional: boolean;
+    /** Strictly necessary cookies (always true, cannot be disabled) */
+    necessary: true;
+}
+/**
+ * Google Consent Mode v2 signals
+ * @see https://developers.google.com/tag-platform/security/guides/consent
+ */
+export interface GoogleConsentSignals {
+    /** Controls Google Analytics cookies */
+    analytics_storage: "granted" | "denied";
+    /** Controls advertising cookies */
+    ad_storage: "granted" | "denied";
+    /** Controls whether user data can be sent to Google for ads */
+    ad_user_data: "granted" | "denied";
+    /** Controls personalized advertising */
+    ad_personalization: "granted" | "denied";
+}
+/**
+ * Stored consent state
+ */
+export interface StoredConsent {
+    /** Consent categories */
+    categories: Omit<ConsentCategories, "necessary">;
+    /** Timestamp when consent was given */
+    timestamp: number;
+    /** Version of the consent configuration */
+    version: string;
+}
+/**
+ * Geo-detection result
+ */
+export interface GeoDetectionResult {
+    /** Whether the user is in the EU */
+    isEU: boolean;
+    /** Country code (ISO 3166-1 alpha-2) */
+    countryCode?: string;
+    /** Detection method used */
+    method: "cloudflare" | "api" | "fallback" | "manual";
+}
+/**
+ * Geo-detection provider interface
+ */
+export interface GeoDetector {
+    /** Detect if user is in the EU */
+    detect(): Promise<GeoDetectionResult>;
+}
+/**
+ * Banner UI configuration
+ */
+export interface BannerConfig {
+    /** Banner title */
+    title: string;
+    /** Main message text */
+    message: string;
+    /** Accept all button text */
+    acceptAll: string;
+    /** Reject all button text */
+    rejectAll: string;
+    /** Customize preferences button text */
+    customize?: string;
+    /** Privacy policy link */
+    privacyLink?: string;
+    /** Privacy policy link text */
+    privacyLinkText?: string;
+}
+/**
+ * Main plugin configuration
+ */
+export interface ConsentConfig {
+    /** Google Analytics measurement ID (G-XXXXXXXXXX) */
+    gaId?: string;
+    /** Consent categories to manage */
+    categories?: Partial<Omit<ConsentCategories, "necessary">>;
+    /** Banner UI configuration */
+    banner?: Partial<BannerConfig>;
+    /** Cookie configuration */
+    cookie?: {
+        /** Cookie name for storing consent */
+        name?: string;
+        /** Cookie expiry in days */
+        expiry?: number;
+        /** Cookie domain */
+        domain?: string;
+        /** Cookie path */
+        path?: string;
+    };
+    /**
+     * EU detection mode:
+     * - 'auto': Try Cloudflare header, fallback to IP API
+     * - 'cloudflare': Only use Cloudflare header
+     * - 'api': Only use IP API
+     * - 'always': Always show banner (treat all as EU)
+     * - 'never': Never show banner (treat all as non-EU)
+     */
+    euDetection?: "auto" | "cloudflare" | "api" | "always" | "never";
+    /** Custom geo-detection provider */
+    geoDetector?: GeoDetector;
+    /** Consent version (changing this resets consent for all users) */
+    version?: string;
+    /** Callback when consent changes */
+    onConsentChange?: (consent: StoredConsent) => void;
+    /** Callback when banner is shown */
+    onBannerShow?: () => void;
+    /** Callback when banner is hidden */
+    onBannerHide?: () => void;
+}
+/**
+ * Required cookie configuration (with defaults)
+ */
+export interface CookieConfigDefaults {
+    name: string;
+    expiry: number;
+    path: string;
+    domain?: string;
+}
+/**
+ * Required banner configuration (with defaults)
+ */
+export interface BannerConfigDefaults {
+    title: string;
+    message: string;
+    acceptAll: string;
+    rejectAll: string;
+    customize: string;
+    privacyLink: string;
+    privacyLinkText: string;
+}
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_CONFIG: {
+    categories: Omit<ConsentCategories, "necessary">;
+    banner: BannerConfigDefaults;
+    cookie: CookieConfigDefaults;
+    euDetection: "auto" | "cloudflare" | "api" | "always" | "never";
+    version: string;
+};

package/dist/geo/index.d.ts

@@ -0,0 +1,45 @@
+import type { GeoDetector, GeoDetectionResult } from "../core/types";
+/**
+ * Cloudflare geo-detection using headers
+ *
+ * Requires Cloudflare Worker or Transform Rule to set X-Is-EU-Country header
+ */
+export declare class CloudflareGeoDetector implements GeoDetector {
+    private headerName;
+    constructor(headerName?: string);
+    detect(): Promise<GeoDetectionResult>;
+}
+/**
+ * IP API geo-detection using ipapi.co
+ *
+ * Free tier: 1000 requests/day
+ * No API key required for basic usage
+ */
+export declare class IPAPIGeoDetector implements GeoDetector {
+    private apiUrl;
+    constructor(apiUrl?: string);
+    detect(): Promise<GeoDetectionResult>;
+}
+/**
+ * Fallback detector that uses browser timezone heuristics
+ *
+ * Not 100% accurate but works without external requests
+ */
+export declare class TimezoneGeoDetector implements GeoDetector {
+    private euTimezones;
+    detect(): Promise<GeoDetectionResult>;
+}
+/**
+ * Auto-detection: tries Cloudflare first, then IP API, then timezone fallback
+ */
+export declare class AutoGeoDetector implements GeoDetector {
+    private cloudflare;
+    private ipapi;
+    private timezone;
+    constructor();
+    detect(): Promise<GeoDetectionResult>;
+}
+/**
+ * Create a geo-detector based on mode
+ */
+export declare function createGeoDetector(mode: "auto" | "cloudflare" | "api" | "always" | "never"): GeoDetector;

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @structured-world/vue-privacy
+ *
+ * GDPR-compliant cookie consent with Google Consent Mode v2 support
+ *
+ * @example
+ * ```ts
+ * import { createConsentManager } from '@structured-world/vue-privacy';
+ *
+ * const manager = createConsentManager({
+ *   gaId: 'G-XXXXXXXXXX',
+ *   euDetection: 'auto',
+ * });
+ *
+ * await manager.init();
+ * ```
+ */
+export { ConsentManager, createConsentManager } from "./core/consent-manager";
+export { getStoredConsent, storeConsent, clearConsent } from "./core/storage";
+export { initGtag, setConsentDefaults, updateConsent, loadGtagScript, initGoogleAnalytics, categoriesToGoogleSignals, } from "./core/gtag";
+export { DEFAULT_CONFIG } from "./core/types";
+export { CloudflareGeoDetector, IPAPIGeoDetector, TimezoneGeoDetector, AutoGeoDetector, createGeoDetector, } from "./geo/index";
+export type { ConsentConfig, ConsentCategories, StoredConsent, GoogleConsentSignals, GeoDetector, GeoDetectionResult, BannerConfig, } from "./core/types";

package/dist/index.js

@@ -0,0 +1,496 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const DEFAULT_CONFIG = {
+  categories: {
+    analytics: false,
+    marketing: false,
+    functional: true
+  },
+  banner: {
+    title: "Cookie Consent",
+    message: "We use cookies to improve your experience. You can accept all cookies or customize your preferences.",
+    acceptAll: "Accept All",
+    rejectAll: "Reject All",
+    customize: "Customize",
+    privacyLink: "/privacy",
+    privacyLinkText: "Privacy Policy"
+  },
+  cookie: {
+    name: "consent_preferences",
+    expiry: 365,
+    path: "/"
+  },
+  euDetection: "auto",
+  version: "1.0"
+};
+function getCookie(name) {
+  if (typeof document === "undefined") return null;
+  const cookies = document.cookie.split(";");
+  for (const cookie of cookies) {
+    const [key, value] = cookie.trim().split("=");
+    if (key === name) {
+      return decodeURIComponent(value);
+    }
+  }
+  return null;
+}
+function setCookie(name, value, options = {}) {
+  if (typeof document === "undefined") return;
+  const { expiry = 365, domain, path = "/", sameSite = "Lax", secure = false } = options;
+  let cookieString = `${name}=${encodeURIComponent(value)}`;
+  if (expiry) {
+    const date = /* @__PURE__ */ new Date();
+    date.setTime(date.getTime() + expiry * 24 * 60 * 60 * 1e3);
+    cookieString += `; expires=${date.toUTCString()}`;
+  }
+  if (domain) {
+    cookieString += `; domain=${domain}`;
+  }
+  cookieString += `; path=${path}`;
+  cookieString += `; SameSite=${sameSite}`;
+  if (secure || sameSite === "None") {
+    cookieString += "; Secure";
+  }
+  document.cookie = cookieString;
+}
+function deleteCookie(name, path = "/") {
+  if (typeof document === "undefined") return;
+  document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=${path}`;
+}
+function getStoredConsent(config = {}) {
+  var _a;
+  const cookieName = ((_a = config.cookie) == null ? void 0 : _a.name) ?? DEFAULT_CONFIG.cookie.name;
+  const version = config.version ?? DEFAULT_CONFIG.version;
+  const raw = getCookie(cookieName);
+  if (!raw) return null;
+  try {
+    const stored = JSON.parse(raw);
+    if (stored.version !== version) {
+      return null;
+    }
+    return stored;
+  } catch {
+    return null;
+  }
+}
+function storeConsent(consent, config = {}) {
+  const cookieConfig = {
+    ...DEFAULT_CONFIG.cookie,
+    ...config.cookie
+  };
+  const version = config.version ?? DEFAULT_CONFIG.version;
+  const stored = {
+    categories: consent.categories,
+    timestamp: Date.now(),
+    version
+  };
+  setCookie(cookieConfig.name, JSON.stringify(stored), {
+    expiry: cookieConfig.expiry,
+    domain: cookieConfig.domain,
+    path: cookieConfig.path
+  });
+}
+function clearConsent(config = {}) {
+  var _a, _b;
+  const cookieName = ((_a = config.cookie) == null ? void 0 : _a.name) ?? DEFAULT_CONFIG.cookie.name;
+  const path = ((_b = config.cookie) == null ? void 0 : _b.path) ?? DEFAULT_CONFIG.cookie.path;
+  deleteCookie(cookieName, path);
+}
+function initGtag() {
+  if (typeof window === "undefined") return;
+  window.dataLayer = window.dataLayer || [];
+  if (typeof window.gtag !== "function") {
+    window.gtag = function gtag(...args) {
+      window.dataLayer.push(args);
+    };
+  }
+}
+function categoriesToGoogleSignals(categories) {
+  return {
+    analytics_storage: categories.analytics ? "granted" : "denied",
+    ad_storage: categories.marketing ? "granted" : "denied",
+    ad_user_data: categories.marketing ? "granted" : "denied",
+    ad_personalization: categories.marketing ? "granted" : "denied"
+  };
+}
+function setConsentDefaults(signals, waitForUpdate = 500) {
+  initGtag();
+  if (typeof window === "undefined") return;
+  window.gtag("consent", "default", {
+    ...signals,
+    wait_for_update: waitForUpdate
+  });
+}
+function updateConsent(signals) {
+  initGtag();
+  if (typeof window === "undefined") return;
+  window.gtag("consent", "update", signals);
+}
+function loadGtagScript(gaId) {
+  return new Promise((resolve, reject) => {
+    if (typeof document === "undefined") {
+      resolve();
+      return;
+    }
+    if (document.querySelector(
+      `script[src*="googletagmanager.com/gtag/js?id=${gaId}"]`
+    )) {
+      resolve();
+      return;
+    }
+    const script = document.createElement("script");
+    script.async = true;
+    script.src = `https://www.googletagmanager.com/gtag/js?id=${gaId}`;
+    script.onload = () => resolve();
+    script.onerror = () => reject(new Error(`Failed to load gtag.js for ${gaId}`));
+    document.head.appendChild(script);
+  });
+}
+async function initGoogleAnalytics(gaId, defaultDenied = true) {
+  initGtag();
+  if (defaultDenied) {
+    setConsentDefaults({
+      analytics_storage: "denied",
+      ad_storage: "denied",
+      ad_user_data: "denied",
+      ad_personalization: "denied"
+    });
+  } else {
+    setConsentDefaults({
+      analytics_storage: "granted",
+      ad_storage: "granted",
+      ad_user_data: "granted",
+      ad_personalization: "granted"
+    });
+  }
+  await loadGtagScript(gaId);
+  if (typeof window !== "undefined") {
+    window.gtag("js", /* @__PURE__ */ new Date());
+    window.gtag("config", gaId);
+  }
+}
+class CloudflareGeoDetector {
+  constructor(headerName = "X-Is-EU-Country") {
+    __publicField(this, "headerName");
+    this.headerName = headerName;
+  }
+  async detect() {
+    if (typeof document === "undefined") {
+      return { isEU: false, method: "cloudflare" };
+    }
+    try {
+      const response = await fetch(window.location.href, {
+        method: "HEAD",
+        cache: "no-store"
+      });
+      const isEUHeader = response.headers.get(this.headerName);
+      const countryCode = response.headers.get("CF-IPCountry") ?? void 0;
+      if (isEUHeader !== null) {
+        return {
+          isEU: isEUHeader.toLowerCase() === "true",
+          countryCode,
+          method: "cloudflare"
+        };
+      }
+      throw new Error("Cloudflare header not present");
+    } catch {
+      throw new Error("Cloudflare geo-detection failed");
+    }
+  }
+}
+class IPAPIGeoDetector {
+  constructor(apiUrl = "https://ipapi.co/json/") {
+    __publicField(this, "apiUrl");
+    this.apiUrl = apiUrl;
+  }
+  async detect() {
+    try {
+      const response = await fetch(this.apiUrl);
+      const data = await response.json();
+      return {
+        isEU: data.in_eu === true,
+        countryCode: data.country_code,
+        method: "api"
+      };
+    } catch {
+      throw new Error("IP API geo-detection failed");
+    }
+  }
+}
+class TimezoneGeoDetector {
+  constructor() {
+    // EU timezones (not exhaustive but covers most)
+    __publicField(this, "euTimezones", /* @__PURE__ */ new Set([
+      "Europe/Amsterdam",
+      "Europe/Andorra",
+      "Europe/Athens",
+      "Europe/Berlin",
+      "Europe/Bratislava",
+      "Europe/Brussels",
+      "Europe/Bucharest",
+      "Europe/Budapest",
+      "Europe/Copenhagen",
+      "Europe/Dublin",
+      "Europe/Helsinki",
+      "Europe/Lisbon",
+      "Europe/Ljubljana",
+      "Europe/Luxembourg",
+      "Europe/Madrid",
+      "Europe/Malta",
+      "Europe/Monaco",
+      "Europe/Oslo",
+      "Europe/Paris",
+      "Europe/Prague",
+      "Europe/Riga",
+      "Europe/Rome",
+      "Europe/San_Marino",
+      "Europe/Sarajevo",
+      "Europe/Skopje",
+      "Europe/Sofia",
+      "Europe/Stockholm",
+      "Europe/Tallinn",
+      "Europe/Tirane",
+      "Europe/Vaduz",
+      "Europe/Vatican",
+      "Europe/Vienna",
+      "Europe/Vilnius",
+      "Europe/Warsaw",
+      "Europe/Zagreb",
+      "Atlantic/Canary",
+      "Atlantic/Faroe",
+      "Atlantic/Madeira"
+    ]));
+  }
+  async detect() {
+    try {
+      const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      const isEU = this.euTimezones.has(timezone);
+      return {
+        isEU,
+        method: "fallback"
+      };
+    } catch {
+      return {
+        isEU: true,
+        method: "fallback"
+      };
+    }
+  }
+}
+class AutoGeoDetector {
+  constructor() {
+    __publicField(this, "cloudflare");
+    __publicField(this, "ipapi");
+    __publicField(this, "timezone");
+    this.cloudflare = new CloudflareGeoDetector();
+    this.ipapi = new IPAPIGeoDetector();
+    this.timezone = new TimezoneGeoDetector();
+  }
+  async detect() {
+    try {
+      return await this.cloudflare.detect();
+    } catch {
+    }
+    try {
+      return await this.ipapi.detect();
+    } catch {
+    }
+    return await this.timezone.detect();
+  }
+}
+function createGeoDetector(mode) {
+  switch (mode) {
+    case "cloudflare":
+      return new CloudflareGeoDetector();
+    case "api":
+      return new IPAPIGeoDetector();
+    case "always":
+      return {
+        detect: async () => ({ isEU: true, method: "manual" })
+      };
+    case "never":
+      return {
+        detect: async () => ({ isEU: false, method: "manual" })
+      };
+    case "auto":
+    default:
+      return new AutoGeoDetector();
+  }
+}
+class ConsentManager {
+  constructor(config = {}) {
+    __publicField(this, "config");
+    __publicField(this, "initialized", false);
+    __publicField(this, "isEU", null);
+    __publicField(this, "showBannerCallback", null);
+    __publicField(this, "hideBannerCallback", null);
+    this.config = {
+      ...config,
+      categories: { ...DEFAULT_CONFIG.categories, ...config.categories },
+      banner: { ...DEFAULT_CONFIG.banner, ...config.banner },
+      cookie: { ...DEFAULT_CONFIG.cookie, ...config.cookie }
+    };
+  }
+  /**
+   * Register callback to show banner
+   */
+  onShowBanner(callback) {
+    this.showBannerCallback = callback;
+  }
+  /**
+   * Register callback to hide banner
+   */
+  onHideBanner(callback) {
+    this.hideBannerCallback = callback;
+  }
+  /**
+   * Initialize consent manager
+   */
+  async init() {
+    var _a, _b, _c, _d;
+    if (this.initialized) return;
+    this.initialized = true;
+    const stored = getStoredConsent(this.config);
+    if (stored) {
+      await this.applyConsent(stored.categories);
+      return;
+    }
+    const detector = this.config.geoDetector ?? createGeoDetector(this.config.euDetection ?? "auto");
+    const geoResult = await detector.detect();
+    this.isEU = geoResult.isEU;
+    if (this.isEU) {
+      if (this.config.gaId) {
+        await initGoogleAnalytics(this.config.gaId, true);
+      }
+      (_a = this.showBannerCallback) == null ? void 0 : _a.call(this);
+      (_c = (_b = this.config).onBannerShow) == null ? void 0 : _c.call(_b);
+    } else {
+      const grantedCategories = {
+        analytics: true,
+        marketing: ((_d = this.config.categories) == null ? void 0 : _d.marketing) ?? false,
+        functional: true
+      };
+      await this.applyConsent(grantedCategories);
+      storeConsent({ categories: grantedCategories }, this.config);
+    }
+  }
+  /**
+   * Apply consent settings
+   */
+  async applyConsent(categories) {
+    var _a, _b;
+    if (this.config.gaId) {
+      await initGoogleAnalytics(this.config.gaId, !categories.analytics);
+    }
+    const signals = categoriesToGoogleSignals(categories);
+    updateConsent(signals);
+    (_b = (_a = this.config).onConsentChange) == null ? void 0 : _b.call(_a, {
+      categories,
+      timestamp: Date.now(),
+      version: this.config.version ?? DEFAULT_CONFIG.version
+    });
+  }
+  /**
+   * Accept all cookies
+   */
+  async acceptAll() {
+    var _a, _b, _c;
+    const categories = {
+      analytics: true,
+      marketing: true,
+      functional: true
+    };
+    await this.applyConsent(categories);
+    storeConsent({ categories }, this.config);
+    (_a = this.hideBannerCallback) == null ? void 0 : _a.call(this);
+    (_c = (_b = this.config).onBannerHide) == null ? void 0 : _c.call(_b);
+  }
+  /**
+   * Reject all non-essential cookies
+   */
+  async rejectAll() {
+    var _a, _b, _c;
+    const categories = {
+      analytics: false,
+      marketing: false,
+      functional: true
+      // Functional is always allowed
+    };
+    await this.applyConsent(categories);
+    storeConsent({ categories }, this.config);
+    (_a = this.hideBannerCallback) == null ? void 0 : _a.call(this);
+    (_c = (_b = this.config).onBannerHide) == null ? void 0 : _c.call(_b);
+  }
+  /**
+   * Save custom preferences
+   */
+  async savePreferences(categories) {
+    var _a, _b, _c;
+    const finalCategories = {
+      analytics: categories.analytics ?? false,
+      marketing: categories.marketing ?? false,
+      functional: categories.functional ?? true
+    };
+    await this.applyConsent(finalCategories);
+    storeConsent({ categories: finalCategories }, this.config);
+    (_a = this.hideBannerCallback) == null ? void 0 : _a.call(this);
+    (_c = (_b = this.config).onBannerHide) == null ? void 0 : _c.call(_b);
+  }
+  /**
+   * Get current consent state
+   */
+  getConsent() {
+    return getStoredConsent(this.config);
+  }
+  /**
+   * Check if user has made a consent choice
+   */
+  hasConsent() {
+    return getStoredConsent(this.config) !== null;
+  }
+  /**
+   * Reset consent (show banner again)
+   */
+  resetConsent() {
+    var _a, _b, _c;
+    clearConsent(this.config);
+    (_a = this.showBannerCallback) == null ? void 0 : _a.call(this);
+    (_c = (_b = this.config).onBannerShow) == null ? void 0 : _c.call(_b);
+  }
+  /**
+   * Check if user is detected as EU
+   */
+  isEUUser() {
+    return this.isEU;
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+}
+function createConsentManager(config = {}) {
+  return new ConsentManager(config);
+}
+export {
+  AutoGeoDetector,
+  CloudflareGeoDetector,
+  ConsentManager,
+  DEFAULT_CONFIG,
+  IPAPIGeoDetector,
+  TimezoneGeoDetector,
+  categoriesToGoogleSignals,
+  clearConsent,
+  createConsentManager,
+  createGeoDetector,
+  getStoredConsent,
+  initGoogleAnalytics,
+  initGtag,
+  loadGtagScript,
+  setConsentDefaults,
+  storeConsent,
+  updateConsent
+};
+//# sourceMappingURL=index.js.map