@libreapps/ui 5.4.1

package/dist/spline/media-stack.mjs

@@ -0,0 +1,185 @@
+"use client";
+import Spline from '@splinetool/react-spline';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import NextImage from 'next/image';
+import { jsx } from 'react/jsx-runtime';
+import React from 'react';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// util/spread-to-transform.ts
+function spreadToTransform(t) {
+  let transformStrings = [];
+  const scaleVal = "scale" in t ? t.scale : void 0;
+  if (scaleVal) {
+    if (typeof scaleVal === "number") {
+      transformStrings.push(`scale(${scaleVal})`);
+    } else if (Array.isArray(scaleVal) && scaleVal.length == 2 && typeof scaleVal[0] === "number") {
+      transformStrings.push(`scale(${scaleVal[0]}, ${scaleVal[1]})`);
+    } else {
+      throw new Error("parsing MediaTransform: Unrecognized value for 'scale'!");
+    }
+  }
+  return transformStrings.length > 0 ? { transform: transformStrings.join(" ") } : {};
+}
+__name(spreadToTransform, "spreadToTransform");
+var spread_to_transform_default = spreadToTransform;
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+__name(cn, "cn");
+
+// util/index.ts
+function constrain(value, minOrConstrainTo, max) {
+  if (typeof value === "number" && typeof minOrConstrainTo === "number" && typeof max === "number") {
+    return Math.min(Math.max(value, minOrConstrainTo), max);
+  }
+  if (typeof value === "object" && typeof minOrConstrainTo === "object") {
+    const dim = value;
+    const constrainTo = minOrConstrainTo;
+    const aspectRatio = dim.w / dim.h;
+    const constrainAspectRatio = constrainTo.w / constrainTo.h;
+    if (aspectRatio > constrainAspectRatio) {
+      return {
+        w: constrainTo.w,
+        h: constrainTo.w / aspectRatio
+      };
+    } else {
+      return {
+        w: constrainTo.h * aspectRatio,
+        h: constrainTo.h
+      };
+    }
+  }
+  throw new Error("Invalid parameters for constrain function");
+}
+__name(constrain, "constrain");
+var Image = /* @__PURE__ */ __name(({
+  def,
+  constrainTo,
+  transform = {},
+  fullWidth = false,
+  className = "",
+  preload = false
+}) => {
+  const {
+    src,
+    alt: _alt,
+    dim,
+    sizes,
+    svgFillClass: _svgFillClass
+  } = def;
+  const toSpread = {};
+  if (fullWidth) {
+    toSpread.style = {
+      width: "100%",
+      height: "auto",
+      ...spread_to_transform_default(transform)
+    };
+    if (constrainTo) {
+      toSpread.style.maxWidth = constrainTo.w;
+      toSpread.style.maxHeight = constrainTo.h;
+    }
+  } else {
+    const resolved = constrainTo ? constrain(dim, constrainTo) : dim;
+    toSpread.width = resolved.w;
+    toSpread.height = resolved.h;
+    toSpread.style = { ...spread_to_transform_default(transform) };
+  }
+  if (sizes) {
+    toSpread.sizes = sizes;
+  }
+  let alt;
+  if (_alt) {
+    alt = _alt;
+  } else {
+    const tokens = src.split("/");
+    alt = tokens.length > 0 ? tokens[tokens.length - 1] : src;
+  }
+  const svgFillClass = _svgFillClass ?? "";
+  return fullWidth ? /* @__PURE__ */ jsx("div", { className: "relative flex flex-col items-center justify-center w-full", children: /* @__PURE__ */ jsx(
+    NextImage,
+    {
+      src,
+      alt,
+      ...toSpread,
+      priority: preload,
+      loading: preload ? "eager" : "lazy",
+      className: cn(svgFillClass, className)
+    }
+  ) }) : /* @__PURE__ */ jsx(
+    NextImage,
+    {
+      src,
+      alt,
+      ...toSpread,
+      priority: preload,
+      loading: preload ? "eager" : "lazy",
+      className: cn(svgFillClass, className)
+    }
+  );
+}, "Image");
+var image_default = Image;
+var VideoPlayer = React.forwardRef(
+  ({
+    sources,
+    ...rest
+  }, ref) => {
+    return /* @__PURE__ */ jsx("video", { ref, ...rest, children: sources.map((source, index) => /* @__PURE__ */ jsx("source", { src: source }, index)) });
+  }
+);
+var video_player_default = VideoPlayer;
+var MediaStack = /* @__PURE__ */ __name(({
+  media,
+  constrainTo: cnst = { w: 250, h: 250 },
+  clx = ""
+}) => {
+  const { img, video, animation, mediaTransform } = media;
+  const transform = mediaTransform ?? {};
+  if (animation) {
+    return /* @__PURE__ */ jsx(
+      Spline,
+      {
+        scene: animation,
+        className: cn(clx, "pointer-events-none"),
+        "data-vaul-no-drag": true,
+        style: {
+          width: 6 / 5 * (typeof cnst.h === "number" ? cnst.h : parseInt(cnst.h)),
+          height: cnst.h,
+          ...spread_to_transform_default(transform)
+        }
+      }
+    );
+  }
+  if (video) {
+    const dim = constrain(video.dim.md, cnst);
+    return /* @__PURE__ */ jsx(
+      video_player_default,
+      {
+        className: clx,
+        sources: video.sources,
+        width: dim.w,
+        height: dim.h,
+        style: {
+          minHeight: dim.h,
+          ...spread_to_transform_default(transform)
+        },
+        ...video.videoProps
+      }
+    );
+  }
+  return img ? /* @__PURE__ */ jsx(
+    image_default,
+    {
+      def: img,
+      constrainTo: cnst,
+      className: clx,
+      transform
+    }
+  ) : /* @__PURE__ */ jsx("div", { style: { width: cnst.w, height: cnst.h }, className: cn("bg-level-2", clx) });
+}, "MediaStack");
+var media_stack_default = MediaStack;
+
+export { media_stack_default as default };

package/dist/spline/player.js

@@ -0,0 +1,37 @@
+"use client";
+'use strict';
+
+var Spline = require('@splinetool/react-spline');
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Spline__default = /*#__PURE__*/_interopDefault(Spline);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function cn(...inputs) {
+  return tailwindMerge.twMerge(clsx.clsx(inputs));
+}
+__name(cn, "cn");
+var SplinePlayer = /* @__PURE__ */ __name(({
+  scene,
+  className,
+  style,
+  onLoad
+}) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Spline__default.default,
+    {
+      scene,
+      className: cn("pointer-events-none", className),
+      style,
+      onLoad
+    }
+  );
+}, "SplinePlayer");
+var player_default = SplinePlayer;
+
+module.exports = player_default;

package/dist/spline/player.mjs

@@ -0,0 +1,31 @@
+"use client";
+import Spline from '@splinetool/react-spline';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import { jsx } from 'react/jsx-runtime';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+__name(cn, "cn");
+var SplinePlayer = /* @__PURE__ */ __name(({
+  scene,
+  className,
+  style,
+  onLoad
+}) => {
+  return /* @__PURE__ */ jsx(
+    Spline,
+    {
+      scene,
+      className: cn("pointer-events-none", className),
+      style,
+      onLoad
+    }
+  );
+}, "SplinePlayer");
+var player_default = SplinePlayer;
+
+export { player_default as default };

package/dist/src/3d/button.d.ts

@@ -0,0 +1,26 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const button3DVariants: (props?: ({
+    variant?: "link" | "default" | "secondary" | "destructive" | "outline" | "ghost" | "neon" | "glass" | "gradient" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "xl" | null | undefined;
+    depth?: "none" | "default" | "sm" | "lg" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface Button3DProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof button3DVariants> {
+    asChild?: boolean;
+    tiltOnHover?: boolean;
+    glowIntensity?: number;
+    shadowColor?: string;
+    pressAnimation?: boolean;
+}
+declare const Button3D: React.ForwardRefExoticComponent<Button3DProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Button3DPreset: {
+    Hero: React.ForwardRefExoticComponent<Omit<Button3DProps, "variant" | "size" | "depth"> & React.RefAttributes<HTMLButtonElement>>;
+    CTA: React.ForwardRefExoticComponent<Omit<Button3DProps, "variant" | "size" | "depth"> & React.RefAttributes<HTMLButtonElement>>;
+    Glass: React.ForwardRefExoticComponent<Omit<Button3DProps, "variant" | "size" | "depth"> & React.RefAttributes<HTMLButtonElement>>;
+    Minimal: React.ForwardRefExoticComponent<Omit<Button3DProps, "variant" | "size" | "depth"> & React.RefAttributes<HTMLButtonElement>>;
+    Danger: React.ForwardRefExoticComponent<Omit<Button3DProps, "variant" | "size" | "depth"> & React.RefAttributes<HTMLButtonElement>>;
+};
+declare const Button3DLoading: React.ForwardRefExoticComponent<Button3DProps & {
+    loading?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+export { Button3D, Button3DPreset, Button3DLoading, button3DVariants, type Button3DProps, };

package/dist/src/3d/card.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+interface Card3DProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    maxTilt?: number;
+    perspective?: number;
+    scale?: number;
+    speed?: number;
+    glare?: boolean;
+    glareMaxOpacity?: number;
+    className?: string;
+}
+declare const Card3D: React.ForwardRefExoticComponent<Card3DProps & React.RefAttributes<HTMLDivElement>>;
+declare const Card3DHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    depth?: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Card3DTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & {
+    depth?: number;
+} & React.RefAttributes<HTMLParagraphElement>>;
+declare const Card3DDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & {
+    depth?: number;
+} & React.RefAttributes<HTMLParagraphElement>>;
+declare const Card3DContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    depth?: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Card3DFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    depth?: number;
+} & React.RefAttributes<HTMLDivElement>>;
+export { Card3D, Card3DHeader, Card3DTitle, Card3DDescription, Card3DContent, Card3DFooter, };

package/dist/src/3d/carousel.d.ts

@@ -0,0 +1,25 @@
+import * as React from "react";
+interface Carousel3DItem {
+    id: string;
+    content: React.ReactNode;
+}
+interface Carousel3DProps extends React.HTMLAttributes<HTMLDivElement> {
+    items: Carousel3DItem[];
+    itemWidth?: number;
+    itemHeight?: number;
+    spacing?: number;
+    perspective?: number;
+    rotateY?: number;
+    autoRotate?: boolean;
+    autoRotateSpeed?: number;
+    showControls?: boolean;
+    infinite?: boolean;
+    className?: string;
+}
+declare const Carousel3D: React.ForwardRefExoticComponent<Carousel3DProps & React.RefAttributes<HTMLDivElement>>;
+declare const Carousel3DCard: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const Carousel3DCardImage: React.ForwardRefExoticComponent<React.ImgHTMLAttributes<HTMLImageElement> & React.RefAttributes<HTMLImageElement>>;
+declare const Carousel3DCardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const Carousel3DCardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+declare const Carousel3DCardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { Carousel3D, Carousel3DCard, Carousel3DCardImage, Carousel3DCardContent, Carousel3DCardTitle, Carousel3DCardDescription, type Carousel3DItem, type Carousel3DProps, };

package/dist/src/3d/grid.d.ts

@@ -0,0 +1,48 @@
+import * as React from "react";
+interface Grid3DItem {
+    id: string;
+    content: React.ReactNode;
+    span?: {
+        x: number;
+        y: number;
+    };
+    elevation?: number;
+}
+interface Grid3DProps extends React.HTMLAttributes<HTMLDivElement> {
+    items: Grid3DItem[];
+    columns?: number;
+    rows?: number;
+    gap?: number;
+    perspective?: number;
+    rotateX?: number;
+    rotateY?: number;
+    cellHeight?: number;
+    cellWidth?: number;
+    isometric?: boolean;
+    tiltOnHover?: boolean;
+    staggerAnimation?: boolean;
+    animationDelay?: number;
+    elevationOnHover?: boolean;
+    maxElevation?: number;
+    className?: string;
+}
+declare const Grid3D: React.ForwardRefExoticComponent<Grid3DProps & React.RefAttributes<HTMLDivElement>>;
+declare const Grid3DCard: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    title?: string;
+    description?: string;
+    image?: string;
+    badge?: string;
+    elevation?: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Grid3DPreset: {
+    Dashboard: React.ForwardRefExoticComponent<Omit<Grid3DProps, "items"> & React.RefAttributes<HTMLDivElement>>;
+    Isometric: React.ForwardRefExoticComponent<Omit<Grid3DProps, "items"> & React.RefAttributes<HTMLDivElement>>;
+    Gallery: React.ForwardRefExoticComponent<Omit<Grid3DProps, "items"> & React.RefAttributes<HTMLDivElement>>;
+    Compact: React.ForwardRefExoticComponent<Omit<Grid3DProps, "items"> & React.RefAttributes<HTMLDivElement>>;
+};
+declare const Grid3DAuto: React.ForwardRefExoticComponent<Omit<Grid3DProps, "columns" | "rows"> & {
+    minCellWidth?: number;
+    maxCellWidth?: number;
+    aspectRatio?: number;
+} & React.RefAttributes<HTMLDivElement>>;
+export { Grid3D, Grid3DCard, Grid3DPreset, Grid3DAuto, type Grid3DItem, type Grid3DProps, };

package/dist/src/3d/index.d.ts

@@ -0,0 +1,6 @@
+export { Button3D, Button3DPreset, Button3DLoading, button3DVariants, type Button3DProps, } from "./button";
+export { Card3D, Card3DHeader, Card3DTitle, Card3DDescription, Card3DContent, Card3DFooter, } from "./card";
+export { Carousel3D, Carousel3DCard, Carousel3DCardImage, Carousel3DCardContent, Carousel3DCardTitle, Carousel3DCardDescription, type Carousel3DItem, type Carousel3DProps, } from "./carousel";
+export { Grid3D, Grid3DCard, Grid3DPreset, Grid3DAuto, type Grid3DItem, type Grid3DProps, } from "./grid";
+export { Marquee3D, Marquee3DPreset, Marquee3DFloating, marquee3DVariants, type Marquee3DProps, } from "./marquee";
+export { Pin3D } from "./pin";

package/dist/src/3d/marquee.d.ts

@@ -0,0 +1,36 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const marquee3DVariants: (props?: ({
+    variant?: "default" | "neon" | "glass" | "rainbow" | "metallic" | "fire" | null | undefined;
+    size?: "default" | "sm" | "lg" | "xl" | "2xl" | "3xl" | null | undefined;
+    direction?: "left" | "right" | "up" | "down" | null | undefined;
+    perspective?: "none" | "default" | "sm" | "lg" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface Marquee3DProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof marquee3DVariants> {
+    children: React.ReactNode;
+    speed?: number;
+    pauseOnHover?: boolean;
+    reverse?: boolean;
+    repeat?: number;
+    gap?: number;
+    rotateX?: number;
+    rotateY?: number;
+    rotateZ?: number;
+    autoFill?: boolean;
+    gradient?: boolean;
+    gradientColor?: string;
+    gradientWidth?: number;
+}
+declare const Marquee3D: React.ForwardRefExoticComponent<Marquee3DProps & React.RefAttributes<HTMLDivElement>>;
+declare const Marquee3DPreset: {
+    Hero: React.ForwardRefExoticComponent<Omit<Marquee3DProps, "variant" | "size"> & React.RefAttributes<HTMLDivElement>>;
+    Neon: React.ForwardRefExoticComponent<Omit<Marquee3DProps, "variant" | "size"> & React.RefAttributes<HTMLDivElement>>;
+    Metallic: React.ForwardRefExoticComponent<Omit<Marquee3DProps, "variant" | "size"> & React.RefAttributes<HTMLDivElement>>;
+    Fire: React.ForwardRefExoticComponent<Omit<Marquee3DProps, "variant" | "size"> & React.RefAttributes<HTMLDivElement>>;
+    Glass: React.ForwardRefExoticComponent<Omit<Marquee3DProps, "variant" | "size"> & React.RefAttributes<HTMLDivElement>>;
+};
+declare const Marquee3DFloating: React.ForwardRefExoticComponent<Marquee3DProps & {
+    floatIntensity?: number;
+    floatSpeed?: number;
+} & React.RefAttributes<HTMLDivElement>>;
+export { Marquee3D, Marquee3DPreset, Marquee3DFloating, marquee3DVariants, type Marquee3DProps, };

package/dist/src/3d/pin.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+interface Pin3DProps extends React.HTMLAttributes<HTMLDivElement> {
+    title?: string;
+    href?: string;
+}
+declare const Pin3D: React.ForwardRefExoticComponent<Pin3DProps & React.RefAttributes<HTMLDivElement>>;
+export { Pin3D };

package/dist/src/animation/apple-cards-carousel.d.ts

@@ -0,0 +1,35 @@
+import * as React from "react";
+export interface CarouselCard {
+    id: string;
+    title: string;
+    subtitle?: string;
+    description?: string;
+    image?: string;
+    gradient?: string;
+    content?: React.ReactNode;
+}
+interface AppleCardsCarouselProps {
+    cards: CarouselCard[];
+    autoPlay?: boolean;
+    autoPlayInterval?: number;
+    className?: string;
+    cardClassName?: string;
+    showArrows?: boolean;
+    showDots?: boolean;
+    parallaxOffset?: number;
+    stackOffset?: number;
+    stackScale?: number;
+    swipeThreshold?: number;
+}
+export declare function AppleCardsCarousel({ cards, autoPlay, autoPlayInterval, className, cardClassName, showArrows, showDots, parallaxOffset, stackOffset, stackScale, swipeThreshold, }: AppleCardsCarouselProps): import("react/jsx-runtime").JSX.Element;
+export declare const gradientPresets: {
+    sunset: string;
+    ocean: string;
+    fire: string;
+    forest: string;
+    galaxy: string;
+    aurora: string;
+    peach: string;
+    lavender: string;
+};
+export {};

package/dist/src/animation/apple-hello-effect.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+interface AppleHelloEffectProps extends React.HTMLAttributes<HTMLDivElement> {
+    text?: string;
+    duration?: number;
+}
+declare const AppleHelloEffect: React.ForwardRefExoticComponent<AppleHelloEffectProps & React.RefAttributes<HTMLDivElement>>;
+export { AppleHelloEffect };

package/dist/src/animation/background.d.ts

@@ -0,0 +1,102 @@
+import React from "react";
+export interface AnimatedBackgroundProps {
+    /**
+     * Background animation type
+     */
+    animation?: "gradient" | "blob" | "wave" | "mesh" | "parallax" | "particles";
+    /**
+     * Animation speed (0.1 - 2.0)
+     */
+    speed?: number;
+    /**
+     * Color palette for the animation
+     */
+    colors?: string[];
+    /**
+     * Whether animation is paused
+     */
+    paused?: boolean;
+    /**
+     * Custom CSS class
+     */
+    className?: string;
+    /**
+     * Custom styling
+     */
+    style?: React.CSSProperties;
+    /**
+     * Children to render on top
+     */
+    children?: React.ReactNode;
+    /**
+     * Intensity of the animation (0-1)
+     */
+    intensity?: number;
+    /**
+     * Whether to blur the background
+     */
+    blur?: boolean;
+    /**
+     * Blur amount in pixels
+     */
+    blurAmount?: number;
+    /**
+     * Opacity of the background
+     */
+    opacity?: number;
+    /**
+     * Number of elements (for blob, particles, etc.)
+     */
+    elementCount?: number;
+    /**
+     * Custom dimensions
+     */
+    width?: number | string;
+    height?: number | string;
+    /**
+     * Whether to cover entire viewport
+     */
+    fullscreen?: boolean;
+    /**
+     * Parallax layers (for parallax animation)
+     */
+    parallaxLayers?: Array<{
+        speed: number;
+        color: string;
+        opacity: number;
+    }>;
+}
+/**
+ * Animated background component with multiple animation types
+ */
+export declare function AnimatedBackground({ animation, speed, colors, paused, className, style, children, intensity, blur, blurAmount, opacity, elementCount, width, height, fullscreen, parallaxLayers, }: AnimatedBackgroundProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Preset animated background variations
+ */
+export declare const AnimatedBackgroundPresets: {
+    /**
+     * Calm gradient flow
+     */
+    CalmGradient: (props: Omit<AnimatedBackgroundProps, "animation" | "colors" | "speed">) => import("react/jsx-runtime").JSX.Element;
+    /**
+     * Ocean waves
+     */
+    OceanWaves: (props: Omit<AnimatedBackgroundProps, "animation" | "colors">) => import("react/jsx-runtime").JSX.Element;
+    /**
+     * Floating bubbles
+     */
+    FloatingBubbles: (props: Omit<AnimatedBackgroundProps, "animation" | "colors" | "elementCount">) => import("react/jsx-runtime").JSX.Element;
+    /**
+     * Cosmic mesh
+     */
+    CosmicMesh: (props: Omit<AnimatedBackgroundProps, "animation" | "colors">) => import("react/jsx-runtime").JSX.Element;
+    /**
+     * Starfield particles
+     */
+    Starfield: (props: Omit<AnimatedBackgroundProps, "animation" | "colors" | "elementCount">) => import("react/jsx-runtime").JSX.Element;
+    /**
+     * Aurora parallax
+     */
+    Aurora: (props: Omit<AnimatedBackgroundProps, "animation" | "parallaxLayers">) => import("react/jsx-runtime").JSX.Element;
+};
+export default AnimatedBackground;

package/dist/src/animation/beam.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+interface AnimatedBeamProps extends React.SVGAttributes<SVGSVGElement> {
+    duration?: number;
+    delay?: number;
+    pathColor?: string;
+    pathWidth?: number;
+    gradientStartColor?: string;
+    gradientStopColor?: string;
+    containerRef?: React.RefObject<HTMLElement>;
+    fromRef?: React.RefObject<HTMLElement>;
+    toRef?: React.RefObject<HTMLElement>;
+}
+declare const AnimatedBeam: React.ForwardRefExoticComponent<AnimatedBeamProps & React.RefAttributes<SVGSVGElement>>;
+export { AnimatedBeam };

package/dist/src/animation/cursor.d.ts

@@ -0,0 +1,69 @@
+export interface AnimatedCursorProps {
+    /**
+     * Whether the cursor is visible
+     */
+    isVisible?: boolean;
+    /**
+     * Cursor size in pixels
+     */
+    size?: number;
+    /**
+     * Main cursor color
+     */
+    color?: string;
+    /**
+     * Trail cursor color
+     */
+    trailColor?: string;
+    /**
+     * Animation duration in milliseconds
+     */
+    animationDuration?: number;
+    /**
+     * Whether to show trail effect
+     */
+    showTrail?: boolean;
+    /**
+     * Number of trail elements
+     */
+    trailLength?: number;
+    /**
+     * Blend mode for cursor
+     */
+    blendMode?: "normal" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion";
+    /**
+     * Scale factor on hover
+     */
+    hoverScale?: number;
+    /**
+     * Whether to hide on touch devices
+     */
+    hideOnTouch?: boolean;
+    /**
+     * Custom CSS class
+     */
+    className?: string;
+    /**
+     * Click animation duration
+     */
+    clickAnimationDuration?: number;
+    /**
+     * Z-index for cursor
+     */
+    zIndex?: number;
+}
+export interface CursorPosition {
+    x: number;
+    y: number;
+}
+export interface CursorState {
+    position: CursorPosition;
+    isHovering: boolean;
+    isClicking: boolean;
+    cursorType: "default" | "pointer" | "text" | "grab" | "grabbing";
+}
+/**
+ * AnimatedCursor component providing customizable animated cursor with trail effects
+ */
+export declare function AnimatedCursor({ isVisible, size, color, trailColor, animationDuration, showTrail, trailLength, blendMode, hoverScale, hideOnTouch, className, clickAnimationDuration, zIndex, }: AnimatedCursorProps): import("react/jsx-runtime").JSX.Element | null;
+export default AnimatedCursor;