Something went wrong. Try again.
Library of 45+ independent Lua modules improving Neovim experience with minimal effort nvim-mini.org/mini.nvim
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118--- *mini.animate* Animate common Neovim actions------ MIT License Copyright (c) 2022 Evgeni Chasnovski
--- Features:--- - Works out of the box with a single `require('mini.animate').setup()`.--- No extra mappings or commands needed.------ - Animate cursor movement inside same buffer by showing customizable path.--- See |MiniAnimate.config.cursor| for more details.------ - Animate scrolling with a series of subscrolls ("smooth scrolling").--- See |MiniAnimate.config.scroll| for more details.------ - Animate window resize by gradually changing sizes of all windows.--- See |MiniAnimate.config.resize| for more details.------ - Animate window open/close with visually updating floating window.--- See |MiniAnimate.config.open| and |MiniAnimate.config.close| for more details.------ - Timings for all actions can be customized independently.--- See |MiniAnimate-timing| for more details.------ - Action animations can be enabled/disabled independently.------ - All animations are asynchronous/non-blocking and trigger a targeted event--- which can be used to perform actions after animation is done.------ - |MiniAnimate.animate()| function which can be used to perform own animations.------ Notes:--- - Cursor movement is animated inside same window and buffer, not as cursor--- moves across the screen.------ - Scroll and resize animations are done with "side effects": they actually--- change the state of what is animated (window view and sizes--- respectively). This has a downside of possibly needing extra work to--- account for asynchronous nature of animation (like adjusting certain--- mappings, etc.). See |MiniAnimate.config.scroll| and--- |MiniAnimate.config.resize| for more details.------ # Setup ~------ This module needs a setup with `require('mini.animate').setup({})` (replace--- `{}` with your `config` table). It will create global Lua table `MiniAnimate`--- which you can use for scripting or manually (with `:lua MiniAnimate.*`).------ See |MiniAnimate.config| for available config settings.------ You can override runtime config settings (like `config.modifiers`) locally--- to buffer inside `vim.b.minianimate_config` which should have same structure--- as `MiniAnimate.config`. See |mini.nvim-buffer-local-config| for more details.------ # Comparisons ~------ - [Neovide](https://neovide.dev/):--- - Neovide is a standalone GUI which has more control over its animations.--- While |mini.animate| works inside terminal emulator (with all its--- limitations, like lack of pixel-size control over animations).--- - Neovide animates cursor movement across screen, while |mini.animate| ---- as it moves across same buffer.--- - Neovide has fixed number of animation effects per action, while--- |mini.animate| is fully customizable.--- - |mini.animate| implements animations for window open/close, while--- Neovide does not.--- - [edluffy/specs.nvim](https://github.com/edluffy/specs.nvim):--- - |mini.animate| approaches cursor movement visualization via--- customizable path function (uses extmarks), while `specs.nvim` can--- customize within its own visual effects (shading and floating--- window resizing).--- - [karb94/neoscroll.nvim](https://github.com/karb94/neoscroll.nvim):--- - Scroll animation is triggered only inside dedicated mappings.--- |mini.animate| animates scroll resulting from any window view change.--- - [anuvyklack/windows.nvim](https://github.com/anuvyklack/windows.nvim):--- - Resize animation is done only within custom commands and mappings,--- while |mini.animate| animates any resize with appropriate values of--- |'winheight'| / |'winwidth'| and |'winminheight'| / |'winminwidth'|).------ # Highlight groups ~--- *MiniAnimate-hl-groups*------ - `MiniAnimateCursor` - highlight of cursor during its animated movement.--- - `MiniAnimateNormalFloat` - highlight of floating window for `open` and--- `close` animations.------ To change any highlight group, set it directly with |nvim_set_hl()|.------ # Disabling ~------ To disable, set `vim.g.minianimate_disable` (globally) or--- `vim.b.minianimate_disable` (for a buffer) to `true`. Considering high--- number of different scenarios and customization intentions, writing exact--- rules for disabling module's functionality is left to user. See--- |mini.nvim-disabling-recipes| for common recipes.---@tag MiniAnimate
---@diagnostic disable:undefined-field
-- Module definition ==========================================================local MiniAnimate = {}local H = {}
--- Module setup------@param config table|nil Module config table. See |MiniAnimate.config|.------@usage >lua--- require('mini.animate').setup() -- use default config--- -- OR--- require('mini.animate').setup({}) -- replace {} with your config table--- <MiniAnimate.setup = function(config) -- Export module _G.MiniAnimate = MiniAnimate
-- Setup config config = H.setup_config(config)
-- Apply config H.apply_config(config)
-- Define behavior H.create_autocommands() H.track_scroll_state()
-- Create default highlighting H.create_default_hl()end
--- Defaults ~---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)---@text # General ~------ - *MiniAnimate-timing* Every animation is a non-blockingly scheduled series of--- specific actions. They are executed in a sequence of timed steps controlled--- by `timing` option. It is a callable which, given next and total step numbers,--- returns wait time (in ms).--- See |MiniAnimate.gen_timing| for builtin timing functions.--- See |MiniAnimate.animate()| for more details about animation process.------ - Every animation can be enabled/disabled independently by setting `enable`--- option to `true` / `false`.------ - *MiniAnimate-done-event* Every animation triggers custom |User| event when it--- is finished. It is named `MiniAnimateDoneXxx` with `Xxx` replaced by capitalized--- supported animation action name (like `MiniAnimateDoneCursor`). Use it to--- schedule some action after certain animation is completed. Alternatively,--- you can use |MiniAnimate.execute_after()| (usually preferred in mappings).------ - Each animation has its main step generator which defines how particular--- animation is done. They all are callables which take some input data and--- return an array of step data. Length of that array determines number of--- animation steps. Outputs `nil` and empty table result in no animation.------ # Cursor ~--- *MiniAnimate.config.cursor*------ This animation is triggered for each movement of cursor inside same window--- and buffer. Its visualization step consists from placing single extmark (see--- |extmarks|) at certain position. This extmark contains single space and is--- highlighted with `MiniAnimateCursor` highlight group.------ Exact places of extmark and their number is controlled by `path` option. It--- is a callable which takes `destination` argument (2d integer point in--- `(line, col)` coordinates) and returns array of relative to `(0, 0)` places--- for extmark to be placed. Example:--- - Input `(2, -3)` means cursor jumped 2 lines forward and 3 columns backward.--- - Output `{ {0, 0 }, { 0, -1 }, { 0, -2 }, { 0, -3 }, { 1, -3 } }` means--- that path is first visualized along the initial line and then along final--- column.------ See |MiniAnimate.gen_path| for builtin path generators.------ Notes:--- - Input `destination` value is computed ignoring folds. This is by design--- as it helps better visualize distance between two cursor positions.--- - Outputs of path generator resulting in a place where extmark can't be--- placed are silently omitted during animation: this step won't show any--- visualization.------ Configuration example: >lua------ local animate = require('mini.animate')--- animate.setup({--- cursor = {--- -- Animate for 200 milliseconds with linear easing--- timing = animate.gen_timing.linear({ duration = 200, unit = 'total' }),------ -- Animate with shortest line for any cursor move--- path = animate.gen_path.line({--- predicate = function() return true end,--- }),--- }--- })--- <--- After animation is done, `MiniAnimateDoneCursor` event is triggered.------ # Scroll ~--- *MiniAnimate.config.scroll*------ This animation is triggered for each vertical scroll of current window.--- Its visualization step consists from performing a small subscroll which all--- in total will result into needed total scroll.------ Exact subscroll values and their number is controlled by `subscroll` option.--- It is a callable which takes `total_scroll` argument (single non-negative--- integer) and returns array of non-negative integers each representing the--- amount of lines needed to be scrolled inside corresponding step. All--- subscroll values should sum to input `total_scroll`.--- Example:--- - Input `5` means that total scroll consists from 5 lines (either up or down,--- which doesn't matter).--- - Output of `{ 1, 1, 1, 1, 1 }` means that there are 5 equal subscrolls.------ See |MiniAnimate.gen_subscroll| for builtin subscroll generators.------ Notes:--- - Input value of `total_scroll` is computed taking folds into account.--- - As scroll animation is essentially a precisely scheduled non-blocking--- subscrolls, this has two important interconnected consequences:--- - If another scroll is attempted during the animation, it is done based--- on the CURRENTLY VISIBLE window view. Example: if user presses |CTRL-D|--- and then |CTRL-U| when animation is half done, window will not display--- the previous view half of |'scroll'| above it. This especially affects--- mouse wheel scrolling, as each its turn results in a new scroll for--- number of lines defined by |'mousescroll'|. Tweak it to your liking.--- - It breaks the use of several relative scrolling commands in the same--- command. Use |MiniAnimate.execute_after()| to schedule action after--- reaching target window view.--- Example: a useful `nnoremap n nzvzz` mapping (consecutive application--- of |n|, |zv|, and |zz|) should be expressed in the following way: >lua------ '<Cmd>lua vim.cmd("normal! n"); ' ..--- 'MiniAnimate.execute_after("scroll", "normal! zvzz")<CR>'--- <--- - Default timing might conflict with scrolling via holding a key (like `j` or `k`--- with |'wrap'| enabled) due to high key repeat rate: next scroll is done before--- first step of current one finishes. Resolve this by not scrolling like that--- or by ensuring maximum value of step duration to be lower than between--- repeated keys: set timing like `function(_, n) return math.min(250/n, 10) end`--- or use timing with constant step duration.------ Configuration example: >lua------ local animate = require('mini.animate')--- animate.setup({--- scroll = {--- -- Animate for 200 milliseconds with linear easing--- timing = animate.gen_timing.linear({ duration = 200, unit = 'total' }),------ -- Animate equally but with at most 120 steps instead of default 60--- subscroll = animate.gen_subscroll.equal({ max_output_steps = 120 }),--- }--- })--- <--- After animation is done, `MiniAnimateDoneScroll` event is triggered.------ # Resize ~--- *MiniAnimate.config.resize*------ This animation is triggered for window resize while having same layout of--- same windows. For example, it won't trigger when window is opened/closed or--- after something like |CTRL-W_K|. Its visualization step consists from setting--- certain sizes to all visible windows (last step being for "true" final sizes).------ Exact window step sizes and their number is controlled by `subresize` option.--- It is a callable which takes `sizes_from` and `sizes_to` arguments (both--- tables with window id as keys and dimension table as values) and returns--- array of same shaped data.--- Example:--- - Input: >lua------ -- First--- { [1000] = {width = 7, height = 5}, [1001] = {width = 7, height = 10} }--- -- Second--- { [1000] = {width = 9, height = 5}, [1001] = {width = 5, height = 10} }--- -- Means window 1000 increased its width by 2 in expense of window 1001--- <--- - The following output demonstrates equal resizing: >lua------ {--- { [1000] = {width = 8, height = 5}, [1001] = {width = 6, height = 10} },--- { [1000] = {width = 9, height = 5}, [1001] = {width = 5, height = 10} },--- }--- <--- See |MiniAnimate.gen_subresize| for builtin subresize generators.------ Notes:------ - As resize animation is essentially a precisely scheduled non-blocking--- subresizes, this has two important interconnected consequences:--- - If another resize is attempted during the animation, it is done based--- on the CURRENTLY VISIBLE window sizes. This might affect relative--- resizing.--- - It breaks the use of several relative resizing commands in the same--- command. Use |MiniAnimate.execute_after()| to schedule action after--- reaching target window sizes.------ Configuration example: >lua------ local is_many_wins = function(sizes_from, sizes_to)--- return vim.tbl_count(sizes_from) >= 3--- end--- local animate = require('mini.animate')--- animate.setup({--- resize = {--- -- Animate for 200 milliseconds with linear easing--- timing = animate.gen_timing.linear({ duration = 200, unit = 'total' }),------ -- Animate only if there are at least 3 windows--- subresize = animate.gen_subscroll.equal({ predicate = is_many_wins }),--- }--- })--- <--- After animation is done, `MiniAnimateDoneResize` event is triggered.------ # Window open/close ~--- *MiniAnimate.config.open*--- *MiniAnimate.config.close*------ These animations are similarly triggered for regular (non-floating) window--- open/close. Their visualization step consists from drawing empty floating--- window with customizable config and transparency.------ Exact window visualization characteristics are controlled by `winconfig`--- and `winblend` options.------ The `winconfig` option is a callable which takes window id (|window-ID|) as--- input and returns an array of floating window configs (as in `config`--- argument of |nvim_open_win()|). Its length determines number of animation steps.--- Example:--- - The following output results into two animation steps with second being--- upper left quarter of a first: >lua------ {--- {--- row = 0, col = 0,--- width = 10, height = 10,--- relative = 'editor', anchor = 'NW', focusable = false,--- zindex = 1, border = 'none', style = 'minimal',--- },--- {--- row = 0, col = 0,--- width = 5, height = 5,--- relative = 'editor', anchor = 'NW', focusable = false,--- zindex = 1, border = 'none', style = 'minimal',--- },--- }--- <--- The `winblend` option is similar to `timing` option: it is a callable--- which, given current and total step numbers, returns value of floating--- window's |'winblend'| option. Note, that it is called for current step (so--- starts from 0), as opposed to `timing` which is called before step.--- Example:--- - Function `function(s, n) return 80 + 20 * s / n end` results in linear--- transition from `winblend` value of 80 to 100.------ See |MiniAnimate.gen_winconfig| for builtin window config generators.--- See |MiniAnimate.gen_winblend| for builtin window transparency generators.------ Configuration example: >lua------ local animate = require('mini.animate')--- animate.setup({--- open = {--- -- Animate for 400 milliseconds with linear easing--- timing = animate.gen_timing.linear({ duration = 400, unit = 'total' }),------ -- Animate with wiping from nearest edge instead of default static one--- winconfig = animate.gen_winconfig.wipe({ direction = 'from_edge' }),------ -- Make bigger windows more transparent--- winblend = animate.gen_winblend.linear({ from = 80, to = 100 }),--- },------ close = {--- -- Animate for 400 milliseconds with linear easing--- timing = animate.gen_timing.linear({ duration = 400, unit = 'total' }),------ -- Animate with wiping to nearest edge instead of default static one--- winconfig = animate.gen_winconfig.wipe({ direction = 'to_edge' }),------ -- Make bigger windows more transparent--- winblend = animate.gen_winblend.linear({ from = 100, to = 80 }),--- },--- })--- <--- After animation is done, `MiniAnimateDoneOpen` or `MiniAnimateDoneClose`--- event is triggered for `open` and `close` animation respectively.MiniAnimate.config = { -- Cursor path cursor = { -- Whether to enable this animation enable = true,
-- Timing of animation (how steps will progress in time) --minidoc_replace_start timing = --<function: linear animation, total 250ms>, timing = function(_, n) return 250 / n end, --minidoc_replace_end
-- Path generator for visualized cursor movement --minidoc_replace_start path = --<function: implements shortest line path no longer than 1000>, path = function(destination) return H.path_line(destination, { predicate = H.default_path_predicate, max_output_steps = 1000 }) end, --minidoc_replace_end },
-- Vertical scroll scroll = { -- Whether to enable this animation enable = true,
-- Timing of animation (how steps will progress in time) --minidoc_replace_start timing = --<function: linear animation, total 250ms>, timing = function(_, n) return 250 / n end, --minidoc_replace_end
-- Subscroll generator based on total scroll --minidoc_replace_start subscroll = --<function: implements equal scroll with at most 60 steps>, subscroll = function(total_scroll) return H.subscroll_equal(total_scroll, { predicate = H.default_subscroll_predicate, max_output_steps = 60 }) end, --minidoc_replace_end },
-- Window resize resize = { -- Whether to enable this animation enable = true,
-- Timing of animation (how steps will progress in time) --minidoc_replace_start timing = --<function: linear animation, total 250ms>, timing = function(_, n) return 250 / n end, --minidoc_replace_end
-- Subresize generator for all steps of resize animations --minidoc_replace_start subresize = --<function: implements equal linear steps>, subresize = function(sizes_from, sizes_to) return H.subresize_equal(sizes_from, sizes_to, { predicate = H.default_subresize_predicate }) end, --minidoc_replace_end },
-- Window open open = { -- Whether to enable this animation enable = true,
-- Timing of animation (how steps will progress in time) --minidoc_replace_start timing = --<function: linear animation, total 250ms>, timing = function(_, n) return 250 / n end, --minidoc_replace_end
-- Floating window config generator visualizing specific window --minidoc_replace_start winconfig = --<function: implements static window for 25 steps>, winconfig = function(win_id) return H.winconfig_static(win_id, { predicate = H.default_winconfig_predicate, n_steps = 25 }) end, --minidoc_replace_end
-- 'winblend' (window transparency) generator for floating window --minidoc_replace_start winblend = --<function: implements equal linear steps from 80 to 100>, winblend = function(s, n) return 80 + 20 * (s / n) end, --minidoc_replace_end },
-- Window close close = { -- Whether to enable this animation enable = true,
-- Timing of animation (how steps will progress in time) --minidoc_replace_start timing = --<function: linear animation, total 250ms>, timing = function(_, n) return 250 / n end, --minidoc_replace_end
-- Floating window config generator visualizing specific window --minidoc_replace_start winconfig = --<function: implements static window for 25 steps>, winconfig = function(win_id) return H.winconfig_static(win_id, { predicate = H.default_winconfig_predicate, n_steps = 25 }) end, --minidoc_replace_end
-- 'winblend' (window transparency) generator for floating window --minidoc_replace_start winblend = --<function: implements equal linear steps from 80 to 100>, winblend = function(s, n) return 80 + 20 * (s / n) end, --minidoc_replace_end },}--minidoc_afterlines_end
-- Module functionality =======================================================--- Check animation activity------@param animation_type string One of supported animation types--- (entries of |MiniAnimate.config|, like `'cursor'`, etc.).------@return boolean Whether the animation is currently active.MiniAnimate.is_active = function(animation_type) local res = H.cache[animation_type .. '_is_active'] if res == nil then H.error('Wrong `animation_type` for `is_active()`.') end return resend
--- Execute action after some animation is done------ Execute action immediately if animation is not active (checked with--- |MiniAnimate.is_active()|). Else, schedule its execution until after--- animation is done (on corresponding "done event", see--- |MiniAnimate-done-event|).------ Mostly meant to be used inside mappings.------ Example:------ A useful `nnoremap n nzvzz` mapping (consecutive application of |n|, |zv|, and |zz|)--- should be expressed in the following way: >lua------ '<Cmd>lua vim.cmd("normal! n"); ' ..--- 'MiniAnimate.execute_after("scroll", "normal! zvzz")<CR>'--- <---@param animation_type string One of supported animation types--- (as in |MiniAnimate.is_active()|).---@param action string|function Action to be executed. If string, executed as--- command (via |vim.cmd()|).MiniAnimate.execute_after = function(animation_type, action) local event_name = H.animation_done_events[animation_type] if event_name == nil then H.error('Wrong `animation_type` for `execute_after`.') end
local callable = action if type(callable) == 'string' then callable = function() vim.cmd(action) end end if not vim.is_callable(callable) then H.error('Argument `action` of `execute_after()` should be string or callable.') end
-- Schedule conditional action execution to allow animation to actually take -- effect. This helps creating more universal mappings, because some commands -- (like `n`) not always result into scrolling. vim.schedule(function() if MiniAnimate.is_active(animation_type) then vim.api.nvim_create_autocmd('User', { pattern = event_name, once = true, callback = callable }) else callable() end end)end
-- Action (step 0) - wait (step 1) - action (step 1) - ...-- `step_action` should return `false` or `nil` (equivalent to not returning anything explicitly) in order to stop animation.--- Animate action------ This is equivalent to asynchronous execution of the following algorithm:--- - Call `step_action(0)` immediately after calling this function. Stop if--- action returned `false` or `nil`.--- - Wait `step_timing(1)` milliseconds.--- - Call `step_action(1)`. Stop if it returned `false` or `nil`.--- - Wait `step_timing(2)` milliseconds.--- - Call `step_action(2)`. Stop if it returned `false` or `nil`.--- - ...------ Notes:--- - Animation is also stopped on action error or if maximum number of steps--- is reached.--- - Asynchronous execution is done with |uv.new_timer()|. It only allows--- integer parts as repeat value. This has several implications:--- - Outputs of `step_timing()` are accumulated in order to preserve total--- execution time.--- - Any wait time less than 1 ms means that action will be executed--- immediately.------@param step_action function|table Callable which takes `step` (integer 0, 1, 2,--- etc. indicating current step) and executes some action. Its return value--- defines when animation should stop: values `false` and `nil` (equivalent--- to no explicit return) stop animation timer; any other continues it.---@param step_timing function|table Callable which takes `step` (integer 1, 2, etc.--- indicating next step) and returns how many milliseconds to wait before--- executing this step action.---@param opts table|nil Options. Possible fields:--- - <max_steps> - Maximum value of allowed step to execute. Default: 10000000.MiniAnimate.animate = function(step_action, step_timing, opts) opts = vim.tbl_deep_extend('force', { max_steps = 10000000 }, opts or {})
local step, max_steps = 0, opts.max_steps local timer, wait_time = vim.uv.new_timer(), 0
local draw_step draw_step = vim.schedule_wrap(function() local ok, should_continue = pcall(step_action, step) if not (ok and should_continue and step < max_steps) then timer:stop() return end
step = step + 1 wait_time = wait_time + step_timing(step)
-- Repeat value of `timer` seems to be rounded down to milliseconds. This -- means that values less than 1 will lead to timer stop repeating. Instead -- call next step function directly. if wait_time < 1 then timer:set_repeat(0) -- Use `return` to make this proper "tail call" return draw_step() else timer:set_repeat(wait_time) wait_time = wait_time - timer:get_repeat() timer:again() end end)
-- Start non-repeating timer without callback execution timer:start(10000000, 0, draw_step)
-- Draw step zero (at origin) immediately draw_step()end
--- Generate animation timing------ Each field corresponds to one family of progression which can be customized--- further by supplying appropriate arguments.------ This is a table with function elements. Call to actually get timing function.------ Example: >lua------ local animate = require('mini.animate')--- animate.setup({--- cursor = {--- timing = animate.gen_timing.linear({ duration = 100, unit = 'total' })--- },--- })--- <---@seealso |MiniIndentscope.gen_animation| for similar concept in |mini.indentscope|.MiniAnimate.gen_timing = {}
---@alias __animate_timing_opts table|nil Options that control progression. Possible keys:--- - <easing> `(string)` - a subtype of progression. One of "in"--- (accelerating from zero speed), "out" (decelerating to zero speed),--- "in-out" (default; accelerating halfway, decelerating after).--- - <duration> `(number)` - duration (in ms) of a unit. Default: 20.--- - <unit> `(string)` - which unit's duration `opts.duration` controls. One--- of "step" (default; ensures average duration of step to be `opts.duration`)--- or "total" (ensures fixed total duration regardless of scope's range).---@alias __animate_timing_return function Timing function (see |MiniAnimate-timing|).
--- Generate timing with no animation------ Show final result immediately. Usually better to use `enable` field in `config`--- if you want to disable animation.MiniAnimate.gen_timing.none = function() return function() return 0 endend
--- Generate timing with linear progression------@param opts __animate_timing_opts------@return __animate_timing_returnMiniAnimate.gen_timing.linear = function(opts) return H.timing_arithmetic(0, H.normalize_timing_opts(opts)) end
--- Generate timing with quadratic progression------@param opts __animate_timing_opts------@return __animate_timing_returnMiniAnimate.gen_timing.quadratic = function(opts) return H.timing_arithmetic(1, H.normalize_timing_opts(opts)) end
--- Generate timing with cubic progression------@param opts __animate_timing_opts------@return __animate_timing_returnMiniAnimate.gen_timing.cubic = function(opts) return H.timing_arithmetic(2, H.normalize_timing_opts(opts)) end
--- Generate timing with quartic progression------@param opts __animate_timing_opts------@return __animate_timing_returnMiniAnimate.gen_timing.quartic = function(opts) return H.timing_arithmetic(3, H.normalize_timing_opts(opts)) end
--- Generate timing with exponential progression------@param opts __animate_timing_opts------@return __animate_timing_returnMiniAnimate.gen_timing.exponential = function(opts) return H.timing_geometrical(H.normalize_timing_opts(opts)) end
--- Generate cursor animation path------ For more information see |MiniAnimate.config.cursor|.------ This is a table with function elements. Call to actually get generator.------ Example: >lua------ local animate = require('mini.animate')--- animate.setup({--- cursor = {--- -- Animate with line-column angle instead of shortest line--- path = animate.gen_path.angle(),--- }--- })--- <MiniAnimate.gen_path = {}
---@alias __animate_path_opts_common table|nil Options that control generator. Possible keys:--- - <predicate> `(function)` - a callable which takes `destination` as input and--- returns boolean value indicating whether animation should be done.--- Default: `false` if `destination` is within one line of origin (reduces--- flickering), `true` otherwise.---@alias __animate_path_return function Path function (see |MiniAnimate.config.cursor|).
--- Generate path as shortest line------@param opts __animate_path_opts_common--- - <max_output_steps> `(number)` - maximum number of steps in output.--- Default: 1000.------@return __animate_path_returnMiniAnimate.gen_path.line = function(opts) opts = vim.tbl_deep_extend('force', { predicate = H.default_path_predicate, max_output_steps = 1000 }, opts or {})
return function(destination) return H.path_line(destination, opts) endend
--- Generate path as line/column angle------@param opts __animate_path_opts_common--- - <max_output_steps> `(number)` - maximum number of steps per side in output.--- Default: 1000.--- - <first_direction> `(string)` - one of `"horizontal"` (default; animates--- across initial line first) or `"vertical"` (animates across initial--- column first).------@return __animate_path_returnMiniAnimate.gen_path.angle = function(opts) local default_opts = { predicate = H.default_path_predicate, max_output_steps = 1000, first_direction = 'horizontal' } opts = vim.tbl_deep_extend('force', default_opts, opts or {})
local append_horizontal = function(res, dest_col, const_line) if dest_col == 0 then return end local n_steps = math.min(math.abs(dest_col), opts.max_output_steps) local coef = dest_col / n_steps for i = 0, n_steps - 1 do table.insert(res, { const_line, H.round(coef * i) }) end end
local append_vertical = function(res, dest_line, const_col) if dest_line == 0 then return end local n_steps = math.min(math.abs(dest_line), opts.max_output_steps) local coef = dest_line / n_steps for i = 0, n_steps - 1 do table.insert(res, { H.round(coef * i), const_col }) end end
return function(destination) -- Don't animate in case of false predicate if not opts.predicate(destination) then return {} end
-- Travel along horizontal/vertical lines local res = {} if opts.first_direction == 'horizontal' then append_horizontal(res, destination[2], 0) append_vertical(res, destination[1], destination[2]) else append_vertical(res, destination[1], 0) append_horizontal(res, destination[2], destination[1]) end
return res endend
--- Generate path as closing walls at final position------@param opts __animate_path_opts_common--- - <width> `(number)` - initial width of left and right walls. Default: 10.------@return __animate_path_returnMiniAnimate.gen_path.walls = function(opts) opts = opts or {} local predicate = opts.predicate or H.default_path_predicate local width = opts.width or 10
return function(destination) -- Don't animate in case of false predicate if not predicate(destination) then return {} end
-- Don't animate in case of no movement if destination[1] == 0 and destination[2] == 0 then return {} end
local dest_line, dest_col = destination[1], destination[2] local res = {} for i = width, 1, -1 do table.insert(res, { dest_line, dest_col + i }) table.insert(res, { dest_line, dest_col - i }) end return res endend
--- Generate path as diminishing spiral at final position------@param opts __animate_path_opts_common--- - <width> `(number)` - initial width of spiral. Default: 2.------@return __animate_path_returnMiniAnimate.gen_path.spiral = function(opts) opts = opts or {} local predicate = opts.predicate or H.default_path_predicate local width = opts.width or 2
--stylua: ignore local add_layer = function(res, w, destination) local dest_line, dest_col = destination[1], destination[2] for j = -w, w-1 do table.insert(res, { dest_line - w, dest_col + j }) end for i = -w, w-1 do table.insert(res, { dest_line + i, dest_col + w }) end for j = -w, w-1 do table.insert(res, { dest_line + w, dest_col - j }) end for i = -w, w-1 do table.insert(res, { dest_line - i, dest_col - w }) end end
return function(destination) -- Don't animate in case of false predicate if not predicate(destination) then return {} end
-- Don't animate in case of no movement if destination[1] == 0 and destination[2] == 0 then return {} end
local res = {} for w = width, 1, -1 do add_layer(res, w, destination) end return res endend
--- Generate scroll animation subscroll------ For more information see |MiniAnimate.config.scroll|.------ This is a table with function elements. Call to actually get generator.------ Example: >lua------ local animate = require('mini.animate')--- animate.setup({--- scroll = {--- -- Animate equally but with 120 maximum steps instead of default 60--- subscroll = animate.gen_subscroll.equal({ max_output_steps = 120 }),--- }--- })--- <MiniAnimate.gen_subscroll = {}
--- Generate subscroll with equal steps------@param opts table|nil Options that control generator. Possible keys:--- - <predicate> `(function)` - a callable which takes `total_scroll` as--- input and returns boolean value indicating whether animation should be--- done. Default: `false` if `total_scroll` is 1 or less (reduces--- unnecessary waiting), `true` otherwise.--- - <max_output_steps> `(number)` - maximum number of subscroll steps in output.--- Adjust this to reduce computations in expense of reduced smoothness.--- Default: 60.------@return function Subscroll function (see |MiniAnimate.config.scroll|).MiniAnimate.gen_subscroll.equal = function(opts) opts = vim.tbl_deep_extend('force', { predicate = H.default_subscroll_predicate, max_output_steps = 60 }, opts or {})
return function(total_scroll) return H.subscroll_equal(total_scroll, opts) endend
--- Generate resize animation subresize------ For more information see |MiniAnimate.config.resize|.------ This is a table with function elements. Call to actually get generator.------ Example: >lua------ local is_many_wins = function(sizes_from, sizes_to)--- return vim.tbl_count(sizes_from) >= 3--- end--- local animate = require('mini.animate')--- animate.setup({--- resize = {--- -- Animate only if there are at least 3 windows--- subresize = animate.gen_subresize.equal({ predicate = is_many_wins }),--- }--- })--- <MiniAnimate.gen_subresize = {}
--- Generate subresize with equal steps------@param opts table|nil Options that control generator. Possible keys:--- - <predicate> `(function)` - a callable which takes `sizes_from` and--- `sizes_to` as input and returns boolean value indicating whether--- animation should be done. Default: always `true`.------@return function Subresize function (see |MiniAnimate.config.resize|).MiniAnimate.gen_subresize.equal = function(opts) opts = vim.tbl_deep_extend('force', { predicate = H.default_subresize_predicate }, opts or {})
return function(sizes_from, sizes_to) return H.subresize_equal(sizes_from, sizes_to, opts) endend
--- Generate open/close animation winconfig------ For more information see |MiniAnimate.config.open| or |MiniAnimate.config.close|.------ This is a table with function elements. Call to actually get generator.------ Example: >lua------ local is_not_single_window = function(win_id)--- local tabpage_id = vim.api.nvim_win_get_tabpage(win_id)--- return #vim.api.nvim_tabpage_list_wins(tabpage_id) > 1--- end--- local animate = require('mini.animate')--- animate.setup({--- open = {--- -- Animate with wiping from nearest edge instead of default static one--- -- and only if it is not a single window in tabpage--- winconfig = animate.gen_winconfig.wipe({--- predicate = is_not_single_window,--- direction = 'from_edge',--- }),--- },--- close = {--- -- Animate with wiping to nearest edge instead of default static one--- -- and only if it is not a single window in tabpage--- winconfig = animate.gen_winconfig.wipe({--- predicate = is_not_single_window,--- direction = 'to_edge',--- }),--- },--- })--- <MiniAnimate.gen_winconfig = {}
---@alias __animate_winconfig_opts_common table|nil Options that control generator. Possible keys:--- - <predicate> `(function)` - a callable which takes `win_id` as input and--- returns boolean value indicating whether animation should be done.--- Default: always `true`.---@alias __animate_winconfig_return function Winconfig function (see |MiniAnimate.config.open|--- or |MiniAnimate.config.close|).
--- Generate winconfig for static floating window------ This will result into floating window statically covering whole target--- window.------@param opts __animate_winconfig_opts_common--- - <n_steps> `(number)` - number of output steps, all with same config.--- Useful to tweak smoothness of transparency animation (done inside--- `winblend` config option). Default: 25.------@return __animate_winconfig_returnMiniAnimate.gen_winconfig.static = function(opts) opts = vim.tbl_deep_extend('force', { predicate = H.default_winconfig_predicate, n_steps = 25 }, opts or {})
return function(win_id) return H.winconfig_static(win_id, opts) endend
--- Generate winconfig for center-focused animated floating window------ This will result into floating window growing from or shrinking to the--- target window center.------@param opts __animate_winconfig_opts_common--- - <direction> `(string)` - one of `"to_center"` (default; window will--- shrink from full coverage to center) or `"from_center"` (window will--- grow from center to full coverage).------@return __animate_winconfig_returnMiniAnimate.gen_winconfig.center = function(opts) opts = opts or {} local predicate = opts.predicate or H.default_winconfig_predicate local direction = opts.direction or 'to_center'
return function(win_id) -- Don't animate in case of false predicate if not predicate(win_id) then return {} end
local pos = vim.fn.win_screenpos(win_id) local row, col = pos[1] - 1, pos[2] - 1 local height, width = vim.api.nvim_win_get_height(win_id), vim.api.nvim_win_get_width(win_id)
local n_steps = math.max(height, width) local res = {} -- Progression should be between fully covering target window and minimal -- dimensions in target window center. for i = 1, n_steps do local coef = (i - 1) / n_steps
-- Reverse output if progression is from center local res_ind = direction == 'to_center' and i or (n_steps - i + 1)
--stylua: ignore res[res_ind] = { relative = 'editor', anchor = 'NW', row = H.round(row + 0.5 * coef * height), col = H.round(col + 0.5 * coef * width), width = math.ceil((1 - coef) * width), height = math.ceil((1 - coef) * height), focusable = false, zindex = 1, border = 'none', style = 'minimal', } end
return res endend
--- Generate winconfig for wiping animated floating window------ This will result into floating window growing from or shrinking to the--- nearest edge. This also takes into account the split type of target window:--- vertically split window will progress towards vertical edge; horizontally ---- towards horizontal.------@param opts __animate_winconfig_opts_common--- - <direction> `(string)` - one of `"to_edge"` (default; window will--- shrink from full coverage to nearest edge) or `"from_edge"` (window--- will grow from edge to full coverage).------@return __animate_winconfig_returnMiniAnimate.gen_winconfig.wipe = function(opts) opts = opts or {} local predicate = opts.predicate or H.default_winconfig_predicate local direction = opts.direction or 'to_edge'
return function(win_id) -- Don't animate in case of false predicate if not predicate(win_id) then return {} end
-- Get window data local win_pos = vim.fn.win_screenpos(win_id) local top_row, left_col = win_pos[1], win_pos[2] local win_height, win_width = vim.api.nvim_win_get_height(win_id), vim.api.nvim_win_get_width(win_id)
-- Compute progression data local cur_row, cur_col = top_row, left_col local cur_width, cur_height = win_width, win_height
local increment_row, increment_col, increment_height, increment_width local n_steps
local win_container = H.get_window_parent_container(win_id) --stylua: ignore if win_container == 'col' then -- Determine closest top/bottom screen edge and progress to it local bottom_row = top_row + win_height - 1 local is_top_edge_closer = top_row < (vim.o.lines - bottom_row + 1)
increment_row, increment_col = (is_top_edge_closer and 0 or 1), 0 increment_width, increment_height = 0, -1 n_steps = win_height else -- Determine closest left/right screen edge and progress to it local right_col = left_col + win_width - 1 local is_left_edge_closer = left_col < (vim.o.columns - right_col + 1)
increment_row, increment_col = 0, (is_left_edge_closer and 0 or 1) increment_width, increment_height = -1, 0 n_steps = win_width end
-- Make step configs local res = {} for i = 1, n_steps do -- Reverse output if progression is from edge local res_ind = direction == 'to_edge' and i or (n_steps - i + 1) res[res_ind] = { relative = 'editor', anchor = 'NW', row = cur_row - 1, col = cur_col - 1, width = cur_width, height = cur_height, focusable = false, zindex = 1, border = 'none', style = 'minimal', } cur_row = cur_row + increment_row cur_col = cur_col + increment_col cur_height = cur_height + increment_height cur_width = cur_width + increment_width end return res endend
--- Generate open/close animation `winblend` progression------ For more information see |MiniAnimate.config.open| or |MiniAnimate.config.close|.------ This is a table with function elements. Call to actually get transparency--- function.------ Example: >lua------ local animate = require('mini.animate')--- animate.setup({--- open = {--- -- Change transparency from 60 to 80 instead of default 80 to 100--- winblend = animate.gen_winblend.linear({ from = 60, to = 80 }),--- },--- close = {--- -- Change transparency from 60 to 80 instead of default 80 to 100--- winblend = animate.gen_winblend.linear({ from = 60, to = 80 }),--- },--- })--- <MiniAnimate.gen_winblend = {}
--- Generate linear `winblend` progression------@param opts table|nil Options that control generator. Possible keys:--- - <from> `(number)` - initial value of |'winblend'|.--- - <to> `(number)` - final value of |'winblend'|.------@return function Winblend function (see |MiniAnimate.config.open|--- or |MiniAnimate.config.close|).MiniAnimate.gen_winblend.linear = function(opts) opts = opts or {} local from = opts.from or 80 local to = opts.to or 100 local diff = to - from
return function(s, n) return from + (s / n) * diff endend
-- Helper data ================================================================-- Module default configH.default_config = vim.deepcopy(MiniAnimate.config)
-- Cache for various operationsH.cache = { -- Cursor move animation data cursor_event_id = 0, cursor_is_active = false, cursor_state = { buf_id = nil, pos = {} },
-- Scroll animation data scroll_event_id = 0, scroll_is_active = false, scroll_state = { buf_id = nil, win_id = nil, view = {}, cursor = {} },
-- Resize animation data resize_event_id = 0, resize_is_active = false, resize_state = { layout = {}, sizes = {}, views = {} },
-- Window open animation data open_event_id = 0, open_is_active = false, open_active_windows = {},
-- Window close animation data close_event_id = 0, close_is_active = false, close_active_windows = {},}
-- Namespaces for module operationsH.ns_id = { -- Extmarks used to show cursor path cursor = vim.api.nvim_create_namespace('MiniAnimateCursor'),}
-- Identifier of empty buffer used inside open/close animationsH.empty_buf_id = nil
-- Names of `User` events triggered after certain type of animation is doneH.animation_done_events = { cursor = 'MiniAnimateDoneCursor', scroll = 'MiniAnimateDoneScroll', resize = 'MiniAnimateDoneResize', open = 'MiniAnimateDoneOpen', close = 'MiniAnimateDoneClose',}
-- Helper functionality =======================================================-- Settings -------------------------------------------------------------------H.setup_config = function(config) H.check_type('config', config, 'table', true) config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})
H.check_type('cursor', config.cursor, 'table') H.check_type('cursor.enable', config.cursor.enable, 'boolean') H.check_type('cursor.timing', config.cursor.timing, 'callable') H.check_type('cursor.path', config.cursor.path, 'callable')
H.check_type('scroll', config.scroll, 'table') H.check_type('scroll.enable', config.scroll.enable, 'boolean') H.check_type('scroll.timing', config.scroll.timing, 'callable') H.check_type('scroll.subscroll', config.scroll.subscroll, 'callable')
H.check_type('resize', config.resize, 'table') H.check_type('resize.enable', config.resize.enable, 'boolean') H.check_type('resize.timing', config.resize.timing, 'callable') H.check_type('resize.subresize', config.resize.subresize, 'callable')
H.check_type('open', config.open, 'table') H.check_type('open.enable', config.open.enable, 'boolean') H.check_type('open.timing', config.open.timing, 'callable') H.check_type('open.winconfig', config.open.winconfig, 'callable') H.check_type('open.winblend', config.open.winblend, 'callable')
H.check_type('close', config.close, 'table') H.check_type('close.enable', config.close.enable, 'boolean') H.check_type('close.timing', config.close.timing, 'callable') H.check_type('close.winconfig', config.close.winconfig, 'callable') H.check_type('close.winblend', config.close.winblend, 'callable')
return configend
H.apply_config = function(config) MiniAnimate.config = config end
H.create_autocommands = function() local gr = vim.api.nvim_create_augroup('MiniAnimate', {})
local au = function(event, pattern, callback, desc) vim.api.nvim_create_autocmd(event, { group = gr, pattern = pattern, callback = callback, desc = desc }) end
au('CursorMoved', '*', H.auto_cursor, 'Animate cursor')
au('WinScrolled', '*', function() -- On Neovim>=0.13 `WinScrolled` is also triggered when window scrolls -- during 'incsearch' and when cancelling. Ignore these state changes to -- not have extra scroll as a result of it. H.ignore_incsearch_scroll()
-- Inside `WinScrolled` first animate resize before scroll to avoid flicker H.auto_resize() H.auto_scroll() end, 'Animate resize and animate scroll') -- Track scroll state on buffer and window enter to animate its first scroll. -- Use `vim.schedule_wrap()` to allow other immediate commands to change view -- (like builtin cursor center on buffer change) to avoid unnecessary -- animated scroll. au({ 'BufEnter', 'WinEnter' }, '*', vim.schedule_wrap(H.track_scroll_state), 'Track scroll state') -- Track immediately scroll state after leaving terminal mode. Otherwise it -- will lead to scroll animation starting at latest non-Terminal mode view. au('TermLeave', '*', H.track_scroll_state, 'Track scroll state') -- Track scroll state (partially) on every cursor move to keep cursor -- position up to date. This enables visually better cursor positioning -- during scroll animation (convex progression from start cursor position to -- end). Use `vim.schedule()` to make it affect state only after scroll is -- done and cursor is already in correct final position. au('CursorMoved', '*', vim.schedule_wrap(H.track_scroll_state_partial), 'Track partial scroll state') au('CmdlineLeave', '*', function() H.ignore_incsearch_scroll() end, 'Ignore incsearch scroll')
-- Use `vim.schedule_wrap()` animation to get a window data used for -- displaying (and not one after just opening). Useful for 'nvim-tree'. au('WinNew', '*', vim.schedule_wrap(function() H.auto_openclose('open') end), 'Animate window open')
au('WinClosed', '*', function() H.auto_openclose('close') end, 'Animate window close')
au('ColorScheme', '*', H.create_default_hl, 'Ensure colors')end
H.create_default_hl = function() vim.api.nvim_set_hl(0, 'MiniAnimateCursor', { default = true, reverse = true, nocombine = true }) vim.api.nvim_set_hl(0, 'MiniAnimateNormalFloat', { default = true, link = 'NormalFloat' })end
H.is_disabled = function() return vim.g.minianimate_disable == true or vim.b.minianimate_disable == true end
H.get_config = function(config) return vim.tbl_deep_extend('force', MiniAnimate.config, vim.b.minianimate_config or {}, config or {})end
-- Autocommands ---------------------------------------------------------------H.auto_cursor = function() -- Don't animate if disabled local cursor_config = H.get_config().cursor if not cursor_config.enable or H.is_disabled() then -- Reset state to not use an outdated one if enabled again H.cache.cursor_state = { buf_id = nil, pos = {} } return end
-- Don't animate if inside scroll animation if H.cache.scroll_is_active then return end
-- Update necessary information. NOTE: update state only on `CursorMoved` and -- not inside every animation step (like in scroll animation) for performance -- reasons: cursor movement is much more common action than scrolling. local prev_state, new_state = H.cache.cursor_state, H.get_cursor_state() H.cache.cursor_state = new_state H.cache.cursor_event_id = H.cache.cursor_event_id + 1
-- Don't animate if changed buffer if new_state.buf_id ~= prev_state.buf_id then return end
-- Make animation step data and possibly animate local animate_step = H.make_cursor_step(prev_state, new_state, cursor_config) if not animate_step then return end
H.start_cursor() MiniAnimate.animate(animate_step.step_action, animate_step.step_timing)end
H.auto_resize = function() -- Don't animate if disabled local resize_config = H.get_config().resize if not resize_config.enable or H.is_disabled() then -- Reset state to not use an outdated one if enabled again H.cache.resize_state = { layout = {}, sizes = {}, views = {} } return end
-- Don't animate if inside scroll animation. This reduces computations and -- occasional flickering. if H.cache.scroll_is_active then return end
-- Update state. This also ensures that window views are up to date. local prev_state, new_state = H.cache.resize_state, H.get_resize_state() H.cache.resize_state = new_state
-- Don't animate if there is nothing to animate (should be same layout but -- different sizes). This also stops triggering animation on window scrolls. local same_state = H.is_equal_resize_state(prev_state, new_state) if not (same_state.layout and not same_state.sizes) then return end
-- Register new event only in case there is something to animate H.cache.resize_event_id = H.cache.resize_event_id + 1
-- Make animation step data and possibly animate local animate_step = H.make_resize_step(prev_state, new_state, resize_config) if not animate_step then return end
H.start_resize(prev_state) MiniAnimate.animate(animate_step.step_action, animate_step.step_timing)end
H.auto_scroll = function() -- Don't animate if disabled local scroll_config = H.get_config().scroll if not scroll_config.enable or H.is_disabled() then -- Reset state to not use an outdated one if enabled again H.cache.scroll_state = { buf_id = nil, win_id = nil, view = {}, cursor = {} } return end
-- Get states local prev_state, new_state = H.cache.scroll_state, H.get_scroll_state()
-- Don't animate if nothing to animate. Mostly used to distinguish -- `WinScrolled` resulting from module animation from the other ones. local is_same_bufwin = new_state.buf_id == prev_state.buf_id and new_state.win_id == prev_state.win_id local is_same_topline = new_state.view.topline == prev_state.view.topline if is_same_topline and is_same_bufwin then return end
-- Update necessary information H.cache.scroll_state = new_state H.cache.scroll_event_id = H.cache.scroll_event_id + 1
-- Don't animate if changed buffer or window if not is_same_bufwin then return end
-- Don't animate if inside resize animation. This reduces computations and -- occasional flickering. if H.cache.resize_is_active then return end
-- Make animation step data and possibly animate local animate_step = H.make_scroll_step(prev_state, new_state, scroll_config) if not animate_step then return end
H.start_scroll(prev_state) MiniAnimate.animate(animate_step.step_action, animate_step.step_timing)end
H.track_scroll_state = function() H.cache.scroll_state = H.get_scroll_state() end
H.track_scroll_state_partial = function() -- This not only improves computation load, but seems to be crucial for -- a proper state tracking if H.cache.scroll_is_active then return end
H.cache.scroll_state.cursor = { line = vim.fn.line('.'), virtcol = vim.fn.virtcol('.') }end
H.ignore_incsearch_scroll = function() local cmd_type = vim.fn.getcmdtype() local is_insearch = vim.o.incsearch and (cmd_type == '/' or cmd_type == '?') if not (is_insearch or H.cache.scroll_state.aborted_incsearch) then return end
-- Update scroll state so that there is no scroll animation after confirming -- incremental search. Otherwise it leads to unnecessary animation from -- initial scroll state to the one **already shown**. H.track_scroll_state() H.cache.scroll_state.aborted_incsearch = vim.v.event.abortend
H.auto_openclose = function(action_type) action_type = action_type or 'open'
-- Don't animate if disabled local config = H.get_config()[action_type] if not config.enable or H.is_disabled() then return end
-- Get window id to act upon local win_id if action_type == 'close' then win_id = tonumber(vim.fn.expand('<amatch>')) end if action_type == 'open' then win_id = math.max(unpack(vim.api.nvim_list_wins())) end
-- Don't animate if created window is not right (valid and not floating) if win_id == nil or not vim.api.nvim_win_is_valid(win_id) then return end if vim.api.nvim_win_get_config(win_id).relative ~= '' then return end
-- Register new event only in case there is something to animate local event_id_name = action_type .. '_event_id' H.cache[event_id_name] = H.cache[event_id_name] + 1
-- Make animation step data and possibly animate local animate_step = H.make_openclose_step(action_type, win_id, config) if not animate_step then return end
H.start_openclose(action_type) MiniAnimate.animate(animate_step.step_action, animate_step.step_timing)end
-- General animation ----------------------------------------------------------H.trigger_done_event = function(animation_type) vim.cmd('doautocmd User ' .. H.animation_done_events[animation_type]) end
-- Cursor ---------------------------------------------------------------------H.make_cursor_step = function(state_from, state_to, opts) local pos_from, pos_to = state_from.pos, state_to.pos local destination = { pos_to[1] - pos_from[1], pos_to[2] - pos_from[2] } local path = opts.path(destination) if path == nil or #path == 0 then return end
local n_steps = #path local timing = opts.timing
-- Using explicit buffer id allows correct animation stop after buffer switch local event_id, buf_id = H.cache.cursor_event_id, state_from.buf_id
return { step_action = function(step) -- Undraw previous mark. Doing it before early return allows to clear -- last animation mark. H.undraw_cursor_mark(buf_id)
-- Stop animation if another cursor movement is active. Don't use -- `stop_cursor()` because it will also stop parallel animation. if H.cache.cursor_event_id ~= event_id then return false end
-- Don't draw outside of set number of steps or not inside current buffer if n_steps <= step or vim.api.nvim_get_current_buf() ~= buf_id then return H.stop_cursor() end
-- Draw cursor mark (starting from initial zero step) local pos = path[step + 1] H.draw_cursor_mark(pos_from[1] + pos[1], pos_from[2] + pos[2], buf_id) return true end, step_timing = function(step) return timing(step, n_steps) end, }end
H.get_cursor_state = function() -- Use virtual column to respect position outside of line width and tabs return { buf_id = vim.api.nvim_get_current_buf(), pos = { vim.fn.line('.'), vim.fn.virtcol('.') } }end
H.draw_cursor_mark = function(line, virt_col, buf_id) -- Use only absolute coordinates. Allows to not draw outside of buffer. if line <= 0 or virt_col <= 0 then return end
-- Compute window column at which to place mark. Don't use explicit `col` -- argument because it won't allow placing mark outside of text line. local win_col = virt_col - vim.fn.winsaveview().leftcol if win_col < 1 then return end
-- Set extmark local extmark_opts = { id = 1, hl_mode = 'combine', priority = 1000, right_gravity = false, virt_text = { { ' ', 'MiniAnimateCursor' } }, virt_text_win_col = win_col - 1, virt_text_pos = 'overlay', } pcall(vim.api.nvim_buf_set_extmark, buf_id, H.ns_id.cursor, line - 1, 0, extmark_opts)end
H.undraw_cursor_mark = function(buf_id) pcall(vim.api.nvim_buf_del_extmark, buf_id, H.ns_id.cursor, 1) end
H.start_cursor = function() H.cache.cursor_is_active = true return trueend
H.stop_cursor = function() H.cache.cursor_is_active = false H.trigger_done_event('cursor') return falseend
-- Scroll ---------------------------------------------------------------------H.make_scroll_step = function(state_from, state_to, opts) -- Do not animate in Select mode because it resets it local is_select_mode = ({ s = true, S = true, ['\19'] = true })[vim.fn.mode()] if is_select_mode then return end
-- Compute how subscrolling is done local from_line, to_line = state_from.view.topline, state_to.view.topline local total_scroll = H.get_n_visible_lines(from_line, to_line) - 1 local step_scrolls = opts.subscroll(total_scroll)
-- Don't animate if no subscroll steps is returned if step_scrolls == nil or #step_scrolls == 0 then return end
-- Compute scrolling key ('\25' and '\5' are escaped '<C-Y>' and '<C-E>') local scroll_key = from_line < to_line and '\5' or '\25'
-- Cache frequently accessed data local from_cur_line, to_cur_line = state_from.cursor.line, state_to.cursor.line local from_cur_virtcol, to_cur_virtcol = state_from.cursor.virtcol, state_to.cursor.virtcol
local event_id, buf_id, win_id = H.cache.scroll_event_id, state_from.buf_id, state_from.win_id local n_steps, timing = #step_scrolls, opts.timing
return { step_action = function(step) -- Stop animation if another scroll is active. Don't use `stop_scroll()` -- because it will stop parallel animation. if H.cache.scroll_event_id ~= event_id then return false end
-- Stop animation if jumped to different buffer or window. Don't restore -- window view as it can only operate on current window. local is_same_win_buf = vim.api.nvim_get_current_buf() == buf_id and vim.api.nvim_get_current_win() == win_id if not is_same_win_buf then return H.stop_scroll() end
-- Compute intermediate cursor position. This relies on `virtualedit=all` -- to be able to place cursor anywhere on screen (has better animation; -- at least for default equally spread subscrolls). local coef = step / n_steps local cursor_line = H.convex_point(from_cur_line, to_cur_line, coef) local cursor_virtcol = H.convex_point(from_cur_virtcol, to_cur_virtcol, coef) local cursor_data = { line = cursor_line, virtcol = cursor_virtcol }
-- Perform scroll. Possibly stop on error. local ok, _ = pcall(H.scroll_action, scroll_key, step_scrolls[step], cursor_data) if not ok then return H.stop_scroll(state_to) end
-- Update current scroll state for two reasons: -- - Be able to distinguish manual `WinScrolled` event from one created -- by `H.scroll_action()`. -- - Be able to start manual scrolling at any animation step. H.cache.scroll_state = H.get_scroll_state()
-- Properly stop animation if step is too big if n_steps <= step then return H.stop_scroll(state_to) end
return true end, step_timing = function(step) return timing(step, n_steps) end, }end
H.scroll_action = function(key, n, cursor_data) -- Scroll. Allow supplying non-valid `n` for initial "scroll" which sets -- cursor immediately, which reduces flicker. if n ~= nil and n > 0 then local command = string.format('normal! %d%s', n, key) vim.cmd(command) end
-- Set cursor to properly handle cursor position -- Computation of available top/bottom line depends on `scrolloff = 0` -- because otherwise it will go out of bounds causing scroll overshoot with -- later "bounce" back on view restore (see -- https://github.com/nvim-mini/mini.nvim/issues/177). local top, bottom = vim.fn.line('w0'), vim.fn.line('w$') local line = math.min(math.max(cursor_data.line, top), bottom)
-- Cursor can only be set using byte column. To place it in the most correct -- virtual column, tweak output of `virtcol2col()` local virtcol = cursor_data.virtcol local col = vim.fn.virtcol2col(0, line, virtcol) -- - Correct for virtual column being outside of line's last virtual column local virtcol_past_lineend = vim.fn.virtcol({ line, '$' }) if virtcol_past_lineend <= virtcol then col = col + virtcol - virtcol_past_lineend + 1 end
pcall(vim.api.nvim_win_set_cursor, 0, { line, col - 1 })end
H.start_scroll = function(start_state) H.cache.scroll_is_active = true -- Disable scrolloff in order to be able to place cursor on top/bottom window -- line inside scroll step. -- Incorporating `vim.wo.scrolloff` in computation of available top and -- bottom window lines works, but only in absence of folds. It gets tricky -- otherwise, so disabling on scroll start and restore on scroll end is -- better solution. vim.wo.scrolloff = 0 -- Allow placing cursor anywhere on screen for better cursor placing vim.wo.virtualedit = 'all'
if start_state ~= nil then vim.fn.winrestview(start_state.view) -- Track state because `winrestview()` later triggers `WinScrolled`. -- Otherwise mapping like `u<Cmd>lua _G.n = 0<CR>` (as in 'mini.bracketed') -- can result into "inverted scroll": from destination to current state. H.track_scroll_state() end
return trueend
H.stop_scroll = function(end_state) if end_state ~= nil then vim.fn.winrestview(end_state.view) H.track_scroll_state() end
vim.wo.scrolloff = end_state.scrolloff vim.wo.virtualedit = end_state.virtualedit
H.cache.scroll_is_active = false H.trigger_done_event('scroll')
return falseend
H.get_scroll_state = function() return { buf_id = vim.api.nvim_get_current_buf(), win_id = vim.api.nvim_get_current_win(), view = vim.fn.winsaveview(), cursor = { line = vim.fn.line('.'), virtcol = vim.fn.virtcol('.') }, scrolloff = H.cache.scroll_is_active and H.cache.scroll_state.scrolloff or vim.wo.scrolloff, virtualedit = H.cache.scroll_is_active and H.cache.scroll_state.virtualedit or vim.wo.virtualedit, }end
-- Resize ---------------------------------------------------------------------H.make_resize_step = function(state_from, state_to, opts) -- Compute number of animation steps local step_sizes = opts.subresize(state_from.sizes, state_to.sizes) if step_sizes == nil or #step_sizes == 0 then return end local n_steps = #step_sizes
-- Create animation step local event_id, timing = H.cache.resize_event_id, opts.timing
return { step_action = function(step) -- Do nothing on initialization if step == 0 then return true end
-- Stop animation if another resize animation is active. Don't use -- `stop_resize()` because it will also stop parallel animation. if H.cache.resize_event_id ~= event_id then return false end
-- Perform animation. Possibly stop on error. -- Use `false` to not restore cursor position to avoid horizontal flicker local ok, _ = pcall(H.apply_resize_state, { sizes = step_sizes[step] }, false) if not ok then return H.stop_resize(state_to) end
-- Properly stop animation if step is too big if n_steps <= step then return H.stop_resize(state_to) end
return true end, step_timing = function(step) return timing(step, n_steps) end, }end
H.start_resize = function(start_state) H.cache.resize_is_active = true -- Don't restore cursor position to avoid horizontal flicker if start_state ~= nil then H.apply_resize_state(start_state, false) end return trueend
H.stop_resize = function(end_state) if end_state ~= nil then H.apply_resize_state(end_state, true) end H.cache.resize_is_active = false H.trigger_done_event('resize') return falseend
H.get_resize_state = function() local layout = vim.fn.winlayout()
local windows = H.get_layout_windows(layout) local sizes, views = {}, {} for _, win_id in ipairs(windows) do sizes[win_id] = { height = vim.api.nvim_win_get_height(win_id), width = vim.api.nvim_win_get_width(win_id) } views[win_id] = vim.api.nvim_win_call(win_id, function() return vim.fn.winsaveview() end) end
return { layout = layout, sizes = sizes, views = views }end
H.is_equal_resize_state = function(state_1, state_2) return { layout = vim.deep_equal(state_1.layout, state_2.layout), sizes = vim.deep_equal(state_1.sizes, state_2.sizes), }end
H.get_layout_windows = function(layout) local res = {} local traverse traverse = function(l) if l[1] == 'leaf' then table.insert(res, l[2]) return end for _, sub_l in ipairs(l[2]) do traverse(sub_l) end end traverse(layout)
return resend
H.apply_resize_state = function(state, full_view) for win_id, dims in pairs(state.sizes) do vim.api.nvim_win_set_height(win_id, dims.height) vim.api.nvim_win_set_width(win_id, dims.width) end
-- Use `or {}` to allow states without `view` (mainly inside animation) for win_id, view in pairs(state.views or {}) do vim.api.nvim_win_call(win_id, function() -- Allow to not restore full view. It mainly solves horizontal flickering -- when resizing from small to big width and cursor is on the end of long -- line. This is especially visible for high 'winwidth'. -- Example: `set winwidth=120 winheight=40` and hop between two -- vertically split windows with cursor on `$` of long line. if full_view then vim.fn.winrestview(view) return end
-- This triggers `CursorMoved` event, but nothing can be done -- (`noautocmd` is of no use, see https://github.com/vim/vim/issues/2084) pcall(vim.api.nvim_win_set_cursor, win_id, { view.lnum, view.leftcol }) vim.fn.winrestview({ topline = view.topline, leftcol = view.leftcol }) end) end
-- Update current resize state to be able to start another resize animation -- at any current animation step. Recompute state to also capture `view`. H.cache.resize_state = H.get_resize_state()end
-- Open/close -----------------------------------------------------------------H.make_openclose_step = function(action_type, win_id, config) -- Compute winconfig progression local step_winconfigs = config.winconfig(win_id) if step_winconfigs == nil or #step_winconfigs == 0 then return end
-- Produce animation steps. local n_steps, event_id_name = #step_winconfigs, action_type .. '_event_id' local timing, winblend, event_id = config.timing, config.winblend, H.cache[event_id_name] local float_win_id
return { step_action = function(step) -- Stop animation if another similar animation is active. Don't use -- `stop_openclose()` because it will also stop parallel animation. if H.cache[event_id_name] ~= event_id then pcall(vim.api.nvim_win_close, float_win_id, true) return false end
-- Stop animation if exceeded number of steps if n_steps <= step then pcall(vim.api.nvim_win_close, float_win_id, true) return H.stop_openclose(action_type) end
-- Empty buffer should always be valid (might have been closed by user command) if H.empty_buf_id == nil or not vim.api.nvim_buf_is_loaded(H.empty_buf_id) then pcall(vim.api.nvim_buf_delete, H.empty_buf_id, { force = true }) H.empty_buf_id = vim.api.nvim_create_buf(false, true) H.set_buf_name(H.empty_buf_id, 'open-close-scratch') end
-- Set step config to window. Possibly (re)open (it could have been -- manually closed like after `:only`) local float_config = step_winconfigs[step + 1] if step == 0 or not vim.api.nvim_win_is_valid(float_win_id) then float_win_id = vim.api.nvim_open_win(H.empty_buf_id, false, float_config) vim.wo[float_win_id].winhighlight = 'Normal:MiniAnimateNormalFloat' else vim.api.nvim_win_set_config(float_win_id, float_config) end
vim.wo[float_win_id].winblend = H.round(winblend(step, n_steps))
return true end, step_timing = function(step) return timing(step, n_steps) end, }end
H.start_openclose = function(action_type) H.cache[action_type .. '_is_active'] = true return trueend
H.stop_openclose = function(action_type) H.cache[action_type .. '_is_active'] = false H.trigger_done_event(action_type) return falseend
-- Animation timings ----------------------------------------------------------H.normalize_timing_opts = function(x) x = vim.tbl_deep_extend('force', H.get_config(), { easing = 'in-out', duration = 20, unit = 'step' }, x or {}) H.validate_if(H.is_valid_timing_opts, x, 'opts') return xend
H.is_valid_timing_opts = function(x) if type(x.duration) ~= 'number' or x.duration < 0 then return false, [[In `gen_timing` option `duration` should be a positive number.]] end
if not vim.tbl_contains({ 'in', 'out', 'in-out' }, x.easing) then return false, [[In `gen_timing` option `easing` should be one of 'in', 'out', or 'in-out'.]] end
if not vim.tbl_contains({ 'total', 'step' }, x.unit) then return false, [[In `gen_timing` option `unit` should be one of 'step' or 'total'.]] end
return trueend
--- Imitate common power easing function------ Every step is preceded by waiting time decreasing/increasing in power--- series fashion (`d` is "delta", ensures total duration time):--- - "in": d*n^p; d*(n-1)^p; ... ; d*2^p; d*1^p--- - "out": d*1^p; d*2^p; ... ; d*(n-1)^p; d*n^p--- - "in-out": "in" until 0.5*n, "out" afterwards------ This way it imitates `power + 1` common easing function because animation--- progression behaves as sum of `power` elements.------@param power number Power of series.---@param opts table Options from `MiniAnimate.gen_timing` entry.---@privateH.timing_arithmetic = function(power, opts) -- Sum of first `n_steps` natural numbers raised to `power` local arith_power_sum = ({ [0] = function(n_steps) return n_steps end, [1] = function(n_steps) return n_steps * (n_steps + 1) / 2 end, [2] = function(n_steps) return n_steps * (n_steps + 1) * (2 * n_steps + 1) / 6 end, [3] = function(n_steps) return n_steps ^ 2 * (n_steps + 1) ^ 2 / 4 end, })[power]
-- Function which computes common delta so that overall duration will have -- desired value (based on supplied `opts`) local duration_unit, duration_value = opts.unit, opts.duration local make_delta = function(n_steps, is_in_out) local total_time = duration_unit == 'total' and duration_value or (duration_value * n_steps) local total_parts if is_in_out then -- Examples: -- - n_steps=5: 3^d, 2^d, 1^d, 2^d, 3^d -- - n_steps=6: 3^d, 2^d, 1^d, 1^d, 2^d, 3^d total_parts = 2 * arith_power_sum(math.ceil(0.5 * n_steps)) - (n_steps % 2 == 1 and 1 or 0) else total_parts = arith_power_sum(n_steps) end return total_time / total_parts end
return ({ ['in'] = function(s, n) return make_delta(n) * (n - s + 1) ^ power end, ['out'] = function(s, n) return make_delta(n) * s ^ power end, ['in-out'] = function(s, n) local n_half = math.ceil(0.5 * n) local s_halved if n % 2 == 0 then s_halved = s <= n_half and (n_half - s + 1) or (s - n_half) else s_halved = s < n_half and (n_half - s + 1) or (s - n_half + 1) end return make_delta(n, true) * s_halved ^ power end, })[opts.easing]end
--- Imitate common exponential easing function------ Every step is preceded by waiting time decreasing/increasing in geometric--- progression fashion (`d` is 'delta', ensures total duration time):--- - 'in': (d-1)*d^(n-1); (d-1)*d^(n-2); ...; (d-1)*d^1; (d-1)*d^0--- - 'out': (d-1)*d^0; (d-1)*d^1; ...; (d-1)*d^(n-2); (d-1)*d^(n-1)--- - 'in-out': 'in' until 0.5*n, 'out' afterwards------@param opts table Options from `MiniAnimate.gen_timing` entry.---@privateH.timing_geometrical = function(opts) -- Function which computes common delta so that overall duration will have -- desired value (based on supplied `opts`) local duration_unit, duration_value = opts.unit, opts.duration local make_delta = function(n_steps, is_in_out) local total_time = duration_unit == 'step' and (duration_value * n_steps) or duration_value -- Exact solution to avoid possible (bad) approximation if n_steps == 1 then return total_time + 1 end if is_in_out then local n_half = math.ceil(0.5 * n_steps) if n_steps % 2 == 1 then total_time = total_time + math.pow(0.5 * total_time + 1, 1 / n_half) - 1 end return math.pow(0.5 * total_time + 1, 1 / n_half) end return math.pow(total_time + 1, 1 / n_steps) end
return ({ ['in'] = function(s, n) local delta = make_delta(n) return (delta - 1) * delta ^ (n - s) end, ['out'] = function(s, n) local delta = make_delta(n) return (delta - 1) * delta ^ (s - 1) end, ['in-out'] = function(s, n) local n_half, delta = math.ceil(0.5 * n), make_delta(n, true) local s_halved if n % 2 == 0 then s_halved = s <= n_half and (n_half - s) or (s - n_half - 1) else s_halved = s < n_half and (n_half - s) or (s - n_half) end return (delta - 1) * delta ^ s_halved end, })[opts.easing]end
-- Animation path -------------------------------------------------------------H.path_line = function(destination, opts) -- Don't animate in case of false predicate if not opts.predicate(destination) then return {} end
-- Travel along the biggest horizontal/vertical difference, but stop one -- step before destination local l, c = destination[1], destination[2] local l_abs, c_abs = math.abs(l), math.abs(c) local max_diff = math.min(math.max(l_abs, c_abs), opts.max_output_steps)
local res = {} for i = 0, max_diff - 1 do local prop = i / max_diff table.insert(res, { H.round(prop * l), H.round(prop * c) }) end return resend
H.default_path_predicate = function(destination) return destination[1] < -1 or 1 < destination[1] end
-- Animation subscroll --------------------------------------------------------H.subscroll_equal = function(total_scroll, opts) -- Don't animate in case of false predicate if not opts.predicate(total_scroll) then return {} end
-- Make equal steps, but no more than `max_output_steps` local n_steps = math.min(total_scroll, opts.max_output_steps) local res, coef = {}, total_scroll / n_steps for i = 1, n_steps do res[i] = math.floor(i * coef) - math.floor((i - 1) * coef) end return resend
H.default_subscroll_predicate = function(total_scroll) return total_scroll > 1 end
-- Animation subresize --------------------------------------------------------H.subresize_equal = function(sizes_from, sizes_to, opts) -- Don't animate in case of false predicate if not opts.predicate(sizes_from, sizes_to) then return {} end
-- Don't animate single window if #vim.tbl_keys(sizes_from) == 1 then return {} end
-- Compute number of steps local n_steps = 0 for win_id, dims_from in pairs(sizes_from) do local height_absidff = math.abs(sizes_to[win_id].height - dims_from.height) local width_absidff = math.abs(sizes_to[win_id].width - dims_from.width) n_steps = math.max(n_steps, height_absidff, width_absidff) end if n_steps <= 1 then return {} end
-- Make subresize array local res = {} for i = 1, n_steps do local coef = i / n_steps local sub_res = {} for win_id, dims_from in pairs(sizes_from) do sub_res[win_id] = { height = H.convex_point(dims_from.height, sizes_to[win_id].height, coef), width = H.convex_point(dims_from.width, sizes_to[win_id].width, coef), } end res[i] = sub_res end
return resend
H.default_subresize_predicate = function(sizes_from, sizes_to) return true end
-- Animation winconfig --------------------------------------------------------H.winconfig_static = function(win_id, opts) -- Don't animate in case of false predicate if not opts.predicate(win_id) then return {} end
local pos = vim.fn.win_screenpos(win_id) local width, height = vim.api.nvim_win_get_width(win_id), vim.api.nvim_win_get_height(win_id) local res = {} for i = 1, opts.n_steps do --stylua: ignore res[i] = { relative = 'editor', anchor = 'NW', row = pos[1] - 1, col = pos[2] - 1, width = width, height = height, focusable = false, zindex = 1, border = 'none', style = 'minimal', } end return resend
H.get_window_parent_container = function(win_id) local f f = function(layout, parent_container) local container, second = layout[1], layout[2] if container == 'leaf' then if second == win_id then return parent_container end return end
for _, sub_layout in ipairs(second) do local res = f(sub_layout, container) if res ~= nil then return res end end end
-- Important to get layout of tabpage window actually belongs to (as it can -- already be not current tabpage) -- NOTE: `winlayout()` takes tabpage number (non unique), not tabpage id local tabpage_id = vim.api.nvim_win_get_tabpage(win_id) local tabpage_nr = vim.api.nvim_tabpage_get_number(tabpage_id) return f(vim.fn.winlayout(tabpage_nr), 'single')end
H.default_winconfig_predicate = function(win_id) return true end
-- Utilities ------------------------------------------------------------------H.error = function(msg) error('(mini.animate) ' .. msg, 0) end
H.check_type = function(name, val, ref, allow_nil) if type(val) == ref or (ref == 'callable' and vim.is_callable(val)) or (allow_nil and val == nil) then return end H.error(string.format('`%s` should be %s, not %s', name, ref, type(val)))end
H.set_buf_name = function(buf_id, name) vim.api.nvim_buf_set_name(buf_id, 'minianimate://' .. buf_id .. '/' .. name) end
H.validate_if = function(predicate, x, x_name) local is_valid, msg = predicate(x, x_name) if not is_valid then H.error(msg) endend
H.get_n_visible_lines = function(from_line, to_line) local min_line, max_line = math.min(from_line, to_line), math.max(from_line, to_line)
-- If `max_line` is inside fold, scroll should stop on the fold (not after) local max_line_fold_start = vim.fn.foldclosed(max_line) local target_line = max_line_fold_start == -1 and max_line or max_line_fold_start
local i, res = min_line, 1 while i < target_line do res = res + 1 local end_fold_line = vim.fn.foldclosedend(i) i = (end_fold_line == -1 and i or end_fold_line) + 1 end return resend
H.round = function(x) return math.floor(x + 0.5) end
H.convex_point = function(x, y, coef) return H.round((1 - coef) * x + coef * y) end
return MiniAnimate