@breakside/jskit 2025.24.0 → 2025.27.0

package/Root/Frameworks/UIKit/UICursor.js

@@ -153,6 +153,10 @@ UICursor.SystemIdentifier = {
     operationNotAllowed: 'not-allowed',
     resizeLeftRight: 'col-resize',
     resizeUpDown: 'row-resize',
+    resizeEastWest: 'ew-resize',
+    resizeNorthSouth: 'ns-resize',
+    resizeNorthEastSouthWest: 'nesw-resize',
+    resizeNorthWestSouthEast: 'nwse-resize',
     openHand: 'grab',
     closedHand: 'grabbing',
     dragLink: 'alias',
@@ -167,6 +171,10 @@ UICursor.pointingHand = UICursor.initWithSystemIdentifier(UICursor.SystemIdentif
 UICursor.operationNotAllowed = UICursor.initWithSystemIdentifier(UICursor.SystemIdentifier.operationNotAllowed);
 UICursor.resizeLeftRight = UICursor.initWithSystemIdentifier(UICursor.SystemIdentifier.resizeLeftRight);
 UICursor.resizeUpDown = UICursor.initWithSystemIdentifier(UICursor.SystemIdentifier.resizeUpDown);
+UICursor.resizeEastWest = UICursor.initWithSystemIdentifier(UICursor.SystemIdentifier.resizeEastWest);
+UICursor.resizeNorthSouth = UICursor.initWithSystemIdentifier(UICursor.SystemIdentifier.resizeNorthSouth);
+UICursor.resizeNorthEastSouthWest = UICursor.initWithSystemIdentifier(UICursor.SystemIdentifier.resizeNorthEastSouthWest);
+UICursor.resizeNorthWestSouthEast = UICursor.initWithSystemIdentifier(UICursor.SystemIdentifier.resizeNorthWestSouthEast);
 UICursor.openHand = UICursor.initWithSystemIdentifier(UICursor.SystemIdentifier.openHand);
 UICursor.closedHand = UICursor.initWithSystemIdentifier(UICursor.SystemIdentifier.closedHand);
 UICursor.dragLink = UICursor.initWithSystemIdentifier(UICursor.SystemIdentifier.dragLink);

package/Root/Frameworks/UIKit/UIPopupWindow.js

@@ -23,6 +23,7 @@ JSClass("UIPopupWindow", UIWindow, {
     showsSourceArrow: JSDynamicProperty('_showsSourceArrow', false),
     sourceArrowSize: JSDynamicProperty('_sourceArrowSize', 10),
     sourceSpacing: JSDynamicProperty('_sourceSpacing', 0),
+    sourceView: null,
     isUserMovable: false,
     placement: 0,
     canBecomeKey: true,
@@ -41,8 +42,59 @@ JSClass("UIPopupWindow", UIWindow, {
     },
 
     setShowsSourceArrow: function(showsSourceArrow){
+        if (showsSourceArrow === this._showsSourceArrow){
+            return;
+        }
+        if (this._isOpen){
+            var frame = JSRect(this.untransformedFrame);
+            if (this.placement === UIPopupWindow.Placement.left){
+                if (this._showsSourceArrow){
+                    frame.size.width -= this._actualArrowSize;
+                }else{
+                    frame.size.width += this._actualArrowSize;
+                }
+            }else if (this.placement === UIPopupWindow.Placement.right){
+                if (this._showsSourceArrow){
+                    frame.size.width -= this._actualArrowSize;
+                    frame.origin.x += this._actualArrowSize;
+                    if (this._downLocation !== null){
+                        this._downLocation.x -= this._actualArrowSize;
+                    }
+                }else{
+                    frame.size.width += this._actualArrowSize;
+                    frame.origin.x -= this._actualArrowSize;
+                    if (this._downLocation !== null){
+                        this._downLocation.x += this._actualArrowSize;
+                    }
+                }
+            }else if (this.placement === UIPopupWindow.Placement.above){
+                if (this._showsSourceArrow){
+                    frame.size.height -= this._actualArrowSize;
+                }else{
+                    frame.size.height += this._actualArrowSize;
+                }
+            }else if (this.placement === UIPopupWindow.Placement.below){
+                if (this._showsSourceArrow){
+                    frame.size.height -= this._actualArrowSize;
+                    frame.origin.y += this._actualArrowSize;
+                    if (this._downLocation !== null){
+                        this._downLocation.y -= this._actualArrowSize;
+                    }
+                }else{
+                    frame.size.height += this._actualArrowSize;
+                    frame.origin.y -= this._actualArrowSize;
+                    if (this._downLocation !== null){
+                        this._downLocation.x += this._actualArrowSize;
+                    }
+                }
+            }
+            this.untransformedFrame = frame;
+        }
         this._showsSourceArrow = showsSourceArrow;
         this._styler.updateWindow(this);
+        if (this._isOpen && !this._showsSourceArrow){
+            JSNotificationCenter.shared.post("UIPopupWindowDidDetachFromSource", this);
+        }
     },
 
     setSourceArrowSize: function(sourceArrowSize){
@@ -68,7 +120,7 @@ JSClass("UIPopupWindow", UIWindow, {
             animated = true;
         }
         var sourceFrame = view.convertRectToScreen(view.bounds).rectWithInsets(-this._sourceSpacing);
-        var safeFrame = view.window.screen.availableFrame;
+        var safeFrame = view.window.screen.availableFrame.rectWithInsets(20);
 
         // Size to our content's preferred size
         this.sizeToFit();
@@ -153,8 +205,8 @@ JSClass("UIPopupWindow", UIWindow, {
             if (frame.origin.x + frame.size.width > safeFrame.origin.x + safeFrame.size.width){
                 frame.origin.x = safeFrame.origin.x + safeFrame.size.width - frame.size.width;
             }
-            if (frame.origin.x < 0){
-                frame.origin.x = 0;
+            if (frame.origin.x < safeFrame.origin.x){
+                frame.origin.x = safeFrame.origin.x;
                 if (frame.size.width > safeFrame.size.width){
                     frame.size.width = safeFrame.size.width;
                 }
@@ -164,8 +216,8 @@ JSClass("UIPopupWindow", UIWindow, {
             if (frame.origin.y + frame.size.height > safeFrame.origin.y + safeFrame.size.height){
                 frame.origin.y = safeFrame.origin.y + safeFrame.size.height - frame.size.height;
             }
-            if (frame.origin.y < 0){
-                frame.origin.y = 0;
+            if (frame.origin.y < safeFrame.origin.y){
+                frame.origin.y = safeFrame.origin.y;
                 if (frame.size.height > safeFrame.size.height){
                     frame.size.height = safeFrame.size.height;
                 }
@@ -216,6 +268,7 @@ JSClass("UIPopupWindow", UIWindow, {
 
         this.placement = placement;
         this.frame = frame;
+        this.sourceView = view;
 
         // Create animated opening, closing
         if (animated){
@@ -241,12 +294,96 @@ JSClass("UIPopupWindow", UIWindow, {
         this.makeKeyAndOrderFront();
     },
 
+    repositionSourceArrow: function(){
+        var view = this.sourceView;
+        if (view === null){
+            return;
+        }
+        var sourceFrame = view.convertRectToScreen(view.bounds);
+        var frame = this.untransformedFrame;
+        if (sourceFrame === null){
+            this.sourceView = null;
+            this.showsSourceArrow = false;
+            return;
+        }
+        var x, y;
+        var minY = frame.origin.y + this.styler.cornerRadius + this._actualArrowSize;
+        var maxY = frame.origin.y + frame.size.height - this.styler.cornerRadius - this._actualArrowSize;
+        var minX = frame.origin.x + this.styler.cornerRadius + this._actualArrowSize;
+        var maxX = frame.origin.x + frame.size.width - this.styler.cornerRadius - this._actualArrowSize;
+        if (this.placement === UIPopupWindow.Placement.left){
+            x = sourceFrame.origin.x - this._sourceSpacing;
+            if (Math.abs(frame.origin.x + frame.size.width - x) < 1){
+                y = sourceFrame.center.y;
+                if (y >= minY && y <= maxY){
+                    this.anchorPoint = JSPoint(1, (y - frame.origin.y) / frame.size.height);
+                    this.untransformedFrame = frame;
+                    this.setNeedsLayout();
+                }else{
+                    this.sourceView = null;
+                    this.showsSourceArrow = false;
+                }
+            }else{
+                this.sourceView = null;
+                this.showsSourceArrow = false;
+            }
+        }else if (this.placement === UIPopupWindow.Placement.right){
+            x = sourceFrame.origin.x + sourceFrame.size.width + this._sourceSpacing;
+            if (Math.abs(frame.origin.x - x) < 1){
+                y = sourceFrame.center.y;
+                if (y >= minY && y <= maxY){
+                    this.anchorPoint = JSPoint(0, (y - frame.origin.y) / frame.size.height);
+                    this.untransformedFrame = frame;
+                    this.setNeedsLayout();
+                }else{
+                    this.sourceView = null;
+                    this.showsSourceArrow = false;
+                }
+            }else{
+                this.sourceView = null;
+                this.showsSourceArrow = false;
+            }
+        }else if (this.placement === UIPopupWindow.Placement.above){
+            y = sourceFrame.origin.y - this._sourceSpacing;
+            if (Math.abs(frame.origin.y + frame.size.height - y) < 1){
+                x = sourceFrame.center.x;
+                if (x >= minX && x <= maxX){
+                    this.anchorPoint = JSPoint((x - frame.origin.x) / frame.size.width, 1);
+                    this.untransformedFrame = frame;
+                    this.setNeedsLayout();
+                }else{
+                    this.sourceView = null;
+                    this.showsSourceArrow = false;
+                }
+            }else{
+                this.sourceView = null;
+                this.showsSourceArrow = false;
+            }
+        }else if (this.placement === UIPopupWindow.Placement.below){
+            y = sourceFrame.origin.y + sourceFrame.size.height + this._sourceSpacing;
+            if (Math.abs(frame.origin.y - y) < 1){
+                x = sourceFrame.center.x;
+                if (x >= minX && x <= maxX){
+                    this.anchorPoint = JSPoint((x - frame.origin.x) / frame.size.width, 0);
+                    this.untransformedFrame = frame;
+                    this.setNeedsLayout();
+                }else{
+                    this.sourceView = null;
+                    this.showsSourceArrow = false;
+                }
+            }else{
+                this.sourceView = null;
+                this.showsSourceArrow = false;
+            }
+        }
+    },
+
     openCenteredInView: function(view, animated){
         if (animated === undefined){
             animated = true;
         }
         var sourceFrame = view.convertRectToScreen(view.bounds);
-        var safeFrame = view.window.screen.availableFrame;
+        var safeFrame = view.window.screen.availableFrame.rectWithInsets(20);
 
         this.sizeToFit();
         var frame = JSRect(this.frame);
@@ -281,9 +418,12 @@ JSClass("UIPopupWindow", UIWindow, {
                 this.closeAnimator = closeAnimator;
             }
         }
-
         this.makeKeyAndOrderFront();
+    },
 
+    close: function(){
+        UIPopupWindow.$super.close.call(this);
+        this.sourceView = null;
     },
 
     modalIndicationClosesWindow: false,
@@ -300,7 +440,33 @@ JSClass("UIPopupWindow", UIWindow, {
         UIPopupWindow.$super.indicateModalStatus.call(this);
     },
 
-    accessibilityRole: UIAccessibility.Role.popover
+    accessibilityRole: UIAccessibility.Role.popover,
+
+    minimumMoveDistance: 10,
+
+    mouseDragged: function(event){
+        if (this._showsSourceArrow && this._isMoving){
+            var frameBeforeMoving = this.frame;
+            var location = this.convertPointToScreen(event.locationInWindow);
+            var distance = this._downLocation ? location.distanceToPoint(this._downLocation) : JSPoint.Zero;
+            UIPopupWindow.$super.mouseDragged.call(this, event);
+            this._didMove = distance >= this.minimumMoveDistance;
+            if (this._didMove){
+                this.showsSourceArrow = false;
+            }else{
+                this.frame = frameBeforeMoving;
+            }
+        }else{
+            UIPopupWindow.$super.mouseDragged.call(this, event);
+        }
+    },
+
+    _windowServerDidResize: function(){
+        UIPopupWindow.$super._windowServerDidResize.call(this);
+        if (this._showsSourceArrow){
+            this.repositionSourceArrow();
+        }
+    },
 
 });
 
@@ -428,6 +594,9 @@ JSClass("UIPopupWindowStyler", UIWindowStyler, {
                 popupArrow.position = anchorPosition;
                 popupArrow.anchorPoint = JSPoint(0.5, 0);
             }
+            window._resizeView = popupBacking;
+        }else{
+            window._resizeView = null;
         }
         window._contentView.frame = window.bounds.rectWithInsets(contentInsets);
     },

package/Root/Frameworks/UIKit/UIWindow.js

@@ -327,6 +327,9 @@ JSClass('UIWindow', UIView, {
             this._setTraitCollection(traits);
         }
     },
+
+    _windowServerDidResize: function(){
+    },
     
     traitCollection: JSReadOnlyProperty('_traitCollection', null),
 
@@ -417,6 +420,7 @@ JSClass('UIWindow', UIView, {
         if (!this._isOpen){
             return;
         }
+        JSNotificationCenter.shared.post("UIWindowWillClose", this);
         if (this.viewController){
             this.viewController.viewWillDisappear(false);
         }else if (this._contentViewController){
@@ -426,13 +430,14 @@ JSClass('UIWindow', UIView, {
             this.openAnimator.stopAndCallCompletions();
         }
         if (this.closeAnimator !== null){
-            var self = this;
             this.closeAnimator.addCompletion(function(){
-                self.windowServer.windowRemoved(self);
-            });
+                this.windowServer.windowRemoved(this);
+                JSNotificationCenter.shared.post("UIWindowDidClose", this);
+            }, this);
             this.closeAnimator.start();
         }else{
             this.windowServer.windowRemoved(this);
+            JSNotificationCenter.shared.post("UIWindowDidClose", this);
         }
         this._isOpen = false;
     },
@@ -663,6 +668,24 @@ JSClass('UIWindow', UIView, {
         return responder;
     },
 
+    minimumSize: JSDynamicProperty("_minimumSize", null),
+    maximumSize: JSDynamicProperty("_maximumSize", null),
+    _canResizeWidth: false,
+    _canResizeHeight: false,
+    _resizeView: null,
+
+    setMinimumSize: function(minimumSize){
+        this._minimumSize = JSSize(minimumSize);
+        this._canResizeWidth = this._minimumSize !== null && this._maximumSize !== null && this._minimumSize.width !== this._maximumSize.width;
+        this._canResizeHeight = this._minimumSize !== null && this._maximumSize !== null && this._minimumSize.height !== this._maximumSize.height;
+    },
+
+    setMaximumSize: function(maximumSize){
+        this._maximumSize = JSSize(maximumSize);
+        this._canResizeWidth = this._minimumSize !== null && this._maximumSize !== null && this._minimumSize.width !== this._maximumSize.width;
+        this._canResizeHeight = this._minimumSize !== null && this._maximumSize !== null && this._minimumSize.height !== this._maximumSize.height;
+    },
+
     // -------------------------------------------------------------------------
     // MARK: - First Responder
 

package/Root/Frameworks/UIKit/UIWindowServer.js

@@ -595,6 +595,52 @@ JSClass("UIWindowServer", JSObject, {
             return;
         }
 
+        var event;
+        var targetWindow;
+        var locationInWindow;
+
+        // window resizing is handled by the window server itself, rather than
+        // passing events to windows
+        if (this._windowResizeWindow !== null && this._windowResizeMouseEventData === null && type === UIEvent.Type.leftMouseDown && this.mouseDownCount === 0){
+            locationInWindow = this._windowResizeWindow.convertPointFromScreen(location);
+            var resizeOperation = this.windowResizeHitTest(this._windowResizeWindow, locationInWindow);
+            if (resizeOperation !== UIWindowServer.ResizeOperation.none){
+                this._mouseIdleTimer.invalidate();
+                if (this._tooltipWindow !== null){
+                    this.hideTooltip();
+                }
+                this._leftClickCount = 1;
+                this._rightClickCount = 0;
+                this.mouseDownCount = 1;
+                this.mouseEventWindow = null;
+                this._previousMouseEventWindow = null;
+                this._windowResizeMouseEventData = {
+                    operation: resizeOperation,
+                    location0: JSPoint(location)
+                };
+            }else{
+                if (this._windowResizeCursor !== null){
+                    this._windowResizeCursor.pop();
+                    this._windowResizeCursor = null;
+                }
+                this._windowResizeWindow = null;
+            }
+        }
+        if (this._windowResizeMouseEventData !== null){
+            if (locationInWindow === undefined || locationInWindow === null){
+                locationInWindow = this._windowResizeWindow.convertPointFromScreen(location);
+            }
+            event = UIEvent.initMouseEventWithType(type, timestamp, this._windowResizeWindow, locationInWindow, modifiers, this._leftClickCount);
+            this.handleWindowResizeMouseEvent(event, location);
+            if (type === UIEvent.Type.leftMouseUp){
+                this._leftClickCount = 0;
+                this.mouseDownCount = 0;
+                this._windowResizeMouseEventData = null;
+                this.sendMouseTrackingEvents(timestamp, modifiers);
+            }
+            return;
+        }
+
         if (isADown){
             this._mouseIdleTimer.invalidate();
             if (this._tooltipWindow !== null){
@@ -643,8 +689,7 @@ JSClass("UIWindowServer", JSObject, {
                 break;
         }
 
-        var event;
-        var targetWindow = this.mouseEventWindow;
+        targetWindow = this.mouseEventWindow;
 
         if (isAnUp){
             --this.mouseDownCount;
@@ -664,7 +709,8 @@ JSClass("UIWindowServer", JSObject, {
             }
         }
         if (targetWindow !== null){
-            event = UIEvent.initMouseEventWithType(type, timestamp, targetWindow, targetWindow.convertPointFromScreen(location), modifiers, clickCount);
+            locationInWindow = targetWindow.convertPointFromScreen(location);
+            event = UIEvent.initMouseEventWithType(type, timestamp, targetWindow, locationInWindow, modifiers, clickCount);
             this._sendEventToApplication(event, targetWindow.application);
         }
     },
@@ -747,30 +793,211 @@ JSClass("UIWindowServer", JSObject, {
     _mouseTrackingWindow: null,
 
     sendMouseTrackingEvents: function(timestamp, modifiers){
-        var window = null;
+        var mouseTrackingWindow = null;
+        var resizeWindow = null;
         var windowIndex;
+        var window;
         var location;
         var event;
         var hasWindowReceivingAllEvents = false;
-        for (windowIndex = this.windowStack.length - 1; windowIndex >= 0 && window === null; --windowIndex){
-            location = this.windowStack[windowIndex].convertPointFromScreen(this.mouseLocation);
-            hasWindowReceivingAllEvents = hasWindowReceivingAllEvents || this.windowStack[windowIndex].receivesAllEvents;
-            if (this.windowStack[windowIndex].userInteractionEnabled && this.windowStack[windowIndex].containsPoint(location)){
-                window = this.windowStack[windowIndex];
+        var hasSeenMainWindow = false;
+        var resizeOperation = UIWindowServer.ResizeOperation.none;
+        for (windowIndex = this.windowStack.length - 1; windowIndex >= 0 && mouseTrackingWindow === null; --windowIndex){
+            window = this.windowStack[windowIndex];
+            if (!window.hidden){
+                location = window.convertPointFromScreen(this.mouseLocation);
+                hasWindowReceivingAllEvents = hasWindowReceivingAllEvents || window.receivesAllEvents;
+                if (window.userInteractionEnabled){
+                    if (!hasSeenMainWindow){
+                        resizeOperation = this.windowResizeHitTest(window, location);
+                    }
+                    if (resizeOperation !== UIWindowServer.ResizeOperation.none){
+                        mouseTrackingWindow = window;
+                    }else if (window.containsPoint(location)){
+                        mouseTrackingWindow = window;
+                    }
+                }
+                hasSeenMainWindow = hasSeenMainWindow || window === this.mainWindow;
             }
         }
-        if (hasWindowReceivingAllEvents && window !== null && !window.receivesAllEvents){
-            window = null;
+        if (hasWindowReceivingAllEvents && mouseTrackingWindow !== null && !mouseTrackingWindow.receivesAllEvents){
+            mouseTrackingWindow = null;
+            resizeOperation = UIWindowServer.ResizeOperation.none;
+        }
+        if (resizeOperation !== UIWindowServer.ResizeOperation.none){
+            resizeWindow = mouseTrackingWindow;
+            mouseTrackingWindow = null;
         }
         if (this._mouseTrackingWindow !== null){
-            if (window !== this._mouseTrackingWindow){
+            if (mouseTrackingWindow !== this._mouseTrackingWindow){
                 this._mouseTrackingWindow.sendMouseTrackingEvents(this._mouseTrackingWindow.convertPointFromScreen(this.mouseLocation), timestamp, modifiers, true);
             }
         }
-        this._mouseTrackingWindow = window;
+        this._mouseTrackingWindow = mouseTrackingWindow;
         if (this._mouseTrackingWindow !== null){
             this._mouseTrackingWindow.sendMouseTrackingEvents(this._mouseTrackingWindow.convertPointFromScreen(this.mouseLocation), timestamp, modifiers, false);
         }
+        var resizeCursor = null;
+        if (resizeOperation !== UIWindowServer.ResizeOperation.none){
+            resizeCursor = this.cursorForWindowResizeOperation(resizeWindow, resizeOperation);
+        }
+        if (resizeCursor !== this._windowResizeCursor){
+            if (this._windowResizeCursor !== null){
+                this._windowResizeCursor.pop();
+            }
+            this._windowResizeCursor = resizeCursor;
+            if (this._windowResizeCursor !== null){
+                this._windowResizeCursor.push();
+            }
+        }
+        this._windowResizeWindow = resizeWindow;
+    },
+
+    _windowResizeCursor: null,
+    _windowResizeWindow: null,
+    _windowResizeMouseEventData: null,
+    _windowResizeWidthInside: 4,
+    _windowResizeWidthOutside: 4,
+
+    windowResizeHitTest: function(window, location){
+        if (!window._canResizeWidth && !window._canResizeHeight){
+            return UIWindowServer.ResizeOperation.none;
+        }
+        var resizeView = window;
+        if (window._resizeView !== null){
+            resizeView = window._resizeView;
+            location = window.convertPointToView(location, resizeView);
+        }
+        var resizeFrame = resizeView.bounds;
+        var cornerSize = Math.max(resizeView.cornerRadius, this._windowResizeWidthInside);
+        if (location.y < resizeFrame.origin.y - this._windowResizeWidthOutside){
+            return UIWindowServer.ResizeOperation.none;
+        }
+        if (location.x < resizeFrame.origin.x - this._windowResizeWidthOutside){
+            return UIWindowServer.ResizeOperation.none;
+        }
+        if (location.y > resizeFrame.origin.y + resizeFrame.size.height + this._windowResizeWidthOutside){
+            return UIWindowServer.ResizeOperation.none;
+        }
+        if (location.x > resizeFrame.origin.x + resizeFrame.size.width + this._windowResizeWidthOutside){
+            return UIWindowServer.ResizeOperation.none;
+        }
+        if (window._canResizeWidth && window._canResizeHeight){
+            if ((location.y <= resizeFrame.origin.y + cornerSize) && (location.x <= resizeFrame.origin.x + cornerSize)){
+                return UIWindowServer.ResizeOperation.topLeft;
+            }
+            if ((location.y <= resizeFrame.origin.y + cornerSize) && (location.x >= resizeFrame.origin.x + resizeFrame.size.width - cornerSize)){
+                return UIWindowServer.ResizeOperation.topRight;
+            }
+            if ((location.y >= resizeFrame.origin.y + resizeFrame.size.height - cornerSize) && (location.x >= resizeFrame.origin.x + resizeFrame.size.width - cornerSize)){
+                return UIWindowServer.ResizeOperation.bottomRight;
+            }
+            if ((location.y >= resizeFrame.origin.y + resizeFrame.size.height - cornerSize) && (location.x <= resizeFrame.origin.x + cornerSize)){
+                return UIWindowServer.ResizeOperation.bottomLeft;
+            }
+        }
+        if (window._canResizeWidth){
+            if (location.x <= resizeFrame.origin.x + this._windowResizeWidthInside){
+                return UIWindowServer.ResizeOperation.left;
+            }
+            if (location.x >= resizeFrame.origin.x + resizeFrame.size.width - this._windowResizeWidthInside){
+                return UIWindowServer.ResizeOperation.right;
+            }
+        }
+        if (window._canResizeHeight){
+            if (location.y <= resizeFrame.origin.y + this._windowResizeWidthInside){
+                return UIWindowServer.ResizeOperation.top;
+            }
+            if (location.y >= resizeFrame.origin.y + resizeFrame.size.height - this._windowResizeWidthInside){
+                return UIWindowServer.ResizeOperation.bottom;
+            }
+        }
+        return UIWindowServer.ResizeOperation.none;
+    },
+
+    handleWindowResizeMouseEvent: function(event, location){
+        var frame;
+        // FIXME: assuming no scale or rotation in window.transform
+        if (event.type === UIEvent.Type.leftMouseDown){
+            frame = event.window._resizeView !== null ? event.window._resizeView.bounds : event.window.bounds;
+            this._windowResizeMouseEventData.frame0 = event.window.untransformedFrame;
+            this._windowResizeMouseEventData.maximumResize = JSSize(
+                event.window.maximumSize.width - frame.size.width,
+                event.window.maximumSize.height - frame.size.height
+            );
+            this._windowResizeMouseEventData.minimumResize = JSSize(
+                event.window.minimumSize.width - frame.size.width,
+                event.window.minimumSize.height - frame.size.height
+            );
+        }else if (event.type === UIEvent.Type.leftMouseDragged){
+            var diff = location.subtracting(this._windowResizeMouseEventData.location0);
+            var over;
+            var resizeOperation = this._windowResizeMouseEventData.operation;
+            frame = JSRect(this._windowResizeMouseEventData.frame0);
+            if (resizeOperation === UIWindowServer.ResizeOperation.top || resizeOperation === UIWindowServer.ResizeOperation.topLeft  || resizeOperation === UIWindowServer.ResizeOperation.topRight){
+                if (diff.y < 0 && diff.y < -this._windowResizeMouseEventData.maximumResize.height){
+                    diff.y = -this._windowResizeMouseEventData.maximumResize.height;
+                }else if (diff.y > 0 && diff.y > -this._windowResizeMouseEventData.minimumResize.height){
+                    diff.y = -this._windowResizeMouseEventData.minimumResize.height;
+                }
+                frame.origin.y += diff.y;
+                frame.size.height -= diff.y;
+            }else if (resizeOperation === UIWindowServer.ResizeOperation.bottom || resizeOperation === UIWindowServer.ResizeOperation.bottomLeft  || resizeOperation === UIWindowServer.ResizeOperation.bottomRight){
+                if (diff.y > 0 && diff.y > this._windowResizeMouseEventData.maximumResize.height){
+                    diff.y = this._windowResizeMouseEventData.maximumResize.height;
+                }else if (diff.y < 0 && diff.y < this._windowResizeMouseEventData.minimumResize.height){
+                    diff.y = this._windowResizeMouseEventData.minimumResize.height;
+                }
+                frame.size.height += diff.y;
+            }
+            if (resizeOperation === UIWindowServer.ResizeOperation.left || resizeOperation === UIWindowServer.ResizeOperation.topLeft  || resizeOperation === UIWindowServer.ResizeOperation.bottomLeft){
+                if (diff.x < 0 && diff.x < -this._windowResizeMouseEventData.maximumResize.width){
+                    diff.x = -this._windowResizeMouseEventData.maximumResize.width;
+                }else if (diff.x > 0 && diff.x > -this._windowResizeMouseEventData.minimumResize.width){
+                    diff.x = -this._windowResizeMouseEventData.minimumResize.width;
+                }
+                frame.origin.x += diff.x;
+                frame.size.width -= diff.x;
+            }else if (resizeOperation === UIWindowServer.ResizeOperation.right || resizeOperation === UIWindowServer.ResizeOperation.topRight  || resizeOperation === UIWindowServer.ResizeOperation.bottomRight){
+                if (diff.x > 0 && diff.x > this._windowResizeMouseEventData.maximumResize.width){
+                    diff.x = this._windowResizeMouseEventData.maximumResize.width;
+                }else if (diff.x < 0 && diff.x < this._windowResizeMouseEventData.minimumResize.width){
+                    diff.x = this._windowResizeMouseEventData.minimumResize.width;
+                }
+                frame.size.width += diff.x;
+            }
+            event.window.untransformedFrame = frame;
+            event.window._windowServerDidResize();
+        }
+    },
+
+    cursorForWindowResizeOperation: function(window, resizeOperation){
+        // TODO: consider window transform
+        if (resizeOperation === UIWindowServer.ResizeOperation.top){
+            return UICursor.resizeNorthSouth;
+        }
+        if (resizeOperation === UIWindowServer.ResizeOperation.left){
+            return UICursor.resizeEastWest;
+        }
+        if (resizeOperation === UIWindowServer.ResizeOperation.bottom){
+            return UICursor.resizeNorthSouth;
+        }
+        if (resizeOperation === UIWindowServer.ResizeOperation.right){
+            return UICursor.resizeEastWest;
+        }
+        if (resizeOperation === UIWindowServer.ResizeOperation.topLeft){
+            return UICursor.resizeNorthWestSouthEast;
+        }
+        if (resizeOperation === UIWindowServer.ResizeOperation.topRight){
+            return UICursor.resizeNorthEastSouthWest;
+        }
+        if (resizeOperation === UIWindowServer.ResizeOperation.bottomLeft){
+            return UICursor.resizeNorthEastSouthWest;
+        }
+        if (resizeOperation === UIWindowServer.ResizeOperation.bottomRight){
+            return UICursor.resizeNorthWestSouthEast;
+        }
+        return null;
     },
 
     // -----------------------------------------------------------------------
@@ -1129,6 +1356,18 @@ JSClass("UIWindowServer", JSObject, {
 
 });
 
+UIWindowServer.ResizeOperation = {
+    none: 0,
+    top: 1,
+    left: 2,
+    bottom: 3,
+    right: 4,
+    topLeft: 5,
+    topRight: 6,
+    bottomLeft: 7,
+    bottomRight: 8
+};
+
 JSClass("UIWindowServerAccessibilityHighlightView", UIView, {
 
     framesetter: JSLazyInitProperty(function(){

package/Root/Frameworks/UIKitTesting/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.UIKitTesting
-JSBundleVersion: 2025.24.0
+JSBundleVersion: 2025.27.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSLicenseNotice: |

package/package.json

@@ -9,7 +9,7 @@
     "node": ">=10.10.0"
   },
   "name": "@breakside/jskit",
-  "version": "2025.24.0",
+  "version": "2025.27.0",
   "license": "SEE LICENSE IN LICENSE.txt",
   "files": [
     "*"