how about add a way to interrupt the loop from outside?

[franckchen]

Currently only provides a way to break the loop internally by return end symbol, It would be useful to provide a way to cancel the loop from outside like below.

const cancellablePromise = pForever(async () => {
});

cancellablePromise.cancel();

why i need to cancel a promise from outside? bcz code like below is stupid.😓

let loopShouldStop = false;

pForever(async () => {
     if (loopShouldStop) return pForever.end;
     await doJobA();
     if (loopShouldStop) return pForever.end;
     await doJobB();
     if (loopShouldStop) return pForever.end;
     await doJobC();
});

[sindresorhus]

I don't see how that could work. pForever cannot interrupt the async function you provide. There's no native async cancellation in JavaScript.

[sindresorhus]

However, we should improve the usability for this specific case.

Braindump: We could maybe add a pForever.endIf() (needs a better name) method, that would accept a boolean for whether to end, and if true or left out, would throw and error that made pForever stop.

Which would look like:

let loopShouldStop = false;

pForever(async () => {
	pForever.endIf(loopShouldStop);
	await doJobA();
	pForever.endIf(loopShouldStop);
	await doJobB();
	pForever.endIf(loopShouldStop);
	await doJobC();
});

I'm also open to other ideas.

[franckchen]

too may pForever.endIf maybe not elegant enough.🤔
I think promise-fun similar to caolan / async, so how about like this.

pForever(
    [
        asyncJobA,
        asyncJobB,
        async () => {
            // some asyn job
        },
        () => {
            // do some sync job
        }
    ],
    () => {
        //  Execute the next task if the condition is true, otherwise, end the loop
        return condition;
    }
)

Also I don't want to wait for the asynchronous task to finish, I want to terminate it immediately.This is a very common requirement in actual development

const promise = pForever(async (onCancel) => {
    let p;
    onCancel(() => p?.cancel());

    p = doJobA();
    await p;
    p = doJobB();
    await p;
    p = doJobC();
    await p;
});

promise.cancel();

[sindresorhus]

The proper solution these days is to use AbortController, so it would be something like this if pForever supported it:

const promise = pForever({signal}, async signal => {
	await doJobA({signal});
	await doJobA({signal});
	await doJobA({signal});
});

[mahnunchik]

It would be helpful to have AbortController be added