@flowtomic/logic 0.1.0 → 0.1.2

package/dist/hooks/useScriptEditor/useScriptEditor.js

@@ -0,0 +1,247 @@
+/**
+ * useScriptEditor - Headless UI Hook
+ *
+ * Fornece apenas: lógica, estado, processamento e API
+ * NÃO fornece: markup, styles ou implementações pré-construídas
+ *
+ * Padrão Headless UI: você controla o markup e styles
+ *
+ * @example
+ * ```tsx
+ * function MyScriptEditor() {
+ *   const {
+ *     script,
+ *     setScript,
+ *     terminalLines,
+ *     preview,
+ *     isRunning,
+ *     isConnected,
+ *     executeScript,
+ *     stopExecution,
+ *     clearTerminal,
+ *   } = useScriptEditor({
+ *     wsUrl: "ws://localhost:8080/ws/terminal",
+ *     executeScript: async (script) => {
+ *       const response = await fetch("/api/scripts/execute", {
+ *         method: "POST",
+ *         body: JSON.stringify({ script }),
+ *       });
+ *       return response.json();
+ *     },
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <textarea value={script} onChange={(e) => setScript(e.target.value)} />
+ *       <button onClick={executeScript}>Executar</button>
+ *       <div>
+ *         {terminalLines.map((line) => (
+ *           <div key={line.id}>{line.content}</div>
+ *         ))}
+ *       </div>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+import { useCallback, useEffect, useRef, useState } from "react";
+/**
+ * Hook headless para gerenciar editor de scripts com terminal interativo
+ */
+export function useScriptEditor(options = {}) {
+    const { wsUrl, executeScript: executeScriptFn, onOutput, onError, autoConnect = true, maxReconnectAttempts = 3, defaultScript = "", } = options;
+    const [script, setScript] = useState(defaultScript);
+    const [terminalLines, setTerminalLines] = useState([]);
+    const [preview, setPreview] = useState("");
+    const [activeTab, setActiveTab] = useState("terminal");
+    const [isRunning, setIsRunning] = useState(false);
+    const [isConnected, setIsConnected] = useState(false);
+    const wsRef = useRef(null);
+    const reconnectAttemptsRef = useRef(0);
+    const shouldReconnectRef = useRef(true);
+    // Adicionar linha ao terminal
+    const addTerminalLine = useCallback((type, content) => {
+        const line = {
+            id: `${Date.now()}-${Math.random()}`,
+            type,
+            content,
+            timestamp: new Date(),
+        };
+        setTerminalLines((prev) => [...prev, line]);
+        onOutput?.(line);
+    }, [onOutput]);
+    // Conectar WebSocket
+    const connectWebSocket = useCallback(() => {
+        if (!wsUrl)
+            return;
+        // Verificar se já existe uma conexão ativa
+        if (wsRef.current && wsRef.current.readyState === WebSocket.OPEN) {
+            return;
+        }
+        // Fechar conexão anterior se existir
+        if (wsRef.current) {
+            try {
+                wsRef.current.close();
+            }
+            catch {
+                // Ignorar erros ao fechar
+            }
+            wsRef.current = null;
+        }
+        if (!shouldReconnectRef.current)
+            return;
+        try {
+            const ws = new WebSocket(wsUrl);
+            wsRef.current = ws;
+            ws.onopen = () => {
+                setIsConnected(true);
+                reconnectAttemptsRef.current = 0;
+            };
+            ws.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(event.data);
+                    if (data.type === "output") {
+                        addTerminalLine("output", data.content);
+                    }
+                    else if (data.type === "error") {
+                        addTerminalLine("error", data.content);
+                    }
+                    else if (data.type === "result") {
+                        setPreview(JSON.stringify(data.content, null, 2));
+                        setActiveTab("preview");
+                    }
+                    else if (data.type === "system") {
+                        // Mensagens de sistema não são exibidas no terminal
+                        console.log("[useScriptEditor] Mensagem de sistema:", data.content);
+                    }
+                }
+                catch {
+                    addTerminalLine("output", event.data);
+                }
+            };
+            ws.onerror = (error) => {
+                console.error("[useScriptEditor] WebSocket error:", error);
+                setIsConnected(false);
+                onError?.(new Error("Erro na conexão WebSocket"));
+            };
+            ws.onclose = (event) => {
+                setIsConnected(false);
+                wsRef.current = null;
+                // Tentar reconectar apenas se não excedeu tentativas e ainda deve reconectar
+                if (event.code !== 1000 &&
+                    shouldReconnectRef.current &&
+                    reconnectAttemptsRef.current < maxReconnectAttempts) {
+                    reconnectAttemptsRef.current += 1;
+                    setTimeout(() => {
+                        if (shouldReconnectRef.current) {
+                            connectWebSocket();
+                        }
+                    }, 3000);
+                }
+                else if (reconnectAttemptsRef.current >= maxReconnectAttempts) {
+                    console.warn("[useScriptEditor] Máximo de tentativas de reconexão atingido");
+                }
+            };
+        }
+        catch (error) {
+            console.error("[useScriptEditor] Erro ao conectar WebSocket:", error);
+            setIsConnected(false);
+            onError?.(error instanceof Error ? error : new Error("Erro desconhecido ao conectar"));
+        }
+    }, [wsUrl, maxReconnectAttempts, addTerminalLine, onError]);
+    // Conectar WebSocket quando montar (se autoConnect)
+    useEffect(() => {
+        if (autoConnect && wsUrl) {
+            const connectTimeout = setTimeout(() => {
+                connectWebSocket();
+            }, 100);
+            return () => {
+                clearTimeout(connectTimeout);
+            };
+        }
+    }, [autoConnect, wsUrl, connectWebSocket]);
+    // Limpar conexão ao desmontar
+    useEffect(() => {
+        return () => {
+            shouldReconnectRef.current = false;
+            if (wsRef.current) {
+                try {
+                    wsRef.current.close(1000, "Component unmounting");
+                }
+                catch {
+                    // Ignorar erros ao fechar
+                }
+                wsRef.current = null;
+            }
+        };
+    }, []);
+    // Executar script
+    const executeScript = useCallback(async () => {
+        if (!script.trim()) {
+            addTerminalLine("error", "❌ Script vazio");
+            return;
+        }
+        setIsRunning(true);
+        addTerminalLine("input", script);
+        try {
+            // Enviar script via WebSocket se conectado
+            if (wsRef.current && wsRef.current.readyState === WebSocket.OPEN) {
+                wsRef.current.send(JSON.stringify({ type: "execute", script }));
+            }
+            else if (executeScriptFn) {
+                // Fallback para HTTP se WebSocket não estiver disponível
+                try {
+                    const result = await executeScriptFn(script);
+                    if (result.output) {
+                        addTerminalLine("output", result.output);
+                    }
+                    if (result.error) {
+                        addTerminalLine("error", result.error);
+                    }
+                    if (result.result) {
+                        setPreview(JSON.stringify(result.result, null, 2));
+                        setActiveTab("preview");
+                    }
+                }
+                catch (error) {
+                    addTerminalLine("error", `❌ Erro na requisição: ${error instanceof Error ? error.message : "Erro desconhecido"}`);
+                }
+            }
+            else {
+                addTerminalLine("error", "❌ Nenhuma forma de execução disponível (WebSocket ou HTTP)");
+            }
+        }
+        catch (error) {
+            addTerminalLine("error", `❌ Erro ao executar: ${error instanceof Error ? error.message : "Erro desconhecido"}`);
+        }
+        finally {
+            setIsRunning(false);
+        }
+    }, [script, executeScriptFn, addTerminalLine]);
+    // Parar execução
+    const stopExecution = useCallback(() => {
+        if (wsRef.current && wsRef.current.readyState === WebSocket.OPEN) {
+            wsRef.current.send(JSON.stringify({ type: "stop" }));
+        }
+        setIsRunning(false);
+    }, []);
+    // Limpar terminal
+    const clearTerminal = useCallback(() => {
+        setTerminalLines([]);
+        setPreview("");
+    }, []);
+    return {
+        script,
+        setScript,
+        terminalLines,
+        preview,
+        activeTab,
+        setActiveTab,
+        isRunning,
+        isConnected,
+        executeScript,
+        stopExecution,
+        clearTerminal,
+        addTerminalLine,
+    };
+}

package/dist/hooks/useStatCard/useStatCard.d.ts

@@ -8,11 +8,11 @@
  *
  * @example
  * ```tsx
+ * // Cálculo automático do delta a partir de lastMonth
  * function MyCustomStatCard() {
  *   const { formattedValue, trend, getCardProps } = useStatCard({
  *     value: 122380,
- *     delta: 15.1,
- *     lastMonth: 105922,
+ *     lastMonth: 105922, // delta será calculado automaticamente: +15.5%
  *   })
  *
  *   return (
@@ -22,35 +22,65 @@
  *     </div>
  *   )
  * }
+ *
+ * // Ou forneça delta explicitamente para casos especiais
+ * function CustomDeltaCard() {
+ *   const { formattedValue, trend } = useStatCard({
+ *     value: 122380,
+ *     delta: 15.1, // delta explícito tem prioridade
+ *     lastMonth: 105922,
+ *   })
+ * }
  * ```
  */
 export interface StatCardData {
     /**
      * Valor principal do card
      */
-    value: number;
+    value: number | string;
     /**
      * Percentual de variação (positivo ou negativo)
+     * Se não fornecido, será calculado automaticamente quando `lastMonth` estiver disponível.
+     * Fórmula: ((value - lastMonth) / lastMonth) * 100
      */
     delta?: number;
     /**
      * Valor do mês anterior para comparação
+     * Se fornecido e `delta` não estiver definido, o delta será calculado automaticamente.
      */
     lastMonth?: number;
     /**
      * Prefixo para formatação do valor (ex: '$', 'R$')
+     * Se `locale` e `currency` forem fornecidos, será ignorado em favor da formatação de moeda
      */
     prefix?: string;
     /**
      * Sufixo para formatação do valor (ex: 'M', 'K')
      */
     suffix?: string;
+    /**
+     * Locale para formatação numérica (ex: 'pt-BR', 'en-US', 'de-DE')
+     * Padrão: 'pt-BR' (formata com ponto como separador de milhares)
+     */
+    locale?: string;
+    /**
+     * Código da moeda para formatação (ex: 'BRL', 'USD', 'EUR')
+     * Se fornecido, usa formatação de moeda do locale
+     */
+    currency?: string;
+    /**
+     * Como exibir a moeda ('symbol' | 'narrowSymbol' | 'code' | 'name')
+     * Padrão: 'symbol' (ex: R$ para BRL, $ para USD)
+     */
+    currencyDisplay?: "symbol" | "narrowSymbol" | "code" | "name";
     /**
      * Função customizada de formatação do valor principal
+     * Tem prioridade sobre locale e currency
      */
     format?: (value: number) => string;
     /**
      * Função customizada de formatação do valor do mês anterior
+     * Tem prioridade sobre locale e currency
      */
     lastFormat?: (value: number) => string;
     /**
@@ -124,11 +154,11 @@ export interface UseStatCardReturn {
  *
  * @example
  * ```tsx
+ * // Cálculo automático do delta a partir de lastMonth
  * function MyCustomStatCard() {
  *   const { formattedValue, trend, getCardProps } = useStatCard({
  *     value: 122380,
- *     delta: 15.1,
- *     lastMonth: 105922,
+ *     lastMonth: 105922, // delta será calculado automaticamente: +15.5%
  *   })
  *
  *   return (
@@ -138,6 +168,15 @@ export interface UseStatCardReturn {
  *     </div>
  *   )
  * }
+ *
+ * // Ou forneça delta explicitamente para casos especiais
+ * function CustomDeltaCard() {
+ *   const { formattedValue, trend } = useStatCard({
+ *     value: 122380,
+ *     delta: 15.1, // delta explícito tem prioridade
+ *     lastMonth: 105922,
+ *   })
+ * }
  * ```
  */
 export declare function useStatCard(data: StatCardData): UseStatCardReturn;

package/dist/hooks/useStatCard/useStatCard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStatCard.d.ts","sourceRoot":"","sources":["../../../src/hooks/useStatCard/useStatCard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAEnC;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAEvC;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,OAAO,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,CAAC;IAEjD;;OAEG;IACH,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAElC;;OAEG;IACH,KAAK,EAAE,SAAS,CAAC;IAEjB;;OAEG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,YAAY,EAAE,CAAC,KAAK,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK;QAC7F,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;QACrB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IAEF;;OAEG;IACH,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CACrC;AAkBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,iBAAiB,CAkFjE"}
+{"version":3,"file":"useStatCard.d.ts","sourceRoot":"","sources":["../../../src/hooks/useStatCard/useStatCard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAIH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAEvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,eAAe,CAAC,EAAE,QAAQ,GAAG,cAAc,GAAG,MAAM,GAAG,MAAM,CAAC;IAE9D;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAEnC;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAEvC;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,OAAO,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,CAAC;IAEjD;;OAEG;IACH,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAElC;;OAEG;IACH,KAAK,EAAE,SAAS,CAAC;IAEjB;;OAEG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,YAAY,EAAE,CAAC,KAAK,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK;QAC7F,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;QACrB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IAEF;;OAEG;IACH,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CACrC;AAwCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,iBAAiB,CAwHjE"}

package/dist/hooks/useStatCard/useStatCard.js

@@ -8,11 +8,11 @@
  *
  * @example
  * ```tsx
+ * // Cálculo automático do delta a partir de lastMonth
  * function MyCustomStatCard() {
  *   const { formattedValue, trend, getCardProps } = useStatCard({
  *     value: 122380,
- *     delta: 15.1,
- *     lastMonth: 105922,
+ *     lastMonth: 105922, // delta será calculado automaticamente: +15.5%
  *   })
  *
  *   return (
@@ -22,23 +22,48 @@
  *     </div>
  *   )
  * }
+ *
+ * // Ou forneça delta explicitamente para casos especiais
+ * function CustomDeltaCard() {
+ *   const { formattedValue, trend } = useStatCard({
+ *     value: 122380,
+ *     delta: 15.1, // delta explícito tem prioridade
+ *     lastMonth: 105922,
+ *   })
+ * }
  * ```
  */
 import { useCallback, useMemo } from "react";
 /**
- * Formata um número seguindo padrões comuns
- * - Valores >= 1.000.000: formata como "X.XM"
- * - Valores >= 1.000: formata com separador de milhares
- * - Valores < 1.000: retorna como string
+ * Formata um número seguindo padrões comuns com suporte a locale
+ * - Valores >= 1.000.000: formata como "X.XM" (respeitando locale para decimais)
+ * - Valores >= 1.000: formata com separador de milhares conforme locale
+ * - Valores < 1.000: retorna formatado conforme locale
  */
-function formatNumberDefault(n) {
+function formatNumberDefault(n, locale = "pt-BR") {
     if (n >= 1_000_000) {
-        return `${(n / 1_000_000).toFixed(1)}M`;
+        const formatter = new Intl.NumberFormat(locale, {
+            minimumFractionDigits: 1,
+            maximumFractionDigits: 1,
+        });
+        return `${formatter.format(n / 1_000_000)}M`;
     }
     if (n >= 1_000) {
-        return n.toLocaleString();
+        return new Intl.NumberFormat(locale).format(n);
     }
-    return n.toString();
+    return new Intl.NumberFormat(locale).format(n);
+}
+/**
+ * Formata um número como moeda usando locale
+ */
+function formatCurrency(n, locale = "pt-BR", currency = "BRL", currencyDisplay = "symbol") {
+    return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency,
+        currencyDisplay,
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 2,
+    }).format(n);
 }
 /**
  * Hook Headless UI para StatCard
@@ -48,11 +73,11 @@ function formatNumberDefault(n) {
  *
  * @example
  * ```tsx
+ * // Cálculo automático do delta a partir de lastMonth
  * function MyCustomStatCard() {
  *   const { formattedValue, trend, getCardProps } = useStatCard({
  *     value: 122380,
- *     delta: 15.1,
- *     lastMonth: 105922,
+ *     lastMonth: 105922, // delta será calculado automaticamente: +15.5%
  *   })
  *
  *   return (
@@ -62,10 +87,32 @@ function formatNumberDefault(n) {
  *     </div>
  *   )
  * }
+ *
+ * // Ou forneça delta explicitamente para casos especiais
+ * function CustomDeltaCard() {
+ *   const { formattedValue, trend } = useStatCard({
+ *     value: 122380,
+ *     delta: 15.1, // delta explícito tem prioridade
+ *     lastMonth: 105922,
+ *   })
+ * }
  * ```
  */
 export function useStatCard(data) {
-    const { value, delta = 0, lastMonth, prefix = "", suffix = "", format, lastFormat, positive: explicitPositive, } = data;
+    const { value, delta: explicitDelta, lastMonth, prefix = "", suffix = "", locale = "pt-BR", currency, currencyDisplay = "symbol", format, lastFormat, positive: explicitPositive, } = data;
+    // Calcula delta automaticamente se não fornecido mas lastMonth estiver disponível
+    const delta = useMemo(() => {
+        // Se delta foi fornecido explicitamente, usa ele (prioridade)
+        if (explicitDelta !== undefined) {
+            return explicitDelta;
+        }
+        // Se lastMonth foi fornecido, calcula o delta automaticamente
+        if (lastMonth !== undefined && lastMonth !== 0) {
+            return ((Number(value) - Number(lastMonth)) / Number(lastMonth)) * 100;
+        }
+        // Caso contrário, retorna 0
+        return 0;
+    }, [value, lastMonth, explicitDelta]);
     // Calcula se a tendência é positiva
     const isPositive = useMemo(() => {
         if (explicitPositive !== undefined) {
@@ -89,10 +136,16 @@ export function useStatCard(data) {
     // Formata o valor principal
     const formattedValue = useMemo(() => {
         if (format) {
-            return format(value);
+            return format(Number(value));
+        }
+        const numValue = Number(value);
+        if (currency) {
+            // Se currency está definido, usa formatação de moeda (ignora prefix)
+            return (formatCurrency(numValue, locale, currency, currencyDisplay) + (suffix ? ` ${suffix}` : ""));
         }
-        return prefix + formatNumberDefault(value) + suffix;
-    }, [value, prefix, suffix, format]);
+        // Caso contrário, usa formatação numérica padrão com prefix/suffix
+        return prefix + formatNumberDefault(numValue, locale) + suffix;
+    }, [value, prefix, suffix, locale, currency, currencyDisplay, format]);
     // Formata o valor do mês anterior
     const formattedLastMonth = useMemo(() => {
         if (!lastMonth)
@@ -100,8 +153,13 @@ export function useStatCard(data) {
         if (lastFormat) {
             return lastFormat(lastMonth);
         }
-        return prefix + formatNumberDefault(lastMonth) + suffix;
-    }, [lastMonth, prefix, suffix, lastFormat]);
+        if (currency) {
+            // Se currency está definido, usa formatação de moeda (ignora prefix)
+            return formatCurrency(lastMonth, locale, currency, currencyDisplay);
+        }
+        // Caso contrário, usa formatação numérica padrão com prefix/suffix
+        return prefix + formatNumberDefault(lastMonth, locale) + suffix;
+    }, [lastMonth, prefix, suffix, locale, currency, currencyDisplay, lastFormat]);
     // Props helper para o card
     const getCardProps = useCallback((props = {}) => {
         return {
@@ -113,8 +171,11 @@ export function useStatCard(data) {
     }, [formattedValue]);
     // Função utilitária de formatação
     const formatNumber = useCallback((n) => {
-        return formatNumberDefault(n);
-    }, []);
+        if (currency) {
+            return formatCurrency(n, locale, currency, currencyDisplay);
+        }
+        return formatNumberDefault(n, locale);
+    }, [locale, currency, currencyDisplay]);
     return {
         formattedValue,
         formattedLastMonth,

package/dist/hooks/useTimeTracker/index.d.ts

@@ -0,0 +1,3 @@
+export type { UseTimeTrackerOptions, UseTimeTrackerReturn } from "./useTimeTracker";
+export { useTimeTracker } from "./useTimeTracker";
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/useTimeTracker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTimeTracker/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACpF,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/hooks/useTimeTracker/index.js

@@ -0,0 +1 @@
+export { useTimeTracker } from "./useTimeTracker";

package/dist/hooks/useTimeTracker/useTimeTracker.d.ts

@@ -0,0 +1,106 @@
+/**
+ * useTimeTracker - Headless UI Hook
+ *
+ * Fornece apenas: lógica, estado, processamento e API
+ * NÃO fornece: markup, styles ou implementações pré-construídas
+ *
+ * Padrão Headless UI: você controla o markup e styles
+ *
+ * @example
+ * ```tsx
+ * function MyTimer() {
+ *   const { time, formattedTime, isRunning, start, pause, stop, reset } = useTimeTracker({
+ *     initialTime: 0,
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       <span>{formattedTime}</span>
+ *       <button onClick={start}>Start</button>
+ *       <button onClick={pause}>Pause</button>
+ *       <button onClick={stop}>Stop</button>
+ *       <button onClick={reset}>Reset</button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+export interface UseTimeTrackerOptions {
+    /**
+     * Tempo inicial em segundos
+     * @default 0
+     */
+    initialTime?: number;
+    /**
+     * Callback quando o timer é pausado
+     */
+    onPause?: (time: number) => void;
+    /**
+     * Callback quando o timer é parado
+     */
+    onStop?: (time: number) => void;
+    /**
+     * Callback quando o timer é iniciado
+     */
+    onStart?: (time: number) => void;
+    /**
+     * Callback quando o timer é retomado
+     */
+    onResume?: (time: number) => void;
+    /**
+     * Callback quando o timer é resetado
+     */
+    onReset?: () => void;
+    /**
+     * Formato de tempo customizado
+     * @default "HH:mm:ss"
+     */
+    format?: "HH:mm:ss" | "mm:ss" | "ss" | ((seconds: number) => string);
+}
+export interface UseTimeTrackerReturn {
+    /**
+     * Tempo atual em segundos
+     */
+    time: number;
+    /**
+     * Tempo formatado como string (HH:mm:ss por padrão)
+     */
+    formattedTime: string;
+    /**
+     * Se o timer está rodando
+     */
+    isRunning: boolean;
+    /**
+     * Se o timer está pausado
+     */
+    isPaused: boolean;
+    /**
+     * Se o timer está parado (não iniciado ou resetado)
+     */
+    isStopped: boolean;
+    /**
+     * Inicia o timer
+     */
+    start: () => void;
+    /**
+     * Pausa o timer
+     */
+    pause: () => void;
+    /**
+     * Para o timer (pausa e mantém o tempo)
+     */
+    stop: () => void;
+    /**
+     * Retoma o timer após pausa
+     */
+    resume: () => void;
+    /**
+     * Reseta o timer para o tempo inicial
+     */
+    reset: () => void;
+}
+/**
+ * Hook headless para gerenciar timer
+ */
+export declare function useTimeTracker(options?: UseTimeTrackerOptions): UseTimeTrackerReturn;
+//# sourceMappingURL=useTimeTracker.d.ts.map

package/dist/hooks/useTimeTracker/useTimeTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTimeTracker.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTimeTracker/useTimeTracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAEjC;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAEhC;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAEjC;;OAEG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAElC;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IAErB;;;OAGG;IACH,MAAM,CAAC,EAAE,UAAU,GAAG,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;CACtE;AAED,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;IAElB;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;IAElB;;OAEG;IACH,IAAI,EAAE,MAAM,IAAI,CAAC;IAEjB;;OAEG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;IAEnB;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,oBAAoB,CAyIxF"}