node-mac-recorder 2.17.12 → 2.17.13

package/package.json

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

package/src/cursor_tracker.mm

@@ -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,130 @@ 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";
-                        }
-                        else if ([elementRole isEqualToString:@"AXLink"] ||
-                                 [elementRole isEqualToString:@"AXButton"] ||
-                                 [elementRole isEqualToString:@"AXMenuItem"]) {
-                            contextualCursorType = @"pointer";
+                    // TEXT CURSORS - high priority
+                    if ([elementRole isEqualToString:@"AXTextField"] ||
+                        [elementRole isEqualToString:@"AXTextArea"] ||
+                        [elementRole isEqualToString:@"AXSearchField"]) {
+                        contextualCursorType = @"text";
+                    }
+                    // POINTER CURSORS - only for interactive elements
+                    else if ([elementRole isEqualToString:@"AXLink"] ||
+                             [elementRole isEqualToString:@"AXButton"] ||
+                             [elementRole isEqualToString:@"AXMenuItem"] ||
+                             [elementRole isEqualToString:@"AXRadioButton"] ||
+                             [elementRole isEqualToString:@"AXCheckBox"]) {
+                        contextualCursorType = @"pointer";
+                    }
+                    // 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);
                         }
-                        else if ([elementRole isEqualToString:@"AXProgressIndicator"]) {
-                            contextualCursorType = @"progress";
+                    }
+                    // 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";
+                            }
                         }
                     }
-                    CFRelease(elementAtPosition);
+                    // 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:
+            // 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 and no resize context, use it
+            else if (nsCursorType != nil) {
+                detectedCursorType = nsCursorType;
+            }
+            // 3. If NSCursor is nil/unknown, but contextual is available, use contextual
+            else if (contextualCursorType != nil) {
+                detectedCursorType = contextualCursorType;
             }
 
-            // 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) {