aura-glass 2.0.39 → 2.1.0

package/dist/esm/components/charts/ModularGlassDataChart.js.map

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

package/dist/esm/components/charts/components/AtmosphericEffects.js

@@ -0,0 +1,125 @@
+'use client';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useState, useRef, useMemo, useEffect } from 'react';
+
+const AtmosphericEffects = ({
+  // TODO: Integrate ContrastGuard in chart labels, tooltips, and legends for WCAG AA compliance
+  qualityTier = 'medium',
+  color = 'var(--glass-color-primary)',
+  isReducedMotion = false
+}) => {
+  const [particles, setParticles] = useState([]);
+  const animationRef = useRef();
+  const containerRef = useRef(null);
+  // Particle count based on quality tier
+  const particleCount = useMemo(() => {
+    switch (qualityTier) {
+      case 'low':
+        return 0;
+      case 'medium':
+        return 15;
+      case 'high':
+        return 30;
+      case 'ultra':
+        return 50;
+      default:
+        return 15;
+    }
+  }, [qualityTier]);
+  // Initialize particles
+  useEffect(() => {
+    if (isReducedMotion || qualityTier === 'low') {
+      setParticles([]);
+      return;
+    }
+    const newParticles = Array.from({
+      length: particleCount
+    }, (_, i) => ({
+      id: i,
+      x: Math.random() * 100,
+      y: Math.random() * 100,
+      size: Math.random() * 3 + 1,
+      opacity: Math.random() * 0.6 + 0.2,
+      velocity: {
+        x: (Math.random() - 0.5) * 0.5,
+        y: (Math.random() - 0.5) * 0.5
+      }
+    }));
+    setParticles(newParticles);
+  }, [particleCount, isReducedMotion, qualityTier]);
+  // Animate particles
+  useEffect(() => {
+    if (isReducedMotion || !particles || particles.length === 0) return;
+    const animate = () => {
+      setParticles(prevParticles => prevParticles.map(particle => ({
+        ...particle,
+        x: (particle.x + particle.velocity.x + 100) % 100,
+        y: (particle.y + particle.velocity.y + 100) % 100,
+        opacity: 0.2 + Math.sin(Date.now() * 0.001 + particle.id) * 0.3
+      })));
+      animationRef.current = requestAnimationFrame(animate);
+    };
+    animationRef.current = requestAnimationFrame(animate);
+    return () => {
+      if (animationRef.current) {
+        cancelAnimationFrame(animationRef.current);
+      }
+    };
+  }, [isReducedMotion, particles.length]);
+  if (qualityTier === 'low' || isReducedMotion) {
+    return null;
+  }
+  const effectStyle = {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    pointerEvents: 'none',
+    overflow: 'hidden',
+    zIndex: -1
+  };
+  return jsxs("div", {
+    "data-glass-component": true,
+    ref: containerRef,
+    style: effectStyle,
+    children: [jsx("div", {
+      style: {
+        position: 'absolute',
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        background: `radial-gradient(ellipse at center, ${color}10 0%, transparent 70%)`,
+        opacity: 0.3
+      }
+    }), particles.map(particle => jsx("div", {
+      style: {
+        position: 'absolute',
+        left: `${particle.x}%`,
+        top: `${particle.y}%`,
+        width: `${particle.size}px`,
+        height: `${particle.size}px`,
+        borderRadius: '50%',
+        background: `radial-gradient(circle, ${color}${Math.round(particle.opacity * 255).toString(16).padStart(2, '0')}, transparent)`,
+        filter: `blur(${particle.size * 0.5}px)`,
+        transition: 'all 0.3s ease'
+      }
+    }, particle.id)), jsx("div", {
+      style: {
+        position: 'absolute',
+        top: '20%',
+        left: '20%',
+        width: '60%',
+        height: '60%',
+        background: `radial-gradient(ellipse, ${color}08, transparent)`,
+        borderRadius: '50%',
+        filter: 'blur(var(--glass-blur-lg))',
+        animation: isReducedMotion ? 'none' : 'pulse 8s ease-in-out infinite'
+      }
+    })]
+  });
+};
+
+export { AtmosphericEffects, AtmosphericEffects as default };
+//# sourceMappingURL=AtmosphericEffects.js.map

package/dist/esm/components/charts/components/AtmosphericEffects.js.map

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

package/dist/esm/components/charts/components/ChartAxis.js

@@ -0,0 +1,131 @@
+'use client';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useRef, useState, useEffect } from 'react';
+import { createGlassStyle } from '../../../core/mixins/glassMixins.js';
+
+const ChartAxis = ({
+  // TODO: Integrate ContrastGuard in chart labels, tooltips, and legends for WCAG AA compliance
+  orientation = 'horizontal',
+  show = true,
+  showLabels = true,
+  showTicks = true,
+  label,
+  style
+}) => {
+  const axisRef = useRef(null);
+  const [ticks, setTicks] = useState([]);
+  // Generate tick marks based on data range
+  useEffect(() => {
+    if (!showTicks) return;
+    // Generate sample ticks - in a real implementation, this would be based on actual data
+    const tickCount = orientation === 'horizontal' ? 6 : 5;
+    const newTicks = Array.from({
+      length: tickCount
+    }, (_, i) => ({
+      value: orientation === 'horizontal' ? `${i * 20}` : `${(tickCount - i - 1) * 25}`,
+      position: i / (tickCount - 1) * 100
+    }));
+    setTicks(newTicks);
+  }, [orientation, showTicks]);
+  if (!show) return null;
+  const glassStyles = createGlassStyle({
+    intent: 'neutral',
+    elevation: 'level1'
+  });
+  const axisLineStyle = {
+    position: 'absolute',
+    background: glassStyles.borderColor || '${glassStyles.borderColor || "rgba(var(--glass-color-white) / var(--glass-opacity-20))"}',
+    ...(orientation === 'horizontal' ? {
+      height: '1px',
+      left: 0,
+      right: 0,
+      bottom: '15px'
+    } : {
+      width: '1px',
+      top: 0,
+      bottom: '15px',
+      right: '15px'
+    })
+  };
+  const containerStyle = {
+    position: 'absolute',
+    ...(orientation === 'horizontal' ? {
+      bottom: 0,
+      left: 0,
+      right: 0,
+      height: '40px'
+    } : {
+      top: 0,
+      bottom: 0,
+      left: 0,
+      width: '60px'
+    }),
+    ...style
+  };
+  return jsxs("div", {
+    "data-glass-component": true,
+    ref: axisRef,
+    style: containerStyle,
+    children: [jsx("div", {
+      style: axisLineStyle
+    }), showTicks && ticks.map((tick, index) => jsx("div", {
+      style: {
+        position: 'absolute',
+        ...(orientation === 'horizontal' ? {
+          left: `${tick.position}%`,
+          bottom: '10px',
+          transform: 'translateX(-50%)',
+          borderLeft: `1px solid ${glassStyles.borderColor || '${glassStyles.borderColor || "rgba(var(--glass-color-white) / var(--glass-opacity-20))"}'}`,
+          height: '10px'
+        } : {
+          top: `${100 - tick.position}%`,
+          right: '10px',
+          transform: 'translateY(50%)',
+          borderTop: `1px solid ${glassStyles.borderColor || '${glassStyles.borderColor || "rgba(var(--glass-color-white) / var(--glass-opacity-20))"}'}`,
+          width: '10px'
+        })
+      },
+      children: showLabels && jsx("span", {
+        style: {
+          position: 'absolute',
+          fontSize: '0.625rem',
+          color: '${glassStyles.text?.secondary || "rgba(var(--glass-color-white) / var(--glass-opacity-60))"}',
+          whiteSpace: 'nowrap',
+          ...(orientation === 'horizontal' ? {
+            top: '12px',
+            left: '50%',
+            transform: 'translateX(-50%)'
+          } : {
+            right: '12px',
+            top: '50%',
+            transform: 'translateY(-50%)'
+          })
+        },
+        children: tick.value
+      })
+    }, index)), label && jsx("div", {
+      style: {
+        position: 'absolute',
+        fontSize: 'var(--typography-caption-size)',
+        color: '${glassStyles.text?.secondary || "rgba(var(--glass-color-white) / var(--glass-opacity-70))"}',
+        fontWeight: 'var(--typography-subheading-weight)',
+        ...(orientation === 'horizontal' ? {
+          bottom: '-25px',
+          left: '50%',
+          transform: 'translateX(-50%)',
+          textAlign: 'center'
+        } : {
+          left: '-45px',
+          top: '50%',
+          transform: 'translateY(-50%) rotate(-90deg)',
+          transformOrigin: 'center',
+          whiteSpace: 'nowrap'
+        })
+      },
+      children: label
+    })]
+  });
+};
+
+export { ChartAxis, ChartAxis as default };
+//# sourceMappingURL=ChartAxis.js.map

package/dist/esm/components/charts/components/ChartAxis.js.map

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

package/dist/esm/components/charts/components/ChartContainer.js

@@ -0,0 +1,49 @@
+'use client';
+import { jsx } from 'react/jsx-runtime';
+import { cn } from '../../../lib/utilsComprehensive.js';
+
+const ChartContainer = ({
+  // TODO: Integrate ContrastGuard in chart labels, tooltips, and legends for WCAG AA compliance
+  children,
+  style,
+  className,
+  glassVariant = 'frosted',
+  blurStrength = 'standard',
+  color = 'primary',
+  borderRadius = 12,
+  borderColor,
+  elevation = 'level3'
+}) => {
+  const containerStyle = {
+    position: 'relative',
+    width: '100%',
+    height: '100%',
+    padding: '16px',
+    borderRadius: typeof borderRadius === 'number' ? `${borderRadius}px` : borderRadius,
+    background: glassVariant === 'clear' ? 'transparent' : '${glassStyles.surface?.base || "var(--glass-bg-default)"}',
+    // Use createGlassStyle() instead,
+    border: `1px solid ${borderColor || '${glassStyles.borderColor || "rgba(var(--glass-color-white) / var(--glass-opacity-20))"}'}`,
+    boxShadow: (() => {
+      const elevationMap = {
+        'level1': 1,
+        'level2': 2,
+        'level3': 3,
+        'level4': 4
+      };
+      const elevationValue = elevationMap[elevation || 'level1'] || 1;
+      return elevationValue > 0 ? `0 ${elevationValue * 2}px ${elevationValue * 6}px rgba(0, 0, 0, 0.${elevationValue * 3})` : 'none';
+    })(),
+    overflow: 'hidden',
+    transition: 'all 0.3s ease',
+    ...style
+  };
+  return jsx("div", {
+    "data-glass-component": true,
+    className: cn('glass-chart-container', className),
+    style: containerStyle,
+    children: children
+  });
+};
+
+export { ChartContainer, ChartContainer as default };
+//# sourceMappingURL=ChartContainer.js.map

package/dist/esm/components/charts/components/ChartContainer.js.map

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

package/dist/esm/components/charts/components/ChartFilters.js

@@ -0,0 +1,185 @@
+'use client';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import React from 'react';
+import { glassTokenUtils } from '../../../tokens/glass.js';
+
+const ChartFilters = ({
+  // TODO: Integrate ContrastGuard in chart labels, tooltips, and legends for WCAG AA compliance
+  palette = ['var(--glass-color-primary)', 'var(--glass-color-danger)', 'var(--glass-color-success)', 'var(--glass-color-warning)', '#8b5cf6'],
+  qualityTier = 'medium'
+}) => {
+  // Generate filter effects based on quality tier
+  const blurAmount = qualityTier === 'low' ? 1 : qualityTier === 'medium' ? 2 : qualityTier === 'high' ? 3 : 4;
+  const glowAmount = qualityTier === 'low' ? 2 : qualityTier === 'medium' ? 4 : qualityTier === 'high' ? 6 : 8;
+  return jsx("svg", {
+    "data-glass-component": true,
+    style: {
+      position: 'absolute',
+      width: 0,
+      height: 0
+    },
+    children: jsxs("defs", {
+      children: [jsxs("filter", {
+        id: "chart-glow",
+        x: "-50%",
+        y: "-50%",
+        width: "200%",
+        height: "200%",
+        children: [jsx("feGaussianBlur", {
+          stdDeviation: glowAmount,
+          result: "coloredBlur"
+        }), jsxs("feMerge", {
+          children: [jsx("feMergeNode", {
+            in: "coloredBlur"
+          }), jsx("feMergeNode", {
+            in: "SourceGraphic"
+          })]
+        })]
+      }), jsx("filter", {
+        id: "chart-blur",
+        children: jsx("feGaussianBlur", {
+          stdDeviation: blurAmount
+        })
+      }), jsx("filter", {
+        id: "chart-shadow",
+        x: "-50%",
+        y: "-50%",
+        width: "200%",
+        height: "200%",
+        children: jsx("feDropShadow", {
+          dx: "0",
+          dy: "4",
+          stdDeviation: "8",
+          floodOpacity: "0.3"
+        })
+      }), jsxs("filter", {
+        id: "chart-glass",
+        x: "-50%",
+        y: "-50%",
+        width: "200%",
+        height: "200%",
+        children: [jsx("feGaussianBlur", {
+          stdDeviation: "8",
+          result: "blur"
+        }), jsx("feColorMatrix", {
+          in: "blur",
+          type: "saturate",
+          values: "1.2",
+          result: "saturatedBlur"
+        }), jsx("feComponentTransfer", {
+          in: "saturatedBlur",
+          result: "opacityBlur",
+          children: jsx("feFuncA", {
+            type: "discrete",
+            tableValues: "0.8"
+          })
+        }), jsxs("feMerge", {
+          children: [jsx("feMergeNode", {
+            in: "opacityBlur"
+          }), jsx("feMergeNode", {
+            in: "SourceGraphic"
+          })]
+        })]
+      }), palette.map((color, index) => jsxs(React.Fragment, {
+        children: [jsxs("linearGradient", {
+          id: `chart-gradient-${index}`,
+          x1: "0%",
+          y1: "0%",
+          x2: "100%",
+          y2: "100%",
+          children: [jsx("stop", {
+            offset: "0%",
+            stopColor: color,
+            stopOpacity: "0.8"
+          }), jsx("stop", {
+            offset: "100%",
+            stopColor: color,
+            stopOpacity: "0.2"
+          })]
+        }), jsxs("radialGradient", {
+          id: `chart-radial-${index}`,
+          cx: "50%",
+          cy: "50%",
+          r: "50%",
+          children: [jsx("stop", {
+            offset: "0%",
+            stopColor: color,
+            stopOpacity: "0.6"
+          }), jsx("stop", {
+            offset: "100%",
+            stopColor: color,
+            stopOpacity: "0"
+          })]
+        })]
+      }, index)), jsx("pattern", {
+        id: "chart-dots",
+        patternUnits: "userSpaceOnUse",
+        width: "4",
+        height: "4",
+        children: jsx("circle", {
+          cx: "2",
+          cy: "2",
+          r: "1",
+          fill: glassTokenUtils.getSurface('neutral', 'level1').surface.base
+        })
+      }), jsx("pattern", {
+        id: "chart-lines",
+        patternUnits: "userSpaceOnUse",
+        width: "8",
+        height: "8",
+        children: jsx("path", {
+          d: "M0,8 L8,0",
+          stroke: glassTokenUtils.getSurface('neutral', 'level1').surface.base,
+          strokeWidth: "1"
+        })
+      }), jsxs("filter", {
+        id: "chart-noise",
+        children: [jsx("feTurbulence", {
+          baseFrequency: "0.9",
+          numOctaves: "4",
+          stitchTiles: "stitch"
+        }), jsx("feComponentTransfer", {
+          children: jsx("feFuncA", {
+            type: "discrete",
+            tableValues: "0.05"
+          })
+        }), jsx("feComposite", {
+          in2: "SourceGraphic",
+          operator: "multiply"
+        })]
+      }), jsxs("filter", {
+        id: "chart-frosted",
+        x: "-20%",
+        y: "-20%",
+        width: "140%",
+        height: "140%",
+        children: [jsx("feGaussianBlur", {
+          stdDeviation: "10",
+          result: "blur"
+        }), jsx("feOffset", {
+          in: "blur",
+          dx: "0",
+          dy: "0",
+          result: "offset"
+        }), jsx("feFlood", {
+          floodColor: glassTokenUtils.getSurface('neutral', 'level1').surface.base,
+          result: "color"
+        }), jsx("feComposite", {
+          in: "color",
+          in2: "offset",
+          operator: "in",
+          result: "shadow"
+        }), jsxs("feMerge", {
+          children: [jsx("feMergeNode", {
+            in: "shadow"
+          }), jsx("feMergeNode", {
+            in: "SourceGraphic"
+          })]
+        })]
+      })]
+    })
+  });
+};
+
+export { ChartFilters, ChartFilters as default };
+//# sourceMappingURL=ChartFilters.js.map

package/dist/esm/components/charts/components/ChartFilters.js.map

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

package/dist/esm/components/charts/components/ChartGrid.js

@@ -0,0 +1,127 @@
+'use client';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useRef } from 'react';
+import { createGlassStyle } from '../../../core/mixins/glassMixins.js';
+
+const ChartGrid = ({
+  // TODO: Integrate ContrastGuard in chart labels, tooltips, and legends for WCAG AA compliance
+  show = true,
+  style = 'solid',
+  color,
+  opacity = 0.3,
+  horizontal = true,
+  vertical = true
+}) => {
+  const glassStyles = createGlassStyle({
+    intent: 'neutral',
+    elevation: 'level1'
+  });
+  const gridColor = color || glassStyles.borderColor || '${glassStyles.surface?.base || "var(--glass-bg-default)"}';
+  const gridRef = useRef(null);
+  if (!show) return null;
+  // Generate grid lines
+  const horizontalLines = horizontal ? Array.from({
+    length: 6
+  }, (_, i) => ({
+    y: i / 5 * 100,
+    key: `h-${i}`
+  })) : [];
+  const verticalLines = vertical ? Array.from({
+    length: 8
+  }, (_, i) => ({
+    x: i / 7 * 100,
+    key: `v-${i}`
+  })) : [];
+  const strokeDashArray = style === 'dashed' ? '5,5' : style === 'dotted' ? '2,3' : 'none';
+  return jsxs("svg", {
+    "data-glass-component": true,
+    ref: gridRef,
+    style: {
+      position: 'absolute',
+      top: 0,
+      left: 0,
+      right: 0,
+      bottom: 0,
+      width: '100%',
+      height: '100%',
+      pointerEvents: 'none',
+      opacity,
+      zIndex: 0
+    },
+    children: [jsx("defs", {
+      children: jsxs("pattern", {
+        id: "grid-pattern",
+        width: "100",
+        height: "100",
+        patternUnits: "userSpaceOnUse",
+        children: [horizontal && jsx("g", {
+          children: Array.from({
+            length: 5
+          }, (_, i) => jsx("line", {
+            x1: "0",
+            y1: i * 20,
+            x2: "100",
+            y2: i * 20,
+            stroke: gridColor,
+            strokeWidth: "0.5",
+            strokeDasharray: strokeDashArray
+          }, `pattern-h-${i}`))
+        }), vertical && jsx("g", {
+          children: Array.from({
+            length: 5
+          }, (_, i) => jsx("line", {
+            x1: i * 20,
+            y1: "0",
+            x2: i * 20,
+            y2: "100",
+            stroke: gridColor,
+            strokeWidth: "0.5",
+            strokeDasharray: strokeDashArray
+          }, `pattern-v-${i}`))
+        })]
+      })
+    }), jsxs("g", {
+      children: [horizontalLines.map(line => jsx("line", {
+        x1: "0%",
+        y1: `${line.y}%`,
+        x2: "100%",
+        y2: `${line.y}%`,
+        stroke: color,
+        strokeWidth: "1",
+        strokeDasharray: strokeDashArray,
+        opacity: line.y === 0 || line.y === 100 ? 0.6 : 0.3
+      }, line.key)), verticalLines.map(line => jsx("line", {
+        x1: `${line.x}%`,
+        y1: "0%",
+        x2: `${line.x}%`,
+        y2: "100%",
+        stroke: color,
+        strokeWidth: "1",
+        strokeDasharray: strokeDashArray,
+        opacity: line.x === 0 || line.x === 100 ? 0.6 : 0.3
+      }, line.key))]
+    }), jsx("defs", {
+      children: jsxs("radialGradient", {
+        id: "grid-gradient",
+        cx: "50%",
+        cy: "50%",
+        r: "70%",
+        children: [jsx("stop", {
+          offset: "0%",
+          stopColor: "transparent"
+        }), jsx("stop", {
+          offset: "100%",
+          stopColor: color,
+          stopOpacity: "0.1"
+        })]
+      })
+    }), jsx("rect", {
+      width: "100%",
+      height: "100%",
+      fill: "url(#grid-gradient)"
+    })]
+  });
+};
+
+export { ChartGrid, ChartGrid as default };
+//# sourceMappingURL=ChartGrid.js.map

package/dist/esm/components/charts/components/ChartGrid.js.map

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