node-mac-recorder 1.2.0 → 1.2.1

package/cursor-data.json

@@ -0,0 +1,93 @@
+[
+	{
+		"x": 1119,
+		"y": 1090,
+		"timestamp": 106,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1119,
+		"y": 1080,
+		"timestamp": 407,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1119,
+		"y": 1066,
+		"timestamp": 423,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1119,
+		"y": 1042,
+		"timestamp": 446,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1119,
+		"y": 968,
+		"timestamp": 466,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1129,
+		"y": 906,
+		"timestamp": 487,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1153,
+		"y": 820,
+		"timestamp": 507,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1168,
+		"y": 782,
+		"timestamp": 528,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1176,
+		"y": 764,
+		"timestamp": 549,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1176,
+		"y": 764,
+		"timestamp": 2578,
+		"cursorType": "default",
+		"type": "mousedown"
+	},
+	{
+		"x": 1176,
+		"y": 764,
+		"timestamp": 2599,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1176,
+		"y": 764,
+		"timestamp": 2724,
+		"cursorType": "default",
+		"type": "mouseup"
+	},
+	{
+		"x": 1176,
+		"y": 764,
+		"timestamp": 2744,
+		"cursorType": "default",
+		"type": "move"
+	}
+]

package/cursor-test.js

@@ -2,175 +2,49 @@ const MacRecorder = require("./index");
 const path = require("path");
 const fs = require("fs");
 
-async function testCursorTracking() {
-	console.log("🎯 Cursor Tracking Test Başlatılıyor...\n");
+async function testCursorCapture() {
+	console.log("🎯 Cursor Capture Demo\n");
 
 	const recorder = new MacRecorder();
+	const outputPath = path.join(__dirname, "cursor-data.json");
 
 	try {
-		// Cursor tracking başlat
-		const outputPath = path.join(__dirname, "cursor-data.json");
-		console.log("📍 Cursor tracking başlatılıyor...");
-		console.log("📁 Output dosyası:", outputPath);
+		// Başlat
+		await recorder.startCursorCapture(outputPath);
+		console.log("✅ Kayıt başladı...");
 
-		await recorder.startCursorTracking(outputPath);
-		console.log("✅ Cursor tracking başlatıldı!");
-
-		// Durum kontrolü
-		const status = recorder.getCursorTrackingStatus();
-		console.log("📊 Tracking durumu:", status);
-
-		// 5 saniye bekle ve pozisyon örnekleri al
-		console.log(
-			"\n🎬 5 saniye boyunca cursor hareketlerinizi takip ediyoruz..."
-		);
-		console.log("💡 Fare hareket ettirin, tıklayın ve sürükleyin!");
-
-		// Manuel data collection - JavaScript tarafında polling
-		const manualData = [];
-		const startTime = Date.now();
+		// 5 saniye bekle
+		console.log("📱 5 saniye hareket ettirin, tıklayın...");
 
 		for (let i = 5; i > 0; i--) {
-			console.log(`⏳ ${i} saniye kaldı...`);
-
-			// 100ms'de bir pozisyon al (10 FPS)
-			for (let j = 0; j < 10; j++) {
-				const position = recorder.getCursorPosition();
-				const timestamp = Date.now() - startTime;
-
-				manualData.push({
-					x: position.x,
-					y: position.y,
-					timestamp: timestamp,
-					cursorType: position.cursorType,
-					type: "move",
-				});
-
-				await new Promise((resolve) => setTimeout(resolve, 100));
-			}
-
-			// Son pozisyonu göster
-			if (manualData.length > 0) {
-				const lastPos = manualData[manualData.length - 1];
-				console.log(
-					`📌 Pozisyon: x=${lastPos.x}, y=${lastPos.y}, tip=${lastPos.cursorType}`
-				);
-			}
+			process.stdout.write(`⏳ ${i}... `);
+			await new Promise((resolve) => setTimeout(resolve, 1000));
 		}
+		console.log("\n");
 
-		// Manuel veriyi dosyaya kaydet
-		console.log(
-			`\n📝 Manuel data collection: ${manualData.length} pozisyon toplandı`
-		);
-		const manualPath = path.join(__dirname, "manual-cursor-data.json");
-		fs.writeFileSync(manualPath, JSON.stringify(manualData, null, 2));
-		console.log(`📄 Manuel veriler kaydedildi: ${manualPath}`);
-
-		// Tracking durdur
-		console.log("\n🛑 Cursor tracking durduruluyor...");
-		await recorder.stopCursorTracking();
-		console.log("✅ Cursor tracking durduruldu!");
+		// Durdur
+		await recorder.stopCursorCapture();
+		console.log("✅ Kayıt tamamlandı!");
 
-		// Final durum kontrolü
-		const finalStatus = recorder.getCursorTrackingStatus();
-		console.log("📊 Final durumu:", finalStatus);
-
-		// Dosya kontrolü
+		// Sonuç
 		if (fs.existsSync(outputPath)) {
 			const data = JSON.parse(fs.readFileSync(outputPath, "utf8"));
-			console.log(
-				`\n📄 JSON dosyası oluşturuldu: ${data.length} adet cursor verisi kaydedildi`
-			);
-
-			// İlk birkaç veriyi göster
-			if (data.length > 0) {
-				console.log("\n📝 İlk 3 cursor verisi:");
-				data.slice(0, 3).forEach((item, index) => {
-					console.log(
-						`${index + 1}. x:${item.x}, y:${item.y}, timestamp:${
-							item.timestamp
-						}, cursorType:${item.cursorType}, type:${item.type}`
-					);
-				});
+			console.log(`📄 ${data.length} event kaydedildi -> ${outputPath}`);
 
-				if (data.length > 3) {
-					console.log(`... ve ${data.length - 3} adet daha`);
-				}
+			// Basit istatistik
+			const clicks = data.filter((d) => d.type === "mousedown").length;
+			if (clicks > 0) {
+				console.log(`🖱️  ${clicks} click algılandı`);
 			}
-
-			// Cursor tipleri istatistiği
-			const cursorTypes = {};
-			const eventTypes = {};
-			data.forEach((item) => {
-				cursorTypes[item.cursorType] = (cursorTypes[item.cursorType] || 0) + 1;
-				eventTypes[item.type] = (eventTypes[item.type] || 0) + 1;
-			});
-
-			console.log("\n📈 Cursor Tipleri İstatistiği:");
-			Object.keys(cursorTypes).forEach((type) => {
-				console.log(`  ${type}: ${cursorTypes[type]} adet`);
-			});
-
-			console.log("\n🎭 Event Tipleri İstatistiği:");
-			Object.keys(eventTypes).forEach((type) => {
-				console.log(`  ${type}: ${eventTypes[type]} adet`);
-			});
-		} else {
-			console.log("❌ JSON dosyası oluşturulamadı!");
 		}
 	} catch (error) {
 		console.error("❌ Hata:", error.message);
 	}
-
-	console.log("\n🎉 Test tamamlandı!");
-}
-
-// Ek fonksiyonlar test et
-async function testCursorPositionOnly() {
-	console.log("\n🎯 Anlık Cursor Pozisyon Testi...");
-
-	const recorder = new MacRecorder();
-
-	try {
-		for (let i = 0; i < 5; i++) {
-			const position = recorder.getCursorPosition();
-			console.log(
-				`📌 Pozisyon ${i + 1}: x=${position.x}, y=${position.y}, tip=${
-					position.cursorType
-				}`
-			);
-			await new Promise((resolve) => setTimeout(resolve, 500));
-		}
-	} catch (error) {
-		console.error("❌ Pozisyon alma hatası:", error.message);
-	}
-}
-
-// Test menüsü
-async function main() {
-	console.log("🚀 MacRecorder Cursor Tracking Test Menüsü\n");
-
-	const args = process.argv.slice(2);
-
-	if (args.includes("--position")) {
-		await testCursorPositionOnly();
-	} else if (args.includes("--full")) {
-		await testCursorTracking();
-	} else {
-		console.log("Kullanım:");
-		console.log(
-			"  node cursor-test.js --full     # Tam cursor tracking testi (5 saniye)"
-		);
-		console.log(
-			"  node cursor-test.js --position # Sadece anlık pozisyon testi"
-		);
-		console.log("\nÖrnek:");
-		console.log("  node cursor-test.js --full");
-	}
 }
 
+// Direkt çalıştır
 if (require.main === module) {
-	main().catch(console.error);
+	testCursorCapture().catch(console.error);
 }
 
-module.exports = { testCursorTracking, testCursorPositionOnly };
+module.exports = { testCursorCapture };

package/index.js

@@ -25,6 +25,14 @@ class MacRecorder extends EventEmitter {
 		this.outputPath = null;
 		this.recordingTimer = null;
 		this.recordingStartTime = null;
+
+		// Cursor capture variables
+		this.cursorCaptureInterval = null;
+		this.cursorCaptureFile = null;
+		this.cursorCaptureStartTime = null;
+		this.cursorCaptureFirstWrite = true;
+		this.lastCapturedData = null;
+
 		this.options = {
 			includeMicrophone: false, // Default olarak mikrofon kapalı
 			includeSystemAudio: true, // Default olarak sistem sesi açık
@@ -414,26 +422,96 @@ class MacRecorder extends EventEmitter {
 	}
 
 	/**
-	 * Cursor tracking başlatır
+	 * Event'in kaydedilip kaydedilmeyeceğini belirler
 	 */
-	async startCursorTracking(outputPath) {
-		if (!outputPath) {
-			throw new Error("Output path is required");
+	shouldCaptureEvent(currentData) {
+		if (!this.lastCapturedData) {
+			return true; // İlk event
+		}
+
+		const last = this.lastCapturedData;
+
+		// Event type değişmişse
+		if (currentData.type !== last.type) {
+			return true;
+		}
+
+		// Pozisyon değişmişse (minimum 2 pixel tolerans)
+		if (
+			Math.abs(currentData.x - last.x) >= 2 ||
+			Math.abs(currentData.y - last.y) >= 2
+		) {
+			return true;
+		}
+
+		// Cursor type değişmişse
+		if (currentData.cursorType !== last.cursorType) {
+			return true;
+		}
+
+		// Hiçbir değişiklik yoksa kaydetme
+		return false;
+	}
+
+	/**
+	 * Cursor capture başlatır - otomatik olarak dosyaya yazmaya başlar
+	 */
+	async startCursorCapture(filepath) {
+		if (!filepath) {
+			throw new Error("File path is required");
+		}
+
+		if (this.cursorCaptureInterval) {
+			throw new Error("Cursor capture is already running");
 		}
 
 		return new Promise((resolve, reject) => {
 			try {
-				const success = nativeBinding.startCursorTracking(outputPath);
-				if (success) {
-					this.emit("cursorTrackingStarted", outputPath);
-					resolve(true);
-				} else {
-					reject(
-						new Error(
-							"Failed to start cursor tracking. Check permissions and try again."
-						)
-					);
-				}
+				// Dosyayı oluştur ve temizle
+				const fs = require("fs");
+				fs.writeFileSync(filepath, "[");
+
+				this.cursorCaptureFile = filepath;
+				this.cursorCaptureStartTime = Date.now();
+				this.cursorCaptureFirstWrite = true;
+				this.lastCapturedData = null;
+
+				// JavaScript interval ile polling yap (daha sık - mouse event'leri yakalamak için)
+				this.cursorCaptureInterval = setInterval(() => {
+					try {
+						const position = nativeBinding.getCursorPosition();
+						const timestamp = Date.now() - this.cursorCaptureStartTime;
+
+						const cursorData = {
+							x: position.x,
+							y: position.y,
+							timestamp: timestamp,
+							cursorType: position.cursorType,
+							type: position.eventType || "move",
+						};
+
+						// Sadece eventType değiştiğinde veya pozisyon değiştiğinde kaydet
+						if (this.shouldCaptureEvent(cursorData)) {
+							// Dosyaya ekle
+							const jsonString = JSON.stringify(cursorData);
+
+							if (this.cursorCaptureFirstWrite) {
+								fs.appendFileSync(filepath, jsonString);
+								this.cursorCaptureFirstWrite = false;
+							} else {
+								fs.appendFileSync(filepath, "," + jsonString);
+							}
+
+							// Son pozisyonu sakla
+							this.lastCapturedData = { ...cursorData };
+						}
+					} catch (error) {
+						console.error("Cursor capture error:", error);
+					}
+				}, 20); // 50 FPS - mouse event'leri yakalamak için daha hızlı
+
+				this.emit("cursorCaptureStarted", filepath);
+				resolve(true);
 			} catch (error) {
 				reject(error);
 			}
@@ -441,18 +519,33 @@ class MacRecorder extends EventEmitter {
 	}
 
 	/**
-	 * Cursor tracking durdurur ve JSON dosyasını kaydeder
+	 * Cursor capture durdurur - dosya yazma işlemini sonlandırır
 	 */
-	async stopCursorTracking() {
+	async stopCursorCapture() {
 		return new Promise((resolve, reject) => {
 			try {
-				const success = nativeBinding.stopCursorTracking();
-				if (success) {
-					this.emit("cursorTrackingStopped");
-					resolve(true);
-				} else {
-					reject(new Error("Failed to stop cursor tracking"));
+				if (!this.cursorCaptureInterval) {
+					return resolve(false);
+				}
+
+				// Interval'ı durdur
+				clearInterval(this.cursorCaptureInterval);
+				this.cursorCaptureInterval = null;
+
+				// Dosyayı kapat
+				if (this.cursorCaptureFile) {
+					const fs = require("fs");
+					fs.appendFileSync(this.cursorCaptureFile, "]");
+					this.cursorCaptureFile = null;
 				}
+
+				// Değişkenleri temizle
+				this.lastCapturedData = null;
+				this.cursorCaptureStartTime = null;
+				this.cursorCaptureFirstWrite = true;
+
+				this.emit("cursorCaptureStopped");
+				resolve(true);
 			} catch (error) {
 				reject(error);
 			}
@@ -471,36 +564,14 @@ class MacRecorder extends EventEmitter {
 	}
 
 	/**
-	 * Cursor tracking durumunu döndürür
+	 * Cursor capture durumunu döndürür
 	 */
-	getCursorTrackingStatus() {
-		try {
-			return nativeBinding.getCursorTrackingStatus();
-		} catch (error) {
-			throw new Error("Failed to get cursor tracking status: " + error.message);
-		}
-	}
-
-	/**
-	 * Cursor verilerini JSON dosyasına kaydeder
-	 */
-	async saveCursorData(outputPath) {
-		if (!outputPath) {
-			throw new Error("Output path is required");
-		}
-
-		return new Promise((resolve, reject) => {
-			try {
-				const success = nativeBinding.saveCursorData(outputPath);
-				if (success) {
-					resolve(true);
-				} else {
-					reject(new Error("Failed to save cursor data"));
-				}
-			} catch (error) {
-				reject(error);
-			}
-		});
+	getCursorCaptureStatus() {
+		return {
+			isCapturing: !!this.cursorCaptureInterval,
+			outputFile: this.cursorCaptureFile || null,
+			startTime: this.cursorCaptureStartTime || null,
+		};
 	}
 
 	/**

package/package.json

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

package/src/cursor_tracker.mm

@@ -8,16 +8,18 @@
 
 // Global state for cursor tracking
 static bool g_isCursorTracking = false;
-static NSMutableArray *g_cursorData = nil;
 static CFMachPortRef g_eventTap = NULL;
 static CFRunLoopSourceRef g_runLoopSource = NULL;
 static NSDate *g_trackingStartTime = nil;
 static NSString *g_outputPath = nil;
 static NSTimer *g_cursorTimer = nil;
 static int g_debugCallbackCount = 0;
+static NSFileHandle *g_fileHandle = nil;
+static bool g_isFirstWrite = true;
 
 // Forward declaration
-void cursorTimerCallback(NSTimer *timer);
+void cursorTimerCallback();
+void writeToFile(NSDictionary *cursorData);
 
 // Timer helper class
 @interface CursorTimerTarget : NSObject
@@ -26,7 +28,7 @@ void cursorTimerCallback(NSTimer *timer);
 
 @implementation CursorTimerTarget
 - (void)timerCallback:(NSTimer *)timer {
-    cursorTimerCallback(timer);
+    cursorTimerCallback();
 }
 @end
 
@@ -36,31 +38,87 @@ static CursorTimerTarget *g_timerTarget = nil;
 static NSString *g_lastDetectedCursorType = nil;
 static int g_cursorTypeCounter = 0;
 
-// Cursor type detection helper
+// Mouse button state tracking
+static bool g_leftMouseDown = false;
+static bool g_rightMouseDown = false;
+static NSString *g_lastEventType = @"move";
+
+// Cursor type detection helper - gerçek cursor type'ı al
 NSString* getCursorType() {
     @autoreleasepool {
         g_cursorTypeCounter++;
         
-        // Simple simulation - cycle through cursor types for demo
-        // Bu gerçek uygulamada daha akıllı olacak
-        int typeIndex = (g_cursorTypeCounter / 6) % 4; // Her 6 call'da değiştir (daha hızlı demo)
-        
-        switch (typeIndex) {
-            case 0:
+        @try {
+            // NSCursor.currentCursor kullanarak gerçek cursor type'ı al
+            NSCursor *currentCursor = [NSCursor currentCursor];
+            
+            if (currentCursor == [NSCursor arrowCursor]) {
                 g_lastDetectedCursorType = @"default";
                 return @"default";
-            case 1:
+            } else if (currentCursor == [NSCursor pointingHandCursor]) {
                 g_lastDetectedCursorType = @"pointer";
                 return @"pointer";
-            case 2:
+            } else if (currentCursor == [NSCursor IBeamCursor]) {
                 g_lastDetectedCursorType = @"text";
                 return @"text";
-            case 3:
+            } else if (currentCursor == [NSCursor openHandCursor]) {
+                g_lastDetectedCursorType = @"grab";
+                return @"grab";
+            } else if (currentCursor == [NSCursor closedHandCursor]) {
                 g_lastDetectedCursorType = @"grabbing";
                 return @"grabbing";
-            default:
+            } else if (currentCursor == [NSCursor resizeLeftRightCursor]) {
+                g_lastDetectedCursorType = @"ew-resize";
+                return @"ew-resize";
+            } else if (currentCursor == [NSCursor resizeUpDownCursor]) {
+                g_lastDetectedCursorType = @"ns-resize";
+                return @"ns-resize";
+            } else if (currentCursor == [NSCursor crosshairCursor]) {
+                g_lastDetectedCursorType = @"crosshair";
+                return @"crosshair";
+            } else {
+                // Bilinmeyen cursor - default olarak dön
                 g_lastDetectedCursorType = @"default";
                 return @"default";
+            }
+        } @catch (NSException *exception) {
+            // Hata durumunda default dön
+            g_lastDetectedCursorType = @"default";
+            return @"default";
+        }
+    }
+}
+
+// Dosyaya yazma helper fonksiyonu
+void writeToFile(NSDictionary *cursorData) {
+    @autoreleasepool {
+        if (!g_fileHandle || !cursorData) {
+            return;
+        }
+        
+        @try {
+            NSError *error;
+            NSData *jsonData = [NSJSONSerialization dataWithJSONObject:cursorData
+                                                               options:0
+                                                                 error:&error];
+            if (jsonData && !error) {
+                NSString *jsonString = [[[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding] autorelease];
+                
+                if (g_isFirstWrite) {
+                    // İlk yazma - array başlat
+                    [g_fileHandle writeData:[@"[" dataUsingEncoding:NSUTF8StringEncoding]];
+                    [g_fileHandle writeData:[jsonString dataUsingEncoding:NSUTF8StringEncoding]];
+                    g_isFirstWrite = false;
+                } else {
+                    // Sonraki yazmalar - virgül + json
+                    [g_fileHandle writeData:[@"," dataUsingEncoding:NSUTF8StringEncoding]];
+                    [g_fileHandle writeData:[jsonString dataUsingEncoding:NSUTF8StringEncoding]];
+                }
+                
+                [g_fileHandle synchronizeFile];
+            }
+        } @catch (NSException *exception) {
+            // Hata durumunda sessizce devam et
         }
     }
 }
@@ -68,7 +126,9 @@ NSString* getCursorType() {
 // Event callback for mouse events
 CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon) {
     @autoreleasepool {
-        if (!g_isCursorTracking || !g_cursorData || !g_trackingStartTime) {
+        g_debugCallbackCount++; // Callback çağrıldığını say
+        
+        if (!g_isCursorTracking || !g_trackingStartTime || !g_fileHandle) {
             return event;
         }
         
@@ -109,21 +169,19 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
             @"type": eventType
         };
         
-        // Thread-safe olarak array'e ekle
-        @synchronized(g_cursorData) {
-            [g_cursorData addObject:cursorInfo];
-        }
+        // Direkt dosyaya yaz
+        writeToFile(cursorInfo);
         
         return event;
     }
 }
 
 // Timer callback for periodic cursor position updates
-void cursorTimerCallback(NSTimer *timer) {
+void cursorTimerCallback() {
     @autoreleasepool {
-        g_debugCallbackCount++;
+        g_debugCallbackCount++; // Timer callback çağrıldığını say
         
-        if (!g_isCursorTracking || !g_cursorData || !g_trackingStartTime) {
+        if (!g_isCursorTracking || !g_trackingStartTime || !g_fileHandle) {
             return;
         }
         
@@ -155,10 +213,8 @@ void cursorTimerCallback(NSTimer *timer) {
             @"type": @"move"
         };
         
-        // Thread-safe olarak array'e ekle
-        @synchronized(g_cursorData) {
-            [g_cursorData addObject:cursorInfo];
-        }
+        // Direkt dosyaya yaz
+        writeToFile(cursorInfo);
     }
 }
 
@@ -166,39 +222,53 @@ void cursorTimerCallback(NSTimer *timer) {
 void cleanupCursorTracking() {
     g_isCursorTracking = false;
     
-    // Timer'ı durdur
+    // Timer temizle
     if (g_cursorTimer) {
         [g_cursorTimer invalidate];
         g_cursorTimer = nil;
     }
     
-    // Timer target'ı temizle
     if (g_timerTarget) {
-        [g_timerTarget release];
+        [g_timerTarget autorelease];
         g_timerTarget = nil;
     }
     
-    // Event tap'i durdur
+    // Dosyayı önce kapat (en önemli işlem)
+    if (g_fileHandle) {
+        @try {
+            if (g_isFirstWrite) {
+                // Hiç veri yazılmamışsa boş array
+                [g_fileHandle writeData:[@"[]" dataUsingEncoding:NSUTF8StringEncoding]];
+            } else {
+                // JSON array'i kapat
+                [g_fileHandle writeData:[@"]" dataUsingEncoding:NSUTF8StringEncoding]];
+            }
+            [g_fileHandle synchronizeFile];
+            [g_fileHandle closeFile];
+        } @catch (NSException *exception) {
+            // Dosya işlemi hata verirse sessizce devam et
+        }
+        g_fileHandle = nil;
+    }
+    
+    // Event tap'i durdur (non-blocking)
     if (g_eventTap) {
         CGEventTapEnable(g_eventTap, false);
-        CFMachPortInvalidate(g_eventTap);
-        CFRelease(g_eventTap);
-        g_eventTap = NULL;
+        g_eventTap = NULL; // CFRelease işlemini yapmıyoruz - system handle etsin
     }
     
-    // Run loop source'unu kaldır
+    // Run loop source'unu kaldır (non-blocking)
     if (g_runLoopSource) {
-        CFRunLoopRemoveSource(CFRunLoopGetCurrent(), g_runLoopSource, kCFRunLoopCommonModes);
-        CFRelease(g_runLoopSource);
-        g_runLoopSource = NULL;
+        g_runLoopSource = NULL; // CFRelease işlemini yapmıyoruz
     }
     
-    g_cursorData = nil;
+    // Global değişkenleri sıfırla
     g_trackingStartTime = nil;
     g_outputPath = nil;
     g_debugCallbackCount = 0;
     g_lastDetectedCursorType = nil;
     g_cursorTypeCounter = 0;
+    g_isFirstWrite = true;
 }
 
 // NAPI Function: Start Cursor Tracking
@@ -217,10 +287,25 @@ Napi::Value StartCursorTracking(const Napi::CallbackInfo& info) {
     std::string outputPath = info[0].As<Napi::String>().Utf8Value();
     
     @try {
-        // Initialize cursor data array
-        g_cursorData = [[NSMutableArray alloc] init];
-        g_trackingStartTime = [NSDate date];
+        // Dosyayı oluştur ve aç
         g_outputPath = [NSString stringWithUTF8String:outputPath.c_str()];
+        g_fileHandle = [[NSFileHandle fileHandleForWritingAtPath:g_outputPath] retain];
+        
+        if (!g_fileHandle) {
+            // Dosya yoksa oluştur
+            [[NSFileManager defaultManager] createFileAtPath:g_outputPath contents:nil attributes:nil];
+            g_fileHandle = [[NSFileHandle fileHandleForWritingAtPath:g_outputPath] retain];
+        }
+        
+        if (!g_fileHandle) {
+            return Napi::Boolean::New(env, false);
+        }
+        
+        // Dosyayı temizle (baştan başla)
+        [g_fileHandle truncateFileAtOffset:0];
+        g_isFirstWrite = true;
+        
+        g_trackingStartTime = [NSDate date];
         
         // Create event tap for mouse events
         CGEventMask eventMask = (CGEventMaskBit(kCGEventLeftMouseDown) |
@@ -244,23 +329,21 @@ Napi::Value StartCursorTracking(const Napi::CallbackInfo& info) {
         if (g_eventTap) {
             // Event tap başarılı - detaylı event tracking aktif
             g_runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, g_eventTap, 0);
-            CFRunLoopAddSource(CFRunLoopGetCurrent(), g_runLoopSource, kCFRunLoopCommonModes);
+            CFRunLoopAddSource(CFRunLoopGetMain(), g_runLoopSource, kCFRunLoopCommonModes);
             CGEventTapEnable(g_eventTap, true);
         }
-        // Event tap başarısız olsa da devam et - sadece timer ile tracking yapar
         
-        // Timer helper oluştur
+        // NSTimer kullan (main thread'de çalışır)
         g_timerTarget = [[CursorTimerTarget alloc] init];
         
-        // NSTimer kullan (ana thread'de çalışır)
-        g_cursorTimer = [NSTimer scheduledTimerWithTimeInterval:0.016667 // ~60 FPS
-                                                         target:g_timerTarget
-                                                       selector:@selector(timerCallback:)
-                                                       userInfo:nil
-                                                        repeats:YES];
+        g_cursorTimer = [NSTimer timerWithTimeInterval:0.05 // 50ms (20 FPS)
+                                                target:g_timerTarget
+                                              selector:@selector(timerCallback:)
+                                              userInfo:nil
+                                               repeats:YES];
         
-        // Timer'ı farklı run loop mode'larında da çalıştır
-        [[NSRunLoop currentRunLoop] addTimer:g_cursorTimer forMode:NSRunLoopCommonModes];
+        // Main run loop'a ekle
+        [[NSRunLoop mainRunLoop] addTimer:g_cursorTimer forMode:NSRunLoopCommonModes];
         
         g_isCursorTracking = true;
         return Napi::Boolean::New(env, true);
@@ -280,19 +363,6 @@ Napi::Value StopCursorTracking(const Napi::CallbackInfo& info) {
     }
     
     @try {
-        // JSON dosyasını kaydet
-        if (g_cursorData && g_outputPath) {
-            @synchronized(g_cursorData) {
-                NSError *error;
-                NSData *jsonData = [NSJSONSerialization dataWithJSONObject:g_cursorData
-                                                                   options:NSJSONWritingPrettyPrinted
-                                                                     error:&error];
-                if (jsonData && !error) {
-                    [jsonData writeToFile:g_outputPath atomically:YES];
-                }
-            }
-        }
-        
         cleanupCursorTracking();
         return Napi::Boolean::New(env, true);
         
@@ -319,10 +389,39 @@ Napi::Value GetCursorPosition(const Napi::CallbackInfo& info) {
         
         NSString *cursorType = getCursorType();
         
+        // Mouse button state'ini kontrol et
+        bool currentLeftMouseDown = CGEventSourceButtonState(kCGEventSourceStateHIDSystemState, kCGMouseButtonLeft);
+        bool currentRightMouseDown = CGEventSourceButtonState(kCGEventSourceStateHIDSystemState, kCGMouseButtonRight);
+        
+        NSString *eventType = @"move";
+        
+        // Mouse button state değişikliklerini tespit et
+        if (currentLeftMouseDown && !g_leftMouseDown) {
+            eventType = @"mousedown";
+            g_lastEventType = @"mousedown";
+        } else if (!currentLeftMouseDown && g_leftMouseDown) {
+            eventType = @"mouseup";
+            g_lastEventType = @"mouseup";
+        } else if (currentRightMouseDown && !g_rightMouseDown) {
+            eventType = @"rightmousedown";
+            g_lastEventType = @"rightmousedown";
+        } else if (!currentRightMouseDown && g_rightMouseDown) {
+            eventType = @"rightmouseup";
+            g_lastEventType = @"rightmouseup";
+        } else {
+            eventType = @"move";
+            g_lastEventType = @"move";
+        }
+        
+        // State'i güncelle
+        g_leftMouseDown = currentLeftMouseDown;
+        g_rightMouseDown = currentRightMouseDown;
+        
         Napi::Object result = Napi::Object::New(env);
         result.Set("x", Napi::Number::New(env, (int)location.x));
         result.Set("y", Napi::Number::New(env, (int)location.y));
         result.Set("cursorType", Napi::String::New(env, [cursorType UTF8String]));
+        result.Set("eventType", Napi::String::New(env, [eventType UTF8String]));
         
         return result;
         
@@ -337,63 +436,22 @@ Napi::Value GetCursorTrackingStatus(const Napi::CallbackInfo& info) {
     
     Napi::Object result = Napi::Object::New(env);
     result.Set("isTracking", Napi::Boolean::New(env, g_isCursorTracking));
-    
-    NSUInteger dataCount = 0;
-    if (g_cursorData) {
-        @synchronized(g_cursorData) {
-            dataCount = [g_cursorData count];
-        }
-    }
-    
-    result.Set("dataCount", Napi::Number::New(env, (int)dataCount));
     result.Set("hasEventTap", Napi::Boolean::New(env, g_eventTap != NULL));
     result.Set("hasRunLoopSource", Napi::Boolean::New(env, g_runLoopSource != NULL));
+    result.Set("hasFileHandle", Napi::Boolean::New(env, g_fileHandle != NULL));
+    result.Set("hasTimer", Napi::Boolean::New(env, g_cursorTimer != NULL));
     result.Set("debugCallbackCount", Napi::Number::New(env, g_debugCallbackCount));
     result.Set("cursorTypeCounter", Napi::Number::New(env, g_cursorTypeCounter));
     
     return result;
 }
 
-// NAPI Function: Save Cursor Data
-Napi::Value SaveCursorData(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (info.Length() < 1) {
-        Napi::TypeError::New(env, "Output path required").ThrowAsJavaScriptException();
-        return env.Null();
-    }
-    
-    std::string outputPath = info[0].As<Napi::String>().Utf8Value();
-    
-    @try {
-        if (g_cursorData) {
-            @synchronized(g_cursorData) {
-                NSError *error;
-                NSData *jsonData = [NSJSONSerialization dataWithJSONObject:g_cursorData
-                                                                   options:NSJSONWritingPrettyPrinted
-                                                                     error:&error];
-                if (jsonData && !error) {
-                    NSString *filePath = [NSString stringWithUTF8String:outputPath.c_str()];
-                    BOOL success = [jsonData writeToFile:filePath atomically:YES];
-                    return Napi::Boolean::New(env, success);
-                }
-            }
-        }
-        
-        return Napi::Boolean::New(env, false);
-        
-    } @catch (NSException *exception) {
-        return Napi::Boolean::New(env, false);
-    }
-}
-
 // Export functions
 Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports) {
     exports.Set("startCursorTracking", Napi::Function::New(env, StartCursorTracking));
     exports.Set("stopCursorTracking", Napi::Function::New(env, StopCursorTracking));
     exports.Set("getCursorPosition", Napi::Function::New(env, GetCursorPosition));
     exports.Set("getCursorTrackingStatus", Napi::Function::New(env, GetCursorTrackingStatus));
-    exports.Set("saveCursorData", Napi::Function::New(env, SaveCursorData));
     
     return exports;
 } 

package/manual-cursor-data.json

@@ -1,352 +0,0 @@
-[
-  {
-    "x": 1195,
-    "y": 590,
-    "timestamp": 36,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1195,
-    "y": 590,
-    "timestamp": 136,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1195,
-    "y": 590,
-    "timestamp": 237,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1195,
-    "y": 590,
-    "timestamp": 340,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1210,
-    "y": 590,
-    "timestamp": 441,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1228,
-    "y": 591,
-    "timestamp": 542,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1233,
-    "y": 593,
-    "timestamp": 644,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1234,
-    "y": 593,
-    "timestamp": 746,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1234,
-    "y": 613,
-    "timestamp": 849,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1231,
-    "y": 696,
-    "timestamp": 951,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1231,
-    "y": 758,
-    "timestamp": 1053,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1232,
-    "y": 771,
-    "timestamp": 1156,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1232,
-    "y": 771,
-    "timestamp": 1257,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1232,
-    "y": 771,
-    "timestamp": 1359,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1235,
-    "y": 782,
-    "timestamp": 1460,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1251,
-    "y": 806,
-    "timestamp": 1562,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1266,
-    "y": 827,
-    "timestamp": 1664,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1268,
-    "y": 838,
-    "timestamp": 1766,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1265,
-    "y": 853,
-    "timestamp": 1867,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1252,
-    "y": 877,
-    "timestamp": 1969,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1240,
-    "y": 904,
-    "timestamp": 2070,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1232,
-    "y": 920,
-    "timestamp": 2173,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1229,
-    "y": 929,
-    "timestamp": 2274,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1228,
-    "y": 931,
-    "timestamp": 2375,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1225,
-    "y": 936,
-    "timestamp": 2476,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1222,
-    "y": 941,
-    "timestamp": 2577,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1219,
-    "y": 945,
-    "timestamp": 2679,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1217,
-    "y": 947,
-    "timestamp": 2781,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1214,
-    "y": 951,
-    "timestamp": 2882,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1214,
-    "y": 951,
-    "timestamp": 2983,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1219,
-    "y": 937,
-    "timestamp": 3084,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1224,
-    "y": 928,
-    "timestamp": 3185,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1227,
-    "y": 923,
-    "timestamp": 3286,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1229,
-    "y": 919,
-    "timestamp": 3390,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1233,
-    "y": 910,
-    "timestamp": 3491,
-    "cursorType": "pointer",
-    "type": "move"
-  },
-  {
-    "x": 1234,
-    "y": 907,
-    "timestamp": 3592,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1236,
-    "y": 904,
-    "timestamp": 3694,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1236,
-    "y": 904,
-    "timestamp": 3795,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1236,
-    "y": 904,
-    "timestamp": 3898,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1236,
-    "y": 904,
-    "timestamp": 3999,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1236,
-    "y": 904,
-    "timestamp": 4101,
-    "cursorType": "text",
-    "type": "move"
-  },
-  {
-    "x": 1236,
-    "y": 904,
-    "timestamp": 4203,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1236,
-    "y": 903,
-    "timestamp": 4304,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1229,
-    "y": 964,
-    "timestamp": 4406,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1220,
-    "y": 991,
-    "timestamp": 4507,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1217,
-    "y": 1004,
-    "timestamp": 4609,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1217,
-    "y": 1005,
-    "timestamp": 4709,
-    "cursorType": "grabbing",
-    "type": "move"
-  },
-  {
-    "x": 1215,
-    "y": 1014,
-    "timestamp": 4810,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1214,
-    "y": 1025,
-    "timestamp": 4912,
-    "cursorType": "default",
-    "type": "move"
-  },
-  {
-    "x": 1214,
-    "y": 1025,
-    "timestamp": 5015,
-    "cursorType": "default",
-    "type": "move"
-  }
-]