map-transform/dist/operations/concat.js

Map and transform objects with mapping definitions

import { mergeStates } from './merge.js';
import { setStateValue, getStateValue, revFromState, flipState, } from '../utils/stateHelpers.js';
import { defToOperation } from '../utils/definitionHelpers.js';
import { noopNext } from '../utils/stateHelpers.js';
const merge = (left, right) => Array.isArray(right) ? [...left, ...right] : [...left, right];
async function getAndMergeArrays(state, fns) {
    let nextValue = [];
    for (const fn of fns) {
        const value = getStateValue(await fn(state));
        nextValue = merge(nextValue, value);
    }
    return setStateValue(state, nextValue.filter((val) => val !== undefined));
}
async function setArrayOnFirstOperation(state, fns) {
    let valueState = await fns[0](state);
    for (const fn of fns.slice(1)) {
        const thisState = await fn(setStateValue(state, []));
        valueState = mergeStates(valueState, thisState);
    }
    return valueState;
}
function concatPipelines(defs, flip) {
    return (options) => {
        const fns = defs.map((def) => defToOperation(def, options)(options)(noopNext));
        if (fns.length === 0) {
            return (next) => async (state) => setStateValue(await next(state), revFromState(state, flip) ? {} : []);
        }
        return (next) => async function doConcat(state) {
            const nextState = flipState(await next(state), flip);
            return revFromState(nextState)
                ? setArrayOnFirstOperation(nextState, fns)
                : getAndMergeArrays(nextState, fns);
        };
    };
}
export function concat(...defs) {
    return concatPipelines(defs, false);
}
export function concatRev(...defs) {
    return concatPipelines(defs, true);
}
//# sourceMappingURL=concat.js.map