node-mac-recorder 2.17.18 → 2.17.19

package/index.js

@@ -359,53 +359,10 @@ class MacRecorder extends EventEmitter {
 					// Start cursor tracking automatically with recording
 					let cursorOptions = {};
 
-					// For window recording, use simplified window-relative coordinates
-					if (this.options.windowId) {
-						// Use cached window info from the earlier window detection
-						this.getWindows().then(windows => {
-							const targetWindow = windows.find(w => w.id === this.options.windowId);
-							if (targetWindow) {
-								// Start cursor capture with simplified window-relative tracking
-								this.startCursorCapture(cursorFilePath, {
-									windowRelative: true,
-									windowInfo: {
-										// Use original global window coordinates for reference
-										x: targetWindow.x,
-										y: targetWindow.y,
-										width: targetWindow.width,
-										height: targetWindow.height,
-										displayId: this.options.displayId,
-										// Persist capture area so we can rebuild global offsets reliably
-										captureArea: this.options.captureArea,
-										// Keep a snapshot of the window details for debugging/analytics
-										originalWindow: targetWindow,
-										// Store display info for multi-display coordinate fixes
-										targetDisplay: this.recordingDisplayInfo
-									}
-								}).catch(cursorError => {
-									console.warn('Window cursor tracking failed:', cursorError.message);
-									// Fallback to display recording
-									this.startCursorCapture(cursorFilePath).catch(fallbackError => {
-										console.warn('Fallback cursor tracking failed:', fallbackError.message);
-									});
-								});
-							}
-						}).catch(error => {
-							console.warn('Could not get window info for cursor tracking:', error.message);
-							// Fallback to display cursor tracking
-							this.startCursorCapture(cursorFilePath).catch(cursorError => {
-								console.warn('Cursor tracking failed to start:', cursorError.message);
-							});
-						});
-					} else {
-						// For display recording, use display-relative cursor tracking
-						this.startCursorCapture(cursorFilePath, {
-							displayRelative: true,
-							displayInfo: this.recordingDisplayInfo
-						}).catch(cursorError => {
-							console.warn('Display cursor tracking failed:', cursorError.message);
-						});
-					}
+					// Hem window hem display recording için aynı native cursor tracking kullan
+					this.startCursorCapture(cursorFilePath).catch(cursorError => {
+						console.warn('Cursor tracking failed to start:', cursorError.message);
+					});
 
 					// Timer başlat (progress tracking için)
 					this.recordingTimer = setInterval(() => {
@@ -916,7 +873,34 @@ class MacRecorder extends EventEmitter {
 	/**
 	 * Cursor capture durdurur - dosya yazma işlemini sonlandırır
 	 */
-	async stopCursorCapture() {
+	stopCursorCapture() {
+		if (!this.cursorCaptureInterval) {
+			return false;
+		}
+
+		try {
+			// Native cursor tracking'i durdur
+			const success = nativeBinding.stopCursorTracking();
+
+			this.cursorCaptureInterval = null;
+			this.cursorCaptureFile = null;
+			this.cursorCaptureStartTime = null;
+
+			this.emit("cursorCaptureStopped", {
+				timestamp: Date.now()
+			});
+
+			return success;
+		} catch (error) {
+			console.warn("Error stopping cursor tracking:", error.message);
+			return false;
+		}
+	}
+
+	/**
+	 * LEGACY: Eski JS-based cursor capture durdurmak için geriye uyumluluk
+	 */
+	async _legacyStopCursorCapture() {
 		return new Promise((resolve, reject) => {
 			try {
 				if (!this.cursorCaptureInterval) {

package/package.json

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

package/src/cursor_tracker.mm

@@ -601,13 +601,15 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
         }
         
         // Cursor data oluştur
+        // Cursor data oluştur - global koordinat sistemi kullan
         NSDictionary *cursorInfo = @{
             @"x": @((int)location.x),
             @"y": @((int)location.y),
             @"timestamp": @(timestamp),
             @"unixTimeMs": @(unixTimeMs),
             @"cursorType": cursorType,
-            @"type": eventType
+            @"type": eventType,
+            @"coordinateSystem": @"global"
         };
         
         // Direkt dosyaya yaz
@@ -636,37 +638,32 @@ void cursorTimerCallback() {
         // Apply DPR scaling correction for Retina displays
         NSDictionary *scalingInfo = getDisplayScalingInfo(rawLocation);
         CGPoint location = rawLocation;
-
+        
         if (scalingInfo) {
             CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
             NSRect displayBounds = [[scalingInfo objectForKey:@"displayBounds"] rectValue];
-
+            
             // Keep logical coordinates - no scaling needed here
             location = rawLocation;
         }
-
+        
         NSDate *currentDate = [NSDate date];
         NSTimeInterval timestamp = [currentDate timeIntervalSinceDate:g_trackingStartTime] * 1000; // milliseconds
         NSTimeInterval unixTimeMs = [currentDate timeIntervalSince1970] * 1000; // unix timestamp in milliseconds
         NSString *cursorType = getCursorType();
-
-        // CRITICAL: Apply coordinate transformation if needed
-        // This should match the transformation logic in index.js cursorTimerCallback
-
-        // Use transformed coordinates from the JavaScript layer if available
-        // The transformation is handled in index.js, so we need to get the transformed position
-        // For now, we'll write the raw coordinates and let the JS layer handle transformation
-
+        
         // Cursor data oluştur
+        // Cursor data oluştur - global koordinat sistemi kullan
         NSDictionary *cursorInfo = @{
             @"x": @((int)location.x),
             @"y": @((int)location.y),
             @"timestamp": @(timestamp),
             @"unixTimeMs": @(unixTimeMs),
             @"cursorType": cursorType,
-            @"type": @"move"
+            @"type": @"move",
+            @"coordinateSystem": @"global"
         };
-
+        
         // Direkt dosyaya yaz
         writeToFile(cursorInfo);
     }

package/test-output/primary-fix-test-1758266910543.json

@@ -0,0 +1 @@
+[]

package/test-output/unified-cursor-1758313640878.json

@@ -0,0 +1 @@
+[{"x":702,"y":607,"timestamp":119,"unixTimeMs":1758313640997,"cursorType":"text","type":"move","coordinateSystem":"display-relative"}

package/test-output/unified-cursor-1758313689471.json

@@ -0,0 +1 @@
+[{"x":702,"y":607,"timestamp":132,"unixTimeMs":1758313689604,"cursorType":"text","type":"move","coordinateSystem":"display-relative"}

package/test-unified-cursor.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+const MacRecorder = require('./index.js');
+const fs = require('fs');
+const path = require('path');
+
+async function testUnifiedCursorTracking() {
+    const recorder = new MacRecorder();
+
+    console.log('🎯 Testing unified cursor tracking...');
+
+    // Create test output directory
+    const outputDir = './test-output';
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir);
+    }
+
+    const cursorFilePath = path.join(outputDir, `unified-cursor-${Date.now()}.json`);
+
+    try {
+        console.log('Starting native cursor tracking...');
+
+        // Test native cursor tracking
+        const result = await recorder.startCursorCapture(cursorFilePath);
+        console.log('✅ Cursor tracking started:', result);
+
+        console.log('\n🔥 Move your mouse around for 5 seconds...');
+
+        // Wait 5 seconds
+        await new Promise(resolve => setTimeout(resolve, 5000));
+
+        console.log('\nStopping cursor tracking...');
+        const stopped = recorder.stopCursorCapture();
+        console.log('✅ Cursor tracking stopped:', stopped);
+
+        // Wait a bit for file to be written
+        await new Promise(resolve => setTimeout(resolve, 1000));
+
+        // Check if file exists and has content
+        if (fs.existsSync(cursorFilePath)) {
+            const fileContent = fs.readFileSync(cursorFilePath, 'utf8');
+            console.log('📁 File size:', fileContent.length, 'bytes');
+
+            try {
+                const cursorData = JSON.parse(fileContent);
+                console.log('📊 Cursor data points:', cursorData.length);
+
+                if (cursorData.length > 0) {
+                    console.log('📍 First point:', cursorData[0]);
+                    console.log('📍 Last point:', cursorData[cursorData.length - 1]);
+
+                    // Check coordinate system
+                    const coordinateSystems = [...new Set(cursorData.map(p => p.coordinateSystem))];
+                    console.log('🔧 Coordinate systems used:', coordinateSystems);
+                }
+            } catch (parseError) {
+                console.log('⚠️ File content (first 500 chars):', fileContent.substring(0, 500));
+            }
+        } else {
+            console.log('❌ Output file not found:', cursorFilePath);
+        }
+
+    } catch (error) {
+        console.error('❌ Test failed:', error.message);
+    }
+}
+
+// Run test
+testUnifiedCursorTracking().then(() => {
+    console.log('\n✨ Test completed');
+    process.exit(0);
+}).catch(error => {
+    console.error('💥 Test error:', error);
+    process.exit(1);
+});

package/debug-primary-cursor.js

@@ -1,180 +0,0 @@
-const MacRecorder = require('./index.js');
-
-async function debugPrimaryCursor() {
-    console.log('🔍 Detailed debugging of primary display cursor coordinates...');
-
-    const recorder = new MacRecorder();
-
-    try {
-        const displays = await recorder.getDisplays();
-        const windows = await recorder.getWindows();
-
-        const primaryDisplay = displays.find(d => d.isPrimary);
-        console.log('\n📱 Primary Display:');
-        console.log(`   Bounds: (${primaryDisplay.x}, ${primaryDisplay.y}) ${primaryDisplay.width}x${primaryDisplay.height}`);
-
-        // Find a window on primary display
-        const primaryWindows = windows.filter(window => {
-            const windowCenterX = window.x + window.width / 2;
-            const windowCenterY = window.y + window.height / 2;
-            return (windowCenterX >= primaryDisplay.x &&
-                    windowCenterX < primaryDisplay.x + primaryDisplay.width &&
-                    windowCenterY >= primaryDisplay.y &&
-                    windowCenterY < primaryDisplay.y + primaryDisplay.height);
-        });
-
-        if (primaryWindows.length === 0) {
-            console.log('❌ No windows found on primary display');
-            return;
-        }
-
-        const testWindow = primaryWindows[0];
-        console.log('\n🪟 Test Window:');
-        console.log(`   Title: "${testWindow.title}"`);
-        console.log(`   Global position: (${testWindow.x}, ${testWindow.y})`);
-        console.log(`   Size: ${testWindow.width}x${testWindow.height}`);
-        console.log(`   Global bounds: (${testWindow.x}, ${testWindow.y}) to (${testWindow.x + testWindow.width}, ${testWindow.y + testWindow.height})`);
-
-        // Manual cursor position check
-        console.log('\n🖱️ Current cursor position:');
-        const currentPos = recorder.getCursorPosition();
-        console.log(`   Global cursor: (${currentPos.x}, ${currentPos.y})`);
-
-        // Manual transformation calculation
-        console.log('\n🧮 Manual transformation calculation:');
-        const manualWindowRelativeX = currentPos.x - testWindow.x;
-        const manualWindowRelativeY = currentPos.y - testWindow.y;
-        console.log(`   Manual window-relative: (${manualWindowRelativeX}, ${manualWindowRelativeY})`);
-
-        const isInWindow = (manualWindowRelativeX >= 0 && manualWindowRelativeX < testWindow.width &&
-                           manualWindowRelativeY >= 0 && manualWindowRelativeY < testWindow.height);
-        console.log(`   Is cursor in window? ${isInWindow ? '✅ YES' : '❌ NO'}`);
-
-        if (!isInWindow) {
-            console.log('\n⚠️ Move cursor to the test window for accurate testing...');
-            console.log('   Waiting 3 seconds for you to move cursor to the window...');
-            await new Promise(resolve => setTimeout(resolve, 3000));
-
-            const newPos = recorder.getCursorPosition();
-            console.log(`\n🖱️ New cursor position: (${newPos.x}, ${newPos.y})`);
-            const newManualX = newPos.x - testWindow.x;
-            const newManualY = newPos.y - testWindow.y;
-            console.log(`   New manual window-relative: (${newManualX}, ${newManualY})`);
-
-            const newIsInWindow = (newManualX >= 0 && newManualX < testWindow.width &&
-                                  newManualY >= 0 && newManualY < testWindow.height);
-            console.log(`   Is cursor in window now? ${newIsInWindow ? '✅ YES' : '❌ NO'}`);
-        }
-
-        // Now test with cursor capture to see what actually gets recorded
-        console.log('\n🎬 Testing actual cursor capture...');
-
-        // Create a custom logger to see what coordinates are being processed
-        const originalLog = console.log;
-        const capturedLogs = [];
-
-        // Temporarily override console.log to capture coordinate logs
-        console.log = (...args) => {
-            const message = args.join(' ');
-            if (message.includes('cursor') || message.includes('position') || message.includes('coordinate')) {
-                capturedLogs.push(message);
-            }
-            originalLog(...args);
-        };
-
-        const outputFile = `./test-output/debug-primary-${Date.now()}.json`;
-
-        // Start capture with detailed logging
-        await recorder.startCursorCapture(outputFile, {
-            windowRelative: true,
-            windowInfo: {
-                x: testWindow.x,
-                y: testWindow.y,
-                width: testWindow.width,
-                height: testWindow.height,
-                displayId: primaryDisplay.id
-            }
-        });
-
-        console.log('\n📍 Cursor capture started. Move mouse in the window for 3 seconds...');
-        console.log(`   Expected window bounds: (0, 0) to (${testWindow.width}, ${testWindow.height})`);
-
-        // Capture for 3 seconds with manual checking
-        for (let i = 0; i < 6; i++) {
-            await new Promise(resolve => setTimeout(resolve, 500));
-            const pos = recorder.getCursorPosition();
-            const windowRelX = pos.x - testWindow.x;
-            const windowRelY = pos.y - testWindow.y;
-
-            console.log(`   Sample ${i+1}: Global(${pos.x}, ${pos.y}) → Window-rel(${windowRelX}, ${windowRelY})`);
-        }
-
-        await recorder.stopCursorCapture();
-
-        // Restore console.log
-        console.log = originalLog;
-
-        // Analyze results
-        const fs = require('fs');
-        if (fs.existsSync(outputFile)) {
-            const cursorData = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
-
-            console.log('\n📊 Analysis Results:');
-            console.log(`   Captured events: ${cursorData.length}`);
-
-            if (cursorData.length > 0) {
-                console.log('\n📍 Sample recorded coordinates:');
-                cursorData.slice(0, 5).forEach((event, i) => {
-                    console.log(`   Event ${i+1}: (${event.x}, ${event.y}) - ${event.coordinateSystem}`);
-                });
-
-                // Check bounds
-                const inBounds = cursorData.filter(event =>
-                    event.x >= 0 && event.x < testWindow.width &&
-                    event.y >= 0 && event.y < testWindow.height
-                );
-
-                const outOfBounds = cursorData.filter(event =>
-                    event.x < 0 || event.x >= testWindow.width ||
-                    event.y < 0 || event.y >= testWindow.height
-                );
-
-                console.log(`\n✅ Events in bounds: ${inBounds.length}/${cursorData.length} (${Math.round(inBounds.length/cursorData.length*100)}%)`);
-
-                if (outOfBounds.length > 0) {
-                    console.log(`❌ Events out of bounds: ${outOfBounds.length}`);
-                    console.log('   Problem coordinates:');
-                    outOfBounds.slice(0, 3).forEach(event => {
-                        console.log(`      (${event.x}, ${event.y}) - Expected: 0-${testWindow.width}, 0-${testWindow.height}`);
-                    });
-
-                    // Calculate offset pattern
-                    const xOffsets = outOfBounds.map(e => e.x - (e.x >= 0 ? 0 : testWindow.width));
-                    const yOffsets = outOfBounds.map(e => e.y - (e.y >= 0 ? 0 : testWindow.height));
-
-                    console.log(`\n🔍 Offset analysis:`);
-                    console.log(`   X offset pattern: ${xOffsets.slice(0, 3).join(', ')}`);
-                    console.log(`   Y offset pattern: ${yOffsets.slice(0, 3).join(', ')}`);
-                } else {
-                    console.log('✅ All coordinates are within bounds!');
-                }
-            } else {
-                console.log('❌ No events captured - cursor might not be in window or transformation is dropping events');
-            }
-        } else {
-            console.log('❌ No output file created');
-        }
-
-        console.log('\n🔍 Captured system logs:');
-        if (capturedLogs.length > 0) {
-            capturedLogs.forEach(log => console.log(`   ${log}`));
-        } else {
-            console.log('   No relevant coordinate logs captured');
-        }
-
-    } catch (error) {
-        console.error('❌ Debug failed:', error.message);
-    }
-}
-
-debugPrimaryCursor().catch(console.error);