node-mac-recorder 2.20.0 → 2.20.2

package/.claude/settings.local.json

@@ -1,15 +1,8 @@
 {
   "permissions": {
     "allow": [
-      "Bash(npm test)",
-      "Bash(node:*)",
-      "Bash(npm install)",
-      "Bash(npm run clean:*)",
-      "Bash(npm run build:*)",
-      "Bash(npm run rebuild:*)",
-      "Bash(system_profiler:*)",
-      "Bash(sw_vers)",
-      "Bash(find:*)"
+      "Bash(node-gyp:*)",
+      "Bash(node:*)"
     ],
     "deny": [],
     "ask": []

package/index.js

@@ -87,11 +87,7 @@ class MacRecorder extends EventEmitter {
 			x: display.x,
 			y: display.y,
 			isPrimary: display.isPrimary,
-			scaleFactor: display.scaleFactor || 1.0,
-			physicalWidth: display.physicalWidth || display.width,
-			physicalHeight: display.physicalHeight || display.height,
 			resolution: `${display.width}x${display.height}`,
-			physicalResolution: `${display.physicalWidth || display.width}x${display.physicalHeight || display.height}`,
 		}));
 	}
 
@@ -775,31 +771,24 @@ class MacRecorder extends EventEmitter {
 				// JavaScript interval ile polling yap (daha sık - mouse event'leri yakalamak için)
 				this.cursorCaptureInterval = setInterval(() => {
 					try {
-						// Get cursor position with recording coordinates
-						const cursorData = this.getCursorPosition();
+						const position = nativeBinding.getCursorPosition();
 						const timestamp = Date.now() - this.cursorCaptureStartTime;
 
-						// Use recording coordinates for video overlay alignment
-						let x = cursorData.recordingX || cursorData.x;
-						let y = cursorData.recordingY || cursorData.y;
-						let coordinateSystem = "recording-coordinates";
+						// Video-relative coordinate transformation for all recording types
+						let x = position.x;
+						let y = position.y;
+						let coordinateSystem = "global";
 
-						// Apply video-relative transformation for window/area recording
+						// Apply video-relative transformation for all recording types
 						if (this.cursorDisplayInfo && this.cursorDisplayInfo.videoRelative) {
-							// For window/area recording: adjust coordinates relative to capture area
-							if (this.cursorDisplayInfo.videoOffsetX || this.cursorDisplayInfo.videoOffsetY) {
-								// Convert from full recording resolution to capture area coordinates
-								const recordingScaleX = cursorData.scaleX || 1;
-								const recordingScaleY = cursorData.scaleY || 1;
-
-								// Scale offsets to recording resolution
-								const scaledOffsetX = this.cursorDisplayInfo.videoOffsetX * recordingScaleX;
-								const scaledOffsetY = this.cursorDisplayInfo.videoOffsetY * recordingScaleY;
-
-								x = x - scaledOffsetX;
-								y = y - scaledOffsetY;
-								coordinateSystem = "video-relative";
-							}
+							// Step 1: Transform global → display-relative coordinates
+							const displayRelativeX = position.x - this.cursorDisplayInfo.displayX;
+							const displayRelativeY = position.y - this.cursorDisplayInfo.displayY;
+
+							// Step 2: Transform display-relative → video-relative coordinates
+							x = displayRelativeX - this.cursorDisplayInfo.videoOffsetX;
+							y = displayRelativeY - this.cursorDisplayInfo.videoOffsetY;
+							coordinateSystem = "video-relative";
 
 							// Bounds check for video area (don't skip, just note if outside)
 							const outsideVideo = x < 0 || y < 0 ||
@@ -812,30 +801,16 @@ class MacRecorder extends EventEmitter {
 							}
 						}
 
-						const captureData = {
+						const cursorData = {
 							x: x,
 							y: y,
 							timestamp: timestamp,
 							unixTimeMs: Date.now(),
-							cursorType: cursorData.cursorType,
-							type: cursorData.eventType || "move",
+							cursorType: position.cursorType,
+							type: position.eventType || "move",
 							coordinateSystem: coordinateSystem,
-							// Recording metadata for video overlay alignment
+							// Video-relative metadata for all recording types
 							recordingType: this.cursorDisplayInfo?.recordingType || "display",
-							recordingInfo: {
-								// Logical coordinates for backward compatibility
-								logicalX: cursorData.x,
-								logicalY: cursorData.y,
-								// Recording coordinates for video overlay
-								recordingX: x,
-								recordingY: y,
-								// Recording resolution
-								recordingWidth: cursorData.recordingWidth,
-								recordingHeight: cursorData.recordingHeight,
-								// Scale factors
-								scaleX: cursorData.scaleX || 1,
-								scaleY: cursorData.scaleY || 1
-							},
 							videoInfo: this.cursorDisplayInfo ? {
 								width: this.cursorDisplayInfo.videoWidth,
 								height: this.cursorDisplayInfo.videoHeight,
@@ -850,9 +825,9 @@ class MacRecorder extends EventEmitter {
 						};
 
 						// Sadece eventType değiştiğinde veya pozisyon değiştiğinde kaydet
-						if (this.shouldCaptureEvent(captureData)) {
+						if (this.shouldCaptureEvent(cursorData)) {
 							// Dosyaya ekle
-							const jsonString = JSON.stringify(captureData);
+							const jsonString = JSON.stringify(cursorData);
 
 							if (this.cursorCaptureFirstWrite) {
 								fs.appendFileSync(filepath, jsonString);
@@ -862,7 +837,7 @@ class MacRecorder extends EventEmitter {
 							}
 
 							// Son pozisyonu sakla
-							this.lastCapturedData = { ...captureData };
+							this.lastCapturedData = { ...cursorData };
 						}
 					} catch (error) {
 						console.error("Cursor capture error:", error);
@@ -921,123 +896,12 @@ class MacRecorder extends EventEmitter {
 			const position = nativeBinding.getCursorPosition();
 
 			// Cursor hangi display'de ise o display'e relative döndür
-			const displayRelativePosition = this.getDisplayRelativePositionSync(position);
-
-			// Add recording coordinates for video overlay alignment
-			const recordingCoordinates = this.calculateRecordingCoordinates(displayRelativePosition);
-
-			return {
-				...displayRelativePosition,
-				// Recording coordinates for video overlay (matches actual video resolution)
-				recordingX: recordingCoordinates.x,
-				recordingY: recordingCoordinates.y,
-				recordingWidth: recordingCoordinates.width,
-				recordingHeight: recordingCoordinates.height,
-				// Scale factors for reference
-				scaleX: recordingCoordinates.scaleX,
-				scaleY: recordingCoordinates.scaleY,
-				// Original coordinates for backward compatibility
-				x: displayRelativePosition.x,
-				y: displayRelativePosition.y
-			};
+			return this.getDisplayRelativePositionSync(position);
 		} catch (error) {
 			throw new Error("Failed to get cursor position: " + error.message);
 		}
 	}
 
-	/**
-	 * Calculate cursor coordinates for recording video overlay alignment
-	 * Converts logical display coordinates to actual video recording coordinates
-	 */
-	calculateRecordingCoordinates(displayPosition) {
-		try {
-			// Get current display information
-			if (!this.cachedDisplays) {
-				this.refreshDisplayCache();
-			}
-
-			// If still null, use native binding directly
-			if (!this.cachedDisplays) {
-				try {
-					const nativeDisplays = nativeBinding.getDisplays();
-					this.cachedDisplays = nativeDisplays.map((display, index) => ({
-						id: display.id,
-						name: display.name,
-						width: display.width,
-						height: display.height,
-						x: display.x,
-						y: display.y,
-						isPrimary: display.isPrimary,
-						scaleFactor: display.scaleFactor || 1.0,
-						physicalWidth: display.physicalWidth || display.width,
-						physicalHeight: display.physicalHeight || display.height,
-						resolution: `${display.width}x${display.height}`,
-					}));
-				} catch (e) {
-					console.warn('Failed to get displays from native binding:', e.message);
-				}
-			}
-
-			// Find the target display
-			let targetDisplay = null;
-			if (displayPosition.displayId) {
-				targetDisplay = this.cachedDisplays.find(d => d.id === displayPosition.displayId);
-			}
-			if (!targetDisplay) {
-				targetDisplay = this.cachedDisplays.find(d => d.isPrimary) || this.cachedDisplays[0];
-			}
-
-			if (!targetDisplay) {
-				// Fallback: assume 1:1 mapping
-				return {
-					x: displayPosition.x,
-					y: displayPosition.y,
-					width: displayPosition.x,
-					height: displayPosition.y
-				};
-			}
-
-			// Parse display dimensions
-			const logicalWidth = parseInt(targetDisplay.resolution.split("x")[0]);
-			const logicalHeight = parseInt(targetDisplay.resolution.split("x")[1]);
-
-			// Get physical recording dimensions
-			// On Retina displays, recording is done at physical resolution (2x logical)
-			const physicalWidth = targetDisplay.physicalWidth || (logicalWidth * (targetDisplay.scaleFactor || 1));
-			const physicalHeight = targetDisplay.physicalHeight || (logicalHeight * (targetDisplay.scaleFactor || 1));
-
-			// Calculate scale factors for coordinate conversion
-			const scaleX = physicalWidth / logicalWidth;
-			const scaleY = physicalHeight / logicalHeight;
-
-			// Convert logical cursor coordinates to recording coordinates
-			const recordingX = Math.round(displayPosition.x * scaleX);
-			const recordingY = Math.round(displayPosition.y * scaleY);
-
-			return {
-				x: recordingX,
-				y: recordingY,
-				width: physicalWidth,
-				height: physicalHeight,
-				scaleX: scaleX,
-				scaleY: scaleY,
-				logicalWidth: logicalWidth,
-				logicalHeight: logicalHeight
-			};
-		} catch (error) {
-			console.warn('Failed to calculate recording coordinates:', error.message);
-			// Fallback: 1:1 mapping
-			return {
-				x: displayPosition.x,
-				y: displayPosition.y,
-				width: displayPosition.x,
-				height: displayPosition.y,
-				scaleX: 1,
-				scaleY: 1
-			};
-		}
-	}
-
 	/**
 	 * Global koordinatları en uygun display'e relative çevirir (sync version)
 	 */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "2.20.0",
+	"version": "2.20.2",
 	"description": "Native macOS screen recording package for Node.js applications",
 	"main": "index.js",
 	"keywords": [