@gud/cli
    Preparing search index...

    Interface LifecycleHooks

    The core hooks interface that defines lifecycle events for the CLI execution process. Hooks are called in sequential order as listed below.

    interface LifecycleHooks {
        afterCommand: (
            payload: {
                command: ResolvedCommand;
                data: unknown;
                setData: (data: unknown) => void;
                state: State;
            },
        ) => MaybePromise<void>;
        afterExecute: (
            payload: {
                result: unknown;
                setResult: (result: unknown) => void;
                state: State;
            },
        ) => MaybePromise<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;
            },
        ) => MaybePromise<void>;
        afterResolve: (
            payload: {
                addResolvedCommands: (resolvedCommands: ResolvedCommand[]) => void;
                context: Context;
                resolvedCommands: ResolvedCommand[];
            },
        ) => MaybePromise<void>;
        afterStateChange: (
            payload: { changes: Partial<NextState>; state: State },
        ) => MaybePromise<void>;
        beforeCommand: (
            payload: {
                command: ResolvedCommand;
                data: unknown;
                params: unknown;
                setCommand: (command: ResolvedCommand) => void;
                setData: (data: unknown) => void;
                setParams: (params: RouteParams) => void;
                state: State;
            },
        ) => MaybePromise<void>;
        beforeEnd: (
            payload: {
                data: unknown;
                setData: (data: unknown) => void;
                state: State;
            },
        ) => MaybePromise<void>;
        beforeError: (
            payload: {
                context: Context;
                error: unknown;
                ignore: () => void;
                setError: (error: unknown) => void;
            },
        ) => MaybePromise<void>;
        beforeExecute: (
            payload: {
                initialData: unknown;
                setInitialData: (data: unknown) => void;
                setResultAndSkip: (result: unknown) => void;
                skip: () => void;
                state: State;
            },
        ) => MaybePromise<void>;
        beforeExit: (
            payload: {
                cancel: () => void;
                code: number;
                context: Context;
                message?: any;
                setCode: (code: number) => void;
                setMessage: (message: any) => void;
            },
        ) => MaybePromise<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;
            },
        ) => MaybePromise<void>;
        beforeResolve: (
            payload: {
                addResolvedCommands: (resolvedCommands: ResolvedCommand[]) => void;
                commandsDir: string;
                commandString: string;
                context: Context;
                setParseFn: (parseFn: ParseCommandFn) => void;
                setResolveFn: (resolveFn: ResolveCommandFn) => void;
                skip: () => void;
            },
        ) => MaybePromise<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;
            },
        ) => MaybePromise<void>;
        beforeStateChange: (
            payload: {
                changes: Partial<NextState>;
                setChanges: (changes: Partial<NextState>) => void;
                skip: () => void;
                state: State;
            },
        ) => MaybePromise<void>;
    }
    Index

    Properties

    afterCommand afterExecute afterParse afterResolve afterStateChange beforeCommand beforeEnd beforeError beforeExecute beforeExit beforeParse beforeResolve beforeResolveNext beforeStateChange

    Properties

    afterCommand: (
        payload: {
            command: ResolvedCommand;
            data: unknown;
            setData: (data: unknown) => void;
            state: State;
        },
    ) => MaybePromise<void>

    Called after each command's handler function.

    Hook order: 8

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

    Called after the command execution completes, just before the result is returned.

    Hook order: 12

    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;
        },
    ) => MaybePromise<void>

    Called after the final command string is parsed using the options configuration from plugins and resolved command modules.

    Hook order: 5

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

    Called after resolving and importing command modules.

    Hook order: 3

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

    Called after each state update during command execution.

    Hook order: 10

    beforeCommand: (
        payload: {
            command: ResolvedCommand;
            data: unknown;
            params: unknown;
            setCommand: (command: ResolvedCommand) => void;
            setData: (data: unknown) => void;
            setParams: (params: RouteParams) => void;
            state: State;
        },
    ) => MaybePromise<void>

    Called before each command's handler function.

    Hook order: 7

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

    Called before the () function is executed.

    Hook order: 11

    beforeError: (
        payload: {
            context: Context;
            error: unknown;
            ignore: () => void;
            setError: (error: unknown) => void;
        },
    ) => MaybePromise<void>

    Called whenever an error is thrown.

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

    Called before command execution begins.

    Hook order: 6

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

    Called whenever a plugin or command intends to exit the process via ().

    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;
        },
    ) => MaybePromise<void>

    Called before parsing the command string using the options config from plugins and resolved command modules.

    Hook order: 4

    The command string will be parsed multiple times during a command string's execution. After each command module is resolved and imported, the string will be re-parsed without validation to determine the next token in the command string that represents the next command or subcommand. The parse hooks will not be called during this phase.

    After all commands are resolved, the command string will be parsed again, this time with validation using the options config from all plugins and resolved commands. This is when the the beforeParse hook is called.

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

    Called before attempting to locate and import command modules.

    Hook order: 1

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

    Called before attempting to locate and import each subcommand module.

    Hook order: 2

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

    Called before each state update during command execution.

    Hook order: 9

    Settings

    Member Visibility

    On This Page

    Properties