@tonyclaw/agent-inspector 3.0.18 → 3.0.20

package/.output/server/_libs/tanstack__virtual-core.mjs

@@ -188,6 +188,11 @@ const observeWindowOffset = (instance, cb) => observeOffset(
   (win) => instance.options.horizontal ? win.scrollX : win.scrollY
 );
 const measureElement = (element, entry, instance) => {
+  if (instance.options.useCachedMeasurements) {
+    const index = instance.indexFromElement(element);
+    const key = instance.options.getItemKey(index);
+    return instance.itemSizeCache.get(key) ?? instance.options.estimateSize(index);
+  }
   if (entry == null ? void 0 : entry.borderBoxSize) {
     const box = entry.borderBoxSize[0];
     if (box) {
@@ -197,6 +202,14 @@ const measureElement = (element, entry, instance) => {
       return size;
     }
   }
+  if (!entry) {
+    const index = instance.indexFromElement(element);
+    const key = instance.options.getItemKey(index);
+    const cachedSize = instance.itemSizeCache.get(key);
+    if (cachedSize !== void 0) {
+      return cachedSize;
+    }
+  }
   return element[instance.options.horizontal ? "offsetWidth" : "offsetHeight"];
 };
 const scrollWithAdjustments = (offset, {
@@ -324,7 +337,8 @@ class Virtualizer {
         isRtl: false,
         useScrollendEvent: false,
         useAnimationFrameWithResizeObserver: false,
-        laneAssignmentMode: "estimate"
+        laneAssignmentMode: "estimate",
+        useCachedMeasurements: false
       };
       for (const key in opts2) {
         const v = opts2[key];
@@ -333,6 +347,7 @@ class Virtualizer {
       const prevOptions = this.options;
       let anchor = null;
       let followOnAppend = null;
+      let edgeKeysChanged = false;
       if (prevOptions !== void 0 && prevOptions.enabled && merged.enabled && merged.anchorTo === "end" && this.scrollElement !== null) {
         const prevCount = prevOptions.count;
         const nextCount = merged.count;
@@ -342,6 +357,7 @@ class Virtualizer {
         const didCountChange = nextCount !== prevCount;
         const didEdgeKeysChange = didCountChange || prevCount > 0 && nextCount > 0 && (merged.getItemKey(0) !== prevFirstKey || merged.getItemKey(nextCount - 1) !== prevLastKey);
         if (didEdgeKeysChange) {
+          edgeKeysChanged = true;
           const item = prevCount > 0 ? this.getVirtualItemForOffset(this.getScrollOffset()) ?? measurements[0] : null;
           if (item) {
             anchor = [item.key, this.getScrollOffset() - item.start];
@@ -353,11 +369,38 @@ class Virtualizer {
         }
       }
       this.options = merged;
-      if (anchor || followOnAppend) {
+      if (edgeKeysChanged) {
+        this.pendingMin = 0;
+        this.itemSizeCacheVersion++;
+      }
+      let anchorResolved = false;
+      let anchorDelta = 0;
+      if (anchor && this.scrollOffset !== null) {
+        const [anchorKey, anchorOffset] = anchor;
+        const newMeasurements = this.getMeasurements();
+        const { count, getItemKey } = this.options;
+        let idx = 0;
+        while (idx < count && getItemKey(idx) !== anchorKey) {
+          idx++;
+        }
+        if (idx < count) {
+          const anchorItem = newMeasurements[idx];
+          if (anchorItem) {
+            const newOffset = anchorItem.start + anchorOffset;
+            if (newOffset !== this.scrollOffset) {
+              anchorDelta = newOffset - this.scrollOffset;
+              this.scrollOffset = newOffset;
+              anchorResolved = true;
+            }
+          }
+        }
+      }
+      if (anchorResolved || followOnAppend) {
         this.pendingScrollAnchor = [
-          (anchor == null ? void 0 : anchor[0]) ?? null,
-          (anchor == null ? void 0 : anchor[1]) ?? 0,
-          followOnAppend
+          anchorResolved ? anchor[0] : null,
+          anchorResolved ? anchor[1] : 0,
+          followOnAppend,
+          anchorDelta
         ];
       }
     };
@@ -430,12 +473,16 @@ class Virtualizer {
         );
         this.unsubs.push(
           this.options.observeElementOffset(this, (offset, isScrolling) => {
+            if (isScrolling && this._intendedScrollOffset === null && offset === this.scrollOffset) {
+              return;
+            }
             if (this._intendedScrollOffset !== null && Math.abs(offset - this._intendedScrollOffset) < 1.5) {
               offset = this._intendedScrollOffset;
             }
             this._intendedScrollOffset = null;
             this.scrollAdjustments = 0;
-            this.scrollDirection = isScrolling ? this.getScrollOffset() < offset ? "forward" : "backward" : null;
+            const prevOffset = this.getScrollOffset();
+            this.scrollDirection = isScrolling ? prevOffset === offset ? this.scrollDirection : prevOffset < offset ? "forward" : "backward" : null;
             this.scrollOffset = offset;
             this.isScrolling = isScrolling;
             this._flushIosDeferredIfReady();
@@ -494,19 +541,17 @@ class Virtualizer {
       const anchor = this.pendingScrollAnchor;
       this.pendingScrollAnchor = null;
       if (anchor && this.scrollElement && this.options.enabled) {
-        const [key, offset, followOnAppend] = anchor;
-        if (key !== null) {
-          const { count, getItemKey } = this.options;
-          let index = 0;
-          while (index < count && getItemKey(index) !== key) {
-            index++;
-          }
-          const item = index < count ? this.getMeasurements()[index] : void 0;
-          if (item) {
-            const delta = item.start + offset - this.getScrollOffset();
-            if (!approxEqual(delta, 0)) {
-              this.applyScrollAdjustment(delta);
+        const [key, _offset, followOnAppend, anchorDelta] = anchor;
+        if (key !== null && !followOnAppend) {
+          if (isIOSWebKit() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded)) {
+            if (anchorDelta !== 0) {
+              this._iosDeferredAdjustment += anchorDelta;
             }
+          } else {
+            this._scrollToOffset(this.getScrollOffset(), {
+              adjustments: void 0,
+              behavior: void 0
+            });
           }
         }
         if (followOnAppend) {
@@ -735,16 +780,20 @@ class Virtualizer {
         this.options.lanes
       ],
       (measurements, outerSize, scrollOffset, lanes) => {
-        return this.range = measurements.length > 0 && outerSize > 0 ? calculateRange({
+        if (measurements.length === 0 || outerSize === 0) {
+          this.range = null;
+          return null;
+        }
+        this.range = calculateRangeImpl(
           measurements,
           outerSize,
           scrollOffset,
           lanes,
-          // Pass the typed array so binary search + forward-walk can
-          // read start/end directly from Float64Array, skipping the
-          // Proxy traps that materialize a full VirtualItem per probe.
-          flat: lanes === 1 && this._flatMeasurements != null ? this._flatMeasurements : null
-        }) : null;
+          // Pass the typed array so binary search + forward-walk can read
+          // start/end directly from Float64Array, skipping the Proxy traps.
+          lanes === 1 && this._flatMeasurements != null ? this._flatMeasurements : null
+        );
+        return this.range;
       },
       {
         key: false,
@@ -874,13 +923,13 @@ class Virtualizer {
           delta,
           this
         ) : (
-          // Default: adjust scrollTop only when the resize is an above-
-          // viewport item AND we're not actively scrolling backward.
-          // Adjusting during backward scroll fights the user's scroll
-          // direction and produces the "items jump while scrolling up"
-          // jank reported across many issues. Users who want the old
-          // behavior can pass shouldAdjustScrollPositionOnItemSizeChange.
-          itemStart < this.getScrollOffset() + this.scrollAdjustments && this.scrollDirection !== "backward"
+          // Default: adjust when the resize is an above-viewport item.
+          // First measurement (!has(key)): always adjust — the item
+          // has never been sized, so the estimate→actual delta must
+          // be compensated regardless of scroll direction.
+          // Re-measurement (has(key)): skip during backward scroll
+          // to avoid the "items jump while scrolling up" cascade.
+          itemStart < this.getScrollOffset() + this.scrollAdjustments && (!this.itemSizeCache.has(key) || this.scrollDirection !== "backward")
         ));
         if (this.pendingMin === null || index < this.pendingMin) {
           this.pendingMin = index;
@@ -1122,6 +1171,10 @@ class Virtualizer {
         adjustments: this.scrollAdjustments += delta,
         behavior
       });
+      if (this.scrollOffset !== null) {
+        this.scrollOffset += this.scrollAdjustments;
+        this.scrollAdjustments = 0;
+      }
     }
   }
   scheduleScrollReconcile() {
@@ -1197,26 +1250,44 @@ const findNearestBinarySearch = (low, high, getCurrentValue, value) => {
     return 0;
   }
 };
-function calculateRange({
-  measurements,
-  outerSize,
-  scrollOffset,
-  lanes,
-  flat
-}) {
+function findNearestBinarySearchFlat(flat, high, value) {
+  let low = 0;
+  while (low <= high) {
+    const middle = (low + high) / 2 | 0;
+    const currentValue = flat[middle * 2];
+    if (currentValue < value) {
+      low = middle + 1;
+    } else if (currentValue > value) {
+      high = middle - 1;
+    } else {
+      return middle;
+    }
+  }
+  return low > 0 ? low - 1 : 0;
+}
+function calculateRangeImpl(measurements, outerSize, scrollOffset, lanes, flat) {
   const lastIndex = measurements.length - 1;
-  const getStart = flat ? (index) => flat[index * 2] : (index) => measurements[index].start;
-  const getEnd = flat ? (index) => flat[index * 2] + flat[index * 2 + 1] : (index) => measurements[index].end;
   if (measurements.length <= lanes) {
-    return {
-      startIndex: 0,
-      endIndex: lastIndex
-    };
+    return { startIndex: 0, endIndex: lastIndex };
+  }
+  if (lanes === 1 && flat !== null) {
+    const startIndex2 = findNearestBinarySearchFlat(
+      flat,
+      lastIndex,
+      scrollOffset
+    );
+    let endIndex2 = startIndex2;
+    const limit = scrollOffset + outerSize;
+    while (endIndex2 < lastIndex && flat[endIndex2 * 2] + flat[endIndex2 * 2 + 1] < limit) {
+      endIndex2++;
+    }
+    return { startIndex: startIndex2, endIndex: endIndex2 };
   }
+  const getStart = (index) => measurements[index].start;
   let startIndex = findNearestBinarySearch(0, lastIndex, getStart, scrollOffset);
   let endIndex = startIndex;
   if (lanes === 1) {
-    while (endIndex < lastIndex && getEnd(endIndex) < scrollOffset + outerSize) {
+    while (endIndex < lastIndex && measurements[endIndex].end < scrollOffset + outerSize) {
       endIndex++;
     }
   } else if (lanes > 1) {

package/.output/server/_libs/use-sync-external-store.mjs

@@ -1,4 +1,4 @@
-import { b as requireReact } from "./react.mjs";
+import { a as requireReact } from "./react.mjs";
 var shim = { exports: {} };
 var useSyncExternalStoreShim_production = {};
 var hasRequiredUseSyncExternalStoreShim_production;

package/.output/server/_libs/zod-to-json-schema.mjs

@@ -1,4 +1,4 @@
-import { D as ZodFirstPartyTypeKind } from "./zod.mjs";
+import { T as ZodFirstPartyTypeKind } from "./zod.mjs";
 const ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
 const defaultOptions = {
   name: void 0,