FED-279: Add improved prop forwarding method

lib/src/component_declaration/builder_helpers.dart

@@ -134,6 +134,91 @@ abstract class UiProps extends component_base.UiProps with GeneratedClass {
   @toBeGenerated PropsMetaCollection get staticMeta => throw UngeneratedError(member: #meta);
 }
 
+
+/*
+UiComponent:
+..addProps(copyUnconsumedProps())
+
+UiComponent2:
+..modifyProps(addUnconsumedProps)
+
+UiFunction and UiComponent2:
+final consumedProps = props.staticMeta.forMixins({BarPropsMixin});
+...
+..addUnconsumedProps(props, consumedProps)
+
+
+Proposed:
+// By default the method not return props for the class it is being called on which makes it super easy and convenient.
+// eg. if `props` is of type `MyPropsMixin` then it would be equivalent to something like `props.getUnconsumed(consumed: {MyPropsMixin})`
+
+
+..addAll(props.getUnconsumed())
+
+..addAll(props.getUnconsumed({MyProps}));
+..addAll(props.getUnconsumed(consumed: {MyProps}));
+..addAll(props.getUnconsumedProps(consumedPropsMixins: {MyProps}))
+
+..addAll(props.getUnconsumed(exclude: {MyProps}))
+
+*/
+
+extension UnusedProps<T extends UiProps> on T {
+
+  /// Returns this instance's props map excluding the keys found in [consumedMixins].
+  ///
+  /// [consumedMixins] should be a `Set` of PropsMixin `Type`s.
+  /// If [consumedMixins] is not set it defaults to using the current instances Type.
+  ///
+  /// __Example:__
+  ///
+  /// ```dart
+  /// // within a functional component: `uiFunction<FooPropsMixin>`
+  /// // filter out the current components props when forwarding to Bar.
+  /// return (Bar()..addAll(props.getConsumed()))();
+  /// ```
+  /// OR
+  /// ```dart
+  /// // within a functional component that has multiple mixins on a Props class: `uiFunction<FooProps>`
+  /// // filter out the Components props when forwarding to Bar.
+  /// return (Bar()..addAll(props.getConsumed(consumedMixins:{FooPropsMixin}))();
+  /// ```
+  ///
+  /// To only add DOM props, use [addUnconsumedDomProps].
+  ///
+  /// Related: `UiComponent2`'s `addUnconsumedProps`
+  Map getPropsToForward({Set<Type> exclude, Set<Type> include, bool domOnly = false}) {
+    final useDefaultExclude = exclude == null && (include == null || (include is Set && include.isEmpty));
+    try {
+      Iterable<PropsMeta> includedProps = [];
+      final unconsumedProps = {};
+      Iterable<PropsMeta> consumedProps;
+      List<List<String>> consumedPropKeys;
+      final excludedProps = staticMeta.forMixins(useDefaultExclude ? {T} : exclude ?? {});
+      final excludedPropKeys = excludedProps.map((consumeProps) => consumeProps.keys).toList();
+
+      if (include != null) {
+        includedProps = staticMeta.allExceptForMixins(include);
+        consumedProps = includedProps.toList()..removeWhere((element) => excludedPropKeys.any((ex) => element.keys.any((el) => !ex.contains(el))));
+        consumedPropKeys = consumedProps.map((consumedProps) => consumedProps.keys).toList();
+      } else {
+        consumedProps = excludedProps;
+        consumedPropKeys = consumedProps.map((consumedProps) => consumedProps.keys).toList();
+      }
+
+      forwardUnconsumedPropsV2(props, propsToUpdate: unconsumedProps, keySetsToOmit: consumedPropKeys, onlyCopyDomProps: domOnly);
+      return unconsumedProps;
+      } catch(_) {
+        if (useDefaultExclude) {
+          throw ArgumentError('Could not find props meta for type $T.'
+            ' If this is not a props mixin, you need to specify the mixins to be excluded as the second argument to `getUnconsumed`.  For example:'
+            '\n  ..addAll(props.getUnconsumed({${T}Mixin}, …)');
+        }
+        rethrow;
+      }
+  }
+}
+
 /// A [dart.collection.MapView]-like class with strongly-typed getters/setters for React state.
 ///
 /// To be used with the over_react builder to generate concrete state implementations

test/over_react/component_declaration/builder_integration_tests/new_boilerplate/function_component_test.dart

@@ -260,68 +260,130 @@ void functionComponentTestHelper(UiFactory<TestProps> factory,
     const anotherProp = 'this should be filtered';
     const className = 'aClassName';
 
-    group('using `addUnconsumedProps`', () {
+    // group('using `addUnconsumedProps`', () {
+    //   TestProps initialProps;
+    //   TestProps secondProps;
+
+    //   setUp(() {
+    //     initialProps = (factory()
+    //       ..stringProp = stringProp
+    //       ..anotherProp = anotherProp
+    //     );
+
+    //     secondProps = factory();
+
+    //     expect(secondProps.stringProp, isNull, reason: 'Test setup sanity check');
+    //     expect(secondProps.anotherProp, isNull, reason: 'Test setup sanity check');
+    //   });
+
+    //   test('', () {
+    //     secondProps.addUnconsumedProps(initialProps, []);
+    //     expect(secondProps.anotherProp, anotherProp);
+    //     expect(secondProps.stringProp, stringProp);
+    //   });
+
+    //   test('and consumed props are correctly filtered', () {
+    //     final consumedProps = initialProps.staticMeta.forMixins({TestPropsMixin});
+    //     secondProps.addUnconsumedProps(initialProps, consumedProps);
+    //     expect(secondProps.stringProp, isNull);
+    //     expect(secondProps.anotherProp, anotherProp);
+    //   });
+    // });
+
+    group('using `getPropsToForwardProps`', () {
       TestProps initialProps;
-      TestProps secondProps;
+      TestPropsMixin secondProps;
 
       setUp(() {
         initialProps = (factory()
           ..stringProp = stringProp
           ..anotherProp = anotherProp
         );
 
-        secondProps = factory();
+        secondProps = initialProps;
 
-        expect(secondProps.stringProp, isNull, reason: 'Test setup sanity check');
-        expect(secondProps.anotherProp, isNull, reason: 'Test setup sanity check');
+        // expect(secondProps.stringProp, isNull, reason: 'Test setup sanity check');
+        // expect(secondProps.anotherProp, isNull, reason: 'Test setup sanity check');
       });
 
-      test('', () {
-        secondProps.addUnconsumedProps(initialProps, []);
-        expect(secondProps.anotherProp, anotherProp);
-        expect(secondProps.stringProp, stringProp);
+      test('by default excludes props mixin type that it is invoked on', () {
+        var unconsumedProps = factory(secondProps.getPropsToForward());
+        expect(unconsumedProps.anotherProp, anotherProp);
+        expect(unconsumedProps.stringProp, isNull);
       });
 
-      test('and consumed props are correctly filtered', () {
-        final consumedProps = initialProps.staticMeta.forMixins({TestPropsMixin});
-        secondProps.addUnconsumedProps(initialProps, consumedProps);
-        expect(secondProps.stringProp, isNull);
-        expect(secondProps.anotherProp, anotherProp);
-      });
-    });
+      group('and props are correctly filtered', () {
 
-    group('using `addUnconsumedDomProps`', ()
-    {
-      TestProps initialProps;
-      TestProps secondProps;
+        group('via exclude', () {
 
-      setUp(() {
-        initialProps = (factory()
-          ..stringProp = stringProp
-          ..anotherProp = anotherProp
-          ..className = className
-        );
+          test('for an empty set', () {
+            var unconsumedProps = factory(initialProps.getPropsToForward(exclude: {}));
 
-        secondProps = factory();
+            expect(unconsumedProps.stringProp, stringProp);
+            expect(unconsumedProps.anotherProp, anotherProp);
+          });
 
-        expect(secondProps.className, isNull, reason: 'Test setup sanity check');
-      });
+          test('for a single value set', () {
+            var unconsumedProps = factory(initialProps.getPropsToForward(exclude: {ASecondPropsMixin}));
 
-      test('', () {
-        secondProps.addUnconsumedDomProps(initialProps, []);
-        expect(secondProps.stringProp, isNull);
-        expect(secondProps.anotherProp, isNull);
-        expect(secondProps.className, className);
-      });
+            expect(unconsumedProps.stringProp, stringProp);
+            expect(unconsumedProps.anotherProp, isNull);
+          });
 
-      test('and consumed props are correctly filtered', () {
-        expect(initialProps.className, isNotNull, reason: 'Test setup sanity check');
-        secondProps.addUnconsumedDomProps(initialProps, [PropsMeta.forSimpleKey('className')]);
-        expect(secondProps.stringProp, isNull);
-        expect(secondProps.anotherProp, isNull);
-        expect(secondProps.className, isNull);
+        });
+
+        group('via include', () {
+
+          test('for an empty set', () {
+            var unconsumedProps = factory(initialProps.getPropsToForward(exclude: {}, include: {}));
+
+            expect(unconsumedProps.stringProp, isNull);
+            expect(unconsumedProps.anotherProp, isNull);
+          });
+
+          test('for a single value set', () {
+            var unconsumedProps = factory(initialProps.getPropsToForward(include: {ASecondPropsMixin}));
+
+            expect(unconsumedProps.stringProp, isNull);
+            expect(unconsumedProps.anotherProp, anotherProp);
+          });
+
+        });
       });
     });
+
+    // group('using `addUnconsumedDomProps`', ()
+    // {
+    //   TestProps initialProps;
+    //   TestProps secondProps;
+
+    //   setUp(() {
+    //     initialProps = (factory()
+    //       ..stringProp = stringProp
+    //       ..anotherProp = anotherProp
+    //       ..className = className
+    //     );
+
+    //     secondProps = factory();
+
+    //     expect(secondProps.className, isNull, reason: 'Test setup sanity check');
+    //   });
+
+    //   test('', () {
+    //     secondProps.addUnconsumedDomProps(initialProps, []);
+    //     expect(secondProps.stringProp, isNull);
+    //     expect(secondProps.anotherProp, isNull);
+    //     expect(secondProps.className, className);
+    //   });
+
+    //   test('and consumed props are correctly filtered', () {
+    //     expect(initialProps.className, isNotNull, reason: 'Test setup sanity check');
+    //     secondProps.addUnconsumedDomProps(initialProps, [PropsMeta.forSimpleKey('className')]);
+    //     expect(secondProps.stringProp, isNull);
+    //     expect(secondProps.anotherProp, isNull);
+    //     expect(secondProps.className, isNull);
+    //   });
+    // });
   });
 }