node-mac-recorder 2.17.21 → 2.18.0

package/cursor-data-1751364226346.json

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

package/cursor-data-1751364314136.json

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

package/cursor-data.json

@@ -0,0 +1 @@
+[{"x":1151,"y":726,"timestamp":20,"cursorType":"text","type":"move"}

package/index.js

@@ -359,10 +359,53 @@ class MacRecorder extends EventEmitter {
 					// Start cursor tracking automatically with recording
 					let cursorOptions = {};
 
-					// 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);
-					});
+					// 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);
+						});
+					}
 
 					// Timer başlat (progress tracking için)
 					this.recordingTimer = setInterval(() => {
@@ -456,11 +499,9 @@ class MacRecorder extends EventEmitter {
 
 				// Stop cursor tracking automatically
 				if (this.cursorCaptureInterval) {
-					try {
-						this.stopCursorCapture();
-					} catch (cursorError) {
+					this.stopCursorCapture().catch(cursorError => {
 						console.warn('Cursor tracking failed to stop:', cursorError.message);
-					}
+					});
 				}
 
 				// Timer durdur
@@ -647,9 +688,11 @@ class MacRecorder extends EventEmitter {
 	 */
 	async startCursorCapture(intervalOrFilepath = 100, options = {}) {
 		let filepath;
+		let interval = 20; // Default 50 FPS
 
 		// Parameter parsing: number = interval, string = filepath
 		if (typeof intervalOrFilepath === "number") {
+			interval = Math.max(10, intervalOrFilepath); // Min 10ms
 			filepath = `cursor-data-${Date.now()}.json`;
 		} else if (typeof intervalOrFilepath === "string") {
 			filepath = intervalOrFilepath;
@@ -663,65 +706,215 @@ class MacRecorder extends EventEmitter {
 			throw new Error("Cursor capture is already running");
 		}
 
-		return new Promise((resolve, reject) => {
-			try {
-				// Native cursor tracking kullan - hem screen hem window için aynı yöntem
-				const success = nativeBinding.startCursorTracking(filepath);
+		// Koordinat sistemi belirle: window-relative, display-relative veya global
+		if (options.windowRelative && options.windowInfo) {
+			const windowInfo = options.windowInfo;
+			const targetDisplay = windowInfo.targetDisplay || this.recordingDisplayInfo || null;
+			const captureArea = windowInfo.captureArea || null;
+			const hasNumber = (value) => typeof value === "number" && Number.isFinite(value);
 
-				if (success) {
-					this.cursorCaptureFile = filepath;
-					this.cursorCaptureStartTime = Date.now();
-					this.cursorCaptureInterval = true; // Mark as active
+			let globalX = hasNumber(windowInfo.x) ? windowInfo.x : null;
+			let globalY = hasNumber(windowInfo.y) ? windowInfo.y : null;
 
-					this.emit("cursorCaptureStarted", {
-						filepath: filepath,
-						timestamp: Date.now()
-					});
+			if (captureArea && targetDisplay) {
+				if (!hasNumber(globalX) && hasNumber(captureArea.x) && hasNumber(targetDisplay.x)) {
+					globalX = targetDisplay.x + captureArea.x;
+				}
+				if (!hasNumber(globalY) && hasNumber(captureArea.y) && hasNumber(targetDisplay.y)) {
+					globalY = targetDisplay.y + captureArea.y;
+				}
+			}
 
-					resolve({
-						filepath: filepath,
-						started: true
-					});
+			if (!hasNumber(globalX)) {
+				if (captureArea && hasNumber(captureArea.x) && targetDisplay && hasNumber(targetDisplay.x)) {
+					globalX = targetDisplay.x + captureArea.x;
 				} else {
-					reject(new Error("Failed to start native cursor tracking"));
+					globalX = hasNumber(captureArea?.x) ? captureArea.x : 0;
 				}
-			} catch (error) {
-				reject(error);
 			}
-		});
-	}
 
-	/**
-	 * Cursor capture durdurur - dosya yazma işlemini sonlandırır
-	 */
-	stopCursorCapture() {
-		if (!this.cursorCaptureInterval) {
-			return false;
+			if (!hasNumber(globalY)) {
+				if (captureArea && hasNumber(captureArea.y) && targetDisplay && hasNumber(targetDisplay.y)) {
+					globalY = targetDisplay.y + captureArea.y;
+				} else {
+					globalY = hasNumber(captureArea?.y) ? captureArea.y : 0;
+				}
+			}
+
+			const displayOffsetX = captureArea && hasNumber(captureArea.x)
+				? captureArea.x
+				: (targetDisplay && hasNumber(globalX) && hasNumber(targetDisplay.x)
+					? globalX - targetDisplay.x
+					: globalX);
+			const displayOffsetY = captureArea && hasNumber(captureArea.y)
+				? captureArea.y
+				: (targetDisplay && hasNumber(globalY) && hasNumber(targetDisplay.y)
+					? globalY - targetDisplay.y
+					: globalY);
+
+			this.cursorDisplayInfo = {
+				displayId:
+					windowInfo.displayId ??
+					targetDisplay?.displayId ??
+					targetDisplay?.id ??
+					null,
+				x: globalX,
+				y: globalY,
+				width: windowInfo.width,
+				height: windowInfo.height,
+				windowRelative: true,
+				windowInfo: {
+					...windowInfo,
+					globalX,
+					globalY,
+					displayOffsetX,
+					displayOffsetY
+				},
+				targetDisplay,
+				captureArea
+			};
+		} else if (options.displayRelative && options.displayInfo) {
+			// Display recording: Use display-relative coordinates
+			this.cursorDisplayInfo = {
+				displayId: options.displayInfo.displayId,
+				x: options.displayInfo.x,
+				y: options.displayInfo.y,
+				width: options.displayInfo.width,
+				height: options.displayInfo.height,
+				displayRelative: true
+			};
+		} else if (this.recordingDisplayInfo) {
+			// Fallback: Use recording display info if available
+			this.cursorDisplayInfo = this.recordingDisplayInfo;
+		} else {
+			// Final fallback: Main display global coordinates
+			try {
+				const displays = await this.getDisplays();
+				const mainDisplay = displays.find((d) => d.isPrimary) || displays[0];
+				if (mainDisplay) {
+					this.cursorDisplayInfo = {
+						displayId: mainDisplay.id,
+						x: mainDisplay.x,
+						y: mainDisplay.y,
+						width: parseInt(mainDisplay.resolution.split("x")[0]),
+						height: parseInt(mainDisplay.resolution.split("x")[1]),
+					};
+				}
+			} catch (error) {
+				console.warn("Main display bilgisi alınamadı:", error.message);
+				this.cursorDisplayInfo = null; // Fallback: global koordinatlar
+			}
 		}
 
-		try {
-			// Native cursor tracking'i durdur
-			const success = nativeBinding.stopCursorTracking();
+		return new Promise((resolve, reject) => {
+			try {
+				// Dosyayı oluştur ve temizle
+				const fs = require("fs");
+				fs.writeFileSync(filepath, "[");
 
-			this.cursorCaptureInterval = null;
-			this.cursorCaptureFile = null;
-			this.cursorCaptureStartTime = null;
+				this.cursorCaptureFile = filepath;
+				this.cursorCaptureStartTime = Date.now();
+				this.cursorCaptureFirstWrite = true;
+				this.lastCapturedData = null;
 
-			this.emit("cursorCaptureStopped", {
-				timestamp: Date.now()
-			});
+				// 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;
+
+						// Transform coordinates based on recording type
+						let x = position.x;
+						let y = position.y;
+						let coordinateSystem = "global";
+
+						if (this.cursorDisplayInfo) {
+							if (this.cursorDisplayInfo.windowRelative) {
+								// Window recording: Transform global → window-relative coordinates
+								x = position.x - this.cursorDisplayInfo.x;
+								y = position.y - this.cursorDisplayInfo.y;
+								coordinateSystem = "window-relative";
+
+								// Window bounds check - skip if cursor is outside window
+								if (x < 0 || y < 0 || x >= this.cursorDisplayInfo.width || y >= this.cursorDisplayInfo.height) {
+									return; // Skip frame - cursor outside window
+								}
+							} else if (this.cursorDisplayInfo.displayRelative) {
+								// Display recording: Transform global → display-relative coordinates
+								x = position.x - this.cursorDisplayInfo.x;
+								y = position.y - this.cursorDisplayInfo.y;
+								coordinateSystem = "display-relative";
+
+								// Display bounds check - skip if cursor is outside display
+								if (x < 0 || y < 0 || x >= this.cursorDisplayInfo.width || y >= this.cursorDisplayInfo.height) {
+									return; // Skip frame - cursor outside display
+								}
+							} else {
+								// Legacy fallback: Use global coordinates with basic offset
+								x = position.x - this.cursorDisplayInfo.x;
+								y = position.y - this.cursorDisplayInfo.y;
+								coordinateSystem = "display-relative";
+							}
+						}
 
-			return success;
-		} catch (error) {
-			console.warn("Error stopping cursor tracking:", error.message);
-			return false;
-		}
+						const cursorData = {
+							x: x,
+							y: y,
+							timestamp: timestamp,
+							unixTimeMs: Date.now(),
+							cursorType: position.cursorType,
+							type: position.eventType || "move",
+							coordinateSystem: coordinateSystem,
+							// Include recording context for window-relative coordinates
+							...(this.cursorDisplayInfo?.windowRelative && {
+								windowInfo: {
+									width: this.cursorDisplayInfo.width,
+									height: this.cursorDisplayInfo.height,
+									displayId: this.cursorDisplayInfo.displayId
+								}
+							}),
+							// Include display context for display-relative coordinates
+							...(this.cursorDisplayInfo?.displayRelative && {
+								displayInfo: {
+									displayId: this.cursorDisplayInfo.displayId,
+									width: this.cursorDisplayInfo.width,
+									height: this.cursorDisplayInfo.height
+								}
+							})
+						};
+
+						// 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);
+					}
+				}, interval); // Configurable FPS
+
+				this.emit("cursorCaptureStarted", filepath);
+				resolve(true);
+			} catch (error) {
+				reject(error);
+			}
+		});
 	}
 
 	/**
-	 * LEGACY: Eski JS-based cursor capture durdurmak için geriye uyumluluk
+	 * Cursor capture durdurur - dosya yazma işlemini sonlandırır
 	 */
-	async _legacyStopCursorCapture() {
+	async stopCursorCapture() {
 		return new Promise((resolve, reject) => {
 			try {
 				if (!this.cursorCaptureInterval) {

package/package.json

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

package/publish.sh

@@ -3,6 +3,37 @@
 # Publish script for node-mac-recorder
 # Usage: ./publish.sh <patch|minor|major> "commit message"
 
+# Clean up development files before publishing
+echo "🧹 Cleaning up development files..."
+
+# Remove video files
+echo "   • Removing .mov and .mp4 files..."
+find . -name "*.mov" -type f -delete 2>/dev/null
+find . -name "*.mp4" -type f -delete 2>/dev/null
+
+# Remove files containing specific keywords
+echo "   • Removing files containing test, debug, example, demo, sample..."
+find . -type f -not -path "./node_modules/*" \( \
+    -name "*test*" -o \
+    -name "*debug*" -o \
+    -name "*example*" -o \
+    -name "*demo*" -o \
+    -name "*sample*" \
+\) -delete 2>/dev/null
+
+# Remove folders containing specific keywords
+echo "   • Removing folders containing test, debug, example, demo, sample..."
+find . -type d -not -path "./node_modules/*" \( \
+    -name "*test*" -o \
+    -name "*debug*" -o \
+    -name "*example*" -o \
+    -name "*demo*" -o \
+    -name "*sample*" \
+\) -exec rm -rf {} + 2>/dev/null
+
+echo "✅ Cleanup completed"
+echo ""
+
 # Check if correct number of arguments provided
 if [ $# -ne 2 ]; then
     echo "❌ Usage: $0 <patch|minor|major> \"commit message\""
@@ -26,24 +57,6 @@ if ! git rev-parse --git-dir > /dev/null 2>&1; then
     exit 1
 fi
 
-# Clean up test files and video files before publishing
-echo "🧹 Cleaning up test files and video files..."
-
-# Remove video files (MP4, MOV, AVI, etc.)
-find . -maxdepth 1 -type f \( -name "*.mp4" -o -name "*.mov" -o -name "*.avi" -o -name "*.mkv" -o -name "*.webm" \) -delete
-
-# Remove test output directories
-rm -rf test-output debug-output
-
-# Remove test files and temporary files
-find . -maxdepth 1 -type f \( -name "*test*.json" -o -name "*debug*.json" -o -name "*cursor*.json" -o -name "temp-*" -o -name "*-temp.*" -o -name "*.tmp" \) -delete
-
-# Remove test JavaScript files that shouldn't be published
-find . -maxdepth 1 -type f -name "*test*.js" ! -name "test.js" -delete
-find . -maxdepth 1 -type f -name "*debug*.js" -delete
-
-echo "✅ Cleanup completed"
-
 # Check if there are uncommitted changes
 if ! git diff --quiet || ! git diff --cached --quiet; then
     echo "📁 Adding all changes to git..."