react-lgpd-consent 0.2.5 → 0.3.1

package/dist/chunk-VFAOBR3X.js

@@ -0,0 +1,1380 @@
+// src/components/PreferencesModal.tsx
+import Button2 from "@mui/material/Button";
+import Dialog from "@mui/material/Dialog";
+import DialogActions from "@mui/material/DialogActions";
+import DialogContent from "@mui/material/DialogContent";
+import DialogTitle from "@mui/material/DialogTitle";
+import FormControlLabel from "@mui/material/FormControlLabel";
+import FormGroup from "@mui/material/FormGroup";
+import Switch from "@mui/material/Switch";
+import Typography3 from "@mui/material/Typography";
+import { useEffect as useEffect4, useState as useState2 } from "react";
+
+// src/context/CategoriesContext.tsx
+import * as React2 from "react";
+
+// src/utils/developerGuidance.ts
+import * as React from "react";
+var DEFAULT_PROJECT_CATEGORIES = {
+  enabledCategories: ["analytics"]
+  // Só analytics além de necessary
+};
+function analyzeDeveloperConfiguration(config) {
+  const guidance = {
+    warnings: [],
+    suggestions: [],
+    activeCategoriesInfo: [],
+    usingDefaults: !config
+  };
+  const finalConfig = config || DEFAULT_PROJECT_CATEGORIES;
+  if (!config) {
+    guidance.warnings.push(
+      'LGPD-CONSENT: Nenhuma configura\xE7\xE3o de categorias especificada. Usando padr\xE3o: necessary + analytics. Para produ\xE7\xE3o, recomenda-se especificar explicitamente as categorias via prop "categories".'
+    );
+  }
+  guidance.activeCategoriesInfo.push({
+    id: "necessary",
+    name: "Cookies Necess\xE1rios",
+    description: "Essenciais para funcionamento b\xE1sico do site",
+    essential: true,
+    uiRequired: false
+    // Não precisa de toggle (sempre ativo)
+  });
+  const enabledCategories = finalConfig.enabledCategories || [];
+  const categoryNames = {
+    analytics: {
+      name: "Cookies Anal\xEDticos",
+      description: "Medem uso e performance do site"
+    },
+    functional: {
+      name: "Cookies Funcionais",
+      description: "Melhoram experi\xEAncia e funcionalidades"
+    },
+    marketing: {
+      name: "Cookies de Marketing",
+      description: "Publicidade direcionada e campanhas"
+    },
+    social: {
+      name: "Cookies de Redes Sociais",
+      description: "Integra\xE7\xE3o com plataformas sociais"
+    },
+    personalization: {
+      name: "Cookies de Personaliza\xE7\xE3o",
+      description: "Adaptam conte\xFAdo \xE0s prefer\xEAncias do usu\xE1rio"
+    }
+  };
+  enabledCategories.forEach((categoryId) => {
+    const categoryInfo = categoryNames[categoryId];
+    if (categoryInfo) {
+      guidance.activeCategoriesInfo.push({
+        id: categoryId,
+        name: categoryInfo.name,
+        description: categoryInfo.description,
+        essential: false,
+        uiRequired: true
+        // Precisa de toggle na UI
+      });
+    }
+  });
+  const totalToggleable = guidance.activeCategoriesInfo.filter(
+    (c) => c.uiRequired
+  ).length;
+  if (totalToggleable === 0) {
+    guidance.suggestions.push(
+      'Apenas cookies necess\xE1rios est\xE3o configurados. Para compliance completo LGPD, considere adicionar categorias como "analytics" ou "functional" conforme uso real.'
+    );
+  }
+  if (totalToggleable > 5) {
+    guidance.warnings.push(
+      `${totalToggleable} categorias opcionais detectadas. UI com muitas op\xE7\xF5es pode ' +
+      'prejudicar experi\xEAncia do usu\xE1rio. Considere agrupar categorias similares.`
+    );
+  }
+  return guidance;
+}
+function logDeveloperGuidance(guidance, disableGuidanceProp) {
+  if (disableGuidanceProp) {
+    return;
+  }
+  const isProduction = (
+    // 1. NODE_ENV de bundlers (Vite, webpack, etc.)
+    typeof globalThis.process !== "undefined" && globalThis.process.env?.NODE_ENV === "production" || // 2. Flag customizada para desabilitar logs
+    typeof globalThis !== "undefined" && globalThis.__LGPD_PRODUCTION__ === true || // 3. Flag de desenvolvimento desabilitada via window global (legado)
+    typeof window !== "undefined" && window.__LGPD_DISABLE_GUIDANCE__ === true
+  );
+  if (isProduction) return;
+  const PREFIX = "[\u{1F36A} LGPD-CONSENT]";
+  if (guidance.warnings.length > 0) {
+    console.group(`${PREFIX} \u26A0\uFE0F  Avisos de Configura\xE7\xE3o`);
+    guidance.warnings.forEach((warning) => console.warn(`${PREFIX} ${warning}`));
+    console.groupEnd();
+  }
+  if (guidance.suggestions.length > 0) {
+    console.group(`${PREFIX} \u{1F4A1} Sugest\xF5es`);
+    guidance.suggestions.forEach(
+      (suggestion) => console.info(`${PREFIX} ${suggestion}`)
+    );
+    console.groupEnd();
+  }
+  if (guidance.usingDefaults) {
+    console.warn(
+      // Changed from console.info to console.warn
+      `${PREFIX} \u{1F4CB} Usando configura\xE7\xE3o padr\xE3o. Para personalizar, use a prop "categories" no ConsentProvider.`
+    );
+  }
+  console.group(`${PREFIX} \u{1F527} Categorias Ativas (para UI customizada)`);
+  console.table(
+    guidance.activeCategoriesInfo.map((cat) => ({
+      ID: cat.id,
+      Nome: cat.name,
+      "Toggle UI?": cat.uiRequired ? "\u2705 SIM" : "\u274C N\xC3O (sempre ativo)",
+      "Essencial?": cat.essential ? "\u{1F512} SIM" : "\u2699\uFE0F N\xC3O"
+    }))
+  );
+  console.info(
+    `${PREFIX} \u2139\uFE0F  Use estes dados para criar componentes customizados adequados.`
+  );
+  console.groupEnd();
+}
+function useDeveloperGuidance(config, disableGuidanceProp) {
+  const guidance = analyzeDeveloperConfiguration(config);
+  const stringifiedConfig = React.useMemo(
+    () => JSON.stringify(config),
+    [config]
+  );
+  React.useEffect(() => {
+    if (disableGuidanceProp === true) {
+      return;
+    }
+    logDeveloperGuidance(guidance, disableGuidanceProp);
+  }, [guidance, stringifiedConfig, disableGuidanceProp]);
+  return guidance;
+}
+
+// src/context/CategoriesContext.tsx
+import { jsx } from "react/jsx-runtime";
+var CategoriesContext = React2.createContext(
+  null
+);
+function CategoriesProvider({
+  children,
+  config,
+  // NOVO: configuração completa
+  disableDeveloperGuidance
+}) {
+  const contextValue = React2.useMemo(() => {
+    const finalConfig = config || DEFAULT_PROJECT_CATEGORIES;
+    const guidance = analyzeDeveloperConfiguration(config);
+    const toggleableCategories = guidance.activeCategoriesInfo.filter(
+      (cat) => cat.uiRequired
+    );
+    return {
+      config: finalConfig,
+      guidance,
+      toggleableCategories,
+      allCategories: guidance.activeCategoriesInfo
+    };
+  }, [config]);
+  React2.useEffect(() => {
+    logDeveloperGuidance(contextValue.guidance, disableDeveloperGuidance);
+  }, [contextValue.guidance, disableDeveloperGuidance]);
+  return /* @__PURE__ */ jsx(CategoriesContext.Provider, { value: contextValue, children });
+}
+function useCategories() {
+  const context = React2.useContext(CategoriesContext);
+  if (!context) {
+    throw new Error(
+      "useCategories deve ser usado dentro de CategoriesProvider. Certifique-se de que o ConsentProvider est\xE1 envolvendo seu componente."
+    );
+  }
+  return context;
+}
+function useCategoryStatus(categoryId) {
+  const { allCategories } = useCategories();
+  const category = allCategories.find((cat) => cat.id === categoryId);
+  return {
+    isActive: !!category,
+    isEssential: category?.essential || false,
+    needsToggle: category?.uiRequired || false,
+    name: category?.name,
+    description: category?.description
+  };
+}
+
+// src/context/ConsentContext.tsx
+import * as React5 from "react";
+
+// src/utils/SafeThemeProvider.tsx
+import * as React3 from "react";
+import { ThemeProvider, createTheme } from "@mui/material/styles";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var createSafeTheme = (userTheme) => {
+  const baseTheme = createTheme({
+    palette: {
+      primary: {
+        main: "#1976d2",
+        dark: "#1565c0",
+        light: "#42a5f5",
+        contrastText: "#ffffff"
+      },
+      secondary: {
+        main: "#dc004e",
+        dark: "#9a0036",
+        light: "#e33371",
+        contrastText: "#ffffff"
+      },
+      background: {
+        default: "#fafafa",
+        paper: "#ffffff"
+      },
+      text: {
+        primary: "#333333",
+        secondary: "#666666"
+      }
+    },
+    transitions: {
+      duration: {
+        shortest: 150,
+        shorter: 200,
+        short: 250,
+        standard: 300,
+        complex: 375,
+        enteringScreen: 225,
+        leavingScreen: 195
+      }
+    }
+  });
+  if (!userTheme) {
+    return baseTheme;
+  }
+  return createTheme({
+    ...baseTheme,
+    ...userTheme,
+    palette: {
+      ...baseTheme.palette,
+      ...userTheme.palette,
+      primary: {
+        ...baseTheme.palette.primary,
+        ...userTheme.palette?.primary
+      },
+      secondary: {
+        ...baseTheme.palette.secondary,
+        ...userTheme.palette?.secondary
+      },
+      background: {
+        ...baseTheme.palette.background,
+        ...userTheme.palette?.background
+      },
+      text: {
+        ...baseTheme.palette.text,
+        ...userTheme.palette?.text
+      }
+    },
+    transitions: {
+      ...baseTheme.transitions,
+      ...userTheme.transitions,
+      duration: {
+        ...baseTheme.transitions.duration,
+        ...userTheme.transitions?.duration
+      }
+    }
+  });
+};
+function SafeThemeProvider({
+  theme,
+  children
+}) {
+  const safeTheme = React3.useMemo(() => createSafeTheme(theme), [theme]);
+  return /* @__PURE__ */ jsx2(ThemeProvider, { theme: safeTheme, children });
+}
+
+// src/utils/cookieUtils.ts
+import Cookies from "js-cookie";
+
+// src/utils/logger.ts
+var IS_DEVELOPMENT = typeof window !== "undefined" && window.__REACT_DEVTOOLS_GLOBAL_HOOK__ || typeof globalThis !== "undefined" && globalThis.process?.env?.NODE_ENV === "development";
+var LOG_PREFIX = "[react-lgpd-consent]";
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["ERROR"] = 0] = "ERROR";
+  LogLevel2[LogLevel2["WARN"] = 1] = "WARN";
+  LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
+  LogLevel2[LogLevel2["DEBUG"] = 3] = "DEBUG";
+  return LogLevel2;
+})(LogLevel || {});
+var ConsentLogger = class {
+  constructor() {
+    this.enabled = IS_DEVELOPMENT;
+    this.level = 2 /* INFO */;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  error(...args) {
+    if (this.enabled && this.level >= 0 /* ERROR */) {
+      console.error(LOG_PREFIX, "[ERROR]", ...args);
+    }
+  }
+  warn(...args) {
+    if (this.enabled && this.level >= 1 /* WARN */) {
+      console.warn(LOG_PREFIX, "[WARN]", ...args);
+    }
+  }
+  info(...args) {
+    if (this.enabled && this.level >= 2 /* INFO */) {
+      console.info(LOG_PREFIX, "[INFO]", ...args);
+    }
+  }
+  debug(...args) {
+    if (this.enabled && this.level >= 3 /* DEBUG */) {
+      console.debug(LOG_PREFIX, "[DEBUG]", ...args);
+    }
+  }
+  // Logs específicos para troubleshooting
+  themeCompatibility(themeInfo) {
+    this.debug("Theme compatibility check:", {
+      hasTheme: !!themeInfo,
+      hasPalette: !!themeInfo?.palette,
+      hasPrimary: !!themeInfo?.palette?.primary,
+      hasTransitions: !!themeInfo?.transitions,
+      hasDuration: !!themeInfo?.transitions?.duration
+    });
+  }
+  consentState(action, state) {
+    this.debug(`Consent state change [${action}]:`, {
+      consented: state.consented,
+      isModalOpen: state.isModalOpen,
+      preferencesCount: Object.keys(state.preferences || {}).length
+    });
+  }
+  cookieOperation(operation, cookieName, data) {
+    this.debug(`Cookie ${operation}:`, {
+      name: cookieName,
+      hasData: !!data,
+      dataSize: data ? JSON.stringify(data).length : 0
+    });
+  }
+  componentRender(componentName, props) {
+    this.debug(`Component render [${componentName}]:`, {
+      hasProps: !!props,
+      propsKeys: props ? Object.keys(props) : []
+    });
+  }
+  scriptIntegration(scriptName, action, success) {
+    this.info(
+      `Script ${action} [${scriptName}]:`,
+      success ? "SUCCESS" : "FAILED"
+    );
+  }
+  apiUsage(method, params) {
+    this.debug(`API call [${method}]:`, params);
+  }
+};
+var logger = new ConsentLogger();
+function setDebugLogging(enabled, level = 2 /* INFO */) {
+  logger.setEnabled(enabled);
+  logger.setLevel(level);
+  logger.info(
+    `Debug logging ${enabled ? "enabled" : "disabled"} with level ${LogLevel[level]}`
+  );
+}
+
+// src/utils/cookieUtils.ts
+var DEFAULT_COOKIE_OPTS = {
+  name: "cookieConsent",
+  maxAgeDays: 365,
+  sameSite: "Lax",
+  secure: typeof window !== "undefined" ? window.location.protocol === "https:" : false,
+  path: "/"
+};
+var COOKIE_SCHEMA_VERSION = "1.0";
+function readConsentCookie(name = DEFAULT_COOKIE_OPTS.name) {
+  logger.debug("Reading consent cookie", { name });
+  if (typeof document === "undefined") {
+    logger.debug("Cookie read skipped: server-side environment");
+    return null;
+  }
+  const raw = Cookies.get(name);
+  if (!raw) {
+    logger.debug("No consent cookie found");
+    return null;
+  }
+  try {
+    const data = JSON.parse(raw);
+    logger.cookieOperation("read", name, data);
+    if (!data.version) {
+      logger.debug("Migrating legacy cookie format");
+      return migrateLegacyCookie(data);
+    }
+    if (data.version !== COOKIE_SCHEMA_VERSION) {
+      logger.warn(
+        `Cookie version mismatch: ${data.version} != ${COOKIE_SCHEMA_VERSION}`
+      );
+      return null;
+    }
+    return data;
+  } catch (error) {
+    logger.error("Error parsing consent cookie", error);
+    return null;
+  }
+}
+function migrateLegacyCookie(legacyData) {
+  try {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      version: COOKIE_SCHEMA_VERSION,
+      consented: legacyData.consented || false,
+      preferences: legacyData.preferences || { necessary: true },
+      consentDate: now,
+      // Não temos o original, usar data atual
+      lastUpdate: now,
+      source: "banner",
+      // Assumir origem banner
+      isModalOpen: false
+      // Nunca persistir estado de UI
+    };
+  } catch {
+    return null;
+  }
+}
+function writeConsentCookie(state, config, opts, source = "banner") {
+  if (typeof document === "undefined") {
+    logger.debug("Cookie write skipped: server-side environment");
+    return;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const o = { ...DEFAULT_COOKIE_OPTS, ...opts };
+  const cookieData = {
+    version: COOKIE_SCHEMA_VERSION,
+    consented: state.consented,
+    preferences: state.preferences,
+    consentDate: state.consentDate || now,
+    // Preservar data original ou usar atual
+    lastUpdate: now,
+    source,
+    projectConfig: config
+    // isModalOpen NÃO é persistido (campo de UI apenas)
+  };
+  logger.cookieOperation("write", o.name, cookieData);
+  Cookies.set(o.name, JSON.stringify(cookieData), {
+    expires: o.maxAgeDays,
+    sameSite: o.sameSite,
+    secure: o.secure,
+    path: o.path
+  });
+  logger.info("Consent cookie saved", {
+    consented: cookieData.consented,
+    source: cookieData.source,
+    preferencesCount: Object.keys(cookieData.preferences).length
+  });
+}
+function removeConsentCookie(opts) {
+  if (typeof document === "undefined") {
+    logger.debug("Cookie removal skipped: server-side environment");
+    return;
+  }
+  const o = { ...DEFAULT_COOKIE_OPTS, ...opts };
+  logger.cookieOperation("delete", o.name);
+  Cookies.remove(o.name, { path: o.path });
+  logger.info("Consent cookie removed");
+}
+
+// src/utils/categoryUtils.ts
+function createProjectPreferences(config, defaultValue = false) {
+  const preferences = {
+    necessary: true
+    // Sempre presente e true (essencial)
+  };
+  const enabledCategories = config?.enabledCategories || [];
+  enabledCategories.forEach((category) => {
+    if (category !== "necessary") {
+      preferences[category] = defaultValue;
+    }
+  });
+  return preferences;
+}
+function validateProjectPreferences(preferences, config) {
+  const validPreferences = {
+    necessary: true
+    // Sempre válida
+  };
+  const enabledCategories = config?.enabledCategories || [];
+  enabledCategories.forEach((category) => {
+    if (category !== "necessary" && preferences[category] !== void 0) {
+      validPreferences[category] = preferences[category];
+    }
+  });
+  return validPreferences;
+}
+
+// src/utils/theme.ts
+import { createTheme as createTheme2 } from "@mui/material/styles";
+var defaultConsentTheme = createTheme2({
+  palette: {
+    primary: {
+      main: "#1976d2",
+      contrastText: "#ffffff"
+    },
+    secondary: {
+      main: "#dc004e",
+      contrastText: "#ffffff"
+    },
+    background: {
+      default: "#fafafa",
+      paper: "#ffffff"
+    },
+    text: {
+      primary: "#333333",
+      secondary: "#666666"
+    },
+    action: {
+      hover: "rgba(25, 118, 210, 0.04)"
+    }
+  },
+  typography: {
+    fontFamily: '"Roboto", "Helvetica", "Arial", sans-serif',
+    body2: {
+      fontSize: "0.875rem",
+      lineHeight: 1.43
+    },
+    button: {
+      fontWeight: 500,
+      textTransform: "none"
+    }
+  },
+  components: {
+    MuiButton: {
+      styleOverrides: {
+        root: {
+          borderRadius: 8,
+          paddingX: 16,
+          paddingY: 8
+        },
+        contained: {
+          boxShadow: "0 2px 4px rgba(0,0,0,0.1)",
+          "&:hover": {
+            boxShadow: "0 4px 8px rgba(0,0,0,0.15)"
+          }
+        }
+      }
+    },
+    MuiPaper: {
+      styleOverrides: {
+        root: {
+          borderRadius: 12
+        }
+      }
+    },
+    MuiDialog: {
+      styleOverrides: {
+        paper: {
+          borderRadius: 16
+        }
+      }
+    }
+  }
+});
+
+// src/context/DesignContext.tsx
+import * as React4 from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var DesignContext = React4.createContext(void 0);
+function DesignProvider({
+  tokens,
+  children
+}) {
+  return /* @__PURE__ */ jsx3(DesignContext.Provider, { value: tokens, children });
+}
+function useDesignTokens() {
+  return React4.useContext(DesignContext);
+}
+
+// src/components/CookieBanner.tsx
+import Button from "@mui/material/Button";
+import Box from "@mui/material/Box";
+import Paper from "@mui/material/Paper";
+import Snackbar from "@mui/material/Snackbar";
+import Stack from "@mui/material/Stack";
+import Typography2 from "@mui/material/Typography";
+import Link2 from "@mui/material/Link";
+
+// src/components/Branding.tsx
+import Link from "@mui/material/Link";
+import Typography from "@mui/material/Typography";
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+var brandingStyles = {
+  banner: {
+    fontSize: "0.65rem",
+    textAlign: "right",
+    mt: 1,
+    opacity: 0.7,
+    fontStyle: "italic",
+    width: "100%"
+  },
+  modal: {
+    fontSize: "0.65rem",
+    textAlign: "right",
+    px: 3,
+    pb: 1,
+    opacity: 0.7,
+    fontStyle: "italic",
+    width: "100%"
+  }
+};
+var linkStyles = {
+  textDecoration: "none",
+  fontWeight: 500,
+  "&:hover": {
+    textDecoration: "underline"
+  }
+};
+function Branding({ variant, hidden = false }) {
+  const texts = useConsentTexts();
+  if (hidden) return null;
+  return /* @__PURE__ */ jsxs(
+    Typography,
+    {
+      variant: "caption",
+      sx: (theme) => ({
+        ...brandingStyles[variant],
+        color: theme.palette.text.secondary
+      }),
+      children: [
+        texts.brandingPoweredBy || "fornecido por",
+        " ",
+        /* @__PURE__ */ jsx4(
+          Link,
+          {
+            href: "https://www.ledipo.eti.br",
+            target: "_blank",
+            rel: "noopener noreferrer",
+            sx: (theme) => ({
+              ...linkStyles,
+              color: theme.palette.primary.main
+            }),
+            children: "L\xC9dipO.eti.br"
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/CookieBanner.tsx
+import { Fragment, jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+function CookieBanner({
+  policyLinkUrl,
+  debug,
+  blocking = true,
+  hideBranding = false,
+  SnackbarProps,
+  PaperProps
+}) {
+  const { consented, acceptAll, rejectAll, openPreferences } = useConsent();
+  const texts = useConsentTexts();
+  const isHydrated = useConsentHydration();
+  const designTokens = useDesignTokens();
+  const open = debug ? true : isHydrated && !consented;
+  logger.componentRender("CookieBanner", {
+    open,
+    consented,
+    isHydrated,
+    blocking,
+    hideBranding
+  });
+  if (!open) return null;
+  const bannerStyle = {
+    p: designTokens?.spacing?.padding?.banner ?? 2,
+    maxWidth: 720,
+    mx: "auto",
+    backgroundColor: designTokens?.colors?.background,
+    color: designTokens?.colors?.text,
+    borderRadius: designTokens?.spacing?.borderRadius?.banner,
+    fontFamily: designTokens?.typography?.fontFamily
+  };
+  const bannerContent = /* @__PURE__ */ jsx5(Paper, { elevation: 3, sx: bannerStyle, ...PaperProps, children: /* @__PURE__ */ jsxs2(Stack, { spacing: 1, children: [
+    /* @__PURE__ */ jsxs2(
+      Typography2,
+      {
+        variant: "body2",
+        sx: { fontSize: designTokens?.typography?.fontSize?.banner },
+        children: [
+          texts.bannerMessage,
+          " ",
+          policyLinkUrl && /* @__PURE__ */ jsx5(
+            Link2,
+            {
+              href: policyLinkUrl,
+              underline: "hover",
+              target: "_blank",
+              rel: "noopener noreferrer",
+              sx: { color: designTokens?.colors?.primary },
+              children: texts.policyLink ?? "Saiba mais"
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs2(
+      Stack,
+      {
+        direction: { xs: "column", sm: "row" },
+        spacing: 1,
+        justifyContent: "flex-end",
+        children: [
+          /* @__PURE__ */ jsx5(
+            Button,
+            {
+              variant: "outlined",
+              onClick: () => {
+                logger.apiUsage("rejectAll", { source: "banner" });
+                rejectAll();
+              },
+              sx: { color: designTokens?.colors?.secondary },
+              children: texts.declineAll
+            }
+          ),
+          /* @__PURE__ */ jsx5(
+            Button,
+            {
+              variant: "contained",
+              onClick: () => {
+                logger.apiUsage("acceptAll", { source: "banner" });
+                acceptAll();
+              },
+              sx: { backgroundColor: designTokens?.colors?.primary },
+              children: texts.acceptAll
+            }
+          ),
+          /* @__PURE__ */ jsx5(
+            Button,
+            {
+              variant: "text",
+              onClick: () => {
+                logger.apiUsage("openPreferences", { source: "banner" });
+                openPreferences();
+              },
+              sx: { color: designTokens?.colors?.text },
+              children: texts.preferences
+            }
+          )
+        ]
+      }
+    ),
+    !hideBranding && /* @__PURE__ */ jsx5(Branding, { variant: "banner" })
+  ] }) });
+  const positionStyle = {
+    position: "fixed",
+    zIndex: 1300,
+    ...designTokens?.layout?.position === "top" ? { top: 0 } : { bottom: 0 },
+    left: 0,
+    right: 0,
+    width: designTokens?.layout?.width?.desktop ?? "100%",
+    p: 2
+  };
+  if (blocking) {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx5(
+        Box,
+        {
+          sx: {
+            position: "fixed",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0,
+            backgroundColor: designTokens?.layout?.backdrop ? "rgba(0, 0, 0, 0.5)" : "transparent",
+            zIndex: 1299
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx5(Box, { sx: positionStyle, children: bannerContent })
+    ] });
+  }
+  return /* @__PURE__ */ jsx5(
+    Snackbar,
+    {
+      open,
+      anchorOrigin: {
+        vertical: designTokens?.layout?.position === "top" ? "top" : "bottom",
+        horizontal: "center"
+      },
+      ...SnackbarProps,
+      children: bannerContent
+    }
+  );
+}
+
+// src/components/FloatingPreferencesButton.tsx
+import CookieOutlined from "@mui/icons-material/CookieOutlined";
+import Fab from "@mui/material/Fab";
+import Tooltip from "@mui/material/Tooltip";
+import { useTheme } from "@mui/material/styles";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function useThemeWithFallbacks() {
+  const theme = useTheme();
+  logger.themeCompatibility(theme);
+  return {
+    palette: {
+      primary: {
+        main: theme?.palette?.primary?.main || "#1976d2",
+        dark: theme?.palette?.primary?.dark || "#1565c0"
+      }
+    },
+    transitions: {
+      duration: {
+        shortest: theme?.transitions?.duration?.shortest || 150,
+        short: theme?.transitions?.duration?.short || 250
+      }
+    }
+  };
+}
+function FloatingPreferencesButton({
+  position = "bottom-right",
+  offset = 24,
+  icon = /* @__PURE__ */ jsx6(CookieOutlined, {}),
+  tooltip,
+  FabProps,
+  hideWhenConsented = false
+}) {
+  const { openPreferences, consented } = useConsent();
+  const texts = useConsentTexts();
+  const safeTheme = useThemeWithFallbacks();
+  logger.componentRender("FloatingPreferencesButton", {
+    position,
+    offset,
+    hideWhenConsented,
+    consented
+  });
+  if (hideWhenConsented && consented) {
+    logger.debug(
+      "FloatingPreferencesButton: Hidden due to hideWhenConsented=true and consented=true"
+    );
+    return null;
+  }
+  const tooltipText = tooltip ?? texts.preferencesButton ?? "Gerenciar Prefer\xEAncias de Cookies";
+  const getPosition = () => {
+    const styles = {
+      position: "fixed",
+      zIndex: 1200
+    };
+    switch (position) {
+      case "bottom-left":
+        return { ...styles, bottom: offset, left: offset };
+      case "bottom-right":
+        return { ...styles, bottom: offset, right: offset };
+      case "top-left":
+        return { ...styles, top: offset, left: offset };
+      case "top-right":
+        return { ...styles, top: offset, right: offset };
+      default:
+        return { ...styles, bottom: offset, right: offset };
+    }
+  };
+  return /* @__PURE__ */ jsx6(Tooltip, { title: tooltipText, placement: "top", children: /* @__PURE__ */ jsx6(
+    Fab,
+    {
+      size: "medium",
+      color: "primary",
+      onClick: openPreferences,
+      sx: {
+        ...getPosition(),
+        backgroundColor: safeTheme.palette.primary.main,
+        "&:hover": {
+          backgroundColor: safeTheme.palette.primary.dark
+        },
+        transition: `all ${safeTheme.transitions.duration.short}ms`
+      },
+      "aria-label": tooltipText,
+      ...FabProps,
+      children: icon
+    }
+  ) });
+}
+
+// src/context/ConsentContext.tsx
+import { jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+var log = {
+  debug: (message, data) => {
+    if (typeof window !== "undefined" && window.__REACT_DEVTOOLS_GLOBAL_HOOK__) {
+      console.debug("[react-lgpd-consent] [DEBUG]", message, data);
+    }
+  },
+  info: (message, data) => {
+    if (typeof window !== "undefined" && window.__REACT_DEVTOOLS_GLOBAL_HOOK__) {
+      console.info("[react-lgpd-consent] [INFO]", message, data);
+    }
+  }
+};
+var PreferencesModal = React5.lazy(
+  () => import("./PreferencesModal-J27W5XAJ.js").then((m) => ({
+    default: m.PreferencesModal
+  }))
+);
+function createFullConsentState(consented, preferences, source, projectConfig, isModalOpen = false, existingState) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: "1.0",
+    consented,
+    preferences,
+    consentDate: existingState?.consentDate || now,
+    lastUpdate: now,
+    source,
+    projectConfig,
+    isModalOpen
+  };
+}
+var DEFAULT_TEXTS = {
+  // Textos básicos
+  bannerMessage: "Utilizamos cookies para melhorar sua experi\xEAncia.",
+  acceptAll: "Aceitar todos",
+  declineAll: "Recusar",
+  preferences: "Prefer\xEAncias",
+  policyLink: "Saiba mais",
+  modalTitle: "Prefer\xEAncias de Cookies",
+  modalIntro: "Ajuste as categorias de cookies. Cookies necess\xE1rios s\xE3o sempre utilizados para funcionalidades b\xE1sicas.",
+  save: "Salvar prefer\xEAncias",
+  necessaryAlwaysOn: "Cookies necess\xE1rios (sempre ativos)",
+  // Textos adicionais para UI customizada
+  preferencesButton: "Configurar Cookies",
+  preferencesTitle: "Gerenciar Prefer\xEAncias de Cookies",
+  preferencesDescription: "Escolha quais tipos de cookies voc\xEA permite que sejam utilizados.",
+  close: "Fechar",
+  accept: "Aceitar",
+  reject: "Rejeitar",
+  // Textos ANPD expandidos (opcionais)
+  brandingPoweredBy: "fornecido por",
+  controllerInfo: void 0,
+  // Exibido se definido
+  dataTypes: void 0,
+  // Exibido se definido
+  thirdPartySharing: void 0,
+  // Exibido se definido
+  userRights: void 0,
+  // Exibido se definido
+  contactInfo: void 0,
+  // Exibido se definido
+  retentionPeriod: void 0,
+  // Exibido se definido
+  lawfulBasis: void 0,
+  // Exibido se definido
+  transferCountries: void 0
+  // Exibido se definido
+};
+function reducer(state, action) {
+  log.debug("State transition:", {
+    action: action.type,
+    currentState: state.consented
+  });
+  switch (action.type) {
+    case "ACCEPT_ALL": {
+      const prefs = createProjectPreferences(action.config, true);
+      const newState = createFullConsentState(
+        true,
+        prefs,
+        "banner",
+        action.config,
+        false,
+        state
+      );
+      log.info("User accepted all cookies", {
+        preferences: newState.preferences
+      });
+      return newState;
+    }
+    case "REJECT_ALL": {
+      const prefs = createProjectPreferences(action.config, false);
+      const newState = createFullConsentState(
+        true,
+        prefs,
+        "banner",
+        action.config,
+        false,
+        state
+      );
+      log.info("User rejected all cookies", {
+        preferences: newState.preferences
+      });
+      return newState;
+    }
+    case "SET_CATEGORY":
+      log.debug("Category preference changed", {
+        category: action.category,
+        value: action.value
+      });
+      return {
+        ...state,
+        preferences: {
+          ...state.preferences,
+          [action.category]: action.value
+        },
+        lastUpdate: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    case "SET_PREFERENCES":
+      log.info("Preferences saved", { preferences: action.preferences });
+      return createFullConsentState(
+        true,
+        action.preferences,
+        "modal",
+        action.config,
+        false,
+        state
+      );
+    case "OPEN_MODAL":
+      return { ...state, isModalOpen: true };
+    case "CLOSE_MODAL":
+      return createFullConsentState(
+        true,
+        state.preferences,
+        "modal",
+        action.config,
+        false,
+        state
+      );
+    case "RESET": {
+      return createFullConsentState(
+        false,
+        createProjectPreferences(action.config),
+        "programmatic",
+        action.config,
+        false
+      );
+    }
+    case "HYDRATE": {
+      const validatedPreferences = validateProjectPreferences(
+        action.state.preferences,
+        action.config
+      );
+      return {
+        ...action.state,
+        preferences: validatedPreferences,
+        isModalOpen: false
+      };
+    }
+    default:
+      return state;
+  }
+}
+var StateCtx = React5.createContext(null);
+var ActionsCtx = React5.createContext(null);
+var TextsCtx = React5.createContext(DEFAULT_TEXTS);
+var HydrationCtx = React5.createContext(false);
+function ConsentProvider({
+  initialState,
+  categories,
+  // Nova prop para configuração de categorias
+  texts: textsProp,
+  theme,
+  designTokens,
+  scriptIntegrations,
+  // eslint-disable-line no-unused-vars
+  PreferencesModalComponent,
+  preferencesModalProps = {},
+  CookieBannerComponent,
+  cookieBannerProps = {},
+  FloatingPreferencesButtonComponent,
+  floatingPreferencesButtonProps = {},
+  disableFloatingPreferencesButton = false,
+  hideBranding = false,
+  onConsentGiven,
+  onPreferencesSaved,
+  cookie: cookieOpts,
+  disableDeveloperGuidance,
+  children
+}) {
+  const texts = React5.useMemo(
+    () => ({ ...DEFAULT_TEXTS, ...textsProp ?? {} }),
+    [textsProp]
+  );
+  const cookie = React5.useMemo(
+    () => ({ ...DEFAULT_COOKIE_OPTS, ...cookieOpts ?? {} }),
+    [cookieOpts]
+  );
+  const appliedTheme = React5.useMemo(
+    () => theme || defaultConsentTheme,
+    [theme]
+  );
+  const finalCategoriesConfig = React5.useMemo(() => {
+    if (categories) return categories;
+    return DEFAULT_PROJECT_CATEGORIES;
+  }, [categories]);
+  useDeveloperGuidance(finalCategoriesConfig, disableDeveloperGuidance);
+  const boot = React5.useMemo(() => {
+    if (initialState) return { ...initialState, isModalOpen: false };
+    return createFullConsentState(
+      false,
+      createProjectPreferences(finalCategoriesConfig),
+      "banner",
+      finalCategoriesConfig,
+      false
+    );
+  }, [initialState, finalCategoriesConfig]);
+  const [state, dispatch] = React5.useReducer(reducer, boot);
+  const [isHydrated, setIsHydrated] = React5.useState(false);
+  React5.useEffect(() => {
+    if (!initialState) {
+      const saved = readConsentCookie(cookie.name);
+      if (saved?.consented) {
+        dispatch({
+          type: "HYDRATE",
+          state: saved,
+          config: finalCategoriesConfig
+        });
+      }
+    }
+    setIsHydrated(true);
+  }, [cookie.name, initialState, finalCategoriesConfig]);
+  React5.useEffect(() => {
+    if (state.consented)
+      writeConsentCookie(state, finalCategoriesConfig, cookie);
+  }, [state, cookie, finalCategoriesConfig]);
+  const prevConsented = React5.useRef(state.consented);
+  React5.useEffect(() => {
+    if (!prevConsented.current && state.consented && onConsentGiven) {
+      setTimeout(() => onConsentGiven(state), 150);
+    }
+    prevConsented.current = state.consented;
+  }, [state, onConsentGiven]);
+  const api = React5.useMemo(() => {
+    const acceptAll = () => dispatch({ type: "ACCEPT_ALL", config: finalCategoriesConfig });
+    const rejectAll = () => dispatch({ type: "REJECT_ALL", config: finalCategoriesConfig });
+    const setPreference = (category, value) => dispatch({ type: "SET_CATEGORY", category, value });
+    const setPreferences = (preferences) => {
+      dispatch({
+        type: "SET_PREFERENCES",
+        preferences,
+        config: finalCategoriesConfig
+      });
+      if (onPreferencesSaved) {
+        setTimeout(() => onPreferencesSaved(preferences), 150);
+      }
+    };
+    const openPreferences = () => dispatch({ type: "OPEN_MODAL" });
+    const closePreferences = () => dispatch({ type: "CLOSE_MODAL", config: finalCategoriesConfig });
+    const resetConsent = () => {
+      removeConsentCookie(cookie);
+      dispatch({ type: "RESET", config: finalCategoriesConfig });
+    };
+    return {
+      consented: !!state.consented,
+      preferences: state.preferences,
+      isModalOpen: state.isModalOpen,
+      acceptAll,
+      rejectAll,
+      setPreference,
+      setPreferences,
+      openPreferences,
+      closePreferences,
+      resetConsent
+    };
+  }, [state, cookie, finalCategoriesConfig, onPreferencesSaved]);
+  React5.useEffect(() => {
+    _registerGlobalOpenPreferences(api.openPreferences);
+    return () => _unregisterGlobalOpenPreferences();
+  }, [api.openPreferences]);
+  return /* @__PURE__ */ jsx7(SafeThemeProvider, { theme: appliedTheme, children: /* @__PURE__ */ jsx7(StateCtx.Provider, { value: state, children: /* @__PURE__ */ jsx7(ActionsCtx.Provider, { value: api, children: /* @__PURE__ */ jsx7(TextsCtx.Provider, { value: texts, children: /* @__PURE__ */ jsx7(HydrationCtx.Provider, { value: isHydrated, children: /* @__PURE__ */ jsx7(DesignProvider, { tokens: designTokens, children: /* @__PURE__ */ jsxs3(
+    CategoriesProvider,
+    {
+      config: finalCategoriesConfig,
+      disableDeveloperGuidance,
+      children: [
+        children,
+        /* @__PURE__ */ jsx7(React5.Suspense, { fallback: null, children: PreferencesModalComponent ? /* @__PURE__ */ jsx7(
+          PreferencesModalComponent,
+          {
+            preferences: api.preferences,
+            setPreferences: api.setPreferences,
+            closePreferences: api.closePreferences,
+            isModalOpen: api.isModalOpen,
+            texts,
+            ...preferencesModalProps
+          }
+        ) : /* @__PURE__ */ jsx7(PreferencesModal, { hideBranding }) }),
+        !state.consented && isHydrated && (CookieBannerComponent ? /* @__PURE__ */ jsx7(
+          CookieBannerComponent,
+          {
+            consented: api.consented,
+            acceptAll: api.acceptAll,
+            rejectAll: api.rejectAll,
+            openPreferences: api.openPreferences,
+            texts,
+            ...cookieBannerProps
+          }
+        ) : /* @__PURE__ */ jsx7(CookieBanner, {})),
+        state.consented && !disableFloatingPreferencesButton && (FloatingPreferencesButtonComponent ? /* @__PURE__ */ jsx7(
+          FloatingPreferencesButtonComponent,
+          {
+            openPreferences: api.openPreferences,
+            consented: api.consented,
+            ...floatingPreferencesButtonProps
+          }
+        ) : /* @__PURE__ */ jsx7(FloatingPreferencesButton, {}))
+      ]
+    }
+  ) }) }) }) }) }) });
+}
+function useConsentStateInternal() {
+  const ctx = React5.useContext(StateCtx);
+  if (!ctx)
+    throw new Error("useConsentState must be used within ConsentProvider");
+  return ctx;
+}
+function useConsentActionsInternal() {
+  const ctx = React5.useContext(ActionsCtx);
+  if (!ctx)
+    throw new Error("useConsentActions must be used within ConsentProvider");
+  return ctx;
+}
+function useConsentTextsInternal() {
+  const ctx = React5.useContext(TextsCtx);
+  return ctx;
+}
+function useConsentHydrationInternal() {
+  return React5.useContext(HydrationCtx);
+}
+
+// src/hooks/useConsent.ts
+function useConsent() {
+  const state = useConsentStateInternal();
+  const actions = useConsentActionsInternal();
+  return {
+    consented: state.consented,
+    preferences: state.preferences,
+    isModalOpen: state.isModalOpen,
+    acceptAll: actions.acceptAll,
+    rejectAll: actions.rejectAll,
+    setPreference: actions.setPreference,
+    setPreferences: actions.setPreferences,
+    openPreferences: actions.openPreferences,
+    closePreferences: actions.closePreferences,
+    resetConsent: actions.resetConsent
+  };
+}
+function useConsentTexts() {
+  return useConsentTextsInternal();
+}
+function useConsentHydration() {
+  return useConsentHydrationInternal();
+}
+function useOpenPreferencesModal() {
+  const { openPreferences } = useConsent();
+  return openPreferences;
+}
+var globalOpenPreferences = null;
+function openPreferencesModal() {
+  if (globalOpenPreferences) {
+    globalOpenPreferences();
+  } else {
+    console.warn(
+      "openPreferencesModal: ConsentProvider n\xE3o foi inicializado ou n\xE3o est\xE1 dispon\xEDvel."
+    );
+  }
+}
+function _registerGlobalOpenPreferences(openPreferences) {
+  globalOpenPreferences = openPreferences;
+}
+function _unregisterGlobalOpenPreferences() {
+  globalOpenPreferences = null;
+}
+
+// src/components/PreferencesModal.tsx
+import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+function PreferencesModal2({
+  DialogProps: DialogProps2,
+  hideBranding = false
+}) {
+  const { preferences, setPreferences, closePreferences, isModalOpen } = useConsent();
+  const texts = useConsentTexts();
+  const { toggleableCategories } = useCategories();
+  const [tempPreferences, setTempPreferences] = useState2(
+    () => {
+      const initialPrefs = { necessary: true };
+      toggleableCategories.forEach((category) => {
+        initialPrefs[category.id] = preferences[category.id] ?? false;
+      });
+      return initialPrefs;
+    }
+  );
+  useEffect4(() => {
+    if (isModalOpen) {
+      const syncedPrefs = { necessary: true };
+      toggleableCategories.forEach((category) => {
+        syncedPrefs[category.id] = preferences[category.id] ?? false;
+      });
+      setTempPreferences(syncedPrefs);
+    }
+  }, [isModalOpen, preferences, toggleableCategories]);
+  const open = DialogProps2?.open ?? isModalOpen ?? false;
+  const handleSave = () => {
+    setPreferences(tempPreferences);
+  };
+  const handleCancel = () => {
+    setTempPreferences(preferences);
+    closePreferences();
+  };
+  return /* @__PURE__ */ jsxs4(
+    Dialog,
+    {
+      "aria-labelledby": "cookie-pref-title",
+      open,
+      onClose: handleCancel,
+      ...DialogProps2,
+      children: [
+        /* @__PURE__ */ jsx8(DialogTitle, { id: "cookie-pref-title", children: texts.modalTitle }),
+        /* @__PURE__ */ jsxs4(DialogContent, { dividers: true, children: [
+          /* @__PURE__ */ jsx8(Typography3, { variant: "body2", sx: { mb: 2 }, children: texts.modalIntro }),
+          /* @__PURE__ */ jsxs4(FormGroup, { children: [
+            toggleableCategories.map((category) => /* @__PURE__ */ jsx8(
+              FormControlLabel,
+              {
+                control: /* @__PURE__ */ jsx8(
+                  Switch,
+                  {
+                    checked: tempPreferences[category.id] ?? false,
+                    onChange: (e) => setTempPreferences((prev) => ({
+                      ...prev,
+                      [category.id]: e.target.checked
+                    }))
+                  }
+                ),
+                label: `${category.name} - ${category.description}`
+              },
+              category.id
+            )),
+            /* @__PURE__ */ jsx8(
+              FormControlLabel,
+              {
+                control: /* @__PURE__ */ jsx8(Switch, { checked: true, disabled: true }),
+                label: texts.necessaryAlwaysOn
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs4(DialogActions, { children: [
+          /* @__PURE__ */ jsx8(Button2, { variant: "outlined", onClick: handleCancel, children: texts.close }),
+          /* @__PURE__ */ jsx8(Button2, { variant: "contained", onClick: handleSave, children: texts.save })
+        ] }),
+        !hideBranding && /* @__PURE__ */ jsx8(Branding, { variant: "modal" })
+      ]
+    }
+  );
+}
+
+export {
+  DEFAULT_PROJECT_CATEGORIES,
+  analyzeDeveloperConfiguration,
+  useCategories,
+  useCategoryStatus,
+  LogLevel,
+  setDebugLogging,
+  defaultConsentTheme,
+  ConsentProvider,
+  useConsent,
+  useConsentTexts,
+  useConsentHydration,
+  useOpenPreferencesModal,
+  openPreferencesModal,
+  PreferencesModal2 as PreferencesModal
+};