node-mac-recorder 2.17.19 → 2.17.21

package/test-cursor-types.js

@@ -1,117 +0,0 @@
-const MacRecorder = require('./index.js');
-
-async function testCursorTypes() {
-    console.log('🧪 Testing improved cursor type detection...');
-
-    const recorder = new MacRecorder();
-
-    try {
-        // Test basic cursor position and type detection
-        console.log('\n📍 Current cursor state:');
-        const cursorPos = recorder.getCursorPosition();
-        console.log(`   Position: (${cursorPos.x}, ${cursorPos.y})`);
-        console.log(`   Type: ${cursorPos.cursorType}`);
-        console.log(`   Event: ${cursorPos.eventType}`);
-
-        console.log('\n🖱️ Starting continuous cursor type monitoring...');
-        console.log('📋 Instructions:');
-        console.log('   1. Move mouse over different UI elements');
-        console.log('   2. Hover over buttons, text fields, links, window borders');
-        console.log('   3. Try resize handles on windows');
-        console.log('   4. Move over different applications');
-        console.log('   5. Test will run for 15 seconds');
-
-        const cursorData = [];
-        let lastReportedType = null;
-        let typeChangeCount = 0;
-
-        const startTime = Date.now();
-        const testDuration = 15000; // 15 seconds
-
-        // Continuous monitoring
-        const monitor = setInterval(() => {
-            const pos = recorder.getCursorPosition();
-            const currentType = pos.cursorType;
-
-            // Record all data for analysis
-            cursorData.push({
-                timestamp: Date.now() - startTime,
-                x: pos.x,
-                y: pos.y,
-                type: currentType,
-                event: pos.eventType
-            });
-
-            // Report type changes immediately
-            if (currentType !== lastReportedType) {
-                const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-                console.log(`   [${elapsed}s] Cursor changed: ${lastReportedType || 'unknown'} → ${currentType} at (${pos.x}, ${pos.y})`);
-                lastReportedType = currentType;
-                typeChangeCount++;
-            }
-        }, 50); // Check every 50ms for high responsiveness
-
-        // Stop after test duration
-        setTimeout(() => {
-            clearInterval(monitor);
-
-            console.log('\n📊 Test Results:');
-            console.log(`   Total cursor events: ${cursorData.length}`);
-            console.log(`   Cursor type changes: ${typeChangeCount}`);
-            console.log(`   Test duration: ${testDuration/1000} seconds`);
-
-            // Analyze cursor types detected
-            const typeDistribution = {};
-            cursorData.forEach(data => {
-                typeDistribution[data.type] = (typeDistribution[data.type] || 0) + 1;
-            });
-
-            console.log('\n🎯 Cursor types detected:');
-            Object.entries(typeDistribution)
-                .sort(([,a], [,b]) => b - a)
-                .forEach(([type, count]) => {
-                    const percentage = ((count / cursorData.length) * 100).toFixed(1);
-                    console.log(`   ${type}: ${count} times (${percentage}%)`);
-                });
-
-            // Responsiveness analysis
-            const typeChanges = cursorData.filter((data, i) =>
-                i === 0 || data.type !== cursorData[i-1].type
-            );
-
-            if (typeChanges.length > 1) {
-                console.log('\n⚡ Responsiveness Analysis:');
-                console.log(`   First type change at: ${typeChanges[1].timestamp}ms`);
-                console.log(`   Last type change at: ${typeChanges[typeChanges.length-1].timestamp}ms`);
-                console.log(`   Average detection frequency: ${(cursorData.length / (testDuration/1000)).toFixed(1)} checks/sec`);
-
-                if (typeChangeCount > 0) {
-                    console.log('✅ Cursor type detection is working and responsive!');
-                } else {
-                    console.log('⚠️  No cursor type changes detected - try moving over different UI elements');
-                }
-            }
-
-            // Save detailed log for analysis
-            const fs = require('fs');
-            const logFile = `./test-output/cursor-types-test-${Date.now()}.json`;
-            fs.writeFileSync(logFile, JSON.stringify({
-                summary: {
-                    totalEvents: cursorData.length,
-                    typeChanges: typeChangeCount,
-                    duration: testDuration,
-                    typeDistribution
-                },
-                events: cursorData
-            }, null, 2));
-
-            console.log(`\n💾 Detailed log saved to: ${logFile}`);
-
-        }, testDuration);
-
-    } catch (error) {
-        console.error('❌ Test failed:', error.message);
-    }
-}
-
-testCursorTypes().catch(console.error);

package/test-display-coordinates.js

@@ -1,72 +0,0 @@
-const MacRecorder = require('./index.js');
-
-async function testDisplayCoordinates() {
-    console.log('🧪 Testing cursor coordinate behavior across displays...');
-
-    const recorder = new MacRecorder();
-
-    try {
-        const displays = await recorder.getDisplays();
-
-        console.log('\n📱 Display information:');
-        displays.forEach((display, i) => {
-            const type = display.isPrimary ? 'PRIMARY' : 'SECONDARY';
-            console.log(`  ${type} Display ${display.id}: ${display.resolution} at (${display.x}, ${display.y})`);
-        });
-
-        console.log('\n🖱️ Real-time cursor position test:');
-        console.log('Move your mouse to different displays and observe coordinates...');
-        console.log('Press Ctrl+C to stop\n');
-
-        let lastDisplay = null;
-        const interval = setInterval(() => {
-            const pos = recorder.getCursorPosition();
-
-            // Determine which display cursor is on
-            let currentDisplay = null;
-            for (const display of displays) {
-                if (pos.x >= display.x &&
-                    pos.x < display.x + display.width &&
-                    pos.y >= display.y &&
-                    pos.y < display.y + display.height) {
-                    currentDisplay = display;
-                    break;
-                }
-            }
-
-            if (currentDisplay && currentDisplay.id !== lastDisplay?.id) {
-                const type = currentDisplay.isPrimary ? 'PRIMARY' : 'SECONDARY';
-                console.log(`\n📍 Moved to ${type} Display ${currentDisplay.id}:`);
-                console.log(`   Display bounds: (${currentDisplay.x}, ${currentDisplay.y}) to (${currentDisplay.x + currentDisplay.width}, ${currentDisplay.y + currentDisplay.height})`);
-                lastDisplay = currentDisplay;
-            }
-
-            if (currentDisplay) {
-                // Calculate display-relative coordinates
-                const displayRelativeX = pos.x - currentDisplay.x;
-                const displayRelativeY = pos.y - currentDisplay.y;
-
-                const type = currentDisplay.isPrimary ? 'PRI' : 'SEC';
-                console.log(`${type} | Global: (${pos.x}, ${pos.y}) | Display-rel: (${displayRelativeX}, ${displayRelativeY})`);
-            } else {
-                console.log(`??? | Global: (${pos.x}, ${pos.y}) | Not on any display`);
-            }
-        }, 200); // Every 200ms
-
-        // Handle Ctrl+C
-        process.on('SIGINT', () => {
-            clearInterval(interval);
-            console.log('\n\n🔍 Test completed. Look for any unusual patterns in the coordinates.');
-            console.log('\nKey things to check:');
-            console.log('1. Do global coordinates look correct on both displays?');
-            console.log('2. Do display-relative coordinates start from (0,0) on each display?');
-            console.log('3. Are there any unexpected offsets on the primary display?');
-            process.exit(0);
-        });
-
-    } catch (error) {
-        console.error('❌ Test failed:', error.message);
-    }
-}
-
-testDisplayCoordinates().catch(console.error);

package/test-integrated-recording.js

@@ -1,120 +0,0 @@
-#!/usr/bin/env node
-
-const MacRecorder = require('./index.js');
-const path = require('path');
-const fs = require('fs');
-
-// Test output directory
-const outputDir = './test-output';
-if (!fs.existsSync(outputDir)) {
-	fs.mkdirSync(outputDir, { recursive: true });
-}
-
-const recorder = new MacRecorder();
-
-async function testIntegratedRecording() {
-	console.log('🎬 Testing integrated screen recording with automatic cursor tracking...');
-
-	try {
-		// Test permissions first
-		const permissions = await recorder.checkPermissions();
-		console.log('📋 Permissions:', permissions);
-
-		if (!permissions.screenRecording) {
-			console.log('❌ Screen recording permission required');
-			return;
-		}
-
-		// Get displays and windows
-		const displays = await recorder.getDisplays();
-		const windows = await recorder.getWindows();
-
-		console.log(`📺 Found ${displays.length} displays and ${windows.length} windows`);
-
-		// Setup recording options
-		const timestamp = Date.now();
-		const videoPath = path.join(outputDir, `integrated-test-${timestamp}.mov`);
-
-		console.log(`🎥 Starting recording to: ${videoPath}`);
-		console.log('📍 Cursor tracking will start automatically and create a JSON file in the same directory');
-
-		// Start recording (cursor tracking will start automatically)
-		// Use the primary display (displayId: 1) where cursor is located
-		await recorder.startRecording(videoPath, {
-			includeMicrophone: false,
-			includeSystemAudio: false,
-			captureCursor: true,
-			displayId: 1  // Use primary display where cursor is located
-		});
-
-		console.log('✅ Recording started successfully!');
-		console.log('🖱️  Cursor tracking started automatically');
-		console.log('⏰ Recording for 5 seconds...');
-		console.log('💡 Move your mouse around to generate cursor data');
-
-		// Wait for 5 seconds
-		await new Promise(resolve => setTimeout(resolve, 5000));
-
-		console.log('🛑 Stopping recording...');
-
-		// Stop recording (cursor tracking will stop automatically)
-		const result = await recorder.stopRecording();
-
-		console.log('✅ Recording stopped:', result);
-		console.log('📁 Checking output files...');
-
-		// Wait a moment for files to be written
-		await new Promise(resolve => setTimeout(resolve, 1000));
-
-		// Check for video file
-		if (fs.existsSync(videoPath)) {
-			const videoStats = fs.statSync(videoPath);
-			console.log(`📹 Video file created: ${videoPath} (${videoStats.size} bytes)`);
-		} else {
-			console.log('❌ Video file not found');
-		}
-
-		// Check for cursor file
-		const files = fs.readdirSync(outputDir);
-		const cursorFile = files.find(f => f.startsWith('temp_cursor_') && f.endsWith('.json'));
-
-		if (cursorFile) {
-			const cursorPath = path.join(outputDir, cursorFile);
-			const cursorStats = fs.statSync(cursorPath);
-			console.log(`🖱️  Cursor file created: ${cursorFile} (${cursorStats.size} bytes)`);
-
-			// Read and validate cursor data
-			try {
-				const cursorData = JSON.parse(fs.readFileSync(cursorPath, 'utf8'));
-				console.log(`📊 Cursor data points: ${cursorData.length}`);
-
-				if (cursorData.length > 0) {
-					const first = cursorData[0];
-					const last = cursorData[cursorData.length - 1];
-					console.log(`📍 First cursor position: (${first.x}, ${first.y}) at ${first.timestamp}ms`);
-					console.log(`📍 Last cursor position: (${last.x}, ${last.y}) at ${last.timestamp}ms`);
-					console.log(`📐 Coordinate system: ${first.coordinateSystem || 'global'}`);
-				}
-			} catch (parseError) {
-				console.log('⚠️  Could not parse cursor data:', parseError.message);
-			}
-		} else {
-			console.log('❌ Cursor file not found');
-		}
-
-		console.log('✅ Test completed successfully!');
-
-	} catch (error) {
-		console.error('❌ Test failed:', error.message);
-		console.error(error.stack);
-	}
-}
-
-// Run the test
-testIntegratedRecording().then(() => {
-	console.log('🏁 All tests finished');
-	process.exit(0);
-}).catch(error => {
-	console.error('💥 Fatal error:', error);
-	process.exit(1);
-});

package/test-menubar-offset.js

@@ -1,110 +0,0 @@
-const MacRecorder = require('./index.js');
-
-async function testMenuBarOffset() {
-    console.log('🧪 Testing macOS menu bar coordinate offset...');
-
-    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 Info:');
-        console.log(`   Bounds: (${primaryDisplay.x}, ${primaryDisplay.y}) ${primaryDisplay.width}x${primaryDisplay.height}`);
-
-        // Get menu bar height by checking screen bounds vs usable bounds
-        const { screen } = require('electron').screen || {};
-
-        // Alternative way to get menu bar info using native macOS APIs
-        console.log('\n🔍 Coordinate System Analysis:');
-
-        // Find windows 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);
-        });
-
-        console.log('\n🪟 Windows on Primary Display:');
-        primaryWindows.slice(0, 3).forEach((window, i) => {
-            console.log(`   ${i+1}. "${window.title}" at (${window.x}, ${window.y}) ${window.width}x${window.height}`);
-
-            // Check if window Y starts suspiciously high (indicating menu bar offset)
-            if (window.y > 20 && window.y < 100) {
-                console.log(`      ⚠️ Window Y=${window.y} suggests menu bar offset of ~${window.y}px`);
-            }
-        });
-
-        // Test cursor coordinates at the very top of the screen
-        console.log('\n🖱️ Move mouse to the very TOP of the primary screen and observe:');
-        console.log('(This will help identify if menu bar affects coordinates)');
-
-        for (let i = 0; i < 10; i++) {
-            await new Promise(resolve => setTimeout(resolve, 500));
-            const pos = recorder.getCursorPosition();
-
-            if (pos.x >= primaryDisplay.x &&
-                pos.x < primaryDisplay.x + primaryDisplay.width &&
-                pos.y >= primaryDisplay.y &&
-                pos.y < primaryDisplay.y + primaryDisplay.height) {
-
-                console.log(`   Test ${i+1}: Global (${pos.x}, ${pos.y}) | Y from top: ${pos.y - primaryDisplay.y}`);
-
-                // If cursor Y is very close to 0 but not exactly 0, there might be menu bar offset
-                if (pos.y >= primaryDisplay.y && pos.y <= primaryDisplay.y + 50) {
-                    const yFromTop = pos.y - primaryDisplay.y;
-                    if (yFromTop > 0 && yFromTop < 40) {
-                        console.log(`      🎯 Potential menu bar detected: ${yFromTop}px from top`);
-                    }
-                }
-            }
-        }
-
-        // Test with a specific window on primary display
-        if (primaryWindows.length > 0) {
-            const testWindow = primaryWindows[0];
-
-            console.log(`\n🧪 Testing window coordinate transformation:`);
-            console.log(`   Window: "${testWindow.title}"`);
-            console.log(`   Global position: (${testWindow.x}, ${testWindow.y})`);
-            console.log(`   Display offset: (${testWindow.x - primaryDisplay.x}, ${testWindow.y - primaryDisplay.y})`);
-
-            // Calculate what window-relative coordinates should be
-            console.log(`\n📊 Expected coordinate transformation:`);
-            console.log(`   If cursor at window's top-left (${testWindow.x}, ${testWindow.y}):`);
-            console.log(`   Should become window-relative: (0, 0)`);
-            console.log(`   Current transformation would give: (${testWindow.x - testWindow.x}, ${testWindow.y - testWindow.y})`);
-
-            // Check if there's a Y offset issue
-            const expectedZeroY = testWindow.y - testWindow.y; // Should be 0
-            if (expectedZeroY !== 0) {
-                console.log(`   ❌ Y transformation issue detected!`);
-            }
-
-            // Now check what happens with display transformation
-            const globalToDisplayX = testWindow.x - primaryDisplay.x;
-            const globalToDisplayY = testWindow.y - primaryDisplay.y;
-            const displayToWindowX = globalToDisplayX - (testWindow.x - primaryDisplay.x);
-            const displayToWindowY = globalToDisplayY - (testWindow.y - primaryDisplay.y);
-
-            console.log(`\n🔧 Two-step transformation analysis:`);
-            console.log(`   Step 1 - Global to display-relative: (${globalToDisplayX}, ${globalToDisplayY})`);
-            console.log(`   Step 2 - Display-relative to window-relative: (${displayToWindowX}, ${displayToWindowY})`);
-
-            if (displayToWindowX !== 0 || displayToWindowY !== 0) {
-                console.log(`   ❌ Two-step transformation creates offset!`);
-                console.log(`   ✅ Should use direct transformation: global - window_global`);
-            }
-        }
-
-    } catch (error) {
-        console.error('❌ Test failed:', error.message);
-    }
-}
-
-testMenuBarOffset().catch(console.error);

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

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

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

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

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

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

package/test-primary-cursor.js

@@ -1,154 +0,0 @@
-const MacRecorder = require('./index.js');
-
-async function testPrimaryCursor() {
-    console.log('🧪 Testing cursor coordinates on primary vs secondary displays...');
-
-    const recorder = new MacRecorder();
-
-    try {
-        // Get available displays and windows
-        const displays = await recorder.getDisplays();
-        const windows = await recorder.getWindows();
-
-        console.log('\n📱 Available displays:');
-        displays.forEach((display, i) => {
-            const type = display.isPrimary ? 'PRIMARY' : 'SECONDARY';
-            console.log(`  ${i + 1}. ${type} Display ${display.id}: ${display.resolution} at (${display.x}, ${display.y})`);
-        });
-
-        // Find windows on each display
-        const primaryDisplay = displays.find(d => d.isPrimary);
-        const secondaryDisplay = displays.find(d => !d.isPrimary);
-
-        console.log('\n🪟 Finding windows on each 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);
-        });
-
-        const secondaryWindows = secondaryDisplay ? windows.filter(window => {
-            const windowCenterX = window.x + window.width / 2;
-            const windowCenterY = window.y + window.height / 2;
-            return (windowCenterX >= secondaryDisplay.x &&
-                    windowCenterX < secondaryDisplay.x + secondaryDisplay.width &&
-                    windowCenterY >= secondaryDisplay.y &&
-                    windowCenterY < secondaryDisplay.y + secondaryDisplay.height);
-        }) : [];
-
-        console.log(`\n📊 Window distribution:`);
-        console.log(`   Primary display: ${primaryWindows.length} windows`);
-        console.log(`   Secondary display: ${secondaryWindows.length} windows`);
-
-        // Test each display type
-        for (const displayType of ['primary', 'secondary']) {
-            const display = displayType === 'primary' ? primaryDisplay : secondaryDisplay;
-            const windowList = displayType === 'primary' ? primaryWindows : secondaryWindows;
-
-            if (!display) {
-                console.log(`\n⚠️ No ${displayType} display found, skipping...`);
-                continue;
-            }
-
-            if (windowList.length === 0) {
-                console.log(`\n⚠️ No windows found on ${displayType} display, skipping...`);
-                continue;
-            }
-
-            const testWindow = windowList[0];
-            console.log(`\n🎯 Testing ${displayType.toUpperCase()} display (${display.id}):`);
-            console.log(`   Display bounds: (${display.x}, ${display.y}) ${display.width}x${display.height}`);
-            console.log(`   Test window: "${testWindow.title}" at (${testWindow.x}, ${testWindow.y}) ${testWindow.width}x${testWindow.height}`);
-
-            // Calculate window position relative to display
-            const windowRelativeX = testWindow.x - display.x;
-            const windowRelativeY = testWindow.y - display.y;
-            console.log(`   Window relative to display: (${windowRelativeX}, ${windowRelativeY})`);
-
-            // Test cursor capture
-            const outputFile = `./test-output/cursor-${displayType}-${Date.now()}.json`;
-
-            console.log(`\n🖱️ Starting cursor test for ${displayType} display...`);
-            console.log('   Move mouse over the test window for 3 seconds');
-
-            await recorder.startCursorCapture(outputFile, {
-                windowRelative: true,
-                windowInfo: {
-                    x: testWindow.x,
-                    y: testWindow.y,
-                    width: testWindow.width,
-                    height: testWindow.height,
-                    displayId: display.id,
-                    targetDisplay: display
-                }
-            });
-
-            // Capture for 3 seconds
-            await new Promise(resolve => setTimeout(resolve, 3000));
-
-            await recorder.stopCursorCapture();
-
-            // Analyze results
-            const fs = require('fs');
-            if (fs.existsSync(outputFile)) {
-                const cursorData = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
-
-                console.log(`\n📊 ${displayType.toUpperCase()} Display Results:`);
-                console.log(`   Captured events: ${cursorData.length}`);
-
-                if (cursorData.length > 0) {
-                    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(`   Events in bounds: ${inBounds.length}/${cursorData.length} (${Math.round(inBounds.length/cursorData.length*100)}%)`);
-                    console.log(`   Events out of bounds: ${outOfBounds.length}`);
-
-                    if (outOfBounds.length > 0) {
-                        console.log(`   ❌ ISSUE DETECTED on ${displayType} display!`);
-                        console.log(`   Sample out-of-bounds coordinates:`);
-                        outOfBounds.slice(0, 5).forEach(event => {
-                            console.log(`      (${event.x}, ${event.y}) - should be 0-${testWindow.width}, 0-${testWindow.height}`);
-                        });
-
-                        // Analyze the offset pattern
-                        const xOffsets = outOfBounds.map(e => e.x);
-                        const yOffsets = outOfBounds.map(e => e.y);
-                        const avgXOffset = xOffsets.reduce((a, b) => a + b, 0) / xOffsets.length;
-                        const avgYOffset = yOffsets.reduce((a, b) => a + b, 0) / yOffsets.length;
-
-                        console.log(`   📊 Average coordinate offsets: X=${avgXOffset.toFixed(1)}, Y=${avgYOffset.toFixed(1)}`);
-                    } else {
-                        console.log(`   ✅ All coordinates within bounds on ${displayType} display`);
-                    }
-
-                    // Show coordinate samples
-                    console.log(`   Sample coordinates (first 3):`);
-                    cursorData.slice(0, 3).forEach((event, i) => {
-                        console.log(`      ${i+1}. (${event.x}, ${event.y}) - ${event.coordinateSystem}`);
-                    });
-                }
-            }
-        }
-
-        console.log('\n🔍 Analysis Summary:');
-        console.log('   If primary display shows out-of-bounds coordinates,');
-        console.log('   but secondary display works correctly, this indicates');
-        console.log('   a coordinate transformation issue specific to primary displays.');
-
-    } catch (error) {
-        console.error('❌ Test failed:', error.message);
-    }
-}
-
-testPrimaryCursor().catch(console.error);