@react-perfscope/core 0.6.0 → 0.7.1

package/dist/index.js

@@ -88,23 +88,25 @@ function isSelfRequest(url) {
 // src/sourcemap.ts
 var CHROME_FRAME = /^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/;
 var FIREFOX_FRAME = /^(.*?)@(.+?):(\d+):(\d+)$/;
+function lookupFrame(tracer, frame) {
+  const pos = originalPositionFor(tracer, { line: frame.line, column: frame.col - 1 });
+  if (pos.source == null || pos.line == null || pos.column == null) {
+    return frame;
+  }
+  const resolved = {
+    file: pos.source,
+    line: pos.line,
+    col: pos.column + 1
+  };
+  if (pos.name) resolved.fnName = pos.name;
+  else if (frame.fnName) resolved.fnName = frame.fnName;
+  return resolved;
+}
 async function resolveFrame(frame, fetchMap) {
   try {
     const map = await fetchMap(frame.file);
     if (!map) return frame;
-    const tracer = new TraceMap(map);
-    const pos = originalPositionFor(tracer, { line: frame.line, column: frame.col });
-    if (pos.source == null || pos.line == null || pos.column == null) {
-      return frame;
-    }
-    const resolved = {
-      file: pos.source,
-      line: pos.line,
-      col: pos.column
-    };
-    if (pos.name) resolved.fnName = pos.name;
-    else if (frame.fnName) resolved.fnName = frame.fnName;
-    return resolved;
+    return lookupFrame(new TraceMap(map), frame);
   } catch (err) {
     console.warn("[react-perfscope] resolveFrame failed:", err);
     return frame;
@@ -127,7 +129,7 @@ function attachLazyStack(target, raw, skipTopFrames = 0) {
 function createSourceMapResolver(opts = {}) {
   const f = opts.fetch ?? (typeof fetch !== "undefined" ? fetch.bind(globalThis) : null);
   const cache = /* @__PURE__ */ new Map();
-  function fetchMapFor(sourceUrl) {
+  function fetchTracerFor(sourceUrl) {
     if (!f) return Promise.resolve(null);
     const existing = cache.get(sourceUrl);
     if (existing) return existing;
@@ -146,13 +148,13 @@ function createSourceMapResolver(opts = {}) {
           const header = ref.slice(0, commaIdx);
           const payload = ref.slice(commaIdx + 1);
           const decoded = header.includes("base64") ? typeof atob === "function" ? atob(payload) : globalThis.Buffer.from(payload, "base64").toString("utf8") : decodeURIComponent(payload);
-          return JSON.parse(decoded);
+          return new TraceMap(JSON.parse(decoded));
         }
         const mapUrl = new URL(ref, sourceUrl).href;
         markSelfRequest(mapUrl);
         const mapRes = await f(mapUrl);
         if (!mapRes || !mapRes.ok) return null;
-        return await mapRes.json();
+        return new TraceMap(await mapRes.json());
       } catch {
         return null;
       }
@@ -163,7 +165,9 @@ function createSourceMapResolver(opts = {}) {
   return {
     async resolve(frame) {
       try {
-        return await resolveFrame(frame, fetchMapFor);
+        const tracer = await fetchTracerFor(frame.file);
+        if (!tracer) return frame;
+        return lookupFrame(tracer, frame);
       } catch {
         return frame;
       }
@@ -227,6 +231,48 @@ function unsupportedKinds() {
   return Object.keys(caps).filter((k) => !caps[k]);
 }
 
+// src/leak-trend.ts
+var MIN_SAMPLES = 4;
+var FLOOR_SEGMENTS = 8;
+var MIN_NET_GROWTH = 3;
+function slope(points) {
+  const n = points.length;
+  if (n < 2) return 0;
+  let sx = 0;
+  let sy = 0;
+  let sxy = 0;
+  let sxx = 0;
+  for (const { x, y } of points) {
+    sx += x;
+    sy += y;
+    sxy += x * y;
+    sxx += x * x;
+  }
+  const denom = n * sxx - sx * sx;
+  if (denom === 0) return 0;
+  return (n * sxy - sx * sy) / denom;
+}
+function analyzeLeakTrend(samples) {
+  if (samples.length < MIN_SAMPLES) return null;
+  const t0 = samples[0].at;
+  const segSize = Math.max(1, Math.ceil(samples.length / FLOOR_SEGMENTS));
+  const floorPoints = [];
+  for (let i = 0; i < samples.length; i += segSize) {
+    const seg = samples.slice(i, i + segSize);
+    let min = Infinity;
+    for (const s of seg) min = Math.min(min, s.retained);
+    const mid = seg[Math.floor(seg.length / 2)];
+    floorPoints.push({ x: (mid.at - t0) / 6e4, y: min });
+  }
+  const slopePerMin = slope(floorPoints);
+  const spanMin = (samples[samples.length - 1].at - t0) / 6e4;
+  const projectedGrowth = slopePerMin * spanMin;
+  const recent = floorPoints.slice(Math.floor(floorPoints.length / 2));
+  const recentSlope = recent.length >= 2 ? slope(recent) : slopePerMin;
+  const leaking = projectedGrowth >= MIN_NET_GROWTH && recentSlope > 0;
+  return { leaking, slopePerMin };
+}
+
 // src/correlate.ts
 var FRAME_MS = 16;
 function isAnchor(signal) {
@@ -678,37 +724,40 @@ function createNetworkCollector() {
 
 // src/collectors/web-vitals.ts
 import { onLCP, onINP, onCLS, onFCP, onTTFB } from "web-vitals";
+var subscribed = false;
+var sinks = /* @__PURE__ */ new Set();
+function ensureSubscribed() {
+  if (subscribed) return true;
+  try {
+    const fan = (name) => (metric) => {
+      for (const sink of sinks) sink(name, metric.value);
+    };
+    onLCP(fan("LCP"));
+    onINP(fan("INP"));
+    onCLS(fan("CLS"));
+    onFCP(fan("FCP"));
+    onTTFB(fan("TTFB"));
+    subscribed = true;
+  } catch (err) {
+    console.warn("[react-perfscope] web-vitals collector failed to subscribe:", err);
+  }
+  return subscribed;
+}
 function createWebVitalsCollector() {
-  let active = false;
-  let subscribed = false;
   let emit = () => {
   };
-  function makeHandler(name) {
-    return (metric) => {
-      if (!active) return;
-      emit({ kind: "web-vital", name, value: metric.value });
-    };
-  }
+  const sink = (name, value) => {
+    emit({ kind: "web-vital", name, value });
+  };
   return {
     kind: "web-vital",
     activate(emitFn) {
+      if (!ensureSubscribed()) return;
       emit = emitFn;
-      active = true;
-      if (subscribed) return;
-      try {
-        onLCP(makeHandler("LCP"));
-        onINP(makeHandler("INP"));
-        onCLS(makeHandler("CLS"));
-        onFCP(makeHandler("FCP"));
-        onTTFB(makeHandler("TTFB"));
-        subscribed = true;
-      } catch (err) {
-        console.warn("[react-perfscope] web-vitals collector failed to subscribe:", err);
-        active = false;
-      }
+      sinks.add(sink);
     },
     deactivate() {
-      active = false;
+      sinks.delete(sink);
     }
   };
 }
@@ -716,19 +765,19 @@ function createWebVitalsCollector() {
 // src/collectors/heap.ts
 var SAMPLE_INTERVAL_MS = 250;
 var MAX_SAMPLES = 2e4;
-var MIN_SAMPLES = 4;
-var FLOOR_SEGMENTS = 8;
+var MIN_SAMPLES2 = 4;
+var FLOOR_SEGMENTS2 = 8;
 var MB = 1024 * 1024;
 var GROWING_SLOPE = 1 * MB;
 var LEAK_SLOPE = 5 * MB;
-var MIN_NET_GROWTH = 2 * MB;
+var MIN_NET_GROWTH2 = 2 * MB;
 function readMemory() {
   const perf = globalThis.performance;
   const mem = perf?.memory;
   if (!mem || typeof mem.usedJSHeapSize !== "number") return null;
   return mem;
 }
-function slope(points) {
+function slope2(points) {
   const n = points.length;
   if (n < 2) return 0;
   let sx = 0;
@@ -746,9 +795,9 @@ function slope(points) {
   return (n * sxy - sx * sy) / denom;
 }
 function analyzeHeapTrend(samples) {
-  if (samples.length < MIN_SAMPLES) return null;
+  if (samples.length < MIN_SAMPLES2) return null;
   const t0 = samples[0].at;
-  const segSize = Math.max(1, Math.ceil(samples.length / FLOOR_SEGMENTS));
+  const segSize = Math.max(1, Math.ceil(samples.length / FLOOR_SEGMENTS2));
   const floorPoints = [];
   for (let i = 0; i < samples.length; i += segSize) {
     const seg = samples.slice(i, i + segSize);
@@ -757,13 +806,13 @@ function analyzeHeapTrend(samples) {
     const mid = seg[Math.floor(seg.length / 2)];
     floorPoints.push({ x: (mid.at - t0) / 6e4, y: min });
   }
-  const slopeBytesPerMin = slope(floorPoints);
+  const slopeBytesPerMin = slope2(floorPoints);
   const spanMin = (samples[samples.length - 1].at - t0) / 6e4;
   const projectedGrowth = slopeBytesPerMin * spanMin;
   const recent = floorPoints.slice(Math.floor(floorPoints.length / 2));
-  const recentSlope = recent.length >= 2 ? slope(recent) : slopeBytesPerMin;
+  const recentSlope = recent.length >= 2 ? slope2(recent) : slopeBytesPerMin;
   let classification = "stable";
-  const sustained = projectedGrowth >= MIN_NET_GROWTH && recentSlope >= GROWING_SLOPE;
+  const sustained = projectedGrowth >= MIN_NET_GROWTH2 && recentSlope >= GROWING_SLOPE;
   if (sustained) {
     classification = slopeBytesPerMin >= LEAK_SLOPE && recentSlope >= LEAK_SLOPE ? "leak-suspected" : "growing";
   }
@@ -801,6 +850,7 @@ function createHeapCollector() {
 
 // src/collectors/interaction.ts
 var DURATION_THRESHOLD = 40;
+var MAX_ENTRIES = 5e3;
 function selectorFor(target) {
   const el = target;
   if (!el || typeof el.tagName !== "string") return void 0;
@@ -829,7 +879,10 @@ function createInteractionCollector() {
       try {
         observer = new PerformanceObserver((list) => {
           if (!active) return;
-          for (const e of list.getEntries()) entries.push(e);
+          for (const e of list.getEntries()) {
+            if (entries.length >= MAX_ENTRIES) break;
+            entries.push(e);
+          }
         });
         observer.observe({ type: "event", buffered: false, durationThreshold: DURATION_THRESHOLD });
         try {
@@ -853,8 +906,10 @@ function createInteractionCollector() {
       }
     },
     finalize(result) {
+      const buffered = entries;
+      entries = [];
       const byId = /* @__PURE__ */ new Map();
-      for (const e of entries) {
+      for (const e of buffered) {
         const id = e.interactionId;
         if (!id) continue;
         const group = byId.get(id);
@@ -1095,6 +1150,7 @@ export {
   BUFFER_CAP,
   analyzeFrames,
   analyzeHeapTrend,
+  analyzeLeakTrend,
   attachLazyStack,
   attributeLongTaskSignals,
   attributeWindow,