clide-js
    Preparing search index...

    Interface ClideHooks

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

    interface ClideHooks {
        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: Params) => void;
                state: State;
            },
        ) => MaybePromise<void>;
        beforeEnd: (
            payload: {
                data: unknown;
                setData: (data: unknown) => void;
                state: State;
            },
        ) => 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>;
        error: (
            payload: {
                context: Context;
                error: unknown;
                ignore: () => void;
                setError: (error: unknown) => void;
            },
        ) => MaybePromise<void>;
    }
    Index

    Properties

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

    Properties

    afterCommand: (
        payload: {
            command: ResolvedCommand;
            data: unknown;
            setData: (data: unknown) => void;
            state: State;
        },
    ) => MaybePromise<void>
    1. Called after each command in the chain is executed.
    afterExecute: (
        payload: {
            result: unknown;
            setResult: (result: unknown) => void;
            state: State;
        },
    ) => MaybePromise<void>
    1. Called once per execution, after the final state update.
    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>
    1. Called after command arguments and options have been parsed.
    afterResolve: (
        payload: {
            addResolvedCommands: (resolvedCommands: ResolvedCommand[]) => void;
            context: Context;
            resolvedCommands: ResolvedCommand[];
        },
    ) => MaybePromise<void>
    1. Called after all commands in the chain have been resolved.
    afterStateChange: (
        payload: { changes: Partial<NextState>; state: State },
    ) => MaybePromise<void>
    1. Called after each state update during command execution.
    beforeCommand: (
        payload: {
            command: ResolvedCommand;
            data: unknown;
            params: unknown;
            setCommand: (command: ResolvedCommand) => void;
            setData: (data: unknown) => void;
            setParams: (params: Params) => void;
            state: State;
        },
    ) => MaybePromise<void>
    1. Called before each command in the chain is executed.

    This hook is triggered by both state.next() calls and the initial state.start() call, which internally uses state.next().

    beforeEnd: (
        payload: {
            data: unknown;
            setData: (data: unknown) => void;
            state: State;
        },
    ) => MaybePromise<void>
    1. Called once per execution, before the final state update, if state.end() is called.
    beforeExecute: (
        payload: {
            initialData: unknown;
            setInitialData: (data: unknown) => void;
            setResultAndSkip: (result: unknown) => void;
            skip: () => void;
            state: State;
        },
    ) => MaybePromise<void>
    1. Called before command execution begins.
    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 context.exit().

    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>
    1. Called before parsing command arguments and options.
    beforeResolve: (
        payload: {
            addResolvedCommands: (resolvedCommands: ResolvedCommand[]) => void;
            commandsDir: string;
            commandString: string;
            context: Context;
            setParseFn: (parseFn: ParseCommandFn) => void;
            setResolveFn: (resolveFn: ResolveCommandFn) => void;
            skip: () => void;
        },
    ) => MaybePromise<void>
    1. Initial preparation hook called before command resolution begins.
    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>
    1. Called before resolving each subcommand in the command chain
    beforeStateChange: (
        payload: {
            changes: Partial<NextState>;
            setChanges: (changes: Partial<NextState>) => void;
            skip: () => void;
            state: State;
        },
    ) => MaybePromise<void>
    1. Called before each state update during command execution.
    error: (
        payload: {
            context: Context;
            error: unknown;
            ignore: () => void;
            setError: (error: unknown) => void;
        },
    ) => MaybePromise<void>

    Called whenever an error is thrown.

    Settings

    Member Visibility

    On This Page

    Properties