node-mac-recorder 2.22.14 → 2.22.16

package/index.js

@@ -1,6 +1,7 @@
 const { EventEmitter } = require("events");
 const path = require("path");
 const fs = require("fs");
+const cursorCapturePolling = require("./lib/cursorCapture/polling");
 
 // Auto-switch to Electron-safe implementation when running under Electron and binary exists
 let USE_ELECTRON_SAFE = false;
@@ -1340,365 +1341,17 @@ class MacRecorder extends EventEmitter {
 		});
 	}
 
-	/**
-	 * Event'in kaydedilip kaydedilmeyeceğini belirler
-	 */
-	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;
-	}
-
-	/**
-	 * Unified cursor capture for all recording types - uses video-relative coordinates
-	 * @param {string|number} intervalOrFilepath - Cursor data JSON dosya yolu veya interval
-	 * @param {Object} options - Cursor capture seçenekleri
-	 * @param {boolean} options.videoRelative - Use video-relative coordinates (recommended)
-	 * @param {Object} options.displayInfo - Display information for coordinate transformation
-	 * @param {string} options.recordingType - Type of recording: 'display', 'window', 'area'
-	 * @param {Object} options.captureArea - Capture area for area recording coordinate transformation
-	 * @param {number} options.windowId - Window ID for window recording coordinate transformation
-	 * @param {number} options.startTimestamp - Pre-defined start timestamp for synchronization (optional)
-	 */
 	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;
-		} else {
-			throw new Error(
-				"Parameter must be interval (number) or filepath (string)"
-			);
-		}
-
-		if (this.cursorCaptureInterval) {
-			throw new Error("Cursor capture is already running");
-		}
-
-		// SYNC FIX: Use pre-defined timestamp if provided for synchronization
-		const syncStartTime = options.startTimestamp || Date.now();
-
-		// Fetch window bounds for multi-window recording
-		if (options.multiWindowBounds && options.multiWindowBounds.length > 0) {
-			try {
-				const allWindows = await this.getWindows();
-				// Match window IDs and populate bounds
-				for (const windowInfo of options.multiWindowBounds) {
-					const windowData = allWindows.find(w => w.id === windowInfo.windowId);
-					if (windowData) {
-						windowInfo.bounds = {
-							x: windowData.x || 0,
-							y: windowData.y || 0,
-							width: windowData.width || 0,
-							height: windowData.height || 0
-						};
-					}
-				}
-			} catch (error) {
-				console.warn('Failed to fetch window bounds for multi-window cursor tracking:', error.message);
-			}
-		}
-
-		// Use video-relative coordinate system for all recording types
-		if (options.videoRelative && options.displayInfo) {
-			// Calculate video offset based on recording type
-			let videoOffsetX = 0;
-			let videoOffsetY = 0;
-			let videoWidth = options.displayInfo.width || options.displayInfo.logicalWidth;
-			let videoHeight = options.displayInfo.height || options.displayInfo.logicalHeight;
-
-			if (options.recordingType === 'window' && options.windowId) {
-				// For window recording: offset = window position in display
-				if (options.captureArea) {
-					videoOffsetX = options.captureArea.x;
-					videoOffsetY = options.captureArea.y;
-					videoWidth = options.captureArea.width;
-					videoHeight = options.captureArea.height;
-				}
-			} else if (options.recordingType === 'area' && options.captureArea) {
-				// For area recording: offset = area position in display
-				videoOffsetX = options.captureArea.x;
-				videoOffsetY = options.captureArea.y;
-				videoWidth = options.captureArea.width;
-				videoHeight = options.captureArea.height;
-			}
-			// For display recording: offset remains 0,0
-
-			this.cursorDisplayInfo = {
-				displayId: options.displayInfo.displayId || options.displayInfo.id,
-				displayX: options.displayInfo.x || 0,
-				displayY: options.displayInfo.y || 0,
-				displayWidth: options.displayInfo.width || options.displayInfo.logicalWidth,
-				displayHeight: options.displayInfo.height || options.displayInfo.logicalHeight,
-				videoOffsetX: videoOffsetX,
-				videoOffsetY: videoOffsetY,
-				videoWidth: videoWidth,
-				videoHeight: videoHeight,
-				videoRelative: true,
-				recordingType: options.recordingType || 'display',
-				// Store additional context for debugging
-				captureArea: options.captureArea,
-				windowId: options.windowId,
-				// Multi-window bounds for location detection
-				multiWindowBounds: options.multiWindowBounds || null
-			};
-		} else if (this.recordingDisplayInfo) {
-			// Fallback: Use recording display info if available
-			this.cursorDisplayInfo = {
-				...this.recordingDisplayInfo,
-				displayX: this.recordingDisplayInfo.x || 0,
-				displayY: this.recordingDisplayInfo.y || 0,
-				displayWidth: this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth,
-				displayHeight: this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight,
-				videoOffsetX: 0,
-				videoOffsetY: 0,
-				videoWidth: this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth,
-				videoHeight: this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight,
-				videoRelative: true,
-				recordingType: options.recordingType || 'display',
-				multiWindowBounds: options.multiWindowBounds || null
-			};
-		} 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]),
-						multiWindowBounds: options.multiWindowBounds || null
-					};
-				}
-			} catch (error) {
-				console.warn("Main display bilgisi alınamadı:", error.message);
-				this.cursorDisplayInfo = null; // Fallback: global koordinatlar
-			}
-		}
-
-		return new Promise((resolve, reject) => {
-			try {
-				// Dosyayı oluştur ve temizle
-				const fs = require("fs");
-				fs.writeFileSync(filepath, "[");
-
-				this.cursorCaptureFile = filepath;
-				// SYNC FIX: Use synchronized start time for accurate timestamp calculation
-				this.cursorCaptureStartTime = syncStartTime;
-				this.cursorCaptureFirstWrite = true;
-				this.lastCapturedData = null;
-				// Store session timestamp for sync metadata
-				this.cursorCaptureSessionTimestamp = this.sessionTimestamp;
-
-				// 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;
-
-						// Video-relative coordinate transformation for all recording types
-						let x = position.x;
-						let y = position.y;
-						let coordinateSystem = "global";
-
-						// Apply video-relative transformation for all recording types
-						if (this.cursorDisplayInfo && this.cursorDisplayInfo.videoRelative) {
-							// 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 ||
-								x >= this.cursorDisplayInfo.videoWidth ||
-								y >= this.cursorDisplayInfo.videoHeight;
-
-							// For debugging - add metadata if cursor is outside video area
-							if (outsideVideo) {
-								coordinateSystem = "video-relative-outside";
-							}
-						}
-
-						const cursorData = {
-							x: x,
-							y: y,
-							timestamp: timestamp,
-							unixTimeMs: Date.now(),
-							cursorType: position.cursorType,
-							type: position.eventType || "move",
-							coordinateSystem: coordinateSystem,
-							// Video-relative metadata for all recording types
-							recordingType: this.cursorDisplayInfo?.recordingType || "display",
-							videoInfo: this.cursorDisplayInfo ? {
-								width: this.cursorDisplayInfo.videoWidth,
-								height: this.cursorDisplayInfo.videoHeight,
-								offsetX: this.cursorDisplayInfo.videoOffsetX,
-								offsetY: this.cursorDisplayInfo.videoOffsetY
-							} : {},
-							displayInfo: this.cursorDisplayInfo ? {
-								displayId: this.cursorDisplayInfo.displayId,
-								width: this.cursorDisplayInfo.displayWidth,
-								height: this.cursorDisplayInfo.displayHeight
-							} : {}
-						};
-
-						// Multi-window location detection with window-relative coordinates
-						if (this.cursorDisplayInfo?.multiWindowBounds && this.cursorDisplayInfo.multiWindowBounds.length > 0) {
-							const location = { hover: null, click: null };
-							let windowRelativeCoords = null;
-
-							// Detect which window the cursor is over
-							for (const windowInfo of this.cursorDisplayInfo.multiWindowBounds) {
-								if (windowInfo.bounds) {
-									const { x: wx, y: wy, width: ww, height: wh } = windowInfo.bounds;
-									// Check if cursor is inside window bounds (using global coordinates)
-									if (position.x >= wx && position.x <= wx + ww &&
-										position.y >= wy && position.y <= wy + wh) {
-										location.hover = windowInfo.windowId;
-
-										// Calculate window-relative coordinates
-										// These coords are relative to the window's top-left corner (0,0)
-										// This allows the desktop app to position cursor correctly
-										// regardless of where the window is placed on canvas
-										windowRelativeCoords = {
-											windowId: windowInfo.windowId,
-											x: position.x - wx,
-											y: position.y - wy,
-											// Also include window dimensions for reference
-											windowWidth: ww,
-											windowHeight: wh
-										};
-
-										// If this is a click/drag event, mark click location
-										// Native eventType values: 'mousedown', 'mouseup', 'drag', 'rightmousedown', 'rightmouseup', 'rightdrag'
-										const eventType = position.eventType || '';
-										if (eventType === 'mousedown' ||
-											eventType === 'mouseup' ||
-											eventType === 'drag' ||
-											eventType === 'rightmousedown' ||
-											eventType === 'rightmouseup' ||
-											eventType === 'rightdrag') {
-											location.click = windowInfo.windowId;
-										}
-										break; // Found the window, stop searching
-									}
-								}
-							}
-
-							// Add location info to cursor data
-							cursorData.location = location;
-
-							// Add window-relative coordinates if cursor is over a window
-							if (windowRelativeCoords) {
-								cursorData.windowRelative = windowRelativeCoords;
-							}
-						}
-
-						// Add sync metadata to first event only
-						if (this.cursorCaptureFirstWrite && this.cursorCaptureSessionTimestamp) {
-							cursorData._syncMetadata = {
-								videoStartTime: this.cursorCaptureSessionTimestamp,
-								cursorStartTime: this.cursorCaptureStartTime,
-								offsetMs: this.cursorCaptureStartTime - this.cursorCaptureSessionTimestamp
-							};
-						}
-
-						// 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);
-			}
-		});
+		return cursorCapturePolling.startCursorCapture(
+			this,
+			nativeBinding,
+			intervalOrFilepath,
+			options,
+		);
 	}
 
-	/**
-	 * Cursor capture durdurur - dosya yazma işlemini sonlandırır
-	 */
 	async stopCursorCapture() {
-		return new Promise((resolve, reject) => {
-			try {
-				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.cursorDisplayInfo = null;
-
-				this.emit("cursorCaptureStopped");
-				resolve(true);
-			} catch (error) {
-				reject(error);
-			}
-		});
+		return cursorCapturePolling.stopCursorCapture(this);
 	}
 
 	/**

package/lib/cursorCapture/displayInfo.js

@@ -0,0 +1,110 @@
+"use strict";
+
+async function resolveCursorDisplayInfo(recorder, options) {
+	if (options.videoRelative && options.displayInfo) {
+		let videoOffsetX = 0;
+		let videoOffsetY = 0;
+		let videoWidth =
+			options.displayInfo.width || options.displayInfo.logicalWidth;
+		let videoHeight =
+			options.displayInfo.height || options.displayInfo.logicalHeight;
+
+		if (options.recordingType === "window" && options.windowId) {
+			if (options.captureArea) {
+				videoOffsetX = options.captureArea.x;
+				videoOffsetY = options.captureArea.y;
+				videoWidth = options.captureArea.width;
+				videoHeight = options.captureArea.height;
+			}
+		} else if (options.recordingType === "area" && options.captureArea) {
+			videoOffsetX = options.captureArea.x;
+			videoOffsetY = options.captureArea.y;
+			videoWidth = options.captureArea.width;
+			videoHeight = options.captureArea.height;
+		}
+
+		recorder.cursorDisplayInfo = {
+			displayId: options.displayInfo.displayId || options.displayInfo.id,
+			displayX: options.displayInfo.x || 0,
+			displayY: options.displayInfo.y || 0,
+			displayWidth:
+				options.displayInfo.width || options.displayInfo.logicalWidth,
+			displayHeight:
+				options.displayInfo.height || options.displayInfo.logicalHeight,
+			videoOffsetX,
+			videoOffsetY,
+			videoWidth,
+			videoHeight,
+			videoRelative: true,
+			recordingType: options.recordingType || "display",
+			captureArea: options.captureArea,
+			windowId: options.windowId,
+			multiWindowBounds: options.multiWindowBounds || null,
+		};
+		return;
+	}
+
+	if (recorder.recordingDisplayInfo) {
+		recorder.cursorDisplayInfo = {
+			...recorder.recordingDisplayInfo,
+			displayX: recorder.recordingDisplayInfo.x || 0,
+			displayY: recorder.recordingDisplayInfo.y || 0,
+			displayWidth:
+				recorder.recordingDisplayInfo.width ||
+				recorder.recordingDisplayInfo.logicalWidth,
+			displayHeight:
+				recorder.recordingDisplayInfo.height ||
+				recorder.recordingDisplayInfo.logicalHeight,
+			videoOffsetX: 0,
+			videoOffsetY: 0,
+			videoWidth:
+				recorder.recordingDisplayInfo.width ||
+				recorder.recordingDisplayInfo.logicalWidth,
+			videoHeight:
+				recorder.recordingDisplayInfo.height ||
+				recorder.recordingDisplayInfo.logicalHeight,
+			videoRelative: true,
+			recordingType: options.recordingType || "display",
+			multiWindowBounds: options.multiWindowBounds || null,
+		};
+		return;
+	}
+
+	try {
+		const displays = await recorder.getDisplays();
+		const mainDisplay =
+			displays.find((d) => d.isPrimary) || displays[0];
+		if (mainDisplay) {
+			let w = mainDisplay.width;
+			let h = mainDisplay.height;
+			const res = mainDisplay.resolution;
+			if ((w == null || h == null) && res) {
+				const parts = String(res).split("x");
+				if (w == null) {
+					w = parseInt(parts[0], 10);
+				}
+				if (h == null) {
+					h = parseInt(parts[1], 10);
+				}
+			}
+			if (!Number.isFinite(w) || w <= 0) {
+				w = 1920;
+			}
+			if (!Number.isFinite(h) || h <= 0) {
+				h = 1080;
+			}
+			recorder.cursorDisplayInfo = {
+				displayId: mainDisplay.id,
+				x: mainDisplay.x,
+				y: mainDisplay.y,
+				width: w,
+				height: h,
+				multiWindowBounds: options.multiWindowBounds || null,
+			};
+		}
+	} catch {
+		recorder.cursorDisplayInfo = null;
+	}
+}
+
+module.exports = { resolveCursorDisplayInfo };