node-mac-recorder 2.17.12 → 2.17.14

package/package.json

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

package/src/cursor_tracker.mm

@@ -43,9 +43,9 @@ 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
+// Cursor stability constants - more responsive
+static const NSTimeInterval CURSOR_STABILITY_THRESHOLD = 0.05; // 50ms (faster response)
+static const int CURSOR_CONFIRMATION_COUNT = 1; // Need 1 detection (more responsive)
 
 // Mouse button state tracking
 static bool g_leftMouseDown = false;
@@ -57,12 +57,12 @@ static CGEventRef eventTapCallback(CGEventTapProxy proxy, CGEventType type, CGEv
     return event;
 }
 
-// Enhanced cursor type detection with multi-layer approach and stability
+// Enhanced cursor type detection with better NSCursor analysis
 NSString* detectCursorTypeFromNSCursor() {
     @try {
         NSCursor *currentCursor = [NSCursor currentSystemCursor];
         if (!currentCursor) {
-            return @"default";
+            return nil; // Return nil to indicate we should try other methods
         }
 
         // Compare with known system cursors using identity comparison
@@ -86,24 +86,43 @@ NSString* detectCursorTypeFromNSCursor() {
             return @"not-allowed";
         }
 
-        // Fallback to image-based comparison for custom cursors
+        // Check for additional resize cursors using image analysis
         NSImage *cursorImage = [currentCursor image];
         if (cursorImage) {
             NSSize imageSize = [cursorImage size];
+            NSPoint hotSpot = [currentCursor hotSpot];
+
+            // Analyze cursor image to detect resize cursors
+            if (imageSize.width > 10 && imageSize.height > 10) {
+                // Check for diagonal resize cursors (corner resize)
+                if (imageSize.width >= 15 && imageSize.height >= 15) {
+                    // These are likely diagonal resize cursors
+                    // hotSpot can help distinguish between nwse and nesw
+                    if (hotSpot.x < imageSize.width / 2 && hotSpot.y < imageSize.height / 2) {
+                        return @"nwse-resize"; // northwest-southeast
+                    } else if (hotSpot.x > imageSize.width / 2 && hotSpot.y < imageSize.height / 2) {
+                        return @"nesw-resize"; // northeast-southwest
+                    }
+                }
+
+                // Check for horizontal/vertical resize cursors
+                if (imageSize.width > imageSize.height + 5) {
+                    return @"col-resize"; // horizontal resize
+                } else if (imageSize.height > imageSize.width + 5) {
+                    return @"ns-resize"; // vertical resize
+                }
+            }
 
             // 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";
+        // Return nil to indicate we should use contextual detection
+        return nil;
     } @catch (NSException *exception) {
-        return @"default";
+        return nil;
     }
 }
 
@@ -114,48 +133,170 @@ NSString* getCursorType() {
         NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
 
         @try {
-            // Layer 1: Fast NSCursor detection (most reliable)
+            // Layer 1: Fast NSCursor detection (high confidence cases)
             NSString *nsCursorType = detectCursorTypeFromNSCursor();
 
-            // Layer 2: Accessibility API for context (when NSCursor isn't enough)
-            NSString *contextualCursorType = nsCursorType;
+            // Layer 2: Contextual detection using Accessibility API
+            NSString *contextualCursorType = nil;
 
-            // 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);
+            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 && elementAtPosition) {
+                CFStringRef role = NULL;
+                error = AXUIElementCopyAttributeValue(elementAtPosition, kAXRoleAttribute, (CFTypeRef*)&role);
 
-                    if (error == kAXErrorSuccess && role) {
-                        NSString *elementRole = (__bridge_transfer NSString*)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";
+                    // TEXT CURSORS - high priority
+                    if ([elementRole isEqualToString:@"AXTextField"] ||
+                        [elementRole isEqualToString:@"AXTextArea"] ||
+                        [elementRole isEqualToString:@"AXSearchField"]) {
+                        contextualCursorType = @"text";
+                    }
+                    // POINTER CURSORS - interactive elements with broader detection
+                    else if ([elementRole isEqualToString:@"AXLink"] ||
+                             [elementRole isEqualToString:@"AXButton"] ||
+                             [elementRole isEqualToString:@"AXMenuItem"] ||
+                             [elementRole isEqualToString:@"AXRadioButton"] ||
+                             [elementRole isEqualToString:@"AXCheckBox"] ||
+                             [elementRole isEqualToString:@"AXPopUpButton"] ||
+                             [elementRole isEqualToString:@"AXTab"]) {
+                        contextualCursorType = @"pointer";
+
+                        // Also check subroles for links and buttons
+                        CFStringRef subrole = NULL;
+                        AXError subroleError = AXUIElementCopyAttributeValue(elementAtPosition, kAXSubroleAttribute, (CFTypeRef*)&subrole);
+                        if (subroleError == kAXErrorSuccess && subrole) {
+                            NSString *elementSubrole = (__bridge_transfer NSString*)subrole;
+                            if ([elementSubrole isEqualToString:@"AXCloseButton"] ||
+                                [elementSubrole isEqualToString:@"AXMinimizeButton"] ||
+                                [elementSubrole isEqualToString:@"AXZoomButton"] ||
+                                [elementSubrole isEqualToString:@"AXToolbarButton"]) {
+                                contextualCursorType = @"pointer";
+                            }
                         }
-                        else if ([elementRole isEqualToString:@"AXLink"] ||
-                                 [elementRole isEqualToString:@"AXButton"] ||
-                                 [elementRole isEqualToString:@"AXMenuItem"]) {
-                            contextualCursorType = @"pointer";
+                    }
+                    // WEB ELEMENTS - for web links that might not show as AXLink
+                    else if ([elementRole isEqualToString:@"AXGroup"] ||
+                             [elementRole isEqualToString:@"AXStaticText"]) {
+                        // Check if it's clickable/has action
+                        CFArrayRef actions = NULL;
+                        AXError actionsError = AXUIElementCopyActionNames(elementAtPosition, &actions);
+                        if (actionsError == kAXErrorSuccess && actions) {
+                            CFIndex actionCount = CFArrayGetCount(actions);
+                            for (CFIndex i = 0; i < actionCount; i++) {
+                                CFStringRef action = (CFStringRef)CFArrayGetValueAtIndex(actions, i);
+                                NSString *actionStr = (__bridge NSString*)action;
+                                if ([actionStr isEqualToString:@"AXPress"] ||
+                                    [actionStr isEqualToString:@"AXShowMenu"]) {
+                                    contextualCursorType = @"pointer";
+                                    break;
+                                }
+                            }
+                            CFRelease(actions);
                         }
-                        else if ([elementRole isEqualToString:@"AXProgressIndicator"]) {
-                            contextualCursorType = @"progress";
+                    }
+                    // WINDOW BORDER RESIZE - critical for resize detection
+                    else if ([elementRole isEqualToString:@"AXWindow"]) {
+                        CFTypeRef position = NULL;
+                        CFTypeRef size = NULL;
+                        AXError posErr = AXUIElementCopyAttributeValue(elementAtPosition, kAXPositionAttribute, &position);
+                        AXError sizeErr = AXUIElementCopyAttributeValue(elementAtPosition, kAXSizeAttribute, &size);
+
+                        if (posErr == kAXErrorSuccess && sizeErr == 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 = 5.0; // 5px edge detection
+
+                            // Corner resize detection
+                            if (x <= edge && y <= edge) {
+                                contextualCursorType = @"nwse-resize";
+                            }
+                            else if (x >= w-edge && y <= edge) {
+                                contextualCursorType = @"nesw-resize";
+                            }
+                            else if (x <= edge && y >= h-edge) {
+                                contextualCursorType = @"nesw-resize";
+                            }
+                            else if (x >= w-edge && y >= h-edge) {
+                                contextualCursorType = @"nwse-resize";
+                            }
+                            // Edge resize detection
+                            else if (x <= edge || x >= w-edge) {
+                                contextualCursorType = @"col-resize";
+                            }
+                            else if (y <= edge || y >= h-edge) {
+                                contextualCursorType = @"ns-resize";
+                            }
+
+                            if (position) CFRelease(position);
+                            if (size) CFRelease(size);
                         }
                     }
-                    CFRelease(elementAtPosition);
+                    // SPLITTER RESIZE
+                    else if ([elementRole isEqualToString:@"AXSplitter"]) {
+                        CFStringRef orientation = NULL;
+                        error = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXOrientation"), (CFTypeRef*)&orientation);
+                        if (error == kAXErrorSuccess && orientation) {
+                            NSString *orientationStr = (__bridge_transfer NSString*)orientation;
+                            if ([orientationStr isEqualToString:@"AXHorizontalOrientation"]) {
+                                contextualCursorType = @"ns-resize";
+                            } else if ([orientationStr isEqualToString:@"AXVerticalOrientation"]) {
+                                contextualCursorType = @"col-resize";
+                            }
+                        }
+                    }
+                    // PROGRESS INDICATORS
+                    else if ([elementRole isEqualToString:@"AXProgressIndicator"]) {
+                        contextualCursorType = @"progress";
+                    }
+                    // OTHER ELEMENTS - be conservative, don't assume pointer
+                    else {
+                        // Don't override NSCursor for unknown elements
+                        contextualCursorType = nil;
+                    }
                 }
-                if (systemWide) CFRelease(systemWide);
+                CFRelease(elementAtPosition);
+            }
+            if (systemWide) CFRelease(systemWide);
+
+            // Layer 3: Intelligent fusion of NSCursor and contextual results
+            NSString *detectedCursorType = @"default";
+
+            // Priority logic with better fallback:
+            // 1. If contextual gives resize cursor, always use it (resize has highest priority)
+            if (contextualCursorType != nil &&
+                ([contextualCursorType hasSuffix:@"resize"] ||
+                 [contextualCursorType isEqualToString:@"col-resize"] ||
+                 [contextualCursorType isEqualToString:@"ns-resize"])) {
+                detectedCursorType = contextualCursorType;
+            }
+            // 2. If NSCursor gives a definitive answer, use it
+            else if (nsCursorType != nil) {
+                detectedCursorType = nsCursorType;
+            }
+            // 3. If contextual gives specific non-resize cursor, use it
+            else if (contextualCursorType != nil &&
+                     ![contextualCursorType isEqualToString:@"default"]) {
+                detectedCursorType = contextualCursorType;
+            }
+            // 4. If both are nil or default, use true default
+            else {
+                detectedCursorType = @"default";
             }
 
-            // Layer 3: Stability filtering to prevent oscillation
-            NSString *detectedCursorType = contextualCursorType;
+            // Layer 4: Stability filtering to prevent oscillation
 
             // Time-based stability check
             if (currentTime - g_lastCursorCheckTime > CURSOR_STABILITY_THRESHOLD) {