export function all()

in src/SyncTasks.ts [541:602]
50 lines of code
8 McCabe index (conditional complexity)

export function all<T1, T2, T3, T4, T5>(
    values: [Raceable<T1>, Raceable<T2>, Raceable<T3>, Raceable<T4>, Raceable<T5>]
): STPromise<[T1, T2, T3, T4, T5]>;

export function all<T1, T2, T3, T4>(values: [Raceable<T1>, Raceable<T2>, Raceable<T3>, Raceable<T4>]): STPromise<[T1, T2, T3, T4]>;

export function all<T1, T2, T3>(values: [Raceable<T1>, Raceable<T2>, Raceable<T3>]): STPromise<[T1, T2, T3]>;

export function all<T1, T2>(values: [Raceable<T1>, Raceable<T2>]): STPromise<[T1, T2]>;

export function all<T>(values: (T | Thenable<T>)[]): STPromise<T[]>;

export function all(items: any[]): STPromise<any[]> {
    if (items.length === 0) {
        return Resolved<any[]>([]);
    }

    const outTask = Defer<any[]>();
    let countRemaining = items.length;
    let foundError: any;
    const results = Array(items.length);

    outTask.onCancel((val) => {
        items.forEach(item => {
            if (isCancelable(item)) {
                Internal.SyncTask.cancelOtherInternal(item, val);
            }
        });
    });

    const checkFinish = (): void => {
        if (--countRemaining === 0) {
            if (foundError !== undefined) {
                outTask.reject(foundError);
            } else {
                outTask.resolve(results);
            }
        }
    };

    items.forEach((item, index) => {
        if (isThenable(item)) {
            const task = item as Thenable<any>;

            task.then(res => {
                results[index] = res;
                checkFinish();
            }, err => {
                if (foundError === undefined) {
                    foundError = (err !== undefined) ? err : true;
                }
                checkFinish();
            });
        } else {
            // Not a task, so resolve directly with the item
            results[index] = item;
            checkFinish();
        }
    });

    return outTask.promise();
}