feat: Prioritize MediaQuery.of(context) in ScreenUtilPlusInit and refactor AdaptiveContainer breakpoint map creation.

Author: muhammadkamel

lib/src/core/screen_util_plus.dart

@@ -101,7 +101,7 @@ class ScreenUtilPlus {
   ///       );
   ///     },
   ///   )
-  /// ```
+  ///   ```
   static Future<void> ensureScreenSize([
     ui.FlutterView? window,
     Duration duration = const Duration(milliseconds: 10),

lib/src/core/screen_util_plus_init.dart

@@ -151,6 +151,10 @@ class _ScreenUtilPlusInitState extends State<ScreenUtilPlusInit>
   }
 
   MediaQueryData? _getMediaQueryData() {
+    final MediaQueryData? mediaQuery = MediaQuery.maybeOf(context);
+    if (mediaQuery != null) {
+      return mediaQuery;
+    }
     final FlutterView? view = View.maybeOf(context);
     return view != null ? MediaQueryData.fromView(view) : null;
   }

lib/src/widgets/adaptive_container.dart

@@ -238,32 +238,27 @@ class SimpleAdaptiveContainer extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     final adaptive = AdaptiveContainer(
-      width: {
-        if (widthXs != null) Breakpoint.xs: widthXs!,
-        if (widthSm != null) Breakpoint.sm: widthSm!,
-        if (widthMd != null) Breakpoint.md: widthMd!,
-        if (widthLg != null) Breakpoint.lg: widthLg!,
-        if (widthXl != null) Breakpoint.xl: widthXl!,
-      },
-      height: {
-        if (heightXs != null) Breakpoint.xs: heightXs!,
-        if (heightSm != null) Breakpoint.sm: heightSm!,
-        if (heightMd != null) Breakpoint.md: heightMd!,
-        if (heightLg != null) Breakpoint.lg: heightLg!,
-        if (heightXl != null) Breakpoint.xl: heightXl!,
-      },
-      padding: {
-        if (paddingXs != null)
-          Breakpoint.xs: EdgeInsets.all(paddingXs!.toDouble()),
-        if (paddingSm != null)
-          Breakpoint.sm: EdgeInsets.all(paddingSm!.toDouble()),
-        if (paddingMd != null)
-          Breakpoint.md: EdgeInsets.all(paddingMd!.toDouble()),
-        if (paddingLg != null)
-          Breakpoint.lg: EdgeInsets.all(paddingLg!.toDouble()),
-        if (paddingXl != null)
-          Breakpoint.xl: EdgeInsets.all(paddingXl!.toDouble()),
-      },
+      width: _createBreakpointMap(
+        xs: widthXs,
+        sm: widthSm,
+        md: widthMd,
+        lg: widthLg,
+        xl: widthXl,
+      ),
+      height: _createBreakpointMap(
+        xs: heightXs,
+        sm: heightSm,
+        md: heightMd,
+        lg: heightLg,
+        xl: heightXl,
+      ),
+      padding: _createBreakpointMap(
+        xs: paddingXs != null ? EdgeInsets.all(paddingXs!.toDouble()) : null,
+        sm: paddingSm != null ? EdgeInsets.all(paddingSm!.toDouble()) : null,
+        md: paddingMd != null ? EdgeInsets.all(paddingMd!.toDouble()) : null,
+        lg: paddingLg != null ? EdgeInsets.all(paddingLg!.toDouble()) : null,
+        xl: paddingXl != null ? EdgeInsets.all(paddingXl!.toDouble()) : null,
+      ),
       color: color,
       decoration: decoration,
       breakpoints: breakpoints,
@@ -272,4 +267,23 @@ class SimpleAdaptiveContainer extends StatelessWidget {
 
     return adaptive;
   }
+
+  Map<Breakpoint, T>? _createBreakpointMap<T>({
+    T? xs,
+    T? sm,
+    T? md,
+    T? lg,
+    T? xl,
+  }) {
+    if (xs == null && sm == null && md == null && lg == null && xl == null) {
+      return null;
+    }
+    return {
+      if (xs != null) Breakpoint.xs: xs,
+      if (sm != null) Breakpoint.sm: sm,
+      if (md != null) Breakpoint.md: md,
+      if (lg != null) Breakpoint.lg: lg,
+      if (xl != null) Breakpoint.xl: xl,
+    };
+  }
 }

test/core/screen_util_plus_init_test.dart

@@ -0,0 +1,53 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_screenutil_plus/flutter_screenutil_plus.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('ScreenUtilPlusInit', () {
+    testWidgets('uses parent MediaQuery data if available', (tester) async {
+      const parentSize = Size(500, 1000);
+      const parentData = MediaQueryData(
+        size: parentSize,
+        devicePixelRatio: 2.0,
+      );
+
+      await tester.pumpWidget(
+        MediaQuery(
+          data: parentData,
+          // ScreenUtilPlusInit inside MediaQuery
+          child: ScreenUtilPlusInit(
+            child: Builder(
+              builder: (context) {
+                // Verify ScreenUtil picked up the size
+                expect(ScreenUtilPlus().screenWidth, parentSize.width);
+                return const SizedBox();
+              },
+            ),
+          ),
+        ),
+      );
+    });
+
+    testWidgets('falls back to View data if no parent MediaQuery', (
+      tester,
+    ) async {
+      tester.view.physicalSize = const Size(1200, 1600);
+      tester.view.devicePixelRatio = 2.0;
+      addTearDown(tester.view.reset);
+
+      // ScreenUtilPlusInit at root (no parent MediaQuery)
+      await tester.pumpWidget(
+        ScreenUtilPlusInit(
+          child: Builder(
+            builder: (context) {
+              // Should use view size (physical / pixelRatio) = 600x800
+              expect(ScreenUtilPlus().screenWidth, 600);
+              expect(ScreenUtilPlus().screenHeight, 800);
+              return const SizedBox();
+            },
+          ),
+        ),
+      );
+    });
+  });
+}

test/widgets/adaptive_container_test.dart

@@ -622,6 +622,25 @@ void main() {
       expect(container.constraints, null);
       expect(container.padding, null);
       expect(container.margin, null);
+      expect(container.margin, null);
+    });
+
+    testWidgets('handles all nulls internally', (tester) async {
+      // This verifies that the internal helper returns null when all inputs are null,
+      // resulting in a standard Container with no AdaptiveContainer behavior overhead.
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: MediaQuery(
+            data: MediaQueryData(size: Size(800, 600)),
+            child: SimpleAdaptiveContainer(child: Text('Test')),
+          ),
+        ),
+      );
+
+      final Container container = tester.widget(find.byType(Container));
+      // No extra constraints or padding should be applied
+      expect(container.constraints, null);
+      expect(container.padding, null);
     });
   });
 }