@flowtomic/logic 0.1.1 → 0.1.3

package/dist/hooks/useGenealogy/useGenealogy.js

@@ -16,8 +16,9 @@ function calculateLevels(hierarchy) {
     const visited = new Set();
     // Função recursiva para calcular nível
     const calculateLevel = (entityId) => {
-        if (levels.has(entityId)) {
-            return levels.get(entityId);
+        const cachedLevel = levels.get(entityId);
+        if (cachedLevel !== undefined) {
+            return cachedLevel;
         }
         if (visited.has(entityId)) {
             // Ciclo detectado, retornar 0 como fallback
@@ -46,7 +47,7 @@ function calculateLevels(hierarchy) {
 /**
  * Organiza entidades por nível (geração) e calcula posições hierárquicas
  */
-function calculateHierarchicalPositions(data, hierarchy, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing) {
+function calculateHierarchicalPositions(_data, hierarchy, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing) {
     const positions = new Map();
     const levels = calculateLevels(hierarchy);
     // Agrupar entidades por nível
@@ -55,12 +56,14 @@ function calculateHierarchicalPositions(data, hierarchy, nodeWidth, nodeHeight,
         if (!entitiesByLevel.has(level)) {
             entitiesByLevel.set(level, []);
         }
-        entitiesByLevel.get(level).push(entityId);
+        entitiesByLevel.get(level)?.push(entityId);
     });
     // Calcular posições para cada nível, começando do nível 0 (raiz)
     const sortedLevels = Array.from(entitiesByLevel.keys()).sort((a, b) => a - b);
     sortedLevels.forEach((level) => {
         const entityIds = entitiesByLevel.get(level);
+        if (!entityIds)
+            return;
         // Ordenar entidades do mesmo nível (por ID para consistência)
         entityIds.sort();
         // Calcular posição Y baseada no nível (pais acima, filhos abaixo)
@@ -91,10 +94,13 @@ function calculateHierarchicalPositions(data, hierarchy, nodeWidth, nodeHeight,
         // Ajustar posições para evitar sobreposição
         entityIds.forEach((entityId, index) => {
             const currentPos = positions.get(entityId);
-            const minX = currentPos.x;
+            if (!currentPos)
+                return;
             // Verificar se há sobreposição com outros nós do mesmo nível
             entityIds.slice(0, index).forEach((otherId) => {
                 const otherPos = positions.get(otherId);
+                if (!otherPos)
+                    return;
                 if (Math.abs(currentPos.x - otherPos.x) < nodeWidth + horizontalSpacing) {
                     // Ajustar para evitar sobreposição
                     currentPos.x = otherPos.x + nodeWidth + horizontalSpacing;

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

@@ -0,0 +1,3 @@
+export type { ExecuteScriptResponse, TerminalLine, UseScriptEditorOptions, UseScriptEditorReturn, } from "./useScriptEditor";
+export { useScriptEditor } from "./useScriptEditor";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/useScriptEditor/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,qBAAqB,EACrB,YAAY,EACZ,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/hooks/useScriptEditor/index.js

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

package/dist/hooks/useScriptEditor/useScriptEditor.d.ts

@@ -0,0 +1,147 @@
+/**
+ * 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>
+ *   );
+ * }
+ * ```
+ */
+export interface TerminalLine {
+    id: string;
+    type: "input" | "output" | "error" | "system";
+    content: string;
+    timestamp: Date;
+}
+export interface ExecuteScriptResponse {
+    output?: string;
+    error?: string;
+    result?: unknown;
+}
+export interface UseScriptEditorOptions {
+    /**
+     * URL do WebSocket para conexão em tempo real
+     * @default undefined
+     */
+    wsUrl?: string;
+    /**
+     * Função para executar script via HTTP (fallback quando WebSocket não está disponível)
+     * @default undefined
+     */
+    executeScript?: (script: string) => Promise<ExecuteScriptResponse>;
+    /**
+     * Callback quando uma linha é adicionada ao terminal
+     */
+    onOutput?: (line: TerminalLine) => void;
+    /**
+     * Callback quando ocorre um erro
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Se deve conectar automaticamente ao WebSocket
+     * @default true
+     */
+    autoConnect?: boolean;
+    /**
+     * Número máximo de tentativas de reconexão
+     * @default 3
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Script inicial
+     * @default ""
+     */
+    defaultScript?: string;
+}
+export interface UseScriptEditorReturn {
+    /**
+     * Script atual
+     */
+    script: string;
+    /**
+     * Atualizar script
+     */
+    setScript: (script: string) => void;
+    /**
+     * Linhas do terminal
+     */
+    terminalLines: TerminalLine[];
+    /**
+     * Preview formatado (JSON)
+     */
+    preview: string;
+    /**
+     * Aba ativa (terminal ou preview)
+     */
+    activeTab: "terminal" | "preview";
+    /**
+     * Mudar aba ativa
+     */
+    setActiveTab: (tab: "terminal" | "preview") => void;
+    /**
+     * Se o script está sendo executado
+     */
+    isRunning: boolean;
+    /**
+     * Se o WebSocket está conectado
+     */
+    isConnected: boolean;
+    /**
+     * Executar script
+     */
+    executeScript: () => Promise<void>;
+    /**
+     * Parar execução
+     */
+    stopExecution: () => void;
+    /**
+     * Limpar terminal e preview
+     */
+    clearTerminal: () => void;
+    /**
+     * Adicionar linha ao terminal manualmente
+     */
+    addTerminalLine: (type: TerminalLine["type"], content: string) => void;
+}
+/**
+ * Hook headless para gerenciar editor de scripts com terminal interativo
+ */
+export declare function useScriptEditor(options?: UseScriptEditorOptions): UseScriptEditorReturn;
+//# sourceMappingURL=useScriptEditor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useScriptEditor.d.ts","sourceRoot":"","sources":["../../../src/hooks/useScriptEditor/useScriptEditor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAIH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAEnE;;OAEG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;IAExC;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEjC;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAEpC;;OAEG;IACH,aAAa,EAAE,YAAY,EAAE,CAAC;IAE9B;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,SAAS,EAAE,UAAU,GAAG,SAAS,CAAC;IAElC;;OAEG;IACH,YAAY,EAAE,CAAC,GAAG,EAAE,UAAU,GAAG,SAAS,KAAK,IAAI,CAAC;IAEpD;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnC;;OAEG;IACH,aAAa,EAAE,MAAM,IAAI,CAAC;IAE1B;;OAEG;IACH,aAAa,EAAE,MAAM,IAAI,CAAC;IAE1B;;OAEG;IACH,eAAe,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACxE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,qBAAqB,CAoO3F"}

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/index.d.ts

@@ -12,6 +12,8 @@ export * from "./hooks/useProjectStats";
 export * from "./hooks/useReactTableBack";
 export * from "./hooks/useReactTableFront";
 export * from "./hooks/useResizable";
+export * from "./hooks/useScriptEditor";
 export * from "./hooks/useStatCard";
 export * from "./hooks/useTimeTracker";
+export * from "./hooks/useAutocomplete";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AAErC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AAErC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC"}