nodebb-plugin-pdf-secure 1.2.15 → 1.2.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-pdf-secure",
-  "version": "1.2.15",
+  "version": "1.2.17",
   "description": "Secure PDF viewer plugin for NodeBB - prevents downloading, enables canvas-only rendering with Premium group support",
   "main": "library.js",
   "repository": {

package/static/lib/main.js

@@ -22,6 +22,18 @@
 		});
 	})();
 
+	// Fullscreen API support detection
+	// On touch devices (tablets, mobiles), always use CSS simulated fullscreen.
+	// Native fullscreen has an unblockable browser "scroll-to-exit" gesture on touch devices.
+	// Desktop keeps native fullscreen for the proper OS-level experience.
+	var isTouchDevice = ('ontouchstart' in window) || (navigator.maxTouchPoints > 0);
+	var fullscreenApiSupported = !isTouchDevice && !!(
+		document.documentElement.requestFullscreen ||
+		document.documentElement.webkitRequestFullscreen
+	);
+	var simulatedFullscreenIframe = null;
+	var savedBodyOverflow = '';
+
 	// Loading queue - only load one PDF at a time
 	const loadQueue = [];
 	let isLoading = false;
@@ -76,19 +88,30 @@
 			});
 			if (!sourceIframe) return;
 
-			var fsEl = document.fullscreenElement || document.webkitFullscreenElement;
-			if (fsEl) {
-				if (document.exitFullscreen) document.exitFullscreen();
-				else if (document.webkitExitFullscreen) document.webkitExitFullscreen();
+			if (fullscreenApiSupported) {
+				// Native fullscreen path
+				var fsEl = document.fullscreenElement || document.webkitFullscreenElement;
+				if (fsEl) {
+					if (document.exitFullscreen) document.exitFullscreen();
+					else if (document.webkitExitFullscreen) document.webkitExitFullscreen();
+				} else {
+					if (sourceIframe.requestFullscreen) sourceIframe.requestFullscreen().catch(function () { });
+					else if (sourceIframe.webkitRequestFullscreen) sourceIframe.webkitRequestFullscreen();
+				}
 			} else {
-				if (sourceIframe.requestFullscreen) sourceIframe.requestFullscreen().catch(function () { });
-				else if (sourceIframe.webkitRequestFullscreen) sourceIframe.webkitRequestFullscreen();
+				// Simulated fullscreen path (iOS Safari / Chrome)
+				if (simulatedFullscreenIframe) {
+					exitSimulatedFullscreen();
+				} else {
+					enterSimulatedFullscreen(sourceIframe);
+				}
 			}
 		}
 
 		// Fullscreen state query from iframe
 		if (event.data && event.data.type === 'pdf-secure-fullscreen-query') {
-			var fsActive = !!(document.fullscreenElement || document.webkitFullscreenElement);
+			var fsActive = !!(document.fullscreenElement || document.webkitFullscreenElement) ||
+				(simulatedFullscreenIframe !== null);
 			if (event.source) {
 				event.source.postMessage({
 					type: 'pdf-secure-fullscreen-state',
@@ -126,8 +149,16 @@
 	// Forward fullscreen state changes to all viewer iframes
 	function notifyFullscreenChange() {
 		var fsActive = !!(document.fullscreenElement || document.webkitFullscreenElement);
+		if (fsActive) {
+			document.body.style.overscrollBehavior = 'none';
+			document.body.style.overflow = 'hidden';
+		} else {
+			document.body.style.overscrollBehavior = '';
+			document.body.style.overflow = '';
+		}
 		document.querySelectorAll('.pdf-secure-iframe').forEach(function (f) {
 			if (f.contentWindow) {
+				f.style.overscrollBehavior = 'none';
 				f.contentWindow.postMessage({
 					type: 'pdf-secure-fullscreen-state',
 					isFullscreen: fsActive
@@ -138,6 +169,85 @@
 	document.addEventListener('fullscreenchange', notifyFullscreenChange);
 	document.addEventListener('webkitfullscreenchange', notifyFullscreenChange);
 
+	// Touch handler to block parent scroll during simulated fullscreen
+	function parentFullscreenTouchHandler(e) {
+		e.preventDefault();
+	}
+
+	// Enter CSS simulated fullscreen (for iOS Safari/Chrome)
+	function enterSimulatedFullscreen(iframe) {
+		if (simulatedFullscreenIframe) return; // already in simulated fullscreen
+		simulatedFullscreenIframe = iframe;
+
+		// Save original iframe styles
+		iframe._savedStyle = {
+			position: iframe.style.position,
+			top: iframe.style.top,
+			left: iframe.style.left,
+			width: iframe.style.width,
+			height: iframe.style.height,
+			zIndex: iframe.style.zIndex
+		};
+
+		// Apply fullscreen styles
+		iframe.style.position = 'fixed';
+		iframe.style.top = '0';
+		iframe.style.left = '0';
+		iframe.style.width = '100vw';
+		iframe.style.height = '100vh';
+		iframe.style.zIndex = '2147483647';
+
+		// Lock body scroll
+		savedBodyOverflow = document.body.style.overflow;
+		document.body.style.overflow = 'hidden';
+		document.body.style.overscrollBehavior = 'none';
+
+		// Block touch scroll on parent
+		document.addEventListener('touchmove', parentFullscreenTouchHandler, { passive: false });
+
+		// Notify iframe it is now fullscreen
+		if (iframe.contentWindow) {
+			iframe.contentWindow.postMessage({
+				type: 'pdf-secure-fullscreen-state',
+				isFullscreen: true
+			}, window.location.origin);
+		}
+	}
+
+	// Exit CSS simulated fullscreen
+	function exitSimulatedFullscreen() {
+		if (!simulatedFullscreenIframe) return;
+		var iframe = simulatedFullscreenIframe;
+		simulatedFullscreenIframe = null;
+
+		// Restore original iframe styles
+		if (iframe._savedStyle) {
+			iframe.style.position = iframe._savedStyle.position;
+			iframe.style.top = iframe._savedStyle.top;
+			iframe.style.left = iframe._savedStyle.left;
+			iframe.style.width = iframe._savedStyle.width;
+			iframe.style.height = iframe._savedStyle.height;
+			iframe.style.zIndex = iframe._savedStyle.zIndex;
+			delete iframe._savedStyle;
+		}
+
+		// Restore body scroll
+		document.body.style.overflow = savedBodyOverflow;
+		document.body.style.overscrollBehavior = '';
+		savedBodyOverflow = '';
+
+		// Remove parent touch block
+		document.removeEventListener('touchmove', parentFullscreenTouchHandler);
+
+		// Notify iframe it is no longer fullscreen
+		if (iframe.contentWindow) {
+			iframe.contentWindow.postMessage({
+				type: 'pdf-secure-fullscreen-state',
+				isFullscreen: false
+			}, window.location.origin);
+		}
+	}
+
 	async function processQueue() {
 		if (isLoading || loadQueue.length === 0) return;
 
@@ -169,6 +279,8 @@
 			loadQueue.length = 0;
 			isLoading = false;
 			currentResolver = null;
+			// Exit simulated fullscreen on SPA navigation
+			exitSimulatedFullscreen();
 			interceptPdfLinks();
 		});
 	} catch (err) {

package/static/viewer.html

@@ -2708,72 +2708,36 @@
 
                 svg.addEventListener('touchstart', (e) => {
                     if (!currentTool || e.touches.length !== 1) return;
-
-                    // Eraser and select need immediate response
-                    if (currentTool === 'eraser' || currentTool === 'select') {
-                        e.preventDefault();
-                        startDraw(e, pageNum);
-                        touchDrawing = true;
-                        touchDrawDecided = true;
-                        return;
-                    }
-
-                    // For pen/highlight/shape: wait to decide scroll vs draw
-                    touchDrawDecided = false;
-                    touchDrawing = false;
+                    // In annotation mode, always draw immediately — no direction detection.
+                    // Pan and pinch-zoom are blocked at the container level when a tool is active.
+                    e.preventDefault();
                     touchStartX = e.touches[0].clientX;
                     touchStartYDraw = e.touches[0].clientY;
+                    startDraw(e, pageNum);
+                    touchDrawing = true;
+                    touchDrawDecided = true;
                 }, { passive: false, signal });
 
                 svg.addEventListener('touchmove', (e) => {
                     if (!currentTool || e.touches.length !== 1) return;
-
                     if (touchDrawing) {
-                        // Already decided: drawing
-                        e.preventDefault();
-                        draw(e);
-                        return;
-                    }
-
-                    if (touchDrawDecided) return; // decided scroll, let it through
-
-                    const dx = e.touches[0].clientX - touchStartX;
-                    const dy = e.touches[0].clientY - touchStartYDraw;
-
-                    if (Math.abs(dx) + Math.abs(dy) > 10) {
-                        touchDrawDecided = true;
-
-                        if (Math.abs(dy) > Math.abs(dx) * 2) {
-                            // Predominantly vertical → scroll (don't prevent default)
-                            return;
-                        }
-                        // Horizontal or diagonal → drawing
                         e.preventDefault();
-                        // Start draw from ORIGINAL touch position (not current 10px-offset position)
-                        const syntheticStart = {
-                            currentTarget: svg,
-                            touches: [{ clientX: touchStartX, clientY: touchStartYDraw }],
-                            preventDefault: () => {}
-                        };
-                        startDraw(syntheticStart, pageNum);
-                        // Then immediately draw to current position for continuity
                         draw(e);
-                        touchDrawing = true;
                     }
                 }, { passive: false, signal });
 
                 svg.addEventListener('touchend', (e) => {
-                    if (!touchDrawDecided && currentTool && currentTool !== 'eraser' && currentTool !== 'select') {
-                        // Tap without moving > 10px → draw a dot at touch position
+                    if (touchDrawing) {
+                        stopDraw(pageNum);
+                    } else if (currentTool && currentTool !== 'eraser' && currentTool !== 'select') {
+                        // Tap without moving → draw a dot at touch position
                         const syntheticStart = {
                             currentTarget: svg,
                             touches: [{ clientX: touchStartX, clientY: touchStartYDraw }],
-                            preventDefault: () => {}
+                            preventDefault: () => { }
                         };
                         startDraw(syntheticStart, pageNum);
                         stopDraw(pageNum);
-                    } else if (touchDrawing) {
-                        stopDraw(pageNum);
                     }
                     touchDrawDecided = false;
                     touchDrawing = false;
@@ -4497,11 +4461,23 @@
                 }
             }
 
+            // Apply touch restrictions when entering/exiting fullscreen
+            function applyFullscreenTouchRestrictions() {
+                if (isFullscreen) {
+                    document.documentElement.style.touchAction = 'pan-y pinch-zoom';
+                    document.documentElement.style.overscrollBehavior = 'none';
+                } else {
+                    document.documentElement.style.touchAction = '';
+                    document.documentElement.style.overscrollBehavior = '';
+                }
+            }
+
             // Listen for fullscreen state from parent (iframe mode)
             window.addEventListener('message', (event) => {
                 if (event.data && event.data.type === 'pdf-secure-fullscreen-state') {
                     isFullscreen = event.data.isFullscreen;
                     updateFullscreenIcon();
+                    applyFullscreenTouchRestrictions();
                 }
             });
 
@@ -4509,10 +4485,12 @@
             document.addEventListener('fullscreenchange', () => {
                 isFullscreen = !!(document.fullscreenElement || document.webkitFullscreenElement);
                 updateFullscreenIcon();
+                applyFullscreenTouchRestrictions();
             });
             document.addEventListener('webkitfullscreenchange', () => {
                 isFullscreen = !!(document.fullscreenElement || document.webkitFullscreenElement);
                 updateFullscreenIcon();
+                applyFullscreenTouchRestrictions();
             });
 
             // Fullscreen button click
@@ -4637,6 +4615,11 @@
 
             container.addEventListener('touchstart', (e) => {
                 if (e.touches.length === 2) {
+                    // Block pinch-zoom when an annotation tool is active
+                    if (annotationMode && currentTool) {
+                        e.preventDefault();
+                        return;
+                    }
                     // Cancel any active drawing and clean up
                     if (isDrawing && currentDrawingPage) {
                         const savePage = currentDrawingPage;
@@ -4802,14 +4785,30 @@
                 container.addEventListener('touchmove', (e) => {
                     if (isPinching || e.touches.length !== 1) return;
 
+                    // Block all container scroll when an annotation tool is active
+                    if (annotationMode && currentTool) {
+                        e.preventDefault();
+                        return;
+                    }
+
                     const touchY = e.touches[0].clientY;
                     const deltaY = touchStartY - touchY; // positive = scrolling down
 
-                    const atTop = container.scrollTop <= 0;
-                    const atBottom = container.scrollTop + container.clientHeight >= container.scrollHeight - 1;
+                    const BUFFER = 5; // px buffer to catch near-boundary gestures
+                    const atTop = container.scrollTop <= BUFFER;
+                    const atBottom = container.scrollTop + container.clientHeight >= container.scrollHeight - 1 - BUFFER;
 
-                    if ((atTop && deltaY < 0) || (atBottom && deltaY > 0)) {
-                        e.preventDefault();
+                    // In fullscreen, use buffer; outside fullscreen, only block at exact boundary
+                    if (isFullscreen) {
+                        if ((atTop && deltaY < 0) || (atBottom && deltaY > 0)) {
+                            e.preventDefault();
+                        }
+                    } else {
+                        const atTopExact = container.scrollTop <= 0;
+                        const atBottomExact = container.scrollTop + container.clientHeight >= container.scrollHeight - 1;
+                        if ((atTopExact && deltaY < 0) || (atBottomExact && deltaY > 0)) {
+                            e.preventDefault();
+                        }
                     }
                     touchStartY = touchY;
                 }, { passive: false });
@@ -4831,11 +4830,15 @@
 
                     const touchY = e.touches[0].clientY;
                     const deltaY = docTouchStartY - touchY;
-                    const atTop = container.scrollTop <= 0;
-                    const atBottom = container.scrollTop + container.clientHeight >= container.scrollHeight - 1;
 
-                    // Block pull-down at top and pull-up at bottom in fullscreen
-                    if ((atTop && deltaY < 0) || (atBottom && deltaY > 0)) {
+                    const BUFFER = 5; // px buffer to catch near-boundary gestures
+                    const atTop = container.scrollTop <= BUFFER;
+                    const atBottom = container.scrollTop + container.clientHeight >= container.scrollHeight - 1 - BUFFER;
+
+                    // If content fits entirely (no scroll needed), block all overscroll
+                    const contentFits = container.scrollHeight <= container.clientHeight + 1;
+
+                    if (contentFits || (atTop && deltaY < 0) || (atBottom && deltaY > 0)) {
                         e.preventDefault();
                     }
                     docTouchStartY = touchY;