2.0.1 • Published 5 days ago
@ugdu/processor v2.0.1
A task processor which could be hooked in.
Overview
The task processor is responsible for creating and managing tasks.
Tasks can be organized in parallel or serial according to your needs.
The hooks defined in the task will be triggered during the task execution.
There are different types of hooks to meet your needs. Such as first
, sequential
and parallel
.
For features, check features.
For a simple example, check usage.
The phrases like hook dirver
are terms. Their brief explanation is here.
For more detail, check our API docs.
Features
- Delegation
- Can hook into the children
hook dirver
through the parenthook dirver
.
- Can hook into the children
- Shareable
- Can create a
task options
which can be seen as a definition of atask
. Others can use it to createtask
s.
- Can create a
- Extensible
- Can extend the
task options
easily.
- Can extend the
- Composable
- Can compose the parent
task options
with childrentask options
in series or parallel mode with your need.
- Can compose the parent
- Preset hooks
- Can preset
hook fn
s fortask options
.
- Can preset
Usage
Below is a simple example of a task
which sets data to the context
, writes the data to disk, and calls the hook fn
s at the same time.
import { writeFile } from 'fs/promises'
import { Processor, TaskOptions, series } from '@ugdu/processor'
declare module '@ugdu/processor' {
interface Context {
data: string
}
}
interface WriteHooks {
'before-write'(data: string): void
'after-write'(data: string): void
}
const setData = new TaskOptions(
function () {
const data = 'xx'
this.manager.context.data = data
}
)
const write = new TaskOptions<WriteHooks>(
// The `action` which will be invoked when the corresponding `task` is running.
async function () {
const {
manager: {
context: { data }
}
} = this
this.call('before-write', 'sequential', data)
await writeFile('/path/to/target/file', data)
this.call('after-write', 'sequential', data)
},
// The `hook name`s that the corresponding `task` could call with.
['before-write', 'after-write'],
// The preset hooks of the corresponding `task`.
{
'before-write' (data) {
console.log(data)
}
}
)
const to = series(setData, write)
const processor = new Processor()
const task = processor.task(to)
task.hook('before-write', () => console.log('before ~'))
task.hook('after-write', () => console.log('after ~'))
task.run()
// Will log
// 'xx'
// 'before ~'
// 'after ~'
Terms
hook dirver
Ahook dirver
is an instance of HookDriver.task
Atask
is an instance of Task which is a subclass of HookDriver.task options
A definition of atask
.hook fn
The hook function.context
The context shared between tasks.