redux-wrapper-extended/dist/src/index.js

Short Cut Reducer definition.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var redux_1 = require("redux");
var StoreWrapper = /** @class */ (function () {
    function StoreWrapper(reducers, initialState, enhancer) {
        var reducerAsExtendedMapObject = reducers;
        var reducerAsReducer = reducers;
        if (typeof reducers === 'object') {
            this.combinedReducers = combineReducerWrapper(reducerAsExtendedMapObject);
        }
        else {
            this.combinedReducers = reducerAsReducer;
        }
        if (initialState) {
            this.store = redux_1.createStore(this.combinedReducers, initialState, enhancer);
        }
        else {
            this.store = redux_1.createStore(this.combinedReducers, enhancer);
        }
    }
    StoreWrapper.prototype.dispatch = function (type, payload) {
        return this.store.dispatch({ type: type, payload: payload });
    };
    StoreWrapper.prototype.getStore = function () {
        return this.store;
    };
    StoreWrapper.prototype.getCombinedReducers = function () {
        return this.combinedReducers;
    };
    return StoreWrapper;
}());
exports.StoreWrapper = StoreWrapper;
var uselessReducer = function (state, action) {
    if (state == undefined) {
        return null;
    }
    return state;
};
exports.uselessReducer = uselessReducer;
var combineReducerWrapper = function (reducers) {
    var items = {};
    for (var prop in reducers) {
        var reducer = reducers[prop];
        var reducerAsMapObject = reducer;
        var reducerAsReducer = reducer;
        if (typeof reducer === 'object') {
            items[prop] = combineReducerWrapper(reducerAsMapObject);
        }
        else if (typeof reducer === 'function') {
            items[prop] = reducerAsReducer;
        }
    }
    return redux_1.combineReducers(items);
};
exports.combineReducerWrapper = combineReducerWrapper;
var ReducerWrapper = /** @class */ (function () {
    function ReducerWrapper(defaultState) {
        this.defaultState = defaultState || null;
        this.funcs = {};
    }
    ReducerWrapper.prototype.withHandlersFromOtherReducerWrappers = function (reducerWrappers) {
        var t = this;
        reducerWrappers.forEach(function (reducer) {
            Object.keys(reducer.funcs).forEach(function (key) {
                t.funcs[key] = reducer.funcs[key];
            });
        });
        return this;
    };
    ReducerWrapper.prototype.addHandler = function (type, handler) {
        var func = function (state, action) {
            if (action.type === type) {
                return handler(state, action.payload);
            }
            return state;
        };
        this.funcs[type] = func;
        return this;
    };
    ReducerWrapper.prototype.getNavigationProps = function (func) {
        var strElement = func.toString().split("=>");
        var arrayProps = "";
        if (strElement.length == 2) {
            arrayProps = strElement[1];
        }
        else if (strElement.length == 1) {
            var regex = /return((.|\n)*(?=\;))/g;
            var matches = strElement[0].match(regex);
            if (matches) {
                arrayProps = matches[0].replace('return', '');
            }
        }
        return arrayProps.trim().split(".");
    };
    ReducerWrapper.prototype.lambdaFuncToInitialPropInfo = function (func) {
        var navigations = this.getNavigationProps(func);
        var navToLast = ["x"].concat(navigations.slice(1, navigations.length - 1)).join(".");
        return {
            rootProp: navigations[1],
            lastProp: navigations[navigations.length - 1],
            beforeLastFunc: eval("(x) => " + navToLast),
            navigations: navigations
        };
    };
    ReducerWrapper.prototype.addPropChangedHandler = function (type, mappingFunc, payloadFunc) {
        var defaultPayloadFunc = function (s, pl) { return pl; };
        var usedPayloadFunc = payloadFunc || defaultPayloadFunc;
        var propInfo = null;
        if (mappingFunc) {
            propInfo = this.lambdaFuncToInitialPropInfo(mappingFunc);
        }
        var func = function (state, action) {
            if (action.type === type) {
                if (typeof state === 'object' && propInfo && propInfo.rootProp) {
                    var stateAsObject = state;
                    var childOfDuplicatedObject = JSON.parse(JSON.stringify(stateAsObject[propInfo.rootProp]));
                    var newState = Object.assign({}, state);
                    var newStateAsObject = newState;
                    newStateAsObject[propInfo.rootProp] = childOfDuplicatedObject;
                    var focusedObject = propInfo.beforeLastFunc(newState);
                    focusedObject[propInfo.lastProp] = usedPayloadFunc(state, action.payload);
                    return newState;
                }
                else {
                    return usedPayloadFunc(state, action.payload);
                }
            }
            return state;
        };
        this.funcs[type] = func;
        return this;
    };
    ReducerWrapper.prototype.getReducer = function (otherReducers) {
        var _this = this;
        var combinedReducerDefault = null;
        if (otherReducers) {
            combinedReducerDefault = combineReducerWrapper(otherReducers);
        }
        var t = this;
        return function (state, action) {
            state = state || _this.defaultState;
            var newState = state;
            for (var funcType in t.funcs) {
                var func = t.funcs[funcType];
                newState = func(state, action);
                if (newState != state) {
                    break;
                }
            }
            if (combinedReducerDefault) {
                newState = newState || {};
                var deeperNewerState = combinedReducerDefault(newState, action);
                return Object.assign({}, newState, deeperNewerState);
            }
            return newState;
        };
    };
    ReducerWrapper.importFrom = function (anotherReducer, initialState) {
        var reducerWrappers = new ReducerWrapper(initialState);
        reducerWrappers.funcs['_importedFrom'] = anotherReducer;
        return reducerWrappers;
    };
    return ReducerWrapper;
}());
exports.ReducerWrapper = ReducerWrapper;
var ActionCollections = /** @class */ (function () {
    function ActionCollections(name, actions) {
        var generator = {};
        Object.keys(actions).forEach(function (key) {
            var callableAction = actions[key];
            generator[key] = function () {
                return {
                    type: name + "." + key,
                    payload: callableAction.apply(null, arguments)
                };
            };
        });
        this.name = name;
        this.generator = generator;
    }
    ActionCollections.prototype.setExecutor = function (dispatch) {
        var executor = {};
        var t = this;
        Object.keys(this.generator).forEach(function (key) {
            var callableAction = t.generator[key];
            executor[key] = function () {
                var generatedAction = callableAction.apply(null, arguments);
                dispatch(generatedAction);
            };
        });
        return executor;
    };
    return ActionCollections;
}());
exports.ActionCollections = ActionCollections;
var dispatchAction = function (dispatchFunc, type, payload) {
    var anyAction = {
        type: type,
        payload: payload
    };
    return dispatchFunc(anyAction);
};
exports.dispatchAction = dispatchAction;