node-mac-recorder 2.22.24 → 2.22.33

package/index.js

@@ -1,7 +1,6 @@
 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;
@@ -870,7 +869,8 @@ class MacRecorder extends EventEmitter {
 									  this.options.captureArea ? 'area' : 'display',
 						captureArea: this.options.captureArea,
 						windowId: this.options.windowId,
-						startTimestamp: syncTimestamp // Align cursor timeline to actual start
+						startTimestamp: syncTimestamp,
+						interval: 33,
 					};
 
 					try {
@@ -1341,17 +1341,377 @@ class MacRecorder extends EventEmitter {
 		});
 	}
 
+	/**
+	 * Event'in kaydedilip kaydedilmeyeceğini belirler
+	 */
+	shouldCaptureEvent(currentData) {
+		if (!this.lastCapturedData) {
+			return true; // İlk event
+		}
+
+		if (
+			currentData.type === "drag" ||
+			currentData.type === "rightdrag"
+		) {
+			return true;
+		}
+
+		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)
+	 * @param {number} options.interval - Örnekleme aralığı (ms), filepath ile çağrıda kullanılır; varsayılan 33ms (~30 Hz)
+	 */
 	async startCursorCapture(intervalOrFilepath = 100, options = {}) {
-		return cursorCapturePolling.startCursorCapture(
-			this,
-			nativeBinding,
-			intervalOrFilepath,
-			options,
-		);
+		let filepath;
+		let interval = 33;
+
+		// 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 (typeof options.interval === "number") {
+			interval = Math.max(10, options.interval);
+		}
+
+		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);
+			}
+		});
 	}
 
+	/**
+	 * Cursor capture durdurur - dosya yazma işlemini sonlandırır
+	 */
 	async stopCursorCapture() {
-		return cursorCapturePolling.stopCursorCapture(this);
+		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);
+			}
+		});
 	}
 
 	/**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "2.22.24",
+	"version": "2.22.33",
 	"description": "Native macOS screen recording package for Node.js applications",
 	"main": "index.js",
 	"keywords": [
@@ -43,7 +43,9 @@
 		"build:electron-safe": "node build-electron-safe.js",
 		"test:electron-safe": "node test-electron-safe.js",
 		"clean:electron-safe": "node-gyp clean && rm -rf build",
-		"canvas": "node make-canvas.js"
+		"canvas": "node make-canvas.js",
+		"cursor:live": "node scripts/cursor-type-live.js",
+		"test:cursor-types": "node scripts/cursor-types-15s-test.js"
 	},
 	"dependencies": {
 		"node-addon-api": "^7.0.0"

package/scripts/cursor-type-live.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+const MacRecorder = require('../index.js');
+
+const INTERVAL_MS = 33;
+
+const recorder = new MacRecorder();
+
+process.stderr.write(
+	`Canlı cursor tipi (${INTERVAL_MS}ms). Çıkmak: Ctrl+C\n`
+);
+
+function tick() {
+	try {
+		const p = recorder.getCursorPosition();
+		const type = p.cursorType != null ? String(p.cursorType) : '?';
+		const seed =
+			typeof p.seed === 'number' && p.seed > 0 ? ` seed:${p.seed}` : '';
+		process.stdout.write(`\r\x1b[KcursorType: ${type}${seed}`);
+	} catch (e) {
+		process.stdout.write(`\r\x1b[K${e.message || e}`);
+	}
+}
+
+const id = setInterval(tick, INTERVAL_MS);
+tick();
+
+process.on('SIGINT', () => {
+	clearInterval(id);
+	process.stdout.write('\n');
+	process.exit(0);
+});

package/scripts/cursor-types-15s-test.js

@@ -0,0 +1,122 @@
+const fs = require('fs');
+const path = require('path');
+
+const MacRecorder = require('../index.js');
+
+const OUT_DIR = path.join(__dirname, '..', 'test-output');
+const DURATION_SEC = 15;
+
+async function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+
+function summarizeCursorTypes(cursorJsonPath) {
+	if (!cursorJsonPath || !fs.existsSync(cursorJsonPath)) {
+		return { counts: {}, ordered: [] };
+	}
+	const raw = fs.readFileSync(cursorJsonPath, 'utf8');
+	let events;
+	try {
+		events = JSON.parse(raw);
+	} catch {
+		return { counts: {}, ordered: [] };
+	}
+	if (!Array.isArray(events)) {
+		return { counts: {}, ordered: [] };
+	}
+	const counts = {};
+	const order = [];
+	for (const ev of events) {
+		const t = ev && ev.cursorType ? String(ev.cursorType) : '?';
+		if (counts[t] === undefined) {
+			counts[t] = 0;
+			order.push(t);
+		}
+		counts[t]++;
+	}
+	return { counts, ordered: order };
+}
+
+async function main() {
+	fs.mkdirSync(OUT_DIR, { recursive: true });
+
+	const stamp = Date.now();
+	const screenPath = path.join(OUT_DIR, `cursor-types-test-${stamp}.mov`);
+
+	const recorder = new MacRecorder();
+
+	const displays = await recorder.getDisplays();
+	const cameras = await recorder.getCameraDevices();
+	const audioDevices = await recorder.getAudioDevices();
+
+	if (!displays.length) {
+		process.stderr.write('No displays.\n');
+		process.exit(1);
+	}
+
+	const display = displays[0];
+
+	let cursorPathFromStart = null;
+	recorder.once('recordingStarted', (info) => {
+		cursorPathFromStart = info.cursorOutputPath || null;
+	});
+
+	const options = {
+		displayId: display.id,
+		captureCamera: cameras.length > 0,
+		cameraDeviceId: cameras.length > 0 ? cameras[0].id : undefined,
+		includeMicrophone: audioDevices.length > 0,
+		audioDeviceId: audioDevices.length > 0 ? audioDevices[0].id : undefined,
+		includeSystemAudio: true,
+		captureCursor: true,
+		frameRate: 60,
+	};
+
+	process.stdout.write(
+		`Kayıt ${DURATION_SEC}s: ekran + sistem sesi + mik ${
+			options.includeMicrophone ? 'açık' : 'kapalı'
+		} + kamera ${options.captureCamera ? 'açık' : 'kapalı'} + cursor JSON.\n` +
+			`Kenarlarda resize, köşelerde çapraz, grab/grabbing ve crosshair deneyin.\n\n`
+	);
+
+	await recorder.startRecording(screenPath, options);
+
+	const cursorPath = cursorPathFromStart;
+
+	for (let i = 1; i <= DURATION_SEC; i++) {
+		await sleep(1000);
+		process.stdout.write(`${i}s `);
+	}
+	process.stdout.write('\n');
+
+	await recorder.stopRecording();
+
+	process.stdout.write('\nDosyalar:\n');
+	process.stdout.write(`  Ekran: ${screenPath}\n`);
+	if (options.captureCamera && cameras.length) {
+		process.stdout.write(
+			`  Kamera: kayıt başladıktan sonra native temp_camera_* ile aynı oturum\n`
+		);
+	}
+	if (options.includeMicrophone || options.includeSystemAudio) {
+		process.stdout.write(
+			`  Ses: kayıt başladıktan sonra native temp_audio_* ile aynı oturum\n`
+		);
+	}
+	process.stdout.write(`  Cursor JSON: ${cursorPath || 'bilinmiyor'}\n`);
+
+	if (cursorPath && fs.existsSync(cursorPath)) {
+		const { counts, ordered } = summarizeCursorTypes(cursorPath);
+		process.stdout.write('\nCursor JSON — cursorType özeti (ilk görülme sırası):\n');
+		for (const t of ordered) {
+			process.stdout.write(`  ${t}: ${counts[t]}\n`);
+		}
+	}
+
+	recorder.removeAllListeners();
+}
+
+main().catch((e) => {
+	process.stderr.write(String(e && e.message ? e.message : e) + '\n');
+	process.exit(1);
+});

package/src/avfoundation_recorder.mm

@@ -502,8 +502,7 @@ extern "C" bool stopAVFoundationRecording() {
         
         // Finish writing with null checks
         AVAssetWriterInput *writerInput = g_avVideoInput;
-        AVAssetWriter *writerRef = g_avWriter;
-        if (writerInput && writerRef && writerRef.status == AVAssetWriterStatusWriting) {
+        if (writerInput) {
             [writerInput markAsFinished];
         }