@hdcodedev/snowfall 1.0.4 → 1.0.5

package/dist/index.mjs

@@ -29,9 +29,14 @@ var SnowfallContext = createContext(void 0);
 function SnowfallProvider({ children }) {
   const [isEnabled, setIsEnabled] = useState(true);
   const [physicsConfig, setPhysicsConfig] = useState(DEFAULT_PHYSICS);
+  const [debugMode, setDebugMode] = useState(false);
+  const [metrics, setMetrics] = useState(null);
   const toggleSnow = () => {
     setIsEnabled((prev) => !prev);
   };
+  const toggleDebug = () => {
+    setDebugMode((prev) => !prev);
+  };
   const updatePhysicsConfig = (config) => {
     setPhysicsConfig((prev) => ({
       ...prev,
@@ -58,7 +63,11 @@ function SnowfallProvider({ children }) {
     toggleSnow,
     physicsConfig,
     updatePhysicsConfig,
-    resetPhysics
+    resetPhysics,
+    debugMode,
+    toggleDebug,
+    metrics,
+    setMetrics
   }, children });
 }
 function useSnowfall() {
@@ -90,6 +99,18 @@ var AUTO_DETECT_CLASSES = [
   '[class*="shadow-"]',
   '[class*="rounded-"]'
 ];
+var styleCache = /* @__PURE__ */ new Map();
+var getCachedStyle = (el) => {
+  let cached = styleCache.get(el);
+  if (!cached) {
+    cached = window.getComputedStyle(el);
+    styleCache.set(el, cached);
+  }
+  return cached;
+};
+var clearStyleCache = () => {
+  styleCache.clear();
+};
 var getElementType = (el) => {
   const tagName = el.tagName.toLowerCase();
   if (BOTTOM_TAGS.includes(tagName)) return VAL_BOTTOM;
@@ -112,6 +133,7 @@ var shouldAccumulate = (el) => {
   return hasBackground || hasBorder || hasBoxShadow || hasBorderRadius;
 };
 var getAccumulationSurfaces = () => {
+  clearStyleCache();
   const surfaces = [];
   const seen = /* @__PURE__ */ new Set();
   const candidates = document.querySelectorAll(
@@ -124,13 +146,13 @@ var getAccumulationSurfaces = () => {
   );
   candidates.forEach((el) => {
     if (seen.has(el)) return;
-    const rect = el.getBoundingClientRect();
     const manualOverride = el.getAttribute(ATTR_SNOWFALL);
     if (manualOverride === VAL_IGNORE) return;
     const isManuallyIncluded = manualOverride !== null;
-    const styles = window.getComputedStyle(el);
+    const styles = getCachedStyle(el);
     const isVisible = styles.display !== "none" && styles.visibility !== "hidden" && parseFloat(styles.opacity) > 0.1;
     if (!isVisible && !isManuallyIncluded) return;
+    const rect = el.getBoundingClientRect();
     const hasSize = rect.width >= 100 && rect.height >= 50;
     if (!hasSize && !isManuallyIncluded) return;
     const isFullPageWrapper = rect.top <= 10 && rect.height >= window.innerHeight * 0.9;
@@ -141,7 +163,7 @@ var getAccumulationSurfaces = () => {
     let isFixed = false;
     let currentEl = el;
     while (currentEl && currentEl !== document.body) {
-      const style = window.getComputedStyle(currentEl);
+      const style = getCachedStyle(currentEl);
       if (style.position === "fixed" || style.position === "sticky") {
         isFixed = true;
         break;
@@ -160,6 +182,7 @@ var getAccumulationSurfaces = () => {
     }
   });
   console.log(`[Snowfall] Auto-detection found ${surfaces.length} surfaces`);
+  console.log("[Snowfall] \u2705 Using OPTIMIZED version with Map-based caching & 5s intervals");
   return surfaces;
 };
 var getElementRects = (accumulationMap) => {
@@ -524,18 +547,28 @@ var drawSideAccumulations = (ctx, fixedCtx, elementRects) => {
 };
 
 // src/Snowfall.tsx
-import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
 function Snowfall() {
-  const { isEnabled, physicsConfig } = useSnowfall();
+  const { isEnabled, physicsConfig, setMetrics } = useSnowfall();
   const isEnabledRef = useRef(isEnabled);
   const physicsConfigRef = useRef(physicsConfig);
+  const setMetricsRef = useRef(setMetrics);
   const [isMounted, setIsMounted] = useState2(false);
   const [isVisible, setIsVisible] = useState2(false);
   const canvasRef = useRef(null);
-  const fixedCanvasRef = useRef(null);
   const snowflakesRef = useRef([]);
   const accumulationRef = useRef(/* @__PURE__ */ new Map());
   const animationIdRef = useRef(0);
+  const fpsFrames = useRef([]);
+  const metricsRef = useRef({
+    scanTime: 0,
+    rectUpdateTime: 0,
+    frameTime: 0,
+    rafGap: 0,
+    clearTime: 0,
+    physicsTime: 0,
+    drawTime: 0
+  });
   useEffect(() => {
     setIsMounted(true);
   }, []);
@@ -545,26 +578,23 @@ function Snowfall() {
   useEffect(() => {
     physicsConfigRef.current = physicsConfig;
   }, [physicsConfig]);
+  useEffect(() => {
+    setMetricsRef.current = setMetrics;
+  }, [setMetrics]);
   useEffect(() => {
     if (!isMounted) return;
     const canvas = canvasRef.current;
-    const fixedCanvas = fixedCanvasRef.current;
-    if (!canvas || !fixedCanvas) return;
+    if (!canvas) return;
     const ctx = canvas.getContext("2d");
-    const fixedCtx = fixedCanvas.getContext("2d");
-    if (!ctx || !fixedCtx) return;
+    if (!ctx) return;
     const resizeCanvas = () => {
-      if (canvasRef.current && fixedCanvasRef.current) {
+      if (canvasRef.current) {
         const newHeight = Math.max(document.documentElement.scrollHeight, window.innerHeight);
         const newWidth = Math.max(document.documentElement.scrollWidth, window.innerWidth);
         if (canvasRef.current.height !== newHeight || canvasRef.current.width !== newWidth) {
           canvasRef.current.width = newWidth;
           canvasRef.current.height = newHeight;
         }
-        if (fixedCanvasRef.current.width !== window.innerWidth || fixedCanvasRef.current.height !== window.innerHeight) {
-          fixedCanvasRef.current.width = window.innerWidth;
-          fixedCanvasRef.current.height = window.innerHeight;
-        }
       }
     };
     resizeCanvas();
@@ -574,11 +604,16 @@ function Snowfall() {
     resizeObserver.observe(document.body);
     snowflakesRef.current = [];
     const initAccumulationWrapper = () => {
+      const scanStart = performance.now();
       initializeAccumulation(accumulationRef.current, physicsConfigRef.current);
+      metricsRef.current.scanTime = performance.now() - scanStart;
     };
     initAccumulationWrapper();
     setIsVisible(true);
     let lastTime = 0;
+    let lastRectUpdate = 0;
+    let lastMetricsUpdate = 0;
+    let cachedElementRects = [];
     const animate = (currentTime) => {
       if (lastTime === 0) {
         lastTime = currentTime;
@@ -586,14 +621,28 @@ function Snowfall() {
         return;
       }
       const deltaTime = Math.min(currentTime - lastTime, 50);
+      const now = performance.now();
+      fpsFrames.current.push(now);
+      fpsFrames.current = fpsFrames.current.filter((t) => now - t < 1e3);
+      metricsRef.current.rafGap = currentTime - lastTime;
       lastTime = currentTime;
       const dt = deltaTime / 16.67;
+      const frameStartTime = performance.now();
+      const clearStart = performance.now();
       ctx.clearRect(0, 0, canvas.width, canvas.height);
-      fixedCtx.clearRect(0, 0, fixedCanvas.width, fixedCanvas.height);
+      metricsRef.current.clearTime = performance.now() - clearStart;
       const snowflakes = snowflakesRef.current;
-      const elementRects = getElementRects(accumulationRef.current);
-      meltAndSmoothAccumulation(elementRects, physicsConfigRef.current, dt);
-      updateSnowflakes(snowflakes, elementRects, physicsConfigRef.current, dt, canvas.width, canvas.height);
+      if (currentTime - lastRectUpdate > 100) {
+        const rectStart = performance.now();
+        cachedElementRects = getElementRects(accumulationRef.current);
+        metricsRef.current.rectUpdateTime = performance.now() - rectStart;
+        lastRectUpdate = currentTime;
+      }
+      const physicsStart = performance.now();
+      meltAndSmoothAccumulation(cachedElementRects, physicsConfigRef.current, dt);
+      updateSnowflakes(snowflakes, cachedElementRects, physicsConfigRef.current, dt, canvas.width, canvas.height);
+      metricsRef.current.physicsTime = performance.now() - physicsStart;
+      const drawStart = performance.now();
       for (const flake of snowflakes) {
         drawSnowflake(ctx, flake);
       }
@@ -601,8 +650,26 @@ function Snowfall() {
         const isBackground = Math.random() < 0.4;
         snowflakes.push(createSnowflake(canvas.width, physicsConfigRef.current, isBackground));
       }
-      drawAccumulations(ctx, fixedCtx, elementRects);
-      drawSideAccumulations(ctx, fixedCtx, elementRects);
+      drawAccumulations(ctx, ctx, cachedElementRects);
+      drawSideAccumulations(ctx, ctx, cachedElementRects);
+      metricsRef.current.drawTime = performance.now() - drawStart;
+      metricsRef.current.frameTime = performance.now() - frameStartTime;
+      if (currentTime - lastMetricsUpdate > 500) {
+        setMetricsRef.current({
+          fps: fpsFrames.current.length,
+          frameTime: metricsRef.current.frameTime,
+          scanTime: metricsRef.current.scanTime,
+          rectUpdateTime: metricsRef.current.rectUpdateTime,
+          surfaceCount: accumulationRef.current.size,
+          flakeCount: snowflakes.length,
+          maxFlakes: physicsConfigRef.current.MAX_FLAKES,
+          rafGap: metricsRef.current.rafGap,
+          clearTime: metricsRef.current.clearTime,
+          physicsTime: metricsRef.current.physicsTime,
+          drawTime: metricsRef.current.drawTime
+        });
+        lastMetricsUpdate = currentTime;
+      }
       animationIdRef.current = requestAnimationFrame(animate);
     };
     animationIdRef.current = requestAnimationFrame(animate);
@@ -612,7 +679,7 @@ function Snowfall() {
       initAccumulationWrapper();
     };
     window.addEventListener("resize", handleResize);
-    const checkInterval = setInterval(initAccumulationWrapper, 3e3);
+    const checkInterval = setInterval(initAccumulationWrapper, 5e3);
     return () => {
       cancelAnimationFrame(animationIdRef.current);
       window.removeEventListener("resize", handleResize);
@@ -621,43 +688,201 @@ function Snowfall() {
     };
   }, [isMounted]);
   if (!isMounted) return null;
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx2(
-      "canvas",
-      {
-        ref: canvasRef,
-        style: {
-          position: "absolute",
-          top: 0,
-          left: 0,
-          pointerEvents: "none",
-          zIndex: 9999,
-          opacity: isVisible ? 1 : 0,
-          transition: "opacity 0.3s ease-in"
-        },
-        "aria-hidden": "true"
-      }
-    ),
-    /* @__PURE__ */ jsx2(
-      "canvas",
-      {
-        ref: fixedCanvasRef,
-        style: {
-          position: "fixed",
-          top: 0,
-          left: 0,
-          pointerEvents: "none",
-          zIndex: 9999,
-          opacity: isVisible ? 1 : 0,
-          transition: "opacity 0.3s ease-in"
-        },
-        "aria-hidden": "true"
+  return /* @__PURE__ */ jsx2(Fragment, { children: /* @__PURE__ */ jsx2(
+    "canvas",
+    {
+      ref: canvasRef,
+      style: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        pointerEvents: "none",
+        zIndex: 9999,
+        opacity: isVisible ? 1 : 0,
+        transition: "opacity 0.3s ease-in",
+        willChange: "transform"
+      },
+      "aria-hidden": "true"
+    }
+  ) });
+}
+
+// src/DebugPanel.tsx
+import { useEffect as useEffect2, useState as useState3 } from "react";
+import { Fragment as Fragment2, jsx as jsx3, jsxs } from "react/jsx-runtime";
+function DebugPanel() {
+  const { debugMode, toggleDebug, metrics } = useSnowfall();
+  const [isMinimized, setIsMinimized] = useState3(false);
+  const [copied, setCopied] = useState3(false);
+  useEffect2(() => {
+    const handleKeyDown = (e) => {
+      if (e.shiftKey && e.key === "D") {
+        toggleDebug();
       }
-    )
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [toggleDebug]);
+  const copyToClipboard = () => {
+    if (metrics) {
+      const data = {
+        ...metrics,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        userAgent: navigator.userAgent,
+        canvasSize: {
+          width: window.innerWidth,
+          height: window.innerHeight
+        }
+      };
+      navigator.clipboard.writeText(JSON.stringify(data, null, 2));
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2e3);
+    }
+  };
+  if (!debugMode) return null;
+  return /* @__PURE__ */ jsxs("div", { style: {
+    position: "fixed",
+    bottom: "20px",
+    left: "20px",
+    backgroundColor: "rgba(0, 0, 0, 0.9)",
+    color: "#0f0",
+    fontFamily: "monospace",
+    fontSize: "12px",
+    padding: isMinimized ? "10px" : "15px",
+    borderRadius: "8px",
+    zIndex: 1e4,
+    minWidth: isMinimized ? "auto" : "320px",
+    maxWidth: "400px",
+    border: "1px solid #0f0",
+    boxShadow: "0 4px 20px rgba(0, 255, 0, 0.3)"
+  }, children: [
+    /* @__PURE__ */ jsxs("div", { style: {
+      display: "flex",
+      justifyContent: "space-between",
+      alignItems: "center",
+      marginBottom: isMinimized ? 0 : "10px"
+    }, children: [
+      /* @__PURE__ */ jsx3("div", { style: { fontWeight: "bold", color: "#0ff" }, children: "\u2744\uFE0F SNOWFALL DEBUG" }),
+      /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "10px" }, children: [
+        /* @__PURE__ */ jsx3(
+          "button",
+          {
+            onClick: () => setIsMinimized(!isMinimized),
+            style: {
+              background: "none",
+              border: "1px solid #0f0",
+              color: "#0f0",
+              cursor: "pointer",
+              padding: "2px 8px",
+              borderRadius: "4px",
+              fontSize: "10px"
+            },
+            children: isMinimized ? "\u25B2" : "\u25BC"
+          }
+        ),
+        /* @__PURE__ */ jsx3(
+          "button",
+          {
+            onClick: toggleDebug,
+            style: {
+              background: "none",
+              border: "1px solid #f00",
+              color: "#f00",
+              cursor: "pointer",
+              padding: "2px 8px",
+              borderRadius: "4px",
+              fontSize: "10px"
+            },
+            children: "\u2715"
+          }
+        )
+      ] })
+    ] }),
+    !isMinimized && metrics && /* @__PURE__ */ jsxs(Fragment2, { children: [
+      /* @__PURE__ */ jsxs("div", { style: { marginBottom: "10px", paddingBottom: "10px", borderBottom: "1px solid #333" }, children: [
+        /* @__PURE__ */ jsx3("div", { style: { color: "#ff0", marginBottom: "5px", fontWeight: "bold" }, children: "\u26A1 PERFORMANCE" }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          "FPS: ",
+          /* @__PURE__ */ jsx3("span", { style: { color: metrics.fps < 30 ? "#f00" : metrics.fps < 50 ? "#ff0" : "#0f0" }, children: metrics.fps.toFixed(1) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          "Frame Time: ",
+          metrics.frameTime.toFixed(2),
+          "ms"
+        ] }),
+        /* @__PURE__ */ jsxs("div", { style: { color: "#f80" }, children: [
+          "rAF Gap: ",
+          metrics.rafGap?.toFixed(1) || 0,
+          "ms ",
+          metrics.rafGap && metrics.rafGap > 20 ? "\u26A0\uFE0F THROTTLED!" : ""
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { style: { marginBottom: "10px", paddingBottom: "10px", borderBottom: "1px solid #333" }, children: [
+        /* @__PURE__ */ jsx3("div", { style: { color: "#ff0", marginBottom: "5px", fontWeight: "bold" }, children: "\u{1F52C} DETAILED TIMINGS" }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          "Clear: ",
+          metrics.clearTime?.toFixed(2) || 0,
+          "ms"
+        ] }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          "Physics: ",
+          metrics.physicsTime?.toFixed(2) || 0,
+          "ms"
+        ] }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          "Draw: ",
+          metrics.drawTime?.toFixed(2) || 0,
+          "ms"
+        ] }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          "Scan: ",
+          metrics.scanTime.toFixed(2),
+          "ms"
+        ] }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          "Rect Update: ",
+          metrics.rectUpdateTime.toFixed(2),
+          "ms"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { style: { marginBottom: "10px", paddingBottom: "10px", borderBottom: "1px solid #333" }, children: [
+        /* @__PURE__ */ jsx3("div", { style: { color: "#ff0", marginBottom: "5px", fontWeight: "bold" }, children: "\u{1F4CA} COUNTS" }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          "Snowflakes: ",
+          metrics.flakeCount,
+          " / ",
+          metrics.maxFlakes
+        ] }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          "Surfaces: ",
+          metrics.surfaceCount
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx3(
+        "button",
+        {
+          onClick: copyToClipboard,
+          style: {
+            width: "100%",
+            padding: "8px",
+            background: copied ? "#0a0" : "#000",
+            border: copied ? "1px solid #0f0" : "1px solid #555",
+            color: "#0f0",
+            cursor: "pointer",
+            borderRadius: "4px",
+            fontSize: "11px",
+            fontFamily: "monospace"
+          },
+          children: copied ? "\u2713 COPIED!" : "\u{1F4CB} COPY METRICS"
+        }
+      ),
+      /* @__PURE__ */ jsx3("div", { style: { marginTop: "8px", fontSize: "10px", color: "#666", textAlign: "center" }, children: "Shift+D to toggle" })
+    ] })
   ] });
 }
 export {
   DEFAULT_PHYSICS,
+  DebugPanel,
   Snowfall,
   SnowfallProvider,
   useSnowfall