nix-community/nixvim
1
0
Fork 0
mirror of https://github.com/nix-community/nixvim.git synced 2025-12-22 17:01:13 +01:00
Code Activity

Merge 941a9f7946 into d4b798a469

Browse source
This commit is contained in:
Heitor Augusto 2025-11-08 09:56:28 -03:00 • committed by GitHub
commit 302afacaac
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
68 changed files with 77 additions and 48 deletions
Download patch file Download diff file Expand all files Collapse all files

47
plugins/colorschemes/ayu.nix
View file

@ -1,47 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts toLuaObject;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "ayu";
isColorscheme = true;
package = "neovim-ayu";
# The colorscheme option is set by the `setup` function.
colorscheme = null;
callSetup = false;
maintainers = [ lib.maintainers.GaetanLepage ];
deprecateExtraOptions = true;
optionsRenamedToSettings = [
"mirage"
"overrides"
];
settingsOptions = {
mirage = defaultNullOpts.mkBool false ''
Set to `true` to use `mirage` variant instead of `dark` for dark background.
'';
overrides = defaultNullOpts.mkStrLuaOr (with lib.types; attrsOf highlight) { } ''
A dictionary of group names, each associated with a dictionary of parameters
(`bg`, `fg`, `sp` and `style`) and colors in hex.
Alternatively, `overrides` can be a function that returns a dictionary of the same
format.
You can use the function to override based on a dynamic condition, such as the value of
`background`.
'';
};
extraConfig = cfg: {
colorschemes.ayu.luaConfig.content = ''
local ayu = require("ayu")
ayu.setup(${toLuaObject cfg.settings})
ayu.colorscheme()
'';
};
}

73
plugins/colorschemes/bamboo.nix
View file

@ -1,73 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) toLuaObject;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "bamboo";
isColorscheme = true;
package = "bamboo-nvim";
maintainers = [ lib.maintainers.alisonjenkins ];
settingsExample = {
style = "vulgaris";
toggle_style_key = null;
toggle_style_list = [
"vulgaris"
"multiplex"
"light"
];
transparent = false;
dim_inactive = false;
term_colors = true;
ending_tildes = false;
cmp_itemkind_reverse = false;
code_style = {
comments = {
italic = true;
};
conditionals = {
italic = true;
};
keywords = { };
functions = { };
namespaces = {
italic = true;
};
parameters = {
italic = true;
};
strings = { };
variables = { };
};
lualine = {
transparent = false;
};
colors = { };
highlights = { };
diagnostics = {
darker = false;
undercurl = true;
background = true;
};
};
# The colorscheme option is set by the `setup` function.
colorscheme = null;
callSetup = false;
extraConfig = cfg: {
colorschemes.bamboo.luaConfig.content = ''
local bamboo = require("bamboo")
bamboo.setup(${toLuaObject cfg.settings})
bamboo.colorscheme()
'';
};
}

171
plugins/colorschemes/base16/default.nix
View file

@ -1,171 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts toLuaObject;
name = "base16";
moduleName = "base16-colorscheme";
in
lib.nixvim.plugins.mkNeovimPlugin {
inherit name moduleName;
setup = ".with_config";
package = "base16-nvim";
isColorscheme = true;
maintainers = with lib.maintainers; [
GaetanLepage
MattSturgeon
];
settingsExample = {
telescope_borders = true;
indentblankline = false;
dapui = false;
};
settingsOptions = {
telescope = defaultNullOpts.mkBool true ''
Whether to enable telescope integration.
'';
telescope_borders = defaultNullOpts.mkBool false ''
Whether to display borders around telescope's panel.
'';
indentblankline = defaultNullOpts.mkBool true ''
Whether to enable indentblankline integration.
'';
notify = defaultNullOpts.mkBool true ''
Whether to enable notify integration.
'';
ts_rainbow = defaultNullOpts.mkBool true ''
Whether to enable ts_rainbow integration.
'';
cmp = defaultNullOpts.mkBool true ''
Whether to enable cmp integration.
'';
illuminate = defaultNullOpts.mkBool true ''
Whether to enable illuminate integration.
'';
lsp_semantic = defaultNullOpts.mkBool true ''
Whether to enable lsp_semantic integration.
'';
mini_completion = defaultNullOpts.mkBool true ''
Whether to enable mini_completion integration.
'';
dapui = defaultNullOpts.mkBool true ''
Whether to enable dapui integration.
'';
};
extraOptions = {
colorscheme =
let
customColorschemeType = lib.types.submodule {
options = lib.mapAttrs (
name: example:
lib.mkOption {
type = with lib.types; maybeRaw str;
description = "The value for color `${name}`.";
inherit example;
}
) customColorschemeExample;
};
customColorschemeExample = {
base00 = "#16161D";
base01 = "#2c313c";
base02 = "#3e4451";
base03 = "#6c7891";
base04 = "#565c64";
base05 = "#abb2bf";
base06 = "#9a9bb3";
base07 = "#c5c8e6";
base08 = "#e06c75";
base09 = "#d19a66";
base0A = "#e5c07b";
base0B = "#98c379";
base0C = "#56b6c2";
base0D = "#0184bc";
base0E = "#c678dd";
base0F = "#a06949";
};
builtinColorschemeExamples = import ./theme-list.nix;
in
defaultNullOpts.mkNullable' {
type =
with lib.types;
oneOf [
str
customColorschemeType
rawLua
];
pluginDefault = lib.literalMD ''`vim.env.BASE16_THEME` or `"schemer-dark"`'';
description = ''
The base16 colorscheme to use.
You may use the name of a builtin colorscheme or an attrs that specifies the colors explicitly.
Examples of builtin themes include:
${lib.concatStrings (
map (e: ''
- "${e}"
'') builtinColorschemeExamples
)}
`:h nvim-base16-builtin-colorschemes` includes a full list of builtin themes,
however the [plugin's source code] may be more up to date.
You can access `require('${moduleName}')` as `base16` in any raw lua,
for example, you could reuse some colors from the builtin colorschemes:
```nix
base03.__raw = "base16.colorschemes['catppuccin'].base06";
```
[plugin's source code]: https://github.com/RRethy/base16-nvim/blob/master/lua/colors/init.lua
'';
example = customColorschemeExample;
};
setUpBar = lib.mkOption {
type = lib.types.bool;
default = true;
example = false;
description = "Whether to set your status bar theme to 'base16'.";
};
};
# We will manually set the colorscheme, using `setup`
colorscheme = null;
callSetup = false;
extraConfig = cfg: {
plugins.airline.settings.theme = lib.mkIf cfg.setUpBar (lib.mkDefault name);
plugins.lualine.settings.options.theme = lib.mkIf cfg.setUpBar (lib.mkDefault name);
plugins.lightline.settings.colorscheme = lib.mkDefault null;
opts.termguicolors = lib.mkDefault true;
# `settings` can either be passed to `with_config` before calling `setup`,
# or it can be passed as `setup`'s 2nd argument.
# See https://github.com/RRethy/base16-nvim/blob/6ac181b5733518040a33017dde654059cd771b7c/lua/base16-colorscheme.lua#L107-L125
colorschemes.base16.luaConfig.content = ''
do
local base16 = require('${moduleName}')
base16.with_config(${toLuaObject cfg.settings})
base16.setup(${toLuaObject cfg.colorscheme})
end
'';
};
}

43
plugins/colorschemes/base16/theme-list.nix
View file

@ -1,43 +0,0 @@
# Example base16 builtin themes to include in the docs
[
"catppuccin"
"catppuccin-frappe"
"catppuccin-latte"
"catppuccin-macchiato"
"catppuccin-mocha"
"darcula"
"dracula"
"espresso"
"github"
"google-dark"
"google-light"
"gruvbox-dark-hard"
"gruvbox-dark-medium"
"gruvbox-dark-pale"
"gruvbox-dark-soft"
"gruvbox-light-hard"
"gruvbox-light-medium"
"gruvbox-light-soft"
"material"
"material-darker"
"material-lighter"
"material-palenight"
"material-vivid"
"nord"
"nova"
"ocean"
"onedark"
"rose-pine"
"rose-pine-dawn"
"rose-pine-moon"
"solarized-dark"
"solarized-light"
"tango"
"tokyo-night-dark"
"tokyo-night-light"
"tokyo-night-storm"
"tokyo-night-terminal-dark"
"tokyo-night-terminal-light"
"tokyo-night-terminal-storm"
"woodland"
]

224
plugins/colorschemes/catppuccin.nix
View file

@ -1,224 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim)
defaultNullOpts
mkNullOrOption
mkNullOrStrLuaFnOr
literalLua
;
inherit (lib) types;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "catppuccin";
isColorscheme = true;
package = "catppuccin-nvim";
maintainers = [ lib.maintainers.GaetanLepage ];
settingsOptions =
let
flavours = [
"latte"
"mocha"
"frappe"
"macchiato"
];
in
{
compile_path = defaultNullOpts.mkStr (literalLua "vim.fn.stdpath 'cache' .. '/catppuccin'") "Set the compile cache directory.";
flavour = mkNullOrOption (types.enum (flavours ++ [ "auto" ])) ''
Theme flavour.
'';
background =
let
mkBackgroundStyle =
name:
defaultNullOpts.mkEnumFirstDefault flavours ''
Background for `${name}` background.
'';
in
{
light = mkBackgroundStyle "light";
dark = mkBackgroundStyle "dark";
};
transparent_background = defaultNullOpts.mkBool false ''
Enable Transparent background.
'';
show_end_of_buffer = defaultNullOpts.mkBool false ''
Show the '~' characters after the end of buffers.
'';
term_colors = defaultNullOpts.mkBool false ''
Configure the colors used when opening a :terminal in Neovim.
'';
dim_inactive = {
enabled = defaultNullOpts.mkBool false ''
If true, dims the background color of inactive window or buffer or split.
'';
shade = defaultNullOpts.mkStr "dark" ''
Sets the shade to apply to the inactive split or window or buffer.
'';
percentage = defaultNullOpts.mkProportion 0.15 ''
percentage of the shade to apply to the inactive window, split or buffer.
'';
};
no_italic = defaultNullOpts.mkBool false ''
Force no italic.
'';
no_bold = defaultNullOpts.mkBool false ''
Force no bold.
'';
no_underline = defaultNullOpts.mkBool false ''
Force no underline.
'';
styles = {
comments = defaultNullOpts.mkListOf types.str [ "italic" ] ''
Define comments highlight properties.
'';
conditionals = defaultNullOpts.mkListOf types.str [ "italic" ] ''
Define conditionals highlight properties.
'';
loops = defaultNullOpts.mkListOf types.str [ ] ''
Define loops highlight properties.
'';
functions = defaultNullOpts.mkListOf types.str [ ] ''
Define functions highlight properties.
'';
keywords = defaultNullOpts.mkListOf types.str [ ] ''
Define keywords highlight properties.
'';
strings = defaultNullOpts.mkListOf types.str [ ] ''
Define strings highlight properties.
'';
variables = defaultNullOpts.mkListOf types.str [ ] ''
Define variables highlight properties.
'';
numbers = defaultNullOpts.mkListOf types.str [ ] ''
Define numbers highlight properties.
'';
booleans = defaultNullOpts.mkListOf types.str [ ] ''
Define booleans highlight properties.
'';
properties = defaultNullOpts.mkListOf types.str [ ] ''
Define properties highlight properties.
'';
types = defaultNullOpts.mkListOf types.str [ ] ''
Define types highlight properties.
'';
operators = defaultNullOpts.mkListOf types.str [ ] ''
Define operators highlight properties.
'';
};
color_overrides = lib.genAttrs (flavours ++ [ "all" ]) (
flavour:
defaultNullOpts.mkAttrsOf types.str { } (
if flavour == "all" then
"Override colors for all the flavours."
else
"Override colors for the ${flavour} flavour."
)
);
custom_highlights = mkNullOrStrLuaFnOr (with types; attrsOf anything) ''
Override specific highlight groups to use other groups or a hex color.
You can provide either a lua function or directly an attrs.
Example:
```lua
function(colors)
return {
Comment = { fg = colors.flamingo },
["@constant.builtin"] = { fg = colors.peach, style = {} },
["@comment"] = { fg = colors.surface2, style = { "italic" } },
}
end
```
Default: `{}`
'';
default_integrations = defaultNullOpts.mkBool true ''
Some integrations are enabled by default, you can control this behaviour with this option.
'';
integrations = mkNullOrOption (with types; attrsOf anything) ''
Catppuccin provides theme support for other plugins in the Neovim ecosystem and extended
Neovim functionality through _integrations_.
To enable/disable an integration you just need to set it to `true`/`false`.
Example:
```nix
{
cmp = true;
gitsigns = true;
nvimtree = true;
treesitter = true;
notify = false;
mini = {
enabled = true;
indentscope_color = "";
};
}
```
Default: see plugin source.
'';
};
settingsExample = {
flavour = "mocha";
disable_underline = true;
term_colors = true;
color_overrides.mocha.base = "#1e1e2f";
styles = {
booleans = [
"bold"
"italic"
];
conditionals = [ "bold" ];
};
integrations = {
cmp = true;
gitsigns = true;
nvimtree = true;
treesitter = true;
notify = false;
mini = {
enabled = true;
indentscope_color = "";
};
};
};
extraConfig = {
opts.termguicolors = lib.mkDefault true;
};
}

86
plugins/colorschemes/cyberdream.nix
View file

@ -1,86 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "cyberdream";
isColorscheme = true;
package = "cyberdream-nvim";
maintainers = [ lib.maintainers.AndresBermeoMarinelli ];
settingsOptions = {
transparent = defaultNullOpts.mkBool false ''
Enable transparent background.
'';
italic_comments = defaultNullOpts.mkBool false ''
Enable italics comments.
'';
hide_fillchars = defaultNullOpts.mkBool false ''
Replace all fillchars with ' ' for the ultimate clean look.
'';
borderless_telescope = defaultNullOpts.mkBool true ''
Modern borderless telescope theme.
'';
terminal_colors = defaultNullOpts.mkBool true ''
Set terminal colors used in `:terminal`.
'';
theme = {
highlights = defaultNullOpts.mkAttrsOf lib.types.highlight { } ''
Highlight groups to override, adding new groups is also possible.
See `:h highlight-groups` for a list of highlight groups.
Example:
```nix
{
Comment = {
fg = "#696969";
bg = "NONE";
italic = true;
};
}
```
Complete list can be found in `lua/cyberdream/theme.lua` in upstream repository.
'';
colors = defaultNullOpts.mkAttrsOf lib.types.str { } ''
Override the default colors used.
For a full list of colors, see upstream documentation.
'';
};
};
settingsExample = {
transparent = true;
italic_comments = true;
hide_fillchars = true;
borderless_telescope = true;
terminal_colors = true;
theme = {
highlights = {
Comment = {
fg = "#696969";
bg = "NONE";
italic = true;
};
};
colors = {
bg = "#000000";
green = "#00ff00";
magenta = "#ff00ff";
};
};
};
}

14
plugins/colorschemes/dracula-nvim.nix
View file

@ -1,14 +0,0 @@
{ lib, ... }:
lib.nixvim.plugins.mkNeovimPlugin {
name = "dracula-nvim";
moduleName = "dracula";
colorscheme = "dracula";
isColorscheme = true;
maintainers = [ lib.maintainers.refaelsh ];
settingsExample = {
italic_comment = true;
colors.green = "#00FF00";
};
}

75
plugins/colorschemes/dracula.nix
View file

@ -1,75 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts;
in
lib.nixvim.plugins.mkVimPlugin {
name = "dracula";
package = "dracula-vim";
isColorscheme = true;
globalPrefix = "dracula_";
maintainers = [ lib.maintainers.GaetanLepage ];
optionsRenamedToSettings = [
"bold"
"italic"
"underline"
"undercurl"
"fullSpecialAttrsSupport"
"highContrastDiff"
"inverse"
"colorterm"
];
settingsOptions = {
bold = defaultNullOpts.mkBool true ''
Include bold attributes in highlighting.
'';
italic = defaultNullOpts.mkBool true ''
Include italic attributes in highlighting.
'';
strikethrough = defaultNullOpts.mkBool true ''
Include strikethrough attributes in highlighting.
'';
underline = defaultNullOpts.mkBool true ''
Include underline attributes in highlighting.
'';
undercurl = defaultNullOpts.mkBool true ''
Include undercurl attributes in highlighting (only if `underline` is enabled).
'';
full_special_attrs_support = defaultNullOpts.mkBool false ''
Explicitly declare full support for special attributes.
On terminal emulators, set to `true` to allow `underline`/`undercurl` highlights without
changing the foreground color.
'';
high_contrast_diff = defaultNullOpts.mkBool false ''
Use high-contrast color when in diff mode.
'';
inverse = defaultNullOpts.mkBool true ''
Include inverse attributes in highlighting.
'';
colorterm = defaultNullOpts.mkBool true ''
Include background fill colors.
'';
};
settingsExample = {
italic = false;
colorterm = false;
};
extraConfig = {
opts.termguicolors = lib.mkDefault true;
};
}

257
plugins/colorschemes/everforest.nix
View file

@ -1,257 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts;
in
lib.nixvim.plugins.mkVimPlugin {
name = "everforest";
isColorscheme = true;
globalPrefix = "everforest_";
maintainers = [ lib.maintainers.sheemap ];
settingsOptions = {
background =
defaultNullOpts.mkEnum
[
"hard"
"medium"
"soft"
]
"medium"
''
The background contrast used in this color scheme.
'';
enable_italic = defaultNullOpts.mkFlagInt 0 ''
To enable italic in this color scheme, set this option to `1`.
'';
disable_italic_comment = defaultNullOpts.mkFlagInt 0 ''
By default, italic is enabled in `Comment`. To disable italic in `Comment`, set this option to `1`
'';
cursor =
defaultNullOpts.mkEnumFirstDefault
[
"auto"
"red"
"orange"
"yellow"
"green"
"aqua"
"blue"
"purple"
]
''
Customize the cursor color, only works in GUI clients.
'';
transparent_background =
defaultNullOpts.mkEnumFirstDefault
[
0
1
2
]
''
To use transparent background, set this option to `1`.
If you want more ui components to be transparent (for example, status line
background), set this option to `2`.
'';
dim_inactive_windows = defaultNullOpts.mkFlagInt 0 ''
Dim inactive windows. Only works in Neovim currently.
When this option is used in conjunction with |g:everforest_show_eob| set to 0,
the end of the buffer will only be hidden inside the active window. Inside
inactive windows, the end of buffer filler characters will be visible in
dimmed symbols. This is due to the way Vim and Neovim handle |hl-EndOfBuffer|.
'';
sign_column_background =
defaultNullOpts.mkEnumFirstDefault
[
"none"
"grey"
]
''
By default, the color of sign column background is the same as normal text
background, but you can use a grey background by setting this option to `'grey'`.
'';
spell_foreground =
defaultNullOpts.mkEnumFirstDefault
[
"none"
"colored"
]
''
By default, this color scheme won't color the foreground of |spell|, instead
colored under curls will be used. If you also want to color the foreground,
set this option to `'colored'`.
'';
ui_contrast =
defaultNullOpts.mkEnumFirstDefault
[
"low"
"high"
]
''
The contrast of line numbers, indent lines, etc.
'';
show_eob = defaultNullOpts.mkFlagInt 1 ''
Whether to show |hl-EndOfBuffer|.
'';
float_style =
defaultNullOpts.mkEnumFirstDefault
[
"bright"
"dim"
]
''
Style used to make floating windows stand out from other windows. `'bright'`
makes the background of these windows lighter than |hl-Normal|, whereas
`'dim'` makes it darker.
Floating windows include for instance diagnostic pop-ups, scrollable
documentation windows from completion engines, overlay windows from
installers, etc.
'';
diagnostic_text_highlight = defaultNullOpts.mkFlagInt 0 ''
Some plugins support highlighting error/warning/info/hint texts, by default
these texts are only underlined, but you can use this option to also highlight
the background of them.
Currently, the following plugins are supported:
- neovim's built-in language server client
- [coc.nvim](https://github.com/neoclide/coc.nvim)
- [vim-lsp](https://github.com/prabirshrestha/vim-lsp)
- [YouCompleteMe](https://github.com/ycm-core/YouCompleteMe)
- [ale](https://github.com/dense-analysis/ale)
- [neomake](https://github.com/neomake/neomake)
- [syntastic](https://github.com/vim-syntastic/syntastic)
'';
diagnostic_line_highlight = defaultNullOpts.mkFlagInt 0 ''
Some plugins support highlighting error/warning/info/hint lines, but this
feature is disabled by default in this color scheme. To enable this feature,
set this option to `1`.
Currently, the following plugins are supported:
- [coc.nvim](https://github.com/neoclide/coc.nvim)
- [YouCompleteMe](https://github.com/ycm-core/YouCompleteMe)
- [ale](https://github.com/dense-analysis/ale)
- [syntastic](https://github.com/vim-syntastic/syntastic)
'';
diagnostic_virtual_text =
defaultNullOpts.mkEnumFirstDefault
[
"grey"
"colored"
"highlighted"
]
''
Some plugins can use the virtual text feature of Neovim to display
error/warning/info/hint information. You can use this option to adjust the
way these virtual texts are highlighted.
Currently, the following plugins are supported:
- Neovim's built-in language server client
- [coc.nvim](https://github.com/neoclide/coc.nvim)
- [vim-lsp](https://github.com/prabirshrestha/vim-lsp)
- [ale](https://github.com/dense-analysis/ale)
- [neomake](https://github.com/neomake/neomake)
- [YouCompleteMe](https://github.com/ycm-core/YouCompleteMe)
'';
current_word =
defaultNullOpts.mkEnumFirstDefault
[
"grey background"
"bold"
"underline"
"italic"
]
''
Some plugins can highlight the word under current cursor, you can use this
option to control their behavior.
Default value: `'grey background'` when not in transparent mode, `'bold'`
when in transparent mode.
Currently, the following plugins are supported:
- [coc-highlight](https://github.com/neoclide/coc-highlight)
- [vim_current_word](https://github.com/dominikduda/vim_current_word)
- [vim-illuminate](https://github.com/RRethy/vim-illuminate)
- [vim-cursorword](https://github.com/itchyny/vim-cursorword)
- [vim-lsp](https://github.com/prabirshrestha/vim-lsp)
'';
inlay_hints_background =
defaultNullOpts.mkEnumFirstDefault
[
"none"
"dimmed"
]
''
Inlay hints are special markers that are displayed inline with the code to
provide you with additional information. You can use this option to customize
the background color of inlay hints.
Currently, the following LSP clients are supported:
- Neovim's built-in language server client
- [coc.nvim](https://github.com/neoclide/coc.nvim)
- [vim-lsp](https://github.com/prabirshrestha/vim-lsp)
- [YouCompleteMe](https://github.com/ycm-core/YouCompleteMe)
'';
disable_terminal_colors = defaultNullOpts.mkFlagInt 0 ''
Setting this option to `1` will disable terminal colors provided by this color
scheme so you can remain terminal colors the same when using |:terminal| in
vim and outside of vim.
'';
lightline_disable_bold = defaultNullOpts.mkFlagInt 0 ''
By default, bold is enabled in lightline color scheme. To disable bold in
lightline color scheme, set this option to `1`.
'';
colors_override = defaultNullOpts.mkAttrsOf (lib.types.listOf lib.types.str) { } ''
Override color palette. The available keys can be found in the plugin's [source code](https://github.com/sainnhe/everforest/blob/master/autoload/everforest.vim)
'';
};
settingsExample = {
background = "hard";
dim_inactive_windows = 1;
colors_override = {
bg0 = [
"#202020"
"234"
];
bg2 = [
"#282828"
"235"
];
};
};
extraConfig = {
opts.termguicolors = lib.mkDefault true;
};
}

22
plugins/colorschemes/github-theme.nix
View file

@ -1,22 +0,0 @@
{
lib,
...
}:
lib.nixvim.plugins.mkNeovimPlugin {
name = "github-theme";
package = "github-nvim-theme";
isColorscheme = true;
maintainers = [ lib.maintainers.GaetanLepage ];
settingsExample = {
options = {
transparent = true;
dim_inactive = true;
styles = {
comments = "italic";
keywords = "bold";
};
};
};
}

28
plugins/colorschemes/gruvbox-baby.nix
View file

@ -1,28 +0,0 @@
{ lib, ... }:
lib.nixvim.plugins.mkNeovimPlugin {
name = "gruvbox-baby";
maintainers = [ lib.maintainers.saygo-png ];
isColorscheme = true;
# Despite being a lua plugin, it's configured via globals without a setup function.
callSetup = false;
hasLuaConfig = false;
settingsExample = {
function_style = "NONE";
keyword_style = "italic";
highlights = {
Normal = {
fg = "#123123";
bg = "NONE";
style = "underline";
};
};
telescope_theme = 1;
transparent_mode = 1;
};
extraConfig = cfg: {
globals = lib.nixvim.applyPrefixToAttrs "gruvbox_baby_" cfg.settings;
};
}

39
plugins/colorschemes/gruvbox-material-nvim.nix
View file

@ -1,39 +0,0 @@
{ lib, ... }:
lib.nixvim.plugins.mkNeovimPlugin {
name = "gruvbox-material-nvim";
isColorscheme = true;
colorscheme = "gruvbox-material";
moduleName = "gruvbox-material";
package = "gruvbox-material-nvim";
maintainers = [ lib.maintainers.f4z3r ];
settingsExample = {
italics = true;
contrast = "medium";
comments = {
italics = true;
};
background = {
transparent = false;
};
float = {
force_background = false;
};
signs = {
force_background = false;
};
customize = lib.nixvim.nestedLiteralLua ''
function(g, o)
local colors = require("gruvbox-material.colors").get(vim.o.background, "medium")
if g == "CursorLineNr" then
o.link = nil -- wipe a potential link, which would take precedence over other
-- attributes
o.fg = colors.orange -- or use any color in "#rrggbb" hex format
o.bold = true
end
return o
end
'';
};
}

33
plugins/colorschemes/gruvbox-material.nix
View file

@ -1,33 +0,0 @@
{ lib, config, ... }:
lib.nixvim.plugins.mkVimPlugin {
name = "gruvbox-material";
isColorscheme = true;
globalPrefix = "gruvbox_material_";
maintainers = [ lib.maintainers.saygo-png ];
settingsExample = {
foreground = "original";
enable_bold = 1;
enable_italic = 1;
transparent_background = 2;
colors_override = {
green = [
"#7d8618"
142
];
};
show_eob = 0;
};
extraConfig = cfg: {
warnings = lib.nixvim.mkWarnings "colorschemes.gruvbox-material" {
when = (cfg.settings.better_performance or 0 == 1) && !config.impureRtp;
message = ''
You have enabled 'better_performance', but the top-level option 'impureRtp' is false.
The performance option generates syntax files at runtime that cannot be accessed with impureRtp disabled.
This breaks the plugin. Either disable 'better_performance' or enable 'impureRtp'.
'';
};
};
}

22
plugins/colorschemes/gruvbox.nix
View file

@ -1,22 +0,0 @@
{
lib,
...
}:
lib.nixvim.plugins.mkNeovimPlugin {
name = "gruvbox";
isColorscheme = true;
package = "gruvbox-nvim";
maintainers = [ lib.maintainers.GaetanLepage ];
settingsExample = {
terminal_colors = true;
palette_overrides = {
dark1 = "#323232";
dark2 = "#383330";
dark3 = "#323232";
bright_blue = "#5476b2";
bright_purple = "#fb4934";
};
};
}

54
plugins/colorschemes/kanagawa-paper.nix
View file

@ -1,54 +0,0 @@
{
lib,
...
}:
lib.nixvim.plugins.mkNeovimPlugin {
name = "kanagawa-paper";
isColorscheme = true;
package = "kanagawa-paper-nvim";
description = ''
You can select the theme in two ways:
- Set `colorschemes.kanagawa-paper.settings.theme` AND explicitly unset `vim.o.background` (i.e. `opts.background = ""`).
- Set `colorschemes.kanagawa-paper.settings.background` (the active theme will depend on the value of `vim.o.background`).
'';
maintainers = [ lib.maintainers.FKouhai ];
settingsExample = {
background = "dark";
cache = false;
colors = {
palette = { };
theme = {
ink = { };
canvas = { };
};
};
undercurl = true;
styles = {
comments = {
italic = true;
};
functions = {
italic = true;
};
keywords = {
italic = true;
};
statement_style = {
bold = true;
};
};
transparent = true;
auto_plugins = false;
dim_inactive = false;
gutter = false;
compile = false;
overrides = lib.nixvim.nestedLiteralLua "function(colors) return {} end";
terminal_colors = false;
theme = "ink";
};
}

198
plugins/colorschemes/kanagawa.nix
View file

@ -1,198 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts;
inherit (lib) types;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "kanagawa";
isColorscheme = true;
package = "kanagawa-nvim";
description = ''
You can select the theme in two ways:
- Set `colorschemes.kanagawa.settings.theme` AND explicitly unset `vim.o.background` (i.e. `options.background = ""`).
- Set `colorschemes.kanagawa.settings.background` (the active theme will depend on the value of `vim.o.background`).
'';
maintainers = [ lib.maintainers.GaetanLepage ];
imports = [
(lib.mkRemovedOptionModule
[
"colorschemes"
"kanagawa"
"overrides"
]
''
Use `colorschemes.kanagawa.settings.overrides` but you now have to add the full function definition:
```
function(colors)
...
end
```
''
)
];
settingsOptions = {
compile = defaultNullOpts.mkBool false ''
Enable compiling the colorscheme.
'';
undercurl = defaultNullOpts.mkBool true ''
Enable undercurls.
'';
commentStyle = defaultNullOpts.mkAttrsOf types.anything { italic = true; } ''
Highlight options for comments.
'';
functionStyle = defaultNullOpts.mkAttrsOf types.anything { } ''
Highlight options for functions.
'';
keywordStyle = defaultNullOpts.mkAttrsOf types.anything { italic = true; } ''
Highlight options for keywords.
'';
statementStyle = defaultNullOpts.mkAttrsOf types.anything { bold = true; } ''
Highlight options for statements.
'';
typeStyle = defaultNullOpts.mkAttrsOf types.anything { } ''
Highlight options for types.
'';
transparent = defaultNullOpts.mkBool false ''
Whether to set a background color.
'';
dimInactive = defaultNullOpts.mkBool false ''
Whether dim inactive window `:h hl-NormalNC`.
'';
terminalColors = defaultNullOpts.mkBool true ''
If true, defines `vim.g.terminal_color_{0,17}`.
'';
colors = {
theme =
defaultNullOpts.mkAttrsOf types.attrs
{
wave = { };
lotus = { };
dragon = { };
all = { };
}
''
Change specific usages for a certain theme, or for all of them
Example:
```nix
{
wave = {
ui = {
float = {
bg = "none";
};
};
};
dragon = {
syn = {
parameter = "yellow";
};
};
all = {
ui = {
bg_gutter = "none";
};
};
}
```
'';
palette = defaultNullOpts.mkAttrsOf types.str { } ''
Change all usages of these colors.
Example:
```nix
{
sumiInk0 = "#000000";
fujiWhite = "#FFFFFF";
}
```
'';
};
overrides =
defaultNullOpts.mkLuaFn
''
function(colors)
return {}
end
''
''
The body of a function that add/modify hihlights.
It takes as input a `colors` argument which is a table of this form:
```
colors = {
palette = {
foo = "#RRGGBB",
bar = "#RRGGBB"
},
theme = {
foo = "#RRGGBB",
bar = "#RRGGBB"
}
}
```
It should return a table of highlights.
```
function(colors)
CONTENT_OF_OVERRIDE_OPTION
end
```
'';
theme = defaultNullOpts.mkStr "wave" ''
The theme to load when background is not set.
'';
background = {
light = defaultNullOpts.mkStr "lotus" ''
The theme to use when `vim.o.background = "light"`.
'';
dark = defaultNullOpts.mkStr "wave" ''
The theme to use when `vim.o.background = "dark"`.
'';
};
};
settingsExample = {
compile = false;
undercurl = true;
commentStyle.italic = true;
functionStyle = { };
transparent = false;
dimInactive = false;
terminalColors = true;
colors = {
theme = {
wave.ui.float.bg = "none";
dragon.syn.parameter = "yellow";
all.ui.bg_gutter = "none";
};
palette = {
sumiInk0 = "#000000";
fujiWhite = "#FFFFFF";
};
};
overrides = "function(colors) return {} end";
theme = "wave";
};
}

15
plugins/colorschemes/melange.nix
View file

@ -1,15 +0,0 @@
{
lib,
...
}:
lib.nixvim.plugins.mkVimPlugin {
name = "melange";
isColorscheme = true;
package = "melange-nvim";
maintainers = [ lib.maintainers.GaetanLepage ];
extraConfig = {
opts.termguicolors = lib.mkDefault true;
};
}

30
plugins/colorschemes/mini-base16.nix
View file

@ -1,30 +0,0 @@
{ lib, ... }:
lib.nixvim.plugins.mkNeovimPlugin {
name = "mini-base16";
moduleName = "mini.base16";
isColorscheme = true;
colorscheme = null;
maintainers = [ lib.maintainers.HeitorAugustoLN ];
settingsExample = {
palette = {
base00 = "#112641";
base01 = "#3a475e";
base02 = "#606b81";
base03 = "#8691a7";
base04 = "#d5dc81";
base05 = "#e2e98f";
base06 = "#eff69c";
base07 = "#fcffaa";
base08 = "#ffcfa0";
base09 = "#cc7e46";
base0A = "#46a436";
base0B = "#9ff895";
base0C = "#ca6ecf";
base0D = "#42f7ff";
base0E = "#ffc4ff";
base0F = "#00a5c5";
};
};
}

19
plugins/colorschemes/mini-hues.nix
View file

@ -1,19 +0,0 @@
{ lib, ... }:
lib.nixvim.plugins.mkNeovimPlugin {
name = "mini-hues";
moduleName = "mini.hues";
isColorscheme = true;
colorscheme = null;
maintainers = [ lib.maintainers.HeitorAugustoLN ];
settingsExample = {
background = "#351721";
foreground = "#cdc4c6";
n_hues = 8;
saturation = "medium";
accent = "bg";
plugins.default = true;
autoadjust = true;
};
}

113
plugins/colorschemes/modus.nix
View file

@ -1,113 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "modus";
moduleName = "modus-themes";
package = "modus-themes-nvim";
isColorscheme = true;
maintainers = [ lib.maintainers.nwjsmith ];
settingsOptions = {
style =
defaultNullOpts.mkEnumFirstDefault
[
"modus_operandi"
"modus_vivendi"
]
''
The theme comes in a light `modus_operandi` style and a dark `modus_vivendi` style.
'';
variant =
defaultNullOpts.mkEnumFirstDefault
[
"default"
"tinted"
"deuteranopia"
"tritanopia"
]
''
Styles come in four variants:
- `default` is the plugin's main style designed to cover a broad range of needs.
- `tinted` tones down intensity and provides more color variety.
- `deuteranopia` is optimized for users with red-green color deficiency.
- `tritanopia` is optimized for users with blue-yellow color deficiency.
'';
transparent = defaultNullOpts.mkBool false ''
Disable setting the background color.
'';
hide_inactive_statusline = defaultNullOpts.mkBool false ''
Hide statuslines in inactive windows.
'';
dim_inactive = defaultNullOpts.mkBool false ''
Dims inactive windows.
'';
styles = {
comments = defaultNullOpts.mkHighlight { italic = true; } "" ''
Define comments highlight properties.
'';
keywords = defaultNullOpts.mkHighlight { italic = true; } "" ''
Define keywords highlight properties.
'';
functions = defaultNullOpts.mkHighlight { } "" ''
Define functions highlight properties.
'';
variables = defaultNullOpts.mkHighlight { } "" ''
Define variables highlight properties.
'';
};
on_colors = defaultNullOpts.mkLuaFn "function(colors) end" ''
Override specific color groups to use other groups or a hex color.
Function will be called with a `ColorScheme` table.
```
@param colors ColorScheme
```
'';
on_highlights = defaultNullOpts.mkLuaFn "function(highlights, colors) end" ''
Override specific highlights to use other groups or a hex color.
Function will be called with a `Highlights` and `ColorScheme` table.
```
@param highlights Highlights
@param colors ColorScheme
```
'';
};
settingsExample = {
style = "auto";
variant = "default";
transparent = false;
dim_inactive = false;
hide_inactive_statusline = false;
styles = {
comments.italic = true;
keywords.italic = true;
functions = { };
variables = { };
};
on_colors = "function(colors) end";
on_highlights = "function(highlights, colors) end";
};
extraConfig = {
opts.termguicolors = lib.mkDefault true;
};
}

126
plugins/colorschemes/monokai-pro.nix
View file

@ -1,126 +0,0 @@
{
lib,
config,
...
}:
let
inherit (lib) types;
inherit (lib.nixvim) defaultNullOpts literalLua;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "monokai-pro";
isColorscheme = true;
package = "monokai-pro-nvim";
maintainers = [ lib.maintainers.GaetanLepage ];
settingsOptions = {
transparent_background = defaultNullOpts.mkBool false ''
Whether to enable transparent background.
'';
terminal_colors = defaultNullOpts.mkBool true ''
Whether to use terminal colors.
'';
devicons = defaultNullOpts.mkBool false ''
Whether to use devicons characters.
'';
styles =
defaultNullOpts.mkAttrsOf (with types; attrsOf anything)
{
comment.italic = true;
keyword.italic = true;
type.italic = true;
storageclass.italic = true;
structure.italic = true;
parameter.italic = true;
annotation.italic = true;
tag_attribute.italic = true;
}
''
Set the style for specific elements.
'';
filter = defaultNullOpts.mkStr' {
pluginDefault = literalLua "vim.o.background == 'light' and 'classic' or 'pro'";
example = "ristretto";
description = ''
Which filter to use.
'';
};
day_night = {
enable = defaultNullOpts.mkBool false ''
Whether to enable day/night mode.
'';
day_filter = defaultNullOpts.mkStr' {
pluginDefault = "pro";
example = "classic";
description = ''
Which day filter to use.
'';
};
night_filter = defaultNullOpts.mkStr' {
pluginDefault = "spectrum";
example = "octagon";
description = ''
Which night filter to use.
'';
};
};
inc_search = defaultNullOpts.mkEnum [ "underline" "background" ] "background" ''
Incremental search look.
'';
background_clear =
defaultNullOpts.mkListOf types.str
[
"toggleterm"
"telescope"
"renamer"
"notify"
]
''
List of plugins for which the background should be clear.
'';
plugins =
defaultNullOpts.mkAttrsOf (with types; attrsOf anything)
{
bufferline = {
underline_selected = false;
underline_visible = false;
underline_fill = false;
bold = true;
};
indent_blankline = {
context_highlight = "default";
context_start_underline = false;
};
}
''
Override configuration for specific plugins.
'';
};
settingsExample = {
terminal_colors = false;
devicons = true;
filter = "ristretto";
};
extraConfig = cfg: {
warnings = lib.nixvim.mkWarnings "colorschemes.monokai-pro" {
when = (cfg.settings.devicons == true) && (!config.plugins.web-devicons.enable);
message = ''
You have enabled `settings.devicons` but `plugins.web-devicons.enable` is `false`.
Consider enabling the plugin for proper devicons support.
'';
};
};
}

24
plugins/colorschemes/moonfly.nix
View file

@ -1,24 +0,0 @@
{
lib,
...
}:
lib.nixvim.plugins.mkVimPlugin {
name = "moonfly";
colorscheme = "moonfly";
package = "vim-moonfly-colors";
isColorscheme = true;
maintainers = [ lib.maintainers.AidanWelch ];
globalPrefix = "moonfly";
settingsExample = {
Italics = true;
NormalFloat = false;
TerminalColors = true;
Transparent = false;
Undercurls = true;
UnderlineMatchParen = false;
VirtualTextColor = false;
WinSeparator = 1;
};
}

353
plugins/colorschemes/nightfox.nix
View file

@ -1,353 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts mkNullOrOption literalLua;
inherit (lib) types;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "nightfox";
isColorscheme = true;
package = "nightfox-nvim";
maintainers = [ lib.maintainers.GaetanLepage ];
colorscheme = null;
extraOptions = {
flavor = lib.mkOption {
type = types.enum [
"carbonfox"
"dawnfox"
"dayfox"
"duskfox"
"nightfox"
"nordfox"
"terafox"
];
example = "dayfox";
default = "nightfox";
description = "Which palette/flavor to use as the colorscheme.";
};
};
extraConfig = cfg: { colorscheme = lib.mkDefault cfg.flavor; };
settingsOptions = {
options = {
compile_path = defaultNullOpts.mkStr (literalLua "vim.fn.stdpath('cache') .. '/nightfox'") ''
The output directory path where the compiled results will be written to.
'';
compile_file_suffix = defaultNullOpts.mkStr "_compiled" ''
The string appended to the compiled file.
Each `style` outputs to its own file.
These files will append the suffix to the end of the file.
'';
transparent = defaultNullOpts.mkBool false ''
A boolean value that if set will disable setting the background of `Normal`, `NormalNC` and
other highlight groups.
This lets you use the colors of the colorscheme but use the background of your terminal.
'';
terminal_colors = defaultNullOpts.mkBool true ''
A boolean value that if set will define the terminal colors for the builtin `terminal`
(`vim.g.terminal_color_*`).
'';
dim_inactive = defaultNullOpts.mkBool false ''
A boolean value that if set will set the background of Non current windows to be darker.
See `:h hl-NormalNC`.
'';
module_default = defaultNullOpts.mkBool true ''
The default value of a module that has not been overridden in the modules table.
'';
styles = defaultNullOpts.mkAttrsOf' {
type = types.str;
description = ''
A table that contains a list of syntax components and their corresponding style.
These styles can be any combination of `|highlight-args|`.
The list of syntax components are:
- comments
- conditionals
- constants
- functions
- keywords
- numbers
- operators
- preprocs
- strings
- types
- variables
'';
example = {
comments = "italic";
functions = "italic,bold";
};
pluginDefault = {
comments = "NONE";
conditionals = "NONE";
constants = "NONE";
functions = "NONE";
keywords = "NONE";
numbers = "NONE";
operators = "NONE";
preprocs = "NONE";
strings = "NONE";
types = "NONE";
variables = "NONE";
};
};
inverse =
defaultNullOpts.mkAttrsOf types.bool
{
match_paren = false;
visual = false;
search = false;
}
''
A table that contains a list of highlight types.
If a highlight type is enabled it will inverse the foreground and background colors
instead of applying the normal highlight group.
Thees highlight types are: `match_paren`, `visual`, `search`.
For an example if search is enabled instead of highlighting a search term with the default
search color it will inverse the foureground and background colors.
'';
colorblind = {
enable = defaultNullOpts.mkBool false ''
Whether to enable nightfox’s _color vision deficiency_ (cdv) mode.
'';
simulate_only = defaultNullOpts.mkBool false ''
Only show simulated colorblind colors and not diff shifted.
'';
severity =
lib.mapAttrs
(
name: color:
defaultNullOpts.mkProportion 0 ''
Severity [0, 1] for ${name} (${color}).
''
)
{
protan = "red";
deutan = "green";
tritan = "blue";
};
};
modules =
defaultNullOpts.mkAttrsOf types.anything
{
coc = {
background = true;
};
diagnostic = {
enable = true;
background = true;
};
native_lsp = {
enable = true;
background = true;
};
treesitter = true;
lsp_semantic_tokens = true;
leap = {
background = true;
};
}
''
`modules` store configuration information for various plugins and other neovim modules.
A module can either be a boolean or a table that contains additional configuration for
that module.
If the value is a table it also has a field called `enable` that will tell nightfox to
load it.
See `|nightfox-modules|` for more information.
By default modules will be enabled.
To change this behaviour change `options.module_default` to `false`.
'';
};
palettes =
mkNullOrOption
(
with types;
attrsOf
# A theme (or `all`)
(
attrsOf
# A color
(either str (attrsOf str))
)
)
''
A `palette` is the base color definitions of a style.
Each style defines its own palette to be used by the other components.
A palette defines base colors, as well as foreground and background shades.
Along with the foreground and background colors a palette also defines other colors such
as selection and comment colors.
The base colors are |nightfox-shade| objects that define a `base`, `bright`, and `dim`
color.
These base colors are: `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`,
`white`, `orange`, `pink`.
Example:
```nix
{
all = {
red = "#ff0000";
};
nightfox = {
red = "#c94f6d";
};
dayfox = {
blue = {
base = "#4d688e";
bright = "#4e75aa";
dim = "#485e7d";
};
};
nordfox = {
bg1 = "#2e3440";
sel0 = "#3e4a5b";
sel1 = "#4f6074";
comment = "#60728a";
};
}
```
'';
specs =
mkNullOrOption
(
with types;
attrsOf
# A theme (or `all`)
(
attrsOf
# `inactive`, `syntax`, `git`, ...
(either str (attrsOf str))
)
)
''
Spec's (specifications) are a mapping of palettes to logical groups that will be used by
the groups.
Some examples of the groups that specs map would be:
- syntax groups (functions, types, keywords, ...)
- diagnostic groups (error, warning, info, hints)
- git groups (add, removed, changed)
You can override these just like palettes.
Example:
```nix
{
all = {
syntax = {
keyword = "magenta";
conditional = "magenta.bright";
number = "orange.dim";
};
git = {
changed = "#f4a261";
};
};
nightfox = {
syntax = {
operator = "orange";
};
};
}
```
'';
groups =
mkNullOrOption
(
with types;
attrsOf
# A theme (or `all`)
(
attrsOf
# `Whitespace`, `IncSearch`, ...
(attrsOf str)
)
)
''
Groups are the highlight group definitions.
The keys of this table are the name of the highlight groups that will be overridden.
The value is a table with the following values:
- fg, bg, style, sp, link,
Just like `spec` groups support templates.
This time the template is based on a spec object.
Example:
```nix
{
all = {
Whitespace.link = "Comment";
IncSearch.bg = "palette.cyan";
},
nightfox.PmenuSel = {
bg = "#73daca";
fg = "bg0";
};
}
```
'';
};
settingsExample = {
options = {
transparent = true;
terminal_colors = true;
styles = {
comments = "italic";
functions = "italic,bold";
};
inverse = {
match_paren = false;
visual = false;
search = true;
};
colorblind = {
enable = true;
severity = {
protan = 0.3;
deutan = 0.6;
};
};
modules = {
coc.background = false;
diagnostic = {
enable = true;
background = false;
};
};
};
palettes.duskfox = {
bg1 = "#000000";
bg0 = "#1d1d2b";
bg3 = "#121820";
sel0 = "#131b24";
};
specs = {
all.inactive = "bg0";
duskfox.inactive = "#090909";
};
groups.all.NormalNC = {
fg = "fg1";
bg = "inactive";
};
};
}

51
plugins/colorschemes/nord.nix
View file

@ -1,51 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts;
in
lib.nixvim.plugins.mkVimPlugin {
name = "nord";
isColorscheme = true;
package = "nord-nvim";
globalPrefix = "nord_";
maintainers = [ lib.maintainers.GaetanLepage ];
settingsOptions = {
contrast = defaultNullOpts.mkBool false ''
Make sidebars and popup menus like nvim-tree and telescope have a different background.
'';
borders = defaultNullOpts.mkBool false ''
Enable the border between vertically split windows.
'';
disable_background = defaultNullOpts.mkBool false ''
Disable the setting of background color so that NeoVim can use your terminal background.
'';
cursorline_transparent = defaultNullOpts.mkBool false ''
Set the cursorline transparent/visible.
'';
enable_sidebar_background = defaultNullOpts.mkBool false ''
Re-enables the background of the sidebar if you disabled the background of everything.
'';
italic = defaultNullOpts.mkBool true ''
Enables/disables italics.
'';
uniform_diff_background = defaultNullOpts.mkBool false ''
Enables/disables colorful backgrounds when used in _diff_ mode.
'';
};
settingsExample = {
borders = true;
disable_background = true;
italic = false;
};
}

26
plugins/colorschemes/one.nix
View file

@ -1,26 +0,0 @@
{
lib,
...
}:
lib.nixvim.plugins.mkVimPlugin {
name = "one";
isColorscheme = true;
package = "vim-one";
globalPrefix = "one_";
maintainers = [ lib.maintainers.GaetanLepage ];
settingsOptions = {
allow_italics = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
Whether to enable _italic_ (as long as your terminal supports it).
'';
};
settingsExample = {
allow_italics = true;
};
extraConfig = {
opts.termguicolors = lib.mkDefault true;
};
}

42
plugins/colorschemes/onedark.nix
View file

@ -1,42 +0,0 @@
{
lib,
...
}:
lib.nixvim.plugins.mkNeovimPlugin {
name = "onedark";
isColorscheme = true;
package = "onedark-nvim";
maintainers = [ lib.maintainers.GaetanLepage ];
settingsExample = {
colors = {
bright_orange = "#ff8800";
green = "#00ffaa";
};
highlights = {
"@keyword".fg = "$green";
"@string" = {
fg = "$bright_orange";
bg = "#00ff00";
fmt = "bold";
};
"@function" = {
fg = "#0000ff";
sp = "$cyan";
fmt = "underline,italic";
};
"@function.builtin".fg = "#0059ff";
};
};
callSetup = false;
colorscheme = null;
extraConfig = cfg: {
colorschemes.onedark.luaConfig.content = ''
_onedark = require('onedark')
_onedark.setup(${lib.nixvim.toLuaObject cfg.settings})
_onedark.load()
'';
};
}

15
plugins/colorschemes/oxocarbon.nix
View file

@ -1,15 +0,0 @@
{
lib,
...
}:
lib.nixvim.plugins.mkVimPlugin {
name = "oxocarbon";
isColorscheme = true;
package = "oxocarbon-nvim";
maintainers = [ lib.maintainers.GaetanLepage ];
extraConfig = {
opts.termguicolors = lib.mkDefault true;
};
}

142
plugins/colorschemes/palette.nix
View file

@ -1,142 +0,0 @@
{
config,
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "palette";
isColorscheme = true;
package = "palette-nvim";
maintainers = [ lib.maintainers.GaetanLepage ];
extraPlugins = [
# Annoyingly, lspconfig is required, otherwise this line is breaking:
# https://github.com/roobert/palette.nvim/blob/a808c190a4f74f73782302152ebf323660d8db5f/lua/palette/init.lua#L45
# An issue has been opened upstream to warn the maintainer: https://github.com/roobert/palette.nvim/issues/2
config.plugins.lsp.package
];
settingsOptions = {
palettes = {
main = defaultNullOpts.mkStr "dark" ''
Palette for the main colors.
'';
accent = defaultNullOpts.mkStr "pastel" ''
Palette for the accent colors.
'';
state = defaultNullOpts.mkStr "pastel" ''
Palette for the state colors.
'';
};
custom_palettes =
lib.mapAttrs
(
name: colorNames:
defaultNullOpts.mkAttrsOf
(lib.types.submodule {
options = lib.genAttrs colorNames (
colorName:
lib.mkOption {
type = lib.types.str;
description = "Definition of color '${colorName}'";
}
);
})
{ }
''
Custom palettes for ${name} colors.
''
)
{
main = [
"color0"
"color1"
"color2"
"color3"
"color4"
"color5"
"color6"
"color7"
"color8"
];
accent = [
"accent0"
"accent1"
"accent2"
"accent3"
"accent4"
"accent5"
"accent6"
];
state = [
"error"
"warning"
"hint"
"ok"
"info"
];
};
italics = defaultNullOpts.mkBool true ''
Whether to use italics.
'';
transparent_background = defaultNullOpts.mkBool false ''
Whether to use transparent background.
'';
caching = defaultNullOpts.mkBool true ''
Whether to enable caching.
'';
cache_dir = defaultNullOpts.mkStr (lib.nixvim.literalLua "vim.fn.stdpath('cache') .. '/palette'") "Cache directory.";
};
settingsExample = { };
extraConfig = cfg: {
assertions = lib.nixvim.mkAssertions "colorschemes.palette" (
lib.mapAttrsToList
(
name: defaultPaletteNames:
let
customPalettesNames = lib.attrNames cfg.settings.custom_palettes.${name};
allowedPaletteNames = customPalettesNames ++ defaultPaletteNames;
palette = cfg.settings.palettes.${name};
in
{
assertion = lib.isString palette -> lib.elem palette allowedPaletteNames;
message = ''
`settings.palettes.${name}` (${palette}") is not part of the allowed ${name} palette names (${lib.concatStringsSep " " allowedPaletteNames}).
'';
}
)
{
main = [
"dark"
"light"
];
accent = [
"pastel"
"dark"
"bright"
];
state = [
"pastel"
"dark"
"bright"
];
}
);
};
}

58
plugins/colorschemes/poimandres.nix
View file

@ -1,58 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts mkNullOrOption;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "poimandres";
isColorscheme = true;
package = "poimandres-nvim";
maintainers = [ lib.maintainers.GaetanLepage ];
settingsOptions = {
bold_vert_split = defaultNullOpts.mkBool false ''
Use bold vertical separators.
'';
dim_nc_background = defaultNullOpts.mkBool false ''
Dim 'non-current' window backgrounds.
'';
disable_background = defaultNullOpts.mkBool false ''
Whether to disable the background.
'';
disable_float_background = defaultNullOpts.mkBool false ''
Whether to disable the background for floats.
'';
disable_italics = defaultNullOpts.mkBool false ''
Whether to disable italics.
'';
dark_variant = defaultNullOpts.mkStr "main" ''
Dark variant.
'';
groups = mkNullOrOption (with lib.types; attrsOf (either str (attrsOf str))) ''
Which color to use for each group.
default: see [source](https://github.com/olivercederborg/poimandres.nvim/blob/main/lua/poimandres/init.lua)
'';
highlight_groups = defaultNullOpts.mkAttrsOf lib.types.str { } ''
Highlight groups.
'';
};
settingsExample = {
bold_vert_split = false;
dim_nc_background = true;
disable_background = false;
disable_float_background = false;
disable_italics = true;
};
}

114
plugins/colorschemes/rose-pine.nix
View file

@ -1,114 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts mkNullOrOption;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "rose-pine";
isColorscheme = true;
maintainers = [ lib.maintainers.GaetanLepage ];
settingsOptions = {
variant =
lib.nixvim.mkNullOrOption
(lib.types.enum [
"auto"
"main"
"moon"
"dawn"
])
''
Set the desired variant: "auto" will follow the vim background, defaulting to `dark_variant`
or "main" for dark and "dawn" for light.
'';
dark_variant =
defaultNullOpts.mkEnumFirstDefault
[
"main"
"moon"
"dawn"
]
''
Set the desired dark variant when `settings.variant` is set to "auto".
'';
dim_inactive_windows = defaultNullOpts.mkBool false ''
Differentiate between active and inactive windows and panels.
'';
extend_background_behind_borders = defaultNullOpts.mkBool true ''
Extend background behind borders.
Appearance differs based on which border characters you are using.
'';
enable = {
legacy_highlights = defaultNullOpts.mkBool true "Enable legacy highlights.";
migrations = defaultNullOpts.mkBool true "Enable migrations.";
terminal = defaultNullOpts.mkBool true "Enable terminal.";
};
styles = {
bold = defaultNullOpts.mkBool true "Enable bold.";
italic = defaultNullOpts.mkBool true "Enable italic.";
transparency = defaultNullOpts.mkBool true "Enable transparency.";
};
groups = mkNullOrOption (with lib.types; attrsOf (either str (attrsOf str))) ''
Highlight groups.
default: see [source](https://github.com/rose-pine/neovim/blob/main/lua/rose-pine/config.lua)
'';
highlight_groups = defaultNullOpts.mkAttrsOf lib.types.highlight { } ''
Custom highlight groups.
'';
before_highlight = defaultNullOpts.mkLuaFn "function(group, highlight, palette) end" ''
Called before each highlight group, before setting the highlight.
`function(group, highlight, palette)`
```lua
@param group string
@param highlight Highlight
@param palette Palette
```
'';
};
settingsExample = {
variant = "auto";
dark_variant = "moon";
dim_inactive_windows = true;
extend_background_behind_borders = true;
enable = {
legacy_highlights = false;
migrations = true;
terminal = false;
};
styles = {
bold = false;
italic = true;
transparency = true;
};
groups = {
border = "muted";
link = "iris";
panel = "surface";
};
highlight_groups = { };
before_highlight = "function(group, highlight, palette) end";
};
extraConfig = {
opts.termguicolors = lib.mkDefault true;
};
}

21
plugins/colorschemes/solarized-osaka.nix
View file

@ -1,21 +0,0 @@
{
lib,
...
}:
lib.nixvim.plugins.mkNeovimPlugin {
name = "solarized-osaka";
isColorscheme = true;
package = "solarized-osaka-nvim";
colorscheme = "solarized-osaka";
maintainers = [ lib.maintainers.GaetanLepage ];
settingsExample = {
transparent = false;
styles = {
comments.italic = true;
keywords.italic = false;
floats = "transparent";
};
};
}

144
plugins/colorschemes/tokyonight.nix
View file

@ -1,144 +0,0 @@
{
lib,
...
}:
let
inherit (lib.nixvim) defaultNullOpts;
in
lib.nixvim.plugins.mkNeovimPlugin {
name = "tokyonight";
isColorscheme = true;
package = "tokyonight-nvim";
maintainers = [ lib.maintainers.GaetanLepage ];
settingsOptions = {
style =
defaultNullOpts.mkEnumFirstDefault
[
"moon"
"storm"
"night"
"day"
]
''
The theme comes in four styles, `moon`, `storm`, a darker variant `night`, and `day`.
'';
light_style = defaultNullOpts.mkStr "day" ''
The theme to use when the background is set to `light`.
'';
transparent = defaultNullOpts.mkBool false ''
Disable setting the background color.
'';
terminal_colors = defaultNullOpts.mkBool true ''
Configure the colors used when opening a :terminal in Neovim
'';
styles =
let
mkBackgroundStyle =
name:
defaultNullOpts.mkEnumFirstDefault [
"dark"
"transparent"
"normal"
] "Background style for ${name}";
in
{
comments = defaultNullOpts.mkHighlight { italic = true; } "" ''
Define comments highlight properties.
'';
keywords = defaultNullOpts.mkHighlight { italic = true; } "" ''
Define keywords highlight properties.
'';
functions = defaultNullOpts.mkHighlight { } "" ''
Define functions highlight properties.
'';
variables = defaultNullOpts.mkHighlight { } "" ''
Define variables highlight properties.
'';
sidebars = mkBackgroundStyle "sidebars";
floats = mkBackgroundStyle "floats";
};
sidebars =
defaultNullOpts.mkListOf lib.types.str
[
"qf"
"help"
]
''
Set a darker background on sidebar-like windows.
'';
day_brightness = defaultNullOpts.mkProportion 0.3 ''
Adjusts the brightness of the colors of the **Day** style.
Number between 0 and 1, from dull to vibrant colors.
'';
hide_inactive_statusline = defaultNullOpts.mkBool false ''
Enabling this option will hide inactive statuslines and replace them with a thin border instead.
Should work with the standard **StatusLine** and **LuaLine**.
'';
dim_inactive = defaultNullOpts.mkBool false ''
Dims inactive windows.
'';
lualine_bold = defaultNullOpts.mkBool false ''
When true, section headers in the lualine theme will be bold.
'';
on_colors = defaultNullOpts.mkLuaFn "function(colors) end" ''
Override specific color groups to use other groups or a hex color.
Function will be called with a `ColorScheme` table.
`@param colors ColorScheme`
'';
on_highlights = defaultNullOpts.mkLuaFn "function(highlights, colors) end" ''
Override specific highlights to use other groups or a hex color.
Function will be called with a `Highlights` and `ColorScheme` table.
`@param highlights Highlights`
`@param colors ColorScheme`
'';
};
settingsExample = {
style = "storm";
light_style = "day";
transparent = false;
terminal_colors = true;
styles = {
comments.italic = true;
keywords.italic = true;
functions = { };
variables = { };
sidebars = "dark";
floats = "dark";
};
sidebars = [
"qf"
"vista_kind"
"terminal"
"packer"
];
day_brightness = 0.3;
hide_inactive_statusline = false;
dim_inactive = false;
lualine_bold = false;
on_colors = "function(colors) end";
on_highlights = "function(highlights, colors) end";
};
extraConfig = {
opts.termguicolors = lib.mkDefault true;
};
}

32
plugins/colorschemes/vscode.nix
View file

@ -1,32 +0,0 @@
{
lib,
...
}:
lib.nixvim.plugins.mkNeovimPlugin {
name = "vscode";
isColorscheme = true;
package = "vscode-nvim";
colorscheme = null; # Color scheme is set by `require.("vscode").load()`
callSetup = false;
maintainers = [ lib.maintainers.loicreynier ];
settingsExample = {
transparent = true;
italic_comments = true;
italic_inlayhints = true;
underline_links = true;
terminal_colors = true;
color_overrides = {
vscLineNumber = "#FFFFFF";
};
};
extraConfig = cfg: {
colorschemes.vscode.luaConfig.content = ''
local _vscode = require("vscode")
_vscode.setup(${lib.nixvim.toLuaObject cfg.settings})
_vscode.load()
'';
};
}

33
plugins/default.nix
View file

@ -2,39 +2,6 @@
imports = [
./cmp
./colorschemes/ayu.nix
./colorschemes/bamboo.nix
./colorschemes/base16
./colorschemes/catppuccin.nix
./colorschemes/cyberdream.nix
./colorschemes/dracula-nvim.nix
./colorschemes/dracula.nix
./colorschemes/everforest.nix
./colorschemes/github-theme.nix
./colorschemes/gruvbox.nix
./colorschemes/gruvbox-baby.nix
./colorschemes/gruvbox-material.nix
./colorschemes/gruvbox-material-nvim.nix
./colorschemes/kanagawa.nix
./colorschemes/kanagawa-paper.nix
./colorschemes/melange.nix
./colorschemes/mini-base16.nix
./colorschemes/mini-hues.nix
./colorschemes/modus.nix
./colorschemes/monokai-pro.nix
./colorschemes/moonfly.nix
./colorschemes/nightfox.nix
./colorschemes/nord.nix
./colorschemes/one.nix
./colorschemes/onedark.nix
./colorschemes/oxocarbon.nix
./colorschemes/palette.nix
./colorschemes/poimandres.nix
./colorschemes/rose-pine.nix
./colorschemes/solarized-osaka.nix
./colorschemes/tokyonight.nix
./colorschemes/vscode.nix
./lsp
./pluginmanagers/lazy.nix