@parca/profile 0.19.140 → 0.19.142

package/dist/ProfileFlameGraph/FlameGraphArrow/useBatchedRendering.js

@@ -1,3 +1,9 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 // Copyright 2022 The Parca Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -10,56 +16,68 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
+/* eslint-disable react-hooks/set-state-in-effect */
+
 import { useEffect, useRef, useState } from 'react';
 // useBatchedRendering - Helps in incrementally rendering items in batches to avoid UI blocking.
-export const useBatchedRendering = (items, options = {}) => {
-    const { batchSize = 500, batchDelay = 0 } = options;
-    const [renderedCount, setRenderedCount] = useState(0);
-    const itemsRef = useRef(items);
-    const rafRef = useRef(null);
-    const timeoutRef = useRef(null);
-    useEffect(() => {
-        if (itemsRef.current !== items) {
-            itemsRef.current = items;
-            setRenderedCount(prev => {
-                if (items.length === 0)
-                    return 0;
-                // If new items were added (scrolling down), keep current progress
-                if (items.length > prev)
-                    return prev;
-                // If items reduced, cap to new length
-                return Math.min(prev, items.length);
-            });
-        }
-    }, [items]);
-    // Progressively render more items
-    useEffect(() => {
-        if (renderedCount === items.length) {
-            return;
-        }
-        const scheduleNextBatch = () => {
-            const incrementState = () => {
-                setRenderedCount(prev => Math.min(prev + batchSize, items.length));
-            };
-            if (batchDelay > 0) {
-                timeoutRef.current = setTimeout(incrementState, batchDelay);
-            }
-            else {
-                rafRef.current = requestAnimationFrame(incrementState);
-            }
-        };
-        scheduleNextBatch();
-        return () => {
-            if (rafRef.current !== null) {
-                cancelAnimationFrame(rafRef.current);
-            }
-            if (timeoutRef.current !== null) {
-                clearTimeout(timeoutRef.current);
-            }
-        };
-    }, [renderedCount, items.length, batchSize, batchDelay]);
-    return {
-        items: items.slice(0, renderedCount),
-        isComplete: renderedCount === items.length,
+export var useBatchedRendering = function useBatchedRendering(items) {
+  'use no memo';
+
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _options$batchSize = options.batchSize,
+    batchSize = _options$batchSize === void 0 ? 500 : _options$batchSize,
+    _options$batchDelay = options.batchDelay,
+    batchDelay = _options$batchDelay === void 0 ? 0 : _options$batchDelay;
+  var _useState = useState(0),
+    _useState2 = _slicedToArray(_useState, 2),
+    renderedCount = _useState2[0],
+    setRenderedCount = _useState2[1];
+  var itemsRef = useRef(items);
+  var rafRef = useRef(null);
+  var timeoutRef = useRef(null);
+  useEffect(function () {
+    if (itemsRef.current !== items) {
+      itemsRef.current = items;
+      setRenderedCount(function (prev) {
+        if (items.length === 0) return 0;
+        // If new items were added (scrolling down), keep current progress
+        if (items.length > prev) return prev;
+        // If items reduced, cap to new length
+        return Math.min(prev, items.length);
+      });
+    }
+  }, [items]);
+
+  // Progressively render more items
+  useEffect(function () {
+    if (renderedCount === items.length) {
+      return;
+    }
+    var scheduleNextBatch = function scheduleNextBatch() {
+      var incrementState = function incrementState() {
+        setRenderedCount(function (prev_0) {
+          return Math.min(prev_0 + batchSize, items.length);
+        });
+      };
+      if (batchDelay > 0) {
+        timeoutRef.current = setTimeout(incrementState, batchDelay);
+      } else {
+        rafRef.current = requestAnimationFrame(incrementState);
+      }
     };
-};
+    scheduleNextBatch();
+    return function () {
+      if (rafRef.current !== null) {
+        cancelAnimationFrame(rafRef.current);
+      }
+      if (timeoutRef.current !== null) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, [renderedCount, items.length, batchSize, batchDelay]);
+  return {
+    items: items.slice(0, renderedCount),
+    isComplete: renderedCount === items.length
+  };
+};

package/dist/ProfileFlameGraph/FlameGraphArrow/useMappingList.js

@@ -1,3 +1,4 @@
+import { c as _c } from "react-compiler-runtime";
 // Copyright 2022 The Parca Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -10,49 +11,72 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
 import { useMemo } from 'react';
 import { getLastItem } from '@parca/utilities';
 import { FIELD_FUNCTION_FILE_NAME } from './index';
 import { arrowToString } from './utils';
-const useMappingList = (mappings) => {
-    const mappingsList = useMemo(() => {
-        if (mappings === undefined) {
-            return [];
-        }
-        const list = mappings
-            ?.map(mapping => {
-            return getLastItem(mapping);
-        })
-            .flat() ?? [];
-        // We add a EVERYTHING ELSE mapping to the list.
-        list.push('');
-        // We sort the mappings alphabetically to make sure that the order is always the same.
-        list.sort((a, b) => a.localeCompare(b));
-        return list;
-    }, [mappings]);
-    return mappingsList;
-};
-export const useFilenamesList = (table) => {
-    if (table === null) {
-        return [];
-    }
-    const filenamesColumn = table.getChild(FIELD_FUNCTION_FILE_NAME);
-    if (filenamesColumn === null) {
-        return [];
+var useMappingList = function useMappingList(mappings) {
+  var $ = _c(3);
+  var t0;
+  bb0: {
+    if (mappings === undefined) {
+      var t1;
+      if ($[0] === Symbol["for"]("react.memo_cache_sentinel")) {
+        t1 = [];
+        $[0] = t1;
+      } else {
+        t1 = $[0];
+      }
+      t0 = t1;
+      break bb0;
     }
-    // Access dictionary directly instead of iterating all rows
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const dictionary = filenamesColumn.data[0]?.dictionary;
-    if (dictionary == null) {
-        return [''];
+    var list;
+    if ($[1] !== mappings) {
+      var _mappings$map$flat;
+      list = (_mappings$map$flat = mappings === null || mappings === void 0 ? void 0 : mappings.map(_temp).flat()) !== null && _mappings$map$flat !== void 0 ? _mappings$map$flat : [];
+      list.push("");
+      list.sort(_temp2);
+      $[1] = mappings;
+      $[2] = list;
+    } else {
+      list = $[2];
     }
-    const filenames = Array.from(dictionary.toArray())
-        .map(value => {
-        const fn = arrowToString(value);
-        return fn != null ? getLastItem(fn) ?? '' : '';
-    })
-        .concat('') // Add empty string for "Everything else"
-        .sort((a, b) => a.localeCompare(b));
-    return filenames;
+    t0 = list;
+  }
+  var mappingsList = t0;
+  return mappingsList;
+};
+export var useFilenamesList = function useFilenamesList(table) {
+  var _filenamesColumn$data;
+  if (table === null) {
+    return [];
+  }
+  var filenamesColumn = table.getChild(FIELD_FUNCTION_FILE_NAME);
+  if (filenamesColumn === null) {
+    return [];
+  }
+
+  // Access dictionary directly instead of iterating all rows
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var dictionary = (_filenamesColumn$data = filenamesColumn.data[0]) === null || _filenamesColumn$data === void 0 ? void 0 : _filenamesColumn$data.dictionary;
+  if (dictionary == null) {
+    return [''];
+  }
+  var filenames = Array.from(dictionary.toArray()).map(function (value) {
+    var _getLastItem;
+    var fn = arrowToString(value);
+    return fn != null ? (_getLastItem = getLastItem(fn)) !== null && _getLastItem !== void 0 ? _getLastItem : '' : '';
+  }).concat('') // Add empty string for "Everything else"
+  .sort(function (a, b) {
+    return a.localeCompare(b);
+  });
+  return filenames;
 };
 export default useMappingList;
+function _temp(mapping) {
+  return getLastItem(mapping);
+}
+function _temp2(a, b) {
+  return a.localeCompare(b);
+}

package/dist/ProfileFlameGraph/FlameGraphArrow/useNodeColor.js

@@ -10,12 +10,20 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
 import { EVERYTHING_ELSE } from '@parca/store';
 import { diffColor, getLastItem } from '@parca/utilities';
-const useNodeColor = ({ isDarkMode, compareMode, cumulative, diff, colorsMap, colorAttribute, }) => {
-    if (compareMode) {
-        return diffColor(diff ?? 0n, cumulative, isDarkMode);
-    }
-    return colorsMap[getLastItem(colorAttribute ?? '') ?? EVERYTHING_ELSE];
+var useNodeColor = function useNodeColor(_ref) {
+  var _getLastItem;
+  var isDarkMode = _ref.isDarkMode,
+    compareMode = _ref.compareMode,
+    cumulative = _ref.cumulative,
+    diff = _ref.diff,
+    colorsMap = _ref.colorsMap,
+    colorAttribute = _ref.colorAttribute;
+  if (compareMode) {
+    return diffColor(diff !== null && diff !== void 0 ? diff : 0n, cumulative, isDarkMode);
+  }
+  return colorsMap[(_getLastItem = getLastItem(colorAttribute !== null && colorAttribute !== void 0 ? colorAttribute : '')) !== null && _getLastItem !== void 0 ? _getLastItem : EVERYTHING_ELSE];
 };
-export default useNodeColor;
+export default useNodeColor;

package/dist/ProfileFlameGraph/FlameGraphArrow/useScrollViewport.js

@@ -1,3 +1,10 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+import { c as _c } from "react-compiler-runtime";
 // Copyright 2022 The Parca Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -10,91 +17,126 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
 import { useCallback, useEffect, useRef, useState } from 'react';
 // Find the scrollable ancestor (the element with overflow: auto/scroll)
-const findScrollableParent = (element) => {
-    if (element === null)
-        return undefined;
-    let current = element.parentElement;
-    while (current !== null) {
-        const style = window.getComputedStyle(current);
-        const overflowY = style.overflowY;
-        if (overflowY === 'auto' || overflowY === 'scroll') {
-            return current;
-        }
-        current = current.parentElement;
+var findScrollableParent = function findScrollableParent(element) {
+  if (element === null) return undefined;
+  var current = element.parentElement;
+  while (current !== null) {
+    var style = window.getComputedStyle(current);
+    var overflowY = style.overflowY;
+    if (overflowY === 'auto' || overflowY === 'scroll') {
+      return current;
     }
-    return undefined;
+    current = current.parentElement;
+  }
+  return undefined;
 };
-export const useScrollViewport = (containerRef) => {
-    const [viewport, setViewport] = useState({
-        scrollTop: 0,
-        scrollLeft: 0,
-        containerHeight: 0,
-        containerWidth: 0,
-    });
-    const throttleRef = useRef(null);
-    const updateViewport = useCallback(() => {
-        if (containerRef.current !== null) {
-            const container = containerRef.current;
-            const rect = container.getBoundingClientRect();
-            // Restrict container height to the visible portion on screen
-            // This handles cases where the container is partially off-screen
-            // We only want to consider the visible part for culling calculations
-            const containerTop = rect.top;
-            const containerBottom = rect.bottom;
-            const viewportTop = 0;
-            const viewportBottom = window.innerHeight;
-            const visibleTop = Math.max(containerTop, viewportTop);
-            const visibleBottom = Math.min(containerBottom, viewportBottom);
-            const visibleHeight = Math.max(0, visibleBottom - visibleTop);
-            const scrollOffset = Math.max(0, viewportTop - containerTop);
-            const newViewport = {
-                scrollTop: scrollOffset,
-                scrollLeft: container.scrollLeft,
-                containerHeight: visibleHeight, // Only the visible portion
-                containerWidth: container.clientWidth,
-            };
-            setViewport(newViewport);
-        }
-    }, [containerRef]);
-    // Throttling Strategy:
-    // Use requestAnimationFrame to throttle scroll events to 60fps max
-    // This ensures smooth performance while preventing excessive re-renders
-    const throttledUpdateViewport = useCallback(() => {
+export var useScrollViewport = function useScrollViewport(containerRef) {
+  var $ = _c(10);
+  var t0;
+  if ($[0] === Symbol["for"]("react.memo_cache_sentinel")) {
+    t0 = {
+      scrollTop: 0,
+      scrollLeft: 0,
+      containerHeight: 0,
+      containerWidth: 0
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  var _useState = useState(t0),
+    _useState2 = _slicedToArray(_useState, 2),
+    viewport = _useState2[0],
+    setViewport = _useState2[1];
+  var throttleRef = useRef(null);
+  var t1;
+  if ($[1] !== containerRef) {
+    t1 = function t1() {
+      if (containerRef.current !== null) {
+        var container = containerRef.current;
+        var rect = container.getBoundingClientRect();
+        var containerTop = rect.top;
+        var containerBottom = rect.bottom;
+        var viewportBottom = window.innerHeight;
+        var visibleTop = Math.max(containerTop, 0);
+        var visibleBottom = Math.min(containerBottom, viewportBottom);
+        var visibleHeight = Math.max(0, visibleBottom - visibleTop);
+        var scrollOffset = Math.max(0, 0 - containerTop);
+        var newViewport = {
+          scrollTop: scrollOffset,
+          scrollLeft: container.scrollLeft,
+          containerHeight: visibleHeight,
+          containerWidth: container.clientWidth
+        };
+        setViewport(newViewport);
+      }
+    };
+    $[1] = containerRef;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  var updateViewport = t1;
+  var t2;
+  if ($[3] !== updateViewport) {
+    t2 = function t2() {
+      if (throttleRef.current !== null) {
+        cancelAnimationFrame(throttleRef.current);
+      }
+      throttleRef.current = requestAnimationFrame(updateViewport);
+    };
+    $[3] = updateViewport;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  var throttledUpdateViewport = t2;
+  var t3;
+  var t4;
+  if ($[5] !== containerRef || $[6] !== throttledUpdateViewport || $[7] !== updateViewport) {
+    t3 = function t3() {
+      var container_0 = containerRef.current;
+      if (container_0 === null) {
+        return;
+      }
+      var scrollableParent = findScrollableParent(container_0);
+      var resizeObserver = new ResizeObserver(function () {
+        throttledUpdateViewport();
+      });
+      scrollableParent === null || scrollableParent === void 0 || scrollableParent.addEventListener("scroll", throttledUpdateViewport, {
+        passive: true
+      });
+      container_0.addEventListener("scroll", throttledUpdateViewport, {
+        passive: true
+      });
+      window.addEventListener("scroll", throttledUpdateViewport, {
+        passive: true
+      });
+      resizeObserver.observe(container_0);
+      updateViewport();
+      return function () {
+        scrollableParent === null || scrollableParent === void 0 || scrollableParent.removeEventListener("scroll", throttledUpdateViewport);
+        container_0.removeEventListener("scroll", throttledUpdateViewport);
+        window.removeEventListener("scroll", throttledUpdateViewport);
+        resizeObserver.disconnect();
         if (throttleRef.current !== null) {
-            cancelAnimationFrame(throttleRef.current);
+          cancelAnimationFrame(throttleRef.current);
         }
-        throttleRef.current = requestAnimationFrame(updateViewport);
-    }, [updateViewport]);
-    useEffect(() => {
-        const container = containerRef.current;
-        if (container === null)
-            return;
-        const scrollableParent = findScrollableParent(container);
-        // ResizeObserver Strategy:
-        // Monitor container size changes (window resize, layout shifts)
-        // to update viewport dimensions for accurate culling calculations
-        const resizeObserver = new ResizeObserver(() => {
-            throttledUpdateViewport();
-        });
-        // Listen to scroll on the actual scrollable parent
-        scrollableParent?.addEventListener('scroll', throttledUpdateViewport, { passive: true });
-        container.addEventListener('scroll', throttledUpdateViewport, { passive: true });
-        window.addEventListener('scroll', throttledUpdateViewport, { passive: true });
-        resizeObserver.observe(container);
-        // Initialize viewport state on mount
-        updateViewport();
-        return () => {
-            // Cleanup: Remove event listeners and cancel pending animations
-            scrollableParent?.removeEventListener('scroll', throttledUpdateViewport);
-            container.removeEventListener('scroll', throttledUpdateViewport);
-            window.removeEventListener('scroll', throttledUpdateViewport);
-            resizeObserver.disconnect();
-            if (throttleRef.current !== null) {
-                cancelAnimationFrame(throttleRef.current);
-            }
-        };
-    }, [containerRef, throttledUpdateViewport, updateViewport]);
-    return viewport;
-};
+      };
+    };
+    t4 = [containerRef, throttledUpdateViewport, updateViewport];
+    $[5] = containerRef;
+    $[6] = throttledUpdateViewport;
+    $[7] = updateViewport;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t3 = $[8];
+    t4 = $[9];
+  }
+  useEffect(t3, t4);
+  return viewport;
+};