aura-glass 2.0.39 → 2.1.0

package/dist/esm/components/backgrounds/ParticleBackground.js

@@ -0,0 +1,264 @@
+'use client';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { forwardRef, useRef, useState, useEffect, useCallback, useMemo } from 'react';
+import { cn } from '../../lib/utilsComprehensive.js';
+import '../../primitives/GlassCore.js';
+import '../../primitives/glass/GlassAdvanced.js';
+import { OptimizedGlassCore } from '../../primitives/OptimizedGlassCore.js';
+import '../../primitives/glass/OptimizedGlassAdvanced.js';
+import '../../primitives/MotionNative.js';
+import '../../primitives/motion/MotionFramer.js';
+import { useReducedMotion } from '../../hooks/useReducedMotion.js';
+import { useMotionPreferenceContext } from '../../contexts/MotionPreferenceContext.js';
+import { useA11yId } from '../../utils/a11y.js';
+import styles from './ParticleBackground.module.css.js';
+
+/**
+ * ParticleBackground Component Implementation
+ */
+const ParticleBackgroundComponent = (props, ref) => {
+  const {
+    children,
+    className,
+    style,
+    baseColor = 'rgba(10, 10, 20, 0.8)',
+    particleColor = 'rgba(var(--glass-color-white) / var(--glass-opacity-70))',
+    particleCount = 50,
+    particleSize = 2,
+    particleSpeed = 1,
+    connectParticles = true,
+    interactive = true,
+    blur = false,
+    blurAmount = 5,
+    count,
+    size,
+    speed,
+    color,
+    intent = 'neutral',
+    elevation = 'level2',
+    tier = 'medium',
+    respectMotionPreference = true,
+    ...rest
+  } = props;
+  // Accessibility and motion preferences
+  const componentId = useA11yId('particle-bg');
+  const prefersReducedMotion = useReducedMotion();
+  const {
+    prefersReducedMotion: motionPrefersReduced
+  } = useMotionPreferenceContext();
+  // Determine if motion should be reduced based on all preferences
+  const shouldReduceMotion = respectMotionPreference && (prefersReducedMotion || motionPrefersReduced);
+  // Refs
+  const containerRef = useRef(null);
+  const canvasRef = useRef(null);
+  const animationRef = useRef(null);
+  // State for mouse position
+  const [mousePosition, setMousePosition] = useState(null);
+  // CRITICAL SSR FIX: Initialize particles as empty array, populate in useEffect
+  // This prevents Math.random() from generating different values on server vs client
+  const [particles, setParticles] = useState([]);
+  // Use correct property names with fallbacks
+  const actualCount = count ?? particleCount ?? 50;
+  const actualSize = size ?? particleSize ?? 2;
+  const actualSpeed = speed ?? particleSpeed ?? 1;
+  const actualColor = color ?? particleColor ?? 'rgba(var(--glass-color-white) / var(--glass-opacity-70))';
+  // Helper function to get color values
+  const getColorValues = colorStr => {
+    if (colorStr.startsWith('rgba(')) {
+      const match = colorStr.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)/);
+      if (match) {
+        return {
+          r: parseInt(match[1]),
+          g: parseInt(match[2]),
+          b: parseInt(match[3]),
+          a: match[4] ? parseFloat(match[4]) : 1
+        };
+      }
+    }
+    // Default fallback
+    return {
+      r: 255,
+      g: 255,
+      b: 255,
+      a: 1
+    };
+  };
+  // CRITICAL SSR FIX: Generate particles only on client-side mount
+  // This ensures deterministic behavior and prevents server/client mismatches
+  useEffect(() => {
+    const newParticles = [];
+    for (let i = 0; i < actualCount; i++) {
+      newParticles.push({
+        x: Math.random() * 100,
+        // Percentage
+        y: Math.random() * 100,
+        // Percentage
+        size: Math.random() * actualSize + 1,
+        speedX: (Math.random() - 0.5) * actualSpeed * 0.1,
+        speedY: (Math.random() - 0.5) * actualSpeed * 0.1,
+        opacity: Math.random() * 0.5 + 0.3,
+        color: actualColor
+      });
+    }
+    setParticles(newParticles);
+  }, [actualCount, actualSize, actualSpeed, actualColor]);
+  // Handle canvas animation
+  useEffect(() => {
+    if (shouldReduceMotion) return;
+    const canvas = canvasRef.current;
+    const container = containerRef.current;
+    if (!canvas || !container) return;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) return;
+    // Set canvas size
+    const resizeCanvas = () => {
+      const {
+        width,
+        height
+      } = container.getBoundingClientRect();
+      canvas.width = width;
+      canvas.height = height;
+    };
+    resizeCanvas();
+    window.addEventListener('resize', resizeCanvas);
+    // Animation loop
+    const animate = () => {
+      ctx.clearRect(0, 0, canvas.width, canvas.height);
+      // Update and draw particles
+      particles.forEach((particle, index) => {
+        // Convert percentage to actual coordinates
+        const x = particle.x / 100 * canvas.width;
+        const y = particle.y / 100 * canvas.height;
+        // Draw particle
+        ctx.beginPath();
+        ctx.arc(x, y, particle.size, 0, Math.PI * 2);
+        const colorValues = getColorValues(particle.color);
+        ctx.fillStyle = `rgba(${colorValues.r}, ${colorValues.g}, ${colorValues.b}, ${particle.opacity})`;
+        ctx.fill();
+        // Draw connections
+        if (connectParticles) {
+          for (let j = index + 1; j < particles.length; j++) {
+            const otherParticle = particles[j];
+            const otherX = otherParticle.x / 100 * canvas.width;
+            const otherY = otherParticle.y / 100 * canvas.height;
+            const distance = Math.sqrt(Math.pow(x - otherX, 2) + Math.pow(y - otherY, 2));
+            if (distance < canvas.width * 0.07) {
+              ctx.beginPath();
+              const connectionOpacity = 0.3 - distance / (canvas.width * 0.07) * 0.3;
+              ctx.strokeStyle = `rgba(${colorValues.r}, ${colorValues.g}, ${colorValues.b}, ${connectionOpacity})`;
+              ctx.lineWidth = 0.5;
+              ctx.moveTo(x, y);
+              ctx.lineTo(otherX, otherY);
+              ctx.stroke();
+            }
+          }
+        }
+        // Connect to mouse if interactive and motion is allowed
+        if (interactive && mousePosition && !shouldReduceMotion) {
+          const mouseX = mousePosition.x * canvas.width;
+          const mouseY = mousePosition.y * canvas.height;
+          const distance = Math.sqrt(Math.pow(x - mouseX, 2) + Math.pow(y - mouseY, 2));
+          if (distance < canvas.width * 0.1) {
+            ctx.beginPath();
+            const mouseConnectionOpacity = 0.5 - distance / (canvas.width * 0.1) * 0.5;
+            ctx.strokeStyle = `rgba(${colorValues.r}, ${colorValues.g}, ${colorValues.b}, ${mouseConnectionOpacity})`;
+            ctx.lineWidth = 1;
+            ctx.moveTo(x, y);
+            ctx.lineTo(mouseX, mouseY);
+            ctx.stroke();
+          }
+        }
+        // Update position
+        particle.x += particle.speedX;
+        particle.y += particle.speedY;
+        // Handle boundaries
+        if (particle.x < 0 || particle.x > 100) {
+          particle.speedX *= -1;
+        }
+        if (particle.y < 0 || particle.y > 100) {
+          particle.speedY *= -1;
+        }
+      });
+      // Continue animation
+      animationRef.current = requestAnimationFrame(animate);
+    };
+    // Start animation
+    animate();
+    // Clean up
+    return () => {
+      if (animationRef.current) {
+        cancelAnimationFrame(animationRef.current);
+      }
+      window.removeEventListener('resize', resizeCanvas);
+    };
+  }, [particles, connectParticles, interactive, mousePosition, shouldReduceMotion]);
+  // Handle mouse movement
+  useEffect(() => {
+    if (!interactive || shouldReduceMotion) return;
+    const handleMouseMove = e => {
+      if (!containerRef.current) return;
+      const rect = containerRef.current.getBoundingClientRect();
+      setMousePosition({
+        x: (e.clientX - rect.left) / rect.width,
+        y: (e.clientY - rect.top) / rect.height
+      });
+    };
+    window.addEventListener('mousemove', handleMouseMove);
+    return () => {
+      window.removeEventListener('mousemove', handleMouseMove);
+    };
+  }, [interactive, shouldReduceMotion]);
+  // Combine external ref with internal containerRef
+  const setRefs = useCallback(node => {
+    if (containerRef.current !== node) {
+      containerRef.current = node;
+    }
+    if (ref) {
+      if (typeof ref === 'function') {
+        ref(node);
+      } else {
+        ref.current = node;
+      }
+    }
+  }, [ref]);
+  const blurStyle = useMemo(() => ({
+    '--particle-blur': blur ? `blur(${blurAmount}px)` : 'none'
+  }), [blur, blurAmount]);
+  return jsxs(OptimizedGlassCore, {
+    ref: setRefs,
+    className: cn(styles.container, 'glass-particle-background', className),
+    intent: intent,
+    elevation: elevation,
+    tier: tier,
+    style: style,
+    id: componentId,
+    role: "img",
+    "aria-label": `Interactive particle background with ${actualCount} ${connectParticles ? 'connected' : 'floating'} particles${interactive && !shouldReduceMotion ? ', responding to mouse movement' : ''}`,
+    tabIndex: interactive ? 0 : -1,
+    ...rest,
+    children: [jsx("div", {
+      className: styles.backgroundLayer,
+      style: {
+        backgroundColor: baseColor
+      }
+    }), jsx("canvas", {
+      ref: canvasRef,
+      "aria-hidden": "true",
+      role: "presentation",
+      className: styles.canvas
+    }), jsx("div", {
+      "aria-hidden": "true",
+      className: styles.blurLayer,
+      style: blurStyle
+    }), jsx("div", {
+      className: styles.contentLayer,
+      children: children
+    })]
+  });
+};
+// Wrap the component function with forwardRef
+const ParticleBackground = /*#__PURE__*/forwardRef(ParticleBackgroundComponent);
+ParticleBackground.displayName = 'ParticleBackground';
+
+export { ParticleBackground as default };
+//# sourceMappingURL=ParticleBackground.js.map

package/dist/esm/components/backgrounds/ParticleBackground.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleBackground.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/components/backgrounds/ParticleBackground.module.css.js

@@ -0,0 +1,4 @@
+var styles = {"container":"ParticleBackground-module_container__ntRlQ","canvas":"ParticleBackground-module_canvas__RYd2S","blurLayer":"ParticleBackground-module_blurLayer__4Pq1r","backgroundLayer":"ParticleBackground-module_backgroundLayer__5O4qp","contentLayer":"ParticleBackground-module_contentLayer__FnRYG"};
+
+export { styles as default };
+//# sourceMappingURL=ParticleBackground.module.css.js.map

package/dist/esm/components/backgrounds/ParticleBackground.module.css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleBackground.module.css.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/esm/components/button/EnhancedGlassButton.js

@@ -0,0 +1,406 @@
+'use client';
+import { jsx } from 'react/jsx-runtime';
+import { useReducedMotion } from '../../hooks/useReducedMotion.js';
+import { cn } from '../../lib/utilsComprehensive.js';
+import { forwardRef, useRef, useState, useMemo, useEffect, useCallback } from 'react';
+import { GlassPhysicsEngine } from '../effects/GlassPhysicsEngine.js';
+import { GlassMorphingEngine } from '../effects/GlassMorphingEngine.js';
+import { Glass3DEngine } from '../effects/Glass3DEngine.js';
+import { COMMON_SEQUENCES, OrganicAnimationEngine } from '../animations/OrganicAnimationEngine.js';
+import { SpatialComputingEngine } from '../spatial/SpatialComputingEngine.js';
+import { useEmotionalIntelligence } from '../../utils/emotionalIntelligence.js';
+import { useAIPersonalization, useInteractionRecording } from '../../utils/aiPersonalization.js';
+
+const EnhancedGlassButton = /*#__PURE__*/forwardRef(({
+  children,
+  className,
+  variant = 'primary',
+  size = 'md',
+  enhancedFeatures = {},
+  userId = 'default-user',
+  componentId = 'enhanced-glass-button',
+  onAdvancedInteraction,
+  onClick,
+  ...restProps
+}, ref) => {
+  useReducedMotion();
+  const buttonRef = useRef(null);
+  const [isInteracting, setIsInteracting] = useState(false);
+  const [adaptationApplied, setAdaptationApplied] = useState(false);
+  // Enhanced feature flags with defaults
+  const features = useMemo(() => ({
+    physics: {
+      enabled: true,
+      interaction: 'ripple',
+      intensity: 1,
+      ...enhancedFeatures.physics
+    },
+    morphing: {
+      enabled: true,
+      environmentalAdaptation: true,
+      userActivityAdaptation: true,
+      contentTypeAdaptation: true,
+      ...enhancedFeatures.morphing
+    },
+    spatial3D: {
+      enabled: true,
+      layers: 4,
+      parallax: true,
+      depthOfField: true,
+      holographic: true,
+      ...enhancedFeatures.spatial3D
+    },
+    organicMotion: {
+      enabled: true,
+      patterns: ['gentle', 'interactive'],
+      emotionalContext: 'calm',
+      enableMicroInteractions: true,
+      ...enhancedFeatures.organicMotion
+    },
+    emotionalAdaptation: {
+      enabled: true,
+      biometricTracking: true,
+      behaviorAnalysis: true,
+      uiAdaptation: true,
+      ...enhancedFeatures.emotionalAdaptation
+    },
+    spatialComputing: {
+      enabled: false,
+      // Disabled by default for compatibility
+      gestureRecognition: true,
+      spatialAnchoring: false,
+      vrOptimized: false,
+      ...enhancedFeatures.spatialComputing
+    },
+    aiPersonalization: {
+      enabled: true,
+      learningMode: 'adaptive',
+      recommendationLevel: 'moderate',
+      ...enhancedFeatures.aiPersonalization
+    }
+  }), [enhancedFeatures]);
+  // Initialize intelligence systems
+  const {
+    currentEmotion,
+    uiAdaptation,
+    addBiometricData,
+    addBehaviorData,
+    analyzeEmotion
+  } = useEmotionalIntelligence();
+  const {
+    profile,
+    recommendations,
+    recordInteraction,
+    predictBehavior
+  } = useAIPersonalization(userId);
+  const {
+    startInteraction,
+    endInteraction
+  } = useInteractionRecording(componentId, userId);
+  // Base button styles with glass design tokens
+  const baseStyles = useMemo(() => {
+    const sizeStyles = {
+      xs: 'glass-h-xs glass-px-xs glass-text-xs',
+      sm: 'glass-h-sm glass-px-sm glass-text-sm',
+      md: 'glass-h-md glass-px-md glass-text-sm',
+      lg: 'glass-h-lg glass-px-lg glass-text-base',
+      xl: 'glass-h-xl glass-px-xl glass-text-lg'
+    };
+    const variantStyles = {
+      primary: 'glass-surface-primary glass-text-primary hover:glass-surface-primary-hover',
+      secondary: 'glass-surface-secondary glass-text-secondary hover:glass-surface-secondary-hover',
+      destructive: 'glass-surface-danger glass-text-danger hover:glass-surface-danger-hover',
+      ghost: 'glass-surface-transparent hover:glass-surface-accent glass-text-secondary hover:glass-text-primary',
+      outline: 'glass-border-subtle glass-surface-background hover:glass-surface-accent glass-text-secondary hover:glass-text-primary'
+    };
+    return cn(
+    // Base glass foundation
+    'glass-foundation-complete', 'inline-flex items-center justify-center whitespace-nowrap', 'glass-radius-md glass-transition glass-focus', 'font-medium cursor-pointer select-none', 'disabled:pointer-events-none disabled:opacity-50',
+    // Glass-specific utilities
+    'glass-overlay-specular glass-parallax', 'glass-magnet glass-ripple glass-press', sizeStyles[size], variantStyles[variant]);
+  }, [size, variant]);
+  // Apply AI personalization adaptations
+  useEffect(() => {
+    if (features.aiPersonalization.enabled && profile && !adaptationApplied) {
+      // Apply learned preferences
+      const buttonEl = buttonRef.current;
+      if (buttonEl) {
+        // Apply animation speed preference
+        if (profile.uiPreferences.animationSpeed !== 1) {
+          buttonEl.style.transitionDuration = `${300 / profile.uiPreferences.animationSpeed}ms`;
+        }
+        // Apply density preference
+        if (profile.uiPreferences.density === 'compact') {
+          buttonEl.style.padding = '0.25rem 0.75rem';
+        } else if (profile.uiPreferences.density === 'spacious') {
+          buttonEl.style.padding = '0.75rem 2rem';
+        }
+        setAdaptationApplied(true);
+      }
+    }
+  }, [features.aiPersonalization.enabled, profile, adaptationApplied]);
+  // Enhanced click handler with all intelligence systems
+  const handleEnhancedClick = useCallback(async event => {
+    setIsInteracting(true);
+    // Start interaction recording
+    const interaction = startInteraction('click', window.location.pathname);
+    // Record biometric data (simulated - would use real sensors)
+    if (features.emotionalAdaptation.enabled && features.emotionalAdaptation.biometricTracking) {
+      addBiometricData({
+        mouseVelocity: Math.sqrt(event.movementX ** 2 + event.movementY ** 2),
+        clickPressure: Math.random() * 0.5 + 0.5,
+        // Simulated
+        dwellTime: Date.now() % 5000 // Simulated
+      });
+    }
+    // Record behavioral data
+    if (features.emotionalAdaptation.enabled && features.emotionalAdaptation.behaviorAnalysis) {
+      addBehaviorData({
+        interactionFrequency: Math.floor(Math.random() * 20) + 5,
+        decisionTime: Math.random() * 2000 + 500,
+        errorRate: Math.random() * 0.1
+      });
+    }
+    // Analyze emotion and trigger UI adaptation
+    if (features.emotionalAdaptation.enabled) {
+      const emotion = analyzeEmotion();
+      if (emotion) {
+        onAdvancedInteraction?.('emotion-detected', emotion);
+      }
+    }
+    // Predict next likely behavior
+    if (features.aiPersonalization.enabled) {
+      const predictions = predictBehavior(window.location.pathname);
+      if (predictions.length > 0) {
+        onAdvancedInteraction?.('behavior-predicted', predictions[0]);
+      }
+    }
+    // Call original onClick
+    onClick?.(event);
+    // End interaction recording
+    endInteraction(interaction, {
+      x: event.clientX,
+      y: event.clientY
+    });
+    // Advanced interaction callback
+    onAdvancedInteraction?.('enhanced-click', {
+      emotion: currentEmotion,
+      predictions: predictBehavior(window.location.pathname),
+      adaptations: uiAdaptation
+    });
+    setTimeout(() => setIsInteracting(false), 300);
+  }, [startInteraction, endInteraction, onClick, features, addBiometricData, addBehaviorData, analyzeEmotion, predictBehavior, currentEmotion, uiAdaptation, onAdvancedInteraction]);
+  // Create the enhanced button with all systems
+  const {
+    ['aria-label']: ariaLabelProp,
+    ...buttonProps
+  } = restProps;
+  const buttonContent = children ?? "Action";
+  const accessibleLabel = ariaLabelProp || (typeof buttonContent === "string" ? buttonContent : "Enhanced glass button");
+  const enhancedButton = useMemo(() => {
+    let buttonElement = jsx("button", {
+      ref: buttonRef,
+      className: cn(baseStyles, className),
+      onClick: handleEnhancedClick,
+      "aria-label": accessibleLabel,
+      ...buttonProps,
+      children: buttonContent
+    });
+    // Wrap with Physics Engine
+    if (features.physics.enabled) {
+      buttonElement = jsx(GlassPhysicsEngine, {
+        interaction: features.physics.interaction,
+        intensity: features.physics.intensity,
+        enabled: features.physics.enabled,
+        children: buttonElement
+      });
+    }
+    // Wrap with Morphing Engine
+    if (features.morphing.enabled) {
+      buttonElement = jsx(GlassMorphingEngine, {
+        enableRealTimeAdaptation: features.morphing.environmentalAdaptation,
+        userActivity: isInteracting ? 'focused' : 'browsing',
+        contentType: "interactive",
+        intensity: features.physics.intensity || 1,
+        children: buttonElement
+      });
+    }
+    // Wrap with 3D Engine
+    if (features.spatial3D.enabled) {
+      buttonElement = jsx(Glass3DEngine, {
+        enableParallax: features.spatial3D.parallax,
+        enableDepthOfField: features.spatial3D.depthOfField,
+        enableHolographic: features.spatial3D.holographic,
+        maxDepthLayers: features.spatial3D.layers,
+        children: buttonElement
+      });
+    }
+    // Wrap with Organic Animation Engine
+    if (features.organicMotion.enabled) {
+      const animationSequences = features.organicMotion.patterns?.flatMap(pattern => COMMON_SEQUENCES[pattern] || []);
+      buttonElement = jsx(OrganicAnimationEngine, {
+        sequences: animationSequences,
+        emotionalContext: currentEmotion?.primary || features.organicMotion.emotionalContext,
+        enableMicroInteractions: features.organicMotion.enableMicroInteractions,
+        children: buttonElement
+      });
+    }
+    // Wrap with Spatial Computing Engine (for AR/VR)
+    if (features.spatialComputing.enabled) {
+      buttonElement = jsx(SpatialComputingEngine, {
+        enableGestures: features.spatialComputing.gestureRecognition,
+        enableAnchoring: features.spatialComputing.spatialAnchoring,
+        spatialId: `${componentId}-spatial`,
+        onGesture: gesture => onAdvancedInteraction?.('gesture', gesture),
+        children: buttonElement
+      });
+    }
+    return buttonElement;
+  }, [accessibleLabel, baseStyles, buttonContent, buttonProps, className, componentId, currentEmotion, features, handleEnhancedClick, isInteracting, onAdvancedInteraction]);
+  // Forward ref to the actual button element
+  useEffect(() => {
+    if (typeof ref === 'function') {
+      ref(buttonRef.current);
+    } else if (ref) {
+      ref.current = buttonRef.current;
+    }
+  }, [ref]);
+  return enhancedButton;
+});
+EnhancedGlassButton.displayName = 'EnhancedGlassButton';
+// Predefined enhanced button variants for common use cases
+const PhysicsGlassButton = props => jsx(EnhancedGlassButton, {
+  ...props,
+  enhancedFeatures: {
+    physics: {
+      enabled: true,
+      interaction: 'ripple',
+      intensity: 1.2
+    },
+    organicMotion: {
+      enabled: true,
+      patterns: ['interactive']
+    },
+    aiPersonalization: {
+      enabled: true
+    }
+  }
+});
+const ImmersiveGlassButton = props => jsx(EnhancedGlassButton, {
+  ...props,
+  enhancedFeatures: {
+    physics: {
+      enabled: true,
+      interaction: 'ripple'
+    },
+    morphing: {
+      enabled: true,
+      environmentalAdaptation: true
+    },
+    spatial3D: {
+      enabled: true,
+      holographic: true
+    },
+    organicMotion: {
+      enabled: true,
+      patterns: ['gentle', 'interactive']
+    },
+    emotionalAdaptation: {
+      enabled: true
+    },
+    aiPersonalization: {
+      enabled: true
+    }
+  }
+});
+const VRGlassButton = props => jsx(EnhancedGlassButton, {
+  ...props,
+  enhancedFeatures: {
+    spatialComputing: {
+      enabled: true,
+      gestureRecognition: true,
+      vrOptimized: true
+    },
+    spatial3D: {
+      enabled: true,
+      layers: 6
+    },
+    physics: {
+      enabled: true,
+      interaction: 'vibrate'
+    },
+    aiPersonalization: {
+      enabled: true
+    }
+  }
+});
+const SmartAdaptiveButton = props => jsx(EnhancedGlassButton, {
+  ...props,
+  enhancedFeatures: {
+    emotionalAdaptation: {
+      enabled: true,
+      biometricTracking: true,
+      behaviorAnalysis: true,
+      uiAdaptation: true
+    },
+    aiPersonalization: {
+      enabled: true,
+      learningMode: 'adaptive',
+      recommendationLevel: 'comprehensive'
+    },
+    morphing: {
+      enabled: true,
+      userActivityAdaptation: true
+    },
+    organicMotion: {
+      enabled: true,
+      enableMicroInteractions: true
+    }
+  }
+});
+const UltraEnhancedButton = props => jsx(EnhancedGlassButton, {
+  ...props,
+  enhancedFeatures: {
+    physics: {
+      enabled: true,
+      interaction: 'ripple',
+      intensity: 1.5
+    },
+    morphing: {
+      enabled: true,
+      environmentalAdaptation: true,
+      userActivityAdaptation: true,
+      contentTypeAdaptation: true
+    },
+    spatial3D: {
+      enabled: true,
+      layers: 6,
+      parallax: true,
+      depthOfField: true,
+      holographic: true
+    },
+    organicMotion: {
+      enabled: true,
+      patterns: ['gentle', 'energetic', 'interactive'],
+      enableMicroInteractions: true
+    },
+    emotionalAdaptation: {
+      enabled: true,
+      biometricTracking: true,
+      behaviorAnalysis: true,
+      uiAdaptation: true
+    },
+    spatialComputing: {
+      enabled: false
+    },
+    // Disabled for web compatibility
+    aiPersonalization: {
+      enabled: true,
+      learningMode: 'adaptive',
+      recommendationLevel: 'comprehensive'
+    }
+  }
+});
+
+export { EnhancedGlassButton, ImmersiveGlassButton, PhysicsGlassButton, SmartAdaptiveButton, UltraEnhancedButton, VRGlassButton, EnhancedGlassButton as default };
+//# sourceMappingURL=EnhancedGlassButton.js.map

package/dist/esm/components/button/EnhancedGlassButton.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnhancedGlassButton.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}