🔧 Fix stack overflow when clamping rect is smaller than the main rect.

Author: SaadArdati

packages/box_transform/lib/src/enums.dart

@@ -200,6 +200,30 @@ enum HandlePosition {
         throw ArgumentError('HandlePosition.none is not supported!');
     }
   }
+
+  /// Displayable representation of the [HandlePosition] value.
+  String get prettify {
+    switch (this) {
+      case HandlePosition.topLeft:
+        return 'Top Left';
+      case HandlePosition.top:
+        return 'Top';
+      case HandlePosition.topRight:
+        return 'Top Right';
+      case HandlePosition.left:
+        return 'Left';
+      case HandlePosition.right:
+        return 'Right';
+      case HandlePosition.bottomLeft:
+        return 'Bottom Left';
+      case HandlePosition.bottom:
+        return 'Bottom';
+      case HandlePosition.bottomRight:
+        return 'Bottom Right';
+      case HandlePosition.none:
+        return 'None';
+    }
+  }
 }
 
 /// Represents the flip state of a rectangle, or, in other words, if the

packages/box_transform/lib/src/resizers/scale_resizing.dart

@@ -13,6 +13,53 @@ final class ScaleResizer extends Resizer {
     required HandlePosition handle,
     required Constraints constraints,
     required Flip flip,
+  }) {
+    ({Box rect, Box largest, bool hasValidFlip}) result = _resizeRect(
+      initialRect: initialRect,
+      explodedRect: explodedRect,
+      clampingRect: clampingRect,
+      handle: handle,
+      constraints: constraints,
+      flip: flip,
+    );
+
+    if (!result.hasValidFlip) {
+      // Since we can't flip the box, explodedRect (which is a raw rect with delta applied)
+      // would be flipped so we can't use that because it would make the size
+      // calculations wrong. Instead we use box from the result which is the
+      // flipped box but with correct constraints applied. (min rect always).
+      final newResult = _resizeRect(
+        explodedRect: result.rect,
+        initialRect: initialRect,
+        clampingRect: clampingRect,
+        handle: handle,
+        flip: Flip.none,
+        constraints: constraints,
+      );
+
+      if (!newResult.hasValidFlip) {
+        // This should never happen. If it does, it means that the box is
+        // invalid even after flipping it back to the original state and we
+        // can't flip it back again. This means that the box might be invalid
+        // in the first place or something catastrophic happened!!! Contact
+        // the package author if this happens.
+        return (rect: initialRect,largest: clampingRect, hasValidFlip: false);
+        throw StateError('Box found to be invalid more than once!');
+      }
+
+      return newResult;
+    }
+
+    return result;
+  }
+
+  ({Box rect, Box largest, bool hasValidFlip}) _resizeRect({
+    required Box initialRect,
+    required Box explodedRect,
+    required Box clampingRect,
+    required HandlePosition handle,
+    required Constraints constraints,
+    required Flip flip,
   }) {
     final flippedHandle = handle.flip(flip);
     final effectiveInitialRect = flipRect(initialRect, flip, handle);
@@ -56,21 +103,6 @@ final class ScaleResizer extends Resizer {
         break;
     }
 
-    if (!result.hasValidFlip) {
-      // Since we can't flip the box, explodedRect (which is a raw rect with delta applied)
-      // would be flipped so we can't use that because it would make the size
-      // calculations wrong. Instead we use box from the result which is the
-      // flipped box but with correct constraints applied. (min rect always).
-      return resize(
-        explodedRect: result.rect,
-        initialRect: initialRect,
-        clampingRect: clampingRect,
-        handle: handle,
-        flip: Flip.none,
-        constraints: constraints,
-      );
-    }
-
     return result;
   }
 

packages/box_transform/lib/src/transformer.dart

@@ -118,6 +118,26 @@ class BoxTransformer {
       );
     }
 
+    // Check if clampingRect is smaller than initialRect.
+    // If it is, then we return the initialRect and not resize it.
+    if (clampingRect.width < initialRect.width ||
+        clampingRect.height < initialRect.height) {
+      return ResizeResult(
+        rect: initialRect,
+        oldRect: initialRect,
+        flip: initialFlip,
+        resizeMode: resizeMode,
+        delta: delta,
+        handle: handle,
+        rawSize: initialRect.size,
+        minWidthReached: false,
+        minHeightReached: false,
+        largestRect: clampingRect,
+        maxHeightReached: false,
+        maxWidthReached: false,
+      );
+    }
+
     // Symmetric resizing requires the delta to be doubled since it grows or
     // shrinks in all directions from center.
     if (resizeMode.hasSymmetry) delta = Vector2(delta.x * 2, delta.y * 2);