Lazy loading firenvim

[hankertrix]

Hi, I'm having trouble lazy loading firenvim. I don't want firenvim to be loaded when I'm just using Neovim in the terminal, but I want it to be loaded when it is opened in the browser. So far, I have searched pretty much everywhere on GitHub and Reddit and I couldn't find any examples of lazy loading firenvim. Currently, when I set firenvim to lazy load, it wouldn't load in the browser and it will just refuse to start, saying Neovim is not responding, so I have it loaded when starting Neovim. Please help, thanks!

[mgnsk]

Firenvim sets a global variable g:started_by_firenvim. You should be able to use lazy.nvims enabled callback to enable firenvim when this variable is set.

EDIT: Link to the docs: https://github.com/glacambre/firenvim#building-a-firenvim-specific-config

[hankertrix]

Thank you! With your help, I managed to figure out that I can't use the lazy keyword in my configuration, otherwise firenvim will not start at all. I also used the cond option rather than enabled as lazy.nvim will uninstall plug-ins that aren't enabled (have enabled as false).

Here's the configuration that worked for me for everyone else that is facing the same issue:

{
    "glacambre/firenvim",
    build = function() vim.fn["firenvim#install"](0) end,
    cond = not not vim.g.started_by_firenvim
}

The not not is to convert the nil value to the boolean false because vim.g.started_by_firenvim will be nil instead of false if Neovim isn't started by firenvim.

I wrote this reply in firenvim!

[hankertrix]

Here's the configuration that worked for me for everyone else that is facing the same issue:

{
    "glacambre/firenvim",
    lazy = not vim.g.started_by_firenvim,
    module = false,
    build = function()
        vim.fn["firenvim#install"](0)
    end,
}

This means that lazy is true when firenvim is not active, which means lazy.nvim will not load firenvim when using Neovim in the terminal, unless you call the build function to build firenvim. Also, lazy will be false when firenvim is being used in the browser, which would get firenvim to load immediately when starting Neovim in the browser. module = false will cause firenvim to throw an error when it is loaded in a require call by another plug-in or in your configuration code.

Thanks to @abeldekat for providing the configuration.

This is currently the best way to lazy load firenvim as @folke has changed the cond keyword to be the same as the enabled keyword, except that it skips uninstalling the plugin. This means that lazy.nvim will not be able to load or install the plugin when cond is false as it is disabled.

This is the commit that changed the functionality of the cond keyword: fbb0bea

This reply was written in firenvim!

[jakubkaczor]

@hankertrix, why not not vim.g.started_by_firenvim with explanation, instead of simply vim.g.started_by_firenvim ~= nil?

[hankertrix]

When I first wrote that snippet, I didn’t know what the uninitialised value for vim.g.started_by_firenvim was. Through my experience with JavaScript, I thought it was much better to invert a value twice instead of checking equality with the many different kinds of uninitialised values, so that’s one reason I chose to invert the value twice despite it being not very readable.

Another reason is that vim.g.started_by_firenvim ~= nil isn’t all that readable either, especially when you are used to mathematical notation and deal with it pretty often. The expression cond = vim.g.started_by_firenvim ~= nil doesn’t really make much sense in mathematical notation, where cond would be equal to vim.g.started_by_firenvim, which itself isn’t equal to nil. So cond isn’t equal to nil and is equal to vim.g.started_by_firenvim. It looks like the mathematical expression x = y ≠ z, which takes a moment to snap out of and tune into programming mode to understand what it actually means instead. The double inversion is just much easier to understand straightaway since it’s obvious that it’ll just be the boolean value of vim.g.started_by_firenvim.

In the end, it doesn’t really matter to me as I don’t write it this way in my Neovim config. I have a function that returns the inversion of vim.g.started_by_firenvim and I simply place a not in front of that function, which is far more readable.

[jakubkaczor]

@hankertrix, thank you for the elaborate reply. I suspected that the reason might be handling also values such as 0, but after a quick check in the interpreter, it turned out that boolean results are the same using ~= in the cases of interest. It appears that values such as 0 are truthy in Lua, not as in JavaScript or Python, so I wondered further if there was any other reason.

I'm definitely used to mathematical notation and deal with it very often, but to me the expression mentioned doesn't seem confusing at all. Many times symbols used in programming are the same as the ones used in mathematical notation, but that's it. Perhaps, they are often somehow similar in the meaning, but not more. Identifying ~= with ≠ goes much further, because these are even not the same symbols.

[hankertrix]

You’re welcome. That is fascinating, I did not know that Lua treats 0 as truthy. Upon further research, I found that Lua treats everything as truthy except for nil and false, which is quite different from most other programming languages. Very interesting.

I see. To me, that is a personal thing. It is perfectly fine for me to see it as confusing while you see it otherwise. Our brains don’t work the same way after all, and that is perfectly fine. To address your last point, I use programming ligatures, so it does end up looking the same for me.

[musjj]

An annoying quirk to keep in mind is that you actually need to omit the cond line if you want to install the manifest file for the first time. This is because you can't load plugins that are disabled, so you won't be able to access the install function.

Also, as an alternative, you can use function() return vim.g.started_by_firenvim end which I think looks a bit more readable. This will still work even if the return value is nil.

[axieax]

You can make Lazy manually load firenvim so the install function works by doing the following:

{
  "glacambre/firenvim",
  lazy = false,
  build = function()
    require("lazy").load({ plugins = "firenvim", wait = true })
    vim.fn["firenvim#install"](0)
  end,
  cond = not not vim.g.started_by_firenvim,
}

[hankertrix]

Thank you! I’ll update my answer.

[cassepipe]

not not ?

[hankertrix]

It’s to convert the nil to a false. not not simply converts anything in Lua, or in any programming language really, to a Boolean, as Lua doesn’t have a function like bool() in Python.

[jrop]

For folks like me who aren't paying attention to what they're pasting in from websites, note that in order to configure firenvim, you have to put that in Lazy's init callback (I was trying to do so in the build callback, which wasn't working):

return {
  'glacambre/firenvim',
  cond = not not vim.g.started_by_firenvim,
  build = function()
    require("lazy").load({ plugins = "firenvim", wait = true })
    vim.fn["firenvim#install"](0)
  end,

  -- configure FireNvim here:
  config = function()
    vim.g.firenvim_config = {
      -- config values, like in my case:
      localSettings = {
        [".*"] = {
          takeover = "never",
        },
      },
    }
  end
}

In my case, this makes FireNvim much less of a hassle since on some sites I don't want it to takeover the textareas. For those (on Chrome), if I press CMD-E, FireNvim kicks in on command.

BTW, this comment was also written in FireNvim

[hankertrix]

You shouldn’t be placing your configuration under init. You should instead have your configuration under config, so you should change init to config.

The reason for this is that init runs on startup, which is when Lazy.nvim loads. Since most people will have Lazy.nvim load on startup, this means whatever code under init will load when you start Neovim. For Firenvim, this doesn’t really matter as the configuration for it doesn’t load any plugins and is just setting a global variable. But for other plugins that need to load themselves to configure, you’ll effectively be loading every single one of those plugins when you start Neovim, which is probably not what you want since you’re using Lazy.nvim.

config will run only when the plugin loads, which is probably what you want.

[jrop]

Good call-out: I swear I tried config and it didn't work, but that was probably at a time when my config was in flux and I was changing lots of things. I'll update the comment, since I just verified that, yes, config does work. Even with init, though, it is important to note that that block is just setting a global variable, so in this case, the difference is moot. However, for correctness sake, config is the right option to use.

[sweetbbak]

No matter what I do it just says "Vim:E117 Unknown function: firenvim#install"

[hankertrix]

I’m also facing this issue.

Could you try typing this into the Neovim command line:

:lua require("lazy").load({ plugins = "firenvim", wait = true })

Then check if firenvim is loaded by using the :Lazy command.

I think the lazy.nvim isn’t loading firenvim.

[sweetbbak]

I gave it a shot and it still says that its disabled at the bottom. It tries to run the install function but it fails every single time. I can go down to the bottom of the :Lazy window and hit "i" and it just fails and throws the error I mentioned.

[abeldekat]

Hello @hankertrix,

I installed firenvim after reading this discussion. A great plugin! Thank you for investigating the setup using lazy.nvim!

It is worth mentioning that on first install, the line containing the "cond" keyword should be a comment. Restart nvim in the terminal for the plugin to install and build. Activate the condition by uncommenting the respective line and the plugin is ready to use.

[hankertrix]

The lazy option, when set to true will cause the plug-in to be lazy loaded, which means it is only loaded when needed. It doesn’t stop the plug-in from loading when you’re using Neovim in the terminal. If the lazy option is set to false, the plug-in will never be lazy loaded and will be loaded every single time you start Neovim. In the case of firenvim, it should just be set to true. It doesn’t stop the plug-in from loading in the terminal however, so no, it doesn’t work.

The build function should have loaded firenvim when it is installed before calling the firenvim#install command. That build function used to work, but something changed in lazy.nvim and now it doesn’t work anymore.

[abeldekat]

@hankertrix,

Did you try? It is working perfectly on my setup, from the install, the build to the runtime activation.

If lazy is true, the plugin will only be loaded on certain conditions, which I do not provide. There are no triggers for it to load. I have a lot of colorschemes setup in that way.
In this setup, lazy will be true when not invoked from firenvim.

Please check this yourself with the config I provided.
Open neovim, type :Lazy, the plugin will be in the "not loaded" section.
Open the browser, and firenvim should work as expected. You can check this in a textbox, typing :Lazy. Firenvim will now be in the "loaded"" section, marked with "start" next to its name.

[abeldekat]

@hankertrix,

In addition to the above comment, allow me to summarize your requirements as I understand them:

1. Plain neovim: The plugin should not load, as there is no use for it. It should not be listed in the "active" section of lazy.nvim's ui.
2. Plain neovim: The plugin should update and build as usual
3. Browser, a textbox: Firenvim should kick in, the plugin should load at startup

If this representation is correct, I sincerely hope you try the config I provided.

[hankertrix]

I know it does work, but it is a bit of a bandaid solution since the cond variable is the method to provide such functionality, so I'm trying to get @folke to look into this problem (most likely a bug, since it used to work perfectly fine in the past). Also, the lazy variable doesn't stop the plugin from loading through other means, like through other plugins that require it or accidentally loading the plugin when doing package operations with lazy.nvim, which isn't really ideal. I would like it to never load in the terminal, except when it is building after an update.

Nonetheless, I will be using your solution until the load function is fixed and I have updated my answer with your solution.

[sweetbbak]

Yea its definitely a bug. The code snippet that @abeldekat provided works. Its better than nothing for now. I appreciate it.

[abeldekat]

Reply: It does work

I know it does work,

That surprises me... It would have been kind if you said so directly after I showed you my solution, when I asked in our discussion above:

...does this meet your requirements?...

I really wonder why you answered like you did. I would appreciate any feedback regarding my tone in the above conversation.

Recently, Folke accepted my pull request.
Thus, my knowledge of lazy.nvim's core plugin handling code is quite fresh.

Reply: bandaid solution

... but it is a bit of a bandaid solution since the cond variable is the method to provide such functionality,...

Respectfully, this is your opinion, not a fact.
The "cond" keyword does not differ much from the "enabled" keyword.

Using enabled = false, lazy.nvim will offer the option to remove the plugin, in addition to showing the plugin in the disabled section of lazy's UI.

Using cond = false, lazy.nvim does not offer to remove the plugin.
It does show the plugin in the disabled section of lazy's UI using a distinct color.

Lazy.nvim only installs, updates and builds plugins that are active, both loaded and not loaded. Disabled plugins, including cond = false, are removed from lazy.nvim's internal active plugin list.
Thus, on a fresh install, firenvim will never be installed via regular neovim when the current cond condition is in effect.

Reply: possible bug

...(most likely a bug, since it used to work perfectly fine in the past)...

My opinion: This is by design. It's up to Folke to decide.

EDIT: See this commit and its comments: cond is now the same as enabled, but skips clean, dated 2023.07.06

Reply: loading by other means

...Also, the lazy variable doesn't stop the plugin from loading through other means...

The only means causing lazy.nvim to load the plugin when in regular nvim are intentional:

1. The code written in your config, which you control. There are no plugins
   that depend on the presence of firenvim however. My example does not contain
   any triggers that will load the plugin. It's either loaded on startup, or not
   at all
2. The statement you mentioned as failing in earlier comments,
   which is loading as expected when using my example: :Lazy! load firenvim
3. EDIT As you wrote earlier: when building after an update.

Reply: updated my answer

... Nonetheless, I will be using your solution until the load function is fixed and I have updated my answer with your solution...

I read the updated answer and I think a lot of the information you supply is currently not correct. I hope I motivated that statement in this reply.
Why do you not mention my name in this section?

EDIT: I think the commit causing the confusion can be found here, dated 2023.07.06

In addition:

1. You can use the lazy keyword. This is the reason the example works.
2. The firenvim "browser" plugin requires the firenvim "nvim" plugin to function.
   As a consequence I think the plugin should be installed and build before firenvim connects.
   Open neovim in the terminal for the plugin to install.

My request

Please update your accepted answer mentioning the solution without the text that is up for debate.

Lazy.nvim example in firenvim's readme

As the example is accepted, the example on the site of firenvim needs to be updated.

[hankertrix]

Something that works doesn't necessarily meet my requirements, which also includes firenvim not being able to be loaded unless explicitly forced to load using the Lazy load command. Now that @folke has changed the functionality of the cond keyword, it seems like this will be the only way to get firenvim to load correctly, so I have updated the accepted answer.

My reply is based on what I remember of lazy.nvim's functionality, which is about 6 months out of date, so that was what was correct back then. In the past, the cond keyword stopped the plugin from loading under regular circumstances, like another plugin requiring firenvim or calling one of firenvim's functions. It would only load the plugin when explicitly loaded using Lazy! load or with the load function with wait = true in the opts table. The current solution using the lazy keyword just isn't as good as the previous one.

That is correct, and for now, there are no plugins that load firenvim, so this solution is sufficient, though not ideal.

[abeldekat]

I appreciate your reply!

Indeed, a working solution can still lack some desired functionality.
You explained the situation before the commit changing the behaviour of the cond keyword.

The new config will load firenvim on require("firenvim")
Fortunately, adding module = false solves that problem:

{
    "glacambre/firenvim",
    -- if firenvim -> vim.g.started_by_firenvim == true -> lazy must be false:
    lazy = not vim.g.started_by_firenvim,
    -- do not load the plugin on require:
    module = false,
    build = function()
      vim.fn["firenvim#install"](0)
    end,
  }

An error is thrown when require("firenvim") is issued.

You also mentioned the possibility of loading the pluging when calling firenvim's functions.
In an old issue Folke writes that this is not supported. I did a test with the vim-floaterm plugin mentioned in the issue.
When lazy = true, I cannot use floaterms's commands nor call its functions.

I think that the new config is on par with the old config(using the cond keyword) when adding module = false, and hope you agree.

As a sidenote, lazy.nvim's documentation needs to be updated. The description next to the cond keyword still mentions "firenvim". When you agree, I will write the pull request needed.

[hankertrix]

Oh wow, thanks! That must be a new option because this is my first time hearing of it. I will update my own configuration with that line.

I see, that's great!

Yeap, I agree.

Oh yeah, please do write the pull request, since the cond keyword isn't used to lazy load firenvim anymore. It might be the same for the VSCode Neovim plugin, which is a plugin to use Neovim in VSCode, but I have no idea about that since I don't use VSCode.

[abeldekat]

@sweetbbak

Yea its definitely a bug. The code snippet that @abeldekat provided works. Its better than nothing for now. I appreciate it.

Thanks!

[abeldekat]

The code snippet for packer is:

use {
    'glacambre/firenvim',
    run = function() vim.fn['firenvim#install'](0) end 
}

The code snippet for lazy can be improved by removing the require("lazy").load statement in the build step. That statement is not needed.

{
    "glacambre/firenvim",
    -- if firenvim -> vim.g.started_by_firenvim == true -> lazy must be false.
    lazy = not vim.g.started_by_firenvim,
    build = function()
      vim.fn["firenvim#install"](0)
    end,
  }

[hankertrix]

Thanks, I have updated the accepted answer.

[cohml]

Does lazy = not vim.g.started_by_firenvim have the effect of not loading a plugin when vimming in the browser? Like could that also be leveraged by other plugins I want firenvim to suppress?

Because currently I have some semi-complex machinery set up to load certain plugins if firenvim is active and load certain other plugins if it's not. However if passing lazy as you have shown works in that same way, that could dramatically simplify my config!

Edit: Or perhaps cond is the preferred parameter to use for this, a la @rodfersou's reply...?

[hankertrix]

@cohml you should use cond instead. lazy does not prevent the plugin from loading. If another module require the plugin, it will be loaded. If any of the lazy loading conditions trigger, the plugin will also be loaded.

cond is the way to completely disable the plugin, but not uninstall it.

You can take a look at an example from my configuration here.

[abeldekat]

Hello @hankertrix,

I submitted the PR that removes firenvim from the description of the cond property in the README.

Would you consider updating your selected answer to also include module = false?

[hankertrix]

That’s great, thanks.

Sure thing.

[rodfersou]

For me, this was the best way:

return {
  "glacambre/firenvim",
  lazy = not vim.g.started_by_firenvim,
  build = function()
    vim.fn["firenvim#install"](0)
  end,
  { "noice.nvim", cond = not vim.g.started_by_firenvim },
  { "lualine.nvim", cond = not vim.g.started_by_firenvim }, -- not useful in the browser
}

[hellovietduc]

I'm trying to make firenvim work with lazyvim too but I'm trying to whitelist the plugins I wanna use instead of disabling ones I don't want to use. Here's my attempt so far (following the VSCode extra) but it's not working:

if not vim.g.started_by_firenvim then
  -- need to keep an entry here otherwise lazy.nvim will uninstall it
  return {
    {
      "glacambre/firenvim",
      -- Lazy load firenvim
      -- Explanation: https://github.com/folke/lazy.nvim/discussions/463#discussioncomment-4819297
      lazy = true,
      module = false,
      build = function()
        vim.fn["firenvim#install"](0)
      end,
    },
  }
end

local enabled = {
  "flit.nvim",
  "lazy.nvim",
  "leap.nvim",
  "mini.ai",
  "mini.pairs",
  "mini.surround",
  "vim-repeat",
  "yanky.nvim",
  "glacambre/firenvim",
  "LazyVim",
}

local Config = require("lazy.core.config")
Config.options.checker.enabled = false
Config.options.change_detection.enabled = false
Config.options.defaults.cond = function(plugin)
  return vim.tbl_contains(enabled, plugin.name)
end

return {
  {
    "LazyVim/LazyVim",
    config = function(_, opts)
      opts = opts or {}
      -- disable the colorscheme
      -- opts.colorscheme = function() end
      require("lazyvim").setup(opts)
    end,
  },
  {
    "glacambre/firenvim",
    lazy = false,
    priority = 100,
    module = false,
    build = function()
      vim.fn["firenvim#install"](0)
    end,
  },
}

Appreciate any help!