export function createStore()

in packages/redux-dynamic-modules-core/src/ModuleStore.ts [92:185]
78 lines of code
4 McCabe index (conditional complexity)

export function createStore<State>(
    moduleStoreSettings: ModuleStoreSettings<State>,
    ...initialModules: IModule<any>[]
): IModuleStore<State>;
export function createStore<State>(
    moduleStoreSettings: ModuleStoreSettings<State>,
    ...initialModules: IModule<any>[]
): IModuleStore<State> {
    const {
        initialState = {},
        extensions = [],
        enhancers = [],
        advancedComposeEnhancers = composeWithDevTools({}),
        advancedCombineReducers,
    } = moduleStoreSettings;

    const extensionMiddleware = extensions.reduce((mw, p) => {
        if (p.middleware) {
            mw.push(...p.middleware);
        }

        return mw;
    }, []);

    const middlewareManager = getRefCountedManager(
        getMiddlewareManager(),
        (a, b) => a === b
    );

    const enhancer = advancedComposeEnhancers(
        ...enhancers,
        applyMiddleware(...extensionMiddleware, middlewareManager.enhancer)
    );

    const moduleManager = getRefCountedManager(
        getModuleManager<State>(
            middlewareManager,
            extensions,
            advancedCombineReducers
        ),
        (a: IModule<any>, b: IModule<any>) => a.id === b.id,
        a => a.retained
    );

    // Create store
    const store: IModuleStore<State> = createReduxStore<State, any, {}, {}>(
        moduleManager.getReducer,
        initialState,
        enhancer as any
    ) as IModuleStore<State>;

    moduleManager.setDispatch(store.dispatch);

    const addModules = (modulesToBeAdded: IModuleTuple) => {
        const flattenedModules = flatten(modulesToBeAdded);
        moduleManager.add(flattenedModules);
        return {
            remove: () => {
                moduleManager.remove(flattenedModules);
            },
        };
    };

    const addModule = (moduleToBeAdded: IModule<any>) => {
        return addModules([moduleToBeAdded]);
    };

    extensions.forEach(p => {
        if (p.onModuleManagerCreated) {
            p.onModuleManagerCreated({
                addModule,
                addModules,
            });
        }
    });

    store.addModule = addModule;
    store.addModules = addModules;

    store.dispose = () => {
        // get all added modules and remove them
        moduleManager.dispose();
        middlewareManager.dispose();
        extensions.forEach(p => {
            if (p.dispose) {
                p.dispose();
            }
        });
    };

    store.addModules(initialModules);

    return store as IModuleStore<State>;
}