Function getReadyCallbacks

dash/dash-renderer/src/actions/dependencies_ts.ts:197–271

(
    paths: any,
    candidates: ICallback[],
    callbacks: ICallback[] = candidates,
    graphs: any = {}
)

}

export const getReadyCallbacks = (
    paths: any,
    candidates: ICallback[],
    callbacks: ICallback[] = candidates,
    graphs: any = {}
): ICallback[] => {
    // Skip if there's no candidates
    if (!candidates.length) {
        return [];
    }

    // Find all outputs of all active callbacks
    const outputs = map(
        combineIdAndProp,
        reduce<ICallback, any[]>(
            (o, cb) => concat(o, flatten(cb.getOutputs(paths))),
            [],
            callbacks
        )
    );

    // Make `outputs` hash table for faster access
    let outputsMap: {[key: string]: boolean} = {};
    outputs.forEach(output => (outputsMap[output] = true));

    // find all the outputs touched by activeCallbacks
    // remove this check if graph is accessible all the time

    if (Object.keys(graphs).length) {
        //not sure if graph will be accessible all the time
        const allTouchedOutputs: {[key: string]: boolean}[] = flatten(
            map(
                cb => getAllSubsequentOutputsForCallback(graphs, paths, cb),
                callbacks
            )
        );

        // overrrides the outputsMap, will duplicate callbacks filtered
        // this is only done to silence typescript errors
        if (allTouchedOutputs.length > 0) {
            outputsMap = Object.assign(
                allTouchedOutputs[0],
                ...allTouchedOutputs
            );
        }
    }

    // Ramda.JS `difference` function is slow because it compares objects entirely
    // This cause the following `filter` to be exponentially slow as the number of inputs or outputs grow
    // We can optimize this by comparing only the `id+prop` part of the inputs & outputs.
    // Original difference takes 380ms on average to compute difference between 200 inputs and 1 output.
    // The following function takes 1-2ms on average.
    const differenceBasedOnId = (inputs: any[], outputs: any[]): any[] =>
        inputs.filter(
            input =>
                !outputs.some(
                    output =>
                        combineIdAndProp(input) === combineIdAndProp(output)