Interface Task<O>

interface Task<O> {
    async?: number | boolean;
    dependencies?: TaskDep<any>[];
    desc?: string;
    fn?: ((ctx: TaskContext<O>) => void | Promise<void>);
    force?: boolean;
    loading?: boolean;
    logCommand?: boolean;
    logger?: ILoggerProps;
    name: string;
    namespaces: string[];
    options: O;
    rawArgs: string[];
    resolveOptions?: ((ctx: TaskContext<any>) => O | Promise<O>);
    strict?: boolean;
}

Type Parameters

  • O = any

Hierarchy (view full)

Properties

async? dependencies? desc? fn? force? loading? logCommand? logger? name namespaces options rawArgs resolveOptions? strict?

Properties

Optionalasync

async?: number | boolean

Dependences are executed serially by default. If order doesn't matter and you want better performance via parallel, you can mark it as asynchronized. Asynchronized will run immediately whether there are synchronized tasks before them or not. You can pass a number as the priority of asynchronized tasks, bigger is formmer.

Optionaldependencies

dependencies?: TaskDep<any>[]

Optionaldesc

desc?: string

Optionalfn

fn?: ((ctx: TaskContext<O>) => void | Promise<void>)

Optionalforce

force?: boolean

Whether rerun it when it occured in dependences tree more then once.

Optionalloading

loading?: boolean

Description

whether show loading

Default

globalOptions.loading

OptionallogCommand

logCommand?: boolean

Description

whether log executed command

Default

globalOptions.logCommand

Optionallogger

logger?: ILoggerProps

name

name: string

namespaces

namespaces: string[]

options

options: O

Parsed options

rawArgs

rawArgs: string[]

Raw arg strings

OptionalresolveOptions

resolveOptions?: ((ctx: TaskContext<any>) => O | Promise<O>)

Optionalstrict

strict?: boolean

Description

Whether task options only allow defined options, default false

Default

false

Settings

Member Visibility

On This Page

Properties