@flowtomic/logic 0.1.7 → 0.1.8

package/dist/hooks/useScriptEditor/useScriptEditor.js

@@ -1,247 +0,0 @@
-/**
- * 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/index.js

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

package/dist/hooks/useStatCard/useStatCard.js

@@ -1,187 +0,0 @@
-/**
- * useStatCard - 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
- * // Cálculo automático do delta a partir de lastMonth
- * function MyCustomStatCard() {
- *   const { formattedValue, trend, getCardProps } = useStatCard({
- *     value: 122380,
- *     lastMonth: 105922, // delta será calculado automaticamente: +15.5%
- *   })
- *
- *   return (
- *     <div {...getCardProps()}>
- *       <span>{formattedValue}</span>
- *       <Badge>{trend.percentage}</Badge>
- *     </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 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, locale = "pt-BR") {
-    if (n >= 1_000_000) {
-        const formatter = new Intl.NumberFormat(locale, {
-            minimumFractionDigits: 1,
-            maximumFractionDigits: 1,
-        });
-        return `${formatter.format(n / 1_000_000)}M`;
-    }
-    if (n >= 1_000) {
-        return new Intl.NumberFormat(locale).format(n);
-    }
-    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
- *
- * Fornece apenas a lógica e API, sem markup ou styles.
- * Você é responsável por criar o visual.
- *
- * @example
- * ```tsx
- * // Cálculo automático do delta a partir de lastMonth
- * function MyCustomStatCard() {
- *   const { formattedValue, trend, getCardProps } = useStatCard({
- *     value: 122380,
- *     lastMonth: 105922, // delta será calculado automaticamente: +15.5%
- *   })
- *
- *   return (
- *     <div {...getCardProps()}>
- *       <span>{formattedValue}</span>
- *       <Badge variant={trend.variant}>{trend.percentage}</Badge>
- *     </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: 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) {
-            return explicitPositive;
-        }
-        return delta >= 0;
-    }, [delta, explicitPositive]);
-    // Calcula informações da tendência
-    const trend = useMemo(() => {
-        const direction = delta > 0 ? "up" : delta < 0 ? "down" : "neutral";
-        const variant = direction === "up" ? "success" : direction === "down" ? "destructive" : "secondary";
-        const percentage = delta > 0 ? `+${delta.toFixed(1)}%` : delta < 0 ? `${delta.toFixed(1)}%` : "0%";
-        return {
-            isPositive,
-            percentage,
-            delta: Math.abs(delta),
-            variant,
-            direction,
-        };
-    }, [delta, isPositive]);
-    // Formata o valor principal
-    const formattedValue = useMemo(() => {
-        if (format) {
-            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}` : ""));
-        }
-        // 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)
-            return null;
-        if (lastFormat) {
-            return lastFormat(lastMonth);
-        }
-        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 {
-            onClick: props.onClick,
-            className: props.className,
-            "aria-label": props["aria-label"] || `Estatística: ${formattedValue}`,
-            role: props.onClick ? "button" : undefined,
-        };
-    }, [formattedValue]);
-    // Função utilitária de formatação
-    const formatNumber = useCallback((n) => {
-        if (currency) {
-            return formatCurrency(n, locale, currency, currencyDisplay);
-        }
-        return formatNumberDefault(n, locale);
-    }, [locale, currency, currencyDisplay]);
-    return {
-        formattedValue,
-        formattedLastMonth,
-        trend,
-        isPositive,
-        getCardProps,
-        formatNumber,
-    };
-}

package/dist/hooks/useThemeTransition/index.js

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

package/dist/hooks/useThemeTransition/useThemeTransition.js

@@ -1,35 +0,0 @@
-/**
- * useThemeTransition - Hook para View Transitions API
- *
- * Gerencia transições suaves de tema usando a View Transitions API
- * com fallback automático para navegadores que não suportam
- */
-import { useCallback } from "react";
-/**
- * Hook para gerenciar transições de tema com View Transitions API
- *
- * @example
- * ```tsx
- * const { startTransition } = useThemeTransition()
- *
- * const handleToggle = () => {
- *   startTransition(() => {
- *     toggleTheme()
- *   })
- * }
- * ```
- */
-export function useThemeTransition() {
-    const startTransition = useCallback((updateFn) => {
-        // Verifica se View Transitions API está disponível
-        if (typeof document !== "undefined" && "startViewTransition" in document) {
-            const doc = document;
-            doc.startViewTransition?.(updateFn);
-        }
-        else {
-            // Fallback: executa diretamente sem animação
-            updateFn();
-        }
-    }, []);
-    return { startTransition };
-}

package/dist/hooks/useTimeTracker/index.js

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

package/dist/hooks/useTimeTracker/useTimeTracker.js

@@ -1,143 +0,0 @@
-/**
- * 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>
- *   )
- * }
- * ```
- */
-import { useCallback, useEffect, useRef, useState } from "react";
-/**
- * Hook headless para gerenciar timer
- */
-export function useTimeTracker(options = {}) {
-    const { initialTime = 0, onPause, onStop, onStart, onResume, onReset, format = "HH:mm:ss", } = options;
-    const [time, setTime] = useState(initialTime);
-    const [isRunning, setIsRunning] = useState(false);
-    const [isPaused, setIsPaused] = useState(false);
-    const intervalRef = useRef(null);
-    const startTimeRef = useRef(null);
-    const pausedTimeRef = useRef(0);
-    // Limpar intervalo ao desmontar
-    useEffect(() => {
-        return () => {
-            if (intervalRef.current) {
-                clearInterval(intervalRef.current);
-                intervalRef.current = null;
-            }
-        };
-    }, []);
-    // Formatar tempo
-    const formatTime = useCallback((seconds) => {
-        if (typeof format === "function") {
-            return format(seconds);
-        }
-        const hours = Math.floor(seconds / 3600);
-        const minutes = Math.floor((seconds % 3600) / 60);
-        const secs = seconds % 60;
-        switch (format) {
-            case "HH:mm:ss":
-                return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(secs).padStart(2, "0")}`;
-            case "mm:ss":
-                return `${String(minutes).padStart(2, "0")}:${String(secs).padStart(2, "0")}`;
-            case "ss":
-                return String(seconds);
-            default:
-                return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(secs).padStart(2, "0")}`;
-        }
-    }, [format]);
-    const formattedTime = formatTime(time);
-    // Limpar intervalo
-    const clearTimerInterval = useCallback(() => {
-        if (intervalRef.current) {
-            clearInterval(intervalRef.current);
-            intervalRef.current = null;
-        }
-    }, []);
-    // Iniciar timer
-    const start = useCallback(() => {
-        if (isRunning)
-            return;
-        clearTimerInterval();
-        // Se estava pausado, continuar de onde parou
-        const startFrom = isPaused ? time : initialTime;
-        setTime(startFrom);
-        setIsRunning(true);
-        setIsPaused(false);
-        pausedTimeRef.current = startFrom;
-        startTimeRef.current = Date.now() - startFrom * 1000;
-        intervalRef.current = setInterval(() => {
-            const elapsed = Math.floor((Date.now() - (startTimeRef.current || 0)) / 1000);
-            setTime(elapsed);
-        }, 100);
-        if (!isPaused) {
-            onStart?.(startFrom);
-        }
-        else {
-            onResume?.(startFrom);
-        }
-    }, [isRunning, isPaused, time, initialTime, onStart, onResume, clearTimerInterval]);
-    // Pausar timer
-    const pause = useCallback(() => {
-        if (!isRunning)
-            return;
-        clearTimerInterval();
-        setIsRunning(false);
-        setIsPaused(true);
-        onPause?.(time);
-    }, [isRunning, time, onPause, clearTimerInterval]);
-    // Parar timer
-    const stop = useCallback(() => {
-        clearTimerInterval();
-        setIsRunning(false);
-        setIsPaused(false);
-        onStop?.(time);
-    }, [time, onStop, clearTimerInterval]);
-    // Retomar timer
-    const resume = useCallback(() => {
-        if (!isPaused)
-            return;
-        start();
-    }, [isPaused, start]);
-    // Resetar timer
-    const reset = useCallback(() => {
-        clearTimerInterval();
-        setTime(initialTime);
-        setIsRunning(false);
-        setIsPaused(false);
-        pausedTimeRef.current = 0;
-        startTimeRef.current = null;
-        onReset?.();
-    }, [initialTime, onReset, clearTimerInterval]);
-    return {
-        time,
-        formattedTime,
-        isRunning,
-        isPaused,
-        isStopped: !isRunning && !isPaused,
-        start,
-        pause,
-        stop,
-        resume,
-        reset,
-    };
-}