🚦vue-concurrency

# TaskInstance

New task instance is created via performing a task.

const task = useTask(function*(signal, a, b) {
  /* ... */
});
const taskInstance = task.perform(1, 2);

# value

T | null

The value of an instance is what the perform function returns.

const taskInstance = task.perform();
await taskInstance;
console.log(taskInstance.value);

# error

any | null

Instance saves in error whatever was thrown during the perform call. Read more about handling errors.

const task = useTask(function*() {
  throw new Error("You shall not pass");
});

const instance = task.perform();
console.log(instance.error);

# hasStarted

boolean

Instance is started immediately after a task is performed unless it was enqueued or dropped or immediately canceled.

# isRunning

boolean

Instance is running unless it's finished, dropped or enqueued.

# isFinished

boolean

Instance is finished if it has resolved a value or threw an error

# isError

boolean

if (instance.isError) {
  console.log(instance.error);
}

# isSuccessful

boolean

Instance is successful if it is finished and there's no error

# isCanceled

boolean

Instance is canceled if it was cancelled implicitly (via cancel on unmount) or explicitly via cancel() or cancelAll().

# isDropped

boolean

Instance may be dropped if the task has drop() or keepLatest() concurrency policy.

# isEnqueued

boolean

Instance may be enqueued if the task has enqueue() or keepLatest() concurrency policy.

# then()

(onfulfilled: onFulfilled<T>, onrejected?: onRejected) => Promise<any>

Allows to use the task in a PromiseLike way. Returns a promise which allows chaining just like with regular promises. This also allows the instance to be awaited.

const instance = task.perform();
instance.then((resultValue) => {
  // ...
});

// or just await

const value = await instance;

Read more about composing tasks.

# catch()

(onrejected?: onRejected) => any

Allows to catch errors that were thrown during the perform call.

const instance = task.perform();
instance.catch((error) => {
  console.error(error);
});

// or just await with try catch

try {
  const value = await instance;
} catch (error) {
  console.error(error);
}

# finally()

() => any

finally is called either way not matter if instance resolved or rejected.

# status

"running" | "enqueued" | "canceled" | "canceling" | "dropped" | "error" | "success"

status might be useful for debugging purposes.

<template>
  <div>{{ myTask.status }}</div>
</template>

# canceledOn()

(signal: AbortSignalWithPromise) => TaskInstance<T>

This is used for some cases when cancelation does not cascade. See details here.

# id

number

id might be useful sometimes for debugging purposes as it's simply the index of the task instance within the task.

← Utils →