@flowtomic/logic 0.1.0 → 0.1.1

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

@@ -0,0 +1,3 @@
+export type { IndicatorStyle, UseAnimatedIndicatorOptions, UseAnimatedIndicatorReturn, } from "./useAnimatedIndicator";
+export { useAnimatedIndicator } from "./useAnimatedIndicator";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAnimatedIndicator/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,cAAc,EACd,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/hooks/useAnimatedIndicator/index.js

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

package/dist/hooks/useAnimatedIndicator/useAnimatedIndicator.d.ts

@@ -0,0 +1,94 @@
+/**
+ * useAnimatedIndicator - Headless UI Hook
+ *
+ * Hook reutilizável para animação de indicador que se move entre elementos
+ * Fornece apenas: lógica, estado e cálculos de posição
+ * NÃO fornece: markup, styles ou implementações pré-construídas
+ *
+ * Padrão Headless UI: você controla o markup e styles
+ */
+export interface IndicatorStyle {
+    left: number;
+    width: number;
+    height: number;
+    top: number;
+    opacity: number;
+}
+export interface UseAnimatedIndicatorOptions {
+    /**
+     * Container que contém os elementos
+     */
+    containerRef: React.RefObject<HTMLElement>;
+    /**
+     * Seletor CSS para encontrar o elemento ativo (ex: '[data-state="active"]')
+     * @default '[data-state="active"]'
+     */
+    activeSelector?: string;
+    /**
+     * Callback para obter o valor/identificador do elemento
+     * Se não fornecido, usa o atributo 'data-value' ou busca no Map
+     */
+    getElementValue?: (element: HTMLElement) => string;
+    /**
+     * Se deve atualizar automaticamente quando o container é redimensionado
+     * @default true
+     */
+    updateOnResize?: boolean;
+}
+export interface UseAnimatedIndicatorReturn {
+    /**
+     * Estilo do indicador (posição e dimensões)
+     */
+    indicatorStyle: IndicatorStyle;
+    /**
+     * Registra um elemento para rastreamento
+     */
+    registerElement: (element: HTMLElement | null, value: string) => void;
+    /**
+     * Remove um elemento do rastreamento
+     */
+    unregisterElement: (value: string) => void;
+    /**
+     * Força atualização do indicador
+     */
+    updateIndicator: () => void;
+    /**
+     * Valor do elemento ativo
+     */
+    activeValue: string | undefined;
+}
+/**
+ * Hook headless para animação de indicador
+ *
+ * @example
+ * ```tsx
+ * const containerRef = useRef<HTMLDivElement>(null);
+ * const { indicatorStyle, registerElement, unregisterElement } = useAnimatedIndicator({
+ *   containerRef,
+ *   activeSelector: '[data-state="active"]',
+ * });
+ *
+ * return (
+ *   <div ref={containerRef}>
+ *     {items.map((item) => (
+ *       <button
+ *         ref={(el) => registerElement(el, item.id)}
+ *         data-state={isActive ? "active" : "inactive"}
+ *       >
+ *         {item.label}
+ *       </button>
+ *     ))}
+ *     <motion.div
+ *       style={{
+ *         left: `${indicatorStyle.left}px`,
+ *         top: `${indicatorStyle.top}px`,
+ *         width: indicatorStyle.width,
+ *         height: indicatorStyle.height,
+ *       }}
+ *     />
+ *   </div>
+ * );
+ * ```
+ */
+export declare function useAnimatedIndicator(options: UseAnimatedIndicatorOptions): UseAnimatedIndicatorReturn;
+//# sourceMappingURL=useAnimatedIndicator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAnimatedIndicator.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAnimatedIndicator/useAnimatedIndicator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,2BAA2B;IAC1C;;OAEG;IACH,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;IAC3C;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,MAAM,CAAC;IACnD;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,0BAA0B;IACzC;;OAEG;IACH,cAAc,EAAE,cAAc,CAAC;IAC/B;;OAEG;IACH,eAAe,EAAE,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACtE;;OAEG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C;;OAEG;IACH,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B;;OAEG;IACH,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,2BAA2B,GACnC,0BAA0B,CA+N5B"}

package/dist/hooks/useAnimatedIndicator/useAnimatedIndicator.js

@@ -0,0 +1,228 @@
+/**
+ * useAnimatedIndicator - Headless UI Hook
+ *
+ * Hook reutilizável para animação de indicador que se move entre elementos
+ * Fornece apenas: lógica, estado e cálculos de posição
+ * NÃO fornece: markup, styles ou implementações pré-construídas
+ *
+ * Padrão Headless UI: você controla o markup e styles
+ */
+import { useCallback, useEffect, useRef, useState } from "react";
+/**
+ * Hook headless para animação de indicador
+ *
+ * @example
+ * ```tsx
+ * const containerRef = useRef<HTMLDivElement>(null);
+ * const { indicatorStyle, registerElement, unregisterElement } = useAnimatedIndicator({
+ *   containerRef,
+ *   activeSelector: '[data-state="active"]',
+ * });
+ *
+ * return (
+ *   <div ref={containerRef}>
+ *     {items.map((item) => (
+ *       <button
+ *         ref={(el) => registerElement(el, item.id)}
+ *         data-state={isActive ? "active" : "inactive"}
+ *       >
+ *         {item.label}
+ *       </button>
+ *     ))}
+ *     <motion.div
+ *       style={{
+ *         left: `${indicatorStyle.left}px`,
+ *         top: `${indicatorStyle.top}px`,
+ *         width: indicatorStyle.width,
+ *         height: indicatorStyle.height,
+ *       }}
+ *     />
+ *   </div>
+ * );
+ * ```
+ */
+export function useAnimatedIndicator(options) {
+    const { containerRef, activeSelector = '[data-state="active"]', getElementValue, updateOnResize = true, } = options;
+    const elementsRef = useRef(new Map());
+    const updateTimeoutRef = useRef(null);
+    const activeValueRef = useRef(undefined);
+    const [indicatorStyle, setIndicatorStyle] = useState({
+        left: 0,
+        width: 0,
+        height: 0,
+        top: 0,
+        opacity: 0,
+    });
+    const [activeValue, setActiveValue] = useState();
+    // Sincronizar ref com state
+    useEffect(() => {
+        activeValueRef.current = activeValue;
+    }, [activeValue]);
+    const updateIndicator = useCallback(() => {
+        const currentActiveValue = activeValueRef.current;
+        if (!currentActiveValue) {
+            setIndicatorStyle((prev) => {
+                if (prev.opacity === 0)
+                    return prev;
+                return { left: 0, width: 0, height: 0, top: 0, opacity: 0 };
+            });
+            return;
+        }
+        const activeElement = elementsRef.current.get(currentActiveValue);
+        const container = containerRef.current;
+        if (activeElement && container) {
+            const elementRect = activeElement.getBoundingClientRect();
+            const containerRect = container.getBoundingClientRect();
+            // Calcular posição relativa ao container
+            const left = elementRect.left - containerRect.left;
+            const width = elementRect.width;
+            const height = elementRect.height;
+            const top = elementRect.top - containerRect.top;
+            setIndicatorStyle((prev) => {
+                // Evitar atualização se os valores não mudaram
+                if (prev.left === left &&
+                    prev.width === width &&
+                    prev.height === height &&
+                    prev.top === top &&
+                    prev.opacity === 1) {
+                    return prev;
+                }
+                return {
+                    left,
+                    width,
+                    height,
+                    top,
+                    opacity: 1,
+                };
+            });
+        }
+    }, [containerRef]);
+    // Função para agendar atualização (debounce) - estável
+    const scheduleUpdateRef = useRef(undefined);
+    // Atualizar a função no ref sempre que updateIndicator mudar
+    useEffect(() => {
+        scheduleUpdateRef.current = () => {
+            if (updateTimeoutRef.current !== null) {
+                cancelAnimationFrame(updateTimeoutRef.current);
+            }
+            updateTimeoutRef.current = requestAnimationFrame(() => {
+                updateIndicator();
+                updateTimeoutRef.current = null;
+            });
+        };
+    }, [updateIndicator]);
+    const scheduleUpdate = useCallback(() => {
+        scheduleUpdateRef.current?.();
+    }, []);
+    // Atualizar quando activeValue mudar
+    useEffect(() => {
+        scheduleUpdate();
+    }, [activeValue, scheduleUpdate]);
+    // Listener de resize
+    useEffect(() => {
+        if (!updateOnResize)
+            return;
+        const handleResize = () => scheduleUpdate();
+        window.addEventListener("resize", handleResize);
+        return () => {
+            window.removeEventListener("resize", handleResize);
+            if (updateTimeoutRef.current !== null) {
+                cancelAnimationFrame(updateTimeoutRef.current);
+            }
+        };
+    }, [scheduleUpdate, updateOnResize]);
+    const registerElement = useCallback((element, value) => {
+        const previousElement = elementsRef.current.get(value);
+        // Só atualizar se o elemento realmente mudou
+        if (element === previousElement) {
+            return;
+        }
+        if (element) {
+            elementsRef.current.set(value, element);
+        }
+        else {
+            // Só remover se o elemento existia antes
+            if (previousElement) {
+                elementsRef.current.delete(value);
+            }
+            else {
+                return; // Elemento já não existe, não precisa atualizar
+            }
+        }
+        // Agendar atualização de forma assíncrona para evitar loops
+        // Só atualizar se temos um elemento válido
+        if (element) {
+            scheduleUpdate();
+        }
+    }, [scheduleUpdate]);
+    const unregisterElement = useCallback((value) => {
+        elementsRef.current.delete(value);
+        scheduleUpdate();
+    }, [scheduleUpdate]);
+    // Refs para opções estáveis
+    const activeSelectorRef = useRef(activeSelector);
+    const getElementValueRef = useRef(getElementValue);
+    useEffect(() => {
+        activeSelectorRef.current = activeSelector;
+        getElementValueRef.current = getElementValue;
+    }, [activeSelector, getElementValue]);
+    // Observar mudanças no elemento ativo
+    useEffect(() => {
+        const container = containerRef.current;
+        if (!container)
+            return;
+        const findActiveValue = () => {
+            const activeElement = container.querySelector(activeSelectorRef.current);
+            if (activeElement) {
+                let value;
+                if (getElementValueRef.current) {
+                    value = getElementValueRef.current(activeElement);
+                }
+                else {
+                    // Tentar obter do atributo data-value
+                    value = activeElement.getAttribute("data-value") || undefined;
+                    // Se não tiver data-value, buscar no Map pelo elemento
+                    if (!value) {
+                        for (const [mapValue, mapElement] of elementsRef.current.entries()) {
+                            if (mapElement === activeElement) {
+                                value = mapValue;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (value) {
+                    setActiveValue((prev) => {
+                        // Só atualizar se o valor realmente mudou
+                        if (prev !== value) {
+                            return value;
+                        }
+                        return prev;
+                    });
+                }
+            }
+        };
+        const observer = new MutationObserver(() => {
+            // Usar requestAnimationFrame para evitar chamadas síncronas
+            requestAnimationFrame(findActiveValue);
+        });
+        observer.observe(container, {
+            attributes: true,
+            attributeFilter: ["data-state", "data-active", "aria-selected"],
+            subtree: true,
+        });
+        // Verificar estado inicial com delay para evitar loop
+        const timeoutId = setTimeout(findActiveValue, 0);
+        return () => {
+            observer.disconnect();
+            clearTimeout(timeoutId);
+        };
+    }, [containerRef]);
+    return {
+        indicatorStyle,
+        registerElement,
+        unregisterElement,
+        updateIndicator,
+        activeValue,
+    };
+}

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

@@ -0,0 +1,3 @@
+export type { EntityData, EntityHierarchy, GenealogyData, NodeExpansionState, Relationship, RelationshipType, UseGenealogyOptions, UseGenealogyReturn, } from "./useGenealogy";
+export { useGenealogy } from "./useGenealogy";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/useGenealogy/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,eAAe,EACf,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/hooks/useGenealogy/index.js

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

package/dist/hooks/useGenealogy/useGenealogy.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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 type { Edge as ReactFlowEdge, Node as ReactFlowNode } from "@xyflow/react";
+/**
+ * Tipos de relacionamento
+ */
+export type RelationshipType = "mother" | "father" | "child";
+/**
+ * Dados de uma entidade na árvore genealógica (pessoa, animal, ninhada, etc.)
+ */
+export interface EntityData {
+    id: string;
+    name: string;
+    birthDate?: string;
+    deathDate?: string;
+    gender?: "male" | "female" | "other";
+    image?: string;
+    photo?: string;
+    [key: string]: unknown;
+}
+/**
+ * Relacionamento entre entidades
+ */
+export interface Relationship {
+    from: string;
+    to: string;
+    type: RelationshipType;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Estrutura de dados de entrada para a árvore genealógica
+ */
+export interface GenealogyData {
+    people: EntityData[];
+    relationships: Relationship[];
+}
+/**
+ * Estrutura interna hierárquica de uma entidade
+ */
+export interface EntityHierarchy {
+    person: EntityData;
+    parents: EntityData[];
+    mother?: EntityData;
+    father?: EntityData;
+    children: EntityData[];
+    spouse?: EntityData;
+    adoptions: EntityData[];
+    siblings: EntityData[];
+}
+/**
+ * Estado de expansão de um nó
+ */
+export interface NodeExpansionState {
+    [nodeId: string]: boolean;
+}
+/**
+ * Opções do hook useGenealogy
+ */
+export interface UseGenealogyOptions {
+    data: GenealogyData;
+    initialExpanded?: string[];
+    nodeWidth?: number;
+    nodeHeight?: number;
+    horizontalSpacing?: number;
+    verticalSpacing?: number;
+    onNodeSelect?: (nodeId: string, entity: EntityData) => void;
+    onNodeExpand?: (nodeId: string, expanded: boolean) => void;
+    onAddRelation?: (fromId: string, toId: string, type: RelationshipType) => void;
+}
+/**
+ * Retorno do hook useGenealogy
+ */
+export interface UseGenealogyReturn {
+    nodes: ReactFlowNode[];
+    edges: ReactFlowEdge[];
+    hierarchy: Map<string, EntityHierarchy>;
+    selectedNodeId: string | null;
+    expansionState: NodeExpansionState;
+    selectNode: (nodeId: string) => void;
+    expandNode: (nodeId: string, expanded?: boolean) => void;
+    collapseNode: (nodeId: string) => void;
+    addRelation: (fromId: string, toId: string, type: RelationshipType) => void;
+    getPersonHierarchy: (entityId: string) => EntityHierarchy | undefined;
+    getPersonRelations: (entityId: string) => Relationship[];
+}
+/**
+ * Hook headless para gerenciar árvores genealógicas
+ */
+export declare function useGenealogy({ data, initialExpanded, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing, onNodeSelect, onNodeExpand, onAddRelation, }: UseGenealogyOptions): UseGenealogyReturn;
+//# sourceMappingURL=useGenealogy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useGenealogy.d.ts","sourceRoot":"","sources":["../../../src/hooks/useGenealogy/useGenealogy.ts"],"names":[],"mappings":"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"}