ngrx-store.js

'use strict';

var rxjs_subject_BehaviorSubject = require('rxjs/subject/BehaviorSubject');
var rxjs_add_operator_map = require('rxjs/add/operator/map');
var rxjs_add_operator_distinctUntilChanged = require('rxjs/add/operator/distinctUntilChanged');
var rxjs_Subject = require('rxjs/Subject');
var rxjs_add_operator_let = require('rxjs/add/operator/let');
var rxjs_add_operator_scan = require('rxjs/add/operator/scan');
var angular2_core = require('angular2/core');

function __extends(d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}

var Store = (function (_super) {
    __extends(Store, _super);
    function Store(_dispatcher, _backend, initialState) {
        var _this = this;
        _super.call(this, initialState);
        this._dispatcher = _dispatcher;
        this._backend = _backend;
        _backend.connect(function (state) { return _super.prototype.next.call(_this, state); });
    }
    Store.prototype.select = function (keyOrSelector) {
        if (typeof keyOrSelector === 'string' ||
            typeof keyOrSelector === 'number' ||
            typeof keyOrSelector === 'symbol') {
            return this.map(function (state) { return state[keyOrSelector]; }).distinctUntilChanged();
        }
        else if (typeof keyOrSelector === 'function') {
            return this.map(keyOrSelector).distinctUntilChanged();
        }
        else {
            throw new TypeError("Store@select Unknown Parameter Type: "
                + ("Expected type of function or valid key type, got " + typeof keyOrSelector));
        }
    };
    Store.prototype.getState = function () {
        return this.value;
    };
    Store.prototype.dispatch = function (action) {
        this._dispatcher.dispatch(action);
    };
    Store.prototype.next = function (action) {
        this._dispatcher.next(action);
    };
    Store.prototype.error = function (error) {
        this._dispatcher.error(error);
    };
    Store.prototype.replaceReducer = function (reducer) {
        this._backend.replaceReducer(reducer);
    };
    return Store;
}(rxjs_subject_BehaviorSubject.BehaviorSubject));

function combineReducers(reducers) {
    var reducerKeys = Object.keys(reducers);
    var finalReducers = {};
    for (var i = 0; i < reducerKeys.length; i++) {
        var key = reducerKeys[i];
        if (typeof reducers[key] === 'function') {
            finalReducers[key] = reducers[key];
        }
    }
    var finalReducerKeys = Object.keys(finalReducers);
    return function combination(state, action) {
        if (state === void 0) { state = {}; }
        var hasChanged = false;
        var nextState = {};
        for (var i = 0; i < finalReducerKeys.length; i++) {
            var key = finalReducerKeys[i];
            var reducer = finalReducers[key];
            var previousStateForKey = state[key];
            var nextStateForKey = reducer(previousStateForKey, action);
            nextState[key] = nextStateForKey;
            hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
        }
        return hasChanged ? nextState : state;
    };
}
var compose = function () {
    var funcs = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        funcs[_i - 0] = arguments[_i];
    }
    return function () {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            args[_i - 0] = arguments[_i];
        }
        if (funcs.length === 0) {
            return args[0];
        }
        var last = funcs[funcs.length - 1];
        var rest = funcs.slice(0, -1);
        return rest.reduceRight(function (composed, f) { return f(composed); }, last.apply(void 0, args));
    };
};

var Dispatcher = (function (_super) {
    __extends(Dispatcher, _super);
    function Dispatcher() {
        _super.apply(this, arguments);
    }
    Dispatcher.prototype.dispatch = function (action) {
        this.next(action);
    };
    return Dispatcher;
}(rxjs_Subject.Subject));

var ActionTypes = {
    INIT: '@@ngrx/INIT'
};
var StoreBackend = (function () {
    function StoreBackend(_dispatcher, _reducer, _initialState, _preMiddleware, _postMiddleware) {
        if (_preMiddleware === void 0) { _preMiddleware = function (t) { return t; }; }
        if (_postMiddleware === void 0) { _postMiddleware = function (t) { return t; }; }
        this._dispatcher = _dispatcher;
        this._reducer = _reducer;
        this._initialState = _initialState;
        this._preMiddleware = _preMiddleware;
        this._postMiddleware = _postMiddleware;
    }
    StoreBackend.prototype._init = function () {
        this._dispatcher.dispatch({ type: ActionTypes.INIT });
    };
    StoreBackend.prototype.connect = function (nextCallbackFn) {
        var _this = this;
        this._dispatcher
            .let(this._preMiddleware)
            .scan(function (state, action) { return _this._reducer(state, action); }, this._initialState)
            .let(this._postMiddleware)
            .subscribe(nextCallbackFn);
        this._init();
    };
    StoreBackend.prototype.replaceReducer = function (reducer) {
        this._reducer = reducer;
        this._init();
    };
    return StoreBackend;
}());

var PRE_MIDDLEWARE = new angular2_core.OpaqueToken('ngrx/store/pre-middleware');
var POST_MIDDLEWARE = new angular2_core.OpaqueToken('ngrx/store/post-middleware');
var RESOLVED_PRE_MIDDLEWARE = new angular2_core.OpaqueToken('ngrx/store/resolved-pre-middleware');
var RESOLVED_POST_MIDDLEWARE = new angular2_core.OpaqueToken('ngrx/store/resolved-post-middleware');
var REDUCER = new angular2_core.OpaqueToken('ngrx/store/reducer');
var INITIAL_STATE = new angular2_core.OpaqueToken('ngrx/store/initial-state');
var dispatcherProvider = angular2_core.provide(Dispatcher, {
    useFactory: function () {
        return new Dispatcher();
    }
});
var storeProvider = angular2_core.provide(Store, {
    deps: [Dispatcher, StoreBackend, INITIAL_STATE],
    useFactory: function (dispatcher, backend, initialState) {
        return new Store(dispatcher, backend, initialState);
    }
});
var storeBackendProvider = angular2_core.provide(StoreBackend, {
    deps: [Dispatcher, REDUCER, INITIAL_STATE, RESOLVED_PRE_MIDDLEWARE, RESOLVED_POST_MIDDLEWARE],
    useFactory: function (dispatcher, reducer, initialState, preMiddleware, postMiddleware) {
        return new StoreBackend(dispatcher, reducer, initialState, preMiddleware, postMiddleware);
    }
});
var resolvedPreMiddlewareProvider = angular2_core.provide(RESOLVED_PRE_MIDDLEWARE, {
    deps: [PRE_MIDDLEWARE],
    useFactory: function (middleware) {
        return compose.apply(void 0, middleware);
    }
});
var resolvedPostMiddlewareProvider = angular2_core.provide(RESOLVED_POST_MIDDLEWARE, {
    deps: [POST_MIDDLEWARE],
    useFactory: function (middleware) {
        return compose.apply(void 0, middleware);
    }
});
function provideStore(reducer, initialState) {
    return [
        angular2_core.provide(REDUCER, {
            useFactory: function () {
                if (typeof reducer === 'function') {
                    return reducer;
                }
                return combineReducers(reducer);
            }
        }),
        angular2_core.provide(INITIAL_STATE, {
            deps: [REDUCER],
            useFactory: function (reducer) {
                if (initialState === undefined) {
                    return reducer(undefined, { type: ActionTypes.INIT });
                }
                return initialState;
            }
        }),
        angular2_core.provide(PRE_MIDDLEWARE, { multi: true, useValue: (function (T) { return T; }) }),
        angular2_core.provide(POST_MIDDLEWARE, { multi: true, useValue: (function (T) { return T; }) }),
        dispatcherProvider,
        storeProvider,
        storeBackendProvider,
        resolvedPreMiddlewareProvider,
        resolvedPostMiddlewareProvider
    ];
}
function usePreMiddleware() {
    var middleware = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        middleware[_i - 0] = arguments[_i];
    }
    return provideMiddlewareForToken(PRE_MIDDLEWARE, middleware);
}
function usePostMiddleware() {
    var middleware = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        middleware[_i - 0] = arguments[_i];
    }
    return provideMiddlewareForToken(POST_MIDDLEWARE, middleware);
}
function createMiddleware(useFactory, deps) {
    return angular2_core.provide(new angular2_core.OpaqueToken('@ngrx/store middleware'), {
        deps,
        useFactory
    });
}
function provideMiddlewareForToken(token, _middleware) {
    function isProvider(t) {
        return t instanceof angular2_core.Provider;
    }
    var provider = angular2_core.provide(token, {
        multi: true,
        deps: [angular2_core.Injector],
        useFactory: function (injector) {
            var middleware = _middleware.map(function (m) {
                if (isProvider(m)) {
                    return injector.get(m.token);
                }
                return m;
            });
            return compose.apply(void 0, middleware);
        }
    });
    return _middleware.filter(isProvider).concat([provider]);
}

exports.Store = Store;
exports.combineReducers = combineReducers;
exports.compose = compose;
exports.Dispatcher = Dispatcher;
exports.ActionTypes = ActionTypes;
exports.StoreBackend = StoreBackend;
exports.PRE_MIDDLEWARE = PRE_MIDDLEWARE;
exports.POST_MIDDLEWARE = POST_MIDDLEWARE;
exports.RESOLVED_PRE_MIDDLEWARE = RESOLVED_PRE_MIDDLEWARE;
exports.RESOLVED_POST_MIDDLEWARE = RESOLVED_POST_MIDDLEWARE;
exports.REDUCER = REDUCER;
exports.INITIAL_STATE = INITIAL_STATE;
exports.provideStore = provideStore;
exports.usePreMiddleware = usePreMiddleware;
exports.usePostMiddleware = usePostMiddleware;
exports.createMiddleware = createMiddleware;
exports.provideMiddlewareForToken = provideMiddlewareForToken;