Yes, modifying global state is bad and relying on global state was a huge problem for early Flux implementations/spin-offs. However not everything that gets called "Flux" uses global state.
A naive implementation of Flux would use global instances of stores, the dispatcher and so on. This is generally not a big problem in client-side code as there is only one instance of the same application running at a time, but it can make it very difficult to solve server-side rendering, especially if you want to pre-load data asynchronously: because there's only one instance of the application running at a time, if something needs to happen asynchronously, another request might be served by the same application and you either respond with the wrong user's data or clobber the first user's state.
However many "Flux" libraries as well as Redux solve this with a very simple solution: instead of having one global instance, they have one instance per application and that instance can be passed down using React context. The context API serves a similar role as the dependency injection mechanism in AngularJS, except it trickles down the component tree and you only need to bind the dependencies when you actually instantiate the outer most component.
In other words while this ostensibly creates a kind of "global" state it is actually still wrapped in another top level component (or render function) which can be multiplied if necessary (e.g. to have multiple applications in parallel during server-side rendering). The "global" state is global to the application but non-global to the environment the application is running inside of.
As to whether this pseudo-global state (or application-local state) is as bad as global state in traditional applications: consider that Flux/Redux makes mutations very explicit. It's not possible to accidentally or sloppily modify shared state, you actually have to explicitly ask for it to be modified. Access to that state is also made explicit: React allows you to isolate the part of the code that knows about the internal structure of your data from the part that presents that data via props and higher order components.