legendary-api.txt

==============================================================================
*legendary*

M.setup()                                                      *legendary.setup*


M.repeat_previous({ignore_filters})                  *legendary.repeat_previous*
Repeat execution of the previously selected item. By default, only executes if the previously used filters
still return true.

Parameters: ~
{ignore_filters}  (boolean|nil)  whether to ignore the filters used when selecting the item, default false


M.find({opts})                                                  *legendary.find*
Find items using vim.ui.select()

Parameters: ~
{opts}  (LegendaryFindOpts)  @overload fun()


M.keymap({keymap})                                            *legendary.keymap*
Bind a *single keymap*

Parameters: ~
{keymap}  (table)


M.command({command})                                         *legendary.command*
Bind a *single command*

Parameters: ~
{command}  (table)


M.func({function})                                              *legendary.func*
Bind a *single function*

Parameters: ~
{function}  (table)


M.itemgroup({itemgroup})                                   *legendary.itemgroup*
Bind a *single item group*

Parameters: ~
{itemgroup}  (table)


M.autocmds({aus})                                           *legendary.autocmds*
@diagnostic enable: undefined-doc-param
Bind a *list of* autocmds and/or augroups

Parameters: ~
{aus}  (table)


M.autocmd({au})                                              *legendary.autocmd*
Bind a *single autocmd/augroup*

Parameters: ~
{au}  (table)


==============================================================================
*legendary.filters*

M.mode({mode})                                          *legendary.filters.mode*
Return a `LegendaryItemFilter` that filters items
by the specified mode

Parameters: ~
{mode}  (string)

Returns: ~
(LegendaryItemFilter)


M.AND({...})                                             *legendary.filters.AND*
Logical AND the given LegendaryItemFilters

Parameters: ~
{...}  (LegendaryItemFilter)

Returns: ~
(LegendaryItemFilter)


M.OR({...})                                               *legendary.filters.OR*
Logical OR the given LegendaryItemFilters

Parameters: ~
{...}  (LegendaryItemFilter)

Returns: ~
(LegendaryItemFilter)


M.current_mode()                                *legendary.filters.current_mode*
Return a `LegendaryItemFilter` that filters items
by the current mode

Returns: ~
(LegendaryItemFilter)


M.keymaps()                                          *legendary.filters.keymaps*
Filter to only show keymaps

Returns: ~
(LegendaryItemFilter)


M.commands()                                        *legendary.filters.commands*
Filter to only show commands

Returns: ~
(LegendaryItemFilter)


M.autocmds()                                        *legendary.filters.autocmds*
Filter to only show autocmds

Returns: ~
(LegendaryItemFilter)


M.funcs()                                              *legendary.filters.funcs*
Filter to only show functions

Returns: ~
(LegendaryItemFilter)


==============================================================================
*legendary.toolbox*

M.lazy({fn}, {...})                                     *legendary.toolbox.lazy*
Return a function with statically set arguments.

Parameters: ~
{fn}   (function)  The function to execute lazily
{...}  (any)       The arguments to pass to `fn` when called

Returns: ~
(function)


*legendary.toolbox.lazy_required_fn*
M.lazy_required_fn({module_name}, {fn_name}, {...})
Return a function which lazily `require`s a module and
calls a function from it. Functions nested within tables
may be accessed using dot-notation, i.e.
`lazy_required_fn('module_name', 'some.nested.fn', some_argument)`

Parameters: ~
{module_name}  (string)  The module to `require`
{fn_name}      (string)  The table path to the function
{...}          (any)     The arguments to pass to the function

Returns: ~
(function)


M.split_then({fn})                                *legendary.toolbox.split_then*
Return a function that creates a new horizontal
split, then calls the given function.

Parameters: ~
{fn}  (function)  The function to call after creating a split

Returns: ~
(function)


M.vsplit_then({fn})                              *legendary.toolbox.vsplit_then*
Return a function that creates a new vertical
split, then calls the given function.

Parameters: ~
{fn}  (function)  The function to call after creating a split

Returns: ~
(function)


M.is_keymap({keymap})                              *legendary.toolbox.is_keymap*
Check if an item is a Keymap

Parameters: ~
{keymap}  (LegendaryItem)

Returns: ~
(boolean)


M.is_command({cmd})                               *legendary.toolbox.is_command*
Check if an item is a Command

Parameters: ~
{cmd}  (LegendaryItem)

Returns: ~
(boolean)


M.is_augroup({au})                                *legendary.toolbox.is_augroup*
Check if an item is an Augroup

Parameters: ~
{au}  (LegendaryItem)

Returns: ~
(boolean)


M.is_autocmd({autocmd})                           *legendary.toolbox.is_autocmd*
Check if an item is an Autocmd

Parameters: ~
{autocmd}  (LegendaryItem)

Returns: ~
(boolean)


M.is_augroup_or_autocmd({au_or_autocmd})*legendary.toolbox.is_augroup_or_autocmd*
Check if an item is an Augroup or Autocmd

Parameters: ~
{au_or_autocmd}  (LegendaryItem)

Returns: ~
(boolean)


M.is_itemgroup()                                *legendary.toolbox.is_itemgroup*


M.is_function({func})                            *legendary.toolbox.is_function*
Check if an item is a Function

Parameters: ~
{func}  (LegendaryItem)

Returns: ~
(boolean)


M.is_visual_mode({mode_str})                  *legendary.toolbox.is_visual_mode*
Check if the given mode string indicates a visual mode or a sub-mode of visual mode.
Defaults to `vim.fn.mode()`

Parameters: ~
{mode_str}  (string|nil)

Returns: ~
(boolean)  @overload fun()


Marks                                                  *legendary.toolbox.Marks*


M.get_marks()                                      *legendary.toolbox.get_marks*
@field [1] integer
@field [2] integer
@field [3] integer
@field [4] integer
Get visual marks in format {start_line, start_col, end_line, end_col}

Returns: ~
(Marks)


M.set_marks({marks})                               *legendary.toolbox.set_marks*
Set visual marks from a table in the format
{start_line, start_col, end_line, end_col}

Parameters: ~
{marks}  (Marks)  the marks to set


*legendary.toolbox.table_from_vimscript*
M.table_from_vimscript({vimscript_str}, {description})
Parse a vimscript mapping command (e.g. `vnoremap <silent> <leader>f :SomeCommand<CR>`)
and return a `legendary.nvim` keymapping table that can be used in your configuration.

Parameters: ~
{vimscript_str}  (string)
{description}    (string)

Returns: ~
(table)


==============================================================================
*legendary.ui.format*

*legendary.ui.format.LegendaryItemFormatter*
LegendaryItemFormatter

Type: ~
fun(items:LegendaryItem[],mode:string):string[]


M.default_format({item})                    *legendary.ui.format.default_format*
Default format

Parameters: ~
{item}  (LegendaryItem)

Returns: ~
(string[])


*legendary.ui.format.compute_padding*
M.compute_padding({items}, {mode}, {formatter})
Format items

Parameters: ~
{items}      (LegendaryItem[])
{mode}       (string)
{formatter}  (LegendaryItemFormatter)


*legendary.ui.format.format_item*
M.format_item({item}, {formatter}, {padding}, {mode})
Format a single item, meant to be used in `vim.ui.select()`

Parameters: ~
{item}       (LegendaryItem)
{formatter}  (LegendaryItemFormatter)
{padding}    (integer[])
{mode}       (string)

Returns: ~
(string)


M.load_all()                                                        *M.load_all*
Load all extensions specified in legendary.nvim config


*M.load_extension*
M.load_extension({extension_name}, {config})
Load a single extension by name. If config is not provided,
it will be looked up in the legendary.nvim config.

Parameters: ~
{extension_name}  (string)
{config}          (any)


M.pre_ui_hook()                                                  *M.pre_ui_hook*


vim:tw=78:ts=8:noet:ft=help:norl: