How to interface with Stylix?

[bbaserdem]

Stylix is a nix module that enables systemwide colorscheme synching, and offers colortheme setting for neovim.

It does this by adding mini.base16 to local plugins in the home-manager configuration module.

I was wondering what would be the right way to interface with my own nixcats. In the packageDefinitions, configDirName would need to be set to nvim but after that I can't imagine how to properly interface them. Another issue is that I already have mini.nvim as a plugin.

I don't need to do this, but it could be nice to have the option to do so. There is a backend that also uses base16.nvim

Here is the module in question; https://github.com/danth/stylix/blob/master/modules/neovim/hm.nix

[BirdeeHub]

You can pass the list of colors from config.stylix straight through packageDefinitions and access them in lua via the nixCats plugin.

You can then provide those straight to mini.base16

The list stylix provides though does not have # at the start of the color number though so you will want to map that on in nix before passing it. (You could do it in Lua too but then that has runtime cost)

I can give a more complete answer in a couple hours or tomorrow with some code when I have a computer, but hopefully that can get you started?

I don't use stylix personally but I've walked someone through this on discord, when I have a computer at hand I can give more info.

[bbaserdem]

I think that would pretty much be the defacto way of doing things. Right now, stylix won't drop any neovim config files in .config/nvim if neovim home-manager module isn't enabled anyway. I definitely don't need steps, I definitely can do this.

[BirdeeHub]

Well, to help others and maybe get you started, the nix side looks something like this:

packageDefinitions = {
  yourpackage = { pkgs, ... }: {
    categories = { /* stuff */ };
    settings = { /* stuff */ };
    extra = {
      base16colors = pkgs.lib.filterAttrs (k: v:
        builtins.match "base0[0-9A-F]" k != null
      ) config.lib.stylix.colors.withHashtag;
    };
  };
};

And then you can just grab them as a lua table. You can pass it straight to mini.base16 or some other base16 color plugin

nixCats.extra("base16colors")

Now, obviously if your nixCats is a separate flake from your main repo you might not have access to this config variable in your flake.

However you can override in the extra values on import, either by using yourpackage.override OR installing the nvim via module exported from your flake containing your setup, and then adding them in via the packageDefinitions.merge module option.

If you had it defined as a separate flake, you would likely want to have a default colorscheme defined, and in lua check if the stylix colors are present or not to decide which to use.

[bbaserdem]

This is what I will do; (kinda wrapped up in troubleshooting other non-nixcats issues atm but will get to this).

My workflow is; in my packageDefinitions.extra; I have the attrset of strings;

packageDefinitions.extra.colorscheme = {
  name = "gruvbox";
  style = "dark";
  translucent = true;
};

Depending on the value of extra.colorscheme.name, theme packages get included or not. (Or if it's the maximal set, then all themes get included.) I'll be using this, where my nixcats instance will get package overrides from stylix.colors.

Currently trying to figure out figure out how to use the homeManager and nixos modules instead of package overrides; but once finalized I'll post my repo and workflow here.

[BirdeeHub]

base16colors = builtins.mapAttrs (k: v: "#" + v) (
  pkgs.lib.filterAttrs (k: v:
    builtins.match "base0[0-9A-F]" k != null
  ) config.lib.stylix.colors
);

This is possibly less verbose than way I grabbed these in the above example, figured I'd put it here too.

Edit: apparently there is also a

base16colors = pkgs.lib.filterAttrs (k: v:
  builtins.match "base0[0-9A-F]" k != null
) config.lib.stylix.colors.withHashtag;

I edited the above comment thats marked as answer with this second one.

[bbaserdem]

My full solution is the following, if anyone is looking through here to be inspired. I'm using separate flakes for my nixcats and system configuration. Both my nixOs and nixcats flakes are public in my repositories; here is my nixcats flake but it is still WIP.

I have, in my system flake, a module that I import in my home-manager. (I'm using overrides to do so; but I should switch to the homeManagerModules to do this instead when I figure it out) Also do note, that this pkgs instance is already applied the overlay provided by nixCats, so my packages are accessible through pkgs. You can skip the overlay, and pull the package straight from the flake outputs inputs.nixCats.packages.${pkgs.system}.<myNixCat>

# <systemFlake>/.../editor.nix
# Neovim config
{
  outputs,
  config,
  pkgs,
  ...
} @ args: let
  # Grab stylix override
  stylix16 = builtins.mapAttrs (k: v: "#" + v) (
    pkgs.lib.filterAttrs (k: v:
      builtins.match "base0[0-9A-F]" k != null
    ) config.lib.stylix.colors
  );
  # We will override the full nixCats with our flake info.
  myNixCats = pkgs.neovim-nixCats-full.override (prev: {
    packageDefinitions =
      prev.packageDefinitions
      // {
        myNixCats =
          pkgs.neovim-nixCats-full.utils.mergeCatDefs
          prev.packageDefinitions.neovim-nixCats-full
          ({pkgs, ...}: {
            # ...
            extra = {
              colorscheme = {
                name = "stylix";
                translucent = config.stylix.targets.neovim.transparentBackground.main;
                base16 = stylix16;
              };
              # ...
            };
          });
      };
    name = "myNixCats";
  });
in {
  home.packages = [ myNixCats ];
}

Basically, two important things. The extra.colorscheme.name should be "stylix" and extra.colorscheme.base16 should be an attrset of the base16 colors with the canonical naming structure.

Do note that using this, you don't need the stylix.targets.neovim.enable = true; set, it will do nothing without programs.neovim.enable = true; anyway so it's pointless to set it. It would append the vimPlugins.mini-base16 package in the programs.neovim.plugins list, and drop a config file named ~/.config/nvim/colors/stylix.lua. You could name the packageDefinitions.settings.configDirName to nvim to integrate with stylix.targets.neovim; but then you have to have a neovim instance in your namespace, and system plugins might end up contamination your nixcats instance. (I wish I could provide the nixCats as a package for programs.neovim.package, but the default homeManager module wants an unwrapped package. I decided it's not worth the hassle. trying to integrate the default homeManager module and nixCats; since they are meant to do the same thing anyway.)

Then in my nixCats flake, I separate my categoryDefinitions and packageDefinitions to different files to make them more readable;

# <nixCats>/flake.nix
{
  inputs = {
  # ...
  };

  outputs = {
    nixpkgs,
    nixCats,
    ...
  } @ inputs: let
    inherit (nixCats) utils;
    # ...
    inherit (nixCats) utils;
    categoryDefinitions = import ./categoryDefinitions.nix {inherit inputs;};
    packageDefinitions = import ./packageDefinitions.nix {inherit inputs nixpkgs utils;};
  in
    # ...

For my categoryDefinitions function; I have the following

# <nixCats>/categoryDefinitions.nix
{inputs, ...}: {
  pkgs,
  settings,
  categories,
  extra,
  name,
  mkNvimPlugin,
  ...
} @ packageDef: let
  # ...
in {
  # ...
  optionalPlugins = with pkgs.vimPlugins; {
    # ...
    main = [
      # ...
      (builtins.getAttr (extra.colorscheme.name or "rose-pine") {
        "catppuccin" = catppuccin-nvim;
        "cyberdream" = cyberdream-nvim;
        "minired" = mini-base16;
        "rose-pine" = {
          name = "rose-pine.nvim";
          plugin = rose-pine;
        };
        "stylix" = mini-base16;
        # ...
      })
    ];
    # ...
  };
}

And for my packageDefinitions, I have an entry neovim-nixCats-full defined;

# <nixCats>/packageDefinitions.nix
{
  inputs,
  nixpkgs,
  utils,
  ...
}: {
  neovim-nixCats-full = {pkgs, ...} @ misc: {
    # ...
  };
  # ...
}

I follow the same scheme as the example template, but I added a new handler for lze;

-- <nixCats>/lua/nixCatsUtils/lzUtils.lua
-- Check the nixCats.extra table for a matching key/value pair
-- This is to turn this value on if it's off
-- Expects a table with { key = "key.subkey", value = "this_val", }
M.in_extra = {
  spec_field = "in_extra",
  set_lazy = false,
  modify = function(plugin)
    if type(plugin.in_extra) == "table" then
      if
        (plugin.enabled == false)
        and (vim.g[ [[nixCats-special-rtp-entry-nixCats]] ] ~= nil)
        and (type(plugin.in_extra.key) == "string")
        -- and (type(plugin.in_extra.value) == "string")
      then
        -- Do oneshot
        if type(plugin.in_extra.value) == "string" then
          plugin.enabled = nixCats.extra(plugin.in_extra.key) == plugin.in_extra.value
        -- Loop if we are given a table
        elseif type(plugin.in_extra.value) == "table" then
          for _, val_string in ipairs(plugin.in_extra.value) do
            plugin.enabled = nixCats.extra(plugin.in_extra.key) == val_string
            if plugin.enabled then
              break
            end
          end
        end
      end
    end
    return plugin
  end,
}

Pretty much copy pasted from the example for_cat handler, but does matching to all elements if the given argument is a table. (This is necessary if I want to have more than one colortheme defined for a single plugin. It also does not have a default false behavior; because all my plugins are using another handler to set the enable state already. I just want to enable the plugin if it was not enabled in the first place.

I load the lze spec with a nested import call, the entry point I have for lze is;

-- <nixCats>/lua/pluginConf/init.lua
-- Register lze handler with the spec field 'for_cat' before any lazy loading
require("lze").register_handlers(require("nixCatsUtils.lzUtils").for_cat)
require("lze").register_handlers(require("nixCatsUtils.lzUtils").in_extra)

-- Load all plugins
require("lze").load({
  -- ...
  { import = "pluginConf.theme" },
  -- ...
})

(This isn't necessary to show, it's my personal workflow. But I'll include it for completeness sake.)

-- <nixCats>/lua/pluginConf/theme/init.lua
-- Register themeing related plugins to lazyload
return {
  -- ...
  { import = "pluginConf/theme/minitheme" },
  -- ...
}

And the lze spec for the colortheme is the following

-- <nixCats>/lua/pluginConf/theme/minitheme.lua
return {
  "mini.base16",
  in_extra = {
    key = "colorscheme.name",
    value = {
      "minired",
      "stylix",
    },
  },
  colorscheme = {
    "minired",
    "stylix",
  },
}

And finally, the colorscheme file in my flake
-- /colors/stylix.lua

-- Stylix integration with nixCats

-- Default to paraiso theme
local _theme = {
  base00 = "#2f1e2e", -- ----
  base01 = "#41323f", -- ---
  base02 = "#4f424c", -- --
  base03 = "#776e71", -- -
  base04 = "#8d8687", -- +
  base05 = "#a39e9b", -- ++
  base06 = "#b9b6b0", -- +++
  base07 = "#e7e9db", -- ++++
  base08 = "#ef6155", -- red
  base09 = "#f99b15", -- orange
  base0A = "#fec418", -- yellow
  base0B = "#48b685", -- green
  base0C = "#5bc4bf", -- aqua
  base0D = "#06b6ef", -- blue
  base0E = "#815ba4", -- purple
  base0F = "#e96ba8", -- brown
}
local _trans = false

-- The stylix base16 array should be provided in the extra.colorscheme.base16 array
if require("nixCatsUtils").isNixCats then
  if nixCats.extra("colorscheme.base16") ~= nil then
    _theme = nixCats.extra("colorscheme.base16")
  end
  if nixCats.extra("colorscheme.translucent") ~= nil then
    _trans = nixCats.extra("colorscheme.translucent")
  end
end

-- Load the colorscheme
require("mini.base16").setup({
  palette = _theme,
  plugins = {
    default = false,
    ["echanovski/mini.nvim"] = true,
    ["anuvyklack/hydra.nvim"] = true,
    ["folke/trouble.nvim"] = true,
    ["folke/which-key.nvim"] = true,
    ["hrsh7th/nvim-cmp"] = true,
    ["lewis6991/gitsigns.nvim"] = true,
    ["nvim-lualine/lualine.nvim"] = true,
    ["nvim-neo-tree/neo-tree.nvim"] = true,
    ["rcarriga/nvim-dap-ui"] = true,
    ["stevearc/aerial"] = true,
    ["williamboman/mason.nvim"] = true,
  },
})

I do already include mini.nvim collection in my main nixCats instance, but I do have other categories. (having a category with sudoeditor with no plugins other than mini.base16 for a specific colorscheme, in my case minired, I found to be very useful) I just make sure the main category is included in each package, and I can define whatever default color theme for that package just by changing the extra.colorscheme.name in a given package definition.

I try to keep things modular so it's easy to play around with. It doesn't have to be this verbose but I think it shows the

[BirdeeHub]

Your override is correct yeah (although below Ive changed it slightly so that it just modifies the package rather than making a new one)

# <systemFlake>/.../editor.nix
# Neovim config
{
  outputs,
  config,
  pkgs,
  ...
} @ args: let
  # Grab stylix override
  stylix16 = pkgs.lib.filterAttrs (k: v:
    builtins.match "base0[0-9A-F]" k != null
  ) config.lib.stylix.colors.withHashtag;
  # We will override the full nixCats with our flake info.
  myNixCats = pkgs.neovim-nixCats-full.override (prev: {
    packageDefinitions =
      prev.packageDefinitions
      // {
        neovim-nixCats-full = # <- you can replace the old def
          pkgs.neovim-nixCats-full.utils.mergeCatDefs
          prev.packageDefinitions.neovim-nixCats-full
          ({pkgs, ...}: {
            # ...
            extra = {
              colorscheme = {
                name = "stylix";
                translucent = config.stylix.targets.neovim.transparentBackground.main;
                base16 = stylix16;
              };
              # ...
            };
          });
      };
    # name = "neovim-nixCats-full"; # you can delete this line too because you arent changing it anymore
  });
in {
  home.packages = [ myNixCats ];
}

To do this with modules, you can just import the module exported by your flake instead of adding the package as an overlay

and then you can install it via this home manager module instead of the above one with the override

{ pkgs, config, lib, ... }: {
  # assuming you already added the module from your flake to your module imports list.
  # imports = [ pkgs.neovim-nixCats-full.homeModule ]; #<- also it does export one directly from passthru too
  config = {
    # default namespace for your options is defaultPackageName
    # can be changed where you call mkHomeModules or mkNixosModules in your flake via moduleNamespace = [ "mymods" "idk" ]
    # or if you imported yourpackage.homeModule it can be set in the package definitions settings set 
    neovim-nixCats-full = {
      # enable will allow you to set things, and by default also install defaultPackageName
      enable = true;
      # which packages to install, if you want ones other then the default one
      packageNames = [ "neovim-nixCats-full" ];
      # using replace will always replace the individual items in colorscheme, merge would merge them if they are lists.
      # replace is the default
      packageDefinitions.existing = "replace";
      # and .replace here chooses the strat for merging options across multiple files for this declaration
      packageDefinitions.replace = {
        # we wanted to edit this package with our new stylix stuff
        neovim-nixCats-full = {pkgs, ... }: { # <- pkgs from your flake, although the modules will also inherit your system overlays
          extra = {
            colorscheme = {
              name = "stylix";
              translucent = config.stylix.targets.neovim.transparentBackground.main;
              base16 = pkgs.lib.filterAttrs (k: v:
                builtins.match "base0[0-9A-F]" k != null
              ) config.lib.stylix.colors.withHashtag;
            };
          };
        };
      };
    };
  };
}

full list of options for home manager https://nixcats.org/nixCats_hm_options.html

The above 2 code examples do the same thing.

you can also export the module-created config from your system flake too, instructions for that here

https://nixcats.org/nixCats_modules.html

but yeah the modules exist because it turns that override with all the merging into

{ pkgs, config, ... }: {
  imports = [ pkgs.neovim-nixCats-full.homeModule ]; # <- exports module with defaultPackageName = name
  neovim-nixCats-full = { # <- moduleNamespace is [ defaultPackageName ] by default
    enable = true; # <- will install the default package, use packageNames option to change which ones you want
    packageDefinitions.replace = {
      neovim-nixCats-full = {pkgs, ... }: {
        extra = {
          colorscheme = {
            name = "stylix";
            translucent = config.stylix.targets.neovim.transparentBackground.main;
            base16 = pkgs.lib.filterAttrs (k: v:
              builtins.match "base0[0-9A-F]" k != null
            ) config.lib.stylix.colors.withHashtag;
          };
        };
      };
    };
  };
}

Which is quite nice but doesnt work in shells because no home manager in those so theres both. Both approaches achieve the same thing though.

Im not sure I documented passthru very well, I think I did cover it, but I cant find it right now. Its defined here internally though, and you can add more stuff to it. But your flake itself already exports all that stuff anyway.