xertica-ui 1.0.0

package/contexts/ApiKeyContext.tsx

@@ -0,0 +1,123 @@
+import React, { createContext, useContext, useState, useEffect, ReactNode } from 'react';
+
+interface ApiKeyContextType {
+  geminiApiKey: string;
+  setGeminiApiKey: (key: string) => void;
+  isApiKeyValid: boolean;
+  googleMapsApiKey: string;
+  setGoogleMapsApiKey: (key: string) => void;
+  isGoogleMapsKeyValid: boolean;
+  reloadMapsApi: () => Promise<void>;
+}
+
+const ApiKeyContext = createContext<ApiKeyContextType | undefined>(undefined);
+
+export function ApiKeyProvider({ children }: { children: ReactNode }) {
+  // Lista de chaves conhecidas como vazadas (para limpeza automática)
+  const LEAKED_KEYS = [
+    'AIzaSyCMsAMytBeOK0Qd7RDFKyA5IW9eWt2WTJg',
+    'AIzaSyAiYWEIEmx212Up9zfM8kqyMXB4jLs8gq0'
+  ];
+
+  const [geminiApiKey, setGeminiApiKeyState] = useState<string>(() => {
+    const saved = localStorage.getItem('xertica-gemini-api-key');
+    
+    // Se a chave salva estiver na lista de vazadas, removê-la
+    if (saved && LEAKED_KEYS.includes(saved)) {
+      localStorage.removeItem('xertica-gemini-api-key');
+      return '';
+    }
+    
+    return saved || '';
+  });
+
+  const [googleMapsApiKey, setGoogleMapsApiKeyState] = useState<string>(() => {
+    const saved = localStorage.getItem('xertica-googlemaps-api-key');
+    return saved || '';
+  });
+
+  const [isApiKeyValid, setIsApiKeyValid] = useState(false);
+  const [isGoogleMapsKeyValid, setIsGoogleMapsKeyValid] = useState(false);
+
+  useEffect(() => {
+    if (geminiApiKey) {
+      localStorage.setItem('xertica-gemini-api-key', geminiApiKey);
+      // Validação básica do formato da chave
+      setIsApiKeyValid(geminiApiKey.startsWith('AIzaSy') && geminiApiKey.length > 20);
+    } else {
+      localStorage.removeItem('xertica-gemini-api-key');
+      setIsApiKeyValid(false);
+    }
+  }, [geminiApiKey]);
+
+  useEffect(() => {
+    if (googleMapsApiKey) {
+      localStorage.setItem('xertica-googlemaps-api-key', googleMapsApiKey);
+      // Validação básica do formato da chave do Google Maps
+      setIsGoogleMapsKeyValid(googleMapsApiKey.startsWith('AIzaSy') && googleMapsApiKey.length > 20);
+      
+      // Recarregar automaticamente o Google Maps quando a chave mudar
+      const reloadMaps = async () => {
+        if (googleMapsApiKey.length < 10) return;
+        
+        try {
+          const { reloadGoogleMaps } = await import('../components/ui/google-maps-loader');
+          await reloadGoogleMaps(googleMapsApiKey);
+          console.log('[ApiKeyContext] Google Maps recarregado com sucesso');
+        } catch (error) {
+          console.error('[ApiKeyContext] Erro ao recarregar Google Maps:', error);
+        }
+      };
+      
+      reloadMaps();
+    } else {
+      localStorage.removeItem('xertica-googlemaps-api-key');
+      setIsGoogleMapsKeyValid(false);
+    }
+  }, [googleMapsApiKey]);
+
+  const setGeminiApiKey = (key: string) => {
+    setGeminiApiKeyState(key.trim());
+  };
+
+  const setGoogleMapsApiKey = (key: string) => {
+    setGoogleMapsApiKeyState(key.trim());
+  };
+
+  const reloadMapsApi = async () => {
+    if (!googleMapsApiKey || googleMapsApiKey.length < 10) {
+      return;
+    }
+
+    try {
+      // Importar dinamicamente a função de reload
+      const { reloadGoogleMaps } = await import('../components/ui/google-maps-loader');
+      await reloadGoogleMaps(googleMapsApiKey);
+      console.log('[ApiKeyContext] Google Maps recarregado manualmente');
+    } catch (error) {
+      console.error('[ApiKeyContext] Erro ao recarregar Google Maps:', error);
+    }
+  };
+
+  return (
+    <ApiKeyContext.Provider value={{ 
+      geminiApiKey, 
+      setGeminiApiKey, 
+      isApiKeyValid,
+      googleMapsApiKey,
+      setGoogleMapsApiKey,
+      isGoogleMapsKeyValid,
+      reloadMapsApi
+    }}>
+      {children}
+    </ApiKeyContext.Provider>
+  );
+}
+
+export function useApiKey() {
+  const context = useContext(ApiKeyContext);
+  if (!context) {
+    throw new Error('useApiKey must be used within ApiKeyProvider');
+  }
+  return context;
+}

package/contexts/AssistenteContext.tsx

@@ -0,0 +1,118 @@
+import React, { createContext, useContext, useState, ReactNode } from 'react';
+
+export interface Message {
+  id: string;
+  type: 'user' | 'assistant';
+  content: string;
+  timestamp: Date;
+  isFavorite?: boolean;
+  attachmentType?: 'file' | 'audio' | 'image' | 'podcast' | 'document' | 'search';
+  attachmentName?: string;
+  audioUrl?: string;
+  isPodcastGenerating?: boolean;
+  documentContent?: string;
+  documentTitle?: string;
+  searchResults?: SearchResult[];
+  searchSources?: SearchSource[];
+  searchCommands?: SearchCommand[];
+}
+
+export interface Conversa {
+  id: string;
+  titulo: string;
+  mensagens: Message[];
+  ultimaMensagem: string;
+  timestamp: string;
+  favorita?: boolean;
+}
+
+export interface SearchResult {
+  id: string;
+  title: string;
+  description: string;
+  type: 'document' | 'file' | 'project' | 'conversation' | 'contact';
+  path: string;
+  relevance: number;
+  lastModified?: string;
+}
+
+export interface SearchSource {
+  name: string;
+  count: number;
+}
+
+export interface SearchCommand {
+  id: string;
+  icon: string;
+  label: string;
+  description: string;
+}
+
+interface AssistenteContextType {
+  conversaAtual: string;
+  setConversaAtual: (id: string) => void;
+  conversas: Conversa[];
+  setConversas: React.Dispatch<React.SetStateAction<Conversa[]>>;
+  isTyping: boolean;
+  setIsTyping: (typing: boolean) => void;
+  abaSelecionada: 'chat' | 'historico' | 'favoritos';
+  setAbaSelecionada: (aba: 'chat' | 'historico' | 'favoritos') => void;
+  editingDocument: { content: string; title: string } | null;
+  setEditingDocument: (doc: { content: string; title: string } | null) => void;
+  searchFilter: 'all' | 'document' | 'project' | 'conversation' | 'file' | 'contact';
+  setSearchFilter: (filter: 'all' | 'document' | 'project' | 'conversation' | 'file' | 'contact') => void;
+  savedSearches: string[];
+  setSavedSearches: React.Dispatch<React.SetStateAction<string[]>>;
+}
+
+const AssistenteContext = createContext<AssistenteContextType | undefined>(undefined);
+
+export function AssistenteProvider({ children }: { children: ReactNode }) {
+  const [conversaAtual, setConversaAtual] = useState<string>('1');
+  const [conversas, setConversas] = useState<Conversa[]>([
+    {
+      id: '1',
+      titulo: 'Nova Conversa',
+      mensagens: [],
+      ultimaMensagem: '',
+      timestamp: new Date().toISOString(),
+      favorita: false
+    }
+  ]);
+  const [isTyping, setIsTyping] = useState(false);
+  const [abaSelecionada, setAbaSelecionada] = useState<'chat' | 'historico' | 'favoritos'>('chat');
+  const [editingDocument, setEditingDocument] = useState<{ content: string; title: string } | null>(null);
+  const [searchFilter, setSearchFilter] = useState<'all' | 'document' | 'project' | 'conversation' | 'file' | 'contact'>('all');
+  const [savedSearches, setSavedSearches] = useState<string[]>([]);
+
+  return (
+    <AssistenteContext.Provider
+      value={{
+        conversaAtual,
+        setConversaAtual,
+        conversas,
+        setConversas,
+        isTyping,
+        setIsTyping,
+        abaSelecionada,
+        setAbaSelecionada,
+        editingDocument,
+        setEditingDocument,
+        searchFilter,
+        setSearchFilter,
+        savedSearches,
+        setSavedSearches,
+      }}
+    >
+      {children}
+    </AssistenteContext.Provider>
+  );
+}
+
+export function useAssistente() {
+  const context = useContext(AssistenteContext);
+  if (!context) {
+    throw new Error('useAssistente must be used within AssistenteProvider');
+  }
+  return context;
+}