loom | Elegant deployment with Fabric and Puppet | Continuous Deployment library

I think the main issue is the usage of state as a React key on the Container component in App. Each time state updates you are specifying a new React key, and React will handle this by unmounting the previous version and mounting a new version of Container.

For anyone coming across the same problem in the future. I have found out the following 2 things:

1. After trying again to set .*400.* a little later it worked fine. Of course, this may not be a good idea, because if you return any results, that contain 400 anywhere in their response, they could incorrectly trigger a 400 HTTP response.

2. The workaround I found was to use .*Invalid Input.*. Since it is not expected that regular results returned from the API would contain this phrase, this should work reliably.

This is pretty strange behavior. I guess even though you clip the picker, the background is technically still drawn but not visible. Anyway, it seems to work if you disable Hit Testing on the background layer of the Picker:

I think this situation is happening cause the div messages are not nested. Once the user clicks outside, form.get('email').errors will become null, so therefore the the above scenario occurs..

The *ngIf on the first div should have a condition such that only upon touch or some condition like that and only then should it display the nested div messages like 'field is required' or 'Enter valid email'...

Please try this code to verify:

I got this to work by using a transform_fold. The problem is that the transform_lookup only matches once, so if there are multiple matches in the dataset, it ignores them. So you have to use a wide-form dataset and then use the transform_fold to convert it back into long-form.

If you have a Yoast SEO plugin check if the redirect is apply in your customer, or you can check if you subscription plugin have a redirection to the index page.

Okay I found your solution!

Remove everything that you have, and remove those classes not-sticky-top and sticky not-sticky-bottom

And your main problem is that body has overflow: hidden; which you must remove so that sticky can work, like this link says

Change your css like this:

Yes and no. I wouldn't say "they render differently", but there is a difference between how it is determined when to renrender a component. I understand how one could expect that the default behavior is the same, however, I also understand that introducing a new state system (useState) gave the developers an opportunity to improve the default behavior.

I don't know how recoil works specifically, but I would assume it behaves at least like useState wrt rerendering the component. From the documentation:

If you update a State Hook to the same value as the current state, React will bail out without rendering the children or firing effects. (React uses the Object.is comparison algorithm.)

So this confirms your observation.

But let me be clear: This is not a characteristic of function components, that's just how useState works. You could develop your own state management hook which behaves differently.

Now looking add class components, from the setState documentation:

setState() will always lead to a re-render unless shouldComponentUpdate() returns false

And about shouldComponentUpdate:

Use shouldComponentUpdate() to let React know if a component’s output is not affected by the current change in state or props. The default behavior is to re-render on every state change, and in the vast majority of cases you should rely on the default behavior.

shouldComponentUpdate() is invoked before rendering when new props or state are being received. Defaults to true.

The first part isn't as clear ("The default behavior is to re-render on every state change", but is setting the same value a "change"?), but the second paragraph makes it clear. shouldComponentUpdate returns true by default, so the component will always rerender when setState was called.

If you implement shouldComponentUpdate to call Object.is you would replicate the behavior of useState.

The jumping issue is because of your with values between the active and the inactive states. In following example where you can run the code i only changed the values for the active item and it solved the issue on mobile. Use more accurate width and max-width values with calculating the max-width for the sections in every state.