diff --git a/test/over_react/util/safe_render_manager/safe_render_manager_test.dart b/test/over_react/util/safe_render_manager/safe_render_manager_test.dart index 40661b176..0bf39633a 100644 --- a/test/over_react/util/safe_render_manager/safe_render_manager_test.dart +++ b/test/over_react/util/safe_render_manager/safe_render_manager_test.dart @@ -11,6 +11,8 @@ import 'package:over_react/src/util/safe_render_manager/safe_render_manager.dart import 'package:over_react_test/over_react_test.dart'; import 'package:test/test.dart'; +import 'test_component.dart'; + /// Main entry point for TopLevelRenderManager testing main() { setClientConfiguration(); @@ -118,26 +120,28 @@ main() { group('on initial mount,', () { setUp(() { try { - renderManager.render(Test({ - 'onComponentDidMount': bind0(expectAsync0(() { + renderManager.render((Test() + ..onComponentDidMount = bind0(expectAsync0(() { throw new SafeRenderManagerTestException(); - })), - })); + })) + )()); } on SafeRenderManagerTestException catch (_) {} }); sharedTests(); }); + // rerender and unmount are tested below + group('on rerender', () { setUp(() { renderManager.render(Dom.div()()); try { - renderManager.render(Test({ - 'onComponentDidMount': bind0(expectAsync0(() { + renderManager.render((Test() + ..onComponentDidMount = bind0(expectAsync0(() { throw new SafeRenderManagerTestException(); - })), - })); + })) + )()); } on SafeRenderManagerTestException catch (_) {} }); @@ -145,264 +149,298 @@ main() { }); }); - group('edge-cases', () { - group('rerenders content correctly when initial and second render happen synchronously calls come from', () { - const render1Text = 'render1'; - const render2Text = 'render2'; + group('edge-cases:', () { + group('rerenders content correctly when when initial and second render happen synchronously and', () { +// var onComponentDidUpdate; +// +// setUp(() { +// onComponentDidUpdate = null; +// }); - bool onMaybeUnmountedCalled; + // --------------------------------------------------------------------- + // Begin unmount sharedTests + sharedTests() { + group('calls come from', () { + const render1Text = 'render1'; + const render2Text = 'render2'; - setUp(() { - onMaybeUnmountedCalled = false; - }); + bool onMaybeUnmountedCalled; - Future sharedTest({@required void Function() setUpAndReturnTriggerRender(void doRenders()), - @required bool verifyImmediateRender, - @required bool verifyDeferredRender, - bool verifyAsyncRender = false, - }) async { - if (verifyImmediateRender && verifyDeferredRender) { - throw new ArgumentError('verifyImmediateRender and verifyDeferredRender ' - 'are mutually exclusive and cannot both be set to true'); - } - - // Bind guarded so that any failing `expect`s, which result in synchronous errors, - // are handled by the test zone's error handler and not swallowed - // by whichever zone they end up being run in - // (e.g., the root zone in the case of event handlers). - final doRenders = bind0Guarded(expectAsync0(() { - renderManager.render(Wrapper()(render1Text)); - renderManager.render(Wrapper()(render2Text)); - - if (verifyImmediateRender) { - expect(mountNode.text, render2Text, reason: 'should have updated synchronously'); - } - - if (verifyDeferredRender) { + setUp(() { + onMaybeUnmountedCalled = false; + }); + + Future sharedTest({@required void Function() setUpAndReturnTriggerRender(void doRenders()), + @required bool verifyImmediateRender, + @required bool verifyDeferredRender, + bool verifyAsyncRender = false, + }) async { + if (verifyImmediateRender && verifyDeferredRender) { + throw new ArgumentError('verifyImmediateRender and verifyDeferredRender ' + 'are mutually exclusive and cannot both be set to true'); + } + + // Bind guarded so that any failing `expect`s, which result in synchronous errors, + // are handled by the test zone's error handler and not swallowed + // by whichever zone they end up being run in + // (e.g., the root zone in the case of event handlers). + final doRenders = bind0Guarded(expectAsync0(() { + renderManager.render(Wrapper()(render1Text)); + renderManager.render(Wrapper()(render2Text)); + + if (verifyImmediateRender) { + expect(mountNode.text, render2Text, reason: 'should have updated synchronously'); + } + + if (verifyDeferredRender) { + expect(mountNode.text, isNot(anyOf(render1Text, render2Text)), + reason: 'should have updated synchronously'); + } + }, reason: 'doRenders needs to be called as part of test')); + + final triggerRenders = setUpAndReturnTriggerRender(doRenders); + + await pumpEventQueue(); + // todo also add componentWillUnmount callback + expect(onMaybeUnmountedCalled, isFalse, + reason: 'test setup: content should still be mounted before doRenders is called'); expect(mountNode.text, isNot(anyOf(render1Text, render2Text)), - reason: 'should have updated synchronously'); + reason: 'test setup: content should still be mounted before doRenders is called'); + + triggerRenders(); + + expect(mountNode.text, render2Text, reason: 'should have updated by now'); } - }, reason: 'doRenders needs to be called as part of test')); - final triggerRenders = setUpAndReturnTriggerRender(doRenders); + group('the same React tree (rerenders only, not mounting), from a', () { + test('event handler', () async { + await sharedTest( + verifyImmediateRender: false, + verifyDeferredRender: true, + setUpAndReturnTriggerRender: (doRenders) { + document.body.append(renderManager.mountNode); + renderManager.render((Wrapper() + ..onClick = (_) { + doRenders(); + } + )('setup render')); - await pumpEventQueue(); - // todo also add componentWillUnmount callback - expect(onMaybeUnmountedCalled, isFalse, - reason: 'test setup: content should still be mounted before doRenders is called'); - expect(mountNode.text, isNot(anyOf(render1Text, render2Text)), - reason: 'test setup: content should still be mounted before doRenders is called'); + // Use a real click since simulated clicks don't trigger this async behavior + return () => findDomNode(renderManager.contentRef).click(); + }, + ); + }); - triggerRenders(); + test('callback of setState performed within event handler', () async { + await sharedTest( + verifyImmediateRender: false, + verifyDeferredRender: true, + setUpAndReturnTriggerRender: (doRenders) { + document.body.append(renderManager.mountNode); + renderManager.render((Wrapper() + ..onClick = (_) { + (renderManager.contentRef as react.Component).setState({}, doRenders); + } + )('setup render')); - expect(mountNode.text, render2Text, reason: 'should have updated by now'); - } + // Use a real click since simulated clicks don't trigger this async behavior + return () => findDomNode(renderManager.contentRef).click(); + }, + ); + }); - group('the same React tree (rerenders only, not mounting), from a', () { - test('event handler', () async { - await sharedTest( - verifyImmediateRender: false, - verifyDeferredRender: true, - setUpAndReturnTriggerRender: (doRenders) { - document.body.append(renderManager.mountNode); - renderManager.render((Wrapper() - ..onClick = (_) { - doRenders(); - } - )('setup render')); - - // Use a real click since simulated clicks don't trigger this async behavior - return () => findDomNode(renderManager.contentRef).click(); - }, - ); - }); + test('lifecycle method (pre-commit phase)', () async { + await sharedTest( + verifyImmediateRender: false, + verifyDeferredRender: true, + setUpAndReturnTriggerRender: (doRenders) { + renderManager.render((Test() + ..onComponentWillUpdate = doRenders + )()); - test('callback of setState performed within event handler', () async { - await sharedTest( - verifyImmediateRender: false, - verifyDeferredRender: true, - setUpAndReturnTriggerRender: (doRenders) { - document.body.append(renderManager.mountNode); - renderManager.render((Wrapper() - ..onClick = (_) { - (renderManager.contentRef as react.Component).setState({}, doRenders); - } - )('setup render')); - - // Use a real click since simulated clicks don't trigger this async behavior - return () => findDomNode(renderManager.contentRef).click(); - }, - ); - }); + return () { + // Exceptions thrown during unmount will propagate to this + // this redraw call. + try { + (renderManager.contentRef as react.Component).redraw(); + } on SafeRenderManagerTestException catch (_) {} + }; + }, + ); + }); - test('lifecycle method (pre-commit phase)', () async { - await sharedTest( - verifyImmediateRender: false, - verifyDeferredRender: true, - setUpAndReturnTriggerRender: (doRenders) { - renderManager.render(Test({ - 'onComponentWillUpdate': doRenders, - })); - - return () { - // Exceptions thrown during unmount will propagate to this - // this redraw call. - try { - (renderManager.contentRef as react.Component).redraw(); - } on SafeRenderManagerTestException catch (_) {} - }; - }, - ); - }); + test('lifecycle method (post-commit phase)', () async { + await sharedTest( + verifyImmediateRender: false, + verifyDeferredRender: true, + setUpAndReturnTriggerRender: (doRenders) { + renderManager.render((Test() + ..onComponentDidUpdate = doRenders + )()); - test('lifecycle method (post-commit phase)', () async { - await sharedTest( - verifyImmediateRender: false, - verifyDeferredRender: true, - setUpAndReturnTriggerRender: (doRenders) { - renderManager.render(Test({ - 'onComponentDidUpdate': doRenders, - })); - - return () { - // Exceptions thrown during unmount will propagate to this - // this redraw call. - try { - (renderManager.contentRef as react.Component).redraw(); - } on SafeRenderManagerTestException catch (_) {} - }; - }, - ); - }); - }); + return () { + // Exceptions thrown during unmount will propagate to this + // this redraw call. + try { + (renderManager.contentRef as react.Component).redraw(); + } on SafeRenderManagerTestException catch (_) {} + }; + }, + ); + }); + }); - group('another React tree, from a', () { - test('event handler', () async { - await sharedTest( - verifyImmediateRender: false, - verifyDeferredRender: false, - setUpAndReturnTriggerRender: (doRenders) { - final jacket = mount((Wrapper() - ..onClick = (_) { - doRenders(); - } - )(), attachedToDocument: true); - - // Use a real click since simulated clicks don't trigger this async behavior - return () => jacket.getNode().click(); - }, - ); - }); + group('another React tree, from a', () { + test('event handler', () async { + await sharedTest( + verifyImmediateRender: false, + verifyDeferredRender: false, + setUpAndReturnTriggerRender: (doRenders) { + final jacket = mount((Wrapper() + ..onClick = (_) { + doRenders(); + } + )(), attachedToDocument: true); - test('callback of setState performed within event handler', () async { - await sharedTest( - verifyImmediateRender: false, - verifyDeferredRender: true, - setUpAndReturnTriggerRender: (doRenders) { - TestJacket jacket; - jacket = mount((Wrapper() - ..onClick = (_) { - jacket.getDartInstance().setState({}, doRenders); - } - )(), attachedToDocument: true); - - // Use a real click since simulated clicks don't trigger this async behavior - return () => jacket.getNode().click(); - }, - ); - }); + // Use a real click since simulated clicks don't trigger this async behavior + return () => jacket.getNode().click(); + }, + ); + }); - test('lifecycle method (pre-commit phase)', () async { - await sharedTest( - verifyImmediateRender: false, - verifyDeferredRender: true, - setUpAndReturnTriggerRender: (doRenders) { - final jacket = mount(Test({ - 'onComponentWillUpdate': doRenders, - })); - - return () => jacket.getDartInstance().redraw(); - }, - ); - }); + test('callback of setState performed within event handler', () async { + await sharedTest( + verifyImmediateRender: false, + verifyDeferredRender: true, + setUpAndReturnTriggerRender: (doRenders) { + TestJacket jacket; + jacket = mount((Wrapper() + ..onClick = (_) { + jacket.getDartInstance().setState({}, doRenders); + } + )(), attachedToDocument: true); + + // Use a real click since simulated clicks don't trigger this async behavior + return () => jacket.getNode().click(); + }, + ); + }); - test('lifecycle method (post-commit phase)', () async { - await sharedTest( - verifyImmediateRender: false, - verifyDeferredRender: true, - setUpAndReturnTriggerRender: (doRenders) { - final jacket = mount(Test({ - 'onComponentDidUpdate': doRenders, - })); - - return () => jacket.getDartInstance().redraw(); - }, - ); + test('lifecycle method (pre-commit phase)', () async { + await sharedTest( + verifyImmediateRender: false, + verifyDeferredRender: true, + setUpAndReturnTriggerRender: (doRenders) { + final jacket = mount((Test() + ..onComponentWillUpdate = doRenders + )()); + + return () => jacket.getDartInstance().redraw(); + }, + ); + }); + + test('lifecycle method (post-commit phase)', () async { + await sharedTest( + verifyImmediateRender: false, + verifyDeferredRender: true, + setUpAndReturnTriggerRender: (doRenders) { + final jacket = mount((Test() + ..onComponentDidUpdate = doRenders + )()); + + return () => jacket.getDartInstance().redraw(); + }, + ); + }); + }); }); + } + // End rerender sharedTests + // --------------------------------------------------------------------- + + group('second render occurs normally and', () { + sharedTests(); }); + +// group('second render throws and', () { +// setUp(() { +// onComponentDidUpdate = bind0(expectAsync0(() { +// throw new SafeRenderManagerTestException(); +// })); +// }); +// +// sharedTests(); +// }); }); group('unmounts content safely when', () { - bool onMaybeUnmountedCalled; var onComponentWillUnmount; setUp(() { - onMaybeUnmountedCalled = false; onComponentWillUnmount = null; }); - sharedTests() { - Future sharedTest({@required void Function() setUpAndReturnUnmounter(void doUnmount()), - @required bool verifyImmediateUnmount, - @required bool verifyDeferredUnmount, - }) async { - if (verifyImmediateUnmount && verifyDeferredUnmount) { - throw new ArgumentError('verifyImmediateUnmount and verifyDeferredUnmount ' - 'are mutually exclusive and cannot both be set to true'); - } - - void _doUnmount() { - expect(mountNode.text, '1', reason: 'test setup check; should not have unmounted yet'); + // --------------------------------------------------------------------- + // Begin unmount sharedTests + void sharedTests() { + group('unmount calls come from', () { + bool onMaybeUnmountedCalled; - renderManager.tryUnmount(onMaybeUnmounted: bind1Guarded(expectAsync1((isUnmounted) { - onMaybeUnmountedCalled = true; - expect(isUnmounted, isTrue, reason: 'should have unmounted'); - }, reason: 'onMaybeUnmounted should always be called on unmount'))); + setUp(() { + onMaybeUnmountedCalled = false; + }); - if (verifyDeferredUnmount) { - expect(onMaybeUnmountedCalled, isFalse, reason: 'should not have unmounted yet'); - expect(mountNode.text, '1', reason: 'should not have unmounted yet'); + Future sharedTest({@required void Function() setUpAndReturnUnmounter(void doUnmount()), + @required bool verifyImmediateUnmount, + @required bool verifyDeferredUnmount, + }) async { + if (verifyImmediateUnmount && verifyDeferredUnmount) { + throw new ArgumentError('verifyImmediateUnmount and verifyDeferredUnmount ' + 'are mutually exclusive and cannot both be set to true'); } - if (verifyImmediateUnmount) { - expect(onMaybeUnmountedCalled, isTrue, reason: 'should have unmounted by now'); - expect(mountNode.text, '', reason: 'should have unmounted by now'); + + void _doUnmount() { + expect(mountNode.text, '1', reason: 'test setup check; should not have unmounted yet'); + + renderManager.tryUnmount(onMaybeUnmounted: bind1Guarded(expectAsync1((isUnmounted) { + onMaybeUnmountedCalled = true; + expect(isUnmounted, isTrue, reason: 'should have unmounted'); + }, reason: 'onMaybeUnmounted should always be called on unmount'))); + + if (verifyDeferredUnmount) { + expect(onMaybeUnmountedCalled, isFalse, reason: 'should not have unmounted yet'); + expect(mountNode.text, '1', reason: 'should not have unmounted yet'); + } + if (verifyImmediateUnmount) { + expect(onMaybeUnmountedCalled, isTrue, reason: 'should have unmounted by now'); + expect(mountNode.text, '', reason: 'should have unmounted by now'); + } } - } - // Bind guarded so that any failing `expect`s, which result in synchronous errors, - // are handled by the test zone's error handler and not swallowed - // by whichever zone they end up being run in - // (e.g., the root zone in the case of event handlers). - final doUnmount = bind0Guarded(expectAsync0(_doUnmount, - reason: 'doUnmount needs to be called as part of test')); + // Bind guarded so that any failing `expect`s, which result in synchronous errors, + // are handled by the test zone's error handler and not swallowed + // by whichever zone they end up being run in + // (e.g., the root zone in the case of event handlers). + final doUnmount = bind0Guarded(expectAsync0(_doUnmount, + reason: 'doUnmount needs to be called as part of test')); - final triggerUnmount = setUpAndReturnUnmounter(doUnmount); + final triggerUnmount = setUpAndReturnUnmounter(doUnmount); - await pumpEventQueue(); - expect(onMaybeUnmountedCalled, isFalse, - reason: 'test setup: content should still be mounted before doUnmount is called'); - expect(mountNode.text, '1', - reason: 'test setup: content should still be mounted before doUnmount is called'); + await pumpEventQueue(); + expect(onMaybeUnmountedCalled, isFalse, + reason: 'test setup: content should still be mounted before doUnmount is called'); + expect(mountNode.text, '1', + reason: 'test setup: content should still be mounted before doUnmount is called'); - triggerUnmount(); + triggerUnmount(); - expect(onMaybeUnmountedCalled, isTrue, - reason: 'should have unmounted by now'); - expect(mountNode.text, '', reason: 'should have unmounted by now'); + expect(onMaybeUnmountedCalled, isTrue, + reason: 'should have unmounted by now'); + expect(mountNode.text, '', reason: 'should have unmounted by now'); - print('done in expect'); - } + print('done in expect'); + } - group('unmount calls come from', () { group('the same React tree, from a', () { test('event handler', () async { await sharedTest( @@ -410,12 +448,12 @@ main() { verifyDeferredUnmount: true, setUpAndReturnUnmounter: (callUnmount) { document.body.append(renderManager.mountNode); - renderManager.render(Test({ - 'onClick': (_) { + renderManager.render((Test() + ..onClick = (_) { callUnmount(); - }, - 'onComponentWillUnmount': onComponentWillUnmount, - }, '1')); + } + ..onComponentWillUnmount = onComponentWillUnmount + )('1')); // Use a real click since simulated clicks don't trigger this async behavior return () => findDomNode(renderManager.contentRef).click(); @@ -429,12 +467,12 @@ main() { verifyDeferredUnmount: true, setUpAndReturnUnmounter: (callUnmount) { document.body.append(renderManager.mountNode); - renderManager.render(Test({ - 'onClick': (_) { + renderManager.render((Test() + ..onClick = (_) { (renderManager.contentRef as react.Component).setState({}, callUnmount); - }, - 'onComponentWillUnmount': onComponentWillUnmount, - }, '1')); + } + ..onComponentWillUnmount = onComponentWillUnmount + )('1')); // Use a real click since simulated clicks don't trigger this async behavior return () => findDomNode(renderManager.contentRef).click(); }, @@ -446,10 +484,10 @@ main() { verifyImmediateUnmount: false, verifyDeferredUnmount: true, setUpAndReturnUnmounter: (callUnmount) { - renderManager.render(Test({ - 'onComponentWillUpdate': callUnmount, - 'onComponentWillUnmount': onComponentWillUnmount, - }, '1')); + renderManager.render((Test() + ..onComponentWillUpdate = callUnmount + ..onComponentWillUnmount = onComponentWillUnmount + )('1')); return () { // Exceptions thrown during unmount will propagate to this @@ -467,10 +505,10 @@ main() { verifyImmediateUnmount: false, verifyDeferredUnmount: true, setUpAndReturnUnmounter: (callUnmount) { - renderManager.render(Test({ - 'onComponentDidUpdate': callUnmount, - 'onComponentWillUnmount': onComponentWillUnmount, - }, '1')); + renderManager.render((Test() + ..onComponentDidUpdate = callUnmount + ..onComponentWillUnmount = onComponentWillUnmount + )('1')); return () { // Exceptions thrown during unmount will propagate to this @@ -486,9 +524,9 @@ main() { group('another React tree, from a', () { setUp(() { - renderManager.render(Test({ - 'onComponentWillUnmount': onComponentWillUnmount, - }, '1')); + renderManager.render((Test() + ..onComponentWillUnmount = onComponentWillUnmount + )('1')); expect(mountNode.text, '1', reason: 'test setup check'); }); @@ -497,11 +535,11 @@ main() { verifyImmediateUnmount: false, verifyDeferredUnmount: true, setUpAndReturnUnmounter: (callUnmount) { - final jacket = mount(Test({ - 'onClick': (_) { + final jacket = mount((Test() + ..onClick = (_) { callUnmount(); - }, - }), attachedToDocument: true); + } + )(), attachedToDocument: true); // Use a real click since simulated clicks don't trigger this async behavior return () => jacket.getNode().click(); @@ -515,11 +553,11 @@ main() { verifyDeferredUnmount: true, setUpAndReturnUnmounter: (callUnmount) { TestJacket jacket; - jacket = mount(Test({ - 'onClick': (_) { + jacket = mount((Test() + ..onClick = (_) { jacket.getDartInstance().setState({}, callUnmount); - }, - }), attachedToDocument: true); + } + )(), attachedToDocument: true); // Use a real click since simulated clicks don't trigger this async behavior return () => jacket.getNode().click(); @@ -532,9 +570,9 @@ main() { verifyImmediateUnmount: false, verifyDeferredUnmount: true, setUpAndReturnUnmounter: (callUnmount) { - final jacket = mount(Test({ - 'onComponentWillUpdate': callUnmount, - })); + final jacket = mount((Test() + ..onComponentWillUpdate = callUnmount + )()); return () { // Exceptions thrown during unmount will propagate to this @@ -552,9 +590,9 @@ main() { verifyImmediateUnmount: false, verifyDeferredUnmount: true, setUpAndReturnUnmounter: (callUnmount) { - final jacket = mount(Test({ - 'onComponentDidUpdate': callUnmount, - })); + final jacket = mount((Test() + ..onComponentDidUpdate = callUnmount + )()); return () { // Exceptions thrown during unmount will propagate to this @@ -569,6 +607,8 @@ main() { }); }); } + // End unmount sharedTests + // --------------------------------------------------------------------- group('unmounting occurs normally and', () { sharedTests(); @@ -604,36 +644,6 @@ ZoneCallback bind0Guarded(ZoneCallback callback) => ZoneUnaryCallback bind1Guarded(ZoneUnaryCallback callback) => Zone.current.bindUnaryCallbackGuarded(callback); -final Test = registerComponent(() => new TestComponent()); -class TestComponent extends react.Component { - @override - componentDidMount() { - props['onComponentDidMount']?.call(); - } - - @override - componentDidUpdate(prevProps, prevState) { - props['onComponentDidUpdate']?.call(); - } - @override - componentWillUpdate(nextProps, nextState) { - nextProps['onComponentWillUpdate']?.call(); - } - @override - componentWillReceiveProps(nextProps) { - nextProps['onComponentWillReceiveProps']?.call(); - } - @override - componentWillUnmount() { - nextProps['onComponentWillUnmount']?.call(); - } - - @override - render() { - return (Dom.div()..addProps(props))(props['children']); - } -} - /// An exception used for testing, which we can tell apart from /// other arbitrary exceptions via type-checking. class SafeRenderManagerTestException implements Exception {} diff --git a/test/over_react/util/safe_render_manager/test_component.dart b/test/over_react/util/safe_render_manager/test_component.dart new file mode 100644 index 000000000..93fab87dc --- /dev/null +++ b/test/over_react/util/safe_render_manager/test_component.dart @@ -0,0 +1,47 @@ +import 'package:over_react/over_react.dart'; + +part 'test_component.over_react.g.dart'; + +@Factory() +UiFactory Test = _$Test; + +@Props() +class _$TestProps extends UiProps { + LifecycleCallback onComponentDidMount; + LifecycleCallback onComponentDidUpdate; + LifecycleCallback onComponentWillUpdate; + LifecycleCallback onComponentWillReceiveProps; + LifecycleCallback onComponentWillUnmount; +} + +@Component(isWrapper: true) +class TestComponent extends UiComponent { + @override + componentDidMount() { + props.onComponentDidMount?.call(); + } + + @override + componentDidUpdate(prevProps, prevState) { + props.onComponentDidUpdate?.call(); + } + @override + componentWillUpdate(nextProps, nextState) { + typedPropsFactory(nextProps).onComponentWillUpdate?.call(); + } + @override + componentWillReceiveProps(nextProps) { + typedPropsFactory(nextProps).onComponentWillReceiveProps?.call(); + } + @override + componentWillUnmount() { + typedPropsFactory(nextProps).onComponentWillUnmount?.call(); + } + + @override + render() { + return (Dom.div()..addProps(copyUnconsumedProps()))(props.children); + } +} + +typedef void LifecycleCallback(); diff --git a/test/over_react/util/safe_render_manager/test_component.over_react.g.dart b/test/over_react/util/safe_render_manager/test_component.over_react.g.dart new file mode 100644 index 000000000..c39efafb1 --- /dev/null +++ b/test/over_react/util/safe_render_manager/test_component.over_react.g.dart @@ -0,0 +1,169 @@ +// GENERATED CODE - DO NOT MODIFY BY HAND + +part of 'test_component.dart'; + +// ************************************************************************** +// OverReactBuilder (package:over_react/src/builder.dart) +// ************************************************************************** + +// React component factory implementation. +// +// Registers component implementation and links type meta to builder factory. +final $TestComponentFactory = registerComponent(() => new _$TestComponent(), + builderFactory: Test, + componentClass: TestComponent, + isWrapper: true, + parentType: null, + displayName: 'Test'); + +abstract class _$TestPropsAccessorsMixin implements _$TestProps { + @override + Map get props; + + /// + @override + LifecycleCallback get onComponentDidMount => + props[_$key__onComponentDidMount___$TestProps] ?? + null; // Add ` ?? null` to workaround DDC bug: ; + /// + @override + set onComponentDidMount(LifecycleCallback value) => + props[_$key__onComponentDidMount___$TestProps] = value; + + /// + @override + LifecycleCallback get onComponentDidUpdate => + props[_$key__onComponentDidUpdate___$TestProps] ?? + null; // Add ` ?? null` to workaround DDC bug: ; + /// + @override + set onComponentDidUpdate(LifecycleCallback value) => + props[_$key__onComponentDidUpdate___$TestProps] = value; + + /// + @override + LifecycleCallback get onComponentWillUpdate => + props[_$key__onComponentWillUpdate___$TestProps] ?? + null; // Add ` ?? null` to workaround DDC bug: ; + /// + @override + set onComponentWillUpdate(LifecycleCallback value) => + props[_$key__onComponentWillUpdate___$TestProps] = value; + + /// + @override + LifecycleCallback get onComponentWillReceiveProps => + props[_$key__onComponentWillReceiveProps___$TestProps] ?? + null; // Add ` ?? null` to workaround DDC bug: ; + /// + @override + set onComponentWillReceiveProps(LifecycleCallback value) => + props[_$key__onComponentWillReceiveProps___$TestProps] = value; + + /// + @override + LifecycleCallback get onComponentWillUnmount => + props[_$key__onComponentWillUnmount___$TestProps] ?? + null; // Add ` ?? null` to workaround DDC bug: ; + /// + @override + set onComponentWillUnmount(LifecycleCallback value) => + props[_$key__onComponentWillUnmount___$TestProps] = value; + /* GENERATED CONSTANTS */ + static const PropDescriptor _$prop__onComponentDidMount___$TestProps = + const PropDescriptor(_$key__onComponentDidMount___$TestProps); + static const PropDescriptor _$prop__onComponentDidUpdate___$TestProps = + const PropDescriptor(_$key__onComponentDidUpdate___$TestProps); + static const PropDescriptor _$prop__onComponentWillUpdate___$TestProps = + const PropDescriptor(_$key__onComponentWillUpdate___$TestProps); + static const PropDescriptor _$prop__onComponentWillReceiveProps___$TestProps = + const PropDescriptor(_$key__onComponentWillReceiveProps___$TestProps); + static const PropDescriptor _$prop__onComponentWillUnmount___$TestProps = + const PropDescriptor(_$key__onComponentWillUnmount___$TestProps); + static const String _$key__onComponentDidMount___$TestProps = + 'TestProps.onComponentDidMount'; + static const String _$key__onComponentDidUpdate___$TestProps = + 'TestProps.onComponentDidUpdate'; + static const String _$key__onComponentWillUpdate___$TestProps = + 'TestProps.onComponentWillUpdate'; + static const String _$key__onComponentWillReceiveProps___$TestProps = + 'TestProps.onComponentWillReceiveProps'; + static const String _$key__onComponentWillUnmount___$TestProps = + 'TestProps.onComponentWillUnmount'; + + static const List $props = const [ + _$prop__onComponentDidMount___$TestProps, + _$prop__onComponentDidUpdate___$TestProps, + _$prop__onComponentWillUpdate___$TestProps, + _$prop__onComponentWillReceiveProps___$TestProps, + _$prop__onComponentWillUnmount___$TestProps + ]; + static const List $propKeys = const [ + _$key__onComponentDidMount___$TestProps, + _$key__onComponentDidUpdate___$TestProps, + _$key__onComponentWillUpdate___$TestProps, + _$key__onComponentWillReceiveProps___$TestProps, + _$key__onComponentWillUnmount___$TestProps + ]; +} + +const PropsMeta _$metaForTestProps = const PropsMeta( + fields: _$TestPropsAccessorsMixin.$props, + keys: _$TestPropsAccessorsMixin.$propKeys, +); + +class TestProps extends _$TestProps with _$TestPropsAccessorsMixin { + static const PropsMeta meta = _$metaForTestProps; +} + +_$$TestProps _$Test([Map backingProps]) => new _$$TestProps(backingProps); + +// Concrete props implementation. +// +// Implements constructor and backing map, and links up to generated component factory. +class _$$TestProps extends _$TestProps + with _$TestPropsAccessorsMixin + implements TestProps { + // This initializer of `_props` to an empty map, as well as the reassignment + // of `_props` in the constructor body is necessary to work around an unknown ddc issue. + // See for more details + _$$TestProps(Map backingMap) : this._props = {} { + this._props = backingMap ?? {}; + } + + /// The backing props map proxied by this class. + @override + Map get props => _props; + Map _props; + + /// Let [UiProps] internals know that this class has been generated. + @override + bool get $isClassGenerated => true; + + /// The [ReactComponentFactory] associated with the component built by this class. + @override + ReactComponentFactoryProxy get componentFactory => $TestComponentFactory; + + /// The default namespace for the prop getters/setters generated for this class. + @override + String get propKeyNamespace => 'TestProps.'; +} + +// Concrete component implementation mixin. +// +// Implements typed props/state factories, defaults `consumedPropKeys` to the keys +// generated for the associated props class. +class _$TestComponent extends TestComponent { + @override + _$$TestProps typedPropsFactory(Map backingMap) => + new _$$TestProps(backingMap); + + /// Let [UiComponent] internals know that this class has been generated. + @override + bool get $isClassGenerated => true; + + /// The default consumed props, taken from _$TestProps. + /// Used in [UiProps.consumedProps] if [consumedProps] is not overridden. + @override + final List $defaultConsumedProps = const [_$metaForTestProps]; +}