[rfw] Add Flexible widget support to core widgets (#9750)

# [rfw] Add Flexible widget support

This PR adds support for the `Flexible` widget to Remote Flutter Widgets (RFW), allowing developers to create flexible layouts with both loose and tight fitting behavior.

Fixes [#173313](flutter/flutter#173313)

The `Flexible` widget provides more granular control over flex layouts compared to the existing `Expanded` widget:
- **FlexFit.loose**: Widget takes only the space it needs (default)
- **FlexFit.tight**: Widget takes all available space (same as Expanded)

**Implementation:**
- Added `Flexible` widget to `lib/src/flutter/core_widgets.dart`
- Supports `flex` (default: 1) and `fit` parameters (loose/tight, default: loose)
- Uses existing `ArgumentDecoders.enumValue` pattern for FlexFit parsing
- Maintains alphabetical ordering and follows existing RFW patterns
- Added comprehensive test coverage in `test/core_widgets_test.dart`
- Refactored tests based on code review feedback to reduce duplication

**Usage Example:**
```rfwtxt
import core.widgets;

widget FlexibleDemo = Column(
  children: [
    Flexible(
      flex: 1,
      fit: "loose",
      child: Text(text: "Takes needed space"),
    ),
    Flexible(
      flex: 2,
      fit: "tight", 
      child: Text(text: "Takes all available space"),
    ),
  ],
);
```

**API Compatibility:**
Follows Flutter's `Flexible` widget API exactly:
- `flex: int` (default: 1)
- `fit: FlexFit` (loose/tight, default: loose)  
- `child: Widget` (required)

## Pre-Review Checklist

Author: BottlePumpkin

packages/rfw/CHANGELOG.md

@@ -1,5 +1,6 @@
-## NEXT
+## 1.1.0
 
+* Adds support for the `Flexible` core widget.
 * Updates minimum supported SDK version to Flutter 3.35/Dart 3.9.
 
 ## 1.0.32

packages/rfw/lib/src/flutter/core_widgets.dart

@@ -34,6 +34,7 @@ import 'runtime.dart';
 ///  * [DefaultTextStyle]
 ///  * [Directionality]
 ///  * [Expanded]
+///  * [Flexible]
 ///  * [FittedBox]
 ///  * [FractionallySizedBox]
 ///  * [GestureDetector]
@@ -349,6 +350,14 @@ Map<String, LocalWidgetBuilder> get _coreWidgetsDefinitions => <String, LocalWid
     );
   },
 
+  'Flexible': (BuildContext context, DataSource source) {
+    return Flexible(
+      flex: source.v<int>(['flex']) ?? 1,
+      fit: ArgumentDecoders.enumValue<FlexFit>(FlexFit.values, source, ['fit']) ?? FlexFit.loose,
+      child: source.child(['child']),
+    );
+  },
+
   'FittedBox': (BuildContext context, DataSource source) {
     return FittedBox(
       fit: ArgumentDecoders.enumValue<BoxFit>(BoxFit.values, source, ['fit']) ?? BoxFit.contain,

packages/rfw/pubspec.yaml

@@ -2,7 +2,7 @@ name: rfw
 description: "Remote Flutter widgets: a library for rendering declarative widget description files at runtime."
 repository: https://github.com/flutter/packages/tree/main/packages/rfw
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+rfw%22
-version: 1.0.32
+version: 1.1.0
 
 environment:
   sdk: ^3.9.0

packages/rfw/test/core_widgets_test.dart

@@ -300,4 +300,195 @@ void main() {
     expect(renderClip.clipBehavior, equals(Clip.antiAlias));
     expect(renderClip.borderRadius, equals(BorderRadius.zero));
   });
+
+  testWidgets('Flexible widget with default values', (WidgetTester tester) async {
+    final runtime = Runtime()
+      ..update(const LibraryName(<String>['core']), createCoreWidgets());
+    addTearDown(runtime.dispose);
+    final data = DynamicContent();
+
+    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
+      import core;
+      widget root = Directionality(
+        textDirection: "ltr",
+        child: Column(
+          children: [
+            Flexible(
+              child: Text(text: "Default flexible"),
+            ),
+          ],
+        ),
+      );
+    '''));
+
+    await tester.pumpWidget(
+      RemoteWidget(
+        runtime: runtime,
+        data: data,
+        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
+      ),
+    );
+    await tester.pump();
+    expect(find.byType(Flexible), findsOneWidget);
+    final Flexible defaultFlexible = tester.widget<Flexible>(find.byType(Flexible));
+    expect(defaultFlexible.flex, equals(1));
+    expect(defaultFlexible.fit, equals(FlexFit.loose));
+  });
+
+  testWidgets('Flexible widget with custom flex value', (WidgetTester tester) async {
+    final runtime = Runtime()
+      ..update(const LibraryName(<String>['core']), createCoreWidgets());
+    addTearDown(runtime.dispose);
+    final data = DynamicContent();
+
+    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
+      import core;
+      widget root = Directionality(
+        textDirection: "ltr",
+        child: Column(
+          children: [
+            Flexible(
+              flex: 3,
+              child: Text(text: "Custom flex"),
+            ),
+          ],
+        ),
+      );
+    '''));
+
+    await tester.pumpWidget(
+      RemoteWidget(
+        runtime: runtime,
+        data: data,
+        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
+      ),
+    );
+    await tester.pump();
+    expect(find.byType(Flexible), findsOneWidget);
+    final Flexible customFlexFlexible = tester.widget<Flexible>(find.byType(Flexible));
+    expect(customFlexFlexible.flex, equals(3));
+    expect(customFlexFlexible.fit, equals(FlexFit.loose));
+  });
+
+  testWidgets('Flexible widget with fit tight', (WidgetTester tester) async {
+    final runtime = Runtime()
+      ..update(const LibraryName(<String>['core']), createCoreWidgets());
+    addTearDown(runtime.dispose);
+    final data = DynamicContent();
+
+    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
+      import core;
+      widget root = Directionality(
+        textDirection: "ltr",
+        child: Column(
+          children: [
+            Flexible(
+              flex: 2,
+              fit: "tight",
+              child: Text(text: "Tight fit"),
+            ),
+          ],
+        ),
+      );
+    '''));
+
+    await tester.pumpWidget(
+      RemoteWidget(
+        runtime: runtime,
+        data: data,
+        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
+      ),
+    );
+    await tester.pump();
+    expect(find.byType(Flexible), findsOneWidget);
+    final Flexible tightFlexible = tester.widget<Flexible>(find.byType(Flexible));
+    expect(tightFlexible.flex, equals(2));
+    expect(tightFlexible.fit, equals(FlexFit.tight));
+  });
+
+  testWidgets('Flexible widget with fit loose', (WidgetTester tester) async {
+    final runtime = Runtime()
+      ..update(const LibraryName(<String>['core']), createCoreWidgets());
+    addTearDown(runtime.dispose);
+    final data = DynamicContent();
+
+    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
+      import core;
+      widget root = Directionality(
+        textDirection: "ltr",
+        child: Column(
+          children: [
+            Flexible(
+              flex: 4,
+              fit: "loose",
+              child: Text(text: "Loose fit"),
+            ),
+          ],
+        ),
+      );
+    '''));
+
+    await tester.pumpWidget(
+      RemoteWidget(
+        runtime: runtime,
+        data: data,
+        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
+      ),
+    );
+    await tester.pump();
+    expect(find.byType(Flexible), findsOneWidget);
+    final Flexible looseFlexible = tester.widget<Flexible>(find.byType(Flexible));
+    expect(looseFlexible.flex, equals(4));
+    expect(looseFlexible.fit, equals(FlexFit.loose));
+  });
+
+  testWidgets('Multiple Flexible widgets in Column', (WidgetTester tester) async {
+    final runtime = Runtime()
+      ..update(const LibraryName(<String>['core']), createCoreWidgets());
+    addTearDown(runtime.dispose);
+    final data = DynamicContent();
+
+    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
+      import core;
+      widget root = Directionality(
+        textDirection: "ltr",
+        child: Column(
+          children: [
+            Flexible(
+              flex: 1,
+              fit: "loose",
+              child: Text(text: "First"),
+            ),
+            Flexible(
+              flex: 2,
+              fit: "tight",
+              child: Text(text: "Second"),
+            ),
+            Flexible(
+              flex: 1,
+              child: Text(text: "Third"),
+            ),
+          ],
+        ),
+      );
+    '''));
+
+    await tester.pumpWidget(
+      RemoteWidget(
+        runtime: runtime,
+        data: data,
+        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
+      ),
+    );
+    await tester.pump();
+    expect(find.byType(Flexible), findsNWidgets(3));
+
+    final List<Flexible> flexibleWidgets = tester.widgetList<Flexible>(find.byType(Flexible)).toList();
+    expect(flexibleWidgets[0].flex, equals(1));
+    expect(flexibleWidgets[0].fit, equals(FlexFit.loose));
+    expect(flexibleWidgets[1].flex, equals(2));
+    expect(flexibleWidgets[1].fit, equals(FlexFit.tight));
+    expect(flexibleWidgets[2].flex, equals(1));
+    expect(flexibleWidgets[2].fit, equals(FlexFit.loose));
+  });
 }