@district01/ng-redux-router/esm2015/district01-ng-redux-router.js

import { pathOr, equals, path, clone } from 'ramda';
import { Injectable, NgModule } from '@angular/core';
import { Router, RoutesRecognized, NavigationEnd, NavigationCancel, RouterModule } from '@angular/router';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
const ROUTE_PENDING = "ROUTE_PENDING";
const ROUTE_CANCEL = "ROUTE_CANCEL";
const ROUTE_UPDATE = "ROUTE_UPDATE";

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
const rebuildStateTree = (rootState, key) => {
    if (!rootState) {
        return {};
    }
    if (rootState.firstChild) {
        return Object.assign({}, rootState[key], rebuildStateTree(rootState.firstChild, key));
    }
    return Object.assign({}, rootState[key]);
};
const getPath = (url = "") => {
    return url.split(/[?#]/)[0];
};
const getFragment = (url = "") => {
    const /** @type {?} */ segments = pathOr(url, ["url"], url).split("/").pop().split(/[#]/);
    return segments.length > 1 ? segments[1] : "";
};
const getData = (rootState) => {
    if (!rootState) {
        return null;
    }
    if (rootState.firstChild) {
        return getData(rootState.firstChild);
    }
    return clone(rootState.data);
};
const routesAreEqual = (current, next) => {
    const /** @type {?} */ getProp = (prop, obj) => path([prop], obj);
    const /** @type {?} */ equalProp = (prop, ...objs) => equals.apply(null, objs.map((obj) => getProp(prop, obj)));
    return (equalProp("url", current, next) &&
        equalProp("params", current, next) &&
        equalProp("query", current, next) &&
        equalProp("fragment", current, next));
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
const initRouteChange = (route) => {
    return {
        type: ROUTE_PENDING,
        route: {
            url: route.urlAfterRedirects || route.url,
            path: getPath(route.urlAfterRedirects || route.url),
            params: rebuildStateTree(route.state.root, "params"),
            query: rebuildStateTree(route.state.root, "queryParams"),
            fragment: getFragment(route.url),
            data: getData(route.state.root),
        },
    };
};
const cancelRouteChange = (route) => {
    return {
        type: ROUTE_CANCEL,
    };
};
const endRouteChange = (route) => {
    return {
        type: ROUTE_UPDATE,
        route,
    };
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
class ReduxRouter {
    /**
     * @param {?} router
     */
    constructor(router) {
        this.router = router;
    }
    /**
     * @param {?} dispatch
     * @return {?}
     */
    initialize(dispatch) {
        if (!dispatch) {
            return console.error("No dispatcher provided."); // tslint:disable-line:no-console
        }
        this.routerSubscription = this.router.events
            .subscribe((routeEvent) => {
            if (routeEvent instanceof RoutesRecognized) {
                return dispatch(initRouteChange(routeEvent));
            }
            if (routeEvent instanceof NavigationCancel) {
                return dispatch(cancelRouteChange(routeEvent));
            }
            if (routeEvent instanceof NavigationEnd) {
                return dispatch(endRouteChange(routeEvent));
            }
        });
    }
}
ReduxRouter.decorators = [
    { type: Injectable },
];
/** @nocollapse */
ReduxRouter.ctorParameters = () => [
    { type: Router, },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
const REDUX_ROUTER_INITIAL_STATE = {
    current: null,
    previous: null,
    pending: null,
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
const routerReducer = (state = REDUX_ROUTER_INITIAL_STATE, action) => {
    if (action.type === ROUTE_PENDING) {
        if (!routesAreEqual(state.current, action.route)) {
            return Object.assign({}, state, { pending: clone(action.route) });
        }
    }
    if (action.type === ROUTE_CANCEL) {
        return Object.assign({}, state, { pending: null });
    }
    if (action.type === ROUTE_UPDATE) {
        return {
            current: clone(state.pending),
            previous: clone(state.current),
            pending: null,
        };
    }
    return state;
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
class ReduxRouterModule {
}
ReduxRouterModule.decorators = [
    { type: NgModule, args: [{
                imports: [
                    RouterModule,
                ],
                providers: [
                    ReduxRouter,
                ],
            },] },
];
/** @nocollapse */
ReduxRouterModule.ctorParameters = () => [];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * Generated bundle index. Do not edit.
 */

export { ReduxRouter, routerReducer, ROUTE_PENDING, ROUTE_CANCEL, ROUTE_UPDATE, REDUX_ROUTER_INITIAL_STATE, ReduxRouterModule };
//# sourceMappingURL=district01-ng-redux-router.js.map