chore(master): release nvim-tree 1.8.0 (#2943)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.editorconfig

@@ -4,9 +4,18 @@ root = true
 insert_final_newline = true
 end_of_line = lf
 
-[*.lua]
-indent_style = space
-indent_size = 2
-
 [nvim-tree-lua.txt]
 max_line_length = 78
+
+[*.lua]
+indent_style = space
+max_line_length = 140
+indent_size = 2
+
+# EmmyLuaCodeStyle specific, see
+# https://github.com/CppCXY/EmmyLuaCodeStyle/blob/master/lua.template.editorconfig
+continuation_indent = 2
+quote_style = double
+call_arg_parentheses = always
+space_before_closure_open_parenthesis = false
+align_continuous_similar_call_args = true

.github/ISSUE_TEMPLATE/nvt-min.lua

@@ -1,12 +1,12 @@
 vim.g.loaded_netrw = 1
 vim.g.loaded_netrwPlugin = 1
 
-vim.cmd [[set runtimepath=$VIMRUNTIME]]
+vim.cmd([[set runtimepath=$VIMRUNTIME]])
-vim.cmd [[set packpath=/tmp/nvt-min/site]]
+vim.cmd([[set packpath=/tmp/nvt-min/site]])
 local package_root = "/tmp/nvt-min/site/pack"
 local install_path = package_root .. "/packer/start/packer.nvim"
 local function load_plugins()
-  require("packer").startup {
+  require("packer").startup({
     {
       "wbthomason/packer.nvim",
       "nvim-tree/nvim-tree.lua",
@@ -18,21 +18,21 @@ local function load_plugins()
       compile_path = install_path .. "/plugin/packer_compiled.lua",
       display = { non_interactive = true },
     },
-  }
+  })
 end
 if vim.fn.isdirectory(install_path) == 0 then
-  print "Installing nvim-tree and dependencies."
+  print("Installing nvim-tree and dependencies.")
-  vim.fn.system { "git", "clone", "--depth=1", "https://github.com/wbthomason/packer.nvim", install_path }
+  vim.fn.system({ "git", "clone", "--depth=1", "https://github.com/wbthomason/packer.nvim", install_path })
 end
 load_plugins()
 require("packer").sync()
-vim.cmd [[autocmd User PackerComplete ++once echo "Ready!" | lua setup()]]
+vim.cmd([[autocmd User PackerComplete ++once echo "Ready!" | lua setup()]])
 vim.opt.termguicolors = true
 vim.opt.cursorline = true
 
 -- MODIFY NVIM-TREE SETTINGS THAT ARE _NECESSARY_ FOR REPRODUCING THE ISSUE
 _G.setup = function()
-  require("nvim-tree").setup {}
+  require("nvim-tree").setup({})
 end
 
 -- UNCOMMENT this block for diagnostics issues, substituting pattern and cmd as appropriate.
@@ -41,7 +41,11 @@ end
 vim.api.nvim_create_autocmd("FileType", {
   pattern = "lua",
   callback = function()
-    vim.lsp.start { cmd = { "lua-language-server" } }
+    vim.lsp.start {
+      name = "my-luals",
+      cmd = { "lua-language-server" },
+      root_dir = vim.loop.cwd(),
+    }
   end,
 })
 ]]

.github/workflows/ci.yml

@@ -38,22 +38,24 @@ jobs:
     runs-on: ubuntu-latest
 
     concurrency:
-      group: ${{ github.workflow }}-${{ matrix.stylua_version }}-${{ github.head_ref || github.ref_name }}
+      group: ${{ github.workflow }}-${{ matrix.emmy_lua_code_style_version }}-${{ github.head_ref || github.ref_name }}
       cancel-in-progress: true
 
     strategy:
       matrix:
-        stylua_version: [ 0.19.1 ]
+        emmy_lua_code_style_version: [ 1.5.6 ]
 
     steps:
       - uses: actions/checkout@v4
 
-      - name: stylua
+      - name: install emmy_lua_code_style
-        uses: JohnnyMorganz/stylua-action@v4
+        run: |
-        with:
+          mkdir -p CodeFormat
-          token: ${{ secrets.GITHUB_TOKEN }}
+          curl -L "https://github.com/CppCXY/EmmyLuaCodeStyle/releases/download/${{ matrix.emmy_lua_code_style_version }}/linux-x64.tar.gz" | tar zx --directory CodeFormat
-          version: ${{ matrix.stylua_version }}
+
-          args: --check lua
+      - run: echo "CodeFormat/linux-x64/bin" >> "$GITHUB_PATH"
+
+      - run: make style
 
       - run: make style-doc
 
@@ -67,7 +69,7 @@ jobs:
     strategy:
       matrix:
         nvim_version: [ stable, nightly ]
-        luals_version: [ 3.10.5 ]
+        luals_version: [ 3.11.0 ]
 
     steps:
       - uses: actions/checkout@v4

.luacheckrc

@@ -1,14 +1,15 @@
--- vim: ft=lua tw=80
+local M = {}
 
 -- Don't report unused self arguments of methods.
-self = false
+M.self = false
 
-ignore = {
+M.ignore = {
   "631",  -- max_line_length
 }
 
 -- Global objects defined by the C code
-globals = {
+M.globals = {
   "vim",
-  "TreeExplorer"
 }
+
+return M

.luarc.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://raw.githubusercontent.com/sumneko/vscode-lua/master/setting/schema.json",
-  "runtime.version": "Lua 5.1",
+  "runtime.version.luals-check-only": "Lua 5.1",
   "workspace": {
     "library": [
       "$VIMRUNTIME/lua/vim",
@@ -33,13 +33,13 @@
       "empty-block": "Any",
       "global-element": "Any",
       "global-in-nil-env": "Any",
-      "incomplete-signature-doc": "None",
+      "incomplete-signature-doc": "Any",
       "inject-field": "Any",
       "invisible": "Any",
       "lowercase-global": "Any",
       "missing-fields": "Any",
       "missing-global-doc": "Any",
-      "missing-local-export-doc": "None",
+      "missing-local-export-doc": "Any",
       "missing-parameter": "Any",
       "missing-return": "Any",
       "missing-return-value": "Any",

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "1.6.1"
+  ".": "1.8.0"
 }

.stylua.toml

@@ -1,6 +0,0 @@
-column_width = 140
-line_endings = "Unix"
-indent_type = "Spaces"
-indent_width = 2
-quote_style = "AutoPreferDouble"
-call_parentheses = "None"

CHANGELOG.md

@@ -1,5 +1,60 @@
 # Changelog
 
+## [1.8.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.7.1...nvim-tree-v1.8.0) (2024-11-09)
+
+
+### Features
+
+* **#2819:** add actions.open_file.relative_path, default enabled, following successful experiment ([#2995](https://github.com/nvim-tree/nvim-tree.lua/issues/2995)) ([2ee1c5e](https://github.com/nvim-tree/nvim-tree.lua/commit/2ee1c5e17fdfbf5013af31b1410e4a5f28f4cadd))
+* **#2938:** add default filesystem_watchers.ignore_dirs = { "/.ccls-cache", "/build", "/node_modules", "/target", } ([#2940](https://github.com/nvim-tree/nvim-tree.lua/issues/2940)) ([010ae03](https://github.com/nvim-tree/nvim-tree.lua/commit/010ae0365aafd6275c478d932515d2e8e897b7bb))
+
+
+### Bug Fixes
+
+* **#2945:** stack overflow on api.git.reload or fugitive event with watchers disabled ([#2949](https://github.com/nvim-tree/nvim-tree.lua/issues/2949)) ([5ad8762](https://github.com/nvim-tree/nvim-tree.lua/commit/5ad87620ec9d1190d15c88171a3f0122bc16b0fe))
+* **#2947:** root is never a dotfile, so that it doesn't propagate to children ([#2958](https://github.com/nvim-tree/nvim-tree.lua/issues/2958)) ([f5f6789](https://github.com/nvim-tree/nvim-tree.lua/commit/f5f67892996b280ae78b1b0a2d07c4fa29ae0905))
+* **#2951:** highlights incorrect following cancelled pick ([#2952](https://github.com/nvim-tree/nvim-tree.lua/issues/2952)) ([1c9553a](https://github.com/nvim-tree/nvim-tree.lua/commit/1c9553a19f70df3dcb171546a3d5e034531ef093))
+* **#2954:** resolve occasional tree flashing on diagnostics, set tree buffer options in deterministic order ([#2980](https://github.com/nvim-tree/nvim-tree.lua/issues/2980)) ([82ab19e](https://github.com/nvim-tree/nvim-tree.lua/commit/82ab19ebf79c1839d7351f2fed213d1af13a598e))
+* **#2961:** windows: escape brackets and parentheses when opening file ([#2962](https://github.com/nvim-tree/nvim-tree.lua/issues/2962)) ([63c7ad9](https://github.com/nvim-tree/nvim-tree.lua/commit/63c7ad9037fb7334682dd0b3a177cee25c5c8a0f))
+* **#2969:** After a rename, the node loses selection ([#2974](https://github.com/nvim-tree/nvim-tree.lua/issues/2974)) ([1403933](https://github.com/nvim-tree/nvim-tree.lua/commit/14039337a563f4efd72831888f332a15585f0ea1))
+* **#2972:** error on :colorscheme ([#2973](https://github.com/nvim-tree/nvim-tree.lua/issues/2973)) ([6e5a204](https://github.com/nvim-tree/nvim-tree.lua/commit/6e5a204ca659bb8f2a564df75df2739edec03cb0))
+* **#2976:** use vim.loop to preserve neovim 0.9 compatibility ([#2977](https://github.com/nvim-tree/nvim-tree.lua/issues/2977)) ([00dff48](https://github.com/nvim-tree/nvim-tree.lua/commit/00dff482f9a8fb806a54fd980359adc6cd45d435))
+* **#2978:** grouped folder not showing closed icon ([#2979](https://github.com/nvim-tree/nvim-tree.lua/issues/2979)) ([120ba58](https://github.com/nvim-tree/nvim-tree.lua/commit/120ba58254835d412bbc91cffe847e9be835fadd))
+* **#2981:** windows: root changed when navigating with LSP ([#2982](https://github.com/nvim-tree/nvim-tree.lua/issues/2982)) ([c22124b](https://github.com/nvim-tree/nvim-tree.lua/commit/c22124b37409bee6d1a0da77f4f3a1526f7a204d))
+* symlink file icons rendered when renderer.icons.show.file = false, folder.symlink* was incorrectly rendered as folder.default|open ([#2983](https://github.com/nvim-tree/nvim-tree.lua/issues/2983)) ([2156bc0](https://github.com/nvim-tree/nvim-tree.lua/commit/2156bc08c982d3c4b4cfc2b8fd7faeff58a88e10))
+
+## [1.7.1](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.7.0...nvim-tree-v1.7.1) (2024-09-30)
+
+
+### Bug Fixes
+
+* **#2794:** sshfs compatibility ([#2922](https://github.com/nvim-tree/nvim-tree.lua/issues/2922)) ([9650e73](https://github.com/nvim-tree/nvim-tree.lua/commit/9650e735baad0d39505f4cb4867a60f02858536a))
+* **#2928:** nil explorer in parent move action ([#2929](https://github.com/nvim-tree/nvim-tree.lua/issues/2929)) ([0429f28](https://github.com/nvim-tree/nvim-tree.lua/commit/0429f286b350c65118d66b646775bf187936fa47))
+* **#2930:** empty groups expanded on reload ([#2935](https://github.com/nvim-tree/nvim-tree.lua/issues/2935)) ([4520c03](https://github.com/nvim-tree/nvim-tree.lua/commit/4520c0355cc561830ee2cf90dc37a2a75abf7995))
+* invalid explorer on open ([#2927](https://github.com/nvim-tree/nvim-tree.lua/issues/2927)) ([59a8a6a](https://github.com/nvim-tree/nvim-tree.lua/commit/59a8a6ae5e9d3eae99d08ab655d12fd51d5d17f3))
+
+
+### Reverts
+
+* **#2794:** sshfs compatibility ([#2920](https://github.com/nvim-tree/nvim-tree.lua/issues/2920)) ([8405ecf](https://github.com/nvim-tree/nvim-tree.lua/commit/8405ecfbd6bb08a94ffc9c68fef211eea56e8a3b))
+
+## [1.7.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.6.1...nvim-tree-v1.7.0) (2024-09-21)
+
+
+### Features
+
+* **#2430:** use vim.ui.open as default system_open, for neovim 0.10+ ([#2912](https://github.com/nvim-tree/nvim-tree.lua/issues/2912)) ([03f737e](https://github.com/nvim-tree/nvim-tree.lua/commit/03f737e5744a2b3ebb4b086f7636a3399224ec0c))
+* help closes on <Esc> and api.tree.toggle_help mappings ([#2909](https://github.com/nvim-tree/nvim-tree.lua/issues/2909)) ([b652dbd](https://github.com/nvim-tree/nvim-tree.lua/commit/b652dbd0e0489c5fbb81fbededf0d99029cd2f38))
+
+
+### Bug Fixes
+
+* **#2862:** windows path replaces backslashes with forward slashes ([#2903](https://github.com/nvim-tree/nvim-tree.lua/issues/2903)) ([45a93d9](https://github.com/nvim-tree/nvim-tree.lua/commit/45a93d99794fff3064141d5b3a50db98ce352697))
+* **#2906:** resource leak on populate children ([#2907](https://github.com/nvim-tree/nvim-tree.lua/issues/2907)) ([a4dd5ad](https://github.com/nvim-tree/nvim-tree.lua/commit/a4dd5ad5c8f9349142291d24e0e6466995594b9a))
+* **#2917:** fix root copy paths: Y, ge, gy, y ([#2918](https://github.com/nvim-tree/nvim-tree.lua/issues/2918)) ([b18ce8b](https://github.com/nvim-tree/nvim-tree.lua/commit/b18ce8be8f162eee0bc37addcfe17d7d019fcec7))
+* safely close last tree window ([#2913](https://github.com/nvim-tree/nvim-tree.lua/issues/2913)) ([bd48816](https://github.com/nvim-tree/nvim-tree.lua/commit/bd4881660bf0ddfa6acb21259f856ba3dcb26a93))
+* safely close tree window with pcall and debug logging ([bd48816](https://github.com/nvim-tree/nvim-tree.lua/commit/bd4881660bf0ddfa6acb21259f856ba3dcb26a93))
+
 ## [1.6.1](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.6.0...nvim-tree-v1.6.1) (2024-09-09)
 
 

CONTRIBUTING.md

@@ -2,17 +2,19 @@
 
 Thank you for contributing.
 
-See [Development](https://github.com/nvim-tree/nvim-tree.lua/wiki/Development) for environment setup, tips and tools.
+See [wiki: Development](https://github.com/nvim-tree/nvim-tree.lua/wiki/Development) for environment setup, tips and tools.
 
 # Tools
 
 Following are used during CI and strongly recommended during local development.
 
+Language server: [luals](https://luals.github.io)
+
 Lint: [luacheck](https://github.com/lunarmodules/luacheck/)
 
-Style: [StyLua](https://github.com/JohnnyMorganz/StyLua)
+Style: [EmmyLuaCodeStyle](https://github.com/CppCXY/EmmyLuaCodeStyle): `CodeCheck`
 
-Language server: [luals](https://luals.github.io)
+nvim-tree.lua migrated from stylua to EmmyLuaCodeStyle ~2024/10. `vim.lsp.buf.format()` may be used as it is the default formatter for luals
 
 You can install them via you OS package manager e.g. `pacman`, `brew` or other via other package managers such as `cargo` or `luarocks`
 
@@ -34,14 +36,14 @@ make lint
 
 ## style
 
-1. Runs stylua using `.stylua.toml` settings
+1. Runs CodeCheck using `.editorconfig` settings
 1. Runs `scripts/doc-comments.sh` to validate annotated documentation
 
 ```sh
 make style
 ```
 
-You can automatically fix stylua issues via:
+You can automatically fix `CodeCheck` issues via:
 
 ```sh
 make style-fix
@@ -88,6 +90,14 @@ Documentation for options should also be added to `nvim-tree-opts` in `doc/nvim-
 
 When adding or changing API please update :help nvim-tree-api
 
+# Windows
+
+Please note that nvim-tree team members do not have access to nor expertise with Windows.
+
+You will need to be an active participant during development and raise a PR to resolve any issues that may arise.
+
+Please ensure that windows specific features and fixes are behind the appropriate feature flag, see [wiki: OS Feature Flags](https://github.com/nvim-tree/nvim-tree.lua/wiki/Development#os-feature-flags)
+
 # Pull Request
 
 Please reference any issues in the description e.g. "resolves #1234", which will be closed upon merge.

Makefile

@@ -5,7 +5,7 @@ all: lint style check
 #
 lint: luacheck
 
-style: stylua style-doc
+style: style-check style-doc
 
 check: luals
 
@@ -15,8 +15,9 @@ check: luals
 luacheck:
 	luacheck -q lua
 
-stylua:
+# --diagnosis-as-error does not function for workspace, hence we post-process the output
-	stylua lua --check
+style-check:
+	CodeFormat check --config .editorconfig --diagnosis-as-error --workspace lua
 
 style-doc:
 	scripts/doc-comments.sh
@@ -28,7 +29,7 @@ luals:
 # fixes
 #
 style-fix:
-	stylua lua
+	CodeFormat format --config .editorconfig --workspace lua
 
 #
 # utility
@@ -43,5 +44,5 @@ help-check: help-update
 	git diff --exit-code doc/nvim-tree-lua.txt
 
 
-.PHONY: all lint style check luacheck stylua style-doc luals style-fix help-update help-check
+.PHONY: all lint style check luacheck style-check style-doc luals style-fix help-update help-check
 

doc/nvim-tree-lua.txt

@@ -117,7 +117,7 @@ Disabling |netrw| is strongly advised, see |nvim-tree-netrw|
 ==============================================================================
  2.1 QUICKSTART: SETUP                            *nvim-tree-quickstart-setup*
 
-Setup the plugin in your `init.lua` >
+Setup the plugin in your `init.lua` e.g. >lua
 
   -- disable netrw at the very start of your init.lua
   vim.g.loaded_netrw = 1
@@ -215,7 +215,7 @@ Show the mappings:  `g?`
  2.3 QUICKSTART: CUSTOM MAPPINGS        *nvim-tree-quickstart-custom-mappings*
 
 |nvim-tree-mappings-default| are applied by default however you may customise
-via |nvim-tree.on_attach| e.g. >
+via |nvim-tree.on_attach| e.g. >lua
 
   local function my_on_attach(bufnr)
     local api = require "nvim-tree.api"
@@ -228,8 +228,8 @@ via |nvim-tree.on_attach| e.g. >
     api.config.mappings.default_on_attach(bufnr)
 
     -- custom mappings
-    vim.keymap.set('n', '<C-t>', api.tree.change_root_to_parent,        opts('Up'))
+    vim.keymap.set("n", "<C-t>", api.tree.change_root_to_parent,        opts("Up"))
-    vim.keymap.set('n', '?',     api.tree.toggle_help,                  opts('Help'))
+    vim.keymap.set("n", "?",     api.tree.toggle_help,                  opts("Help"))
   end
 
   -- pass to setup along with your other options
@@ -245,7 +245,7 @@ via |nvim-tree.on_attach| e.g. >
 Run |:NvimTreeHiTest| to show all the highlights that nvim-tree uses.
 
 They can be customised before or after setup is called and will be immediately
-applied at runtime. e.g. >
+applied at runtime. e.g. >lua
 
     vim.cmd([[
         :hi      NvimTreeExecFile    guifg=#ffa0a0
@@ -366,15 +366,15 @@ again to apply a change in configuration without restarting nvim.
 
 setup() function takes one optional argument: configuration table. If omitted
 nvim-tree will be initialised with default configuration.
->
+
 The first setup() call is cheap: it does nothing more than validate / apply
 the configuration. Nothing happens until the tree is first opened.
 
 Subsequent setup() calls are expensive as they tear down the world before
 applying configuration.
 
-Following is the default configuration. See |nvim-tree-opts| for details.
+Following is the default configuration. See |nvim-tree-opts| for details. >lua
->
+
     require("nvim-tree").setup { -- BEGIN_DEFAULT_OPTS
       on_attach = "default",
       hijack_cursor = false,
@@ -561,7 +561,12 @@ Following is the default configuration. See |nvim-tree-opts| for details.
       filesystem_watchers = {
         enable = true,
         debounce_delay = 50,
-        ignore_dirs = {},
+        ignore_dirs = {
+          "/.ccls-cache",
+          "/build",
+          "/node_modules",
+          "/target",
+        },
       },
       actions = {
         use_system_clipboard = true,
@@ -587,6 +592,7 @@ Following is the default configuration. See |nvim-tree-opts| for details.
           quit_on_open = false,
           eject = true,
           resize_window = true,
+          relative_path = true,
           window_picker = {
             enable = true,
             picker = "default",
@@ -626,11 +632,6 @@ Following is the default configuration. See |nvim-tree-opts| for details.
         },
       },
       experimental = {
-        actions = {
-          open_file = {
-            relative_path = false,
-          },
-        },
       },
       log = {
         enable = false,
@@ -672,7 +673,7 @@ Completely disable netrw
 
 It is strongly advised to eagerly disable netrw, due to race conditions at vim
 startup.
-Set the following at the very beginning of your `init.lua` / `init.vim`: >
+Set the following at the very beginning of your `init.lua` / `init.vim`: >lua
     vim.g.loaded_netrw = 1
     vim.g.loaded_netrwPlugin = 1
 <
@@ -734,7 +735,7 @@ Can be one of `"name"`, `"case_sensitive"`, `"modification_time"`, `"extension"`
   - `name`:          `string`
   - `type`:          `"directory"` | `"file"` | `"link"`
 
-  Example: sort by name length: >
+  Example: sort by name length: >lua
     local sorter = function(nodes)
       table.sort(nodes, function(a, b)
         return #a.name < #b.name
@@ -866,7 +867,7 @@ Set to `false` to hide the root folder.
   Type: `string` or `boolean` or `function(root_cwd)`, Default: `":~:s?$?/..?"`
 
   Function is passed the absolute path of the root folder and should
-  return a string. e.g. >
+  return a string. e.g. >lua
     my_root_folder_label = function(path)
       return ".../" .. vim.fn.fnamemodify(path, ":t")
     end
@@ -898,7 +899,7 @@ Show a summary of hidden files below the tree using `NvimTreeHiddenDisplay
   reasons and values are the count of hidden files for that reason.
 
   The `hidden_stats` argument is structured as follows, where <num> is the
-  number of hidden files related to the field: >
+  number of hidden files related to the field: >lua
     hidden_stats = {
       bookmark = <num>,
       buf = <num>,
@@ -908,7 +909,7 @@ Show a summary of hidden files below the tree using `NvimTreeHiddenDisplay
       live_filter = <num>,
     }
 <
-  Example of function that can be passed: >
+  Example of function that can be passed: >lua
     function(hidden_stats)
       local total_count = 0
       for reason, count in pairs(hidden_stats) do
@@ -983,7 +984,7 @@ Configuration options for tree indent markers.
 
     *nvim-tree.renderer.indent_markers.icons*
     Icons shown before the file/directory. Length 1.
-      Type: `table`, Default: >
+      Type: `table`, Default: >lua
         {
           corner = "└",
           edge = "│",
@@ -1198,11 +1199,18 @@ Takes the `BufEnter` event as an argument. see |autocmd-events|
 
 Open a file or directory in your preferred application.
 
+|vim.ui.open| was introduced in neovim 0.10 and is the default.
+
+Once nvim-tree minimum neovim version is updated to 0.10, these options will
+no longer be necessary and will be removed.
+
 *nvim-tree.system_open.cmd*
 The open command itself.
   Type: `string`, Default: `""`
 
-Leave empty for OS specific default:
+neovim >= 0.10 defaults to |vim.ui.open|
+
+neovim <  0.10 defaults to:
   UNIX:    `"xdg-open"`
   macOS:   `"open"`
   Windows: `"cmd"`
@@ -1288,7 +1296,7 @@ Severity for which the diagnostics will be displayed. See |diagnostic-severity|
 
 *nvim-tree.diagnostics.icons*
 Icons for diagnostic severity.
-  Type: `table`, Default: >
+  Type: `table`, Default: >lua
     {
       hint = "",
       info = "",
@@ -1409,8 +1417,14 @@ function returning whether a path should be ignored.
 Strings must be backslash escaped e.g. `"my-proj/\\.build$"`. See |string-match|.
 Function is passed an absolute path.
 Useful when path is not in `.gitignore` or git integration is disabled.
-  Type: `string[] | fun(path: string): boolean`, Default: `{}`
+  Type: `string[] | fun(path: string): boolean`, Default: >lua
-
+    {
+      "/.ccls-cache",
+      "/build",
+      "/node_modules",
+      "/target",
+    }
+<
 ==============================================================================
  5.13 OPTS: ACTIONS                                   *nvim-tree-opts-actions*
 
@@ -1429,8 +1443,6 @@ vim |current-directory| behaviour.
 
     *nvim-tree.actions.change_dir.global*
     Use `:cd` instead of `:lcd` when changing directories.
-    Consider that this might cause issues with the
-    |nvim-tree.sync_root_with_cwd| option.
       Type: `boolean`, Default: `false`
 
     *nvim-tree.actions.change_dir.restrict_above_cwd*
@@ -1481,6 +1493,11 @@ Configuration options for opening a file from nvim-tree.
     Resizes the tree when opening a file.
       Type: `boolean`, Default: `true`
 
+    *nvim-tree.experimental.actions.open_file.relative_path*
+    Buffers opened by nvim-tree will use with relative paths instead of
+    absolute.
+      Type: `boolean`, Default: `true`
+
     *nvim-tree.actions.open_file.window_picker*
     Window picker configuration.
 
@@ -1495,10 +1512,10 @@ Configuration options for opening a file from nvim-tree.
         or `nil` if an invalid window is picked or user cancelled the action.
         The picker may create a new window.
           Type: `string` | `function`, Default: `"default"`
-          e.g. s1n7ax/nvim-window-picker plugin: >
+          e.g. s1n7ax/nvim-window-picker plugin: >lua
             window_picker = {
               enable = true,
-              picker = require('window-picker').pick_window,
+              picker = require("window-picker").pick_window,
 <
         *nvim-tree.actions.open_file.window_picker.chars*
         A string of chars used as identifiers by the window picker.
@@ -1508,7 +1525,7 @@ Configuration options for opening a file from nvim-tree.
         Table of buffer option names mapped to a list of option values that
         indicates to the picker that the buffer's window should not be
         selectable.
-          Type: `table`, Default: >
+          Type: `table`, Default: >lua
             {
               filetype = {
                 "notify",
@@ -1569,7 +1586,7 @@ Specify minimum notification level, uses the values from |vim.log.levels|
 `ERROR`:   hard errors e.g. failure to read from the file system.
 `WARNING`: non-fatal errors e.g. unable to system open a file.
 `INFO:`    information only e.g. file copy path confirmation.
-`DEBUG:`   not used.
+`DEBUG:`   information for troubleshooting, e.g. failures in some window closing operations.
 
 *nvim-tree.notify.absolute_path* 
 Whether to use absolute paths or item names in fs action notifications. 
@@ -1609,12 +1626,6 @@ Confirmation prompts.
 Experimental features that may become default or optional functionality.
 In the event of a problem please disable the experiment and raise an issue.
 
-    *nvim-tree.experimental.actions.open_file.relative_path*
-    Buffers opened by nvim-tree will use with relative paths instead of
-    absolute.
-    Execute |:ls| to see the paths of all open buffers.
-      Type: `boolean`, Default: `false`
-
 ==============================================================================
  5.20 OPTS: LOG                                           *nvim-tree-opts-log*
 
@@ -1667,9 +1678,7 @@ Specify which information to log.
 ==============================================================================
  6. API                                                        *nvim-tree-api*
 
-Nvim-tree's public API can be used to access features.
+Nvim-tree's public API can be used to access features. e.g. >lua
->
-e.g. >
     local api = require("nvim-tree.api")
     api.tree.toggle()
 <
@@ -1953,6 +1962,13 @@ fs.copy.absolute_path({node})          *nvim-tree-api.fs.copy.absolute_path()*
     Parameters: ~
       • {node} (Node|nil) file or folder
 
+fs.copy.basename({node})                    *nvim-tree-api.fs.copy.basename()*
+    Copy the name of a file or folder with extension omitted to the system
+    clipboard.
+
+    Parameters: ~
+      • {node} (Node|nil) file or folder
+
 fs.copy.filename({node})                    *nvim-tree-api.fs.copy.filename()*
     Copy the name of a file or folder to the system clipboard.
 
@@ -2261,30 +2277,30 @@ Active mappings may be viewed via HELP, default `g?`. The mapping's description
 is used when displaying HELP.
 
 The `on_attach` function is passed the `bufnr` of nvim-tree. Use
-|vim.keymap.set()| or |nvim_set_keymap()| to define mappings as usual. e.g. >
+|vim.keymap.set()| or |nvim_set_keymap()| to define mappings as usual. e.g. >lua
 
   local function my_on_attach(bufnr)
-    local api = require('nvim-tree.api')
+    local api = require("nvim-tree.api")
 
     local function opts(desc)
-      return { desc = 'nvim-tree: ' .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true }
+      return { desc = "nvim-tree: " .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true }
     end
 
     -- copy default mappings here from defaults in next section
-    vim.keymap.set('n', '<C-]>', api.tree.change_root_to_node,          opts('CD'))
+    vim.keymap.set("n", "<C-]>", api.tree.change_root_to_node,          opts("CD"))
-    vim.keymap.set('n', '<C-e>', api.node.open.replace_tree_buffer,     opts('Open: In Place'))
+    vim.keymap.set("n", "<C-e>", api.node.open.replace_tree_buffer,     opts("Open: In Place"))
     ---
     -- OR use all default mappings
     api.config.mappings.default_on_attach(bufnr)
 
     -- remove a default
-    vim.keymap.del('n', '<C-]>', { buffer = bufnr })
+    vim.keymap.del("n", "<C-]>", { buffer = bufnr })
 
     -- override a default
-    vim.keymap.set('n', '<C-e>', api.tree.reload,                       opts('Refresh'))
+    vim.keymap.set("n", "<C-e>", api.tree.reload,                       opts("Refresh"))
 
     -- add your mappings
-    vim.keymap.set('n', '?',     api.tree.toggle_help,                  opts('Help'))
+    vim.keymap.set("n", "?",     api.tree.toggle_help,                  opts("Help"))
     ---
   end
 
@@ -2301,16 +2317,16 @@ Single left mouse mappings can be achieved via `<LeftRelease>`.
 Single right / middle mouse mappings will require changes to |mousemodel| or |mouse|.
 
 |vim.keymap.set()| {rhs} is a `(function|string)` thus it may be necessary to
-define your own function to map complex functionality e.g. >
+define your own function to map complex functionality e.g. >lua
 
   local function print_node_path()
-    local api = require('nvim-tree.api')
+    local api = require("nvim-tree.api")
     local node = api.tree.get_node_under_cursor()
     print(node.absolute_path)
   end
 
   -- on_attach
-  vim.keymap.set('n', '<C-P>', print_node_path, opts('Print Path'))
+  vim.keymap.set("n", "<C-P>", print_node_path, opts("Print Path"))
 <
 ==============================================================================
  7.1 MAPPINGS: DEFAULT                            *nvim-tree-mappings-default*
@@ -2318,83 +2334,83 @@ define your own function to map complex functionality e.g. >
 In the absence of an |nvim-tree.on_attach| function, the following defaults
 will be applied.
 
-You are encouraged to copy these to your own |nvim-tree.on_attach| function.
+You are encouraged to copy these to your own |nvim-tree.on_attach| function. >lua
->
+
-  local api = require('nvim-tree.api')
+  local api = require("nvim-tree.api")
 
   local function opts(desc)
-    return { desc = 'nvim-tree: ' .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true }
+    return { desc = "nvim-tree: " .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true }
   end
 
   -- BEGIN_DEFAULT_ON_ATTACH
-  vim.keymap.set('n', '<C-]>',   api.tree.change_root_to_node,        opts('CD'))
+  vim.keymap.set("n", "<C-]>",          api.tree.change_root_to_node,       opts("CD"))
-  vim.keymap.set('n', '<C-e>',   api.node.open.replace_tree_buffer,   opts('Open: In Place'))
+  vim.keymap.set("n", "<C-e>",          api.node.open.replace_tree_buffer,  opts("Open: In Place"))
-  vim.keymap.set('n', '<C-k>',   api.node.show_info_popup,            opts('Info'))
+  vim.keymap.set("n", "<C-k>",          api.node.show_info_popup,           opts("Info"))
-  vim.keymap.set('n', '<C-r>',   api.fs.rename_sub,                   opts('Rename: Omit Filename'))
+  vim.keymap.set("n", "<C-r>",          api.fs.rename_sub,                  opts("Rename: Omit Filename"))
-  vim.keymap.set('n', '<C-t>',   api.node.open.tab,                   opts('Open: New Tab'))
+  vim.keymap.set("n", "<C-t>",          api.node.open.tab,                  opts("Open: New Tab"))
-  vim.keymap.set('n', '<C-v>',   api.node.open.vertical,              opts('Open: Vertical Split'))
+  vim.keymap.set("n", "<C-v>",          api.node.open.vertical,             opts("Open: Vertical Split"))
-  vim.keymap.set('n', '<C-x>',   api.node.open.horizontal,            opts('Open: Horizontal Split'))
+  vim.keymap.set("n", "<C-x>",          api.node.open.horizontal,           opts("Open: Horizontal Split"))
-  vim.keymap.set('n', '<BS>',    api.node.navigate.parent_close,      opts('Close Directory'))
+  vim.keymap.set("n", "<BS>",           api.node.navigate.parent_close,     opts("Close Directory"))
-  vim.keymap.set('n', '<CR>',    api.node.open.edit,                  opts('Open'))
+  vim.keymap.set("n", "<CR>",           api.node.open.edit,                 opts("Open"))
-  vim.keymap.set('n', '<Tab>',   api.node.open.preview,               opts('Open Preview'))
+  vim.keymap.set("n", "<Tab>",          api.node.open.preview,              opts("Open Preview"))
-  vim.keymap.set('n', '>',       api.node.navigate.sibling.next,      opts('Next Sibling'))
+  vim.keymap.set("n", ">",              api.node.navigate.sibling.next,     opts("Next Sibling"))
-  vim.keymap.set('n', '<',       api.node.navigate.sibling.prev,      opts('Previous Sibling'))
+  vim.keymap.set("n", "<",              api.node.navigate.sibling.prev,     opts("Previous Sibling"))
-  vim.keymap.set('n', '.',       api.node.run.cmd,                    opts('Run Command'))
+  vim.keymap.set("n", ".",              api.node.run.cmd,                   opts("Run Command"))
-  vim.keymap.set('n', '-',       api.tree.change_root_to_parent,      opts('Up'))
+  vim.keymap.set("n", "-",              api.tree.change_root_to_parent,     opts("Up"))
-  vim.keymap.set('n', 'a',       api.fs.create,                       opts('Create File Or Directory'))
+  vim.keymap.set("n", "a",              api.fs.create,                      opts("Create File Or Directory"))
-  vim.keymap.set('n', 'bd',      api.marks.bulk.delete,               opts('Delete Bookmarked'))
+  vim.keymap.set("n", "bd",             api.marks.bulk.delete,              opts("Delete Bookmarked"))
-  vim.keymap.set('n', 'bt',      api.marks.bulk.trash,                opts('Trash Bookmarked'))
+  vim.keymap.set("n", "bt",             api.marks.bulk.trash,               opts("Trash Bookmarked"))
-  vim.keymap.set('n', 'bmv',     api.marks.bulk.move,                 opts('Move Bookmarked'))
+  vim.keymap.set("n", "bmv",            api.marks.bulk.move,                opts("Move Bookmarked"))
-  vim.keymap.set('n', 'B',       api.tree.toggle_no_buffer_filter,    opts('Toggle Filter: No Buffer'))
+  vim.keymap.set("n", "B",              api.tree.toggle_no_buffer_filter,   opts("Toggle Filter: No Buffer"))
-  vim.keymap.set('n', 'c',       api.fs.copy.node,                    opts('Copy'))
+  vim.keymap.set("n", "c",              api.fs.copy.node,                   opts("Copy"))
-  vim.keymap.set('n', 'C',       api.tree.toggle_git_clean_filter,    opts('Toggle Filter: Git Clean'))
+  vim.keymap.set("n", "C",              api.tree.toggle_git_clean_filter,   opts("Toggle Filter: Git Clean"))
-  vim.keymap.set('n', '[c',      api.node.navigate.git.prev,          opts('Prev Git'))
+  vim.keymap.set("n", "[c",             api.node.navigate.git.prev,         opts("Prev Git"))
-  vim.keymap.set('n', ']c',      api.node.navigate.git.next,          opts('Next Git'))
+  vim.keymap.set("n", "]c",             api.node.navigate.git.next,         opts("Next Git"))
-  vim.keymap.set('n', 'd',       api.fs.remove,                       opts('Delete'))
+  vim.keymap.set("n", "d",              api.fs.remove,                      opts("Delete"))
-  vim.keymap.set('n', 'D',       api.fs.trash,                        opts('Trash'))
+  vim.keymap.set("n", "D",              api.fs.trash,                       opts("Trash"))
-  vim.keymap.set('n', 'E',       api.tree.expand_all,                 opts('Expand All'))
+  vim.keymap.set("n", "E",              api.tree.expand_all,                opts("Expand All"))
-  vim.keymap.set('n', 'e',       api.fs.rename_basename,              opts('Rename: Basename'))
+  vim.keymap.set("n", "e",              api.fs.rename_basename,             opts("Rename: Basename"))
-  vim.keymap.set('n', ']e',      api.node.navigate.diagnostics.next,  opts('Next Diagnostic'))
+  vim.keymap.set("n", "]e",             api.node.navigate.diagnostics.next, opts("Next Diagnostic"))
-  vim.keymap.set('n', '[e',      api.node.navigate.diagnostics.prev,  opts('Prev Diagnostic'))
+  vim.keymap.set("n", "[e",             api.node.navigate.diagnostics.prev, opts("Prev Diagnostic"))
-  vim.keymap.set('n', 'F',       api.live_filter.clear,               opts('Live Filter: Clear'))
+  vim.keymap.set("n", "F",              api.live_filter.clear,              opts("Live Filter: Clear"))
-  vim.keymap.set('n', 'f',       api.live_filter.start,               opts('Live Filter: Start'))
+  vim.keymap.set("n", "f",              api.live_filter.start,              opts("Live Filter: Start"))
-  vim.keymap.set('n', 'g?',      api.tree.toggle_help,                opts('Help'))
+  vim.keymap.set("n", "g?",             api.tree.toggle_help,               opts("Help"))
-  vim.keymap.set('n', 'gy',      api.fs.copy.absolute_path,           opts('Copy Absolute Path'))
+  vim.keymap.set("n", "gy",             api.fs.copy.absolute_path,          opts("Copy Absolute Path"))
-  vim.keymap.set('n', 'ge',      api.fs.copy.basename,                opts('Copy Basename'))
+  vim.keymap.set("n", "ge",             api.fs.copy.basename,               opts("Copy Basename"))
-  vim.keymap.set('n', 'H',       api.tree.toggle_hidden_filter,       opts('Toggle Filter: Dotfiles'))
+  vim.keymap.set("n", "H",              api.tree.toggle_hidden_filter,      opts("Toggle Filter: Dotfiles"))
-  vim.keymap.set('n', 'I',       api.tree.toggle_gitignore_filter,    opts('Toggle Filter: Git Ignore'))
+  vim.keymap.set("n", "I",              api.tree.toggle_gitignore_filter,   opts("Toggle Filter: Git Ignore"))
-  vim.keymap.set('n', 'J',       api.node.navigate.sibling.last,      opts('Last Sibling'))
+  vim.keymap.set("n", "J",              api.node.navigate.sibling.last,     opts("Last Sibling"))
-  vim.keymap.set('n', 'K',       api.node.navigate.sibling.first,     opts('First Sibling'))
+  vim.keymap.set("n", "K",              api.node.navigate.sibling.first,    opts("First Sibling"))
-  vim.keymap.set('n', 'L',       api.node.open.toggle_group_empty,    opts('Toggle Group Empty'))
+  vim.keymap.set("n", "L",              api.node.open.toggle_group_empty,   opts("Toggle Group Empty"))
-  vim.keymap.set('n', 'M',       api.tree.toggle_no_bookmark_filter,  opts('Toggle Filter: No Bookmark'))
+  vim.keymap.set("n", "M",              api.tree.toggle_no_bookmark_filter, opts("Toggle Filter: No Bookmark"))
-  vim.keymap.set('n', 'm',       api.marks.toggle,                    opts('Toggle Bookmark'))
+  vim.keymap.set("n", "m",              api.marks.toggle,                   opts("Toggle Bookmark"))
-  vim.keymap.set('n', 'o',       api.node.open.edit,                  opts('Open'))
+  vim.keymap.set("n", "o",              api.node.open.edit,                 opts("Open"))
-  vim.keymap.set('n', 'O',       api.node.open.no_window_picker,      opts('Open: No Window Picker'))
+  vim.keymap.set("n", "O",              api.node.open.no_window_picker,     opts("Open: No Window Picker"))
-  vim.keymap.set('n', 'p',       api.fs.paste,                        opts('Paste'))
+  vim.keymap.set("n", "p",              api.fs.paste,                       opts("Paste"))
-  vim.keymap.set('n', 'P',       api.node.navigate.parent,            opts('Parent Directory'))
+  vim.keymap.set("n", "P",              api.node.navigate.parent,           opts("Parent Directory"))
-  vim.keymap.set('n', 'q',       api.tree.close,                      opts('Close'))
+  vim.keymap.set("n", "q",              api.tree.close,                     opts("Close"))
-  vim.keymap.set('n', 'r',       api.fs.rename,                       opts('Rename'))
+  vim.keymap.set("n", "r",              api.fs.rename,                      opts("Rename"))
-  vim.keymap.set('n', 'R',       api.tree.reload,                     opts('Refresh'))
+  vim.keymap.set("n", "R",              api.tree.reload,                    opts("Refresh"))
-  vim.keymap.set('n', 's',       api.node.run.system,                 opts('Run System'))
+  vim.keymap.set("n", "s",              api.node.run.system,                opts("Run System"))
-  vim.keymap.set('n', 'S',       api.tree.search_node,                opts('Search'))
+  vim.keymap.set("n", "S",              api.tree.search_node,               opts("Search"))
-  vim.keymap.set('n', 'u',       api.fs.rename_full,                  opts('Rename: Full Path'))
+  vim.keymap.set("n", "u",              api.fs.rename_full,                 opts("Rename: Full Path"))
-  vim.keymap.set('n', 'U',       api.tree.toggle_custom_filter,       opts('Toggle Filter: Hidden'))
+  vim.keymap.set("n", "U",              api.tree.toggle_custom_filter,      opts("Toggle Filter: Hidden"))
-  vim.keymap.set('n', 'W',       api.tree.collapse_all,               opts('Collapse'))
+  vim.keymap.set("n", "W",              api.tree.collapse_all,              opts("Collapse"))
-  vim.keymap.set('n', 'x',       api.fs.cut,                          opts('Cut'))
+  vim.keymap.set("n", "x",              api.fs.cut,                         opts("Cut"))
-  vim.keymap.set('n', 'y',       api.fs.copy.filename,                opts('Copy Name'))
+  vim.keymap.set("n", "y",              api.fs.copy.filename,               opts("Copy Name"))
-  vim.keymap.set('n', 'Y',       api.fs.copy.relative_path,           opts('Copy Relative Path'))
+  vim.keymap.set("n", "Y",              api.fs.copy.relative_path,          opts("Copy Relative Path"))
-  vim.keymap.set('n', '<2-LeftMouse>',  api.node.open.edit,           opts('Open'))
+  vim.keymap.set("n", "<2-LeftMouse>",  api.node.open.edit,                 opts("Open"))
-  vim.keymap.set('n', '<2-RightMouse>', api.tree.change_root_to_node, opts('CD'))
+  vim.keymap.set("n", "<2-RightMouse>", api.tree.change_root_to_node,       opts("CD"))
   -- END_DEFAULT_ON_ATTACH
 <
 Alternatively, you may apply these default mappings from your |nvim-tree.on_attach| via
-|nvim-tree-api.config.mappings.default_on_attach()| e.g.
+|nvim-tree-api.config.mappings.default_on_attach()| e.g. >lua
->
+
   local function my_on_attach(bufnr)
-    local api = require('nvim-tree.api')
+    local api = require("nvim-tree.api")
 
     local function opts(desc)
-      return { desc = 'nvim-tree: ' .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true }
+      return { desc = "nvim-tree: " .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true }
     end
 
     api.config.mappings.default_on_attach(bufnr)
@@ -2409,10 +2425,10 @@ All the following highlight groups can be configured by hand. Aside from
 `NvimTreeWindowPicker`, it is not advised to colorize the background of these
 groups.
 
-Example |:highlight| >
+Example |:highlight| >vim
     :hi NvimTreeSymlink guifg=blue gui=bold,underline
 <
-It is recommended to enable 'termguicolors' for the more pleasant 24-bit
+It is recommended to enable |termguicolors| for the more pleasant 24-bit
 colours.
 
 To view the nvim-tree highlight groups run |:NvimTreeHiTest|
@@ -2423,16 +2439,18 @@ as per |:highlight|
 The `*HL` groups are additive as per |nvim-tree-opts-renderer| precedence.
 Only present attributes will clobber each other.
 In this example a modified, opened file will have magenta text, with cyan
-undercurl: >
+undercurl: >vim
     :hi NvimTreeOpenedHL       guifg=magenta guisp=red  gui=underline
     :hi NvimTreeModifiedFileHL               guisp=cyan gui=undercurl
 <
 To prevent usage of a highlight:
-- Before setup: link the group to `Normal` e.g.
-    `:hi NvimTreeExecFile Normal`
-- After setup: link it to `NONE`, to override the default link e.g.
-    `:hi! link NvimTreeExecFile NONE`
 
+- Before setup: link the group to `Normal` e.g. >vim
+    :hi NvimTreeExecFile Normal
+<
+- After setup: link it to `NONE`, to override the default link e.g. >lua
+    :hi! link NvimTreeExecFile NONE
+<
 ==============================================================================
  8.1 HIGHLIGHT: DEFAULT                          *nvim-tree-highlight-default*
 
@@ -2587,7 +2605,7 @@ See |nvim-tree-legacy-highlight| for old highlight group compatibility.
 - NvimTreeSpecialFile  PreProc   -> SpellCap
 - NvimTreeSymlink      Statement -> SpellCap
 
-Approximate pre-overhaul values for the `SpellCap` groups may be set via: >
+Approximate pre-overhaul values for the `SpellCap` groups may be set via: >lua
 
     vim.cmd([[
         :hi NvimTreeExecFile    gui=bold           guifg=#ffa0a0
@@ -2614,7 +2632,8 @@ to |nvim_tree_registering_handlers| for more information.
 Handlers are registered by calling |nvim-tree-api.events.subscribe()|
 function with an |nvim-tree-api.events.Event|
 
-e.g. handler for node renamed: >
+e.g. handler for node renamed: >lua
+
     local api = require("nvim-tree.api")
     local Event = api.events.Event
 
@@ -2701,7 +2720,8 @@ There are two special startup events in the form of User autocommands:
 Immediately before firing: a global variable of the same name will be set to a
 value of 1.
 
-Example subscription: >
+Example subscription: >lua
+
   vim.api.nvim_create_autocmd("User", {
     pattern = "NvimTreeRequired",
     callback = function(data)
@@ -2742,6 +2762,9 @@ Windows WSL and PowerShell
 - Executable file detection is disabled as this is non-performant and can
   freeze nvim
 - Some filesystem watcher error related to permissions will not be reported
+- Some users have reported unspecified issues with
+  |nvim-tree.experimental.actions.open_file.relative_path|. Please report any
+  issues or disable this feature.
 
 ==============================================================================
  12. NETRW                                                   *nvim-tree-netrw*
@@ -2753,7 +2776,7 @@ It interferes with nvim-tree and the intended user experience is nvim-tree
 replacing the |netrw| browser.
 
 It is strongly recommended to disable |netrw|. As it is a bundled plugin it
-must be disabled manually at the start of your `init.lua` as per |netrw-noload|: >
+must be disabled manually at the start of your `init.lua` as per |netrw-noload|: >lua
 
   vim.g.loaded_netrw       = 1
   vim.g.loaded_netrwPlugin = 1
@@ -3020,6 +3043,7 @@ highlight group is not, hard linking as follows: >
 |nvim-tree-api.events.subscribe()|
 |nvim-tree-api.fs.clear_clipboard()|
 |nvim-tree-api.fs.copy.absolute_path()|
+|nvim-tree-api.fs.copy.basename()|
 |nvim-tree-api.fs.copy.filename()|
 |nvim-tree-api.fs.copy.node()|
 |nvim-tree-api.fs.copy.relative_path()|

lua/nvim-tree.lua

@@ -1,16 +1,9 @@
-local lib = require "nvim-tree.lib"
+local log = require("nvim-tree.log")
-local log = require "nvim-tree.log"
+local view = require("nvim-tree.view")
-local appearance = require "nvim-tree.appearance"
+local utils = require("nvim-tree.utils")
-local renderer = require "nvim-tree.renderer"
+local actions = require("nvim-tree.actions")
-local view = require "nvim-tree.view"
+local core = require("nvim-tree.core")
-local commands = require "nvim-tree.commands"
+local notify = require("nvim-tree.notify")
-local utils = require "nvim-tree.utils"
-local actions = require "nvim-tree.actions"
-local legacy = require "nvim-tree.legacy"
-local core = require "nvim-tree.core"
-local git = require "nvim-tree.git"
-local buffers = require "nvim-tree.buffers"
-local notify = require "nvim-tree.notify"
 
 local _config = {}
 
@@ -26,7 +19,7 @@ function M.change_root(path, bufnr)
   if type(bufnr) == "number" then
     local ft
 
-    if vim.fn.has "nvim-0.10" == 1 then
+    if vim.fn.has("nvim-0.10") == 1 then
       ft = vim.api.nvim_get_option_value("filetype", { buf = bufnr }) or ""
     else
       ft = vim.api.nvim_buf_get_option(bufnr, "filetype") or "" ---@diagnostic disable-line: deprecated
@@ -81,11 +74,11 @@ function M.change_root(path, bufnr)
 end
 
 function M.tab_enter()
-  if view.is_visible { any_tabpage = true } then
+  if view.is_visible({ any_tabpage = true }) then
     local bufname = vim.api.nvim_buf_get_name(0)
 
     local ft
-    if vim.fn.has "nvim-0.10" == 1 then
+    if vim.fn.has("nvim-0.10") == 1 then
       ft = vim.api.nvim_get_option_value("filetype", { buf = 0 }) or ""
     else
       ft = vim.api.nvim_buf_get_option(0, "ft") ---@diagnostic disable-line: deprecated
@@ -96,8 +89,12 @@ function M.tab_enter()
         return
       end
     end
-    view.open { focus_tree = false }
+    view.open({ focus_tree = false })
-    renderer.draw()
+
+    local explorer = core.get_explorer()
+    if explorer then
+      explorer.renderer:draw()
+    end
   end
 end
 
@@ -116,27 +113,6 @@ function M.open_on_directory()
   actions.root.change_dir.force_dirchange(bufname, true)
 end
 
-function M.place_cursor_on_node()
-  local ok, search = pcall(vim.fn.searchcount)
-  if ok and search and search.exact_match == 1 then
-    return
-  end
-
-  local node = lib.get_node_at_cursor()
-  if not node or node.name == ".." then
-    return
-  end
-  node = utils.get_parent_of_group(node)
-
-  local line = vim.api.nvim_get_current_line()
-  local cursor = vim.api.nvim_win_get_cursor(0)
-  local idx = vim.fn.stridx(line, node.name)
-
-  if idx >= 0 then
-    vim.api.nvim_win_set_cursor(0, { cursor[1], idx })
-  end
-end
-
 ---@return table
 function M.get_config()
   return M.config
@@ -146,8 +122,8 @@ end
 ---@param hijack_netrw boolean
 local function manage_netrw(disable_netrw, hijack_netrw)
   if hijack_netrw then
-    vim.cmd "silent! autocmd! FileExplorer *"
+    vim.cmd("silent! autocmd! FileExplorer *")
-    vim.cmd "autocmd VimEnter * ++once silent! autocmd! FileExplorer *"
+    vim.cmd("autocmd VimEnter * ++once silent! autocmd! FileExplorer *")
   end
   if disable_netrw then
     vim.g.loaded_netrw = 1
@@ -174,15 +150,6 @@ local function setup_autocommands(opts)
     vim.api.nvim_create_autocmd(name, vim.tbl_extend("force", default_opts, custom_opts))
   end
 
-  -- reset and draw (highlights) when colorscheme is changed
-  create_nvim_tree_autocmd("ColorScheme", {
-    callback = function()
-      appearance.setup()
-      view.reset_winhl()
-      renderer.draw()
-    end,
-  })
-
   -- prevent new opened file from opening in the same window as nvim-tree
   create_nvim_tree_autocmd("BufWipeout", {
     pattern = "NvimTree_*",
@@ -198,70 +165,9 @@ local function setup_autocommands(opts)
     end,
   })
 
-  create_nvim_tree_autocmd("BufWritePost", {
-    callback = function()
-      if opts.auto_reload_on_write and not opts.filesystem_watchers.enable then
-        actions.reloaders.reload_explorer()
-      end
-    end,
-  })
-
-  create_nvim_tree_autocmd("BufReadPost", {
-    callback = function(data)
-      -- update opened file buffers
-      local explorer = core.get_explorer()
-      if not explorer then
-        return
-      end
-      if
-        (explorer.filters.config.filter_no_buffer or renderer.config.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == ""
-      then
-        utils.debounce("Buf:filter_buffer", opts.view.debounce_delay, function()
-          actions.reloaders.reload_explorer()
-        end)
-      end
-    end,
-  })
-
-  create_nvim_tree_autocmd("BufUnload", {
-    callback = function(data)
-      -- update opened file buffers
-      local explorer = core.get_explorer()
-      if not explorer then
-        return
-      end
-      if
-        (explorer.filters.config.filter_no_buffer or renderer.config.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == ""
-      then
-        utils.debounce("Buf:filter_buffer", opts.view.debounce_delay, function()
-          actions.reloaders.reload_explorer()
-        end)
-      end
-    end,
-  })
-
-  create_nvim_tree_autocmd("User", {
-    pattern = { "FugitiveChanged", "NeogitStatusRefreshed" },
-    callback = function()
-      if not opts.filesystem_watchers.enable and opts.git.enable then
-        actions.reloaders.reload_git()
-      end
-    end,
-  })
-
   if opts.tab.sync.open then
     create_nvim_tree_autocmd("TabEnter", { callback = vim.schedule_wrap(M.tab_enter) })
   end
-  if opts.hijack_cursor then
-    create_nvim_tree_autocmd("CursorMoved", {
-      pattern = "NvimTree_*",
-      callback = function()
-        if utils.is_nvim_tree_buf(0) then
-          M.place_cursor_on_node()
-        end
-      end,
-    })
-  end
   if opts.sync_root_with_cwd then
     create_nvim_tree_autocmd("DirChanged", {
       callback = function()
@@ -287,24 +193,13 @@ local function setup_autocommands(opts)
     create_nvim_tree_autocmd({ "BufEnter", "BufNewFile" }, { callback = M.open_on_directory })
   end
 
-  create_nvim_tree_autocmd("BufEnter", {
-    pattern = "NvimTree_*",
-    callback = function()
-      if utils.is_nvim_tree_buf(0) then
-        if vim.fn.getcwd() ~= core.get_cwd() or (opts.reload_on_bufenter and not opts.filesystem_watchers.enable) then
-          actions.reloaders.reload_explorer()
-        end
-      end
-    end,
-  })
-
   if opts.view.centralize_selection then
     create_nvim_tree_autocmd("BufEnter", {
       pattern = "NvimTree_*",
       callback = function()
         vim.schedule(function()
           vim.api.nvim_buf_call(0, function()
-            vim.cmd [[norm! zz]]
+            vim.cmd([[norm! zz]])
           end)
         end)
       end,
@@ -337,17 +232,6 @@ local function setup_autocommands(opts)
       end,
     })
   end
-
-  if opts.modified.enable then
-    create_nvim_tree_autocmd({ "BufModifiedSet", "BufWritePost" }, {
-      callback = function()
-        utils.debounce("Buf:modified", opts.view.debounce_delay, function()
-          buffers.reload_modified()
-          actions.reloaders.reload_explorer()
-        end)
-      end,
-    })
-  end
 end
 
 local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
@@ -536,7 +420,12 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
   filesystem_watchers = {
     enable = true,
     debounce_delay = 50,
-    ignore_dirs = {},
+    ignore_dirs = {
+      "/.ccls-cache",
+      "/build",
+      "/node_modules",
+      "/target",
+    },
   },
   actions = {
     use_system_clipboard = true,
@@ -562,6 +451,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
       quit_on_open = false,
       eject = true,
       resize_window = true,
+      relative_path = true,
       window_picker = {
         enable = true,
         picker = "default",
@@ -601,11 +491,6 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
     },
   },
   experimental = {
-    actions = {
-      open_file = {
-        relative_path = false,
-      },
-    },
   },
   log = {
     enable = false,
@@ -785,19 +670,22 @@ local function localise_default_opts()
 end
 
 function M.purge_all_state()
-  require("nvim-tree.watcher").purge_watchers()
   view.close_all_tabs()
   view.abandon_all_windows()
-  if core.get_explorer() ~= nil then
+  local explorer = core.get_explorer()
-    git.purge_state()
+  if explorer then
+    require("nvim-tree.git").purge_state()
+    explorer:destroy()
     core.reset_explorer()
   end
+  -- purge orphaned that were not destroyed by their nodes
+  require("nvim-tree.watcher").purge_watchers()
 end
 
 ---@param conf table|nil
 function M.setup(conf)
-  if vim.fn.has "nvim-0.9" == 0 then
+  if vim.fn.has("nvim-0.9") == 0 then
-    notify.warn "nvim-tree.lua requires Neovim 0.9 or higher"
+    notify.warn("nvim-tree.lua requires Neovim 0.9 or higher")
     return
   end
 
@@ -805,7 +693,7 @@ function M.setup(conf)
 
   localise_default_opts()
 
-  legacy.migrate_legacy_options(conf or {})
+  require("nvim-tree.legacy").migrate_legacy_options(conf or {})
 
   validate_options(conf)
 
@@ -825,7 +713,7 @@ function M.setup(conf)
   require("nvim-tree.notify").setup(opts)
   require("nvim-tree.log").setup(opts)
 
-  if log.enabled "config" then
+  if log.enabled("config") then
     log.line("config", "default config + user")
     log.raw("config", "%s\n", vim.inspect(opts))
   end
@@ -834,24 +722,22 @@ function M.setup(conf)
   require("nvim-tree.keymap").setup(opts)
   require("nvim-tree.appearance").setup()
   require("nvim-tree.diagnostics").setup(opts)
-  require("nvim-tree.explorer").setup(opts)
+  require("nvim-tree.explorer"):setup(opts)
+  require("nvim-tree.explorer.watch").setup(opts)
   require("nvim-tree.git").setup(opts)
   require("nvim-tree.git.utils").setup(opts)
   require("nvim-tree.view").setup(opts)
   require("nvim-tree.lib").setup(opts)
-  require("nvim-tree.renderer").setup(opts)
+  require("nvim-tree.renderer.components").setup(opts)
   require("nvim-tree.buffers").setup(opts)
   require("nvim-tree.help").setup(opts)
   require("nvim-tree.watcher").setup(opts)
-  if M.config.renderer.icons.show.file and pcall(require, "nvim-web-devicons") then
-    require("nvim-web-devicons").setup()
-  end
 
   setup_autocommands(opts)
 
   if vim.g.NvimTreeSetup ~= 1 then
     -- first call to setup
-    commands.setup()
+    require("nvim-tree.commands").setup()
   else
     -- subsequent calls to setup
     M.purge_all_state()

lua/nvim-tree/actions/finders/find-file.lua

@@ -1,9 +1,10 @@
-local log = require "nvim-tree.log"
+local log = require("nvim-tree.log")
-local view = require "nvim-tree.view"
+local view = require("nvim-tree.view")
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local renderer = require "nvim-tree.renderer"
+local core = require("nvim-tree.core")
-local core = require "nvim-tree.core"
+
-local Iterator = require "nvim-tree.iterators.node-iterator"
+local DirectoryNode = require("nvim-tree.node.directory")
+local Iterator = require("nvim-tree.iterators.node-iterator")
 
 local M = {}
 
@@ -59,25 +60,33 @@ function M.fn(path)
       local link_match = node.link_to and vim.startswith(path_real, node.link_to .. utils.path_separator)
 
       if abs_match or link_match then
-        if not node.group_next then
+        local dir = node:as(DirectoryNode)
-          node.open = true
+        if dir then
-        end
+          if not dir.group_next then
-        if #node.nodes == 0 then
+            dir.open = true
-          core.get_explorer():expand(node)
+          end
-          if node.group_next and incremented_line then
+          if #dir.nodes == 0 then
-            line = line - 1
+            core.get_explorer():expand(dir)
+            if dir.group_next and incremented_line then
+              line = line - 1
+            end
           end
         end
       end
     end)
     :recursor(function(node)
-      return node.group_next and { node.group_next } or (node.open and #node.nodes > 0 and node.nodes)
+      node = node and node:as(DirectoryNode)
+      if node then
+        return node.group_next and { node.group_next } or (node.open and #node.nodes > 0 and node.nodes)
+      else
+        return nil
+      end
     end)
     :iterate()
 
   if found and view.is_visible() then
-    renderer.draw()
+    explorer.renderer:draw()
-    view.set_cursor { line, 0 }
+    view.set_cursor({ line, 0 })
   end
 
   running[path_real] = false

lua/nvim-tree/actions/finders/init.lua

@@ -1,6 +1,6 @@
 local M = {}
 
-M.find_file = require "nvim-tree.actions.finders.find-file"
+M.find_file = require("nvim-tree.actions.finders.find-file")
-M.search_node = require "nvim-tree.actions.finders.search-node"
+M.search_node = require("nvim-tree.actions.finders.search-node")
 
 return M

lua/nvim-tree/actions/finders/search-node.lua

@@ -1,4 +1,4 @@
-local core = require "nvim-tree.core"
+local core = require("nvim-tree.core")
 local find_file = require("nvim-tree.actions.finders.find-file").fn
 
 local M = {}
@@ -75,7 +75,7 @@ function M.fn()
   local bufnr = vim.api.nvim_get_current_buf()
 
   local path_existed, path_opt
-  if vim.fn.has "nvim-0.10" == 1 then
+  if vim.fn.has("nvim-0.10") == 1 then
     path_existed, path_opt = pcall(vim.api.nvim_get_option_value, "path", { buf = bufnr })
     vim.api.nvim_set_option_value("path", core.get_cwd() .. "/**", { buf = bufnr })
   else
@@ -89,13 +89,13 @@ function M.fn()
     end
     -- reset &path
     if path_existed then
-      if vim.fn.has "nvim-0.10" == 1 then
+      if vim.fn.has("nvim-0.10") == 1 then
         vim.api.nvim_set_option_value("path", path_opt, { buf = bufnr })
       else
         vim.api.nvim_buf_set_option(bufnr, "path", path_opt) ---@diagnostic disable-line: deprecated
       end
     else
-      if vim.fn.has "nvim-0.10" == 1 then
+      if vim.fn.has("nvim-0.10") == 1 then
         vim.api.nvim_set_option_value("path", nil, { buf = bufnr })
       else
         vim.api.nvim_buf_set_option(bufnr, "path", nil) ---@diagnostic disable-line: deprecated

lua/nvim-tree/actions/fs/clipboard.lua

@@ -1,45 +1,45 @@
-local lib = require "nvim-tree.lib"
+local lib = require("nvim-tree.lib")
-local log = require "nvim-tree.log"
+local log = require("nvim-tree.log")
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local core = require "nvim-tree.core"
+local core = require("nvim-tree.core")
-local events = require "nvim-tree.events"
+local events = require("nvim-tree.events")
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
-local renderer = require "nvim-tree.renderer"
-local reloaders = require "nvim-tree.actions.reloaders"
 
 local find_file = require("nvim-tree.actions.finders.find-file").fn
 
----@enum ACTION
+local Class = require("nvim-tree.classic")
-local ACTION = {
+local DirectoryNode = require("nvim-tree.node.directory")
-  copy = "copy",
-  cut = "cut",
-}
 
----@class Clipboard to handle all actions.fs clipboard API
+---@alias ClipboardAction "copy" | "cut"
----@field config table hydrated user opts.filters
+---@alias ClipboardData table<ClipboardAction, Node[]>
+
+---@alias ClipboardActionFn fun(source: string, dest: string): boolean, string?
+
+---@class (exact) Clipboard: Class
 ---@field private explorer Explorer
----@field private data table<ACTION, Node[]>
+---@field private data ClipboardData
-local Clipboard = {}
+---@field private clipboard_name string
+---@field private reg string
+local Clipboard = Class:extend()
 
----@param opts table user options
+---@class Clipboard
----@param explorer Explorer
+---@overload fun(args: ClipboardArgs): Clipboard
----@return Clipboard
+
-function Clipboard:new(opts, explorer)
+---@class (exact) ClipboardArgs
-  local o = {
+---@field explorer Explorer
-    explorer = explorer,
+
-    data = {
+---@protected
-      [ACTION.copy] = {},
+---@param args ClipboardArgs
-      [ACTION.cut] = {},
+function Clipboard:new(args)
-    },
+  self.explorer = args.explorer
-    config = {
+
-      filesystem_watchers = opts.filesystem_watchers,
+  self.data = {
-      actions = opts.actions,
+    copy = {},
-    },
+    cut = {},
   }
 
-  setmetatable(o, self)
+  self.clipboard_name = self.explorer.opts.actions.use_system_clipboard and "system" or "neovim"
-  self.__index = self
+  self.reg = self.explorer.opts.actions.use_system_clipboard and "+" or "1"
-  return o
 end
 
 ---@param source string
@@ -47,13 +47,11 @@ end
 ---@return boolean
 ---@return string|nil
 local function do_copy(source, destination)
-  local source_stats, handle
+  local source_stats, err = vim.loop.fs_stat(source)
-  local success, errmsg
 
-  source_stats, errmsg = vim.loop.fs_stat(source)
   if not source_stats then
-    log.line("copy_paste", "do_copy fs_stat '%s' failed '%s'", source, errmsg)
+    log.line("copy_paste", "do_copy fs_stat '%s' failed '%s'", source, err)
-    return false, errmsg
+    return false, err
   end
 
   log.line("copy_paste", "do_copy %s '%s' -> '%s'", source_stats.type, source, destination)
@@ -64,25 +62,28 @@ local function do_copy(source, destination)
   end
 
   if source_stats.type == "file" then
-    success, errmsg = vim.loop.fs_copyfile(source, destination)
+    local success
+    success, err = vim.loop.fs_copyfile(source, destination)
     if not success then
-      log.line("copy_paste", "do_copy fs_copyfile failed '%s'", errmsg)
+      log.line("copy_paste", "do_copy fs_copyfile failed '%s'", err)
-      return false, errmsg
+      return false, err
     end
     return true
   elseif source_stats.type == "directory" then
-    handle, errmsg = vim.loop.fs_scandir(source)
+    local handle
+    handle, err = vim.loop.fs_scandir(source)
     if type(handle) == "string" then
       return false, handle
     elseif not handle then
-      log.line("copy_paste", "do_copy fs_scandir '%s' failed '%s'", source, errmsg)
+      log.line("copy_paste", "do_copy fs_scandir '%s' failed '%s'", source, err)
-      return false, errmsg
+      return false, err
     end
 
-    success, errmsg = vim.loop.fs_mkdir(destination, source_stats.mode)
+    local success
+    success, err = vim.loop.fs_mkdir(destination, source_stats.mode)
     if not success then
-      log.line("copy_paste", "do_copy fs_mkdir '%s' failed '%s'", destination, errmsg)
+      log.line("copy_paste", "do_copy fs_mkdir '%s' failed '%s'", destination, err)
-      return false, errmsg
+      return false, err
     end
 
     while true do
@@ -91,17 +92,17 @@ local function do_copy(source, destination)
         break
       end
 
-      local new_name = utils.path_join { source, name }
+      local new_name = utils.path_join({ source, name })
-      local new_destination = utils.path_join { destination, name }
+      local new_destination = utils.path_join({ destination, name })
-      success, errmsg = do_copy(new_name, new_destination)
+      success, err = do_copy(new_name, new_destination)
       if not success then
-        return false, errmsg
+        return false, err
       end
     end
   else
-    errmsg = string.format("'%s' illegal file type '%s'", source, source_stats.type)
+    err = string.format("'%s' illegal file type '%s'", source, source_stats.type)
-    log.line("copy_paste", "do_copy %s", errmsg)
+    log.line("copy_paste", "do_copy %s", err)
-    return false, errmsg
+    return false, err
   end
 
   return true
@@ -109,28 +110,26 @@ end
 
 ---@param source string
 ---@param dest string
----@param action ACTION
+---@param action ClipboardAction
----@param action_fn fun(source: string, dest: string)
+---@param action_fn ClipboardActionFn
 ---@return boolean|nil -- success
 ---@return string|nil -- error message
 local function do_single_paste(source, dest, action, action_fn)
-  local dest_stats
-  local success, errmsg, errcode
   local notify_source = notify.render_path(source)
 
   log.line("copy_paste", "do_single_paste '%s' -> '%s'", source, dest)
 
-  dest_stats, errmsg, errcode = vim.loop.fs_stat(dest)
+  local dest_stats, err, err_name = vim.loop.fs_stat(dest)
-  if not dest_stats and errcode ~= "ENOENT" then
+  if not dest_stats and err_name ~= "ENOENT" then
-    notify.error("Could not " .. action .. " " .. notify_source .. " - " .. (errmsg or "???"))
+    notify.error("Could not " .. action .. " " .. notify_source .. " - " .. (err or "???"))
-    return false, errmsg
+    return false, err
   end
 
   local function on_process()
-    success, errmsg = action_fn(source, dest)
+    local success, error = action_fn(source, dest)
     if not success then
-      notify.error("Could not " .. action .. " " .. notify_source .. " - " .. (errmsg or "???"))
+      notify.error("Could not " .. action .. " " .. notify_source .. " - " .. (error or "???"))
-      return false, errmsg
+      return false, error
     end
 
     find_file(utils.path_remove_trailing(dest))
@@ -173,7 +172,7 @@ local function do_single_paste(source, dest, action, action_fn)
 end
 
 ---@param node Node
----@param clip table
+---@param clip ClipboardData
 local function toggle(node, clip)
   if node.name == ".." then
     return
@@ -191,38 +190,41 @@ end
 
 ---Clear copied and cut
 function Clipboard:clear_clipboard()
-  self.data[ACTION.copy] = {}
+  self.data.copy = {}
-  self.data[ACTION.cut] = {}
+  self.data.cut = {}
-  notify.info "Clipboard has been emptied."
+  notify.info("Clipboard has been emptied.")
-  renderer.draw()
+  self.explorer.renderer:draw()
 end
 
 ---Copy one node
 ---@param node Node
 function Clipboard:copy(node)
-  utils.array_remove(self.data[ACTION.cut], node)
+  utils.array_remove(self.data.cut, node)
-  toggle(node, self.data[ACTION.copy])
+  toggle(node, self.data.copy)
-  renderer.draw()
+  self.explorer.renderer:draw()
 end
 
 ---Cut one node
 ---@param node Node
 function Clipboard:cut(node)
-  utils.array_remove(self.data[ACTION.copy], node)
+  utils.array_remove(self.data.copy, node)
-  toggle(node, self.data[ACTION.cut])
+  toggle(node, self.data.cut)
-  renderer.draw()
+  self.explorer.renderer:draw()
 end
 
 ---Paste cut or cop
 ---@private
 ---@param node Node
----@param action ACTION
+---@param action ClipboardAction
----@param action_fn fun(source: string, dest: string)
+---@param action_fn ClipboardActionFn
 function Clipboard:do_paste(node, action, action_fn)
-  node = lib.get_last_group_node(node)
+  if node.name == ".." then
-  local explorer = core.get_explorer()
+    node = self.explorer
-  if node.name == ".." and explorer then
+  else
-    node = explorer
+    local dir = node:as(DirectoryNode)
+    if dir then
+      node = dir:last_group_node()
+    end
   end
   local clip = self.data[action]
   if #clip == 0 then
@@ -230,10 +232,10 @@ function Clipboard:do_paste(node, action, action_fn)
   end
 
   local destination = node.absolute_path
-  local stats, errmsg, errcode = vim.loop.fs_stat(destination)
+  local stats, err, err_name = vim.loop.fs_stat(destination)
-  if not stats and errcode ~= "ENOENT" then
+  if not stats and err_name ~= "ENOENT" then
-    log.line("copy_paste", "do_paste fs_stat '%s' failed '%s'", destination, errmsg)
+    log.line("copy_paste", "do_paste fs_stat '%s' failed '%s'", destination, err)
-    notify.error("Could not " .. action .. " " .. notify.render_path(destination) .. " - " .. (errmsg or "???"))
+    notify.error("Could not " .. action .. " " .. notify.render_path(destination) .. " - " .. (err or "???"))
     return
   end
   local is_dir = stats and stats.type == "directory"
@@ -242,13 +244,13 @@ function Clipboard:do_paste(node, action, action_fn)
   end
 
   for _, _node in ipairs(clip) do
-    local dest = utils.path_join { destination, _node.name }
+    local dest = utils.path_join({ destination, _node.name })
     do_single_paste(_node.absolute_path, dest, action, action_fn)
   end
 
   self.data[action] = {}
-  if not self.config.filesystem_watchers.enable then
+  if not self.explorer.opts.filesystem_watchers.enable then
-    reloaders.reload_explorer()
+    self.explorer:reload_explorer()
   end
 end
 
@@ -278,24 +280,24 @@ end
 ---Paste cut (if present) or copy (if present)
 ---@param node Node
 function Clipboard:paste(node)
-  if self.data[ACTION.cut][1] ~= nil then
+  if self.data.cut[1] ~= nil then
-    self:do_paste(node, ACTION.cut, do_cut)
+    self:do_paste(node, "cut", do_cut)
-  elseif self.data[ACTION.copy][1] ~= nil then
+  elseif self.data.copy[1] ~= nil then
-    self:do_paste(node, ACTION.copy, do_copy)
+    self:do_paste(node, "copy", do_copy)
   end
 end
 
 function Clipboard:print_clipboard()
   local content = {}
-  if #self.data[ACTION.cut] > 0 then
+  if #self.data.cut > 0 then
     table.insert(content, "Cut")
-    for _, node in pairs(self.data[ACTION.cut]) do
+    for _, node in pairs(self.data.cut) do
       table.insert(content, " * " .. (notify.render_path(node.absolute_path)))
     end
   end
-  if #self.data[ACTION.copy] > 0 then
+  if #self.data.copy > 0 then
     table.insert(content, "Copy")
-    for _, node in pairs(self.data[ACTION.copy]) do
+    for _, node in pairs(self.data.copy) do
       table.insert(content, " * " .. (notify.render_path(node.absolute_path)))
     end
   end
@@ -305,54 +307,68 @@ end
 
 ---@param content string
 function Clipboard:copy_to_reg(content)
-  local clipboard_name
-  local reg
-  if self.config.actions.use_system_clipboard == true then
-    clipboard_name = "system"
-    reg = "+"
-  else
-    clipboard_name = "neovim"
-    reg = "1"
-  end
-
   -- manually firing TextYankPost does not set vim.v.event
   -- workaround: create a scratch buffer with the clipboard contents and send a yank command
   local temp_buf = vim.api.nvim_create_buf(false, true)
   vim.api.nvim_buf_set_text(temp_buf, 0, 0, 0, 0, { content })
   vim.api.nvim_buf_call(temp_buf, function()
-    vim.cmd(string.format('normal! "%sy$', reg))
+    vim.cmd(string.format('normal! "%sy$', self.reg))
   end)
   vim.api.nvim_buf_delete(temp_buf, {})
 
-  notify.info(string.format("Copied %s to %s clipboard!", content, clipboard_name))
+  notify.info(string.format("Copied %s to %s clipboard!", content, self.clipboard_name))
 end
 
 ---@param node Node
 function Clipboard:copy_filename(node)
-  self:copy_to_reg(node.name)
+  if node.name == ".." then
+    -- root
+    self:copy_to_reg(vim.fn.fnamemodify(self.explorer.absolute_path, ":t"))
+  else
+    -- node
+    self:copy_to_reg(node.name)
+  end
 end
 
 ---@param node Node
 function Clipboard:copy_basename(node)
-  local basename = vim.fn.fnamemodify(node.name, ":r")
+  if node.name == ".." then
-  self:copy_to_reg(basename)
+    -- root
+    self:copy_to_reg(vim.fn.fnamemodify(self.explorer.absolute_path, ":t:r"))
+  else
+    -- node
+    self:copy_to_reg(vim.fn.fnamemodify(node.name, ":r"))
+  end
 end
 
 ---@param node Node
 function Clipboard:copy_path(node)
-  local absolute_path = node.absolute_path
+  if node.name == ".." then
-  local cwd = core.get_cwd()
+    -- root
-  if cwd == nil then
+    self:copy_to_reg(utils.path_add_trailing(""))
-    return
+  else
-  end
+    -- node
+    local absolute_path = node.absolute_path
+    local cwd = core.get_cwd()
+    if cwd == nil then
+      return
+    end
 
-  local relative_path = utils.path_relative(absolute_path, cwd)
+    local relative_path = utils.path_relative(absolute_path, cwd)
-  local content = node.nodes ~= nil and utils.path_add_trailing(relative_path) or relative_path
+    if node:is(DirectoryNode) then
-  self:copy_to_reg(content)
+      self:copy_to_reg(utils.path_add_trailing(relative_path))
+    else
+      self:copy_to_reg(relative_path)
+    end
+  end
 end
 
 ---@param node Node
 function Clipboard:copy_absolute_path(node)
+  if node.name == ".." then
+    node = self.explorer
+  end
+
   local absolute_path = node.absolute_path
   local content = node.nodes ~= nil and utils.path_add_trailing(absolute_path) or absolute_path
   self:copy_to_reg(content)
@@ -362,14 +378,14 @@ end
 ---@param node Node
 ---@return boolean
 function Clipboard:is_cut(node)
-  return vim.tbl_contains(self.data[ACTION.cut], node)
+  return vim.tbl_contains(self.data.cut, node)
 end
 
 ---Node is copied. Will not be cut.
 ---@param node Node
 ---@return boolean
 function Clipboard:is_copied(node)
-  return vim.tbl_contains(self.data[ACTION.copy], node)
+  return vim.tbl_contains(self.data.copy, node)
 end
 
 return Clipboard

lua/nvim-tree/actions/fs/create-file.lua

@@ -1,11 +1,13 @@
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local events = require "nvim-tree.events"
+local events = require("nvim-tree.events")
-local lib = require "nvim-tree.lib"
+local core = require("nvim-tree.core")
-local core = require "nvim-tree.core"
+local notify = require("nvim-tree.notify")
-local notify = require "nvim-tree.notify"
 
 local find_file = require("nvim-tree.actions.finders.find-file").fn
 
+local FileNode = require("nvim-tree.node.file")
+local DirectoryNode = require("nvim-tree.node.directory")
+
 local M = {}
 
 ---@param file string
@@ -30,34 +32,21 @@ local function get_num_nodes(iter)
   return i
 end
 
----@param node Node
+---@param node Node?
----@return string
-local function get_containing_folder(node)
-  if node.nodes ~= nil then
-    return utils.path_add_trailing(node.absolute_path)
-  end
-  local node_name_size = #(node.name or "")
-  return node.absolute_path:sub(0, -node_name_size - 1)
-end
-
----@param node Node|nil
 function M.fn(node)
-  local cwd = core.get_cwd()
+  node = node or core.get_explorer()
-  if cwd == nil then
+  if not node then
     return
   end
 
-  node = node and lib.get_last_group_node(node)
+  local dir = node:is(FileNode) and node.parent or node:as(DirectoryNode)
-  if not node or node.name == ".." then
+  if not dir then
-    node = {
+    return
-      absolute_path = cwd,
-      name = "",
-      nodes = core.get_explorer().nodes,
-      open = true,
-    }
   end
 
-  local containing_folder = get_containing_folder(node)
+  dir = dir:last_group_node()
+
+  local containing_folder = utils.path_add_trailing(dir.absolute_path)
 
   local input_opts = {
     prompt = "Create file ",
@@ -72,7 +61,7 @@ function M.fn(node)
     end
 
     if utils.file_exists(new_file_path) then
-      notify.warn "Cannot create: file already exists"
+      notify.warn("Cannot create: file already exists")
       return
     end
 
@@ -87,10 +76,10 @@ function M.fn(node)
     for path in utils.path_split(new_file_path) do
       idx = idx + 1
       local p = utils.path_remove_trailing(path)
-      if #path_to_create == 0 and vim.fn.has "win32" == 1 then
+      if #path_to_create == 0 and vim.fn.has("win32") == 1 then
-        path_to_create = utils.path_join { p, path_to_create }
+        path_to_create = utils.path_join({ p, path_to_create })
       else
-        path_to_create = utils.path_join { path_to_create, p }
+        path_to_create = utils.path_join({ path_to_create, p })
       end
       if is_last_path_file and idx == num_nodes then
         create_and_notify(path_to_create)

lua/nvim-tree/actions/fs/init.lua

@@ -1,9 +1,9 @@
 local M = {}
 
-M.create_file = require "nvim-tree.actions.fs.create-file"
+M.create_file = require("nvim-tree.actions.fs.create-file")
-M.remove_file = require "nvim-tree.actions.fs.remove-file"
+M.remove_file = require("nvim-tree.actions.fs.remove-file")
-M.rename_file = require "nvim-tree.actions.fs.rename-file"
+M.rename_file = require("nvim-tree.actions.fs.rename-file")
-M.trash = require "nvim-tree.actions.fs.trash"
+M.trash = require("nvim-tree.actions.fs.trash")
 
 function M.setup(opts)
   M.remove_file.setup(opts)

lua/nvim-tree/actions/fs/remove-file.lua

@@ -1,8 +1,12 @@
-local utils = require "nvim-tree.utils"
+local core = require("nvim-tree.core")
-local events = require "nvim-tree.events"
+local utils = require("nvim-tree.utils")
-local view = require "nvim-tree.view"
+local events = require("nvim-tree.events")
-local lib = require "nvim-tree.lib"
+local view = require("nvim-tree.view")
-local notify = require "nvim-tree.notify"
+local lib = require("nvim-tree.lib")
+local notify = require("nvim-tree.notify")
+
+local DirectoryLinkNode = require("nvim-tree.node.directory-link")
+local DirectoryNode = require("nvim-tree.node.directory")
 
 local M = {
   config = {},
@@ -26,13 +30,13 @@ end
 
 ---@param absolute_path string
 local function clear_buffer(absolute_path)
-  local bufs = vim.fn.getbufinfo { bufloaded = 1, buflisted = 1 }
+  local bufs = vim.fn.getbufinfo({ bufloaded = 1, buflisted = 1 })
   for _, buf in pairs(bufs) do
     if buf.name == absolute_path then
       local tree_winnr = vim.api.nvim_get_current_win()
       if buf.hidden == 0 and (#bufs > 1 or view.View.float.enable) then
         vim.api.nvim_set_current_win(buf.windows[1])
-        vim.cmd ":bn"
+        vim.cmd(":bn")
       end
       vim.api.nvim_buf_delete(buf.bufnr, { force = true })
       if not view.View.float.quit_on_focus_loss then
@@ -61,7 +65,7 @@ local function remove_dir(cwd)
       break
     end
 
-    local new_cwd = utils.path_join { cwd, name }
+    local new_cwd = utils.path_join({ cwd, name })
 
     -- Type must come from fs_stat and not fs_scandir_next to maintain sshfs compatibility
     local stat = vim.loop.fs_stat(new_cwd)
@@ -88,7 +92,7 @@ end
 ---@param node Node
 function M.remove(node)
   local notify_node = notify.render_path(node.absolute_path)
-  if node.nodes ~= nil and not node.link_to then
+  if node:is(DirectoryNode) and not node:is(DirectoryLinkNode) then
     local success = remove_dir(node.absolute_path)
     if not success then
       notify.error("Could not remove " .. notify_node)
@@ -116,8 +120,9 @@ function M.fn(node)
 
   local function do_remove()
     M.remove(node)
-    if not M.config.filesystem_watchers.enable then
+    local explorer = core.get_explorer()
-      require("nvim-tree.actions.reloaders").reload_explorer()
+    if not M.config.filesystem_watchers.enable and explorer then
+      explorer:reload_explorer()
     end
   end
 

lua/nvim-tree/actions/fs/rename-file.lua

@@ -1,10 +1,12 @@
-local lib = require "nvim-tree.lib"
+local core = require("nvim-tree.core")
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local events = require "nvim-tree.events"
+local events = require("nvim-tree.events")
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
 
 local find_file = require("nvim-tree.actions.finders.find-file").fn
 
+local DirectoryNode = require("nvim-tree.node.directory")
+
 local M = {
   config = {},
 }
@@ -63,10 +65,10 @@ function M.rename(node, to)
     idx = idx + 1
 
     local p = utils.path_remove_trailing(path)
-    if #path_to_create == 0 and vim.fn.has "win32" == 1 then
+    if #path_to_create == 0 and vim.fn.has("win32") == 1 then
-      path_to_create = utils.path_join { p, path_to_create }
+      path_to_create = utils.path_join({ p, path_to_create })
     else
-      path_to_create = utils.path_join { path_to_create, p }
+      path_to_create = utils.path_join({ path_to_create, p })
     end
 
     if idx == num_nodes then
@@ -101,11 +103,15 @@ function M.fn(default_modifier)
   default_modifier = default_modifier or ":t"
 
   return function(node, modifier)
-    if type(node) ~= "table" then
+    local explorer = core.get_explorer()
-      node = lib.get_node_at_cursor()
+    if not explorer then
+      return
     end
 
-    if node == nil then
+    if type(node) ~= "table" then
+      node = explorer:get_node_at_cursor()
+    end
+    if not node then
       return
     end
 
@@ -119,7 +125,10 @@ function M.fn(default_modifier)
       return
     end
 
-    node = lib.get_last_group_node(node)
+    local dir = node:as(DirectoryNode)
+    if dir then
+      node = dir:last_group_node()
+    end
     if node.name == ".." then
       return
     end
@@ -153,12 +162,14 @@ function M.fn(default_modifier)
         return
       end
 
-      M.rename(node, prepend .. new_file_path .. append)
+      local full_new_path = prepend .. new_file_path .. append
+
+      M.rename(node, full_new_path)
       if not M.config.filesystem_watchers.enable then
-        require("nvim-tree.actions.reloaders").reload_explorer()
+        explorer:reload_explorer()
       end
 
-      find_file(utils.path_remove_trailing(new_file_path))
+      find_file(utils.path_remove_trailing(full_new_path))
     end)
   end
 end

lua/nvim-tree/actions/fs/trash.lua

@@ -1,23 +1,26 @@
-local lib = require "nvim-tree.lib"
+local core = require("nvim-tree.core")
-local notify = require "nvim-tree.notify"
+local lib = require("nvim-tree.lib")
-local reloaders = require "nvim-tree.actions.reloaders"
+local notify = require("nvim-tree.notify")
+
+local DirectoryLinkNode = require("nvim-tree.node.directory-link")
+local DirectoryNode = require("nvim-tree.node.directory")
 
 local M = {
   config = {},
 }
 
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local events = require "nvim-tree.events"
+local events = require("nvim-tree.events")
 
 ---@param absolute_path string
 local function clear_buffer(absolute_path)
-  local bufs = vim.fn.getbufinfo { bufloaded = 1, buflisted = 1 }
+  local bufs = vim.fn.getbufinfo({ bufloaded = 1, buflisted = 1 })
   for _, buf in pairs(bufs) do
     if buf.name == absolute_path then
       if buf.hidden == 0 and #bufs > 1 then
         local winnr = vim.api.nvim_get_current_win()
         vim.api.nvim_set_current_win(buf.windows[1])
-        vim.cmd ":bn"
+        vim.cmd(":bn")
         vim.api.nvim_set_current_win(winnr)
       end
       vim.api.nvim_buf_delete(buf.bufnr, {})
@@ -48,19 +51,21 @@ function M.remove(node)
       on_stderr = on_stderr,
     })
     if need_sync_wait then
-      vim.fn.jobwait { job }
+      vim.fn.jobwait({ job })
     end
   end
 
-  if node.nodes ~= nil and not node.link_to then
+  local explorer = core.get_explorer()
+
+  if node:is(DirectoryNode) and not node:is(DirectoryLinkNode) then
     trash_path(function(_, rc)
       if rc ~= 0 then
         notify.warn("trash failed: " .. err_msg .. "; please see :help nvim-tree.trash")
         return
       end
       events._dispatch_folder_removed(node.absolute_path)
-      if not M.config.filesystem_watchers.enable then
+      if not M.config.filesystem_watchers.enable and explorer then
-        reloaders.reload_explorer()
+        explorer:reload_explorer()
       end
     end)
   else
@@ -72,8 +77,8 @@ function M.remove(node)
       end
       events._dispatch_file_removed(node.absolute_path)
       clear_buffer(node.absolute_path)
-      if not M.config.filesystem_watchers.enable then
+      if not M.config.filesystem_watchers.enable and explorer then
-        reloaders.reload_explorer()
+        explorer:reload_explorer()
       end
     end)
   end

lua/nvim-tree/actions/init.lua

@@ -1,12 +1,11 @@
 local M = {}
 
-M.finders = require "nvim-tree.actions.finders"
+M.finders = require("nvim-tree.actions.finders")
-M.fs = require "nvim-tree.actions.fs"
+M.fs = require("nvim-tree.actions.fs")
-M.moves = require "nvim-tree.actions.moves"
+M.moves = require("nvim-tree.actions.moves")
-M.node = require "nvim-tree.actions.node"
+M.node = require("nvim-tree.actions.node")
-M.reloaders = require "nvim-tree.actions.reloaders"
+M.root = require("nvim-tree.actions.root")
-M.root = require "nvim-tree.actions.root"
+M.tree = require("nvim-tree.actions.tree")
-M.tree = require "nvim-tree.actions.tree"
 
 function M.setup(opts)
   M.fs.setup(opts)

lua/nvim-tree/actions/moves/init.lua

@@ -1,7 +1,7 @@
 local M = {}
 
-M.item = require "nvim-tree.actions.moves.item"
+M.item = require("nvim-tree.actions.moves.item")
-M.parent = require "nvim-tree.actions.moves.parent"
+M.parent = require("nvim-tree.actions.moves.parent")
-M.sibling = require "nvim-tree.actions.moves.sibling"
+M.sibling = require("nvim-tree.actions.moves.sibling")
 
 return M

lua/nvim-tree/actions/moves/item.lua

@@ -1,23 +1,24 @@
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local view = require "nvim-tree.view"
+local view = require("nvim-tree.view")
-local core = require "nvim-tree.core"
+local core = require("nvim-tree.core")
-local lib = require "nvim-tree.lib"
+local diagnostics = require("nvim-tree.diagnostics")
-local explorer_node = require "nvim-tree.explorer.node"
+
-local diagnostics = require "nvim-tree.diagnostics"
+local FileNode = require("nvim-tree.node.file")
+local DirectoryNode = require("nvim-tree.node.directory")
 
 local M = {}
 local MAX_DEPTH = 100
 
 ---Return the status of the node or nil if no status, depending on the type of
 ---status.
----@param node table node to inspect
+---@param node Node to inspect
----@param what string type of status
+---@param what string? type of status
----@param skip_gitignored boolean default false
+---@param skip_gitignored boolean? default false
 ---@return boolean
 local function status_is_valid(node, what, skip_gitignored)
   if what == "git" then
-    local git_status = explorer_node.get_git_status(node)
+    local git_xy = node:get_git_xy()
-    return git_status ~= nil and (not skip_gitignored or git_status[1] ~= "!!")
+    return git_xy ~= nil and (not skip_gitignored or git_xy[1] ~= "!!")
   elseif what == "diag" then
     local diag_status = diagnostics.get_diag_status(node)
     return diag_status ~= nil and diag_status.value ~= nil
@@ -29,15 +30,16 @@ local function status_is_valid(node, what, skip_gitignored)
 end
 
 ---Move to the next node that has a valid status. If none found, don't move.
----@param where string where to move (forwards or backwards)
+---@param explorer Explorer
----@param what string type of status
+---@param where string? where to move (forwards or backwards)
----@param skip_gitignored boolean default false
+---@param what string? type of status
-local function move(where, what, skip_gitignored)
+---@param skip_gitignored boolean? default false
+local function move(explorer, where, what, skip_gitignored)
   local first_node_line = core.get_nodes_starting_line()
-  local nodes_by_line = utils.get_nodes_by_line(core.get_explorer().nodes, first_node_line)
+  local nodes_by_line = utils.get_nodes_by_line(explorer.nodes, first_node_line)
   local iter_start, iter_end, iter_step, cur, first, nex
 
-  local cursor = lib.get_cursor_position()
+  local cursor = explorer:get_cursor_position()
   if cursor and cursor[1] < first_node_line then
     cur = cursor[1]
   end
@@ -65,31 +67,33 @@ local function move(where, what, skip_gitignored)
   end
 
   if nex then
-    view.set_cursor { nex, 0 }
+    view.set_cursor({ nex, 0 })
   elseif vim.o.wrapscan and first then
-    view.set_cursor { first, 0 }
+    view.set_cursor({ first, 0 })
   end
 end
 
+---@param node DirectoryNode
 local function expand_node(node)
   if not node.open then
     -- Expand the node.
     -- Should never collapse since we checked open.
-    lib.expand_or_collapse(node)
+    node:expand_or_collapse(false)
   end
 end
 
 --- Move to the next node recursively.
----@param what string type of status
+---@param explorer Explorer
----@param skip_gitignored boolean default false
+---@param what string? type of status
-local function move_next_recursive(what, skip_gitignored)
+---@param skip_gitignored? boolean default false
+local function move_next_recursive(explorer, what, skip_gitignored)
   -- If the current node:
   -- * is a directory
   -- * and is not the root node
   -- * and has a git/diag status
   -- * and is not opened
   -- expand it.
-  local node_init = lib.get_node_at_cursor()
+  local node_init = explorer:get_node_at_cursor()
   if not node_init then
     return
   end
@@ -97,13 +101,14 @@ local function move_next_recursive(what, skip_gitignored)
   if node_init.name ~= ".." then -- root node cannot have a status
     valid = status_is_valid(node_init, what, skip_gitignored)
   end
-  if node_init.nodes ~= nil and valid and not node_init.open then
+  local node_dir = node_init:as(DirectoryNode)
-    lib.expand_or_collapse(node_init)
+  if node_dir and valid and not node_dir.open then
+    node_dir:expand_or_collapse(false)
   end
 
-  move("next", what, skip_gitignored)
+  move(explorer, "next", what, skip_gitignored)
 
-  local node_cur = lib.get_node_at_cursor()
+  local node_cur = explorer:get_node_at_cursor()
   if not node_cur then
     return
   end
@@ -115,20 +120,15 @@ local function move_next_recursive(what, skip_gitignored)
 
   -- i is used to limit iterations.
   local i = 0
-  local is_dir = node_cur.nodes ~= nil
+  local dir_cur = node_cur:as(DirectoryNode)
-  while is_dir and i < MAX_DEPTH do
+  while dir_cur and i < MAX_DEPTH do
-    expand_node(node_cur)
+    expand_node(dir_cur)
 
-    move("next", what, skip_gitignored)
+    move(explorer, "next", what, skip_gitignored)
 
     -- Save current node.
-    node_cur = lib.get_node_at_cursor()
+    node_cur = explorer:get_node_at_cursor()
-    -- Update is_dir.
+    dir_cur = node_cur and node_cur:as(DirectoryNode)
-    if node_cur then
-      is_dir = node_cur.nodes ~= nil
-    else
-      is_dir = false
-    end
 
     i = i + 1
   end
@@ -149,24 +149,25 @@ end
 --- 4.4) Call a non-recursive prev.
 --- 4.5) Save the current node and start back from 4.1.
 ---
----@param what string type of status
+---@param explorer Explorer
----@param skip_gitignored boolean default false
+---@param what string? type of status
-local function move_prev_recursive(what, skip_gitignored)
+---@param skip_gitignored boolean? default false
+local function move_prev_recursive(explorer, what, skip_gitignored)
   local node_init, node_cur
 
   -- 1)
-  node_init = lib.get_node_at_cursor()
+  node_init = explorer:get_node_at_cursor()
   if node_init == nil then
     return
   end
 
   -- 2)
-  move("prev", what, skip_gitignored)
+  move(explorer, "prev", what, skip_gitignored)
 
-  node_cur = lib.get_node_at_cursor()
+  node_cur = explorer:get_node_at_cursor()
   if node_cur == node_init.parent then
     -- 3)
-    move_prev_recursive(what, skip_gitignored)
+    move_prev_recursive(explorer, what, skip_gitignored)
   else
     -- i is used to limit iterations.
     local i = 0
@@ -175,31 +176,33 @@ local function move_prev_recursive(what, skip_gitignored)
       if
         node_cur == nil
         or node_cur == node_init -- we didn't move
-        or not node_cur.nodes -- node is a file
+        or node_cur:is(FileNode) -- node is a file
       then
         return
       end
 
       -- 4.2)
-      local node_dir = node_cur
+      local node_dir = node_cur:as(DirectoryNode)
-      expand_node(node_dir)
+      if node_dir then
+        expand_node(node_dir)
+      end
 
       -- 4.3)
       if node_init.name == ".." then -- root node
-        view.set_cursor { 1, 0 } -- move to root node (position 1)
+        view.set_cursor({ 1, 0 })    -- move to root node (position 1)
       else
         local node_init_line = utils.find_node_line(node_init)
         if node_init_line < 0 then
           return
         end
-        view.set_cursor { node_init_line, 0 }
+        view.set_cursor({ node_init_line, 0 })
       end
 
       -- 4.4)
-      move("prev", what, skip_gitignored)
+      move(explorer, "prev", what, skip_gitignored)
 
       -- 4.5)
-      node_cur = lib.get_node_at_cursor()
+      node_cur = explorer:get_node_at_cursor()
 
       i = i + 1
     end
@@ -207,34 +210,36 @@ local function move_prev_recursive(what, skip_gitignored)
 end
 
 ---@class NavigationItemOpts
----@field where string
+---@field where string?
----@field what string
+---@field what string?
+---@field skip_gitignored boolean?
+---@field recurse boolean?
 
 ---@param opts NavigationItemOpts
 ---@return fun()
 function M.fn(opts)
   return function()
+    local explorer = core.get_explorer()
+    if not explorer then
+      return
+    end
+
     local recurse = false
-    local skip_gitignored = false
 
     -- recurse only valid for git and diag moves.
     if (opts.what == "git" or opts.what == "diag") and opts.recurse ~= nil then
       recurse = opts.recurse
     end
 
-    if opts.skip_gitignored ~= nil then
-      skip_gitignored = opts.skip_gitignored
-    end
-
     if not recurse then
-      move(opts.where, opts.what, skip_gitignored)
+      move(explorer, opts.where, opts.what, opts.skip_gitignored)
       return
     end
 
     if opts.where == "next" then
-      move_next_recursive(opts.what, skip_gitignored)
+      move_next_recursive(explorer, opts.what, opts.skip_gitignored)
     elseif opts.where == "prev" then
-      move_prev_recursive(opts.what, skip_gitignored)
+      move_prev_recursive(explorer, opts.what, opts.skip_gitignored)
     end
   end
 end

lua/nvim-tree/actions/moves/parent.lua

@@ -1,8 +1,7 @@
-local renderer = require "nvim-tree.renderer"
+local view = require("nvim-tree.view")
-local view = require "nvim-tree.view"
+local utils = require("nvim-tree.utils")
-local utils = require "nvim-tree.utils"
+
-local core = require "nvim-tree.core"
+local DirectoryNode = require("nvim-tree.node.directory")
-local lib = require "nvim-tree.lib"
 
 local M = {}
 
@@ -11,27 +10,33 @@ local M = {}
 function M.fn(should_close)
   should_close = should_close or false
 
+  ---@param node Node
   return function(node)
-    node = lib.get_last_group_node(node)
+    local dir = node:as(DirectoryNode)
-    if should_close and node.open then
+    if dir then
-      node.open = false
+      dir = dir:last_group_node()
-      return renderer.draw()
+      if should_close and dir.open then
+        dir.open = false
+        dir.explorer.renderer:draw()
+        return
+      end
     end
 
-    local parent = utils.get_parent_of_group(node).parent
+    local parent = (node:get_parent_of_group() or node).parent
 
     if not parent or not parent.parent then
-      return view.set_cursor { 1, 0 }
+      view.set_cursor({ 1, 0 })
+      return
     end
 
-    local _, line = utils.find_node(core.get_explorer().nodes, function(n)
+    local _, line = utils.find_node(parent.explorer.nodes, function(n)
       return n.absolute_path == parent.absolute_path
     end)
 
-    view.set_cursor { line + 1, 0 }
+    view.set_cursor({ line + 1, 0 })
     if should_close then
       parent.open = false
-      renderer.draw()
+      parent.explorer.renderer:draw()
     end
   end
 end

lua/nvim-tree/actions/moves/sibling.lua

@@ -1,6 +1,6 @@
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local core = require "nvim-tree.core"
+local core = require("nvim-tree.core")
-local Iterator = require "nvim-tree.iterators.node-iterator"
+local Iterator = require("nvim-tree.iterators.node-iterator")
 
 local M = {}
 
@@ -15,7 +15,7 @@ function M.fn(direction)
     local first, last, next, prev = nil, nil, nil, nil
     local found = false
     local parent = node.parent or core.get_explorer()
-    Iterator.builder(parent.nodes)
+    Iterator.builder(parent and parent.nodes or {})
       :recursor(function()
         return nil
       end)

lua/nvim-tree/actions/node/file-popup.lua

@@ -1,4 +1,4 @@
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
 
 local M = {}
 
@@ -57,7 +57,7 @@ end
 function M.close_popup()
   if current_popup ~= nil then
     vim.api.nvim_win_close(current_popup.winnr, true)
-    vim.cmd "augroup NvimTreeRemoveFilePopup | au! CursorMoved | augroup END"
+    vim.cmd("augroup NvimTreeRemoveFilePopup | au! CursorMoved | augroup END")
 
     current_popup = nil
   end

lua/nvim-tree/actions/node/init.lua

@@ -1,9 +1,9 @@
 local M = {}
 
-M.file_popup = require "nvim-tree.actions.node.file-popup"
+M.file_popup = require("nvim-tree.actions.node.file-popup")
-M.open_file = require "nvim-tree.actions.node.open-file"
+M.open_file = require("nvim-tree.actions.node.open-file")
-M.run_command = require "nvim-tree.actions.node.run-command"
+M.run_command = require("nvim-tree.actions.node.run-command")
-M.system_open = require "nvim-tree.actions.node.system-open"
+M.system_open = require("nvim-tree.actions.node.system-open")
 
 function M.setup(opts)
   require("nvim-tree.actions.node.system-open").setup(opts)

lua/nvim-tree/actions/node/open-file.lua

@@ -1,8 +1,8 @@
 -- Copyright 2019 Yazdani Kiyan under MIT License
-local lib = require "nvim-tree.lib"
+local lib = require("nvim-tree.lib")
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local view = require "nvim-tree.view"
+local view = require("nvim-tree.view")
 
 local M = {}
 
@@ -27,7 +27,7 @@ local function usable_win_ids()
     local bufid = vim.api.nvim_win_get_buf(id)
     for option, v in pairs(M.window_picker.exclude) do
       local ok, option_value
-      if vim.fn.has "nvim-0.10" == 1 then
+      if vim.fn.has("nvim-0.10") == 1 then
         ok, option_value = pcall(vim.api.nvim_get_option_value, option, { buf = bufid })
       else
         ok, option_value = pcall(vim.api.nvim_buf_get_option, bufid, option) ---@diagnostic disable-line: deprecated
@@ -75,7 +75,8 @@ local function pick_win_id()
   end
 
   local i = 1
-  local win_opts = {}
+  local win_opts_selectable = {}
+  local win_opts_unselectable = {}
   local win_map = {}
   local laststatus = vim.o.laststatus
   vim.o.laststatus = 2
@@ -89,23 +90,20 @@ local function pick_win_id()
 
   if laststatus == 3 then
     for _, win_id in ipairs(not_selectable) do
-      local ok_status, statusline, ok_hl, winhl
+      local ok_status, statusline
 
-      if vim.fn.has "nvim-0.10" == 1 then
+      if vim.fn.has("nvim-0.10") == 1 then
         ok_status, statusline = pcall(vim.api.nvim_get_option_value, "statusline", { win = win_id })
-        ok_hl, winhl = pcall(vim.api.nvim_get_option_value, "winhl", { win = win_id })
       else
         ok_status, statusline = pcall(vim.api.nvim_win_get_option, win_id, "statusline") ---@diagnostic disable-line: deprecated
-        ok_hl, winhl = pcall(vim.api.nvim_win_get_option, win_id, "winhl") ---@diagnostic disable-line: deprecated
       end
 
-      win_opts[win_id] = {
+      win_opts_unselectable[win_id] = {
         statusline = ok_status and statusline or "",
-        winhl = ok_hl and winhl or "",
       }
 
       -- Clear statusline for windows not selectable
-      if vim.fn.has "nvim-0.10" == 1 then
+      if vim.fn.has("nvim-0.10") == 1 then
         vim.api.nvim_set_option_value("statusline", " ", { win = win_id })
       else
         vim.api.nvim_win_set_option(win_id, "statusline", " ") ---@diagnostic disable-line: deprecated
@@ -118,7 +116,7 @@ local function pick_win_id()
     local char = M.window_picker.chars:sub(i, i)
 
     local ok_status, statusline, ok_hl, winhl
-    if vim.fn.has "nvim-0.10" == 1 then
+    if vim.fn.has("nvim-0.10") == 1 then
       ok_status, statusline = pcall(vim.api.nvim_get_option_value, "statusline", { win = id })
       ok_hl, winhl = pcall(vim.api.nvim_get_option_value, "winhl", { win = id })
     else
@@ -126,18 +124,18 @@ local function pick_win_id()
       ok_hl, winhl = pcall(vim.api.nvim_win_get_option, id, "winhl") ---@diagnostic disable-line: deprecated
     end
 
-    win_opts[id] = {
+    win_opts_selectable[id] = {
       statusline = ok_status and statusline or "",
       winhl = ok_hl and winhl or "",
     }
     win_map[char] = id
 
-    if vim.fn.has "nvim-0.10" == 1 then
+    if vim.fn.has("nvim-0.10") == 1 then
-      vim.api.nvim_set_option_value("statusline", "%=" .. char .. "%=", { win = id })
+      vim.api.nvim_set_option_value("statusline", "%=" .. char .. "%=",                                                { win = id })
-      vim.api.nvim_set_option_value("winhl", "StatusLine:NvimTreeWindowPicker,StatusLineNC:NvimTreeWindowPicker", { win = id })
+      vim.api.nvim_set_option_value("winhl",      "StatusLine:NvimTreeWindowPicker,StatusLineNC:NvimTreeWindowPicker", { win = id })
     else
       vim.api.nvim_win_set_option(id, "statusline", "%=" .. char .. "%=") ---@diagnostic disable-line: deprecated
-      vim.api.nvim_win_set_option(id, "winhl", "StatusLine:NvimTreeWindowPicker,StatusLineNC:NvimTreeWindowPicker") ---@diagnostic disable-line: deprecated
+      vim.api.nvim_win_set_option(id, "winhl",      "StatusLine:NvimTreeWindowPicker,StatusLineNC:NvimTreeWindowPicker") ---@diagnostic disable-line: deprecated
     end
 
     i = i + 1
@@ -146,9 +144,9 @@ local function pick_win_id()
     end
   end
 
-  vim.cmd "redraw"
+  vim.cmd("redraw")
   if vim.opt.cmdheight._value ~= 0 then
-    print "Pick window: "
+    print("Pick window: ")
   end
   local _, resp = pcall(get_user_input_char)
   resp = (resp or ""):upper()
@@ -156,8 +154,8 @@ local function pick_win_id()
 
   -- Restore window options
   for _, id in ipairs(selectable) do
-    for opt, value in pairs(win_opts[id]) do
+    for opt, value in pairs(win_opts_selectable[id]) do
-      if vim.fn.has "nvim-0.10" == 1 then
+      if vim.fn.has("nvim-0.10") == 1 then
         vim.api.nvim_set_option_value(opt, value, { win = id })
       else
         vim.api.nvim_win_set_option(id, opt, value) ---@diagnostic disable-line: deprecated
@@ -169,8 +167,8 @@ local function pick_win_id()
     for _, id in ipairs(not_selectable) do
       -- Ensure window still exists at this point
       if vim.api.nvim_win_is_valid(id) then
-        for opt, value in pairs(win_opts[id]) do
+        for opt, value in pairs(win_opts_unselectable[id]) do
-          if vim.fn.has "nvim-0.10" == 1 then
+          if vim.fn.has("nvim-0.10") == 1 then
             vim.api.nvim_set_option_value(opt, value, { win = id })
           else
             vim.api.nvim_win_set_option(id, opt, value) ---@diagnostic disable-line: deprecated
@@ -300,7 +298,7 @@ local function open_in_new_window(filename, mode)
 
     -- No need to split, as we created a new window.
     create_new_window = false
-    if mode:match "split$" then
+    if mode:match("split$") then
       mode = "edit"
     end
   elseif not vim.o.hidden then
@@ -309,14 +307,14 @@ local function open_in_new_window(filename, mode)
     local target_bufid = vim.api.nvim_win_get_buf(target_winid)
 
     local modified
-    if vim.fn.has "nvim-0.10" == 1 then
+    if vim.fn.has("nvim-0.10") == 1 then
       modified = vim.api.nvim_get_option_value("modified", { buf = target_bufid })
     else
       modified = vim.api.nvim_buf_get_option(target_bufid, "modified") ---@diagnostic disable-line: deprecated
     end
 
     if modified then
-      if not mode:match "split$" then
+      if not mode:match("split$") then
         mode = "vsplit"
       end
     end
@@ -342,7 +340,7 @@ local function open_in_new_window(filename, mode)
   if create_new_window then
     -- generated from vim.api.nvim_parse_cmd("belowright vsplit foo", {})
     command = { cmd = "vsplit", mods = { split = new_window_side }, args = { fname } }
-  elseif mode:match "split$" then
+  elseif mode:match("split$") then
     command = { cmd = mode, args = { fname } }
   else
     command = { cmd = "edit", args = { fname } }
@@ -371,6 +369,7 @@ end
 
 ---@param mode string
 ---@param filename string
+---@return nil
 function M.fn(mode, filename)
   if type(mode) ~= "string" then
     mode = ""
@@ -422,7 +421,7 @@ end
 function M.setup(opts)
   M.quit_on_open = opts.actions.open_file.quit_on_open
   M.resize_window = opts.actions.open_file.resize_window
-  M.relative_path = opts.experimental.actions.open_file.relative_path
+  M.relative_path = opts.actions.open_file.relative_path
   if opts.actions.open_file.window_picker.chars then
     opts.actions.open_file.window_picker.chars = tostring(opts.actions.open_file.window_picker.chars):upper()
   end

lua/nvim-tree/actions/node/run-command.lua

@@ -1,5 +1,5 @@
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local core = require "nvim-tree.core"
+local core = require("nvim-tree.core")
 
 local M = {}
 

lua/nvim-tree/actions/node/system-open.lua

@@ -1,12 +1,12 @@
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
 
 local M = {}
 
 ---@param node Node
-function M.fn(node)
+local function user(node)
   if #M.config.system_open.cmd == 0 then
-    require("nvim-tree.utils").notify.warn "Cannot open file with system application. Unrecognized platform."
+    require("nvim-tree.utils").notify.warn("Cannot open file with system application. Unrecognized platform.")
     return
   end
 
@@ -49,20 +49,41 @@ function M.fn(node)
   vim.loop.unref(process.handle)
 end
 
+---@param node Node
+local function native(node)
+  local _, err = vim.ui.open(node.link_to or node.absolute_path)
+
+  -- err only provided on opener executable not found hence logging path is not useful
+  if err then
+    notify.warn(err)
+  end
+end
+
+---@param node Node
+function M.fn(node)
+  M.open(node)
+end
+
+-- TODO #2430 always use native once 0.10 is the minimum neovim version
 function M.setup(opts)
   M.config = {}
   M.config.system_open = opts.system_open or {}
 
-  if #M.config.system_open.cmd == 0 then
+  if vim.fn.has("nvim-0.10") == 1 and #M.config.system_open.cmd == 0 then
-    if utils.is_windows then
+    M.open = native
-      M.config.system_open = {
+  else
-        cmd = "cmd",
+    M.open = user
-        args = { "/c", "start", '""' },
+    if #M.config.system_open.cmd == 0 then
-      }
+      if utils.is_windows then
-    elseif utils.is_macos then
+        M.config.system_open = {
-      M.config.system_open.cmd = "open"
+          cmd = "cmd",
-    elseif utils.is_unix then
+          args = { "/c", "start", '""' },
-      M.config.system_open.cmd = "xdg-open"
+        }
+      elseif utils.is_macos then
+        M.config.system_open.cmd = "open"
+      elseif utils.is_unix then
+        M.config.system_open.cmd = "xdg-open"
+      end
     end
   end
 end

lua/nvim-tree/actions/reloaders.lua

@@ -1,72 +0,0 @@
-local git = require "nvim-tree.git"
-local view = require "nvim-tree.view"
-local renderer = require "nvim-tree.renderer"
-local core = require "nvim-tree.core"
-local explorer_node = require "nvim-tree.explorer.node"
-local Iterator = require "nvim-tree.iterators.node-iterator"
-
-local M = {}
-
----@param explorer Explorer|nil
----@param projects table
-local function refresh_nodes(explorer, projects)
-  Iterator.builder({ explorer })
-    :applier(function(n)
-      if n.nodes then
-        local toplevel = git.get_toplevel(n.cwd or n.link_to or n.absolute_path)
-        if explorer then
-          explorer:reload(n, projects[toplevel] or {})
-        end
-      end
-    end)
-    :recursor(function(n)
-      return n.group_next and { n.group_next } or (n.open and n.nodes)
-    end)
-    :iterate()
-end
-
----@param parent_node Node|nil
----@param projects table
-function M.reload_node_status(parent_node, projects)
-  if parent_node == nil then
-    return
-  end
-
-  local toplevel = git.get_toplevel(parent_node.absolute_path)
-  local status = projects[toplevel] or {}
-  for _, node in ipairs(parent_node.nodes) do
-    explorer_node.update_git_status(node, explorer_node.is_git_ignored(parent_node), status)
-    if node.nodes and #node.nodes > 0 then
-      M.reload_node_status(node, projects)
-    end
-  end
-end
-
-local event_running = false
-function M.reload_explorer()
-  if event_running or not core.get_explorer() or vim.v.exiting ~= vim.NIL then
-    return
-  end
-  event_running = true
-
-  local projects = git.reload()
-  refresh_nodes(core.get_explorer(), projects)
-  if view.is_visible() then
-    renderer.draw()
-  end
-  event_running = false
-end
-
-function M.reload_git()
-  if not core.get_explorer() or not git.config.git.enable or event_running then
-    return
-  end
-  event_running = true
-
-  local projects = git.reload()
-  M.reload_node_status(core.get_explorer(), projects)
-  renderer.draw()
-  event_running = false
-end
-
-return M

lua/nvim-tree/actions/root/change-dir.lua

@@ -1,6 +1,6 @@
-local log = require "nvim-tree.log"
+local log = require("nvim-tree.log")
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local core = require "nvim-tree.core"
+local core = require("nvim-tree.core")
 
 local M = {
   current_tab = vim.api.nvim_get_current_tabpage(),
@@ -91,7 +91,10 @@ M.force_dirchange = add_profiling_to(function(foldername, should_open_view)
   if should_open_view then
     require("nvim-tree.lib").open()
   else
-    require("nvim-tree.renderer").draw()
+    local explorer = core.get_explorer()
+    if explorer then
+      explorer.renderer:draw()
+    end
   end
 end)
 

lua/nvim-tree/actions/root/dir-up.lua

@@ -1,12 +1,12 @@
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local core = require "nvim-tree.core"
+local core = require("nvim-tree.core")
 
 local M = {}
 
 ---@param node Node
 function M.fn(node)
   if not node or node.name == ".." then
-    require("nvim-tree.actions.root.change-dir").fn ".."
+    require("nvim-tree.actions.root.change-dir").fn("..")
   else
     local cwd = core.get_cwd()
     if cwd == nil then

lua/nvim-tree/actions/root/init.lua

@@ -1,7 +1,7 @@
 local M = {}
 
-M.change_dir = require "nvim-tree.actions.root.change-dir"
+M.change_dir = require("nvim-tree.actions.root.change-dir")
-M.dir_up = require "nvim-tree.actions.root.dir-up"
+M.dir_up = require("nvim-tree.actions.root.dir-up")
 
 function M.setup(opts)
   M.change_dir.setup(opts)

lua/nvim-tree/actions/tree/find-file.lua

@@ -1,7 +1,7 @@
-local core = require "nvim-tree.core"
+local core = require("nvim-tree.core")
-local lib = require "nvim-tree.lib"
+local lib = require("nvim-tree.lib")
-local view = require "nvim-tree.view"
+local view = require("nvim-tree.view")
-local finders_find_file = require "nvim-tree.actions.finders.find-file"
+local finders_find_file = require("nvim-tree.actions.finders.find-file")
 
 local M = {}
 
@@ -49,9 +49,9 @@ function M.fn(opts)
     end
   elseif opts.open then
     -- open
-    lib.open { current_window = opts.current_window, winid = opts.winid }
+    lib.open({ current_window = opts.current_window, winid = opts.winid })
     if not opts.focus then
-      vim.cmd "noautocmd wincmd p"
+      vim.cmd("noautocmd wincmd p")
     end
   end
 

lua/nvim-tree/actions/tree/init.lua

@@ -1,10 +1,10 @@
 local M = {}
 
-M.find_file = require "nvim-tree.actions.tree.find-file"
+M.find_file = require("nvim-tree.actions.tree.find-file")
-M.modifiers = require "nvim-tree.actions.tree.modifiers"
+M.modifiers = require("nvim-tree.actions.tree.modifiers")
-M.open = require "nvim-tree.actions.tree.open"
+M.open = require("nvim-tree.actions.tree.open")
-M.toggle = require "nvim-tree.actions.tree.toggle"
+M.toggle = require("nvim-tree.actions.tree.toggle")
-M.resize = require "nvim-tree.actions.tree.resize"
+M.resize = require("nvim-tree.actions.tree.resize")
 
 function M.setup(opts)
   M.find_file.setup(opts)

lua/nvim-tree/actions/tree/modifiers/collapse-all.lua

@@ -1,8 +1,8 @@
-local renderer = require "nvim-tree.renderer"
+local utils = require("nvim-tree.utils")
-local utils = require "nvim-tree.utils"
+local core = require("nvim-tree.core")
-local core = require "nvim-tree.core"
+local Iterator = require("nvim-tree.iterators.node-iterator")
-local lib = require "nvim-tree.lib"
+
-local Iterator = require "nvim-tree.iterators.node-iterator"
+local DirectoryNode = require("nvim-tree.node.directory")
 
 local M = {}
 
@@ -25,10 +25,13 @@ end
 
 ---@param keep_buffers boolean
 function M.fn(keep_buffers)
-  local node = lib.get_node_at_cursor()
   local explorer = core.get_explorer()
+  if not explorer then
+    return
+  end
 
-  if explorer == nil then
+  local node = explorer:get_node_at_cursor()
+  if not node then
     return
   end
 
@@ -37,8 +40,9 @@ function M.fn(keep_buffers)
   Iterator.builder(explorer.nodes)
     :hidden()
     :applier(function(n)
-      if n.nodes ~= nil then
+      local dir = n:as(DirectoryNode)
-        n.open = keep_buffers == true and matches(n.absolute_path)
+      if dir then
+        dir.open = keep_buffers and matches(dir.absolute_path)
       end
     end)
     :recursor(function(n)
@@ -46,7 +50,7 @@ function M.fn(keep_buffers)
     end)
     :iterate()
 
-  renderer.draw()
+  explorer.renderer:draw()
   utils.focus_node_or_parent(node)
 end
 

lua/nvim-tree/actions/tree/modifiers/expand-all.lua

@@ -1,8 +1,8 @@
-local core = require "nvim-tree.core"
+local core = require("nvim-tree.core")
-local renderer = require "nvim-tree.renderer"
+local Iterator = require("nvim-tree.iterators.node-iterator")
-local Iterator = require "nvim-tree.iterators.node-iterator"
+local notify = require("nvim-tree.notify")
-local notify = require "nvim-tree.notify"
+
-local lib = require "nvim-tree.lib"
+local DirectoryNode = require("nvim-tree.node.directory")
 
 local M = {}
 
@@ -17,9 +17,9 @@ local function to_lookup_table(list)
   return table
 end
 
----@param node Node
+---@param node DirectoryNode
 local function expand(node)
-  node = lib.get_last_group_node(node)
+  node = node:last_group_node()
   node.open = true
   if #node.nodes == 0 then
     core.get_explorer():expand(node)
@@ -30,9 +30,13 @@ end
 ---@param node Node
 ---@return boolean
 local function should_expand(expansion_count, node)
+  local dir = node:as(DirectoryNode)
+  if not dir then
+    return false
+  end
   local should_halt = expansion_count >= M.MAX_FOLDER_DISCOVERY
-  local should_exclude = M.EXCLUDE[node.name]
+  local should_exclude = M.EXCLUDE[dir.name]
-  return not should_halt and node.nodes and not node.open and not should_exclude
+  return not should_halt and not dir.open and not should_exclude
 end
 
 local function gen_iterator()
@@ -49,7 +53,10 @@ local function gen_iterator()
       :applier(function(node)
         if should_expand(expansion_count, node) then
           expansion_count = expansion_count + 1
-          expand(node)
+          node = node:as(DirectoryNode)
+          if node then
+            expand(node)
+          end
         end
       end)
       :recursor(function(node)
@@ -63,13 +70,21 @@ local function gen_iterator()
   end
 end
 
----@param base_node table
+---Expand the directory node or the root
-function M.fn(base_node)
+---@param node Node
-  local node = base_node.nodes and base_node or core.get_explorer()
+function M.fn(node)
-  if gen_iterator()(node) then
+  local explorer = core.get_explorer()
+  local parent = node:as(DirectoryNode) or explorer
+  if not parent then
+    return
+  end
+
+  if gen_iterator()(parent) then
     notify.warn("expansion iteration was halted after " .. M.MAX_FOLDER_DISCOVERY .. " discovered folders")
   end
-  renderer.draw()
+  if explorer then
+    explorer.renderer:draw()
+  end
 end
 
 function M.setup(opts)

lua/nvim-tree/actions/tree/modifiers/init.lua

@@ -1,8 +1,7 @@
 local M = {}
 
-M.collapse_all = require "nvim-tree.actions.tree.modifiers.collapse-all"
+M.collapse_all = require("nvim-tree.actions.tree.modifiers.collapse-all")
-M.expand_all = require "nvim-tree.actions.tree.modifiers.expand-all"
+M.expand_all = require("nvim-tree.actions.tree.modifiers.expand-all")
-M.toggles = require "nvim-tree.actions.tree.modifiers.toggles"
 
 function M.setup(opts)
   M.expand_all.setup(opts)

lua/nvim-tree/actions/tree/modifiers/toggles.lua

@@ -1,65 +0,0 @@
-local lib = require "nvim-tree.lib"
-local utils = require "nvim-tree.utils"
-local reloaders = require "nvim-tree.actions.reloaders"
-local core = require "nvim-tree.core"
-local M = {}
-
-local function reload()
-  local node = lib.get_node_at_cursor()
-  reloaders.reload_explorer()
-  utils.focus_node_or_parent(node)
-end
-
-local function wrap_explorer(fn)
-  return function(...)
-    local explorer = core.get_explorer()
-    if explorer then
-      return fn(explorer, ...)
-    end
-  end
-end
-
-local function custom(explorer)
-  explorer.filters.config.filter_custom = not explorer.filters.config.filter_custom
-  reload()
-end
-
-local function git_ignored(explorer)
-  explorer.filters.config.filter_git_ignored = not explorer.filters.config.filter_git_ignored
-  reload()
-end
-
-local function git_clean(explorer)
-  explorer.filters.config.filter_git_clean = not explorer.filters.config.filter_git_clean
-  reload()
-end
-
-local function no_buffer(explorer)
-  explorer.filters.config.filter_no_buffer = not explorer.filters.config.filter_no_buffer
-  reload()
-end
-
-local function no_bookmark(explorer)
-  explorer.filters.config.filter_no_bookmark = not explorer.filters.config.filter_no_bookmark
-  reload()
-end
-
-local function dotfiles(explorer)
-  explorer.filters.config.filter_dotfiles = not explorer.filters.config.filter_dotfiles
-  reload()
-end
-
-local function enable(explorer)
-  explorer.filters.config.enable = not explorer.filters.config.enable
-  reload()
-end
-
-M.custom = wrap_explorer(custom)
-M.git_ignored = wrap_explorer(git_ignored)
-M.git_clean = wrap_explorer(git_clean)
-M.no_buffer = wrap_explorer(no_buffer)
-M.no_bookmark = wrap_explorer(no_bookmark)
-M.dotfiles = wrap_explorer(dotfiles)
-M.enable = wrap_explorer(enable)
-
-return M

lua/nvim-tree/actions/tree/open.lua

@@ -1,6 +1,6 @@
-local lib = require "nvim-tree.lib"
+local lib = require("nvim-tree.lib")
-local view = require "nvim-tree.view"
+local view = require("nvim-tree.view")
-local finders_find_file = require "nvim-tree.actions.finders.find-file"
+local finders_find_file = require("nvim-tree.actions.finders.find-file")
 
 local M = {}
 
@@ -29,11 +29,11 @@ function M.fn(opts)
     view.focus()
   else
     -- open
-    lib.open {
+    lib.open({
       path = opts.path,
       current_window = opts.current_window,
       winid = opts.winid,
-    }
+    })
   end
 
   -- find file

lua/nvim-tree/actions/tree/resize.lua

@@ -1,4 +1,4 @@
-local view = require "nvim-tree.view"
+local view = require("nvim-tree.view")
 
 local M = {}
 

lua/nvim-tree/actions/tree/toggle.lua

@@ -1,6 +1,6 @@
-local lib = require "nvim-tree.lib"
+local lib = require("nvim-tree.lib")
-local view = require "nvim-tree.view"
+local view = require("nvim-tree.view")
-local finders_find_file = require "nvim-tree.actions.finders.find-file"
+local finders_find_file = require("nvim-tree.actions.finders.find-file")
 
 local M = {}
 
@@ -45,11 +45,11 @@ function M.fn(opts, no_focus, cwd, bang)
     view.close()
   else
     -- open
-    lib.open {
+    lib.open({
       path = opts.path,
       current_window = opts.current_window,
       winid = opts.winid,
-    }
+    })
 
     -- find file
     if M.config.update_focused_file.enable or opts.find_file then
@@ -64,7 +64,7 @@ function M.fn(opts, no_focus, cwd, bang)
 
     -- restore focus
     if not opts.focus then
-      vim.cmd "noautocmd wincmd p"
+      vim.cmd("noautocmd wincmd p")
     end
   end
 end

lua/nvim-tree/api.lua

@@ -1,13 +1,16 @@
-local lib = require "nvim-tree.lib"
+local core = require("nvim-tree.core")
-local core = require "nvim-tree.core"
+local view = require("nvim-tree.view")
-local view = require "nvim-tree.view"
+local utils = require("nvim-tree.utils")
-local utils = require "nvim-tree.utils"
+local actions = require("nvim-tree.actions")
-local actions = require "nvim-tree.actions"
+local appearance_hi_test = require("nvim-tree.appearance.hi-test")
-local appearance_diagnostics = require "nvim-tree.appearance.diagnostics"
+local events = require("nvim-tree.events")
-local events = require "nvim-tree.events"
+local help = require("nvim-tree.help")
-local help = require "nvim-tree.help"
+local keymap = require("nvim-tree.keymap")
-local keymap = require "nvim-tree.keymap"
+local notify = require("nvim-tree.notify")
-local notify = require "nvim-tree.notify"
+
+local DirectoryNode = require("nvim-tree.node.directory")
+local FileLinkNode = require("nvim-tree.node.file-link")
+local RootNode = require("nvim-tree.node.root")
 
 local Api = {
   tree = {},
@@ -38,25 +41,38 @@ local Api = {
   diagnostics = {},
 }
 
---- Print error when setup not called.
+---Print error when setup not called.
---- f function to invoke
+---@param fn fun(...): any
----@param f function
+---@return fun(...): any
----@return fun(...) : any
+local function wrap(fn)
-local function wrap(f)
   return function(...)
     if vim.g.NvimTreeSetup == 1 then
-      return f(...)
+      return fn(...)
     else
-      notify.error "nvim-tree setup not called"
+      notify.error("nvim-tree setup not called")
     end
   end
 end
 
+---Invoke a method on the singleton explorer.
+---Print error when setup not called.
+---@param explorer_method string explorer method name
+---@return fun(...): any
+local function wrap_explorer(explorer_method)
+  return wrap(function(...)
+    local explorer = core.get_explorer()
+    if explorer then
+      return explorer[explorer_method](explorer, ...)
+    end
+  end)
+end
+
 ---Inject the node as the first argument if present otherwise do nothing.
----@param fn function function to invoke
+---@param fn fun(node: Node, ...): any
+---@return fun(node: Node, ...): any
 local function wrap_node(fn)
   return function(node, ...)
-    node = node or lib.get_node_at_cursor()
+    node = node or wrap_explorer("get_node_at_cursor")()
     if node then
       return fn(node, ...)
     end
@@ -64,10 +80,11 @@ local function wrap_node(fn)
 end
 
 ---Inject the node or nil as the first argument if absent.
----@param fn function function to invoke
+---@param fn fun(node: Node, ...): any
+---@return fun(node: Node, ...): any
 local function wrap_node_or_nil(fn)
   return function(node, ...)
-    node = node or lib.get_node_at_cursor()
+    node = node or wrap_explorer("get_node_at_cursor")()
     return fn(node, ...)
   end
 end
@@ -76,7 +93,23 @@ end
 ---Print error when setup not called.
 ---@param explorer_member string explorer member name
 ---@param member_method string method name to invoke on member
----@return fun(...) : any
+---@param ... any passed to method
+---@return fun(...): any
+local function wrap_explorer_member_args(explorer_member, member_method, ...)
+  local method_args = ...
+  return wrap(function(...)
+    local explorer = core.get_explorer()
+    if explorer then
+      return explorer[explorer_member][member_method](explorer[explorer_member], method_args, ...)
+    end
+  end)
+end
+
+---Invoke a member's method on the singleton explorer.
+---Print error when setup not called.
+---@param explorer_member string explorer member name
+---@param member_method string method name to invoke on member
+---@return fun(...): any
 local function wrap_explorer_member(explorer_member, member_method)
   return wrap(function(...)
     local explorer = core.get_explorer()
@@ -108,7 +141,7 @@ Api.tree.toggle = wrap(actions.tree.toggle.fn)
 Api.tree.close = wrap(view.close)
 Api.tree.close_in_this_tab = wrap(view.close_this_tab_only)
 Api.tree.close_in_all_tabs = wrap(view.close_all_tabs)
-Api.tree.reload = wrap(actions.reloaders.reload_explorer)
+Api.tree.reload = wrap_explorer("reload_explorer")
 
 ---@class ApiTreeResizeOpts
 ---@field width string|function|number|table|nil
@@ -122,16 +155,19 @@ Api.tree.change_root = wrap(function(...)
 end)
 
 Api.tree.change_root_to_node = wrap_node(function(node)
-  if node.name == ".." then
+  if node.name == ".." or node:is(RootNode) then
-    actions.root.change_dir.fn ".."
+    actions.root.change_dir.fn("..")
-  elseif node.nodes ~= nil then
+  else
-    actions.root.change_dir.fn(lib.get_last_group_node(node).absolute_path)
+    node = node:as(DirectoryNode)
+    if node then
+      actions.root.change_dir.fn(node:last_group_node().absolute_path)
+    end
   end
 end)
 
 Api.tree.change_root_to_parent = wrap_node(actions.root.dir_up.fn)
-Api.tree.get_node_under_cursor = wrap(lib.get_node_at_cursor)
+Api.tree.get_node_under_cursor = wrap_explorer("get_node_at_cursor")
-Api.tree.get_nodes = wrap(lib.get_nodes)
+Api.tree.get_nodes = wrap_explorer("get_nodes")
 
 ---@class ApiTreeFindFileOpts
 ---@field buf string|number|nil
@@ -145,13 +181,13 @@ Api.tree.find_file = wrap(actions.tree.find_file.fn)
 Api.tree.search_node = wrap(actions.finders.search_node.fn)
 Api.tree.collapse_all = wrap(actions.tree.modifiers.collapse_all.fn)
 Api.tree.expand_all = wrap_node(actions.tree.modifiers.expand_all.fn)
-Api.tree.toggle_enable_filters = wrap(actions.tree.modifiers.toggles.enable)
+Api.tree.toggle_enable_filters = wrap_explorer_member("filters", "toggle")
-Api.tree.toggle_gitignore_filter = wrap(actions.tree.modifiers.toggles.git_ignored)
+Api.tree.toggle_gitignore_filter = wrap_explorer_member_args("filters", "toggle", "git_ignored")
-Api.tree.toggle_git_clean_filter = wrap(actions.tree.modifiers.toggles.git_clean)
+Api.tree.toggle_git_clean_filter = wrap_explorer_member_args("filters", "toggle", "git_clean")
-Api.tree.toggle_no_buffer_filter = wrap(actions.tree.modifiers.toggles.no_buffer)
+Api.tree.toggle_no_buffer_filter = wrap_explorer_member_args("filters", "toggle", "no_buffer")
-Api.tree.toggle_custom_filter = wrap(actions.tree.modifiers.toggles.custom)
+Api.tree.toggle_custom_filter = wrap_explorer_member_args("filters", "toggle", "custom")
-Api.tree.toggle_hidden_filter = wrap(actions.tree.modifiers.toggles.dotfiles)
+Api.tree.toggle_hidden_filter = wrap_explorer_member_args("filters", "toggle", "dotfiles")
-Api.tree.toggle_no_bookmark_filter = wrap(actions.tree.modifiers.toggles.no_bookmark)
+Api.tree.toggle_no_bookmark_filter = wrap_explorer_member_args("filters", "toggle", "no_bookmark")
 Api.tree.toggle_help = wrap(help.toggle)
 Api.tree.is_tree_buf = wrap(utils.is_nvim_tree_buf)
 
@@ -169,11 +205,11 @@ Api.tree.winid = wrap(view.winid)
 Api.fs.create = wrap_node_or_nil(actions.fs.create_file.fn)
 Api.fs.remove = wrap_node(actions.fs.remove_file.fn)
 Api.fs.trash = wrap_node(actions.fs.trash.fn)
-Api.fs.rename_node = wrap_node(actions.fs.rename_file.fn ":t")
+Api.fs.rename_node = wrap_node(actions.fs.rename_file.fn(":t"))
-Api.fs.rename = wrap_node(actions.fs.rename_file.fn ":t")
+Api.fs.rename = wrap_node(actions.fs.rename_file.fn(":t"))
-Api.fs.rename_sub = wrap_node(actions.fs.rename_file.fn ":p:h")
+Api.fs.rename_sub = wrap_node(actions.fs.rename_file.fn(":p:h"))
-Api.fs.rename_basename = wrap_node(actions.fs.rename_file.fn ":t:r")
+Api.fs.rename_basename = wrap_node(actions.fs.rename_file.fn(":t:r"))
-Api.fs.rename_full = wrap_node(actions.fs.rename_file.fn ":p")
+Api.fs.rename_full = wrap_node(actions.fs.rename_file.fn(":p"))
 Api.fs.cut = wrap_node(wrap_explorer_member("clipboard", "cut"))
 Api.fs.paste = wrap_node(wrap_explorer_member("clipboard", "paste"))
 Api.fs.clear_clipboard = wrap_explorer_member("clipboard", "clear_clipboard")
@@ -185,65 +221,68 @@ Api.fs.copy.basename = wrap_node(wrap_explorer_member("clipboard", "copy_basenam
 Api.fs.copy.relative_path = wrap_node(wrap_explorer_member("clipboard", "copy_path"))
 
 ---@param mode string
----@param node table
+---@param node Node
 local function edit(mode, node)
-  local path = node.absolute_path
+  local file_link = node:as(FileLinkNode)
-  if node.link_to and not node.nodes then
+  local path = file_link and file_link.link_to or node.absolute_path
-    path = node.link_to
-  end
   actions.node.open_file.fn(mode, path)
 end
 
 ---@param mode string
----@return fun(node: table)
+---@param toggle_group boolean?
+---@return fun(node: Node)
 local function open_or_expand_or_dir_up(mode, toggle_group)
+  ---@param node Node
   return function(node)
-    if node.name == ".." then
+    local root = node:as(RootNode)
-      actions.root.change_dir.fn ".."
+    local dir = node:as(DirectoryNode)
-    elseif node.nodes then
+
-      lib.expand_or_collapse(node, toggle_group)
+    if root or node.name == ".." then
+      actions.root.change_dir.fn("..")
+    elseif dir then
+      dir:expand_or_collapse(toggle_group)
     elseif not toggle_group then
       edit(mode, node)
     end
   end
 end
 
-Api.node.open.edit = wrap_node(open_or_expand_or_dir_up "edit")
+Api.node.open.edit = wrap_node(open_or_expand_or_dir_up("edit"))
-Api.node.open.drop = wrap_node(open_or_expand_or_dir_up "drop")
+Api.node.open.drop = wrap_node(open_or_expand_or_dir_up("drop"))
-Api.node.open.tab_drop = wrap_node(open_or_expand_or_dir_up "tab_drop")
+Api.node.open.tab_drop = wrap_node(open_or_expand_or_dir_up("tab_drop"))
-Api.node.open.replace_tree_buffer = wrap_node(open_or_expand_or_dir_up "edit_in_place")
+Api.node.open.replace_tree_buffer = wrap_node(open_or_expand_or_dir_up("edit_in_place"))
-Api.node.open.no_window_picker = wrap_node(open_or_expand_or_dir_up "edit_no_picker")
+Api.node.open.no_window_picker = wrap_node(open_or_expand_or_dir_up("edit_no_picker"))
-Api.node.open.vertical = wrap_node(open_or_expand_or_dir_up "vsplit")
+Api.node.open.vertical = wrap_node(open_or_expand_or_dir_up("vsplit"))
-Api.node.open.horizontal = wrap_node(open_or_expand_or_dir_up "split")
+Api.node.open.horizontal = wrap_node(open_or_expand_or_dir_up("split"))
-Api.node.open.tab = wrap_node(open_or_expand_or_dir_up "tabnew")
+Api.node.open.tab = wrap_node(open_or_expand_or_dir_up("tabnew"))
 Api.node.open.toggle_group_empty = wrap_node(open_or_expand_or_dir_up("toggle_group_empty", true))
-Api.node.open.preview = wrap_node(open_or_expand_or_dir_up "preview")
+Api.node.open.preview = wrap_node(open_or_expand_or_dir_up("preview"))
-Api.node.open.preview_no_picker = wrap_node(open_or_expand_or_dir_up "preview_no_picker")
+Api.node.open.preview_no_picker = wrap_node(open_or_expand_or_dir_up("preview_no_picker"))
 
 Api.node.show_info_popup = wrap_node(actions.node.file_popup.toggle_file_info)
 Api.node.run.cmd = wrap_node(actions.node.run_command.run_file_command)
 Api.node.run.system = wrap_node(actions.node.system_open.fn)
 
-Api.node.navigate.sibling.next = wrap_node(actions.moves.sibling.fn "next")
+Api.node.navigate.sibling.next = wrap_node(actions.moves.sibling.fn("next"))
-Api.node.navigate.sibling.prev = wrap_node(actions.moves.sibling.fn "prev")
+Api.node.navigate.sibling.prev = wrap_node(actions.moves.sibling.fn("prev"))
-Api.node.navigate.sibling.first = wrap_node(actions.moves.sibling.fn "first")
+Api.node.navigate.sibling.first = wrap_node(actions.moves.sibling.fn("first"))
-Api.node.navigate.sibling.last = wrap_node(actions.moves.sibling.fn "last")
+Api.node.navigate.sibling.last = wrap_node(actions.moves.sibling.fn("last"))
 Api.node.navigate.parent = wrap_node(actions.moves.parent.fn(false))
 Api.node.navigate.parent_close = wrap_node(actions.moves.parent.fn(true))
-Api.node.navigate.git.next = wrap_node(actions.moves.item.fn { where = "next", what = "git" })
+Api.node.navigate.git.next = wrap_node(actions.moves.item.fn({ where = "next", what = "git" }))
-Api.node.navigate.git.next_skip_gitignored = wrap_node(actions.moves.item.fn { where = "next", what = "git", skip_gitignored = true })
+Api.node.navigate.git.next_skip_gitignored = wrap_node(actions.moves.item.fn({ where = "next", what = "git", skip_gitignored = true }))
-Api.node.navigate.git.next_recursive = wrap_node(actions.moves.item.fn { where = "next", what = "git", recurse = true })
+Api.node.navigate.git.next_recursive = wrap_node(actions.moves.item.fn({ where = "next", what = "git", recurse = true }))
-Api.node.navigate.git.prev = wrap_node(actions.moves.item.fn { where = "prev", what = "git" })
+Api.node.navigate.git.prev = wrap_node(actions.moves.item.fn({ where = "prev", what = "git" }))
-Api.node.navigate.git.prev_skip_gitignored = wrap_node(actions.moves.item.fn { where = "prev", what = "git", skip_gitignored = true })
+Api.node.navigate.git.prev_skip_gitignored = wrap_node(actions.moves.item.fn({ where = "prev", what = "git", skip_gitignored = true }))
-Api.node.navigate.git.prev_recursive = wrap_node(actions.moves.item.fn { where = "prev", what = "git", recurse = true })
+Api.node.navigate.git.prev_recursive = wrap_node(actions.moves.item.fn({ where = "prev", what = "git", recurse = true }))
-Api.node.navigate.diagnostics.next = wrap_node(actions.moves.item.fn { where = "next", what = "diag" })
+Api.node.navigate.diagnostics.next = wrap_node(actions.moves.item.fn({ where = "next", what = "diag" }))
-Api.node.navigate.diagnostics.next_recursive = wrap_node(actions.moves.item.fn { where = "next", what = "diag", recurse = true })
+Api.node.navigate.diagnostics.next_recursive = wrap_node(actions.moves.item.fn({ where = "next", what = "diag", recurse = true }))
-Api.node.navigate.diagnostics.prev = wrap_node(actions.moves.item.fn { where = "prev", what = "diag" })
+Api.node.navigate.diagnostics.prev = wrap_node(actions.moves.item.fn({ where = "prev", what = "diag" }))
-Api.node.navigate.diagnostics.prev_recursive = wrap_node(actions.moves.item.fn { where = "prev", what = "diag", recurse = true })
+Api.node.navigate.diagnostics.prev_recursive = wrap_node(actions.moves.item.fn({ where = "prev", what = "diag", recurse = true }))
-Api.node.navigate.opened.next = wrap_node(actions.moves.item.fn { where = "next", what = "opened" })
+Api.node.navigate.opened.next = wrap_node(actions.moves.item.fn({ where = "next", what = "opened" }))
-Api.node.navigate.opened.prev = wrap_node(actions.moves.item.fn { where = "prev", what = "opened" })
+Api.node.navigate.opened.prev = wrap_node(actions.moves.item.fn({ where = "prev", what = "opened" }))
 
-Api.git.reload = wrap(actions.reloaders.reload_git)
+Api.git.reload = wrap_explorer("reload_git")
 
 Api.events.subscribe = events.subscribe
 Api.events.Event = events.Event
@@ -266,7 +305,7 @@ Api.config.mappings.get_keymap = wrap(keymap.get_keymap)
 Api.config.mappings.get_keymap_default = wrap(keymap.get_keymap_default)
 Api.config.mappings.default_on_attach = keymap.default_on_attach
 
-Api.diagnostics.hi_test = wrap(appearance_diagnostics.hi_test)
+Api.diagnostics.hi_test = wrap(appearance_hi_test)
 
 Api.commands.get = wrap(function()
   return require("nvim-tree.commands").get()

lua/nvim-tree/appearance/hi-test.lua

@@ -1,45 +1,46 @@
-local appearance = require "nvim-tree.appearance"
+local appearance = require("nvim-tree.appearance")
+
+local Class = require("nvim-tree.classic")
 
 -- others with name and links less than this arbitrary value are short
 local SHORT_LEN = 50
 
-local M = {}
+---@class (exact) HighlightDisplay: Class for :NvimTreeHiTest
-
----@class HighlightDisplay for :NvimTreeHiTest
 ---@field group string nvim-tree highlight group name
 ---@field links string link chain to a concretely defined group
 ---@field def string :hi concrete definition after following any links
-local HighlightDisplay = {}
+local HighlightDisplay = Class:extend()
 
----@param group string nvim-tree highlight group name
+---@class HighlightDisplay
----@return HighlightDisplay
+---@overload fun(args: HighlightDisplayArgs): HighlightDisplay
-function HighlightDisplay:new(group)
-  local o = {}
-  setmetatable(o, self)
-  self.__index = self
 
-  o.group = group
+---@class (exact) HighlightDisplayArgs
-  local concrete = o.group
+---@field group string nvim-tree highlight group name
+
+---@protected
+---@param args HighlightDisplayArgs
+function HighlightDisplay:new(args)
+  self.group = args.group
+
+  local concrete = self.group
 
   -- maybe follow links
   local links = {}
-  local link = vim.api.nvim_get_hl(0, { name = o.group }).link
+  local link = vim.api.nvim_get_hl(0, { name = self.group }).link
   while link do
     table.insert(links, link)
     concrete = link
     link = vim.api.nvim_get_hl(0, { name = link }).link
   end
-  o.links = table.concat(links, " ")
+  self.links = table.concat(links, " ")
 
   -- concrete definition
   local ok, res = pcall(vim.api.nvim_cmd, { cmd = "highlight", args = { concrete } }, { output = true })
   if ok and type(res) == "string" then
-    o.def = res:gsub(".*xxx *", "")
+    self.def = res:gsub(".*xxx *", "")
   else
-    o.def = ""
+    self.def = ""
   end
-
-  return o
 end
 
 ---Render one group.
@@ -87,7 +88,7 @@ end
 
 ---Run a test similar to :so $VIMRUNTIME/syntax/hitest.vim
 ---Display all nvim-tree and neovim highlight groups, their link chain and actual definition
-function M.hi_test()
+return function()
   -- create a buffer
   local bufnr = vim.api.nvim_create_buf(false, true)
 
@@ -96,7 +97,7 @@ function M.hi_test()
   -- nvim-tree groups, ordered
   local displays = {}
   for _, highlight_group in ipairs(appearance.HIGHLIGHT_GROUPS) do
-    local display = HighlightDisplay:new(highlight_group.group)
+    local display = HighlightDisplay({ group = highlight_group.group })
     table.insert(displays, display)
   end
   l = render_displays("nvim-tree", displays, bufnr, l)
@@ -110,7 +111,7 @@ function M.hi_test()
   if ok then
     for group in string.gmatch(out, "(%w*)%s+xxx") do
       if group:find("NvimTree", 1, true) ~= 1 then
-        local display = HighlightDisplay:new(group)
+        local display = HighlightDisplay({ group = group })
         if #display.group + #display.links > SHORT_LEN then
           table.insert(displays_long, display)
         else
@@ -129,7 +130,7 @@ function M.hi_test()
   render_displays("other, long", displays_long, bufnr, l)
 
   -- finalise and focus the buffer
-  if vim.fn.has "nvim-0.10" == 1 then
+  if vim.fn.has("nvim-0.10") == 1 then
     vim.api.nvim_set_option_value("modifiable", false, { buf = bufnr })
   else
     vim.api.nvim_buf_set_option(bufnr, "modifiable", false) ---@diagnostic disable-line: deprecated
@@ -137,5 +138,3 @@ function M.hi_test()
 
   vim.cmd.buffer(bufnr)
 end
-
-return M

lua/nvim-tree/appearance/init.lua

@@ -12,126 +12,126 @@ local M = {}
 M.HIGHLIGHT_GROUPS = {
 
   -- Standard
-  { group = "NvimTreeNormal", link = "Normal" },
+  { group = "NvimTreeNormal",                  link = "Normal" },
-  { group = "NvimTreeNormalFloat", link = "NormalFloat" },
+  { group = "NvimTreeNormalFloat",             link = "NormalFloat" },
-  { group = "NvimTreeNormalFloatBorder", link = "FloatBorder" },
+  { group = "NvimTreeNormalFloatBorder",       link = "FloatBorder" },
-  { group = "NvimTreeNormalNC", link = "NvimTreeNormal" },
+  { group = "NvimTreeNormalNC",                link = "NvimTreeNormal" },
 
-  { group = "NvimTreeLineNr", link = "LineNr" },
+  { group = "NvimTreeLineNr",                  link = "LineNr" },
-  { group = "NvimTreeWinSeparator", link = "WinSeparator" },
+  { group = "NvimTreeWinSeparator",            link = "WinSeparator" },
-  { group = "NvimTreeEndOfBuffer", link = "EndOfBuffer" },
+  { group = "NvimTreeEndOfBuffer",             link = "EndOfBuffer" },
-  { group = "NvimTreePopup", link = "Normal" },
+  { group = "NvimTreePopup",                   link = "Normal" },
-  { group = "NvimTreeSignColumn", link = "NvimTreeNormal" },
+  { group = "NvimTreeSignColumn",              link = "NvimTreeNormal" },
 
-  { group = "NvimTreeCursorColumn", link = "CursorColumn" },
+  { group = "NvimTreeCursorColumn",            link = "CursorColumn" },
-  { group = "NvimTreeCursorLine", link = "CursorLine" },
+  { group = "NvimTreeCursorLine",              link = "CursorLine" },
-  { group = "NvimTreeCursorLineNr", link = "CursorLineNr" },
+  { group = "NvimTreeCursorLineNr",            link = "CursorLineNr" },
 
-  { group = "NvimTreeStatusLine", link = "StatusLine" },
+  { group = "NvimTreeStatusLine",              link = "StatusLine" },
-  { group = "NvimTreeStatusLineNC", link = "StatusLineNC" },
+  { group = "NvimTreeStatusLineNC",            link = "StatusLineNC" },
 
   -- File Text
-  { group = "NvimTreeExecFile", link = "Question" },
+  { group = "NvimTreeExecFile",                link = "Question" },
-  { group = "NvimTreeImageFile", link = "Question" },
+  { group = "NvimTreeImageFile",               link = "Question" },
-  { group = "NvimTreeSpecialFile", link = "Title" },
+  { group = "NvimTreeSpecialFile",             link = "Title" },
-  { group = "NvimTreeSymlink", link = "Underlined" },
+  { group = "NvimTreeSymlink",                 link = "Underlined" },
 
   -- Folder Text
-  { group = "NvimTreeRootFolder", link = "Title" },
+  { group = "NvimTreeRootFolder",              link = "Title" },
-  { group = "NvimTreeFolderName", link = "Directory" },
+  { group = "NvimTreeFolderName",              link = "Directory" },
-  { group = "NvimTreeEmptyFolderName", link = "Directory" },
+  { group = "NvimTreeEmptyFolderName",         link = "Directory" },
-  { group = "NvimTreeOpenedFolderName", link = "Directory" },
+  { group = "NvimTreeOpenedFolderName",        link = "Directory" },
-  { group = "NvimTreeSymlinkFolderName", link = "Directory" },
+  { group = "NvimTreeSymlinkFolderName",       link = "Directory" },
 
   -- File Icons
-  { group = "NvimTreeFileIcon", link = "NvimTreeNormal" },
+  { group = "NvimTreeFileIcon",                link = "NvimTreeNormal" },
-  { group = "NvimTreeSymlinkIcon", link = "NvimTreeNormal" },
+  { group = "NvimTreeSymlinkIcon",             link = "NvimTreeNormal" },
 
   -- Folder Icons
-  { group = "NvimTreeFolderIcon", def = "guifg=#8094b4 ctermfg=Blue" },
+  { group = "NvimTreeFolderIcon",              def = "guifg=#8094b4 ctermfg=Blue" },
-  { group = "NvimTreeOpenedFolderIcon", link = "NvimTreeFolderIcon" },
+  { group = "NvimTreeOpenedFolderIcon",        link = "NvimTreeFolderIcon" },
-  { group = "NvimTreeClosedFolderIcon", link = "NvimTreeFolderIcon" },
+  { group = "NvimTreeClosedFolderIcon",        link = "NvimTreeFolderIcon" },
-  { group = "NvimTreeFolderArrowClosed", link = "NvimTreeIndentMarker" },
+  { group = "NvimTreeFolderArrowClosed",       link = "NvimTreeIndentMarker" },
-  { group = "NvimTreeFolderArrowOpen", link = "NvimTreeIndentMarker" },
+  { group = "NvimTreeFolderArrowOpen",         link = "NvimTreeIndentMarker" },
 
   -- Indent
-  { group = "NvimTreeIndentMarker", link = "NvimTreeFolderIcon" },
+  { group = "NvimTreeIndentMarker",            link = "NvimTreeFolderIcon" },
 
   -- Picker
-  { group = "NvimTreeWindowPicker", def = "guifg=#ededed guibg=#4493c8 gui=bold ctermfg=White ctermbg=DarkBlue" },
+  { group = "NvimTreeWindowPicker",            def = "guifg=#ededed guibg=#4493c8 gui=bold ctermfg=White ctermbg=DarkBlue" },
 
   -- LiveFilter
-  { group = "NvimTreeLiveFilterPrefix", link = "PreProc" },
+  { group = "NvimTreeLiveFilterPrefix",        link = "PreProc" },
-  { group = "NvimTreeLiveFilterValue", link = "ModeMsg" },
+  { group = "NvimTreeLiveFilterValue",         link = "ModeMsg" },
 
   -- Clipboard
-  { group = "NvimTreeCutHL", link = "SpellBad" },
+  { group = "NvimTreeCutHL",                   link = "SpellBad" },
-  { group = "NvimTreeCopiedHL", link = "SpellRare" },
+  { group = "NvimTreeCopiedHL",                link = "SpellRare" },
 
   -- Bookmark
-  { group = "NvimTreeBookmarkIcon", link = "NvimTreeFolderIcon" },
+  { group = "NvimTreeBookmarkIcon",            link = "NvimTreeFolderIcon" },
-  { group = "NvimTreeBookmarkHL", link = "SpellLocal" },
+  { group = "NvimTreeBookmarkHL",              link = "SpellLocal" },
 
   -- Modified
-  { group = "NvimTreeModifiedIcon", link = "Type" },
+  { group = "NvimTreeModifiedIcon",            link = "Type" },
-  { group = "NvimTreeModifiedFileHL", link = "NvimTreeModifiedIcon" },
+  { group = "NvimTreeModifiedFileHL",          link = "NvimTreeModifiedIcon" },
-  { group = "NvimTreeModifiedFolderHL", link = "NvimTreeModifiedFileHL" },
+  { group = "NvimTreeModifiedFolderHL",        link = "NvimTreeModifiedFileHL" },
 
   -- Hidden
-  { group = "NvimTreeHiddenIcon", link = "Conceal" },
+  { group = "NvimTreeHiddenIcon",              link = "Conceal" },
-  { group = "NvimTreeHiddenFileHL", link = "NvimTreeHiddenIcon" },
+  { group = "NvimTreeHiddenFileHL",            link = "NvimTreeHiddenIcon" },
-  { group = "NvimTreeHiddenFolderHL", link = "NvimTreeHiddenFileHL" },
+  { group = "NvimTreeHiddenFolderHL",          link = "NvimTreeHiddenFileHL" },
 
   -- Hidden Display
-  { group = "NvimTreeHiddenDisplay", link = "Conceal" },
+  { group = "NvimTreeHiddenDisplay",           link = "Conceal" },
 
   -- Opened
-  { group = "NvimTreeOpenedHL", link = "Special" },
+  { group = "NvimTreeOpenedHL",                link = "Special" },
 
   -- Git Icon
-  { group = "NvimTreeGitDeletedIcon", link = "Statement" },
+  { group = "NvimTreeGitDeletedIcon",          link = "Statement" },
-  { group = "NvimTreeGitDirtyIcon", link = "Statement" },
+  { group = "NvimTreeGitDirtyIcon",            link = "Statement" },
-  { group = "NvimTreeGitIgnoredIcon", link = "Comment" },
+  { group = "NvimTreeGitIgnoredIcon",          link = "Comment" },
-  { group = "NvimTreeGitMergeIcon", link = "Constant" },
+  { group = "NvimTreeGitMergeIcon",            link = "Constant" },
-  { group = "NvimTreeGitNewIcon", link = "PreProc" },
+  { group = "NvimTreeGitNewIcon",              link = "PreProc" },
-  { group = "NvimTreeGitRenamedIcon", link = "PreProc" },
+  { group = "NvimTreeGitRenamedIcon",          link = "PreProc" },
-  { group = "NvimTreeGitStagedIcon", link = "Constant" },
+  { group = "NvimTreeGitStagedIcon",           link = "Constant" },
 
   -- Git File Highlight
-  { group = "NvimTreeGitFileDeletedHL", link = "NvimTreeGitDeletedIcon" },
+  { group = "NvimTreeGitFileDeletedHL",        link = "NvimTreeGitDeletedIcon" },
-  { group = "NvimTreeGitFileDirtyHL", link = "NvimTreeGitDirtyIcon" },
+  { group = "NvimTreeGitFileDirtyHL",          link = "NvimTreeGitDirtyIcon" },
-  { group = "NvimTreeGitFileIgnoredHL", link = "NvimTreeGitIgnoredIcon" },
+  { group = "NvimTreeGitFileIgnoredHL",        link = "NvimTreeGitIgnoredIcon" },
-  { group = "NvimTreeGitFileMergeHL", link = "NvimTreeGitMergeIcon" },
+  { group = "NvimTreeGitFileMergeHL",          link = "NvimTreeGitMergeIcon" },
-  { group = "NvimTreeGitFileNewHL", link = "NvimTreeGitNewIcon" },
+  { group = "NvimTreeGitFileNewHL",            link = "NvimTreeGitNewIcon" },
-  { group = "NvimTreeGitFileRenamedHL", link = "NvimTreeGitRenamedIcon" },
+  { group = "NvimTreeGitFileRenamedHL",        link = "NvimTreeGitRenamedIcon" },
-  { group = "NvimTreeGitFileStagedHL", link = "NvimTreeGitStagedIcon" },
+  { group = "NvimTreeGitFileStagedHL",         link = "NvimTreeGitStagedIcon" },
 
   -- Git Folder Highlight
-  { group = "NvimTreeGitFolderDeletedHL", link = "NvimTreeGitFileDeletedHL" },
+  { group = "NvimTreeGitFolderDeletedHL",      link = "NvimTreeGitFileDeletedHL" },
-  { group = "NvimTreeGitFolderDirtyHL", link = "NvimTreeGitFileDirtyHL" },
+  { group = "NvimTreeGitFolderDirtyHL",        link = "NvimTreeGitFileDirtyHL" },
-  { group = "NvimTreeGitFolderIgnoredHL", link = "NvimTreeGitFileIgnoredHL" },
+  { group = "NvimTreeGitFolderIgnoredHL",      link = "NvimTreeGitFileIgnoredHL" },
-  { group = "NvimTreeGitFolderMergeHL", link = "NvimTreeGitFileMergeHL" },
+  { group = "NvimTreeGitFolderMergeHL",        link = "NvimTreeGitFileMergeHL" },
-  { group = "NvimTreeGitFolderNewHL", link = "NvimTreeGitFileNewHL" },
+  { group = "NvimTreeGitFolderNewHL",          link = "NvimTreeGitFileNewHL" },
-  { group = "NvimTreeGitFolderRenamedHL", link = "NvimTreeGitFileRenamedHL" },
+  { group = "NvimTreeGitFolderRenamedHL",      link = "NvimTreeGitFileRenamedHL" },
-  { group = "NvimTreeGitFolderStagedHL", link = "NvimTreeGitFileStagedHL" },
+  { group = "NvimTreeGitFolderStagedHL",       link = "NvimTreeGitFileStagedHL" },
 
   -- Diagnostics Icon
-  { group = "NvimTreeDiagnosticErrorIcon", link = "DiagnosticError" },
+  { group = "NvimTreeDiagnosticErrorIcon",     link = "DiagnosticError" },
-  { group = "NvimTreeDiagnosticWarnIcon", link = "DiagnosticWarn" },
+  { group = "NvimTreeDiagnosticWarnIcon",      link = "DiagnosticWarn" },
-  { group = "NvimTreeDiagnosticInfoIcon", link = "DiagnosticInfo" },
+  { group = "NvimTreeDiagnosticInfoIcon",      link = "DiagnosticInfo" },
-  { group = "NvimTreeDiagnosticHintIcon", link = "DiagnosticHint" },
+  { group = "NvimTreeDiagnosticHintIcon",      link = "DiagnosticHint" },
 
   -- Diagnostics File Highlight
-  { group = "NvimTreeDiagnosticErrorFileHL", link = "DiagnosticUnderlineError" },
+  { group = "NvimTreeDiagnosticErrorFileHL",   link = "DiagnosticUnderlineError" },
-  { group = "NvimTreeDiagnosticWarnFileHL", link = "DiagnosticUnderlineWarn" },
+  { group = "NvimTreeDiagnosticWarnFileHL",    link = "DiagnosticUnderlineWarn" },
-  { group = "NvimTreeDiagnosticInfoFileHL", link = "DiagnosticUnderlineInfo" },
+  { group = "NvimTreeDiagnosticInfoFileHL",    link = "DiagnosticUnderlineInfo" },
-  { group = "NvimTreeDiagnosticHintFileHL", link = "DiagnosticUnderlineHint" },
+  { group = "NvimTreeDiagnosticHintFileHL",    link = "DiagnosticUnderlineHint" },
 
   -- Diagnostics Folder Highlight
   { group = "NvimTreeDiagnosticErrorFolderHL", link = "NvimTreeDiagnosticErrorFileHL" },
-  { group = "NvimTreeDiagnosticWarnFolderHL", link = "NvimTreeDiagnosticWarnFileHL" },
+  { group = "NvimTreeDiagnosticWarnFolderHL",  link = "NvimTreeDiagnosticWarnFileHL" },
-  { group = "NvimTreeDiagnosticInfoFolderHL", link = "NvimTreeDiagnosticInfoFileHL" },
+  { group = "NvimTreeDiagnosticInfoFolderHL",  link = "NvimTreeDiagnosticInfoFileHL" },
-  { group = "NvimTreeDiagnosticHintFolderHL", link = "NvimTreeDiagnosticHintFileHL" },
+  { group = "NvimTreeDiagnosticHintFolderHL",  link = "NvimTreeDiagnosticHintFileHL" },
 }
 
 -- nvim-tree highlight groups to legacy

lua/nvim-tree/buffers.lua

@@ -1,3 +1,5 @@
+local DirectoryNode = require("nvim-tree.node.directory")
+
 local M = {}
 
 ---@type table<string, boolean> record of which file is modified
@@ -6,16 +8,14 @@ M._modified = {}
 ---refresh M._modified
 function M.reload_modified()
   M._modified = {}
-  local bufs = vim.fn.getbufinfo { bufmodified = 1, buflisted = 1 }
+  local bufs = vim.fn.getbufinfo({ bufmodified = 1, buflisted = 1 })
   for _, buf in pairs(bufs) do
     local path = buf.name
     if path ~= "" then -- not a [No Name] buffer
       -- mark all the parent as modified as well
-      while
+      while M._modified[path] ~= true do
-        M._modified[path] ~= true
         -- no need to keep going if already recorded
         -- This also prevents an infinite loop
-      do
         M._modified[path] = true
         path = vim.fn.fnamemodify(path, ":h")
       end
@@ -23,18 +23,33 @@ function M.reload_modified()
   end
 end
 
----@param node table
+---@param node Node
 ---@return boolean
 function M.is_modified(node)
-  return node
+  if not M.config.modified.enable then
-    and M.config.modified.enable
+    return false
-    and M._modified[node.absolute_path]
+  end
-    and (not node.nodes or M.config.modified.show_on_dirs)
+
-    and (not node.open or M.config.modified.show_on_open_dirs)
+  if not M._modified[node.absolute_path] then
+    return false
+  end
+
+  local dir = node:as(DirectoryNode)
+  if dir then
+    if not M.config.modified.show_on_dirs then
+      return false
+    end
+
+    if dir.open and not M.config.modified.show_on_open_dirs then
+      return false
+    end
+  end
+
+  return true
 end
 
 ---A buffer exists for the node's absolute path
----@param node table
+---@param node Node
 ---@return boolean
 function M.is_opened(node)
   return node and vim.fn.bufloaded(node.absolute_path) > 0

lua/nvim-tree/classic.lua

@@ -0,0 +1,91 @@
+--
+-- classic
+--
+-- Copyright (c) 2014, rxi
+--
+-- This module is free software; you can redistribute it and/or modify it under
+-- the terms of the MIT license. See LICENSE for details.
+--
+-- https://github.com/rxi/classic
+--
+
+---@class (exact) Class
+---@field super Class
+---@field private implements table<Class, boolean>
+local Class = {}
+Class.__index = Class ---@diagnostic disable-line: inject-field
+
+---Default constructor
+---@protected
+function Class:new(...) --luacheck: ignore 212
+end
+
+---Extend a class, setting .super
+function Class:extend()
+  local cls = {}
+  for k, v in pairs(self) do
+    if k:find("__") == 1 then
+      cls[k] = v
+    end
+  end
+  cls.__index = cls
+  cls.super = self
+  setmetatable(cls, self)
+  return cls
+end
+
+---Implement the functions of a mixin
+---Add the mixin to .implements
+---@param mixin Class
+function Class:implement(mixin)
+  if not rawget(self, "implements") then
+    -- set on the class itself instead of parents
+    rawset(self, "implements", {})
+  end
+  self.implements[mixin] = true
+  for k, v in pairs(mixin) do
+    if self[k] == nil and type(v) == "function" then
+      self[k] = v
+    end
+  end
+end
+
+---Object is an instance of class or implements a mixin
+---@generic T
+---@param class T
+---@return boolean
+function Class:is(class)
+  local mt = getmetatable(self)
+  while mt do
+    if mt == class then
+      return true
+    end
+    if mt.implements and mt.implements[class] then
+      return true
+    end
+    mt = getmetatable(mt)
+  end
+  return false
+end
+
+---Return object if :is otherwise nil
+---@generic T
+---@param class T
+---@return T|nil
+function Class:as(class)
+  return self:is(class) and self or nil
+end
+
+---Constructor to create instance, call :new and return
+function Class:__call(...)
+  local obj = setmetatable({}, self)
+  obj:new(...)
+  return obj
+end
+
+-- avoid unused param warnings in abstract methods
+---@param ... any
+function Class:nop(...) --luacheck: ignore 212
+end
+
+return Class

lua/nvim-tree/commands.lua

@@ -1,5 +1,5 @@
-local api = require "nvim-tree.api"
+local api = require("nvim-tree.api")
-local view = require "nvim-tree.view"
+local view = require("nvim-tree.view")
 
 local M = {}
 
@@ -12,7 +12,7 @@ local CMDS = {
       complete = "dir",
     },
     command = function(c)
-      api.tree.open { path = c.args }
+      api.tree.open({ path = c.args })
     end,
   },
   {
@@ -33,12 +33,12 @@ local CMDS = {
       complete = "dir",
     },
     command = function(c)
-      api.tree.toggle {
+      api.tree.toggle({
         find_file = false,
         focus = true,
         path = c.args,
         update_root = false,
-      }
+      })
     end,
   },
   {
@@ -79,11 +79,11 @@ local CMDS = {
       bar = true,
     },
     command = function(c)
-      api.tree.find_file {
+      api.tree.find_file({
         open = true,
         focus = true,
         update_root = c.bang,
-      }
+      })
     end,
   },
   {
@@ -95,12 +95,12 @@ local CMDS = {
       complete = "dir",
     },
     command = function(c)
-      api.tree.toggle {
+      api.tree.toggle({
         find_file = true,
         focus = true,
         path = c.args,
         update_root = c.bang,
-      }
+      })
     end,
   },
   {

lua/nvim-tree/core.lua

@@ -1,7 +1,7 @@
-local events = require "nvim-tree.events"
+local events = require("nvim-tree.events")
-local explorer = require "nvim-tree.explorer"
+local notify = require("nvim-tree.notify")
-local view = require "nvim-tree.view"
+local view = require("nvim-tree.view")
-local log = require "nvim-tree.log"
+local log = require("nvim-tree.log")
 
 local M = {}
 
@@ -16,7 +16,21 @@ function M.init(foldername)
   if TreeExplorer then
     TreeExplorer:destroy()
   end
-  TreeExplorer = explorer:new(foldername)
+
+  local err, path
+
+  if foldername then
+    path, err = vim.loop.fs_realpath(foldername)
+  else
+    path, err = vim.loop.cwd()
+  end
+  if path then
+    TreeExplorer = require("nvim-tree.explorer")({ path = path })
+  else
+    notify.error(err)
+    TreeExplorer = nil
+  end
+
   if not first_init_done then
     events._dispatch_ready()
     first_init_done = true

lua/nvim-tree/diagnostics.lua

@@ -1,6 +1,9 @@
-local utils = require "nvim-tree.utils"
+local core = require("nvim-tree.core")
-local view = require "nvim-tree.view"
+local utils = require("nvim-tree.utils")
-local log = require "nvim-tree.log"
+local view = require("nvim-tree.view")
+local log = require("nvim-tree.log")
+
+local DirectoryNode = require("nvim-tree.node.directory")
 
 local M = {}
 
@@ -41,7 +44,7 @@ local function from_nvim_lsp()
 
   -- is_enabled is not present in all 0.10 builds/releases, see #2781
   local is_enabled = false
-  if vim.fn.has "nvim-0.10" == 1 and type(vim.diagnostic.is_enabled) == "function" then
+  if vim.fn.has("nvim-0.10") == 1 and type(vim.diagnostic.is_enabled) == "function" then
     is_enabled = vim.diagnostic.is_enabled()
   elseif type(vim.diagnostic.is_disabled) == "function" then ---@diagnostic disable-line: deprecated
     is_enabled = not vim.diagnostic.is_disabled() ---@diagnostic disable-line: deprecated
@@ -76,7 +79,7 @@ local function handle_coc_exception(err)
   local notify = true
 
   -- avoid distractions on interrupts (CTRL-C)
-  if err:find "Vim:Interrupt" or err:find "Keyboard interrupt" then
+  if err:find("Vim:Interrupt") or err:find("Keyboard interrupt") then
     notify = false
   end
 
@@ -99,7 +102,7 @@ local function from_coc()
   end
 
   local ok, diagnostic_list = xpcall(function()
-    return vim.fn.CocAction "diagnosticList"
+    return vim.fn.CocAction("diagnosticList")
   end, handle_coc_exception)
   if not ok or type(diagnostic_list) ~= "table" or vim.tbl_isempty(diagnostic_list) then
     return {}
@@ -124,7 +127,7 @@ end
 local function from_cache(node)
   local nodepath = uniformize_path(node.absolute_path)
   local max_severity = nil
-  if not node.nodes then
+  if not node:is(DirectoryNode) then
     -- direct cache hit for files
     max_severity = NODE_SEVERITIES[nodepath]
   else
@@ -151,21 +154,30 @@ function M.update()
     return
   end
   utils.debounce("diagnostics", M.debounce_delay, function()
-    local profile = log.profile_start "diagnostics update"
+    local profile = log.profile_start("diagnostics update")
     if is_using_coc() then
       NODE_SEVERITIES = from_coc()
     else
       NODE_SEVERITIES = from_nvim_lsp()
     end
     NODE_SEVERITIES_VERSION = NODE_SEVERITIES_VERSION + 1
-    if log.enabled "diagnostics" then
+    if log.enabled("diagnostics") then
       for bufname, severity in pairs(NODE_SEVERITIES) do
         log.line("diagnostics", "Indexing bufname '%s' with severity %d", bufname, severity)
       end
     end
     log.profile_end(profile)
-    if view.is_buf_valid(view.get_bufnr()) then
+
-      require("nvim-tree.renderer").draw()
+    local bufnr = view.get_bufnr()
+    local should_draw = bufnr
+      and vim.api.nvim_buf_is_valid(bufnr)
+      and vim.api.nvim_buf_is_loaded(bufnr)
+      and vim.api.nvim_get_option_value("buflisted", { buf = bufnr })
+    if should_draw then
+      local explorer = core.get_explorer()
+      if explorer then
+        explorer.renderer:draw()
+      end
     end
   end)
 end
@@ -180,7 +192,7 @@ function M.get_diag_status(node)
   end
 
   -- dir but we shouldn't show on dirs at all
-  if node.nodes ~= nil and not M.show_on_dirs then
+  if node:is(DirectoryNode) and not M.show_on_dirs then
     return nil
   end
 
@@ -191,13 +203,15 @@ function M.get_diag_status(node)
     node.diag_status = from_cache(node)
   end
 
+  local dir = node:as(DirectoryNode)
+
   -- file
-  if not node.nodes then
+  if not dir then
     return node.diag_status
   end
 
   -- dir is closed or we should show on open_dirs
-  if not node.open or M.show_on_open_dirs then
+  if not dir.open or M.show_on_open_dirs then
     return node.diag_status
   end
   return nil

lua/nvim-tree/enum.lua

@@ -1,24 +1,5 @@
 local M = {}
 
----Setup options for "highlight_*"
----@enum HL_POSITION
-M.HL_POSITION = {
-  none = 0,
-  icon = 1,
-  name = 2,
-  all = 4,
-}
-
----Setup options for "*_placement"
----@enum ICON_PLACEMENT
-M.ICON_PLACEMENT = {
-  none = 0,
-  signcolumn = 1,
-  before = 2,
-  after = 3,
-  right_align = 4,
-}
-
 ---Reason for filter in filter.lua
 ---@enum FILTER_REASON
 M.FILTER_REASON = {

lua/nvim-tree/events.lua

@@ -1,4 +1,4 @@
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
 
 local M = {}
 

lua/nvim-tree/explorer/explore.lua

@@ -1,118 +0,0 @@
-local utils = require "nvim-tree.utils"
-local builders = require "nvim-tree.explorer.node-builders"
-local explorer_node = require "nvim-tree.explorer.node"
-local git = require "nvim-tree.git"
-local log = require "nvim-tree.log"
-
-local FILTER_REASON = require("nvim-tree.enum").FILTER_REASON
-local Watcher = require "nvim-tree.watcher"
-
-local M = {}
-
----@param handle uv.uv_fs_t
----@param cwd string
----@param node Node
----@param git_status table
----@param parent Explorer
-local function populate_children(handle, cwd, node, git_status, parent)
-  local node_ignored = explorer_node.is_git_ignored(node)
-  local nodes_by_path = utils.bool_record(node.nodes, "absolute_path")
-
-  local filter_status = parent.filters:prepare(git_status)
-
-  node.hidden_stats = vim.tbl_deep_extend("force", node.hidden_stats or {}, {
-    git = 0,
-    buf = 0,
-    dotfile = 0,
-    custom = 0,
-    bookmark = 0,
-  })
-
-  while true do
-    local name, _ = vim.loop.fs_scandir_next(handle)
-    if not name then
-      break
-    end
-
-    local abs = utils.path_join { cwd, name }
-
-    if Watcher.is_fs_event_capable(abs) then
-      local profile = log.profile_start("explore populate_children %s", abs)
-
-      ---@type uv.fs_stat.result|nil
-      local stat = vim.loop.fs_stat(abs)
-
-      -- Type must come from fs_stat and not fs_scandir_next to maintain sshfs compatibility
-      local type = stat and stat.type or nil
-
-      local filter_reason = parent.filters:should_filter_as_reason(abs, stat, filter_status)
-      if filter_reason == FILTER_REASON.none and not nodes_by_path[abs] then
-        local child = nil
-        if type == "directory" and vim.loop.fs_access(abs, "R") then
-          child = builders.folder(node, abs, name, stat)
-        elseif type == "file" then
-          child = builders.file(node, abs, name, stat)
-        elseif type == "link" then
-          local link = builders.link(node, abs, name, stat)
-          if link.link_to ~= nil then
-            child = link
-          end
-        end
-        if child then
-          table.insert(node.nodes, child)
-          nodes_by_path[child.absolute_path] = true
-          explorer_node.update_git_status(child, node_ignored, git_status)
-        end
-      else
-        for reason, value in pairs(FILTER_REASON) do
-          if filter_reason == value then
-            node.hidden_stats[reason] = node.hidden_stats[reason] + 1
-          end
-        end
-      end
-
-      log.profile_end(profile)
-    end
-  end
-end
-
----@param node Node
----@param status table
----@param parent Explorer
----@return Node[]|nil
-function M.explore(node, status, parent)
-  local cwd = node.link_to or node.absolute_path
-  local handle = vim.loop.fs_scandir(cwd)
-  if not handle then
-    return
-  end
-
-  local profile = log.profile_start("explore init %s", node.absolute_path)
-
-  populate_children(handle, cwd, node, status, parent)
-
-  local is_root = not node.parent
-  local child_folder_only = explorer_node.has_one_child_folder(node) and node.nodes[1]
-  if M.config.group_empty and not is_root and child_folder_only then
-    local child_cwd = child_folder_only.link_to or child_folder_only.absolute_path
-    local child_status = git.load_project_status(child_cwd)
-    node.group_next = child_folder_only
-    local ns = M.explore(child_folder_only, child_status, parent)
-    node.nodes = ns or {}
-
-    log.profile_end(profile)
-    return ns
-  end
-
-  parent.sorters:sort(node.nodes)
-  parent.live_filter:apply_filter(node)
-
-  log.profile_end(profile)
-  return node.nodes
-end
-
-function M.setup(opts)
-  M.config = opts.renderer
-end
-
-return M

lua/nvim-tree/explorer/filters.lua

@@ -1,52 +1,59 @@
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
 local FILTER_REASON = require("nvim-tree.enum").FILTER_REASON
 
----@class Filters to handle all opts.filters and related API
+local Class = require("nvim-tree.classic")
----@field config table hydrated user opts.filters
+
+---@alias FilterType "custom" | "dotfiles" | "git_ignored" | "git_clean" | "no_buffer" | "no_bookmark"
+
+---@class (exact) Filters: Class
+---@field enabled boolean
+---@field state table<FilterType, boolean>
 ---@field private explorer Explorer
 ---@field private exclude_list string[] filters.exclude
----@field private ignore_list string[] filters.custom string table
+---@field private ignore_list table<string, boolean> filters.custom string table
 ---@field private custom_function (fun(absolute_path: string): boolean)|nil filters.custom function
-local Filters = {}
+local Filters = Class:extend()
 
----@param opts table user options
+---@class Filters
----@param explorer Explorer
+---@overload fun(args: FiltersArgs): Filters
----@return Filters
+
-function Filters:new(opts, explorer)
+---@class (exact) FiltersArgs
-  local o = {
+---@field explorer Explorer
-    explorer = explorer,
+
-    ignore_list = {},
+---@protected
-    exclude_list = opts.filters.exclude,
+---@param args FiltersArgs
-    custom_function = nil,
+function Filters:new(args)
-    config = {
+  self.explorer        = args.explorer
-      enable = opts.filters.enable,
+  self.ignore_list     = {}
-      filter_custom = true,
+  self.exclude_list    = self.explorer.opts.filters.exclude
-      filter_dotfiles = opts.filters.dotfiles,
+  self.custom_function = nil
-      filter_git_ignored = opts.filters.git_ignored,
+
-      filter_git_clean = opts.filters.git_clean,
+  self.enabled         = self.explorer.opts.filters.enable
-      filter_no_buffer = opts.filters.no_buffer,
+  self.state           = {
-      filter_no_bookmark = opts.filters.no_bookmark,
+    custom      = true,
-    },
+    dotfiles    = self.explorer.opts.filters.dotfiles,
+    git_ignored = self.explorer.opts.filters.git_ignored,
+    git_clean   = self.explorer.opts.filters.git_clean,
+    no_buffer   = self.explorer.opts.filters.no_buffer,
+    no_bookmark = self.explorer.opts.filters.no_bookmark,
   }
 
-  local custom_filter = opts.filters.custom
+  local custom_filter  = self.explorer.opts.filters.custom
   if type(custom_filter) == "function" then
-    o.custom_function = custom_filter
+    self.custom_function = custom_filter
   else
     if custom_filter and #custom_filter > 0 then
       for _, filter_name in pairs(custom_filter) do
-        o.ignore_list[filter_name] = true
+        self.ignore_list[filter_name] = true
       end
     end
   end
-  setmetatable(o, self)
-  self.__index = self
-  return o
 end
 
+---@private
 ---@param path string
 ---@return boolean
-local function is_excluded(self, path)
+function Filters:is_excluded(path)
   for _, node in ipairs(self.exclude_list) do
     if path:match(node) then
       return true
@@ -56,26 +63,27 @@ local function is_excluded(self, path)
 end
 
 ---Check if the given path is git clean/ignored
+---@private
 ---@param path string Absolute path
----@param git_status table from prepare
+---@param project GitProject from prepare
 ---@return boolean
-local function git(self, path, git_status)
+function Filters:git(path, project)
-  if type(git_status) ~= "table" or type(git_status.files) ~= "table" or type(git_status.dirs) ~= "table" then
+  if type(project) ~= "table" or type(project.files) ~= "table" or type(project.dirs) ~= "table" then
     return false
   end
 
   -- default status to clean
-  local status = git_status.files[path]
+  local xy = project.files[path]
-  status = status or git_status.dirs.direct[path] and git_status.dirs.direct[path][1]
+  xy = xy or project.dirs.direct[path] and project.dirs.direct[path][1]
-  status = status or git_status.dirs.indirect[path] and git_status.dirs.indirect[path][1]
+  xy = xy or project.dirs.indirect[path] and project.dirs.indirect[path][1]
 
   -- filter ignored; overrides clean as they are effectively dirty
-  if self.config.filter_git_ignored and status == "!!" then
+  if self.state.git_ignored and xy == "!!" then
     return true
   end
 
   -- filter clean
-  if self.config.filter_git_clean and not status then
+  if self.state.git_clean and not xy then
     return true
   end
 
@@ -83,11 +91,12 @@ local function git(self, path, git_status)
 end
 
 ---Check if the given path has no listed buffer
+---@private
 ---@param path string Absolute path
 ---@param bufinfo table vim.fn.getbufinfo { buflisted = 1 }
 ---@return boolean
-local function buf(self, path, bufinfo)
+function Filters:buf(path, bufinfo)
-  if not self.config.filter_no_buffer or type(bufinfo) ~= "table" then
+  if not self.state.no_buffer or type(bufinfo) ~= "table" then
     return false
   end
 
@@ -101,17 +110,21 @@ local function buf(self, path, bufinfo)
   return true
 end
 
+---@private
 ---@param path string
 ---@return boolean
-local function dotfile(self, path)
+function Filters:dotfile(path)
-  return self.config.filter_dotfiles and utils.path_basename(path):sub(1, 1) == "."
+  return self.state.dotfiles and utils.path_basename(path):sub(1, 1) == "."
 end
 
+---Bookmark is present
+---@private
 ---@param path string
 ---@param path_type string|nil filetype of path
 ---@param bookmarks table<string, string|nil> path, filetype table of bookmarked files
-local function bookmark(self, path, path_type, bookmarks)
+---@return boolean
-  if not self.config.filter_no_bookmark then
+function Filters:bookmark(path, path_type, bookmarks)
+  if not self.state.no_bookmark then
     return false
   end
   -- if bookmark is empty, we should see a empty filetree
@@ -143,10 +156,11 @@ local function bookmark(self, path, path_type, bookmarks)
   return true
 end
 
+---@private
 ---@param path string
 ---@return boolean
-local function custom(self, path)
+function Filters:custom(path)
-  if not self.config.filter_custom then
+  if not self.state.custom then
     return false
   end
 
@@ -165,7 +179,7 @@ local function custom(self, path)
     end
   end
 
-  local idx = path:match ".+()%.[^.]+$"
+  local idx = path:match(".+()%.[^.]+$")
   if idx then
     if self.ignore_list["*" .. string.sub(path, idx)] == true then
       return true
@@ -176,20 +190,20 @@ local function custom(self, path)
 end
 
 ---Prepare arguments for should_filter. This is done prior to should_filter for efficiency reasons.
----@param git_status table|nil optional results of git.load_project_status(...)
+---@param project GitProject? optional results of git.load_projects(...)
 ---@return table
---- git_status: reference
+--- project: reference
 --- bufinfo: empty unless no_buffer set: vim.fn.getbufinfo { buflisted = 1 }
 --- bookmarks: absolute paths to boolean
-function Filters:prepare(git_status)
+function Filters:prepare(project)
   local status = {
-    git_status = git_status or {},
+    project = project or {},
     bufinfo = {},
     bookmarks = {},
   }
 
-  if self.config.filter_no_buffer then
+  if self.state.no_buffer then
-    status.bufinfo = vim.fn.getbufinfo { buflisted = 1 }
+    status.bufinfo = vim.fn.getbufinfo({ buflisted = 1 })
   end
 
   local explorer = require("nvim-tree.core").get_explorer()
@@ -208,20 +222,20 @@ end
 ---@param status table from prepare
 ---@return boolean
 function Filters:should_filter(path, fs_stat, status)
-  if not self.config.enable then
+  if not self.enabled then
     return false
   end
 
   -- exclusions override all filters
-  if is_excluded(self, path) then
+  if self:is_excluded(path) then
     return false
   end
 
-  return git(self, path, status.git_status)
+  return self:git(path, status.project)
-    or buf(self, path, status.bufinfo)
+    or self:buf(path, status.bufinfo)
-    or dotfile(self, path)
+    or self:dotfile(path)
-    or custom(self, path)
+    or self:custom(path)
-    or bookmark(self, path, fs_stat and fs_stat.type, status.bookmarks)
+    or self:bookmark(path, fs_stat and fs_stat.type, status.bookmarks)
 end
 
 --- Check if the given path should be filtered, and provide the reason why it was
@@ -230,27 +244,44 @@ end
 ---@param status table from prepare
 ---@return FILTER_REASON
 function Filters:should_filter_as_reason(path, fs_stat, status)
-  if not self.config.enable then
+  if not self.enabled then
     return FILTER_REASON.none
   end
 
-  if is_excluded(self, path) then
+  if self:is_excluded(path) then
     return FILTER_REASON.none
   end
 
-  if git(self, path, status.git_status) then
+  if self:git(path, status.project) then
     return FILTER_REASON.git
-  elseif buf(self, path, status.bufinfo) then
+  elseif self:buf(path, status.bufinfo) then
     return FILTER_REASON.buf
-  elseif dotfile(self, path) then
+  elseif self:dotfile(path) then
     return FILTER_REASON.dotfile
-  elseif custom(self, path) then
+  elseif self:custom(path) then
     return FILTER_REASON.custom
-  elseif bookmark(self, path, fs_stat and fs_stat.type, status.bookmarks) then
+  elseif self:bookmark(path, fs_stat and fs_stat.type, status.bookmarks) then
     return FILTER_REASON.bookmark
   else
     return FILTER_REASON.none
   end
 end
 
+---Toggle a type and refresh
+---@private
+---@param type FilterType? nil to disable all
+function Filters:toggle(type)
+  if not type or self.state[type] == nil then
+    self.enabled = not self.enabled
+  else
+    self.state[type] = not self.state[type]
+  end
+
+  local node = self.explorer:get_node_at_cursor()
+  self.explorer:reload_explorer()
+  if node then
+    utils.focus_node_or_parent(node)
+  end
+end
+
 return Filters

lua/nvim-tree/explorer/init.lua

@@ -1,93 +1,182 @@
-local builders = require "nvim-tree.explorer.node-builders"
+local appearance = require("nvim-tree.appearance")
-local git = require "nvim-tree.git"
+local buffers = require("nvim-tree.buffers")
-local log = require "nvim-tree.log"
+local core = require("nvim-tree.core")
-local notify = require "nvim-tree.notify"
+local git = require("nvim-tree.git")
-local utils = require "nvim-tree.utils"
+local log = require("nvim-tree.log")
-local watch = require "nvim-tree.explorer.watch"
+local utils = require("nvim-tree.utils")
-local explorer_node = require "nvim-tree.explorer.node"
+local view = require("nvim-tree.view")
+local node_factory = require("nvim-tree.node.factory")
 
-local NodeIterator = require "nvim-tree.iterators.node-iterator"
+local DirectoryNode = require("nvim-tree.node.directory")
-local Watcher = require "nvim-tree.watcher"
+local RootNode = require("nvim-tree.node.root")
+local Watcher = require("nvim-tree.watcher")
 
-local Filters = require "nvim-tree.explorer.filters"
+local Iterator = require("nvim-tree.iterators.node-iterator")
-local Marks = {} -- circular dependencies
+local NodeIterator = require("nvim-tree.iterators.node-iterator")
-local LiveFilter = require "nvim-tree.explorer.live-filter"
+
-local Sorters = require "nvim-tree.explorer.sorters"
+local Filters = require("nvim-tree.explorer.filters")
-local Clipboard = {} -- circular dependencies
+local Marks = require("nvim-tree.marks")
+local LiveFilter = require("nvim-tree.explorer.live-filter")
+local Sorter = require("nvim-tree.explorer.sorter")
+local Clipboard = require("nvim-tree.actions.fs.clipboard")
+local Renderer = require("nvim-tree.renderer")
 
 local FILTER_REASON = require("nvim-tree.enum").FILTER_REASON
 
 local config
 
----@class Explorer
+---@class (exact) Explorer: RootNode
----@field absolute_path string
+---@field uid_explorer number vim.loop.hrtime() at construction time
----@field nodes Node[]
+---@field opts table user options
----@field open boolean
+---@field augroup_id integer
+---@field renderer Renderer
 ---@field filters Filters
 ---@field live_filter LiveFilter
 ---@field sorters Sorter
 ---@field marks Marks
 ---@field clipboard Clipboard
-local Explorer = {}
+local Explorer = RootNode:extend()
 
-Explorer.explore = require("nvim-tree.explorer.explore").explore
+---@class Explorer
+---@overload fun(args: ExplorerArgs): Explorer
 
----@param path string|nil
+---@class (exact) ExplorerArgs
----@return Explorer|nil
+---@field path string
-function Explorer:new(path)
-  local err
 
-  if path then
+---@protected
-    path, err = vim.loop.fs_realpath(path)
+---@param args ExplorerArgs
-  else
+function Explorer:new(args)
-    path, err = vim.loop.cwd()
+  Explorer.super.new(self, {
-  end
+    explorer      = self,
-  if not path then
+    absolute_path = args.path,
-    notify.error(err)
+    name          = "..",
-    return
+  })
-  end
 
-  ---@class Explorer
+  self.uid_explorer = vim.loop.hrtime()
-  local o = setmetatable({
+  self.augroup_id   = vim.api.nvim_create_augroup("NvimTree_Explorer_" .. self.uid_explorer, {})
-    absolute_path = path,
-    nodes = {},
-    open = true,
-    sorters = Sorters:new(config),
-  }, Explorer)
-  setmetatable(o, self)
-  self.__index = self
 
-  o.watcher = watch.create_watcher(o)
+  self.open         = true
-  o.filters = Filters:new(config, o)
+  self.opts         = config
-  o.live_filter = LiveFilter:new(config, o)
-  o.marks = Marks:new(config, o)
-  o.clipboard = Clipboard:new(config, o)
 
-  o:_load(o)
+  self.sorters      = Sorter({ explorer = self })
+  self.renderer     = Renderer({ explorer = self })
+  self.filters      = Filters({ explorer = self })
+  self.live_filter  = LiveFilter({ explorer = self })
+  self.marks        = Marks({ explorer = self })
+  self.clipboard    = Clipboard({ explorer = self })
 
-  return o
+  self:create_autocmds()
+
+  self:_load(self)
 end
 
----@param node Node
+function Explorer:destroy()
+  log.line("dev", "Explorer:destroy")
+
+  vim.api.nvim_del_augroup_by_id(self.augroup_id)
+
+  RootNode.destroy(self)
+end
+
+function Explorer:create_autocmds()
+  -- reset and draw (highlights) when colorscheme is changed
+  vim.api.nvim_create_autocmd("ColorScheme", {
+    group = self.augroup_id,
+    callback = function()
+      appearance.setup()
+      view.reset_winhl()
+      self.renderer:draw()
+    end,
+  })
+
+  vim.api.nvim_create_autocmd("BufWritePost", {
+    group = self.augroup_id,
+    callback = function()
+      if self.opts.auto_reload_on_write and not self.opts.filesystem_watchers.enable then
+        self:reload_explorer()
+      end
+    end,
+  })
+
+  vim.api.nvim_create_autocmd("BufReadPost", {
+    group = self.augroup_id,
+    callback = function(data)
+      if (self.filters.state.no_buffer or self.opts.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == "" then
+        utils.debounce("Buf:filter_buffer_" .. self.uid_explorer, self.opts.view.debounce_delay, function()
+          self:reload_explorer()
+        end)
+      end
+    end,
+  })
+
+  -- update opened file buffers
+  vim.api.nvim_create_autocmd("BufUnload", {
+    group = self.augroup_id,
+    callback = function(data)
+      if (self.filters.state.no_buffer or self.opts.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == "" then
+        utils.debounce("Buf:filter_buffer_" .. self.uid_explorer, self.opts.view.debounce_delay, function()
+          self:reload_explorer()
+        end)
+      end
+    end,
+  })
+
+  vim.api.nvim_create_autocmd("BufEnter", {
+    group = self.augroup_id,
+    pattern = "NvimTree_*",
+    callback = function()
+      if utils.is_nvim_tree_buf(0) then
+        if vim.fn.getcwd() ~= core.get_cwd() or (self.opts.reload_on_bufenter and not self.opts.filesystem_watchers.enable) then
+          self:reload_explorer()
+        end
+      end
+    end,
+  })
+
+  vim.api.nvim_create_autocmd("User", {
+    group = self.augroup_id,
+    pattern = { "FugitiveChanged", "NeogitStatusRefreshed" },
+    callback = function()
+      if not self.opts.filesystem_watchers.enable and self.opts.git.enable then
+        self:reload_git()
+      end
+    end,
+  })
+
+  if self.opts.hijack_cursor then
+    vim.api.nvim_create_autocmd("CursorMoved", {
+      group = self.augroup_id,
+      pattern = "NvimTree_*",
+      callback = function()
+        if utils.is_nvim_tree_buf(0) then
+          self:place_cursor_on_node()
+        end
+      end,
+    })
+  end
+
+  if self.opts.modified.enable then
+    vim.api.nvim_create_autocmd({ "BufModifiedSet", "BufWritePost" }, {
+      group = self.augroup_id,
+      callback = function()
+        utils.debounce("Buf:modified_" .. self.uid_explorer, self.opts.view.debounce_delay, function()
+          buffers.reload_modified()
+          self:reload_explorer()
+        end)
+      end,
+    })
+  end
+end
+
+---@param node DirectoryNode
 function Explorer:expand(node)
   self:_load(node)
 end
 
-function Explorer:destroy()
+---@param node DirectoryNode
-  local function iterate(node)
+---@param project GitProject?
-    explorer_node.node_destroy(node)
+---@return Node[]?
-    if node.nodes then
+function Explorer:reload(node, project)
-      for _, child in pairs(node.nodes) do
-        iterate(child)
-      end
-    end
-  end
-  iterate(self)
-end
-
----@param node Node
----@param git_status table|nil
-function Explorer:reload(node, git_status)
   local cwd = node.link_to or node.absolute_path
   local handle = vim.loop.fs_scandir(cwd)
   if not handle then
@@ -96,7 +185,7 @@ function Explorer:reload(node, git_status)
 
   local profile = log.profile_start("reload %s", node.absolute_path)
 
-  local filter_status = self.filters:prepare(git_status)
+  local filter_status = self.filters:prepare(project)
 
   if node.group_next then
     node.nodes = { node.group_next }
@@ -105,16 +194,16 @@ function Explorer:reload(node, git_status)
 
   local remain_childs = {}
 
-  local node_ignored = explorer_node.is_git_ignored(node)
+  local node_ignored = node:is_git_ignored()
   ---@type table<string, Node>
   local nodes_by_path = utils.key_by(node.nodes, "absolute_path")
 
   -- To reset we must 'zero' everything that we use
   node.hidden_stats = vim.tbl_deep_extend("force", node.hidden_stats or {}, {
-    git = 0,
+    git      = 0,
-    buf = 0,
+    buf      = 0,
-    dotfile = 0,
+    dotfile  = 0,
-    custom = 0,
+    custom   = 0,
     bookmark = 0,
   })
 
@@ -124,40 +213,33 @@ function Explorer:reload(node, git_status)
       break
     end
 
-    local abs = utils.path_join { cwd, name }
+    local abs = utils.path_join({ cwd, name })
     ---@type uv.fs_stat.result|nil
-    local stat = vim.loop.fs_stat(abs)
+    local stat = vim.loop.fs_lstat(abs)
 
     local filter_reason = self.filters:should_filter_as_reason(abs, stat, filter_status)
     if filter_reason == FILTER_REASON.none then
       remain_childs[abs] = true
 
-      -- Type must come from fs_stat and not fs_scandir_next to maintain sshfs compatibility
-      local type = stat and stat.type or nil
-
       -- Recreate node if type changes.
       if nodes_by_path[abs] then
         local n = nodes_by_path[abs]
 
-        if n.type ~= type then
+        if not stat or n.type ~= stat.type then
           utils.array_remove(node.nodes, n)
-          explorer_node.node_destroy(n)
+          n:destroy()
           nodes_by_path[abs] = nil
         end
       end
 
       if not nodes_by_path[abs] then
-        local new_child = nil
+        local new_child = node_factory.create({
-        if type == "directory" and vim.loop.fs_access(abs, "R") and Watcher.is_fs_event_capable(abs) then
+          explorer      = self,
-          new_child = builders.folder(node, abs, name, stat)
+          parent        = node,
-        elseif type == "file" then
+          absolute_path = abs,
-          new_child = builders.file(node, abs, name, stat)
+          name          = name,
-        elseif type == "link" then
+          fs_stat       = stat
-          local link = builders.link(node, abs, name, stat)
+        })
-          if link.link_to ~= nil then
-            new_child = link
-          end
-        end
         if new_child then
           table.insert(node.nodes, new_child)
           nodes_by_path[abs] = new_child
@@ -165,7 +247,7 @@ function Explorer:reload(node, git_status)
       else
         local n = nodes_by_path[abs]
         if n then
-          n.executable = builders.is_executable(abs) or false
+          n.executable = utils.is_executable(abs) or false
           n.fs_stat = stat
         end
       end
@@ -179,22 +261,21 @@ function Explorer:reload(node, git_status)
   end
 
   node.nodes = vim.tbl_map(
-    self:update_status(nodes_by_path, node_ignored, git_status),
+    self:update_git_statuses(nodes_by_path, node_ignored, project),
     vim.tbl_filter(function(n)
       if remain_childs[n.absolute_path] then
         return remain_childs[n.absolute_path]
       else
-        explorer_node.node_destroy(n)
+        n:destroy()
         return false
       end
     end, node.nodes)
   )
 
-  local is_root = not node.parent
+  local single_child = node:single_child_directory()
-  local child_folder_only = explorer_node.has_one_child_folder(node) and node.nodes[1]
+  if config.renderer.group_empty and node.parent and single_child then
-  if config.group_empty and not is_root and child_folder_only then
+    node.group_next = single_child
-    node.group_next = child_folder_only
+    local ns = self:reload(single_child, project)
-    local ns = self:reload(child_folder_only, git_status)
     node.nodes = ns or {}
     log.profile_end(profile)
     return ns
@@ -206,26 +287,6 @@ function Explorer:reload(node, git_status)
   return node.nodes
 end
 
----TODO #2837 #2871 move this and similar to node
----Refresh contents and git status for a single node
----@param node Node
----@param callback function
-function Explorer:refresh_node(node, callback)
-  if type(node) ~= "table" then
-    callback()
-  end
-
-  local parent_node = utils.get_parent_of_group(node)
-
-  self:reload_and_get_git_project(node.absolute_path, function(toplevel, project)
-    self:reload(parent_node, project)
-
-    self:update_parent_statuses(parent_node, project, toplevel)
-
-    callback()
-  end)
-end
-
 ---Refresh contents of all nodes to a path: actual directory and links.
 ---Groups will be expanded if needed.
 ---@param path string absolute path
@@ -253,88 +314,229 @@ function Explorer:refresh_parent_nodes_for_path(path)
     local project = git.get_project(toplevel) or {}
 
     self:reload(node, project)
-    self:update_parent_statuses(node, project, toplevel)
+    git.update_parent_projects(node, project, toplevel)
   end
 
   log.profile_end(profile)
 end
 
 ---@private
----@param node Node
+---@param node DirectoryNode
 function Explorer:_load(node)
   local cwd = node.link_to or node.absolute_path
-  local git_status = git.load_project_status(cwd)
+  local project = git.load_project(cwd)
-  Explorer.explore(node, git_status, self)
+  self:explore(node, project, self)
-end
-
-function Explorer.setup(opts)
-  config = opts
-  require("nvim-tree.explorer.node").setup(opts)
-  require("nvim-tree.explorer.explore").setup(opts)
-  require("nvim-tree.explorer.watch").setup(opts)
-
-  Marks = require "nvim-tree.marks"
-  Clipboard = require "nvim-tree.actions.fs.clipboard"
 end
 
 ---@private
----@param nodes_by_path table
+---@param nodes_by_path Node[]
 ---@param node_ignored boolean
----@param status table|nil
+---@param project GitProject?
----@return fun(node: Node): table
+---@return fun(node: Node): Node
-function Explorer:update_status(nodes_by_path, node_ignored, status)
+function Explorer:update_git_statuses(nodes_by_path, node_ignored, project)
   return function(node)
     if nodes_by_path[node.absolute_path] then
-      explorer_node.update_git_status(node, node_ignored, status)
+      node:update_git_status(node_ignored, project)
     end
     return node
   end
 end
 
----TODO #2837 #2871 move this and similar to node
 ---@private
----@param path string
+---@param handle uv.uv_fs_t
----@param callback fun(toplevel: string|nil, project: table|nil)
+---@param cwd string
-function Explorer:reload_and_get_git_project(path, callback)
+---@param node DirectoryNode
-  local toplevel = git.get_toplevel(path)
+---@param project GitProject
+---@param parent Explorer
+function Explorer:populate_children(handle, cwd, node, project, parent)
+  local node_ignored = node:is_git_ignored()
+  local nodes_by_path = utils.bool_record(node.nodes, "absolute_path")
 
-  git.reload_project(toplevel, path, function()
+  local filter_status = parent.filters:prepare(project)
-    callback(toplevel, git.get_project(toplevel) or {})
-  end)
-end
 
----TODO #2837 #2871 move this and similar to node
+  node.hidden_stats = vim.tbl_deep_extend("force", node.hidden_stats or {}, {
----@private
+    git      = 0,
----@param node Node
+    buf      = 0,
----@param project table|nil
+    dotfile  = 0,
----@param root string|nil
+    custom   = 0,
-function Explorer:update_parent_statuses(node, project, root)
+    bookmark = 0,
-  while project and node do
+  })
-    -- step up to the containing project
-    if node.absolute_path == root then
-      -- stop at the top of the tree
-      if not node.parent then
-        break
-      end
 
-      root = git.get_toplevel(node.parent.absolute_path)
+  while true do
-
+    local name, _ = vim.loop.fs_scandir_next(handle)
-      -- stop when no more projects
+    if not name then
-      if not root then
+      break
-        break
-      end
-
-      -- update the containing project
-      project = git.get_project(root)
-      git.reload_project(root, node.absolute_path, nil)
     end
 
-    -- update status
+    local abs = utils.path_join({ cwd, name })
-    explorer_node.update_git_status(node, explorer_node.is_git_ignored(node.parent), project)
 
-    -- maybe parent
+    if Watcher.is_fs_event_capable(abs) then
-    node = node.parent
+      local profile = log.profile_start("populate_children %s", abs)
+
+      ---@type uv.fs_stat.result|nil
+      local stat = vim.loop.fs_lstat(abs)
+      local filter_reason = parent.filters:should_filter_as_reason(abs, stat, filter_status)
+      if filter_reason == FILTER_REASON.none and not nodes_by_path[abs] then
+        local child = node_factory.create({
+          explorer      = self,
+          parent        = node,
+          absolute_path = abs,
+          name          = name,
+          fs_stat       = stat
+        })
+        if child then
+          table.insert(node.nodes, child)
+          nodes_by_path[child.absolute_path] = true
+          child:update_git_status(node_ignored, project)
+        end
+      else
+        for reason, value in pairs(FILTER_REASON) do
+          if filter_reason == value then
+            node.hidden_stats[reason] = node.hidden_stats[reason] + 1
+          end
+        end
+      end
+
+      log.profile_end(profile)
+    end
   end
 end
 
+---@private
+---@param node DirectoryNode
+---@param project GitProject
+---@param parent Explorer
+---@return Node[]|nil
+function Explorer:explore(node, project, parent)
+  local cwd = node.link_to or node.absolute_path
+  local handle = vim.loop.fs_scandir(cwd)
+  if not handle then
+    return
+  end
+
+  local profile = log.profile_start("explore %s", node.absolute_path)
+
+  self:populate_children(handle, cwd, node, project, parent)
+
+  local is_root = not node.parent
+  local single_child = node:single_child_directory()
+  if config.renderer.group_empty and not is_root and single_child then
+    local child_cwd = single_child.link_to or single_child.absolute_path
+    local child_project = git.load_project(child_cwd)
+    node.group_next = single_child
+    local ns = self:explore(single_child, child_project, parent)
+    node.nodes = ns or {}
+
+    log.profile_end(profile)
+    return ns
+  end
+
+  parent.sorters:sort(node.nodes)
+  parent.live_filter:apply_filter(node)
+
+  log.profile_end(profile)
+  return node.nodes
+end
+
+---@private
+---@param projects GitProject[]
+function Explorer:refresh_nodes(projects)
+  Iterator.builder({ self })
+    :applier(function(n)
+      local dir = n:as(DirectoryNode)
+      if dir then
+        local toplevel = git.get_toplevel(dir.cwd or dir.link_to or dir.absolute_path)
+        self:reload(dir, projects[toplevel] or {})
+      end
+    end)
+    :recursor(function(n)
+      return n.group_next and { n.group_next } or (n.open and n.nodes)
+    end)
+    :iterate()
+end
+
+local event_running = false
+function Explorer:reload_explorer()
+  if event_running or vim.v.exiting ~= vim.NIL then
+    return
+  end
+  event_running = true
+
+  local projects = git.reload_all_projects()
+  self:refresh_nodes(projects)
+  if view.is_visible() then
+    self.renderer:draw()
+  end
+  event_running = false
+end
+
+function Explorer:reload_git()
+  if not git.config.git.enable or event_running then
+    return
+  end
+  event_running = true
+
+  local projects = git.reload_all_projects()
+  git.reload_node_status(self, projects)
+  self.renderer:draw()
+  event_running = false
+end
+
+---Cursor position as per vim.api.nvim_win_get_cursor
+---nil on no explorer or invalid view win
+---@return integer[]|nil
+function Explorer:get_cursor_position()
+  local winnr = view.get_winnr()
+  if not winnr or not vim.api.nvim_win_is_valid(winnr) then
+    return
+  end
+
+  return vim.api.nvim_win_get_cursor(winnr)
+end
+
+---@return Node|nil
+function Explorer:get_node_at_cursor()
+  local cursor = self:get_cursor_position()
+  if not cursor then
+    return
+  end
+
+  if cursor[1] == 1 and view.is_root_folder_visible(core.get_cwd()) then
+    return self
+  end
+
+  return utils.get_nodes_by_line(self.nodes, core.get_nodes_starting_line())[cursor[1]]
+end
+
+function Explorer:place_cursor_on_node()
+  local ok, search = pcall(vim.fn.searchcount)
+  if ok and search and search.exact_match == 1 then
+    return
+  end
+
+  local node = self:get_node_at_cursor()
+  if not node or node.name == ".." then
+    return
+  end
+  node = node:get_parent_of_group() or node
+
+  local line = vim.api.nvim_get_current_line()
+  local cursor = vim.api.nvim_win_get_cursor(0)
+  local idx = vim.fn.stridx(line, node.name)
+
+  if idx >= 0 then
+    vim.api.nvim_win_set_cursor(0, { cursor[1], idx })
+  end
+end
+
+---Api.tree.get_nodes
+---@return Node
+function Explorer:get_nodes()
+  return self:clone()
+end
+
+function Explorer:setup(opts)
+  config = opts
+end
+
 return Explorer

lua/nvim-tree/explorer/live-filter.lua

@@ -1,33 +1,33 @@
-local view = require "nvim-tree.view"
+local view = require("nvim-tree.view")
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local Iterator = require "nvim-tree.iterators.node-iterator"
 
----@class LiveFilter
+local Class = require("nvim-tree.classic")
+local Iterator = require("nvim-tree.iterators.node-iterator")
+local DirectoryNode = require("nvim-tree.node.directory")
+
+---@class (exact) LiveFilter: Class
 ---@field explorer Explorer
 ---@field prefix string
 ---@field always_show_folders boolean
 ---@field filter string
-local LiveFilter = {}
+local LiveFilter = Class:extend()
 
----@param opts table
+---@class LiveFilter
----@param explorer Explorer
+---@overload fun(args: LiveFilterArgs): LiveFilter
-function LiveFilter:new(opts, explorer)
+
-  local o = {
+---@class (exact) LiveFilterArgs
-    explorer = explorer,
+---@field explorer Explorer
-    prefix = opts.live_filter.prefix,
+
-    always_show_folders = opts.live_filter.always_show_folders,
+---@protected
-    filter = nil,
+---@param args LiveFilterArgs
-  }
+function LiveFilter:new(args)
-  setmetatable(o, self)
+  self.explorer = args.explorer
-  self.__index = self
+  self.prefix = self.explorer.opts.live_filter.prefix
-  return o
+  self.always_show_folders = self.explorer.opts.live_filter.always_show_folders
+  self.filter = nil
 end
 
-local function redraw()
+---@param node_ Node?
-  require("nvim-tree.renderer").draw()
-end
-
----@param node_ Node|nil
 local function reset_filter(self, node_)
   node_ = node_ or self.explorer
 
@@ -35,17 +35,19 @@ local function reset_filter(self, node_)
     return
   end
 
-  node_.hidden_stats = vim.tbl_deep_extend("force", node_.hidden_stats or {}, {
+  local dir_ = node_:as(DirectoryNode)
-    live_filter = 0,
+  if dir_ then
-  })
+    dir_.hidden_stats = vim.tbl_deep_extend("force", dir_.hidden_stats or {}, { live_filter = 0, })
+  end
 
   Iterator.builder(node_.nodes)
     :hidden()
     :applier(function(node)
       node.hidden = false
-      node.hidden_stats = vim.tbl_deep_extend("force", node.hidden_stats or {}, {
+      local dir = node:as(DirectoryNode)
-        live_filter = 0,
+      if dir then
-      })
+        dir.hidden_stats = vim.tbl_deep_extend("force", dir.hidden_stats or {}, { live_filter = 0, })
+      end
     end)
     :iterate()
 end
@@ -80,7 +82,7 @@ end
 ---@param node Node
 ---@return boolean
 local function matches(self, node)
-  if not self.explorer.filters.config.enable then
+  if not self.explorer.filters.enabled then
     return true
   end
 
@@ -89,14 +91,14 @@ local function matches(self, node)
   return vim.regex(self.filter):match_str(name) ~= nil
 end
 
----@param node_ Node|nil
+---@param node_ DirectoryNode?
 function LiveFilter:apply_filter(node_)
   if not self.filter or self.filter == "" then
     reset_filter(self, node_)
     return
   end
 
-  -- TODO(kiyan): this iterator cannot yet be refactored with the Iterator module
+  -- this iterator cannot yet be refactored with the Iterator module
   -- since the node mapper is based on its children
   local function iterate(node)
     local filtered_nodes = 0
@@ -129,7 +131,7 @@ local function record_char(self)
   vim.schedule(function()
     self.filter = vim.api.nvim_buf_get_lines(overlay_bufnr, 0, -1, false)[1]
     self:apply_filter()
-    redraw()
+    self.explorer.renderer:draw()
   end)
 end
 
@@ -166,43 +168,43 @@ end
 local function create_overlay(self)
   if view.View.float.enable then
     -- don't close nvim-tree float when focus is changed to filter window
-    vim.api.nvim_clear_autocmds {
+    vim.api.nvim_clear_autocmds({
-      event = "WinLeave",
+      event   = "WinLeave",
       pattern = "NvimTree_*",
-      group = vim.api.nvim_create_augroup("NvimTree", { clear = false }),
+      group   = vim.api.nvim_create_augroup("NvimTree", { clear = false }),
-    }
+    })
   end
 
   configure_buffer_overlay(self)
   overlay_winnr = vim.api.nvim_open_win(overlay_bufnr, true, {
-    col = 1,
+    col      = 1,
-    row = 0,
+    row      = 0,
     relative = "cursor",
-    width = calculate_overlay_win_width(self),
+    width    = calculate_overlay_win_width(self),
-    height = 1,
+    height   = 1,
-    border = "none",
+    border   = "none",
-    style = "minimal",
+    style    = "minimal",
   })
 
-  if vim.fn.has "nvim-0.10" == 1 then
+  if vim.fn.has("nvim-0.10") == 1 then
     vim.api.nvim_set_option_value("modifiable", true, { buf = overlay_bufnr })
   else
     vim.api.nvim_buf_set_option(overlay_bufnr, "modifiable", true) ---@diagnostic disable-line: deprecated
   end
 
   vim.api.nvim_buf_set_lines(overlay_bufnr, 0, -1, false, { self.filter })
-  vim.cmd "startinsert"
+  vim.cmd("startinsert")
   vim.api.nvim_win_set_cursor(overlay_winnr, { 1, #self.filter + 1 })
 end
 
 function LiveFilter:start_filtering()
-  view.View.live_filter.prev_focused_node = require("nvim-tree.lib").get_node_at_cursor()
+  view.View.live_filter.prev_focused_node = self.explorer:get_node_at_cursor()
   self.filter = self.filter or ""
 
-  redraw()
+  self.explorer.renderer:draw()
   local row = require("nvim-tree.core").get_nodes_starting_line() - 1
   local col = #self.prefix > 0 and #self.prefix - 1 or 1
-  view.set_cursor { row, col }
+  view.set_cursor({ row, col })
   -- needs scheduling to let the cursor move before initializing the window
   vim.schedule(function()
     return create_overlay(self)
@@ -210,12 +212,12 @@ function LiveFilter:start_filtering()
 end
 
 function LiveFilter:clear_filter()
-  local node = require("nvim-tree.lib").get_node_at_cursor()
+  local node = self.explorer:get_node_at_cursor()
   local last_node = view.View.live_filter.prev_focused_node
 
   self.filter = nil
   reset_filter(self)
-  redraw()
+  self.explorer.renderer:draw()
 
   if node then
     utils.focus_file(node.absolute_path)

lua/nvim-tree/explorer/node-builders.lua

@@ -1,107 +0,0 @@
-local utils = require "nvim-tree.utils"
-local watch = require "nvim-tree.explorer.watch"
-
-local M = {}
-
----@param parent Node
----@param absolute_path string
----@param name string
----@param fs_stat uv.fs_stat.result|nil
----@return Node
-function M.folder(parent, absolute_path, name, fs_stat)
-  local handle = vim.loop.fs_scandir(absolute_path)
-  local has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil
-
-  local node = {
-    type = "directory",
-    absolute_path = absolute_path,
-    fs_stat = fs_stat,
-    group_next = nil, -- If node is grouped, this points to the next child dir/link node
-    has_children = has_children,
-    name = name,
-    nodes = {},
-    open = false,
-    parent = parent,
-  }
-
-  node.watcher = watch.create_watcher(node)
-
-  return node
-end
-
---- path is an executable file or directory
----@param absolute_path string
----@return boolean|nil
-function M.is_executable(absolute_path)
-  if utils.is_windows or utils.is_wsl then
-    --- executable detection on windows is buggy and not performant hence it is disabled
-    return false
-  else
-    return vim.loop.fs_access(absolute_path, "X")
-  end
-end
-
----@param parent Node
----@param absolute_path string
----@param name string
----@param fs_stat uv.fs_stat.result|nil
----@return Node
-function M.file(parent, absolute_path, name, fs_stat)
-  local ext = string.match(name, ".?[^.]+%.(.*)") or ""
-
-  return {
-    type = "file",
-    absolute_path = absolute_path,
-    executable = M.is_executable(absolute_path),
-    extension = ext,
-    fs_stat = fs_stat,
-    name = name,
-    parent = parent,
-  }
-end
-
--- TODO-INFO: sometimes fs_realpath returns nil
--- I expect this be a bug in glibc, because it fails to retrieve the path for some
--- links (for instance libr2.so in /usr/lib) and thus even with a C program realpath fails
--- when it has no real reason to. Maybe there is a reason, but errno is definitely wrong.
--- So we need to check for link_to ~= nil when adding new links to the main tree
----@param parent Node
----@param absolute_path string
----@param name string
----@param fs_stat uv.fs_stat.result|nil
----@return Node
-function M.link(parent, absolute_path, name, fs_stat)
-  --- I dont know if this is needed, because in my understanding, there isn't hard links in windows, but just to be sure i changed it.
-  local link_to = vim.loop.fs_realpath(absolute_path)
-  local open, nodes, has_children
-
-  local is_dir_link = (link_to ~= nil) and vim.loop.fs_stat(link_to).type == "directory"
-
-  if is_dir_link and link_to then
-    local handle = vim.loop.fs_scandir(link_to)
-    has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil
-    open = false
-    nodes = {}
-  end
-
-  local node = {
-    type = "link",
-    absolute_path = absolute_path,
-    fs_stat = fs_stat,
-    group_next = nil, -- If node is grouped, this points to the next child dir/link node
-    has_children = has_children,
-    link_to = link_to,
-    name = name,
-    nodes = nodes,
-    open = open,
-    parent = parent,
-  }
-
-  if is_dir_link then
-    node.watcher = watch.create_watcher(node)
-  end
-
-  return node
-end
-
-return M

lua/nvim-tree/explorer/node.lua

@@ -1,162 +0,0 @@
-local M = {}
-
----@class GitStatus
----@field file string|nil
----@field dir table|nil
-
----@param parent_ignored boolean
----@param status table|nil
----@param absolute_path string
----@return GitStatus|nil
-local function get_dir_git_status(parent_ignored, status, absolute_path)
-  if parent_ignored then
-    return { file = "!!" }
-  end
-
-  if status then
-    return {
-      file = status.files and status.files[absolute_path],
-      dir = status.dirs and {
-        direct = status.dirs.direct[absolute_path],
-        indirect = status.dirs.indirect[absolute_path],
-      },
-    }
-  end
-end
-
----@param parent_ignored boolean
----@param status table
----@param absolute_path string
----@return GitStatus
-local function get_git_status(parent_ignored, status, absolute_path)
-  local file_status = parent_ignored and "!!" or (status and status.files and status.files[absolute_path])
-  return { file = file_status }
-end
-
----@param node Node
----@return boolean
-function M.has_one_child_folder(node)
-  return #node.nodes == 1 and node.nodes[1].nodes and vim.loop.fs_access(node.nodes[1].absolute_path, "R") or false
-end
-
----@param node Node
----@param parent_ignored boolean
----@param status table|nil
-function M.update_git_status(node, parent_ignored, status)
-  local get_status
-  if node.nodes then
-    get_status = get_dir_git_status
-  else
-    get_status = get_git_status
-  end
-
-  -- status of the node's absolute path
-  node.git_status = get_status(parent_ignored, status, node.absolute_path)
-
-  -- status of the link target, if the link itself is not dirty
-  if node.link_to and not node.git_status then
-    node.git_status = get_status(parent_ignored, status, node.link_to)
-  end
-end
-
----@param node Node
----@return GitStatus|nil
-function M.get_git_status(node)
-  local git_status = node and node.git_status
-  if not git_status then
-    -- status doesn't exist
-    return nil
-  end
-
-  if not node.nodes then
-    -- file
-    return git_status.file and { git_status.file }
-  end
-
-  -- dir
-  if not M.config.git.show_on_dirs then
-    return nil
-  end
-
-  local status = {}
-  if not require("nvim-tree.lib").get_last_group_node(node).open or M.config.git.show_on_open_dirs then
-    -- dir is closed or we should show on open_dirs
-    if git_status.file ~= nil then
-      table.insert(status, git_status.file)
-    end
-    if git_status.dir ~= nil then
-      if git_status.dir.direct ~= nil then
-        for _, s in pairs(node.git_status.dir.direct) do
-          table.insert(status, s)
-        end
-      end
-      if git_status.dir.indirect ~= nil then
-        for _, s in pairs(node.git_status.dir.indirect) do
-          table.insert(status, s)
-        end
-      end
-    end
-  else
-    -- dir is open and we shouldn't show on open_dirs
-    if git_status.file ~= nil then
-      table.insert(status, git_status.file)
-    end
-    if git_status.dir ~= nil and git_status.dir.direct ~= nil then
-      local deleted = {
-        [" D"] = true,
-        ["D "] = true,
-        ["RD"] = true,
-        ["DD"] = true,
-      }
-      for _, s in pairs(node.git_status.dir.direct) do
-        if deleted[s] then
-          table.insert(status, s)
-        end
-      end
-    end
-  end
-  if #status == 0 then
-    return nil
-  else
-    return status
-  end
-end
-
----@param node Node
----@return boolean
-function M.is_git_ignored(node)
-  return node and node.git_status ~= nil and node.git_status.file == "!!"
-end
-
----@param node Node
----@return boolean
-function M.is_dotfile(node)
-  if node == nil then
-    return false
-  end
-  if node.is_dot or (node.name and (node.name:sub(1, 1) == ".")) or M.is_dotfile(node.parent) then
-    node.is_dot = true
-    return true
-  end
-  return false
-end
-
----@param node Node
-function M.node_destroy(node)
-  if not node then
-    return
-  end
-
-  if node.watcher then
-    node.watcher:destroy()
-    node.watcher = nil
-  end
-end
-
-function M.setup(opts)
-  M.config = {
-    git = opts.git,
-  }
-end
-
-return M

lua/nvim-tree/explorer/sorter.lua

@@ -1,27 +1,25 @@
-local C = {}
+local Class = require("nvim-tree.classic")
+local DirectoryNode = require("nvim-tree.node.directory")
+
+---@alias SorterType "name" | "case_sensitive" | "modification_time" | "extension" | "suffix" | "filetype"
+---@alias SorterComparator fun(self: Sorter, a: Node, b: Node): boolean?
+
+---@alias SorterUser fun(nodes: Node[]): SorterType?
+
+---@class (exact) Sorter: Class
+---@field private explorer Explorer
+local Sorter = Class:extend()
 
 ---@class Sorter
-local Sorter = {}
+---@overload fun(args: SorterArgs): Sorter
 
-function Sorter:new(opts)
+---@class (exact) SorterArgs
-  local o = {}
+---@field explorer Explorer
-  setmetatable(o, self)
-  self.__index = self
-  o.config = vim.deepcopy(opts.sort)
 
-  if type(o.config.sorter) == "function" then
+---@protected
-    o.user = o.config.sorter
+---@param args SorterArgs
-  end
+function Sorter:new(args)
-  return o
+  self.explorer = args.explorer
-end
-
---- Predefined comparator, defaulting to name
----@param sorter string as per options
----@return function
-function Sorter:get_comparator(sorter)
-  return function(a, b)
-    return (C[sorter] or C.name)(a, b, self.config)
-  end
 end
 
 ---Create a shallow copy of a portion of a list.
@@ -38,30 +36,32 @@ local function tbl_slice(t, first, last)
   return slice
 end
 
----Evaluate `sort.folders_first` and `sort.files_first`
+---Evaluate folders_first and sort.files_first returning nil when no order is necessary
----@param a Node
+---@private
----@param b Node
+---@type SorterComparator
----@return boolean|nil
+function Sorter:folders_or_files_first(a, b)
-local function folders_or_files_first(a, b, cfg)
+  if not (self.explorer.opts.sort.folders_first or self.explorer.opts.sort.files_first) then
-  if not (cfg.folders_first or cfg.files_first) then
+    return nil
-    return
   end
 
-  if not a.nodes and b.nodes then
+  if not a:is(DirectoryNode) and b:is(DirectoryNode) then
     -- file <> folder
-    return cfg.files_first
+    return self.explorer.opts.sort.files_first
-  elseif a.nodes and not b.nodes then
+  elseif a:is(DirectoryNode) and not b:is(DirectoryNode) then
     -- folder <> file
-    return not cfg.files_first
+    return not self.explorer.opts.sort.files_first
   end
+
+  return nil
 end
 
----@param t table
+---@private
+---@param t Node[]
 ---@param first number
 ---@param mid number
 ---@param last number
----@param comparator fun(a: Node, b: Node): boolean
+---@param comparator SorterComparator
-local function merge(t, first, mid, last, comparator)
+function Sorter:merge(t, first, mid, last, comparator)
   local n1 = mid - first + 1
   local n2 = last - mid
   local ls = tbl_slice(t, first, mid)
@@ -71,7 +71,7 @@ local function merge(t, first, mid, last, comparator)
   local k = first
 
   while i <= n1 and j <= n2 do
-    if comparator(ls[i], rs[j]) then
+    if comparator(self, ls[i], rs[j]) then
       t[k] = ls[i]
       i = i + 1
     else
@@ -94,45 +94,49 @@ local function merge(t, first, mid, last, comparator)
   end
 end
 
----@param t table
+---@private
+---@param t Node[]
 ---@param first number
 ---@param last number
----@param comparator fun(a: Node, b: Node): boolean
+---@param comparator SorterComparator
-local function split_merge(t, first, last, comparator)
+function Sorter:split_merge(t, first, last, comparator)
   if (last - first) < 1 then
     return
   end
 
   local mid = math.floor((first + last) / 2)
 
-  split_merge(t, first, mid, comparator)
+  self:split_merge(t, first,   mid,  comparator)
-  split_merge(t, mid + 1, last, comparator)
+  self:split_merge(t, mid + 1, last, comparator)
-  merge(t, first, mid, last, comparator)
+  self:merge(t, first, mid, last, comparator)
 end
 
 ---Perform a merge sort using sorter option.
----@param t table nodes
+---@param t Node[]
 function Sorter:sort(t)
-  if self.user then
+  if self[self.explorer.opts.sort.sorter] then
+    self:split_merge(t, 1, #t, self[self.explorer.opts.sort.sorter])
+  elseif type(self.explorer.opts.sort.sorter) == "function" then
     local t_user = {}
     local origin_index = {}
 
     for _, n in ipairs(t) do
       table.insert(t_user, {
         absolute_path = n.absolute_path,
-        executable = n.executable,
+        executable    = n.executable,
-        extension = n.extension,
+        extension     = n.extension,
-        filetype = vim.filetype.match { filename = n.name },
+        filetype      = vim.filetype.match({ filename = n.name }),
-        link_to = n.link_to,
+        link_to       = n.link_to,
-        name = n.name,
+        name          = n.name,
-        type = n.type,
+        type          = n.type,
       })
       table.insert(origin_index, n)
     end
 
-    local predefined = self.user(t_user)
+    -- user may return a SorterType
-    if predefined then
+    local ret = self.explorer.opts.sort.sorter(t_user)
-      split_merge(t, 1, #t, self:get_comparator(predefined))
+    if self[ret] then
+      self:split_merge(t, 1, #t, self[ret])
       return
     end
 
@@ -145,7 +149,7 @@ function Sorter:sort(t)
     end
 
     -- if missing value found, then using origin_index
-    local mini_comparator = function(a, b)
+    local mini_comparator = function(_, a, b)
       local a_index = user_index[a.absolute_path] or origin_index[a.absolute_path]
       local b_index = user_index[b.absolute_path] or origin_index[b.absolute_path]
 
@@ -155,47 +159,52 @@ function Sorter:sort(t)
       return (a_index or 0) <= (b_index or 0)
     end
 
-    split_merge(t, 1, #t, mini_comparator) -- sort by user order
+    self:split_merge(t, 1, #t, mini_comparator) -- sort by user order
-  else
-    split_merge(t, 1, #t, self:get_comparator(self.config.sorter))
   end
 end
 
+---@private
 ---@param a Node
 ---@param b Node
----@param ignorecase boolean|nil
+---@param ignore_case boolean
 ---@return boolean
-local function node_comparator_name_ignorecase_or_not(a, b, ignorecase, cfg)
+function Sorter:name_case(a, b, ignore_case)
   if not (a and b) then
     return true
   end
 
-  local early_return = folders_or_files_first(a, b, cfg)
+  local early_return = self:folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
 
-  if ignorecase then
+  if ignore_case then
     return a.name:lower() <= b.name:lower()
   else
     return a.name <= b.name
   end
 end
 
-function C.case_sensitive(a, b, cfg)
+---@private
-  return node_comparator_name_ignorecase_or_not(a, b, false, cfg)
+---@type SorterComparator
+function Sorter:case_sensitive(a, b)
+  return self:name_case(a, b, false)
 end
 
-function C.name(a, b, cfg)
+---@private
-  return node_comparator_name_ignorecase_or_not(a, b, true, cfg)
+---@type SorterComparator
+function Sorter:name(a, b)
+  return self:name_case(a, b, true)
 end
 
-function C.modification_time(a, b, cfg)
+---@private
+---@type SorterComparator
+function Sorter:modification_time(a, b)
   if not (a and b) then
     return true
   end
 
-  local early_return = folders_or_files_first(a, b, cfg)
+  local early_return = self:folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
@@ -214,17 +223,19 @@ function C.modification_time(a, b, cfg)
   return last_modified_b <= last_modified_a
 end
 
-function C.suffix(a, b, cfg)
+---@private
+---@type SorterComparator
+function Sorter:suffix(a, b)
   if not (a and b) then
     return true
   end
 
   -- directories go first
-  local early_return = folders_or_files_first(a, b, cfg)
+  local early_return = self:folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   elseif a.nodes and b.nodes then
-    return C.name(a, b, cfg)
+    return self:name(a, b)
   end
 
   -- dotfiles go second
@@ -233,19 +244,19 @@ function C.suffix(a, b, cfg)
   elseif a.name:sub(1, 1) ~= "." and b.name:sub(1, 1) == "." then
     return false
   elseif a.name:sub(1, 1) == "." and b.name:sub(1, 1) == "." then
-    return C.name(a, b, cfg)
+    return self:name(a, b)
   end
 
   -- unsuffixed go third
-  local a_suffix_ndx = a.name:find "%.%w+$"
+  local a_suffix_ndx = a.name:find("%.%w+$")
-  local b_suffix_ndx = b.name:find "%.%w+$"
+  local b_suffix_ndx = b.name:find("%.%w+$")
 
   if not a_suffix_ndx and b_suffix_ndx then
     return true
   elseif a_suffix_ndx and not b_suffix_ndx then
     return false
   elseif not (a_suffix_ndx and b_suffix_ndx) then
-    return C.name(a, b, cfg)
+    return self:name(a, b)
   end
 
   -- finally, compare by suffixes
@@ -257,18 +268,20 @@ function C.suffix(a, b, cfg)
   elseif not a_suffix and b_suffix then
     return false
   elseif a_suffix:lower() == b_suffix:lower() then
-    return C.name(a, b, cfg)
+    return self:name(a, b)
   end
 
   return a_suffix:lower() < b_suffix:lower()
 end
 
-function C.extension(a, b, cfg)
+---@private
+---@type SorterComparator
+function Sorter:extension(a, b)
   if not (a and b) then
     return true
   end
 
-  local early_return = folders_or_files_first(a, b, cfg)
+  local early_return = self:folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
@@ -282,18 +295,20 @@ function C.extension(a, b, cfg)
   local a_ext = (a.extension or ""):lower()
   local b_ext = (b.extension or ""):lower()
   if a_ext == b_ext then
-    return C.name(a, b, cfg)
+    return self:name(a, b)
   end
 
   return a_ext < b_ext
 end
 
-function C.filetype(a, b, cfg)
+---@private
-  local a_ft = vim.filetype.match { filename = a.name }
+---@type SorterComparator
-  local b_ft = vim.filetype.match { filename = b.name }
+function Sorter:filetype(a, b)
+  local a_ft = vim.filetype.match({ filename = a.name })
+  local b_ft = vim.filetype.match({ filename = b.name })
 
   -- directories first
-  local early_return = folders_or_files_first(a, b, cfg)
+  local early_return = self:folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
@@ -307,7 +322,7 @@ function C.filetype(a, b, cfg)
 
   -- same filetype or both nil, sort by name
   if a_ft == b_ft then
-    return C.name(a, b, cfg)
+    return self:name(a, b)
   end
 
   return a_ft < b_ft

lua/nvim-tree/explorer/watch.lua

@@ -1,5 +1,6 @@
-local log = require "nvim-tree.log"
+local log = require("nvim-tree.log")
-local utils = require "nvim-tree.utils"
+local git = require("nvim-tree.git")
+local utils = require("nvim-tree.utils")
 local Watcher = require("nvim-tree.watcher").Watcher
 
 local M = {
@@ -53,7 +54,7 @@ local function is_folder_ignored(path)
   return false
 end
 
----@param node Node
+---@param node DirectoryNode
 ---@return Watcher|nil
 function M.create_watcher(node)
   if not M.config.filesystem_watchers.enable or type(node) ~= "table" then
@@ -65,9 +66,10 @@ function M.create_watcher(node)
     return nil
   end
 
+  ---@param watcher Watcher
   local function callback(watcher)
-    log.line("watcher", "node event scheduled refresh %s", watcher.context)
+    log.line("watcher", "node event scheduled refresh %s", watcher.data.context)
-    utils.debounce(watcher.context, M.config.filesystem_watchers.debounce_delay, function()
+    utils.debounce(watcher.data.context, M.config.filesystem_watchers.debounce_delay, function()
       if watcher.destroyed then
         return
       end
@@ -76,18 +78,17 @@ function M.create_watcher(node)
       else
         log.line("watcher", "node event executing refresh '%s'", node.absolute_path)
       end
-      local explorer = require("nvim-tree.core").get_explorer()
+      git.refresh_dir(node)
-      if explorer then
-        explorer:refresh_node(node, function()
-          require("nvim-tree.renderer").draw()
-        end)
-      end
     end)
   end
 
   M.uid = M.uid + 1
-  return Watcher:new(path, nil, callback, {
+  return Watcher:create({
-    context = "explorer:watch:" .. path .. ":" .. M.uid,
+    path = path,
+    callback = callback,
+    data = {
+      context = "explorer:watch:" .. path .. ":" .. M.uid
+    }
   })
 end
 

lua/nvim-tree/git/init.lua

@@ -1,21 +1,48 @@
-local log = require "nvim-tree.log"
+local log = require("nvim-tree.log")
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local git_utils = require "nvim-tree.git.utils"
+local git_utils = require("nvim-tree.git.utils")
-local Runner = require "nvim-tree.git.runner"
+
+local GitRunner = require("nvim-tree.git.runner")
 local Watcher = require("nvim-tree.watcher").Watcher
-local Iterator = require "nvim-tree.iterators.node-iterator"
+local Iterator = require("nvim-tree.iterators.node-iterator")
-local explorer_node = require "nvim-tree.explorer.node"
+local DirectoryNode = require("nvim-tree.node.directory")
+
+---Git short format status xy
+---@alias GitXY string
+
+-- Git short-format status
+---@alias GitPathXY table<string, GitXY>
+
+-- Git short-format statuses
+---@alias GitPathXYs table<string, GitXY[]>
+
+---Git short-format statuses for a single node
+---@class (exact) GitNodeStatus
+---@field file GitXY?
+---@field dir table<"direct" | "indirect", GitXY[]>?
+
+---Git state for an entire repo
+---@class (exact) GitProject
+---@field files GitProjectFiles?
+---@field dirs GitProjectDirs?
+---@field watcher Watcher?
+
+---@alias GitProjectFiles GitPathXY
+---@alias GitProjectDirs table<"direct" | "indirect", GitPathXYs>
 
 local M = {
   config = {},
 
-  -- all projects keyed by toplevel
+  ---all projects keyed by toplevel
+  ---@type table<string, GitProject>
   _projects_by_toplevel = {},
 
-  -- index of paths inside toplevels, false when not inside a project
+  ---index of paths inside toplevels, false when not inside a project
+  ---@type table<string, string|false>
   _toplevels_by_path = {},
 
   -- git dirs by toplevel
+  ---@type table<string, string>
   _git_dirs_by_toplevel = {},
 }
 
@@ -23,43 +50,43 @@ local M = {
 -- Utilities (like watchman) can also write to this directory (often) and aren't useful for us.
 local WATCHED_FILES = {
   "FETCH_HEAD", -- remote ref
-  "HEAD", -- local ref
+  "HEAD",       -- local ref
-  "HEAD.lock", -- HEAD will not always be updated e.g. revert
+  "HEAD.lock",  -- HEAD will not always be updated e.g. revert
-  "config", -- user config
+  "config",     -- user config
-  "index", -- staging area
+  "index",      -- staging area
 }
 
 ---@param toplevel string|nil
 ---@param path string|nil
----@param project table
+---@param project GitProject
----@param git_status table|nil
+---@param project_files GitProjectFiles?
-local function reload_git_status(toplevel, path, project, git_status)
+local function reload_git_project(toplevel, path, project, project_files)
   if path then
     for p in pairs(project.files) do
       if p:find(path, 1, true) == 1 then
         project.files[p] = nil
       end
     end
-    project.files = vim.tbl_deep_extend("force", project.files, git_status)
+    project.files = vim.tbl_deep_extend("force", project.files, project_files)
   else
-    project.files = git_status
+    project.files = project_files or {}
   end
 
-  project.dirs = git_utils.file_status_to_dir_status(project.files, toplevel)
+  project.dirs = git_utils.project_files_to_project_dirs(project.files, toplevel)
 end
 
 --- Is this path in a known ignored directory?
 ---@param path string
----@param project table git status
+---@param project GitProject
 ---@return boolean
 local function path_ignored_in_project(path, project)
   if not path or not project then
     return false
   end
 
-  if project and project.files then
+  if project.files then
-    for file, status in pairs(project.files) do
+    for p, xy in pairs(project.files) do
-      if status == "!!" and vim.startswith(path, file) then
+      if xy == "!!" and vim.startswith(path, p) then
         return true
       end
     end
@@ -67,9 +94,8 @@ local function path_ignored_in_project(path, project)
   return false
 end
 
---- Reload all projects
+---@return GitProject[] maybe empty
----@return table projects maybe empty
+function M.reload_all_projects()
-function M.reload()
   if not M.config.git.enable then
     return {}
   end
@@ -82,11 +108,12 @@ function M.reload()
 end
 
 --- Reload one project. Does nothing when no project or path is ignored
----@param toplevel string|nil
+---@param toplevel string?
----@param path string|nil optional path to update only
+---@param path string? optional path to update only
----@param callback function|nil
+---@param callback function?
 function M.reload_project(toplevel, path, callback)
-  local project = M._projects_by_toplevel[toplevel]
+  local project = M._projects_by_toplevel[toplevel] --[[@as GitProject]]
+
   if not toplevel or not project or not M.config.git.enable then
     if callback then
       callback()
@@ -101,29 +128,31 @@ function M.reload_project(toplevel, path, callback)
     return
   end
 
-  local opts = {
+  ---@type GitRunnerArgs
-    toplevel = toplevel,
+  local args = {
-    path = path,
+    toplevel       = toplevel,
+    path           = path,
     list_untracked = git_utils.should_show_untracked(toplevel),
-    list_ignored = true,
+    list_ignored   = true,
-    timeout = M.config.git.timeout,
+    timeout        = M.config.git.timeout,
   }
 
   if callback then
-    Runner.run(opts, function(git_status)
+    ---@param path_xy GitPathXY
-      reload_git_status(toplevel, path, project, git_status)
+    args.callback = function(path_xy)
+      reload_git_project(toplevel, path, project, path_xy)
       callback()
-    end)
+    end
+    GitRunner:run(args)
   else
-    -- TODO use callback once async/await is available
+    -- TODO #1974 use callback once async/await is available
-    local git_status = Runner.run(opts)
+    reload_git_project(toplevel, path, project, GitRunner:run(args))
-    reload_git_status(toplevel, path, project, git_status)
   end
 end
 
 --- Retrieve a known project
----@param toplevel string|nil
+---@param toplevel string?
----@return table|nil project
+---@return GitProject? project
 function M.get_project(toplevel)
   return M._projects_by_toplevel[toplevel]
 end
@@ -144,11 +173,10 @@ function M.get_toplevel(path)
     return nil
   end
 
-  if M._toplevels_by_path[path] then
+  local tl = M._toplevels_by_path[path]
-    return M._toplevels_by_path[path]
+  if tl then
-  end
+    return tl
-
+  elseif tl == false then
-  if M._toplevels_by_path[path] == false then
     return nil
   end
 
@@ -187,8 +215,15 @@ function M.get_toplevel(path)
   end
 
   M._toplevels_by_path[path] = toplevel
+
   M._git_dirs_by_toplevel[toplevel] = git_dir
-  return M._toplevels_by_path[path]
+
+  toplevel = M._toplevels_by_path[path]
+  if toplevel == false then
+    return nil
+  else
+    return toplevel
+  end
 end
 
 local function reload_tree_at(toplevel)
@@ -203,28 +238,28 @@ local function reload_tree_at(toplevel)
   end
 
   M.reload_project(toplevel, nil, function()
-    local git_status = M.get_project(toplevel)
+    local project = M.get_project(toplevel)
 
     Iterator.builder(root_node.nodes)
       :hidden()
       :applier(function(node)
-        local parent_ignored = explorer_node.is_git_ignored(node.parent)
+        local parent_ignored = node.parent and node.parent:is_git_ignored() or false
-        explorer_node.update_git_status(node, parent_ignored, git_status)
+        node:update_git_status(parent_ignored, project)
       end)
       :recursor(function(node)
         return node.nodes and #node.nodes > 0 and node.nodes
       end)
       :iterate()
 
-    require("nvim-tree.renderer").draw()
+    root_node.explorer.renderer:draw()
   end)
 end
 
 --- Load the project status for a path. Does nothing when no toplevel for path.
 --- Only fetches project status when unknown, otherwise returns existing.
 ---@param path string absolute
----@return table project maybe empty
+---@return GitProject maybe empty
-function M.load_project_status(path)
+function M.load_project(path)
   if not M.config.git.enable then
     return {}
   end
@@ -235,42 +270,48 @@ function M.load_project_status(path)
     return {}
   end
 
-  local status = M._projects_by_toplevel[toplevel]
+  local project = M._projects_by_toplevel[toplevel]
-  if status then
+  if project then
-    return status
+    return project
   end
 
-  local git_status = Runner.run {
+  local path_xys = GitRunner:run({
-    toplevel = toplevel,
+    toplevel       = toplevel,
     list_untracked = git_utils.should_show_untracked(toplevel),
-    list_ignored = true,
+    list_ignored   = true,
-    timeout = M.config.git.timeout,
+    timeout        = M.config.git.timeout,
-  }
+  })
 
   local watcher = nil
   if M.config.filesystem_watchers.enable then
     log.line("watcher", "git start")
 
+    ---@param w Watcher
     local callback = function(w)
-      log.line("watcher", "git event scheduled '%s'", w.toplevel)
+      log.line("watcher", "git event scheduled '%s'", w.data.toplevel)
-      utils.debounce("git:watcher:" .. w.toplevel, M.config.filesystem_watchers.debounce_delay, function()
+      utils.debounce("git:watcher:" .. w.data.toplevel, M.config.filesystem_watchers.debounce_delay, function()
         if w.destroyed then
           return
         end
-        reload_tree_at(w.toplevel)
+        reload_tree_at(w.data.toplevel)
       end)
     end
 
-    local git_dir = vim.env.GIT_DIR or M._git_dirs_by_toplevel[toplevel] or utils.path_join { toplevel, ".git" }
+    local git_dir = vim.env.GIT_DIR or M._git_dirs_by_toplevel[toplevel] or utils.path_join({ toplevel, ".git" })
-    watcher = Watcher:new(git_dir, WATCHED_FILES, callback, {
+    watcher = Watcher:create({
-      toplevel = toplevel,
+      path     = git_dir,
+      files    = WATCHED_FILES,
+      callback = callback,
+      data     = {
+        toplevel = toplevel,
+      }
     })
   end
 
-  if git_status then
+  if path_xys then
     M._projects_by_toplevel[toplevel] = {
-      files = git_status,
+      files   = path_xys,
-      dirs = git_utils.file_status_to_dir_status(git_status, toplevel),
+      dirs    = git_utils.project_files_to_project_dirs(path_xys, toplevel),
       watcher = watcher,
     }
     return M._projects_by_toplevel[toplevel]
@@ -280,6 +321,71 @@ function M.load_project_status(path)
   end
 end
 
+---@param dir DirectoryNode
+---@param project GitProject?
+---@param root string?
+function M.update_parent_projects(dir, project, root)
+  while project and dir do
+    -- step up to the containing project
+    if dir.absolute_path == root then
+      -- stop at the top of the tree
+      if not dir.parent then
+        break
+      end
+
+      root = M.get_toplevel(dir.parent.absolute_path)
+
+      -- stop when no more projects
+      if not root then
+        break
+      end
+
+      -- update the containing project
+      project = M.get_project(root)
+      M.reload_project(root, dir.absolute_path, nil)
+    end
+
+    -- update status
+    dir:update_git_status(dir.parent and dir.parent:is_git_ignored() or false, project)
+
+    -- maybe parent
+    dir = dir.parent
+  end
+end
+
+---Refresh contents and git status for a single directory
+---@param dir DirectoryNode
+function M.refresh_dir(dir)
+  local node = dir:get_parent_of_group() or dir
+  local toplevel = M.get_toplevel(dir.absolute_path)
+
+  M.reload_project(toplevel, dir.absolute_path, function()
+    local project = M.get_project(toplevel) or {}
+
+    dir.explorer:reload(node, project)
+
+    M.update_parent_projects(dir, project, toplevel)
+
+    dir.explorer.renderer:draw()
+  end)
+end
+
+---@param dir DirectoryNode?
+---@param projects GitProject[]
+function M.reload_node_status(dir, projects)
+  dir = dir and dir:as(DirectoryNode)
+  if not dir or #dir.nodes == 0 then
+    return
+  end
+
+  local toplevel = M.get_toplevel(dir.absolute_path)
+  local project = projects[toplevel] or {}
+  for _, node in ipairs(dir.nodes) do
+    node:update_git_status(dir:is_git_ignored(), project)
+    M.reload_node_status(node:as(DirectoryNode), projects)
+  end
+end
+
 function M.purge_state()
   log.line("git", "purge_state")
 

lua/nvim-tree/git/runner.lua

@@ -1,28 +1,62 @@
-local log = require "nvim-tree.log"
+local log = require("nvim-tree.log")
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
 
----@class Runner
+local Class = require("nvim-tree.classic")
-local Runner = {}
+
-Runner.__index = Runner
+---@class (exact) GitRunner: Class
+---@field private toplevel string absolute path
+---@field private path string? absolute path
+---@field private list_untracked boolean
+---@field private list_ignored boolean
+---@field private timeout integer
+---@field private callback fun(path_xy: GitPathXY)?
+---@field private path_xy GitPathXY
+---@field private rc integer? -- -1 indicates timeout
+local GitRunner = Class:extend()
+
+---@class GitRunner
+---@overload fun(args: GitRunnerArgs): GitRunner
+
+---@class (exact) GitRunnerArgs
+---@field toplevel string absolute path
+---@field path string? absolute path
+---@field list_untracked boolean
+---@field list_ignored boolean
+---@field timeout integer
+---@field callback fun(path_xy: GitPathXY)?
 
 local timeouts = 0
 local MAX_TIMEOUTS = 5
 
+---@protected
+---@param args GitRunnerArgs
+function GitRunner:new(args)
+  self.toplevel       = args.toplevel
+  self.path           = args.path
+  self.list_untracked = args.list_untracked
+  self.list_ignored   = args.list_ignored
+  self.timeout        = args.timeout
+  self.callback       = args.callback
+
+  self.path_xy        = {}
+  self.rc             = nil
+end
+
 ---@private
 ---@param status string
 ---@param path string|nil
-function Runner:_parse_status_output(status, path)
+function GitRunner:parse_status_output(status, path)
   if not path then
     return
   end
 
   -- replacing slashes if on windows
-  if vim.fn.has "win32" == 1 then
+  if vim.fn.has("win32") == 1 then
     path = path:gsub("/", "\\")
   end
   if #status > 0 and #path > 0 then
-    self.output[utils.path_remove_trailing(utils.path_join { self.toplevel, path })] = status
+    self.path_xy[utils.path_remove_trailing(utils.path_join({ self.toplevel, path }))] = status
   end
 end
 
@@ -30,12 +64,12 @@ end
 ---@param prev_output string
 ---@param incoming string
 ---@return string
-function Runner:_handle_incoming_data(prev_output, incoming)
+function GitRunner:handle_incoming_data(prev_output, incoming)
   if incoming and utils.str_find(incoming, "\n") then
     local prev = prev_output .. incoming
     local i = 1
     local skip_next_line = false
-    for line in prev:gmatch "[^\n]*\n" do
+    for line in prev:gmatch("[^\n]*\n") do
       if skip_next_line then
         skip_next_line = false
       else
@@ -45,7 +79,7 @@ function Runner:_handle_incoming_data(prev_output, incoming)
           -- skip next line if it is a rename entry
           skip_next_line = true
         end
-        self:_parse_status_output(status, path)
+        self:parse_status_output(status, path)
       end
       i = i + #line
     end
@@ -57,36 +91,39 @@ function Runner:_handle_incoming_data(prev_output, incoming)
     return prev_output .. incoming
   end
 
-  for line in prev_output:gmatch "[^\n]*\n" do
+  for line in prev_output:gmatch("[^\n]*\n") do
-    self:_parse_status_output(line)
+    self:parse_status_output(line)
   end
 
   return ""
 end
 
+---@private
 ---@param stdout_handle uv.uv_pipe_t
 ---@param stderr_handle uv.uv_pipe_t
----@return table
+---@return uv.spawn.options
-function Runner:_getopts(stdout_handle, stderr_handle)
+function GitRunner:get_spawn_options(stdout_handle, stderr_handle)
   local untracked = self.list_untracked and "-u" or nil
   local ignored = (self.list_untracked and self.list_ignored) and "--ignored=matching" or "--ignored=no"
   return {
-    args = { "--no-optional-locks", "status", "--porcelain=v1", "-z", ignored, untracked, self.path },
+    args  = { "--no-optional-locks", "status", "--porcelain=v1", "-z", ignored, untracked, self.path },
-    cwd = self.toplevel,
+    cwd   = self.toplevel,
     stdio = { nil, stdout_handle, stderr_handle },
   }
 end
 
+---@private
 ---@param output string
-function Runner:_log_raw_output(output)
+function GitRunner:log_raw_output(output)
-  if log.enabled "git" and output and type(output) == "string" then
+  if log.enabled("git") and output and type(output) == "string" then
     log.raw("git", "%s", output)
     log.line("git", "done")
   end
 end
 
+---@private
 ---@param callback function|nil
-function Runner:_run_git_job(callback)
+function GitRunner:run_git_job(callback)
   local handle, pid
   local stdout = vim.loop.new_pipe(false)
   local stderr = vim.loop.new_pipe(false)
@@ -123,13 +160,13 @@ function Runner:_run_git_job(callback)
     end
   end
 
-  local opts = self:_getopts(stdout, stderr)
+  local spawn_options = self:get_spawn_options(stdout, stderr)
   log.line("git", "running job with timeout %dms", self.timeout)
-  log.line("git", "git %s", table.concat(utils.array_remove_nils(opts.args), " "))
+  log.line("git", "git %s",                        table.concat(utils.array_remove_nils(spawn_options.args), " "))
 
   handle, pid = vim.loop.spawn(
     "git",
-    opts,
+    spawn_options,
     vim.schedule_wrap(function(rc)
       on_finish(rc)
     end)
@@ -151,19 +188,20 @@ function Runner:_run_git_job(callback)
     if data then
       data = data:gsub("%z", "\n")
     end
-    self:_log_raw_output(data)
+    self:log_raw_output(data)
-    output_leftover = self:_handle_incoming_data(output_leftover, data)
+    output_leftover = self:handle_incoming_data(output_leftover, data)
   end
 
   local function manage_stderr(_, data)
-    self:_log_raw_output(data)
+    self:log_raw_output(data)
   end
 
   vim.loop.read_start(stdout, vim.schedule_wrap(manage_stdout))
   vim.loop.read_start(stderr, vim.schedule_wrap(manage_stderr))
 end
 
-function Runner:_wait()
+---@private
+function GitRunner:wait()
   local function is_done()
     return self.rc ~= nil
   end
@@ -172,64 +210,64 @@ function Runner:_wait()
   end
 end
 
----@param opts table
+---@private
-function Runner:_finalise(opts)
+function GitRunner:finalise()
   if self.rc == -1 then
-    log.line("git", "job timed out  %s %s", opts.toplevel, opts.path)
+    log.line("git", "job timed out  %s %s", self.toplevel, self.path)
     timeouts = timeouts + 1
     if timeouts == MAX_TIMEOUTS then
-      notify.warn(string.format("%d git jobs have timed out after git.timeout %dms, disabling git integration.", timeouts, opts.timeout))
+      notify.warn(string.format("%d git jobs have timed out after git.timeout %dms, disabling git integration.", timeouts,
+        self.timeout))
       require("nvim-tree.git").disable_git_integration()
     end
   elseif self.rc ~= 0 then
-    log.line("git", "job fail rc %d %s %s", self.rc, opts.toplevel, opts.path)
+    log.line("git", "job fail rc %d %s %s", self.rc, self.toplevel, self.path)
   else
-    log.line("git", "job success    %s %s", opts.toplevel, opts.path)
+    log.line("git", "job success    %s %s", self.toplevel, self.path)
   end
 end
 
---- Runs a git process, which will be killed if it takes more than timeout which defaults to 400ms
+---Return nil when callback present
----@param opts table
+---@private
----@param callback function|nil executed passing return when complete
+---@return GitPathXY?
----@return table|nil status by absolute path, nil if callback present
+function GitRunner:execute()
-function Runner.run(opts, callback)
+  local async = self.callback ~= nil
-  local self = setmetatable({
+  local profile = log.profile_start("git %s job %s %s", async and "async" or "sync", self.toplevel, self.path)
-    toplevel = opts.toplevel,
-    path = opts.path,
-    list_untracked = opts.list_untracked,
-    list_ignored = opts.list_ignored,
-    timeout = opts.timeout or 400,
-    output = {},
-    rc = nil, -- -1 indicates timeout
-  }, Runner)
 
-  local async = callback ~= nil
+  if async and self.callback then
-  local profile = log.profile_start("git %s job %s %s", async and "async" or "sync", opts.toplevel, opts.path)
-
-  if async and callback then
     -- async, always call back
-    self:_run_git_job(function()
+    self:run_git_job(function()
       log.profile_end(profile)
 
-      self:_finalise(opts)
+      self:finalise()
 
-      callback(self.output)
+      self.callback(self.path_xy)
     end)
   else
     -- sync, maybe call back
-    self:_run_git_job()
+    self:run_git_job()
-    self:_wait()
+    self:wait()
 
     log.profile_end(profile)
 
-    self:_finalise(opts)
+    self:finalise()
 
-    if callback then
+    if self.callback then
-      callback(self.output)
+      self.callback(self.path_xy)
     else
-      return self.output
+      return self.path_xy
     end
   end
 end
 
-return Runner
+---Static method to run a git process, which will be killed if it takes more than timeout
+---Return nil when callback present
+---@param args GitRunnerArgs
+---@return GitPathXY?
+function GitRunner:run(args)
+  local runner = GitRunner(args)
+
+  return runner:execute()
+end
+
+return GitRunner

lua/nvim-tree/git/utils.lua

@@ -1,5 +1,5 @@
-local log = require "nvim-tree.log"
+local log = require("nvim-tree.log")
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
 
 local M = {
   use_cygpath = false,
@@ -21,30 +21,30 @@ function M.get_toplevel(cwd)
   log.raw("git", out)
   log.profile_end(profile)
 
-  if vim.v.shell_error ~= 0 or not out or #out == 0 or out:match "fatal" then
+  if vim.v.shell_error ~= 0 or not out or #out == 0 or out:match("fatal") then
     return nil, nil
   end
 
-  local toplevel, git_dir = out:match "([^\n]+)\n+([^\n]+)"
+  local toplevel, git_dir = out:match("([^\n]+)\n+([^\n]+)")
   if not toplevel then
     return nil, nil
   end
   if not git_dir then
-    git_dir = utils.path_join { toplevel, ".git" }
+    git_dir = utils.path_join({ toplevel, ".git" })
   end
 
   -- git always returns path with forward slashes
-  if vim.fn.has "win32" == 1 then
+  if vim.fn.has("win32") == 1 then
     -- msys2 git support
     -- cygpath calls must in array format to avoid shell compatibility issues
     if M.use_cygpath then
-      toplevel = vim.fn.system { "cygpath", "-w", toplevel }
+      toplevel = vim.fn.system({ "cygpath", "-w", toplevel })
       if vim.v.shell_error ~= 0 then
         return nil, nil
       end
       -- remove trailing newline(\n) character added by vim.fn.system
       toplevel = toplevel:gsub("\n", "")
-      git_dir = vim.fn.system { "cygpath", "-w", git_dir }
+      git_dir = vim.fn.system({ "cygpath", "-w", git_dir })
       if vim.v.shell_error ~= 0 then
         return nil, nil
       end
@@ -58,10 +58,11 @@ function M.get_toplevel(cwd)
   return toplevel, git_dir
 end
 
+---@type table<string, boolean>
 local untracked = {}
 
 ---@param cwd string
----@return string|nil
+---@return boolean
 function M.should_show_untracked(cwd)
   if untracked[cwd] ~= nil then
     return untracked[cwd]
@@ -81,8 +82,8 @@ function M.should_show_untracked(cwd)
   return untracked[cwd]
 end
 
----@param t table|nil
+---@param t table<string|integer, boolean>?
----@param k string
+---@param k string|integer
 ---@return table
 local function nil_insert(t, k)
   t = t or {}
@@ -90,31 +91,33 @@ local function nil_insert(t, k)
   return t
 end
 
----@param status table
+---@param project_files GitProjectFiles
 ---@param cwd string|nil
----@return table
+---@return GitProjectDirs
-function M.file_status_to_dir_status(status, cwd)
+function M.project_files_to_project_dirs(project_files, cwd)
-  local direct = {}
+  ---@type GitProjectDirs
-  for p, s in pairs(status) do
+  local project_dirs = {}
+
+  project_dirs.direct = {}
+  for p, s in pairs(project_files) do
     if s ~= "!!" then
       local modified = vim.fn.fnamemodify(p, ":h")
-      direct[modified] = nil_insert(direct[modified], s)
+      project_dirs.direct[modified] = nil_insert(project_dirs.direct[modified], s)
     end
   end
 
-  local indirect = {}
+  project_dirs.indirect = {}
-  for dirname, statuses in pairs(direct) do
+  for dirname, statuses in pairs(project_dirs.direct) do
     for s, _ in pairs(statuses) do
       local modified = dirname
       while modified ~= cwd and modified ~= "/" do
         modified = vim.fn.fnamemodify(modified, ":h")
-        indirect[modified] = nil_insert(indirect[modified], s)
+        project_dirs.indirect[modified] = nil_insert(project_dirs.indirect[modified], s)
       end
     end
   end
 
-  local r = { indirect = indirect, direct = direct }
+  for _, d in pairs(project_dirs) do
-  for _, d in pairs(r) do
     for dirname, statuses in pairs(d) do
       local new_statuses = {}
       for s, _ in pairs(statuses) do
@@ -123,12 +126,65 @@ function M.file_status_to_dir_status(status, cwd)
       d[dirname] = new_statuses
     end
   end
-  return r
+
+  return project_dirs
+end
+
+---Git file status for an absolute path
+---@param parent_ignored boolean
+---@param project GitProject?
+---@param path string
+---@param path_fallback string? alternative file path when no other file status
+---@return GitNodeStatus
+function M.git_status_file(parent_ignored, project, path, path_fallback)
+  ---@type GitNodeStatus
+  local ns
+
+  if parent_ignored then
+    ns = {
+      file = "!!"
+    }
+  elseif project and project.files then
+    ns = {
+      file = project.files[path] or project.files[path_fallback]
+    }
+  else
+    ns = {}
+  end
+
+  return ns
+end
+
+---Git file and directory status for an absolute path
+---@param parent_ignored boolean
+---@param project GitProject?
+---@param path string
+---@param path_fallback string? alternative file path when no other file status
+---@return GitNodeStatus?
+function M.git_status_dir(parent_ignored, project, path, path_fallback)
+  ---@type GitNodeStatus?
+  local ns
+
+  if parent_ignored then
+    ns = {
+      file = "!!"
+    }
+  elseif project then
+    ns = {
+      file = project.files and (project.files[path] or project.files[path_fallback]),
+      dir  = project.dirs and {
+        direct   = project.dirs.direct and project.dirs.direct[path],
+        indirect = project.dirs.indirect and project.dirs.indirect[path],
+      },
+    }
+  end
+
+  return ns
 end
 
 function M.setup(opts)
   if opts.git.cygwin_support then
-    M.use_cygpath = vim.fn.executable "cygpath" == 1
+    M.use_cygpath = vim.fn.executable("cygpath") == 1
   end
 end
 

lua/nvim-tree/help.lua

@@ -1,4 +1,5 @@
-local keymap = require "nvim-tree.keymap"
+local keymap = require("nvim-tree.keymap")
+local api = {} -- circular dependency
 
 local PAT_MOUSE = "^<.*Mouse"
 local PAT_CTRL = "^<C%-"
@@ -26,12 +27,12 @@ local function tidy_lhs(lhs)
   lhs = lhs:gsub("^<lt>", "<")
 
   -- shorten ctrls
-  if lhs:lower():match "^<ctrl%-" then
+  if lhs:lower():match("^<ctrl%-") then
     lhs = lhs:lower():gsub("^<ctrl%-", "<C%-")
   end
 
   -- uppercase ctrls
-  if lhs:lower():match "^<c%-" then
+  if lhs:lower():match("^<c%-") then
     lhs = lhs:upper()
   end
 
@@ -52,6 +53,7 @@ end
 --- sort vim command lhs roughly as per :help index
 ---@param a string
 ---@param b string
+---@return boolean
 local function sort_lhs(a, b)
   -- mouse first
   if a:match(PAT_MOUSE) and not b:match(PAT_MOUSE) then
@@ -79,18 +81,19 @@ local function sort_lhs(a, b)
 end
 
 --- Compute all lines for the buffer
+---@param map table keymap.get_keymap
 ---@return table strings of text
 ---@return table arrays of arguments 3-6 for nvim_buf_add_highlight()
 ---@return number maximum length of text
-local function compute()
+local function compute(map)
   local head_lhs = "nvim-tree mappings"
   local head_rhs1 = "exit: q"
   local head_rhs2 = string.format("sort by %s: s", M.config.sort_by == "key" and "description" or "keymap")
 
   -- formatted lhs and desc from active keymap
-  local mappings = vim.tbl_map(function(map)
+  local mappings = vim.tbl_map(function(m)
-    return { lhs = tidy_lhs(map.lhs), desc = tidy_desc(map.desc) }
+    return { lhs = tidy_lhs(m.lhs), desc = tidy_desc(m.desc) }
-  end, keymap.get_keymap())
+  end, map)
 
   -- sorter function for mappings
   local sort_fn
@@ -128,7 +131,7 @@ local function compute()
 
   -- header highlight, assume one character keys
   local hl = {
-    { "NvimTreeFolderName", 0, 0, #head_lhs },
+    { "NvimTreeFolderName", 0, 0,         #head_lhs },
     { "NvimTreeFolderName", 0, width - 1, width },
     { "NvimTreeFolderName", 1, width - 1, width },
   }
@@ -165,8 +168,11 @@ local function open()
   -- close existing, shouldn't be necessary
   close()
 
+  -- fetch all mappings
+  local map = keymap.get_keymap()
+
   -- text and highlight
-  local lines, hl, width = compute()
+  local lines, hl, width = compute(map)
 
   -- create the buffer
   M.bufnr = vim.api.nvim_create_buf(false, true)
@@ -174,7 +180,7 @@ local function open()
   -- populate it
   vim.api.nvim_buf_set_lines(M.bufnr, 0, -1, false, lines)
 
-  if vim.fn.has "nvim-0.10" == 1 then
+  if vim.fn.has("nvim-0.10") == 1 then
     vim.api.nvim_set_option_value("modifiable", false, { buf = M.bufnr })
   else
     vim.api.nvim_buf_set_option(M.bufnr, "modifiable", false) ---@diagnostic disable-line: deprecated
@@ -206,12 +212,21 @@ local function open()
     open()
   end
 
-  local keymaps = {
+  -- hardcoded
+  local help_keymaps = {
     q = { fn = close, desc = "nvim-tree: exit help" },
+    ["<Esc>"] = { fn = close, desc = "nvim-tree: exit help" }, -- hidden
     s = { fn = toggle_sort, desc = "nvim-tree: toggle sorting method" },
   }
 
-  for k, v in pairs(keymaps) do
+  -- api help binding closes
+  for _, m in ipairs(map) do
+    if m.callback == api.tree.toggle_help then
+      help_keymaps[m.lhs] = { fn = close, desc = "nvim-tree: exit help" }
+    end
+  end
+
+  for k, v in pairs(help_keymaps) do
     vim.keymap.set("n", k, v.fn, {
       desc = v.desc,
       buffer = M.bufnr,
@@ -240,6 +255,8 @@ end
 function M.setup(opts)
   M.config.cursorline = opts.view.cursorline
   M.config.sort_by = opts.help.sort_by
+
+  api = require("nvim-tree.api")
 end
 
 return M

lua/nvim-tree/keymap.lua

@@ -1,7 +1,7 @@
 local M = {}
 
 --- Apply mappings to a scratch buffer and return buffer local mappings
----@param fn function(bufnr) on_attach or default_on_attach
+---@param fn fun(bufnr: integer) on_attach or default_on_attach
 ---@return table as per vim.api.nvim_buf_get_keymap
 local function generate_keymap(fn)
   -- create an unlisted scratch buffer
@@ -19,84 +19,6 @@ local function generate_keymap(fn)
   return keymap
 end
 
--- stylua: ignore start
----@param bufnr integer
-function M.default_on_attach(bufnr)
-  local api = require('nvim-tree.api')
-
-  local function opts(desc)
-    return {
-      desc = 'nvim-tree: ' .. desc,
-      buffer = bufnr,
-      noremap = true,
-      silent = true,
-      nowait = true,
-  }
-  end
-
-  -- BEGIN_DEFAULT_ON_ATTACH
-  vim.keymap.set('n', '<C-]>',   api.tree.change_root_to_node,        opts('CD'))
-  vim.keymap.set('n', '<C-e>',   api.node.open.replace_tree_buffer,   opts('Open: In Place'))
-  vim.keymap.set('n', '<C-k>',   api.node.show_info_popup,            opts('Info'))
-  vim.keymap.set('n', '<C-r>',   api.fs.rename_sub,                   opts('Rename: Omit Filename'))
-  vim.keymap.set('n', '<C-t>',   api.node.open.tab,                   opts('Open: New Tab'))
-  vim.keymap.set('n', '<C-v>',   api.node.open.vertical,              opts('Open: Vertical Split'))
-  vim.keymap.set('n', '<C-x>',   api.node.open.horizontal,            opts('Open: Horizontal Split'))
-  vim.keymap.set('n', '<BS>',    api.node.navigate.parent_close,      opts('Close Directory'))
-  vim.keymap.set('n', '<CR>',    api.node.open.edit,                  opts('Open'))
-  vim.keymap.set('n', '<Tab>',   api.node.open.preview,               opts('Open Preview'))
-  vim.keymap.set('n', '>',       api.node.navigate.sibling.next,      opts('Next Sibling'))
-  vim.keymap.set('n', '<',       api.node.navigate.sibling.prev,      opts('Previous Sibling'))
-  vim.keymap.set('n', '.',       api.node.run.cmd,                    opts('Run Command'))
-  vim.keymap.set('n', '-',       api.tree.change_root_to_parent,      opts('Up'))
-  vim.keymap.set('n', 'a',       api.fs.create,                       opts('Create File Or Directory'))
-  vim.keymap.set('n', 'bd',      api.marks.bulk.delete,               opts('Delete Bookmarked'))
-  vim.keymap.set('n', 'bt',      api.marks.bulk.trash,                opts('Trash Bookmarked'))
-  vim.keymap.set('n', 'bmv',     api.marks.bulk.move,                 opts('Move Bookmarked'))
-  vim.keymap.set('n', 'B',       api.tree.toggle_no_buffer_filter,    opts('Toggle Filter: No Buffer'))
-  vim.keymap.set('n', 'c',       api.fs.copy.node,                    opts('Copy'))
-  vim.keymap.set('n', 'C',       api.tree.toggle_git_clean_filter,    opts('Toggle Filter: Git Clean'))
-  vim.keymap.set('n', '[c',      api.node.navigate.git.prev,          opts('Prev Git'))
-  vim.keymap.set('n', ']c',      api.node.navigate.git.next,          opts('Next Git'))
-  vim.keymap.set('n', 'd',       api.fs.remove,                       opts('Delete'))
-  vim.keymap.set('n', 'D',       api.fs.trash,                        opts('Trash'))
-  vim.keymap.set('n', 'E',       api.tree.expand_all,                 opts('Expand All'))
-  vim.keymap.set('n', 'e',       api.fs.rename_basename,              opts('Rename: Basename'))
-  vim.keymap.set('n', ']e',      api.node.navigate.diagnostics.next,  opts('Next Diagnostic'))
-  vim.keymap.set('n', '[e',      api.node.navigate.diagnostics.prev,  opts('Prev Diagnostic'))
-  vim.keymap.set('n', 'F',       api.live_filter.clear,               opts('Live Filter: Clear'))
-  vim.keymap.set('n', 'f',       api.live_filter.start,               opts('Live Filter: Start'))
-  vim.keymap.set('n', 'g?',      api.tree.toggle_help,                opts('Help'))
-  vim.keymap.set('n', 'gy',      api.fs.copy.absolute_path,           opts('Copy Absolute Path'))
-  vim.keymap.set('n', 'ge',      api.fs.copy.basename,                opts('Copy Basename'))
-  vim.keymap.set('n', 'H',       api.tree.toggle_hidden_filter,       opts('Toggle Filter: Dotfiles'))
-  vim.keymap.set('n', 'I',       api.tree.toggle_gitignore_filter,    opts('Toggle Filter: Git Ignore'))
-  vim.keymap.set('n', 'J',       api.node.navigate.sibling.last,      opts('Last Sibling'))
-  vim.keymap.set('n', 'K',       api.node.navigate.sibling.first,     opts('First Sibling'))
-  vim.keymap.set('n', 'L',       api.node.open.toggle_group_empty,    opts('Toggle Group Empty'))
-  vim.keymap.set('n', 'M',       api.tree.toggle_no_bookmark_filter,  opts('Toggle Filter: No Bookmark'))
-  vim.keymap.set('n', 'm',       api.marks.toggle,                    opts('Toggle Bookmark'))
-  vim.keymap.set('n', 'o',       api.node.open.edit,                  opts('Open'))
-  vim.keymap.set('n', 'O',       api.node.open.no_window_picker,      opts('Open: No Window Picker'))
-  vim.keymap.set('n', 'p',       api.fs.paste,                        opts('Paste'))
-  vim.keymap.set('n', 'P',       api.node.navigate.parent,            opts('Parent Directory'))
-  vim.keymap.set('n', 'q',       api.tree.close,                      opts('Close'))
-  vim.keymap.set('n', 'r',       api.fs.rename,                       opts('Rename'))
-  vim.keymap.set('n', 'R',       api.tree.reload,                     opts('Refresh'))
-  vim.keymap.set('n', 's',       api.node.run.system,                 opts('Run System'))
-  vim.keymap.set('n', 'S',       api.tree.search_node,                opts('Search'))
-  vim.keymap.set('n', 'u',       api.fs.rename_full,                  opts('Rename: Full Path'))
-  vim.keymap.set('n', 'U',       api.tree.toggle_custom_filter,       opts('Toggle Filter: Hidden'))
-  vim.keymap.set('n', 'W',       api.tree.collapse_all,               opts('Collapse'))
-  vim.keymap.set('n', 'x',       api.fs.cut,                          opts('Cut'))
-  vim.keymap.set('n', 'y',       api.fs.copy.filename,                opts('Copy Name'))
-  vim.keymap.set('n', 'Y',       api.fs.copy.relative_path,           opts('Copy Relative Path'))
-  vim.keymap.set('n', '<2-LeftMouse>',  api.node.open.edit,           opts('Open'))
-  vim.keymap.set('n', '<2-RightMouse>', api.tree.change_root_to_node, opts('CD'))
-  -- END_DEFAULT_ON_ATTACH
-end
--- stylua: ignore end
-
 ---@return table
 function M.get_keymap()
   return generate_keymap(M.on_attach)
@@ -107,6 +29,82 @@ function M.get_keymap_default()
   return generate_keymap(M.default_on_attach)
 end
 
+---@param bufnr integer
+function M.default_on_attach(bufnr)
+  local api = require("nvim-tree.api")
+
+  local function opts(desc)
+    return {
+      desc = "nvim-tree: " .. desc,
+      buffer = bufnr,
+      noremap = true,
+      silent = true,
+      nowait = true,
+    }
+  end
+
+  -- BEGIN_DEFAULT_ON_ATTACH
+  vim.keymap.set("n", "<C-]>",          api.tree.change_root_to_node,       opts("CD"))
+  vim.keymap.set("n", "<C-e>",          api.node.open.replace_tree_buffer,  opts("Open: In Place"))
+  vim.keymap.set("n", "<C-k>",          api.node.show_info_popup,           opts("Info"))
+  vim.keymap.set("n", "<C-r>",          api.fs.rename_sub,                  opts("Rename: Omit Filename"))
+  vim.keymap.set("n", "<C-t>",          api.node.open.tab,                  opts("Open: New Tab"))
+  vim.keymap.set("n", "<C-v>",          api.node.open.vertical,             opts("Open: Vertical Split"))
+  vim.keymap.set("n", "<C-x>",          api.node.open.horizontal,           opts("Open: Horizontal Split"))
+  vim.keymap.set("n", "<BS>",           api.node.navigate.parent_close,     opts("Close Directory"))
+  vim.keymap.set("n", "<CR>",           api.node.open.edit,                 opts("Open"))
+  vim.keymap.set("n", "<Tab>",          api.node.open.preview,              opts("Open Preview"))
+  vim.keymap.set("n", ">",              api.node.navigate.sibling.next,     opts("Next Sibling"))
+  vim.keymap.set("n", "<",              api.node.navigate.sibling.prev,     opts("Previous Sibling"))
+  vim.keymap.set("n", ".",              api.node.run.cmd,                   opts("Run Command"))
+  vim.keymap.set("n", "-",              api.tree.change_root_to_parent,     opts("Up"))
+  vim.keymap.set("n", "a",              api.fs.create,                      opts("Create File Or Directory"))
+  vim.keymap.set("n", "bd",             api.marks.bulk.delete,              opts("Delete Bookmarked"))
+  vim.keymap.set("n", "bt",             api.marks.bulk.trash,               opts("Trash Bookmarked"))
+  vim.keymap.set("n", "bmv",            api.marks.bulk.move,                opts("Move Bookmarked"))
+  vim.keymap.set("n", "B",              api.tree.toggle_no_buffer_filter,   opts("Toggle Filter: No Buffer"))
+  vim.keymap.set("n", "c",              api.fs.copy.node,                   opts("Copy"))
+  vim.keymap.set("n", "C",              api.tree.toggle_git_clean_filter,   opts("Toggle Filter: Git Clean"))
+  vim.keymap.set("n", "[c",             api.node.navigate.git.prev,         opts("Prev Git"))
+  vim.keymap.set("n", "]c",             api.node.navigate.git.next,         opts("Next Git"))
+  vim.keymap.set("n", "d",              api.fs.remove,                      opts("Delete"))
+  vim.keymap.set("n", "D",              api.fs.trash,                       opts("Trash"))
+  vim.keymap.set("n", "E",              api.tree.expand_all,                opts("Expand All"))
+  vim.keymap.set("n", "e",              api.fs.rename_basename,             opts("Rename: Basename"))
+  vim.keymap.set("n", "]e",             api.node.navigate.diagnostics.next, opts("Next Diagnostic"))
+  vim.keymap.set("n", "[e",             api.node.navigate.diagnostics.prev, opts("Prev Diagnostic"))
+  vim.keymap.set("n", "F",              api.live_filter.clear,              opts("Live Filter: Clear"))
+  vim.keymap.set("n", "f",              api.live_filter.start,              opts("Live Filter: Start"))
+  vim.keymap.set("n", "g?",             api.tree.toggle_help,               opts("Help"))
+  vim.keymap.set("n", "gy",             api.fs.copy.absolute_path,          opts("Copy Absolute Path"))
+  vim.keymap.set("n", "ge",             api.fs.copy.basename,               opts("Copy Basename"))
+  vim.keymap.set("n", "H",              api.tree.toggle_hidden_filter,      opts("Toggle Filter: Dotfiles"))
+  vim.keymap.set("n", "I",              api.tree.toggle_gitignore_filter,   opts("Toggle Filter: Git Ignore"))
+  vim.keymap.set("n", "J",              api.node.navigate.sibling.last,     opts("Last Sibling"))
+  vim.keymap.set("n", "K",              api.node.navigate.sibling.first,    opts("First Sibling"))
+  vim.keymap.set("n", "L",              api.node.open.toggle_group_empty,   opts("Toggle Group Empty"))
+  vim.keymap.set("n", "M",              api.tree.toggle_no_bookmark_filter, opts("Toggle Filter: No Bookmark"))
+  vim.keymap.set("n", "m",              api.marks.toggle,                   opts("Toggle Bookmark"))
+  vim.keymap.set("n", "o",              api.node.open.edit,                 opts("Open"))
+  vim.keymap.set("n", "O",              api.node.open.no_window_picker,     opts("Open: No Window Picker"))
+  vim.keymap.set("n", "p",              api.fs.paste,                       opts("Paste"))
+  vim.keymap.set("n", "P",              api.node.navigate.parent,           opts("Parent Directory"))
+  vim.keymap.set("n", "q",              api.tree.close,                     opts("Close"))
+  vim.keymap.set("n", "r",              api.fs.rename,                      opts("Rename"))
+  vim.keymap.set("n", "R",              api.tree.reload,                    opts("Refresh"))
+  vim.keymap.set("n", "s",              api.node.run.system,                opts("Run System"))
+  vim.keymap.set("n", "S",              api.tree.search_node,               opts("Search"))
+  vim.keymap.set("n", "u",              api.fs.rename_full,                 opts("Rename: Full Path"))
+  vim.keymap.set("n", "U",              api.tree.toggle_custom_filter,      opts("Toggle Filter: Hidden"))
+  vim.keymap.set("n", "W",              api.tree.collapse_all,              opts("Collapse"))
+  vim.keymap.set("n", "x",              api.fs.cut,                         opts("Cut"))
+  vim.keymap.set("n", "y",              api.fs.copy.filename,               opts("Copy Name"))
+  vim.keymap.set("n", "Y",              api.fs.copy.relative_path,          opts("Copy Relative Path"))
+  vim.keymap.set("n", "<2-LeftMouse>",  api.node.open.edit,                 opts("Open"))
+  vim.keymap.set("n", "<2-RightMouse>", api.tree.change_root_to_node,       opts("CD"))
+  -- END_DEFAULT_ON_ATTACH
+end
+
 function M.setup(opts)
   if type(opts.on_attach) ~= "function" then
     M.on_attach = M.default_on_attach

lua/nvim-tree/legacy.lua

@@ -1,17 +1,17 @@
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
 
 local M = {}
 
 -- silently move, please add to help nvim-tree-legacy-opts
 local function refactored(opts)
   -- 2022/06/20
-  utils.move_missing_val(opts, "update_focused_file", "update_cwd", opts, "update_focused_file", "update_root", true)
+  utils.move_missing_val(opts, "update_focused_file", "update_cwd", opts, "update_focused_file", "update_root",        true)
-  utils.move_missing_val(opts, "", "update_cwd", opts, "", "sync_root_with_cwd", true)
+  utils.move_missing_val(opts, "",                    "update_cwd", opts, "",                    "sync_root_with_cwd", true)
 
   -- 2022/11/07
-  utils.move_missing_val(opts, "", "open_on_tab", opts, "tab.sync", "open", false)
+  utils.move_missing_val(opts, "", "open_on_tab",              opts, "tab.sync", "open",   false)
-  utils.move_missing_val(opts, "", "open_on_tab", opts, "tab.sync", "close", true)
+  utils.move_missing_val(opts, "", "open_on_tab",              opts, "tab.sync", "close",  true)
   utils.move_missing_val(opts, "", "ignore_buf_on_tab_change", opts, "tab.sync", "ignore", true)
 
   -- 2022/11/22
@@ -64,23 +64,24 @@ end
 
 local function deprecated(opts)
   if type(opts.view) == "table" and opts.view.hide_root_folder then
-    notify.info "view.hide_root_folder is deprecated, please set renderer.root_folder_label = false"
+    notify.info("view.hide_root_folder is deprecated, please set renderer.root_folder_label = false")
   end
 end
 
 local function removed(opts)
   if opts.auto_close then
-    notify.warn "auto close feature has been removed: https://github.com/nvim-tree/nvim-tree.lua/wiki/Auto-Close"
+    notify.warn("auto close feature has been removed: https://github.com/nvim-tree/nvim-tree.lua/wiki/Auto-Close")
     opts.auto_close = nil
   end
 
   if opts.focus_empty_on_setup then
-    notify.warn "focus_empty_on_setup has been removed: https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup"
+    notify.warn("focus_empty_on_setup has been removed: https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup")
     opts.focus_empty_on_setup = nil
   end
 
   if opts.create_in_closed_folder then
-    notify.warn "create_in_closed_folder has been removed and is now the default behaviour. You may use api.fs.create to add a file under your desired node."
+    notify.warn(
+      "create_in_closed_folder has been removed and is now the default behaviour. You may use api.fs.create to add a file under your desired node.")
   end
   opts.create_in_closed_folder = nil
 end

lua/nvim-tree/lib.lua

@@ -1,10 +1,7 @@
-local renderer = require "nvim-tree.renderer"
+local view = require("nvim-tree.view")
-local view = require "nvim-tree.view"
+local core = require("nvim-tree.core")
-local core = require "nvim-tree.core"
+local events = require("nvim-tree.events")
-local utils = require "nvim-tree.utils"
+local notify = require("nvim-tree.notify")
-local events = require "nvim-tree.events"
-local notify = require "nvim-tree.notify"
-local explorer_node = require "nvim-tree.explorer.node"
 
 ---@class LibOpenOpts
 ---@field path string|nil path
@@ -15,169 +12,6 @@ local M = {
   target_winid = nil,
 }
 
----Cursor position as per vim.api.nvim_win_get_cursor
----@return integer[]|nil
-function M.get_cursor_position()
-  if not core.get_explorer() then
-    return
-  end
-
-  local winnr = view.get_winnr()
-  if not winnr or not vim.api.nvim_win_is_valid(winnr) then
-    return
-  end
-
-  return vim.api.nvim_win_get_cursor(winnr)
-end
-
----@return Node|nil
-function M.get_node_at_cursor()
-  local cursor = M.get_cursor_position()
-  if not cursor then
-    return
-  end
-
-  if cursor[1] == 1 and view.is_root_folder_visible(core.get_cwd()) then
-    return { name = ".." }
-  end
-
-  return utils.get_nodes_by_line(core.get_explorer().nodes, core.get_nodes_starting_line())[cursor[1]]
-end
-
----Create a sanitized partial copy of a node, populating children recursively.
----@param node Node|nil
----@return Node|nil cloned node
-local function clone_node(node)
-  if not node then
-    node = core.get_explorer()
-    if not node then
-      return nil
-    end
-  end
-
-  local n = {
-    absolute_path = node.absolute_path,
-    executable = node.executable,
-    extension = node.extension,
-    git_status = node.git_status,
-    has_children = node.has_children,
-    hidden = node.hidden,
-    link_to = node.link_to,
-    name = node.name,
-    open = node.open,
-    type = node.type,
-    fs_stat = node.fs_stat,
-  }
-
-  if type(node.nodes) == "table" then
-    n.nodes = {}
-    for _, child in ipairs(node.nodes) do
-      table.insert(n.nodes, clone_node(child))
-    end
-  end
-
-  return n
-end
-
----Api.tree.get_nodes
----@return Node[]|nil
-function M.get_nodes()
-  return clone_node(core.get_explorer())
-end
-
--- If node is grouped, return the last node in the group. Otherwise, return the given node.
----@param node Node
----@return Node
-function M.get_last_group_node(node)
-  while node and node.group_next do
-    node = node.group_next
-  end
-
-  return node ---@diagnostic disable-line: return-type-mismatch -- it can't be nil
-end
-
----Group empty folders
--- Recursively group nodes
----@param node Node
----@return Node[]
-function M.group_empty_folders(node)
-  local is_root = not node.parent
-  local child_folder_only = explorer_node.has_one_child_folder(node) and node.nodes[1]
-  if M.group_empty and not is_root and child_folder_only then
-    node.group_next = child_folder_only
-    local ns = M.group_empty_folders(child_folder_only)
-    node.nodes = ns or {}
-    return ns
-  end
-  return node.nodes
-end
-
----Ungroup empty folders
--- If a node is grouped, ungroup it: put node.group_next to the node.nodes and set node.group_next to nil
----@param node Node
-function M.ungroup_empty_folders(node)
-  local cur = node
-  while cur and cur.group_next do
-    cur.nodes = { cur.group_next }
-    cur.group_next = nil
-    cur = cur.nodes[1]
-  end
-end
-
----@param node Node
----@return Node[]
-function M.get_all_nodes_in_group(node)
-  local next_node = utils.get_parent_of_group(node)
-  local nodes = {}
-  while next_node do
-    table.insert(nodes, next_node)
-    next_node = next_node.group_next
-  end
-  return nodes
-end
-
--- Toggle group empty folders
----@param head_node Node
-local function toggle_group_folders(head_node)
-  local is_grouped = head_node.group_next ~= nil
-
-  if is_grouped then
-    M.ungroup_empty_folders(head_node)
-  else
-    M.group_empty_folders(head_node)
-  end
-end
-
----@param node Node
-function M.expand_or_collapse(node, toggle_group)
-  toggle_group = toggle_group or false
-  if node.has_children then
-    node.has_children = false
-  end
-
-  if #node.nodes == 0 then
-    core.get_explorer():expand(node)
-  end
-
-  local head_node = utils.get_parent_of_group(node)
-  if toggle_group then
-    toggle_group_folders(head_node)
-  end
-
-  local open = M.get_last_group_node(node).open
-  local next_open
-  if toggle_group then
-    next_open = open
-  else
-    next_open = not open
-  end
-  for _, n in ipairs(M.get_all_nodes_in_group(head_node)) do
-    n.open = next_open
-  end
-
-  renderer.draw()
-end
-
 function M.set_target_win()
   local id = vim.api.nvim_get_current_win()
   local tree_id = view.get_winnr()
@@ -200,7 +34,11 @@ local function open_view_and_draw()
   local cwd = vim.fn.getcwd()
   view.open()
   handle_buf_cwd(cwd)
-  renderer.draw()
+
+  local explorer = core.get_explorer()
+  if explorer then
+    explorer.renderer:draw()
+  end
 end
 
 local function should_hijack_current_buf()
@@ -208,7 +46,7 @@ local function should_hijack_current_buf()
   local bufname = vim.api.nvim_buf_get_name(bufnr)
 
   local bufmodified, ft
-  if vim.fn.has "nvim-0.10" == 1 then
+  if vim.fn.has("nvim-0.10") == 1 then
     bufmodified = vim.api.nvim_get_option_value("modified", { buf = bufnr })
     ft = vim.api.nvim_get_option_value("ft", { buf = bufnr })
   else
@@ -227,7 +65,7 @@ end
 ---@param items_short string[]
 ---@param items_long string[]
 ---@param kind string|nil
----@param callback fun(item_short: string)
+---@param callback fun(item_short: string|nil)
 function M.prompt(prompt_input, prompt_select, items_short, items_long, kind, callback)
   local function format_item(short)
     for i, s in ipairs(items_short) do
@@ -269,16 +107,25 @@ function M.open(opts)
       core.init(cwd)
     end
   end
+
+  local explorer = core.get_explorer()
+
   if should_hijack_current_buf() then
     view.close_this_tab_only()
     view.open_in_win()
-    renderer.draw()
+    if explorer then
+      explorer.renderer:draw()
+    end
   elseif opts.winid then
-    view.open_in_win { hijack_current_buf = false, resize = false, winid = opts.winid }
+    view.open_in_win({ hijack_current_buf = false, resize = false, winid = opts.winid })
-    renderer.draw()
+    if explorer then
+      explorer.renderer:draw()
+    end
   elseif opts.current_window then
-    view.open_in_win { hijack_current_buf = false, resize = false }
+    view.open_in_win({ hijack_current_buf = false, resize = false })
-    renderer.draw()
+    if explorer then
+      explorer.renderer:draw()
+    end
   else
     open_view_and_draw()
   end

lua/nvim-tree/log.lua

@@ -1,7 +1,12 @@
-local M = {
+---@alias LogTypes "all" | "config" | "copy_paste" | "dev" | "diagnostics" | "git" | "profile" | "watcher"
-  config = nil,
+
-  path = nil,
+---@type table<LogTypes, boolean>
-}
+local types = {}
+
+---@type string
+local file_path
+
+local M = {}
 
 --- Write to log file
 ---@param typ string as per log.types config
@@ -13,7 +18,26 @@ function M.raw(typ, fmt, ...)
   end
 
   local line = string.format(fmt, ...)
-  local file = io.open(M.path, "a")
+  local file = io.open(file_path, "a")
+  if file then
+    io.output(file)
+    io.write(line)
+    io.close(file)
+  end
+end
+
+--- Write to a new file
+---@param typ LogTypes as per log.types config
+---@param path string absolute path
+---@param fmt string for string.format
+---@param ... any arguments for string.format
+function M.file(typ, path, fmt, ...)
+  if not M.enabled(typ) then
+    return
+  end
+
+  local line = string.format(fmt, ...)
+  local file = io.open(path, "w")
   if file then
     io.output(file)
     io.write(line)
@@ -32,7 +56,7 @@ end
 ---@return Profile to pass to profile_end
 function M.profile_start(fmt, ...)
   local profile = {}
-  if M.enabled "profile" then
+  if M.enabled("profile") then
     profile.start = vim.loop.hrtime()
     profile.tag = string.format((fmt or "???"), ...)
     M.line("profile", "START %s", profile.tag)
@@ -44,7 +68,7 @@ end
 --- END is prefixed and duration in seconds is suffixed
 ---@param profile Profile returned from profile_start
 function M.profile_end(profile)
-  if M.enabled "profile" and type(profile) == "table" then
+  if M.enabled("profile") and type(profile) == "table" then
     local millis = profile.start and math.modf((vim.loop.hrtime() - profile.start) / 1000000) or -1
     M.line("profile", "END   %s %dms", profile.tag or "", millis)
   end
@@ -52,12 +76,12 @@ end
 
 --- Write to log file
 --- time and typ are prefixed and a trailing newline is added
----@param typ string as per log.types config
+---@param typ LogTypes as per log.types config
 ---@param fmt string for string.format
 ---@param ... any arguments for string.format
 function M.line(typ, fmt, ...)
   if M.enabled(typ) then
-    M.raw(typ, string.format("[%s] [%s] %s\n", os.date "%Y-%m-%d %H:%M:%S", typ, (fmt or "???")), ...)
+    M.raw(typ, string.format("[%s] [%s] %s\n", os.date("%Y-%m-%d %H:%M:%S"), typ, (fmt or "???")), ...)
   end
 end
 
@@ -69,33 +93,31 @@ function M.set_inspect_opts(opts)
 end
 
 --- Write to log file the inspection of a node
---- defaults to the node under cursor if none is provided
+---@param typ LogTypes as per log.types config
----@param typ string as per log.types config
+---@param node Node node to be inspected
----@param node table|nil node to be inspected
 ---@param fmt string for string.format
----@vararg any arguments for string.format
+---@param ... any arguments for string.format
 function M.node(typ, node, fmt, ...)
   if M.enabled(typ) then
-    node = node or require("nvim-tree.lib").get_node_at_cursor()
+    M.raw(typ, string.format("[%s] [%s] %s\n%s\n", os.date("%Y-%m-%d %H:%M:%S"), typ, (fmt or "???"), vim.inspect(node, inspect_opts)), ...)
-    M.raw(typ, string.format("[%s] [%s] %s\n%s\n", os.date "%Y-%m-%d %H:%M:%S", typ, (fmt or "???"), vim.inspect(node, inspect_opts)), ...)
   end
 end
 
 --- Logging is enabled for typ or all
----@param typ string as per log.types config
+---@param typ LogTypes as per log.types config
 ---@return boolean
 function M.enabled(typ)
-  return M.path ~= nil and (M.config.types[typ] or M.config.types.all)
+  return file_path ~= nil and (types[typ] or types.all)
 end
 
 function M.setup(opts)
-  M.config = opts.log
+  if opts.log and opts.log.enable and opts.log.types then
-  if M.config and M.config.enable and M.config.types then
+    types = opts.log.types
-    M.path = string.format("%s/nvim-tree.log", vim.fn.stdpath "log", os.date "%H:%M:%S", vim.env.USER)
+    file_path = string.format("%s/nvim-tree.log", vim.fn.stdpath("log"), os.date("%H:%M:%S"), vim.env.USER)
-    if M.config.truncate then
+    if opts.log.truncate then
-      os.remove(M.path)
+      os.remove(file_path)
     end
-    require("nvim-tree.notify").debug("nvim-tree.lua logging to " .. M.path)
+    require("nvim-tree.notify").debug("nvim-tree.lua logging to " .. file_path)
   end
 end
 

lua/nvim-tree/marks/init.lua

@@ -1,44 +1,41 @@
-local Iterator = require "nvim-tree.iterators.node-iterator"
+local Iterator = require("nvim-tree.iterators.node-iterator")
-local core = require "nvim-tree.core"
+local core = require("nvim-tree.core")
-local lib = require "nvim-tree.lib"
+local lib = require("nvim-tree.lib")
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
-local open_file = require "nvim-tree.actions.node.open-file"
+local open_file = require("nvim-tree.actions.node.open-file")
-local remove_file = require "nvim-tree.actions.fs.remove-file"
+local remove_file = require("nvim-tree.actions.fs.remove-file")
-local rename_file = require "nvim-tree.actions.fs.rename-file"
+local rename_file = require("nvim-tree.actions.fs.rename-file")
-local renderer = require "nvim-tree.renderer"
+local trash = require("nvim-tree.actions.fs.trash")
-local trash = require "nvim-tree.actions.fs.trash"
+local utils = require("nvim-tree.utils")
-local utils = require "nvim-tree.utils"
 
----@class Marks
+local Class = require("nvim-tree.classic")
----@field config table hydrated user opts.filters
+local DirectoryNode = require("nvim-tree.node.directory")
+
+---@class (exact) Marks: Class
 ---@field private explorer Explorer
 ---@field private marks table<string, Node> by absolute path
-local Marks = {}
+local Marks = Class:extend()
 
----@return Marks
+---@class Marks
----@param opts table user options
+---@overload fun(args: MarksArgs): Marks
----@param explorer Explorer
-function Marks:new(opts, explorer)
-  local o = {
-    explorer = explorer,
-    config = {
-      ui = opts.ui,
-      filesystem_watchers = opts.filesystem_watchers,
-    },
-    marks = {},
-  }
 
-  setmetatable(o, self)
+---@class (exact) MarksArgs
-  self.__index = self
+---@field explorer Explorer
-  return o
+
+---@protected
+---@param args MarksArgs
+function Marks:new(args)
+  self.explorer = args.explorer
+
+  self.marks = {}
 end
 
 ---Clear all marks and reload if watchers disabled
 ---@private
 function Marks:clear_reload()
   self:clear()
-  if not self.config.filesystem_watchers.enable then
+  if not self.explorer.opts.filesystem_watchers.enable then
-    require("nvim-tree.actions.reloaders").reload_explorer()
+    self.explorer:reload_explorer()
   end
 end
 
@@ -46,7 +43,7 @@ end
 ---@public
 function Marks:clear()
   self.marks = {}
-  renderer.draw()
+  self.explorer.renderer:draw()
 end
 
 ---@public
@@ -62,7 +59,7 @@ function Marks:toggle(node)
     self.marks[node.absolute_path] = node
   end
 
-  renderer.draw()
+  self.explorer.renderer:draw()
 end
 
 ---Return node if marked
@@ -88,7 +85,7 @@ end
 ---@public
 function Marks:bulk_delete()
   if not next(self.marks) then
-    notify.warn "No bookmarks to delete."
+    notify.warn("No bookmarks to delete.")
     return
   end
 
@@ -99,7 +96,7 @@ function Marks:bulk_delete()
     self:clear_reload()
   end
 
-  if self.config.ui.confirm.remove then
+  if self.explorer.opts.ui.confirm.remove then
     local prompt_select = "Remove bookmarked ?"
     local prompt_input = prompt_select .. " y/N: "
     lib.prompt(prompt_input, prompt_select, { "", "y" }, { "No", "Yes" }, "nvimtree_bulk_delete", function(item_short)
@@ -117,7 +114,7 @@ end
 ---@public
 function Marks:bulk_trash()
   if not next(self.marks) then
-    notify.warn "No bookmarks to trash."
+    notify.warn("No bookmarks to trash.")
     return
   end
 
@@ -128,7 +125,7 @@ function Marks:bulk_trash()
     self:clear_reload()
   end
 
-  if self.config.ui.confirm.trash then
+  if self.explorer.opts.ui.confirm.trash then
     local prompt_select = "Trash bookmarked ?"
     local prompt_input = prompt_select .. " y/N: "
     lib.prompt(prompt_input, prompt_select, { "", "y" }, { "No", "Yes" }, "nvimtree_bulk_trash", function(item_short)
@@ -146,14 +143,14 @@ end
 ---@public
 function Marks:bulk_move()
   if not next(self.marks) then
-    notify.warn "No bookmarks to move."
+    notify.warn("No bookmarks to move.")
     return
   end
 
-  local node_at_cursor = lib.get_node_at_cursor()
+  local node_at_cursor = self.explorer:get_node_at_cursor()
   local default_path = core.get_cwd()
 
-  if node_at_cursor and node_at_cursor.type == "directory" then
+  if node_at_cursor and node_at_cursor:is(DirectoryNode) then
     default_path = node_at_cursor.absolute_path
   elseif node_at_cursor and node_at_cursor.parent then
     default_path = node_at_cursor.parent.absolute_path
@@ -177,7 +174,7 @@ function Marks:bulk_move()
 
     for _, node in pairs(self.marks) do
       local head = vim.fn.fnamemodify(node.absolute_path, ":t")
-      local to = utils.path_join { location, head }
+      local to = utils.path_join({ location, head })
       rename_file.rename(node, to)
     end
 
@@ -189,7 +186,7 @@ end
 ---@private
 ---@param up boolean
 function Marks:navigate(up)
-  local node = lib.get_node_at_cursor()
+  local node = self.explorer:get_node_at_cursor()
   if not node then
     return
   end
@@ -199,7 +196,8 @@ function Marks:navigate(up)
 
   Iterator.builder(self.explorer.nodes)
     :recursor(function(n)
-      return n.open and n.nodes
+      local dir = n:as(DirectoryNode)
+      return dir and dir.open and dir.nodes
     end)
     :applier(function(n)
       if n.absolute_path == node.absolute_path then
@@ -262,7 +260,7 @@ function Marks:navigate_select()
       return
     end
     local node = self.marks[choice]
-    if node and not node.nodes and not utils.get_win_buf_from_path(node.absolute_path) then
+    if node and not node:is(DirectoryNode) and not utils.get_win_buf_from_path(node.absolute_path) then
       open_file.fn("edit", node.absolute_path)
     elseif node then
       utils.focus_file(node.absolute_path)

lua/nvim-tree/node.lua

@@ -1,36 +0,0 @@
----@meta
-
----@class ParentNode
----@field name string
-
----@class BaseNode
----@field absolute_path string
----@field executable boolean
----@field fs_stat uv.fs_stat.result|nil
----@field git_status GitStatus|nil
----@field hidden boolean
----@field is_dot boolean
----@field name string
----@field parent DirNode
----@field type string
----@field watcher function|nil
----@field diag_status DiagStatus|nil
-
----@class DirNode: BaseNode
----@field has_children boolean
----@field group_next Node|nil
----@field nodes Node[]
----@field open boolean
----@field hidden_stats table -- Each field of this table is a key for source and value for count
-
----@class FileNode: BaseNode
----@field extension string
-
----@class SymlinkDirNode: DirNode
----@field link_to string
-
----@class SymlinkFileNode: FileNode
----@field link_to string
-
----@alias SymlinkNode SymlinkDirNode|SymlinkFileNode
----@alias Node ParentNode|DirNode|FileNode|SymlinkNode|Explorer

lua/nvim-tree/node/directory-link.lua

@@ -0,0 +1,86 @@
+local git_utils = require("nvim-tree.git.utils")
+local utils = require("nvim-tree.utils")
+
+local DirectoryNode = require("nvim-tree.node.directory")
+local LinkNode = require("nvim-tree.node.link")
+
+---@class (exact) DirectoryLinkNode: DirectoryNode, LinkNode
+local DirectoryLinkNode = DirectoryNode:extend()
+DirectoryLinkNode:implement(LinkNode)
+
+---@class DirectoryLinkNode
+---@overload fun(args: LinkNodeArgs): DirectoryLinkNode
+
+---@protected
+---@param args LinkNodeArgs
+function DirectoryLinkNode:new(args)
+  LinkNode.new(self, args)
+
+  -- create DirectoryNode with watcher on link_to
+  local absolute_path = args.absolute_path
+  args.absolute_path = args.link_to
+  DirectoryLinkNode.super.new(self, args)
+
+  self.type          = "link"
+
+  -- reset absolute path to the link itself
+  self.absolute_path = absolute_path
+end
+
+function DirectoryLinkNode:destroy()
+  DirectoryNode.destroy(self)
+end
+
+---Update the directory git_status of link target and the file status of the link itself
+---@param parent_ignored boolean
+---@param project GitProject?
+function DirectoryLinkNode:update_git_status(parent_ignored, project)
+  self.git_status = git_utils.git_status_dir(parent_ignored, project, self.link_to, self.absolute_path)
+end
+
+---@return HighlightedString name
+function DirectoryLinkNode:highlighted_icon()
+  if not self.explorer.opts.renderer.icons.show.folder then
+    return self:highlighted_icon_empty()
+  end
+
+  local str, hl
+
+  if self.open then
+    str = self.explorer.opts.renderer.icons.glyphs.folder.symlink_open
+    hl  = "NvimTreeOpenedFolderIcon"
+  else
+    str = self.explorer.opts.renderer.icons.glyphs.folder.symlink
+    hl  = "NvimTreeClosedFolderIcon"
+  end
+
+  return { str = str, hl = { hl } }
+end
+
+---Maybe override name with arrow
+---@return HighlightedString name
+function DirectoryLinkNode:highlighted_name()
+  local name = DirectoryNode.highlighted_name(self)
+
+  if self.explorer.opts.renderer.symlink_destination then
+    local link_to = utils.path_relative(self.link_to, self.explorer.absolute_path)
+
+    name.str      = string.format("%s%s%s", name.str, self.explorer.opts.renderer.icons.symlink_arrow, link_to)
+    name.hl       = { "NvimTreeSymlinkFolderName" }
+  end
+
+  return name
+end
+
+---Create a sanitized partial copy of a node, populating children recursively.
+---@return DirectoryLinkNode cloned
+function DirectoryLinkNode:clone()
+  local clone = DirectoryNode.clone(self) --[[@as DirectoryLinkNode]]
+
+  clone.link_to = self.link_to
+  clone.fs_stat_target = self.fs_stat_target
+
+  return clone
+end
+
+return DirectoryLinkNode

lua/nvim-tree/node/directory.lua

@@ -0,0 +1,291 @@
+local git_utils = require("nvim-tree.git.utils")
+local icons = require("nvim-tree.renderer.components.devicons")
+local notify = require("nvim-tree.notify")
+
+local Node = require("nvim-tree.node")
+
+---@class (exact) DirectoryNode: Node
+---@field has_children boolean
+---@field group_next DirectoryNode? -- If node is grouped, this points to the next child dir/link node
+---@field nodes Node[]
+---@field open boolean
+---@field hidden_stats table? -- Each field of this table is a key for source and value for count
+---@field private watcher Watcher?
+local DirectoryNode = Node:extend()
+
+---@class DirectoryNode
+---@overload fun(args: NodeArgs): DirectoryNode
+
+---@protected
+---@param args NodeArgs
+function DirectoryNode:new(args)
+  DirectoryNode.super.new(self, args)
+
+  local handle       = vim.loop.fs_scandir(args.absolute_path)
+  local has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil or false
+
+  self.type          = "directory"
+
+  self.has_children  = has_children
+  self.group_next    = nil
+  self.nodes         = {}
+  self.open          = false
+  self.hidden_stats  = nil
+
+  self.watcher       = require("nvim-tree.explorer.watch").create_watcher(self)
+end
+
+function DirectoryNode:destroy()
+  if self.watcher then
+    self.watcher:destroy()
+    self.watcher = nil
+  end
+
+  if self.nodes then
+    for _, node in pairs(self.nodes) do
+      node:destroy()
+    end
+  end
+
+  Node.destroy(self)
+end
+
+---Update the git_status of the directory
+---@param parent_ignored boolean
+---@param project GitProject?
+function DirectoryNode:update_git_status(parent_ignored, project)
+  self.git_status = git_utils.git_status_dir(parent_ignored, project, self.absolute_path, nil)
+end
+
+---@return GitXY[]?
+function DirectoryNode:get_git_xy()
+  if not self.git_status or not self.explorer.opts.git.show_on_dirs then
+    return nil
+  end
+
+  local xys = {}
+  if not self:last_group_node().open or self.explorer.opts.git.show_on_open_dirs then
+    -- dir is closed or we should show on open_dirs
+    if self.git_status.file ~= nil then
+      table.insert(xys, self.git_status.file)
+    end
+    if self.git_status.dir ~= nil then
+      if self.git_status.dir.direct ~= nil then
+        for _, s in pairs(self.git_status.dir.direct) do
+          table.insert(xys, s)
+        end
+      end
+      if self.git_status.dir.indirect ~= nil then
+        for _, s in pairs(self.git_status.dir.indirect) do
+          table.insert(xys, s)
+        end
+      end
+    end
+  else
+    -- dir is open and we shouldn't show on open_dirs
+    if self.git_status.file ~= nil then
+      table.insert(xys, self.git_status.file)
+    end
+    if self.git_status.dir ~= nil and self.git_status.dir.direct ~= nil then
+      local deleted = {
+        [" D"] = true,
+        ["D "] = true,
+        ["RD"] = true,
+        ["DD"] = true,
+      }
+      for _, s in pairs(self.git_status.dir.direct) do
+        if deleted[s] then
+          table.insert(xys, s)
+        end
+      end
+    end
+  end
+  if #xys == 0 then
+    return nil
+  else
+    return xys
+  end
+end
+
+-- If node is grouped, return the last node in the group. Otherwise, return the given node.
+---@return DirectoryNode
+function DirectoryNode:last_group_node()
+  return self.group_next and self.group_next:last_group_node() or self
+end
+
+---Return the one and only one child directory
+---@return DirectoryNode?
+function DirectoryNode:single_child_directory()
+  if #self.nodes == 1 then
+    return self.nodes[1]:as(DirectoryNode)
+  end
+end
+
+---@private
+-- Toggle group empty folders
+function DirectoryNode:toggle_group_folders()
+  local is_grouped = self.group_next ~= nil
+
+  if is_grouped then
+    self:ungroup_empty_folders()
+  else
+    self:group_empty_folders()
+  end
+end
+
+---Group empty folders
+-- Recursively group nodes
+---@private
+---@return Node[]
+function DirectoryNode:group_empty_folders()
+  local single_child = self:single_child_directory()
+  if self.explorer.opts.renderer.group_empty and self.parent and single_child then
+    self.group_next = single_child
+    local ns = single_child:group_empty_folders()
+    self.nodes = ns or {}
+    return ns
+  end
+  return self.nodes
+end
+
+---Ungroup empty folders
+-- If a node is grouped, ungroup it: put node.group_next to the node.nodes and set node.group_next to nil
+---@private
+function DirectoryNode:ungroup_empty_folders()
+  if self.group_next then
+    self.group_next:ungroup_empty_folders()
+    self.nodes = { self.group_next }
+    self.group_next = nil
+  end
+end
+
+---@param toggle_group boolean?
+function DirectoryNode:expand_or_collapse(toggle_group)
+  toggle_group = toggle_group or false
+  if self.has_children then
+    self.has_children = false
+  end
+
+  if #self.nodes == 0 then
+    self.explorer:expand(self)
+  end
+
+  local head_node = self:get_parent_of_group() or self
+  if toggle_group then
+    head_node:toggle_group_folders()
+  end
+
+  local open = self:last_group_node().open
+  local next_open
+  if toggle_group then
+    next_open = open
+  else
+    next_open = not open
+  end
+
+  local node = head_node
+  while node do
+    node.open = next_open
+    node = node.group_next
+  end
+
+  self.explorer.renderer:draw()
+end
+
+---@return HighlightedString icon
+function DirectoryNode:highlighted_icon()
+  if not self.explorer.opts.renderer.icons.show.folder then
+    return self:highlighted_icon_empty()
+  end
+
+  local str, hl
+
+  -- devicon if enabled and available
+  if self.explorer.opts.renderer.icons.web_devicons.folder.enable then
+    str, hl = icons.get_icon(self.name)
+    if not self.explorer.opts.renderer.icons.web_devicons.folder.color then
+      hl = nil
+    end
+  end
+
+  -- default icon from opts
+  if not str then
+    if #self.nodes ~= 0 or self.has_children then
+      if self.open then
+        str = self.explorer.opts.renderer.icons.glyphs.folder.open
+      else
+        str = self.explorer.opts.renderer.icons.glyphs.folder.default
+      end
+    else
+      if self.open then
+        str = self.explorer.opts.renderer.icons.glyphs.folder.empty_open
+      else
+        str = self.explorer.opts.renderer.icons.glyphs.folder.empty
+      end
+    end
+  end
+
+  -- default hl
+  if not hl then
+    if self.open then
+      hl = "NvimTreeOpenedFolderIcon"
+    else
+      hl = "NvimTreeClosedFolderIcon"
+    end
+  end
+
+  return { str = str, hl = { hl } }
+end
+
+---@return HighlightedString icon
+function DirectoryNode:highlighted_name()
+  local str, hl
+
+  local name = self.name
+  local next = self.group_next
+  while next do
+    name = string.format("%s/%s", name, next.name)
+    next = next.group_next
+  end
+
+  if self.group_next and type(self.explorer.opts.renderer.group_empty) == "function" then
+    local new_name = self.explorer.opts.renderer.group_empty(name)
+    if type(new_name) == "string" then
+      name = new_name
+    else
+      notify.warn(string.format("Invalid return type for field renderer.group_empty. Expected string, got %s", type(new_name)))
+    end
+  end
+  str = string.format("%s%s", name, self.explorer.opts.renderer.add_trailing and "/" or "")
+
+  hl = "NvimTreeFolderName"
+  if vim.tbl_contains(self.explorer.opts.renderer.special_files, self.absolute_path) or vim.tbl_contains(self.explorer.opts.renderer.special_files, self.name) then
+    hl = "NvimTreeSpecialFolderName"
+  elseif self.open then
+    hl = "NvimTreeOpenedFolderName"
+  elseif #self.nodes == 0 and not self.has_children then
+    hl = "NvimTreeEmptyFolderName"
+  end
+
+  return { str = str, hl = { hl } }
+end
+
+---Create a sanitized partial copy of a node, populating children recursively.
+---@return DirectoryNode cloned
+function DirectoryNode:clone()
+  local clone        = Node.clone(self) --[[@as DirectoryNode]]
+
+  clone.has_children = self.has_children
+  clone.group_next   = nil
+  clone.nodes        = {}
+  clone.open         = self.open
+  clone.hidden_stats = nil
+
+  for _, child in ipairs(self.nodes) do
+    table.insert(clone.nodes, child:clone())
+  end
+
+  return clone
+end
+
+return DirectoryNode

lua/nvim-tree/node/factory.lua

@@ -0,0 +1,48 @@
+local DirectoryLinkNode = require("nvim-tree.node.directory-link")
+local DirectoryNode = require("nvim-tree.node.directory")
+local FileLinkNode = require("nvim-tree.node.file-link")
+local FileNode = require("nvim-tree.node.file")
+local Watcher = require("nvim-tree.watcher")
+
+local M = {}
+
+---Factory function to create the appropriate Node
+---nil on invalid stat or invalid link target stat
+---@param args NodeArgs
+---@return Node?
+function M.create(args)
+  if not args.fs_stat then
+    return nil
+  end
+
+  if args.fs_stat.type == "directory" then
+    -- directory must be readable and enumerable
+    if vim.loop.fs_access(args.absolute_path, "R") and Watcher.is_fs_event_capable(args.absolute_path) then
+      return DirectoryNode(args)
+    end
+  elseif args.fs_stat.type == "file" then
+    return FileNode(args)
+  elseif args.fs_stat.type == "link" then
+    -- link target path and stat must resolve
+    local link_to = vim.loop.fs_realpath(args.absolute_path)
+    local link_to_stat = link_to and vim.loop.fs_stat(link_to)
+    if not link_to or not link_to_stat then
+      return
+    end
+
+    ---@cast args LinkNodeArgs
+    args.link_to        = link_to
+    args.fs_stat_target = link_to_stat
+
+    -- choose directory or file
+    if link_to_stat.type == "directory" then
+      return DirectoryLinkNode(args)
+    else
+      return FileLinkNode(args)
+    end
+  end
+
+  return nil
+end
+
+return M

lua/nvim-tree/node/file-link.lua

@@ -0,0 +1,71 @@
+local git_utils = require("nvim-tree.git.utils")
+local utils = require("nvim-tree.utils")
+
+local FileNode = require("nvim-tree.node.file")
+local LinkNode = require("nvim-tree.node.link")
+
+---@class (exact) FileLinkNode: FileNode, LinkNode
+local FileLinkNode = FileNode:extend()
+FileLinkNode:implement(LinkNode)
+
+---@class FileLinkNode
+---@overload fun(args: LinkNodeArgs): FileLinkNode
+
+---@protected
+---@param args LinkNodeArgs
+function FileLinkNode:new(args)
+  LinkNode.new(self, args)
+  FileLinkNode.super.new(self, args)
+
+  self.type = "link"
+end
+
+function FileLinkNode:destroy()
+  FileNode.destroy(self)
+end
+
+---Update the git_status of the target otherwise the link itself
+---@param parent_ignored boolean
+---@param project GitProject?
+function FileLinkNode:update_git_status(parent_ignored, project)
+  self.git_status = git_utils.git_status_file(parent_ignored, project, self.link_to, self.absolute_path)
+end
+
+---@return HighlightedString icon
+function FileLinkNode:highlighted_icon()
+  if not self.explorer.opts.renderer.icons.show.file then
+    return self:highlighted_icon_empty()
+  end
+
+  local str, hl
+
+  -- default icon from opts
+  str = self.explorer.opts.renderer.icons.glyphs.symlink
+  hl = "NvimTreeSymlinkIcon"
+
+  return { str = str, hl = { hl } }
+end
+
+---@return HighlightedString name
+function FileLinkNode:highlighted_name()
+  local str = self.name
+  if self.explorer.opts.renderer.symlink_destination then
+    local link_to = utils.path_relative(self.link_to, self.explorer.absolute_path)
+    str = string.format("%s%s%s", str, self.explorer.opts.renderer.icons.symlink_arrow, link_to)
+  end
+
+  return { str = str, hl = { "NvimTreeSymlink" } }
+end
+
+---Create a sanitized partial copy of a node
+---@return FileLinkNode cloned
+function FileLinkNode:clone()
+  local clone = FileNode.clone(self) --[[@as FileLinkNode]]
+
+  clone.link_to = self.link_to
+  clone.fs_stat_target = self.fs_stat_target
+
+  return clone
+end
+
+return FileLinkNode

lua/nvim-tree/node/file.lua

@@ -0,0 +1,106 @@
+local git_utils = require("nvim-tree.git.utils")
+local icons = require("nvim-tree.renderer.components.devicons")
+local utils = require("nvim-tree.utils")
+
+local Node = require("nvim-tree.node")
+
+local PICTURE_MAP = {
+  jpg = true,
+  jpeg = true,
+  png = true,
+  gif = true,
+  webp = true,
+  jxl = true,
+}
+
+---@class (exact) FileNode: Node
+---@field extension string
+local FileNode = Node:extend()
+
+---@class FileNode
+---@overload fun(args: NodeArgs): FileNode
+
+---@protected
+---@param args NodeArgs
+function FileNode:new(args)
+  FileNode.super.new(self, args)
+
+  self.type       = "file"
+  self.extension  = string.match(args.name, ".?[^.]+%.(.*)") or ""
+  self.executable = utils.is_executable(args.absolute_path)
+end
+
+function FileNode:destroy()
+  Node.destroy(self)
+end
+
+---Update the GitStatus of the file
+---@param parent_ignored boolean
+---@param project GitProject?
+function FileNode:update_git_status(parent_ignored, project)
+  self.git_status = git_utils.git_status_file(parent_ignored, project, self.absolute_path, nil)
+end
+
+---@return GitXY[]?
+function FileNode:get_git_xy()
+  if not self.git_status then
+    return nil
+  end
+
+  return self.git_status.file and { self.git_status.file }
+end
+
+---@return HighlightedString icon
+function FileNode:highlighted_icon()
+  if not self.explorer.opts.renderer.icons.show.file then
+    return self:highlighted_icon_empty()
+  end
+
+  local str, hl
+
+  -- devicon if enabled and available, fallback to default
+  if self.explorer.opts.renderer.icons.web_devicons.file.enable then
+    str, hl = icons.get_icon(self.name, nil, { default = true })
+    if not self.explorer.opts.renderer.icons.web_devicons.file.color then
+      hl = nil
+    end
+  end
+
+  -- default icon from opts
+  if not str then
+    str = self.explorer.opts.renderer.icons.glyphs.default
+  end
+
+  -- default hl
+  if not hl then
+    hl = "NvimTreeFileIcon"
+  end
+
+  return { str = str, hl = { hl } }
+end
+
+---@return HighlightedString name
+function FileNode:highlighted_name()
+  local hl
+  if vim.tbl_contains(self.explorer.opts.renderer.special_files, self.absolute_path) or vim.tbl_contains(self.explorer.opts.renderer.special_files, self.name) then
+    hl = "NvimTreeSpecialFile"
+  elseif self.executable then
+    hl = "NvimTreeExecFile"
+  elseif PICTURE_MAP[self.extension] then
+    hl = "NvimTreeImageFile"
+  end
+
+  return { str = self.name, hl = { hl } }
+end
+
+---Create a sanitized partial copy of a node
+---@return FileNode cloned
+function FileNode:clone()
+  local clone = Node.clone(self) --[[@as FileNode]]
+
+  clone.extension = self.extension
+
+  return clone
+end
+
+return FileNode

lua/nvim-tree/node/init.lua

@@ -0,0 +1,144 @@
+local Class = require("nvim-tree.classic")
+
+---Abstract Node class.
+---@class (exact) Node: Class
+---@field type "file" | "directory" | "link" uv.fs_stat.result.type
+---@field explorer Explorer
+---@field absolute_path string
+---@field executable boolean
+---@field fs_stat uv.fs_stat.result?
+---@field git_status GitNodeStatus?
+---@field hidden boolean
+---@field name string
+---@field parent DirectoryNode?
+---@field diag_status DiagStatus?
+---@field private is_dot boolean cached is_dotfile
+local Node = Class:extend()
+
+---@class (exact) NodeArgs
+---@field explorer Explorer
+---@field parent DirectoryNode?
+---@field absolute_path string
+---@field name string
+---@field fs_stat uv.fs_stat.result?
+
+---@protected
+---@param args NodeArgs
+function Node:new(args)
+  self.explorer      = args.explorer
+  self.absolute_path = args.absolute_path
+  self.executable    = false
+  self.fs_stat       = args.fs_stat
+  self.git_status    = nil
+  self.hidden        = false
+  self.name          = args.name
+  self.parent        = args.parent
+  self.diag_status   = nil
+  self.is_dot        = false
+end
+
+function Node:destroy()
+end
+
+---Update the git_status of the node
+---Abstract
+---@param parent_ignored boolean
+---@param project GitProject?
+function Node:update_git_status(parent_ignored, project)
+  self:nop(parent_ignored, project)
+end
+
+---Short-format statuses
+---@return GitXY[]?
+function Node:get_git_xy()
+end
+
+---@return boolean
+function Node:is_git_ignored()
+  return self.git_status ~= nil and self.git_status.file == "!!"
+end
+
+---Node or one of its parents begins with a dot
+---@return boolean
+function Node:is_dotfile()
+  if
+    self.is_dot
+    or (self.name and (self.name:sub(1, 1) == "."))
+    or (self.parent and self.parent:is_dotfile())
+  then
+    self.is_dot = true
+    return true
+  end
+  return false
+end
+
+---Get the highest parent of grouped nodes, nil when not grouped
+---@return DirectoryNode?
+function Node:get_parent_of_group()
+  if not self.parent or not self.parent.group_next then
+    return nil
+  end
+
+  local node = self.parent
+  while node do
+    if node.parent and node.parent.group_next then
+      node = node.parent
+    else
+      return node
+    end
+  end
+end
+
+---Empty highlighted icon
+---@protected
+---@return HighlightedString icon
+function Node:highlighted_icon_empty()
+  return { str = "", hl = {} }
+end
+
+---Highlighted icon for the node
+---Empty for base Node
+---@return HighlightedString icon
+function Node:highlighted_icon()
+  return self:highlighted_icon_empty()
+end
+
+---Empty highlighted name
+---@protected
+---@return HighlightedString name
+function Node:highlighted_name_empty()
+  return { str = "", hl = {} }
+end
+
+---Highlighted name for the node
+---Empty for base Node
+---@return HighlightedString icon
+function Node:highlighted_name()
+  return self:highlighted_name_empty()
+end
+
+---Create a sanitized partial copy of a node, populating children recursively.
+---@return Node cloned
+function Node:clone()
+  ---@type Explorer
+  local explorer_placeholder = nil
+
+  ---@type Node
+  local clone = {
+    type          = self.type,
+    explorer      = explorer_placeholder,
+    absolute_path = self.absolute_path,
+    executable    = self.executable,
+    fs_stat       = self.fs_stat,
+    git_status    = self.git_status,
+    hidden        = self.hidden,
+    name          = self.name,
+    parent        = nil,
+    diag_status   = nil,
+    is_dot        = self.is_dot,
+  }
+
+  return clone
+end
+
+return Node

lua/nvim-tree/node/link.lua

@@ -0,0 +1,19 @@
+local Class = require("nvim-tree.classic")
+
+---@class (exact) LinkNode: Class
+---@field link_to string
+---@field protected fs_stat_target uv.fs_stat.result
+local LinkNode = Class:extend()
+
+---@class (exact) LinkNodeArgs: NodeArgs
+---@field link_to string
+---@field fs_stat_target uv.fs_stat.result
+
+---@protected
+---@param args LinkNodeArgs
+function LinkNode:new(args)
+  self.link_to = args.link_to
+  self.fs_stat_target = args.fs_stat_target
+end
+
+return LinkNode

lua/nvim-tree/node/root.lua

@@ -0,0 +1,25 @@
+local DirectoryNode = require("nvim-tree.node.directory")
+
+---@class (exact) RootNode: DirectoryNode
+local RootNode = DirectoryNode:extend()
+
+---@class RootNode
+---@overload fun(args: NodeArgs): RootNode
+
+---@protected
+---@param args NodeArgs
+function RootNode:new(args)
+  RootNode.super.new(self, args)
+end
+
+---Root is never a dotfile
+---@return boolean
+function RootNode:is_dotfile()
+  return false
+end
+
+function RootNode:destroy()
+  DirectoryNode.destroy(self)
+end
+
+return RootNode

lua/nvim-tree/notify.lua

@@ -9,9 +9,9 @@ local title_support
 ---@return boolean
 function M.supports_title()
   if title_support == nil then
-    title_support = (package.loaded.notify and (vim.notify == require "notify" or vim.notify == require("notify").notify))
+    title_support = (package.loaded.notify and (vim.notify == require("notify") or vim.notify == require("notify").notify))
       or (package.loaded.noice and (vim.notify == require("noice").notify or vim.notify == require("noice.source.notify").notify))
-      or (package.loaded.notifier and require("notifier.config").has_component "nvim")
+      or (package.loaded.notifier and require("notifier.config").has_component("nvim"))
       or false
   end
 
@@ -21,8 +21,8 @@ end
 local modes = {
   { name = "trace", level = vim.log.levels.TRACE },
   { name = "debug", level = vim.log.levels.DEBUG },
-  { name = "info", level = vim.log.levels.INFO },
+  { name = "info",  level = vim.log.levels.INFO },
-  { name = "warn", level = vim.log.levels.WARN },
+  { name = "warn",  level = vim.log.levels.WARN },
   { name = "error", level = vim.log.levels.ERROR },
 }
 
@@ -35,7 +35,7 @@ do
     vim.schedule(function()
       if not M.supports_title() then
         -- add title to the message, with a newline if the message is multiline
-        msg = string.format("[NvimTree]%s%s", (msg:match "\n" and "\n" or " "), msg)
+        msg = string.format("[NvimTree]%s%s", (msg:match("\n") and "\n" or " "), msg)
       end
 
       vim.notify(msg, level, { title = "NvimTree" })

lua/nvim-tree/renderer/builder.lua

@@ -1,74 +1,77 @@
-local core = require "nvim-tree.core"
+local notify = require("nvim-tree.notify")
-local notify = require "nvim-tree.notify"
+local utils = require("nvim-tree.utils")
-local utils = require "nvim-tree.utils"
+local view = require("nvim-tree.view")
-local view = require "nvim-tree.view"
 
-local DecoratorBookmarks = require "nvim-tree.renderer.decorator.bookmarks"
+local Class = require("nvim-tree.classic")
-local DecoratorCopied = require "nvim-tree.renderer.decorator.copied"
+local DirectoryNode = require("nvim-tree.node.directory")
-local DecoratorCut = require "nvim-tree.renderer.decorator.cut"
-local DecoratorDiagnostics = require "nvim-tree.renderer.decorator.diagnostics"
-local DecoratorGit = require "nvim-tree.renderer.decorator.git"
-local DecoratorModified = require "nvim-tree.renderer.decorator.modified"
-local DecoratorHidden = require "nvim-tree.renderer.decorator.hidden"
-local DecoratorOpened = require "nvim-tree.renderer.decorator.opened"
 
-local pad = require "nvim-tree.renderer.components.padding"
+local DecoratorBookmarks = require("nvim-tree.renderer.decorator.bookmarks")
-local icons = require "nvim-tree.renderer.components.icons"
+local DecoratorCopied = require("nvim-tree.renderer.decorator.copied")
+local DecoratorCut = require("nvim-tree.renderer.decorator.cut")
+local DecoratorDiagnostics = require("nvim-tree.renderer.decorator.diagnostics")
+local DecoratorGit = require("nvim-tree.renderer.decorator.git")
+local DecoratorModified = require("nvim-tree.renderer.decorator.modified")
+local DecoratorHidden = require("nvim-tree.renderer.decorator.hidden")
+local DecoratorOpened = require("nvim-tree.renderer.decorator.opened")
 
-local M = {
+local pad = require("nvim-tree.renderer.components.padding")
-  opts = {},
-  decorators = {},
-  picture_map = {
-    jpg = true,
-    jpeg = true,
-    png = true,
-    gif = true,
-    webp = true,
-    jxl = true,
-  },
-}
 
----@class HighlightedString
+---@class (exact) HighlightedString
 ---@field str string
 ---@field hl string[]
 
----@class AddHighlightArgs
+---@class (exact) AddHighlightArgs
 ---@field group string[]
 ---@field line number
 ---@field col_start number
 ---@field col_end number
 
----@class Builder
+---@class (exact) Builder
 ---@field lines string[] includes icons etc.
 ---@field hl_args AddHighlightArgs[] line highlights
 ---@field signs string[] line signs
 ---@field extmarks table[] extra marks for right icon placement
 ---@field virtual_lines table[] virtual lines for hidden count display
----@field private root_cwd string absolute path
+---@field private explorer Explorer
 ---@field private index number
 ---@field private depth number
 ---@field private combined_groups table<string, boolean> combined group names
 ---@field private markers boolean[] indent markers
-local Builder = {}
+---@field private decorators Decorator[]
+---@field private hidden_display fun(node: Node): string|nil
+local Builder = Class:extend()
 
----@return Builder
+---@class Builder
-function Builder:new()
+---@overload fun(args: BuilderArgs): Builder
-  local o = {
+
-    root_cwd = core.get_cwd(),
+---@class (exact) BuilderArgs
-    index = 0,
+---@field explorer Explorer
-    depth = 0,
+
-    hl_args = {},
+---@protected
-    combined_groups = {},
+---@param args BuilderArgs
-    lines = {},
+function Builder:new(args)
-    markers = {},
+  self.explorer        = args.explorer
-    signs = {},
+  self.index           = 0
-    extmarks = {},
+  self.depth           = 0
-    virtual_lines = {},
+  self.hl_args         = {}
+  self.combined_groups = {}
+  self.lines           = {}
+  self.markers         = {}
+  self.signs           = {}
+  self.extmarks        = {}
+  self.virtual_lines   = {}
+  self.decorators      = {
+    -- priority order
+    DecoratorCut({ explorer = args.explorer }),
+    DecoratorCopied({ explorer = args.explorer }),
+    DecoratorDiagnostics({ explorer = args.explorer }),
+    DecoratorBookmarks({ explorer = args.explorer }),
+    DecoratorModified({ explorer = args.explorer }),
+    DecoratorHidden({ explorer = args.explorer }),
+    DecoratorOpened({ explorer = args.explorer }),
+    DecoratorGit({ explorer = args.explorer })
   }
-  setmetatable(o, self)
+  self.hidden_display  = Builder:setup_hidden_display_function(self.explorer.opts)
-  self.__index = self
-
-  return o
 end
 
 ---Insert ranged highlight groups into self.highlights
@@ -80,27 +83,6 @@ function Builder:insert_highlight(groups, start, end_)
   table.insert(self.hl_args, { groups, self.index, start, end_ or -1 })
 end
 
----@private
-function Builder:get_folder_name(node)
-  local name = node.name
-  local next = node.group_next
-  while next do
-    name = string.format("%s/%s", name, next.name)
-    next = next.group_next
-  end
-
-  if node.group_next and type(M.opts.renderer.group_empty) == "function" then
-    local new_name = M.opts.renderer.group_empty(name)
-    if type(new_name) == "string" then
-      name = new_name
-    else
-      notify.warn(string.format("Invalid return type for field renderer.group_empty. Expected string, got %s", type(new_name)))
-    end
-  end
-
-  return string.format("%s%s", name, M.opts.renderer.add_trailing and "/" or "")
-end
-
 ---@private
 ---@param highlighted_strings HighlightedString[]
 ---@return string
@@ -121,76 +103,6 @@ function Builder:unwrap_highlighted_strings(highlighted_strings)
   return string
 end
 
----@private
----@param node table
----@return HighlightedString icon
----@return HighlightedString name
-function Builder:build_folder(node)
-  local has_children = #node.nodes ~= 0 or node.has_children
-  local icon, icon_hl = icons.get_folder_icon(node, has_children)
-  local foldername = self:get_folder_name(node)
-
-  if #icon > 0 and icon_hl == nil then
-    if node.open then
-      icon_hl = "NvimTreeOpenedFolderIcon"
-    else
-      icon_hl = "NvimTreeClosedFolderIcon"
-    end
-  end
-
-  local foldername_hl = "NvimTreeFolderName"
-  if node.link_to and M.opts.renderer.symlink_destination then
-    local arrow = icons.i.symlink_arrow
-    local link_to = utils.path_relative(node.link_to, self.root_cwd)
-    foldername = string.format("%s%s%s", foldername, arrow, link_to)
-    foldername_hl = "NvimTreeSymlinkFolderName"
-  elseif
-    vim.tbl_contains(M.opts.renderer.special_files, node.absolute_path) or vim.tbl_contains(M.opts.renderer.special_files, node.name)
-  then
-    foldername_hl = "NvimTreeSpecialFolderName"
-  elseif node.open then
-    foldername_hl = "NvimTreeOpenedFolderName"
-  elseif not has_children then
-    foldername_hl = "NvimTreeEmptyFolderName"
-  end
-
-  return { str = icon, hl = { icon_hl } }, { str = foldername, hl = { foldername_hl } }
-end
-
----@private
----@param node table
----@return HighlightedString icon
----@return HighlightedString name
-function Builder:build_symlink(node)
-  local icon = icons.i.symlink
-  local arrow = icons.i.symlink_arrow
-  local symlink_formatted = node.name
-  if M.opts.renderer.symlink_destination then
-    local link_to = utils.path_relative(node.link_to, self.root_cwd)
-    symlink_formatted = string.format("%s%s%s", symlink_formatted, arrow, link_to)
-  end
-
-  return { str = icon, hl = { "NvimTreeSymlinkIcon" } }, { str = symlink_formatted, hl = { "NvimTreeSymlink" } }
-end
-
----@private
----@param node table
----@return HighlightedString icon
----@return HighlightedString name
-function Builder:build_file(node)
-  local hl
-  if vim.tbl_contains(M.opts.renderer.special_files, node.absolute_path) or vim.tbl_contains(M.opts.renderer.special_files, node.name) then
-    hl = "NvimTreeSpecialFile"
-  elseif node.executable then
-    hl = "NvimTreeExecFile"
-  elseif M.picture_map[node.extension] then
-    hl = "NvimTreeImageFile"
-  end
-
-  local icon, hl_group = icons.get_file_icon(node.name, node.extension)
-  return { str = icon, hl = { hl_group } }, { str = node.name, hl = { hl } }
-end
-
 ---@private
 ---@param indent_markers HighlightedString[]
 ---@param arrows HighlightedString[]|nil
@@ -206,7 +118,7 @@ function Builder:format_line(indent_markers, arrows, icon, name, node)
     end
     for _, v in ipairs(t2) do
       if added_len > 0 then
-        table.insert(t1, { str = M.opts.renderer.icons.padding })
+        table.insert(t1, { str = self.explorer.opts.renderer.icons.padding })
       end
       table.insert(t1, v)
     end
@@ -222,19 +134,19 @@ function Builder:format_line(indent_markers, arrows, icon, name, node)
   local line = { indent_markers, arrows }
   add_to_end(line, { icon })
 
-  for i = #M.decorators, 1, -1 do
+  for i = #self.decorators, 1, -1 do
-    add_to_end(line, M.decorators[i]:icons_before(node))
+    add_to_end(line, self.decorators[i]:icons_before(node))
   end
 
   add_to_end(line, { name })
 
-  for i = #M.decorators, 1, -1 do
+  for i = #self.decorators, 1, -1 do
-    add_to_end(line, M.decorators[i]:icons_after(node))
+    add_to_end(line, self.decorators[i]:icons_after(node))
   end
 
   local rights = {}
-  for i = #M.decorators, 1, -1 do
+  for i = #self.decorators, 1, -1 do
-    add_to_end(rights, M.decorators[i]:icons_right_align(node))
+    add_to_end(rights, self.decorators[i]:icons_right_align(node))
   end
   if #rights > 0 then
     self.extmarks[self.index] = rights
@@ -248,7 +160,7 @@ end
 function Builder:build_signs(node)
   -- first in priority order
   local sign_name
-  for _, d in ipairs(M.decorators) do
+  for _, d in ipairs(self.decorators) do
     sign_name = d:sign_name(node)
     if sign_name then
       self.signs[self.index] = sign_name
@@ -300,8 +212,8 @@ function Builder:add_highlights(node)
   local icon_groups = {}
   local name_groups = {}
   local d, icon, name
-  for i = #M.decorators, 1, -1 do
+  for i = #self.decorators, 1, -1 do
-    d = M.decorators[i]
+    d = self.decorators[i]
     icon, name = d:groups_icon_name(node)
     table.insert(icon_groups, icon)
     table.insert(name_groups, name)
@@ -324,23 +236,18 @@ function Builder:add_highlights(node)
   return icon_hl_group, name_hl_group
 end
 
+---Insert node line into self.lines, calling Builder:build_lines for each directory
 ---@private
+---@param node Node
+---@param idx integer line number starting at 1
+---@param num_children integer of node
 function Builder:build_line(node, idx, num_children)
   -- various components
   local indent_markers = pad.get_indent_markers(self.depth, idx, num_children, node, self.markers)
   local arrows = pad.get_arrows(node)
 
   -- main components
-  local is_folder = node.nodes ~= nil
+  local icon, name = node:highlighted_icon(), node:highlighted_name()
-  local is_symlink = node.link_to ~= nil
-  local icon, name
-  if is_folder then
-    icon, name = self:build_folder(node)
-  elseif is_symlink then
-    icon, name = self:build_symlink(node)
-  else
-    icon, name = self:build_file(node)
-  end
 
   -- highighting
   local icon_hl_group, name_hl_group = self:add_highlights(node)
@@ -352,11 +259,14 @@ function Builder:build_line(node, idx, num_children)
 
   self.index = self.index + 1
 
-  node = require("nvim-tree.lib").get_last_group_node(node)
+  local dir = node:as(DirectoryNode)
-  if node.open then
+  if dir then
-    self.depth = self.depth + 1
+    dir = dir:last_group_node()
-    self:build_lines(node)
+    if dir.open then
-    self.depth = self.depth - 1
+      self.depth = self.depth + 1
+      self:build_lines(dir)
+      self.depth = self.depth - 1
+    end
   end
 end
 
@@ -366,10 +276,10 @@ function Builder:add_hidden_count_string(node, idx, num_children)
   if not node.open then
     return
   end
-  local hidden_count_string = M.opts.renderer.hidden_display(node.hidden_stats)
+  local hidden_count_string = self.hidden_display(node.hidden_stats)
   if hidden_count_string and hidden_count_string ~= "" then
     local indent_markers = pad.get_indent_markers(self.depth, idx or 0, num_children or 0, node, self.markers, 1)
-    local indent_width = M.opts.renderer.indent_width
+    local indent_width = self.explorer.opts.renderer.indent_width
 
     local indent_padding = string.rep(" ", indent_width)
     local indent_string = indent_padding .. indent_markers.str
@@ -380,16 +290,18 @@ function Builder:add_hidden_count_string(node, idx, num_children)
     -- if we change the traversal, we might need to sort by depth before rendering `self.virtual_lines`
     -- to maintain proper ordering of parent and child folder hidden count info.
     table.insert(self.virtual_lines[line_nr], {
-      { indent_string, indent_markers.hl },
+      { indent_string,                                                                      indent_markers.hl },
       { string.rep(indent_padding, (node.parent == nil and 0 or 1)) .. hidden_count_string, "NvimTreeHiddenDisplay" },
     })
   end
 end
 
+---Number of visible nodes
 ---@private
-function Builder:get_nodes_number(nodes)
+---@param nodes Node[]
-  local explorer = core.get_explorer()
+---@return integer
-  if not explorer or not explorer.live_filter.filter then
+function Builder:num_visible(nodes)
+  if not self.explorer.live_filter.filter then
     return #nodes
   end
 
@@ -405,9 +317,9 @@ end
 ---@private
 function Builder:build_lines(node)
   if not node then
-    node = core.get_explorer()
+    node = self.explorer
   end
-  local num_children = self:get_nodes_number(node.nodes)
+  local num_children = self:num_visible(node.nodes)
   local idx = 1
   for _, n in ipairs(node.nodes) do
     if not n.hidden then
@@ -424,32 +336,31 @@ end
 ---@return string
 function Builder:format_root_name(root_label)
   if type(root_label) == "function" then
-    local label = root_label(self.root_cwd)
+    local label = root_label(self.explorer.absolute_path)
     if type(label) == "string" then
       return label
     end
   elseif type(root_label) == "string" then
-    return utils.path_remove_trailing(vim.fn.fnamemodify(self.root_cwd, root_label))
+    return utils.path_remove_trailing(vim.fn.fnamemodify(self.explorer.absolute_path, root_label))
   end
   return "???"
 end
 
 ---@private
 function Builder:build_header()
-  local explorer = core.get_explorer()
+  if view.is_root_folder_visible(self.explorer.absolute_path) then
-  if view.is_root_folder_visible(core.get_cwd()) then
+    local root_name = self:format_root_name(self.explorer.opts.renderer.root_folder_label)
-    local root_name = self:format_root_name(M.opts.renderer.root_folder_label)
     table.insert(self.lines, root_name)
     self:insert_highlight({ "NvimTreeRootFolder" }, 0, string.len(root_name))
     self.index = 1
   end
 
-  if explorer and explorer.live_filter.filter then
+  if self.explorer.live_filter.filter then
-    local filter_line = string.format("%s/%s/", M.opts.live_filter.prefix, explorer.live_filter.filter)
+    local filter_line = string.format("%s/%s/", self.explorer.opts.live_filter.prefix, self.explorer.live_filter.filter)
     table.insert(self.lines, filter_line)
-    local prefix_length = string.len(M.opts.live_filter.prefix)
+    local prefix_length = string.len(self.explorer.opts.live_filter.prefix)
-    self:insert_highlight({ "NvimTreeLiveFilterPrefix" }, 0, prefix_length)
+    self:insert_highlight({ "NvimTreeLiveFilterPrefix" }, 0,             prefix_length)
-    self:insert_highlight({ "NvimTreeLiveFilterValue" }, prefix_length, string.len(filter_line))
+    self:insert_highlight({ "NvimTreeLiveFilterValue" },  prefix_length, string.len(filter_line))
     self.index = self.index + 1
   end
 end
@@ -472,63 +383,47 @@ function Builder:build()
   return self
 end
 
+---@private
 ---@param opts table
-local setup_hidden_display_function = function(opts)
+---@return fun(node: Node): string|nil
+function Builder:setup_hidden_display_function(opts)
   local hidden_display = opts.renderer.hidden_display
   -- options are already validated, so ´hidden_display´ can ONLY be `string` or `function` if type(hidden_display) == "string" then
   if type(hidden_display) == "string" then
     if hidden_display == "none" then
-      opts.renderer.hidden_display = function()
+      return function()
         return nil
       end
     elseif hidden_display == "simple" then
-      opts.renderer.hidden_display = function(hidden_stats)
+      return function(hidden_stats)
         return utils.default_format_hidden_count(hidden_stats, true)
       end
-    elseif hidden_display == "all" then
+    else -- "all"
-      opts.renderer.hidden_display = function(hidden_stats)
+      return function(hidden_stats)
         return utils.default_format_hidden_count(hidden_stats, false)
       end
     end
-  elseif type(hidden_display) == "function" then
+  else -- "function
-    local safe_render = function(hidden_stats)
+    return function(hidden_stats)
       -- In case of missing field such as live_filter we zero it, otherwise keep field as is
       hidden_stats = vim.tbl_deep_extend("force", {
         live_filter = 0,
-        git = 0,
+        git         = 0,
-        buf = 0,
+        buf         = 0,
-        dotfile = 0,
+        dotfile     = 0,
-        custom = 0,
+        custom      = 0,
-        bookmark = 0,
+        bookmark    = 0,
       }, hidden_stats or {})
 
       local ok, result = pcall(hidden_display, hidden_stats)
       if not ok then
-        notify.warn "Problem occurred in the function ``opts.renderer.hidden_display`` see nvim-tree.renderer.hidden_display on :h nvim-tree"
+        notify.warn(
+          "Problem occurred in the function ``opts.renderer.hidden_display`` see nvim-tree.renderer.hidden_display on :h nvim-tree")
         return nil
       end
       return result
     end
-
-    opts.renderer.hidden_display = safe_render
   end
 end
 
-function Builder.setup(opts)
-  setup_hidden_display_function(opts)
-  M.opts = opts
-
-  -- priority order
-  M.decorators = {
-    DecoratorCut:new(opts),
-    DecoratorCopied:new(opts),
-    DecoratorDiagnostics:new(opts),
-    DecoratorBookmarks:new(opts),
-    DecoratorModified:new(opts),
-    DecoratorHidden:new(opts),
-    DecoratorOpened:new(opts),
-    DecoratorGit:new(opts),
-  }
-end
-
 return Builder

lua/nvim-tree/renderer/components/devicons.lua

@@ -0,0 +1,35 @@
+---@alias devicons_get_icon fun(name: string, ext: string?, opts: table?): string?, string?
+---@alias devicons_setup fun(opts: table?)
+
+---@class (strict) DevIcons?
+---@field setup devicons_setup
+---@field get_icon devicons_get_icon
+local devicons
+
+local M = {}
+
+---Wrapper around nvim-web-devicons, nils if devicons not available
+---@type devicons_get_icon
+function M.get_icon(name, ext, opts)
+  if devicons then
+    return devicons.get_icon(name, ext, opts)
+  else
+    return nil, nil
+  end
+end
+
+---Attempt to use nvim-web-devicons if present and enabled for file or folder
+---@param opts table
+function M.setup(opts)
+  if opts.renderer.icons.show.file or opts.renderer.icons.show.folder then
+    local ok, di = pcall(require, "nvim-web-devicons")
+    if ok then
+      devicons = di --[[@as DevIcons]]
+
+      -- does nothing if already called i.e. doesn't clobber previous user setup
+      devicons.setup()
+    end
+  end
+end
+
+return M

lua/nvim-tree/renderer/components/diagnostics.lua

@@ -1,93 +0,0 @@
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
-local diagnostics = require "nvim-tree.diagnostics"
-
-local M = {
-  -- highlight strings for the icons
-  HS_ICON = {},
-
-  -- highlight groups for HL
-  HG_FILE = {},
-  HG_FOLDER = {},
-
-  -- position for HL
-  HL_POS = HL_POSITION.none,
-}
-
----Diagnostics highlight group and position when highlight_diagnostics.
----@param node table
----@return HL_POSITION position none when no status
----@return string|nil group only when status
-function M.get_highlight(node)
-  if not node or M.HL_POS == HL_POSITION.none then
-    return HL_POSITION.none, nil
-  end
-
-  local group
-  local diag_status = diagnostics.get_diag_status(node)
-  if node.nodes then
-    group = M.HS_FOLDER[diag_status and diag_status.value]
-  else
-    group = M.HS_FILE[diag_status and diag_status.value]
-  end
-
-  if group then
-    return M.HL_POS, group
-  else
-    return HL_POSITION.none, nil
-  end
-end
-
----diagnostics icon if there is a status
----@param node table
----@return HighlightedString|nil modified icon
-function M.get_icon(node)
-  if node and M.config.diagnostics.enable and M.config.renderer.icons.show.diagnostics then
-    local diag_status = diagnostics.get_diag_status(node)
-    return M.ICON[diag_status and diag_status.value]
-  end
-end
-
-function M.setup(opts)
-  M.config = {
-    diagnostics = opts.diagnostics,
-    renderer = opts.renderer,
-  }
-
-  if opts.diagnostics.enable and opts.renderer.highlight_diagnostics then
-    M.HL_POS = HL_POSITION[opts.renderer.highlight_diagnostics]
-  end
-
-  M.HG_FILE[vim.diagnostic.severity.ERROR] = "NvimTreeDiagnosticErrorFileHL"
-  M.HG_FILE[vim.diagnostic.severity.WARN] = "NvimTreeDiagnosticWarningFileHL"
-  M.HG_FILE[vim.diagnostic.severity.INFO] = "NvimTreeDiagnosticInfoFileHL"
-  M.HG_FILE[vim.diagnostic.severity.HINT] = "NvimTreeDiagnosticHintFileHL"
-
-  M.HG_FOLDER[vim.diagnostic.severity.ERROR] = "NvimTreeDiagnosticErrorFolderHL"
-  M.HG_FOLDER[vim.diagnostic.severity.WARN] = "NvimTreeDiagnosticWarningFolderHL"
-  M.HG_FOLDER[vim.diagnostic.severity.INFO] = "NvimTreeDiagnosticInfoFolderHL"
-  M.HG_FOLDER[vim.diagnostic.severity.HINT] = "NvimTreeDiagnosticHintFolderHL"
-
-  M.HS_ICON[vim.diagnostic.severity.ERROR] = {
-    str = M.config.diagnostics.icons.error,
-    hl = { "NvimTreeDiagnosticErrorIcon" },
-  }
-
-  M.HS_ICON[vim.diagnostic.severity.WARN] = {
-    str = M.config.diagnostics.icons.warning,
-    hl = { "NvimTreeDiagnosticWarningIcon" },
-  }
-  M.HS_ICON[vim.diagnostic.severity.INFO] = {
-    str = M.config.diagnostics.icons.info,
-    hl = { "NvimTreeDiagnosticInfoIcon" },
-  }
-  M.HS_ICON[vim.diagnostic.severity.HINT] = {
-    str = M.config.diagnostics.icons.hint,
-    hl = { "NvimTreeDiagnosticHintIcon" },
-  }
-
-  for _, i in ipairs(M.HS_ICON) do
-    vim.fn.sign_define(i.hl[1], { text = i.str, texthl = i.hl[1] })
-  end
-end
-
-return M

lua/nvim-tree/renderer/components/full-name.lua

@@ -1,6 +1,6 @@
 local M = {}
 
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
 
 local function hide(win)
   if win then
@@ -42,7 +42,7 @@ local function show()
     return
   end
 
-  local line = vim.fn.getline "."
+  local line = vim.fn.getline(".")
   local leftcol = vim.fn.winsaveview().leftcol
   -- hide full name if left column of node in nvim-tree win is not zero
   if leftcol ~= 0 then
@@ -57,13 +57,13 @@ local function show()
   end
 
   M.popup_win = vim.api.nvim_open_win(vim.api.nvim_create_buf(false, false), false, {
-    relative = "win",
+    relative  = "win",
-    row = 0,
+    row       = 0,
-    bufpos = { vim.api.nvim_win_get_cursor(0)[1] - 1, 0 },
+    bufpos    = { vim.api.nvim_win_get_cursor(0)[1] - 1, 0 },
-    width = math.min(text_width, vim.o.columns - 2),
+    width     = math.min(text_width, vim.o.columns - 2),
-    height = 1,
+    height    = 1,
     noautocmd = true,
-    style = "minimal",
+    style     = "minimal",
   })
 
   local ns_id = vim.api.nvim_get_namespaces()["NvimTreeHighlights"]
@@ -81,7 +81,7 @@ local function show()
 
       vim.api.nvim_buf_add_highlight(0, ns_id, details.hl_group, 0, col, details.end_col)
     end
-    vim.cmd [[ setlocal nowrap cursorline noswapfile nobuflisted buftype=nofile bufhidden=hide ]]
+    vim.cmd([[ setlocal nowrap cursorline noswapfile nobuflisted buftype=nofile bufhidden=hide ]])
   end)
 end
 

lua/nvim-tree/renderer/components/icons.lua

@@ -1,113 +0,0 @@
-local M = { i = {} }
-
-local function config_symlinks()
-  M.i.symlink = #M.config.glyphs.symlink > 0 and M.config.glyphs.symlink or ""
-  M.i.symlink_arrow = M.config.symlink_arrow
-end
-
-local function empty()
-  return ""
-end
-
-local function get_folder_icon_default(node, has_children)
-  local is_symlink = node.links_to ~= nil
-  local n
-  if is_symlink and node.open then
-    n = M.config.glyphs.folder.symlink_open
-  elseif is_symlink then
-    n = M.config.glyphs.folder.symlink
-  elseif node.open then
-    if has_children then
-      n = M.config.glyphs.folder.open
-    else
-      n = M.config.glyphs.folder.empty_open
-    end
-  else
-    if has_children then
-      n = M.config.glyphs.folder.default
-    else
-      n = M.config.glyphs.folder.empty
-    end
-  end
-  return n, nil
-end
-
-local function get_folder_icon_webdev(node, has_children)
-  local icon, hl_group = M.devicons.get_icon(node.name, node.extension)
-  if not M.config.web_devicons.folder.color then
-    hl_group = nil
-  end
-  if icon ~= nil then
-    return icon, hl_group
-  else
-    return get_folder_icon_default(node, has_children)
-  end
-end
-
-local function get_file_icon_default()
-  local hl_group = "NvimTreeFileIcon"
-  local icon = M.config.glyphs.default
-  if #icon > 0 then
-    return icon, hl_group
-  else
-    return ""
-  end
-end
-
-local function get_file_icon_webdev(fname, extension)
-  local icon, hl_group = M.devicons.get_icon(fname, extension)
-  if not M.config.web_devicons.file.color then
-    hl_group = "NvimTreeFileIcon"
-  end
-  if icon and hl_group ~= "DevIconDefault" then
-    return icon, hl_group
-  elseif string.match(extension, "%.(.*)") then
-    -- If there are more extensions to the file, try to grab the icon for them recursively
-    return get_file_icon_webdev(fname, string.match(extension, "%.(.*)"))
-  else
-    local devicons_default = M.devicons.get_default_icon()
-    if devicons_default and type(devicons_default.icon) == "string" and type(devicons_default.name) == "string" then
-      return devicons_default.icon, "DevIcon" .. devicons_default.name
-    else
-      return get_file_icon_default()
-    end
-  end
-end
-
-local function config_file_icon()
-  if M.config.show.file then
-    if M.devicons and M.config.web_devicons.file.enable then
-      M.get_file_icon = get_file_icon_webdev
-    else
-      M.get_file_icon = get_file_icon_default
-    end
-  else
-    M.get_file_icon = empty
-  end
-end
-
-local function config_folder_icon()
-  if M.config.show.folder then
-    if M.devicons and M.config.web_devicons.folder.enable then
-      M.get_folder_icon = get_folder_icon_webdev
-    else
-      M.get_folder_icon = get_folder_icon_default
-    end
-  else
-    M.get_folder_icon = empty
-  end
-end
-
-function M.reset_config()
-  config_symlinks()
-  config_file_icon()
-  config_folder_icon()
-end
-
-function M.setup(opts)
-  M.config = opts.renderer.icons
-
-  M.devicons = pcall(require, "nvim-web-devicons") and require "nvim-web-devicons" or nil
-end
-
-return M

lua/nvim-tree/renderer/components/init.lua

@@ -0,0 +1,13 @@
+local M = {}
+
+M.full_name = require("nvim-tree.renderer.components.full-name")
+M.devicons = require("nvim-tree.renderer.components.devicons")
+M.padding = require("nvim-tree.renderer.components.padding")
+
+function M.setup(opts)
+  M.full_name.setup(opts)
+  M.devicons.setup(opts)
+  M.padding.setup(opts)
+end
+
+return M

lua/nvim-tree/renderer/components/padding.lua

@@ -1,3 +1,5 @@
+local DirectoryNode = require("nvim-tree.node.directory")
+
 local M = {}
 
 local function check_siblings_for_folder(node, with_arrows)
@@ -59,9 +61,10 @@ end
 ---@param depth integer
 ---@param idx integer
 ---@param nodes_number integer
----@param node table
+---@param node Node
 ---@param markers table
----@return HighlightedString[]
+---@param early_stop integer?
+---@return HighlightedString
 function M.get_indent_markers(depth, idx, nodes_number, node, markers, early_stop)
   local str = ""
 
@@ -79,7 +82,7 @@ function M.get_indent_markers(depth, idx, nodes_number, node, markers, early_sto
   return { str = str, hl = { "NvimTreeIndentMarker" } }
 end
 
----@param node table
+---@param node Node
 ---@return HighlightedString[]|nil
 function M.get_arrows(node)
   if not M.config.icons.show.folder_arrow then
@@ -89,8 +92,9 @@ function M.get_arrows(node)
   local str
   local hl = "NvimTreeFolderArrowClosed"
 
-  if node.nodes then
+  local dir = node:as(DirectoryNode)
-    if node.open then
+  if dir then
+    if dir.open then
       str = M.config.icons.glyphs.folder["arrow_open"] .. " "
       hl = "NvimTreeFolderArrowOpen"
     else
@@ -117,7 +121,7 @@ function M.setup(opts)
       return " "
     end
     -- return the first character from the UTF-8 encoded string; we may use utf8.codes from Lua 5.3 when available
-    return symbol:match "[%z\1-\127\194-\244][\128-\191]*"
+    return symbol:match("[%z\1-\127\194-\244][\128-\191]*")
   end
 
   for k, v in pairs(M.config.indent_markers.icons) do

lua/nvim-tree/renderer/decorator/bookmarks.lua

@@ -1,40 +1,36 @@
-local core = require "nvim-tree.core"
+local Decorator = require("nvim-tree.renderer.decorator")
 
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
+---@class (exact) DecoratorBookmarks: Decorator
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
+---@field icon HighlightedString?
+local DecoratorBookmarks = Decorator:extend()
 
-local Decorator = require "nvim-tree.renderer.decorator"
+---@class DecoratorBookmarks
+---@overload fun(explorer: DecoratorArgs): DecoratorBookmarks
 
----@class DecoratorBookmarks: Decorator
+---@protected
----@field icon HighlightedString
+---@param args DecoratorArgs
-local DecoratorBookmarks = Decorator:new()
+function DecoratorBookmarks:new(args)
-
+  Decorator.new(self, {
----@param opts table
+    explorer       = args.explorer,
----@return DecoratorBookmarks
+    enabled        = true,
-function DecoratorBookmarks:new(opts)
+    hl_pos         = args.explorer.opts.renderer.highlight_bookmarks or "none",
-  local o = Decorator.new(self, {
+    icon_placement = args.explorer.opts.renderer.icons.bookmarks_placement or "none",
-    enabled = true,
-    hl_pos = HL_POSITION[opts.renderer.highlight_bookmarks] or HL_POSITION.none,
-    icon_placement = ICON_PLACEMENT[opts.renderer.icons.bookmarks_placement] or ICON_PLACEMENT.none,
   })
-  ---@cast o DecoratorBookmarks
 
-  if opts.renderer.icons.show.bookmarks then
+  if self.explorer.opts.renderer.icons.show.bookmarks then
-    o.icon = {
+    self.icon = {
-      str = opts.renderer.icons.glyphs.bookmark,
+      str = self.explorer.opts.renderer.icons.glyphs.bookmark,
       hl = { "NvimTreeBookmarkIcon" },
     }
-    o:define_sign(o.icon)
+    self:define_sign(self.icon)
   end
-
-  return o
 end
 
 ---Bookmark icon: renderer.icons.show.bookmarks and node is marked
 ---@param node Node
 ---@return HighlightedString[]|nil icons
 function DecoratorBookmarks:calculate_icons(node)
-  if core.get_explorer() and core.get_explorer().marks:get(node) then
+  if self.explorer.marks:get(node) then
     return { self.icon }
   end
 end
@@ -43,7 +39,7 @@ end
 ---@param node Node
 ---@return string|nil group
 function DecoratorBookmarks:calculate_highlight(node)
-  if self.hl_pos ~= HL_POSITION.none and core.get_explorer() and core.get_explorer().marks:get(node) then
+  if self.range ~= "none" and self.explorer.marks:get(node) then
     return "NvimTreeBookmarkHL"
   end
 end

lua/nvim-tree/renderer/decorator/copied.lua

@@ -1,33 +1,27 @@
-local core = require "nvim-tree.core"
+local Decorator = require("nvim-tree.renderer.decorator")
 
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
+---@class (exact) DecoratorCopied: Decorator
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
+local DecoratorCopied = Decorator:extend()
 
-local Decorator = require "nvim-tree.renderer.decorator"
+---@class DecoratorCopied
+---@overload fun(explorer: DecoratorArgs): DecoratorCopied
 
----@class DecoratorCopied: Decorator
+---@protected
----@field enabled boolean
+---@param args DecoratorArgs
----@field icon HighlightedString|nil
+function DecoratorCopied:new(args)
-local DecoratorCopied = Decorator:new()
+  Decorator.new(self, {
-
+    explorer       = args.explorer,
----@param opts table
+    enabled        = true,
----@return DecoratorCopied
+    hl_pos         = args.explorer.opts.renderer.highlight_clipboard or "none",
-function DecoratorCopied:new(opts)
+    icon_placement = "none",
-  local o = Decorator.new(self, {
-    enabled = true,
-    hl_pos = HL_POSITION[opts.renderer.highlight_clipboard] or HL_POSITION.none,
-    icon_placement = ICON_PLACEMENT.none,
   })
-  ---@cast o DecoratorCopied
-
-  return o
 end
 
 ---Copied highlight: renderer.highlight_clipboard and node is copied
 ---@param node Node
 ---@return string|nil group
 function DecoratorCopied:calculate_highlight(node)
-  if self.hl_pos ~= HL_POSITION.none and core.get_explorer() and core.get_explorer().clipboard:is_copied(node) then
+  if self.range ~= "none" and self.explorer.clipboard:is_copied(node) then
     return "NvimTreeCopiedHL"
   end
 end

lua/nvim-tree/renderer/decorator/cut.lua

@@ -1,33 +1,27 @@
-local core = require "nvim-tree.core"
+local Decorator = require("nvim-tree.renderer.decorator")
 
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
+---@class (exact) DecoratorCut: Decorator
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
+local DecoratorCut = Decorator:extend()
 
-local Decorator = require "nvim-tree.renderer.decorator"
+---@class DecoratorCut
+---@overload fun(explorer: DecoratorArgs): DecoratorCut
 
----@class DecoratorCut: Decorator
+---@protected
----@field enabled boolean
+---@param args DecoratorArgs
----@field icon HighlightedString|nil
+function DecoratorCut:new(args)
-local DecoratorCut = Decorator:new()
+  Decorator.new(self, {
-
+    explorer       = args.explorer,
----@param opts table
+    enabled        = true,
----@return DecoratorCut
+    hl_pos         = args.explorer.opts.renderer.highlight_clipboard or "none",
-function DecoratorCut:new(opts)
+    icon_placement = "none",
-  local o = Decorator.new(self, {
-    enabled = true,
-    hl_pos = HL_POSITION[opts.renderer.highlight_clipboard] or HL_POSITION.none,
-    icon_placement = ICON_PLACEMENT.none,
   })
-  ---@cast o DecoratorCut
-
-  return o
 end
 
 ---Cut highlight: renderer.highlight_clipboard and node is cut
 ---@param node Node
 ---@return string|nil group
 function DecoratorCut:calculate_highlight(node)
-  if self.hl_pos ~= HL_POSITION.none and core.get_explorer() and core.get_explorer().clipboard:is_cut(node) then
+  if self.range ~= "none" and self.explorer.clipboard:is_cut(node) then
     return "NvimTreeCutHL"
   end
 end

lua/nvim-tree/renderer/decorator/diagnostics.lua

@@ -1,9 +1,7 @@
-local diagnostics = require "nvim-tree.diagnostics"
+local diagnostics = require("nvim-tree.diagnostics")
 
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
+local Decorator = require("nvim-tree.renderer.decorator")
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
+local DirectoryNode = require("nvim-tree.node.directory")
-
-local Decorator = require "nvim-tree.renderer.decorator"
 
 -- highlight groups by severity
 local HG_ICON = {
@@ -32,36 +30,37 @@ local ICON_KEYS = {
   ["hint"] = vim.diagnostic.severity.HINT,
 }
 
----@class DecoratorDiagnostics: Decorator
+---@class (exact) DecoratorDiagnostics: Decorator
----@field icons HighlightedString[]
+---@field icons HighlightedString[]?
-local DecoratorDiagnostics = Decorator:new()
+local DecoratorDiagnostics = Decorator:extend()
 
----@param opts table
+---@class DecoratorDiagnostics
----@return DecoratorDiagnostics
+---@overload fun(explorer: DecoratorArgs): DecoratorDiagnostics
-function DecoratorDiagnostics:new(opts)
+
-  local o = Decorator.new(self, {
+---@protected
-    enabled = opts.diagnostics.enable,
+---@param args DecoratorArgs
-    hl_pos = HL_POSITION[opts.renderer.highlight_diagnostics] or HL_POSITION.none,
+function DecoratorDiagnostics:new(args)
-    icon_placement = ICON_PLACEMENT[opts.renderer.icons.diagnostics_placement] or ICON_PLACEMENT.none,
+  Decorator.new(self, {
+    explorer       = args.explorer,
+    enabled        = true,
+    hl_pos         = args.explorer.opts.renderer.highlight_diagnostics or "none",
+    icon_placement = args.explorer.opts.renderer.icons.diagnostics_placement or "none",
   })
-  ---@cast o DecoratorDiagnostics
 
-  if not o.enabled then
+  if not self.enabled then
-    return o
+    return
   end
 
-  if opts.renderer.icons.show.diagnostics then
+  if self.explorer.opts.renderer.icons.show.diagnostics then
-    o.icons = {}
+    self.icons = {}
     for name, sev in pairs(ICON_KEYS) do
-      o.icons[sev] = {
+      self.icons[sev] = {
-        str = opts.diagnostics.icons[name],
+        str = self.explorer.opts.diagnostics.icons[name],
         hl = { HG_ICON[sev] },
       }
-      o:define_sign(o.icons[sev])
+      self:define_sign(self.icons[sev])
     end
   end
-
-  return o
 end
 
 ---Diagnostic icon: diagnostics.enable, renderer.icons.show.diagnostics and node has status
@@ -82,7 +81,7 @@ end
 ---@param node Node
 ---@return string|nil group
 function DecoratorDiagnostics:calculate_highlight(node)
-  if not node or not self.enabled or self.hl_pos == HL_POSITION.none then
+  if not node or not self.enabled or self.range == "none" then
     return nil
   end
 
@@ -94,7 +93,7 @@ function DecoratorDiagnostics:calculate_highlight(node)
   end
 
   local group
-  if node.nodes then
+  if node:is(DirectoryNode) then
     group = HG_FOLDER[diag_value]
   else
     group = HG_FILE[diag_value]

lua/nvim-tree/renderer/decorator/git.lua

@@ -1,65 +1,68 @@
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
-local explorer_node = require "nvim-tree.explorer.node"
 
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
+local Decorator = require("nvim-tree.renderer.decorator")
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
+local DirectoryNode = require("nvim-tree.node.directory")
 
-local Decorator = require "nvim-tree.renderer.decorator"
+---@class (exact) GitHighlightedString: HighlightedString
-
----@class HighlightedStringGit: HighlightedString
 ---@field ord number decreasing priority
 
----@class DecoratorGit: Decorator
+---@alias GitStatusStrings "deleted" | "ignored" | "renamed" | "staged" | "unmerged" | "unstaged" | "untracked"
----@field file_hl table<string, string> by porcelain status e.g. "AM"
----@field folder_hl table<string, string> by porcelain status
----@field icons_by_status HighlightedStringGit[] by human status
----@field icons_by_xy table<string, HighlightedStringGit[]> by porcelain status
-local DecoratorGit = Decorator:new()
 
----@param opts table
+---@alias GitIconsByStatus table<GitStatusStrings, GitHighlightedString> human status
----@return DecoratorGit
+---@alias GitIconsByXY table<GitXY, GitHighlightedString[]> porcelain status
-function DecoratorGit:new(opts)
+---@alias GitGlyphsByStatus table<GitStatusStrings, string> from opts
-  local o = Decorator.new(self, {
+
-    enabled = opts.git.enable,
+---@class (exact) DecoratorGit: Decorator
-    hl_pos = HL_POSITION[opts.renderer.highlight_git] or HL_POSITION.none,
+---@field file_hl_by_xy table<GitXY, string>?
-    icon_placement = ICON_PLACEMENT[opts.renderer.icons.git_placement] or ICON_PLACEMENT.none,
+---@field folder_hl_by_xy table<GitXY, string>?
+---@field icons_by_status GitIconsByStatus?
+---@field icons_by_xy GitIconsByXY?
+local DecoratorGit = Decorator:extend()
+
+---@class DecoratorGit
+---@overload fun(explorer: DecoratorArgs): DecoratorGit
+
+---@protected
+---@param args DecoratorArgs
+function DecoratorGit:new(args)
+  Decorator.new(self, {
+    explorer       = args.explorer,
+    enabled        = args.explorer.opts.git.enable,
+    hl_pos         = args.explorer.opts.renderer.highlight_git or "none",
+    icon_placement = args.explorer.opts.renderer.icons.git_placement or "none",
   })
-  ---@cast o DecoratorGit
 
-  if not o.enabled then
+  if not self.enabled then
-    return o
+    return
   end
 
-  if o.hl_pos ~= HL_POSITION.none then
+  if self.range ~= "none" then
-    o:build_hl_table()
+    self:build_file_folder_hl_by_xy()
   end
 
-  if opts.renderer.icons.show.git then
+  if self.explorer.opts.renderer.icons.show.git then
-    o:build_icons_by_status(opts.renderer.icons.glyphs.git)
+    self:build_icons_by_status(self.explorer.opts.renderer.icons.glyphs.git)
-    o:build_icons_by_xy(o.icons_by_status)
+    self:build_icons_by_xy(self.icons_by_status)
 
-    for _, icon in pairs(o.icons_by_status) do
+    for _, icon in pairs(self.icons_by_status) do
       self:define_sign(icon)
     end
   end
-
-  return o
 end
 
----@param glyphs table<string, string> user glyps
+---@param glyphs GitGlyphsByStatus
 function DecoratorGit:build_icons_by_status(glyphs)
-  self.icons_by_status = {
+  self.icons_by_status           = {}
-    staged = { str = glyphs.staged, hl = { "NvimTreeGitStagedIcon" }, ord = 1 },
+  self.icons_by_status.staged    = { str = glyphs.staged, hl = { "NvimTreeGitStagedIcon" }, ord = 1 }
-    unstaged = { str = glyphs.unstaged, hl = { "NvimTreeGitDirtyIcon" }, ord = 2 },
+  self.icons_by_status.unstaged  = { str = glyphs.unstaged, hl = { "NvimTreeGitDirtyIcon" }, ord = 2 }
-    renamed = { str = glyphs.renamed, hl = { "NvimTreeGitRenamedIcon" }, ord = 3 },
+  self.icons_by_status.renamed   = { str = glyphs.renamed, hl = { "NvimTreeGitRenamedIcon" }, ord = 3 }
-    deleted = { str = glyphs.deleted, hl = { "NvimTreeGitDeletedIcon" }, ord = 4 },
+  self.icons_by_status.deleted   = { str = glyphs.deleted, hl = { "NvimTreeGitDeletedIcon" }, ord = 4 }
-    unmerged = { str = glyphs.unmerged, hl = { "NvimTreeGitMergeIcon" }, ord = 5 },
+  self.icons_by_status.unmerged  = { str = glyphs.unmerged, hl = { "NvimTreeGitMergeIcon" }, ord = 5 }
-    untracked = { str = glyphs.untracked, hl = { "NvimTreeGitNewIcon" }, ord = 6 },
+  self.icons_by_status.untracked = { str = glyphs.untracked, hl = { "NvimTreeGitNewIcon" }, ord = 6 }
-    ignored = { str = glyphs.ignored, hl = { "NvimTreeGitIgnoredIcon" }, ord = 7 },
+  self.icons_by_status.ignored   = { str = glyphs.ignored, hl = { "NvimTreeGitIgnoredIcon" }, ord = 7 }
-  }
 end
 
----@param icons HighlightedStringGit[]
+---@param icons GitIconsByXY
 function DecoratorGit:build_icons_by_xy(icons)
   self.icons_by_xy = {
     ["M "] = { icons.staged },
@@ -93,12 +96,12 @@ function DecoratorGit:build_icons_by_xy(icons)
     ["DD"] = { icons.deleted },
     ["DU"] = { icons.deleted, icons.unmerged },
     ["!!"] = { icons.ignored },
-    dirty = { icons.unstaged },
+    dirty  = { icons.unstaged },
   }
 end
 
-function DecoratorGit:build_hl_table()
+function DecoratorGit:build_file_folder_hl_by_xy()
-  self.file_hl = {
+  self.file_hl_by_xy = {
     ["M "] = "NvimTreeGitFileStagedHL",
     ["C "] = "NvimTreeGitFileStagedHL",
     ["AA"] = "NvimTreeGitFileStagedHL",
@@ -112,7 +115,7 @@ function DecoratorGit:build_hl_table()
     [" T"] = "NvimTreeGitFileDirtyHL",
     ["MM"] = "NvimTreeGitFileDirtyHL",
     ["AM"] = "NvimTreeGitFileDirtyHL",
-    dirty = "NvimTreeGitFileDirtyHL",
+    dirty  = "NvimTreeGitFileDirtyHL",
     ["A "] = "NvimTreeGitFileStagedHL",
     ["??"] = "NvimTreeGitFileNewHL",
     ["AU"] = "NvimTreeGitFileMergeHL",
@@ -131,9 +134,9 @@ function DecoratorGit:build_hl_table()
     [" A"] = "none",
   }
 
-  self.folder_hl = {}
+  self.folder_hl_by_xy = {}
-  for k, v in pairs(self.file_hl) do
+  for k, v in pairs(self.file_hl_by_xy) do
-    self.folder_hl[k] = v:gsub("File", "Folder")
+    self.folder_hl_by_xy[k] = v:gsub("File", "Folder")
   end
 end
 
@@ -145,19 +148,19 @@ function DecoratorGit:calculate_icons(node)
     return nil
   end
 
-  local git_status = explorer_node.get_git_status(node)
+  local git_xy = node:get_git_xy()
-  if git_status == nil then
+  if git_xy == nil then
     return nil
   end
 
   local inserted = {}
   local iconss = {}
 
-  for _, s in pairs(git_status) do
+  for _, s in pairs(git_xy) do
     local icons = self.icons_by_xy[s]
     if not icons then
-      if self.hl_pos == HL_POSITION.none then
+      if self.range == "none" then
-        notify.warn(string.format("Unrecognized git state '%s'", git_status))
+        notify.warn(string.format("Unrecognized git state '%s'", git_xy))
       end
       return nil
     end
@@ -188,7 +191,7 @@ end
 ---@param node Node
 ---@return string|nil name
 function DecoratorGit:sign_name(node)
-  if self.icon_placement ~= ICON_PLACEMENT.signcolumn then
+  if self.icon_placement ~= "signcolumn" then
     return
   end
 
@@ -202,19 +205,19 @@ end
 ---@param node Node
 ---@return string|nil group
 function DecoratorGit:calculate_highlight(node)
-  if not node or not self.enabled or self.hl_pos == HL_POSITION.none then
+  if not node or not self.enabled or self.range == "none" then
     return nil
   end
 
-  local git_status = explorer_node.get_git_status(node)
+  local git_xy = node:get_git_xy()
-  if not git_status then
+  if not git_xy then
     return nil
   end
 
-  if node.nodes then
+  if node:is(DirectoryNode) then
-    return self.folder_hl[git_status[1]]
+    return self.folder_hl_by_xy[git_xy[1]]
   else
-    return self.file_hl[git_status[1]]
+    return self.file_hl_by_xy[git_xy[1]]
   end
 end
 

lua/nvim-tree/renderer/decorator/hidden.lua

@@ -1,38 +1,37 @@
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
+local Decorator = require("nvim-tree.renderer.decorator")
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
+local DirectoryNode = require("nvim-tree.node.directory")
-local explorer_node = require "nvim-tree.explorer.node"
-local Decorator = require "nvim-tree.renderer.decorator"
 
----@class DecoratorHidden: Decorator
+---@class (exact) DecoratorHidden: Decorator
----@field icon HighlightedString|nil
+---@field icon HighlightedString?
-local DecoratorHidden = Decorator:new()
+local DecoratorHidden = Decorator:extend()
 
----@param opts table
+---@class DecoratorHidden
----@return DecoratorHidden
+---@overload fun(explorer: DecoratorArgs): DecoratorHidden
-function DecoratorHidden:new(opts)
+
-  local o = Decorator.new(self, {
+---@protected
-    enabled = true,
+---@param args DecoratorArgs
-    hl_pos = HL_POSITION[opts.renderer.highlight_hidden] or HL_POSITION.none,
+function DecoratorHidden:new(args)
-    icon_placement = ICON_PLACEMENT[opts.renderer.icons.hidden_placement] or ICON_PLACEMENT.none,
+  Decorator.new(self, {
+    explorer       = args.explorer,
+    enabled        = true,
+    hl_pos         = args.explorer.opts.renderer.highlight_hidden or "none",
+    icon_placement = args.explorer.opts.renderer.icons.hidden_placement or "none",
   })
-  ---@cast o DecoratorHidden
 
-  if opts.renderer.icons.show.hidden then
+  if self.explorer.opts.renderer.icons.show.hidden then
-    o.icon = {
+    self.icon = {
-      str = opts.renderer.icons.glyphs.hidden,
+      str = self.explorer.opts.renderer.icons.glyphs.hidden,
       hl = { "NvimTreeHiddenIcon" },
     }
-    o:define_sign(o.icon)
+    self:define_sign(self.icon)
   end
-
-  return o
 end
 
 ---Hidden icon: renderer.icons.show.hidden and node starts with `.` (dotfile).
 ---@param node Node
 ---@return HighlightedString[]|nil icons
 function DecoratorHidden:calculate_icons(node)
-  if self.enabled and explorer_node.is_dotfile(node) then
+  if self.enabled and node:is_dotfile() then
     return { self.icon }
   end
 end
@@ -41,11 +40,11 @@ end
 ---@param node Node
 ---@return string|nil group
 function DecoratorHidden:calculate_highlight(node)
-  if not self.enabled or self.hl_pos == HL_POSITION.none or (not explorer_node.is_dotfile(node)) then
+  if not self.enabled or self.range == "none" or not node:is_dotfile() then
     return nil
   end
 
-  if node.nodes then
+  if node:is(DirectoryNode) then
     return "NvimTreeHiddenFolderHL"
   else
     return "NvimTreeHiddenFileHL"

lua/nvim-tree/renderer/decorator/init.lua

@@ -1,20 +1,32 @@
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
+local Class = require("nvim-tree.classic")
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
 
----@class Decorator
+---@alias DecoratorRange "none" | "icon" | "name" | "all"
+---@alias DecoratorIconPlacement "none" | "before" | "after" | "signcolumn" | "right_align"
+
+---Abstract Decorator
+---Uses the factory pattern to instantiate child instances.
+---@class (exact) Decorator: Class
+---@field protected explorer Explorer
 ---@field protected enabled boolean
----@field protected hl_pos HL_POSITION
+---@field protected range DecoratorRange
----@field protected icon_placement ICON_PLACEMENT
+---@field protected icon_placement DecoratorIconPlacement
-local Decorator = {}
+local Decorator = Class:extend()
 
----@param o Decorator|nil
+---@class (exact) DecoratorArgs
----@return Decorator
+---@field explorer Explorer
-function Decorator:new(o)
-  o = o or {}
-  setmetatable(o, self)
-  self.__index = self
 
-  return o
+---@class (exact) AbstractDecoratorArgs: DecoratorArgs
+---@field enabled boolean
+---@field hl_pos DecoratorRange
+---@field icon_placement DecoratorIconPlacement
+
+---@protected
+---@param args AbstractDecoratorArgs
+function Decorator:new(args)
+  self.explorer       = args.explorer
+  self.enabled        = args.enabled
+  self.range          = args.hl_pos
+  self.icon_placement = args.icon_placement
 end
 
 ---Maybe highlight groups
@@ -24,13 +36,13 @@ end
 function Decorator:groups_icon_name(node)
   local icon_hl, name_hl
 
-  if self.enabled and self.hl_pos ~= HL_POSITION.none then
+  if self.enabled and self.range ~= "none" then
     local hl = self:calculate_highlight(node)
 
-    if self.hl_pos == HL_POSITION.all or self.hl_pos == HL_POSITION.icon then
+    if self.range == "all" or self.range == "icon" then
       icon_hl = hl
     end
-    if self.hl_pos == HL_POSITION.all or self.hl_pos == HL_POSITION.name then
+    if self.range == "all" or self.range == "name" then
       name_hl = hl
     end
   end
@@ -42,7 +54,7 @@ end
 ---@param node Node
 ---@return string|nil name
 function Decorator:sign_name(node)
-  if not self.enabled or self.icon_placement ~= ICON_PLACEMENT.signcolumn then
+  if not self.enabled or self.icon_placement ~= "signcolumn" then
     return
   end
 
@@ -52,33 +64,33 @@ function Decorator:sign_name(node)
   end
 end
 
----Icons when ICON_PLACEMENT.before
+---Icons when "before"
 ---@param node Node
 ---@return HighlightedString[]|nil icons
 function Decorator:icons_before(node)
-  if not self.enabled or self.icon_placement ~= ICON_PLACEMENT.before then
+  if not self.enabled or self.icon_placement ~= "before" then
     return
   end
 
   return self:calculate_icons(node)
 end
 
----Icons when ICON_PLACEMENT.after
+---Icons when "after"
 ---@param node Node
 ---@return HighlightedString[]|nil icons
 function Decorator:icons_after(node)
-  if not self.enabled or self.icon_placement ~= ICON_PLACEMENT.after then
+  if not self.enabled or self.icon_placement ~= "after" then
     return
   end
 
   return self:calculate_icons(node)
 end
 
----Icons when ICON_PLACEMENT.right_align
+---Icons when "right_align"
 ---@param node Node
 ---@return HighlightedString[]|nil icons
 function Decorator:icons_right_align(node)
-  if not self.enabled or self.icon_placement ~= ICON_PLACEMENT.right_align then
+  if not self.enabled or self.icon_placement ~= "right_align" then
     return
   end
 
@@ -114,7 +126,7 @@ function Decorator:define_sign(icon)
 
     -- don't use sign if not defined
     if #icon.str < 1 then
-      self.icon_placement = ICON_PLACEMENT.none
+      self.icon_placement = "none"
       return
     end
 

lua/nvim-tree/renderer/decorator/modified.lua

@@ -1,37 +1,36 @@
-local buffers = require "nvim-tree.buffers"
+local buffers = require("nvim-tree.buffers")
 
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
+local Decorator = require("nvim-tree.renderer.decorator")
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
+local DirectoryNode = require("nvim-tree.node.directory")
 
-local Decorator = require "nvim-tree.renderer.decorator"
+---@class (exact) DecoratorModified: Decorator
+---@field icon HighlightedString?
+local DecoratorModified = Decorator:extend()
 
----@class DecoratorModified: Decorator
+---@class DecoratorModified
----@field icon HighlightedString|nil
+---@overload fun(explorer: DecoratorArgs): DecoratorModified
-local DecoratorModified = Decorator:new()
 
----@param opts table
+---@protected
----@return DecoratorModified
+---@param args DecoratorArgs
-function DecoratorModified:new(opts)
+function DecoratorModified:new(args)
-  local o = Decorator.new(self, {
+  Decorator.new(self, {
-    enabled = opts.modified.enable,
+    explorer       = args.explorer,
-    hl_pos = HL_POSITION[opts.renderer.highlight_modified] or HL_POSITION.none,
+    enabled        = true,
-    icon_placement = ICON_PLACEMENT[opts.renderer.icons.modified_placement] or ICON_PLACEMENT.none,
+    hl_pos         = args.explorer.opts.renderer.highlight_modified or "none",
+    icon_placement = args.explorer.opts.renderer.icons.modified_placement or "none",
   })
-  ---@cast o DecoratorModified
 
-  if not o.enabled then
+  if not self.enabled then
-    return o
+    return
   end
 
-  if opts.renderer.icons.show.modified then
+  if self.explorer.opts.renderer.icons.show.modified then
-    o.icon = {
+    self.icon = {
-      str = opts.renderer.icons.glyphs.modified,
+      str = self.explorer.opts.renderer.icons.glyphs.modified,
       hl = { "NvimTreeModifiedIcon" },
     }
-    o:define_sign(o.icon)
+    self:define_sign(self.icon)
   end
-
-  return o
 end
 
 ---Modified icon: modified.enable, renderer.icons.show.modified and node is modified
@@ -47,11 +46,11 @@ end
 ---@param node Node
 ---@return string|nil group
 function DecoratorModified:calculate_highlight(node)
-  if not self.enabled or self.hl_pos == HL_POSITION.none or not buffers.is_modified(node) then
+  if not self.enabled or self.range == "none" or not buffers.is_modified(node) then
     return nil
   end
 
-  if node.nodes then
+  if node:is(DirectoryNode) then
     return "NvimTreeModifiedFolderHL"
   else
     return "NvimTreeModifiedFileHL"

lua/nvim-tree/renderer/decorator/opened.lua

@@ -1,33 +1,30 @@
-local buffers = require "nvim-tree.buffers"
+local buffers = require("nvim-tree.buffers")
 
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
+local Decorator = require("nvim-tree.renderer.decorator")
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
 
-local Decorator = require "nvim-tree.renderer.decorator"
+---@class (exact) DecoratorOpened: Decorator
-
----@class DecoratorOpened: Decorator
----@field enabled boolean
 ---@field icon HighlightedString|nil
-local DecoratorOpened = Decorator:new()
+local DecoratorOpened = Decorator:extend()
 
----@param opts table
+---@class DecoratorOpened
----@return DecoratorOpened
+---@overload fun(explorer: DecoratorArgs): DecoratorOpened
-function DecoratorOpened:new(opts)
+
-  local o = Decorator.new(self, {
+---@protected
-    enabled = true,
+---@param args DecoratorArgs
-    hl_pos = HL_POSITION[opts.renderer.highlight_opened_files] or HL_POSITION.none,
+function DecoratorOpened:new(args)
-    icon_placement = ICON_PLACEMENT.none,
+  Decorator.new(self, {
+    explorer       = args.explorer,
+    enabled        = true,
+    hl_pos         = args.explorer.opts.renderer.highlight_opened_files or "none",
+    icon_placement = "none",
   })
-  ---@cast o DecoratorOpened
-
-  return o
 end
 
 ---Opened highlight: renderer.highlight_opened_files and node has an open buffer
 ---@param node Node
 ---@return string|nil group
 function DecoratorOpened:calculate_highlight(node)
-  if self.hl_pos ~= HL_POSITION.none and buffers.is_opened(node) then
+  if self.range ~= "none" and buffers.is_opened(node) then
     return "NvimTreeOpenedHL"
   end
 end

lua/nvim-tree/renderer/init.lua

@@ -1,36 +1,50 @@
-local core = require "nvim-tree.core"
+local log = require("nvim-tree.log")
-local log = require "nvim-tree.log"
+local view = require("nvim-tree.view")
-local view = require "nvim-tree.view"
+local events = require("nvim-tree.events")
-local events = require "nvim-tree.events"
 
-local _padding = require "nvim-tree.renderer.components.padding"
+local Class = require("nvim-tree.classic")
-local icon_component = require "nvim-tree.renderer.components.icons"
+local Builder = require("nvim-tree.renderer.builder")
-local full_name = require "nvim-tree.renderer.components.full-name"
-local Builder = require "nvim-tree.renderer.builder"
-
-local M = {}
 
 local SIGN_GROUP = "NvimTreeRendererSigns"
 
-local namespace_highlights_id = vim.api.nvim_create_namespace "NvimTreeHighlights"
+local namespace_highlights_id = vim.api.nvim_create_namespace("NvimTreeHighlights")
-local namespace_extmarks_id = vim.api.nvim_create_namespace "NvimTreeExtmarks"
+local namespace_extmarks_id = vim.api.nvim_create_namespace("NvimTreeExtmarks")
-local namespace_virtual_lines_id = vim.api.nvim_create_namespace "NvimTreeVirtualLines"
+local namespace_virtual_lines_id = vim.api.nvim_create_namespace("NvimTreeVirtualLines")
 
+---@class (exact) Renderer: Class
+---@field explorer Explorer
+local Renderer = Class:extend()
+
+---@class Renderer
+---@overload fun(args: RendererArgs): Renderer
+
+---@class (exact) RendererArgs
+---@field explorer Explorer
+
+---@protected
+---@param args RendererArgs
+function Renderer:new(args)
+  self.explorer = args.explorer
+end
+
+---@private
 ---@param bufnr number
 ---@param lines string[]
 ---@param hl_args AddHighlightArgs[]
 ---@param signs string[]
-local function _draw(bufnr, lines, hl_args, signs, extmarks, virtual_lines)
+---@param extmarks table[] extra marks for right icon placement
-  if vim.fn.has "nvim-0.10" == 1 then
+---@param virtual_lines table[] virtual lines for hidden count display
+function Renderer:_draw(bufnr, lines, hl_args, signs, extmarks, virtual_lines)
+  if vim.fn.has("nvim-0.10") == 1 then
     vim.api.nvim_set_option_value("modifiable", true, { buf = bufnr })
   else
     vim.api.nvim_buf_set_option(bufnr, "modifiable", true) ---@diagnostic disable-line: deprecated
   end
 
   vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
-  M.render_hl(bufnr, hl_args)
+  self:render_hl(bufnr, hl_args)
 
-  if vim.fn.has "nvim-0.10" == 1 then
+  if vim.fn.has("nvim-0.10") == 1 then
     vim.api.nvim_set_option_value("modifiable", false, { buf = bufnr })
   else
     vim.api.nvim_buf_set_option(bufnr, "modifiable", false) ---@diagnostic disable-line: deprecated
@@ -45,9 +59,9 @@ local function _draw(bufnr, lines, hl_args, signs, extmarks, virtual_lines)
   for i, extname in pairs(extmarks) do
     for _, mark in ipairs(extname) do
       vim.api.nvim_buf_set_extmark(bufnr, namespace_extmarks_id, i, -1, {
-        virt_text = { { mark.str, mark.hl } },
+        virt_text     = { { mark.str, mark.hl } },
         virt_text_pos = "right_align",
-        hl_mode = "combine",
+        hl_mode       = "combine",
       })
     end
   end
@@ -55,14 +69,15 @@ local function _draw(bufnr, lines, hl_args, signs, extmarks, virtual_lines)
   vim.api.nvim_buf_clear_namespace(bufnr, namespace_virtual_lines_id, 0, -1)
   for line_nr, vlines in pairs(virtual_lines) do
     vim.api.nvim_buf_set_extmark(bufnr, namespace_virtual_lines_id, line_nr, 0, {
-      virt_lines = vlines,
+      virt_lines         = vlines,
-      virt_lines_above = false,
+      virt_lines_above   = false,
       virt_lines_leftcol = true,
     })
   end
 end
 
-function M.render_hl(bufnr, hl)
+---@private
+function Renderer:render_hl(bufnr, hl)
   if not bufnr or not vim.api.nvim_buf_is_loaded(bufnr) then
     return
   end
@@ -76,20 +91,19 @@ function M.render_hl(bufnr, hl)
   end
 end
 
-function M.draw()
+function Renderer:draw()
   local bufnr = view.get_bufnr()
-  if not core.get_explorer() or not bufnr or not vim.api.nvim_buf_is_loaded(bufnr) then
+  if not bufnr or not vim.api.nvim_buf_is_loaded(bufnr) then
     return
   end
 
-  local profile = log.profile_start "draw"
+  local profile = log.profile_start("draw")
 
   local cursor = vim.api.nvim_win_get_cursor(view.get_winnr() or 0)
-  icon_component.reset_config()
 
-  local builder = Builder:new():build()
+  local builder = Builder(self.explorer):build()
 
-  _draw(bufnr, builder.lines, builder.hl_args, builder.signs, builder.extmarks, builder.virtual_lines)
+  self:_draw(bufnr, builder.lines, builder.hl_args, builder.signs, builder.extmarks, builder.virtual_lines)
 
   if cursor and #builder.lines >= cursor[1] then
     vim.api.nvim_win_set_cursor(view.get_winnr() or 0, cursor)
@@ -102,14 +116,4 @@ function M.draw()
   events._dispatch_on_tree_rendered(bufnr, view.get_winnr())
 end
 
-function M.setup(opts)
+return Renderer
-  M.config = opts.renderer
-
-  _padding.setup(opts)
-  full_name.setup(opts)
-  icon_component.setup(opts)
-
-  Builder.setup(opts)
-end
-
-return M

lua/nvim-tree/utils.lua

@@ -1,15 +1,15 @@
-local Iterator = require "nvim-tree.iterators.node-iterator"
+local Iterator = require("nvim-tree.iterators.node-iterator")
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
 
 local M = {
   debouncers = {},
 }
 
-M.is_unix = vim.fn.has "unix" == 1
+M.is_unix = vim.fn.has("unix") == 1
-M.is_macos = vim.fn.has "mac" == 1 or vim.fn.has "macunix" == 1
+M.is_macos = vim.fn.has("mac") == 1 or vim.fn.has("macunix") == 1
-M.is_wsl = vim.fn.has "wsl" == 1
+M.is_wsl = vim.fn.has("wsl") == 1
 -- false for WSL
-M.is_windows = vim.fn.has "win32" == 1 or vim.fn.has "win32unix" == 1
+M.is_windows = vim.fn.has("win32") == 1 or vim.fn.has("win32unix") == 1
 
 ---@param haystack string
 ---@param needle string
@@ -59,6 +59,34 @@ function M.path_basename(path)
   return path:sub(i + 1, #path)
 end
 
+--- Check if there are parentheses before brackets, it causes problems for windows.
+--- Refer to issue #2862 and #2961 for more details.
+local function has_parentheses_and_brackets(path)
+  local _, i_parentheses = path:find("(", 1, true)
+  local _, i_brackets = path:find("[", 1, true)
+  if i_parentheses and i_brackets then
+    return true
+  end
+  return false
+end
+
+--- Path normalizations for windows only
+local function win_norm_path(path)
+  if path == nil then
+    return path
+  end
+  local norm_path = path
+  -- Normalize for issue #2862 and #2961
+  if has_parentheses_and_brackets(norm_path) then
+    norm_path = norm_path:gsub("/", "\\")
+  end
+  -- Normalize the drive letter
+  norm_path = norm_path:gsub("^%l:", function(drive)
+    return drive:upper()
+  end)
+  return norm_path
+end
+
 --- Get a path relative to another path.
 ---@param path string
 ---@param relative_to string|nil
@@ -68,13 +96,18 @@ function M.path_relative(path, relative_to)
     return path
   end
 
-  local _, r = path:find(M.path_add_trailing(relative_to), 1, true)
+  local norm_path = path
-  local p = path
+  if M.is_windows then
+    norm_path = win_norm_path(norm_path)
+  end
+
+  local _, r = norm_path:find(M.path_add_trailing(relative_to), 1, true)
+  local p = norm_path
   if r then
     -- take the relative path starting after '/'
     -- if somehow given a completely matching path,
     -- returns ""
-    p = path:sub(r + 1)
+    p = norm_path:sub(r + 1)
   end
   return p
 end
@@ -112,8 +145,7 @@ function M.find_node(nodes, fn)
     end)
     :iterate()
   i = require("nvim-tree.view").is_root_folder_visible() and i or i - 1
-  local explorer = require("nvim-tree.core").get_explorer()
+  if node and node.explorer.live_filter.filter then
-  if explorer and explorer.live_filter.filter then
     i = i + 1
   end
   return node, i
@@ -121,7 +153,7 @@ end
 
 -- Find the line number of a node.
 -- Return -1 is node is nil or not found.
----@param node Node|nil
+---@param node Node?
 ---@return integer
 function M.find_node_line(node)
   if not node then
@@ -174,16 +206,6 @@ function M.get_node_from_path(path)
     :iterate()
 end
 
----Get the highest parent of grouped nodes
----@param node Node
----@return Node node or parent
-function M.get_parent_of_group(node)
-  while node and node.parent and node.parent.group_next do
-    node = node.parent
-  end
-  return node
-end
-
 M.default_format_hidden_count = function(hidden_count, simple)
   local parts = {}
   local total_count = 0
@@ -250,7 +272,7 @@ function M.rename_loaded_buffers(old_path, new_path)
         -- to avoid the 'overwrite existing file' error message on write for
         -- normal files
         local buftype
-        if vim.fn.has "nvim-0.10" == 1 then
+        if vim.fn.has("nvim-0.10") == 1 then
           buftype = vim.api.nvim_get_option_value("buftype", { buf = buf })
         else
           buftype = vim.api.nvim_buf_get_option(buf, "buftype") ---@diagnostic disable-line: deprecated
@@ -258,8 +280,8 @@ function M.rename_loaded_buffers(old_path, new_path)
 
         if buftype == "" then
           vim.api.nvim_buf_call(buf, function()
-            vim.cmd "silent! write!"
+            vim.cmd("silent! write!")
-            vim.cmd "edit"
+            vim.cmd("edit")
           end)
         end
       end
@@ -277,12 +299,20 @@ end
 ---@param path string
 ---@return string
 function M.canonical_path(path)
-  if M.is_windows and path:match "^%a:" then
+  if M.is_windows and path:match("^%a:") then
     return path:sub(1, 1):upper() .. path:sub(2)
   end
   return path
 end
 
+--- Escapes special characters in string for windows, refer to issue #2862 and #2961 for more details.
+local function escape_special_char_for_windows(path)
+  if has_parentheses_and_brackets(path) then
+    return path:gsub("\\", "/"):gsub("/ ", "\\ ")
+  end
+  return path:gsub("%(", "\\("):gsub("%)", "\\)")
+end
+
 --- Escapes special characters in string if windows else returns unmodified string.
 ---@param path string
 ---@return string|nil
@@ -290,7 +320,7 @@ function M.escape_special_chars(path)
   if path == nil then
     return path
   end
-  return M.is_windows and path:gsub("%(", "\\("):gsub("%)", "\\)") or path
+  return M.is_windows and escape_special_char_for_windows(path) or path
 end
 
 --- Create empty sub-tables if not present
@@ -467,13 +497,13 @@ function M.focus_file(path)
   local _, i = M.find_node(require("nvim-tree.core").get_explorer().nodes, function(node)
     return node.absolute_path == path
   end)
-  require("nvim-tree.view").set_cursor { i + 1, 1 }
+  require("nvim-tree.view").set_cursor({ i + 1, 1 })
 end
 
 ---Focus node passed as parameter if visible, otherwise focus first visible parent.
 ---If none of the parents is visible focus root.
 ---If node is nil do nothing.
----@param node Node|nil node to focus
+---@param node Node? node to focus
 function M.focus_node_or_parent(node)
   local explorer = require("nvim-tree.core").get_explorer()
 
@@ -487,7 +517,7 @@ function M.focus_node_or_parent(node)
     end)
 
     if found_node or node.parent == nil then
-      require("nvim-tree.view").set_cursor { i + 1, 1 }
+      require("nvim-tree.view").set_cursor({ i + 1, 1 })
       break
     end
 
@@ -510,7 +540,7 @@ end
 
 function M.clear_prompt()
   if vim.opt.cmdheight._value ~= 0 then
-    vim.cmd "normal! :"
+    vim.cmd("normal! :")
   end
 end
 
@@ -549,14 +579,6 @@ function M.array_remove_nils(array)
   end, array)
 end
 
----@param f fun(node: Node|nil)
----@return function
-function M.inject_node(f)
-  return function()
-    f(require("nvim-tree.lib").get_node_at_cursor())
-  end
-end
-
 --- Is the buffer named NvimTree_[0-9]+ a tree? filetype is "NvimTree" or not readable file.
 --- This is cheap, as the readable test should only ever be needed when resuming a vim session.
 ---@param bufnr number|nil may be 0 or nil for current
@@ -567,7 +589,7 @@ function M.is_nvim_tree_buf(bufnr)
   end
   if vim.api.nvim_buf_is_valid(bufnr) then
     local bufname = vim.api.nvim_buf_get_name(bufnr)
-    if vim.fn.fnamemodify(bufname, ":t"):match "^NvimTree_[0-9]+$" then
+    if vim.fn.fnamemodify(bufname, ":t"):match("^NvimTree_[0-9]+$") then
       if vim.bo[bufnr].filetype == "NvimTree" then
         return true
       elseif vim.fn.filereadable(bufname) == 0 then
@@ -578,4 +600,44 @@ function M.is_nvim_tree_buf(bufnr)
   return false
 end
 
+--- path is an executable file or directory
+---@param absolute_path string
+---@return boolean
+function M.is_executable(absolute_path)
+  if M.is_windows or M.is_wsl then
+    --- executable detection on windows is buggy and not performant hence it is disabled
+    return false
+  else
+    return vim.loop.fs_access(absolute_path, "X") or false
+  end
+end
+
+---List of all option info/values
+---@param opts vim.api.keyset.option passed directly to vim.api.nvim_get_option_info2 and vim.api.nvim_get_option_value
+---@param was_set boolean filter was_set
+---@return { info: vim.api.keyset.get_option_info, val: any }[]
+function M.enumerate_options(opts, was_set)
+  local res = {}
+
+  local infos = vim.tbl_filter(function(info)
+    if opts.buf and info.scope ~= "buf" then
+      return false
+    elseif opts.win and info.scope ~= "win" then
+      return false
+    else
+      return true
+    end
+  end, vim.api.nvim_get_all_options_info())
+
+  for _, info in vim.spairs(infos) do
+    local _, info2 = pcall(vim.api.nvim_get_option_info2, info.name, opts)
+    if not was_set or info2.was_set then
+      local val = pcall(vim.api.nvim_get_option_value, info.name, opts)
+      table.insert(res, { info = info2, val = val })
+    end
+  end
+
+  return res
+end
+
 return M

lua/nvim-tree/view.lua

@@ -1,6 +1,7 @@
-local events = require "nvim-tree.events"
+local events = require("nvim-tree.events")
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
-local log = require "nvim-tree.log"
+local log = require("nvim-tree.log")
+local notify = require("nvim-tree.notify")
 
 ---@class OpenInWinOpts
 ---@field hijack_current_buf boolean|nil default true
@@ -14,31 +15,31 @@ local DEFAULT_MAX_WIDTH = -1
 local DEFAULT_PADDING = 1
 
 M.View = {
-  adaptive_size = false,
+  adaptive_size        = false,
   centralize_selection = false,
-  tabpages = {},
+  tabpages             = {},
-  cursors = {},
+  cursors              = {},
-  hide_root_folder = false,
+  hide_root_folder     = false,
-  live_filter = {
+  live_filter          = {
     prev_focused_node = nil,
   },
-  winopts = {
+  winopts              = {
     relativenumber = false,
-    number = false,
+    number         = false,
-    list = false,
+    list           = false,
-    foldenable = false,
+    foldenable     = false,
-    winfixwidth = true,
+    winfixwidth    = true,
-    winfixheight = true,
+    winfixheight   = true,
-    spell = false,
+    spell          = false,
-    signcolumn = "yes",
+    signcolumn     = "yes",
-    foldmethod = "manual",
+    foldmethod     = "manual",
-    foldcolumn = "0",
+    foldcolumn     = "0",
-    cursorcolumn = false,
+    cursorcolumn   = false,
-    cursorline = true,
+    cursorline     = true,
-    cursorlineopt = "both",
+    cursorlineopt  = "both",
-    colorcolumn = "0",
+    colorcolumn    = "0",
-    wrap = false,
+    wrap           = false,
-    winhl = table.concat({
+    winhl          = table.concat({
       "EndOfBuffer:NvimTreeEndOfBuffer",
       "CursorLine:NvimTreeCursorLine",
       "CursorLineNr:NvimTreeCursorLineNr",
@@ -64,13 +65,15 @@ local tabinitial = {
 }
 
 local BUFNR_PER_TAB = {}
+
+---@type { name: string, value: any }[]
 local BUFFER_OPTIONS = {
-  swapfile = false,
+  { name = "bufhidden",  value = "wipe" },
-  buftype = "nofile",
+  { name = "buflisted",  value = false },
-  modifiable = false,
+  { name = "buftype",    value = "nofile" },
-  filetype = "NvimTree",
+  { name = "filetype",   value = "NvimTree" },
-  bufhidden = "wipe",
+  { name = "modifiable", value = false },
-  buflisted = false,
+  { name = "swapfile",   value = false },
 }
 
 ---@param bufnr integer
@@ -100,8 +103,9 @@ local function create_buffer(bufnr)
   BUFNR_PER_TAB[tab] = bufnr or vim.api.nvim_create_buf(false, false)
   vim.api.nvim_buf_set_name(M.get_bufnr(), "NvimTree_" .. tab)
 
-  for option, value in pairs(BUFFER_OPTIONS) do
+  bufnr = M.get_bufnr()
-    vim.bo[M.get_bufnr()][option] = value
+  for _, option in ipairs(BUFFER_OPTIONS) do
+    vim.api.nvim_set_option_value(option.name, option.value, { buf = bufnr })
   end
 
   require("nvim-tree.keymap").on_attach(M.get_bufnr())
@@ -123,6 +127,7 @@ local function get_size(size)
 end
 
 ---@param size (fun():integer)|integer|nil
+---@return integer
 local function get_width(size)
   if size then
     return get_size(size)
@@ -145,12 +150,26 @@ end
 
 local function set_window_options_and_buffer()
   pcall(vim.api.nvim_command, "buffer " .. M.get_bufnr())
-  local eventignore = vim.opt.eventignore:get()
+
-  vim.opt.eventignore = "all"
+  if vim.fn.has("nvim-0.10") == 1 then
-  for k, v in pairs(M.View.winopts) do
+    local eventignore = vim.api.nvim_get_option_value("eventignore", {})
-    vim.opt_local[k] = v
+    vim.api.nvim_set_option_value("eventignore", "all", {})
+
+    for k, v in pairs(M.View.winopts) do
+      vim.api.nvim_set_option_value(k, v, { scope = "local" })
+    end
+
+    vim.api.nvim_set_option_value("eventignore", eventignore, {})
+  else
+    local eventignore = vim.api.nvim_get_option("eventignore") ---@diagnostic disable-line: deprecated
+    vim.api.nvim_set_option("eventignore", "all") ---@diagnostic disable-line: deprecated
+
+    for k, v in pairs(M.View.winopts) do
+      vim.api.nvim_win_set_option(0, k, v) ---@diagnostic disable-line: deprecated
+    end
+
+    vim.api.nvim_set_option("eventignore", eventignore) ---@diagnostic disable-line: deprecated
   end
-  vim.opt.eventignore = eventignore
 end
 
 ---@return table
@@ -166,7 +185,7 @@ local function open_window()
   if M.View.float.enable then
     vim.api.nvim_open_win(0, true, open_win_config())
   else
-    vim.api.nvim_command "vsp"
+    vim.api.nvim_command("vsp")
     M.reposition_window()
   end
   setup_tabpage(vim.api.nvim_get_current_tabpage())
@@ -181,7 +200,7 @@ end
 
 ---@return number|nil
 local function get_alt_or_next_buf()
-  local alt_buf = vim.fn.bufnr "#"
+  local alt_buf = vim.fn.bufnr("#")
   if is_buf_displayed(alt_buf) then
     return alt_buf
   end
@@ -199,7 +218,7 @@ local function switch_buf_if_last_buf()
     if buf then
       vim.cmd("sb" .. buf)
     else
-      vim.cmd "new"
+      vim.cmd("new")
     end
   end
 end
@@ -213,7 +232,7 @@ end
 
 ---@param tabpage integer
 local function close(tabpage)
-  if not M.is_visible { tabpage = tabpage } then
+  if not M.is_visible({ tabpage = tabpage }) then
     return
   end
   save_tab_state(tabpage)
@@ -222,12 +241,16 @@ local function close(tabpage)
   local current_win = vim.api.nvim_get_current_win()
   for _, win in pairs(vim.api.nvim_tabpage_list_wins(tabpage)) do
     if vim.api.nvim_win_get_config(win).relative == "" then
-      local prev_win = vim.fn.winnr "#" -- this tab only
+      local prev_win = vim.fn.winnr("#") -- this tab only
       if tree_win == current_win and prev_win > 0 then
         vim.api.nvim_set_current_win(vim.fn.win_getid(prev_win))
       end
       if vim.api.nvim_win_is_valid(tree_win or 0) then
-        vim.api.nvim_win_close(tree_win or 0, true)
+        local success, error = pcall(vim.api.nvim_win_close, tree_win or 0, true)
+        if not success then
+          notify.debug("Failed to close window: " .. error)
+          return
+        end
       end
       events._dispatch_on_tree_close()
       return
@@ -259,7 +282,7 @@ function M.open(options)
     return
   end
 
-  local profile = log.profile_start "view open"
+  local profile = log.profile_start("view open")
 
   create_buffer()
   open_window()
@@ -267,7 +290,7 @@ function M.open(options)
 
   local opts = options or { focus_tree = true }
   if not opts.focus_tree then
-    vim.cmd "wincmd p"
+    vim.cmd("wincmd p")
   end
   events._dispatch_on_tree_open()
 
@@ -353,7 +376,7 @@ function M.resize(size)
   if new_size ~= vim.api.nvim_win_get_width(winnr) then
     vim.api.nvim_win_set_width(winnr, new_size)
     if not M.View.preserve_window_proportions then
-      vim.cmd ":wincmd ="
+      vim.cmd(":wincmd =")
     end
   end
 
@@ -406,6 +429,7 @@ function M.abandon_all_windows()
 end
 
 ---@param opts table|nil
+---@return boolean
 function M.is_visible(opts)
   if opts and opts.tabpage then
     if M.View.tabpages[opts.tabpage] == nil then
@@ -460,7 +484,7 @@ function M.winid(opts)
   if tabpage == 0 then
     tabpage = vim.api.nvim_get_current_tabpage()
   end
-  if M.is_visible { tabpage = tabpage } then
+  if M.is_visible({ tabpage = tabpage }) then
     return M.get_winnr(tabpage)
   else
     return nil
@@ -490,12 +514,6 @@ function M.get_bufnr()
   return BUFNR_PER_TAB[vim.api.nvim_get_current_tabpage()]
 end
 
----@param bufnr number
----@return boolean
-function M.is_buf_valid(bufnr)
-  return bufnr and vim.api.nvim_buf_is_valid(bufnr) and vim.api.nvim_buf_is_loaded(bufnr)
-end
-
 function M._prevent_buffer_override()
   local view_winnr = M.get_winnr()
   local view_bufnr = M.get_bufnr()
@@ -509,7 +527,7 @@ function M._prevent_buffer_override()
     local curbuf = vim.api.nvim_win_get_buf(curwin)
     local bufname = vim.api.nvim_buf_get_name(curbuf)
 
-    if not bufname:match "NvimTree" then
+    if not bufname:match("NvimTree") then
       for i, tabpage in ipairs(M.View.tabpages) do
         if tabpage.winnr == view_winnr then
           M.View.tabpages[i] = nil
@@ -523,10 +541,15 @@ function M._prevent_buffer_override()
 
     -- patch to avoid the overriding window to be fixed in size
     -- might need a better patch
-    vim.cmd "setlocal nowinfixwidth"
+    vim.cmd("setlocal nowinfixwidth")
-    vim.cmd "setlocal nowinfixheight"
+    vim.cmd("setlocal nowinfixheight")
-    M.open { focus_tree = false }
+    M.open({ focus_tree = false })
-    require("nvim-tree.renderer").draw()
+
+    local explorer = require("nvim-tree.core").get_explorer()
+    if explorer then
+      explorer.renderer:draw()
+    end
+
     pcall(vim.api.nvim_win_close, curwin, { force = true })
 
     -- to handle opening a file using :e when nvim-tree is on floating mode