node-mac-recorder 2.17.11 → 2.17.12

package/.claude/settings.local.json

@@ -4,7 +4,9 @@
       "Bash(node:*)",
       "Bash(chmod:*)",
       "Bash(cat:*)",
-      "Bash(git checkout:*)"
+      "Bash(git checkout:*)",
+      "WebSearch",
+      "WebFetch(domain:stackoverflow.com)"
     ],
     "deny": [],
     "ask": []

package/package.json

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

package/src/cursor_tracker.mm

@@ -35,9 +35,17 @@ NSDictionary* getDisplayScalingInfo(CGPoint globalPoint);
 
 static CursorTimerTarget *g_timerTarget = nil;
 
-// Global cursor state tracking
+// Enhanced cursor state tracking with stability
 static NSString *g_lastDetectedCursorType = nil;
+static NSString *g_stableCursorType = @"default";
 static int g_cursorTypeCounter = 0;
+static NSTimeInterval g_lastCursorCheckTime = 0;
+static int g_sameCursorDetectionCount = 0;
+static NSString *g_pendingCursorType = nil;
+
+// Cursor stability constants
+static const NSTimeInterval CURSOR_STABILITY_THRESHOLD = 0.1; // 100ms
+static const int CURSOR_CONFIRMATION_COUNT = 2; // Need 2 consecutive detections
 
 // Mouse button state tracking
 static bool g_leftMouseDown = false;
@@ -49,255 +57,145 @@ static CGEventRef eventTapCallback(CGEventTapProxy proxy, CGEventType type, CGEv
     return event;
 }
 
-// Cursor type detection helper - sistem genelindeki cursor type'ı al
+// Enhanced cursor type detection with multi-layer approach and stability
+NSString* detectCursorTypeFromNSCursor() {
+    @try {
+        NSCursor *currentCursor = [NSCursor currentSystemCursor];
+        if (!currentCursor) {
+            return @"default";
+        }
+
+        // Compare with known system cursors using identity comparison
+        if (currentCursor == [NSCursor arrowCursor]) {
+            return @"default";
+        } else if (currentCursor == [NSCursor IBeamCursor]) {
+            return @"text";
+        } else if (currentCursor == [NSCursor pointingHandCursor]) {
+            return @"pointer";
+        } else if (currentCursor == [NSCursor resizeLeftRightCursor]) {
+            return @"col-resize";
+        } else if (currentCursor == [NSCursor resizeUpDownCursor]) {
+            return @"ns-resize";
+        } else if (currentCursor == [NSCursor crosshairCursor]) {
+            return @"crosshair";
+        } else if (currentCursor == [NSCursor openHandCursor]) {
+            return @"grab";
+        } else if (currentCursor == [NSCursor closedHandCursor]) {
+            return @"grabbing";
+        } else if (currentCursor == [NSCursor operationNotAllowedCursor]) {
+            return @"not-allowed";
+        }
+
+        // Fallback to image-based comparison for custom cursors
+        NSImage *cursorImage = [currentCursor image];
+        if (cursorImage) {
+            NSSize imageSize = [cursorImage size];
+
+            // Text cursors typically have I-beam shape (narrow width)
+            if (imageSize.width < 8 && imageSize.height > 15) {
+                return @"text";
+            }
+            // Pointer cursors are typically hand-shaped
+            else if (imageSize.width > 15 && imageSize.height > 15) {
+                return @"pointer";
+            }
+        }
+
+        return @"default";
+    } @catch (NSException *exception) {
+        return @"default";
+    }
+}
+
+// Improved cursor type detection with stability and multi-layer approach
 NSString* getCursorType() {
     @autoreleasepool {
         g_cursorTypeCounter++;
-        
-        @try {
-            // ACCESSIBILITY API BASED CURSOR DETECTION
-            // Determine cursor type based on the UI element under the cursor
-
-            CGPoint cursorPos = CGEventGetLocation(CGEventCreate(NULL));
-            AXUIElementRef systemWide = AXUIElementCreateSystemWide();
-            AXUIElementRef elementAtPosition = NULL;
-            AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
-
-            NSString *cursorType = @"default"; // Default fallback
-
-            if (error == kAXErrorSuccess && elementAtPosition) {
-                CFStringRef role = NULL;
-                error = AXUIElementCopyAttributeValue(elementAtPosition, kAXRoleAttribute, (CFTypeRef*)&role);
-
-                if (error == kAXErrorSuccess && role) {
-                    NSString *elementRole = (__bridge_transfer NSString*)role;
-                    NSLog(@"🎯 ELEMENT ROLE: %@", elementRole);
-
-                    // TEXT CURSORS
-                    if ([elementRole isEqualToString:@"AXTextField"] ||
-                        [elementRole isEqualToString:@"AXTextArea"] ||
-                        [elementRole isEqualToString:@"AXStaticText"] ||
-                        [elementRole isEqualToString:@"AXSearchField"]) {
-                        cursorType = @"text";
-                    }
-                    // POINTER CURSORS (clickable elements)
-                    else if ([elementRole isEqualToString:@"AXLink"] ||
-                             [elementRole isEqualToString:@"AXButton"] ||
-                             [elementRole isEqualToString:@"AXMenuItem"] ||
-                             [elementRole isEqualToString:@"AXRadioButton"] ||
-                             [elementRole isEqualToString:@"AXCheckBox"] ||
-                             [elementRole isEqualToString:@"AXPopUpButton"] ||
-                             [elementRole isEqualToString:@"AXTab"]) {
-                        cursorType = @"pointer";
-                    }
-                    // GRAB CURSORS (draggable elements)
-                    else if ([elementRole isEqualToString:@"AXImage"] ||
-                             [elementRole isEqualToString:@"AXGroup"]) {
-                        // Check if element is draggable
-                        CFBooleanRef draggable = NULL;
-                        error = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXMovable"), (CFTypeRef*)&draggable);
-                        if (error == kAXErrorSuccess && draggable && CFBooleanGetValue(draggable)) {
-                            cursorType = @"grab";
-                        } else {
-                            cursorType = @"default";
-                        }
-                    }
-                    // PROGRESS CURSORS (loading/busy elements)
-                    else if ([elementRole isEqualToString:@"AXProgressIndicator"] ||
-                             [elementRole isEqualToString:@"AXBusyIndicator"]) {
-                        cursorType = @"progress";
-                    }
-                    // HELP CURSORS (help buttons/tooltips)
-                    else if ([elementRole isEqualToString:@"AXHelpTag"] ||
-                             [elementRole isEqualToString:@"AXTooltip"]) {
-                        cursorType = @"help";
-                    }
-                    // RESIZE CURSORS - sadece AXSplitter için
-                    else if ([elementRole isEqualToString:@"AXSplitter"]) {
-                        // Get splitter orientation to determine resize direction
-                        CFStringRef orientation = NULL;
-                        error = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXOrientation"), (CFTypeRef*)&orientation);
-                        if (error == kAXErrorSuccess && orientation) {
-                            NSString *orientationStr = (__bridge_transfer NSString*)orientation;
-                            if ([orientationStr isEqualToString:@"AXHorizontalOrientation"]) {
-                                cursorType = @"ns-resize"; // Yatay splitter -> dikey hareket (north-south)
-                            } else if ([orientationStr isEqualToString:@"AXVerticalOrientation"]) {
-                                cursorType = @"col-resize"; // Dikey splitter -> yatay hareket (east-west)
-                            } else {
-                                cursorType = @"default"; // Bilinmeyen orientation
-                            }
-                        } else {
-                            cursorType = @"default"; // Orientation alınamazsa default
-                        }
-                    }
-                    // SCROLL CURSORS - hep default olsun, all-scroll görünmesin
-                    else if ([elementRole isEqualToString:@"AXScrollBar"]) {
-                        cursorType = @"default"; // ScrollBar'lar için de default
-                    }
-                    // AXScrollArea - hep default
-                    else if ([elementRole isEqualToString:@"AXScrollArea"]) {
-                        cursorType = @"default"; // ScrollArea her zaman default
-                    }
-                    // CROSSHAIR CURSORS (drawing/selection tools)
-                    else if ([elementRole isEqualToString:@"AXCanvas"] ||
-                             [elementRole isEqualToString:@"AXDrawingArea"]) {
-                        cursorType = @"crosshair";
-                    }
-                    // ZOOM CURSORS (zoom controls)
-                    else if ([elementRole isEqualToString:@"AXZoomButton"]) {
-                        cursorType = @"zoom-in";
-                    }
-                    // NOT-ALLOWED CURSORS (disabled elements)
-                    else if ([elementRole isEqualToString:@"AXStaticText"] ||
-                             [elementRole isEqualToString:@"AXGroup"]) {
-                        // Check if element is disabled/readonly
-                        CFBooleanRef enabled = NULL;
-                        error = AXUIElementCopyAttributeValue(elementAtPosition, kAXEnabledAttribute, (CFTypeRef*)&enabled);
-                        if (error == kAXErrorSuccess && enabled && !CFBooleanGetValue(enabled)) {
-                            cursorType = @"not-allowed";
-                        }
-                    }
-                    // WINDOW BORDER RESIZE - sadece pencere kenarlarında
-                    else if ([elementRole isEqualToString:@"AXWindow"]) {
-                        // Check window attributes to see if it's resizable
-                        CFBooleanRef resizable = NULL;
-                        AXError resizableError = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXResizeButton"), (CFTypeRef*)&resizable);
-
-                        // Sadece resize edilebilir pencereler için cursor değişimi
-                        if (resizableError == kAXErrorSuccess || true) { // AXResizeButton bulunamazsa da devam et
-                            CFTypeRef position = NULL;
-                            CFTypeRef size = NULL;
-                            error = AXUIElementCopyAttributeValue(elementAtPosition, kAXPositionAttribute, &position);
-                            AXError sizeError = AXUIElementCopyAttributeValue(elementAtPosition, kAXSizeAttribute, &size);
-
-                            if (error == kAXErrorSuccess && sizeError == kAXErrorSuccess && position && size) {
-                                CGPoint windowPos;
-                                CGSize windowSize;
-                                AXValueGetValue((AXValueRef)position, kAXValueTypeCGPoint, &windowPos);
-                                AXValueGetValue((AXValueRef)size, kAXValueTypeCGSize, &windowSize);
-
-                                CGFloat x = cursorPos.x - windowPos.x;
-                                CGFloat y = cursorPos.y - windowPos.y;
-                                CGFloat w = windowSize.width;
-                                CGFloat h = windowSize.height;
-                                CGFloat edge = 3.0; // Daha küçük edge detection (3px)
-
-                                // Sadece çok kenar köşelerde resize cursor'ı göster
-                                BOOL isOnBorder = NO;
-
-                                // Corner resize detection - çok dar alanda, doğru açılar
-                                if (x <= edge && y <= edge) {
-                                    cursorType = @"nwse-resize"; // Sol üst köşe - northwest-southeast
-                                    isOnBorder = YES;
-                                }
-                                else if (x >= w-edge && y <= edge) {
-                                    cursorType = @"nesw-resize"; // Sağ üst köşe - northeast-southwest
-                                    isOnBorder = YES;
-                                }
-                                else if (x <= edge && y >= h-edge) {
-                                    cursorType = @"nesw-resize"; // Sol alt köşe - southwest-northeast
-                                    isOnBorder = YES;
-                                }
-                                else if (x >= w-edge && y >= h-edge) {
-                                    cursorType = @"nwse-resize"; // Sağ alt köşe - southeast-northwest
-                                    isOnBorder = YES;
-                                }
-                                // Edge resize detection - sadece çok kenarlarda
-                                else if (x <= edge && y > edge && y < h-edge) {
-                                    cursorType = @"col-resize"; // Sol kenar - column resize (yatay)
-                                    isOnBorder = YES;
-                                }
-                                else if (x >= w-edge && y > edge && y < h-edge) {
-                                    cursorType = @"col-resize"; // Sağ kenar - column resize (yatay)
-                                    isOnBorder = YES;
-                                }
-                                else if (y <= edge && x > edge && x < w-edge) {
-                                    cursorType = @"ns-resize"; // Üst kenar - north-south resize (dikey)
-                                    isOnBorder = YES;
-                                }
-                                else if (y >= h-edge && x > edge && x < w-edge) {
-                                    cursorType = @"ns-resize"; // Alt kenar - north-south resize (dikey)
-                                    isOnBorder = YES;
-                                }
-
-                                // Eğer border'da değilse default
-                                if (!isOnBorder) {
-                                    cursorType = @"default";
-                                }
-
-                                if (position) CFRelease(position);
-                                if (size) CFRelease(size);
-                            } else {
-                                cursorType = @"default";
-                            }
-                        } else {
-                            cursorType = @"default";
-                        }
-                    }
-                    // HER DURUM İÇİN DEFAULT FALLBACK
-                    else {
-                        // Bilinmeyen elementler için her zaman default
-                        cursorType = @"default";
-                    }
+        NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
 
-                    // Check subroles for additional context
-                    CFStringRef subrole = NULL;
-                    error = AXUIElementCopyAttributeValue(elementAtPosition, kAXSubroleAttribute, (CFTypeRef*)&subrole);
-                    if (error == kAXErrorSuccess && subrole) {
-                        NSString *elementSubrole = (__bridge_transfer NSString*)subrole;
-                        NSLog(@"🎯 ELEMENT SUBROLE: %@", elementSubrole);
-
-                        // Subrole override'ları - sadece çok spesifik durumlar için
-                        if ([elementSubrole isEqualToString:@"AXCloseButton"] ||
-                            [elementSubrole isEqualToString:@"AXMinimizeButton"] ||
-                            [elementSubrole isEqualToString:@"AXZoomButton"] ||
-                            [elementSubrole isEqualToString:@"AXToolbarButton"]) {
-                            cursorType = @"pointer";
-                        }
-                        // Copy/alias subroles - sadece bu durumlar için override
-                        else if ([elementSubrole isEqualToString:@"AXFileDrop"] ||
-                                 [elementSubrole isEqualToString:@"AXDropTarget"]) {
-                            cursorType = @"copy";
-                        }
-                        // Alias/shortcut subroles
-                        else if ([elementSubrole isEqualToString:@"AXAlias"] ||
-                                 [elementSubrole isEqualToString:@"AXShortcut"]) {
-                            cursorType = @"alias";
-                        }
-                        // Grabbing state (being dragged) - sadece gerçek drag sırasında
-                        else if ([elementSubrole isEqualToString:@"AXDragging"] ||
-                                 [elementSubrole isEqualToString:@"AXMoving"]) {
-                            cursorType = @"grabbing";
+        @try {
+            // Layer 1: Fast NSCursor detection (most reliable)
+            NSString *nsCursorType = detectCursorTypeFromNSCursor();
+
+            // Layer 2: Accessibility API for context (when NSCursor isn't enough)
+            NSString *contextualCursorType = nsCursorType;
+
+            // Only use expensive Accessibility API if NSCursor gives us "default"
+            if ([nsCursorType isEqualToString:@"default"]) {
+                CGPoint cursorPos = CGEventGetLocation(CGEventCreate(NULL));
+                AXUIElementRef systemWide = AXUIElementCreateSystemWide();
+                AXUIElementRef elementAtPosition = NULL;
+                AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
+
+                if (error == kAXErrorSuccess && elementAtPosition) {
+                    CFStringRef role = NULL;
+                    error = AXUIElementCopyAttributeValue(elementAtPosition, kAXRoleAttribute, (CFTypeRef*)&role);
+
+                    if (error == kAXErrorSuccess && role) {
+                        NSString *elementRole = (__bridge_transfer NSString*)role;
+
+                        // Simplified, high-confidence role mappings only
+                        if ([elementRole isEqualToString:@"AXTextField"] ||
+                            [elementRole isEqualToString:@"AXTextArea"] ||
+                            [elementRole isEqualToString:@"AXSearchField"]) {
+                            contextualCursorType = @"text";
                         }
-                        // Zoom controls - sadece spesifik zoom butonları için
-                        else if ([elementSubrole isEqualToString:@"AXZoomIn"]) {
-                            cursorType = @"zoom-in";
+                        else if ([elementRole isEqualToString:@"AXLink"] ||
+                                 [elementRole isEqualToString:@"AXButton"] ||
+                                 [elementRole isEqualToString:@"AXMenuItem"]) {
+                            contextualCursorType = @"pointer";
                         }
-                        else if ([elementSubrole isEqualToString:@"AXZoomOut"]) {
-                            cursorType = @"zoom-out";
+                        else if ([elementRole isEqualToString:@"AXProgressIndicator"]) {
+                            contextualCursorType = @"progress";
                         }
-                        // Subrole'dan bir şey bulamazsa role-based cursor'ı koruyoruz
                     }
+                    CFRelease(elementAtPosition);
                 }
+                if (systemWide) CFRelease(systemWide);
+            }
 
-                CFRelease(elementAtPosition);
+            // Layer 3: Stability filtering to prevent oscillation
+            NSString *detectedCursorType = contextualCursorType;
+
+            // Time-based stability check
+            if (currentTime - g_lastCursorCheckTime > CURSOR_STABILITY_THRESHOLD) {
+                // Enough time has passed, reset counters
+                g_sameCursorDetectionCount = 0;
+                g_pendingCursorType = detectedCursorType;
             }
 
-            if (systemWide) {
-                CFRelease(systemWide);
+            // Check if detected cursor matches pending cursor
+            if ([detectedCursorType isEqualToString:g_pendingCursorType]) {
+                g_sameCursorDetectionCount++;
+
+                // If we have enough confirmations, update stable cursor
+                if (g_sameCursorDetectionCount >= CURSOR_CONFIRMATION_COUNT) {
+                    g_stableCursorType = detectedCursorType;
+                    g_lastDetectedCursorType = detectedCursorType;
+                }
+            } else {
+                // Different cursor detected, start new pending
+                g_pendingCursorType = detectedCursorType;
+                g_sameCursorDetectionCount = 1;
             }
 
-            // Son güvence - eğer cursorType hala nil veya geçersizse default'a çevir
-            if (!cursorType || [cursorType length] == 0) {
-                cursorType = @"default";
+            g_lastCursorCheckTime = currentTime;
+
+            // Final validation
+            NSString *finalCursorType = g_stableCursorType;
+            if (!finalCursorType || [finalCursorType length] == 0) {
+                finalCursorType = @"default";
             }
 
-            NSLog(@"🎯 FINAL CURSOR TYPE: %@", cursorType);
-            return cursorType;
-            
+            // Debug logging for stability tracking
+            NSLog(@"🎯 CURSOR DETECTION - NSCursor: %@, Contextual: %@, Stable: %@, Count: %d",
+                  nsCursorType, contextualCursorType, finalCursorType, g_sameCursorDetectionCount);
+
+            return finalCursorType;
+
         } @catch (NSException *exception) {
             NSLog(@"Error in getCursorType: %@", exception);
-            return @"default";
+            return g_stableCursorType ?: @"default";
         }
     }
 }
@@ -501,7 +399,11 @@ void cleanupCursorTracking() {
     g_outputPath = nil;
     g_debugCallbackCount = 0;
     g_lastDetectedCursorType = nil;
+    g_stableCursorType = @"default";
     g_cursorTypeCounter = 0;
+    g_lastCursorCheckTime = 0;
+    g_sameCursorDetectionCount = 0;
+    g_pendingCursorType = nil;
     g_isFirstWrite = true;
 }