Al usar redux-observable con react-router, ¿tendría sentido agregar asincrónicamente nuevas epopeyas según las instrucciones en la documentación?aquí dentro onEnter ganchos de react-router durante los cambios de ruta?

./epics/index.js

import { BehaviorSubject } from 'rxjs/BehaviorSubject';
import { combineEpics } from 'redux-observable';

import { epic1 } from './epic1'
import { epic2 } from './epic2'

export const epic$ = new BehaviorSubject(combineEpics(epic1, epic2));
export const rootEpic = (action$, store) =>
    epic$.mergeMap(epic =>
        epic(action$, store)
    );

export {
    rootEpic
};

... rutas / SomePath / index.js

import { epic$ } from './../../../../epics/index'
import { epic3 } from './../../../../epics/epic3'

module.exports = {
    path: 'some-path',
    getComponent( location, cb ) {
        require.ensure( [], ( require ) => {
            cb( null, require( './components/SomePath' ) )
        } )
    },
    onEnter() {
        epic$.next(epic3)

    }
}

Muy nuevo en Rxjs y redux-observable. Esto parece funcionar, pero se pregunta: 1. En este caso, ¿epic3 se agregaría nuevamente al rootEpic cada vez que naveguemos a / some-path? 2. Si quisiera console.log qué epopeyas se han agregado al rootEpic, ¿cómo lo haría?

Editado en respuesta a @JayPhelps

¿Puedo solicitar aclaraciones sobre algunos puntos?

El registerEpic fn funciona muy bien. Había estado usando el operador .distinct () para abordar el problema de registro épico duplicado de la siguiente manera:

export const epic$ = new BehaviorSubject(combineEpics(epic1, epic2)).distinct()

¿Es esta una forma igualmente válida / buena de manejar el registro épico perezoso, y si no, podría explicar por qué?

Estoy usando create-react-app que requiere require.ensure y ES6 import (son diferentes formas de importar ¿verdad?), Y básicamente, copié y peguéejemplo de aplicaciones enormes de react-router que tenía elrequire.ensure código, pero en cualquier otro lugar, estoy usando declaraciones de importación en la parte superior del archivo.

Por lo tanto, importar las epopeyas y el registerEpic fn en la parte superior parece funcionar, mientras que colocar las rutas dentro de require.ensure el primer argumento también parece funcionar. ¿Se complican las cosas si utilizo require.ensure y las declaraciones de importación? Si uso require.ensure para cargar TODO lo que necesita la ruta, ¿eso significa que elimino todas las declaraciones de importación dentro de los componentes anidados (sin ruta) del componente de esa ruta?

import { epic3 } from './../../epics/epic3'
import { epic4 } from './../../epics/epic4'
import { registerEpic } from './../../epics/index'

module.exports = {
    path: 'my-path',
    getComponent( location, done ) {
        require.ensure( [], ( require ) => {
           registerEpic(addYoutubeEpic)
            registerEpic(linkYourSiteEpic)
            done( null, require( './components/Edit' ) )
        } )
    }
}

Con respecto al registro de epopeyas en el 'getComponent' fn para la carga asíncrona, pensé que era realmente deseable tener una carga sincrónica aquí, para que el componente de la ruta no se procese hasta que la epopeya se haya registrado. ¿Qué sucede si el usuario intenta hacer algo en la ruta, como obtener información detallada o enviar un formulario, que requiere que se registre la epopeya y la epopeya aún no se haya registrado?

¿Hay algún otro lugar fuera del módulo react-router. Declaraciones de exportación que serían apropiadas para registrar épicamente? Dado que muchas rutas en mi proyecto no requieren inicio de sesión, iniciar sesión no siempre desencadena un cambio de ruta. Sin embargo, hay un montón de epopeyas que deberían registrarse después de que un usuario inicie sesión. Actualmente, lo estoy haciendo de una manera realmente estúpida y probablemente incorrecta al configurar una variable de token en mi authReducer, pero todo lo que hace es llamar a una función que registra las nuevas epopeyas:

'./../reducers/authReducer.js'

import { greatEpic } from './../epics/fetchFollowListEpic'
import { usefulEpic } from './../epics/fetchMyCollectionsEpic'
// and a few more 
import { registerEpic } from './../epics/index'

const addEpics = () => {
    registerEpic(greatEpic)
     registerEpic(usefulEpic)
     ...etc
}

export default function reducer( state = {
    loggingIn: false,   
    loggedIn: false,
    error: '',
}, action ) {
    switch ( action.type ) {
        case "LOGIN_SEQUENCE_DONE": {
            return {
                ...state,
                aid: setAuthToken(action.payload),
                loginFailed: false,
                addEpics: addEpics(),
            }

        }

Me imagino que loginEpic sería un mejor lugar para registrar las epopeyas, en lugar del reductor. (Encontrésu ejemplo de inicio de sesión en github entonces puede parecer familiar). ¿Es correcto o estoy totalmente fuera de lugar? Sé que .concat () es síncrono, y sé que redux es síncrono; no estoy seguro de si registerEpics () es síncrono, pero usar el reductor para registrar las epopeyas SEEMS para que funcione bien, ¿eso significa que registerEpics es síncrono? ¿O simplemente significa que las cosas se disparan tan rápido que no importa? ¿O solo funciona debido a algunos malentendidos esenciales que tengo sobre las declaraciones de importación y cómo webpack maneja la división de código que tengo que investigar más?

./../epics/loginEpic

export const loginEpic = action$ =>
    action$.ofType("LOGIN")
        .mergeMap(action =>

            Observable.fromPromise(axios.post('webapi/login', action.payload))
                .flatMap(payload =>
                    // Concat multiple observables so they fire sequentially
                    Observable.concat(
                        // after LOGIN_FULILLED
                        Observable.of({ type: "LOGIN_FULFILLED", payload: payload.data.aid }),                   
                        // ****This is where I think I should be registering the epics right after logging in. "ANOTHER_ACTION" below depends upon one of these epics****     
                        Observable.of({type: "ANOTHER_ACTION", payload: 'webapi/following'}),
                        Observable.of({type: "LOGIN_SEQUENCE_DONE"}),
                    )
                )
                .startWith({ type: "LOGIN_PENDING" })
                .takeUntil(action$.ofType("LOGIN_CANCELLED"))
                .catch(error => Observable.of({
                    type: "LOGIN_REJECTED",
                    payload: error,
                    error: true
                }))
        );