@anaralabs/lector 3.7.1 → 3.7.3

package/dist/_tsup-dts-rollup.d.ts

@@ -145,7 +145,7 @@ export declare const CanvasLayer: ({ style, background, ...props }: HTMLProps<HT
     background?: string;
 }) => JSX.Element;
 
-export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const clamp: (value: number, minimum: number, maximum: number) => number;
 
 declare type CollapsibleSelection = {
     highlights: HighlightRect[];

package/dist/index.js

@@ -14,8 +14,8 @@ import { useVirtualizer, elementScroll, debounce } from '@tanstack/react-virtual
 // src/components/annotation-tooltip.tsx
 
 // src/lib/clamp.ts
-var clamp = (value, min, max) => {
-  return Math.min(Math.max(value, min), max);
+var clamp = (value, minimum, maximum) => {
+  return Math.min(Math.max(value, minimum), maximum);
 };
 
 // src/lib/zoom.ts
@@ -4543,7 +4543,7 @@ function parseMergedHandlers(mergedHandlers, mergedConfig) {
   };
 }
 
-// ../../node_modules/.pnpm/@use-gesture+react@10.3.1_react@18.3.1/node_modules/@use-gesture/react/dist/use-gesture-react.esm.js
+// ../../node_modules/.pnpm/@use-gesture+react@10.3.1_react@19.2.0/node_modules/@use-gesture/react/dist/use-gesture-react.esm.js
 function useRecognizers(handlers, config = {}, gestureKey, nativeHandlers) {
   const ctrl = React.useMemo(() => new Controller(handlers), []);
   ctrl.applyHandlers(handlers, nativeHandlers);
@@ -4587,12 +4587,21 @@ var firstMemo = (first, memo, initializer) => {
 };
 
 // src/hooks/viewport/useViewportContainer.tsx
+var WHEEL_ZOOM_SENSITIVITY = 0.01;
+var WHEEL_INERTIA_GAP_MS = 140;
+var WHEEL_INERTIA_ESCAPE_FACTOR = 1.35;
 var useViewportContainer = ({
   containerRef,
   elementWrapperRef,
   elementRef
 }) => {
   const [origin, setOrigin] = useState([0, 0]);
+  const wheelInertia = useRef({
+    active: false,
+    lastTime: 0,
+    lastAbsDeltaY: 0,
+    lastSign: 0
+  });
   const { maxZoom, minZoom } = usePdf((state) => state.zoomOptions);
   const zoom = usePdf((state) => state.zoom);
   const viewportRef = usePdf((state) => state.viewportRef);
@@ -4628,7 +4637,17 @@ var useViewportContainer = ({
     if (transformations.current.zoom === zoom || !containerRef.current) {
       return;
     }
-    const dZoom = zoom / transformations.current.zoom;
+    const prevZoom = transformations.current.zoom;
+    if (!prevZoom || !Number.isFinite(prevZoom)) {
+      transformations.current = {
+        translateX: containerRef.current.scrollLeft,
+        translateY: containerRef.current.scrollTop,
+        zoom
+      };
+      updateTransform();
+      return;
+    }
+    const dZoom = zoom / prevZoom;
     transformations.current = {
       translateX: containerRef.current.scrollLeft * dZoom,
       translateY: containerRef.current.scrollTop * dZoom,
@@ -4645,16 +4664,67 @@ var useViewportContainer = ({
       document.removeEventListener("gesturechange", preventDefault);
     };
   }, []);
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const sign = (n) => n === 0 ? 0 : n > 0 ? 1 : -1;
+    const handleWheelCapture = (event) => {
+      const st = wheelInertia.current;
+      const now = Date.now();
+      const ctrl = event.ctrlKey || event.metaKey;
+      const abs = Math.abs(event.deltaY);
+      const s = sign(event.deltaY);
+      if (ctrl) {
+        st.active = true;
+        st.lastTime = now;
+        st.lastAbsDeltaY = abs;
+        st.lastSign = s;
+        event.preventDefault();
+        return;
+      }
+      if (!st.active) {
+        return;
+      }
+      if (now - st.lastTime > WHEEL_INERTIA_GAP_MS) {
+        st.active = false;
+        return;
+      }
+      if (st.lastSign !== 0 && s !== 0 && s !== st.lastSign) {
+        st.active = false;
+        return;
+      }
+      if (st.lastAbsDeltaY > 0 && abs > st.lastAbsDeltaY * WHEEL_INERTIA_ESCAPE_FACTOR + 1) {
+        st.active = false;
+        return;
+      }
+      st.lastTime = now;
+      st.lastAbsDeltaY = abs;
+      st.lastSign = s;
+      event.preventDefault();
+    };
+    container.addEventListener("wheel", handleWheelCapture, {
+      passive: false,
+      capture: true
+    });
+    return () => {
+      container.removeEventListener("wheel", handleWheelCapture, {
+        capture: true
+      });
+    };
+  }, [containerRef]);
   useGesture(
     {
-      onPinch: ({ origin: origin2, first, movement: [ms], memo }) => {
+      onPinch: (state) => {
+        const { origin: origin2, first, movement, delta, event, memo } = state;
+        const [ms] = movement;
+        const [deltaScale] = delta;
         const currentElement = elementRef.current;
         const currentContainer = containerRef.current;
         if (!currentElement || !currentContainer) return;
-        if (!elementRef.current || !containerRef.current) return;
         const newMemo = firstMemo(first, memo, () => {
           const elementRect = currentElement.getBoundingClientRect();
           const containerRect = currentContainer.getBoundingClientRect();
+          const currentZoom = transformations.current.zoom;
           const contentPosition = [
             origin2[0] - elementRect.left,
             origin2[1] - elementRect.top
@@ -4664,17 +4734,37 @@ var useViewportContainer = ({
             origin2[1] - containerRect.top
           ];
           setOrigin([
-            contentPosition[0] / transformations.current.zoom,
-            contentPosition[1] / transformations.current.zoom
+            contentPosition[0] / currentZoom,
+            contentPosition[1] / currentZoom
           ]);
           return {
             contentPosition,
             containerPosition,
-            originZoom: transformations.current.zoom,
-            originTranslate: transformations.current.translateY
+            originZoom: currentZoom,
+            lastZoom: currentZoom
           };
         });
-        const newZoom = clamp(ms * newMemo.originZoom, minZoom, maxZoom);
+        if (first) {
+          return newMemo;
+        }
+        const gestureValuesValid = Number.isFinite(ms) && ms > 0;
+        let effectiveScale = ms;
+        if (!gestureValuesValid) {
+          const wheelEvent = event;
+          if (wheelEvent?.deltaY !== void 0) {
+            const wheelDelta = -wheelEvent.deltaY * WHEEL_ZOOM_SENSITIVITY;
+            effectiveScale = newMemo.lastZoom / newMemo.originZoom * (1 + wheelDelta);
+          } else if (Number.isFinite(deltaScale) && deltaScale !== 0) {
+            effectiveScale = newMemo.lastZoom / newMemo.originZoom * (1 + deltaScale);
+          } else {
+            return newMemo;
+          }
+        }
+        const newZoom = clamp(
+          effectiveScale * newMemo.originZoom,
+          minZoom,
+          maxZoom
+        );
         const realMs = newZoom / newMemo.originZoom;
         const newTranslateX = newMemo.contentPosition[0] * realMs - newMemo.containerPosition[0];
         const newTranslateY = newMemo.contentPosition[1] * realMs - newMemo.containerPosition[1];
@@ -4683,6 +4773,7 @@ var useViewportContainer = ({
           translateX: newTranslateX,
           translateY: newTranslateY
         };
+        newMemo.lastZoom = newZoom;
         updateTransform(true);
         return newMemo;
       },

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@anaralabs/lector",
-	"version": "3.7.1",
+	"version": "3.7.3",
 	"description": "Headless PDF viewer for React",
 	"author": "andrewdr (https://github.com/andrewdoro)",
 	"license": "MIT",
@@ -46,7 +46,7 @@
 		"clsx": "^2.1.1",
 		"pdfjs-dist": "^4.10.38",
 		"playwright": "^1.45.3",
-		"react": "^18.3.1",
+		"react": "^19.1.1",
 		"size-limit": "^11.1.6",
 		"tsc-alias": "^1.8.10",
 		"tslib": "^2.6.3",
@@ -58,13 +58,13 @@
 	},
 	"peerDependencies": {
 		"pdfjs-dist": "^4.9",
-		"react": ">=18"
+		"react": ">=19"
 	},
 	"dependencies": {
 		"@floating-ui/react": "^0.26.28",
 		"@radix-ui/react-slot": "^1.1.0",
 		"@tanstack/react-virtual": "^3.10.9",
-		"react-dom": "18.3.1",
+		"react-dom": "^19.1.1",
 		"use-debounce": "^10.0.4",
 		"uuid": "^11.1.0",
 		"zustand": "^5.0.2"