pi-lens/dist/clients/lsp/aggregation.js

Real-time code feedback for pi — LSP, linters, formatters, type-checking, structural analysis & booboo

/**
 * Diagnostic Aggregation Utilities for pi-lens LSP
 *
 * Provides result-aware racing for multi-client diagnostic collection.
 * Replaces the simple Promise.race + grace window pattern with one that
 * only fires the grace window when a client actually returned diagnostics.
 */
/**
 * Race a set of promises to completion, resolving as soon as the
 * `shouldComplete` predicate is satisfied by the accumulated results.
 *
 * Key difference from Promise.race: Promise.race resolves when ANY promise
 * settles (even with an empty/useless result). raceToCompletion only resolves
 * early when results meet a quality threshold, optionally with a grace window
 * to let more results accumulate.
 *
 * @param promises - Array of promises producing results
 * @param shouldComplete - Called after each settled promise with all results
 *   accumulated so far. Return true to trigger early completion.
 * @param options.timeoutMs - Hard deadline; after this, resolve with whatever is ready
 * @param options.graceMs - After shouldComplete returns true, wait this many ms
 *   for additional results before finalizing. 0 = finalize immediately.
 */
export async function raceToCompletion(promises, shouldComplete, options = { timeoutMs: 1500 }) {
    const results = new Array(promises.length).fill(undefined);
    let graceTimer;
    let completed = false;
    let remaining = promises.length;
    return new Promise((resolve) => {
        const timeout = setTimeout(() => {
            completed = true;
            if (graceTimer)
                clearTimeout(graceTimer);
            resolve(results.filter((r) => r !== undefined));
        }, options.timeoutMs);
        const finalize = () => {
            if (completed)
                return;
            completed = true;
            clearTimeout(timeout);
            if (graceTimer)
                clearTimeout(graceTimer);
            resolve(results.filter((r) => r !== undefined));
        };
        const check = () => {
            if (completed)
                return;
            if (remaining === 0) {
                finalize();
                return;
            }
            const collected = results.filter((r) => r !== undefined);
            if (shouldComplete(collected)) {
                if (options.graceMs !== undefined &&
                    options.graceMs > 0 &&
                    !graceTimer) {
                    // Start grace window — more results may arrive
                    graceTimer = setTimeout(() => finalize(), options.graceMs);
                }
                else {
                    finalize();
                }
            }
        };
        for (let i = 0; i < promises.length; i++) {
            const index = i;
            promises[i]
                .then((result) => {
                if (!completed) {
                    results[index] = result;
                    remaining--;
                    check();
                }
            })
                .catch(() => {
                if (!completed) {
                    remaining--;
                    check();
                }
            });
        }
    });
}