@tonyclaw/llm-inspector 1.9.8 → 1.10.0

package/.output/server/_libs/tanstack__react-router.mjs

@@ -1,5 +1,5 @@
-import { i as invariant, a as isDangerousProtocol, e as exactPathTest, r as removeTrailingSlash, h as hasKeys, d as deepEqual, f as functionalUpdate, B as BaseRootRoute, b as BaseRoute, c as isModuleNotFoundError, g as isNotFound, j as getScrollRestorationScriptForRouter, k as rootRouteId, l as isServer, m as isRedirect, n as createNonReactiveReadonlyStore, o as createNonReactiveMutableStore, R as RouterCore, p as escapeHtml, q as getAssetCrossOrigin, s as getScriptPreloadAttrs, t as appendUniqueUserTags, u as resolveManifestCssLink, v as transformReadableStreamWithRouter, w as createSsrStreamResponse, x as transformPipeableStreamWithRouter } from "./tanstack__router-core.mjs";
 import { r as reactExports, j as jsxRuntimeExports, R as React } from "./react.mjs";
+import { i as invariant, a as isDangerousProtocol, e as exactPathTest, r as removeTrailingSlash, h as hasKeys, d as deepEqual, f as functionalUpdate, B as BaseRootRoute, b as BaseRoute, c as isModuleNotFoundError, g as isNotFound, j as getScrollRestorationScriptForRouter, k as rootRouteId, l as isServer, m as isRedirect, n as createNonReactiveReadonlyStore, o as createNonReactiveMutableStore, R as RouterCore, p as escapeHtml, q as getAssetCrossOrigin, s as getScriptPreloadAttrs, t as appendUniqueUserTags, u as resolveManifestCssLink, v as transformReadableStreamWithRouter, w as createSsrStreamResponse, x as transformPipeableStreamWithRouter } from "./tanstack__router-core.mjs";
 import { R as ReactDOMServer } from "./react-dom.mjs";
 import { PassThrough } from "node:stream";
 import { i as isbot } from "./isbot.mjs";

package/.output/server/_libs/tanstack__react-store.mjs

@@ -1 +1 @@
-
+import "./react.mjs";

package/.output/server/_libs/tanstack__react-virtual.mjs

@@ -4,24 +4,96 @@ import { V as Virtualizer, e as elementScroll, o as observeElementOffset, a as o
 const useIsomorphicLayoutEffect = typeof document !== "undefined" ? reactExports.useLayoutEffect : reactExports.useEffect;
 function useVirtualizerBase({
   useFlushSync = true,
+  directDomUpdates = false,
+  directDomUpdatesMode = "transform",
   ...options
 }) {
   const rerender = reactExports.useReducer((x) => x + 1, 0)[1];
+  const directRef = reactExports.useRef({
+    enabled: directDomUpdates,
+    mode: directDomUpdatesMode,
+    container: null,
+    lastSize: null,
+    // Keyed by the element itself so a remounted node (same key, new DOM
+    // node — e.g. when `enabled` is toggled off then on) is treated as fresh
+    // and gets its style written.
+    lastPositions: /* @__PURE__ */ new WeakMap(),
+    prevRange: null
+  });
+  directRef.current.enabled = directDomUpdates;
+  directRef.current.mode = directDomUpdatesMode;
+  const applyDirectStyles = (instance2) => {
+    const state = directRef.current;
+    if (!state.enabled) return;
+    const totalSize = instance2.getTotalSize();
+    if (state.container && totalSize !== state.lastSize) {
+      state.lastSize = totalSize;
+      const sizeAxis = instance2.options.horizontal ? "width" : "height";
+      state.container.style[sizeAxis] = `${totalSize}px`;
+    }
+    const horizontal = !!instance2.options.horizontal;
+    const useTransform = state.mode === "transform";
+    const posAxis = horizontal ? "left" : "top";
+    const scrollMargin = instance2.options.scrollMargin;
+    const items = instance2.getVirtualItems();
+    for (const item of items) {
+      const next = item.start - scrollMargin;
+      const el = instance2.elementsCache.get(item.key);
+      if (!el) continue;
+      if (state.lastPositions.get(el) === next) continue;
+      state.lastPositions.set(el, next);
+      if (useTransform) {
+        el.style.transform = horizontal ? `translate3d(${next}px, 0, 0)` : `translate3d(0, ${next}px, 0)`;
+      } else {
+        el.style[posAxis] = `${next}px`;
+      }
+    }
+  };
   const resolvedOptions = {
     ...options,
     onChange: (instance2, sync) => {
       var _a;
-      if (useFlushSync && sync) {
-        reactDomExports.flushSync(rerender);
-      } else {
-        rerender();
+      const state = directRef.current;
+      let shouldRerender = true;
+      if (state.enabled) {
+        applyDirectStyles(instance2);
+        const range = instance2.range;
+        const prev = state.prevRange;
+        shouldRerender = !prev || prev.isScrolling !== instance2.isScrolling || prev.startIndex !== (range == null ? void 0 : range.startIndex) || prev.endIndex !== (range == null ? void 0 : range.endIndex);
+        if (shouldRerender) {
+          state.prevRange = range ? {
+            startIndex: range.startIndex,
+            endIndex: range.endIndex,
+            isScrolling: instance2.isScrolling
+          } : null;
+        }
+      }
+      if (shouldRerender) {
+        if (useFlushSync && sync) {
+          reactDomExports.flushSync(rerender);
+        } else {
+          rerender();
+        }
       }
       (_a = options.onChange) == null ? void 0 : _a.call(options, instance2, sync);
     }
   };
-  const [instance] = reactExports.useState(
-    () => new Virtualizer(resolvedOptions)
-  );
+  const [instance] = reactExports.useState(() => {
+    const v = new Virtualizer(resolvedOptions);
+    return Object.assign(v, {
+      containerRef: (node) => {
+        const state = directRef.current;
+        state.container = node;
+        state.lastSize = null;
+        if (node && state.enabled) {
+          const total = v.getTotalSize();
+          state.lastSize = total;
+          const axis = v.options.horizontal ? "width" : "height";
+          node.style[axis] = `${total}px`;
+        }
+      }
+    });
+  });
   instance.setOptions(resolvedOptions);
   useIsomorphicLayoutEffect(() => {
     return instance._didMount();
@@ -29,6 +101,9 @@ function useVirtualizerBase({
   useIsomorphicLayoutEffect(() => {
     return instance._willUpdate();
   });
+  useIsomorphicLayoutEffect(() => {
+    applyDirectStyles(instance);
+  });
   return instance;
 }
 function useVirtualizer(options) {

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

@@ -169,6 +169,11 @@ const observeElementOffset = (instance, cb) => observeOffset(instance, cb, (el)
   return horizontal ? el.scrollLeft * (isRtl && -1 || 1) : el.scrollTop;
 });
 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) {
@@ -178,6 +183,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, {
@@ -304,7 +317,8 @@ class Virtualizer {
         isRtl: false,
         useScrollendEvent: false,
         useAnimationFrameWithResizeObserver: false,
-        laneAssignmentMode: "estimate"
+        laneAssignmentMode: "estimate",
+        useCachedMeasurements: false
       };
       for (const key in opts2) {
         const v = opts2[key];
@@ -313,6 +327,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;
@@ -322,6 +337,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];
@@ -333,11 +349,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
         ];
       }
     };
@@ -474,19 +517,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) {