Interface RunParams

Params for the run function.

interface RunParams {
    afterExecute?: (
        payload: {
            result: unknown;
            setResult: (result: unknown) => void;
            state: State;
        },
    ) => void;
    afterParse?: (
        payload: {
            context: Context;
            parsedOptions: {
                [key: string]:
                    | undefined
                    | string
                    | number
                    | boolean
                    | string[]
                    | number[]
                    | false[]
                    | true[];
            };
            setParsedOptions: (
                optionValues: {
                    [key: string]:
                        | undefined
                        | string
                        | number
                        | boolean
                        | string[]
                        | number[]
                        | false[]
                        | true[];
                },
            ) => void;
        },
    ) => void;
    afterResolve?: (
        payload: {
            addResolvedCommands: (resolvedCommands: ResolvedCommand[]) => void;
            context: Context;
            resolvedCommands: ResolvedCommand[];
        },
    ) => void;
    afterStateChange?: (
        payload: { changes: Partial<NextState>; state: State },
    ) => void;
    beforeEnd?: (
        payload: {
            data: unknown;
            setData: (data: unknown) => void;
            state: State;
        },
    ) => void;
    beforeExecute?: (
        payload: {
            initialData: unknown;
            setInitialData: (data: unknown) => void;
            setResultAndSkip: (result: unknown) => void;
            skip: () => void;
            state: State;
        },
    ) => void;
    beforeNext?: (
        payload: {
            data: unknown;
            nextCommand: undefined | ResolvedCommand;
            setData: (data: unknown) => void;
            setNextCommand: (command: ResolvedCommand) => void;
            state: State;
        },
    ) => void;
    beforeParse?: (
        payload: {
            commandString: string | string[];
            context: Context;
            optionsConfig: OptionsConfig;
            setParsedOptionsAndSkip: (
                optionValues: {
                    [key: string]:
                        | undefined
                        | string
                        | number
                        | boolean
                        | string[]
                        | number[]
                        | false[]
                        | true[];
                },
            ) => void;
            setParseFn: (parseFn: ParseCommandFn) => void;
            skip: () => void;
        },
    ) => void;
    beforeResolve?: (
        payload: {
            addResolvedCommands: (resolvedCommands: ResolvedCommand[]) => void;
            commandsDir: string;
            commandString: string;
            context: Context;
            setParseFn: (parseFn: ParseCommandFn) => void;
            setResolveFn: (resolveFn: ResolveCommandFn) => void;
            skip: () => void;
        },
    ) => void;
    beforeResolveNext?: (
        payload: {
            addResolvedCommands: (resolvedCommands: ResolvedCommand[]) => void;
            commandsDir: string;
            commandString: string;
            context: Context;
            lastResolved: ResolvedCommand;
            setParseFn: (parseFn: ParseCommandFn) => void;
            setResolveFn: (resolveFn: ResolveCommandFn) => void;
            skip: () => void;
        },
    ) => void;
    beforeStateChange?: (
        payload: {
            changes: Partial<NextState>;
            setChanges: (changes: Partial<NextState>) => void;
            skip: () => void;
            state: State;
        },
    ) => void;
    command?: string
    | string[];
    commandsDir?: string;
    defaultCommand?: string | string[];
    initialData?: unknown;
    onError?: (
        payload: {
            context: Context;
            error: unknown;
            ignore: () => void;
            setError: (error: unknown) => void;
        },
    ) => void;
    onExit?: (
        payload: {
            cancel: () => void;
            code: number;
            context: Context;
            message?: any;
            setCode: (code: number) => void;
            setMessage: (message: any) => void;
        },
    ) => void;
    options?: OptionsConfig;
    plugins?: {
        description?: string;
        init: (context: Context) => MaybePromise<boolean>;
        meta?: AnyObject;
        name: string;
        version?: string;
    }[];
}

Properties

afterExecute? afterParse? afterResolve? afterStateChange? beforeEnd? beforeExecute? beforeNext? beforeParse? beforeResolve? beforeResolveNext? beforeStateChange? command? commandsDir? defaultCommand? initialData? onError? onExit? options? plugins?

Properties

OptionalafterExecute

afterExecute?: (
    payload: {
        result: unknown;
        setResult: (result: unknown) => void;
        state: State;
    },
) => void

A hook that runs once all commands have been called or when context.end() is called.

OptionalafterParse

afterParse?: (
    payload: {
        context: Context;
        parsedOptions: {
            [key: string]:
                | undefined
                | string
                | number
                | boolean
                | string[]
                | number[]
                | false[]
                | true[];
        };
        setParsedOptions: (
            optionValues: {
                [key: string]:
                    | undefined
                    | string
                    | number
                    | boolean
                    | string[]
                    | number[]
                    | false[]
                    | true[];
            },
        ) => void;
    },
) => void

A hook that runs after parsing the command string.

OptionalafterResolve

afterResolve?: (
    payload: {
        addResolvedCommands: (resolvedCommands: ResolvedCommand[]) => void;
        context: Context;
        resolvedCommands: ResolvedCommand[];
    },
) => void

A hook that runs after importing command modules.

OptionalafterStateChange

afterStateChange?: (
    payload: { changes: Partial<NextState>; state: State },
) => void

A hook that runs after each state update during command execution.

OptionalbeforeEnd

beforeEnd?: (
    payload: {
        data: unknown;
        setData: (data: unknown) => void;
        state: State;
    },
) => void

A hook that runs before executing the context.end() function.

OptionalbeforeExecute

beforeExecute?: (
    payload: {
        initialData: unknown;
        setInitialData: (data: unknown) => void;
        setResultAndSkip: (result: unknown) => void;
        skip: () => void;
        state: State;
    },
) => void

A hook that runs before calling the first command.

OptionalbeforeNext

beforeNext?: (
    payload: {
        data: unknown;
        nextCommand: undefined | ResolvedCommand;
        setData: (data: unknown) => void;
        setNextCommand: (command: ResolvedCommand) => void;
        state: State;
    },
) => void

A hook that runs before executing the context.next() function.

OptionalbeforeParse

beforeParse?: (
    payload: {
        commandString: string | string[];
        context: Context;
        optionsConfig: OptionsConfig;
        setParsedOptionsAndSkip: (
            optionValues: {
                [key: string]:
                    | undefined
                    | string
                    | number
                    | boolean
                    | string[]
                    | number[]
                    | false[]
                    | true[];
            },
        ) => void;
        setParseFn: (parseFn: ParseCommandFn) => void;
        skip: () => void;
    },
) => void

A hook that runs before parsing the command string using the options config from plugins and imported command modules.

OptionalbeforeResolve

beforeResolve?: (
    payload: {
        addResolvedCommands: (resolvedCommands: ResolvedCommand[]) => void;
        commandsDir: string;
        commandString: string;
        context: Context;
        setParseFn: (parseFn: ParseCommandFn) => void;
        setResolveFn: (resolveFn: ResolveCommandFn) => void;
        skip: () => void;
    },
) => void

A hook that runs before attempting to locate and import command modules.

OptionalbeforeResolveNext

beforeResolveNext?: (
    payload: {
        addResolvedCommands: (resolvedCommands: ResolvedCommand[]) => void;
        commandsDir: string;
        commandString: string;
        context: Context;
        lastResolved: ResolvedCommand;
        setParseFn: (parseFn: ParseCommandFn) => void;
        setResolveFn: (resolveFn: ResolveCommandFn) => void;
        skip: () => void;
    },
) => void

A hook that runs before attempting to locate and import each subcommand module.

OptionalbeforeStateChange

beforeStateChange?: (
    payload: {
        changes: Partial<NextState>;
        setChanges: (changes: Partial<NextState>) => void;
        skip: () => void;
        state: State;
    },
) => void

A hook that runs before each state update during command execution.

Optionalcommand

command?: string | string[]

The command string or array to be parsed and executed. If not provided, it defaults to system arguments.

OptionalcommandsDir

commandsDir?: string

A directory path containing command modules.

Default

${process.cwd()}/commands || ${__dirname}/commands

OptionaldefaultCommand

defaultCommand?: string | string[]

The command string to run if no command is provided.

OptionalinitialData

initialData?: unknown

Initial context or data to pass to commands during execution.

OptionalonError

onError?: (
    payload: {
        context: Context;
        error: unknown;
        ignore: () => void;
        setError: (error: unknown) => void;
    },
) => void

A hook that runs whenever an error is thrown.

OptionalonExit

onExit?: (
    payload: {
        cancel: () => void;
        code: number;
        context: Context;
        message?: any;
        setCode: (code: number) => void;
        setMessage: (message: any) => void;
    },
) => void

A hook that runs whenever a plugin or command intends to exit the process.

Optionaloptions

options?: OptionsConfig

Options to include in the context.

Optionalplugins

plugins?: {
    description?: string;
    init: (context: Context) => MaybePromise<boolean>;
    meta?: AnyObject;
    name: string;
    version?: string;
}[]

An array of plugins that can modify or augment the behavior of commands.

Type declaration

  • Optionaldescription?: string
  • init: (context: Context) => MaybePromise<boolean>

    Initialize the plugin.

  • Optionalmeta?: AnyObject

    Additional metadata about the plugin that doesn't fit in the standard fields.

    Note: Plugin info on the Context object will be frozen after the plugin is initialized. However, the freeze is shallow, so the fields of this object will be mutable by default.

  • name: string
  • Optionalversion?: string

Settings

Member Visibility

On This Page

Properties