Updated nvim-cmp & lsp: config/saga

1 files changed, 1921 insertions, 0 deletions

diff --git a/lua/plugins/heirline.backup2.lua b/lua/plugins/heirline.backup2.lua
new file mode 100644
index 0000000..9f5c4ca
--- /dev/null
+++ b/lua/plugins/heirline.backup2.lua
@@ -0,0 +1,1921 @@
+local conditions = require("heirline.conditions")
+local utils = require("heirline.utils")
+
+-- Colors
+--local colors = {
+--    bright_bg = utils.get_highlight("Folded").bg,
+--    bright_fg = utils.get_highlight("Folded").fg,
+--    red = utils.get_highlight("DiagnosticError").fg,
+--    dark_red = utils.get_highlight("DiffDelete").bg,
+--    green = utils.get_highlight("String").fg,
+--    blue = utils.get_highlight("Function").fg,
+--    gray = utils.get_highlight("NonText").fg,
+--    orange = utils.get_highlight("Constant").fg,
+--    purple = utils.get_highlight("Statement").fg,
+--    cyan = utils.get_highlight("Special").fg,
+--    diag_warn = utils.get_highlight("DiagnosticWarn").fg,
+--    diag_error = utils.get_highlight("DiagnosticError").fg,
+--    diag_hint = utils.get_highlight("DiagnosticHint").fg,
+--    diag_info = utils.get_highlight("DiagnosticInfo").fg,
+--    git_del = utils.get_highlight("diffDeleted").fg,
+--    git_add = utils.get_highlight("diffAdded").fg,
+--    git_change = utils.get_highlight("diffChanged").fg,
+--}
+
+--local colors = {
+--    gray       = '#23232e',
+--    lightgray  = '#5f6a8e',
+--    orange     = '#ffb86c',
+--    purple     = '#bd93f9',
+--    red        = '#ff5555',
+--    yellow     = '#f1fa8c',
+--    green      = '#50fa7b',
+--    white      = '#f8f8f2',
+--    black      = '#282a36',
+--}
+local colors = {
+	bg = "#333842",
+	nobg = nil,
+	bright_fg = "#ffffff",
+	bright_bg = "#000000",
+	brown = "#504945",
+	white = "#f8f8f0",
+	grey = "#8F908A",
+	pink = "#f92672",
+	--green = "#a6e22e",
+	green = "#AAD94C",
+	--blue = "#66d9ef",
+	blue = "#39BAE6",
+	yellow = "#e6db74",
+	--orange = "#fd971f",
+	orange = "#FA8D3F",
+	purple = "#ae81ff",
+	--red = "#e95678",
+	red = "#F07171",
+	cyan = "#66d9eC",
+	mode_fg = "#242424",
+	diag = {
+		warn = utils.get_highlight("DiagnosticSignWarn").fg,
+		error = utils.get_highlight("DiagnosticSignError").fg,
+		hint = utils.get_highlight("DiagnosticSignHint").fg,
+		info = utils.get_highlight("DiagnosticSignInfo").fg,
+	},
+	git = {
+		del = "#e95678",
+		add = "#a6e22e",
+		change = "#ae81ff",
+	},
+}
+
+require("heirline").load_colors(colors)
+
+--local mode_lable = {
+--	n         = 'NORMAL',
+--	no        = 'OPPEND',
+--	nov       = 'N?',
+--	noV       = 'N?',
+--	['no\22'] = 'N?',
+--	niI       = 'Ni',
+--	niR       = 'Nr',
+--	niV       = 'Nv',
+--	nt        = 'N-TERM',
+--	v         = 'VISUAL',
+--	vs        = 'Vs',
+--	V         = 'V-LINE',
+--	Vs        = 'Vs',
+--	['\22']   = 'V-BLCK',
+--	['\22s']  = '^V',
+--	s         = 'SELECT',
+--	S         = 'S-LINE',
+--	['\19']   = 'S-BLCK',
+--	i         = 'INSERT',
+--	ic        = 'ICOMPL',
+--	ix        = 'Ix',
+--	R         = 'REPLACE',
+--	Rc        = 'Rc',
+--	Rx        = 'Rx',
+--	Rv        = 'VRPLCE',
+--	Rvc       = 'Rv',
+--	Rvx       = 'Rv',
+--	c         = 'CMMAND',
+--	cv        = 'PROMPT',
+--	r         = '...',
+--	rm        = 'MORE',
+--	['r?']    = 'CNFIRM',
+--	['!']     = 'SHELL',
+--	t         = 'TERM',
+--}
+--
+--local mode_colors_table = {
+--	n        = 'red',
+--	no       = 'blue',
+--	nov      = 'blue',
+--	noV      = 'blue',
+--	niI      = 'red',
+--	niR      = 'red',
+--	niV      = 'red',
+--	nt       = 'red',
+--	v        = 'cyan',
+--	vs       = 'cyan',
+--	V        = 'cyan',
+--	Vs       = 'cyan',
+--	['\22']  = 'cyan',
+--	['\22s'] = 'cyan',
+--	s        = 'purple',
+--	S        = 'purple',
+--	['\19']  = 'purple',
+--	i        = 'blue',
+--	ic       = 'blue',
+--	ix       = 'blue',
+--	R        = 'orange',
+--	Rc       = 'orange',
+--	Rx       = 'orange',
+--	Rv       = 'orange',
+--	Rvc      = 'orange',
+--	Rvx      = 'orange',
+--	c        = 'green',
+--	cv       = 'green',
+--	r        = 'green',
+--	rm       = 'green',
+--	['r?']   = 'green',
+--	['!']    = 'red',
+--	t        = 'red',
+--}
+--
+--local mode_colors = setmetatable({
+--	n = { fg = 'red' }
+--}, {
+--	__index = function(_, mode)
+--		return {
+--			fg = 'mode_fg',
+--			bg = mode_colors_table[mode],
+--		}
+--	end
+--})
+--
+--
+--local VimModeNormal = {
+--	condition = function(self)
+--		return self.mode == 'n'
+--	end,
+--	provider = ' ●',
+--}
+--
+--local VimModeOthers = {
+--	condition = function(self)
+--		return self.mode ~= 'n'
+--	end,
+--
+--	utils.surround({ '', '' },
+--		function(self)
+--			return mode_colors[self.mode].bg
+--		end,
+--		{
+--			{
+--				provider = function(self)
+--					return '● ' .. mode_lable[self.mode]
+--				end,
+--			},
+--			hl = function(self)
+--				return mode_colors[self.mode]
+--			end
+--		}
+--	),
+--}
+--
+--local ViMode = {
+--	init = function(self)
+--		self.mode = vim.fn.mode(1)
+--	end,
+--
+--	VimModeNormal, VimModeOthers,
+--
+--	update = { 'ModeChanged' }
+--}
+--local colors = require'kanagawa.colors'.setup() -- wink
+
+--utils.surround({ "", "" }, function(self) return self:mode_color() end, {Ruler, hl = {fg = 'black'}} ),
+-- we are surrounding the component and adjusting the foreground in one go!
+
+-- ViMode truemode
+--local ViMode = {
+--	-- get vim current mode, this information will be required by the provider
+--	-- and the highlight functions, so we compute it only once per component
+--	-- evaluation and store it as a component attribute
+--	init = function(self)
+--		self.mode = vim.fn.mode(1) -- :h mode()
+--
+--		-- execute this only once, this is required if you want the ViMode
+--		-- component to be updated on operator pending mode
+--		if not self.once then
+--			vim.api.nvim_create_autocmd("ModeChanged", {
+--				pattern = "*:*o",
+--				command = "redrawstatus",
+--			})
+--			self.once = true
+--		end
+--	end,
+--	-- Now we define some dictionaries to map the output of mode() to the
+--	-- corresponding string and color. We can put these into `static` to compute
+--	-- them at initialisation time.
+--	static = {
+--		mode_names = { -- change the strings if you like it vvvvverbose!
+--			["n"] = "NORMAL ",
+--			["no"] = "N·OPERATOR PENDING ",
+--			["v"] = "VISUAL ",
+--			["V"] = "V·LINE ",
+--			[""] = "V·BLOCK ",
+--			["s"] = "SELECT ",
+--			["S"] = "S·LINE ",
+--			[""] = "S·BLOCK ",
+--			["i"] = "INSERT ",
+--			["R"] = "REPLACE ",
+--			["Rv"] = "V·REPLACE ",
+--			["c"] = "COMMAND ",
+--			["cv"] = "VIM EX ",
+--			["ce"] = "EX ",
+--			["r"] = "PROMPT ",
+--			["rm"] = "MORE ",
+--			["r?"] = "CONFIRM ",
+--			["!"] = "SHELL ",
+--			["t"] = "TERMINAL ",
+--		},
+--		mode_colors = {
+--			n = colors.blue,
+--			i = colors.green,
+--			v = colors.purple,
+--			V = colors.purple,
+--			[""] = colors.purple,
+--			c = colors.red,
+--			s = colors.purple,
+--			S = colors.purple,
+--			[""] = colors.purple,
+--			R = colors.orange,
+--			r = colors.orange,
+--			["!"] = colors.red,
+--			t = colors.red,
+--			--n = "blue" ,
+--			--i = "green",
+--			--v = "cyan",
+--			--V =  "cyan",
+--			--["\22"] =  "cyan",
+--			--c =  "orange",
+--			--s =  "purple",
+--			--S =  "purple",
+--			--["\19"] =  "purple",
+--			--R =  "orange",
+--			--r =  "orange",
+--			--["!"] =  "red",
+--			--t =  "red",
+--		},
+--	},
+--	-- We can now access the value of mode() that, by now, would have been
+--	-- computed by `init()` and use it to index our strings dictionary.
+--	-- note how `static` fields become just regular attributes once the
+--	-- component is instantiated.
+--	-- To be extra meticulous, we can also add some vim statusline syntax to
+--	-- control the padding and make sure our string is always at least 2
+--	-- characters long. Plus a nice Icon.
+--	provider = function(self)
+--		return " %2(" .. self.mode_names[self.mode] .. "%)"
+--		--return " %2("..self.mode_names[self.mode].."%)"
+--		--
+--		--
+--		--
+--	end,
+--	-- Same goes for the highlight. Now the foreground will change according to the current mode.
+--	hl = function(self)
+--		local mode = self.mode:sub(1, 1) -- get only the first mode character
+--		--return { fg = self.mode_colors[mode], bold = true, }
+--		return { bg = self.mode_colors[mode], fg = colors.bg, bold = true }
+--	end,
+--	-- Re-evaluate the component only on ModeChanged event!
+--	-- This is not required in any way, but it's there, and it's a small
+--	-- performance improvement.
+--	update = {
+--		"ModeChanged",
+--	}, --optional
+--}
+local ViMode = {
+	static = {
+		mode_names = { -- change the strings if you like it vvvvverbose!
+			["n"] = "NORMAL ",
+			["no"] = "N·OPERATOR PENDING ",
+			["v"] = "VISUAL ",
+			["V"] = "V·LINE ",
+			[""] = "V·BLOCK ",
+			["s"] = "SELECT ",
+			["S"] = "S·LINE ",
+			[""] = "S·BLOCK ",
+			["i"] = "INSERT ",
+			["R"] = "REPLACE ",
+			["Rv"] = "V·REPLACE ",
+			["c"] = "COMMAND ",
+			["cv"] = "VIM EX ",
+			["ce"] = "EX ",
+			["r"] = "PROMPT ",
+			["rm"] = "MORE ",
+			["r?"] = "CONFIRM ",
+			["!"] = "SHELL ",
+			["t"] = "TERMINAL ",
+		},
+	},
+	provider = function(self)
+		return " %2(" .. self.mode_names[vim.fn.mode(1)] .. "%)"
+	end,
+	hl = function(self)
+		local color = self:mode_color() -- here!
+		return { bg = color, fg = colors.bg, bold = true }
+	end,
+}
+
+local ViModeColor = {
+	static = {
+		mode_colors_map = {
+			n = colors.blue,
+			i = colors.green,
+			v = colors.purple,
+			V = colors.purple,
+			[""] = colors.purple,
+			c = colors.red,
+			s = colors.purple,
+			S = colors.purple,
+			[""] = colors.purple,
+			R = colors.orange,
+			r = colors.orange,
+			["!"] = colors.red,
+			t = colors.red,
+		},
+		mode_color = function(self)
+			local mode = conditions.is_active() and vim.fn.mode() or "n"
+			return self.mode_colors_map[mode]
+		end,
+	},
+}
+
+-- LSP
+
+--local LSPActive = {
+--    condition = conditions.lsp_attached,
+--    update = {'LspAttach', 'LspDetach'},
+--
+--    -- You can keep it simple,
+--    -- provider = " [LSP]",
+--
+--    -- Or complicate things a bit and get the servers names
+--    provider  = function()
+--        local names = {}
+--        for i, server in pairs(vim.lsp.buf_get_clients(0)) do
+--            table.insert(names, server.name)
+--        end
+--        return " [" .. table.concat(names, " ") .. "]"
+--    end,
+--    hl = { fg = "green", bold = true },
+--    on_click = {
+--        callback = function()
+--            vim.defer_fn(function()
+--                vim.cmd("LspInfo")
+--            end, 100)
+--        end,
+--        name = "heirline_LSP",
+--    },
+--}
+--
+---- lsp status
+---- I personally use it only to display progress messages!
+---- See lsp-status/README.md for configuration options.
+--
+---- Note: check "j-hui/fidget.nvim" for a nice statusline-free alternative.
+--local LSPMessages = {
+--    provider = require("lsp-status").status,
+--    hl = { fg = "gray" },
+--}
+
+-- Nvim Navic
+--local Navic = {
+--    condition = require("nvim-navic").is_available,
+--    provider = require("nvim-navic").get_location,
+--}
+--local Navic = utils.make_flexible_component(3, Navic, { provider = "" })
+
+-- Full nerd (with icon colors)!
+local Navic = {
+	condition = require("nvim-navic").is_available,
+	static = {
+		-- create a type highlight map
+		type_hl = {
+			File = "Directory",
+			Module = "Include",
+			Namespace = "TSNamespace",
+			Package = "Include",
+			Class = "Struct",
+			Method = "Method",
+			Property = "TSProperty",
+			Field = "TSField",
+			Constructor = "TSConstructor ",
+			Enum = "TSField",
+			Interface = "Type",
+			Function = "Function",
+			Variable = "TSVariable",
+			Constant = "Constant",
+			String = "String",
+			Number = "Number",
+			Boolean = "Boolean",
+			Array = "TSField",
+			Object = "Type",
+			Key = "TSKeyword",
+			Null = "Comment",
+			EnumMember = "TSField",
+			Struct = "Struct",
+			Event = "Keyword",
+			Operator = "Operator",
+			TypeParameter = "Type",
+		},
+	},
+	init = function(self)
+		local data = require("nvim-navic").get_data() or {}
+		local children = {}
+		-- create a child for each level
+		for i, d in ipairs(data) do
+			local child = {
+				{
+					provider = d.icon,
+					hl = self.type_hl[d.type],
+				},
+				{
+					provider = d.name,
+					-- highlight icon only or location name as well
+					-- hl = self.type_hl[d.type],
+				},
+			}
+			-- add a separator only if needed
+			if #data > 1 and i < #data then
+				table.insert(child, {
+					provider = " > ",
+					hl = { fg = "bright_fg" },
+				})
+			end
+			table.insert(children, child)
+		end
+		-- instantiate the new child, overwriting the previous one
+		self[1] = self:new(children, 1)
+	end,
+	hl = { fg = "gray" },
+}
+
+-- Diagnostics
+local Diagnostics = {
+
+	condition = conditions.has_diagnostics,
+
+	static = {
+		error_icon = vim.fn.sign_getdefined("DiagnosticSignError")[1].text,
+		warn_icon = vim.fn.sign_getdefined("DiagnosticSignWarn")[1].text,
+		info_icon = vim.fn.sign_getdefined("DiagnosticSignInfo")[1].text,
+		hint_icon = vim.fn.sign_getdefined("DiagnosticSignHint")[1].text,
+	},
+
+	init = function(self)
+		self.errors = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.ERROR })
+		self.warnings = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.WARN })
+		self.hints = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.HINT })
+		self.info = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.INFO })
+	end,
+
+	update = { "DiagnosticChanged", "BufEnter" },
+
+	{
+		provider = function(self)
+			-- 0 is just another output, we can decide to print it or not!
+			return self.errors > 0 and (self.error_icon .. self.errors .. " ")
+		end,
+		hl = { fg = colors.diag.error, bg = colors.bg },
+	},
+	{
+		provider = function(self)
+			return self.warnings > 0 and (self.warn_icon .. self.warnings .. " ")
+		end,
+		hl = { fg = colors.diag.warn, bg = colors.bg },
+	},
+	{
+		provider = function(self)
+			return self.info > 0 and (self.info_icon .. self.info .. " ")
+		end,
+		hl = { fg = colors.diag.info, bg = colors.bg },
+	},
+	{
+		provider = function(self)
+			return self.hints > 0 and (self.hint_icon .. self.hints)
+		end,
+		hl = { fg = colors.diag.hint, bg = colors.bg },
+	},
+	--{
+	--    provider = "]",
+	--},
+	on_click = {
+		callback = function()
+			require("trouble").toggle({ mode = "document_diagnostics" })
+			-- or
+			-- vim.diagnostic.setqflist()
+		end,
+		name = "heirline_diagnostics",
+	},
+}
+
+-- Git
+-- For the ones who're not (too) afraid of changes! Uses gitsigns.
+local Git = {
+	condition = conditions.is_git_repo,
+
+	init = function(self)
+		self.status_dict = vim.b.gitsigns_status_dict
+		self.has_changes = self.status_dict.added ~= 0 or self.status_dict.removed ~= 0 or self.status_dict.changed ~= 0
+	end,
+	--hl = { fg = "orange" },
+	hl = { fg = colors.orange, bg = colors.bg },
+	{ -- git branch name
+		provider = function(self)
+			return " " .. self.status_dict.head
+		end,
+		--hl = { bold = true },
+		hl = { bold = true, bg = colors.bg },
+	},
+	-- You could handle delimiters, icons and counts similar to Diagnostics
+	{
+		condition = function(self)
+			return self.has_changes
+		end,
+		--provider = "("
+		provider = " ",
+	},
+	{
+		provider = function(self)
+			local count = self.status_dict.added or 0
+			--return count > 0 and ("+" .. count)
+			return count > 0 and ("  " .. count)
+		end,
+		--hl = { fg = "git_add" },
+		hl = { fg = colors.git.add, bg = colors.bg },
+	},
+	{
+		provider = function(self)
+			local count = self.status_dict.removed or 0
+			--return count > 0 and ("-" .. count)
+			return count > 0 and ("  " .. count)
+		end,
+		--hl = { fg = "git_del" },
+		hl = { fg = colors.git.del, bg = colors.bg },
+	},
+	{
+		provider = function(self)
+			local count = self.status_dict.changed or 0
+			--return count > 0 and ("~" .. count)
+			return count > 0 and ("  " .. count)
+		end,
+		--hl = { fg = "git_change" },
+		hl = { fg = colors.git.change, bg = colors.bg },
+	},
+	--{
+	--    condition = function(self)
+	--        return self.has_changes
+	--    end,
+	--    provider = ")",
+	--},
+	on_click = {
+		callback = function()
+			-- If you want to use Fugitive:
+			-- vim.cmd("G")
+
+			-- If you prefer Lazygit
+			-- use vim.defer_fn() if the callback requires
+			-- opening of a floating window
+			-- (this also applies to telescope)
+			vim.defer_fn(function()
+				vim.cmd("Lazygit")
+			end, 100)
+		end,
+		name = "heirline_git",
+	},
+}
+
+-- Debugger
+-- Display informations from nvim-dap!
+local DAPMessages = {
+	-- display the dap messages only on the debugged file
+	condition = function()
+		local session = require("dap").session()
+		if session then
+			local filename = vim.api.nvim_buf_get_name(0)
+			if session.config then
+				local progname = session.config.program
+				return filename == progname
+			end
+		end
+		return false
+	end,
+	provider = function()
+		return " " .. require("dap").status()
+	end,
+	hl = { fg = utils.get_highlight("Debug").fg },
+	-- Debugger on_click: step-over, step-into, next, previous, stop buttons
+	--    coming soon!
+}
+
+-- Tests
+-- This requires the great ultest.
+--local UltTest = {
+--    condition = function()
+--        return vim .api.nvim_call_function("ultest#is_test_file", {}) ~= 0
+--    end,
+--    static = {
+--        passed_icon = vim.fn.sign_getdefined("test_pass")[1].text,
+--        failed_icon = vim.fn.sign_getdefined("test_fail")[1].text,
+--        passed_hl = { fg = utils.get_highlight("UltestPass").fg },
+--        failed_hl = { fg = utils.get_highlight("UltestFail").fg },
+--    },
+--    init = function(self)
+--        self.status = vim.api.nvim_call_function("ultest#status", {})
+--    end,
+--
+--    -- again, if you'd like icons and numbers to be colored differently,
+--    -- just split the component in two
+--    {
+--        provider = function(self)
+--            return self.passed_icon .. self.status.passed .. " "
+--        end,
+--        hl = function(self)
+--            return self.passed_hl
+--        end,
+--    },
+--    {
+--        provider = function(self)
+--            return self.failed_icon .. self.status.failed .. " "
+--        end,
+--        hl = function(self)
+--            return self.failed_hl
+--        end,
+--    },
+--    {
+--        provider = function(self)
+--            return "of " .. self.status.tests - 1
+--        end,
+--    },
+--}
+
+-- FileName and Friends
+
+--local Align = { provider = "%=" }
+local Align = { provider = "%=", hl = { bg = colors.bg } }
+local Space = { provider = " ", hl = { bg = colors.bg } }
+local fill = { provider = "%=", hl = { bg = colors.nobg } }
+--local LeftSep = { provider = ""  hl = { fg = colors.bg } }
+--local RightSep = { provider = "" hl = { fg = colors.bg }}
+
+local FileNameBlock = {
+	-- let's first set up some attributes needed by this component and it's children
+	init = function(self)
+		self.filename = vim.api.nvim_buf_get_name(0)
+	end,
+	--hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+	hl = { bg = colors.bg },
+}
+-- We can now define some children separately and add them later
+--
+
+local FileIcon = {
+	init = function(self)
+		local filename = self.filename
+		local extension = vim.fn.fnamemodify(filename, ":e")
+		self.icon, self.icon_color =
+			require("nvim-web-devicons").get_icon_color(filename, extension, { default = true })
+	end,
+	provider = function(self)
+		return self.icon and (self.icon .. " ")
+	end,
+	hl = function(self)
+		--return { fg = self.icon_color }
+		return { fg = self.icon_color, bg = colors.bg }
+	end,
+}
+
+local FileName = {
+	provider = function(self)
+		-- first, trim the pattern relative to the current directory. For other
+		-- options, see :h filename-modifers
+		local filename = vim.fn.fnamemodify(self.filename, ":.")
+		if filename == "" then
+			return "[No Name]"
+		end
+		-- now, if the filename would occupy more than 1/4th of the available
+		-- space, we trim the file path to its initials
+		-- See Flexible Components section below for dynamic truncation
+		if not conditions.width_percent_below(#filename, 0.25) then
+			filename = vim.fn.pathshorten(filename)
+		end
+		return filename
+	end,
+	--hl = { fg = utils.get_highlight("Directory").fg, bg = colors.bg },
+	hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+}
+
+local FileFlags = {
+	{
+		provider = function()
+			if vim.bo.modified then
+				return " [+]"
+			end
+		end,
+		hl = { fg = colors.green, bg = colors.bg },
+	},
+	{
+		provider = function()
+			if not vim.bo.modifiable or vim.bo.readonly then
+				return ""
+			end
+		end,
+		--hl = { fg = colors.orange },
+		hl = { fg = colors.orange, bold = true, bg = colors.bg },
+	},
+}
+-- Now, let's say that we want the filename color to change if the buffer is
+-- modified. Of course, we could do that directly using the FileName.hl field,
+-- but we'll see how easy it is to alter existing components using a "modifier"
+-- component
+
+local FileNameModifer = {
+	hl = function()
+		if vim.bo.modified then
+			-- use `force` because we need to override the child's hl foreground
+			--return { fg = "cyan", bold = true, force = true }
+			return { fg = "blue", bold = true, force = true, bg = colors.bg }
+		end
+	end,
+}
+
+-- FileType, FileEncoding and FileFormat
+local FileType = {
+	provider = function()
+		--	return string.upper(vim.bo.filetype)
+		--end,
+		----hl = { fg = utils.get_highlight("Type").fg, bold = true },
+		--hl = { fg = utils.get_highlight("Type").fg, bold = true, bg = colors.bg },
+		return vim.bo.filetype
+	end,
+	hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+}
+
+--local FileEncoding = {
+--	provider = function()
+--		local enc = (vim.bo.fenc ~= "" and vim.bo.fenc) or vim.o.enc -- :h 'enc'
+--		return enc ~= "utf-8" and enc:upper()
+--	end,
+--}
+local FileEncoding = {
+	Space,
+	provider = function()
+		local enc = (vim.bo.fenc ~= "" and vim.bo.fenc) or vim.o.enc -- :h 'enc'
+		return enc:upper()
+	end,
+	--hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+	hl = { bg = colors.bg },
+}
+
+local FileFormat = {
+	provider = function()
+		local fmt = vim.bo.fileformat
+		return fmt ~= "unix" and fmt:upper()
+	end,
+	hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+}
+
+-- FileSize and FileLastModified
+local FileSize = {
+	provider = function()
+		-- stackoverflow, compute human readable file size
+		local suffix = { "b", "k", "M", "G", "T", "P", "E" }
+		local fsize = vim.fn.getfsize(vim.api.nvim_buf_get_name(0))
+		fsize = (fsize < 0 and 0) or fsize
+		if fsize < 1024 then
+			return fsize .. suffix[1]
+		end
+		local i = math.floor((math.log(fsize) / math.log(1024)))
+		return string.format("%.2g%s", fsize / math.pow(1024, i), suffix[i + 1])
+	end,
+	hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+}
+
+local FileLastModified = {
+	-- did you know? Vim is full of functions!
+	provider = function()
+		local ftime = vim.fn.getftime(vim.api.nvim_buf_get_name(0))
+		return (ftime > 0) and os.date("%c", ftime)
+	end,
+	hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+}
+
+-- Spell
+-- Add indicator when spell is set!
+local Spell = {
+	condition = function()
+		return vim.wo.spell
+	end,
+	provider = "SPELL ",
+	hl = { bold = true, fg = "orange" },
+}
+
+-- Cursor position: Ruler and ScrollBar
+-- We're getting minimalists here!
+local Ruler = {
+	-- We're getting minimalists here!
+	-- %l = current line number
+	-- %L = number of lines in the buffer
+	-- %c = column number
+	-- %P = percentage through file of displayed window
+	provider = "%3(%2l%):%c %P",
+	--provider = "%7(%l/%3L%):%2c %P",
+	--provider = "%3(%P%)",
+	--provider = "%7(%l/%3L%):%2c %P",
+	--provider = "%7 %p%% Ln %l, Col %c",
+	hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+}
+--local ScrollBar = {
+--	static = {
+--		--sbar = { "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█" },
+--		sbar = { "🭶", "🭷", "🭸", "🭹", "🭺", "🭻" },
+--	},
+--	provider = function(self)
+--		local curr_line = vim.api.nvim_win_get_cursor(0)[1]
+--		local lines = vim.api.nvim_buf_line_count(0)
+--		local i = math.floor((curr_line - 1) / lines * #self.sbar) + 1
+--		return string.rep(self.sbar[i], 2)
+--	end,
+--	--hl = { fg = "blue", bg = "bright_bg" },
+--	hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+--}
+local WordCount = {
+	condition = function()
+		return conditions.buffer_matches({
+			filetype = {
+				"markdown",
+				"txt",
+				"vimwiki",
+			},
+		})
+	end,
+	Space,
+	{
+		provider = function()
+			return "W:" .. vim.fn.wordcount().words
+		end,
+	},
+}
+
+local Position = {
+	Space,
+	{ provider = "%l:%c" },
+	hl = { bg = colors.bg },
+}
+
+local Percentage = {
+	Space,
+	{ provider = "%p%%" },
+	hl = { bg = colors.bg },
+}
+-- Working Directory
+local WorkDir = {
+	provider = function(self)
+		self.icon = (vim.fn.haslocaldir(0) == 1 and "l" or "g") .. " " .. " "
+		local cwd = vim.fn.getcwd(0)
+		self.cwd = vim.fn.fnamemodify(cwd, ":~")
+	end,
+	--hl = { fg = "blue", bold = true },
+	hl = { fg = colors.blue, bold = true, bg = colors.bg },
+
+	utils.make_flexible_component(1, {
+		-- evaluates to the full-lenth path
+		provider = function(self)
+			local trail = self.cwd:sub(-1) == "/" and "" or "/"
+			return self.icon .. self.cwd .. trail .. " "
+		end,
+	}, {
+		-- evaluates to the shortened path
+		provider = function(self)
+			local cwd = vim.fn.pathshorten(self.cwd)
+			local trail = self.cwd:sub(-1) == "/" and "" or "/"
+			return self.icon .. cwd .. trail .. " "
+		end,
+	}, {
+		-- evaluates to "", hiding the component
+		provider = "",
+	}),
+}
+
+-- Terminal Name
+-- Special handling of the built-in terminal bufname. See conditional statuslines below to see an example of dedicated statusline for terminals!
+
+local TerminalName = {
+	-- we could add a condition to check that buftype == 'terminal'
+	-- or we could do that later (see #conditional-statuslines below)
+	provider = function()
+		local tname, _ = vim.api.nvim_buf_get_name(0):gsub(".*:", "")
+		return " " .. tname
+	end,
+	--hl = { fg = "blue", bold = true },
+	hl = { bold = true, bg = colors.bg },
+}
+
+-- Snippets Indicator
+-- This requires ultisnips
+--local Snippets = {
+--    -- check that we are in insert or select mode
+--    condition = function()
+--        return vim.tbl_contains({'s', 'i'}, vim.fn.mode())
+--    end,
+--    provider = function()
+--        local forward = (vim.fn["UltiSnips#CanJumpForwards"]() == 1) and "" or ""
+--        local backward = (vim.fn["UltiSnips#CanJumpBackwards"]() == 1) and " " or ""
+--        return backward .. forward
+--    end,
+--    hl = { fg = "red", bold = true },
+--}
+
+-- let's add the children to our FileNameBlock component
+--FileNameBlock = utils.insert(
+--	FileNameBlock,
+--FileEncoding,
+--Space,
+--FileIcon,
+--FileType,
+--FileLastModified,
+--FileSize,
+--FileFormat,
+--FileNameModifer,
+--	unpack(FileFlags),
+--	{ provider = "%<" } -- this means that the statusline is cut here when there's not enough space
+--)
+-- let's add the children to our FileNameBlock component
+FileNameBlock = utils.insert(
+	FileNameBlock,
+	FileIcon,
+	utils.insert(FileNameModifer, FileName), -- a new table where FileName is a child of FileNameModifier
+	unpack(FileFlags), -- A small optimisation, since their parent does nothing
+	{ provider = "%<" } -- this means that the statusline is cut here when there's not enough space
+)
+
+local FileInfoBlock = {
+	-- let's first set up some attributes needed by this component and it's children
+	init = function(self)
+		self.filename = vim.api.nvim_buf_get_name(0)
+	end,
+}
+
+FileInfoBlock = utils.insert(
+	FileInfoBlock,
+	FileEncoding,
+	Space,
+	FileIcon,
+	FileType,
+	{ provider = "%<" } -- this means that the statusline is cut here when there's not enough space
+)
+--FileNameBlock = utils.insert(
+--	FileNameBlock,
+--	FileIcon,
+--	utils.insert(FileNameModifer, FileName), -- a new table where FileName is a child of FileNameModifier
+--	unpack(FileFlags), -- A small optimisation, since their parent does nothing
+--	{ provider = "%<" } -- this means that the statusline is cut here when there's not enough space
+--)
+
+-- Statusline
+
+local Surrr = {
+	utils.surround({ "", "" }, "red", {
+		utils.surround({ "", "" }, "green", utils.surround({ "", "" }, "blue", { provider = "heyya" })),
+		{ provider = "Normal" },
+	}),
+}
+--ViMode = utils.surround({ "", "" }, "bright_bg", { ViMode, Snippets })
+ViMode = utils.surround({ "", "" }, function(self)
+	return self:mode_color()
+end, { ViMode, hl = { fg = utils.get_highlight("statusline").bg, force = true } })
+
+--ViMode = utils.surround({ "◥", "" }, function(self) return self:mode_color() end, {
+--  utils.surround({ "█", "" }, function(self) return self:mode_color() end, utils.surround({ "", "" }, function(self) return self:mode_color() end, { {provider = "normal" }, ViMode, hl = { fg = utils.get_highlight("statusline").bg, force = true } } )),
+--  { provider = "heyya" },
+--  })
+
+--utils.surround({ "█", "█" }, function(self) return self:mode_color() end, { FileNameBlock, hl = { fg = colors.bg, force = true } } ),
+local DefaultStatusline = {
+	ViMode,
+	Space,
+	FileNameBlock,
+	Space,
+	Git,
+	Space,
+	Diagnostics,
+	Align,
+	Navic,
+	DAPMessages,
+	Align,
+	Space,
+	FileInfoBlock,
+	Space,
+	WordCount,
+	Ruler,
+	Space,
+	--Position,
+	--Percentage,
+	--ScrollBar,
+	--Space,
+	--LSPActive, Space, LSPMessages, Space, UltTest, Space, FileType, Space, Ruler, Space, ScrollBar
+}
+
+--local InactiveStatusline = {
+--	condition = conditions.is_not_active,
+--	FileType,
+--	Space,
+--	FileName,
+--	Align,
+--}
+
+local SpecialStatusline = {
+	condition = function()
+		return conditions.buffer_matches({
+			buftype = { "nofile", "prompt", "help", "quickfix" },
+			filetype = { "^git.*", "fugitive" },
+		})
+	end,
+
+	FileType,
+	Space,
+	Align,
+	--FileType, Space, HelpFileName, Align
+}
+
+local TerminalStatusline = {
+
+	condition = function()
+		return conditions.buffer_matches({ buftype = { "terminal" } })
+	end,
+
+	hl = { bg = "dark_red" },
+
+	-- Quickly add a condition to the ViMode to only show it when buffer is active!
+	{ condition = conditions.is_active, ViMode, Space },
+	FileType,
+	Space,
+	TerminalName,
+	Align,
+}
+
+--local StatusLines = {
+--
+--	hl = function()
+--		if conditions.is_active() then
+--			return "StatusLine"
+--		else
+--			return "StatusLineNC"
+--		end
+--	end,
+--
+--	-- the first statusline with no condition, or which condition returns true is used.
+--	-- think of it as a switch case with breaks to stop fallthrough.
+--	fallthrough = false,
+--
+--	SpecialStatusline,
+--	TerminalStatusline,
+--	--InactiveStatusline,
+--	DefaultStatusline,
+--}
+local StatusLines = {
+
+	hl = function()
+		if conditions.is_active() then
+			return "StatusLine"
+		else
+			return "StatusLineNC"
+		end
+	end,
+
+	static = {
+		mode_colors_map = {
+			n = colors.blue,
+			i = colors.green,
+			v = colors.purple,
+			V = colors.purple,
+			[""] = colors.purple,
+			c = colors.red,
+			s = colors.purple,
+			S = colors.purple,
+			[""] = colors.purple,
+			R = colors.orange,
+			r = colors.orange,
+			["!"] = colors.red,
+			t = colors.red,
+		},
+		mode_color = function(self)
+			local mode = conditions.is_active() and vim.fn.mode() or "n"
+			return self.mode_colors_map[mode]
+		end,
+	},
+	fallthrough = false,
+
+	SpecialStatusline,
+	TerminalStatusline,
+	--InactiveStatusline,
+	DefaultStatusline,
+}
+--hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+--	hl = { bg = colors.bg },
+--require("heirline").setup(StatusLines)
+-- we're done.
+
+--local FelineStyle = {
+--
+--    -- stop at child where buftype/filetype/bufname matches
+--    fallthrough = false,
+--
+--    {   -- Identify the buftype/filetype/bufname first
+--        condtion = function()
+--            return conditions.buffer_matches({...})
+--        end,
+--
+--        -- Evaluate only the "active" or "inactive" child
+--        fallthrough = false,
+--
+--        {   -- If it's the current window, display some components
+--            condition = conditions.is_active
+--            {...} --
+--        },
+--        {   -- Otherwise, display some other components
+--            {...} --
+--        }
+--    },
+--    {   -- this block can be exactly as the one above for a different kind of
+--        -- buffer
+--        ...
+--    }
+--}
+
+-- WinBar
+
+vim.api.nvim_create_autocmd("User", {
+	pattern = "HeirlineInitWinbar",
+	callback = function(args)
+		local buf = args.buf
+		local buftype = vim.tbl_contains({ "prompt", "nofile", "help", "quickfix" }, vim.bo[buf].buftype)
+		local filetype = vim.tbl_contains({ "gitcommit", "fugitive" }, vim.bo[buf].filetype)
+		if buftype or filetype then
+			vim.opt_local.winbar = nil
+		end
+	end,
+})
+local active_middle_segment = { --{{{
+	--	provider = "%999X  %X",
+
+	--provider = function(self)
+	--	--return " %999X  %999X "
+	--	return " %2("..self.mode_names[self.mode].."%)"
+	--	--
+	--	--
+	--	--
+	--end,
+	fallthrough = false,
+	{ -- Hide the winbar for special buffers
+		condition = function()
+			return conditions.buffer_matches({
+				buftype = { "nofile", "prompt", "help", "quickfix" },
+				filetype = { "^git.*", "fugitive" },
+			})
+		end,
+		init = function()
+			vim.opt_local.winbar = nil
+		end,
+	},
+	static = {
+		mode_colors_map = {
+			n = colors.blue,
+			i = colors.green,
+			v = colors.purple,
+			V = colors.purple,
+			[""] = colors.purple,
+			c = colors.red,
+			s = colors.purple,
+			S = colors.purple,
+			[""] = colors.purple,
+			R = colors.orange,
+			r = colors.orange,
+			["!"] = colors.red,
+			t = colors.red,
+		},
+		mode_color = function(self)
+			local mode = conditions.is_active() and vim.fn.mode() or "n"
+			return self.mode_colors_map[mode]
+		end,
+		provider = "%f",
+		hl = function(self)
+			local color = self:mode_color() -- here!
+			return { fg = color }
+		end,
+		-- self.filename will be defined later, just keep looking at the example!
+	},
+	{ -- A special winbar for terminals
+		condition = function()
+			return conditions.buffer_matches({ buftype = { "terminal" } })
+		end,
+		utils.surround({ "", "" }, "dark_red", {
+			FileType,
+			Space,
+			TerminalName,
+		}),
+	},
+	{ -- An inactive winbar for regular files
+		condition = function()
+			return not conditions.is_active()
+		end,
+		--utils.surround({ "", "" }, "bright_bg", { hl = { fg = "gray", force = true }, FileNameBlock }),
+		--utils.surround({ "", "" }, function(self) return self:mode_color() end, { FileNameBlock, hl = { fg = colors.bg, force = true } } ),
+	},
+	-- A winbar for regular files
+	--utils.surround({ "", "" }, "bright_bg", FileNameBlock),
+	--█🙼🙽🙼█⮘██⮚
+	--utils.surround({ "", "" }, function(self) return self:mode_color() end, { FileNameBlock, hl = function(self)
+	--    local color = self:mode_color() -- here!
+	--    return { bg = color, bold = true, force = true }
+	--end,
+	--}),
+	--utils.surround({ "", "" }, function(self) return self:mode_color() end, FileNameBlock),
+}
+
+--utils.surround({ "", "" }, function(self) return self:mode_color() end, { active_middle_segment, hl = { fg = colors.bg, force = true } })
+
+local WinBars = {
+	fill,
+	active_middle_segment,
+	fill,
+}
+--	--utils.surround({ " ", " " }, colors.nobg, { fill, active_middle_segment, fill })
+--	--static = {
+--	--    mode_colors_map = {
+--	--	      n = colors.blue,
+--	--	      i = colors.green,
+--	--	      v = colors.purple,
+--	--	      V = colors.purple,
+--	--	      [""] = colors.purple,
+--	--	      c = colors.red,
+--	--	      s = colors.purple,
+--	--	      S = colors.purple,
+--	--	      [""] = colors.purple,
+--	--	      R = colors.orange,
+--	--	      r = colors.orange,
+--	--	      ["!"] = colors.red,
+--	--	      t = colors.red,
+--	--    },
+--	--    mode_color = function(self)
+--	--        local mode = conditions.is_active() and vim.fn.mode() or "n"
+--	--        return self.mode_colors_map[mode]
+--	--    end,
+--	--},
+--	--utils.surround({ " ", " " }, colors.nobg, { active_middle_segment, hl = function(self)
+--	--    local color = self:mode_color() -- here!
+--	--    return { bg = color, bold = true, force = true }
+--	--end,
+--	--})
+--}
+on_click = {
+	-- get the window id of the window in which the component was evaluated
+	minwid = function()
+		return vim.api.nvim_get_current_win()
+	end,
+	callback = function(_, minwid)
+		-- winid is the window id of the window the component was clicked from
+		local winid = minwid
+		-- do something with the window id, e.g.:
+		local buf = vim.api.nvim_win_get_buf(winid)
+		-- ...
+	end,
+}
+
+local CloseButton = {
+	condition = function(self)
+		return not vim.bo.modified
+	end,
+	-- a small performance improvement:
+	-- re register the component callback only on layout/buffer changes.
+	update = { "WinNew", "WinClosed", "BufEnter" },
+	{ provider = " " },
+	{
+		provider = "",
+		hl = { fg = "gray" },
+		on_click = {
+			minwid = function()
+				return vim.api.nvim_get_current_win()
+			end,
+			callback = function(_, minwid)
+				vim.api.nvim_win_close(minwid, true)
+			end,
+			name = "heirline_winbar_close_button",
+		},
+	},
+}
+
+-- Use it anywhere!
+--local WinBarFileName = utils.surround({ "", "" }, "bright_bg", {
+--	hl = function()
+--		if not conditions.is_active() then
+--			return { fg = "gray", force = true }
+--		end
+--	end,
+--	FileNameBlock,
+--	Space,
+--	CloseButton,
+--})
+
+--local WinBars = {
+--	-- init = utils.pick_child_on_condition,
+--	fallthrough = false,
+--	{
+--		condition = function()
+--			return conditions.buffer_matches({
+--				buftype = { "nofile", "prompt", "help", "quickfix" },
+--				filetype = { "^git.*", "fugitive" },
+--			})
+--		end,
+--		init = function()
+--			vim.opt_local.winbar = nil
+--		end,
+--	},
+--	{
+--		condition = function()
+--			return conditions.buffer_matches({ buftype = { "terminal" } })
+--		end,
+--		utils.surround({ "", "" }, "dark_red", {
+--			FileType,
+--			Space,
+--			TerminalName,
+--			CloseButton,
+--		}),
+--	},
+--	utils.surround({ "", "" }, "bright_bg", {
+--		hl = function()
+--			if conditions.is_not_active() then
+--				return { fg = "gray", force = true }
+--			end
+--		end,
+--
+--		FileNameBlock,
+--		CloseButton,
+--	}),
+--}
+
+-- TabLine
+--local TabLine ={
+--    hl = { bg = colors.bg },
+--}
+local TablineBufnr = {
+	provider = function(self)
+		return tostring(self.bufnr) .. ". "
+	end,
+	--hl = "Comment",
+	--hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+	hl = { fg = utils.get_highlight("Statusline").fg, bold = true },
+}
+
+-- we redefine the filename component, as we probably only want the tail and not the relative path
+local TablineFileName = {
+	provider = function(self)
+		-- self.filename will be defined later, just keep looking at the example!
+		local filename = self.filename
+		filename = filename == "" and "[No Name]" or vim.fn.fnamemodify(filename, ":t")
+		return filename
+	end,
+	hl = function(self)
+		return { bold = self.is_active or self.is_visible, italic = true }
+	end,
+}
+
+-- this looks exactly like the FileFlags component that we saw in
+-- #crash-course-part-ii-filename-and-friends, but we are indexing the bufnr explicitly
+-- also, we are adding a nice icon for terminal buffers.
+--local TablineFileFlags = {
+--	{
+--		condition = function(self)
+--			return vim.api.nvim_buf_get_option(self.bufnr, "modified")
+--		end,
+--		provider = "[+]",
+--		--hl = { fg = colors.green },
+--		hl = { fg = colors.green, bold = true, bg = colors.bg },
+--	},
+--	{
+--		condition = function(self)
+--			return not vim.api.nvim_buf_get_option(self.bufnr, "modifiable")
+--				or vim.api.nvim_buf_get_option(self.bufnr, "readonly")
+--		end,
+--		provider = function(self)
+--			if vim.api.nvim_buf_get_option(self.bufnr, "buftype") == "terminal" then
+--				return "  "
+--			else
+--				return ""
+--			end
+--		end,
+--		hl = { fg = "orange", bg = colors.bg },
+--	},
+--}
+
+local TablineFileFlags = {
+	{
+		provider = function(self)
+			if vim.bo[self.bufnr].modified then
+				return " [+]"
+			end
+		end,
+		hl = { fg = colors.green },
+	},
+	{
+		provider = function(self)
+			if not vim.bo[self.bufnr].modifiable or vim.bo[self.bufnr].readonly then
+				return ""
+			end
+		end,
+		hl = { fg = "orange" },
+	},
+}
+
+local TablineFileIcon = {
+	init = function(self)
+		local filename = self.filename
+		local extension = vim.fn.fnamemodify(filename, ":e")
+		self.icon, self.icon_color =
+			require("nvim-web-devicons").get_icon_color(filename, extension, { default = true })
+	end,
+	provider = function(self)
+		return self.icon and (" " .. self.icon .. " ")
+	end,
+	hl = function(self)
+		return { fg = self.icon_color }
+	end,
+}
+
+-- Here the filename block finally comes together
+local TablineFileNameBlock = {
+	init = function(self)
+		self.filename = vim.api.nvim_buf_get_name(self.bufnr)
+	end,
+	hl = function(self)
+		if self.is_active then
+			return "TabLineSel"
+		-- why not?
+		--elseif not vim.api.nvim_buf_is_loaded(self.bufnr) then
+		--return { fg = "gray", bg = colors.bg }
+		else
+			return "TabLine"
+		end
+	end,
+	on_click = {
+		callback = function(_, minwid, _, button)
+			if button == "m" then -- close on mouse middle click
+				vim.api.nvim_buf_delete(minwid, { force = false })
+			else
+				vim.api.nvim_win_set_buf(0, minwid)
+			end
+		end,
+		minwid = function(self)
+			return self.bufnr
+		end,
+		name = "heirline_tabline_buffer_callback",
+	},
+	TablineBufnr,
+	--FileIcon, -- turns out the version defined in #crash-course-part-ii-filename-and-friends can be reutilized as is here!
+	TablineFileIcon,
+	TablineFileName,
+	TablineFileFlags,
+}
+
+-- a nice "x" button to close the buffer
+local TablineCloseButton = {
+	condition = function(self)
+		return not vim.api.nvim_buf_get_option(self.bufnr, "modified")
+	end,
+	{ provider = " " },
+	{
+		provider = " ",
+		--hl = { fg = "red", bg = colors.bg },
+		hl = { fg = "red" },
+		on_click = {
+			callback = function(_, minwid)
+				vim.api.nvim_buf_delete(minwid, { force = false })
+			end,
+			minwid = function(self)
+				return self.bufnr
+			end,
+			name = "heirline_tabline_close_buffer_callback",
+		},
+	},
+}
+
+-- The final touch!
+--local TablineBufferBlock = utils.surround({ "", "", hl = { bg =colors.bg } }, function(self)
+--	if self.is_active then
+--		return utils.get_highlight("TabLineSel").fg, utils.get_highlight("TabLineSel").bg
+--	else
+--		return utils.get_highlight("TabLine").fg, utils.get_highlight("TabLine").bg
+--	end
+----end, { TabLine, TablineFileNameBlock, TablineCloseButton })
+--end, { TablineFileNameBlock, TablineCloseButton })
+
+--local TablineBufferBlock = utils.surround({ "█", "█" }, "bg", {
+--	hl = function()
+--		if not conditions.is_active() then
+--			return { fg = "gray", force = true, bg = colors.bg }
+--		end
+--	end,
+--	TablineFileNameBlock,
+--	TablineCloseButton,
+--})
+--local TablineBufferBlock = utils.surround({ "█", "█" },
+--  { hl = function(self)
+--		local mode = self.mode:sub(1, 1) -- get only the first mode character
+--		--return { fg = self.mode_colors[mode], bold = true, }
+--		return { bg = self.mode_colors[mode], fg = colors.bg, bold = true }
+--	end, },
+--{ TablineFileNameBlock, TablineCloseButton, { hl = ViMode }, })
+
+--local TablineBufferBlock = {
+--	init = function(self)
+--
+--		self.mode = vim.fn.mode(1) -- :h mode()
+--
+--			vim.api.nvim_create_autocmd("ModeChanged", {
+--				pattern = "*:*o",
+--				command = "redrawstatus",
+--			})
+--			self.once = true
+--		end,
+--	static = {
+--		mode_colors = {
+--			n = colors.blue,
+--			i = colors.green,
+--			v = colors.purple,
+--			V = colors.purple,
+--			[""] = colors.purple,
+--			c = colors.red,
+--			s = colors.purple,
+--			S = colors.purple,
+--			[""] = colors.purple,
+--			R = colors.orange,
+--			r = colors.orange,
+--			["!"] = colors.red,
+--			t = colors.red,
+--		},
+--  },
+--	hl = function(self)
+--  if self.is_active then
+--		local mode = self.mode:sub(1, 1) -- get only the first mode character
+--		--return { fg = self.mode_colors[mode], bold = true, }
+--		return { bg = self.mode_colors[mode], fg = colors.bg, bold = true }
+--  else
+--		return utils.get_highlight("TabLine").bg
+--	end
+--  end,
+--	update = {
+--		"ModeChanged",
+--	}, --optional
+--  { TablineFileNameBlock, TablineCloseButton }
+--}
+
+--local TabLineSel = {
+--  hl = { bg = self.mode_colors[mode], fg = colors.bg, bold = true }
+--}
+--local ViMode2 = {
+--	init = function(self)
+--        self.mode = vim.fn.mode()
+--    end,
+--    static = {
+--        mode_colors = {
+--            n = "red",
+--            i = "green",
+--            v = "blue",
+--            c = "orange"
+--
+--        }
+--    },
+--    provider = function(self)
+--        return string.upper(self.mode)
+--    end,
+--    hl = function(self)
+--        return { fg = self.mode_colors[self.mode], bold = true, }
+--    end
+--}
+--local surrr = {
+--    utils.surround({ "", "" }, "red", {
+--        utils.surround({ "", "" }, "green", utils.surround({ "", "" }, "blue", { provider = "heyya" })),
+--        { provider = "Normal" },
+--    }),
+--}
+--local statusline = ViMode
+
+--local TablineBufferBlock = utils.surround({ "", "" }, function(self)
+--	if self.is_active then
+--		--self.mode = vim.fn.mode(1) -- :h mode()
+--
+--    --return utils.get_highlight(vim.api.nvim_get_mode().mode).bg
+--		return utils.get_highlight("TabLineSel").bg
+--		--return utils.get_highlight("Normal").bg
+--		--local mode = self.mode:sub(1, 1) -- get only the first mode character
+--    --return { bg = TabLineSel, fg = colors.bg, bold = true }
+--	else
+--		return utils.get_highlight("TabLine").bg
+--	end
+--end, { TablineFileNameBlock, TablineCloseButton })
+
+local TablineBufferBlock = utils.surround({ "█", "▎" }, function(self)
+	--local TablineBufferBlock = utils.surround({ "█", "█" }, function(self)
+	if self.is_active then
+		return utils.get_highlight("TabLineSel").bg
+	else
+		return utils.get_highlight("TabLine").bg
+	end
+end, { TablineFileNameBlock, TablineCloseButton })
+--█
+--local TablineBufferBlock = {
+--	init = function(self)
+--		self.mode = vim.fn.mode()
+--	end,
+--	static = {
+--		mode_colors = {
+--			n = colors.blue,
+--			i = colors.green,
+--			v = colors.purple,
+--			V = colors.purple,
+--			[""] = colors.purple,
+--			c = colors.red,
+--			s = colors.purple,
+--			S = colors.purple,
+--			[""] = colors.purple,
+--			R = colors.orange,
+--			r = colors.orange,
+--			["!"] = colors.red,
+--			t = colors.red,
+--		},
+--	},
+--	hl = function(self)
+--		if conditions.is_active() then
+--			return { bg = self.mode_colors[self.mode], fg = colors.bg, bold = true }
+--		else
+--			return utils.get_highlight("Tabline").bg
+--		end
+--	end,
+--	update = {
+--		"ModeChanged",
+--	}, --optional
+--	{ TablineFileNameBlock, TablineCloseButton },
+--}
+
+--local TablineBufferBlock = {
+--    static = {
+--        mode_colors_map = {
+--			      n = colors.blue,
+--			      i = colors.green,
+--			      v = colors.purple,
+--			      V = colors.purple,
+--			      [""] = colors.purple,
+--			      c = colors.red,
+--			      s = colors.purple,
+--			      S = colors.purple,
+--			      [""] = colors.purple,
+--			      R = colors.orange,
+--			      r = colors.orange,
+--			      ["!"] = colors.red,
+--			      t = colors.red,
+--        },
+--        mode_color = function(self)
+--            local mode = conditions.is_active() and vim.fn.mode() or "n"
+--            return self.mode_colors_map[mode]
+--        end,
+--    },
+--	{ -- A special winbar for terminals
+--		condition = function()
+--			return conditions.buffer_matches({ buftype = { "terminal" } })
+--		end,
+--		utils.surround({ "", "" }, "dark_red", {
+--			FileType,
+--			Space,
+--			TerminalName,
+--		}),
+--	},
+--	{ -- An inactive winbar for regular files
+--		condition = function()
+--			return conditions.is_not_active()
+--    end,
+--  utils.surround({ "█", "█" }, function() return utils.get_highlight("TabLine").bg end, { TablineFileNameBlock, TablineCloseButton } )
+--  },
+--  {
+--		condition = function()
+--			return conditions.is_active()
+--    end,
+--  utils.surround({ "█", "█" }, function(self) return self:mode_color() end, { TablineFileNameBlock, TablineCloseButton, hl = { fg = colors.bg, force = true } } )
+--  },
+--function()
+--if self.is_active then
+--utils.surround({ "", "" }, "bright_bg", { hl = { fg = "gray", force = true }, FileNameBlock }),
+--utils.surround({ "", "" }, function(self) return self:mode_color() end, { FileNameBlock, hl = { fg = colors.bg, force = true } } ),
+--utils.surround({ "█", "█" }, function() return utils.get_highlight("TabLine").bg end, { TablineFileNameBlock, TablineCloseButton, hl = { fg = colors.bg, force = true } } ),
+--}
+--ViMode = utils.surround({ "", "" }, function(self)
+--    if self.is_active then
+--      return self:mode_color()
+--    else
+--      return utils.get_highlight("TabLine").bg
+--    end
+--    end, { ViMode, hl = { fg = utils.get_highlight("statusline").bg, force = true } } )
+--
+----}
+--local TablineBufferBlock = {
+--  ViMode,
+--  TablineFileName,
+--  TablineCloseButton,
+--}
+-- A winbar for regular files
+--utils.surround({ "", "" }, "bright_bg", FileNameBlock),
+--utils.surround({ "", "" }, function(self) return self:mode_color() end, FileNameBlock),
+local BufferLine = utils.make_buflist(
+	TablineBufferBlock,
+	{ provider = "", hl = { fg = "gray" } }, -- left truncation, optional (defaults to "<")
+	{ provider = "", hl = { fg = "gray" } } -- right trunctation, also optional (defaults to ...... yep, ">")
+	--{ provider = "", hl = { fg = "gray" } }, -- left truncation, optional (defaults to "<")
+	--{ provider = "", hl = { fg = "gray" } } -- right trunctation, also optional (defaults to ...... yep, ">")
+	-- by the way, open a lot of buffers and try clicking them ;)
+)
+
+--	if self.is_active then
+--		return utils.get_highlight("TabLineSel").bg
+--	else
+--		return utils.get_highlight("TabLine").bg
+--	end
+--end, { TablineFileNameBlock, TablineCloseButton, } )
+-- TabList
+local Tabpage = {
+	provider = function(self)
+		return "%" .. self.tabnr .. "T " .. self.tabnr .. " %T"
+	end,
+	hl = function(self)
+		if not self.is_active then
+			return "TabLine"
+		else
+			return "TabLineSel"
+		end
+	end,
+}
+
+local TabpageClose = {
+	provider = "%999X  %X",
+	--hl = "TabLine",
+	hl = { fg = colors.red, bg = colors.bg },
+}
+
+local TabPages = {
+	-- only show this component if there's 2 or more tabpages
+	condition = function()
+		return #vim.api.nvim_list_tabpages() >= 2
+	end,
+	{ provider = "%=" },
+	utils.make_tablist(Tabpage),
+	TabpageClose,
+}
+
+-- TabLineOffset
+local TabLineOffset = {
+	condition = function(self)
+		local win = vim.api.nvim_tabpage_list_wins(0)[1]
+		local bufnr = vim.api.nvim_win_get_buf(win)
+		self.winid = win
+
+		if vim.bo[bufnr].filetype == "NvimTree" then
+			self.title = "NvimTree"
+			return true
+			-- elseif vim.bo[bufnr].filetype == "TagBar" then
+			--     ...
+		end
+	end,
+
+	provider = function(self)
+		local title = self.title
+		local width = vim.api.nvim_win_get_width(self.winid)
+		local pad = math.ceil((width - #title) / 2)
+		return string.rep(" ", pad) .. title .. string.rep(" ", pad)
+	end,
+
+	hl = function(self)
+		if vim.api.nvim_get_current_win() == self.winid then
+			return "TablineSel"
+		else
+			return "Tabline"
+		end
+	end,
+}
+
+local TabLine = {
+	--hl = { bg = colors.bg },
+	fallthrough = false,
+	TabLineOffset,
+	BufferLine,
+	TabPages,
+}
+
+vim.cmd([[au FileType * if index(['wipe', 'delete', 'unload'], &bufhidden) >= 0 | set nobuflisted | endif]])
+--local StatusLines = {
+--
+--	hl = function()
+--		if conditions.is_active() then
+--			return "StatusLine"
+--		else
+--			return "StatusLineNC"
+--		end
+--	end,
+--
+--	-- the first statusline with no condition, or which condition returns true is used.
+--	-- think of it as a switch case with breaks to stop fallthrough.
+--	fallthrough = false,
+--
+--	SpecialStatusline,
+--	TerminalStatusline,
+--	--InactiveStatusline,
+--	DefaultStatusline,
+--}
+--
+--	--hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+--	hl = { bg = colors.bg },
+--local TabLine ={
+--    hl = { bg = colors.bg },
+--}
+-- Window Close button: Let the callback know from which window it was clicked from!
+-- The following is the recommended way of achieving that:
+require("heirline").setup(StatusLines, WinBars, TabLine)
+
+-- Yep, with heirline we're driving manual!
+vim.cmd([[au FileType * if index(['wipe', 'delete', 'unload'], &bufhidden) >= 0 | set nobuflisted | endif]])
+
+vim.api.nvim_create_augroup("Heirline", { clear = true })
+vim.api.nvim_create_autocmd("ColorScheme", {
+	callback = function()
+		local colors = setup_colors()
+		utils.on_colorscheme(colors)
+	end,
+	group = "Heirline",
+})
+
+local function get_bufs()
+	return vim.tbl_filter(function(bufnr)
+		return vim.api.nvim_buf_is_loaded(bufnr) and vim.bo[bufnr].buflisted
+	end, vim.api.nvim_list_bufs())
+end
+
+local function goto_buf(index)
+	local bufs = get_bufs()
+	if index > #bufs then
+		index = #bufs
+	end
+	vim.api.nvim_win_set_buf(0, bufs[index])
+end
+
+local function addKey(key, index)
+	vim.keymap.set("", "<A-" .. key .. ">", function()
+		goto_buf(index)
+	end, { noremap = true, silent = true })
+end
+
+for i = 1, 9 do
+	addKey(i, i)
+end
+addKey("0", 10)
+-- Theming
+--local function setup_colors()
+--    return {
+--        bright_bg = utils.get_highlight("Folded").bg,
+--        bright_fg = utils.get_highlight("Folded").fg,
+--        red = utils.get_highlight("DiagnosticError").fg,
+--        dark_red = utils.get_highlight("DiffDelete").bg,
+--        green = utils.get_highlight("String").fg,
+--        blue = utils.get_highlight("Function").fg,
+--        gray = utils.get_highlight("NonText").fg,
+--        orange = utils.get_highlight("Constant").fg,
+--        purple = utils.get_highlight("Statement").fg,
+--        cyan = utils.get_highlight("Special").fg,
+--        diag_warn = utils.get_highlight("DiagnosticWarn").fg,
+--        diag_error = utils.get_highlight("DiagnosticError").fg,
+--        diag_hint = utils.get_highlight("DiagnosticHint").fg,
+--        diag_info = utils.get_highlight("DiagnosticInfo").fg,
+--        git_del = utils.get_highlight("diffDeleted").fg,
+--        git_add = utils.get_highlight("diffAdded").fg,
+--        git_change = utils.get_highlight("diffChanged").fg,
+--    }
+--end
+--require('heirline').load_colors(setup_colors())
+--
+--vim.api.nvim_create_augroup("Heirline", { clear = true })
+--vim.api.nvim_create_autocmd("ColorScheme", {
+--    callback = function()
+--        local colors = setup_colors()
+--        utils.on_colorscheme(colors)
+--    end,
+--    group = "Heirline",
+--})