@flikk/ui 1.0.0-beta.1 → 1.0.0-beta.10

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

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { ScrollRevealProps } from './ScrollReveal.types';
+/**
+ * ScrollReveal
+ *
+ * Intersection-observer wrapper that triggers an entrance animation when
+ * its children scroll into the viewport.
+ *
+ * Supports six built-in presets, custom variants, stagger-children timing,
+ * and respects the `prefers-reduced-motion` media query.
+ *
+ * @example
+ * ```tsx
+ * <ScrollReveal preset="fadeUp">
+ *   <h2>Hello world</h2>
+ * </ScrollReveal>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Stagger children
+ * <ScrollReveal preset="fadeUp" stagger={0.12}>
+ *   <Card />
+ *   <Card />
+ *   <Card />
+ * </ScrollReveal>
+ * ```
+ */
+export declare const ScrollReveal: React.ForwardRefExoticComponent<ScrollRevealProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/effects/ScrollReveal/ScrollReveal.js

@@ -0,0 +1,121 @@
+import { jsx } from 'react/jsx-runtime';
+import React__default, { useRef } from 'react';
+import { useReducedMotion, useInView, motion } from 'motion/react';
+import { cn } from '../../../utils/cn.js';
+
+/* ------------------------------------------------------------------ */
+/*  Animation presets                                                   */
+/* ------------------------------------------------------------------ */
+const PRESET_VARIANTS = {
+    fadeUp: {
+        hidden: { opacity: 0, y: 32 },
+        visible: { opacity: 1, y: 0 },
+    },
+    fadeDown: {
+        hidden: { opacity: 0, y: -32 },
+        visible: { opacity: 1, y: 0 },
+    },
+    fadeLeft: {
+        hidden: { opacity: 0, x: -32 },
+        visible: { opacity: 1, x: 0 },
+    },
+    fadeRight: {
+        hidden: { opacity: 0, x: 32 },
+        visible: { opacity: 1, x: 0 },
+    },
+    scaleUp: {
+        hidden: { opacity: 0, scale: 0.85 },
+        visible: { opacity: 1, scale: 1 },
+    },
+    blur: {
+        hidden: { opacity: 0, filter: 'blur(8px)' },
+        visible: { opacity: 1, filter: 'blur(0px)' },
+    },
+};
+/* ------------------------------------------------------------------ */
+/*  Component                                                           */
+/* ------------------------------------------------------------------ */
+/**
+ * ScrollReveal
+ *
+ * Intersection-observer wrapper that triggers an entrance animation when
+ * its children scroll into the viewport.
+ *
+ * Supports six built-in presets, custom variants, stagger-children timing,
+ * and respects the `prefers-reduced-motion` media query.
+ *
+ * @example
+ * ```tsx
+ * <ScrollReveal preset="fadeUp">
+ *   <h2>Hello world</h2>
+ * </ScrollReveal>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Stagger children
+ * <ScrollReveal preset="fadeUp" stagger={0.12}>
+ *   <Card />
+ *   <Card />
+ *   <Card />
+ * </ScrollReveal>
+ * ```
+ */
+const ScrollReveal = React__default.forwardRef(({ preset = 'fadeUp', variants: customVariants, threshold = 0.1, rootMargin = '0px 0px -50px 0px', once = true, delay = 0, duration = 0.6, stagger = 0, className, children, 
+// Destructure HTML event handlers that conflict with motion's API
+onDrag: _onDrag, onDragStart: _onDragStart, onDragEnd: _onDragEnd, onAnimationStart: _onAnimationStart, ...restProps }, ref) => {
+    const shouldReduceMotion = useReducedMotion();
+    const internalRef = useRef(null);
+    const isInView = useInView(internalRef, {
+        once,
+        amount: threshold,
+        margin: rootMargin,
+    });
+    // When reduced motion is preferred, render content immediately.
+    if (shouldReduceMotion) {
+        return (jsx("div", { ref: (node) => {
+                internalRef.current = node;
+                if (typeof ref === 'function')
+                    ref(node);
+                else if (ref)
+                    ref.current = node;
+            }, className: className, ...restProps, children: children }));
+    }
+    // Build variants --------------------------------------------------
+    const presetData = customVariants !== null && customVariants !== void 0 ? customVariants : PRESET_VARIANTS[preset];
+    const motionVariants = {
+        hidden: presetData.hidden,
+        visible: {
+            ...presetData.visible,
+            transition: {
+                duration,
+                delay,
+                ease: [0.25, 0.1, 0.25, 1], // cubic-bezier easeOut
+                ...(stagger > 0
+                    ? { staggerChildren: stagger, delayChildren: delay }
+                    : {}),
+            },
+        },
+    };
+    // When stagger is used, each direct child needs to be a motion element.
+    // We wrap each child in a motion.div that inherits parent variants.
+    const content = stagger > 0
+        ? React__default.Children.map(children, (child) => (jsx(motion.div, { variants: {
+                hidden: presetData.hidden,
+                visible: {
+                    ...presetData.visible,
+                    transition: { duration, ease: [0.25, 0.1, 0.25, 1] },
+                },
+            }, children: child })))
+        : children;
+    return (jsx(motion.div, { ref: (node) => {
+            internalRef.current = node;
+            if (typeof ref === 'function')
+                ref(node);
+            else if (ref)
+                ref.current = node;
+        }, className: cn(className), variants: motionVariants, initial: "hidden", animate: isInView ? 'visible' : 'hidden', ...restProps, children: content }));
+});
+ScrollReveal.displayName = 'ScrollReveal';
+
+export { ScrollReveal };

package/dist/components/effects/ScrollReveal/ScrollReveal.types.d.ts

@@ -0,0 +1,25 @@
+import type { Variants } from 'motion/react';
+export type ScrollRevealPreset = 'fadeUp' | 'fadeDown' | 'fadeLeft' | 'fadeRight' | 'scaleUp' | 'blur';
+export interface ScrollRevealProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Animation preset (default 'fadeUp') */
+    preset?: ScrollRevealPreset;
+    /** Custom animation variants (overrides preset) */
+    variants?: {
+        hidden: Variants['hidden'];
+        visible: Variants['visible'];
+    };
+    /** Intersection threshold 0-1 (default 0.1) */
+    threshold?: number;
+    /** Root margin for early/late triggering (default '0px 0px -50px 0px') */
+    rootMargin?: string;
+    /** Only animate once (default true) */
+    once?: boolean;
+    /** Animation delay in seconds (default 0) */
+    delay?: number;
+    /** Animation duration in seconds (default 0.6) */
+    duration?: number;
+    /** Stagger children by this amount in seconds (default 0) */
+    stagger?: number;
+    className?: string;
+    children: React.ReactNode;
+}

package/dist/components/effects/ScrollReveal/index.d.ts

@@ -0,0 +1,2 @@
+export { ScrollReveal } from './ScrollReveal';
+export type { ScrollRevealProps, ScrollRevealPreset, } from './ScrollReveal.types';

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

@@ -0,0 +1,36 @@
+import React from "react";
+import type { SpotlightProps } from "./Spotlight.types";
+/**
+ * Spotlight Component
+ *
+ * A mouse-following radial gradient that creates a subtle surface illumination
+ * effect. Tracks the mouse position within the parent element and renders a
+ * smooth, animated glow that follows the cursor.
+ *
+ * The parent container should have `position: relative` and `overflow: hidden`.
+ *
+ * Unlike SpotlightBorder (which highlights borders), this component illuminates
+ * the surface area itself with a soft radial gradient.
+ *
+ * @example
+ * ```tsx
+ * <div className="relative overflow-hidden bg-gray-900 rounded-lg p-8">
+ *   <Spotlight color="var(--color-primary)" intensity={0.2} />
+ *   <span className="relative z-10">Hover over me</span>
+ * </div>
+ * ```
+ *
+ * @example Custom spring and size
+ * ```tsx
+ * <div className="relative overflow-hidden bg-slate-800 rounded-xl p-12">
+ *   <Spotlight
+ *     size={500}
+ *     color="#8b5cf6"
+ *     intensity={0.25}
+ *     springConfig={{ damping: 20, stiffness: 150 }}
+ *   />
+ *   <h2 className="relative z-10 text-white">Interactive card</h2>
+ * </div>
+ * ```
+ */
+export declare const Spotlight: React.FC<SpotlightProps>;

package/dist/components/effects/Spotlight/Spotlight.js

@@ -0,0 +1,112 @@
+import { jsx } from 'react/jsx-runtime';
+import { useRef, useState, useCallback } from 'react';
+import { useReducedMotion, useMotionValue, useSpring, motion } from 'motion/react';
+import { cn } from '../../../utils/cn.js';
+
+/**
+ * Spotlight Component
+ *
+ * A mouse-following radial gradient that creates a subtle surface illumination
+ * effect. Tracks the mouse position within the parent element and renders a
+ * smooth, animated glow that follows the cursor.
+ *
+ * The parent container should have `position: relative` and `overflow: hidden`.
+ *
+ * Unlike SpotlightBorder (which highlights borders), this component illuminates
+ * the surface area itself with a soft radial gradient.
+ *
+ * @example
+ * ```tsx
+ * <div className="relative overflow-hidden bg-gray-900 rounded-lg p-8">
+ *   <Spotlight color="var(--color-primary)" intensity={0.2} />
+ *   <span className="relative z-10">Hover over me</span>
+ * </div>
+ * ```
+ *
+ * @example Custom spring and size
+ * ```tsx
+ * <div className="relative overflow-hidden bg-slate-800 rounded-xl p-12">
+ *   <Spotlight
+ *     size={500}
+ *     color="#8b5cf6"
+ *     intensity={0.25}
+ *     springConfig={{ damping: 20, stiffness: 150 }}
+ *   />
+ *   <h2 className="relative z-10 text-white">Interactive card</h2>
+ * </div>
+ * ```
+ */
+const Spotlight = ({ size = 300, color = "var(--color-primary)", intensity = 0.15, springConfig = { damping: 30, stiffness: 200 }, className, style, ...props }) => {
+    var _a, _b, _c, _d;
+    const shouldReduceMotion = useReducedMotion();
+    const containerRef = useRef(null);
+    const [isHovered, setIsHovered] = useState(false);
+    // Raw mouse position motion values
+    const mouseX = useMotionValue(0);
+    const mouseY = useMotionValue(0);
+    // Spring-animated values for smooth following
+    const springX = useSpring(mouseX, {
+        damping: (_a = springConfig.damping) !== null && _a !== void 0 ? _a : 30,
+        stiffness: (_b = springConfig.stiffness) !== null && _b !== void 0 ? _b : 200,
+    });
+    const springY = useSpring(mouseY, {
+        damping: (_c = springConfig.damping) !== null && _c !== void 0 ? _c : 30,
+        stiffness: (_d = springConfig.stiffness) !== null && _d !== void 0 ? _d : 200,
+    });
+    // Use raw values when reduced motion is preferred
+    const x = shouldReduceMotion ? mouseX : springX;
+    const y = shouldReduceMotion ? mouseY : springY;
+    const handleMouseMove = useCallback((event) => {
+        var _a;
+        const parent = (_a = containerRef.current) === null || _a === void 0 ? void 0 : _a.parentElement;
+        if (!parent)
+            return;
+        const rect = parent.getBoundingClientRect();
+        mouseX.set(event.clientX - rect.left);
+        mouseY.set(event.clientY - rect.top);
+    }, [mouseX, mouseY]);
+    const handleMouseEnter = useCallback((event) => {
+        var _a;
+        // Set position immediately on enter to avoid animating from origin
+        const parent = (_a = containerRef.current) === null || _a === void 0 ? void 0 : _a.parentElement;
+        if (parent) {
+            const rect = parent.getBoundingClientRect();
+            const posX = event.clientX - rect.left;
+            const posY = event.clientY - rect.top;
+            mouseX.set(posX);
+            mouseY.set(posY);
+            // Jump springs to current position to avoid initial slide-in
+            if (!shouldReduceMotion) {
+                springX.jump(posX);
+                springY.jump(posY);
+            }
+        }
+        setIsHovered(true);
+    }, [mouseX, mouseY, springX, springY, shouldReduceMotion]);
+    const handleMouseLeave = useCallback(() => {
+        setIsHovered(false);
+    }, []);
+    const halfSize = size / 2;
+    return (jsx("div", { ref: containerRef, className: cn("absolute inset-0 pointer-events-none", className), style: {
+            // Re-enable pointer events so we can track mouse within this layer.
+            // The layer itself is visually transparent to interaction.
+            pointerEvents: "auto",
+            ...style,
+        }, onMouseMove: handleMouseMove, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, "aria-hidden": "true", ...props, children: jsx(motion.div, { className: "absolute pointer-events-none", style: {
+                width: size,
+                height: size,
+                borderRadius: "50%",
+                x,
+                y,
+                marginLeft: -halfSize,
+                marginTop: -halfSize,
+                background: `radial-gradient(circle at center, ${color}, transparent 70%)`,
+                opacity: isHovered ? intensity : 0,
+                transition: shouldReduceMotion
+                    ? "opacity 0s"
+                    : "opacity 0.3s ease-in-out",
+            } }) }));
+};
+Spotlight.displayName = "Spotlight";
+
+export { Spotlight };

package/dist/components/effects/Spotlight/Spotlight.types.d.ts

@@ -0,0 +1,29 @@
+import React from "react";
+export interface SpotlightProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Diameter of the spotlight glow in pixels.
+     * @default 300
+     */
+    size?: number;
+    /**
+     * Color of the spotlight glow.
+     * Accepts any valid CSS color value or CSS variable reference.
+     * @default "var(--color-primary)"
+     */
+    color?: string;
+    /**
+     * Peak opacity of the spotlight glow (0-1).
+     * @default 0.15
+     */
+    intensity?: number;
+    /**
+     * Spring animation configuration for the mouse-following behavior.
+     * @default { damping: 30, stiffness: 200 }
+     */
+    springConfig?: {
+        damping?: number;
+        stiffness?: number;
+    };
+    /** Additional className for style overrides (shadcn pattern). */
+    className?: string;
+}

package/dist/components/effects/Spotlight/index.d.ts

@@ -0,0 +1,2 @@
+export { Spotlight } from "./Spotlight";
+export type { SpotlightProps } from "./Spotlight.types";

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

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { StickyScrollProps } from './StickyScroll.types';
+/**
+ * StickyScroll
+ *
+ * Creates an Apple-style sticky scroll experience where one column stays
+ * pinned while the other scrolls.  As each scrolling section enters the
+ * viewport, the sticky content transitions to match.
+ *
+ * @example
+ * ```tsx
+ * <StickyScroll
+ *   sections={[
+ *     {
+ *       id: 'design',
+ *       title: 'Design System',
+ *       description: 'Build consistent interfaces with a shared design language.',
+ *       content: <img src="/design.png" alt="Design system" />,
+ *     },
+ *     {
+ *       id: 'develop',
+ *       title: 'Developer Experience',
+ *       description: 'TypeScript-first components with full IntelliSense.',
+ *       content: <img src="/develop.png" alt="Developer experience" />,
+ *     },
+ *   ]}
+ * />
+ * ```
+ */
+export declare const StickyScroll: React.ForwardRefExoticComponent<StickyScrollProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/effects/StickyScroll/StickyScroll.js

@@ -0,0 +1,128 @@
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import React__default, { useState, useRef, useCallback, useEffect } from 'react';
+import { useReducedMotion, AnimatePresence, motion } from 'motion/react';
+import { cn } from '../../../utils/cn.js';
+
+/* ------------------------------------------------------------------ */
+/*  Content transition variants                                         */
+/* ------------------------------------------------------------------ */
+const contentVariants = {
+    enter: { opacity: 0, y: 12 },
+    center: {
+        opacity: 1,
+        y: 0,
+        transition: { duration: 0.35, ease: [0.25, 0.1, 0.25, 1] },
+    },
+    exit: {
+        opacity: 0,
+        y: -12,
+        transition: { duration: 0.25, ease: [0.25, 0.1, 0.25, 1] },
+    },
+};
+const reducedMotionVariants = {
+    enter: { opacity: 1, y: 0 },
+    center: { opacity: 1, y: 0 },
+    exit: { opacity: 1, y: 0 },
+};
+/* ------------------------------------------------------------------ */
+/*  Component                                                           */
+/* ------------------------------------------------------------------ */
+/**
+ * StickyScroll
+ *
+ * Creates an Apple-style sticky scroll experience where one column stays
+ * pinned while the other scrolls.  As each scrolling section enters the
+ * viewport, the sticky content transitions to match.
+ *
+ * @example
+ * ```tsx
+ * <StickyScroll
+ *   sections={[
+ *     {
+ *       id: 'design',
+ *       title: 'Design System',
+ *       description: 'Build consistent interfaces with a shared design language.',
+ *       content: <img src="/design.png" alt="Design system" />,
+ *     },
+ *     {
+ *       id: 'develop',
+ *       title: 'Developer Experience',
+ *       description: 'TypeScript-first components with full IntelliSense.',
+ *       content: <img src="/develop.png" alt="Developer experience" />,
+ *     },
+ *   ]}
+ * />
+ * ```
+ */
+const StickyScroll = React__default.forwardRef(({ sections, contentPosition = 'left', showProgress = true, className, ...props }, ref) => {
+    const shouldReduceMotion = useReducedMotion();
+    const [activeIndex, setActiveIndex] = useState(0);
+    const sectionRefs = useRef([]);
+    const containerRef = useRef(null);
+    // Set up Intersection Observer to track which section is in view.
+    const observerCallback = useCallback((entries) => {
+        for (const entry of entries) {
+            if (entry.isIntersecting) {
+                const index = sectionRefs.current.indexOf(entry.target);
+                if (index !== -1) {
+                    setActiveIndex(index);
+                }
+            }
+        }
+    }, []);
+    useEffect(() => {
+        const observer = new IntersectionObserver(observerCallback, {
+            // Trigger when a section crosses the vertical center of the viewport.
+            rootMargin: '-35% 0px -35% 0px',
+            threshold: 0,
+        });
+        const currentRefs = sectionRefs.current;
+        for (const sectionRef of currentRefs) {
+            if (sectionRef)
+                observer.observe(sectionRef);
+        }
+        return () => {
+            for (const sectionRef of currentRefs) {
+                if (sectionRef)
+                    observer.unobserve(sectionRef);
+            }
+        };
+    }, [observerCallback, sections.length]);
+    const activeSection = sections[activeIndex];
+    const variants = shouldReduceMotion
+        ? reducedMotionVariants
+        : contentVariants;
+    /* -------------------------------------------------------------- */
+    /*  Sub-renders                                                     */
+    /* -------------------------------------------------------------- */
+    const stickyContent = (jsxs("div", { className: "sticky top-[20vh] flex h-[60vh] items-center justify-center", children: [showProgress && (jsx("div", { className: cn('absolute top-1/2 -translate-y-1/2 flex flex-col gap-2', contentPosition === 'left' ? 'right-0 mr-4' : 'left-0 ml-4'), children: sections.map((section, index) => (jsx("button", { type: "button", "aria-label": `Go to ${section.title}`, onClick: () => {
+                        var _a;
+                        (_a = sectionRefs.current[index]) === null || _a === void 0 ? void 0 : _a.scrollIntoView({
+                            behavior: shouldReduceMotion ? 'auto' : 'smooth',
+                            block: 'center',
+                        });
+                    }, className: cn('h-2 w-2 rounded-full transition-all duration-300', index === activeIndex
+                        ? 'scale-125 bg-[var(--color-primary)]'
+                        : 'bg-[var(--color-border)] hover:bg-[var(--color-text-muted)]') }, section.id))) })), jsx(AnimatePresence, { mode: "wait", children: jsx(motion.div, { variants: variants, initial: "enter", animate: "center", exit: "exit", className: "flex h-full w-full items-center justify-center", children: activeSection.content }, activeSection.id) })] }));
+    const scrollingSections = (jsx("div", { className: "flex flex-col", children: sections.map((section, index) => (jsxs("div", { ref: (el) => {
+                sectionRefs.current[index] = el;
+            }, className: "flex min-h-[60vh] flex-col justify-center py-16 lg:py-24", children: [jsx("h3", { className: cn('text-2xl font-semibold transition-colors duration-300 lg:text-3xl', index === activeIndex
+                        ? 'text-[var(--color-text-primary)]'
+                        : 'text-[var(--color-text-muted)]'), children: section.title }), jsx("p", { className: cn('mt-4 max-w-lg text-lg leading-relaxed transition-colors duration-300 lg:text-xl', index === activeIndex
+                        ? 'text-[var(--color-text-secondary)]'
+                        : 'text-[var(--color-text-placeholder)]'), children: section.description })] }, section.id))) }));
+    /* -------------------------------------------------------------- */
+    /*  Layout                                                          */
+    /* -------------------------------------------------------------- */
+    const isContentLeft = contentPosition === 'left';
+    return (jsx("div", { ref: (node) => {
+            containerRef.current = node;
+            if (typeof ref === 'function')
+                ref(node);
+            else if (ref)
+                ref.current = node;
+        }, className: cn('relative grid grid-cols-1 gap-8 lg:grid-cols-2 lg:gap-16', className), ...props, children: isContentLeft ? (jsxs(Fragment, { children: [jsx("div", { className: "hidden lg:block", children: stickyContent }), scrollingSections] })) : (jsxs(Fragment, { children: [scrollingSections, jsx("div", { className: "hidden lg:block", children: stickyContent })] })) }));
+});
+StickyScroll.displayName = 'StickyScroll';
+
+export { StickyScroll };

package/dist/components/effects/StickyScroll/StickyScroll.types.d.ts

@@ -0,0 +1,19 @@
+export interface StickyScrollSection {
+    /** Unique identifier for this section */
+    id: string;
+    /** Section title displayed in the scrolling column */
+    title: string;
+    /** Section description displayed in the scrolling column */
+    description: string;
+    /** The sticky content to show when this section is active */
+    content: React.ReactNode;
+}
+export interface StickyScrollProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Array of sections defining the scroll experience */
+    sections: StickyScrollSection[];
+    /** Which side the sticky content appears (default 'left') */
+    contentPosition?: 'left' | 'right';
+    /** Show progress dots (default true) */
+    showProgress?: boolean;
+    className?: string;
+}

package/dist/components/effects/StickyScroll/index.d.ts

@@ -0,0 +1,2 @@
+export { StickyScroll } from './StickyScroll';
+export type { StickyScrollProps, StickyScrollSection, } from './StickyScroll.types';

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

@@ -4,11 +4,29 @@ export { GlassEffect } from "./GlassEffect";
 export type { GlassEffectProps, BlendMode } from "./GlassEffect";
 export { Overlay } from "./Overlay";
 export type { OverlayProps, OverlayPosition, OverlayAnimations, } from "./Overlay";
-export { SpotlightBorder } from "./SpotlightBorder";
-export type { SpotlightBorderProps, SpotlightBorderVariation, } from "./SpotlightBorder";
 export { GlassSurface } from "./GlassSurface";
 export type { GlassSurfaceProps, GlassChannel, GlassMixBlendMode, } from "./GlassSurface";
-export { AIOrb } from "./AIOrb";
-export type { AIOrbProps, DotSphereProps, LiquidProps } from "./AIOrb";
 export { Animated } from "./Animated";
 export type { AnimatedGroupProps, AnimatedItemProps, AnimationPreset, AnimatedElement, } from "./Animated";
+export { ProgressiveBlur } from "./ProgressiveBlur";
+export type { ProgressiveBlurProps, ProgressiveBlurPosition, ProgressiveBlurThemeOverrides, } from "./ProgressiveBlur";
+export { Aurora } from "./Aurora";
+export type { AuroraProps } from "./Aurora";
+export { MagneticElement } from "./MagneticElement";
+export type { MagneticElementProps } from "./MagneticElement";
+export { MorphingText } from "./MorphingText";
+export type { MorphingTextProps } from "./MorphingText";
+export { GridPattern } from "./GridPattern";
+export type { GridPatternProps, GridPatternFadeDirection, } from "./GridPattern";
+export { DotPattern } from "./DotPattern";
+export type { DotPatternProps, DotPatternFadeDirection, } from "./DotPattern";
+export { NoiseOverlay } from "./NoiseOverlay";
+export type { NoiseOverlayProps, NoiseBlendMode } from "./NoiseOverlay";
+export { Spotlight } from "./Spotlight";
+export type { SpotlightProps } from "./Spotlight";
+export { ParallaxSection } from "./ParallaxSection";
+export type { ParallaxSectionProps } from "./ParallaxSection";
+export { ScrollReveal } from "./ScrollReveal";
+export type { ScrollRevealProps, ScrollRevealPreset } from "./ScrollReveal";
+export { StickyScroll } from "./StickyScroll";
+export type { StickyScrollProps, StickyScrollSection, } from "./StickyScroll";

package/dist/components/effects/index.js

@@ -1,7 +1,16 @@
 export { CustomCursor } from './CustomCursor/CustomCursor.js';
 export { GlassEffect } from './GlassEffect/GlassEffect.js';
 export { Overlay } from './Overlay/Overlay.js';
-export { SpotlightBorder } from './SpotlightBorder/SpotlightBorder.js';
 export { GlassSurface } from './GlassSurface/GlassSurface.js';
-export { AIOrb } from './AIOrb/AIOrb.js';
 export { Animated } from './Animated/Animated.js';
+export { ProgressiveBlur } from './ProgressiveBlur/ProgressiveBlur.js';
+export { Aurora } from './Aurora/Aurora.js';
+export { MagneticElement } from './MagneticElement/MagneticElement.js';
+export { MorphingText } from './MorphingText/MorphingText.js';
+export { GridPattern } from './GridPattern/GridPattern.js';
+export { DotPattern } from './DotPattern/DotPattern.js';
+export { NoiseOverlay } from './NoiseOverlay/NoiseOverlay.js';
+export { Spotlight } from './Spotlight/Spotlight.js';
+export { ParallaxSection } from './ParallaxSection/ParallaxSection.js';
+export { ScrollReveal } from './ScrollReveal/ScrollReveal.js';
+export { StickyScroll } from './StickyScroll/StickyScroll.js';

package/dist/components/forms/Checkbox/Checkbox.d.ts

@@ -1,6 +1,5 @@
 import React from "react";
 import { CheckboxProps } from "./Checkbox.types";
-/**
- * Checkbox component for selecting one or more options
- */
-export declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;
+export declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>> & {
+    Group: React.ForwardRefExoticComponent<import("./Checkbox.types").CheckboxGroupProps & React.RefAttributes<HTMLFieldSetElement>>;
+};