Saving release notes

.editorconfig

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

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -59,9 +59,9 @@ body:
 
         If not provided it is very unlikely that the nvim-tree team will be able to address your issue.
 
-        See [wiki: Clean Room Replication](https://github.com/nvim-tree/nvim-tree.lua/wiki/Troubleshooting#clean-room-replication) for instructions and paste the contents of your `/tmp/nvt-min.lua` here.
+        See [wiki: Clean Room Replication](https://github.com/nvim-tree/nvim-tree.lua/wiki/Troubleshooting#clean-room-replication) for instructions.
 
-        Please do NOT post a configuration that uses other plugin managers such as lazy, see [wiki: Lazy Loading](https://github.com/nvim-tree/nvim-tree.lua/wiki/Installation#lazy-loading)"
+        Please paste the contents of your `/tmp/nvt-min.lua` here."
       render: lua
     validations:
       required: true

.github/workflows/ci.yml

@@ -2,9 +2,11 @@ name: CI
 
 on:
   pull_request:
+    branches:
+      - '*'
   push:
-    branches: [master]
+    branches:
-  workflow_dispatch:
+      - master
 
 permissions:
   contents: read
@@ -12,83 +14,29 @@ permissions:
 jobs:
   lint:
     runs-on: ubuntu-latest
-
-    concurrency:
-      group: ${{ github.workflow }}-${{ matrix.lua_version }}-${{ github.head_ref || github.ref_name }}
-      cancel-in-progress: true
-
-    strategy:
-      matrix:
-        lua_version: [ 5.1 ]
-
     steps:
       - uses: actions/checkout@v4
 
       - uses: leafo/gh-actions-lua@v10
         with:
-          luaVersion: ${{ matrix.lua_version }}
+          luaVersion: "5.1"
 
       - uses: leafo/gh-actions-luarocks@v4
 
-      - run: luarocks install luacheck 1.1.1
+      - name: luacheck
-
+        run: |
-      - run: make lint
+          luarocks install luacheck 1.1.1
+          luacheck lua
 
   style:
     runs-on: ubuntu-latest
-
-    concurrency:
-      group: ${{ github.workflow }}-${{ matrix.emmy_lua_code_style_version }}-${{ github.head_ref || github.ref_name }}
-      cancel-in-progress: true
-
-    strategy:
-      matrix:
-        emmy_lua_code_style_version: [ 1.5.6 ]
-
     steps:
       - uses: actions/checkout@v4
 
-      - name: install emmy_lua_code_style
+      - name: stylua
-        run: |
+        uses: JohnnyMorganz/stylua-action@v3
-          mkdir -p CodeFormat
-          curl -L "https://github.com/CppCXY/EmmyLuaCodeStyle/releases/download/${{ matrix.emmy_lua_code_style_version }}/linux-x64.tar.gz" | tar zx --directory CodeFormat
-
-      - run: echo "CodeFormat/linux-x64/bin" >> "$GITHUB_PATH"
-
-      - run: make style
-
-      - run: make style-doc
-
-  check:
-    runs-on: ubuntu-latest
-
-    concurrency:
-      group: ${{ github.workflow }}-${{ matrix.nvim_version }}-${{ matrix.luals_version }}-${{ github.head_ref || github.ref_name }}
-      cancel-in-progress: true
-
-    strategy:
-      matrix:
-        nvim_version: [ stable, nightly ]
-        luals_version: [ 3.10.5 ]
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: rhysd/action-setup-vim@v1
         with:
-          neovim: true
+          token: ${{ secrets.GITHUB_TOKEN }}
-          version: ${{ matrix.nvim_version }}
+          version: "0.19"
+          args: --check lua
 
-      - name: install luals
-        run: |
-          mkdir -p luals
-          curl -L "https://github.com/LuaLS/lua-language-server/releases/download/${{ matrix.luals_version }}/lua-language-server-${{ matrix.luals_version }}-linux-x64.tar.gz" | tar zx --directory luals
-
-      - run: echo "luals/bin" >> "$GITHUB_PATH"
-
-      - name: make check
-        env:
-          VIMRUNTIME: /home/runner/nvim-${{ matrix.nvim_version }}/share/nvim/runtime
-        run: make check
-
-      - run: make help-check

.github/workflows/luarocks-release.yml

@@ -1,37 +0,0 @@
-name: Luarocks Release
-on:
-  push:
-    tags:
-      - 'v[0-9]+.[0-9]+.[0-9]+'
-  workflow_dispatch:
-jobs:
-  luarocks-upload:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: LuaRocks Upload
-        uses: nvim-neorocks/luarocks-tag-release@v7
-        env:
-          LUAROCKS_API_KEY: ${{ secrets.LUAROCKS_API_KEY }}
-        with:
-          summary: A File Explorer For Neovim
-          detailed_description: |
-            Automatic updates
-
-            File type icons
-
-            Git integration
-
-            Diagnostics integration - LSP and COC
-
-            (Live) filtering
-
-            Cut, copy, paste, rename, delete, create etc.
-
-            Highly customisable
-
-            Rich API
-          license: "GPL-3.0"
-          labels: neovim
-          dependencies: |
-            nvim-web-devicons

.github/workflows/release-please.yml

@@ -2,20 +2,17 @@ on:
   push:
     branches:
       - master
-  workflow_dispatch:
-concurrency:
-  group: ${{ github.workflow }}
-  cancel-in-progress: true
 name: release-please
-permissions:
-  contents: write
-  pull-requests: write
 jobs:
   release-please:
     runs-on: ubuntu-latest
     steps:
       - uses: google-github-actions/release-please-action@v4
         id: release
+        with:
+          release-type: simple
+          package-name: nvim-tree
+          command: github-release
       - uses: actions/checkout@v4
       - name: tag major and minor versions
         if: ${{ steps.release.outputs.release_created }}
@@ -23,15 +20,11 @@ jobs:
           git config user.name github-actions[bot]
           git config user.email 41898282+github-actions[bot]@users.noreply.github.com
           git remote add gh-token "https://${{ secrets.GITHUB_TOKEN }}@github.com/google-github-actions/release-please-action.git"
-          git tag -d       v${{ steps.release.outputs.major }}                                                                       || true
+          git tag -d v${{ steps.release.outputs.major }} || true
-          git tag -d       v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}                                    || true
+          git tag -d v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }} || true
-          git tag -d       v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}.${{ steps.release.outputs.patch }} || true
+          git push origin :v${{ steps.release.outputs.major }} || true
-          git push origin :v${{ steps.release.outputs.major }}                                                                       || true
+          git push origin :v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }} || true
-          git push origin :v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}                                    || true
+          git tag -a v${{ steps.release.outputs.major }} -m "Release v${{ steps.release.outputs.major }}"
-          git push origin :v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}.${{ steps.release.outputs.patch }} || true
+          git tag -a v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }} -m "Release v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}"
-          git tag -a       v${{ steps.release.outputs.major }}                                                                       -m "Release v${{ steps.release.outputs.major }}"
+          git push origin v${{ steps.release.outputs.major }}
-          git tag -a       v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}                                    -m "Release v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}"
+          git push origin v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}
-          git tag -a       v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}.${{ steps.release.outputs.patch }} -m "Release v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}.${{ steps.release.outputs.patch }}"
-          git push origin  v${{ steps.release.outputs.major }}
-          git push origin  v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}
-          git push origin  v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}.${{ steps.release.outputs.patch }}

.github/workflows/semantic-pr-subject.yml

@@ -6,14 +6,10 @@ on:
       - reopened
       - edited
       - synchronize
-  workflow_dispatch:
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref }}
-  cancel-in-progress: true
 jobs:
   semantic-pr-subject:
     runs-on: ubuntu-latest
     steps:
-      - uses: amannn/action-semantic-pull-request@v5.5.3
+      - uses: amannn/action-semantic-pull-request@v5.4.0
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,4 +0,0 @@
-/luals-out/
-/luals/
-# backup vim files
-*~

.hooks/pre-commit.sh

@@ -1,3 +1,4 @@
-#!/bin/sh
+#!/usr/bin/env bash
 
-make
+stylua . --check || exit 1
+luacheck . || exit 1

.luarc.json

@@ -1,15 +1,10 @@
 {
   "$schema": "https://raw.githubusercontent.com/sumneko/vscode-lua/master/setting/schema.json",
-  "runtime.version": "Lua 5.1",
+  "runtime.version" : "Lua 5.1",
-  "workspace": {
-    "library": [
-      "$VIMRUNTIME/lua/vim",
-      "${3rd}/luv/library"
-    ]
-  },
   "diagnostics": {
-    "libraryFiles": "Disable",
+    "globals": [
-    "globals": [],
+      "vim"
+    ],
     "neededFileStatus": {
       "ambiguity-1": "Any",
       "assign-type-mismatch": "Any",
@@ -31,19 +26,11 @@
       "duplicate-index": "Any",
       "duplicate-set-field": "Any",
       "empty-block": "Any",
-      "global-element": "Any",
       "global-in-nil-env": "Any",
-      "incomplete-signature-doc": "None",
-      "inject-field": "Any",
-      "invisible": "Any",
       "lowercase-global": "Any",
-      "missing-fields": "Any",
-      "missing-global-doc": "Any",
-      "missing-local-export-doc": "None",
       "missing-parameter": "Any",
       "missing-return": "Any",
       "missing-return-value": "Any",
-      "name-style-check": "None",
       "need-check-nil": "Any",
       "newfield-call": "Any",
       "newline-call": "Any",
@@ -76,3 +63,4 @@
     }
   }
 }
+

.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "1.7.1"
-}

.stylua.toml

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

CHANGELOG.md

@@ -1,210 +0,0 @@
-# Changelog
-
-## [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)
-
-
-### Bug Fixes
-
-* **#2794:** sshfs compatibility ([#2893](https://github.com/nvim-tree/nvim-tree.lua/issues/2893)) ([2d6e64d](https://github.com/nvim-tree/nvim-tree.lua/commit/2d6e64dd8c45a86f312552b7a47eef2c8623a25c))
-* **#2868:** windows: do not visit unenumerable directories such as Application Data ([#2874](https://github.com/nvim-tree/nvim-tree.lua/issues/2874)) ([2104786](https://github.com/nvim-tree/nvim-tree.lua/commit/210478677cb9d672c4265deb0e9b59d58b675bd4))
-* **#2878:** nowrapscan prevents move from root ([#2880](https://github.com/nvim-tree/nvim-tree.lua/issues/2880)) ([4234095](https://github.com/nvim-tree/nvim-tree.lua/commit/42340952af598a08ab80579d067b6da72a9e6d29))
-* **#2879:** remove unnecessary tree window width setting to prevent unnecessary :wincmd = ([#2881](https://github.com/nvim-tree/nvim-tree.lua/issues/2881)) ([d43ab67](https://github.com/nvim-tree/nvim-tree.lua/commit/d43ab67d0eb4317961c5e9d15fffe908519debe0))
-
-## [1.6.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.5.0...nvim-tree-v1.6.0) (2024-08-10)
-
-
-### Features
-
-* **#2225:** add renderer.hidden_display to show a summary of hidden files below the tree ([#2856](https://github.com/nvim-tree/nvim-tree.lua/issues/2856)) ([e25eb7f](https://github.com/nvim-tree/nvim-tree.lua/commit/e25eb7fa83f7614bb23d762e91d2de44fcd7103b))
-* **#2349:** add "right_align" option for renderer.icons.*_placement ([#2839](https://github.com/nvim-tree/nvim-tree.lua/issues/2839)) ([1d629a5](https://github.com/nvim-tree/nvim-tree.lua/commit/1d629a5d3f7d83d516494c221a2cfc079f43bc47))
-* **#2349:** add "right_align" option for renderer.icons.*_placement ([#2846](https://github.com/nvim-tree/nvim-tree.lua/issues/2846)) ([48d0e82](https://github.com/nvim-tree/nvim-tree.lua/commit/48d0e82f9434691cc50d970898142a8c084a49d6))
-* add renderer.highlight_hidden, renderer.icons.show.hidden and renderer.icons.hidden_placement for dotfile icons/highlights ([#2840](https://github.com/nvim-tree/nvim-tree.lua/issues/2840)) ([48a9290](https://github.com/nvim-tree/nvim-tree.lua/commit/48a92907575df1dbd7242975a04e98169cb3a115))
-
-
-### Bug Fixes
-
-* **#2859:** make sure window still exists when restoring options ([#2863](https://github.com/nvim-tree/nvim-tree.lua/issues/2863)) ([466fbed](https://github.com/nvim-tree/nvim-tree.lua/commit/466fbed3e4b61fcc23a48fe99de7bfa264a9fee8))
-
-## [1.5.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.4.0...nvim-tree-v1.5.0) (2024-07-11)
-
-
-### Features
-
-* **#2127:** add experimental.actions.open_file.relative_path to open files with a relative path rather than absolute ([#2805](https://github.com/nvim-tree/nvim-tree.lua/issues/2805)) ([869c064](https://github.com/nvim-tree/nvim-tree.lua/commit/869c064721a6c2091f22c3541e8f0ff958361771))
-* **#2598:** add api.tree.resize ([#2811](https://github.com/nvim-tree/nvim-tree.lua/issues/2811)) ([2ede0de](https://github.com/nvim-tree/nvim-tree.lua/commit/2ede0de67b47e89e2b4cb488ea3f58b8f5a8c90a))
-* **#2799:** `filesystem_watchers.ignore_dirs` and `git.disable_for_dirs` may be functions ([#2800](https://github.com/nvim-tree/nvim-tree.lua/issues/2800)) ([8b2c5c6](https://github.com/nvim-tree/nvim-tree.lua/commit/8b2c5c678be4b49dff6a2df794877000113fd77b))
-* **#2799:** filesystem_watchers.ignore_dirs and git.disable_for_dirs may be functions ([8b2c5c6](https://github.com/nvim-tree/nvim-tree.lua/commit/8b2c5c678be4b49dff6a2df794877000113fd77b))
-
-
-### Bug Fixes
-
-* **#2813:** macos: enable file renaming with changed capitalization ([#2814](https://github.com/nvim-tree/nvim-tree.lua/issues/2814)) ([abfd1d1](https://github.com/nvim-tree/nvim-tree.lua/commit/abfd1d1b6772540364743531cc0331e08a0027a9))
-* **#2819:** experimental.actions.open_file.relative_path issue following change directory ([#2820](https://github.com/nvim-tree/nvim-tree.lua/issues/2820)) ([12a9a99](https://github.com/nvim-tree/nvim-tree.lua/commit/12a9a995a455d2c2466e47140663275365a5d2fc))
-
-## [1.4.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.3.3...nvim-tree-v1.4.0) (2024-06-09)
-
-### Notice
-
-* Neovim 0.9 is now the minimum supported version; please upgrade to neovim release version 0.9 or 0.10.
-
-### Reverts
-
-* **#2781:** "refactor: replace deprecated use of vim.diagnostic.is_disabled()" ([#2784](https://github.com/nvim-tree/nvim-tree.lua/issues/2784)) ([517e4fb](https://github.com/nvim-tree/nvim-tree.lua/commit/517e4fbb9ef3c0986da7047f44b4b91a2400f93c))
-
-
-### Miscellaneous Chores
-
-* release 1.4.0 ([1cac800](https://github.com/nvim-tree/nvim-tree.lua/commit/1cac8005df6da484c97499247754afa59fef92db))
-
-## [1.3.3](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.3.2...nvim-tree-v1.3.3) (2024-05-14)
-
-
-### Bug Fixes
-
-* nil access exception with git integration when changing branches ([#2774](https://github.com/nvim-tree/nvim-tree.lua/issues/2774)) ([340d3a9](https://github.com/nvim-tree/nvim-tree.lua/commit/340d3a9795e06bdd1814228de398cd510f9bfbb0))
-
-## [1.3.2](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.3.1...nvim-tree-v1.3.2) (2024-05-12)
-
-
-### Bug Fixes
-
-* **#2758:** use nvim-webdevicons default file icon, not renderer.icons.glyphs.default, as per :help ([#2759](https://github.com/nvim-tree/nvim-tree.lua/issues/2759)) ([347e1eb](https://github.com/nvim-tree/nvim-tree.lua/commit/347e1eb35264677f66a79466bb5e3d111968e12c))
-* **#2758:** use nvim-webdevicons default for default files ([347e1eb](https://github.com/nvim-tree/nvim-tree.lua/commit/347e1eb35264677f66a79466bb5e3d111968e12c))
-* **#925:** handle newlines in file names ([#2754](https://github.com/nvim-tree/nvim-tree.lua/issues/2754)) ([64f61e4](https://github.com/nvim-tree/nvim-tree.lua/commit/64f61e4c913047a045ff90bd188dd3b54ee443cf))
-
-## [1.3.1](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.3.0...nvim-tree-v1.3.1) (2024-04-25)
-
-
-### Bug Fixes
-
-* **#2535:** TextYankPost event sends vim.v.event ([#2734](https://github.com/nvim-tree/nvim-tree.lua/issues/2734)) ([d8d3a15](https://github.com/nvim-tree/nvim-tree.lua/commit/d8d3a1590a05b2d8b5eb26e2ed1c6052b1b47a77))
-* **#2733:** escape trash path ([#2735](https://github.com/nvim-tree/nvim-tree.lua/issues/2735)) ([81eb8d5](https://github.com/nvim-tree/nvim-tree.lua/commit/81eb8d519233c105f30dc0a278607e62b20502fd))
-
-## [1.3.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.2.0...nvim-tree-v1.3.0) (2024-03-30)
-
-
-### Features
-
-* add update_focused_file.exclude  ([#2673](https://github.com/nvim-tree/nvim-tree.lua/issues/2673)) ([e20966a](https://github.com/nvim-tree/nvim-tree.lua/commit/e20966ae558524f8d6f93dc37f5d2a8605f893e2))
-
-
-### Bug Fixes
-
-* **#2658:** change SpellCap groups to reduce confusion: ExecFile->Question, ImageFile->Question, SpecialFile->Title, Symlink->Underlined; add all other highlight groups to :NvimTreeHiTest ([#2732](https://github.com/nvim-tree/nvim-tree.lua/issues/2732)) ([0aca092](https://github.com/nvim-tree/nvim-tree.lua/commit/0aca0920f44b12a8383134bcb52da9faec123608))
-* bookmark filter shows marked directory children ([#2719](https://github.com/nvim-tree/nvim-tree.lua/issues/2719)) ([2d97059](https://github.com/nvim-tree/nvim-tree.lua/commit/2d97059661c83787372c8c003e743c984ba3ac50))
-
-## [1.2.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.1.1...nvim-tree-v1.2.0) (2024-03-24)
-
-
-### Features
-
-* add api.tree.toggle_enable_filters ([#2706](https://github.com/nvim-tree/nvim-tree.lua/issues/2706)) ([f7c09bd](https://github.com/nvim-tree/nvim-tree.lua/commit/f7c09bd72e50e1795bd3afb9e2a2b157b4bfb3c3))
-
-## [1.1.1](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.1.0...nvim-tree-v1.1.1) (2024-03-15)
-
-
-### Bug Fixes
-
-* **#2395:** marks.bulk.move defaults to directory at cursor ([#2688](https://github.com/nvim-tree/nvim-tree.lua/issues/2688)) ([cfea5bd](https://github.com/nvim-tree/nvim-tree.lua/commit/cfea5bd0806aab41bef6014c6cf5a510910ddbdb))
-* **#2705:** change NvimTreeWindowPicker cterm background from Cyan to more visible DarkBlue ([#2708](https://github.com/nvim-tree/nvim-tree.lua/issues/2708)) ([1fd9c98](https://github.com/nvim-tree/nvim-tree.lua/commit/1fd9c98960463d2d5d400916c0633b2df016941d))
-* bookmark filter should include parent directory ([#2704](https://github.com/nvim-tree/nvim-tree.lua/issues/2704)) ([76b9810](https://github.com/nvim-tree/nvim-tree.lua/commit/76b98109f62caa12b2f1dff472060b2233ea2e90))
-
-## [1.1.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.0.0...nvim-tree-v1.1.0) (2024-03-14)
-
-
-### Features
-
-* **#2630:** file renames can now create directories ([#2657](https://github.com/nvim-tree/nvim-tree.lua/issues/2657)) ([efafd73](https://github.com/nvim-tree/nvim-tree.lua/commit/efafd73efa9bc8c26282aed563ba0f01c7465b06))
-* add api.fs.copy.basename, default mapping ge ([#2698](https://github.com/nvim-tree/nvim-tree.lua/issues/2698)) ([8f2a50f](https://github.com/nvim-tree/nvim-tree.lua/commit/8f2a50f1cd0c64003042364cf317c8788eaa6c8c))
-
-
-### Bug Fixes
-
-* **#2695:** git toplevel guard against missing paths ([#2696](https://github.com/nvim-tree/nvim-tree.lua/issues/2696)) ([3c4267e](https://github.com/nvim-tree/nvim-tree.lua/commit/3c4267eb5045fa86b67fe40c0c63d31efc801e77))
-* searchcount exception on invalid search regex ([#2693](https://github.com/nvim-tree/nvim-tree.lua/issues/2693)) ([041dbd1](https://github.com/nvim-tree/nvim-tree.lua/commit/041dbd18f440207ad161503a384e7c82d575db66))
-
-## [1.0.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v0.100.0...nvim-tree-v1.0.0) (2024-02-18)
-
-
-### Features
-
-* **#2654:** filters.custom may be a function ([#2655](https://github.com/nvim-tree/nvim-tree.lua/issues/2655)) ([4a87b8b](https://github.com/nvim-tree/nvim-tree.lua/commit/4a87b8b46b4a30107971871df3cb7f4c30fdd5d0))
-
-
-### Miscellaneous Chores
-
-* release 1.0.0 ([#2678](https://github.com/nvim-tree/nvim-tree.lua/issues/2678)) ([d16246a](https://github.com/nvim-tree/nvim-tree.lua/commit/d16246a7575538f77e9246520449b99333c469f7))
-
-## [0.100.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v0.99.0...nvim-tree-v0.100.0) (2024-02-11)
-
-
-### Features
-
-* **#1389:** api: recursive node navigation for git and diagnostics ([#2525](https://github.com/nvim-tree/nvim-tree.lua/issues/2525)) ([5d13cc8](https://github.com/nvim-tree/nvim-tree.lua/commit/5d13cc8205bce4963866f73c50f6fdc18a515ffe))
-* **#2415:** add :NvimTreeHiTest ([#2664](https://github.com/nvim-tree/nvim-tree.lua/issues/2664)) ([b278fc2](https://github.com/nvim-tree/nvim-tree.lua/commit/b278fc25ae0fc95e4808eb5618f07fc2522fd2b3))
-* **#2415:** colour and highlight overhaul, see :help nvim-tree-highlight-overhaul ([#2455](https://github.com/nvim-tree/nvim-tree.lua/issues/2455)) ([e9c5abe](https://github.com/nvim-tree/nvim-tree.lua/commit/e9c5abe073a973f54d3ca10bfe30f253569f4405))
-* add node.open.toggle_group_empty, default mapping L ([#2647](https://github.com/nvim-tree/nvim-tree.lua/issues/2647)) ([8cbb1db](https://github.com/nvim-tree/nvim-tree.lua/commit/8cbb1db8e90b62fc56f379992e622e9f919792ce))
-
-
-### Bug Fixes
-
-* **#2415:** disambiguate highlight groups, see :help nvim-tree-highlight-overhaul ([#2639](https://github.com/nvim-tree/nvim-tree.lua/issues/2639)) ([d9cb432](https://github.com/nvim-tree/nvim-tree.lua/commit/d9cb432d2c8d8fa9267ddbd7535d76fe4df89360))
-* **#2415:** fix NvimTreeIndentMarker highlight group: FileIcon->FolderIcon ([e9ac136](https://github.com/nvim-tree/nvim-tree.lua/commit/e9ac136a3ab996aa8e4253253521dcf2cb66b81b))
-* **#2415:** highlight help header and mappings ([#2669](https://github.com/nvim-tree/nvim-tree.lua/issues/2669)) ([39e6fef](https://github.com/nvim-tree/nvim-tree.lua/commit/39e6fef85ac3bb29532b877aa7c9c34911c661af))
-* **#2415:** nvim 0.8 highlight overhaul support, limited to only show highest highlight precedence ([#2642](https://github.com/nvim-tree/nvim-tree.lua/issues/2642)) ([f39f7b6](https://github.com/nvim-tree/nvim-tree.lua/commit/f39f7b6fcd3865ac2146de4cb4045286308f2935))
-* **#2415:** NvimTreeIndentMarker highlight group: FileIcon->FolderIcon ([#2656](https://github.com/nvim-tree/nvim-tree.lua/issues/2656)) ([e9ac136](https://github.com/nvim-tree/nvim-tree.lua/commit/e9ac136a3ab996aa8e4253253521dcf2cb66b81b))
-* **#2624:** open file from docked floating window ([#2627](https://github.com/nvim-tree/nvim-tree.lua/issues/2627)) ([f24afa2](https://github.com/nvim-tree/nvim-tree.lua/commit/f24afa2cef551122b8bd53bb2e4a7df42343ce2e))
-* **#2632:** occasional error stack when locating nvim-tree window ([#2633](https://github.com/nvim-tree/nvim-tree.lua/issues/2633)) ([48b1d86](https://github.com/nvim-tree/nvim-tree.lua/commit/48b1d8638fa3726236ae22e0e48a74ac8ea6592a))
-* **#2637:** show buffer modified icons and highlights ([#2638](https://github.com/nvim-tree/nvim-tree.lua/issues/2638)) ([7bdb220](https://github.com/nvim-tree/nvim-tree.lua/commit/7bdb220d0fe604a77361e92cdbc7af1b8a412126))
-* **#2643:** correctly apply linked highlight groups in tree window ([#2653](https://github.com/nvim-tree/nvim-tree.lua/issues/2653)) ([fbee8a6](https://github.com/nvim-tree/nvim-tree.lua/commit/fbee8a69a46f558d29ab84e96301425b0501c668))
-* allow highlight overrides for DEFAULT_DEFS: NvimTreeFolderIcon, NvimTreeWindowPicker ([#2636](https://github.com/nvim-tree/nvim-tree.lua/issues/2636)) ([74525ac](https://github.com/nvim-tree/nvim-tree.lua/commit/74525ac04760bf0d9fec2bf51474d2b05f36048e))
-* bad column offset when using full_name ([#2629](https://github.com/nvim-tree/nvim-tree.lua/issues/2629)) ([75ff64e](https://github.com/nvim-tree/nvim-tree.lua/commit/75ff64e6663fc3b23c72dca32b2f838acefe7c8a))
-* passing nil as window handle in view.get_winnr ([48b1d86](https://github.com/nvim-tree/nvim-tree.lua/commit/48b1d8638fa3726236ae22e0e48a74ac8ea6592a))
-
-## 0.99.0 (2024-01-01)
-
-
-### Features
-
-* **#1850:** add "no bookmark" filter ([#2571](https://github.com/nvim-tree/nvim-tree.lua/issues/2571)) ([8f92e1e](https://github.com/nvim-tree/nvim-tree.lua/commit/8f92e1edd399f839a23776dcc6eee4ba18030370))
-* add kind param to vim.ui.select function calls ([#2602](https://github.com/nvim-tree/nvim-tree.lua/issues/2602)) ([dc839a7](https://github.com/nvim-tree/nvim-tree.lua/commit/dc839a72a6496ce22ebd3dd959115cf97c1b20a0))
-* add option to skip gitignored files on git navigation ([#2583](https://github.com/nvim-tree/nvim-tree.lua/issues/2583)) ([50f30bc](https://github.com/nvim-tree/nvim-tree.lua/commit/50f30bcd8c62ac4a83d133d738f268279f2c2ce2))
-
-
-### Bug Fixes
-
-* **#2519:** Diagnostics Not Updated When Tree Not Visible ([#2597](https://github.com/nvim-tree/nvim-tree.lua/issues/2597)) ([96a783f](https://github.com/nvim-tree/nvim-tree.lua/commit/96a783fbd606a458bcce2ef8041240a8b94510ce))
-* **#2609:** help toggle ([#2611](https://github.com/nvim-tree/nvim-tree.lua/issues/2611)) ([fac4900](https://github.com/nvim-tree/nvim-tree.lua/commit/fac4900bd18a9fa15be3d104645d9bdef7b3dcec))
-* hijack_cursor on update focused file and vim search ([#2600](https://github.com/nvim-tree/nvim-tree.lua/issues/2600)) ([02ae523](https://github.com/nvim-tree/nvim-tree.lua/commit/02ae52357ba4da77a4c120390791584a81d15340))

CONTRIBUTING.md

@@ -4,119 +4,35 @@ Thank you for contributing.
 
 See [Development](https://github.com/nvim-tree/nvim-tree.lua/wiki/Development) for environment setup, tips and tools.
 
-# Tools
+## Styling and formatting
 
-Following are used during CI and strongly recommended during local development.
+Code is formatted using luacheck, and linted using stylua.
+You can install these with:
 
-Language server: [luals](https://luals.github.io)
+```bash
-
+luarocks install luacheck
-Lint: [luacheck](https://github.com/lunarmodules/luacheck/)
+cargo install stylua
-
-Style: [EmmyLuaCodeStyle](https://github.com/CppCXY/EmmyLuaCodeStyle): `CodeCheck`
-
-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`
-
-# Quality
-
-The following quality checks are mandatory and are performed during CI. They run on the entire `lua` directory and return 1 on any failure.
-
-You can run them all via `make` or `make all`
-
-You can setup git hooks to run all checks by running `scripts/setup-hooks.sh`
-
-## lint
-
-1. Runs luacheck quietly using `.luacheck` settings
-
-```sh
-make lint
 ```
 
-## style
+You can setup the git hooks by running `scripts/setup-hooks.sh`.
 
-1. Runs CodeCheck using `.editorconfig` settings
+## Adding new actions
-1. Runs `scripts/doc-comments.sh` to validate annotated documentation
-
-```sh
-make style
-```
-
-You can automatically fix `CodeCheck` issues via:
-
-```sh
-make style-fix
-```
-
-## check
-
-1. Runs the checks that the LSP lua language server runs inside nvim using `.luarc.json` via `scripts/luals-check.sh`
-
-```sh
-make check
-```
-
-Assumes `$VIMRUNTIME` is `/usr/share/nvim/runtime`. Adjust as necessary e.g.
-
-```sh
-VIMRUNTIME="/my/path/to/runtime" make check
-```
-
-If `lua-language-server` is not available or `--check` doesn't function (e.g. Arch Linux 3.9.1-1) you can manually install it as per `ci.yml` e.g.
-
-```sh
-mkdir luals
-curl -L "https://github.com/LuaLS/lua-language-server/releases/download/3.9.1/lua-language-server-3.9.1-linux-x64.tar.gz" | tar zx --directory luals
-
-PATH="luals/bin:${PATH}" make check
-```
-
-# Adding New Actions
 
 To add a new action, add a file in `actions/name-of-the-action.lua`. You should export a `setup` function if some configuration is needed.
+Once you did, you should run the `scripts/update-help.sh`.
 
-Once you did, you should run `make help-update`
+## Documentation
-
-# Documentation
-
-## Opts
 
 When adding new options, you should declare the defaults in the main `nvim-tree.lua` file.
+Once you did, you should run the `scripts/update-help.sh`.
 
 Documentation for options should also be added to `nvim-tree-opts` in `doc/nvim-tree-lua.txt`
 
-## API
+## Pull Request
 
-When adding or changing API please update :help nvim-tree-api
+Please reference any issues in the description e.g. "resolves #1234".
-
-# Pull Request
-
-Please reference any issues in the description e.g. "resolves #1234", which will be closed upon merge.
 
 Please check "allow edits by maintainers" to allow nvim-tree developers to make small changes such as documentation tweaks.
 
-## Subject
+A test case to reproduce the issue is required. A ["Clean Room" Replication](https://github.com/nvim-tree/nvim-tree.lua/wiki/Troubleshooting#clean-room-replication) is preferred.
 
-The merge commit message will be the subject of the PR.
-
-A [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0) subject will be validated by the Semantic Pull Request Subject CI job. Reference the issue to be used in the release notes e.g.
-
-`fix(#2395): marks.bulk.move defaults to directory at cursor`
-
-Available types:
-* feat: A new feature
-* fix: A bug fix
-* docs: Documentation only changes
-* style: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)
-* refactor: A code change that neither fixes a bug nor adds a feature
-* perf: A code change that improves performance
-* test: Adding missing tests or correcting existing tests
-* build: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
-* ci: Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)
-* chore: Other changes that don't modify src or test files
-* revert: Reverts a previous commit
-
-If in doubt, look at previous commits.
-
-See also [The Conventional Commits ultimate cheatsheet](https://gist.github.com/gabrielecanepa/fa6cca1a8ae96f77896fe70ddee65527)

Makefile

@@ -1,48 +0,0 @@
-all: lint style check
-
-#
-# mandatory checks
-#
-lint: luacheck
-
-style: style-check style-doc
-
-check: luals
-
-#
-# subtasks
-#
-luacheck:
-	luacheck -q lua
-
-# --diagnosis-as-error does not function for workspace, hence we post-process the output
-style-check:
-	CodeFormat check --config .editorconfig --diagnosis-as-error --workspace lua
-
-style-doc:
-	scripts/doc-comments.sh
-
-luals:
-	@scripts/luals-check.sh
-
-#
-# fixes
-#
-style-fix:
-	CodeFormat format --config .editorconfig --workspace lua
-
-#
-# utility
-#
-help-update:
-	scripts/help-update.sh
-
-#
-# CI
-#
-help-check: help-update
-	git diff --exit-code doc/nvim-tree-lua.txt
-
-
-.PHONY: all lint style check luacheck style-check style-doc luals style-fix help-update help-check
-

README.md

@@ -24,11 +24,11 @@
 
 Take a look at the [wiki](https://github.com/nvim-tree/nvim-tree.lua/wiki) for Showcases, Tips, Recipes and more.
 
-Questions and general support: [Discussions](https://github.com/nvim-tree/nvim-tree.lua/discussions)
+Community support: [matrix](https://matrix.to/#/#nvim-tree:matrix.org)
 
 ## Requirements
 
-[neovim >=0.9.0](https://github.com/neovim/neovim/wiki/Installing-Neovim)
+[neovim >=0.8.0](https://github.com/neovim/neovim/wiki/Installing-Neovim)
 
 [nvim-web-devicons](https://github.com/nvim-tree/nvim-web-devicons) is optional and used to display file icons. It requires a [patched font](https://www.nerdfonts.com/). Your terminal emulator must be configured to use that font, usually "Hack Nerd Font"
 
@@ -38,8 +38,6 @@ Please install via your preferred package manager. See [Installation](https://gi
 
 `nvim-tree/nvim-tree.lua`
 
-Major or minor versions may be specified via tags: `v<MAJOR>` e.g. `v1` or `v<MAJOR>.<MINOR>` e.g. `v1.23`
-
 `nvim-tree/nvim-web-devicons` optional, for file icons
 
 Disabling [netrw](https://neovim.io/doc/user/pi_netrw.html) is strongly advised, see [:help nvim-tree-netrw](doc/nvim-tree-lua.txt)
@@ -55,7 +53,7 @@ Setup the plugin in your `init.lua`
 vim.g.loaded_netrw = 1
 vim.g.loaded_netrwPlugin = 1
 
--- optionally enable 24-bit colour
+-- set termguicolors to enable highlight groups
 vim.opt.termguicolors = true
 
 -- empty setup using defaults
@@ -112,23 +110,6 @@ require("nvim-tree").setup {
 }
 ```
 
-### Highlight
-
-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.
-
-```lua
-vim.cmd([[
-    :hi      NvimTreeExecFile    guifg=#ffa0a0
-    :hi      NvimTreeSpecialFile guifg=#ff80ff gui=underline
-    :hi      NvimTreeSymlink     guifg=Yellow  gui=italic
-    :hi link NvimTreeImageFile   Title
-]])
-```
-See [:help nvim-tree-highlight](doc/nvim-tree-lua.txt) for details.
-
 ## Commands
 
 See [:help nvim-tree-commands](doc/nvim-tree-lua.txt)

lua/nvim-tree.lua

@@ -1,11 +1,20 @@
-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 appearance = require("nvim-tree.appearance")
+local colors = require "nvim-tree.colors"
-local view = require("nvim-tree.view")
+local renderer = require "nvim-tree.renderer"
-local utils = require("nvim-tree.utils")
+local view = require "nvim-tree.view"
-local actions = require("nvim-tree.actions")
+local commands = require "nvim-tree.commands"
-local core = require("nvim-tree.core")
+local utils = require "nvim-tree.utils"
-local notify = require("nvim-tree.notify")
+local change_dir = require "nvim-tree.actions.root.change-dir"
+local legacy = require "nvim-tree.legacy"
+local core = require "nvim-tree.core"
+local reloaders = require "nvim-tree.actions.reloaders.reloaders"
+local git = require "nvim-tree.git"
+local filters = require "nvim-tree.explorer.filters"
+local modified = require "nvim-tree.modified"
+local find_file = require "nvim-tree.actions.tree.find-file"
+local events = require "nvim-tree.events"
+local notify = require "nvim-tree.notify"
 
 local _config = {}
 
@@ -19,15 +28,8 @@ local M = {
 function M.change_root(path, bufnr)
   -- skip if current file is in ignore_list
   if type(bufnr) == "number" then
-    local ft
+    local ft = vim.api.nvim_buf_get_option(bufnr, "filetype") or ""
-
+    for _, value in pairs(_config.update_focused_file.ignore_list) do
-    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
-    end
-
-    for _, value in pairs(_config.update_focused_file.update_root.ignore_list) do
       if utils.str_find(path, value) or utils.str_find(ft, value) then
         return
       end
@@ -49,7 +51,7 @@ function M.change_root(path, bufnr)
   -- test if in vim_cwd
   if utils.path_relative(path, vim_cwd) ~= path then
     if vim_cwd ~= cwd then
-      actions.root.change_dir.fn(vim_cwd)
+      change_dir.fn(vim_cwd)
     end
     return
   end
@@ -60,43 +62,56 @@ function M.change_root(path, bufnr)
 
   -- otherwise test M.init_root
   if _config.prefer_startup_root and utils.path_relative(path, M.init_root) ~= path then
-    actions.root.change_dir.fn(M.init_root)
+    change_dir.fn(M.init_root)
     return
   end
   -- otherwise root_dirs
   for _, dir in pairs(_config.root_dirs) do
     dir = vim.fn.fnamemodify(dir, ":p")
     if utils.path_relative(path, dir) ~= path then
-      actions.root.change_dir.fn(dir)
+      change_dir.fn(dir)
       return
     end
   end
   -- finally fall back to the folder containing the file
-  actions.root.change_dir.fn(vim.fn.fnamemodify(path, ":p:h"))
+  change_dir.fn(vim.fn.fnamemodify(path, ":p:h"))
+end
+
+---@param cwd string|nil
+function M.open_replacing_current_buffer(cwd)
+  if view.is_visible() then
+    return
+  end
+
+  local buf = vim.api.nvim_get_current_buf()
+  local bufname = vim.api.nvim_buf_get_name(buf)
+  if bufname == "" or vim.loop.fs_stat(bufname) == nil then
+    return
+  end
+
+  if cwd == "" or cwd == nil then
+    cwd = vim.fn.fnamemodify(bufname, ":p:h")
+  end
+
+  if not core.get_explorer() or cwd ~= core.get_cwd() then
+    core.init(cwd)
+  end
+  view.open_in_win { hijack_current_buf = false, resize = false }
+  require("nvim-tree.renderer").draw()
+  require("nvim-tree.actions.finders.find-file").fn(bufname)
 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 = vim.api.nvim_buf_get_option(0, "ft")
-    local ft
-    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
-    end
-
     for _, filter in ipairs(M.config.tab.sync.ignore) do
       if bufname:match(filter) ~= nil or ft:match(filter) ~= nil then
         return
       end
     end
-    view.open({ focus_tree = false })
+    view.open { focus_tree = false }
-
+    require("nvim-tree.renderer").draw()
-    local explorer = core.get_explorer()
-    if explorer then
-      explorer.renderer:draw()
-    end
   end
 end
 
@@ -112,20 +127,27 @@ function M.open_on_directory()
     return
   end
 
-  actions.root.change_dir.force_dirchange(bufname, true)
+  change_dir.force_dirchange(bufname, true)
 end
 
+function M.reset_highlight()
+  colors.setup()
+  view.reset_winhl()
+  renderer.render_hl(view.get_bufnr())
+end
+
+local prev_line
 function M.place_cursor_on_node()
-  local ok, search = pcall(vim.fn.searchcount)
+  local l = vim.api.nvim_win_get_cursor(0)[1]
-  if ok and search and search.exact_match == 1 then
+  if l == prev_line then
     return
   end
+  prev_line = l
 
   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)
@@ -145,8 +167,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
@@ -157,11 +179,11 @@ end
 ---@param name string|nil
 function M.change_dir(name)
   if name then
-    actions.root.change_dir.fn(name)
+    change_dir.fn(name)
   end
 
-  if _config.update_focused_file.update_root.enable then
+  if _config.update_focused_file.enable then
-    actions.tree.find_file.fn()
+    find_file.fn()
   end
 end
 
@@ -173,18 +195,8 @@ 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
+  -- reset highlights when colorscheme is changed
-  create_nvim_tree_autocmd("ColorScheme", {
+  create_nvim_tree_autocmd("ColorScheme", { callback = M.reset_highlight })
-    callback = function()
-      appearance.setup()
-      view.reset_winhl()
-
-      local explorer = core.get_explorer()
-      if explorer then
-        explorer.renderer:draw()
-      end
-    end,
-  })
 
   -- prevent new opened file from opening in the same window as nvim-tree
   create_nvim_tree_autocmd("BufWipeout", {
@@ -204,10 +216,7 @@ local function setup_autocommands(opts)
   create_nvim_tree_autocmd("BufWritePost", {
     callback = function()
       if opts.auto_reload_on_write and not opts.filesystem_watchers.enable then
-        local explorer = core.get_explorer()
+        reloaders.reload_explorer()
-        if explorer then
-          explorer:reload_explorer()
-        end
       end
     end,
   })
@@ -215,15 +224,9 @@ local function setup_autocommands(opts)
   create_nvim_tree_autocmd("BufReadPost", {
     callback = function(data)
       -- update opened file buffers
-      local explorer = core.get_explorer()
+      if (filters.config.filter_no_buffer or renderer.config.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == "" then
-      if not explorer then
-        return
-      end
-      if
-        (explorer.filters.config.filter_no_buffer or explorer.opts.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == ""
-      then
         utils.debounce("Buf:filter_buffer", opts.view.debounce_delay, function()
-          explorer:reload_explorer()
+          reloaders.reload_explorer()
         end)
       end
     end,
@@ -232,15 +235,9 @@ local function setup_autocommands(opts)
   create_nvim_tree_autocmd("BufUnload", {
     callback = function(data)
       -- update opened file buffers
-      local explorer = core.get_explorer()
+      if (filters.config.filter_no_buffer or renderer.config.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == "" then
-      if not explorer then
-        return
-      end
-      if
-        (explorer.filters.config.filter_no_buffer or explorer.opts.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == ""
-      then
         utils.debounce("Buf:filter_buffer", opts.view.debounce_delay, function()
-          explorer:reload_explorer()
+          reloaders.reload_explorer(nil, data.buf)
         end)
       end
     end,
@@ -250,10 +247,7 @@ local function setup_autocommands(opts)
     pattern = { "FugitiveChanged", "NeogitStatusRefreshed" },
     callback = function()
       if not opts.filesystem_watchers.enable and opts.git.enable then
-        local explorer = core.get_explorer()
+        reloaders.reload_git()
-        if explorer then
-          explorer:reload_git()
-        end
       end
     end,
   })
@@ -280,13 +274,9 @@ local function setup_autocommands(opts)
   end
   if opts.update_focused_file.enable then
     create_nvim_tree_autocmd("BufEnter", {
-      callback = function(event)
+      callback = function()
-        local exclude = opts.update_focused_file.exclude
-        if type(exclude) == "function" and exclude(event) then
-          return
-        end
         utils.debounce("BufEnter:find_file", opts.view.debounce_delay, function()
-          actions.tree.find_file.fn()
+          find_file.fn()
         end)
       end,
     })
@@ -301,10 +291,7 @@ local function setup_autocommands(opts)
     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
-          local explorer = core.get_explorer()
+          reloaders.reload_explorer()
-          if explorer then
-            explorer:reload_explorer()
-          end
         end
       end
     end,
@@ -316,7 +303,7 @@ local function setup_autocommands(opts)
       callback = function()
         vim.schedule(function()
           vim.api.nvim_buf_call(0, function()
-            vim.cmd([[norm! zz]])
+            vim.cmd [[norm! zz]]
           end)
         end)
       end,
@@ -354,15 +341,27 @@ local function setup_autocommands(opts)
     create_nvim_tree_autocmd({ "BufModifiedSet", "BufWritePost" }, {
       callback = function()
         utils.debounce("Buf:modified", opts.view.debounce_delay, function()
-          require("nvim-tree.buffers").reload_modified()
+          modified.reload()
-          local explorer = core.get_explorer()
+          reloaders.reload_explorer()
-          if explorer then
-            explorer:reload_explorer()
-          end
         end)
       end,
     })
   end
+
+  -- TODO #1545 remove similar check from view.resize
+  if vim.fn.has "nvim-0.9" == 1 then
+    create_nvim_tree_autocmd("WinResized", {
+      callback = function()
+        if vim.v.event and vim.v.event.windows then
+          for _, winid in ipairs(vim.v.event.windows) do
+            if vim.api.nvim_win_is_valid(winid) and utils.is_nvim_tree_buf(vim.api.nvim_win_get_buf(winid)) then
+              events._dispatch_on_tree_resize(vim.api.nvim_win_get_width(winid))
+            end
+          end
+        end
+      end,
+    })
+  end
 end
 
 local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
@@ -413,13 +412,11 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
     root_folder_label = ":~:s?$?/..?",
     indent_width = 2,
     special_files = { "Cargo.toml", "Makefile", "README.md", "readme.md" },
-    hidden_display = "none",
     symlink_destination = true,
-    highlight_git = "none",
+    highlight_git = false,
-    highlight_diagnostics = "none",
+    highlight_diagnostics = false,
     highlight_opened_files = "none",
     highlight_modified = "none",
-    highlight_hidden = "none",
     highlight_bookmarks = "none",
     highlight_clipboard = "name",
     indent_markers = {
@@ -446,7 +443,6 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
       },
       git_placement = "before",
       modified_placement = "after",
-      hidden_placement = "after",
       diagnostics_placement = "signcolumn",
       bookmarks_placement = "signcolumn",
       padding = " ",
@@ -457,7 +453,6 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
         folder_arrow = true,
         git = true,
         modified = true,
-        hidden = false,
         diagnostics = true,
         bookmarks = true,
       },
@@ -466,7 +461,6 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
         symlink = "",
         bookmark = "󰆤",
         modified = "●",
-        hidden = "󰜌",
         folder = {
           arrow_closed = "",
           arrow_open = "",
@@ -495,11 +489,8 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
   },
   update_focused_file = {
     enable = false,
-    update_root = {
+    update_root = false,
-      enable = false,
+    ignore_list = {},
-      ignore_list = {},
-    },
-    exclude = false,
   },
   system_open = {
     cmd = "",
@@ -535,12 +526,10 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
     show_on_open_dirs = true,
   },
   filters = {
-    enable = true,
     git_ignored = true,
     dotfiles = false,
     git_clean = false,
     no_buffer = false,
-    no_bookmark = false,
     custom = {},
     exclude = {},
   },
@@ -615,13 +604,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
       default_yes = false,
     },
   },
-  experimental = {
+  experimental = {},
-    actions = {
-      open_file = {
-        relative_path = false,
-      },
-    },
-  },
   log = {
     enable = false,
     truncate = false,
@@ -663,22 +646,9 @@ local ACCEPTED_TYPES = {
     },
   },
   renderer = {
-    hidden_display = { "function", "string" },
     group_empty = { "boolean", "function" },
     root_folder_label = { "function", "string", "boolean" },
   },
-  update_focused_file = {
-    exclude = { "function" },
-  },
-  git = {
-    disable_for_dirs = { "function" },
-  },
-  filters = {
-    custom = { "function" },
-  },
-  filesystem_watchers = {
-    ignore_dirs = { "function" },
-  },
   actions = {
     open_file = {
       window_picker = {
@@ -697,20 +667,15 @@ local ACCEPTED_STRINGS = {
     signcolumn = { "yes", "no", "auto" },
   },
   renderer = {
-    hidden_display = { "none", "simple", "all" },
-    highlight_git = { "none", "icon", "name", "all" },
     highlight_opened_files = { "none", "icon", "name", "all" },
     highlight_modified = { "none", "icon", "name", "all" },
-    highlight_hidden = { "none", "icon", "name", "all" },
     highlight_bookmarks = { "none", "icon", "name", "all" },
-    highlight_diagnostics = { "none", "icon", "name", "all" },
     highlight_clipboard = { "none", "icon", "name", "all" },
     icons = {
-      git_placement = { "before", "after", "signcolumn", "right_align" },
+      git_placement = { "before", "after", "signcolumn" },
-      modified_placement = { "before", "after", "signcolumn", "right_align" },
+      modified_placement = { "before", "after", "signcolumn" },
-      hidden_placement = { "before", "after", "signcolumn", "right_align" },
+      diagnostics_placement = { "before", "after", "signcolumn" },
-      diagnostics_placement = { "before", "after", "signcolumn", "right_align" },
+      bookmarks_placement = { "before", "after", "signcolumn" },
-      bookmarks_placement = { "before", "after", "signcolumn", "right_align" },
     },
   },
   help = {
@@ -804,15 +769,15 @@ function M.purge_all_state()
   view.close_all_tabs()
   view.abandon_all_windows()
   if core.get_explorer() ~= nil then
-    require("nvim-tree.git").purge_state()
+    git.purge_state()
     core.reset_explorer()
   end
 end
 
 ---@param conf table|nil
 function M.setup(conf)
-  if vim.fn.has("nvim-0.9") == 0 then
+  if vim.fn.has "nvim-0.8" == 0 then
-    notify.warn("nvim-tree.lua requires Neovim 0.9 or higher")
+    notify.warn "nvim-tree.lua requires Neovim 0.8 or higher"
     return
   end
 
@@ -820,7 +785,7 @@ function M.setup(conf)
 
   localise_default_opts()
 
-  require("nvim-tree.legacy").migrate_legacy_options(conf or {})
+  legacy.migrate_legacy_options(conf or {})
 
   validate_options(conf)
 
@@ -840,22 +805,24 @@ 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
 
   require("nvim-tree.actions").setup(opts)
   require("nvim-tree.keymap").setup(opts)
-  require("nvim-tree.appearance").setup()
+  require("nvim-tree.colors").setup()
   require("nvim-tree.diagnostics").setup(opts)
   require("nvim-tree.explorer").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.components").setup(opts)
+  require("nvim-tree.renderer").setup(opts)
-  require("nvim-tree.buffers").setup(opts)
+  require("nvim-tree.live-filter").setup(opts)
+  require("nvim-tree.marks").setup(opts)
+  require("nvim-tree.modified").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
@@ -866,7 +833,7 @@ function M.setup(conf)
 
   if vim.g.NvimTreeSetup ~= 1 then
     -- first call to setup
-    require("nvim-tree.commands").setup()
+    commands.setup()
   else
     -- subsequent calls to setup
     M.purge_all_state()

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

@@ -1,8 +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 core = require("nvim-tree.core")
+local renderer = require "nvim-tree.renderer"
-local Iterator = require("nvim-tree.iterators.node-iterator")
+local reload = require "nvim-tree.explorer.reload"
+local core = require "nvim-tree.core"
+local Iterator = require "nvim-tree.iterators.node-iterator"
 
 local M = {}
 
@@ -11,8 +13,7 @@ local running = {}
 ---Find a path in the tree, expand it and focus it
 ---@param path string relative or absolute
 function M.fn(path)
-  local explorer = core.get_explorer()
+  if not core.get_explorer() or not view.is_visible() then
-  if not explorer or not view.is_visible() then
     return
   end
 
@@ -31,7 +32,7 @@ function M.fn(path)
 
   -- refresh the contents of all parents, expanding groups as needed
   if utils.get_node_from_path(path_real) == nil then
-    explorer:refresh_parent_nodes_for_path(vim.fn.fnamemodify(path_real, ":h"))
+    reload.refresh_parent_nodes_for_path(vim.fn.fnamemodify(path_real, ":h"))
   end
 
   local line = core.get_nodes_starting_line()
@@ -75,8 +76,8 @@ function M.fn(path)
     :iterate()
 
   if found and view.is_visible() then
-    explorer.renderer:draw()
+    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 +0,0 @@
-local M = {}
-
-M.find_file = require("nvim-tree.actions.finders.find-file")
-M.search_node = require("nvim-tree.actions.finders.search-node")
-
-return M

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

@@ -1,4 +1,5 @@
-local core = require("nvim-tree.core")
+local core = require "nvim-tree.core"
+local filters = require "nvim-tree.explorer.filters"
 local find_file = require("nvim-tree.actions.finders.find-file").fn
 
 local M = {}
@@ -8,11 +9,6 @@ local M = {}
 ---@return string|nil
 local function search(search_dir, input_path)
   local realpaths_searched = {}
-  local explorer = core.get_explorer()
-
-  if not explorer then
-    return
-  end
 
   if not search_dir then
     return
@@ -23,7 +19,7 @@ local function search(search_dir, input_path)
   local function iter(dir)
     local realpath, path, name, stat, handle, _
 
-    local filter_status = explorer.filters:prepare()
+    local filter_status = filters.prepare()
 
     handle, _ = vim.loop.fs_scandir(dir)
     if not handle then
@@ -40,13 +36,12 @@ local function search(search_dir, input_path)
     while name do
       path = dir .. "/" .. name
 
-      ---@type uv.fs_stat.result|nil
       stat, _ = vim.loop.fs_stat(path)
       if not stat then
         break
       end
 
-      if not explorer.filters:should_filter(path, stat, filter_status) then
+      if not filters.should_filter(path, filter_status) then
         if string.find(path, "/" .. input_path .. "$") then
           return path
         end
@@ -73,15 +68,8 @@ function M.fn()
 
   -- temporarily set &path
   local bufnr = vim.api.nvim_get_current_buf()
-
+  local path_existed, path_opt = pcall(vim.api.nvim_buf_get_option, bufnr, "path")
-  local path_existed, path_opt
+  vim.api.nvim_buf_set_option(bufnr, "path", core.get_cwd() .. "/**")
-  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
-    path_existed, path_opt = pcall(vim.api.nvim_buf_get_option, bufnr, "path") ---@diagnostic disable-line: deprecated
-    vim.api.nvim_buf_set_option(bufnr, "path", core.get_cwd() .. "/**") ---@diagnostic disable-line: deprecated
-  end
 
   vim.ui.input({ prompt = "Search: ", completion = "file_in_path" }, function(input_path)
     if not input_path or input_path == "" then
@@ -89,17 +77,9 @@ function M.fn()
     end
     -- reset &path
     if path_existed then
-      if vim.fn.has("nvim-0.10") == 1 then
+      vim.api.nvim_buf_set_option(bufnr, "path", path_opt)
-        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
+      vim.api.nvim_buf_set_option(bufnr, "path", nil)
-        vim.api.nvim_set_option_value("path", nil, { buf = bufnr })
-      else
-        vim.api.nvim_buf_set_option(bufnr, "path", nil) ---@diagnostic disable-line: deprecated
-      end
     end
 
     -- strip trailing slash

lua/nvim-tree/actions/fs/copy-paste.lua

@@ -1,44 +1,24 @@
-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.reloaders"
+
+local HL_POSITION = require("nvim-tree.enum").HL_POSITION
 
 local find_file = require("nvim-tree.actions.finders.find-file").fn
 
----@enum ACTION
+local M = {
-local ACTION = {
+  config = {},
-  copy = "copy",
-  cut = "cut",
 }
 
----@class Clipboard to handle all actions.fs clipboard API
+local clipboard = {
----@field config table hydrated user opts.filters
+  cut = {},
----@field private explorer Explorer
+  copy = {},
----@field private data table<ACTION, Node[]>
+}
-local Clipboard = {}
-
----@param opts table user options
----@param explorer Explorer
----@return Clipboard
-function Clipboard:new(opts, explorer)
-  local o = {
-    explorer = explorer,
-    data = {
-      [ACTION.copy] = {},
-      [ACTION.cut] = {},
-    },
-    config = {
-      filesystem_watchers = opts.filesystem_watchers,
-      actions = opts.actions,
-    },
-  }
-
-  setmetatable(o, self)
-  self.__index = self
-  return o
-end
 
 ---@param source string
 ---@param destination string
@@ -89,8 +69,8 @@ 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)
       if not success then
         return false, errmsg
@@ -107,11 +87,11 @@ end
 
 ---@param source string
 ---@param dest string
----@param action ACTION
+---@param action_type string
 ---@param action_fn fun(source: string, dest: string)
 ---@return boolean|nil -- success
 ---@return string|nil -- error message
-local function do_single_paste(source, dest, action, action_fn)
+local function do_single_paste(source, dest, action_type, action_fn)
   local dest_stats
   local success, errmsg, errcode
   local notify_source = notify.render_path(source)
@@ -120,14 +100,14 @@ local function do_single_paste(source, dest, action, action_fn)
 
   dest_stats, errmsg, errcode = vim.loop.fs_stat(dest)
   if not dest_stats and errcode ~= "ENOENT" then
-    notify.error("Could not " .. action .. " " .. notify_source .. " - " .. (errmsg or "???"))
+    notify.error("Could not " .. action_type .. " " .. notify_source .. " - " .. (errmsg or "???"))
     return false, errmsg
   end
 
   local function on_process()
     success, errmsg = action_fn(source, dest)
     if not success then
-      notify.error("Could not " .. action .. " " .. notify_source .. " - " .. (errmsg or "???"))
+      notify.error("Could not " .. action_type .. " " .. notify_source .. " - " .. (errmsg or "???"))
       return false, errmsg
     end
 
@@ -145,13 +125,13 @@ local function do_single_paste(source, dest, action, action_fn)
       vim.ui.input(input_opts, function(new_dest)
         utils.clear_prompt()
         if new_dest then
-          do_single_paste(source, new_dest, action, action_fn)
+          do_single_paste(source, new_dest, action_type, action_fn)
         end
       end)
     else
       local prompt_select = "Overwrite " .. dest .. " ?"
       local prompt_input = prompt_select .. " R(ename)/y/n: "
-      lib.prompt(prompt_input, prompt_select, { "", "y", "n" }, { "Rename", "Yes", "No" }, "nvimtree_overwrite_rename", function(item_short)
+      lib.prompt(prompt_input, prompt_select, { "", "y", "n" }, { "Rename", "Yes", "No" }, function(item_short)
         utils.clear_prompt()
         if item_short == "y" then
           on_process()
@@ -159,7 +139,7 @@ local function do_single_paste(source, dest, action, action_fn)
           vim.ui.input(input_opts, function(new_dest)
             utils.clear_prompt()
             if new_dest then
-              do_single_paste(source, new_dest, action, action_fn)
+              do_single_paste(source, new_dest, action_type, action_fn)
             end
           end)
         end
@@ -187,42 +167,37 @@ local function toggle(node, clip)
   notify.info(notify_node .. " added to clipboard.")
 end
 
----Clear copied and cut
+function M.clear_clipboard()
-function Clipboard:clear_clipboard()
+  clipboard.cut = {}
-  self.data[ACTION.copy] = {}
+  clipboard.copy = {}
-  self.data[ACTION.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)
+function M.copy(node)
-  utils.array_remove(self.data[ACTION.cut], node)
+  utils.array_remove(clipboard.cut, node)
-  toggle(node, self.data[ACTION.copy])
+  toggle(node, clipboard.copy)
-  self.explorer.renderer:draw()
+  renderer.draw()
 end
 
----Cut one node
 ---@param node Node
-function Clipboard:cut(node)
+function M.cut(node)
-  utils.array_remove(self.data[ACTION.copy], node)
+  utils.array_remove(clipboard.copy, node)
-  toggle(node, self.data[ACTION.cut])
+  toggle(node, clipboard.cut)
-  self.explorer.renderer:draw()
+  renderer.draw()
 end
 
----Paste cut or cop
----@private
 ---@param node Node
----@param action ACTION
+---@param action_type string
 ---@param action_fn fun(source: string, dest: string)
-function Clipboard:do_paste(node, action, action_fn)
+local function do_paste(node, action_type, action_fn)
   node = lib.get_last_group_node(node)
   local explorer = core.get_explorer()
   if node.name == ".." and explorer then
     node = explorer
   end
-  local clip = self.data[action]
+  local clip = clipboard[action_type]
   if #clip == 0 then
     return
   end
@@ -231,7 +206,7 @@ function Clipboard:do_paste(node, action, action_fn)
   local stats, errmsg, errcode = vim.loop.fs_stat(destination)
   if not stats and errcode ~= "ENOENT" then
     log.line("copy_paste", "do_paste fs_stat '%s' failed '%s'", destination, errmsg)
-    notify.error("Could not " .. action .. " " .. notify.render_path(destination) .. " - " .. (errmsg or "???"))
+    notify.error("Could not " .. action_type .. " " .. notify.render_path(destination) .. " - " .. (errmsg or "???"))
     return
   end
   local is_dir = stats and stats.type == "directory"
@@ -240,13 +215,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)
+    do_single_paste(_node.absolute_path, dest, action_type, action_fn)
   end
 
-  self.data[action] = {}
+  clipboard[action_type] = {}
-  if not self.config.filesystem_watchers.enable then
+  if not M.config.filesystem_watchers.enable then
-    self.explorer:reload_explorer()
+    reloaders.reload_explorer()
   end
 end
 
@@ -273,27 +248,26 @@ local function do_cut(source, destination)
   return true
 end
 
----Paste cut (if present) or copy (if present)
 ---@param node Node
-function Clipboard:paste(node)
+function M.paste(node)
-  if self.data[ACTION.cut][1] ~= nil then
+  if clipboard.cut[1] ~= nil then
-    self:do_paste(node, ACTION.cut, do_cut)
+    do_paste(node, "cut", do_cut)
-  elseif self.data[ACTION.copy][1] ~= nil then
+  else
-    self:do_paste(node, ACTION.copy, do_copy)
+    do_paste(node, "copy", do_copy)
   end
 end
 
-function Clipboard:print_clipboard()
+function M.print_clipboard()
   local content = {}
-  if #self.data[ACTION.cut] > 0 then
+  if #clipboard.cut > 0 then
     table.insert(content, "Cut")
-    for _, node in pairs(self.data[ACTION.cut]) do
+    for _, node in pairs(clipboard.cut) do
       table.insert(content, " * " .. (notify.render_path(node.absolute_path)))
     end
   end
-  if #self.data[ACTION.copy] > 0 then
+  if #clipboard.copy > 0 then
     table.insert(content, "Copy")
-    for _, node in pairs(self.data[ACTION.copy]) do
+    for _, node in pairs(clipboard.copy) do
       table.insert(content, " * " .. (notify.render_path(node.absolute_path)))
     end
   end
@@ -302,104 +276,75 @@ function Clipboard:print_clipboard()
 end
 
 ---@param content string
-function Clipboard:copy_to_reg(content)
+local function copy_to_clipboard(content)
   local clipboard_name
-  local reg
+  if M.config.actions.use_system_clipboard == true then
-  if self.config.actions.use_system_clipboard == true then
+    vim.fn.setreg("+", content)
+    vim.fn.setreg('"', content)
     clipboard_name = "system"
-    reg = "+"
   else
+    vim.fn.setreg('"', content)
+    vim.fn.setreg("1", content)
     clipboard_name = "neovim"
-    reg = "1"
   end
 
-  -- manually firing TextYankPost does not set vim.v.event
+  vim.api.nvim_exec_autocmds("TextYankPost", {})
-  -- 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))
-  end)
-  vim.api.nvim_buf_delete(temp_buf, {})
-
   notify.info(string.format("Copied %s to %s clipboard!", content, clipboard_name))
 end
 
 ---@param node Node
-function Clipboard:copy_filename(node)
+function M.copy_filename(node)
-  local content
+  copy_to_clipboard(node.name)
-
-  if node.name == ".." then
-    -- root
-    content = vim.fn.fnamemodify(self.explorer.absolute_path, ":t")
-  else
-    -- node
-    content = node.name
-  end
-
-  self:copy_to_reg(content)
 end
 
 ---@param node Node
-function Clipboard:copy_basename(node)
+function M.copy_path(node)
-  local content
+  local absolute_path = node.absolute_path
-
+  local cwd = core.get_cwd()
-  if node.name == ".." then
+  if cwd == nil then
-    -- root
+    return
-    content = vim.fn.fnamemodify(self.explorer.absolute_path, ":t:r")
-  else
-    -- node
-    content = vim.fn.fnamemodify(node.name, ":r")
   end
 
-  self:copy_to_reg(content)
+  local relative_path = utils.path_relative(absolute_path, cwd)
+  local content = node.nodes ~= nil and utils.path_add_trailing(relative_path) or relative_path
+  copy_to_clipboard(content)
 end
 
 ---@param node Node
-function Clipboard:copy_path(node)
+function M.copy_absolute_path(node)
-  local content
-
-  if node.name == ".." then
-    -- root
-    content = utils.path_add_trailing("")
-  else
-    -- 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)
-    content = node.nodes ~= nil and utils.path_add_trailing(relative_path) or relative_path
-  end
-
-  self:copy_to_reg(content)
-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)
+  copy_to_clipboard(content)
 end
 
----Node is cut. Will not be copied.
+--- Clipboard text highlight group and position when highlight_clipboard.
 ---@param node Node
----@return boolean
+---@return HL_POSITION position none when clipboard empty
-function Clipboard:is_cut(node)
+---@return string|nil group only when node present in clipboard
-  return vim.tbl_contains(self.data[ACTION.cut], node)
+function M.get_highlight(node)
+  if M.hl_pos == HL_POSITION.none then
+    return HL_POSITION.none, nil
+  end
+
+  for _, n in ipairs(clipboard.cut) do
+    if node == n then
+      return M.hl_pos, "NvimTreeCutHL"
+    end
+  end
+
+  for _, n in ipairs(clipboard.copy) do
+    if node == n then
+      return M.hl_pos, "NvimTreeCopiedHL"
+    end
+  end
+
+  return HL_POSITION.none, nil
 end
 
----Node is copied. Will not be cut.
+function M.setup(opts)
----@param node Node
+  M.config.filesystem_watchers = opts.filesystem_watchers
----@return boolean
+  M.config.actions = opts.actions
-function Clipboard:is_copied(node)
+  M.hl_pos = HL_POSITION[opts.renderer.highlight_clipboard] or HL_POSITION.none
-  return vim.tbl_contains(self.data[ACTION.copy], node)
 end
 
-return Clipboard
+return M

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

@@ -1,8 +1,8 @@
-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 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
 
@@ -12,7 +12,7 @@ local M = {}
 local function create_and_notify(file)
   events._dispatch_will_create_file(file)
   local ok, fd = pcall(vim.loop.fs_open, file, "w", 420)
-  if not ok or type(fd) ~= "number" then
+  if not ok then
     notify.error("Couldn't create file " .. notify.render_path(file))
     return
   end
@@ -72,7 +72,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 +87,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,14 +0,0 @@
-local M = {}
-
-M.create_file = require("nvim-tree.actions.fs.create-file")
-M.remove_file = require("nvim-tree.actions.fs.remove-file")
-M.rename_file = require("nvim-tree.actions.fs.rename-file")
-M.trash = require("nvim-tree.actions.fs.trash")
-
-function M.setup(opts)
-  M.remove_file.setup(opts)
-  M.rename_file.setup(opts)
-  M.trash.setup(opts)
-end
-
-return M

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

@@ -1,9 +1,8 @@
-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 view = require "nvim-tree.view"
-local view = require("nvim-tree.view")
+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 M = {
   config = {},
@@ -27,13 +26,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
@@ -50,25 +49,20 @@ end
 ---@param cwd string
 ---@return boolean|nil
 local function remove_dir(cwd)
-  local handle, err = vim.loop.fs_scandir(cwd)
+  local handle = vim.loop.fs_scandir(cwd)
-  if not handle then
+  if type(handle) == "string" then
-    notify.error(err)
+    notify.error(handle)
     return
   end
 
   while true do
-    local name, _ = vim.loop.fs_scandir_next(handle)
+    local name, t = vim.loop.fs_scandir_next(handle)
     if not name then
       break
     end
 
-    local new_cwd = utils.path_join({ cwd, name })
+    local new_cwd = utils.path_join { cwd, name }
-
+    if t == "directory" then
-    -- Type must come from fs_stat and not fs_scandir_next to maintain sshfs compatibility
-    local stat = vim.loop.fs_stat(new_cwd)
-    local type = stat and stat.type or nil
-
-    if type == "directory" then
       local success = remove_dir(new_cwd)
       if not success then
         return false
@@ -117,9 +111,8 @@ function M.fn(node)
 
   local function do_remove()
     M.remove(node)
-    local explorer = core.get_explorer()
+    if not M.config.filesystem_watchers.enable then
-    if not M.config.filesystem_watchers.enable and explorer then
+      require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
-      explorer:reload_explorer()
     end
   end
 
@@ -137,7 +130,7 @@ function M.fn(node)
       items_long = { "No", "Yes" }
     end
 
-    lib.prompt(prompt_input, prompt_select, items_short, items_long, "nvimtree_remove", function(item_short)
+    lib.prompt(prompt_input, prompt_select, items_short, items_long, function(item_short)
       utils.clear_prompt()
       if item_short == "y" or item_short == (M.config.ui.confirm.default_yes and "") then
         do_remove()

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

@@ -1,8 +1,7 @@
-local core = require("nvim-tree.core")
+local lib = require "nvim-tree.lib"
-local lib = require("nvim-tree.lib")
+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
 
@@ -10,16 +9,6 @@ local M = {
   config = {},
 }
 
----@param iter function iterable
----@return integer
-local function get_num_nodes(iter)
-  local i = 0
-  for _ in iter do
-    i = i + 1
-  end
-  return i
-end
-
 local ALLOWED_MODIFIERS = {
   [":p"] = true,
   [":p:h"] = true,
@@ -31,69 +20,26 @@ local function err_fmt(from, to, reason)
   return string.format("Cannot rename %s -> %s: %s", from, to, reason)
 end
 
-local function rename_file_exists(node, to)
-  if not utils.is_macos then
-    return utils.file_exists(to)
-  end
-
-  if string.lower(node) == string.lower(to) then
-    return false
-  end
-
-  return utils.file_exists(to)
-end
-
 ---@param node Node
 ---@param to string
 function M.rename(node, to)
   local notify_from = notify.render_path(node.absolute_path)
   local notify_to = notify.render_path(to)
 
-  if rename_file_exists(notify_from, notify_to) then
+  if utils.file_exists(to) then
     notify.warn(err_fmt(notify_from, notify_to, "file already exists"))
     return
   end
 
-  -- create a folder for each path element if the folder does not exist
+  events._dispatch_will_rename_node(node.absolute_path, to)
-  local idx = 0
+  local success, err = vim.loop.fs_rename(node.absolute_path, to)
-  local path_to_create = ""
+  if not success then
-
+    notify.warn(err_fmt(notify_from, notify_to, err))
-  local num_nodes = get_num_nodes(utils.path_split(utils.path_remove_trailing(to)))
+    return
-  local is_error = false
-  for path in utils.path_split(to) do
-    idx = idx + 1
-
-    local p = utils.path_remove_trailing(path)
-    if #path_to_create == 0 and vim.fn.has("win32") == 1 then
-      path_to_create = utils.path_join({ p, path_to_create })
-    else
-      path_to_create = utils.path_join({ path_to_create, p })
-    end
-
-    if idx == num_nodes then
-      events._dispatch_will_rename_node(node.absolute_path, to)
-      local success, err = vim.loop.fs_rename(node.absolute_path, to)
-
-      if not success then
-        notify.warn(err_fmt(notify_from, notify_to, err))
-        return
-      end
-    elseif not rename_file_exists(notify_from, path_to_create) then
-      local success = vim.loop.fs_mkdir(path_to_create, 493)
-      if not success then
-        notify.error("Could not create folder " .. notify.render_path(path_to_create))
-        is_error = true
-        break
-      end
-      is_error = false
-    end
-  end
-
-  if not is_error then
-    notify.info(string.format("%s -> %s", notify_from, notify_to))
-    utils.rename_loaded_buffers(node.absolute_path, to)
-    events._dispatch_node_renamed(node.absolute_path, to)
   end
+  notify.info(string.format("%s -> %s", notify_from, notify_to))
+  utils.rename_loaded_buffers(node.absolute_path, to)
+  events._dispatch_node_renamed(node.absolute_path, to)
 end
 
 ---@param default_modifier string|nil
@@ -156,10 +102,7 @@ function M.fn(default_modifier)
 
       M.rename(node, prepend .. new_file_path .. append)
       if not M.config.filesystem_watchers.enable then
-        local explorer = core.get_explorer()
+        require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
-        if explorer then
-          explorer:reload_explorer()
-        end
       end
 
       find_file(utils.path_remove_trailing(new_file_path))

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

@@ -1,23 +1,22 @@
-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 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, {})
@@ -42,18 +41,16 @@ function M.remove(node)
   -- trashes a path (file or folder)
   local function trash_path(on_exit)
     local need_sync_wait = utils.is_windows
-    local job = vim.fn.jobstart(M.config.trash.cmd .. " " .. vim.fn.shellescape(node.absolute_path), {
+    local job = vim.fn.jobstart(M.config.trash.cmd .. ' "' .. node.absolute_path .. '"', {
       detach = not need_sync_wait,
       on_exit = on_exit,
       on_stderr = on_stderr,
     })
     if need_sync_wait then
-      vim.fn.jobwait({ job })
+      vim.fn.jobwait { job }
     end
   end
 
-  local explorer = core.get_explorer()
-
   if node.nodes ~= nil and not node.link_to then
     trash_path(function(_, rc)
       if rc ~= 0 then
@@ -61,8 +58,8 @@ function M.remove(node)
         return
       end
       events._dispatch_folder_removed(node.absolute_path)
-      if not M.config.filesystem_watchers.enable and explorer then
+      if not M.config.filesystem_watchers.enable then
-        explorer:reload_explorer()
+        require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
       end
     end)
   else
@@ -74,8 +71,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 and explorer then
+      if not M.config.filesystem_watchers.enable then
-        explorer:reload_explorer()
+        require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
       end
     end)
   end
@@ -105,7 +102,7 @@ function M.fn(node)
       items_long = { "No", "Yes" }
     end
 
-    lib.prompt(prompt_input, prompt_select, items_short, items_long, "nvimtree_trash", function(item_short)
+    lib.prompt(prompt_input, prompt_select, items_short, items_long, function(item_short)
       utils.clear_prompt()
       if item_short == "y" or item_short == (M.config.ui.confirm.default_yes and "") then
         do_trash()

lua/nvim-tree/actions/init.lua

@@ -1,17 +1,18 @@
 local M = {}
 
-M.finders = require("nvim-tree.actions.finders")
-M.fs = require("nvim-tree.actions.fs")
-M.moves = require("nvim-tree.actions.moves")
-M.node = require("nvim-tree.actions.node")
-M.root = require("nvim-tree.actions.root")
-M.tree = require("nvim-tree.actions.tree")
-
 function M.setup(opts)
-  M.fs.setup(opts)
+  require("nvim-tree.actions.fs.trash").setup(opts)
-  M.node.setup(opts)
+  require("nvim-tree.actions.node.system-open").setup(opts)
-  M.root.setup(opts)
+  require("nvim-tree.actions.node.file-popup").setup(opts)
-  M.tree.setup(opts)
+  require("nvim-tree.actions.node.open-file").setup(opts)
+  require("nvim-tree.actions.root.change-dir").setup(opts)
+  require("nvim-tree.actions.fs.rename-file").setup(opts)
+  require("nvim-tree.actions.fs.remove-file").setup(opts)
+  require("nvim-tree.actions.fs.copy-paste").setup(opts)
+  require("nvim-tree.actions.tree-modifiers.expand-all").setup(opts)
+  require("nvim-tree.actions.tree.find-file").setup(opts)
+  require("nvim-tree.actions.tree.open").setup(opts)
+  require("nvim-tree.actions.tree.toggle").setup(opts)
 end
 
 return M

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

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

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

@@ -1,240 +1,55 @@
-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 lib = require "nvim-tree.lib"
-local explorer_node = require("nvim-tree.explorer.node")
+local explorer_node = require "nvim-tree.explorer.node"
-local diagnostics = require("nvim-tree.diagnostics")
 
 local M = {}
-local MAX_DEPTH = 100
 
----Return the status of the node or nil if no status, depending on the type of
+---@param where string
----status.
+---@param what string
----@param node table node to inspect
----@param what string type of status
----@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)
-    return git_status ~= nil and (not skip_gitignored or git_status[1] ~= "!!")
-  elseif what == "diag" then
-    local diag_status = diagnostics.get_diag_status(node)
-    return diag_status ~= nil and diag_status.value ~= nil
-  elseif what == "opened" then
-    return vim.fn.bufloaded(node.absolute_path) ~= 0
-  end
-
-  return false
-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 what string type of status
----@param skip_gitignored boolean default false
-local function move(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 iter_start, iter_end, iter_step, cur, first, nex
-
-  local cursor = lib.get_cursor_position()
-  if cursor and cursor[1] < first_node_line then
-    cur = cursor[1]
-  end
-
-  if where == "next" then
-    iter_start, iter_end, iter_step = first_node_line, #nodes_by_line, 1
-  elseif where == "prev" then
-    iter_start, iter_end, iter_step = #nodes_by_line, first_node_line, -1
-  end
-
-  for line = iter_start, iter_end, iter_step do
-    local node = nodes_by_line[line]
-    local valid = status_is_valid(node, what, skip_gitignored)
-
-    if not first and valid then
-      first = line
-    end
-
-    if cursor and line == cursor[1] then
-      cur = line
-    elseif valid and cur then
-      nex = line
-      break
-    end
-  end
-
-  if nex then
-    view.set_cursor({ nex, 0 })
-  elseif vim.o.wrapscan and first then
-    view.set_cursor({ first, 0 })
-  end
-end
-
-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)
-  end
-end
-
---- Move to the next node recursively.
----@param what string type of status
----@param skip_gitignored boolean default false
-local function move_next_recursive(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()
-  if not node_init then
-    return
-  end
-  local valid = false
-  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
-    lib.expand_or_collapse(node_init)
-  end
-
-  move("next", what, skip_gitignored)
-
-  local node_cur = lib.get_node_at_cursor()
-  if not node_cur then
-    return
-  end
-
-  -- If we haven't moved at all at this point, return.
-  if node_init == node_cur then
-    return
-  end
-
-  -- i is used to limit iterations.
-  local i = 0
-  local is_dir = node_cur.nodes ~= nil
-  while is_dir and i < MAX_DEPTH do
-    expand_node(node_cur)
-
-    move("next", what, skip_gitignored)
-
-    -- Save current node.
-    node_cur = lib.get_node_at_cursor()
-    -- Update is_dir.
-    if node_cur then
-      is_dir = node_cur.nodes ~= nil
-    else
-      is_dir = false
-    end
-
-    i = i + 1
-  end
-end
-
---- Move to the previous node recursively.
----
---- move_prev_recursive:
----
---- 1) Save current as node_init.
---  2) Call a non-recursive prev.
---- 3) If current node is node_init's parent, call move_prev_recursive.
---- 4) Else:
---- 4.1) If current node is nil, is node_init (we didn't move), or is a file, return.
---- 4.2) The current file is a directory, expand it.
---- 4.3) Find node_init in current window, and move to it (if not found, return).
----      If node_init is the root node (name = ".."), directly move to position 1.
---- 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 skip_gitignored boolean default false
-local function move_prev_recursive(what, skip_gitignored)
-  local node_init, node_cur
-
-  -- 1)
-  node_init = lib.get_node_at_cursor()
-  if node_init == nil then
-    return
-  end
-
-  -- 2)
-  move("prev", what, skip_gitignored)
-
-  node_cur = lib.get_node_at_cursor()
-  if node_cur == node_init.parent then
-    -- 3)
-    move_prev_recursive(what, skip_gitignored)
-  else
-    -- i is used to limit iterations.
-    local i = 0
-    while i < MAX_DEPTH do
-      -- 4.1)
-      if
-        node_cur == nil
-        or node_cur == node_init -- we didn't move
-        or not node_cur.nodes    -- node is a file
-      then
-        return
-      end
-
-      -- 4.2)
-      local node_dir = node_cur
-      expand_node(node_dir)
-
-      -- 4.3)
-      if node_init.name == ".." then -- root node
-        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 })
-      end
-
-      -- 4.4)
-      move("prev", what, skip_gitignored)
-
-      -- 4.5)
-      node_cur = lib.get_node_at_cursor()
-
-      i = i + 1
-    end
-  end
-end
-
----@class NavigationItemOpts
----@field where string
----@field what string
-
----@param opts NavigationItemOpts
 ---@return fun()
-function M.fn(opts)
+function M.fn(where, what)
   return function()
-    local recurse = false
+    local node_cur = lib.get_node_at_cursor()
-    local skip_gitignored = false
+    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 iter_start, iter_end, iter_step, cur, first, nex
 
-    -- recurse only valid for git and diag moves.
+    if where == "next" then
-    if (opts.what == "git" or opts.what == "diag") and opts.recurse ~= nil then
+      iter_start, iter_end, iter_step = first_node_line, #nodes_by_line, 1
-      recurse = opts.recurse
+    elseif where == "prev" then
+      iter_start, iter_end, iter_step = #nodes_by_line, first_node_line, -1
     end
 
-    if opts.skip_gitignored ~= nil then
+    for line = iter_start, iter_end, iter_step do
-      skip_gitignored = opts.skip_gitignored
+      local node = nodes_by_line[line]
+      local valid = false
+
+      if what == "git" then
+        valid = explorer_node.get_git_status(node) ~= nil
+      elseif what == "diag" then
+        valid = node.diag_status ~= nil
+      elseif what == "opened" then
+        valid = vim.fn.bufloaded(node.absolute_path) ~= 0
+      end
+
+      if not first and valid then
+        first = line
+      end
+
+      if node == node_cur then
+        cur = line
+      elseif valid and cur then
+        nex = line
+        break
+      end
     end
 
-    if not recurse then
+    if nex then
-      move(opts.where, opts.what, skip_gitignored)
+      view.set_cursor { nex, 0 }
-      return
+    elseif vim.o.wrapscan and first then
-    end
+      view.set_cursor { first, 0 }
-
-    if opts.where == "next" then
-      move_next_recursive(opts.what, skip_gitignored)
-    elseif opts.where == "prev" then
-      move_prev_recursive(opts.what, skip_gitignored)
     end
   end
 end

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

@@ -1,7 +1,8 @@
-local view = require("nvim-tree.view")
+local renderer = require "nvim-tree.renderer"
-local utils = require("nvim-tree.utils")
+local view = require "nvim-tree.view"
-local core = require("nvim-tree.core")
+local utils = require "nvim-tree.utils"
-local lib = require("nvim-tree.lib")
+local core = require "nvim-tree.core"
+local lib = require "nvim-tree.lib"
 
 local M = {}
 
@@ -11,32 +12,26 @@ function M.fn(should_close)
   should_close = should_close or false
 
   return function(node)
-    local explorer = core.get_explorer()
     node = lib.get_last_group_node(node)
     if should_close and node.open then
       node.open = false
-      if explorer then
+      return renderer.draw()
-        explorer.renderer:draw()
-      end
-      return
     end
 
     local parent = utils.get_parent_of_group(node).parent
 
     if not parent or not parent.parent then
-      return view.set_cursor({ 1, 0 })
+      return view.set_cursor { 1, 0 }
     end
 
     local _, line = utils.find_node(core.get_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
-      if explorer then
+      renderer.draw()
-        explorer.renderer:draw()
-      end
     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 = {}
 

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 = {}
 
@@ -6,14 +6,6 @@ local M = {}
 ---@return table
 local function get_formatted_lines(node)
   local stats = node.fs_stat
-  if stats == nil then
-    return {
-      "",
-      "  Can't retrieve file information",
-      "",
-    }
-  end
-
   local fpath = " fullpath: " .. node.absolute_path
   local created_at = " created:  " .. os.date("%x %X", stats.birthtime.sec)
   local modified_at = " modified: " .. os.date("%x %X", stats.mtime.sec)
@@ -56,8 +48,8 @@ end
 
 function M.close_popup()
   if current_popup ~= nil then
-    vim.api.nvim_win_close(current_popup.winnr, true)
+    vim.api.nvim_win_close(current_popup.winnr, { force = 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,14 +0,0 @@
-local M = {}
-
-M.file_popup = require("nvim-tree.actions.node.file-popup")
-M.open_file = require("nvim-tree.actions.node.open-file")
-M.run_command = require("nvim-tree.actions.node.run-command")
-M.system_open = require("nvim-tree.actions.node.system-open")
-
-function M.setup(opts)
-  require("nvim-tree.actions.node.system-open").setup(opts)
-  require("nvim-tree.actions.node.file-popup").setup(opts)
-  require("nvim-tree.actions.node.open-file").setup(opts)
-end
-
-return M

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 = {}
 
@@ -26,20 +26,14 @@ local function usable_win_ids()
   return vim.tbl_filter(function(id)
     local bufid = vim.api.nvim_win_get_buf(id)
     for option, v in pairs(M.window_picker.exclude) do
-      local ok, option_value
+      local ok, option_value = pcall(vim.api.nvim_buf_get_option, bufid, option)
-      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
-      end
-
       if ok and vim.tbl_contains(v, option_value) then
         return false
       end
     end
 
     local win_config = vim.api.nvim_win_get_config(id)
-    return id ~= tree_winid and win_config.focusable and not win_config.external or false
+    return id ~= tree_winid and win_config.focusable and not win_config.external
   end, win_ids)
 end
 
@@ -89,15 +83,8 @@ 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 = pcall(vim.api.nvim_win_get_option, win_id, "statusline")
-
+      local ok_hl, winhl = pcall(vim.api.nvim_win_get_option, win_id, "winhl")
-      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] = {
         statusline = ok_status and statusline or "",
@@ -105,26 +92,15 @@ local function pick_win_id()
       }
 
       -- Clear statusline for windows not selectable
-      if vim.fn.has("nvim-0.10") == 1 then
+      vim.api.nvim_win_set_option(win_id, "statusline", " ")
-        vim.api.nvim_set_option_value("statusline", " ", { win = win_id })
-      else
-        vim.api.nvim_win_set_option(win_id, "statusline", " ") ---@diagnostic disable-line: deprecated
-      end
     end
   end
 
   -- Setup UI
   for _, id in ipairs(selectable) do
     local char = M.window_picker.chars:sub(i, i)
-
+    local ok_status, statusline = pcall(vim.api.nvim_win_get_option, id, "statusline")
-    local ok_status, statusline, ok_hl, winhl
+    local ok_hl, winhl = pcall(vim.api.nvim_win_get_option, id, "winhl")
-    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
-      ok_status, statusline = pcall(vim.api.nvim_win_get_option, id, "statusline") ---@diagnostic disable-line: deprecated
-      ok_hl, winhl = pcall(vim.api.nvim_win_get_option, id, "winhl") ---@diagnostic disable-line: deprecated
-    end
 
     win_opts[id] = {
       statusline = ok_status and statusline or "",
@@ -132,13 +108,8 @@ local function pick_win_id()
     }
     win_map[char] = id
 
-    if vim.fn.has("nvim-0.10") == 1 then
+    vim.api.nvim_win_set_option(id, "statusline", "%=" .. char .. "%=")
-      vim.api.nvim_set_option_value("statusline", "%=" .. char .. "%=", { win = id })
+    vim.api.nvim_win_set_option(id, "winhl", "StatusLine:NvimTreeWindowPicker,StatusLineNC:NvimTreeWindowPicker")
-      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
-    end
 
     i = i + 1
     if i > #M.window_picker.chars then
@@ -146,9 +117,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()
@@ -157,25 +128,14 @@ local function pick_win_id()
   -- Restore window options
   for _, id in ipairs(selectable) do
     for opt, value in pairs(win_opts[id]) do
-      if vim.fn.has("nvim-0.10") == 1 then
+      vim.api.nvim_win_set_option(id, opt, value)
-        vim.api.nvim_set_option_value(opt, value, { win = id })
-      else
-        vim.api.nvim_win_set_option(id, opt, value) ---@diagnostic disable-line: deprecated
-      end
     end
   end
 
   if laststatus == 3 then
     for _, id in ipairs(not_selectable) do
-      -- Ensure window still exists at this point
+      for opt, value in pairs(win_opts[id]) do
-      if vim.api.nvim_win_is_valid(id) then
+        vim.api.nvim_win_set_option(id, opt, value)
-        for opt, value in pairs(win_opts[id]) do
-          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
-          end
-        end
       end
     end
   end
@@ -193,9 +153,6 @@ local function open_file_in_tab(filename)
   if M.quit_on_open then
     view.close()
   end
-  if M.relative_path then
-    filename = utils.path_relative(filename, vim.fn.getcwd())
-  end
   vim.cmd("tabe " .. vim.fn.fnameescape(filename))
 end
 
@@ -203,9 +160,6 @@ local function drop(filename)
   if M.quit_on_open then
     view.close()
   end
-  if M.relative_path then
-    filename = utils.path_relative(filename, vim.fn.getcwd())
-  end
   vim.cmd("drop " .. vim.fn.fnameescape(filename))
 end
 
@@ -213,9 +167,6 @@ local function tab_drop(filename)
   if M.quit_on_open then
     view.close()
   end
-  if M.relative_path then
-    filename = utils.path_relative(filename, vim.fn.getcwd())
-  end
   vim.cmd("tab :drop " .. vim.fn.fnameescape(filename))
 end
 
@@ -300,28 +251,32 @@ 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
     -- If `hidden` is not enabled, check if buffer in target window is
     -- modified, and create new split if it is.
     local target_bufid = vim.api.nvim_win_get_buf(target_winid)
-
+    if vim.api.nvim_buf_get_option(target_bufid, "modified") then
-    local modified
+      if not mode:match "split$" 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
         mode = "vsplit"
       end
     end
   end
 
+  local fname = vim.fn.fnameescape(filename)
+  fname = utils.escape_special_chars(fname)
+
+  local cmd
+  if create_new_window then
+    cmd = string.format("%s vsplit %s", new_window_side, fname)
+  elseif mode:match "split$" then
+    cmd = string.format("%s %s", mode, fname)
+  else
+    cmd = string.format("edit %s", fname)
+  end
+
   if (mode == "preview" or mode == "preview_no_picker") and view.View.float.enable then
     -- ignore "WinLeave" autocmd on preview
     -- because the registered "WinLeave"
@@ -331,24 +286,7 @@ local function open_in_new_window(filename, mode)
     set_current_win_no_autocmd(target_winid, { "BufEnter" })
   end
 
-  local fname
+  pcall(vim.cmd, cmd)
-  if M.relative_path then
-    fname = vim.fn.fnameescape(utils.path_relative(filename, vim.fn.getcwd()))
-  else
-    fname = vim.fn.fnameescape(filename)
-  end
-
-  local command
-  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
-    command = { cmd = mode, args = { fname } }
-  else
-    command = { cmd = "edit", args = { fname } }
-  end
-
-  pcall(vim.api.nvim_cmd, command, { output = false })
   lib.set_target_win()
 end
 
@@ -363,37 +301,33 @@ end
 
 local function edit_in_current_buf(filename)
   require("nvim-tree.view").abandon_current_window()
-  if M.relative_path then
-    filename = utils.path_relative(filename, vim.fn.getcwd())
-  end
   vim.cmd("keepalt keepjumps edit " .. vim.fn.fnameescape(filename))
 end
 
 ---@param mode string
 ---@param filename string
 function M.fn(mode, filename)
-  local fname = utils.escape_special_chars(filename)
   if type(mode) ~= "string" then
     mode = ""
   end
 
   if mode == "tabnew" then
-    return open_file_in_tab(fname)
+    return open_file_in_tab(filename)
   end
 
   if mode == "drop" then
-    return drop(fname)
+    return drop(filename)
   end
 
   if mode == "tab_drop" then
-    return tab_drop(fname)
+    return tab_drop(filename)
   end
 
   if mode == "edit_in_place" then
-    return edit_in_current_buf(fname)
+    return edit_in_current_buf(filename)
   end
 
-  local buf_loaded = is_already_loaded(fname)
+  local buf_loaded = is_already_loaded(filename)
 
   local found_win = utils.get_win_buf_from_path(filename)
   if found_win and (mode == "preview" or mode == "preview_no_picker") then
@@ -401,7 +335,7 @@ function M.fn(mode, filename)
   end
 
   if not found_win then
-    open_in_new_window(fname, mode)
+    open_in_new_window(filename, mode)
   else
     vim.api.nvim_set_current_win(found_win)
     vim.bo.bufhidden = ""
@@ -423,7 +357,6 @@ 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
   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
-local function user(node)
+function M.fn(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,41 +49,20 @@ local function user(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 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 vim.fn.has("nvim-0.10") == 1 and #M.config.system_open.cmd == 0 then
+  if #M.config.system_open.cmd == 0 then
-    M.open = native
+    if utils.is_windows then
-  else
+      M.config.system_open = {
-    M.open = user
+        cmd = "cmd",
-    if #M.config.system_open.cmd == 0 then
+        args = { "/c", "start", '""' },
-      if utils.is_windows then
+      }
-        M.config.system_open = {
+    elseif utils.is_macos then
-          cmd = "cmd",
+      M.config.system_open.cmd = "open"
-          args = { "/c", "start", '""' },
+    elseif utils.is_unix then
-        }
+      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/reloaders.lua

@@ -0,0 +1,74 @@
+local git = require "nvim-tree.git"
+local view = require "nvim-tree.view"
+local renderer = require "nvim-tree.renderer"
+local explorer_module = require "nvim-tree.explorer"
+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 node Explorer|nil
+---@param projects table
+---@param unloaded_bufnr number|nil
+local function refresh_nodes(node, projects, unloaded_bufnr)
+  Iterator.builder({ node })
+    :applier(function(n)
+      if n.nodes then
+        local toplevel = git.get_toplevel(n.cwd or n.link_to or n.absolute_path)
+        explorer_module.reload(n, projects[toplevel] or {}, unloaded_bufnr)
+      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
+---@param _ table|nil unused node passed by action
+---@param unloaded_bufnr number|nil optional bufnr recently unloaded via BufUnload event
+function M.reload_explorer(_, unloaded_bufnr)
+  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, unloaded_bufnr)
+  if view.is_visible() then
+    renderer.draw(unloaded_bufnr)
+  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,10 +91,7 @@ M.force_dirchange = add_profiling_to(function(foldername, should_open_view)
   if should_open_view then
     require("nvim-tree.lib").open()
   else
-    local explorer = core.get_explorer()
+    require("nvim-tree.renderer").draw()
-    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,10 +0,0 @@
-local M = {}
-
-M.change_dir = require("nvim-tree.actions.root.change-dir")
-M.dir_up = require("nvim-tree.actions.root.dir-up")
-
-function M.setup(opts)
-  M.change_dir.setup(opts)
-end
-
-return M

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

@@ -1,7 +1,8 @@
-local utils = require("nvim-tree.utils")
+local renderer = require "nvim-tree.renderer"
-local core = require("nvim-tree.core")
+local utils = require "nvim-tree.utils"
-local lib = require("nvim-tree.lib")
+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 M = {}
 
@@ -45,7 +46,7 @@ function M.fn(keep_buffers)
     end)
     :iterate()
 
-  explorer.renderer:draw()
+  renderer.draw()
   utils.focus_node_or_parent(node)
 end
 

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

@@ -1,7 +1,8 @@
-local core = require("nvim-tree.core")
+local core = require "nvim-tree.core"
-local Iterator = require("nvim-tree.iterators.node-iterator")
+local renderer = require "nvim-tree.renderer"
-local notify = require("nvim-tree.notify")
+local Iterator = require "nvim-tree.iterators.node-iterator"
-local lib = require("nvim-tree.lib")
+local notify = require "nvim-tree.notify"
+local lib = require "nvim-tree.lib"
 
 local M = {}
 
@@ -64,14 +65,11 @@ end
 
 ---@param base_node table
 function M.fn(base_node)
-  local explorer = core.get_explorer()
+  local node = base_node.nodes and base_node or core.get_explorer()
-  local node = base_node.nodes and base_node or explorer
   if gen_iterator()(node) then
     notify.warn("expansion iteration was halted after " .. M.MAX_FOLDER_DISCOVERY .. " discovered folders")
   end
-  if explorer then
+  renderer.draw()
-    explorer.renderer:draw()
-  end
 end
 
 function M.setup(opts)

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

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

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 = {}
 
@@ -24,19 +24,18 @@ function M.fn(opts)
   local bufnr, path
 
   -- (optional) buffer number and path
-  local opts_buf = opts.buf
+  if type(opts.buf) == "nil" then
-  if type(opts_buf) == "nil" then
     bufnr = vim.api.nvim_get_current_buf()
     path = vim.api.nvim_buf_get_name(bufnr)
-  elseif type(opts_buf) == "number" then
+  elseif type(opts.buf) == "number" then
-    if not vim.api.nvim_buf_is_valid(opts_buf) then
+    if not vim.api.nvim_buf_is_valid(opts.buf) then
       return
     end
-    bufnr = opts_buf
+    bufnr = tonumber(opts.buf)
     path = vim.api.nvim_buf_get_name(bufnr)
-  elseif type(opts_buf) == "string" then
+  elseif type(opts.buf) == "string" then
     bufnr = nil
-    path = tostring(opts_buf)
+    path = tostring(opts.buf)
   else
     return
   end
@@ -49,14 +48,14 @@ 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
 
   -- update root
-  if opts.update_root or M.config.update_focused_file.update_root.enable then
+  if opts.update_root or M.config.update_focused_file.update_root then
     require("nvim-tree").change_root(path, bufnr)
   end
 

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

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

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

@@ -1,11 +0,0 @@
-local M = {}
-
-M.collapse_all = require("nvim-tree.actions.tree.modifiers.collapse-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)
-end
-
-return M

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

@@ -1,72 +0,0 @@
-local lib = require("nvim-tree.lib")
-local utils = require("nvim-tree.utils")
-local core = require("nvim-tree.core")
-local M = {}
-
----@param explorer Explorer
-local function reload(explorer)
-  local node = lib.get_node_at_cursor()
-  explorer: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
-
----@param explorer Explorer
-local function custom(explorer)
-  explorer.filters.config.filter_custom = not explorer.filters.config.filter_custom
-  reload(explorer)
-end
-
----@param explorer Explorer
-local function git_ignored(explorer)
-  explorer.filters.config.filter_git_ignored = not explorer.filters.config.filter_git_ignored
-  reload(explorer)
-end
-
----@param explorer Explorer
-local function git_clean(explorer)
-  explorer.filters.config.filter_git_clean = not explorer.filters.config.filter_git_clean
-  reload(explorer)
-end
-
----@param explorer Explorer
-local function no_buffer(explorer)
-  explorer.filters.config.filter_no_buffer = not explorer.filters.config.filter_no_buffer
-  reload(explorer)
-end
-
----@param explorer Explorer
-local function no_bookmark(explorer)
-  explorer.filters.config.filter_no_bookmark = not explorer.filters.config.filter_no_bookmark
-  reload(explorer)
-end
-
----@param explorer Explorer
-local function dotfiles(explorer)
-  explorer.filters.config.filter_dotfiles = not explorer.filters.config.filter_dotfiles
-  reload(explorer)
-end
-
----@param explorer Explorer
-local function enable(explorer)
-  explorer.filters.config.enable = not explorer.filters.config.enable
-  reload(explorer)
-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,51 +0,0 @@
-local view = require("nvim-tree.view")
-
-local M = {}
-
----Resize the tree, persisting the new size.
----@param opts ApiTreeResizeOpts|nil
-function M.fn(opts)
-  if opts == nil then
-    -- reset to config values
-    view.configure_width()
-    view.resize()
-    return
-  end
-
-  local options = opts or {}
-  local width_cfg = options.width
-
-  if width_cfg ~= nil then
-    view.configure_width(width_cfg)
-    view.resize()
-    return
-  end
-
-  if not view.is_width_determined() then
-    -- {absolute} and {relative} do nothing when {width} is a function.
-    return
-  end
-
-  local absolute = options.absolute
-  if type(absolute) == "number" then
-    view.resize(absolute)
-    return
-  end
-
-  local relative = options.relative
-  if type(relative) == "number" then
-    local relative_size = tostring(relative)
-    if relative > 0 then
-      relative_size = "+" .. relative_size
-    end
-
-    view.resize(relative_size)
-    return
-  end
-end
-
-function M.setup(opts)
-  M.config = opts or {}
-end
-
-return 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,4 @@
-local lib = require("nvim-tree.lib")
+local notify = require "nvim-tree.notify"
-local core = require("nvim-tree.core")
-local view = require("nvim-tree.view")
-local utils = require("nvim-tree.utils")
-local actions = require("nvim-tree.actions")
-local appearance_diagnostics = require("nvim-tree.appearance.diagnostics")
-local events = require("nvim-tree.events")
-local help = require("nvim-tree.help")
-local keymap = require("nvim-tree.keymap")
-local notify = require("nvim-tree.notify")
 
 local Api = {
   tree = {},
@@ -35,30 +26,28 @@ local Api = {
     mappings = {},
   },
   commands = {},
-  diagnostics = {},
 }
 
---- Print error when setup not called.
+--- Do nothing when setup not called.
 --- f function to invoke
 ---@param f function
----@return fun(...) : any
 local function wrap(f)
   return function(...)
     if vim.g.NvimTreeSetup == 1 then
       return f(...)
     else
-      notify.error("nvim-tree setup not called")
+      notify.error "nvim-tree setup not called"
     end
   end
 end
 
----Inject the node as the first argument if present otherwise do nothing.
+---Inject the node as the first argument if absent.
 ---@param fn function function to invoke
 local function wrap_node(fn)
   return function(node, ...)
-    node = node or lib.get_node_at_cursor()
+    node = node or require("nvim-tree.lib").get_node_at_cursor()
     if node then
-      return fn(node, ...)
+      fn(node, ...)
     end
   end
 end
@@ -67,38 +56,11 @@ end
 ---@param fn function function to invoke
 local function wrap_node_or_nil(fn)
   return function(node, ...)
-    node = node or lib.get_node_at_cursor()
+    node = node or require("nvim-tree.lib").get_node_at_cursor()
-    return fn(node, ...)
+    fn(node, ...)
   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
-
----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()
-    if explorer then
-      return explorer[explorer_member][member_method](explorer[explorer_member], ...)
-    end
-  end)
-end
-
 ---@class ApiTreeOpenOpts
 ---@field path string|nil path
 ---@field current_window boolean|nil default false
@@ -106,8 +68,7 @@ end
 ---@field find_file boolean|nil default false
 ---@field update_root boolean|nil default false
 
-Api.tree.open = wrap(actions.tree.open.fn)
+Api.tree.open = wrap(require("nvim-tree.actions.tree.open").fn)
-Api.tree.focus = Api.tree.open
 
 ---@class ApiTreeToggleOpts
 ---@field path string|nil
@@ -117,18 +78,19 @@ Api.tree.focus = Api.tree.open
 ---@field update_root boolean|nil default false
 ---@field focus boolean|nil default true
 
-Api.tree.toggle = wrap(actions.tree.toggle.fn)
+Api.tree.toggle = wrap(require("nvim-tree.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_explorer("reload_explorer")
 
----@class ApiTreeResizeOpts
+Api.tree.close = wrap(require("nvim-tree.view").close)
----@field width string|function|number|table|nil
----@field absolute number|nil
----@field relative number|nil
 
-Api.tree.resize = wrap(actions.tree.resize.fn)
+Api.tree.close_in_this_tab = wrap(require("nvim-tree.view").close_this_tab_only)
+
+Api.tree.close_in_all_tabs = wrap(require("nvim-tree.view").close_all_tabs)
+
+Api.tree.focus = wrap(function()
+  Api.tree.open()
+end)
+
+Api.tree.reload = wrap(require("nvim-tree.actions.reloaders.reloaders").reload_explorer)
 
 Api.tree.change_root = wrap(function(...)
   require("nvim-tree").change_dir(...)
@@ -136,15 +98,17 @@ end)
 
 Api.tree.change_root_to_node = wrap_node(function(node)
   if node.name == ".." then
-    actions.root.change_dir.fn("..")
+    require("nvim-tree.actions.root.change-dir").fn ".."
   elseif node.nodes ~= nil then
-    actions.root.change_dir.fn(lib.get_last_group_node(node).absolute_path)
+    require("nvim-tree.actions.root.change-dir").fn(require("nvim-tree.lib").get_last_group_node(node).absolute_path)
   end
 end)
 
-Api.tree.change_root_to_parent = wrap_node(actions.root.dir_up.fn)
+Api.tree.change_root_to_parent = wrap_node(require("nvim-tree.actions.root.dir-up").fn)
-Api.tree.get_node_under_cursor = wrap(lib.get_node_at_cursor)
+
-Api.tree.get_nodes = wrap(lib.get_nodes)
+Api.tree.get_node_under_cursor = wrap(require("nvim-tree.lib").get_node_at_cursor)
+
+Api.tree.get_nodes = wrap(require("nvim-tree.lib").get_nodes)
 
 ---@class ApiTreeFindFileOpts
 ---@field buf string|number|nil
@@ -154,48 +118,55 @@ Api.tree.get_nodes = wrap(lib.get_nodes)
 ---@field update_root boolean|nil default false
 ---@field focus boolean|nil default false
 
-Api.tree.find_file = wrap(actions.tree.find_file.fn)
+Api.tree.find_file = wrap(require("nvim-tree.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.search_node = wrap(require("nvim-tree.actions.finders.search-node").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.collapse_all = wrap(require("nvim-tree.actions.tree-modifiers.collapse-all").fn)
-Api.tree.toggle_gitignore_filter = wrap(actions.tree.modifiers.toggles.git_ignored)
+
-Api.tree.toggle_git_clean_filter = wrap(actions.tree.modifiers.toggles.git_clean)
+Api.tree.expand_all = wrap_node(require("nvim-tree.actions.tree-modifiers.expand-all").fn)
-Api.tree.toggle_no_buffer_filter = wrap(actions.tree.modifiers.toggles.no_buffer)
+
-Api.tree.toggle_custom_filter = wrap(actions.tree.modifiers.toggles.custom)
+Api.tree.toggle_gitignore_filter = wrap(require("nvim-tree.actions.tree-modifiers.toggles").git_ignored)
-Api.tree.toggle_hidden_filter = wrap(actions.tree.modifiers.toggles.dotfiles)
+
-Api.tree.toggle_no_bookmark_filter = wrap(actions.tree.modifiers.toggles.no_bookmark)
+Api.tree.toggle_git_clean_filter = wrap(require("nvim-tree.actions.tree-modifiers.toggles").git_clean)
-Api.tree.toggle_help = wrap(help.toggle)
+
-Api.tree.is_tree_buf = wrap(utils.is_nvim_tree_buf)
+Api.tree.toggle_no_buffer_filter = wrap(require("nvim-tree.actions.tree-modifiers.toggles").no_buffer)
+
+Api.tree.toggle_custom_filter = wrap(require("nvim-tree.actions.tree-modifiers.toggles").custom)
+
+Api.tree.toggle_hidden_filter = wrap(require("nvim-tree.actions.tree-modifiers.toggles").dotfiles)
+
+Api.tree.toggle_help = wrap(require("nvim-tree.help").toggle)
+
+Api.tree.is_tree_buf = wrap(require("nvim-tree.utils").is_nvim_tree_buf)
 
 ---@class ApiTreeIsVisibleOpts
 ---@field tabpage number|nil
 ---@field any_tabpage boolean|nil default false
 
-Api.tree.is_visible = wrap(view.is_visible)
+Api.tree.is_visible = wrap(require("nvim-tree.view").is_visible)
 
 ---@class ApiTreeWinIdOpts
 ---@field tabpage number|nil default nil
 
-Api.tree.winid = wrap(view.winid)
+Api.tree.winid = wrap(require("nvim-tree.view").winid)
 
-Api.fs.create = wrap_node_or_nil(actions.fs.create_file.fn)
+Api.fs.create = wrap_node_or_nil(require("nvim-tree.actions.fs.create-file").fn)
-Api.fs.remove = wrap_node(actions.fs.remove_file.fn)
+Api.fs.remove = wrap_node(require("nvim-tree.actions.fs.remove-file").fn)
-Api.fs.trash = wrap_node(actions.fs.trash.fn)
+Api.fs.trash = wrap_node(require("nvim-tree.actions.fs.trash").fn)
-Api.fs.rename_node = wrap_node(actions.fs.rename_file.fn(":t"))
+Api.fs.rename_node = wrap_node(require("nvim-tree.actions.fs.rename-file").fn ":t")
-Api.fs.rename = wrap_node(actions.fs.rename_file.fn(":t"))
+Api.fs.rename = wrap_node(require("nvim-tree.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(require("nvim-tree.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(require("nvim-tree.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(require("nvim-tree.actions.fs.rename-file").fn ":p")
-Api.fs.cut = wrap_node(wrap_explorer_member("clipboard", "cut"))
+Api.fs.cut = wrap_node(require("nvim-tree.actions.fs.copy-paste").cut)
-Api.fs.paste = wrap_node(wrap_explorer_member("clipboard", "paste"))
+Api.fs.paste = wrap_node(require("nvim-tree.actions.fs.copy-paste").paste)
-Api.fs.clear_clipboard = wrap_explorer_member("clipboard", "clear_clipboard")
+Api.fs.clear_clipboard = wrap(require("nvim-tree.actions.fs.copy-paste").clear_clipboard)
-Api.fs.print_clipboard = wrap_explorer_member("clipboard", "print_clipboard")
+Api.fs.print_clipboard = wrap(require("nvim-tree.actions.fs.copy-paste").print_clipboard)
-Api.fs.copy.node = wrap_node(wrap_explorer_member("clipboard", "copy"))
+Api.fs.copy.node = wrap_node(require("nvim-tree.actions.fs.copy-paste").copy)
-Api.fs.copy.absolute_path = wrap_node(wrap_explorer_member("clipboard", "copy_absolute_path"))
+Api.fs.copy.absolute_path = wrap_node(require("nvim-tree.actions.fs.copy-paste").copy_absolute_path)
-Api.fs.copy.filename = wrap_node(wrap_explorer_member("clipboard", "copy_filename"))
+Api.fs.copy.filename = wrap_node(require("nvim-tree.actions.fs.copy-paste").copy_filename)
-Api.fs.copy.basename = wrap_node(wrap_explorer_member("clipboard", "copy_basename"))
+Api.fs.copy.relative_path = wrap_node(require("nvim-tree.actions.fs.copy-paste").copy_path)
-Api.fs.copy.relative_path = wrap_node(wrap_explorer_member("clipboard", "copy_path"))
 
 ---@param mode string
 ---@param node table
@@ -204,82 +175,78 @@ local function edit(mode, node)
   if node.link_to and not node.nodes then
     path = node.link_to
   end
-  actions.node.open_file.fn(mode, path)
+  require("nvim-tree.actions.node.open-file").fn(mode, path)
 end
 
 ---@param mode string
 ---@return fun(node: table)
-local function open_or_expand_or_dir_up(mode, toggle_group)
+local function open_or_expand_or_dir_up(mode)
   return function(node)
     if node.name == ".." then
-      actions.root.change_dir.fn("..")
+      require("nvim-tree.actions.root.change-dir").fn ".."
     elseif node.nodes then
-      lib.expand_or_collapse(node, toggle_group)
+      require("nvim-tree.lib").expand_or_collapse(node)
-    elseif not toggle_group then
+    else
       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.show_info_popup = wrap_node(require("nvim-tree.actions.node.file-popup").toggle_file_info)
-Api.node.run.cmd = wrap_node(actions.node.run_command.run_file_command)
+Api.node.run.cmd = wrap_node(require("nvim-tree.actions.node.run-command").run_file_command)
-Api.node.run.system = wrap_node(actions.node.system_open.fn)
+Api.node.run.system = wrap_node(require("nvim-tree.actions.node.system-open").fn)
+Api.node.navigate.sibling.next = wrap_node(require("nvim-tree.actions.moves.sibling").fn "next")
+Api.node.navigate.sibling.prev = wrap_node(require("nvim-tree.actions.moves.sibling").fn "prev")
+Api.node.navigate.sibling.first = wrap_node(require("nvim-tree.actions.moves.sibling").fn "first")
+Api.node.navigate.sibling.last = wrap_node(require("nvim-tree.actions.moves.sibling").fn "last")
+Api.node.navigate.parent = wrap_node(require("nvim-tree.actions.moves.parent").fn(false))
+Api.node.navigate.parent_close = wrap_node(require("nvim-tree.actions.moves.parent").fn(true))
+Api.node.navigate.git.next = wrap_node(require("nvim-tree.actions.moves.item").fn("next", "git"))
+Api.node.navigate.git.prev = wrap_node(require("nvim-tree.actions.moves.item").fn("prev", "git"))
+Api.node.navigate.diagnostics.next = wrap_node(require("nvim-tree.actions.moves.item").fn("next", "diag"))
+Api.node.navigate.diagnostics.prev = wrap_node(require("nvim-tree.actions.moves.item").fn("prev", "diag"))
+Api.node.navigate.opened.next = wrap_node(require("nvim-tree.actions.moves.item").fn("next", "opened"))
+Api.node.navigate.opened.prev = wrap_node(require("nvim-tree.actions.moves.item").fn("prev", "opened"))
 
-Api.node.navigate.sibling.next = wrap_node(actions.moves.sibling.fn("next"))
+Api.git.reload = wrap(require("nvim-tree.actions.reloaders.reloaders").reload_git)
-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.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_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.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_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_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_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.prev = wrap_node(actions.moves.item.fn({ where = "prev", what = "opened" }))
 
-Api.git.reload = wrap_explorer("reload_git")
+Api.events.subscribe = require("nvim-tree.events").subscribe
+Api.events.Event = require("nvim-tree.events").Event
 
-Api.events.subscribe = events.subscribe
+Api.live_filter.start = wrap(require("nvim-tree.live-filter").start_filtering)
-Api.events.Event = events.Event
+Api.live_filter.clear = wrap(require("nvim-tree.live-filter").clear_filter)
 
-Api.live_filter.start = wrap_explorer_member("live_filter", "start_filtering")
+Api.marks.get = wrap_node(require("nvim-tree.marks").get_mark)
-Api.live_filter.clear = wrap_explorer_member("live_filter", "clear_filter")
+Api.marks.list = wrap(require("nvim-tree.marks").get_marks)
+Api.marks.toggle = wrap_node(require("nvim-tree.marks").toggle_mark)
+Api.marks.clear = wrap(require("nvim-tree.marks").clear_marks)
+Api.marks.bulk.delete = wrap(require("nvim-tree.marks.bulk-delete").bulk_delete)
+Api.marks.bulk.trash = wrap(require("nvim-tree.marks.bulk-trash").bulk_trash)
+Api.marks.bulk.move = wrap(require("nvim-tree.marks.bulk-move").bulk_move)
+Api.marks.navigate.next = wrap(require("nvim-tree.marks.navigation").next)
+Api.marks.navigate.prev = wrap(require("nvim-tree.marks.navigation").prev)
+Api.marks.navigate.select = wrap(require("nvim-tree.marks.navigation").select)
 
-Api.marks.get = wrap_node(wrap_explorer_member("marks", "get"))
+Api.config.mappings.default_on_attach = require("nvim-tree.keymap").default_on_attach
-Api.marks.list = wrap_explorer_member("marks", "list")
-Api.marks.toggle = wrap_node(wrap_explorer_member("marks", "toggle"))
-Api.marks.clear = wrap_explorer_member("marks", "clear")
-Api.marks.bulk.delete = wrap_explorer_member("marks", "bulk_delete")
-Api.marks.bulk.trash = wrap_explorer_member("marks", "bulk_trash")
-Api.marks.bulk.move = wrap_explorer_member("marks", "bulk_move")
-Api.marks.navigate.next = wrap_explorer_member("marks", "navigate_next")
-Api.marks.navigate.prev = wrap_explorer_member("marks", "navigate_prev")
-Api.marks.navigate.select = wrap_explorer_member("marks", "navigate_select")
 
-Api.config.mappings.get_keymap = wrap(keymap.get_keymap)
+Api.config.mappings.get_keymap = wrap(function()
-Api.config.mappings.get_keymap_default = wrap(keymap.get_keymap_default)
+  return require("nvim-tree.keymap").get_keymap()
-Api.config.mappings.default_on_attach = keymap.default_on_attach
+end)
 
-Api.diagnostics.hi_test = wrap(appearance_diagnostics.hi_test)
+Api.config.mappings.get_keymap_default = wrap(function()
+  return require("nvim-tree.keymap").get_keymap_default()
+end)
 
 Api.commands.get = wrap(function()
   return require("nvim-tree.commands").get()

lua/nvim-tree/appearance/diagnostics.lua

@@ -1,141 +0,0 @@
-local appearance = require("nvim-tree.appearance")
-
--- others with name and links less than this arbitrary value are short
-local SHORT_LEN = 50
-
-local M = {}
-
----@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 = {}
-
----@param group string nvim-tree highlight group name
----@return HighlightDisplay
-function HighlightDisplay:new(group)
-  local o = {}
-  setmetatable(o, self)
-  self.__index = self
-
-  o.group = group
-  local concrete = o.group
-
-  -- maybe follow links
-  local links = {}
-  local link = vim.api.nvim_get_hl(0, { name = o.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, " ")
-
-  -- 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 *", "")
-  else
-    o.def = ""
-  end
-
-  return o
-end
-
----Render one group.
----@param bufnr number to render in
----@param fmt string format string for group, links, def
----@param l number line number to render at
----@return number l next line number
-function HighlightDisplay:render(bufnr, fmt, l)
-  local text = string.format(fmt, self.group, self.links, self.def)
-
-  vim.api.nvim_buf_set_lines(bufnr, l, -1, true, { text })
-  vim.api.nvim_buf_add_highlight(bufnr, -1, self.group, l, 0, #self.group)
-
-  return l + 1
-end
-
----Render many groups.
----@param header string before with underline line
----@param displays HighlightDisplay[] highlight group
----@param bufnr number to render in
----@param l number line number to start at
----@return number l next line number
-local function render_displays(header, displays, bufnr, l)
-  local max_group_len = 0
-  local max_links_len = 0
-
-  -- build all highlight groups, using name only
-  for _, display in ipairs(displays) do
-    max_group_len = math.max(max_group_len, #display.group)
-    max_links_len = math.max(max_links_len, #display.links)
-  end
-
-  -- header
-  vim.api.nvim_buf_set_lines(bufnr, l, -1, true, { header, (header:gsub(".", "-")) })
-  l = l + 2
-
-  -- render and highlight
-  local fmt = string.format("%%-%d.%ds %%-%d.%ds %%s", max_group_len, max_group_len, max_links_len, max_links_len)
-  for _, display in ipairs(displays) do
-    l = display:render(bufnr, fmt, l)
-  end
-
-  return l
-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()
-  -- create a buffer
-  local bufnr = vim.api.nvim_create_buf(false, true)
-
-  local l = 0
-
-  -- nvim-tree groups, ordered
-  local displays = {}
-  for _, highlight_group in ipairs(appearance.HIGHLIGHT_GROUPS) do
-    local display = HighlightDisplay:new(highlight_group.group)
-    table.insert(displays, display)
-  end
-  l = render_displays("nvim-tree", displays, bufnr, l)
-
-  vim.api.nvim_buf_set_lines(bufnr, l, -1, true, { "" })
-  l = l + 1
-
-  -- built in groups, ordered opaquely by nvim
-  local displays_short, displays_long = {}, {}
-  local ok, out = pcall(vim.api.nvim_cmd, { cmd = "highlight" }, { output = true })
-  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)
-        if #display.group + #display.links > SHORT_LEN then
-          table.insert(displays_long, display)
-        else
-          table.insert(displays_short, display)
-        end
-      end
-    end
-  end
-
-  -- short ones first
-  l = render_displays("other, short", displays_short, bufnr, l)
-  vim.api.nvim_buf_set_lines(bufnr, l, -1, true, { "" })
-  l = l + 1
-
-  -- long
-  render_displays("other, long", displays_long, bufnr, l)
-
-  -- finalise and focus the buffer
-  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
-  end
-
-  vim.cmd.buffer(bufnr)
-end
-
-return M

lua/nvim-tree/appearance/init.lua

@@ -1,210 +0,0 @@
-local M = {}
-
----@class HighlightGroup
----@field group string
----@field link string|nil
----@field def string|nil
-
----@type HighlightGroup[]
--- All highlight groups: linked or directly defined.
--- Please add new groups to help and preserve order.
--- Please avoid directly defined groups to preserve accessibility for TUI.
-M.HIGHLIGHT_GROUPS = {
-
-  -- Standard
-  { group = "NvimTreeNormal",                  link = "Normal" },
-  { group = "NvimTreeNormalFloat",             link = "NormalFloat" },
-  { group = "NvimTreeNormalFloatBorder",       link = "FloatBorder" },
-  { group = "NvimTreeNormalNC",                link = "NvimTreeNormal" },
-
-  { group = "NvimTreeLineNr",                  link = "LineNr" },
-  { group = "NvimTreeWinSeparator",            link = "WinSeparator" },
-  { group = "NvimTreeEndOfBuffer",             link = "EndOfBuffer" },
-  { group = "NvimTreePopup",                   link = "Normal" },
-  { group = "NvimTreeSignColumn",              link = "NvimTreeNormal" },
-
-  { group = "NvimTreeCursorColumn",            link = "CursorColumn" },
-  { group = "NvimTreeCursorLine",              link = "CursorLine" },
-  { group = "NvimTreeCursorLineNr",            link = "CursorLineNr" },
-
-  { group = "NvimTreeStatusLine",              link = "StatusLine" },
-  { group = "NvimTreeStatusLineNC",            link = "StatusLineNC" },
-
-  -- File Text
-  { group = "NvimTreeExecFile",                link = "Question" },
-  { group = "NvimTreeImageFile",               link = "Question" },
-  { group = "NvimTreeSpecialFile",             link = "Title" },
-  { group = "NvimTreeSymlink",                 link = "Underlined" },
-
-  -- Folder Text
-  { group = "NvimTreeRootFolder",              link = "Title" },
-  { group = "NvimTreeFolderName",              link = "Directory" },
-  { group = "NvimTreeEmptyFolderName",         link = "Directory" },
-  { group = "NvimTreeOpenedFolderName",        link = "Directory" },
-  { group = "NvimTreeSymlinkFolderName",       link = "Directory" },
-
-  -- File Icons
-  { group = "NvimTreeFileIcon",                link = "NvimTreeNormal" },
-  { group = "NvimTreeSymlinkIcon",             link = "NvimTreeNormal" },
-
-  -- Folder Icons
-  { group = "NvimTreeFolderIcon",              def = "guifg=#8094b4 ctermfg=Blue" },
-  { group = "NvimTreeOpenedFolderIcon",        link = "NvimTreeFolderIcon" },
-  { group = "NvimTreeClosedFolderIcon",        link = "NvimTreeFolderIcon" },
-  { group = "NvimTreeFolderArrowClosed",       link = "NvimTreeIndentMarker" },
-  { group = "NvimTreeFolderArrowOpen",         link = "NvimTreeIndentMarker" },
-
-  -- Indent
-  { group = "NvimTreeIndentMarker",            link = "NvimTreeFolderIcon" },
-
-  -- Picker
-  { group = "NvimTreeWindowPicker",            def = "guifg=#ededed guibg=#4493c8 gui=bold ctermfg=White ctermbg=DarkBlue" },
-
-  -- LiveFilter
-  { group = "NvimTreeLiveFilterPrefix",        link = "PreProc" },
-  { group = "NvimTreeLiveFilterValue",         link = "ModeMsg" },
-
-  -- Clipboard
-  { group = "NvimTreeCutHL",                   link = "SpellBad" },
-  { group = "NvimTreeCopiedHL",                link = "SpellRare" },
-
-  -- Bookmark
-  { group = "NvimTreeBookmarkIcon",            link = "NvimTreeFolderIcon" },
-  { group = "NvimTreeBookmarkHL",              link = "SpellLocal" },
-
-  -- Modified
-  { group = "NvimTreeModifiedIcon",            link = "Type" },
-  { group = "NvimTreeModifiedFileHL",          link = "NvimTreeModifiedIcon" },
-  { group = "NvimTreeModifiedFolderHL",        link = "NvimTreeModifiedFileHL" },
-
-  -- Hidden
-  { group = "NvimTreeHiddenIcon",              link = "Conceal" },
-  { group = "NvimTreeHiddenFileHL",            link = "NvimTreeHiddenIcon" },
-  { group = "NvimTreeHiddenFolderHL",          link = "NvimTreeHiddenFileHL" },
-
-  -- Hidden Display
-  { group = "NvimTreeHiddenDisplay",           link = "Conceal" },
-
-  -- Opened
-  { group = "NvimTreeOpenedHL",                link = "Special" },
-
-  -- Git Icon
-  { group = "NvimTreeGitDeletedIcon",          link = "Statement" },
-  { group = "NvimTreeGitDirtyIcon",            link = "Statement" },
-  { group = "NvimTreeGitIgnoredIcon",          link = "Comment" },
-  { group = "NvimTreeGitMergeIcon",            link = "Constant" },
-  { group = "NvimTreeGitNewIcon",              link = "PreProc" },
-  { group = "NvimTreeGitRenamedIcon",          link = "PreProc" },
-  { group = "NvimTreeGitStagedIcon",           link = "Constant" },
-
-  -- Git File Highlight
-  { group = "NvimTreeGitFileDeletedHL",        link = "NvimTreeGitDeletedIcon" },
-  { group = "NvimTreeGitFileDirtyHL",          link = "NvimTreeGitDirtyIcon" },
-  { group = "NvimTreeGitFileIgnoredHL",        link = "NvimTreeGitIgnoredIcon" },
-  { group = "NvimTreeGitFileMergeHL",          link = "NvimTreeGitMergeIcon" },
-  { group = "NvimTreeGitFileNewHL",            link = "NvimTreeGitNewIcon" },
-  { group = "NvimTreeGitFileRenamedHL",        link = "NvimTreeGitRenamedIcon" },
-  { group = "NvimTreeGitFileStagedHL",         link = "NvimTreeGitStagedIcon" },
-
-  -- Git Folder Highlight
-  { group = "NvimTreeGitFolderDeletedHL",      link = "NvimTreeGitFileDeletedHL" },
-  { group = "NvimTreeGitFolderDirtyHL",        link = "NvimTreeGitFileDirtyHL" },
-  { group = "NvimTreeGitFolderIgnoredHL",      link = "NvimTreeGitFileIgnoredHL" },
-  { group = "NvimTreeGitFolderMergeHL",        link = "NvimTreeGitFileMergeHL" },
-  { group = "NvimTreeGitFolderNewHL",          link = "NvimTreeGitFileNewHL" },
-  { group = "NvimTreeGitFolderRenamedHL",      link = "NvimTreeGitFileRenamedHL" },
-  { group = "NvimTreeGitFolderStagedHL",       link = "NvimTreeGitFileStagedHL" },
-
-  -- Diagnostics Icon
-  { group = "NvimTreeDiagnosticErrorIcon",     link = "DiagnosticError" },
-  { group = "NvimTreeDiagnosticWarnIcon",      link = "DiagnosticWarn" },
-  { group = "NvimTreeDiagnosticInfoIcon",      link = "DiagnosticInfo" },
-  { group = "NvimTreeDiagnosticHintIcon",      link = "DiagnosticHint" },
-
-  -- Diagnostics File Highlight
-  { group = "NvimTreeDiagnosticErrorFileHL",   link = "DiagnosticUnderlineError" },
-  { group = "NvimTreeDiagnosticWarnFileHL",    link = "DiagnosticUnderlineWarn" },
-  { group = "NvimTreeDiagnosticInfoFileHL",    link = "DiagnosticUnderlineInfo" },
-  { group = "NvimTreeDiagnosticHintFileHL",    link = "DiagnosticUnderlineHint" },
-
-  -- Diagnostics Folder Highlight
-  { group = "NvimTreeDiagnosticErrorFolderHL", link = "NvimTreeDiagnosticErrorFileHL" },
-  { group = "NvimTreeDiagnosticWarnFolderHL",  link = "NvimTreeDiagnosticWarnFileHL" },
-  { group = "NvimTreeDiagnosticInfoFolderHL",  link = "NvimTreeDiagnosticInfoFileHL" },
-  { group = "NvimTreeDiagnosticHintFolderHL",  link = "NvimTreeDiagnosticHintFileHL" },
-}
-
--- nvim-tree highlight groups to legacy
-M.LEGACY_LINKS = {
-  NvimTreeModifiedIcon = "NvimTreeModifiedFile",
-
-  NvimTreeOpenedHL = "NvimTreeOpenedFile",
-
-  NvimTreeBookmarkIcon = "NvimTreeBookmark",
-
-  NvimTreeGitDeletedIcon = "NvimTreeGitDeleted",
-  NvimTreeGitDirtyIcon = "NvimTreeGitDirty",
-  NvimTreeGitIgnoredIcon = "NvimTreeGitIgnored",
-  NvimTreeGitMergeIcon = "NvimTreeGitMerge",
-  NvimTreeGitNewIcon = "NvimTreeGitNew",
-  NvimTreeGitRenamedIcon = "NvimTreeGitRenamed",
-  NvimTreeGitStagedIcon = "NvimTreeGitStaged",
-
-  NvimTreeGitFileDeletedHL = "NvimTreeFileDeleted",
-  NvimTreeGitFileDirtyHL = "NvimTreeFileDirty",
-  NvimTreeGitFileIgnoredHL = "NvimTreeFileIgnored",
-  NvimTreeGitFileMergeHL = "NvimTreeFileMerge",
-  NvimTreeGitFileNewHL = "NvimTreeFileNew",
-  NvimTreeGitFileRenamedHL = "NvimTreeFileRenamed",
-  NvimTreeGitFileStagedHL = "NvimTreeFileStaged",
-
-  NvimTreeGitFolderDeletedHL = "NvimTreeFolderDeleted",
-  NvimTreeGitFolderDirtyHL = "NvimTreeFolderDirty",
-  NvimTreeGitFolderIgnoredHL = "NvimTreeFolderIgnored",
-  NvimTreeGitFolderMergeHL = "NvimTreeFolderMerge",
-  NvimTreeGitFolderNewHL = "NvimTreeFolderNew",
-  NvimTreeGitFolderRenamedHL = "NvimTreeFolderRenamed",
-  NvimTreeGitFolderStagedHL = "NvimTreeFolderStaged",
-
-  NvimTreeDiagnosticErrorIcon = "NvimTreeLspDiagnosticsError",
-  NvimTreeDiagnosticWarnIcon = "NvimTreeLspDiagnosticsWarning",
-  NvimTreeDiagnosticInfoIcon = "NvimTreeLspDiagnosticsInformation",
-  NvimTreeDiagnosticHintIcon = "NvimTreeLspDiagnosticsHint",
-
-  NvimTreeDiagnosticErrorFileHL = "NvimTreeLspDiagnosticsErrorText",
-  NvimTreeDiagnosticWarnFileHL = "NvimTreeLspDiagnosticsWarningText",
-  NvimTreeDiagnosticInfoFileHL = "NvimTreeLspDiagnosticsInformationText",
-  NvimTreeDiagnosticHintFileHL = "NvimTreeLspDiagnosticsHintText",
-
-  NvimTreeDiagnosticErrorFolderHL = "NvimTreeLspDiagnosticsErrorFolderText",
-  NvimTreeDiagnosticWarnFolderHL = "NvimTreeLspDiagnosticsWarningFolderText",
-  NvimTreeDiagnosticInfoFolderHL = "NvimTreeLspDiagnosticsInformationFolderText",
-  NvimTreeDiagnosticHintFolderHL = "NvimTreeLspDiagnosticsHintFolderText",
-}
-
-function M.setup()
-  -- non-linked
-  for _, g in ipairs(M.HIGHLIGHT_GROUPS) do
-    if g.def then
-      vim.api.nvim_command("hi def " .. g.group .. " " .. g.def)
-    end
-  end
-
-  -- hard link override when legacy only is present
-  for from, to in pairs(M.LEGACY_LINKS) do
-    local hl_from = vim.api.nvim_get_hl(0, { name = from })
-    local hl_to = vim.api.nvim_get_hl(0, { name = to })
-    if vim.tbl_isempty(hl_from) and not vim.tbl_isempty(hl_to) then
-      vim.api.nvim_command("hi link " .. from .. " " .. to)
-    end
-  end
-
-  -- default links
-  for _, g in ipairs(M.HIGHLIGHT_GROUPS) do
-    if g.link then
-      vim.api.nvim_command("hi def link " .. g.group .. " " .. g.link)
-    end
-  end
-end
-
-return M

lua/nvim-tree/buffers.lua

@@ -1,48 +0,0 @@
-local M = {}
-
----@type table<string, boolean> record of which file is modified
-M._modified = {}
-
----refresh M._modified
-function M.reload_modified()
-  M._modified = {}
-  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 M._modified[path] ~= true do
-        -- no need to keep going if already recorded
-        -- This also prevents an infinite loop
-        M._modified[path] = true
-        path = vim.fn.fnamemodify(path, ":h")
-      end
-    end
-  end
-end
-
----@param node table
----@return boolean
-function M.is_modified(node)
-  return node
-    and M.config.modified.enable
-    and M._modified[node.absolute_path]
-    and (not node.nodes or M.config.modified.show_on_dirs)
-    and (not node.open or M.config.modified.show_on_open_dirs)
-end
-
----A buffer exists for the node's absolute path
----@param node table
----@return boolean
-function M.is_opened(node)
-  return node and vim.fn.bufloaded(node.absolute_path) > 0
-end
-
----@param opts table
-function M.setup(opts)
-  M.config = {
-    modified = opts.modified,
-  }
-end
-
-return M

lua/nvim-tree/colors.lua

@@ -0,0 +1,130 @@
+local M = {}
+
+local function get_color_from_hl(hl_name, fallback)
+  local id = vim.api.nvim_get_hl_id_by_name(hl_name)
+  if not id then
+    return fallback
+  end
+
+  local foreground = vim.fn.synIDattr(vim.fn.synIDtrans(id), "fg")
+  if not foreground or foreground == "" then
+    return fallback
+  end
+
+  return foreground
+end
+
+local function get_colors()
+  return {
+    red = vim.g.terminal_color_1 or get_color_from_hl("Keyword", "Red"),
+    green = vim.g.terminal_color_2 or get_color_from_hl("Character", "Green"),
+    yellow = vim.g.terminal_color_3 or get_color_from_hl("PreProc", "Yellow"),
+    blue = vim.g.terminal_color_4 or get_color_from_hl("Include", "Blue"),
+    purple = vim.g.terminal_color_5 or get_color_from_hl("Define", "Purple"),
+    cyan = vim.g.terminal_color_6 or get_color_from_hl("Conditional", "Cyan"),
+    dark_red = vim.g.terminal_color_9 or get_color_from_hl("Keyword", "DarkRed"),
+    orange = vim.g.terminal_color_11 or get_color_from_hl("Number", "Orange"),
+  }
+end
+
+local function get_hl_groups()
+  local colors = get_colors()
+
+  return {
+    IndentMarker = { fg = "#8094b4" },
+    Symlink = { gui = "bold", fg = colors.cyan },
+    FolderIcon = { fg = "#8094b4" },
+    RootFolder = { fg = colors.purple },
+
+    ExecFile = { gui = "bold", fg = colors.green },
+    SpecialFile = { gui = "bold,underline", fg = colors.yellow },
+    ImageFile = { gui = "bold", fg = colors.purple },
+    OpenedFile = { gui = "bold", fg = colors.green },
+    ModifiedFile = { fg = colors.green },
+
+    GitDirty = { fg = colors.dark_red },
+    GitDeleted = { fg = colors.dark_red },
+    GitStaged = { fg = colors.green },
+    GitMerge = { fg = colors.orange },
+    GitRenamed = { fg = colors.purple },
+    GitNew = { fg = colors.yellow },
+
+    WindowPicker = { gui = "bold", fg = "#ededed", bg = "#4493c8" },
+    LiveFilterPrefix = { gui = "bold", fg = colors.purple },
+    LiveFilterValue = { gui = "bold", fg = "#fff" },
+
+    Bookmark = { fg = colors.green },
+  }
+end
+
+local function get_links()
+  return {
+    FolderName = "Directory",
+    EmptyFolderName = "Directory",
+    OpenedFolderName = "Directory",
+    SymlinkFolderName = "Directory",
+    OpenedFolderIcon = "NvimTreeFolderIcon",
+    ClosedFolderIcon = "NvimTreeFolderIcon",
+    OpenedFileIcon = "NvimTreeOpenedFile",
+    Normal = "Normal",
+    NormalFloat = "NormalFloat",
+    NormalNC = "NvimTreeNormal",
+    EndOfBuffer = "EndOfBuffer",
+    CursorLineNr = "CursorLineNr",
+    LineNr = "LineNr",
+    CursorLine = "CursorLine",
+    WinSeparator = "WinSeparator",
+    CursorColumn = "CursorColumn",
+    FileDirty = "NvimTreeGitDirty",
+    FileNew = "NvimTreeGitNew",
+    FileRenamed = "NvimTreeGitRenamed",
+    FileMerge = "NvimTreeGitMerge",
+    FileStaged = "NvimTreeGitStaged",
+    FileDeleted = "NvimTreeGitDeleted",
+    FileIgnored = "NvimTreeGitIgnored",
+    FolderDirty = "NvimTreeFileDirty",
+    FolderNew = "NvimTreeFileNew",
+    FolderRenamed = "NvimTreeFileRenamed",
+    FolderMerge = "NvimTreeFileMerge",
+    FolderStaged = "NvimTreeFileStaged",
+    FolderDeleted = "NvimTreeFileDeleted",
+    FolderIgnored = "NvimTreeFileIgnored",
+    LspDiagnosticsError = "DiagnosticError",
+    LspDiagnosticsWarning = "DiagnosticWarn",
+    LspDiagnosticsInformation = "DiagnosticInfo",
+    LspDiagnosticsHint = "DiagnosticHint",
+    LspDiagnosticsErrorText = "NvimTreeLspDiagnosticsError",
+    LspDiagnosticsWarningText = "NvimTreeLspDiagnosticsWarning",
+    LspDiagnosticsInformationText = "NvimTreeLspDiagnosticsInformation",
+    LspDiagnosticsHintText = "NvimTreeLspDiagnosticsHintFile",
+    LspDiagnosticsErrorFolderText = "NvimTreeLspDiagnosticsErrorText",
+    LspDiagnosticsWarningFolderText = "NvimTreeLspDiagnosticsWarningText",
+    LspDiagnosticsInformationFolderText = "NvimTreeLspDiagnosticsInformationText",
+    LspDiagnosticsHintFolderText = "NvimTreeLspDiagnosticsHintFileText",
+    Popup = "Normal",
+    GitIgnored = "Comment",
+    StatusLine = "StatusLine",
+    StatusLineNC = "StatusLineNC",
+    SignColumn = "NvimTreeNormal",
+    CutHL = "SpellBad",
+    CopiedHL = "SpellRare",
+    BookmarkHL = "SpellLocal",
+  }
+end
+
+function M.setup()
+  local highlight_groups = get_hl_groups()
+  for k, d in pairs(highlight_groups) do
+    local gui = d.gui and " gui=" .. d.gui or ""
+    local fg = d.fg and " guifg=" .. d.fg or ""
+    local bg = d.bg and " guibg=" .. d.bg or ""
+    vim.api.nvim_command("hi def NvimTree" .. k .. gui .. fg .. bg)
+  end
+
+  local links = get_links()
+  for k, d in pairs(links) do
+    vim.api.nvim_command("hi def link NvimTree" .. k .. " " .. d)
+  end
+end
+
+return M

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,
   },
   {
@@ -134,13 +134,6 @@ local CMDS = {
       api.tree.collapse_all(true)
     end,
   },
-  {
-    name = "NvimTreeHiTest",
-    opts = {
-      desc = "nvim-tree: highlight test",
-    },
-    command = api.diagnostics.hi_test,
-  },
 }
 
 function M.get()

lua/nvim-tree/core.lua

@@ -1,6 +1,8 @@
-local events = require("nvim-tree.events")
+local events = require "nvim-tree.events"
-local view = require("nvim-tree.view")
+local explorer = require "nvim-tree.explorer"
-local log = require("nvim-tree.log")
+local live_filter = require "nvim-tree.live-filter"
+local view = require "nvim-tree.view"
+local log = require "nvim-tree.log"
 
 local M = {}
 
@@ -15,7 +17,7 @@ function M.init(foldername)
   if TreeExplorer then
     TreeExplorer:destroy()
   end
-  TreeExplorer = require("nvim-tree.explorer"):new(foldername)
+  TreeExplorer = explorer.Explorer.new(foldername)
   if not first_init_done then
     events._dispatch_ready()
     first_init_done = true
@@ -43,7 +45,7 @@ function M.get_nodes_starting_line()
   if view.is_root_folder_visible(M.get_cwd()) then
     offset = offset + 1
   end
-  if TreeExplorer and TreeExplorer.live_filter.filter then
+  if live_filter.filter then
     return offset + 1
   end
   return offset

lua/nvim-tree/diagnostics.lua

@@ -1,58 +1,33 @@
-local core = require("nvim-tree.core")
+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 log = require("nvim-tree.log")
+local log = require "nvim-tree.log"
 
 local M = {}
 
----COC severity level strings to LSP severity levels
+local severity_levels = {
----@enum COC_SEVERITY_LEVELS
-local COC_SEVERITY_LEVELS = {
   Error = 1,
   Warning = 2,
   Information = 3,
   Hint = 4,
 }
 
----Absolute Node path to LSP severity level
+---@return table
----@alias NodeSeverities table<string, lsp.DiagnosticSeverity>
-
----@class DiagStatus
----@field value lsp.DiagnosticSeverity|nil
----@field cache_version integer
-
---- The buffer-severity mappings derived during the last diagnostic list update.
----@type NodeSeverities
-local NODE_SEVERITIES = {}
-
----The cache version number of the buffer-severity mappings.
----@type integer
-local NODE_SEVERITIES_VERSION = 0
-
----@param path string
----@return string
-local function uniformize_path(path)
-  return utils.canonical_path(path:gsub("\\", "/"))
-end
-
----Marshal severities from LSP. Does nothing when LSP disabled.
----@return NodeSeverities
 local function from_nvim_lsp()
   local buffer_severity = {}
 
-  -- is_enabled is not present in all 0.10 builds/releases, see #2781
+  local is_disabled = false
-  local is_enabled = false
+  if vim.fn.has "nvim-0.9" == 1 then
-  if vim.fn.has("nvim-0.10") == 1 and type(vim.diagnostic.is_enabled) == "function" then
+    is_disabled = vim.diagnostic.is_disabled()
-    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
   end
 
-  if is_enabled then
+  if not is_disabled then
     for _, diagnostic in ipairs(vim.diagnostic.get(nil, { severity = M.severity })) do
-      if diagnostic.severity and diagnostic.bufnr and vim.api.nvim_buf_is_valid(diagnostic.bufnr) then
+      local buf = diagnostic.bufnr
-        local bufname = uniformize_path(vim.api.nvim_buf_get_name(diagnostic.bufnr))
+      if vim.api.nvim_buf_is_valid(buf) then
-        if not buffer_severity[bufname] or diagnostic.severity < buffer_severity[bufname] then
+        local bufname = vim.api.nvim_buf_get_name(buf)
+        local lowest_severity = buffer_severity[bufname]
+        if not lowest_severity or diagnostic.severity < lowest_severity then
           buffer_severity[bufname] = diagnostic.severity
         end
       end
@@ -62,151 +37,91 @@ local function from_nvim_lsp()
   return buffer_severity
 end
 
----Severity is within diagnostics.severity.min, diagnostics.severity.max
+---@param severity integer
----@param severity lsp.DiagnosticSeverity
 ---@param config table
 ---@return boolean
 local function is_severity_in_range(severity, config)
   return config.max <= severity and severity <= config.min
 end
 
----Handle any COC exceptions, preventing any propagation
+---@return table
----@param err string
-local function handle_coc_exception(err)
-  log.line("diagnostics", "handle_coc_exception: %s", vim.inspect(err))
-  local notify = true
-
-  -- avoid distractions on interrupts (CTRL-C)
-  if err:find("Vim:Interrupt") or err:find("Keyboard interrupt") then
-    notify = false
-  end
-
-  if notify then
-    require("nvim-tree.notify").error("Diagnostics update from coc.nvim failed. " .. vim.inspect(err))
-  end
-end
-
----COC service initialized
----@return boolean
-local function is_using_coc()
-  return vim.g.coc_service_initialized == 1
-end
-
----Marshal severities from COC. Does nothing when COC service not started.
----@return NodeSeverities
 local function from_coc()
-  if not is_using_coc() then
+  if vim.g.coc_service_initialized ~= 1 then
     return {}
   end
 
-  local ok, diagnostic_list = xpcall(function()
+  local diagnostic_list = vim.fn.CocAction "diagnosticList"
-    return vim.fn.CocAction("diagnosticList")
+  if type(diagnostic_list) ~= "table" or vim.tbl_isempty(diagnostic_list) then
-  end, handle_coc_exception)
-  if not ok or type(diagnostic_list) ~= "table" or vim.tbl_isempty(diagnostic_list) then
     return {}
   end
 
+  local diagnostics = {}
+  for _, diagnostic in ipairs(diagnostic_list) do
+    local bufname = diagnostic.file
+    local coc_severity = severity_levels[diagnostic.severity]
+
+    local serverity = diagnostics[bufname] or vim.diagnostic.severity.HINT
+    diagnostics[bufname] = math.min(coc_severity, serverity)
+  end
+
   local buffer_severity = {}
-  for _, diagnostic in ipairs(diagnostic_list) do
+  for bufname, severity in pairs(diagnostics) do
-    local bufname = uniformize_path(diagnostic.file)
+    if is_severity_in_range(severity, M.severity) then
-    local coc_severity = COC_SEVERITY_LEVELS[diagnostic.severity]
+      buffer_severity[bufname] = severity
-    local highest_severity = buffer_severity[bufname] or coc_severity
-    if is_severity_in_range(highest_severity, M.severity) then
-      buffer_severity[bufname] = math.min(highest_severity, coc_severity)
     end
   end
 
   return buffer_severity
 end
 
----Maybe retrieve severity level from the cache
+local function is_using_coc()
----@param node Node
+  return vim.g.coc_service_initialized == 1
----@return DiagStatus
-local function from_cache(node)
-  local nodepath = uniformize_path(node.absolute_path)
-  local max_severity = nil
-  if not node.nodes then
-    -- direct cache hit for files
-    max_severity = NODE_SEVERITIES[nodepath]
-  else
-    -- dirs should be searched in the list of cached buffer names by prefix
-    for bufname, severity in pairs(NODE_SEVERITIES) do
-      local node_contains_buf = vim.startswith(bufname, nodepath .. "/")
-      if node_contains_buf then
-        if severity == M.severity.max then
-          max_severity = severity
-          break
-        else
-          max_severity = math.min(max_severity or severity, severity)
-        end
-      end
-    end
-  end
-  return { value = max_severity, cache_version = NODE_SEVERITIES_VERSION }
 end
 
----Fired on DiagnosticChanged and CocDiagnosticChanged events:
----debounced retrieval, cache update, version increment and draw
 function M.update()
-  if not M.enable then
+  if not M.enable or not core.get_explorer() or not view.is_buf_valid(view.get_bufnr()) then
     return
   end
   utils.debounce("diagnostics", M.debounce_delay, function()
-    local profile = log.profile_start("diagnostics update")
+    local profile = log.profile_start "diagnostics update"
+    log.line("diagnostics", "update")
+
+    local buffer_severity
     if is_using_coc() then
-      NODE_SEVERITIES = from_coc()
+      buffer_severity = from_coc()
     else
-      NODE_SEVERITIES = from_nvim_lsp()
+      buffer_severity = from_nvim_lsp()
     end
-    NODE_SEVERITIES_VERSION = NODE_SEVERITIES_VERSION + 1
+
-    if log.enabled("diagnostics") then
+    local nodes_by_line = utils.get_nodes_by_line(core.get_explorer().nodes, core.get_nodes_starting_line())
-      for bufname, severity in pairs(NODE_SEVERITIES) do
+    for _, node in pairs(nodes_by_line) do
-        log.line("diagnostics", "Indexing bufname '%s' with severity %d", bufname, severity)
+      node.diag_status = nil
+    end
+
+    for bufname, severity in pairs(buffer_severity) do
+      local bufpath = utils.canonical_path(bufname)
+      log.line("diagnostics", " bufpath '%s' severity %d", bufpath, severity)
+      if 0 < severity and severity < 5 then
+        for line, node in pairs(nodes_by_line) do
+          local nodepath = utils.canonical_path(node.absolute_path)
+          log.line("diagnostics", "  %d checking nodepath '%s'", line, nodepath)
+
+          local node_contains_buf = vim.startswith(bufpath:gsub("\\", "/"), nodepath:gsub("\\", "/") .. "/")
+          if M.show_on_dirs and node_contains_buf and (not node.open or M.show_on_open_dirs) then
+            log.line("diagnostics", " matched fold node '%s'", node.absolute_path)
+            node.diag_status = severity
+          elseif nodepath == bufpath then
+            log.line("diagnostics", " matched file node '%s'", node.absolute_path)
+            node.diag_status = severity
+          end
+        end
       end
     end
     log.profile_end(profile)
-    if view.is_buf_valid(view.get_bufnr()) then
+    require("nvim-tree.renderer").draw()
-      local explorer = core.get_explorer()
-      if explorer then
-        explorer.renderer:draw()
-      end
-    end
   end)
 end
 
----Maybe retrieve diagnostic status for a node.
----Returns cached value when node's version matches.
----@param node Node
----@return DiagStatus|nil
-function M.get_diag_status(node)
-  if not M.enable then
-    return nil
-  end
-
-  -- dir but we shouldn't show on dirs at all
-  if node.nodes ~= nil and not M.show_on_dirs then
-    return nil
-  end
-
-  -- here, we do a lazy update of the diagnostic status carried by the node.
-  -- This is by design, as diagnostics and nodes live in completely separate
-  -- worlds, and this module is the link between the two
-  if not node.diag_status or node.diag_status.cache_version < NODE_SEVERITIES_VERSION then
-    node.diag_status = from_cache(node)
-  end
-
-  -- file
-  if not node.nodes 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
-    return node.diag_status
-  end
-  return nil
-end
-
 function M.setup(opts)
   M.enable = opts.diagnostics.enable
   M.debounce_delay = opts.diagnostics.debounce_delay

lua/nvim-tree/enum.lua

@@ -12,22 +12,9 @@ M.HL_POSITION = {
 ---Setup options for "*_placement"
 ---@enum ICON_PLACEMENT
 M.ICON_PLACEMENT = {
-  none = 0,
+  signcolumn = 0,
-  signcolumn = 1,
+  before = 1,
-  before = 2,
+  after = 2,
-  after = 3,
-  right_align = 4,
-}
-
----Reason for filter in filter.lua
----@enum FILTER_REASON
-M.FILTER_REASON = {
-  none = 0, -- It's not filtered
-  git = 1,
-  buf = 2,
-  dotfile = 4,
-  custom = 8,
-  bookmark = 16,
 }
 
 return M

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

@@ -0,0 +1,101 @@
+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 sorters = require "nvim-tree.explorer.sorters"
+local filters = require "nvim-tree.explorer.filters"
+local live_filter = require "nvim-tree.live-filter"
+local log = require "nvim-tree.log"
+
+local Watcher = require "nvim-tree.watcher"
+
+local M = {}
+
+---@param type_ string|nil
+---@param cwd string
+---@return any
+local function get_type_from(type_, cwd)
+  return type_ or (vim.loop.fs_stat(cwd) or {}).type
+end
+
+---@param handle uv.uv_fs_t
+---@param cwd string
+---@param node Node
+---@param git_status table
+local function populate_children(handle, cwd, node, git_status)
+  local node_ignored = explorer_node.is_git_ignored(node)
+  local nodes_by_path = utils.bool_record(node.nodes, "absolute_path")
+  local filter_status = filters.prepare(git_status)
+  while true do
+    local name, t = vim.loop.fs_scandir_next(handle)
+    if not name then
+      break
+    end
+
+    local abs = utils.path_join { cwd, name }
+
+    local profile = log.profile_start("explore populate_children %s", abs)
+
+    t = get_type_from(t, abs)
+    if not filters.should_filter(abs, filter_status) and not nodes_by_path[abs] and Watcher.is_fs_event_capable(abs) then
+      local child = nil
+      if t == "directory" and vim.loop.fs_access(abs, "R") then
+        child = builders.folder(node, abs, name)
+      elseif t == "file" then
+        child = builders.file(node, abs, name)
+      elseif t == "link" then
+        local link = builders.link(node, abs, name)
+        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
+    end
+
+    log.profile_end(profile)
+  end
+end
+
+---@param node Node
+---@param status table
+---@return Node[]|nil
+function M.explore(node, status)
+  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)
+
+  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)
+    node.nodes = ns or {}
+
+    log.profile_end(profile)
+    return ns
+  end
+
+  sorters.sort(node.nodes)
+  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,53 +1,14 @@
-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 M = {
----@field config table hydrated user opts.filters
+  ignore_list = {},
----@field private explorer Explorer
+  exclude_list = {},
----@field private exclude_list string[] filters.exclude
+}
----@field private ignore_list string[] filters.custom string table
----@field private custom_function (fun(absolute_path: string): boolean)|nil filters.custom function
-local Filters = {}
-
----@param opts table user options
----@param explorer Explorer
----@return Filters
-function Filters:new(opts, explorer)
-  local o = {
-    explorer = explorer,
-    ignore_list = {},
-    exclude_list = opts.filters.exclude,
-    custom_function = nil,
-    config = {
-      enable = opts.filters.enable,
-      filter_custom = true,
-      filter_dotfiles = opts.filters.dotfiles,
-      filter_git_ignored = opts.filters.git_ignored,
-      filter_git_clean = opts.filters.git_clean,
-      filter_no_buffer = opts.filters.no_buffer,
-      filter_no_bookmark = opts.filters.no_bookmark,
-    },
-  }
-
-  local custom_filter = opts.filters.custom
-  if type(custom_filter) == "function" then
-    o.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
-      end
-    end
-  end
-  setmetatable(o, self)
-  self.__index = self
-  return o
-end
 
 ---@param path string
 ---@return boolean
-local function is_excluded(self, path)
+local function is_excluded(path)
-  for _, node in ipairs(self.exclude_list) do
+  for _, node in ipairs(M.exclude_list) do
     if path:match(node) then
       return true
     end
@@ -59,7 +20,7 @@ end
 ---@param path string Absolute path
 ---@param git_status table from prepare
 ---@return boolean
-local function git(self, path, git_status)
+local function git(path, git_status)
   if type(git_status) ~= "table" or type(git_status.files) ~= "table" or type(git_status.dirs) ~= "table" then
     return false
   end
@@ -70,12 +31,12 @@ local function git(self, path, git_status)
   status = status or git_status.dirs.indirect[path] and git_status.dirs.indirect[path][1]
 
   -- filter ignored; overrides clean as they are effectively dirty
-  if self.config.filter_git_ignored and status == "!!" then
+  if M.config.filter_git_ignored and status == "!!" then
     return true
   end
 
   -- filter clean
-  if self.config.filter_git_clean and not status then
+  if M.config.filter_git_clean and not status then
     return true
   end
 
@@ -85,15 +46,16 @@ end
 ---Check if the given path has no listed buffer
 ---@param path string Absolute path
 ---@param bufinfo table vim.fn.getbufinfo { buflisted = 1 }
+---@param unloaded_bufnr number optional bufnr recently unloaded via BufUnload event
 ---@return boolean
-local function buf(self, path, bufinfo)
+local function buf(path, bufinfo, unloaded_bufnr)
-  if not self.config.filter_no_buffer or type(bufinfo) ~= "table" then
+  if not M.config.filter_no_buffer or type(bufinfo) ~= "table" then
     return false
   end
 
   -- filter files with no open buffer and directories containing no open buffers
   for _, b in ipairs(bufinfo) do
-    if b.name == path or b.name:find(path .. "/", 1, true) then
+    if b.name == path or b.name:find(path .. "/", 1, true) and b.bufnr ~= unloaded_bufnr then
       return false
     end
   end
@@ -103,71 +65,30 @@ end
 
 ---@param path string
 ---@return boolean
-local function dotfile(self, path)
+local function dotfile(path)
-  return self.config.filter_dotfiles and utils.path_basename(path):sub(1, 1) == "."
+  return M.config.filter_dotfiles and utils.path_basename(path):sub(1, 1) == "."
-end
-
----@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)
-  if not self.config.filter_no_bookmark then
-    return false
-  end
-  -- if bookmark is empty, we should see a empty filetree
-  if next(bookmarks) == nil then
-    return true
-  end
-
-  local mark_parent = utils.path_add_trailing(path)
-  for mark, mark_type in pairs(bookmarks) do
-    if path == mark then
-      return false
-    end
-
-    if path_type == "directory" then
-      -- check if path is mark's parent
-      if vim.fn.stridx(mark, mark_parent) == 0 then
-        return false
-      end
-    end
-    if mark_type == "directory" then
-      -- check if mark is path's parent
-      local path_parent = utils.path_add_trailing(mark)
-      if vim.fn.stridx(path, path_parent) == 0 then
-        return false
-      end
-    end
-  end
-
-  return true
 end
 
 ---@param path string
 ---@return boolean
-local function custom(self, path)
+local function custom(path)
-  if not self.config.filter_custom then
+  if not M.config.filter_custom then
     return false
   end
 
   local basename = utils.path_basename(path)
 
-  -- filter user's custom function
-  if self.custom_function and self.custom_function(path) then
-    return true
-  end
-
   -- filter custom regexes
   local relpath = utils.path_relative(path, vim.loop.cwd())
-  for pat, _ in pairs(self.ignore_list) do
+  for pat, _ in pairs(M.ignore_list) do
     if vim.fn.match(relpath, pat) ~= -1 or vim.fn.match(basename, pat) ~= -1 then
       return true
     end
   end
 
-  local idx = path:match(".+()%.[^.]+$")
+  local idx = path:match ".+()%.[^.]+$"
   if idx then
-    if self.ignore_list["*" .. string.sub(path, idx)] == true then
+    if M.ignore_list["*" .. string.sub(path, idx)] == true then
       return true
     end
   end
@@ -177,26 +98,20 @@ 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 unloaded_bufnr number|nil optional bufnr recently unloaded via BufUnload event
 ---@return table
 --- git_status: reference
+--- unloaded_bufnr: copy
 --- bufinfo: empty unless no_buffer set: vim.fn.getbufinfo { buflisted = 1 }
---- bookmarks: absolute paths to boolean
+function M.prepare(git_status, unloaded_bufnr)
-function Filters:prepare(git_status)
   local status = {
     git_status = git_status or {},
+    unloaded_bufnr = unloaded_bufnr,
     bufinfo = {},
-    bookmarks = {},
   }
 
-  if self.config.filter_no_buffer then
+  if M.config.filter_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()
-  if explorer then
-    for _, node in pairs(explorer.marks:list()) do
-      status.bookmarks[node.absolute_path] = node.type
-    end
   end
 
   return status
@@ -204,53 +119,35 @@ end
 
 ---Check if the given path should be filtered.
 ---@param path string Absolute path
----@param fs_stat uv.fs_stat.result|nil fs_stat of file
 ---@param status table from prepare
 ---@return boolean
-function Filters:should_filter(path, fs_stat, status)
+function M.should_filter(path, status)
-  if not self.config.enable then
-    return false
-  end
-
   -- exclusions override all filters
-  if is_excluded(self, path) then
+  if is_excluded(path) then
     return false
   end
 
-  return git(self, path, status.git_status)
+  return git(path, status.git_status) or buf(path, status.bufinfo, status.unloaded_bufnr) or dotfile(path) or custom(path)
-    or buf(self, path, status.bufinfo)
-    or dotfile(self, path)
-    or custom(self, path)
-    or bookmark(self, 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
+function M.setup(opts)
----@param path string Absolute path
+  M.config = {
----@param fs_stat uv.fs_stat.result|nil fs_stat of file
+    filter_custom = true,
----@param status table from prepare
+    filter_dotfiles = opts.filters.dotfiles,
----@return FILTER_REASON
+    filter_git_ignored = opts.filters.git_ignored,
-function Filters:should_filter_as_reason(path, fs_stat, status)
+    filter_git_clean = opts.filters.git_clean,
-  if not self.config.enable then
+    filter_no_buffer = opts.filters.no_buffer,
-    return FILTER_REASON.none
+  }
-  end
 
-  if is_excluded(self, path) then
+  M.ignore_list = {}
-    return FILTER_REASON.none
+  M.exclude_list = opts.filters.exclude
-  end
 
-  if git(self, path, status.git_status) then
+  local custom_filter = opts.filters.custom
-    return FILTER_REASON.git
+  if custom_filter and #custom_filter > 0 then
-  elseif buf(self, path, status.bufinfo) then
+    for _, filter_name in pairs(custom_filter) do
-    return FILTER_REASON.buf
+      M.ignore_list[filter_name] = true
-  elseif dotfile(self, path) then
+    end
-    return FILTER_REASON.dotfile
-  elseif custom(self, path) then
-    return FILTER_REASON.custom
-  elseif bookmark(self, path, fs_stat and fs_stat.type, status.bookmarks) then
-    return FILTER_REASON.bookmark
-  else
-    return FILTER_REASON.none
   end
 end
 
-return Filters
+return M

lua/nvim-tree/explorer/init.lua

@@ -1,77 +1,42 @@
-local builders = require("nvim-tree.explorer.node-builders")
+local git = require "nvim-tree.git"
-local git = require("nvim-tree.git")
+local watch = require "nvim-tree.explorer.watch"
-local log = require("nvim-tree.log")
+local explorer_node = require "nvim-tree.explorer.node"
-local notify = require("nvim-tree.notify")
-local utils = require("nvim-tree.utils")
-local view = require("nvim-tree.view")
-local watch = require("nvim-tree.explorer.watch")
-local explorer_node = require("nvim-tree.explorer.node")
 
-local Iterator = require("nvim-tree.iterators.node-iterator")
+local M = {}
-local NodeIterator = require("nvim-tree.iterators.node-iterator")
-local Watcher = require("nvim-tree.watcher")
 
-local Filters = require("nvim-tree.explorer.filters")
+M.explore = require("nvim-tree.explorer.explore").explore
-local Marks = require("nvim-tree.marks")
+M.reload = require("nvim-tree.explorer.reload").reload
-local LiveFilter = require("nvim-tree.explorer.live-filter")
-local Sorters = require("nvim-tree.explorer.sorters")
-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
----@field opts table user options
 ---@field absolute_path string
 ---@field nodes Node[]
 ---@field open boolean
----@field watcher Watcher|nil
+
----@field renderer Renderer
----@field filters Filters
----@field live_filter LiveFilter
----@field sorters Sorter
----@field marks Marks
----@field clipboard Clipboard
 local Explorer = {}
+Explorer.__index = Explorer
 
----@param path string|nil
+---@param cwd string|nil
----@return Explorer|nil
+---@return Explorer
-function Explorer:new(path)
+function Explorer.new(cwd)
-  local err
+  cwd = vim.loop.fs_realpath(cwd or vim.loop.cwd())
 
-  if path then
+  ---@class Explorer
-    path, err = vim.loop.fs_realpath(path)
+  local explorer = setmetatable({
-  else
+    absolute_path = cwd,
-    path, err = vim.loop.cwd()
-  end
-  if not path then
-    notify.error(err)
-    return
-  end
-
-  local o = {
-    opts = config,
-    absolute_path = path,
     nodes = {},
     open = true,
-    sorters = Sorters:new(config),
+  }, Explorer)
-  }
+  explorer.watcher = watch.create_watcher(explorer)
+  explorer:_load(explorer)
+  return explorer
+end
 
-  setmetatable(o, self)
+---@private
-  self.__index = self
+---@param node Node
-
+function Explorer:_load(node)
-  o.watcher = watch.create_watcher(o)
+  local cwd = node.link_to or node.absolute_path
-  o.renderer = Renderer:new(config, o)
+  local git_status = git.load_project_status(cwd)
-  o.filters = Filters:new(config, o)
+  M.explore(node, git_status)
-  o.live_filter = LiveFilter:new(config, o)
-  o.marks = Marks:new(config, o)
-  o.clipboard = Clipboard:new(config, o)
-
-  o:_load(o)
-
-  return o
 end
 
 ---@param node Node
@@ -91,397 +56,15 @@ function Explorer:destroy()
   iterate(self)
 end
 
----@param node Node
+function M.setup(opts)
----@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
-    return
-  end
-
-  local profile = log.profile_start("reload %s", node.absolute_path)
-
-  local filter_status = self.filters:prepare(git_status)
-
-  if node.group_next then
-    node.nodes = { node.group_next }
-    node.group_next = nil
-  end
-
-  local remain_childs = {}
-
-  local node_ignored = explorer_node.is_git_ignored(node)
-  ---@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,
-    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 })
-    ---@type uv.fs_stat.result|nil
-    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 t = 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 ~= t then
-          utils.array_remove(node.nodes, n)
-          explorer_node.node_destroy(n)
-          nodes_by_path[abs] = nil
-        end
-      end
-
-      if not nodes_by_path[abs] then
-        local new_child = nil
-        if t == "directory" and vim.loop.fs_access(abs, "R") and Watcher.is_fs_event_capable(abs) then
-          new_child = builders.folder(node, abs, name, stat)
-        elseif t == "file" then
-          new_child = builders.file(node, abs, name, stat)
-        elseif t == "link" then
-          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
-        end
-      else
-        local n = nodes_by_path[abs]
-        if n then
-          n.executable = builders.is_executable(abs) or false
-          n.fs_stat = stat
-        end
-      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
-  end
-
-  node.nodes = vim.tbl_map(
-    self:update_status(nodes_by_path, node_ignored, git_status),
-    vim.tbl_filter(function(n)
-      if remain_childs[n.absolute_path] then
-        return remain_childs[n.absolute_path]
-      else
-        explorer_node.node_destroy(n)
-        return false
-      end
-    end, node.nodes)
-  )
-
-  local is_root = not node.parent
-  local child_folder_only = explorer_node.has_one_child_folder(node) and node.nodes[1]
-  if config.renderer.group_empty and not is_root and child_folder_only then
-    node.group_next = child_folder_only
-    local ns = self:reload(child_folder_only, git_status)
-    node.nodes = ns or {}
-    log.profile_end(profile)
-    return ns
-  end
-
-  self.sorters:sort(node.nodes)
-  self.live_filter:apply_filter(node)
-  log.profile_end(profile)
-  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
-function Explorer:refresh_parent_nodes_for_path(path)
-  local profile = log.profile_start("refresh_parent_nodes_for_path %s", path)
-
-  -- collect parent nodes from the top down
-  local parent_nodes = {}
-  NodeIterator.builder({ self })
-    :recursor(function(node)
-      return node.nodes
-    end)
-    :applier(function(node)
-      local abs_contains = node.absolute_path and path:find(node.absolute_path, 1, true) == 1
-      local link_contains = node.link_to and path:find(node.link_to, 1, true) == 1
-      if abs_contains or link_contains then
-        table.insert(parent_nodes, node)
-      end
-    end)
-    :iterate()
-
-  -- refresh in order; this will expand groups as needed
-  for _, node in ipairs(parent_nodes) do
-    local toplevel = git.get_toplevel(node.absolute_path)
-    local project = git.get_project(toplevel) or {}
-
-    self:reload(node, project)
-    self:update_parent_statuses(node, project, toplevel)
-  end
-
-  log.profile_end(profile)
-end
-
----@private
----@param node Node
-function Explorer:_load(node)
-  local cwd = node.link_to or node.absolute_path
-  local git_status = git.load_project_status(cwd)
-  self:explore(node, git_status, self)
-end
-
----@private
----@param nodes_by_path table
----@param node_ignored boolean
----@param status table|nil
----@return fun(node: Node): table
-function Explorer:update_status(nodes_by_path, node_ignored, status)
-  return function(node)
-    if nodes_by_path[node.absolute_path] then
-      explorer_node.update_git_status(node, node_ignored, status)
-    end
-    return node
-  end
-end
-
----TODO #2837 #2871 move this and similar to node
----@private
----@param path string
----@param callback fun(toplevel: string|nil, project: table|nil)
-function Explorer:reload_and_get_git_project(path, callback)
-  local toplevel = git.get_toplevel(path)
-
-  git.reload_project(toplevel, path, function()
-    callback(toplevel, git.get_project(toplevel) or {})
-  end)
-end
-
----TODO #2837 #2871 move this and similar to node
----@private
----@param node Node
----@param project table|nil
----@param root string|nil
-function Explorer:update_parent_statuses(node, project, root)
-  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)
-
-      -- stop when no more projects
-      if not root then
-        break
-      end
-
-      -- update the containing project
-      project = git.get_project(root)
-      git.reload_project(root, node.absolute_path, nil)
-    end
-
-    -- update status
-    explorer_node.update_git_status(node, explorer_node.is_git_ignored(node.parent), project)
-
-    -- maybe parent
-    node = node.parent
-  end
-end
-
----@private
----@param handle uv.uv_fs_t
----@param cwd string
----@param node Node
----@param git_status table
----@param parent Explorer
-function Explorer: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("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
-        -- Type must come from fs_stat and not fs_scandir_next to maintain sshfs compatibility
-        local t = stat and stat.type or nil
-        local child = nil
-        if t == "directory" and vim.loop.fs_access(abs, "R") then
-          child = builders.folder(node, abs, name, stat)
-        elseif t == "file" then
-          child = builders.file(node, abs, name, stat)
-        elseif t == "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
-
----@private
----@param node Node
----@param status table
----@param parent Explorer
----@return Node[]|nil
-function Explorer: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 %s", node.absolute_path)
-
-  self: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 config.renderer.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 = self: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
-
----@private
----@param projects table
-function Explorer:refresh_nodes(projects)
-  Iterator.builder({ self })
-    :applier(function(n)
-      if n.nodes then
-        local toplevel = git.get_toplevel(n.cwd or n.link_to or n.absolute_path)
-        self:reload(n, 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()
-  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()
-  explorer_node.reload_node_status(self, projects)
-  self.renderer:draw()
-  event_running = false
-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.filters").setup(opts)
+  require("nvim-tree.explorer.sorters").setup(opts)
+  require("nvim-tree.explorer.reload").setup(opts)
   require("nvim-tree.explorer.watch").setup(opts)
 end
 
-return Explorer
+M.Explorer = Explorer
+
+return M

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

@@ -1,223 +0,0 @@
-local view = require("nvim-tree.view")
-local utils = require("nvim-tree.utils")
-local Iterator = require("nvim-tree.iterators.node-iterator")
-
----@class LiveFilter
----@field explorer Explorer
----@field prefix string
----@field always_show_folders boolean
----@field filter string
-local LiveFilter = {}
-
----@param opts table
----@param explorer Explorer
-function LiveFilter:new(opts, explorer)
-  local o = {
-    explorer = explorer,
-    prefix = opts.live_filter.prefix,
-    always_show_folders = opts.live_filter.always_show_folders,
-    filter = nil,
-  }
-  setmetatable(o, self)
-  self.__index = self
-  return o
-end
-
----@param node_ Node|nil
-local function reset_filter(self, node_)
-  node_ = node_ or self.explorer
-
-  if node_ == nil then
-    return
-  end
-
-  node_.hidden_stats = vim.tbl_deep_extend("force", node_.hidden_stats or {}, {
-    live_filter = 0,
-  })
-
-  Iterator.builder(node_.nodes)
-    :hidden()
-    :applier(function(node)
-      node.hidden = false
-      node.hidden_stats = vim.tbl_deep_extend("force", node.hidden_stats or {}, {
-        live_filter = 0,
-      })
-    end)
-    :iterate()
-end
-
-local overlay_bufnr = 0
-local overlay_winnr = 0
-
-local function remove_overlay(self)
-  if view.View.float.enable and view.View.float.quit_on_focus_loss then
-    -- return to normal nvim-tree float behaviour when filter window is closed
-    vim.api.nvim_create_autocmd("WinLeave", {
-      pattern = "NvimTree_*",
-      group = vim.api.nvim_create_augroup("NvimTree", { clear = false }),
-      callback = function()
-        if utils.is_nvim_tree_buf(0) then
-          view.close()
-        end
-      end,
-    })
-  end
-
-  vim.api.nvim_win_close(overlay_winnr, true)
-  vim.api.nvim_buf_delete(overlay_bufnr, { force = true })
-  overlay_bufnr = 0
-  overlay_winnr = 0
-
-  if self.filter == "" then
-    self:clear_filter()
-  end
-end
-
----@param node Node
----@return boolean
-local function matches(self, node)
-  if not self.explorer.filters.config.enable then
-    return true
-  end
-
-  local path = node.absolute_path
-  local name = vim.fn.fnamemodify(path, ":t")
-  return vim.regex(self.filter):match_str(name) ~= nil
-end
-
----@param node_ Node|nil
-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
-  -- since the node mapper is based on its children
-  local function iterate(node)
-    local filtered_nodes = 0
-    local nodes = node.group_next and { node.group_next } or node.nodes
-
-    node.hidden_stats = vim.tbl_deep_extend("force", node.hidden_stats or {}, {
-      live_filter = 0,
-    })
-
-    if nodes then
-      for _, n in pairs(nodes) do
-        iterate(n)
-        if n.hidden then
-          filtered_nodes = filtered_nodes + 1
-        end
-      end
-    end
-
-    node.hidden_stats.live_filter = filtered_nodes
-
-    local has_nodes = nodes and (self.always_show_folders or #nodes > filtered_nodes)
-    local ok, is_match = pcall(matches, self, node)
-    node.hidden = not (has_nodes or (ok and is_match))
-  end
-
-  iterate(node_ or self.explorer)
-end
-
-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()
-    self.explorer.renderer:draw()
-  end)
-end
-
-local function configure_buffer_overlay(self)
-  overlay_bufnr = vim.api.nvim_create_buf(false, true)
-
-  vim.api.nvim_buf_attach(overlay_bufnr, true, {
-    on_lines = function()
-      return record_char(self)
-    end,
-  })
-
-  vim.api.nvim_create_autocmd("InsertLeave", {
-    callback = function()
-      return remove_overlay(self)
-    end,
-    once = true,
-  })
-
-  vim.api.nvim_buf_set_keymap(overlay_bufnr, "i", "<CR>", "<cmd>stopinsert<CR>", {})
-end
-
----@return integer
-local function calculate_overlay_win_width(self)
-  local wininfo = vim.fn.getwininfo(view.get_winnr())[1]
-
-  if wininfo then
-    return wininfo.width - wininfo.textoff - #self.prefix
-  end
-
-  return 20
-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({
-      event = "WinLeave",
-      pattern = "NvimTree_*",
-      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,
-    row = 0,
-    relative = "cursor",
-    width = calculate_overlay_win_width(self),
-    height = 1,
-    border = "none",
-    style = "minimal",
-  })
-
-  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.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()
-  self.filter = self.filter or ""
-
-  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 })
-  -- needs scheduling to let the cursor move before initializing the window
-  vim.schedule(function()
-    return create_overlay(self)
-  end)
-end
-
-function LiveFilter:clear_filter()
-  local node = require("nvim-tree.lib").get_node_at_cursor()
-  local last_node = view.View.live_filter.prev_focused_node
-
-  self.filter = nil
-  reset_filter(self)
-  self.explorer.renderer:draw()
-
-  if node then
-    utils.focus_file(node.absolute_path)
-  elseif last_node then
-    utils.focus_file(last_node.absolute_path)
-  end
-end
-
-return LiveFilter

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

@@ -1,21 +1,20 @@
-local utils = require("nvim-tree.utils")
+local utils = require "nvim-tree.utils"
-local watch = require("nvim-tree.explorer.watch")
+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)
+function M.folder(parent, absolute_path, name)
   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,
+    fs_stat = vim.loop.fs_stat(absolute_path),
     group_next = nil, -- If node is grouped, this points to the next child dir/link node
     has_children = has_children,
     name = name,
@@ -44,9 +43,8 @@ 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)
+function M.file(parent, absolute_path, name)
   local ext = string.match(name, ".?[^.]+%.(.*)") or ""
 
   return {
@@ -54,7 +52,7 @@ function M.file(parent, absolute_path, name, fs_stat)
     absolute_path = absolute_path,
     executable = M.is_executable(absolute_path),
     extension = ext,
-    fs_stat = fs_stat,
+    fs_stat = vim.loop.fs_stat(absolute_path),
     name = name,
     parent = parent,
   }
@@ -68,16 +66,15 @@ end
 ---@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)
+function M.link(parent, absolute_path, name)
   --- 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
+  if is_dir_link then
     local handle = vim.loop.fs_scandir(link_to)
     has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil
     open = false
@@ -87,7 +84,7 @@ function M.link(parent, absolute_path, name, fs_stat)
   local node = {
     type = "link",
     absolute_path = absolute_path,
-    fs_stat = fs_stat,
+    fs_stat = vim.loop.fs_stat(absolute_path),
     group_next = nil, -- If node is grouped, this points to the next child dir/link node
     has_children = has_children,
     link_to = link_to,

lua/nvim-tree/explorer/node.lua

@@ -1,5 +1,3 @@
-local git = {} -- circular dependencies
-
 local M = {}
 
 ---@class GitStatus
@@ -31,7 +29,7 @@ end
 ---@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])
+  local file_status = parent_ignored and "!!" or status.files and status.files[absolute_path]
   return { file = file_status }
 end
 
@@ -124,42 +122,12 @@ function M.get_git_status(node)
   end
 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
-    M.update_git_status(node, M.is_git_ignored(parent_node), status)
-    if node.nodes and #node.nodes > 0 then
-      M.reload_node_status(node, projects)
-    end
-  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
@@ -176,8 +144,6 @@ function M.setup(opts)
   M.config = {
     git = opts.git,
   }
-
-  git = require("nvim-tree.git")
 end
 
 return M

lua/nvim-tree/explorer/reload.lua

@@ -0,0 +1,240 @@
+local utils = require "nvim-tree.utils"
+local builders = require "nvim-tree.explorer.node-builders"
+local explorer_node = require "nvim-tree.explorer.node"
+local filters = require "nvim-tree.explorer.filters"
+local sorters = require "nvim-tree.explorer.sorters"
+local live_filter = require "nvim-tree.live-filter"
+local git = require "nvim-tree.git"
+local log = require "nvim-tree.log"
+
+local NodeIterator = require "nvim-tree.iterators.node-iterator"
+local Watcher = require "nvim-tree.watcher"
+
+local M = {}
+
+---@param nodes_by_path table
+---@param node_ignored boolean
+---@param status table
+---@return fun(node: Node): table
+local function update_status(nodes_by_path, node_ignored, status)
+  return function(node)
+    if nodes_by_path[node.absolute_path] then
+      explorer_node.update_git_status(node, node_ignored, status)
+    end
+    return node
+  end
+end
+
+---@param path string
+---@param callback fun(toplevel: string|nil, project: table|nil)
+local function reload_and_get_git_project(path, callback)
+  local toplevel = git.get_toplevel(path)
+
+  git.reload_project(toplevel, path, function()
+    callback(toplevel, git.get_project(toplevel) or {})
+  end)
+end
+
+---@param node Node
+---@param project table|nil
+---@param root string|nil
+local function update_parent_statuses(node, project, root)
+  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)
+
+      -- stop when no more projects
+      if not root then
+        break
+      end
+
+      -- update the containing project
+      project = git.get_project(root)
+      git.reload_project(root, node.absolute_path, nil)
+    end
+
+    -- update status
+    explorer_node.update_git_status(node, explorer_node.is_git_ignored(node.parent), project)
+
+    -- maybe parent
+    node = node.parent
+  end
+end
+
+---@param node Node
+---@param git_status table
+---@param unloaded_bufnr number|nil
+function M.reload(node, git_status, unloaded_bufnr)
+  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("reload %s", node.absolute_path)
+
+  local filter_status = filters.prepare(git_status, unloaded_bufnr)
+
+  if node.group_next then
+    node.nodes = { node.group_next }
+    node.group_next = nil
+  end
+
+  local child_names = {}
+
+  local node_ignored = explorer_node.is_git_ignored(node)
+  local nodes_by_path = utils.key_by(node.nodes, "absolute_path")
+  while true do
+    local name, t = vim.loop.fs_scandir_next(handle, cwd)
+    if not name then
+      break
+    end
+
+    local stat
+    local function fs_stat_cached(path)
+      if stat ~= nil then
+        return stat
+      end
+
+      stat = vim.loop.fs_stat(path)
+      return stat
+    end
+
+    local abs = utils.path_join { cwd, name }
+    t = t or (fs_stat_cached(abs) or {}).type
+    if not filters.should_filter(abs, filter_status) then
+      child_names[abs] = true
+
+      -- Recreate node if type changes.
+      if nodes_by_path[abs] then
+        local n = nodes_by_path[abs]
+
+        if n.type ~= t then
+          utils.array_remove(node.nodes, n)
+          explorer_node.node_destroy(n)
+          nodes_by_path[abs] = nil
+        end
+      end
+
+      if not nodes_by_path[abs] then
+        if t == "directory" and vim.loop.fs_access(abs, "R") and Watcher.is_fs_event_capable(abs) then
+          local folder = builders.folder(node, abs, name)
+          nodes_by_path[abs] = folder
+          table.insert(node.nodes, folder)
+        elseif t == "file" then
+          local file = builders.file(node, abs, name)
+          nodes_by_path[abs] = file
+          table.insert(node.nodes, file)
+        elseif t == "link" then
+          local link = builders.link(node, abs, name)
+          if link.link_to ~= nil then
+            nodes_by_path[abs] = link
+            table.insert(node.nodes, link)
+          end
+        end
+      else
+        local n = nodes_by_path[abs]
+        if n then
+          n.executable = builders.is_executable(abs)
+          n.fs_stat = fs_stat_cached(abs)
+        end
+      end
+    end
+  end
+
+  node.nodes = vim.tbl_map(
+    update_status(nodes_by_path, node_ignored, git_status),
+    vim.tbl_filter(function(n)
+      if child_names[n.absolute_path] then
+        return child_names[n.absolute_path]
+      else
+        explorer_node.node_destroy(n)
+        return false
+      end
+    end, node.nodes)
+  )
+
+  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
+    node.group_next = child_folder_only
+    local ns = M.reload(child_folder_only, git_status)
+    node.nodes = ns or {}
+    log.profile_end(profile)
+    return ns
+  end
+
+  sorters.sort(node.nodes)
+  live_filter.apply_filter(node)
+  log.profile_end(profile)
+  return node.nodes
+end
+
+---Refresh contents and git status for a single node
+---@param node Node
+---@param callback function
+function M.refresh_node(node, callback)
+  if type(node) ~= "table" then
+    callback()
+  end
+
+  local parent_node = utils.get_parent_of_group(node)
+
+  reload_and_get_git_project(node.absolute_path, function(toplevel, project)
+    require("nvim-tree.explorer.reload").reload(parent_node, project)
+
+    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
+function M.refresh_parent_nodes_for_path(path)
+  local explorer = require("nvim-tree.core").get_explorer()
+  if not explorer then
+    return
+  end
+
+  local profile = log.profile_start("refresh_parent_nodes_for_path %s", path)
+
+  -- collect parent nodes from the top down
+  local parent_nodes = {}
+  NodeIterator.builder({ explorer })
+    :recursor(function(node)
+      return node.nodes
+    end)
+    :applier(function(node)
+      local abs_contains = node.absolute_path and path:find(node.absolute_path, 1, true) == 1
+      local link_contains = node.link_to and path:find(node.link_to, 1, true) == 1
+      if abs_contains or link_contains then
+        table.insert(parent_nodes, node)
+      end
+    end)
+    :iterate()
+
+  -- refresh in order; this will expand groups as needed
+  for _, node in ipairs(parent_nodes) do
+    local toplevel = git.get_toplevel(node.absolute_path)
+    local project = git.get_project(toplevel) or {}
+
+    M.reload(node, project)
+    update_parent_statuses(node, project, toplevel)
+  end
+
+  log.profile_end(profile)
+end
+
+function M.setup(opts)
+  M.config = opts.renderer
+end
+
+return M

lua/nvim-tree/explorer/sorters.lua

@@ -1,27 +1,12 @@
+local M = {}
+
 local C = {}
 
----@class Sorter
-local Sorter = {}
-
-function Sorter:new(opts)
-  local o = {}
-  setmetatable(o, self)
-  self.__index = self
-  o.config = vim.deepcopy(opts.sort)
-
-  if type(o.config.sorter) == "function" then
-    o.user = o.config.sorter
-  end
-  return o
-end
-
 --- Predefined comparator, defaulting to name
 ---@param sorter string as per options
 ---@return function
-function Sorter:get_comparator(sorter)
+local function get_comparator(sorter)
-  return function(a, b)
+  return C[sorter] or C.name
-    return (C[sorter] or C.name)(a, b, self.config)
-  end
 end
 
 ---Create a shallow copy of a portion of a list.
@@ -42,17 +27,17 @@ end
 ---@param a Node
 ---@param b Node
 ---@return boolean|nil
-local function folders_or_files_first(a, b, cfg)
+local function folders_or_files_first(a, b)
-  if not (cfg.folders_first or cfg.files_first) then
+  if not (M.config.sort.folders_first or M.config.sort.files_first) then
     return
   end
 
   if not a.nodes and b.nodes then
     -- file <> folder
-    return cfg.files_first
+    return M.config.sort.files_first
   elseif a.nodes and not b.nodes then
     -- folder <> file
-    return not cfg.files_first
+    return not M.config.sort.files_first
   end
 end
 
@@ -112,8 +97,8 @@ end
 
 ---Perform a merge sort using sorter option.
 ---@param t table nodes
-function Sorter:sort(t)
+function M.sort(t)
-  if self.user then
+  if C.user then
     local t_user = {}
     local origin_index = {}
 
@@ -122,7 +107,7 @@ function Sorter:sort(t)
         absolute_path = n.absolute_path,
         executable = n.executable,
         extension = n.extension,
-        filetype = vim.filetype.match({ filename = n.name }),
+        filetype = vim.filetype.match { filename = n.name },
         link_to = n.link_to,
         name = n.name,
         type = n.type,
@@ -130,9 +115,9 @@ function Sorter:sort(t)
       table.insert(origin_index, n)
     end
 
-    local predefined = self.user(t_user)
+    local predefined = C.user(t_user)
     if predefined then
-      split_merge(t, 1, #t, self:get_comparator(predefined))
+      split_merge(t, 1, #t, get_comparator(predefined))
       return
     end
 
@@ -157,7 +142,7 @@ function Sorter:sort(t)
 
     split_merge(t, 1, #t, mini_comparator) -- sort by user order
   else
-    split_merge(t, 1, #t, self:get_comparator(self.config.sorter))
+    split_merge(t, 1, #t, get_comparator(M.config.sort.sorter))
   end
 end
 
@@ -165,12 +150,12 @@ end
 ---@param b Node
 ---@param ignorecase boolean|nil
 ---@return boolean
-local function node_comparator_name_ignorecase_or_not(a, b, ignorecase, cfg)
+local function node_comparator_name_ignorecase_or_not(a, b, ignorecase)
   if not (a and b) then
     return true
   end
 
-  local early_return = folders_or_files_first(a, b, cfg)
+  local early_return = folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
@@ -182,20 +167,20 @@ local function node_comparator_name_ignorecase_or_not(a, b, ignorecase, cfg)
   end
 end
 
-function C.case_sensitive(a, b, cfg)
+function C.case_sensitive(a, b)
-  return node_comparator_name_ignorecase_or_not(a, b, false, cfg)
+  return node_comparator_name_ignorecase_or_not(a, b, false)
 end
 
-function C.name(a, b, cfg)
+function C.name(a, b)
-  return node_comparator_name_ignorecase_or_not(a, b, true, cfg)
+  return node_comparator_name_ignorecase_or_not(a, b, true)
 end
 
-function C.modification_time(a, b, cfg)
+function C.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 = folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
@@ -214,17 +199,17 @@ function C.modification_time(a, b, cfg)
   return last_modified_b <= last_modified_a
 end
 
-function C.suffix(a, b, cfg)
+function C.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 = 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 C.name(a, b)
   end
 
   -- dotfiles go second
@@ -233,19 +218,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 C.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 C.name(a, b)
   end
 
   -- finally, compare by suffixes
@@ -257,18 +242,18 @@ 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 C.name(a, b)
   end
 
   return a_suffix:lower() < b_suffix:lower()
 end
 
-function C.extension(a, b, cfg)
+function C.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 = folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
@@ -282,18 +267,18 @@ 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 C.name(a, b)
   end
 
   return a_ext < b_ext
 end
 
-function C.filetype(a, b, cfg)
+function C.filetype(a, b)
-  local a_ft = vim.filetype.match({ filename = a.name })
+  local a_ft = vim.filetype.match { filename = a.name }
-  local b_ft = vim.filetype.match({ filename = b.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 = folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
@@ -307,10 +292,19 @@ 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 C.name(a, b)
   end
 
   return a_ft < b_ft
 end
 
-return Sorter
+function M.setup(opts)
+  M.config = {}
+  M.config.sort = opts.sort
+
+  if type(M.config.sort.sorter) == "function" then
+    C.user = M.config.sort.sorter
+  end
+end
+
+return M

lua/nvim-tree/explorer/watch.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 Watcher = require("nvim-tree.watcher").Watcher
 
 local M = {
@@ -40,14 +40,10 @@ local function is_folder_ignored(path)
     end
   end
 
-  if type(M.config.filesystem_watchers.ignore_dirs) == "table" then
+  for _, ignore_dir in ipairs(M.config.filesystem_watchers.ignore_dirs) do
-    for _, ignore_dir in ipairs(M.config.filesystem_watchers.ignore_dirs) do
+    if vim.fn.match(path, ignore_dir) ~= -1 then
-      if vim.fn.match(path, ignore_dir) ~= -1 then
+      return true
-        return true
-      end
     end
-  elseif type(M.config.filesystem_watchers.ignore_dirs) == "function" then
-    return M.config.filesystem_watchers.ignore_dirs(path)
   end
 
   return false
@@ -76,12 +72,9 @@ 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()
+      require("nvim-tree.explorer.reload").refresh_node(node, function()
-      if explorer then
+        require("nvim-tree.renderer").draw()
-        explorer:refresh_node(node, function()
+      end)
-          explorer.renderer:draw()
-        end)
-      end
     end)
   end
 

lua/nvim-tree/git/init.lua

@@ -1,10 +1,10 @@
-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 Runner = 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 explorer_node = require "nvim-tree.explorer.node"
 
 local M = {
   config = {},
@@ -23,10 +23,10 @@ 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
@@ -136,10 +136,6 @@ end
 ---@param path string absolute
 ---@return string|nil
 function M.get_toplevel(path)
-  if not path then
-    return nil
-  end
-
   if not M.config.git.enable then
     return nil
   end
@@ -170,18 +166,12 @@ function M.get_toplevel(path)
   if not toplevel or not git_dir then
     return nil
   end
-  local toplevel_norm = vim.fn.fnamemodify(toplevel, ":p")
 
   -- ignore disabled paths
-  if type(M.config.git.disable_for_dirs) == "table" then
+  for _, disabled_for_dir in ipairs(M.config.git.disable_for_dirs) do
-    for _, disabled_for_dir in ipairs(M.config.git.disable_for_dirs) do
+    local toplevel_norm = vim.fn.fnamemodify(toplevel, ":p")
-      local disabled_norm = vim.fn.fnamemodify(disabled_for_dir, ":p")
+    local disabled_norm = vim.fn.fnamemodify(disabled_for_dir, ":p")
-      if toplevel_norm == disabled_norm then
+    if toplevel_norm == disabled_norm then
-        return nil
-      end
-    end
-  elseif type(M.config.git.disable_for_dirs) == "function" then
-    if M.config.git.disable_for_dirs(toplevel_norm) then
       return nil
     end
   end
@@ -216,10 +206,7 @@ local function reload_tree_at(toplevel)
       end)
       :iterate()
 
-    local explorer = require("nvim-tree.core").get_explorer()
+    require("nvim-tree.renderer").draw()
-    if explorer then
-      explorer.renderer:draw()
-    end
   end)
 end
 
@@ -243,12 +230,12 @@ function M.load_project_status(path)
     return status
   end
 
-  local git_status = Runner.run({
+  local git_status = Runner.run {
     toplevel = toplevel,
     list_untracked = git_utils.should_show_untracked(toplevel),
     list_ignored = true,
     timeout = M.config.git.timeout,
-  })
+  }
 
   local watcher = nil
   if M.config.filesystem_watchers.enable then
@@ -264,7 +251,7 @@ function M.load_project_status(path)
       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, {
       toplevel = toplevel,
     })

lua/nvim-tree/git/runner.lua

@@ -1,6 +1,11 @@
-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"
+
+-- TODO add "${3rd}/luv/library" to "workspace.library"
+---@class uv.uv_handle_t: table
+---@class uv.uv_stream_t: uv.uv_handle_t
+---@class uv.uv_pipe_t: uv.uv_stream_t
 
 ---@class Runner
 local Runner = {}
@@ -18,11 +23,11 @@ function Runner:_parse_status_output(status, path)
   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.output[utils.path_remove_trailing(utils.path_join { self.toplevel, path })] = status
   end
 end
 
@@ -35,7 +40,7 @@ function Runner:_handle_incoming_data(prev_output, incoming)
     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
@@ -57,7 +62,7 @@ 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)
   end
 
@@ -79,7 +84,7 @@ end
 
 ---@param output string
 function Runner:_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

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
@@ -128,7 +128,7 @@ 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,5 +1,4 @@
-local keymap = require("nvim-tree.keymap")
+local keymap = require "nvim-tree.keymap"
-local api = {} -- circular dependency
 
 local PAT_MOUSE = "^<.*Mouse"
 local PAT_CTRL = "^<C%-"
@@ -27,12 +26,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
 
@@ -80,19 +79,18 @@ 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(map)
+local function compute()
   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(m)
+  local mappings = vim.tbl_map(function(map)
-    return { lhs = tidy_lhs(m.lhs), desc = tidy_desc(m.desc) }
+    return { lhs = tidy_lhs(map.lhs), desc = tidy_desc(map.desc) }
-  end, map)
+  end, keymap.get_keymap())
 
   -- sorter function for mappings
   local sort_fn
@@ -121,20 +119,14 @@ local function compute(map)
   -- increase desc if lines are shorter than the header
   max_desc = math.max(max_desc, #head_lhs + #head_rhs1 - max_lhs)
 
-  -- header text, not padded
+  -- header, not padded
+  local hl = { { "NvimTreeRootFolder", 0, 0, #head_lhs } }
   local lines = {
     head_lhs .. string.rep(" ", max_desc + max_lhs - #head_lhs - #head_rhs1 + 2) .. head_rhs1,
     string.rep(" ", max_desc + max_lhs - #head_rhs2 + 2) .. head_rhs2,
   }
   local width = #lines[1]
 
-  -- header highlight, assume one character keys
-  local hl = {
-    { "NvimTreeFolderName", 0, 0,         #head_lhs },
-    { "NvimTreeFolderName", 0, width - 1, width },
-    { "NvimTreeFolderName", 1, width - 1, width },
-  }
-
   -- mappings, left padded 1
   local fmt = string.format(" %%-%ds %%-%ds", max_lhs, max_desc)
   for i, l in ipairs(mappings) do
@@ -167,23 +159,15 @@ 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(map)
+  local lines, hl, width = compute()
 
   -- create the buffer
   M.bufnr = vim.api.nvim_create_buf(false, true)
 
   -- populate it
   vim.api.nvim_buf_set_lines(M.bufnr, 0, -1, false, lines)
-
+  vim.api.nvim_buf_set_option(M.bufnr, "modifiable", false)
-  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
-  end
 
   -- highlight it
   for _, h in ipairs(hl) do
@@ -211,21 +195,12 @@ local function open()
     open()
   end
 
-  -- hardcoded
+  local keymaps = {
-  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" },
   }
 
-  -- api help binding closes
+  for k, v in pairs(keymaps) do
-  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,
@@ -254,8 +229,6 @@ 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

@@ -19,40 +19,21 @@ local function generate_keymap(fn)
   return keymap
 end
 
----@return table
+-- stylua: ignore start
-function M.get_keymap()
-  return generate_keymap(M.on_attach)
-end
-
----@return table
-function M.get_keymap_default()
-  return generate_keymap(M.default_on_attach)
-end
-
-function M.setup(opts)
-  if type(opts.on_attach) ~= "function" then
-    M.on_attach = M.default_on_attach
-  else
-    M.on_attach = opts.on_attach
-  end
-end
-
 ---@param bufnr integer
 function M.default_on_attach(bufnr)
-  local api = require("nvim-tree.api")
+  local api = require('nvim-tree.api')
 
   local function opts(desc)
     return {
-      desc = "nvim-tree: " .. desc,
+      desc = 'nvim-tree: ' .. desc,
       buffer = bufnr,
       noremap = true,
       silent = true,
       nowait = true,
-    }
+  }
   end
 
-  -- formatting cannot be re-enabled, hence this is at the end
-  ---@format disable
   -- 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'))
@@ -83,17 +64,14 @@ function M.default_on_attach(bufnr)
   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.clear,               opts('Clean Filter'))
-  vim.keymap.set('n', 'f',       api.live_filter.start,               opts('Live Filter: Start'))
+  vim.keymap.set('n', 'f',       api.live_filter.start,               opts('Filter'))
   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'))
@@ -114,5 +92,24 @@ function M.default_on_attach(bufnr)
   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)
+end
+
+---@return table
+function M.get_keymap_default()
+  return generate_keymap(M.default_on_attach)
+end
+
+function M.setup(opts)
+  if type(opts.on_attach) ~= "function" then
+    M.on_attach = M.default_on_attach
+  else
+    M.on_attach = opts.on_attach
+  end
+end
 
 return M

lua/nvim-tree/legacy.lua

@@ -1,9 +1,8 @@
-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)
@@ -42,46 +41,27 @@ local function refactored(opts)
 
   -- 2023/08/26
   utils.move_missing_val(opts, "renderer.icons", "webdev_colors", opts, "renderer.icons.web_devicons.file", "color", true)
-
-  -- 2023/10/08
-  if type(opts.renderer) == "table" and type(opts.renderer.highlight_diagnostics) == "boolean" then
-    opts.renderer.highlight_diagnostics = opts.renderer.highlight_diagnostics and "name" or "none"
-  end
-
-  -- 2023/10/21
-  if type(opts.renderer) == "table" and type(opts.renderer.highlight_git) == "boolean" then
-    opts.renderer.highlight_git = opts.renderer.highlight_git and "name" or "none"
-  end
-
-  -- 2024/02/15
-  if type(opts.update_focused_file) == "table" then
-    if type(opts.update_focused_file.update_root) ~= "table" then
-      opts.update_focused_file.update_root = { enable = opts.update_focused_file.update_root }
-    end
-  end
-  utils.move_missing_val(opts, "update_focused_file", "ignore_list", opts, "update_focused_file.update_root", "ignore_list", true)
 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, see note in the README (tips & reminder section)"
     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 and will be replaced by a new startup configuration. Please remove this option. See https://bit.ly/3yJch2T"
     opts.focus_empty_on_setup = nil
   end
 
   if opts.create_in_closed_folder then
-    notify.warn(
+    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."
-      "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,9 +1,8 @@
-local view = require("nvim-tree.view")
+local renderer = require "nvim-tree.renderer"
-local core = require("nvim-tree.core")
+local view = require "nvim-tree.view"
-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 notify = require("nvim-tree.notify")
+local events = require "nvim-tree.events"
-local explorer_node = require("nvim-tree.explorer.node")
 
 ---@class LibOpenOpts
 ---@field path string|nil path
@@ -14,33 +13,25 @@ local M = {
   target_winid = nil,
 }
 
----Cursor position as per vim.api.nvim_win_get_cursor
+---@return Node|nil
----@return integer[]|nil
+function M.get_node_at_cursor()
-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
+  if not winnr then
     return
   end
 
-  return vim.api.nvim_win_get_cursor(winnr)
+  local cursor = vim.api.nvim_win_get_cursor(view.get_winnr())
-end
+  local line = cursor[1]
 
----@return Node|nil
+  if line == 1 and view.is_root_folder_visible(core.get_cwd()) then
-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]]
+  return utils.get_nodes_by_line(core.get_explorer().nodes, core.get_nodes_starting_line())[line]
 end
 
 ---Create a sanitized partial copy of a node, populating children recursively.
@@ -65,7 +56,6 @@ local function clone_node(node)
     name = node.name,
     open = node.open,
     type = node.type,
-    fs_stat = node.fs_stat,
   }
 
   if type(node.nodes) == "table" then
@@ -92,35 +82,8 @@ function M.get_last_group_node(node)
     node = node.group_next
   end
 
-  return node ---@diagnostic disable-line: return-type-mismatch -- it can't be nil
+  ---@diagnostic disable-next-line: return-type-mismatch -- it can't be nil
-end
+  return node
-
----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
@@ -135,50 +98,22 @@ function M.get_all_nodes_in_group(node)
   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)
+function M.expand_or_collapse(node)
-  local explorer = core.get_explorer()
-
-  toggle_group = toggle_group or false
   if node.has_children then
     node.has_children = false
   end
 
-  if #node.nodes == 0 and explorer then
+  if #node.nodes == 0 then
-    explorer:expand(node)
+    core.get_explorer():expand(node)
   end
 
-  local head_node = utils.get_parent_of_group(node)
+  local open = not M.get_last_group_node(node).open
-  if toggle_group then
+  for _, n in ipairs(M.get_all_nodes_in_group(node)) do
-    toggle_group_folders(head_node)
+    n.open = open
   end
 
-  local open = M.get_last_group_node(node).open
+  renderer.draw()
-  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
-
-  if explorer then
-    explorer.renderer:draw()
-  end
 end
 
 function M.set_target_win()
@@ -203,25 +138,14 @@ 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()
   local bufnr = vim.api.nvim_get_current_buf()
   local bufname = vim.api.nvim_buf_get_name(bufnr)
-
+  local bufmodified = vim.api.nvim_buf_get_option(bufnr, "modified")
-  local bufmodified, ft
+  local ft = vim.api.nvim_buf_get_option(bufnr, "ft")
-  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
-    bufmodified = vim.api.nvim_buf_get_option(bufnr, "modified") ---@diagnostic disable-line: deprecated
-    ft = vim.api.nvim_buf_get_option(bufnr, "ft") ---@diagnostic disable-line: deprecated
-  end
 
   local should_hijack_unnamed = M.hijack_unnamed_buffer_when_opening and bufname == "" and not bufmodified and ft == ""
   local should_hijack_dir = bufname ~= "" and vim.fn.isdirectory(bufname) == 1 and M.hijack_directories.enable
@@ -233,9 +157,8 @@ end
 ---@param prompt_select string
 ---@param items_short string[]
 ---@param items_long string[]
----@param kind string|nil
 ---@param callback fun(item_short: string)
-function M.prompt(prompt_input, prompt_select, items_short, items_long, kind, callback)
+function M.prompt(prompt_input, prompt_select, items_short, items_long, callback)
   local function format_item(short)
     for i, s in ipairs(items_short) do
       if short == s then
@@ -246,7 +169,7 @@ function M.prompt(prompt_input, prompt_select, items_short, items_long, kind, ca
   end
 
   if M.select_prompts then
-    vim.ui.select(items_short, { prompt = prompt_select, kind = kind, format_item = format_item }, function(item_short)
+    vim.ui.select(items_short, { prompt = prompt_select, format_item = format_item }, function(item_short)
       callback(item_short)
     end)
   else
@@ -265,36 +188,18 @@ function M.open(opts)
 
   M.set_target_win()
   if not core.get_explorer() or opts.path then
-    if opts.path then
+    core.init(opts.path or vim.loop.cwd())
-      core.init(opts.path)
-    else
-      local cwd, err = vim.loop.cwd()
-      if not cwd then
-        notify.error(string.format("current working directory unavailable: %s", err))
-        return
-      end
-      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()
-    if explorer then
+    renderer.draw()
-      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 }
-    if explorer then
+    renderer.draw()
-      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 }
-    if explorer then
+    renderer.draw()
-      explorer.renderer:draw()
-    end
   else
     open_view_and_draw()
   end
@@ -307,7 +212,6 @@ function M.setup(opts)
   M.hijack_directories = opts.hijack_directories
   M.respect_buf_cwd = opts.respect_buf_cwd
   M.select_prompts = opts.select_prompts
-  M.group_empty = opts.renderer.group_empty
 end
 
 return M

lua/nvim-tree/live-filter.lua

@@ -0,0 +1,186 @@
+local view = require "nvim-tree.view"
+local utils = require "nvim-tree.utils"
+local Iterator = require "nvim-tree.iterators.node-iterator"
+
+local M = {
+  filter = nil,
+}
+
+local function redraw()
+  require("nvim-tree.renderer").draw()
+end
+
+---@param node_ Node|nil
+local function reset_filter(node_)
+  node_ = node_ or require("nvim-tree.core").get_explorer()
+
+  if node_ == nil then
+    return
+  end
+
+  Iterator.builder(node_.nodes)
+    :hidden()
+    :applier(function(node)
+      node.hidden = false
+    end)
+    :iterate()
+end
+
+local overlay_bufnr = nil
+local overlay_winnr = nil
+
+local function remove_overlay()
+  if view.View.float.enable and view.View.float.quit_on_focus_loss then
+    -- return to normal nvim-tree float behaviour when filter window is closed
+    vim.api.nvim_create_autocmd("WinLeave", {
+      pattern = "NvimTree_*",
+      group = vim.api.nvim_create_augroup("NvimTree", { clear = false }),
+      callback = function()
+        if utils.is_nvim_tree_buf(0) then
+          view.close()
+        end
+      end,
+    })
+  end
+
+  vim.api.nvim_win_close(overlay_winnr, true)
+  vim.api.nvim_buf_delete(overlay_bufnr, { force = true })
+  overlay_bufnr = nil
+  overlay_winnr = nil
+
+  if M.filter == "" then
+    M.clear_filter()
+  end
+end
+
+---@param node Node
+---@return boolean
+local function matches(node)
+  local path = node.absolute_path
+  local name = vim.fn.fnamemodify(path, ":t")
+  return vim.regex(M.filter):match_str(name) ~= nil
+end
+
+---@param node_ Node|nil
+function M.apply_filter(node_)
+  if not M.filter or M.filter == "" then
+    reset_filter(node_)
+    return
+  end
+
+  -- TODO(kiyan): 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
+    local nodes = node.group_next and { node.group_next } or node.nodes
+
+    if nodes then
+      for _, n in pairs(nodes) do
+        iterate(n)
+        if n.hidden then
+          filtered_nodes = filtered_nodes + 1
+        end
+      end
+    end
+
+    local has_nodes = nodes and (M.always_show_folders or #nodes > filtered_nodes)
+    local ok, is_match = pcall(matches, node)
+    node.hidden = not (has_nodes or (ok and is_match))
+  end
+
+  iterate(node_ or require("nvim-tree.core").get_explorer())
+end
+
+local function record_char()
+  vim.schedule(function()
+    M.filter = vim.api.nvim_buf_get_lines(overlay_bufnr, 0, -1, false)[1]
+    M.apply_filter()
+    redraw()
+  end)
+end
+
+local function configure_buffer_overlay()
+  overlay_bufnr = vim.api.nvim_create_buf(false, true)
+
+  vim.api.nvim_buf_attach(overlay_bufnr, true, {
+    on_lines = record_char,
+  })
+
+  vim.api.nvim_create_autocmd("InsertLeave", {
+    callback = remove_overlay,
+    once = true,
+  })
+
+  vim.api.nvim_buf_set_keymap(overlay_bufnr, "i", "<CR>", "<cmd>stopinsert<CR>", {})
+end
+
+---@return integer
+local function calculate_overlay_win_width()
+  local wininfo = vim.fn.getwininfo(view.get_winnr())[1]
+
+  if wininfo then
+    return wininfo.width - wininfo.textoff - #M.prefix
+  end
+
+  return 20
+end
+
+local function create_overlay()
+  if view.View.float.enable then
+    -- don't close nvim-tree float when focus is changed to filter window
+    vim.api.nvim_clear_autocmds {
+      event = "WinLeave",
+      pattern = "NvimTree_*",
+      group = vim.api.nvim_create_augroup("NvimTree", { clear = false }),
+    }
+  end
+
+  configure_buffer_overlay()
+  overlay_winnr = vim.api.nvim_open_win(overlay_bufnr, true, {
+    col = 1,
+    row = 0,
+    relative = "cursor",
+    width = calculate_overlay_win_width(),
+    height = 1,
+    border = "none",
+    style = "minimal",
+  })
+  vim.api.nvim_buf_set_option(overlay_bufnr, "modifiable", true)
+  vim.api.nvim_buf_set_lines(overlay_bufnr, 0, -1, false, { M.filter })
+  vim.cmd "startinsert"
+  vim.api.nvim_win_set_cursor(overlay_winnr, { 1, #M.filter + 1 })
+end
+
+function M.start_filtering()
+  view.View.live_filter.prev_focused_node = require("nvim-tree.lib").get_node_at_cursor()
+  M.filter = M.filter or ""
+
+  redraw()
+  local row = require("nvim-tree.core").get_nodes_starting_line() - 1
+  local col = #M.prefix > 0 and #M.prefix - 1 or 1
+  view.set_cursor { row, col }
+  -- needs scheduling to let the cursor move before initializing the window
+  vim.schedule(create_overlay)
+end
+
+function M.clear_filter()
+  local node = require("nvim-tree.lib").get_node_at_cursor()
+  local last_node = view.View.live_filter.prev_focused_node
+
+  M.filter = nil
+  reset_filter()
+  redraw()
+
+  if node then
+    utils.focus_file(node.absolute_path)
+  elseif last_node then
+    utils.focus_file(last_node.absolute_path)
+  end
+end
+
+function M.setup(opts)
+  M.prefix = opts.live_filter.prefix
+  M.always_show_folders = opts.live_filter.always_show_folders
+end
+
+return M

lua/nvim-tree/log.lua

@@ -32,7 +32,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 +44,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
@@ -57,7 +57,7 @@ end
 ---@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
 
@@ -77,7 +77,7 @@ end
 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
 
@@ -91,7 +91,7 @@ end
 function M.setup(opts)
   M.config = opts.log
   if M.config and M.config.enable and M.config.types then
-    M.path = string.format("%s/nvim-tree.log", vim.fn.stdpath("log"), os.date("%H:%M:%S"), vim.env.USER)
+    M.path = string.format("%s/nvim-tree.log", vim.fn.stdpath "log", os.date "%H:%M:%S", vim.env.USER)
     if M.config.truncate then
       os.remove(M.path)
     end

lua/nvim-tree/marks/bulk-delete.lua

@@ -0,0 +1,52 @@
+local marks = require "nvim-tree.marks"
+local utils = require "nvim-tree.utils"
+local remove_file = require "nvim-tree.actions.fs.remove-file"
+local notify = require "nvim-tree.notify"
+local lib = require "nvim-tree.lib"
+
+local M = {
+  config = {},
+}
+
+--- Delete nodes; each removal will be optionally notified
+---@param nodes Node[]
+local function do_delete(nodes)
+  for _, node in pairs(nodes) do
+    remove_file.remove(node)
+  end
+
+  marks.clear_marks()
+
+  if not M.config.filesystem_watchers.enable then
+    require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+  end
+end
+
+--- Delete marked nodes, optionally prompting
+function M.bulk_delete()
+  local nodes = marks.get_marks()
+  if not nodes or #nodes == 0 then
+    notify.warn "No bookmarksed to delete."
+    return
+  end
+
+  if M.config.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" }, function(item_short)
+      utils.clear_prompt()
+      if item_short == "y" then
+        do_delete(nodes)
+      end
+    end)
+  else
+    do_delete(nodes)
+  end
+end
+
+function M.setup(opts)
+  M.config.ui = opts.ui
+  M.config.filesystem_watchers = opts.filesystem_watchers
+end
+
+return M

lua/nvim-tree/marks/bulk-move.lua

@@ -0,0 +1,52 @@
+local marks = require "nvim-tree.marks"
+local core = require "nvim-tree.core"
+local utils = require "nvim-tree.utils"
+local rename_file = require "nvim-tree.actions.fs.rename-file"
+local notify = require "nvim-tree.notify"
+
+local M = {
+  config = {},
+}
+
+function M.bulk_move()
+  if #marks.get_marks() == 0 then
+    notify.warn "No bookmarks to move."
+    return
+  end
+
+  local input_opts = {
+    prompt = "Move to: ",
+    default = core.get_cwd(),
+    completion = "dir",
+  }
+
+  vim.ui.input(input_opts, function(location)
+    utils.clear_prompt()
+    if not location or location == "" then
+      return
+    end
+    if vim.fn.filewritable(location) ~= 2 then
+      notify.warn(location .. " is not writable, cannot move.")
+      return
+    end
+
+    local nodes = marks.get_marks()
+    for _, node in pairs(nodes) do
+      local head = vim.fn.fnamemodify(node.absolute_path, ":t")
+      local to = utils.path_join { location, head }
+      rename_file.rename(node, to)
+    end
+
+    marks.clear_marks()
+
+    if not M.config.filesystem_watchers.enable then
+      require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+    end
+  end)
+end
+
+function M.setup(opts)
+  M.config.filesystem_watchers = opts.filesystem_watchers
+end
+
+return M

lua/nvim-tree/marks/bulk-trash.lua

@@ -0,0 +1,47 @@
+local marks = require "nvim-tree.marks"
+local utils = require "nvim-tree.utils"
+local remove_file = require "nvim-tree.actions.fs.trash"
+local notify = require "nvim-tree.notify"
+local lib = require "nvim-tree.lib"
+
+local M = {
+  config = {},
+}
+
+--- Delete nodes; each removal will be optionally notified
+---@param nodes Node[]
+local function do_trash(nodes)
+  for _, node in pairs(nodes) do
+    remove_file.remove(node)
+  end
+
+  marks.clear_marks()
+end
+
+function M.bulk_trash()
+  local nodes = marks.get_marks()
+  if not nodes or #nodes == 0 then
+    notify.warn "No bookmarks to trash."
+    return
+  end
+
+  if M.config.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" }, function(item_short)
+      utils.clear_prompt()
+      if item_short == "y" then
+        do_trash(nodes)
+      end
+    end)
+  else
+    do_trash(nodes)
+  end
+end
+
+function M.setup(opts)
+  M.config.ui = opts.ui
+  M.config.filesystem_watchers = opts.filesystem_watchers
+end
+
+return M

lua/nvim-tree/marks/init.lua

@@ -1,272 +1,68 @@
-local Iterator = require("nvim-tree.iterators.node-iterator")
+local renderer = {} -- circular dependency
-local core = require("nvim-tree.core")
-local lib = require("nvim-tree.lib")
-local notify = require("nvim-tree.notify")
-local open_file = require("nvim-tree.actions.node.open-file")
-local remove_file = require("nvim-tree.actions.fs.remove-file")
-local rename_file = require("nvim-tree.actions.fs.rename-file")
-local trash = require("nvim-tree.actions.fs.trash")
-local utils = require("nvim-tree.utils")
 
----@class Marks
+local NvimTreeMarks = {}
----@field config table hydrated user opts.filters
----@field private explorer Explorer
----@field private marks table<string, Node> by absolute path
-local Marks = {}
 
----@return Marks
+local M = {}
----@param opts table user options
----@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 MinimalNode
-  self.__index = self
+---@field absolute_path string
-  return o
+
+---@param node Node|MinimalNode
+local function add_mark(node)
+  NvimTreeMarks[node.absolute_path] = node
+
+  renderer.draw()
 end
 
----Clear all marks and reload if watchers disabled
+---@param node Node|MinimalNode
----@private
+local function remove_mark(node)
-function Marks:clear_reload()
+  NvimTreeMarks[node.absolute_path] = nil
-  self:clear()
+
-  if not self.config.filesystem_watchers.enable then
+  renderer.draw()
-    self.explorer:reload_explorer()
-  end
 end
 
----Clear all marks and redraw
+---@param node Node|MinimalNode
----@public
+function M.toggle_mark(node)
-function Marks:clear()
-  self.marks = {}
-  self.explorer.renderer:draw()
-end
-
----@public
----@param node Node
-function Marks:toggle(node)
   if node.absolute_path == nil then
     return
   end
 
-  if self:get(node) then
+  if M.get_mark(node) then
-    self.marks[node.absolute_path] = nil
+    remove_mark(node)
   else
-    self.marks[node.absolute_path] = node
+    add_mark(node)
   end
 
-  self.explorer.renderer:draw()
+  renderer.draw()
 end
 
----Return node if marked
+function M.clear_marks()
----@public
+  NvimTreeMarks = {}
----@param node Node
+
----@return Node|nil
+  renderer.draw()
-function Marks:get(node)
-  return node and self.marks[node.absolute_path]
 end
 
----List marked nodes
+---@param node Node|MinimalNode
----@public
+---@return table|nil
----@return Node[]
+function M.get_mark(node)
-function Marks:list()
+  return NvimTreeMarks[node.absolute_path]
+end
+
+---@return table
+function M.get_marks()
   local list = {}
-  for _, node in pairs(self.marks) do
+  for _, node in pairs(NvimTreeMarks) do
     table.insert(list, node)
   end
   return list
 end
 
----Delete marked; each removal will be optionally notified
+function M.setup(opts)
----@public
+  renderer = require "nvim-tree.renderer"
-function Marks:bulk_delete()
-  if not next(self.marks) then
-    notify.warn("No bookmarks to delete.")
-    return
-  end
 
-  local function execute()
+  require("nvim-tree.marks.bulk-delete").setup(opts)
-    for _, node in pairs(self.marks) do
+  require("nvim-tree.marks.bulk-trash").setup(opts)
-      remove_file.remove(node)
+  require("nvim-tree.marks.bulk-move").setup(opts)
-    end
-    self:clear_reload()
-  end
-
-  if self.config.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)
-      utils.clear_prompt()
-      if item_short == "y" then
-        execute()
-      end
-    end)
-  else
-    execute()
-  end
 end
 
----Trash marked; each removal will be optionally notified
+return M
----@public
-function Marks:bulk_trash()
-  if not next(self.marks) then
-    notify.warn("No bookmarks to trash.")
-    return
-  end
-
-  local function execute()
-    for _, node in pairs(self.marks) do
-      trash.remove(node)
-    end
-    self:clear_reload()
-  end
-
-  if self.config.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)
-      utils.clear_prompt()
-      if item_short == "y" then
-        execute()
-      end
-    end)
-  else
-    execute()
-  end
-end
-
----Move marked
----@public
-function Marks:bulk_move()
-  if not next(self.marks) then
-    notify.warn("No bookmarks to move.")
-    return
-  end
-
-  local node_at_cursor = lib.get_node_at_cursor()
-  local default_path = core.get_cwd()
-
-  if node_at_cursor and node_at_cursor.type == "directory" 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
-  end
-
-  local input_opts = {
-    prompt = "Move to: ",
-    default = default_path,
-    completion = "dir",
-  }
-
-  vim.ui.input(input_opts, function(location)
-    utils.clear_prompt()
-    if not location or location == "" then
-      return
-    end
-    if vim.fn.filewritable(location) ~= 2 then
-      notify.warn(location .. " is not writable, cannot move.")
-      return
-    end
-
-    for _, node in pairs(self.marks) do
-      local head = vim.fn.fnamemodify(node.absolute_path, ":t")
-      local to = utils.path_join({ location, head })
-      rename_file.rename(node, to)
-    end
-
-    self:clear_reload()
-  end)
-end
-
----Focus nearest marked node in direction.
----@private
----@param up boolean
-function Marks:navigate(up)
-  local node = lib.get_node_at_cursor()
-  if not node then
-    return
-  end
-
-  local first, prev, next, last = nil, nil, nil, nil
-  local found = false
-
-  Iterator.builder(self.explorer.nodes)
-    :recursor(function(n)
-      return n.open and n.nodes
-    end)
-    :applier(function(n)
-      if n.absolute_path == node.absolute_path then
-        found = true
-        return
-      end
-
-      if not self:get(n) then
-        return
-      end
-
-      last = n
-      first = first or n
-
-      if found and not next then
-        next = n
-      end
-
-      if not found then
-        prev = n
-      end
-    end)
-    :iterate()
-
-  if not found then
-    return
-  end
-
-  if up then
-    utils.focus_node_or_parent(prev or last)
-  else
-    utils.focus_node_or_parent(next or first)
-  end
-end
-
----@public
-function Marks:navigate_prev()
-  self:navigate(true)
-end
-
----@public
-function Marks:navigate_next()
-  self:navigate(false)
-end
-
----Prompts for selection of a marked node, sorted by absolute paths.
----A folder will be focused, a file will be opened.
----@public
-function Marks:navigate_select()
-  local list = vim.tbl_map(function(n)
-    return n.absolute_path
-  end, self:list())
-
-  table.sort(list)
-
-  vim.ui.select(list, {
-    prompt = "Select a file to open or a folder to focus",
-  }, function(choice)
-    if not choice or choice == "" then
-      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
-      open_file.fn("edit", node.absolute_path)
-    elseif node then
-      utils.focus_file(node.absolute_path)
-    end
-  end)
-end
-
-return Marks

lua/nvim-tree/marks/navigation.lua

@@ -0,0 +1,102 @@
+local Iterator = require "nvim-tree.iterators.node-iterator"
+local core = require "nvim-tree.core"
+local Marks = require "nvim-tree.marks"
+local open_file = require "nvim-tree.actions.node.open-file"
+local utils = require "nvim-tree.utils"
+local lib = require "nvim-tree.lib"
+
+---@param node table
+---@param where string
+---@return Node|nil
+local function get_nearest(node, where)
+  local first, prev, next, last = nil, nil, nil, nil
+  local found = false
+
+  Iterator.builder(core.get_explorer().nodes)
+    :recursor(function(n)
+      return n.open and n.nodes
+    end)
+    :applier(function(n)
+      if n.absolute_path == node.absolute_path then
+        found = true
+        return
+      end
+
+      if not Marks.get_mark(n) then
+        return
+      end
+
+      last = n
+      first = first or n
+
+      if found and not next then
+        next = n
+      end
+
+      if not found then
+        prev = n
+      end
+    end)
+    :iterate()
+
+  if not found then
+    return
+  end
+
+  if where == "next" then
+    return next or first
+  else
+    return prev or last
+  end
+end
+
+---@param where string
+---@param node table|nil
+---@return Node|nil
+local function get(where, node)
+  if node then
+    return get_nearest(node, where)
+  end
+end
+
+---@param node table|nil
+local function open_or_focus(node)
+  if node and not node.nodes 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)
+  end
+end
+
+---@param where string
+---@return function
+local function navigate_to(where)
+  return function()
+    local node = lib.get_node_at_cursor()
+    local next = get(where, node)
+    open_or_focus(next)
+  end
+end
+
+local M = {}
+
+M.next = navigate_to "next"
+M.prev = navigate_to "prev"
+
+function M.select()
+  local list = vim.tbl_map(function(n)
+    return n.absolute_path
+  end, Marks.get_marks())
+
+  vim.ui.select(list, {
+    prompt = "Select a file to open or a folder to focus",
+  }, function(choice)
+    if not choice or choice == "" then
+      return
+    end
+    local node = Marks.get_mark { absolute_path = choice }
+    open_or_focus(node)
+  end)
+end
+
+return M

lua/nvim-tree/modified.lua

@@ -0,0 +1,40 @@
+local M = {}
+
+---@type table<string, boolean> record of which file is modified
+M._record = {}
+
+---refresh M.record
+function M.reload()
+  M._record = {}
+  local bufs = vim.fn.getbufinfo { bufmodified = true, buflisted = true }
+  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
+        M._record[path] ~= true
+        -- no need to keep going if already recorded
+        -- This also prevents an infinite loop
+      do
+        M._record[path] = true
+        path = vim.fn.fnamemodify(path, ":h")
+      end
+    end
+  end
+end
+
+---@param node Node
+---@return boolean
+function M.is_modified(node)
+  return M.config.enable
+    and M._record[node.absolute_path]
+    and (not node.nodes or M.config.show_on_dirs)
+    and (not node.open or M.config.show_on_open_dirs)
+end
+
+---@param opts table
+function M.setup(opts)
+  M.config = opts.modified
+end
+
+return M

lua/nvim-tree/node.lua

@@ -1,27 +1,28 @@
 ---@meta
 
+-- TODO add "${3rd}/luv/library" to "workspace.library"
+---@class uv.uv_req_t: table
+---@class uv.uv_fs_t: uv.uv_req_t
+
 ---@class ParentNode
 ---@field name string
 
 ---@class BaseNode
 ---@field absolute_path string
 ---@field executable boolean
----@field fs_stat uv.fs_stat.result|nil
+---@field fs_stat uv.uv_fs_t
 ---@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

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,111 +1,136 @@
-local notify = require("nvim-tree.notify")
+local utils = require "nvim-tree.utils"
-local utils = require("nvim-tree.utils")
+local core = require "nvim-tree.core"
-local view = require("nvim-tree.view")
+local notify = require "nvim-tree.notify"
 
-local DecoratorBookmarks = require("nvim-tree.renderer.decorator.bookmarks")
+local git = require "nvim-tree.renderer.components.git"
-local DecoratorCopied = require("nvim-tree.renderer.decorator.copied")
+local pad = require "nvim-tree.renderer.components.padding"
-local DecoratorCut = require("nvim-tree.renderer.decorator.cut")
+local icons = require "nvim-tree.renderer.components.icons"
-local DecoratorDiagnostics = require("nvim-tree.renderer.decorator.diagnostics")
+local modified = require "nvim-tree.renderer.components.modified"
-local DecoratorGit = require("nvim-tree.renderer.decorator.git")
+local diagnostics = require "nvim-tree.renderer.components.diagnostics"
-local DecoratorModified = require("nvim-tree.renderer.decorator.modified")
+local bookmarks = require "nvim-tree.renderer.components.bookmarks"
-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 HL_POSITION = require("nvim-tree.enum").HL_POSITION
-local icons = require("nvim-tree.renderer.components.icons")
 
-local PICTURE_MAP = {
-  jpg = true,
-  jpeg = true,
-  png = true,
-  gif = true,
-  webp = true,
-  jxl = true,
-}
-
----@class (exact) HighlightedString
----@field str string
----@field hl string[]
-
----@class (exact) AddHighlightArgs
----@field group string[]
----@field line number
----@field col_start number
----@field col_end number
-
----@class (exact) Builder
----@field private __index? table
----@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 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
----@field private decorators Decorator[]
----@field private hidden_display fun(node: Node): string|nil
 local Builder = {}
+Builder.__index = Builder
 
----@param opts table user options
+local DEFAULT_ROOT_FOLDER_LABEL = ":~:s?$?/..?"
----@param explorer Explorer
+
----@return Builder
+function Builder.new(root_cwd)
-function Builder:new(opts, explorer)
+  return setmetatable({
-  ---@type Builder
-  local o = {
-    opts = opts,
-    explorer = explorer,
     index = 0,
     depth = 0,
-    hl_args = {},
+    highlights = {},
-    combined_groups = {},
     lines = {},
     markers = {},
     signs = {},
-    extmarks = {},
+    root_cwd = root_cwd,
-    virtual_lines = {},
+  }, Builder)
-    decorators = {
-      -- priority order
-      DecoratorCut:new(opts, explorer),
-      DecoratorCopied:new(opts, explorer),
-      DecoratorDiagnostics:new(opts, explorer),
-      DecoratorBookmarks:new(opts, explorer),
-      DecoratorModified:new(opts, explorer),
-      DecoratorHidden:new(opts, explorer),
-      DecoratorOpened:new(opts, explorer),
-      DecoratorGit:new(opts, explorer),
-    },
-    hidden_display = Builder:setup_hidden_display_function(opts),
-  }
-
-  setmetatable(o, self)
-  self.__index = self
-
-  return o
 end
 
----Insert ranged highlight groups into self.highlights
+function Builder:configure_root_label(root_folder_label)
----@private
+  self.root_folder_label = root_folder_label or DEFAULT_ROOT_FOLDER_LABEL
----@param groups string[]
+  return self
----@param start number
----@param end_ number|nil
-function Builder:insert_highlight(groups, start, end_)
-  table.insert(self.hl_args, { groups, self.index, start, end_ or -1 })
 end
 
----@private
+function Builder:configure_trailing_slash(with_trailing)
-function Builder:get_folder_name(node)
+  self.trailing_slash = with_trailing and "/" or ""
+  return self
+end
+
+function Builder:configure_special_files(special_files)
+  self.special_files = special_files
+  return self
+end
+
+function Builder:configure_picture_map(picture_map)
+  self.picture_map = picture_map
+  return self
+end
+
+function Builder:configure_filter(filter, prefix)
+  self.filter_prefix = prefix
+  self.filter = filter
+  return self
+end
+
+function Builder:configure_opened_file_highlighting(highlight_opened_files)
+  self.highlight_opened_files = highlight_opened_files
+  return self
+end
+
+function Builder:configure_modified_highlighting(highlight_modified)
+  self.highlight_modified = highlight_modified
+  return self
+end
+
+function Builder:configure_icon_padding(padding)
+  self.icon_padding = padding or " "
+  return self
+end
+
+function Builder:configure_git_icons_placement(where)
+  if where ~= "after" and where ~= "before" and where ~= "signcolumn" then
+    where = "before" -- default before
+  end
+  self.git_placement = where
+  return self
+end
+
+function Builder:configure_diagnostics_icon_placement(where)
+  if where ~= "after" and where ~= "before" and where ~= "signcolumn" then
+    where = "before" -- default before
+  end
+  self.diagnostics_placement = where
+  return self
+end
+
+function Builder:configure_bookmark_icon_placement(where)
+  if where ~= "after" and where ~= "before" and where ~= "signcolumn" then
+    where = "before" -- default before
+  end
+  self.bookmarks_placement = where
+  return self
+end
+
+function Builder:configure_modified_placement(where)
+  if where ~= "after" and where ~= "before" and where ~= "signcolumn" then
+    where = "after" -- default after
+  end
+  self.modified_placement = where
+  return self
+end
+
+function Builder:configure_symlink_destination(show)
+  self.symlink_destination = show
+  return self
+end
+
+function Builder:configure_group_name_modifier(group_name_modifier)
+  if type(group_name_modifier) == "function" then
+    self.group_name_modifier = group_name_modifier
+  end
+  return self
+end
+
+function Builder:_insert_highlight(group, start, end_)
+  table.insert(self.highlights, { group, self.index, start, end_ or -1 })
+end
+
+function Builder:_insert_line(line)
+  table.insert(self.lines, line)
+end
+
+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)
+    name = name .. "/" .. next.name
     next = next.group_next
   end
 
-  if node.group_next and type(self.opts.renderer.group_empty) == "function" then
+  if node.group_next and self.group_name_modifier then
-    local new_name = self.opts.renderer.group_empty(name)
+    local new_name = self.group_name_modifier(name)
     if type(new_name) == "string" then
       name = new_name
     else
@@ -113,13 +138,16 @@ function Builder:get_folder_name(node)
     end
   end
 
-  return string.format("%s%s", name, self.opts.renderer.add_trailing and "/" or "")
+  return name .. self.trailing_slash
 end
 
----@private
+---@class HighlightedString
+---@field str string
+---@field hl string[]
+
 ---@param highlighted_strings HighlightedString[]
 ---@return string
-function Builder:unwrap_highlighted_strings(highlighted_strings)
+function Builder:_unwrap_highlighted_strings(highlighted_strings)
   if not highlighted_strings then
     return ""
   end
@@ -128,22 +156,21 @@ function Builder:unwrap_highlighted_strings(highlighted_strings)
   for _, v in ipairs(highlighted_strings) do
     if #v.str > 0 then
       if v.hl and type(v.hl) == "table" then
-        self:insert_highlight(v.hl, #string, #string + #v.str)
+        self:_insert_highlight(v.hl, #string, #string + #v.str)
       end
-      string = string.format("%s%s", string, v.str)
+      string = string .. v.str
     end
   end
   return string
 end
 
----@private
 ---@param node table
 ---@return HighlightedString icon
 ---@return HighlightedString name
-function Builder:build_folder(node)
+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)
+  local foldername = self:_get_folder_name(node)
 
   if #icon > 0 and icon_hl == nil then
     if node.open then
@@ -154,14 +181,12 @@ function Builder:build_folder(node)
   end
 
   local foldername_hl = "NvimTreeFolderName"
-  if node.link_to and self.opts.renderer.symlink_destination then
+  if node.link_to and self.symlink_destination then
     local arrow = icons.i.symlink_arrow
-    local link_to = utils.path_relative(node.link_to, self.explorer.absolute_path)
+    local link_to = utils.path_relative(node.link_to, core.get_cwd())
-    foldername = string.format("%s%s%s", foldername, arrow, link_to)
+    foldername = foldername .. arrow .. link_to
     foldername_hl = "NvimTreeSymlinkFolderName"
-  elseif
+  elseif vim.tbl_contains(self.special_files, node.absolute_path) or vim.tbl_contains(self.special_files, node.name) then
-    vim.tbl_contains(self.opts.renderer.special_files, node.absolute_path) or vim.tbl_contains(self.opts.renderer.special_files, node.name)
-  then
     foldername_hl = "NvimTreeSpecialFolderName"
   elseif node.open then
     foldername_hl = "NvimTreeOpenedFolderName"
@@ -172,58 +197,174 @@ function Builder:build_folder(node)
   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)
+function Builder:_build_symlink(node)
   local icon = icons.i.symlink
   local arrow = icons.i.symlink_arrow
   local symlink_formatted = node.name
-  if self.opts.renderer.symlink_destination then
+  if self.symlink_destination then
-    local link_to = utils.path_relative(node.link_to, self.explorer.absolute_path)
+    local link_to = utils.path_relative(node.link_to, core.get_cwd())
-    symlink_formatted = string.format("%s%s%s", symlink_formatted, arrow, link_to)
+    symlink_formatted = symlink_formatted .. arrow .. link_to
   end
 
   return { str = icon, hl = { "NvimTreeSymlinkIcon" } }, { str = symlink_formatted, hl = { "NvimTreeSymlink" } }
 end
 
----@private
+---@param node table
+---@return HighlightedString icon
+function Builder:_build_file_icon(node)
+  local icon, hl_group = icons.get_file_icon(node.name, node.extension)
+  return { str = icon, hl = { hl_group } }
+end
+
 ---@param node table
 ---@return HighlightedString icon
 ---@return HighlightedString name
-function Builder:build_file(node)
+function Builder:_build_file(node)
+  local icon = self:_build_file_icon(node)
+
   local hl
-  if
+  if vim.tbl_contains(self.special_files, node.absolute_path) or vim.tbl_contains(self.special_files, node.name) then
-    vim.tbl_contains(self.opts.renderer.special_files, node.absolute_path) or vim.tbl_contains(self.opts.renderer.special_files, node.name)
-  then
     hl = "NvimTreeSpecialFile"
   elseif node.executable then
     hl = "NvimTreeExecFile"
-  elseif PICTURE_MAP[node.extension] then
+  elseif self.picture_map[node.extension] then
     hl = "NvimTreeImageFile"
   end
 
-  local icon, hl_group = icons.get_file_icon(node.name, node.extension)
+  return icon, { str = node.name, hl = { hl } }
-  return { str = icon, hl = { hl_group } }, { str = node.name, hl = { hl } }
+end
+
+---@param node table
+---@return HighlightedString[]|nil icon
+function Builder:_get_git_icons(node)
+  local git_icons = git.get_icons(node)
+  if git_icons and #git_icons > 0 and self.git_placement == "signcolumn" then
+    table.insert(self.signs, {
+      sign = git_icons[1].hl[1],
+      lnum = self.index + 1,
+      priority = 1,
+    })
+    git_icons = nil
+  end
+  return git_icons
+end
+
+---@param node table
+---@return HighlightedString[]|nil icon
+function Builder:_get_diagnostics_icon(node)
+  local diagnostics_icon = diagnostics.get_icon(node)
+  if diagnostics_icon and self.diagnostics_placement == "signcolumn" then
+    table.insert(self.signs, {
+      sign = diagnostics_icon.hl[1],
+      lnum = self.index + 1,
+      priority = 2,
+    })
+    diagnostics_icon = nil
+  end
+  return diagnostics_icon
+end
+
+---@param node table
+---@return HighlightedString|nil icon
+function Builder:_get_modified_icon(node)
+  local modified_icon = modified.get_icon(node)
+  if modified_icon and self.modified_placement == "signcolumn" then
+    table.insert(self.signs, {
+      sign = modified_icon.hl[1],
+      lnum = self.index + 1,
+      priority = 3,
+    })
+    modified_icon = nil
+  end
+  return modified_icon
+end
+
+---@param node table
+---@return HighlightedString[]|nil icon
+function Builder:_get_bookmark_icon(node)
+  local bookmark_icon = bookmarks.get_icon(node)
+  if bookmark_icon and self.bookmarks_placement == "signcolumn" then
+    table.insert(self.signs, {
+      sign = bookmark_icon.hl[1],
+      lnum = self.index + 1,
+      priority = 4,
+    })
+    bookmark_icon = nil
+  end
+  return bookmark_icon
+end
+
+---@param node table
+---@return string|nil icon_hl
+---@return string|nil name_hl
+function Builder:_get_highlight_override(node, unloaded_bufnr)
+  local name_hl, icon_hl
+
+  -- git
+  local git_highlight = git.get_highlight(node)
+  if git_highlight then
+    name_hl = git_highlight
+  end
+
+  -- opened file
+  if self.highlight_opened_files and vim.fn.bufloaded(node.absolute_path) > 0 and vim.fn.bufnr(node.absolute_path) ~= unloaded_bufnr then
+    if self.highlight_opened_files == "all" or self.highlight_opened_files == "name" then
+      name_hl = "NvimTreeOpenedFile"
+    end
+    if self.highlight_opened_files == "all" or self.highlight_opened_files == "icon" then
+      icon_hl = "NvimTreeOpenedFileIcon"
+    end
+  end
+
+  -- modified file
+  local modified_highlight = modified.get_highlight(node)
+  if modified_highlight then
+    if self.highlight_modified == "all" or self.highlight_modified == "name" then
+      name_hl = modified_highlight
+    end
+    if self.highlight_modified == "all" or self.highlight_modified == "icon" then
+      icon_hl = modified_highlight
+    end
+  end
+
+  return icon_hl, name_hl
+end
+
+---Append optional highlighting to icon or name.
+---@param node table
+---@param get_hl fun(node: table): HL_POSITION, string
+---@param icon_hl string[] icons to append to
+---@param name_hl string[] names to append to
+function Builder:_append_highlight(node, get_hl, icon_hl, name_hl)
+  local pos, hl = get_hl(node)
+  if pos ~= HL_POSITION.none and hl then
+    if pos == HL_POSITION.all or pos == HL_POSITION.icon then
+      table.insert(icon_hl, hl)
+    end
+    if pos == HL_POSITION.all or pos == HL_POSITION.name then
+      table.insert(name_hl, hl)
+    end
+  end
 end
 
----@private
 ---@param indent_markers HighlightedString[]
 ---@param arrows HighlightedString[]|nil
 ---@param icon HighlightedString
 ---@param name HighlightedString
----@param node table
+---@param git_icons HighlightedString[]|nil
+---@param diagnostics_icon HighlightedString|nil
+---@param modified_icon HighlightedString|nil
+---@param bookmark_icon HighlightedString|nil
 ---@return HighlightedString[]
-function Builder:format_line(indent_markers, arrows, icon, name, node)
+function Builder:_format_line(indent_markers, arrows, icon, name, git_icons, diagnostics_icon, modified_icon, bookmark_icon)
   local added_len = 0
   local function add_to_end(t1, t2)
-    if not t2 then
-      return
-    end
     for _, v in ipairs(t2) do
       if added_len > 0 then
-        table.insert(t1, { str = self.opts.renderer.icons.padding })
+        table.insert(t1, { str = self.icon_padding })
       end
       table.insert(t1, v)
     end
@@ -238,174 +379,92 @@ function Builder:format_line(indent_markers, arrows, icon, name, node)
 
   local line = { indent_markers, arrows }
   add_to_end(line, { icon })
-
+  if git_icons and self.git_placement == "before" then
-  for i = #self.decorators, 1, -1 do
+    add_to_end(line, git_icons)
-    add_to_end(line, self.decorators[i]:icons_before(node))
+  end
+  if modified_icon and self.modified_placement == "before" then
+    add_to_end(line, { modified_icon })
+  end
+  if diagnostics_icon and self.diagnostics_placement == "before" then
+    add_to_end(line, { diagnostics_icon })
+  end
+  if bookmark_icon and self.bookmarks_placement == "before" then
+    add_to_end(line, { bookmark_icon })
   end
 
   add_to_end(line, { name })
 
-  for i = #self.decorators, 1, -1 do
+  if git_icons and self.git_placement == "after" then
-    add_to_end(line, self.decorators[i]:icons_after(node))
+    add_to_end(line, git_icons)
   end
-
+  if modified_icon and self.modified_placement == "after" then
-  local rights = {}
+    add_to_end(line, { modified_icon })
-  for i = #self.decorators, 1, -1 do
-    add_to_end(rights, self.decorators[i]:icons_right_align(node))
   end
-  if #rights > 0 then
+  if diagnostics_icon and self.diagnostics_placement == "after" then
-    self.extmarks[self.index] = rights
+    add_to_end(line, { diagnostics_icon })
+  end
+  if bookmark_icon and self.bookmarks_placement == "after" then
+    add_to_end(line, { bookmark_icon })
   end
 
   return line
 end
 
----@private
+function Builder:_build_line(node, idx, num_children, unloaded_bufnr)
----@param node Node
+  local copy_paste = require "nvim-tree.actions.fs.copy-paste"
-function Builder:build_signs(node)
-  -- first in priority order
-  local sign_name
-  for _, d in ipairs(self.decorators) do
-    sign_name = d:sign_name(node)
-    if sign_name then
-      self.signs[self.index] = sign_name
-      break
-    end
-  end
-end
 
----Create a highlight group for groups with later groups overriding previous.
----Combined group name is less than the 200 byte limit of highlight group names
----@private
----@param groups string[] highlight group names
----@return string group_name "NvimTreeCombinedHL" .. sha256
-function Builder:create_combined_group(groups)
-  local combined_name = string.format("NvimTreeCombinedHL%s", vim.fn.sha256(table.concat(groups)))
-
-  -- only create if necessary
-  if not self.combined_groups[combined_name] then
-    self.combined_groups[combined_name] = true
-    local combined_hl = {}
-
-    -- build the highlight, overriding values
-    for _, group in ipairs(groups) do
-      local hl = vim.api.nvim_get_hl(0, { name = group, link = false })
-      combined_hl = vim.tbl_extend("force", combined_hl, hl)
-    end
-
-    -- add highlights to the global namespace
-    vim.api.nvim_set_hl(0, combined_name, combined_hl)
-
-    table.insert(self.combined_groups, combined_name)
-  end
-
-  return combined_name
-end
-
----Calculate highlight group for icon and name. A combined highlight group will be created
----when there is more than one highlight.
----A highlight group is always calculated and upserted for the case of highlights changing.
----@private
----@param node Node
----@return string|nil icon_hl_group
----@return string|nil name_hl_group
-function Builder:add_highlights(node)
-  -- result
-  local icon_hl_group, name_hl_group
-
-  -- calculate all groups
-  local icon_groups = {}
-  local name_groups = {}
-  local d, icon, name
-  for i = #self.decorators, 1, -1 do
-    d = self.decorators[i]
-    icon, name = d:groups_icon_name(node)
-    table.insert(icon_groups, icon)
-    table.insert(name_groups, name)
-  end
-
-  -- one or many icon groups
-  if #icon_groups > 1 then
-    icon_hl_group = self:create_combined_group(icon_groups)
-  else
-    icon_hl_group = icon_groups[1]
-  end
-
-  -- one or many name groups
-  if #name_groups > 1 then
-    name_hl_group = self:create_combined_group(name_groups)
-  else
-    name_hl_group = name_groups[1]
-  end
-
-  return icon_hl_group, name_hl_group
-end
-
----@private
-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)
 
+  -- adds icons to signcolumn
+  local bookmark_icon = self:_get_bookmark_icon(node)
+  local git_icons = self:_get_git_icons(node)
+  local modified_icon = self:_get_modified_icon(node)
+  local diagnostics_icon = self:_get_diagnostics_icon(node)
+
   -- main components
   local is_folder = node.nodes ~= nil
   local is_symlink = node.link_to ~= nil
   local icon, name
   if is_folder then
-    icon, name = self:build_folder(node)
+    icon, name = self:_build_folder(node)
   elseif is_symlink then
-    icon, name = self:build_symlink(node)
+    icon, name = self:_build_symlink(node)
   else
-    icon, name = self:build_file(node)
+    icon, name = self:_build_file(node)
   end
 
-  -- highighting
+  -- highlight override
-  local icon_hl_group, name_hl_group = self:add_highlights(node)
+  local icon_hl_override, name_hl_override = self:_get_highlight_override(node, unloaded_bufnr)
-  table.insert(icon.hl, icon_hl_group)
+  if icon_hl_override then
-  table.insert(name.hl, name_hl_group)
+    icon.hl = { icon_hl_override }
+  end
+  if name_hl_override then
+    name.hl = { name_hl_override }
+  end
 
-  local line = self:format_line(indent_markers, arrows, icon, name, node)
+  -- extra highighting
-  table.insert(self.lines, self:unwrap_highlighted_strings(line))
+  self:_append_highlight(node, bookmarks.get_highlight, icon.hl, name.hl)
+  self:_append_highlight(node, diagnostics.get_highlight, icon.hl, name.hl)
+  self:_append_highlight(node, copy_paste.get_highlight, icon.hl, name.hl)
+
+  local line = self:_format_line(indent_markers, arrows, icon, name, git_icons, diagnostics_icon, modified_icon, bookmark_icon)
+  self:_insert_line(self:_unwrap_highlighted_strings(line))
 
   self.index = self.index + 1
 
   node = require("nvim-tree.lib").get_last_group_node(node)
+
   if node.open then
     self.depth = self.depth + 1
-    self:build_lines(node)
+    self:build(node, unloaded_bufnr)
     self.depth = self.depth - 1
   end
 end
 
----Add virtual lines for rendering hidden count information per node
+function Builder:_get_nodes_number(nodes)
----@private
+  if not self.filter then
-function Builder:add_hidden_count_string(node, idx, num_children)
-  if not node.open then
-    return
-  end
-  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 = self.opts.renderer.indent_width
-
-    local indent_padding = string.rep(" ", indent_width)
-    local indent_string = indent_padding .. indent_markers.str
-    local line_nr = #self.lines - 1
-    self.virtual_lines[line_nr] = self.virtual_lines[line_nr] or {}
-
-    -- NOTE: We are inserting in depth order because of current traversal
-    -- 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 },
-      { string.rep(indent_padding, (node.parent == nil and 0 or 1)) .. hidden_count_string, "NvimTreeHiddenDisplay" },
-    })
-  end
-end
-
----@private
-function Builder:get_nodes_number(nodes)
-  if not self.explorer.live_filter.filter then
     return #nodes
   end
 
@@ -418,116 +477,53 @@ function Builder:get_nodes_number(nodes)
   return i
 end
 
----@private
+function Builder:build(tree, unloaded_bufnr)
-function Builder:build_lines(node)
+  local num_children = self:_get_nodes_number(tree.nodes)
-  if not node then
-    node = self.explorer
-  end
-  local num_children = self:get_nodes_number(node.nodes)
   local idx = 1
-  for _, n in ipairs(node.nodes) do
+  for _, node in ipairs(tree.nodes) do
-    if not n.hidden then
+    if not node.hidden then
-      self:build_signs(n)
+      self:_build_line(node, idx, num_children, unloaded_bufnr)
-      self:build_line(n, idx, num_children)
       idx = idx + 1
     end
   end
-  self:add_hidden_count_string(node)
-end
 
----@private
----@param root_label function|string
----@return string
-function Builder:format_root_name(root_label)
-  if type(root_label) == "function" then
-    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.explorer.absolute_path, root_label))
-  end
-  return "???"
-end
-
----@private
-function Builder:build_header()
-  if view.is_root_folder_visible(self.explorer.absolute_path) then
-    local root_name = self:format_root_name(self.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 self.explorer.live_filter.filter then
-    local filter_line = string.format("%s/%s/", self.opts.live_filter.prefix, self.explorer.live_filter.filter)
-    table.insert(self.lines, filter_line)
-    local prefix_length = string.len(self.opts.live_filter.prefix)
-    self:insert_highlight({ "NvimTreeLiveFilterPrefix" }, 0, prefix_length)
-    self:insert_highlight({ "NvimTreeLiveFilterValue" }, prefix_length, string.len(filter_line))
-    self.index = self.index + 1
-  end
-end
-
----Sanitize lines for rendering.
----Replace newlines with literal \n
----@private
-function Builder:sanitize_lines()
-  self.lines = vim.tbl_map(function(line)
-    return line and line:gsub("\n", "\\n") or ""
-  end, self.lines)
-end
-
----Build all lines with highlights and signs
----@return Builder
-function Builder:build()
-  self:build_header()
-  self:build_lines()
-  self:sanitize_lines()
   return self
 end
 
----TODO refactor back to function; this was left here to reduce PR noise
+local function format_root_name(root_cwd, root_label)
----@param opts table
+  if type(root_label) == "function" then
----@return fun(node: Node): string|nil
+    local label = root_label(root_cwd)
-function Builder:setup_hidden_display_function(opts)
+    if type(label) == "string" then
-  local hidden_display = opts.renderer.hidden_display
+      return label
-  -- options are already validated, so ´hidden_display´ can ONLY be `string` or `function` if type(hidden_display) == "string" then
+    else
-  if type(hidden_display) == "string" then
+      root_label = DEFAULT_ROOT_FOLDER_LABEL
-    if hidden_display == "none" then
-      return function()
-        return nil
-      end
-    elseif hidden_display == "simple" then
-      return function(hidden_stats)
-        return utils.default_format_hidden_count(hidden_stats, true)
-      end
-    else -- "all"
-      return function(hidden_stats)
-        return utils.default_format_hidden_count(hidden_stats, false)
-      end
-    end
-  else -- "function
-    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,
-        buf = 0,
-        dotfile = 0,
-        custom = 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")
-        return nil
-      end
-      return result
     end
   end
+  return utils.path_remove_trailing(vim.fn.fnamemodify(root_cwd, root_label))
+end
+
+function Builder:build_header(show_header)
+  if show_header then
+    local root_name = format_root_name(self.root_cwd, self.root_folder_label)
+    self:_insert_line(root_name)
+    self:_insert_highlight({ "NvimTreeRootFolder" }, 0, string.len(root_name))
+    self.index = 1
+  end
+
+  if self.filter then
+    local filter_line = self.filter_prefix .. "/" .. self.filter .. "/"
+    self:_insert_line(filter_line)
+    local prefix_length = string.len(self.filter_prefix)
+    self:_insert_highlight({ "NvimTreeLiveFilterPrefix" }, 0, prefix_length)
+    self:_insert_highlight({ "NvimTreeLiveFilterValue" }, prefix_length, string.len(filter_line))
+    self.index = self.index + 1
+  end
+
+  return self
+end
+
+function Builder:unwrap()
+  return self.lines, self.highlights, self.signs
 end
 
 return Builder

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

@@ -0,0 +1,51 @@
+local marks = require "nvim-tree.marks"
+
+local HL_POSITION = require("nvim-tree.enum").HL_POSITION
+
+local M = {
+  ICON = {},
+  hl_pos = HL_POSITION.none,
+}
+
+---Bookmark highlight group and position when highlight_bookmark.
+---@param node table
+---@return HL_POSITION position none when clipboard empty
+---@return string|nil group only when node present in clipboard
+function M.get_highlight(node)
+  if M.hl_pos == HL_POSITION.none then
+    return HL_POSITION.none, nil
+  end
+
+  local mark = marks.get_mark(node)
+  if mark then
+    return M.hl_pos, "NvimTreeBookmarkHL"
+  else
+    return HL_POSITION.none, nil
+  end
+end
+
+---bookmark icon if marked
+---@param node table
+---@return HighlightedString|nil bookmark icon
+function M.get_icon(node)
+  if M.config.renderer.icons.show.bookmarks and marks.get_mark(node) then
+    return M.ICON
+  end
+end
+
+function M.setup(opts)
+  M.config = {
+    renderer = opts.renderer,
+  }
+
+  M.hl_pos = HL_POSITION[opts.renderer.highlight_bookmarks] or HL_POSITION.none
+
+  M.ICON = {
+    str = opts.renderer.icons.glyphs.bookmark,
+    hl = { "NvimTreeBookmark" },
+  }
+
+  vim.fn.sign_define(M.ICON.hl[1], { text = M.ICON.str, texthl = M.ICON.hl[1] })
+end
+
+return M

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

@@ -1,37 +1,30 @@
 local HL_POSITION = require("nvim-tree.enum").HL_POSITION
-local diagnostics = require("nvim-tree.diagnostics")
 
 local M = {
-  -- highlight strings for the icons
+  HS_FILE = {},
-  HS_ICON = {},
+  HS_FOLDER = {},
-
+  ICON = {},
-  -- highlight groups for HL
+  hl_pos = HL_POSITION.none,
-  HG_FILE = {},
-  HG_FOLDER = {},
-
-  -- position for HL
-  HL_POS = HL_POSITION.none,
 }
 
----Diagnostics highlight group and position when highlight_diagnostics.
+---Diagnostics text highlight group 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
+  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]
+    group = M.HS_FOLDER[node.diag_status]
   else
-    group = M.HS_FILE[diag_status and diag_status.value]
+    group = M.HS_FILE[node.diag_status]
   end
 
   if group then
-    return M.HL_POS, group
+    return M.hl_pos, group
   else
     return HL_POSITION.none, nil
   end
@@ -42,8 +35,7 @@ end
 ---@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[node.diag_status]
-    return M.ICON[diag_status and diag_status.value]
   end
 end
 
@@ -54,38 +46,40 @@ function M.setup(opts)
   }
 
   if opts.diagnostics.enable and opts.renderer.highlight_diagnostics then
-    M.HL_POS = HL_POSITION[opts.renderer.highlight_diagnostics]
+    -- TODO add a HL_POSITION
+    -- M.hl_pos = HL_POSITION[opts.renderer.highlight_diagnostics]
+    M.hl_pos = HL_POSITION.name
   end
 
-  M.HG_FILE[vim.diagnostic.severity.ERROR] = "NvimTreeDiagnosticErrorFileHL"
+  M.HS_FILE[vim.diagnostic.severity.ERROR] = "NvimTreeLspDiagnosticsErrorText"
-  M.HG_FILE[vim.diagnostic.severity.WARN] = "NvimTreeDiagnosticWarningFileHL"
+  M.HS_FILE[vim.diagnostic.severity.WARN] = "NvimTreeLspDiagnosticsWarningText"
-  M.HG_FILE[vim.diagnostic.severity.INFO] = "NvimTreeDiagnosticInfoFileHL"
+  M.HS_FILE[vim.diagnostic.severity.INFO] = "NvimTreeLspDiagnosticsInfoText"
-  M.HG_FILE[vim.diagnostic.severity.HINT] = "NvimTreeDiagnosticHintFileHL"
+  M.HS_FILE[vim.diagnostic.severity.HINT] = "NvimTreeLspDiagnosticsHintText"
 
-  M.HG_FOLDER[vim.diagnostic.severity.ERROR] = "NvimTreeDiagnosticErrorFolderHL"
+  M.HS_FOLDER[vim.diagnostic.severity.ERROR] = "NvimTreeLspDiagnosticsErrorFolderText"
-  M.HG_FOLDER[vim.diagnostic.severity.WARN] = "NvimTreeDiagnosticWarningFolderHL"
+  M.HS_FOLDER[vim.diagnostic.severity.WARN] = "NvimTreeLspDiagnosticsWarningFolderText"
-  M.HG_FOLDER[vim.diagnostic.severity.INFO] = "NvimTreeDiagnosticInfoFolderHL"
+  M.HS_FOLDER[vim.diagnostic.severity.INFO] = "NvimTreeLspDiagnosticsInfoFolderText"
-  M.HG_FOLDER[vim.diagnostic.severity.HINT] = "NvimTreeDiagnosticHintFolderHL"
+  M.HS_FOLDER[vim.diagnostic.severity.HINT] = "NvimTreeLspDiagnosticsHintFolderText"
 
-  M.HS_ICON[vim.diagnostic.severity.ERROR] = {
+  M.ICON[vim.diagnostic.severity.ERROR] = {
     str = M.config.diagnostics.icons.error,
-    hl = { "NvimTreeDiagnosticErrorIcon" },
+    hl = { "NvimTreeLspDiagnosticsError" },
   }
 
-  M.HS_ICON[vim.diagnostic.severity.WARN] = {
+  M.ICON[vim.diagnostic.severity.WARN] = {
     str = M.config.diagnostics.icons.warning,
-    hl = { "NvimTreeDiagnosticWarningIcon" },
+    hl = { "NvimTreeLspDiagnosticsWarning" },
   }
-  M.HS_ICON[vim.diagnostic.severity.INFO] = {
+  M.ICON[vim.diagnostic.severity.INFO] = {
     str = M.config.diagnostics.icons.info,
-    hl = { "NvimTreeDiagnosticInfoIcon" },
+    hl = { "NvimTreeLspDiagnosticsInformation" },
   }
-  M.HS_ICON[vim.diagnostic.severity.HINT] = {
+  M.ICON[vim.diagnostic.severity.HINT] = {
     str = M.config.diagnostics.icons.hint,
-    hl = { "NvimTreeDiagnosticHintIcon" },
+    hl = { "NvimTreeLspDiagnosticsHint" },
   }
 
-  for _, i in ipairs(M.HS_ICON) do
+  for _, i in ipairs(M.ICON) do
     vim.fn.sign_define(i.hl[1], { text = i.str, texthl = i.hl[1] })
   end
 end

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,9 +57,9 @@ local function show()
   end
 
   M.popup_win = vim.api.nvim_open_win(vim.api.nvim_create_buf(false, false), false, {
-    relative = "win",
+    relative = "cursor",
     row = 0,
-    bufpos = { vim.api.nvim_win_get_cursor(0)[1] - 1, 0 },
+    col = 1 - vim.fn.getcursorcharpos()[3],
     width = math.min(text_width, vim.o.columns - 2),
     height = 1,
     noautocmd = true,
@@ -67,21 +67,14 @@ local function show()
   })
 
   local ns_id = vim.api.nvim_get_namespaces()["NvimTreeHighlights"]
-  local extmarks = vim.api.nvim_buf_get_extmarks(0, ns_id, { line_nr - 1, 0 }, { line_nr - 1, -1 }, { details = true })
+  local extmarks = vim.api.nvim_buf_get_extmarks(0, ns_id, { line_nr - 1, 0 }, { line_nr - 1, -1 }, { details = 1 })
   vim.api.nvim_win_call(M.popup_win, function()
     vim.api.nvim_buf_set_lines(0, 0, -1, true, { line })
     for _, extmark in ipairs(extmarks) do
-      -- nvim 0.10 luadoc is incorrect: vim.api.keyset.get_extmark_item is missing the extmark_id at the start
+      local hl = extmark[4]
-
+      vim.api.nvim_buf_add_highlight(0, ns_id, hl.hl_group, 0, extmark[3], hl.end_col)
-      ---@cast extmark table
-      ---@type integer
-      local col = extmark[3]
-      ---@type vim.api.keyset.extmark_details
-      local details = extmark[4]
-
-      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/git.lua

@@ -0,0 +1,191 @@
+local notify = require "nvim-tree.notify"
+local explorer_node = require "nvim-tree.explorer.node"
+
+local M = {}
+
+local function build_icons_table(i)
+  local icons = {
+    staged = { str = i.staged, hl = { "NvimTreeGitStaged" }, ord = 1 },
+    unstaged = { str = i.unstaged, hl = { "NvimTreeGitDirty" }, ord = 2 },
+    renamed = { str = i.renamed, hl = { "NvimTreeGitRenamed" }, ord = 3 },
+    deleted = { str = i.deleted, hl = { "NvimTreeGitDeleted" }, ord = 4 },
+    unmerged = { str = i.unmerged, hl = { "NvimTreeGitMerge" }, ord = 5 },
+    untracked = { str = i.untracked, hl = { "NvimTreeGitNew" }, ord = 6 },
+    ignored = { str = i.ignored, hl = { "NvimTreeGitIgnored" }, ord = 7 },
+  }
+  return {
+    ["M "] = { icons.staged },
+    [" M"] = { icons.unstaged },
+    ["C "] = { icons.staged },
+    [" C"] = { icons.unstaged },
+    ["CM"] = { icons.unstaged },
+    [" T"] = { icons.unstaged },
+    ["T "] = { icons.staged },
+    ["TM"] = { icons.staged, icons.unstaged },
+    ["MM"] = { icons.staged, icons.unstaged },
+    ["MD"] = { icons.staged },
+    ["A "] = { icons.staged },
+    ["AD"] = { icons.staged },
+    [" A"] = { icons.untracked },
+    -- not sure about this one
+    ["AA"] = { icons.unmerged, icons.untracked },
+    ["AU"] = { icons.unmerged, icons.untracked },
+    ["AM"] = { icons.staged, icons.unstaged },
+    ["??"] = { icons.untracked },
+    ["R "] = { icons.renamed },
+    [" R"] = { icons.renamed },
+    ["RM"] = { icons.unstaged, icons.renamed },
+    ["UU"] = { icons.unmerged },
+    ["UD"] = { icons.unmerged },
+    ["UA"] = { icons.unmerged },
+    [" D"] = { icons.deleted },
+    ["D "] = { icons.deleted },
+    ["DA"] = { icons.unstaged },
+    ["RD"] = { icons.deleted },
+    ["DD"] = { icons.deleted },
+    ["DU"] = { icons.deleted, icons.unmerged },
+    ["!!"] = { icons.ignored },
+    dirty = { icons.unstaged },
+  }
+end
+
+local function build_hl_table()
+  local file = {
+    ["M "] = "NvimTreeFileStaged",
+    ["C "] = "NvimTreeFileStaged",
+    ["AA"] = "NvimTreeFileStaged",
+    ["AD"] = "NvimTreeFileStaged",
+    ["MD"] = "NvimTreeFileStaged",
+    ["T "] = "NvimTreeFileStaged",
+    ["TT"] = "NvimTreeFileStaged",
+    [" M"] = "NvimTreeFileDirty",
+    ["CM"] = "NvimTreeFileDirty",
+    [" C"] = "NvimTreeFileDirty",
+    [" T"] = "NvimTreeFileDirty",
+    ["MM"] = "NvimTreeFileDirty",
+    ["AM"] = "NvimTreeFileDirty",
+    dirty = "NvimTreeFileDirty",
+    ["A "] = "NvimTreeFileStaged",
+    ["??"] = "NvimTreeFileNew",
+    ["AU"] = "NvimTreeFileMerge",
+    ["UU"] = "NvimTreeFileMerge",
+    ["UD"] = "NvimTreeFileMerge",
+    ["DU"] = "NvimTreeFileMerge",
+    ["UA"] = "NvimTreeFileMerge",
+    [" D"] = "NvimTreeFileDeleted",
+    ["DD"] = "NvimTreeFileDeleted",
+    ["RD"] = "NvimTreeFileDeleted",
+    ["D "] = "NvimTreeFileDeleted",
+    ["R "] = "NvimTreeFileRenamed",
+    ["RM"] = "NvimTreeFileRenamed",
+    [" R"] = "NvimTreeFileRenamed",
+    ["!!"] = "NvimTreeFileIgnored",
+    [" A"] = "none",
+  }
+
+  local folder = {}
+  for k, v in pairs(file) do
+    folder[k] = v:gsub("File", "Folder")
+  end
+
+  return file, folder
+end
+
+local function nil_() end
+
+local function warn_status(git_status)
+  notify.warn(string.format("Unrecognized git state '%s'", git_status))
+end
+
+---@param node table
+---@return HighlightedString[]|nil
+local function get_icons_(node)
+  local git_status = explorer_node.get_git_status(node)
+  if git_status == nil then
+    return nil
+  end
+
+  local inserted = {}
+  local iconss = {}
+
+  for _, s in pairs(git_status) do
+    local icons = M.git_icons[s]
+    if not icons then
+      if not M.config.highlight_git then
+        warn_status(s)
+      end
+      return nil
+    end
+
+    for _, icon in pairs(icons) do
+      if #icon.str > 0 then
+        if not inserted[icon] then
+          table.insert(iconss, icon)
+          inserted[icon] = true
+        end
+      end
+    end
+  end
+
+  if #iconss == 0 then
+    return nil
+  end
+
+  -- sort icons so it looks slightly better
+  table.sort(iconss, function(a, b)
+    return a.ord < b.ord
+  end)
+
+  return iconss
+end
+
+function M.setup_signs(i)
+  vim.fn.sign_define("NvimTreeGitDirty", { text = i.unstaged, texthl = "NvimTreeGitDirty" })
+  vim.fn.sign_define("NvimTreeGitStaged", { text = i.staged, texthl = "NvimTreeGitStaged" })
+  vim.fn.sign_define("NvimTreeGitMerge", { text = i.unmerged, texthl = "NvimTreeGitMerge" })
+  vim.fn.sign_define("NvimTreeGitRenamed", { text = i.renamed, texthl = "NvimTreeGitRenamed" })
+  vim.fn.sign_define("NvimTreeGitNew", { text = i.untracked, texthl = "NvimTreeGitNew" })
+  vim.fn.sign_define("NvimTreeGitDeleted", { text = i.deleted, texthl = "NvimTreeGitDeleted" })
+  vim.fn.sign_define("NvimTreeGitIgnored", { text = i.ignored, texthl = "NvimTreeGitIgnored" })
+end
+
+local function get_highlight_(node)
+  local git_status = explorer_node.get_git_status(node)
+  if git_status == nil then
+    return
+  end
+
+  if node.nodes then
+    return M.folder_hl[git_status[1]]
+  else
+    return M.file_hl[git_status[1]]
+  end
+end
+
+function M.setup(opts)
+  M.config = opts.renderer
+
+  M.git_icons = build_icons_table(opts.renderer.icons.glyphs.git)
+
+  M.file_hl, M.folder_hl = build_hl_table()
+
+  if opts.renderer.icons.git_placement == "signcolumn" then
+    M.setup_signs(opts.renderer.icons.glyphs.git)
+  end
+
+  if opts.renderer.icons.show.git then
+    M.get_icons = get_icons_
+  else
+    M.get_icons = nil_
+  end
+
+  if opts.renderer.highlight_git then
+    M.get_highlight = get_highlight_
+  else
+    M.get_highlight = nil_
+  end
+
+  M.git_show_on_open_dirs = opts.git.show_on_open_dirs
+end
+
+return M

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

@@ -65,12 +65,7 @@ local function get_file_icon_webdev(fname, extension)
     -- 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()
+    return get_file_icon_default()
-    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
 
@@ -107,7 +102,7 @@ end
 function M.setup(opts)
   M.config = opts.renderer.icons
 
-  M.devicons = pcall(require, "nvim-web-devicons") and require("nvim-web-devicons") or nil
+  M.devicons = pcall(require, "nvim-web-devicons") and require "nvim-web-devicons" or nil
 end
 
 return M

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

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

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

@@ -0,0 +1,41 @@
+local modified = require "nvim-tree.modified"
+
+local M = {}
+
+local HIGHLIGHT = "NvimTreeModifiedFile"
+
+---return modified icon if node is modified, otherwise return empty string
+---@param node table
+---@return HighlightedString|nil modified icon
+function M.get_icon(node)
+  if not modified.is_modified(node) or not M.show_icon then
+    return nil
+  end
+
+  return { str = M.icon, hl = { HIGHLIGHT } }
+end
+
+function M.setup_signs()
+  vim.fn.sign_define(HIGHLIGHT, { text = M.icon, texthl = HIGHLIGHT })
+end
+
+---@param node table
+---@return string|nil
+function M.get_highlight(node)
+  if not modified.is_modified(node) then
+    return nil
+  end
+
+  return HIGHLIGHT
+end
+
+function M.setup(opts)
+  M.icon = opts.renderer.icons.glyphs.modified
+  M.show_icon = opts.renderer.icons.show.modified
+
+  if opts.renderer.icons.modified_placement == "signcolumn" then
+    M.setup_signs()
+  end
+end
+
+return M

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

@@ -19,7 +19,7 @@ local function check_siblings_for_folder(node, with_arrows)
   return false
 end
 
-local function get_padding_indent_markers(depth, idx, nodes_number, markers, with_arrows, inline_arrows, node, early_stop)
+local function get_padding_indent_markers(depth, idx, nodes_number, markers, with_arrows, inline_arrows, node)
   local base_padding = with_arrows and (not node.nodes or depth > 0) and "  " or ""
   local padding = (inline_arrows or depth == 0) and base_padding or ""
 
@@ -27,7 +27,7 @@ local function get_padding_indent_markers(depth, idx, nodes_number, markers, wit
     local has_folder_sibling = check_siblings_for_folder(node, with_arrows)
     local indent = string.rep(" ", M.config.indent_width - 1)
     markers[depth] = idx ~= nodes_number
-    for i = 1, depth - early_stop do
+    for i = 1, depth do
       local glyph
       if idx == nodes_number and i == depth then
         local bottom_width = M.config.indent_width - 2 + (with_arrows and not inline_arrows and has_folder_sibling and 2 or 0)
@@ -62,7 +62,7 @@ end
 ---@param node table
 ---@param markers table
 ---@return HighlightedString[]
-function M.get_indent_markers(depth, idx, nodes_number, node, markers, early_stop)
+function M.get_indent_markers(depth, idx, nodes_number, node, markers)
   local str = ""
 
   local show_arrows = M.config.icons.show.folder_arrow
@@ -71,7 +71,7 @@ function M.get_indent_markers(depth, idx, nodes_number, node, markers, early_sto
   local indent_width = M.config.indent_width
 
   if show_markers then
-    str = str .. get_padding_indent_markers(depth, idx, nodes_number, markers, show_arrows, inline_arrows, node, early_stop or 0)
+    str = str .. get_padding_indent_markers(depth, idx, nodes_number, markers, show_arrows, inline_arrows, node)
   else
     str = str .. string.rep(" ", depth * indent_width)
   end
@@ -117,7 +117,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,51 +0,0 @@
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
-
-local Decorator = require("nvim-tree.renderer.decorator")
-
----@class (exact) DecoratorBookmarks: Decorator
----@field icon HighlightedString
-local DecoratorBookmarks = Decorator:new()
-
----@param opts table
----@param explorer Explorer
----@return DecoratorBookmarks
-function DecoratorBookmarks:new(opts, explorer)
-  local o = Decorator.new(self, {
-    explorer = explorer,
-    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
-    o.icon = {
-      str = opts.renderer.icons.glyphs.bookmark,
-      hl = { "NvimTreeBookmarkIcon" },
-    }
-    o:define_sign(o.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 self.explorer.marks:get(node) then
-    return { self.icon }
-  end
-end
-
----Bookmark highlight: renderer.highlight_bookmarks and node is marked
----@param node Node
----@return string|nil group
-function DecoratorBookmarks:calculate_highlight(node)
-  if self.hl_pos ~= HL_POSITION.none and self.explorer.marks:get(node) then
-    return "NvimTreeBookmarkHL"
-  end
-end
-
-return DecoratorBookmarks

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

@@ -1,35 +0,0 @@
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
-
-local Decorator = require("nvim-tree.renderer.decorator")
-
----@class (exact) DecoratorCopied: Decorator
----@field enabled boolean
----@field icon HighlightedString|nil
-local DecoratorCopied = Decorator:new()
-
----@param opts table
----@param explorer Explorer
----@return DecoratorCopied
-function DecoratorCopied:new(opts, explorer)
-  local o = Decorator.new(self, {
-    explorer = explorer,
-    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 self.explorer.clipboard:is_copied(node) then
-    return "NvimTreeCopiedHL"
-  end
-end
-
-return DecoratorCopied

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

@@ -1,35 +0,0 @@
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
-
-local Decorator = require("nvim-tree.renderer.decorator")
-
----@class (exact) DecoratorCut: Decorator
----@field enabled boolean
----@field icon HighlightedString|nil
-local DecoratorCut = Decorator:new()
-
----@param opts table
----@param explorer Explorer
----@return DecoratorCut
-function DecoratorCut:new(opts, explorer)
-  local o = Decorator.new(self, {
-    explorer = explorer,
-    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 self.explorer.clipboard:is_cut(node) then
-    return "NvimTreeCutHL"
-  end
-end
-
-return DecoratorCut

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

@@ -1,112 +0,0 @@
-local diagnostics = require("nvim-tree.diagnostics")
-
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
-
-local Decorator = require("nvim-tree.renderer.decorator")
-
--- highlight groups by severity
-local HG_ICON = {
-  [vim.diagnostic.severity.ERROR] = "NvimTreeDiagnosticErrorIcon",
-  [vim.diagnostic.severity.WARN] = "NvimTreeDiagnosticWarnIcon",
-  [vim.diagnostic.severity.INFO] = "NvimTreeDiagnosticInfoIcon",
-  [vim.diagnostic.severity.HINT] = "NvimTreeDiagnosticHintIcon",
-}
-local HG_FILE = {
-  [vim.diagnostic.severity.ERROR] = "NvimTreeDiagnosticErrorFileHL",
-  [vim.diagnostic.severity.WARN] = "NvimTreeDiagnosticWarnFileHL",
-  [vim.diagnostic.severity.INFO] = "NvimTreeDiagnosticInfoFileHL",
-  [vim.diagnostic.severity.HINT] = "NvimTreeDiagnosticHintFileHL",
-}
-local HG_FOLDER = {
-  [vim.diagnostic.severity.ERROR] = "NvimTreeDiagnosticErrorFolderHL",
-  [vim.diagnostic.severity.WARN] = "NvimTreeDiagnosticWarnFolderHL",
-  [vim.diagnostic.severity.INFO] = "NvimTreeDiagnosticInfoFolderHL",
-  [vim.diagnostic.severity.HINT] = "NvimTreeDiagnosticHintFolderHL",
-}
--- opts.diagnostics.icons.
-local ICON_KEYS = {
-  ["error"] = vim.diagnostic.severity.ERROR,
-  ["warning"] = vim.diagnostic.severity.WARN,
-  ["info"] = vim.diagnostic.severity.INFO,
-  ["hint"] = vim.diagnostic.severity.HINT,
-}
-
----@class (exact) DecoratorDiagnostics: Decorator
----@field icons HighlightedString[]
-local DecoratorDiagnostics = Decorator:new()
-
----@param opts table
----@param explorer Explorer
----@return DecoratorDiagnostics
-function DecoratorDiagnostics:new(opts, explorer)
-  local o = Decorator.new(self, {
-    explorer = explorer,
-    enabled = opts.diagnostics.enable,
-    hl_pos = HL_POSITION[opts.renderer.highlight_diagnostics] or HL_POSITION.none,
-    icon_placement = ICON_PLACEMENT[opts.renderer.icons.diagnostics_placement] or ICON_PLACEMENT.none,
-  })
-  ---@cast o DecoratorDiagnostics
-
-  if not o.enabled then
-    return o
-  end
-
-  if opts.renderer.icons.show.diagnostics then
-    o.icons = {}
-    for name, sev in pairs(ICON_KEYS) do
-      o.icons[sev] = {
-        str = opts.diagnostics.icons[name],
-        hl = { HG_ICON[sev] },
-      }
-      o:define_sign(o.icons[sev])
-    end
-  end
-
-  return o
-end
-
----Diagnostic icon: diagnostics.enable, renderer.icons.show.diagnostics and node has status
----@param node Node
----@return HighlightedString[]|nil icons
-function DecoratorDiagnostics:calculate_icons(node)
-  if node and self.enabled and self.icons then
-    local diag_status = diagnostics.get_diag_status(node)
-    local diag_value = diag_status and diag_status.value
-
-    if diag_value then
-      return { self.icons[diag_value] }
-    end
-  end
-end
-
----Diagnostic highlight: diagnostics.enable, renderer.highlight_diagnostics and node has status
----@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
-    return nil
-  end
-
-  local diag_status = diagnostics.get_diag_status(node)
-  local diag_value = diag_status and diag_status.value
-
-  if not diag_value then
-    return nil
-  end
-
-  local group
-  if node.nodes then
-    group = HG_FOLDER[diag_value]
-  else
-    group = HG_FILE[diag_value]
-  end
-
-  if group then
-    return group
-  else
-    return nil
-  end
-end
-
-return DecoratorDiagnostics

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

@@ -1,223 +0,0 @@
-local notify = require("nvim-tree.notify")
-local explorer_node = require("nvim-tree.explorer.node")
-
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
-local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
-
-local Decorator = require("nvim-tree.renderer.decorator")
-
----@class HighlightedStringGit: HighlightedString
----@field ord number decreasing priority
-
----@class (exact) DecoratorGit: Decorator
----@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
----@param explorer Explorer
----@return DecoratorGit
-function DecoratorGit:new(opts, explorer)
-  local o = Decorator.new(self, {
-    explorer = explorer,
-    enabled = opts.git.enable,
-    hl_pos = HL_POSITION[opts.renderer.highlight_git] or HL_POSITION.none,
-    icon_placement = ICON_PLACEMENT[opts.renderer.icons.git_placement] or ICON_PLACEMENT.none,
-  })
-  ---@cast o DecoratorGit
-
-  if not o.enabled then
-    return o
-  end
-
-  if o.hl_pos ~= HL_POSITION.none then
-    o:build_hl_table()
-  end
-
-  if opts.renderer.icons.show.git then
-    o:build_icons_by_status(opts.renderer.icons.glyphs.git)
-    o:build_icons_by_xy(o.icons_by_status)
-
-    for _, icon in pairs(o.icons_by_status) do
-      self:define_sign(icon)
-    end
-  end
-
-  return o
-end
-
----@param glyphs table<string, string> user glyps
-function DecoratorGit:build_icons_by_status(glyphs)
-  self.icons_by_status = {
-    staged = { str = glyphs.staged, hl = { "NvimTreeGitStagedIcon" }, ord = 1 },
-    unstaged = { str = glyphs.unstaged, hl = { "NvimTreeGitDirtyIcon" }, ord = 2 },
-    renamed = { str = glyphs.renamed, hl = { "NvimTreeGitRenamedIcon" }, ord = 3 },
-    deleted = { str = glyphs.deleted, hl = { "NvimTreeGitDeletedIcon" }, ord = 4 },
-    unmerged = { str = glyphs.unmerged, hl = { "NvimTreeGitMergeIcon" }, ord = 5 },
-    untracked = { str = glyphs.untracked, hl = { "NvimTreeGitNewIcon" }, ord = 6 },
-    ignored = { str = glyphs.ignored, hl = { "NvimTreeGitIgnoredIcon" }, ord = 7 },
-  }
-end
-
----@param icons HighlightedStringGit[]
-function DecoratorGit:build_icons_by_xy(icons)
-  self.icons_by_xy = {
-    ["M "] = { icons.staged },
-    [" M"] = { icons.unstaged },
-    ["C "] = { icons.staged },
-    [" C"] = { icons.unstaged },
-    ["CM"] = { icons.unstaged },
-    [" T"] = { icons.unstaged },
-    ["T "] = { icons.staged },
-    ["TM"] = { icons.staged, icons.unstaged },
-    ["MM"] = { icons.staged, icons.unstaged },
-    ["MD"] = { icons.staged },
-    ["A "] = { icons.staged },
-    ["AD"] = { icons.staged },
-    [" A"] = { icons.untracked },
-    -- not sure about this one
-    ["AA"] = { icons.unmerged, icons.untracked },
-    ["AU"] = { icons.unmerged, icons.untracked },
-    ["AM"] = { icons.staged, icons.unstaged },
-    ["??"] = { icons.untracked },
-    ["R "] = { icons.renamed },
-    [" R"] = { icons.renamed },
-    ["RM"] = { icons.unstaged, icons.renamed },
-    ["UU"] = { icons.unmerged },
-    ["UD"] = { icons.unmerged },
-    ["UA"] = { icons.unmerged },
-    [" D"] = { icons.deleted },
-    ["D "] = { icons.deleted },
-    ["DA"] = { icons.unstaged },
-    ["RD"] = { icons.deleted },
-    ["DD"] = { icons.deleted },
-    ["DU"] = { icons.deleted, icons.unmerged },
-    ["!!"] = { icons.ignored },
-    dirty = { icons.unstaged },
-  }
-end
-
-function DecoratorGit:build_hl_table()
-  self.file_hl = {
-    ["M "] = "NvimTreeGitFileStagedHL",
-    ["C "] = "NvimTreeGitFileStagedHL",
-    ["AA"] = "NvimTreeGitFileStagedHL",
-    ["AD"] = "NvimTreeGitFileStagedHL",
-    ["MD"] = "NvimTreeGitFileStagedHL",
-    ["T "] = "NvimTreeGitFileStagedHL",
-    ["TT"] = "NvimTreeGitFileStagedHL",
-    [" M"] = "NvimTreeGitFileDirtyHL",
-    ["CM"] = "NvimTreeGitFileDirtyHL",
-    [" C"] = "NvimTreeGitFileDirtyHL",
-    [" T"] = "NvimTreeGitFileDirtyHL",
-    ["MM"] = "NvimTreeGitFileDirtyHL",
-    ["AM"] = "NvimTreeGitFileDirtyHL",
-    dirty = "NvimTreeGitFileDirtyHL",
-    ["A "] = "NvimTreeGitFileStagedHL",
-    ["??"] = "NvimTreeGitFileNewHL",
-    ["AU"] = "NvimTreeGitFileMergeHL",
-    ["UU"] = "NvimTreeGitFileMergeHL",
-    ["UD"] = "NvimTreeGitFileMergeHL",
-    ["DU"] = "NvimTreeGitFileMergeHL",
-    ["UA"] = "NvimTreeGitFileMergeHL",
-    [" D"] = "NvimTreeGitFileDeletedHL",
-    ["DD"] = "NvimTreeGitFileDeletedHL",
-    ["RD"] = "NvimTreeGitFileDeletedHL",
-    ["D "] = "NvimTreeGitFileDeletedHL",
-    ["R "] = "NvimTreeGitFileRenamedHL",
-    ["RM"] = "NvimTreeGitFileRenamedHL",
-    [" R"] = "NvimTreeGitFileRenamedHL",
-    ["!!"] = "NvimTreeGitFileIgnoredHL",
-    [" A"] = "none",
-  }
-
-  self.folder_hl = {}
-  for k, v in pairs(self.file_hl) do
-    self.folder_hl[k] = v:gsub("File", "Folder")
-  end
-end
-
----Git icons: git.enable, renderer.icons.show.git and node has status
----@param node Node
----@return HighlightedString[]|nil modified icon
-function DecoratorGit:calculate_icons(node)
-  if not node or not self.enabled or not self.icons_by_xy then
-    return nil
-  end
-
-  local git_status = explorer_node.get_git_status(node)
-  if git_status == nil then
-    return nil
-  end
-
-  local inserted = {}
-  local iconss = {}
-
-  for _, s in pairs(git_status) do
-    local icons = self.icons_by_xy[s]
-    if not icons then
-      if self.hl_pos == HL_POSITION.none then
-        notify.warn(string.format("Unrecognized git state '%s'", git_status))
-      end
-      return nil
-    end
-
-    for _, icon in pairs(icons) do
-      if #icon.str > 0 then
-        if not inserted[icon] then
-          table.insert(iconss, icon)
-          inserted[icon] = true
-        end
-      end
-    end
-  end
-
-  if #iconss == 0 then
-    return nil
-  end
-
-  -- sort icons so it looks slightly better
-  table.sort(iconss, function(a, b)
-    return a.ord < b.ord
-  end)
-
-  return iconss
-end
-
----Get the first icon as the sign if appropriate
----@param node Node
----@return string|nil name
-function DecoratorGit:sign_name(node)
-  if self.icon_placement ~= ICON_PLACEMENT.signcolumn then
-    return
-  end
-
-  local icons = self:calculate_icons(node)
-  if icons and #icons > 0 then
-    return icons[1].hl[1]
-  end
-end
-
----Git highlight: git.enable, renderer.highlight_git and node has status
----@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
-    return nil
-  end
-
-  local git_status = explorer_node.get_git_status(node)
-  if not git_status then
-    return nil
-  end
-
-  if node.nodes then
-    return self.folder_hl[git_status[1]]
-  else
-    return self.file_hl[git_status[1]]
-  end
-end
-
-return DecoratorGit