@flowtomic/logic 0.1.7 → 0.1.8

package/dist/hooks/useDashboardLayout/useDashboardLayout.js

@@ -1,175 +0,0 @@
-/**
- * useDashboardLayout - 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 MyDashboard() {
- *   const [widgets, setWidgets] = useState<WidgetLayout[]>([]);
- *   const gridConfig: GridConfig = { columns: 12, cellSize: 50, gap: 16 };
- *
- *   const {
- *     getWidgetGridPosition,
- *     moveWidget,
- *     resizeWidget,
- *     findNextAvailablePosition,
- *   } = useDashboardLayout({
- *     widgetsLayout: widgets,
- *     gridConfig,
- *     onUpdateLayout: setWidgets,
- *   });
- *
- *   return (
- *     <div>
- *       {widgets.map(widget => (
- *         <div style={getWidgetGridPosition(widget)}>
- *           Widget Content
- *         </div>
- *       ))}
- *     </div>
- *   );
- * }
- * ```
- */
-import { useCallback, useMemo } from "react";
-const DEFAULT_GRID_CONFIG = {
-    columns: 12,
-    cellSize: 50,
-    gap: 16,
-};
-/**
- * Hook para gerenciar layout do dashboard
- *
- * Hook headless que fornece apenas lógica de layout, sem UI.
- * Você controla o markup e styles.
- */
-export function useDashboardLayout({ widgetsLayout, gridConfig, onUpdateLayout, }) {
-    // Normaliza gridConfig com defaults
-    const normalizedGridConfig = useMemo(() => {
-        return {
-            ...DEFAULT_GRID_CONFIG,
-            ...gridConfig,
-        };
-    }, [gridConfig]);
-    /**
-     * Calcula posição CSS Grid para um widget
-     */
-    const getWidgetGridPosition = useCallback((widget) => {
-        return {
-            gridColumnStart: widget.x + 1, // CSS Grid é 1-indexed
-            gridColumnEnd: widget.x + widget.w + 1,
-            gridRowStart: widget.y + 1,
-            gridRowEnd: widget.y + widget.h + 1,
-        };
-    }, []);
-    /**
-     * Verifica se uma posição está ocupada
-     */
-    const isPositionOccupied = useCallback((x, y, w, h, excludeWidgetId) => {
-        return widgetsLayout.some((widget) => {
-            if (excludeWidgetId && widget.id === excludeWidgetId) {
-                return false;
-            }
-            // Verifica sobreposição
-            const widgetRight = widget.x + widget.w;
-            const widgetBottom = widget.y + widget.h;
-            const newRight = x + w;
-            const newBottom = y + h;
-            return !(widgetRight <= x ||
-                widget.x >= newRight ||
-                widgetBottom <= y ||
-                widget.y >= newBottom);
-        });
-    }, [widgetsLayout]);
-    /**
-     * Encontra próxima posição disponível
-     */
-    const findNextAvailablePosition = useCallback((w, h) => {
-        const maxColumns = normalizedGridConfig.columns;
-        const maxRows = 100; // Limite razoável
-        for (let y = 0; y < maxRows; y++) {
-            for (let x = 0; x <= maxColumns - w; x++) {
-                if (!isPositionOccupied(x, y, w, h)) {
-                    return { x, y };
-                }
-            }
-        }
-        return null;
-    }, [normalizedGridConfig.columns, isPositionOccupied]);
-    /**
-     * Valida se um widget pode ser movido para uma posição
-     */
-    const canMoveToPosition = useCallback((widgetId, x, y) => {
-        const widget = widgetsLayout.find((w) => w.id === widgetId);
-        if (!widget)
-            return false;
-        // Valida limites do grid
-        if (x < 0 || y < 0)
-            return false;
-        if (x + widget.w > normalizedGridConfig.columns)
-            return false;
-        // Verifica colisões
-        return !isPositionOccupied(x, y, widget.w, widget.h, widgetId);
-    }, [widgetsLayout, normalizedGridConfig.columns, isPositionOccupied]);
-    /**
-     * Valida se um widget pode ser redimensionado
-     */
-    const canResize = useCallback((widgetId, newW, newH) => {
-        const widget = widgetsLayout.find((w) => w.id === widgetId);
-        if (!widget)
-            return false;
-        // Valida tamanhos mínimos e máximos
-        if (newW < 2 || newH < 2)
-            return false; // Mínimo 2x2
-        if (newW > normalizedGridConfig.columns)
-            return false;
-        if (newH > 20)
-            return false; // Máximo 20 linhas
-        // Valida limites do grid
-        if (widget.x + newW > normalizedGridConfig.columns)
-            return false;
-        // Verifica colisões
-        return !isPositionOccupied(widget.x, widget.y, newW, newH, widgetId);
-    }, [widgetsLayout, normalizedGridConfig.columns, isPositionOccupied]);
-    /**
-     * Move widget para nova posição
-     */
-    const moveWidget = useCallback((widgetId, x, y) => {
-        if (!canMoveToPosition(widgetId, x, y)) {
-            return;
-        }
-        const updatedLayout = widgetsLayout.map((widget) => widget.id === widgetId ? { ...widget, x, y } : widget);
-        onUpdateLayout(updatedLayout);
-    }, [widgetsLayout, canMoveToPosition, onUpdateLayout]);
-    /**
-     * Redimensiona widget
-     */
-    const resizeWidget = useCallback((widgetId, w, h) => {
-        if (!canResize(widgetId, w, h)) {
-            return;
-        }
-        const updatedLayout = widgetsLayout.map((widget) => widget.id === widgetId ? { ...widget, w, h } : widget);
-        onUpdateLayout(updatedLayout);
-    }, [widgetsLayout, canResize, onUpdateLayout]);
-    /**
-     * Atualiza layout completo
-     */
-    const updateLayout = useCallback((layout) => {
-        onUpdateLayout(layout);
-    }, [onUpdateLayout]);
-    return {
-        gridConfig: normalizedGridConfig,
-        getWidgetGridPosition,
-        isPositionOccupied,
-        findNextAvailablePosition,
-        canMoveToPosition,
-        canResize,
-        moveWidget,
-        resizeWidget,
-        updateLayout,
-    };
-}

package/dist/hooks/useGenealogy/index.js

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

package/dist/hooks/useGenealogy/useGenealogy.js

@@ -1,341 +0,0 @@
-/**
- * useGenealogy - Headless UI Hook
- *
- * Fornece apenas: lógica, estado, processamento e API para árvores genealógicas
- * NÃO fornece: markup, styles ou implementações pré-construídas
- *
- * Padrão Headless UI: você controla o markup e styles
- */
-import { useCallback, useMemo, useState } from "react";
-/**
- * Calcula o nível (geração) de cada entidade na hierarquia
- * Retorna um Map com entityId -> nível (0 = raiz, 1 = filhos da raiz, etc)
- */
-function calculateLevels(hierarchy) {
-    const levels = new Map();
-    const visited = new Set();
-    // Função recursiva para calcular nível
-    const calculateLevel = (entityId) => {
-        const cachedLevel = levels.get(entityId);
-        if (cachedLevel !== undefined) {
-            return cachedLevel;
-        }
-        if (visited.has(entityId)) {
-            // Ciclo detectado, retornar 0 como fallback
-            return 0;
-        }
-        visited.add(entityId);
-        const entityHierarchy = hierarchy.get(entityId);
-        if (!entityHierarchy || entityHierarchy.parents.length === 0) {
-            // Sem pais = raiz (nível 0)
-            levels.set(entityId, 0);
-            return 0;
-        }
-        // Nível = nível do pai mais alto + 1
-        const parentLevels = entityHierarchy.parents.map((parent) => calculateLevel(parent.id));
-        const maxParentLevel = Math.max(...parentLevels);
-        const level = maxParentLevel + 1;
-        levels.set(entityId, level);
-        return level;
-    };
-    // Calcular nível para todas as entidades
-    hierarchy.forEach((_, entityId) => {
-        calculateLevel(entityId);
-    });
-    return levels;
-}
-/**
- * Organiza entidades por nível (geração) e calcula posições hierárquicas
- */
-function calculateHierarchicalPositions(_data, hierarchy, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing) {
-    const positions = new Map();
-    const levels = calculateLevels(hierarchy);
-    // Agrupar entidades por nível
-    const entitiesByLevel = new Map();
-    levels.forEach((level, entityId) => {
-        if (!entitiesByLevel.has(level)) {
-            entitiesByLevel.set(level, []);
-        }
-        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)
-        const y = level * (nodeHeight + verticalSpacing);
-        // Para cada entidade, tentar centralizar abaixo dos pais
-        entityIds.forEach((entityId) => {
-            const entityHierarchy = hierarchy.get(entityId);
-            let x = 0;
-            if (entityHierarchy && entityHierarchy.parents.length > 0) {
-                // Calcular posição média dos pais
-                const parentPositions = entityHierarchy.parents
-                    .map((parent) => positions.get(parent.id))
-                    .filter((pos) => pos !== undefined);
-                if (parentPositions.length > 0) {
-                    const avgX = parentPositions.reduce((sum, pos) => sum + pos.x, 0) / parentPositions.length;
-                    x = avgX;
-                }
-            }
-            // Se não tem pais ou não conseguiu calcular, distribuir horizontalmente
-            if (x === 0 && entityIds.length > 1) {
-                const index = entityIds.indexOf(entityId);
-                const totalWidth = entityIds.length * nodeWidth + (entityIds.length - 1) * horizontalSpacing;
-                const startX = -totalWidth / 2 + nodeWidth / 2;
-                x = startX + index * (nodeWidth + horizontalSpacing);
-            }
-            positions.set(entityId, { x, y });
-        });
-        // Ajustar posições para evitar sobreposição
-        entityIds.forEach((entityId, index) => {
-            const currentPos = positions.get(entityId);
-            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;
-                }
-            });
-        });
-    });
-    return positions;
-}
-/**
- * Gera nodes do ReactFlow a partir dos dados de genealogia
- */
-function generateNodes(data, hierarchy, expansionState, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing) {
-    const nodes = [];
-    // Calcular posições hierárquicas
-    const positions = calculateHierarchicalPositions(data, hierarchy, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing);
-    // Criar nodes com posições calculadas
-    data.people.forEach((entity) => {
-        const position = positions.get(entity.id) || { x: 0, y: 0 };
-        const entityHierarchy = hierarchy.get(entity.id);
-        nodes.push({
-            id: entity.id,
-            type: "genealogy",
-            position,
-            data: {
-                person: entity,
-                hierarchy: entityHierarchy,
-                isExpanded: expansionState[entity.id] ?? false,
-            },
-        });
-    });
-    return nodes;
-}
-/**
- * Gera edges do ReactFlow a partir dos relacionamentos
- * Para hierarquia vertical: source (pai) -> target (filho)
- */
-function generateEdges(data, hierarchy, expansionState) {
-    const edges = [];
-    const edgeIds = new Set();
-    data.relationships.forEach((relationship) => {
-        // Determinar source e target baseado no tipo de relacionamento
-        let source;
-        let target;
-        switch (relationship.type) {
-            case "father":
-            case "mother": {
-                // from é pai/mãe de to
-                // source = pai (from), target = filho (to)
-                source = relationship.from;
-                target = relationship.to;
-                break;
-            }
-            case "child": {
-                // from é filho de to
-                // source = pai (to), target = filho (from)
-                source = relationship.to;
-                target = relationship.from;
-                break;
-            }
-            default: {
-                source = relationship.from;
-                target = relationship.to;
-            }
-        }
-        // Criar edge ID único
-        const edgeId = `e-${source}-${target}-${relationship.type}`;
-        // Evitar duplicatas
-        if (edgeIds.has(edgeId)) {
-            return;
-        }
-        edgeIds.add(edgeId);
-        // Verificar se ambos os nós existem
-        const sourceHierarchy = hierarchy.get(source);
-        const targetHierarchy = hierarchy.get(target);
-        if (!sourceHierarchy || !targetHierarchy) {
-            return;
-        }
-        // Só criar edge se ambos os nós estiverem visíveis (expandidos ou raiz)
-        const sourceExpanded = expansionState[source] ?? true;
-        const targetExpanded = expansionState[target] ?? true;
-        // Para relacionamentos pai/filho, só mostrar se o nó pai estiver expandido
-        if (relationship.type === "father" ||
-            relationship.type === "mother" ||
-            relationship.type === "child") {
-            if (!sourceExpanded || !targetExpanded)
-                return;
-        }
-        edges.push({
-            id: edgeId,
-            source,
-            target,
-            type: "animated",
-            data: {
-                relationship,
-            },
-        });
-    });
-    return edges;
-}
-/**
- * Constrói hierarquia de entidades a partir dos dados
- */
-function buildHierarchy(data) {
-    const hierarchy = new Map();
-    // Inicializar todas as entidades
-    data.people.forEach((entity) => {
-        hierarchy.set(entity.id, {
-            person: entity,
-            parents: [],
-            children: [],
-            adoptions: [],
-            siblings: [],
-        });
-    });
-    // Processar relacionamentos
-    data.relationships.forEach((relationship) => {
-        const fromHierarchy = hierarchy.get(relationship.from);
-        const toHierarchy = hierarchy.get(relationship.to);
-        if (!fromHierarchy || !toHierarchy)
-            return;
-        switch (relationship.type) {
-            case "father":
-            case "mother": {
-                // from é pai/mãe de to
-                if (!toHierarchy.parents.find((p) => p.id === relationship.from)) {
-                    toHierarchy.parents.push(fromHierarchy.person);
-                }
-                if (relationship.type === "father") {
-                    toHierarchy.father = fromHierarchy.person;
-                }
-                else if (relationship.type === "mother") {
-                    toHierarchy.mother = fromHierarchy.person;
-                }
-                if (!fromHierarchy.children.find((c) => c.id === relationship.to)) {
-                    fromHierarchy.children.push(toHierarchy.person);
-                }
-                break;
-            }
-            case "child": {
-                // from é filho de to
-                if (!toHierarchy.children.find((c) => c.id === relationship.from)) {
-                    toHierarchy.children.push(fromHierarchy.person);
-                }
-                if (!fromHierarchy.parents.find((p) => p.id === relationship.to)) {
-                    fromHierarchy.parents.push(toHierarchy.person);
-                }
-                break;
-            }
-        }
-    });
-    // Calcular irmãos (pessoas com os mesmos pais)
-    hierarchy.forEach((personHierarchy) => {
-        if (personHierarchy.parents.length > 0) {
-            const parentIds = personHierarchy.parents.map((p) => p.id);
-            hierarchy.forEach((otherHierarchy, otherId) => {
-                if (otherId !== personHierarchy.person.id) {
-                    const hasCommonParent = otherHierarchy.parents.some((p) => parentIds.includes(p.id));
-                    if (hasCommonParent && !personHierarchy.siblings.find((s) => s.id === otherId)) {
-                        personHierarchy.siblings.push(otherHierarchy.person);
-                    }
-                }
-            });
-        }
-    });
-    return hierarchy;
-}
-/**
- * Hook headless para gerenciar árvores genealógicas
- */
-export function useGenealogy({ data, initialExpanded = [], nodeWidth = 200, nodeHeight = 100, horizontalSpacing = 250, verticalSpacing = 150, onNodeSelect, onNodeExpand, onAddRelation, }) {
-    // Estado de expansão dos nós
-    const [expansionState, setExpansionState] = useState(() => {
-        const state = {};
-        initialExpanded.forEach((id) => {
-            state[id] = true;
-        });
-        return state;
-    });
-    // Estado de seleção
-    const [selectedNodeId, setSelectedNodeId] = useState(null);
-    // Construir hierarquia
-    const hierarchy = useMemo(() => buildHierarchy(data), [data]);
-    // Gerar nodes e edges
-    const nodes = useMemo(() => generateNodes(data, hierarchy, expansionState, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing), [data, hierarchy, expansionState, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing]);
-    const edges = useMemo(() => generateEdges(data, hierarchy, expansionState), [data, hierarchy, expansionState]);
-    // Função para selecionar um nó
-    const selectNode = useCallback((nodeId) => {
-        setSelectedNodeId(nodeId);
-        const entity = data.people.find((p) => p.id === nodeId);
-        if (entity && onNodeSelect) {
-            onNodeSelect(nodeId, entity);
-        }
-    }, [data.people, onNodeSelect]);
-    // Função para expandir/colapsar um nó
-    const expandNode = useCallback((nodeId, expanded) => {
-        setExpansionState((prev) => {
-            const newState = { ...prev };
-            const isCurrentlyExpanded = prev[nodeId] ?? false;
-            newState[nodeId] = expanded ?? !isCurrentlyExpanded;
-            if (onNodeExpand) {
-                onNodeExpand(nodeId, newState[nodeId]);
-            }
-            return newState;
-        });
-    }, [onNodeExpand]);
-    // Função para colapsar um nó
-    const collapseNode = useCallback((nodeId) => {
-        expandNode(nodeId, false);
-    }, [expandNode]);
-    // Função para adicionar relacionamento
-    const addRelation = useCallback((fromId, toId, type) => {
-        if (onAddRelation) {
-            onAddRelation(fromId, toId, type);
-        }
-    }, [onAddRelation]);
-    // Função para obter hierarquia de uma pessoa
-    const getPersonHierarchy = useCallback((personId) => {
-        return hierarchy.get(personId);
-    }, [hierarchy]);
-    // Função para obter relacionamentos de uma pessoa
-    const getPersonRelations = useCallback((personId) => {
-        return data.relationships.filter((r) => r.from === personId || r.to === personId);
-    }, [data.relationships]);
-    return {
-        nodes,
-        edges,
-        hierarchy,
-        selectedNodeId,
-        expansionState,
-        selectNode,
-        expandNode,
-        collapseNode,
-        addRelation,
-        getPersonHierarchy,
-        getPersonRelations,
-    };
-}

package/dist/hooks/useMoblile/index.js

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

package/dist/hooks/useMoblile/useMobile.js

@@ -1,15 +0,0 @@
-import * as React from "react";
-const MOBILE_BREAKPOINT = 768;
-export function useIsMobile() {
-    const [isMobile, setIsMobile] = React.useState(undefined);
-    React.useEffect(() => {
-        const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
-        const onChange = () => {
-            setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
-        };
-        mql.addEventListener("change", onChange);
-        setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
-        return () => mql.removeEventListener("change", onChange);
-    }, []);
-    return !!isMobile;
-}

package/dist/hooks/useProjectProgress/index.js

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

package/dist/hooks/useProjectProgress/useProjectProgress.js

@@ -1,124 +0,0 @@
-/**
- * useProjectProgress - 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 MyProjectProgress() {
- *   const { percentage, status, distribution } = useProjectProgress({
- *     projects: [
- *       { id: '1', status: 'completed', ... },
- *       { id: '2', status: 'in-progress', ... },
- *       { id: '3', status: 'pending', ... },
- *     ],
- *   })
- *
- *   return (
- *     <div>
- *       <div>Progress: {percentage}%</div>
- *       <div>Status: {status}</div>
- *     </div>
- *   )
- * }
- * ```
- */
-import { useMemo } from "react";
-/**
- * Calcula progresso padrão baseado no status
- */
-function getDefaultProgress(project) {
-    if (project.progress !== undefined) {
-        return project.progress;
-    }
-    switch (project.status) {
-        case "completed":
-            return 100;
-        case "in-progress":
-            return 50; // Valor padrão para projetos em progresso
-        case "pending":
-            return 0;
-        case "on-hold":
-            return 0;
-        default:
-            return 0;
-    }
-}
-/**
- * Hook headless para calcular progresso de projetos
- */
-export function useProjectProgress(options) {
-    const { projects, calculateProgress = getDefaultProgress } = options;
-    const result = useMemo(() => {
-        if (projects.length === 0) {
-            return {
-                percentage: 0,
-                status: "pending",
-                distribution: {
-                    completed: 0,
-                    inProgress: 0,
-                    pending: 0,
-                    onHold: 0,
-                },
-                total: 0,
-                completed: 0,
-                inProgress: 0,
-                pending: 0,
-                onHold: 0,
-            };
-        }
-        // Calcular distribuição
-        const distribution = {
-            completed: 0,
-            inProgress: 0,
-            pending: 0,
-            onHold: 0,
-        };
-        let totalProgress = 0;
-        projects.forEach((project) => {
-            const progress = calculateProgress(project);
-            totalProgress += progress;
-            switch (project.status) {
-                case "completed":
-                    distribution.completed++;
-                    break;
-                case "in-progress":
-                    distribution.inProgress++;
-                    break;
-                case "pending":
-                    distribution.pending++;
-                    break;
-                case "on-hold":
-                    distribution.onHold++;
-                    break;
-            }
-        });
-        // Calcular porcentagem média
-        const percentage = Math.round(totalProgress / projects.length);
-        // Determinar status geral
-        let status = "pending";
-        if (distribution.completed === projects.length) {
-            status = "completed";
-        }
-        else if (distribution.inProgress > 0 || distribution.completed > 0) {
-            status = "in-progress";
-        }
-        else if (distribution.onHold > 0) {
-            status = "on-hold";
-        }
-        return {
-            percentage,
-            status,
-            distribution,
-            total: projects.length,
-            completed: distribution.completed,
-            inProgress: distribution.inProgress,
-            pending: distribution.pending,
-            onHold: distribution.onHold,
-        };
-    }, [projects, calculateProgress]);
-    return result;
-}

package/dist/hooks/useProjectStats/index.js

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