flikkui 0.1.0-beta.11

package/dist/components/core/Tooltip/index.d.ts

@@ -0,0 +1,3 @@
+export { Tooltip } from './Tooltip';
+export type { TooltipProps, TooltipThemeOverrides, TooltipPlacement } from './Tooltip.types';
+export { baseTooltipVariants, getTooltipVariants, tooltipSpringConfig } from './Tooltip.animations';

package/dist/components/core/Tooltip/useTooltipPositioning.d.ts

@@ -0,0 +1,12 @@
+type Placement = 'top' | 'right' | 'bottom' | 'left';
+interface UseTooltipPositioningProps {
+    tooltipRef: React.RefObject<HTMLDivElement | null>;
+    triggerRef: React.RefObject<HTMLDivElement | null>;
+    placement: Placement;
+    isVisible: boolean;
+}
+export declare const useTooltipPositioning: ({ tooltipRef, triggerRef, placement, isVisible, }: UseTooltipPositioningProps) => {
+    positionTooltip: () => void;
+    debouncedPositioning: () => void;
+};
+export {};

package/dist/components/core/Tree/Tree.animations.d.ts

@@ -0,0 +1,6 @@
+import { Variants, Transition } from 'motion/react';
+export declare const treeNodeVariants: Variants;
+export declare const expandIconVariants: Variants;
+export declare const childrenStagger: Transition;
+export declare const childNodeVariants: Variants;
+export declare const getReducedMotionVariants: (originalVariants: Variants) => Variants;

package/dist/components/core/Tree/Tree.animations.js

@@ -0,0 +1,77 @@
+import { __assign } from '../../../node_modules/tslib/tslib.es6.js';
+
+// Optimized spring configuration for smooth expand/collapse
+var SPRING_CONFIG = {
+    type: 'spring',
+    stiffness: 400,
+    damping: 30,
+    mass: 0.8,
+};
+// Core expand/collapse animation for tree nodes
+var treeNodeVariants = {
+    expanded: {
+        opacity: 1,
+        scaleY: 1,
+        height: 'auto',
+        transition: {
+            height: __assign(__assign({}, SPRING_CONFIG), { duration: 0.3 }),
+            opacity: __assign(__assign({}, SPRING_CONFIG), { duration: 0.2 }),
+            scaleY: __assign(__assign({}, SPRING_CONFIG), { duration: 0.25 }),
+        },
+    },
+    collapsed: {
+        opacity: 0,
+        scaleY: 0.8,
+        height: 0,
+        transition: {
+            height: __assign(__assign({}, SPRING_CONFIG), { duration: 0.25 }),
+            opacity: __assign(__assign({}, SPRING_CONFIG), { duration: 0.15 }),
+            scaleY: __assign(__assign({}, SPRING_CONFIG), { duration: 0.2 }),
+        },
+    },
+};
+// Icon rotation animation for expand/collapse indication
+var expandIconVariants = {
+    expanded: {
+        rotate: 90,
+        transition: SPRING_CONFIG,
+    },
+    collapsed: {
+        rotate: 0,
+        transition: SPRING_CONFIG,
+    },
+};
+// Stagger animation for children nodes
+var childrenStagger = {
+    staggerChildren: 0.03,
+    delayChildren: 0.05,
+};
+// Individual child node entry animation
+var childNodeVariants = {
+    hidden: {
+        opacity: 0,
+        x: -10,
+        transition: SPRING_CONFIG,
+    },
+    visible: {
+        opacity: 1,
+        x: 0,
+        transition: SPRING_CONFIG,
+    },
+};
+// Reduced motion variants for accessibility
+var getReducedMotionVariants = function (originalVariants) {
+    var reducedVariants = {};
+    Object.keys(originalVariants).forEach(function (key) {
+        var variant = originalVariants[key];
+        if (typeof variant === 'object' && variant !== null) {
+            reducedVariants[key] = __assign(__assign({}, variant), { transition: {
+                    duration: 0.01, // Nearly instant for reduced motion
+                    ease: 'linear',
+                } });
+        }
+    });
+    return reducedVariants;
+};
+
+export { childNodeVariants, childrenStagger, expandIconVariants, getReducedMotionVariants, treeNodeVariants };

package/dist/components/core/Tree/Tree.d.ts

@@ -0,0 +1,2 @@
+import { TreeComponent } from './Tree.types';
+export declare const Tree: TreeComponent;

package/dist/components/core/Tree/Tree.js

@@ -0,0 +1,213 @@
+import { __rest, __assign, __spreadArray } from '../../../node_modules/tslib/tslib.es6.js';
+import React__default, { useState, useCallback } from 'react';
+import { cn } from '../../../utils/cn.js';
+import { treeTheme } from './Tree.theme.js';
+import { Checkbox } from '../../forms/Checkbox/Checkbox.js';
+import { getReducedMotionVariants, treeNodeVariants, expandIconVariants, childNodeVariants, childrenStagger } from './Tree.animations.js';
+import ForwardRef from '../../../node_modules/@heroicons/react/24/outline/esm/ChevronRightIcon.js';
+import ForwardRef$1 from '../../../node_modules/@heroicons/react/24/outline/esm/DocumentIcon.js';
+import { useReducedMotion } from '../../../node_modules/framer-motion/dist/es/utils/reduced-motion/use-reduced-motion.js';
+import { motion } from '../../../node_modules/framer-motion/dist/es/render/components/motion/proxy.js';
+import { AnimatePresence } from '../../../node_modules/framer-motion/dist/es/components/AnimatePresence/index.js';
+
+// Simplified selection utilities (merged from Tree.utils.ts)
+var getDescendantIds = function (node) {
+    var descendants = [];
+    var traverse = function (currentNode) {
+        if (currentNode.children) {
+            currentNode.children.forEach(function (child) {
+                descendants.push(child.id);
+                traverse(child);
+            });
+        }
+    };
+    traverse(node);
+    return descendants;
+};
+var calculateSelection = function (nodeId, selectedKeys, data) {
+    // Find the node in the tree
+    var findNode = function (nodes, id) {
+        for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+            var node_1 = nodes_1[_i];
+            if (node_1.id === id)
+                return node_1;
+            if (node_1.children) {
+                var found = findNode(node_1.children, id);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    };
+    var node = findNode(data, nodeId);
+    if (!node)
+        return { selectedKeys: selectedKeys, indeterminateKeys: [] };
+    var isCurrentlySelected = selectedKeys.includes(nodeId);
+    var newSelectedKeys = __spreadArray([], selectedKeys, true);
+    if (isCurrentlySelected) {
+        // Deselecting: remove this node and all its descendants
+        var descendantIds_1 = getDescendantIds(node);
+        newSelectedKeys = newSelectedKeys.filter(function (id) {
+            return id !== nodeId && !descendantIds_1.includes(id);
+        });
+    }
+    else {
+        // Selecting: add this node and all its descendants
+        var descendantIds = getDescendantIds(node);
+        newSelectedKeys.push.apply(newSelectedKeys, __spreadArray([nodeId], descendantIds, false));
+        newSelectedKeys = Array.from(new Set(newSelectedKeys));
+    }
+    // Calculate indeterminate states (simplified)
+    var indeterminateKeys = [];
+    var calculateIndeterminate = function (nodes) {
+        nodes.forEach(function (node) {
+            if (node.children && node.children.length > 0) {
+                var childrenIds = node.children.map(function (child) { return child.id; });
+                var selectedChildren = childrenIds.filter(function (id) { return newSelectedKeys.includes(id); });
+                // Node is indeterminate if some (but not all) children are selected
+                if (selectedChildren.length > 0 && selectedChildren.length < childrenIds.length && !newSelectedKeys.includes(node.id)) {
+                    indeterminateKeys.push(node.id);
+                }
+                calculateIndeterminate(node.children);
+            }
+        });
+    };
+    calculateIndeterminate(data);
+    return {
+        selectedKeys: newSelectedKeys,
+        indeterminateKeys: indeterminateKeys
+    };
+};
+var InternalTreeNode = function (_a) {
+    var _b;
+    var node = _a.node, level = _a.level, expanded = _a.expanded, selected = _a.selected, isIndeterminate = _a.isIndeterminate, selectable = _a.selectable, checkable = _a.checkable, hierarchicalSelection = _a.hierarchicalSelection, expandable = _a.expandable, expandedKeys = _a.expandedKeys, selectedKeys = _a.selectedKeys, indeterminateKeys = _a.indeterminateKeys, onNodeClick = _a.onNodeClick, onToggleExpand = _a.onToggleExpand, theme = _a.theme, className = _a.className, shouldReduceMotion = _a.shouldReduceMotion;
+    var hasChildren = node.children && node.children.length > 0;
+    var isExpandable = expandable && hasChildren;
+    // Get appropriate animation variants based on reduced motion preference
+    var nodeVariants = shouldReduceMotion ? getReducedMotionVariants(treeNodeVariants) : treeNodeVariants;
+    var iconVariants = shouldReduceMotion ? getReducedMotionVariants(expandIconVariants) : expandIconVariants;
+    var childVariants = shouldReduceMotion ? getReducedMotionVariants(childNodeVariants) : childNodeVariants;
+    var handleNodeClick = function (e) {
+        e.stopPropagation();
+        if (node.disabled)
+            return;
+        if (selectable) {
+            onNodeClick(node);
+        }
+    };
+    var handleExpandClick = function (e) {
+        e.stopPropagation(); // Prevent bubbling to parent node click handler
+        if (isExpandable && !node.disabled) {
+            onToggleExpand(node);
+        }
+    };
+    var handleKeyDown = function (e) {
+        if (node.disabled)
+            return;
+        switch (e.key) {
+            case 'Enter':
+            case ' ':
+                e.preventDefault();
+                if (selectable) {
+                    onNodeClick(node);
+                }
+                break;
+            case 'ArrowRight':
+                if (isExpandable && !expanded) {
+                    e.preventDefault();
+                    onToggleExpand(node);
+                }
+                break;
+            case 'ArrowLeft':
+                if (isExpandable && expanded) {
+                    e.preventDefault();
+                    onToggleExpand(node);
+                }
+                break;
+        }
+    };
+    var nodeStyle = cn(theme.nodeStyle, {
+        'opacity-50 cursor-not-allowed': node.disabled,
+        'cursor-pointer': (selectable || (hasChildren && expandable)) && !node.disabled,
+    }, className);
+    var labelStyle = cn(theme.labelStyle, {
+        'text-[var(--color-text-muted)]': node.disabled,
+    });
+    return (React__default.createElement("div", null,
+        React__default.createElement("div", { className: nodeStyle, style: { paddingLeft: "calc(".concat(level, " * ").concat(theme.indentSize, " + 0.25rem)") }, onClick: handleNodeClick, onKeyDown: handleKeyDown, tabIndex: node.disabled ? -1 : 0, role: "treeitem", "aria-expanded": isExpandable ? expanded : false, "aria-selected": selectable ? selected : undefined, "aria-disabled": node.disabled },
+            isExpandable ? (React__default.createElement(motion.span, { className: cn(theme.expandIconStyle), variants: iconVariants, initial: "collapsed", animate: expanded ? "expanded" : "collapsed", onClick: handleExpandClick, role: "button", "aria-label": expanded ? 'Collapse' : 'Expand', tabIndex: -1 },
+                React__default.createElement(ForwardRef, { className: "size-4", strokeWidth: 2 }))) : (React__default.createElement("span", { className: "w-4 mr-1" })),
+            checkable && (React__default.createElement(Checkbox, { size: 'sm', id: "tree-checkbox-".concat(node.id), name: "tree-checkbox-".concat(node.id), value: node.id, checked: selected, indeterminate: hierarchicalSelection && isIndeterminate, onChange: function () { return onNodeClick(node); }, state: node.disabled ? "disabled" : "default", className: cn(theme.checkboxStyle, "flex-shrink-0"), onClick: function (e) { return e.stopPropagation(); } })),
+            (node.icon || !isExpandable) && (React__default.createElement("span", { className: cn(theme.iconStyle) }, node.icon || React__default.createElement(ForwardRef$1, { className: "w-4 h-4" }))),
+            React__default.createElement("span", { className: labelStyle, title: node.label }, node.label)),
+        hasChildren && (React__default.createElement(AnimatePresence, { initial: false }, expanded && (React__default.createElement(motion.div, { key: "".concat(node.id, "-children"), variants: nodeVariants, initial: "collapsed", animate: "expanded", exit: "collapsed", style: {
+                overflow: 'hidden',
+                transformOrigin: 'top'
+            }, transition: shouldReduceMotion ? { duration: 0.01 } : childrenStagger }, (_b = node.children) === null || _b === void 0 ? void 0 : _b.map(function (childNode, index) { return (React__default.createElement(motion.div, { key: childNode.id, variants: childVariants, initial: "hidden", animate: "visible", exit: "hidden", custom: index },
+            React__default.createElement(InternalTreeNode, { node: childNode, level: level + 1, expanded: expandedKeys.includes(childNode.id), selected: selectedKeys.includes(childNode.id), isIndeterminate: indeterminateKeys.includes(childNode.id), selectable: selectable, checkable: checkable, hierarchicalSelection: hierarchicalSelection, expandable: expandable, expandedKeys: expandedKeys, selectedKeys: selectedKeys, indeterminateKeys: indeterminateKeys, onNodeClick: onNodeClick, onToggleExpand: onToggleExpand, theme: theme, shouldReduceMotion: shouldReduceMotion }))); })))))));
+};
+var TreeRoot = React__default.forwardRef(function (_a, ref) {
+    var _b;
+    var data = _a.data, _c = _a.selectable, selectable = _c === void 0 ? false : _c, _d = _a.checkable, checkable = _d === void 0 ? false : _d, hierarchicalSelection = _a.hierarchicalSelection, _e = _a.expandable, expandable = _e === void 0 ? true : _e, _f = _a.defaultExpandedKeys, defaultExpandedKeys = _f === void 0 ? [] : _f, _g = _a.defaultSelectedKeys, defaultSelectedKeys = _g === void 0 ? [] : _g, onSelectionChange = _a.onSelectionChange, onExpand = _a.onExpand, className = _a.className, _h = _a.theme, customTheme = _h === void 0 ? {} : _h, htmlProps = __rest(_a, ["data", "selectable", "checkable", "hierarchicalSelection", "expandable", "defaultExpandedKeys", "defaultSelectedKeys", "onSelectionChange", "onExpand", "className", "theme"]);
+    // Auto-enable hierarchical selection when checkboxes are used, unless explicitly overridden
+    var enableHierarchicalSelection = hierarchicalSelection !== null && hierarchicalSelection !== void 0 ? hierarchicalSelection : checkable;
+    var shouldReduceMotion = (_b = useReducedMotion()) !== null && _b !== void 0 ? _b : false;
+    var theme = __assign(__assign({}, treeTheme), customTheme);
+    // Simplified state management
+    var _j = useState(defaultExpandedKeys), expandedKeys = _j[0], setExpandedKeys = _j[1];
+    var _k = useState(defaultSelectedKeys), selectedKeys = _k[0], setSelectedKeys = _k[1];
+    var _l = useState([]), indeterminateKeys = _l[0], setIndeterminateKeys = _l[1];
+    // Handle node selection
+    var handleNodeSelect = useCallback(function (node) {
+        if (!selectable || node.disabled)
+            return;
+        if (enableHierarchicalSelection && checkable) {
+            // Hierarchical selection mode
+            var result = calculateSelection(node.id, selectedKeys, data);
+            setSelectedKeys(result.selectedKeys);
+            setIndeterminateKeys(result.indeterminateKeys);
+            // Call callback with simplified signature
+            onSelectionChange === null || onSelectionChange === void 0 ? void 0 : onSelectionChange(result.selectedKeys, node, result.indeterminateKeys);
+        }
+        else {
+            // Simple selection mode
+            var newSelectedKeys = void 0;
+            if (checkable) {
+                // Multi-selection mode
+                if (selectedKeys.includes(node.id)) {
+                    newSelectedKeys = selectedKeys.filter(function (key) { return key !== node.id; });
+                }
+                else {
+                    newSelectedKeys = __spreadArray(__spreadArray([], selectedKeys, true), [node.id], false);
+                }
+            }
+            else {
+                // Single selection mode
+                newSelectedKeys = selectedKeys.includes(node.id) ? [] : [node.id];
+            }
+            setSelectedKeys(newSelectedKeys);
+            onSelectionChange === null || onSelectionChange === void 0 ? void 0 : onSelectionChange(newSelectedKeys, node);
+        }
+    }, [selectedKeys, data, selectable, checkable, enableHierarchicalSelection, onSelectionChange]);
+    // Handle node expand/collapse
+    var handleNodeToggleExpand = useCallback(function (node) {
+        if (!expandable || node.disabled)
+            return;
+        var isExpanded = expandedKeys.includes(node.id);
+        var newExpandedKeys;
+        if (isExpanded) {
+            newExpandedKeys = expandedKeys.filter(function (key) { return key !== node.id; });
+        }
+        else {
+            newExpandedKeys = __spreadArray(__spreadArray([], expandedKeys, true), [node.id], false);
+        }
+        setExpandedKeys(newExpandedKeys);
+        onExpand === null || onExpand === void 0 ? void 0 : onExpand(newExpandedKeys, node, !isExpanded);
+    }, [expandedKeys, expandable, onExpand]);
+    return (React__default.createElement("div", __assign({ ref: ref, className: cn(theme.baseStyle, 'tree-container', className), role: "tree", "aria-multiselectable": checkable }, htmlProps), data.map(function (node) { return (React__default.createElement(InternalTreeNode, { key: node.id, node: node, level: 0, expanded: expandedKeys.includes(node.id), selected: selectedKeys.includes(node.id), isIndeterminate: indeterminateKeys.includes(node.id), selectable: selectable, checkable: checkable, hierarchicalSelection: enableHierarchicalSelection, expandable: expandable, expandedKeys: expandedKeys, selectedKeys: selectedKeys, indeterminateKeys: indeterminateKeys, onNodeClick: handleNodeSelect, onToggleExpand: handleNodeToggleExpand, theme: theme, shouldReduceMotion: shouldReduceMotion })); })));
+});
+TreeRoot.displayName = 'Tree';
+// Simplified compound component
+var Tree = TreeRoot;
+
+export { Tree };

package/dist/components/core/Tree/Tree.theme.d.ts

@@ -0,0 +1,2 @@
+import { TreeTheme } from './Tree.types';
+export declare const treeTheme: TreeTheme;

package/dist/components/core/Tree/Tree.theme.js

@@ -0,0 +1,10 @@
+var treeTheme = {
+    baseStyle: 'flex flex-col w-full',
+    nodeStyle: 'flex items-center py-1 pr-1 rounded-md hover:bg-[var(--color-background-secondary)] cursor-pointer transition-colors select-none gap-2',
+    labelStyle: 'flex-1 text-base text-[var(--color-text-primary)] truncate',
+    iconStyle: 'flex-shrink-0 text-[var(--color-text-muted)]',
+    expandIconStyle: 'flex-shrink-0 mr-1 text-[var(--color-text-muted)] hover:text-[var(--color-text-primary)] transition-colors cursor-pointer size-4 flex items-center justify-center',
+    indentSize: '1rem',
+};
+
+export { treeTheme };

package/dist/components/core/Tree/Tree.types.d.ts

@@ -0,0 +1,62 @@
+import { HTMLAttributes, ReactNode, ForwardRefExoticComponent, RefAttributes } from 'react';
+export interface TreeNode {
+    /** Unique identifier for the node */
+    id: string;
+    /** Display label for the node */
+    label: string;
+    /** Child nodes */
+    children?: TreeNode[];
+    /** Whether the node is expanded (only for nodes with children) */
+    expanded?: boolean;
+    /** Whether the node is selected */
+    selected?: boolean;
+    /** Whether the node is disabled */
+    disabled?: boolean;
+    /** Custom icon for the node */
+    icon?: ReactNode;
+    /** Additional data attached to the node */
+    data?: any;
+}
+export interface TreeTheme {
+    baseStyle: string;
+    nodeStyle: string;
+    labelStyle: string;
+    iconStyle: string;
+    expandIconStyle: string;
+    indentSize: string;
+}
+export interface TreeThemeOverrides {
+    baseStyle?: string;
+    nodeStyle?: string;
+    labelStyle?: string;
+    iconStyle?: string;
+    expandIconStyle?: string;
+    indentSize?: string;
+}
+export interface TreeProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    /** Tree data structure */
+    data: TreeNode[];
+    /** Whether nodes can be selected */
+    selectable?: boolean;
+    /** Whether to show checkboxes for multi-selection */
+    checkable?: boolean;
+    /** Whether nodes can be expanded/collapsed */
+    expandable?: boolean;
+    /** Keys of nodes that are expanded by default */
+    defaultExpandedKeys?: string[];
+    /** Keys of nodes that are selected by default */
+    defaultSelectedKeys?: string[];
+    /** Enable hierarchical selection behavior
+     * @default automatically enabled when checkable=true, false otherwise */
+    hierarchicalSelection?: boolean;
+    /** Callback when selection changes */
+    onSelectionChange?: (selectedKeys: string[], node: TreeNode, indeterminateKeys?: string[]) => void;
+    /** Callback when a node is expanded/collapsed */
+    onExpand?: (expandedKeys: string[], node: TreeNode, expanded: boolean) => void;
+    /** Custom class name */
+    className?: string;
+    /** Theme overrides */
+    theme?: TreeThemeOverrides;
+}
+export interface TreeComponent extends ForwardRefExoticComponent<TreeProps & RefAttributes<HTMLDivElement>> {
+}

package/dist/components/core/Tree/index.d.ts

@@ -0,0 +1,3 @@
+export { Tree } from './Tree';
+export type { TreeProps, TreeNode as TreeNodeType, TreeTheme, TreeThemeOverrides, TreeComponent, } from './Tree.types';
+export { treeTheme } from './Tree.theme';

package/dist/components/core/index.d.ts

@@ -0,0 +1,42 @@
+export * from "./Accordion";
+export * from "./AlertDialog";
+export * from "./Avatar";
+export * from "./AvatarGroup";
+export * from "./Badge";
+export * from "./Breadcrumbs";
+export * from "./Button";
+export * from "./ButtonGroup";
+export * from "./Calendar";
+export * from "./Card";
+export * from "./Carousel";
+export * from "./CommandPalette";
+export * from "./Divider";
+export * from "./Drawer";
+export * from "./Dropdown";
+export * from "./Kbd";
+export * from "./Link";
+export * from "./Loader";
+export * from "./Metric";
+export * from "./Modal";
+export * from "./Pagination";
+export * from "./Popover";
+export * from "./ProgressiveBlur";
+export * from "./Segmented";
+export * from "./Skeleton";
+export * from "./SlidingNumber";
+export * from "./Stepper";
+export * from "./Tabs";
+export * from "./Tooltip";
+export * from "./Tree";
+export * from "./Alert";
+export * from "./Toast";
+export * from "./Notification";
+export * from "./Spinner";
+export * from "./ChatMessage";
+export * from "./Empty";
+export * from "./Masonry";
+export * from "./Table";
+export * from "./DragDrop";
+export * from "./Sortable";
+export * from "./NavItem";
+export * from "./Sidebar";

package/dist/components/effects/CustomCursor/CustomCursor.animations.d.ts

@@ -0,0 +1,16 @@
+import type { Variants, SpringOptions } from 'motion/react';
+/**
+ * Animation variants for CustomCursor component
+ * Handles enter/exit animations with scale and opacity
+ */
+export declare const customCursorVariants: Variants;
+/**
+ * Default spring configuration for smooth following behavior
+ * High stiffness for responsive movement, damping to reduce oscillation
+ */
+export declare const defaultSpringConfig: SpringOptions;
+/**
+ * Reduced motion spring configuration
+ * Nearly instant movement for users who prefer reduced motion
+ */
+export declare const reducedMotionSpringConfig: SpringOptions;

package/dist/components/effects/CustomCursor/CustomCursor.animations.js

@@ -0,0 +1,46 @@
+/**
+ * Animation variants for CustomCursor component
+ * Handles enter/exit animations with scale and opacity
+ */
+var customCursorVariants = {
+    initial: {
+        scale: 0,
+        opacity: 0,
+    },
+    animate: {
+        scale: 1,
+        opacity: 1,
+        transition: {
+            duration: 0.2,
+            ease: 'easeOut',
+        },
+    },
+    exit: {
+        scale: 0,
+        opacity: 0,
+        transition: {
+            duration: 0.15,
+            ease: 'easeIn',
+        },
+    },
+};
+/**
+ * Default spring configuration for smooth following behavior
+ * High stiffness for responsive movement, damping to reduce oscillation
+ */
+var defaultSpringConfig = {
+    stiffness: 500,
+    damping: 50,
+    bounce: 0,
+};
+/**
+ * Reduced motion spring configuration
+ * Nearly instant movement for users who prefer reduced motion
+ */
+var reducedMotionSpringConfig = {
+    stiffness: 1000,
+    damping: 100,
+    bounce: 0,
+};
+
+export { customCursorVariants, defaultSpringConfig, reducedMotionSpringConfig };

package/dist/components/effects/CustomCursor/CustomCursor.d.ts

@@ -0,0 +1,48 @@
+import * as React from 'react';
+import type { CustomCursorContextType, CustomCursorProviderProps, CustomCursorProps, CustomCursorFollowProps } from './CustomCursor.types';
+/**
+ * Hook to access CustomCursor context
+ * @throws Error if used outside CustomCursorProvider
+ */
+export declare const useCustomCursor: () => CustomCursorContextType;
+/**
+ * CustomCursorProvider - Context provider component
+ * Tracks mouse movement within parent element and manages cursor state
+ *
+ * @example
+ * ```tsx
+ * <CustomCursorProvider>
+ *   <CustomCursor>
+ *     <div className="w-4 h-4 bg-blue-500 rounded-full" />
+ *   </CustomCursor>
+ *   <YourContent />
+ * </CustomCursorProvider>
+ * ```
+ */
+export declare const CustomCursorProvider: React.ForwardRefExoticComponent<Omit<CustomCursorProviderProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * CustomCursor - Main cursor element component
+ * Follows mouse position exactly with instant movement
+ *
+ * @example
+ * ```tsx
+ * <CustomCursor size="md" color="primary" variant="glass">
+ *   <PaperAirplaneIcon />
+ * </CustomCursor>
+ * ```
+ */
+export declare const CustomCursor: React.ForwardRefExoticComponent<Omit<CustomCursorProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * CustomCursorFollow - Smooth following cursor element
+ * Follows the main cursor with spring physics for smooth, laggy movement
+ *
+ * @example
+ * ```tsx
+ * <CustomCursorFollow align="bottom-right" sideOffset={20}>
+ *   <div className="bg-white rounded-lg shadow-lg p-2">
+ *     Tooltip content
+ *   </div>
+ * </CustomCursorFollow>
+ * ```
+ */
+export declare const CustomCursorFollow: React.ForwardRefExoticComponent<Omit<CustomCursorFollowProps, "ref"> & React.RefAttributes<HTMLDivElement>>;