clide-js
    Preparing search index...

    Interface RunParams

    Params for the run function.

    interface RunParams {
        afterCommand?: (
            payload: {
                command: ResolvedCommand;
                data: unknown;
                setData: (data: unknown) => void;
                state: State;
            },
        ) => void;
        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;
        beforeCommand?: (
            payload: {
                command: ResolvedCommand;
                data: unknown;
                params: unknown;
                setCommand: (command: ResolvedCommand) => void;
                setData: (data: unknown) => void;
                setParams: (params: Params) => void;
                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;
        beforeExit?: (
            payload: {
                cancel: () => void;
                code: number;
                context: Context;
                message?: any;
                setCode: (code: number) => void;
                setMessage: (message: any) => void;
            },
        ) => 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;
        options?: OptionsConfig;
        plugins?: {
            description?: string;
            init: (context: Context) => MaybePromise<boolean>;
            meta?: AnyObject;
            name: string;
            version?: string;
        }[];
    }
    Index

    Properties

    afterCommand? afterExecute? afterParse? afterResolve? afterStateChange? beforeCommand? beforeEnd? beforeExecute? beforeExit? beforeParse? beforeResolve? beforeResolveNext? beforeStateChange? command? commandsDir? defaultCommand? initialData? onError? options? plugins?

    Properties

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

    A hook that runs after executing a command module.

    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.

    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.

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

    A hook that runs after importing command modules.

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

    A hook that runs 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;
        },
    ) => void

    A hook that runs before executing a command module.

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

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

    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.

    beforeExit?: (
        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.

    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.

    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.

    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.

    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.

    command?: string | string[]

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

    commandsDir?: string

    A directory path containing command modules.

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

    defaultCommand?: string | string[]

    The command string to run if no command is provided.

    initialData?: unknown

    Initial context or data to pass to commands during execution.

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

    A hook that runs whenever an error is thrown.

    options?: OptionsConfig

    Options to include in the context.

    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