@lumieslab/stasho/dist/utils.js

lightweight state management library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.combinedReducers = exports.subReducer = exports.filteredReducer = exports.actionWithoutParams = exports.actionWithParams = exports.isAction = exports.buildEffect = exports.buildReducer = exports.buildMemory = void 0;
function buildMemory(...callbacks) {
    return function (input) {
        return callbacks.reduce((acc, callback, i) => callback(acc), input);
    };
}
exports.buildMemory = buildMemory;
function buildReducer(...callbacks) {
    return (previousState, action) => {
        return callbacks.reduce((state, reducerCallback) => reducerCallback(state, action), previousState);
    };
}
exports.buildReducer = buildReducer;
function buildEffect(...callbacks) {
    return (action) => callbacks.forEach((effectCallback) => effectCallback(action));
    ;
}
exports.buildEffect = buildEffect;
function isAction(actionA, actionB) {
    if (typeof (actionA) === "object" && typeof (actionB) === "object") {
        return actionA.type === actionB.type;
    }
    else if (typeof (actionA) === "object") {
        return actionA.type === actionB;
    }
    else if (typeof (actionB) === "object") {
        return actionA === actionB.type;
    }
    else {
        return actionA === actionB;
    }
}
exports.isAction = isAction;
function actionWithParams(type) {
    const callback = (params) => {
        return Object.assign({ type }, params);
    };
    const callbackContext = {
        type,
        equals: (action) => {
            if (typeof action == "object") {
                return action.type === type;
            }
            else {
                return action === type;
            }
        }
    };
    return Object.assign(callback, callbackContext);
}
exports.actionWithParams = actionWithParams;
function actionWithoutParams(type) {
    const callback = () => ({
        type
    });
    const callbackContext = {
        type,
        equals: (action) => {
            if (typeof action == "object") {
                return action.type === type;
            }
            else {
                return action === type;
            }
        }
    };
    return Object.assign(callback, callbackContext);
}
exports.actionWithoutParams = actionWithoutParams;
function filteredReducer(whitelist, callback) {
    return (state, action) => {
        // Filter out action types
        const isActionWhitelisted = whitelist.find((actionCaller) => {
            return actionCaller().type == action.type;
        });
        // Call the action if it's whitelisted
        if (isActionWhitelisted) {
            return callback(state, action);
        }
        else {
            return state;
        }
    };
}
exports.filteredReducer = filteredReducer;
function subReducer(slice, callback) {
    return (state, action) => {
        state[slice] = callback(state[slice], action);
        return state;
    };
}
exports.subReducer = subReducer;
function combinedReducers(...callbacks) {
    return (startingState, action) => {
        return callbacks.reduce((state, reducer) => reducer(state, action), startingState);
    };
}
exports.combinedReducers = combinedReducers;