chore(master): release nvim-tree 1.3.3 (#2776)

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

.editorconfig

@@ -7,3 +7,6 @@ end_of_line = lf
 [*.lua]
 indent_style = space
 indent_size = 2
+
+[nvim-tree-lua.txt]
+max_line_length = 78

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -13,6 +13,8 @@ body:
         * ensure that nvim-tree is updated to the latest version
 
         If you are experiencing performance issues, please [enable profiling](https://github.com/nvim-tree/nvim-tree.lua#performance-issues) and attach the logs.
+
+        Please note that nvim-tree team members do not have access to nor expertise with Windows. You will need to be an active participant during resolution.
   - type: textarea
     attributes:
       label: "Description"
@@ -36,6 +38,12 @@ body:
       placeholder: "Linux 5.16.11-arch1-1, macOS 11.5, Windows 10"
     validations:
       required: true
+  - type: input
+    attributes:
+      label: "Windows variant"
+      placeholder: "WSL, PowerShell, cygwin, msys"
+    validations:
+      required: false
   - type: input
     attributes:
       label: "nvim-tree version"
@@ -46,14 +54,14 @@ body:
       required: true
   - type: textarea
     attributes:
-      label: "Minimal config"
+      label: "Clean room replication"
       description: "Minimal(!) configuration necessary to reproduce the issue.
 
-        (Right click) save [nvt-min.lua](https://raw.githubusercontent.com/nvim-tree/nvim-tree.lua/master/.github/ISSUE_TEMPLATE/nvt-min.lua) to `/tmp` and run using `nvim -nu /tmp/nvt-min.lua`
+        If not provided it is very unlikely that the nvim-tree team will be able to address your issue.
 
-        If _absolutely_ necessary, add plugins and modify the nvim-tree setup at the indicated lines.
+        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.
 
-        Paste the contents of your `/tmp/nvt-min.lua` here."
+        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)"
       render: lua
     validations:
       required: true

.github/ISSUE_TEMPLATE/nvt-min.lua

@@ -1,3 +1,6 @@
+vim.g.loaded_netrw = 1
+vim.g.loaded_netrwPlugin = 1
+
 vim.cmd [[set runtimepath=$VIMRUNTIME]]
 vim.cmd [[set packpath=/tmp/nvt-min/site]]
 local package_root = "/tmp/nvt-min/site/pack"
@@ -32,3 +35,13 @@ _G.setup = function()
   require("nvim-tree").setup {}
 end
 
+-- UNCOMMENT this block for diagnostics issues, substituting pattern and cmd as appropriate.
+-- Requires diagnostics.enable = true in setup.
+--[[
+vim.api.nvim_create_autocmd("FileType", {
+  pattern = "lua",
+  callback = function()
+    vim.lsp.start { cmd = { "lua-language-server" } }
+  end,
+})
+]]

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    reviewers:
+      - "gegoune"

.github/workflows/ci.yml

@@ -2,34 +2,91 @@ name: CI
 
 on:
   pull_request:
-    branches:
-      - '*'
   push:
-    branches:
-      - master
+    branches: [master]
+  workflow_dispatch:
+
+permissions:
+  contents: read
 
 jobs:
-  luacheck:
-    name: luacheck
+  lint:
     runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
 
-      - name: Prepare
-        run: |
-          sudo apt-get update
-          sudo add-apt-repository universe
-          sudo apt install luarocks -y
-          sudo luarocks install luacheck
-      - name: Run luacheck
-        run: luacheck .
-  stylua:
-    name: stylua
-    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@v2
-      - uses: JohnnyMorganz/stylua-action@v1
+      - uses: actions/checkout@v4
+
+      - uses: leafo/gh-actions-lua@v10
+        with:
+          luaVersion: ${{ matrix.lua_version }}
+
+      - uses: leafo/gh-actions-luarocks@v4
+
+      - run: luarocks install luacheck 1.1.1
+
+      - run: make lint
+
+  style:
+    runs-on: ubuntu-latest
+
+    concurrency:
+      group: ${{ github.workflow }}-${{ matrix.stylua_version }}-${{ github.head_ref || github.ref_name }}
+      cancel-in-progress: true
+
+    strategy:
+      matrix:
+        stylua_version: [ 0.19.1 ]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: stylua
+        uses: JohnnyMorganz/stylua-action@v4
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          version: 0.15.1
-          args: --color always --check lua/
+          version: ${{ matrix.stylua_version }}
+          args: --check lua
+
+      - 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.7.3 ]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: rhysd/action-setup-vim@v1
+        with:
+          neovim: true
+          version: ${{ matrix.nvim_version }}
+
+      - 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.yml

@@ -0,0 +1,37 @@
+name: 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@v5
+        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

@@ -0,0 +1,33 @@
+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
+      - uses: actions/checkout@v4
+      - name: tag major and minor versions
+        if: ${{ steps.release.outputs.release_created }}
+        run: |
+          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 }}.${{ steps.release.outputs.minor }} || true
+          git push origin :v${{ steps.release.outputs.major }} || 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 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 }}
+          git push origin v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}

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

@@ -0,0 +1,19 @@
+name: Semantic Pull Request Subject
+on:
+  pull_request:
+    types:
+      - opened
+      - 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.2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -0,0 +1,2 @@
+/luals-out/
+/luals/

.hooks/pre-commit.sh

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

.luarc.json

@@ -1,19 +1,73 @@
 {
-	"$schema": "https://raw.githubusercontent.com/sumneko/vscode-lua/master/setting/schema.json",
-	"runtime.version" : "Lua 5.1",
-	"diagnostics": {
-		"globals": [
-			"vim"
-		],
-		"disable": [
-			"cast-local-type",
-			"lowercase-global",
-			"missing-parameter",
-			"missing-return",
-			"missing-return-value",
-			"need-check-nil",
-			"param-type-mismatch"
-		]
-	}
+  "$schema": "https://raw.githubusercontent.com/sumneko/vscode-lua/master/setting/schema.json",
+  "runtime.version" : "Lua 5.1",
+  "workspace": {
+    "library": [
+      "$VIMRUNTIME/lua/vim/lsp",
+      "${3rd}/luv/library"
+    ]
+  },
+  "diagnostics": {
+    "libraryFiles": "Disable",
+    "globals": [
+      "vim"
+    ],
+    "neededFileStatus": {
+      "ambiguity-1": "Any",
+      "assign-type-mismatch": "Any",
+      "await-in-sync": "Any",
+      "cast-local-type": "Any",
+      "cast-type-mismatch": "Any",
+      "circle-doc-class": "Any",
+      "close-non-object": "Any",
+      "code-after-break": "Any",
+      "codestyle-check": "None",
+      "count-down-loop": "Any",
+      "deprecated": "Any",
+      "different-requires": "Any",
+      "discard-returns": "Any",
+      "doc-field-no-class": "Any",
+      "duplicate-doc-alias": "Any",
+      "duplicate-doc-field": "Any",
+      "duplicate-doc-param": "Any",
+      "duplicate-index": "Any",
+      "duplicate-set-field": "Any",
+      "empty-block": "Any",
+      "global-in-nil-env": "Any",
+      "lowercase-global": "Any",
+      "missing-parameter": "Any",
+      "missing-return": "Any",
+      "missing-return-value": "Any",
+      "need-check-nil": "Any",
+      "newfield-call": "Any",
+      "newline-call": "Any",
+      "no-unknown": "None",
+      "not-yieldable": "Any",
+      "param-type-mismatch": "Any",
+      "redefined-local": "Any",
+      "redundant-parameter": "Any",
+      "redundant-return": "Any",
+      "redundant-return-value": "Any",
+      "redundant-value": "Any",
+      "return-type-mismatch": "Any",
+      "spell-check": "None",
+      "trailing-space": "Any",
+      "unbalanced-assignments": "Any",
+      "undefined-doc-class": "Any",
+      "undefined-doc-name": "Any",
+      "undefined-doc-param": "Any",
+      "undefined-env-child": "Any",
+      "undefined-field": "None",
+      "undefined-global": "Any",
+      "unknown-cast-variable": "Any",
+      "unknown-diag-code": "Any",
+      "unknown-operator": "Any",
+      "unreachable-code": "Any",
+      "unused-function": "Any",
+      "unused-label": "Any",
+      "unused-local": "Any",
+      "unused-vararg": "Any"
+    }
+  }
 }
 

.release-please-manifest.json

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

.stylua.toml

@@ -1,4 +1,4 @@
-column_width = 120
+column_width = 140
 line_endings = "Unix"
 indent_type = "Spaces"
 indent_width = 2

CHANGELOG.md

@@ -0,0 +1,122 @@
+# Changelog
+
+## [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

@@ -2,32 +2,110 @@
 
 Thank you for contributing.
 
-## Styling and formatting
+See [Development](https://github.com/nvim-tree/nvim-tree.lua/wiki/Development) for environment setup, tips and tools.
 
-Code is formatted using luacheck, and linted using stylua.
-You can install these with:
+# Tools
 
-```bash
-luarocks install luacheck
-cargo install stylua
+Following are used during CI and strongly recommended during local development.
+
+Lint: [luacheck](https://github.com/lunarmodules/luacheck/)
+
+Style: [StyLua](https://github.com/JohnnyMorganz/StyLua)
+
+Language server: [luals](https://luals.github.io)
+
+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
 ```
 
-You can setup the git hooks by running `scripts/setup-hooks.sh`.
+## style
 
-## Adding new actions
+1. Runs stylua using `.stylua.toml` settings
+1. Runs `scripts/doc-comments.sh` to validate annotated documentation
+
+```sh
+make style
+```
+
+You can automatically fix stylua 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
+```
+
+# 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`.
 
-## Documentation
+Once you did, you should run `make help-update`
+
+# 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, see how this is done after `nvim-tree.disable_netrw` in the `nvim-tree-lua.txt` file.
+Documentation for options should also be added to `nvim-tree-opts` in `doc/nvim-tree-lua.txt`
 
-## Pull Request
+## API
 
-Please reference any issues in the description e.g. "resolves #1234".
+When adding or changing API please update :help nvim-tree-api
+
+# 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
+
+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

@@ -0,0 +1,47 @@
+all: lint style check
+
+#
+# mandatory checks
+#
+lint: luacheck
+
+style: stylua style-doc
+
+check: luals
+
+#
+# subtasks
+#
+luacheck:
+	luacheck -q lua
+
+stylua:
+	stylua lua --check
+
+style-doc:
+	scripts/doc-comments.sh
+
+luals:
+	scripts/luals-check.sh
+
+#
+# fixes
+#
+style-fix:
+	stylua 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 stylua style-doc luals style-fix help-update help-check
+

README.md

@@ -2,8 +2,8 @@
 
 [![CI](https://github.com/nvim-tree/nvim-tree.lua/actions/workflows/ci.yml/badge.svg)](https://github.com/nvim-tree/nvim-tree.lua/actions/workflows/ci.yml)
 
-<img align="left" width="149" height="484" src="https://user-images.githubusercontent.com/17254073/195207026-f3434ba1-dc86-4c48-8ab3-b2efc3b85227.png">
-<img align="left" width="149" height="484" src="https://user-images.githubusercontent.com/17254073/195207023-7b709e35-7f10-416b-aafb-5bb61268c7d3.png">
+<img align="left" width="199" height="598" src="https://user-images.githubusercontent.com/1505378/232662694-8dc494e0-24da-497a-8541-29344293378c.png">
+<img align="left" width="199" height="598" src="https://user-images.githubusercontent.com/1505378/232662698-2f321315-c67a-486b-85d8-8c391de52392.png">
 
    Automatic updates
 
@@ -24,47 +24,38 @@
 
 Take a look at the [wiki](https://github.com/nvim-tree/nvim-tree.lua/wiki) for Showcases, Tips, Recipes and more.
 
-[Join us on matrix](https://matrix.to/#/#nvim-tree:matrix.org)
+Questions and general support: [Discussions](https://github.com/nvim-tree/nvim-tree.lua/discussions)
 
 ## Requirements
 
-[neovim >=0.7.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"
 
 ## Install
 
-Install with [vim-plug](https://github.com/junegunn/vim-plug):
+Please install via your preferred package manager. See [Installation](https://github.com/nvim-tree/nvim-tree.lua/wiki/Installation) for specific package manager instructions.
 
-```vim
-Plug 'nvim-tree/nvim-web-devicons' " optional, for file icons
-Plug 'nvim-tree/nvim-tree.lua'
-```
+`nvim-tree/nvim-tree.lua`
 
-or with [packer](https://github.com/wbthomason/packer.nvim):
+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)
+
+## Quick Start
+
+### Setup
+
+Setup the plugin in your `init.lua`
 
 ```lua
-use {
-  'nvim-tree/nvim-tree.lua',
-  requires = {
-    'nvim-tree/nvim-web-devicons', -- optional, for file icons
-  },
-  tag = 'nightly' -- optional, updated every week. (see issue #1193)
-}
-```
-
-## Setup
-
-Setup should be run in a lua file or in a lua heredoc [:help lua-heredoc](https://neovim.io/doc/user/lua.html) if using in a vim file.
-
-```lua
--- examples for your init.lua
-
--- disable netrw at the very start of your init.lua (strongly advised)
+-- disable netrw at the very start of your init.lua
 vim.g.loaded_netrw = 1
 vim.g.loaded_netrwPlugin = 1
 
--- set termguicolors to enable highlight groups
+-- optionally enable 24-bit colour
 vim.opt.termguicolors = true
 
 -- empty setup using defaults
@@ -72,14 +63,11 @@ require("nvim-tree").setup()
 
 -- OR setup with some options
 require("nvim-tree").setup({
-  sort_by = "case_sensitive",
+  sort = {
+    sorter = "case_sensitive",
+  },
   view = {
-    adaptive_size = true,
-    mappings = {
-      list = {
-        { key = "u", action = "dir_up" },
-      },
-    },
+    width = 30,
   },
   renderer = {
     group_empty = true,
@@ -90,9 +78,56 @@ require("nvim-tree").setup({
 })
 ```
 
-For complete list of available configuration options see [:help nvim-tree-setup](doc/nvim-tree-lua.txt)
+### Help
 
-Each option is documented in `:help nvim-tree.OPTION_NAME`. Nested options can be accessed by appending `.`, for example [:help nvim-tree.view.mappings](doc/nvim-tree-lua.txt)
+Open the tree:  `:NvimTreeOpen`
+
+Show the mappings:  `g?`
+
+### Custom Mappings
+
+[:help nvim-tree-mappings-default](doc/nvim-tree-lua.txt) are applied by default however you may customise via |nvim-tree.on_attach| e.g.
+
+```lua
+local function my_on_attach(bufnr)
+  local api = require "nvim-tree.api"
+
+  local function opts(desc)
+    return { desc = "nvim-tree: " .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true }
+  end
+
+  -- default mappings
+  api.config.mappings.default_on_attach(bufnr)
+
+  -- custom mappings
+  vim.keymap.set('n', '<C-t>', api.tree.change_root_to_parent,        opts('Up'))
+  vim.keymap.set('n', '?',     api.tree.toggle_help,                  opts('Help'))
+end
+
+-- pass to setup along with your other options
+require("nvim-tree").setup {
+  ---
+  on_attach = my_on_attach,
+  ---
+}
+```
+
+### 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
 
@@ -108,12 +143,6 @@ Basic commands:
 
 `:NvimTreeCollapse` Collapses the nvim-tree recursively.
 
-## Mappings
-
-nvim-tree comes with number of mappings; for default mappings please see [:help nvim-tree-default-mappings](doc/nvim-tree-lua.txt), for way of configuring mappings see [:help nvim-tree-mappings](doc/nvim-tree-lua.txt)
-
-`g?` toggles help, showing all the mappings and their actions.
-
 ## Roadmap
 
 nvim-tree is stable and new major features will not be added. The focus is on existing user experience.
@@ -129,23 +158,13 @@ Development is focused on:
 
 ## API
 
-nvim-tree exposes a public API. This is non breaking, with additions made as necessary.
+nvim-tree exposes a public API. This is non breaking, with additions made as necessary. See [:help nvim-tree-api](doc/nvim-tree-lua.txt)
 
-Please raise a [feature request](https://github.com/nvim-tree/nvim-tree.lua/issues/new?assignees=&labels=feature+request&template=feature_request.md&title=) if the API is insufficent for your needs. [Contributions](#Contributing) are always welcome.
+See wiki [Recipes](https://github.com/nvim-tree/nvim-tree.lua/wiki/Recipes) and [Tips](https://github.com/nvim-tree/nvim-tree.lua/wiki/Tips) for ideas and inspiration.
 
-[:help nvim-tree-api](doc/nvim-tree-lua.txt)
+Please raise a [feature request](https://github.com/nvim-tree/nvim-tree.lua/issues/new?assignees=&labels=feature+request&template=feature_request.md&title=) if the API is insufficient for your needs. [Contributions](#Contributing) are always welcome.
 
-### Events
-
-Users may subscribe to events that nvim-tree will dispatch in a variety of situations.
-
-[:help nvim-tree-events](doc/nvim-tree-lua.txt)
-
-### Actions
-
-Custom actions may be mapped which can invoke API or perform your own actions.
-
-[:help nvim-tree-mappings](doc/nvim-tree-lua.txt)
+You may also subscribe to events that nvim-tree will dispatch in a variety of situations, see [:help nvim-tree-events](doc/nvim-tree-lua.txt)
 
 ## Contributing
 
@@ -153,23 +172,15 @@ PRs are always welcome. See [wiki](https://github.com/nvim-tree/nvim-tree.lua/wi
 
 See [bug](https://github.com/nvim-tree/nvim-tree.lua/issues?q=is%3Aissue+is%3Aopen+label%3Abug) and [PR Please](https://github.com/nvim-tree/nvim-tree.lua/issues?q=is%3Aopen+is%3Aissue+label%3A%22PR+please%22) issues if you are looking for some work to get you started.
 
-### Help Wanted
-
-Developers with the following environments:
-
-* Apple macOS
-* Windows
-  * WSL
-  * msys
-  * powershell
-
-Help triaging, diagnosing and fixing issues specific to those environments is needed, as the nvim-tree developers do not have access to or expertise in these environments.
-
-Let us know you're interested by commenting on issues and raising PRs.
-
 ## Screenshots
 
 See [Showcases](https://github.com/nvim-tree/nvim-tree.lua/wiki/Showcases) wiki page for examples of user's configurations with sources.
 
 Please add your own!
 
+## Team
+
+* [@alex-courtis](https://github.com/alex-courtis) Arch Linux
+* [@gegoune](https://github.com/gegoune) macOS
+* [@Akmadan23](https://github.com/Akmadan23) Linux
+* [@dependabot[bot]](https://github.com/apps/dependabot) Ubuntu Linux

lua/nvim-tree/actions/dispatch.lua

@@ -1,131 +0,0 @@
-local view = require "nvim-tree.view"
-local lib = require "nvim-tree.lib"
-
-local M = {}
-
-local Actions = {
-  close = view.close,
-
-  -- Tree modifiers
-  collapse_all = require("nvim-tree.actions.tree-modifiers.collapse-all").fn,
-  expand_all = require("nvim-tree.actions.tree-modifiers.expand-all").fn,
-  toggle_dotfiles = require("nvim-tree.actions.tree-modifiers.toggles").dotfiles,
-  toggle_custom = require("nvim-tree.actions.tree-modifiers.toggles").custom,
-  toggle_git_ignored = require("nvim-tree.actions.tree-modifiers.toggles").git_ignored,
-  toggle_git_clean = require("nvim-tree.actions.tree-modifiers.toggles").git_clean,
-  toggle_no_buffer = require("nvim-tree.actions.tree-modifiers.toggles").no_buffer,
-
-  -- Filesystem operations
-  copy_absolute_path = require("nvim-tree.actions.fs.copy-paste").copy_absolute_path,
-  copy_name = require("nvim-tree.actions.fs.copy-paste").copy_filename,
-  copy_path = require("nvim-tree.actions.fs.copy-paste").copy_path,
-  copy = require("nvim-tree.actions.fs.copy-paste").copy,
-  create = require("nvim-tree.actions.fs.create-file").fn,
-  cut = require("nvim-tree.actions.fs.copy-paste").cut,
-  full_rename = require("nvim-tree.actions.fs.rename-file").fn ":p",
-  paste = require("nvim-tree.actions.fs.copy-paste").paste,
-  trash = require("nvim-tree.actions.fs.trash").fn,
-  remove = require("nvim-tree.actions.fs.remove-file").fn,
-  rename = require("nvim-tree.actions.fs.rename-file").fn ":t",
-  rename_basename = require("nvim-tree.actions.fs.rename-file").fn ":t:r",
-
-  -- Movements in tree
-  close_node = require("nvim-tree.actions.moves.parent").fn(true),
-  first_sibling = require("nvim-tree.actions.moves.sibling").fn "first",
-  last_sibling = require("nvim-tree.actions.moves.sibling").fn "last",
-  next_diag_item = require("nvim-tree.actions.moves.item").fn("next", "diag"),
-  next_git_item = require("nvim-tree.actions.moves.item").fn("next", "git"),
-  next_sibling = require("nvim-tree.actions.moves.sibling").fn "next",
-  parent_node = require("nvim-tree.actions.moves.parent").fn(false),
-  prev_diag_item = require("nvim-tree.actions.moves.item").fn("prev", "diag"),
-  prev_git_item = require("nvim-tree.actions.moves.item").fn("prev", "git"),
-  prev_sibling = require("nvim-tree.actions.moves.sibling").fn "prev",
-
-  -- Other types
-  refresh = require("nvim-tree.actions.reloaders.reloaders").reload_explorer,
-  dir_up = require("nvim-tree.actions.root.dir-up").fn,
-  search_node = require("nvim-tree.actions.finders.search-node").fn,
-  run_file_command = require("nvim-tree.actions.node.run-command").run_file_command,
-  toggle_file_info = require("nvim-tree.actions.node.file-popup").toggle_file_info,
-  system_open = require("nvim-tree.actions.node.system-open").fn,
-  toggle_mark = require("nvim-tree.marks").toggle_mark,
-  bulk_move = require("nvim-tree.marks.bulk-move").bulk_move,
-}
-
-local function handle_action_on_help_ui(action)
-  if action == "close" or action == "toggle_help" then
-    require("nvim-tree.actions.tree-modifiers.toggles").help()
-  end
-end
-
-local function handle_filter_actions(action)
-  if action == "live_filter" then
-    require("nvim-tree.live-filter").start_filtering()
-  elseif action == "clear_live_filter" then
-    require("nvim-tree.live-filter").clear_filter()
-  end
-end
-
-local function change_dir_action(node)
-  if node.name == ".." then
-    require("nvim-tree.actions.root.change-dir").fn ".."
-  elseif node.nodes ~= nil then
-    require("nvim-tree.actions.root.change-dir").fn(lib.get_last_group_node(node).absolute_path)
-  end
-end
-
-local function open_file(action, node)
-  local path = node.absolute_path
-  if node.link_to and not node.nodes then
-    path = node.link_to
-  end
-  require("nvim-tree.actions.node.open-file").fn(action, path)
-end
-
-local function handle_tree_actions(action)
-  local node = lib.get_node_at_cursor()
-  if not node then
-    return
-  end
-
-  local custom_function = M.custom_keypress_funcs[action]
-  local defined_action = Actions[action]
-
-  if type(custom_function) == "function" then
-    return custom_function(node)
-  elseif defined_action then
-    return defined_action(node)
-  end
-
-  local is_parent = node.name == ".."
-
-  if action == "preview" and is_parent then
-    return
-  end
-
-  if action == "cd" or is_parent then
-    return change_dir_action(node)
-  end
-
-  if node.nodes then
-    lib.expand_or_collapse(node)
-  else
-    open_file(action, node)
-  end
-end
-
-function M.dispatch(action)
-  if view.is_help_ui() or action == "toggle_help" then
-    handle_action_on_help_ui(action)
-  elseif action == "live_filter" or action == "clear_live_filter" then
-    handle_filter_actions(action)
-  else
-    handle_tree_actions(action)
-  end
-end
-
-function M.setup(custom_keypress_funcs)
-  M.custom_keypress_funcs = custom_keypress_funcs
-end
-
-return M

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

@@ -2,8 +2,8 @@ local log = require "nvim-tree.log"
 local view = require "nvim-tree.view"
 local utils = require "nvim-tree.utils"
 local renderer = require "nvim-tree.renderer"
-local core = require "nvim-tree.core"
 local reload = require "nvim-tree.explorer.reload"
+local core = require "nvim-tree.core"
 local Iterator = require "nvim-tree.iterators.node-iterator"
 
 local M = {}
@@ -11,27 +11,29 @@ local M = {}
 local running = {}
 
 ---Find a path in the tree, expand it and focus it
----@param fname string full path
-function M.fn(fname)
-  if not core.get_explorer() then
+---@param path string relative or absolute
+function M.fn(path)
+  if not core.get_explorer() or not view.is_visible() then
     return
   end
 
   -- always match against the real path
-  local fname_real = vim.loop.fs_realpath(fname)
-  if not fname_real then
+  local path_real = vim.loop.fs_realpath(path)
+  if not path_real then
     return
   end
 
-  if running[fname_real] then
+  if running[path_real] then
     return
   end
-  running[fname_real] = true
+  running[path_real] = true
 
-  local ps = log.profile_start("find file %s", fname_real)
+  local profile = log.profile_start("find file %s", path_real)
 
-  -- we cannot wait for watchers
-  reload.refresh_nodes_for_path(vim.fn.fnamemodify(fname_real, ":h"))
+  -- refresh the contents of all parents, expanding groups as needed
+  if utils.get_node_from_path(path_real) == nil then
+    reload.refresh_parent_nodes_for_path(vim.fn.fnamemodify(path_real, ":h"))
+  end
 
   local line = core.get_nodes_starting_line()
 
@@ -39,28 +41,37 @@ function M.fn(fname)
 
   local found = Iterator.builder(core.get_explorer().nodes)
     :matcher(function(node)
-      return node.absolute_path == fname_real or node.link_to == fname_real
+      return node.absolute_path == path_real or node.link_to == path_real
     end)
     :applier(function(node)
-      line = line + 1
+      local incremented_line = false
+      if not node.group_next then
+        line = line + 1
+        incremented_line = true
+      end
 
       if vim.tbl_contains(absolute_paths_searched, node.absolute_path) then
         return
       end
       table.insert(absolute_paths_searched, node.absolute_path)
 
-      local abs_match = vim.startswith(fname_real, node.absolute_path .. utils.path_separator)
-      local link_match = node.link_to and vim.startswith(fname_real, node.link_to .. utils.path_separator)
+      local abs_match = vim.startswith(path_real, node.absolute_path .. utils.path_separator)
+      local link_match = node.link_to and vim.startswith(path_real, node.link_to .. utils.path_separator)
 
       if abs_match or link_match then
-        node.open = true
+        if not node.group_next then
+          node.open = true
+        end
         if #node.nodes == 0 then
           core.get_explorer():expand(node)
+          if node.group_next and incremented_line then
+            line = line - 1
+          end
         end
       end
     end)
     :recursor(function(node)
-      return node.open and node.nodes
+      return node.group_next and { node.group_next } or (node.open and #node.nodes > 0 and node.nodes)
     end)
     :iterate()
 
@@ -69,9 +80,9 @@ function M.fn(fname)
     view.set_cursor { line, 0 }
   end
 
-  running[fname_real] = false
+  running[path_real] = false
 
-  log.profile_end(ps, "find file %s", fname_real)
+  log.profile_end(profile)
 end
 
 return M

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

@@ -0,0 +1,6 @@
+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

@@ -4,6 +4,9 @@ local find_file = require("nvim-tree.actions.finders.find-file").fn
 
 local M = {}
 
+---@param search_dir string|nil
+---@param input_path string
+---@return string|nil
 local function search(search_dir, input_path)
   local realpaths_searched = {}
 
@@ -11,6 +14,8 @@ local function search(search_dir, input_path)
     return
   end
 
+  ---@param dir string
+  ---@return string|nil
   local function iter(dir)
     local realpath, path, name, stat, handle, _
 
@@ -31,12 +36,13 @@ 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 filters.should_filter(path, filter_status) then
+      if not filters.should_filter(path, stat, filter_status) then
         if string.find(path, "/" .. input_path .. "$") then
           return path
         end

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

@@ -4,14 +4,24 @@ local utils = require "nvim-tree.utils"
 local core = require "nvim-tree.core"
 local events = require "nvim-tree.events"
 local notify = require "nvim-tree.notify"
+local renderer = require "nvim-tree.renderer"
+local reloaders = require "nvim-tree.actions.reloaders"
 
-local M = {}
+local find_file = require("nvim-tree.actions.finders.find-file").fn
+
+local M = {
+  config = {},
+}
 
 local clipboard = {
-  move = {},
+  cut = {},
   copy = {},
 }
 
+---@param source string
+---@param destination string
+---@return boolean
+---@return string|nil
 local function do_copy(source, destination)
   local source_stats, handle
   local success, errmsg
@@ -73,80 +83,117 @@ local function do_copy(source, destination)
   return true
 end
 
+---@param source string
+---@param dest string
+---@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_type, action_fn)
   local dest_stats
   local success, errmsg, errcode
+  local notify_source = notify.render_path(source)
 
   log.line("copy_paste", "do_single_paste '%s' -> '%s'", source, dest)
 
   dest_stats, errmsg, errcode = vim.loop.fs_stat(dest)
   if not dest_stats and errcode ~= "ENOENT" then
-    notify.error("Could not " .. action_type .. " " .. 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_type .. " " .. source .. " - " .. (errmsg or "???"))
+      notify.error("Could not " .. action_type .. " " .. notify_source .. " - " .. (errmsg or "???"))
       return false, errmsg
     end
+
+    find_file(utils.path_remove_trailing(dest))
   end
 
   if dest_stats then
-    local prompt_select = "Overwrite " .. dest .. " ?"
-    local prompt_input = prompt_select .. " y/n/r(ename): "
-    lib.prompt(prompt_input, prompt_select, { "y", "n", "r" }, { "Yes", "No", "Rename" }, function(item_short)
-      utils.clear_prompt()
-      if item_short == "y" then
-        on_process()
-      elseif item_short == "r" then
-        vim.ui.input({ prompt = "Rename to ", default = dest, completion = "dir" }, function(new_dest)
-          utils.clear_prompt()
-          if new_dest then
-            do_single_paste(source, new_dest, action_type, action_fn)
-          end
-        end)
-      end
-    end)
+    local input_opts = {
+      prompt = "Rename to ",
+      default = dest,
+      completion = "dir",
+    }
+
+    if source == dest then
+      vim.ui.input(input_opts, function(new_dest)
+        utils.clear_prompt()
+        if new_dest then
+          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)
+        utils.clear_prompt()
+        if item_short == "y" then
+          on_process()
+        elseif item_short == "" or item_short == "r" then
+          vim.ui.input(input_opts, function(new_dest)
+            utils.clear_prompt()
+            if new_dest then
+              do_single_paste(source, new_dest, action_type, action_fn)
+            end
+          end)
+        end
+      end)
+    end
   else
     on_process()
   end
 end
 
-local function add_to_clipboard(node, clip)
+---@param node Node
+---@param clip table
+local function toggle(node, clip)
   if node.name == ".." then
     return
   end
+  local notify_node = notify.render_path(node.absolute_path)
 
-  for idx, _node in ipairs(clip) do
-    if _node.absolute_path == node.absolute_path then
-      table.remove(clip, idx)
-      return notify.info(node.absolute_path .. " removed to clipboard.")
-    end
+  if utils.array_remove(clip, node) then
+    notify.info(notify_node .. " removed from clipboard.")
+    return
   end
+
   table.insert(clip, node)
-  notify.info(node.absolute_path .. " added to clipboard.")
+  notify.info(notify_node .. " added to clipboard.")
 end
 
 function M.clear_clipboard()
-  clipboard.move = {}
+  clipboard.cut = {}
   clipboard.copy = {}
-  utils.notify.info "Clipboard has been emptied."
+  notify.info "Clipboard has been emptied."
+  renderer.draw()
 end
 
+---@param node Node
 function M.copy(node)
-  add_to_clipboard(node, clipboard.copy)
+  utils.array_remove(clipboard.cut, node)
+  toggle(node, clipboard.copy)
+  renderer.draw()
 end
 
+---@param node Node
 function M.cut(node)
-  add_to_clipboard(node, clipboard.move)
+  utils.array_remove(clipboard.copy, node)
+  toggle(node, clipboard.cut)
+  renderer.draw()
 end
 
+---@param node Node
+---@param action_type string
+---@param action_fn fun(source: string, dest: string)
 local function do_paste(node, action_type, action_fn)
   node = lib.get_last_group_node(node)
-  if node.name == ".." then
-    node = core.get_explorer()
+  local explorer = core.get_explorer()
+  if node.name == ".." and explorer then
+    node = explorer
   end
   local clip = clipboard[action_type]
   if #clip == 0 then
@@ -157,7 +204,7 @@ local function do_paste(node, action_type, 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_type .. " " .. 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"
@@ -171,11 +218,15 @@ local function do_paste(node, action_type, action_fn)
   end
 
   clipboard[action_type] = {}
-  if M.enable_reload then
-    return require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+  if not M.config.filesystem_watchers.enable then
+    reloaders.reload_explorer()
   end
 end
 
+---@param source string
+---@param destination string
+---@return boolean
+---@return string?
 local function do_cut(source, destination)
   log.line("copy_paste", "do_cut '%s' -> '%s'", source, destination)
 
@@ -195,64 +246,105 @@ local function do_cut(source, destination)
   return true
 end
 
+---@param node Node
 function M.paste(node)
-  if clipboard.move[1] ~= nil then
-    return do_paste(node, "move", do_cut)
+  if clipboard.cut[1] ~= nil then
+    do_paste(node, "cut", do_cut)
+  else
+    do_paste(node, "copy", do_copy)
   end
-
-  return do_paste(node, "copy", do_copy)
 end
 
 function M.print_clipboard()
   local content = {}
-  if #clipboard.move > 0 then
+  if #clipboard.cut > 0 then
     table.insert(content, "Cut")
-    for _, item in pairs(clipboard.move) do
-      table.insert(content, " * " .. item.absolute_path)
+    for _, node in pairs(clipboard.cut) do
+      table.insert(content, " * " .. (notify.render_path(node.absolute_path)))
     end
   end
   if #clipboard.copy > 0 then
     table.insert(content, "Copy")
-    for _, item in pairs(clipboard.copy) do
-      table.insert(content, " * " .. item.absolute_path)
+    for _, node in pairs(clipboard.copy) do
+      table.insert(content, " * " .. (notify.render_path(node.absolute_path)))
     end
   end
 
-  return notify.info(table.concat(content, "\n") .. "\n")
+  notify.info(table.concat(content, "\n") .. "\n")
 end
 
+---@param content string
 local function copy_to_clipboard(content)
-  if M.use_system_clipboard == true then
-    vim.fn.setreg("+", content)
-    vim.fn.setreg('"', content)
-    return notify.info(string.format("Copied %s to system clipboard!", content))
+  local clipboard_name
+  local reg
+  if M.config.actions.use_system_clipboard == true then
+    clipboard_name = "system"
+    reg = "+"
   else
-    vim.fn.setreg('"', content)
-    vim.fn.setreg("1", content)
-    return notify.info(string.format("Copied %s to neovim clipboard!", content))
+    clipboard_name = "neovim"
+    reg = "1"
   end
+
+  -- manually firing TextYankPost does not set vim.v.event
+  -- workaround: create a scratch buffer with the clipboard contents and send a yank command
+  local temp_buf = vim.api.nvim_create_buf(false, true)
+  vim.api.nvim_buf_set_text(temp_buf, 0, 0, 0, 0, { content })
+  vim.api.nvim_buf_call(temp_buf, function()
+    vim.cmd(string.format('normal! "%sy$', reg))
+  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 M.copy_filename(node)
-  return copy_to_clipboard(node.name)
+  copy_to_clipboard(node.name)
 end
 
+---@param node Node
+function M.copy_basename(node)
+  local basename = vim.fn.fnamemodify(node.name, ":r")
+  copy_to_clipboard(basename)
+end
+
+---@param node Node
 function M.copy_path(node)
   local absolute_path = node.absolute_path
-  local relative_path = utils.path_relative(absolute_path, core.get_cwd())
+  local cwd = core.get_cwd()
+  if cwd == nil then
+    return
+  end
+
+  local relative_path = utils.path_relative(absolute_path, cwd)
   local content = node.nodes ~= nil and utils.path_add_trailing(relative_path) or relative_path
-  return copy_to_clipboard(content)
+  copy_to_clipboard(content)
 end
 
+---@param node Node
 function M.copy_absolute_path(node)
   local absolute_path = node.absolute_path
   local content = node.nodes ~= nil and utils.path_add_trailing(absolute_path) or absolute_path
-  return copy_to_clipboard(content)
+  copy_to_clipboard(content)
+end
+
+---Node is cut. Will not be copied.
+---@param node Node
+---@return boolean
+function M.is_cut(node)
+  return vim.tbl_contains(clipboard.cut, node)
+end
+
+---Node is copied. Will not be cut.
+---@param node Node
+---@return boolean
+function M.is_copied(node)
+  return vim.tbl_contains(clipboard.copy, node)
 end
 
 function M.setup(opts)
-  M.use_system_clipboard = opts.actions.use_system_clipboard
-  M.enable_reload = not opts.filesystem_watchers.enable
+  M.config.filesystem_watchers = opts.filesystem_watchers
+  M.config.actions = opts.actions
 end
 
 return M

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

@@ -8,31 +8,20 @@ local find_file = require("nvim-tree.actions.finders.find-file").fn
 
 local M = {}
 
+---@param file string
 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 then
-    notify.error("Couldn't create file " .. file)
+    notify.error("Couldn't create file " .. notify.render_path(file))
     return
   end
   vim.loop.fs_close(fd)
   events._dispatch_file_created(file)
 end
 
-local function create_file(file)
-  if utils.file_exists(file) then
-    local prompt_select = "Overwrite " .. file .. " ?"
-    local prompt_input = prompt_select .. " y/n: "
-    lib.prompt(prompt_input, prompt_select, { "y", "n" }, { "Yes", "No" }, function(item_short)
-      utils.clear_prompt()
-      if item_short == "y" then
-        create_and_notify(file)
-      end
-    end)
-  else
-    create_and_notify(file)
-  end
-end
-
+---@param iter function iterable
+---@return integer
 local function get_num_nodes(iter)
   local i = 0
   for _ in iter do
@@ -41,6 +30,8 @@ local function get_num_nodes(iter)
   return i
 end
 
+---@param node Node
+---@return string
 local function get_containing_folder(node)
   if node.nodes ~= nil then
     return utils.path_add_trailing(node.absolute_path)
@@ -49,11 +40,18 @@ local function get_containing_folder(node)
   return node.absolute_path:sub(0, -node_name_size - 1)
 end
 
+---@param node Node|nil
 function M.fn(node)
+  local cwd = core.get_cwd()
+  if cwd == nil then
+    return
+  end
+
   node = node and lib.get_last_group_node(node)
   if not node or node.name == ".." then
     node = {
-      absolute_path = core.get_cwd(),
+      absolute_path = cwd,
+      name = "",
       nodes = core.get_explorer().nodes,
       open = true,
     }
@@ -61,7 +59,11 @@ function M.fn(node)
 
   local containing_folder = get_containing_folder(node)
 
-  local input_opts = { prompt = "Create file ", default = containing_folder, completion = "file" }
+  local input_opts = {
+    prompt = "Create file ",
+    default = containing_folder,
+    completion = "file",
+  }
 
   vim.ui.input(input_opts, function(new_file_path)
     utils.clear_prompt()
@@ -91,11 +93,11 @@ function M.fn(node)
         path_to_create = utils.path_join { path_to_create, p }
       end
       if is_last_path_file and idx == num_nodes then
-        create_file(path_to_create)
+        create_and_notify(path_to_create)
       elseif not utils.file_exists(path_to_create) then
         local success = vim.loop.fs_mkdir(path_to_create, 493)
         if not success then
-          notify.error("Could not create folder " .. path_to_create)
+          notify.error("Could not create folder " .. notify.render_path(path_to_create))
           is_error = true
           break
         end
@@ -103,7 +105,7 @@ function M.fn(node)
       end
     end
     if not is_error then
-      notify.info(new_file_path .. " was properly created")
+      notify.info(notify.render_path(new_file_path) .. " was properly created")
     end
 
     -- synchronously refreshes as we can't wait for the watchers
@@ -111,8 +113,4 @@ function M.fn(node)
   end)
 end
 
-function M.setup(opts)
-  M.enable_reload = not opts.filesystem_watchers.enable
-end
-
 return M

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

@@ -0,0 +1,16 @@
+local M = {}
+
+M.copy_paste = require "nvim-tree.actions.fs.copy-paste"
+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.copy_paste.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

@@ -4,10 +4,16 @@ local view = require "nvim-tree.view"
 local lib = require "nvim-tree.lib"
 local notify = require "nvim-tree.notify"
 
-local M = {}
+local M = {
+  config = {},
+}
 
+---@param windows integer[]
 local function close_windows(windows)
-  if view.View.float.enable and #vim.api.nvim_list_wins() == 1 then
+  -- Prevent from closing when the win count equals 1 or 2,
+  -- where the win to remove could be the last opened.
+  -- For details see #2503.
+  if view.View.float.enable and #vim.api.nvim_list_wins() < 3 then
     return
   end
 
@@ -18,20 +24,21 @@ local function close_windows(windows)
   end
 end
 
+---@param absolute_path string
 local function clear_buffer(absolute_path)
   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
-        local winnr = vim.api.nvim_get_current_win()
         vim.api.nvim_set_current_win(buf.windows[1])
         vim.cmd ":bn"
-        if not view.View.float.enable then
-          vim.api.nvim_set_current_win(winnr)
-        end
       end
       vim.api.nvim_buf_delete(buf.bufnr, { force = true })
-      if M.close_window then
+      if not view.View.float.quit_on_focus_loss then
+        vim.api.nvim_set_current_win(tree_winnr)
+      end
+      if M.config.actions.remove_file.close_window then
         close_windows(buf.windows)
       end
       return
@@ -39,10 +46,13 @@ local function clear_buffer(absolute_path)
   end
 end
 
+---@param cwd string
+---@return boolean|nil
 local function remove_dir(cwd)
   local handle = vim.loop.fs_scandir(cwd)
   if type(handle) == "string" then
-    return notify.error(handle)
+    notify.error(handle)
+    return
   end
 
   while true do
@@ -69,40 +79,72 @@ local function remove_dir(cwd)
   return vim.loop.fs_rmdir(cwd)
 end
 
+--- Remove a node, notify errors, dispatch events
+---@param node Node
+function M.remove(node)
+  local notify_node = notify.render_path(node.absolute_path)
+  if node.nodes ~= nil and not node.link_to then
+    local success = remove_dir(node.absolute_path)
+    if not success then
+      notify.error("Could not remove " .. notify_node)
+      return
+    end
+    events._dispatch_folder_removed(node.absolute_path)
+  else
+    events._dispatch_will_remove_file(node.absolute_path)
+    local success = vim.loop.fs_unlink(node.absolute_path)
+    if not success then
+      notify.error("Could not remove " .. notify_node)
+      return
+    end
+    events._dispatch_file_removed(node.absolute_path)
+    clear_buffer(node.absolute_path)
+  end
+  notify.info(notify_node .. " was properly removed.")
+end
+
+---@param node Node
 function M.fn(node)
   if node.name == ".." then
     return
   end
-  local prompt_select = "Remove " .. node.name .. " ?"
-  local prompt_input = prompt_select .. " y/n: "
-  lib.prompt(prompt_input, prompt_select, { "y", "n" }, { "Yes", "No" }, function(item_short)
-    utils.clear_prompt()
-    if item_short == "y" then
-      if node.nodes ~= nil and not node.link_to then
-        local success = remove_dir(node.absolute_path)
-        if not success then
-          return notify.error("Could not remove " .. node.name)
-        end
-        events._dispatch_folder_removed(node.absolute_path)
-      else
-        local success = vim.loop.fs_unlink(node.absolute_path)
-        if not success then
-          return notify.error("Could not remove " .. node.name)
-        end
-        events._dispatch_file_removed(node.absolute_path)
-        clear_buffer(node.absolute_path)
-      end
-      notify.info(node.absolute_path .. " was properly removed.")
-      if M.enable_reload then
-        require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
-      end
+
+  local function do_remove()
+    M.remove(node)
+    if not M.config.filesystem_watchers.enable then
+      require("nvim-tree.actions.reloaders").reload_explorer()
     end
-  end)
+  end
+
+  if M.config.ui.confirm.remove then
+    local prompt_select = "Remove " .. node.name .. "?"
+    local prompt_input, items_short, items_long
+
+    if M.config.ui.confirm.default_yes then
+      prompt_input = prompt_select .. " Y/n: "
+      items_short = { "", "n" }
+      items_long = { "Yes", "No" }
+    else
+      prompt_input = prompt_select .. " y/N: "
+      items_short = { "", "y" }
+      items_long = { "No", "Yes" }
+    end
+
+    lib.prompt(prompt_input, prompt_select, items_short, items_long, "nvimtree_remove", function(item_short)
+      utils.clear_prompt()
+      if item_short == "y" or item_short == (M.config.ui.confirm.default_yes and "") then
+        do_remove()
+      end
+    end)
+  else
+    do_remove()
+  end
 end
 
 function M.setup(opts)
-  M.enable_reload = not opts.filesystem_watchers.enable
-  M.close_window = opts.actions.remove_file.close_window
+  M.config.ui = opts.ui
+  M.config.actions = opts.actions
+  M.config.filesystem_watchers = opts.filesystem_watchers
 end
 
 return M

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

@@ -3,10 +3,25 @@ local utils = require "nvim-tree.utils"
 local events = require "nvim-tree.events"
 local notify = require "nvim-tree.notify"
 
-local M = {}
+local find_file = require("nvim-tree.actions.finders.find-file").fn
+
+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,
   [":t"] = true,
   [":t:r"] = true,
 }
@@ -15,22 +30,61 @@ local function err_fmt(from, to, reason)
   return string.format("Cannot rename %s -> %s: %s", from, to, reason)
 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 utils.file_exists(to) then
-    notify.warn(err_fmt(node.absolute_path, to, "file already exists"))
+    notify.warn(err_fmt(notify_from, notify_to, "file already exists"))
     return
   end
 
-  events._dispatch_will_rename_node(node.absolute_path, to)
-  local success, err = vim.loop.fs_rename(node.absolute_path, to)
-  if not success then
-    return notify.warn(err_fmt(node.absolute_path, to, err))
+  -- create a folder for each path element if the folder does not exist
+  local idx = 0
+  local path_to_create = ""
+
+  local num_nodes = get_num_nodes(utils.path_split(utils.path_remove_trailing(to)))
+  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 utils.file_exists(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(node.absolute_path .. " ➜ " .. to)
-  utils.rename_loaded_buffers(node.absolute_path, to)
-  events._dispatch_node_renamed(node.absolute_path, to)
 end
 
+---@param default_modifier string|nil
+---@return fun(node: Node, modifier: string)
 function M.fn(default_modifier)
   default_modifier = default_modifier or ":t"
 
@@ -39,15 +93,18 @@ function M.fn(default_modifier)
       node = lib.get_node_at_cursor()
     end
 
+    if node == nil then
+      return
+    end
+
     if type(modifier) ~= "string" then
       modifier = default_modifier
     end
 
     -- support for only specific modifiers have been implemented
     if not ALLOWED_MODIFIERS[modifier] then
-      return notify.warn(
-        "Modifier " .. vim.inspect(modifier) .. " is not in allowed list : " .. table.concat(ALLOWED_MODIFIERS, ",")
-      )
+      notify.warn("Modifier " .. vim.inspect(modifier) .. " is not in allowed list : " .. table.concat(ALLOWED_MODIFIERS, ","))
+      return
     end
 
     node = lib.get_last_group_node(node)
@@ -68,8 +125,15 @@ function M.fn(default_modifier)
       local extension = vim.fn.fnamemodify(node.name, ":e")
       append = extension:len() == 0 and "" or "." .. extension
     end
+    if modifier == ":p:h" then
+      default_path = default_path .. "/"
+    end
 
-    local input_opts = { prompt = "Rename to ", default = default_path, completion = "file" }
+    local input_opts = {
+      prompt = "Rename to ",
+      default = default_path,
+      completion = "file",
+    }
 
     vim.ui.input(input_opts, function(new_file_path)
       utils.clear_prompt()
@@ -78,15 +142,17 @@ function M.fn(default_modifier)
       end
 
       M.rename(node, prepend .. new_file_path .. append)
-      if M.enable_reload then
-        require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+      if not M.config.filesystem_watchers.enable then
+        require("nvim-tree.actions.reloaders").reload_explorer()
       end
+
+      find_file(utils.path_remove_trailing(new_file_path))
     end)
   end
 end
 
 function M.setup(opts)
-  M.enable_reload = not opts.filesystem_watchers.enable
+  M.config.filesystem_watchers = opts.filesystem_watchers
 end
 
 return M

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

@@ -1,17 +1,15 @@
 local lib = require "nvim-tree.lib"
 local notify = require "nvim-tree.notify"
+local reloaders = require "nvim-tree.actions.reloaders"
 
 local M = {
-  config = {
-    is_windows = vim.fn.has "win32" == 1 or vim.fn.has "win32unix" == 1,
-    is_macos = vim.fn.has "mac" == 1 or vim.fn.has "macunix" == 1,
-    is_unix = vim.fn.has "unix" == 1,
-  },
+  config = {},
 }
 
 local utils = require "nvim-tree.utils"
 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 }
   for _, buf in pairs(bufs) do
@@ -28,27 +26,11 @@ local function clear_buffer(absolute_path)
   end
 end
 
-function M.fn(node)
-  if node.name == ".." then
-    return
-  end
-
-  -- configs
-  if M.config.is_unix then
-    if M.config.trash.cmd == nil then
-      M.config.trash.cmd = "trash"
-    end
-    if M.config.trash.require_confirm == nil then
-      M.config.trash.require_confirm = true
-    end
-  else
-    notify.warn "Trash is currently a UNIX only feature!"
-    return
-  end
-
+---@param node Node
+function M.remove(node)
   local binary = M.config.trash.cmd:gsub(" .*$", "")
   if vim.fn.executable(binary) == 0 then
-    notify.warn(binary .. " is not executable.")
+    notify.warn(string.format("trash.cmd '%s' is not an executable.", M.config.trash.cmd))
     return
   end
 
@@ -59,46 +41,71 @@ function M.fn(node)
 
   -- trashes a path (file or folder)
   local function trash_path(on_exit)
-    vim.fn.jobstart(M.config.trash.cmd .. ' "' .. node.absolute_path .. '"', {
-      detach = true,
+    local need_sync_wait = utils.is_windows
+    local job = vim.fn.jobstart(M.config.trash.cmd .. " " .. vim.fn.shellescape(node.absolute_path), {
+      detach = not need_sync_wait,
       on_exit = on_exit,
       on_stderr = on_stderr,
     })
-  end
-
-  local function do_trash()
-    if node.nodes ~= nil and not node.link_to then
-      trash_path(function(_, rc)
-        if rc ~= 0 then
-          notify.warn("trash failed: " .. err_msg .. "; please see :help nvim-tree.trash")
-          return
-        end
-        events._dispatch_folder_removed(node.absolute_path)
-        if M.enable_reload then
-          require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
-        end
-      end)
-    else
-      trash_path(function(_, rc)
-        if rc ~= 0 then
-          notify.warn("trash failed: " .. err_msg .. "; please see :help nvim-tree.trash")
-          return
-        end
-        events._dispatch_file_removed(node.absolute_path)
-        clear_buffer(node.absolute_path)
-        if M.enable_reload then
-          require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
-        end
-      end)
+    if need_sync_wait then
+      vim.fn.jobwait { job }
     end
   end
 
-  if M.config.trash.require_confirm then
-    local prompt_select = "Trash " .. node.name .. " ?"
-    local prompt_input = prompt_select .. " y/n: "
-    lib.prompt(prompt_input, prompt_select, { "y", "n" }, { "Yes", "No" }, function(item_short)
+  if node.nodes ~= nil and not node.link_to then
+    trash_path(function(_, rc)
+      if rc ~= 0 then
+        notify.warn("trash failed: " .. err_msg .. "; please see :help nvim-tree.trash")
+        return
+      end
+      events._dispatch_folder_removed(node.absolute_path)
+      if not M.config.filesystem_watchers.enable then
+        reloaders.reload_explorer()
+      end
+    end)
+  else
+    events._dispatch_will_remove_file(node.absolute_path)
+    trash_path(function(_, rc)
+      if rc ~= 0 then
+        notify.warn("trash failed: " .. err_msg .. "; please see :help nvim-tree.trash")
+        return
+      end
+      events._dispatch_file_removed(node.absolute_path)
+      clear_buffer(node.absolute_path)
+      if not M.config.filesystem_watchers.enable then
+        reloaders.reload_explorer()
+      end
+    end)
+  end
+end
+
+---@param node Node
+function M.fn(node)
+  if node.name == ".." then
+    return
+  end
+
+  local function do_trash()
+    M.remove(node)
+  end
+
+  if M.config.ui.confirm.trash then
+    local prompt_select = "Trash " .. node.name .. "?"
+    local prompt_input, items_short, items_long
+
+    if M.config.ui.confirm.default_yes then
+      prompt_input = prompt_select .. " Y/n: "
+      items_short = { "", "n" }
+      items_long = { "Yes", "No" }
+    else
+      prompt_input = prompt_select .. " y/N: "
+      items_short = { "", "y" }
+      items_long = { "No", "Yes" }
+    end
+
+    lib.prompt(prompt_input, prompt_select, items_short, items_long, "nvimtree_trash", function(item_short)
       utils.clear_prompt()
-      if item_short == "y" then
+      if item_short == "y" or item_short == (M.config.ui.confirm.default_yes and "") then
         do_trash()
       end
     end)
@@ -108,8 +115,9 @@ function M.fn(node)
 end
 
 function M.setup(opts)
-  M.config.trash = opts.trash or {}
-  M.enable_reload = not opts.filesystem_watchers.enable
+  M.config.ui = opts.ui
+  M.config.trash = opts.trash
+  M.config.filesystem_watchers = opts.filesystem_watchers
 end
 
 return M

lua/nvim-tree/actions/init.lua

@@ -1,432 +1,18 @@
--- @deprecated: new implementation in nvim-tree.keymap. Please do not edit this file.
+local M = {}
 
-local log = require "nvim-tree.log"
-local view = require "nvim-tree.view"
-local notify = require "nvim-tree.notify"
-
--- BEGIN_DEFAULT_MAPPINGS
-local DEFAULT_MAPPINGS = {
-  {
-    key = { "<CR>", "o", "<2-LeftMouse>" },
-    action = "edit",
-    desc = "open a file or folder; root will cd to the above directory",
-  },
-  {
-    key = "<C-e>",
-    action = "edit_in_place",
-    desc = "edit the file in place, effectively replacing the tree explorer",
-  },
-  {
-    key = "O",
-    action = "edit_no_picker",
-    desc = "same as (edit) with no window picker",
-  },
-  {
-    key = { "<C-]>", "<2-RightMouse>" },
-    action = "cd",
-    desc = "cd in the directory under the cursor",
-  },
-  {
-    key = "<C-v>",
-    action = "vsplit",
-    desc = "open the file in a vertical split",
-  },
-  {
-    key = "<C-x>",
-    action = "split",
-    desc = "open the file in a horizontal split",
-  },
-  {
-    key = "<C-t>",
-    action = "tabnew",
-    desc = "open the file in a new tab",
-  },
-  {
-    key = "<",
-    action = "prev_sibling",
-    desc = "navigate to the previous sibling of current file/directory",
-  },
-  {
-    key = ">",
-    action = "next_sibling",
-    desc = "navigate to the next sibling of current file/directory",
-  },
-  {
-    key = "P",
-    action = "parent_node",
-    desc = "move cursor to the parent directory",
-  },
-  {
-    key = "<BS>",
-    action = "close_node",
-    desc = "close current opened directory or parent",
-  },
-  {
-    key = "<Tab>",
-    action = "preview",
-    desc = "open the file as a preview (keeps the cursor in the tree)",
-  },
-  {
-    key = "K",
-    action = "first_sibling",
-    desc = "navigate to the first sibling of current file/directory",
-  },
-  {
-    key = "J",
-    action = "last_sibling",
-    desc = "navigate to the last sibling of current file/directory",
-  },
-  {
-    key = "C",
-    action = "toggle_git_clean",
-    desc = "toggle visibility of git clean via |filters.git_clean| option",
-  },
-  {
-    key = "I",
-    action = "toggle_git_ignored",
-    desc = "toggle visibility of files/folders hidden via |git.ignore| option",
-  },
-  {
-    key = "H",
-    action = "toggle_dotfiles",
-    desc = "toggle visibility of dotfiles via |filters.dotfiles| option",
-  },
-  {
-    key = "B",
-    action = "toggle_no_buffer",
-    desc = "toggle visibility of files/folders hidden via |filters.no_buffer| option",
-  },
-  {
-    key = "U",
-    action = "toggle_custom",
-    desc = "toggle visibility of files/folders hidden via |filters.custom| option",
-  },
-  {
-    key = "R",
-    action = "refresh",
-    desc = "refresh the tree",
-  },
-  {
-    key = "a",
-    action = "create",
-    desc = "add a file; leaving a trailing `/` will add a directory",
-  },
-  {
-    key = "d",
-    action = "remove",
-    desc = "delete a file (will prompt for confirmation)",
-  },
-  {
-    key = "D",
-    action = "trash",
-    desc = "trash a file via |trash| option",
-  },
-  {
-    key = "r",
-    action = "rename",
-    desc = "rename a file",
-  },
-  {
-    key = "<C-r>",
-    action = "full_rename",
-    desc = "rename a file and omit the filename on input",
-  },
-  {
-    key = "e",
-    action = "rename_basename",
-    desc = "rename a file with filename-modifiers ':t:r' without changing extension",
-  },
-  {
-    key = "x",
-    action = "cut",
-    desc = "add/remove file/directory to cut clipboard",
-  },
-  {
-    key = "c",
-    action = "copy",
-    desc = "add/remove file/directory to copy clipboard",
-  },
-  {
-    key = "p",
-    action = "paste",
-    desc = "paste from clipboard; cut clipboard has precedence over copy; will prompt for confirmation",
-  },
-  {
-    key = "y",
-    action = "copy_name",
-    desc = "copy name to system clipboard",
-  },
-  {
-    key = "Y",
-    action = "copy_path",
-    desc = "copy relative path to system clipboard",
-  },
-  {
-    key = "gy",
-    action = "copy_absolute_path",
-    desc = "copy absolute path to system clipboard",
-  },
-  {
-    key = "[e",
-    action = "prev_diag_item",
-    desc = "go to next diagnostic item",
-  },
-  {
-    key = "[c",
-    action = "prev_git_item",
-    desc = "go to next git item",
-  },
-  {
-    key = "]e",
-    action = "next_diag_item",
-    desc = "go to prev diagnostic item",
-  },
-  {
-    key = "]c",
-    action = "next_git_item",
-    desc = "go to prev git item",
-  },
-  {
-    key = "-",
-    action = "dir_up",
-    desc = "navigate up to the parent directory of the current file/directory",
-  },
-  {
-    key = "s",
-    action = "system_open",
-    desc = "open a file with default system application or a folder with default file manager, using |system_open| option",
-  },
-  {
-    key = "f",
-    action = "live_filter",
-    desc = "live filter nodes dynamically based on regex matching.",
-  },
-  {
-    key = "F",
-    action = "clear_live_filter",
-    desc = "clear live filter",
-  },
-  {
-    key = "q",
-    action = "close",
-    desc = "close tree window",
-  },
-  {
-    key = "W",
-    action = "collapse_all",
-    desc = "collapse the whole tree",
-  },
-  {
-    key = "E",
-    action = "expand_all",
-    desc = "expand the whole tree, stopping after expanding |actions.expand_all.max_folder_discovery| folders; this might hang neovim for a while if running on a big folder",
-  },
-  {
-    key = "S",
-    action = "search_node",
-    desc = "prompt the user to enter a path and then expands the tree to match the path",
-  },
-  {
-    key = ".",
-    action = "run_file_command",
-    desc = "enter vim command mode with the file the cursor is on",
-  },
-  {
-    key = "<C-k>",
-    action = "toggle_file_info",
-    desc = "toggle a popup with file infos about the file under the cursor",
-  },
-  {
-    key = "g?",
-    action = "toggle_help",
-    desc = "toggle help",
-  },
-  {
-    key = "m",
-    action = "toggle_mark",
-    desc = "Toggle node in bookmarks",
-  },
-  {
-    key = "bmv",
-    action = "bulk_move",
-    desc = "Move all bookmarked nodes into specified location",
-  },
-}
--- END_DEFAULT_MAPPINGS
-
-local M = {
-  mappings = {},
-  custom_keypress_funcs = {},
-}
-
-local function set_map_for(bufnr)
-  local opts = { noremap = true, silent = true, nowait = true, buffer = bufnr }
-  return function(mode, rhs)
-    return function(lhs)
-      vim.keymap.set(mode or "n", lhs, rhs, opts)
-    end
-  end
-end
-
-local function run_dispatch(action)
-  return function()
-    require("nvim-tree.actions.dispatch").dispatch(action)
-  end
-end
-
-function M.apply_mappings(bufnr)
-  local setter_for = set_map_for(bufnr)
-  for _, b in pairs(M.mappings) do
-    local rhs = b.cb or run_dispatch(b.action)
-    if rhs then
-      local setter = setter_for(b.mode, rhs)
-
-      local keys = type(b.key) == "table" and b.key or { b.key }
-      for _, key in pairs(keys) do
-        setter(key)
-      end
-    end
-  end
-end
-
-local function merge_mappings(user_mappings)
-  if #user_mappings == 0 then
-    return M.mappings
-  end
-
-  local function is_empty(s)
-    return s == ""
-  end
-
-  local user_keys = {}
-  local removed_keys = {}
-  -- remove default mappings if action is a empty string
-  for _, map in pairs(user_mappings) do
-    if type(map.key) == "table" then
-      for _, key in pairs(map.key) do
-        table.insert(user_keys, key)
-        if is_empty(map.action) then
-          table.insert(removed_keys, key)
-        end
-      end
-    else
-      table.insert(user_keys, map.key)
-      if is_empty(map.action) then
-        table.insert(removed_keys, map.key)
-      end
-    end
-
-    if map.action and type(map.action_cb) == "function" then
-      if not is_empty(map.action) then
-        M.custom_keypress_funcs[map.action] = map.action_cb
-      else
-        notify.warn "action can't be empty if action_cb provided"
-      end
-    end
-  end
-
-  local default_map = vim.tbl_filter(function(map)
-    if type(map.key) == "table" then
-      local filtered_keys = {}
-      for _, key in pairs(map.key) do
-        if not vim.tbl_contains(user_keys, key) and not vim.tbl_contains(removed_keys, key) then
-          table.insert(filtered_keys, key)
-        end
-      end
-      map.key = filtered_keys
-      return not vim.tbl_isempty(map.key)
-    else
-      return not vim.tbl_contains(user_keys, map.key) and not vim.tbl_contains(removed_keys, map.key)
-    end
-  end, M.mappings)
-
-  local user_map = vim.tbl_filter(function(map)
-    return not is_empty(map.action)
-  end, user_mappings)
-
-  return vim.fn.extend(default_map, user_map)
-end
-
-local function copy_mappings(user_mappings)
-  if #user_mappings == 0 then
-    return M.mappings
-  end
-
-  for _, map in pairs(user_mappings) do
-    if map.action and type(map.action_cb) == "function" then
-      M.custom_keypress_funcs[map.action] = map.action_cb
-    end
-  end
-
-  return user_mappings
-end
-
-local function cleanup_existing_mappings()
-  local bufnr = view.get_bufnr()
-  if bufnr == nil or not vim.api.nvim_buf_is_valid(bufnr) then
-    return
-  end
-
-  for _, b in pairs(M.mappings) do
-    local keys = type(b.key) == "table" and b.key or { b.key }
-    for _, key in pairs(keys) do
-      vim.keymap.del(b.mode or "n", key, { buffer = bufnr })
-    end
-  end
-end
-
-local function filter_mappings(mappings, keys)
-  if type(keys) == "boolean" and keys then
-    return {}
-  elseif type(keys) == "table" then
-    return vim.tbl_filter(function(m)
-      if type(m.key) == "table" then
-        m.key = vim.tbl_filter(function(k)
-          return not vim.tbl_contains(keys, k)
-        end, m.key)
-        return #m.key > 0
-      else
-        return not vim.tbl_contains(keys, m.key)
-      end
-    end, vim.deepcopy(mappings))
-  else
-    return vim.deepcopy(mappings)
-  end
-end
-
-local DEFAULT_MAPPING_CONFIG = {
-  custom_only = false,
-  list = {},
-}
+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.reloaders = require "nvim-tree.actions.reloaders"
+M.root = require "nvim-tree.actions.root"
+M.tree = require "nvim-tree.actions.tree"
 
 function M.setup(opts)
-  require("nvim-tree.actions.fs.trash").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)
-  require("nvim-tree.actions.root.change-dir").setup(opts)
-  require("nvim-tree.actions.fs.create-file").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)
-
-  cleanup_existing_mappings()
-
-  M.mappings = filter_mappings(DEFAULT_MAPPINGS, opts.remove_keymaps)
-
-  local user_map_config = (opts.view or {}).mappings or {}
-  local options = vim.tbl_deep_extend("force", DEFAULT_MAPPING_CONFIG, user_map_config)
-  if options.custom_only then
-    M.mappings = copy_mappings(options.list)
-  else
-    M.mappings = merge_mappings(options.list)
-  end
-
-  require("nvim-tree.actions.dispatch").setup(M.custom_keypress_funcs)
-
-  log.line("config", "active mappings")
-  log.raw("config", "%s\n", vim.inspect(M.mappings))
+  M.fs.setup(opts)
+  M.node.setup(opts)
+  M.root.setup(opts)
+  M.tree.setup(opts)
 end
 
 return M

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

@@ -0,0 +1,7 @@
+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

@@ -2,53 +2,235 @@ local utils = require "nvim-tree.utils"
 local view = require "nvim-tree.view"
 local core = require "nvim-tree.core"
 local lib = require "nvim-tree.lib"
-local explorer_common = require "nvim-tree.explorer.common"
+local explorer_node = require "nvim-tree.explorer.node"
+local diagnostics = require "nvim-tree.diagnostics"
 
 local M = {}
+local MAX_DEPTH = 100
 
-function M.fn(where, what)
-  return function()
-    local node_cur = lib.get_node_at_cursor()
-    local nodes_by_line = utils.get_nodes_by_line(core.get_explorer().nodes, core.get_nodes_starting_line())
+---Return the status of the node or nil if no status, depending on the type of
+---status.
+---@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
 
-    local cur, first, prev, nex = nil, nil, nil, nil
-    for line, node in pairs(nodes_by_line) do
-      local valid = false
-      if what == "git" then
-        valid = explorer_common.shows_git_status(node)
-      elseif what == "diag" then
-        valid = node.diag_status ~= nil
-      end
+  return false
+end
 
-      if not first and valid then
-        first = line
-      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 node_cur = lib.get_node_at_cursor()
+  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
 
-      if node == node_cur then
-        cur = line
-      elseif valid then
-        if not cur then
-          prev = line
-        end
-        if cur and not nex then
-          nex = line
-          break
-        end
-      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 where == "prev" then
-      if prev then
-        view.set_cursor { prev, 0 }
-      end
+    if node == node_cur 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
-      if cur then
-        if nex then
-          view.set_cursor { nex, 0 }
-        end
-      elseif first then
-        view.set_cursor { first, 0 }
+      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)
+  return function()
+    local recurse = false
+    local skip_gitignored = false
+
+    -- recurse only valid for git and diag moves.
+    if (opts.what == "git" or opts.what == "diag") and opts.recurse ~= nil then
+      recurse = opts.recurse
+    end
+
+    if opts.skip_gitignored ~= nil then
+      skip_gitignored = opts.skip_gitignored
+    end
+
+    if not recurse then
+      move(opts.where, opts.what, skip_gitignored)
+      return
+    end
+
+    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

@@ -2,25 +2,23 @@ local renderer = require "nvim-tree.renderer"
 local view = require "nvim-tree.view"
 local utils = require "nvim-tree.utils"
 local core = require "nvim-tree.core"
+local lib = require "nvim-tree.lib"
 
 local M = {}
 
+---@param should_close boolean|nil
+---@return fun(node: Node): boolean|nil
 function M.fn(should_close)
   should_close = should_close or false
 
   return function(node)
+    node = lib.get_last_group_node(node)
     if should_close and node.open then
       node.open = false
       return renderer.draw()
     end
 
-    local parent = node.parent
-
-    if renderer.config.group_empty and parent then
-      while parent.parent and parent.parent.group_next do
-        parent = parent.parent
-      end
-    end
+    local parent = utils.get_parent_of_group(node).parent
 
     if not parent or not parent.parent then
       return view.set_cursor { 1, 0 }

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

@@ -4,6 +4,8 @@ local Iterator = require "nvim-tree.iterators.node-iterator"
 
 local M = {}
 
+---@param direction string
+---@return fun(node: Node): nil
 function M.fn(direction)
   return function(node)
     if node.name == ".." or not direction then

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

@@ -2,8 +2,18 @@ local utils = require "nvim-tree.utils"
 
 local M = {}
 
+---@param node Node
+---@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)
@@ -21,6 +31,7 @@ end
 
 local current_popup = nil
 
+---@param node Node
 local function setup_window(node)
   local lines = get_formatted_lines(node)
 
@@ -52,6 +63,7 @@ function M.close_popup()
   end
 end
 
+---@param node Node
 function M.toggle_file_info(node)
   if node.name == ".." then
     return

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

@@ -0,0 +1,14 @@
+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,10 +1,13 @@
 -- Copyright 2019 Yazdani Kiyan under MIT License
 local lib = require "nvim-tree.lib"
+local notify = require "nvim-tree.notify"
 local utils = require "nvim-tree.utils"
 local view = require "nvim-tree.view"
 
 local M = {}
 
+---Get single char from user input
+---@return string
 local function get_user_input_char()
   local c = vim.fn.getchar()
   while type(c) ~= "number" do
@@ -60,6 +63,11 @@ local function pick_win_id()
     return selectable[1]
   end
 
+  if #M.window_picker.chars < #selectable then
+    notify.error(string.format("More windows (%d) than actions.open_file.window_picker.chars (%d).", #selectable, #M.window_picker.chars))
+    return nil
+  end
+
   local i = 1
   local win_opts = {}
   local win_map = {}
@@ -148,6 +156,20 @@ local function open_file_in_tab(filename)
   vim.cmd("tabe " .. vim.fn.fnameescape(filename))
 end
 
+local function drop(filename)
+  if M.quit_on_open then
+    view.close()
+  end
+  vim.cmd("drop " .. vim.fn.fnameescape(filename))
+end
+
+local function tab_drop(filename)
+  if M.quit_on_open then
+    view.close()
+  end
+  vim.cmd("tab :drop " .. vim.fn.fnameescape(filename))
+end
+
 local function on_preview(buf_loaded)
   if not buf_loaded then
     vim.bo.bufhidden = "delete"
@@ -164,18 +186,22 @@ local function on_preview(buf_loaded)
   view.focus()
 end
 
-local function get_target_winid(mode, win_ids)
+local function get_target_winid(mode)
   local target_winid
-  if not M.window_picker.enable or mode == "edit_no_picker" then
+  if not M.window_picker.enable or mode == "edit_no_picker" or mode == "preview_no_picker" then
     target_winid = lib.target_winid
 
     -- first available window
-    if not vim.tbl_contains(win_ids, target_winid) then
+    if not vim.tbl_contains(vim.api.nvim_tabpage_list_wins(0), target_winid) then
       target_winid = first_win_id()
     end
   else
     -- pick a window
-    target_winid = pick_win_id()
+    if type(M.window_picker.picker) == "function" then
+      target_winid = M.window_picker.picker()
+    else
+      target_winid = pick_win_id()
+    end
     if target_winid == nil then
       -- pick failed/cancelled
       return
@@ -197,20 +223,27 @@ local function set_current_win_no_autocmd(winid, autocmd)
   vim.opt.eventignore = eventignore
 end
 
-local function open_in_new_window(filename, mode, win_ids)
+local function open_in_new_window(filename, mode)
   if type(mode) ~= "string" then
     mode = ""
   end
 
-  local target_winid = get_target_winid(mode, win_ids)
+  local target_winid = get_target_winid(mode)
   if not target_winid then
     return
   end
 
-  local create_new_window = #vim.api.nvim_list_wins() == 1
+  -- non-floating, non-nvim-tree windows
+  local win_ids = vim.tbl_filter(function(id)
+    local config = vim.api.nvim_win_get_config(id)
+    local bufnr = vim.api.nvim_win_get_buf(id)
+    return config and config.relative == "" or utils.is_nvim_tree_buf(bufnr)
+  end, vim.api.nvim_list_wins())
+
+  local create_new_window = #win_ids == 1 -- This implies that the nvim-tree window is the only one
   local new_window_side = (view.View.side == "right") and "aboveleft" or "belowright"
 
-  -- Target is invalid or window does not exist in current tabpage: create new window
+  -- Target is invalid: create new window
   if not vim.tbl_contains(win_ids, target_winid) then
     vim.cmd(new_window_side .. " vsplit")
     target_winid = vim.api.nvim_get_current_win()
@@ -226,22 +259,26 @@ local function open_in_new_window(filename, mode, win_ids)
     -- 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
-      mode = "vsplit"
+      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
+  local command
   if create_new_window then
-    cmd = string.format("%s vsplit %s", new_window_side, fname)
+    -- 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
-    cmd = string.format("%s %s", mode, fname)
+    command = { cmd = mode, args = { fname } }
   else
-    cmd = string.format("edit %s", fname)
+    command = { cmd = "edit", args = { fname } }
   end
 
-  if mode == "preview" and view.View.float.enable then
+  if (mode == "preview" or mode == "preview_no_picker") and view.View.float.enable then
     -- ignore "WinLeave" autocmd on preview
     -- because the registered "WinLeave"
     -- will kill the floating window immediately
@@ -250,7 +287,7 @@ local function open_in_new_window(filename, mode, win_ids)
     set_current_win_no_autocmd(target_winid, { "BufEnter" })
   end
 
-  pcall(vim.cmd, cmd)
+  pcall(vim.cmd, command)
   lib.set_target_win()
 end
 
@@ -265,9 +302,11 @@ end
 
 local function edit_in_current_buf(filename)
   require("nvim-tree.view").abandon_current_window()
-  vim.cmd("edit " .. vim.fn.fnameescape(filename))
+  vim.cmd("keepalt keepjumps edit " .. vim.fn.fnameescape(filename))
 end
 
+---@param mode string
+---@param filename string
 function M.fn(mode, filename)
   if type(mode) ~= "string" then
     mode = ""
@@ -277,21 +316,27 @@ function M.fn(mode, filename)
     return open_file_in_tab(filename)
   end
 
+  if mode == "drop" then
+    return drop(filename)
+  end
+
+  if mode == "tab_drop" then
+    return tab_drop(filename)
+  end
+
   if mode == "edit_in_place" then
     return edit_in_current_buf(filename)
   end
 
-  local tabpage = vim.api.nvim_get_current_tabpage()
-  local win_ids = vim.api.nvim_tabpage_list_wins(tabpage)
   local buf_loaded = is_already_loaded(filename)
 
   local found_win = utils.get_win_buf_from_path(filename)
-  if found_win and mode == "preview" then
+  if found_win and (mode == "preview" or mode == "preview_no_picker") then
     return
   end
 
   if not found_win then
-    open_in_new_window(filename, mode, win_ids)
+    open_in_new_window(filename, mode)
   else
     vim.api.nvim_set_current_win(found_win)
     vim.bo.bufhidden = ""
@@ -301,7 +346,7 @@ function M.fn(mode, filename)
     view.resize()
   end
 
-  if mode == "preview" then
+  if mode == "preview" or mode == "preview_no_picker" then
     return on_preview(buf_loaded)
   end
 

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

@@ -6,14 +6,18 @@ local M = {}
 ---Retrieves the absolute path to the node.
 ---Safely handles the node representing the current directory
 ---(the topmost node in the nvim-tree window)
+---@param node Node
+---@return string
 local function get_node_path(node)
-  if node.name == ".." then
-    return utils.path_remove_trailing(core.get_cwd())
+  local cwd = core.get_cwd()
+  if node.name == ".." and cwd then
+    return utils.path_remove_trailing(cwd)
   else
     return node.absolute_path
   end
 end
 
+---@param node Node
 function M.run_file_command(node)
   local node_path = get_node_path(node)
   vim.api.nvim_input(": " .. node_path .. "<Home>")

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

@@ -1,13 +1,9 @@
 local notify = require "nvim-tree.notify"
+local utils = require "nvim-tree.utils"
 
-local M = {
-  config = {
-    is_windows = vim.fn.has "win32" == 1 or vim.fn.has "win32unix" == 1,
-    is_macos = vim.fn.has "mac" == 1 or vim.fn.has "macunix" == 1,
-    is_unix = vim.fn.has "unix" == 1,
-  },
-}
+local M = {}
 
+---@param node 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."
@@ -21,18 +17,22 @@ function M.fn(node)
     stderr = vim.loop.new_pipe(false),
   }
   table.insert(process.args, node.link_to or node.absolute_path)
-  process.handle, process.pid = vim.loop.spawn(
-    process.cmd,
-    { args = process.args, stdio = { nil, nil, process.stderr }, detached = true },
-    function(code)
-      process.stderr:read_stop()
-      process.stderr:close()
-      process.handle:close()
-      if code ~= 0 then
-        notify.warn(string.format("system_open failed with return code %d: %s", code, process.errors))
-      end
+
+  local opts = {
+    args = process.args,
+    stdio = { nil, nil, process.stderr },
+    detached = true,
+  }
+
+  process.handle, process.pid = vim.loop.spawn(process.cmd, opts, function(code)
+    process.stderr:read_stop()
+    process.stderr:close()
+    process.handle:close()
+    if code ~= 0 then
+      notify.warn(string.format("system_open failed with return code %d: %s", code, process.errors))
     end
-  )
+  end)
+
   table.remove(process.args)
   if not process.handle then
     notify.warn(string.format("system_open failed to spawn command '%s': %s", process.cmd, process.pid))
@@ -50,17 +50,18 @@ function M.fn(node)
 end
 
 function M.setup(opts)
+  M.config = {}
   M.config.system_open = opts.system_open or {}
 
   if #M.config.system_open.cmd == 0 then
-    if M.config.is_windows then
+    if utils.is_windows then
       M.config.system_open = {
         cmd = "cmd",
         args = { "/c", "start", '""' },
       }
-    elseif M.config.is_macos then
+    elseif utils.is_macos then
       M.config.system_open.cmd = "open"
-    elseif M.config.is_unix then
+    elseif utils.is_unix then
       M.config.system_open.cmd = "xdg-open"
     end
   end

lua/nvim-tree/actions/reloaders.lua

@@ -0,0 +1,71 @@
+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
+local function refresh_nodes(node, projects)
+  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 {})
+      end
+    end)
+    :recursor(function(n)
+      return n.group_next and { n.group_next } or (n.open and n.nodes)
+    end)
+    :iterate()
+end
+
+---@param parent_node Node|nil
+---@param projects table
+function M.reload_node_status(parent_node, projects)
+  if parent_node == nil then
+    return
+  end
+
+  local toplevel = git.get_toplevel(parent_node.absolute_path)
+  local status = projects[toplevel] or {}
+  for _, node in ipairs(parent_node.nodes) do
+    explorer_node.update_git_status(node, explorer_node.is_git_ignored(parent_node), status)
+    if node.nodes and #node.nodes > 0 then
+      M.reload_node_status(node, projects)
+    end
+  end
+end
+
+local event_running = false
+function M.reload_explorer()
+  if event_running or not core.get_explorer() or vim.v.exiting ~= vim.NIL then
+    return
+  end
+  event_running = true
+
+  local projects = git.reload()
+  refresh_nodes(core.get_explorer(), projects)
+  if view.is_visible() then
+    renderer.draw()
+  end
+  event_running = false
+end
+
+function M.reload_git()
+  if not core.get_explorer() or not git.config.git.enable or event_running then
+    return
+  end
+  event_running = true
+
+  local projects = git.reload()
+  M.reload_node_status(core.get_explorer(), projects)
+  renderer.draw()
+  event_running = false
+end
+
+return M

lua/nvim-tree/actions/reloaders/reloaders.lua

@@ -1,64 +0,0 @@
-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 M = {}
-
-local function refresh_nodes(node, projects, unloaded_bufnr)
-  local cwd = node.cwd or node.link_to or node.absolute_path
-  local project_root = git.get_project_root(cwd)
-  explorer_module.reload(node, projects[project_root] or {}, unloaded_bufnr)
-  for _, _node in ipairs(node.nodes) do
-    if _node.nodes and _node.open then
-      refresh_nodes(_node, projects, unloaded_bufnr)
-    end
-  end
-end
-
-function M.reload_node_status(parent_node, projects)
-  local project_root = git.get_project_root(parent_node.absolute_path)
-  local status = projects[project_root] or {}
-  for _, node in ipairs(parent_node.nodes) do
-    if node.nodes then
-      node.git_status = status.dirs and status.dirs[node.absolute_path]
-    else
-      node.git_status = status.files and status.files[node.absolute_path]
-    end
-    if node.nodes and #node.nodes > 0 then
-      M.reload_node_status(node, projects)
-    end
-  end
-end
-
-local event_running = false
----@param _ table unused node passed by action
----@param unloaded_bufnr number 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()
-  end
-  event_running = false
-end
-
-function M.reload_git()
-  if not core.get_explorer() or not git.config.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

@@ -6,9 +6,15 @@ local M = {
   current_tab = vim.api.nvim_get_current_tabpage(),
 }
 
+---@param name string
+---@return string|nil
 local function clean_input_cwd(name)
   name = vim.fn.fnameescape(name)
-  local root_parent_cwd = vim.fn.fnamemodify(utils.path_remove_trailing(core.get_cwd()), ":h")
+  local cwd = core.get_cwd()
+  if cwd == nil then
+    return
+  end
+  local root_parent_cwd = vim.fn.fnamemodify(utils.path_remove_trailing(cwd), ":h")
   if name == ".." and root_parent_cwd then
     return vim.fn.expand(root_parent_cwd)
   else
@@ -16,17 +22,23 @@ local function clean_input_cwd(name)
   end
 end
 
+---@param new_tabpage integer
+---@return boolean
 local function is_window_event(new_tabpage)
   local is_event_scope_window = vim.v.event.scope == "window" or vim.v.event.changed_window
   return is_event_scope_window and new_tabpage == M.current_tab
 end
 
+---@param foldername string
+---@return boolean
 local function prevent_cwd_change(foldername)
   local is_same_cwd = foldername == core.get_cwd()
   local is_restricted_above = M.options.restrict_above_cwd and foldername < vim.fn.getcwd(-1, -1)
   return is_same_cwd or is_restricted_above
 end
 
+---@param input_cwd string
+---@param with_open boolean|nil
 function M.fn(input_cwd, with_open)
   if not core.get_explorer() then
     return
@@ -38,7 +50,7 @@ function M.fn(input_cwd, with_open)
   end
 
   local foldername = clean_input_cwd(input_cwd)
-  if prevent_cwd_change(foldername) then
+  if foldername == nil or prevent_cwd_change(foldername) then
     return
   end
 
@@ -46,29 +58,36 @@ function M.fn(input_cwd, with_open)
   M.force_dirchange(foldername, with_open)
 end
 
+---@param global boolean
+---@param path string
 local function cd(global, path)
   vim.cmd((global and "cd " or "lcd ") .. vim.fn.fnameescape(path))
 end
 
+---@return boolean
 local function should_change_dir()
   return M.options.enable and vim.tbl_isempty(vim.v.event)
 end
 
+---@param f function
+---@return fun(foldername: string, should_open_view: boolean|nil)
 local function add_profiling_to(f)
   return function(foldername, should_open_view)
-    local ps = log.profile_start("change dir %s", foldername)
+    local profile = log.profile_start("change dir %s", foldername)
     f(foldername, should_open_view)
-    log.profile_end(ps, "change dir %s", foldername)
+    log.profile_end(profile)
   end
 end
 
 M.force_dirchange = add_profiling_to(function(foldername, should_open_view)
-  if should_change_dir() then
-    cd(M.options.global, foldername)
+  local valid_dir = vim.fn.isdirectory(foldername) == 1 -- prevent problems on non existing dirs
+  if valid_dir then
+    if should_change_dir() then
+      cd(M.options.global, foldername)
+    end
+    core.init(foldername)
   end
 
-  core.init(foldername)
-
   if should_open_view then
     require("nvim-tree.lib").open()
   else

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

@@ -3,13 +3,19 @@ local core = require "nvim-tree.core"
 
 local M = {}
 
+---@param node Node
 function M.fn(node)
   if not node or node.name == ".." then
-    return require("nvim-tree.actions.root.change-dir").fn ".."
+    require("nvim-tree.actions.root.change-dir").fn ".."
   else
-    local newdir = vim.fn.fnamemodify(utils.path_remove_trailing(core.get_cwd()), ":h")
+    local cwd = core.get_cwd()
+    if cwd == nil then
+      return
+    end
+
+    local newdir = vim.fn.fnamemodify(utils.path_remove_trailing(cwd), ":h")
     require("nvim-tree.actions.root.change-dir").fn(newdir)
-    return require("nvim-tree.actions.finders.find-file").fn(node.absolute_path)
+    require("nvim-tree.actions.finders.find-file").fn(node.absolute_path)
   end
 end
 

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

@@ -0,0 +1,10 @@
+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/find-file.lua

@@ -0,0 +1,70 @@
+local core = require "nvim-tree.core"
+local lib = require "nvim-tree.lib"
+local view = require "nvim-tree.view"
+local finders_find_file = require "nvim-tree.actions.finders.find-file"
+
+local M = {}
+
+--- Find file or buffer
+---@param opts ApiTreeFindFileOpts|nil|boolean legacy -> opts.buf
+function M.fn(opts)
+  -- legacy arguments
+  if type(opts) == "string" then
+    opts = {
+      buf = opts,
+    }
+  end
+  opts = opts or {}
+
+  -- do nothing if closed and open not requested
+  if not opts.open and not core.get_explorer() then
+    return
+  end
+
+  local bufnr, path
+
+  -- (optional) buffer number and path
+  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
+    if not vim.api.nvim_buf_is_valid(opts.buf) then
+      return
+    end
+    bufnr = tonumber(opts.buf)
+    path = vim.api.nvim_buf_get_name(bufnr)
+  elseif type(opts.buf) == "string" then
+    bufnr = nil
+    path = tostring(opts.buf)
+  else
+    return
+  end
+
+  if view.is_visible() then
+    -- focus
+    if opts.focus then
+      lib.set_target_win()
+      view.focus()
+    end
+  elseif opts.open then
+    -- open
+    lib.open { current_window = opts.current_window, winid = opts.winid }
+    if not opts.focus then
+      vim.cmd "noautocmd wincmd p"
+    end
+  end
+
+  -- update root
+  if opts.update_root or M.config.update_focused_file.update_root.enable then
+    require("nvim-tree").change_root(path, bufnr)
+  end
+
+  -- find
+  finders_find_file.fn(path)
+end
+
+function M.setup(opts)
+  M.config = opts or {}
+end
+
+return M

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

@@ -0,0 +1,15 @@
+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"
+
+function M.setup(opts)
+  M.find_file.setup(opts)
+  M.modifiers.setup(opts)
+  M.open.setup(opts)
+  M.toggle.setup(opts)
+end
+
+return M

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

@@ -1,10 +1,12 @@
 local renderer = require "nvim-tree.renderer"
 local utils = require "nvim-tree.utils"
 local core = require "nvim-tree.core"
+local lib = require "nvim-tree.lib"
 local Iterator = require "nvim-tree.iterators.node-iterator"
 
 local M = {}
 
+---@return fun(path: string): boolean
 local function buf_match()
   local buffer_paths = vim.tbl_map(function(buffer)
     return vim.api.nvim_buf_get_name(buffer)
@@ -21,26 +23,31 @@ local function buf_match()
   end
 end
 
+---@param keep_buffers boolean
 function M.fn(keep_buffers)
-  if not core.get_explorer() then
+  local node = lib.get_node_at_cursor()
+  local explorer = core.get_explorer()
+
+  if explorer == nil then
     return
   end
 
   local matches = buf_match()
 
-  Iterator.builder(core.get_explorer().nodes)
+  Iterator.builder(explorer.nodes)
     :hidden()
-    :applier(function(node)
-      if node.nodes ~= nil then
-        node.open = keep_buffers == true and matches(node.absolute_path)
+    :applier(function(n)
+      if n.nodes ~= nil then
+        n.open = keep_buffers == true and matches(n.absolute_path)
       end
     end)
     :recursor(function(n)
-      return n.nodes
+      return n.group_next and { n.group_next } or n.nodes
     end)
     :iterate()
 
   renderer.draw()
+  utils.focus_node_or_parent(node)
 end
 
 return M

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

@@ -2,9 +2,12 @@ local core = require "nvim-tree.core"
 local renderer = require "nvim-tree.renderer"
 local Iterator = require "nvim-tree.iterators.node-iterator"
 local notify = require "nvim-tree.notify"
+local lib = require "nvim-tree.lib"
 
 local M = {}
 
+---@param list string[]
+---@return table
 local function to_lookup_table(list)
   local table = {}
   for _, element in ipairs(list) do
@@ -14,13 +17,18 @@ local function to_lookup_table(list)
   return table
 end
 
+---@param node Node
 local function expand(node)
+  node = lib.get_last_group_node(node)
   node.open = true
   if #node.nodes == 0 then
     core.get_explorer():expand(node)
   end
 end
 
+---@param expansion_count integer
+---@param node Node
+---@return boolean
 local function should_expand(expansion_count, node)
   local should_halt = expansion_count >= M.MAX_FOLDER_DISCOVERY
   local should_exclude = M.EXCLUDE[node.name]
@@ -45,7 +53,7 @@ local function gen_iterator()
         end
       end)
       :recursor(function(node)
-        return expansion_count < M.MAX_FOLDER_DISCOVERY and node.open and node.nodes
+        return expansion_count < M.MAX_FOLDER_DISCOVERY and (node.group_next and { node.group_next } or (node.open and node.nodes))
       end)
       :iterate()
 
@@ -55,6 +63,7 @@ local function gen_iterator()
   end
 end
 
+---@param base_node table
 function M.fn(base_node)
   local node = base_node.nodes and base_node or core.get_explorer()
   if gen_iterator()(node) then

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

@@ -0,0 +1,11 @@
+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,38 +1,49 @@
-local view = require "nvim-tree.view"
+local lib = require "nvim-tree.lib"
+local utils = require "nvim-tree.utils"
 local filters = require "nvim-tree.explorer.filters"
-local renderer = require "nvim-tree.renderer"
-local reloaders = require "nvim-tree.actions.reloaders.reloaders"
+local reloaders = require "nvim-tree.actions.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
-  return reloaders.reload_explorer()
+  reload()
 end
 
 function M.git_ignored()
   filters.config.filter_git_ignored = not filters.config.filter_git_ignored
-  return reloaders.reload_explorer()
+  reload()
 end
 
 function M.git_clean()
   filters.config.filter_git_clean = not filters.config.filter_git_clean
-  return reloaders.reload_explorer()
+  reload()
 end
 
 function M.no_buffer()
   filters.config.filter_no_buffer = not filters.config.filter_no_buffer
-  return reloaders.reload_explorer()
+  reload()
+end
+
+function M.no_bookmark()
+  filters.config.filter_no_bookmark = not filters.config.filter_no_bookmark
+  reload()
 end
 
 function M.dotfiles()
   filters.config.filter_dotfiles = not filters.config.filter_dotfiles
-  return reloaders.reload_explorer()
+  reload()
 end
 
-function M.help()
-  view.toggle_help()
-  renderer.draw()
+function M.enable()
+  filters.config.enable = not filters.config.enable
+  reload()
 end
 
 return M

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

@@ -0,0 +1,55 @@
+local lib = require "nvim-tree.lib"
+local view = require "nvim-tree.view"
+local finders_find_file = require "nvim-tree.actions.finders.find-file"
+
+local M = {}
+
+---Open the tree, focusing if already open.
+---@param opts ApiTreeOpenOpts|nil|string legacy -> opts.path
+function M.fn(opts)
+  -- legacy arguments
+  if type(opts) == "string" then
+    opts = {
+      path = opts,
+    }
+  end
+  opts = opts or {}
+
+  local previous_buf = vim.api.nvim_get_current_buf()
+  local previous_path = vim.api.nvim_buf_get_name(previous_buf)
+
+  -- sanitise path
+  if type(opts.path) ~= "string" or vim.fn.isdirectory(opts.path) == 0 then
+    opts.path = nil
+  end
+
+  if view.is_visible() then
+    -- focus
+    lib.set_target_win()
+    view.focus()
+  else
+    -- open
+    lib.open {
+      path = opts.path,
+      current_window = opts.current_window,
+      winid = opts.winid,
+    }
+  end
+
+  -- find file
+  if M.config.update_focused_file.enable or opts.find_file then
+    -- update root
+    if opts.update_root then
+      require("nvim-tree").change_root(previous_path, previous_buf)
+    end
+
+    -- find
+    finders_find_file.fn(previous_path)
+  end
+end
+
+function M.setup(opts)
+  M.config = opts or {}
+end
+
+return M

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

@@ -0,0 +1,76 @@
+local lib = require "nvim-tree.lib"
+local view = require "nvim-tree.view"
+local finders_find_file = require "nvim-tree.actions.finders.find-file"
+
+local M = {}
+
+---Toggle the tree.
+---@param opts ApiTreeToggleOpts|nil|boolean legacy -> opts.find_file
+---@param no_focus string|nil legacy -> opts.focus
+---@param cwd boolean|nil legacy -> opts.path
+---@param bang boolean|nil legacy -> opts.update_root
+function M.fn(opts, no_focus, cwd, bang)
+  -- legacy arguments
+  if type(opts) == "boolean" then
+    opts = {
+      find_file = opts,
+    }
+    if type(cwd) == "string" then
+      opts.path = cwd
+    end
+    if type(no_focus) == "boolean" then
+      opts.focus = not no_focus
+    end
+    if type(bang) == "boolean" then
+      opts.update_root = bang
+    end
+  end
+  opts = opts or {}
+
+  -- defaults
+  if opts.focus == nil then
+    opts.focus = true
+  end
+
+  local previous_buf = vim.api.nvim_get_current_buf()
+  local previous_path = vim.api.nvim_buf_get_name(previous_buf)
+
+  -- sanitise path
+  if type(opts.path) ~= "string" or vim.fn.isdirectory(opts.path) == 0 then
+    opts.path = nil
+  end
+
+  if view.is_visible() then
+    -- close
+    view.close()
+  else
+    -- 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
+      -- update root
+      if opts.update_root then
+        require("nvim-tree").change_root(previous_path, previous_buf)
+      end
+
+      -- find
+      finders_find_file.fn(previous_path)
+    end
+
+    -- restore focus
+    if not opts.focus then
+      vim.cmd "noautocmd wincmd p"
+    end
+  end
+end
+
+function M.setup(opts)
+  M.config = opts or {}
+end
+
+return M

lua/nvim-tree/api.lua

@@ -1,130 +1,258 @@
+local lib = require "nvim-tree.lib"
+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 live_filter = require "nvim-tree.live-filter"
+local marks = require "nvim-tree.marks"
+local marks_navigation = require "nvim-tree.marks.navigation"
+local marks_bulk_delete = require "nvim-tree.marks.bulk-delete"
+local marks_bulk_trash = require "nvim-tree.marks.bulk-trash"
+local marks_bulk_move = require "nvim-tree.marks.bulk-move"
+local keymap = require "nvim-tree.keymap"
+local notify = require "nvim-tree.notify"
+
 local Api = {
   tree = {},
-  node = { navigate = { sibling = {}, git = {}, diagnostics = {} }, run = {}, open = {} },
+  node = {
+    navigate = {
+      sibling = {},
+      git = {},
+      diagnostics = {},
+      opened = {},
+    },
+    run = {},
+    open = {},
+  },
   events = {},
-  marks = { bulk = {}, navigate = {} },
-  fs = { copy = {} },
+  marks = {
+    bulk = {},
+    navigate = {},
+  },
+  fs = {
+    copy = {},
+  },
   git = {},
   live_filter = {},
+  config = {
+    mappings = {},
+  },
+  commands = {},
+  diagnostics = {},
 }
 
-local function inject_node(f)
-  return function(node, ...)
-    node = node or require("nvim-tree.lib").get_node_at_cursor()
-    f(node, ...)
+--- Do nothing when setup not called.
+--- f function to invoke
+---@param f function
+local function wrap(f)
+  return function(...)
+    if vim.g.NvimTreeSetup == 1 then
+      return f(...)
+    else
+      notify.error "nvim-tree setup not called"
+    end
   end
 end
 
-Api.tree.open = require("nvim-tree").open
-Api.tree.toggle = require("nvim-tree").toggle
-Api.tree.close = require("nvim-tree.view").close
-Api.tree.close_in_this_tab = require("nvim-tree.view").close_this_tab_only
-Api.tree.close_in_all_tabs = require("nvim-tree.view").close_all_tabs
-Api.tree.focus = require("nvim-tree").focus
-Api.tree.reload = require("nvim-tree.actions.reloaders.reloaders").reload_explorer
-Api.tree.change_root = require("nvim-tree").change_dir
-Api.tree.change_root_to_node = inject_node(function(node)
+---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()
+    if node then
+      fn(node, ...)
+    end
+  end
+end
+
+---Inject the node or nil as the first argument if absent.
+---@param fn function function to invoke
+local function wrap_node_or_nil(fn)
+  return function(node, ...)
+    node = node or lib.get_node_at_cursor()
+    fn(node, ...)
+  end
+end
+
+---@class ApiTreeOpenOpts
+---@field path string|nil path
+---@field current_window boolean|nil default false
+---@field winid number|nil
+---@field find_file boolean|nil default false
+---@field update_root boolean|nil default false
+
+Api.tree.open = wrap(actions.tree.open.fn)
+Api.tree.focus = Api.tree.open
+
+---@class ApiTreeToggleOpts
+---@field path string|nil
+---@field current_window boolean|nil default false
+---@field winid number|nil
+---@field find_file boolean|nil default false
+---@field update_root boolean|nil default false
+---@field focus boolean|nil default true
+
+Api.tree.toggle = wrap(actions.tree.toggle.fn)
+Api.tree.close = wrap(view.close)
+Api.tree.close_in_this_tab = wrap(view.close_this_tab_only)
+Api.tree.close_in_all_tabs = wrap(view.close_all_tabs)
+Api.tree.reload = wrap(actions.reloaders.reload_explorer)
+
+Api.tree.change_root = wrap(function(...)
+  require("nvim-tree").change_dir(...)
+end)
+
+Api.tree.change_root_to_node = wrap_node(function(node)
   if node.name == ".." then
-    require("nvim-tree.actions.root.change-dir").fn ".."
+    actions.root.change_dir.fn ".."
   elseif node.nodes ~= nil then
-    require("nvim-tree.actions.root.change-dir").fn(require("nvim-tree.lib").get_last_group_node(node).absolute_path)
+    actions.root.change_dir.fn(lib.get_last_group_node(node).absolute_path)
   end
 end)
-Api.tree.change_root_to_parent = inject_node(require("nvim-tree.actions.root.dir-up").fn)
-Api.tree.get_node_under_cursor = require("nvim-tree.lib").get_node_at_cursor
-Api.tree.get_nodes = require("nvim-tree.lib").get_nodes
-Api.tree.find_file = require("nvim-tree.actions.finders.find-file").fn
-Api.tree.search_node = require("nvim-tree.actions.finders.search-node").fn
-Api.tree.collapse_all = require("nvim-tree.actions.tree-modifiers.collapse-all").fn
-Api.tree.expand_all = inject_node(require("nvim-tree.actions.tree-modifiers.expand-all").fn)
-Api.tree.toggle_gitignore_filter = require("nvim-tree.actions.tree-modifiers.toggles").git_ignored
-Api.tree.toggle_git_clean_filter = require("nvim-tree.actions.tree-modifiers.toggles").git_clean
-Api.tree.toggle_no_buffer_filter = require("nvim-tree.actions.tree-modifiers.toggles").no_buffer
-Api.tree.toggle_custom_filter = require("nvim-tree.actions.tree-modifiers.toggles").custom
-Api.tree.toggle_hidden_filter = require("nvim-tree.actions.tree-modifiers.toggles").dotfiles
-Api.tree.toggle_help = require("nvim-tree.actions.tree-modifiers.toggles").help
 
-Api.fs.create = inject_node(require("nvim-tree.actions.fs.create-file").fn)
-Api.fs.remove = inject_node(require("nvim-tree.actions.fs.remove-file").fn)
-Api.fs.trash = inject_node(require("nvim-tree.actions.fs.trash").fn)
-Api.fs.rename_node = inject_node(require("nvim-tree.actions.fs.rename-file").fn ":t")
-Api.fs.rename = inject_node(require("nvim-tree.actions.fs.rename-file").fn ":t")
-Api.fs.rename_sub = inject_node(require("nvim-tree.actions.fs.rename-file").fn ":p")
-Api.fs.rename_basename = inject_node(require("nvim-tree.actions.fs.rename-file").fn ":t:r")
-Api.fs.cut = inject_node(require("nvim-tree.actions.fs.copy-paste").cut)
-Api.fs.paste = inject_node(require("nvim-tree.actions.fs.copy-paste").paste)
-Api.fs.clear_clipboard = require("nvim-tree.actions.fs.copy-paste").clear_clipboard
-Api.fs.print_clipboard = require("nvim-tree.actions.fs.copy-paste").print_clipboard
-Api.fs.copy.node = inject_node(require("nvim-tree.actions.fs.copy-paste").copy)
-Api.fs.copy.absolute_path = inject_node(require("nvim-tree.actions.fs.copy-paste").copy_absolute_path)
-Api.fs.copy.filename = inject_node(require("nvim-tree.actions.fs.copy-paste").copy_filename)
-Api.fs.copy.relative_path = inject_node(require("nvim-tree.actions.fs.copy-paste").copy_path)
+Api.tree.change_root_to_parent = wrap_node(actions.root.dir_up.fn)
+Api.tree.get_node_under_cursor = wrap(lib.get_node_at_cursor)
+Api.tree.get_nodes = wrap(lib.get_nodes)
 
+---@class ApiTreeFindFileOpts
+---@field buf string|number|nil
+---@field open boolean|nil default false
+---@field current_window boolean|nil default false
+---@field winid number|nil
+---@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.search_node = wrap(actions.finders.search_node.fn)
+Api.tree.collapse_all = wrap(actions.tree.modifiers.collapse_all.fn)
+Api.tree.expand_all = wrap_node(actions.tree.modifiers.expand_all.fn)
+Api.tree.toggle_enable_filters = wrap(actions.tree.modifiers.toggles.enable)
+Api.tree.toggle_gitignore_filter = wrap(actions.tree.modifiers.toggles.git_ignored)
+Api.tree.toggle_git_clean_filter = wrap(actions.tree.modifiers.toggles.git_clean)
+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_hidden_filter = wrap(actions.tree.modifiers.toggles.dotfiles)
+Api.tree.toggle_no_bookmark_filter = wrap(actions.tree.modifiers.toggles.no_bookmark)
+Api.tree.toggle_help = wrap(help.toggle)
+Api.tree.is_tree_buf = wrap(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)
+
+---@class ApiTreeWinIdOpts
+---@field tabpage number|nil default nil
+
+Api.tree.winid = wrap(view.winid)
+
+Api.fs.create = wrap_node_or_nil(actions.fs.create_file.fn)
+Api.fs.remove = wrap_node(actions.fs.remove_file.fn)
+Api.fs.trash = wrap_node(actions.fs.trash.fn)
+Api.fs.rename_node = wrap_node(actions.fs.rename_file.fn ":t")
+Api.fs.rename = wrap_node(actions.fs.rename_file.fn ":t")
+Api.fs.rename_sub = wrap_node(actions.fs.rename_file.fn ":p:h")
+Api.fs.rename_basename = wrap_node(actions.fs.rename_file.fn ":t:r")
+Api.fs.rename_full = wrap_node(actions.fs.rename_file.fn ":p")
+Api.fs.cut = wrap_node(actions.fs.copy_paste.cut)
+Api.fs.paste = wrap_node(actions.fs.copy_paste.paste)
+Api.fs.clear_clipboard = wrap(actions.fs.copy_paste.clear_clipboard)
+Api.fs.print_clipboard = wrap(actions.fs.copy_paste.print_clipboard)
+Api.fs.copy.node = wrap_node(actions.fs.copy_paste.copy)
+Api.fs.copy.absolute_path = wrap_node(actions.fs.copy_paste.copy_absolute_path)
+Api.fs.copy.filename = wrap_node(actions.fs.copy_paste.copy_filename)
+Api.fs.copy.basename = wrap_node(actions.fs.copy_paste.copy_basename)
+Api.fs.copy.relative_path = wrap_node(actions.fs.copy_paste.copy_path)
+
+---@param mode string
+---@param node table
 local function edit(mode, node)
   local path = node.absolute_path
   if node.link_to and not node.nodes then
     path = node.link_to
   end
-  require("nvim-tree.actions.node.open-file").fn(mode, path)
+  actions.node.open_file.fn(mode, path)
 end
 
-local function open_or_expand_or_dir_up(mode)
+---@param mode string
+---@return fun(node: table)
+local function open_or_expand_or_dir_up(mode, toggle_group)
   return function(node)
     if node.name == ".." then
-      require("nvim-tree.actions.root.change-dir").fn ".."
+      actions.root.change_dir.fn ".."
     elseif node.nodes then
-      require("nvim-tree.lib").expand_or_collapse(node)
-    else
+      lib.expand_or_collapse(node, toggle_group)
+    elseif not toggle_group then
       edit(mode, node)
     end
   end
 end
 
-local function open_preview(node)
-  if node.nodes or node.name == ".." then
-    return
-  end
+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.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.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.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.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_no_picker = wrap_node(open_or_expand_or_dir_up "preview_no_picker")
 
-  edit("preview", node)
-end
+Api.node.show_info_popup = wrap_node(actions.node.file_popup.toggle_file_info)
+Api.node.run.cmd = wrap_node(actions.node.run_command.run_file_command)
+Api.node.run.system = wrap_node(actions.node.system_open.fn)
 
-Api.node.open.edit = inject_node(open_or_expand_or_dir_up "edit")
-Api.node.open.replace_tree_buffer = inject_node(open_or_expand_or_dir_up "edit_in_place")
-Api.node.open.no_window_picker = inject_node(open_or_expand_or_dir_up "edit_no_picker")
-Api.node.open.vertical = inject_node(open_or_expand_or_dir_up "vsplit")
-Api.node.open.horizontal = inject_node(open_or_expand_or_dir_up "split")
-Api.node.open.tab = inject_node(open_or_expand_or_dir_up "tabnew")
-Api.node.open.preview = inject_node(open_preview)
+Api.node.navigate.sibling.next = wrap_node(actions.moves.sibling.fn "next")
+Api.node.navigate.sibling.prev = wrap_node(actions.moves.sibling.fn "prev")
+Api.node.navigate.sibling.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.node.show_info_popup = inject_node(require("nvim-tree.actions.node.file-popup").toggle_file_info)
-Api.node.run.cmd = inject_node(require("nvim-tree.actions.node.run-command").run_file_command)
-Api.node.run.system = inject_node(require("nvim-tree.actions.node.system-open").fn)
-Api.node.navigate.sibling.next = inject_node(require("nvim-tree.actions.moves.sibling").fn "next")
-Api.node.navigate.sibling.prev = inject_node(require("nvim-tree.actions.moves.sibling").fn "prev")
-Api.node.navigate.sibling.first = inject_node(require("nvim-tree.actions.moves.sibling").fn "first")
-Api.node.navigate.sibling.last = inject_node(require("nvim-tree.actions.moves.sibling").fn "last")
-Api.node.navigate.parent = inject_node(require("nvim-tree.actions.moves.parent").fn(false))
-Api.node.navigate.parent_close = inject_node(require("nvim-tree.actions.moves.parent").fn(true))
-Api.node.navigate.git.next = inject_node(require("nvim-tree.actions.moves.item").fn("next", "git"))
-Api.node.navigate.git.prev = inject_node(require("nvim-tree.actions.moves.item").fn("prev", "git"))
-Api.node.navigate.diagnostics.next = inject_node(require("nvim-tree.actions.moves.item").fn("next", "diag"))
-Api.node.navigate.diagnostics.prev = inject_node(require("nvim-tree.actions.moves.item").fn("prev", "diag"))
+Api.git.reload = wrap(actions.reloaders.reload_git)
 
-Api.git.reload = require("nvim-tree.actions.reloaders.reloaders").reload_git
+Api.events.subscribe = events.subscribe
+Api.events.Event = events.Event
 
-Api.events.subscribe = require("nvim-tree.events").subscribe
-Api.events.Event = require("nvim-tree.events").Event
+Api.live_filter.start = wrap(live_filter.start_filtering)
+Api.live_filter.clear = wrap(live_filter.clear_filter)
 
-Api.live_filter.start = require("nvim-tree.live-filter").start_filtering
-Api.live_filter.clear = require("nvim-tree.live-filter").clear_filter
+Api.marks.get = wrap_node(marks.get_mark)
+Api.marks.list = wrap(marks.get_marks)
+Api.marks.toggle = wrap_node(marks.toggle_mark)
+Api.marks.clear = wrap(marks.clear_marks)
+Api.marks.bulk.delete = wrap(marks_bulk_delete.bulk_delete)
+Api.marks.bulk.trash = wrap(marks_bulk_trash.bulk_trash)
+Api.marks.bulk.move = wrap(marks_bulk_move.bulk_move)
+Api.marks.navigate.next = wrap(marks_navigation.next)
+Api.marks.navigate.prev = wrap(marks_navigation.prev)
+Api.marks.navigate.select = wrap(marks_navigation.select)
 
-Api.marks.get = inject_node(require("nvim-tree.marks").get_mark)
-Api.marks.list = require("nvim-tree.marks").get_marks
-Api.marks.toggle = inject_node(require("nvim-tree.marks").toggle_mark)
-Api.marks.clear = require("nvim-tree.marks").clear_marks
-Api.marks.bulk.move = require("nvim-tree.marks.bulk-move").bulk_move
-Api.marks.navigate.next = require("nvim-tree.marks.navigation").next
-Api.marks.navigate.prev = require("nvim-tree.marks.navigation").prev
-Api.marks.navigate.select = require("nvim-tree.marks.navigation").select
+Api.config.mappings.get_keymap = wrap(keymap.get_keymap)
+Api.config.mappings.get_keymap_default = wrap(keymap.get_keymap_default)
+Api.config.mappings.default_on_attach = keymap.default_on_attach
+
+Api.diagnostics.hi_test = wrap(appearance_diagnostics.hi_test)
+
+Api.commands.get = wrap(function()
+  return require("nvim-tree.commands").get()
+end)
 
 return Api

lua/nvim-tree/appearance/diagnostics.lua

@@ -0,0 +1,136 @@
+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
+  vim.api.nvim_buf_set_option(bufnr, "modifiable", false)
+  vim.cmd.buffer(bufnr)
+end
+
+return M

lua/nvim-tree/appearance/init.lua

@@ -0,0 +1,208 @@
+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 = "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" },
+
+  -- 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
+    local hl_to
+    if vim.fn.has "nvim-0.9" == 1 then
+      hl_from = vim.api.nvim_get_hl(0, { name = from })
+      hl_to = vim.api.nvim_get_hl(0, { name = to })
+    else
+      hl_from = vim.api.nvim__get_hl_defs(0)[from] or {}
+      hl_to = vim.api.nvim__get_hl_defs(0)[to] or {}
+    end
+    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

@@ -0,0 +1,50 @@
+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 = 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._modified[path] ~= true
+        -- no need to keep going if already recorded
+        -- This also prevents an infinite loop
+      do
+        M._modified[path] = true
+        path = vim.fn.fnamemodify(path, ":h")
+      end
+    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

@@ -1,105 +0,0 @@
-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 },
-
-    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",
-    OpenedFolderIcon = "NvimTreeFolderIcon",
-    ClosedFolderIcon = "NvimTreeFolderIcon",
-    Normal = "Normal",
-    NormalNC = "NvimTreeNormal",
-    EndOfBuffer = "EndOfBuffer",
-    CursorLineNr = "CursorLineNr",
-    LineNr = "LineNr",
-    CursorLine = "CursorLine",
-    VertSplit = "VertSplit",
-    WinSeparator = "NvimTreeVertSplit",
-    CursorColumn = "CursorColumn",
-    FileDirty = "NvimTreeGitDirty",
-    FileNew = "NvimTreeGitNew",
-    FileRenamed = "NvimTreeGitRenamed",
-    FileMerge = "NvimTreeGitMerge",
-    FileStaged = "NvimTreeGitStaged",
-    FileDeleted = "NvimTreeGitDeleted",
-    FileIgnored = "NvimTreeGitIgnored",
-    Popup = "Normal",
-    GitIgnored = "Comment",
-    StatusLine = "StatusLine",
-    StatusLineNC = "StatusLineNC",
-    SignColumn = "NvimTreeNormal",
-  }
-end
-
-function M.setup()
-  local higlight_groups = get_hl_groups()
-  for k, d in pairs(higlight_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

@@ -0,0 +1,157 @@
+local api = require "nvim-tree.api"
+local view = require "nvim-tree.view"
+
+local M = {}
+
+local CMDS = {
+  {
+    name = "NvimTreeOpen",
+    opts = {
+      desc = "nvim-tree: open",
+      nargs = "?",
+      complete = "dir",
+    },
+    command = function(c)
+      api.tree.open { path = c.args }
+    end,
+  },
+  {
+    name = "NvimTreeClose",
+    opts = {
+      desc = "nvim-tree: close",
+      bar = true,
+    },
+    command = function()
+      api.tree.close()
+    end,
+  },
+  {
+    name = "NvimTreeToggle",
+    opts = {
+      desc = "nvim-tree: toggle",
+      nargs = "?",
+      complete = "dir",
+    },
+    command = function(c)
+      api.tree.toggle {
+        find_file = false,
+        focus = true,
+        path = c.args,
+        update_root = false,
+      }
+    end,
+  },
+  {
+    name = "NvimTreeFocus",
+    opts = {
+      desc = "nvim-tree: focus",
+      bar = true,
+    },
+    command = function()
+      api.tree.open()
+    end,
+  },
+  {
+    name = "NvimTreeRefresh",
+    opts = {
+      desc = "nvim-tree: refresh",
+      bar = true,
+    },
+    command = function()
+      api.tree.reload()
+    end,
+  },
+  {
+    name = "NvimTreeClipboard",
+    opts = {
+      desc = "nvim-tree: print clipboard",
+      bar = true,
+    },
+    command = function()
+      api.fs.print_clipboard()
+    end,
+  },
+  {
+    name = "NvimTreeFindFile",
+    opts = {
+      desc = "nvim-tree: find file",
+      bang = true,
+      bar = true,
+    },
+    command = function(c)
+      api.tree.find_file {
+        open = true,
+        focus = true,
+        update_root = c.bang,
+      }
+    end,
+  },
+  {
+    name = "NvimTreeFindFileToggle",
+    opts = {
+      desc = "nvim-tree: find file, toggle",
+      bang = true,
+      nargs = "?",
+      complete = "dir",
+    },
+    command = function(c)
+      api.tree.toggle {
+        find_file = true,
+        focus = true,
+        path = c.args,
+        update_root = c.bang,
+      }
+    end,
+  },
+  {
+    name = "NvimTreeResize",
+    opts = {
+      desc = "nvim-tree: resize",
+      nargs = 1,
+      bar = true,
+    },
+    command = function(c)
+      view.resize(c.args)
+    end,
+  },
+  {
+    name = "NvimTreeCollapse",
+    opts = {
+      desc = "nvim-tree: collapse",
+      bar = true,
+    },
+    command = function()
+      api.tree.collapse_all(false)
+    end,
+  },
+  {
+    name = "NvimTreeCollapseKeepBuffers",
+    opts = {
+      desc = "nvim-tree: collapse, keep directories open",
+      bar = true,
+    },
+    command = function()
+      api.tree.collapse_all(true)
+    end,
+  },
+  {
+    name = "NvimTreeHiTest",
+    opts = {
+      desc = "nvim-tree: highlight test",
+    },
+    command = api.diagnostics.hi_test,
+  },
+}
+
+function M.get()
+  return vim.deepcopy(CMDS)
+end
+
+function M.setup()
+  for _, cmd in ipairs(CMDS) do
+    local opts = vim.tbl_extend("force", cmd.opts, { force = true })
+    vim.api.nvim_create_user_command(cmd.name, cmd.command, opts)
+  end
+end
+
+return M

lua/nvim-tree/config.lua

@@ -1,10 +0,0 @@
--- INFO: DEPRECATED FILE, DO NOT ADD ANYTHING IN THERE
--- keeping to avoid breaking user configs. Will remove during a weekend.
-local M = {}
-
--- TODO: remove this once the cb property is not supported in mappings
-function M.nvim_tree_callback(callback_name)
-  return string.format("<cmd>lua require'nvim-tree.actions.dispatch'.dispatch('%s')<CR>", callback_name)
-end
-
-return M

lua/nvim-tree/core.lua

@@ -6,12 +6,13 @@ local log = require "nvim-tree.log"
 
 local M = {}
 
-TreeExplorer = nil
+---@type Explorer|nil
+local TreeExplorer = nil
 local first_init_done = false
 
+---@param foldername string
 function M.init(foldername)
-  local pn = string.format("core init %s", foldername)
-  local ps = log.profile_start(pn)
+  local profile = log.profile_start("core init %s", foldername)
 
   if TreeExplorer then
     TreeExplorer:destroy()
@@ -21,17 +22,24 @@ function M.init(foldername)
     events._dispatch_ready()
     first_init_done = true
   end
-  log.profile_end(ps, pn)
+  log.profile_end(profile)
 end
 
+---@return Explorer|nil
 function M.get_explorer()
   return TreeExplorer
 end
 
-function M.get_cwd()
-  return TreeExplorer.absolute_path
+function M.reset_explorer()
+  TreeExplorer = nil
 end
 
+---@return string|nil
+function M.get_cwd()
+  return TreeExplorer and TreeExplorer.absolute_path
+end
+
+---@return integer
 function M.get_nodes_starting_line()
   local offset = 1
   if view.is_root_folder_visible(M.get_cwd()) then

lua/nvim-tree/diagnostics.lua

@@ -1,39 +1,57 @@
 local utils = require "nvim-tree.utils"
 local view = require "nvim-tree.view"
-local core = require "nvim-tree.core"
 local log = require "nvim-tree.log"
 
 local M = {}
 
-local GROUP = "NvimTreeDiagnosticSigns"
-
-local severity_levels = { Error = 1, Warning = 2, Information = 3, Hint = 4 }
-local sign_names = {
-  { "NvimTreeSignError", "NvimTreeLspDiagnosticsError" },
-  { "NvimTreeSignWarning", "NvimTreeLspDiagnosticsWarning" },
-  { "NvimTreeSignInformation", "NvimTreeLspDiagnosticsInformation" },
-  { "NvimTreeSignHint", "NvimTreeLspDiagnosticsHint" },
+---COC severity level strings to LSP severity levels
+---@enum COC_SEVERITY_LEVELS
+local COC_SEVERITY_LEVELS = {
+  Error = 1,
+  Warning = 2,
+  Information = 3,
+  Hint = 4,
 }
 
-local function add_sign(linenr, severity)
-  local buf = view.get_bufnr()
-  if not vim.api.nvim_buf_is_valid(buf) or not vim.api.nvim_buf_is_loaded(buf) then
-    return
-  end
-  local sign_name = sign_names[severity][1]
-  vim.fn.sign_place(0, GROUP, sign_name, buf, { lnum = linenr, priority = 2 })
+---Absolute Node path to LSP severity level
+---@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 = {}
 
-  for _, diagnostic in ipairs(vim.diagnostic.get(nil, { severity = M.severity })) do
-    local buf = diagnostic.bufnr
-    if vim.api.nvim_buf_is_valid(buf) 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
+  local is_disabled = false
+  if vim.fn.has "nvim-0.9" == 1 then
+    is_disabled = vim.diagnostic.is_disabled()
+  end
+
+  if not is_disabled then
+    for _, diagnostic in ipairs(vim.diagnostic.get(nil, { severity = M.severity })) do
+      local buf = diagnostic.bufnr
+      if vim.api.nvim_buf_is_valid(buf) then
+        local bufname = uniformize_path(vim.api.nvim_buf_get_name(buf))
+        local severity = diagnostic.severity
+        local highest_severity = buffer_severity[bufname] or severity
+        buffer_severity[bufname] = math.min(highest_severity, severity)
       end
     end
   end
@@ -41,101 +59,147 @@ local function from_nvim_lsp()
   return buffer_severity
 end
 
-local function from_coc()
-  if vim.g.coc_service_initialized ~= 1 then
-    return {}
-  end
-
-  local diagnostic_list = vim.fn.CocAction "diagnosticList"
-  if type(diagnostic_list) ~= "table" or vim.tbl_isempty(diagnostic_list) then
-    return {}
-  end
-
-  local buffer_severity = {}
-  local diagnostics = {}
-
-  for _, diagnostic in ipairs(diagnostic_list) do
-    local bufname = diagnostic.file
-    local severity = severity_levels[diagnostic.severity]
-
-    local severity_list = diagnostics[bufname] or {}
-    table.insert(severity_list, severity)
-    diagnostics[bufname] = severity_list
-  end
-
-  for bufname, severity_list in pairs(diagnostics) do
-    if not buffer_severity[bufname] then
-      local severity = math.min(unpack(severity_list))
-      buffer_severity[bufname] = severity
-    end
-  end
-
-  return buffer_severity
+---Severity is within diagnostics.severity.min, diagnostics.severity.max
+---@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
+---@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
 
-function M.clear()
-  if not M.enable or not view.is_buf_valid(view.get_bufnr()) then
-    return
+---Marshal severities from COC. Does nothing when COC service not started.
+---@return NodeSeverities
+local function from_coc()
+  if not is_using_coc() then
+    return {}
   end
 
-  vim.fn.sign_unplace(GROUP)
+  local ok, diagnostic_list = xpcall(function()
+    return vim.fn.CocAction "diagnosticList"
+  end, handle_coc_exception)
+  if not ok or type(diagnostic_list) ~= "table" or vim.tbl_isempty(diagnostic_list) then
+    return {}
+  end
+
+  local buffer_severity = {}
+  for _, diagnostic in ipairs(diagnostic_list) do
+    local bufname = uniformize_path(diagnostic.file)
+    local coc_severity = COC_SEVERITY_LEVELS[diagnostic.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
 
-function M.update()
-  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 ps = log.profile_start "diagnostics update"
-    log.line("diagnostics", "update")
-
-    local buffer_severity
-    if is_using_coc() then
-      buffer_severity = from_coc()
-    else
-      buffer_severity = from_nvim_lsp()
-    end
-
-    M.clear()
-
-    local nodes_by_line = utils.get_nodes_by_line(core.get_explorer().nodes, core.get_nodes_starting_line())
-    for _, node in pairs(nodes_by_line) do
-      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)
-          if M.show_on_dirs and vim.startswith(bufpath, nodepath) 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
-            add_sign(line, severity)
-          elseif nodepath == bufpath then
-            log.line("diagnostics", " matched file node '%s'", node.absolute_path)
-            node.diag_status = severity
-            add_sign(line, severity)
-          end
+---Maybe retrieve severity level from the cache
+---@param node Node
+---@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
-    log.profile_end(ps, "diagnostics update")
+  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
+    return
+  end
+  utils.debounce("diagnostics", M.debounce_delay, function()
+    local profile = log.profile_start "diagnostics update"
+    if is_using_coc() then
+      NODE_SEVERITIES = from_coc()
+    else
+      NODE_SEVERITIES = from_nvim_lsp()
+    end
+    NODE_SEVERITIES_VERSION = NODE_SEVERITIES_VERSION + 1
+    if log.enabled "diagnostics" then
+      for bufname, severity in pairs(NODE_SEVERITIES) do
+        log.line("diagnostics", "Indexing bufname '%s' with severity %d", bufname, severity)
+      end
+    end
+    log.profile_end(profile)
+    if view.is_buf_valid(view.get_bufnr()) then
+      require("nvim-tree.renderer").draw()
+    end
   end)
 end
 
-local links = {
-  NvimTreeLspDiagnosticsError = "DiagnosticError",
-  NvimTreeLspDiagnosticsWarning = "DiagnosticWarn",
-  NvimTreeLspDiagnosticsInformation = "DiagnosticInfo",
-  NvimTreeLspDiagnosticsHint = "DiagnosticHint",
-}
+---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
@@ -148,14 +212,6 @@ function M.setup(opts)
 
   M.show_on_dirs = opts.diagnostics.show_on_dirs
   M.show_on_open_dirs = opts.diagnostics.show_on_open_dirs
-  vim.fn.sign_define(sign_names[1][1], { text = opts.diagnostics.icons.error, texthl = sign_names[1][2] })
-  vim.fn.sign_define(sign_names[2][1], { text = opts.diagnostics.icons.warning, texthl = sign_names[2][2] })
-  vim.fn.sign_define(sign_names[3][1], { text = opts.diagnostics.icons.info, texthl = sign_names[3][2] })
-  vim.fn.sign_define(sign_names[4][1], { text = opts.diagnostics.icons.hint, texthl = sign_names[4][2] })
-
-  for lhs, rhs in pairs(links) do
-    vim.cmd("hi def link " .. lhs .. " " .. rhs)
-  end
 end
 
 return M

lua/nvim-tree/enum.lua

@@ -0,0 +1,21 @@
+local M = {}
+
+---Setup options for "highlight_*"
+---@enum HL_POSITION
+M.HL_POSITION = {
+  none = 0,
+  icon = 1,
+  name = 2,
+  all = 4,
+}
+
+---Setup options for "*_placement"
+---@enum ICON_PLACEMENT
+M.ICON_PLACEMENT = {
+  none = 0,
+  signcolumn = 1,
+  before = 2,
+  after = 3,
+}
+
+return M

lua/nvim-tree/events.lua

@@ -10,23 +10,33 @@ M.Event = {
   NodeRenamed = "NodeRenamed",
   TreeOpen = "TreeOpen",
   TreeClose = "TreeClose",
+  WillCreateFile = "WillCreateFile",
   FileCreated = "FileCreated",
+  WillRemoveFile = "WillRemoveFile",
   FileRemoved = "FileRemoved",
   FolderCreated = "FolderCreated",
   FolderRemoved = "FolderRemoved",
   Resize = "Resize",
+  TreeAttachedPost = "TreeAttachedPost",
+  TreeRendered = "TreeRendered",
 }
 
+---@param event_name string
+---@return table
 local function get_handlers(event_name)
   return global_handlers[event_name] or {}
 end
 
+---@param event_name string
+---@param handler function
 function M.subscribe(event_name, handler)
   local handlers = get_handlers(event_name)
   table.insert(handlers, handler)
   global_handlers[event_name] = handlers
 end
 
+---@param event_name string
+---@param payload table|nil
 local function dispatch(event_name, payload)
   for _, handler in pairs(get_handlers(event_name)) do
     local success, error = pcall(handler, payload)
@@ -51,11 +61,21 @@ function M._dispatch_node_renamed(old_name, new_name)
   dispatch(M.Event.NodeRenamed, { old_name = old_name, new_name = new_name })
 end
 
+--@private
+function M._dispatch_will_remove_file(fname)
+  dispatch(M.Event.WillRemoveFile, { fname = fname })
+end
+
 --@private
 function M._dispatch_file_removed(fname)
   dispatch(M.Event.FileRemoved, { fname = fname })
 end
 
+--@private
+function M._dispatch_will_create_file(fname)
+  dispatch(M.Event.WillCreateFile, { fname = fname })
+end
+
 --@private
 function M._dispatch_file_created(fname)
   dispatch(M.Event.FileCreated, { fname = fname })
@@ -86,49 +106,14 @@ function M._dispatch_on_tree_resize(size)
   dispatch(M.Event.Resize, size)
 end
 
---- @deprecated
-function M.on_nvim_tree_ready(handler)
-  M.subscribe(M.Event.Ready, handler)
+--@private
+function M._dispatch_tree_attached_post(buf)
+  dispatch(M.Event.TreeAttachedPost, buf)
 end
 
---- @deprecated
-function M.on_node_renamed(handler)
-  M.subscribe(M.Event.NodeRenamed, handler)
-end
-
---- @deprecated
-function M.on_file_created(handler)
-  M.subscribe(M.Event.FileCreated, handler)
-end
-
---- @deprecated
-function M.on_file_removed(handler)
-  M.subscribe(M.Event.FileRemoved, handler)
-end
-
---- @deprecated
-function M.on_folder_created(handler)
-  M.subscribe(M.Event.FolderCreated, handler)
-end
-
---- @deprecated
-function M.on_folder_removed(handler)
-  M.subscribe(M.Event.FolderRemoved, handler)
-end
-
---- @deprecated
-function M.on_tree_open(handler)
-  M.subscribe(M.Event.TreeOpen, handler)
-end
-
---- @deprecated
-function M.on_tree_close(handler)
-  M.subscribe(M.Event.TreeClose, handler)
-end
-
---- @deprecated
-function M.on_tree_resize(handler)
-  M.subscribe(M.Event.Resize, handler)
+--@private
+function M._dispatch_on_tree_rendered(bufnr, winnr)
+  dispatch(M.Event.TreeRendered, { bufnr = bufnr, winnr = winnr })
 end
 
 return M

lua/nvim-tree/explorer/common.lua

@@ -1,74 +0,0 @@
-local M = {}
-
-local function get_dir_git_status(parent_ignored, status, absolute_path)
-  if parent_ignored then
-    return "!!"
-  end
-
-  local file_status = status.files and status.files[absolute_path]
-  if file_status then
-    return file_status
-  end
-
-  return status.dirs and status.dirs[absolute_path]
-end
-
-local function get_git_status(parent_ignored, status, absolute_path)
-  return parent_ignored and "!!" or status.files and status.files[absolute_path]
-end
-
-function M.has_one_child_folder(node)
-  return #node.nodes == 1 and node.nodes[1].nodes and vim.loop.fs_access(node.nodes[1].absolute_path, "R")
-end
-
-function M.update_git_status(node, parent_ignored, status)
-  -- status of the node's absolute path
-  if node.nodes then
-    node.git_status = get_dir_git_status(parent_ignored, status, node.absolute_path)
-  else
-    node.git_status = get_git_status(parent_ignored, status, node.absolute_path)
-  end
-
-  -- status of the link target, if the link itself is not dirty
-  if node.link_to and not node.git_status then
-    if node.nodes then
-      node.git_status = get_dir_git_status(parent_ignored, status, node.link_to)
-    else
-      node.git_status = get_git_status(parent_ignored, status, node.link_to)
-    end
-  end
-end
-
-function M.shows_git_status(node)
-  if not node.git_status then
-    -- status doesn't exist
-    return false
-  elseif not node.nodes then
-    -- status exist and is a file
-    return true
-  elseif not node.open then
-    -- status exist, is a closed dir
-    return M.config.git.show_on_dirs
-  else
-    -- status exist, is a open dir
-    return M.config.git.show_on_dirs and M.config.git.show_on_open_dirs
-  end
-end
-
-function M.node_destroy(node)
-  if not node then
-    return
-  end
-
-  if node.watcher then
-    node.watcher:destroy()
-  end
-end
-
-function M.setup(opts)
-  M.config = {
-    git = opts.git,
-  }
-end
-
-return M

lua/nvim-tree/explorer/explore.lua

@@ -1,20 +1,22 @@
 local utils = require "nvim-tree.utils"
 local builders = require "nvim-tree.explorer.node-builders"
-local common = require "nvim-tree.explorer.common"
+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 notify = require "nvim-tree.notify"
 local log = require "nvim-tree.log"
 
+local Watcher = require "nvim-tree.watcher"
+
 local M = {}
 
-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 = 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
@@ -24,15 +26,19 @@ local function populate_children(handle, cwd, node, git_status)
     end
 
     local abs = utils.path_join { cwd, name }
-    t = get_type_from(t, abs)
-    if not filters.should_filter(abs, filter_status) and not nodes_by_path[abs] then
+    local profile = log.profile_start("explore populate_children %s", abs)
+
+    ---@type uv.fs_stat.result|nil
+    local stat = vim.loop.fs_stat(abs)
+
+    if not filters.should_filter(abs, stat, 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)
+        child = builders.folder(node, abs, name, stat)
       elseif t == "file" then
-        child = builders.file(node, abs, name)
+        child = builders.file(node, abs, name, stat)
       elseif t == "link" then
-        local link = builders.link(node, abs, name)
+        local link = builders.link(node, abs, name, stat)
         if link.link_to ~= nil then
           child = link
         end
@@ -40,48 +46,45 @@ local function populate_children(handle, cwd, node, git_status)
       if child then
         table.insert(node.nodes, child)
         nodes_by_path[child.absolute_path] = true
-        common.update_git_status(child, node_ignored, git_status)
+        explorer_node.update_git_status(child, node_ignored, git_status)
       end
     end
+
+    log.profile_end(profile)
   end
 end
 
-local function get_dir_handle(cwd)
-  local handle = vim.loop.fs_scandir(cwd)
-  if type(handle) == "string" then
-    notify.error(handle)
-    return
-  end
-  return handle
-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 = get_dir_handle(cwd)
+  local handle = vim.loop.fs_scandir(cwd)
   if not handle then
     return
   end
 
-  local pn = string.format("explore init %s", node.absolute_path)
-  local ps = log.profile_start(pn)
+  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 = common.has_one_child_folder(node) and node.nodes[1]
+  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, status)
+    local ns = M.explore(child_folder_only, child_status)
     node.nodes = ns or {}
 
-    log.profile_end(ps, pn)
+    log.profile_end(profile)
     return ns
   end
 
-  sorters.merge_sort(node.nodes, sorters.node_comparator)
+  sorters.sort(node.nodes)
   live_filter.apply_filter(node)
 
-  log.profile_end(ps, pn)
+  log.profile_end(profile)
   return node.nodes
 end
 

lua/nvim-tree/explorer/filters.lua

@@ -1,10 +1,14 @@
 local utils = require "nvim-tree.utils"
+local marks = require "nvim-tree.marks"
 
 local M = {
   ignore_list = {},
   exclude_list = {},
+  custom_function = nil,
 }
 
+---@param path string
+---@return boolean
 local function is_excluded(path)
   for _, node in ipairs(M.exclude_list) do
     if path:match(node) then
@@ -24,7 +28,9 @@ local function git(path, git_status)
   end
 
   -- default status to clean
-  local status = git_status.files[path] or git_status.dirs[path] or "  "
+  local status = git_status.files[path]
+  status = status or git_status.dirs.direct[path] and git_status.dirs.direct[path][1]
+  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 M.config.filter_git_ignored and status == "!!" then
@@ -32,7 +38,7 @@ local function git(path, git_status)
   end
 
   -- filter clean
-  if M.config.filter_git_clean and status == "  " then
+  if M.config.filter_git_clean and not status then
     return true
   end
 
@@ -42,16 +48,15 @@ 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(path, bufinfo, unloaded_bufnr)
+local function buf(path, bufinfo)
   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) and b.bufnr ~= unloaded_bufnr then
+    if b.name == path or b.name:find(path .. "/", 1, true) then
       return false
     end
   end
@@ -59,10 +64,50 @@ local function buf(path, bufinfo, unloaded_bufnr)
   return true
 end
 
+---@param path string
+---@return boolean
 local function dotfile(path)
   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(path, path_type, bookmarks)
+  if not M.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(path)
   if not M.config.filter_custom then
     return false
@@ -70,6 +115,11 @@ local function custom(path)
 
   local basename = utils.path_basename(path)
 
+  -- filter user's custom function
+  if M.custom_function and M.custom_function(path) then
+    return true
+  end
+
   -- filter custom regexes
   local relpath = utils.path_relative(path, vim.loop.cwd())
   for pat, _ in pairs(M.ignore_list) do
@@ -89,58 +139,73 @@ local function custom(path)
 end
 
 ---Prepare arguments for should_filter. This is done prior to should_filter for efficiency reasons.
----@param git_status table results of git.load_project_status(...)
----@param unloaded_bufnr number optional bufnr recently unloaded via BufUnload event
+---@param git_status table|nil optional results of git.load_project_status(...)
 ---@return table
 --- git_status: reference
---- unloaded_bufnr: copy
 --- bufinfo: empty unless no_buffer set: vim.fn.getbufinfo { buflisted = 1 }
-function M.prepare(git_status, unloaded_bufnr)
+--- bookmarks: absolute paths to boolean
+function M.prepare(git_status)
   local status = {
     git_status = git_status or {},
-    unloaded_bufnr = unloaded_bufnr,
     bufinfo = {},
+    bookmarks = {},
   }
 
   if M.config.filter_no_buffer then
     status.bufinfo = vim.fn.getbufinfo { buflisted = 1 }
   end
 
+  for _, node in pairs(marks.get_marks()) do
+    status.bookmarks[node.absolute_path] = node.type
+  end
+
   return status
 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 M.should_filter(path, status)
+function M.should_filter(path, fs_stat, status)
+  if not M.config.enable then
+    return false
+  end
+
   -- exclusions override all filters
   if is_excluded(path) then
     return false
   end
 
   return git(path, status.git_status)
-    or buf(path, status.bufinfo, status.unloaded_bufnr)
+    or buf(path, status.bufinfo)
     or dotfile(path)
     or custom(path)
+    or bookmark(path, fs_stat and fs_stat.type, status.bookmarks)
 end
 
 function M.setup(opts)
   M.config = {
+    enable = opts.filters.enable,
     filter_custom = true,
     filter_dotfiles = opts.filters.dotfiles,
-    filter_git_ignored = opts.git.ignore,
+    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,
   }
 
   M.ignore_list = {}
   M.exclude_list = opts.filters.exclude
 
   local custom_filter = opts.filters.custom
-  if custom_filter and #custom_filter > 0 then
-    for _, filter_name in pairs(custom_filter) do
-      M.ignore_list[filter_name] = true
+  if type(custom_filter) == "function" then
+    M.custom_function = custom_filter
+  else
+    if custom_filter and #custom_filter > 0 then
+      for _, filter_name in pairs(custom_filter) do
+        M.ignore_list[filter_name] = true
+      end
     end
   end
 end

lua/nvim-tree/explorer/init.lua

@@ -1,17 +1,26 @@
 local git = require "nvim-tree.git"
 local watch = require "nvim-tree.explorer.watch"
-local common = require "nvim-tree.explorer.common"
+local explorer_node = require "nvim-tree.explorer.node"
 
 local M = {}
 
 M.explore = require("nvim-tree.explorer.explore").explore
 M.reload = require("nvim-tree.explorer.reload").reload
 
+---@class Explorer
+---@field absolute_path string
+---@field nodes Node[]
+---@field open boolean
+
 local Explorer = {}
 Explorer.__index = Explorer
 
+---@param cwd string|nil
+---@return Explorer
 function Explorer.new(cwd)
   cwd = vim.loop.fs_realpath(cwd or vim.loop.cwd())
+
+  ---@class Explorer
   local explorer = setmetatable({
     absolute_path = cwd,
     nodes = {},
@@ -22,19 +31,22 @@ function Explorer.new(cwd)
   return explorer
 end
 
+---@private
+---@param node Node
 function Explorer:_load(node)
   local cwd = node.link_to or node.absolute_path
-  local git_statuses = git.load_project_status(cwd)
-  M.explore(node, git_statuses)
+  local git_status = git.load_project_status(cwd)
+  M.explore(node, git_status)
 end
 
+---@param node Node
 function Explorer:expand(node)
   self:_load(node)
 end
 
 function Explorer:destroy()
   local function iterate(node)
-    common.node_destroy(node)
+    explorer_node.node_destroy(node)
     if node.nodes then
       for _, child in pairs(node.nodes) do
         iterate(child)
@@ -45,7 +57,7 @@ function Explorer:destroy()
 end
 
 function M.setup(opts)
-  require("nvim-tree.explorer.common").setup(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)

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

@@ -1,19 +1,21 @@
 local utils = require "nvim-tree.utils"
 local watch = require "nvim-tree.explorer.watch"
 
-local M = {
-  is_windows = vim.fn.has "win32" == 1,
-  is_wsl = vim.fn.has "wsl" == 1,
-}
+local M = {}
 
-function M.folder(parent, absolute_path, name)
+---@param parent Node
+---@param absolute_path string
+---@param name string
+---@param fs_stat uv.fs_stat.result|nil
+---@return Node
+function M.folder(parent, absolute_path, name, fs_stat)
   local handle = vim.loop.fs_scandir(absolute_path)
   local has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil
 
   local node = {
     type = "directory",
     absolute_path = absolute_path,
-    fs_stat = vim.loop.fs_stat(absolute_path),
+    fs_stat = fs_stat,
     group_next = nil, -- If node is grouped, this points to the next child dir/link node
     has_children = has_children,
     name = name,
@@ -27,32 +29,32 @@ function M.folder(parent, absolute_path, name)
   return node
 end
 
-function M.is_executable(parent, absolute_path, ext)
-  if M.is_windows then
-    return utils.is_windows_exe(ext)
-  elseif M.is_wsl then
-    if parent.is_wsl_windows_fs_path == nil then
-      -- Evaluate lazily when needed and do so only once for each parent
-      -- as 'wslpath' calls can get expensive in highly populated directories.
-      parent.is_wsl_windows_fs_path = utils.is_wsl_windows_fs_path(absolute_path)
-    end
-
-    if parent.is_wsl_windows_fs_path then
-      return utils.is_wsl_windows_fs_exe(ext)
-    end
+--- path is an executable file or directory
+---@param absolute_path string
+---@return boolean|nil
+function M.is_executable(absolute_path)
+  if utils.is_windows or utils.is_wsl then
+    --- executable detection on windows is buggy and not performant hence it is disabled
+    return false
+  else
+    return vim.loop.fs_access(absolute_path, "X")
   end
-  return vim.loop.fs_access(absolute_path, "X")
 end
 
-function M.file(parent, absolute_path, name)
+---@param parent Node
+---@param absolute_path string
+---@param name string
+---@param fs_stat uv.fs_stat.result|nil
+---@return Node
+function M.file(parent, absolute_path, name, fs_stat)
   local ext = string.match(name, ".?[^.]+%.(.*)") or ""
 
   return {
     type = "file",
     absolute_path = absolute_path,
-    executable = M.is_executable(parent, absolute_path, ext),
+    executable = M.is_executable(absolute_path),
     extension = ext,
-    fs_stat = vim.loop.fs_stat(absolute_path),
+    fs_stat = fs_stat,
     name = name,
     parent = parent,
   }
@@ -63,7 +65,12 @@ end
 -- links (for instance libr2.so in /usr/lib) and thus even with a C program realpath fails
 -- when it has no real reason to. Maybe there is a reason, but errno is definitely wrong.
 -- So we need to check for link_to ~= nil when adding new links to the main tree
-function M.link(parent, absolute_path, name)
+---@param parent Node
+---@param absolute_path string
+---@param name string
+---@param fs_stat uv.fs_stat.result|nil
+---@return Node
+function M.link(parent, absolute_path, name, fs_stat)
   --- I dont know if this is needed, because in my understanding, there isn't hard links in windows, but just to be sure i changed it.
   local link_to = vim.loop.fs_realpath(absolute_path)
   local open, nodes, has_children
@@ -80,7 +87,7 @@ function M.link(parent, absolute_path, name)
   local node = {
     type = "link",
     absolute_path = absolute_path,
-    fs_stat = vim.loop.fs_stat(absolute_path),
+    fs_stat = fs_stat,
     group_next = nil, -- If node is grouped, this points to the next child dir/link node
     has_children = has_children,
     link_to = link_to,

lua/nvim-tree/explorer/node.lua

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

lua/nvim-tree/explorer/reload.lua

@@ -1,80 +1,107 @@
 local utils = require "nvim-tree.utils"
 local builders = require "nvim-tree.explorer.node-builders"
-local common = require "nvim-tree.explorer.common"
+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 notify = require "nvim-tree.notify"
 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
-      common.update_git_status(node, node_ignored, status)
+      explorer_node.update_git_status(node, node_ignored, status)
     end
     return node
   end
 end
 
-local function reload_and_get_git_project(path)
-  local project_root = git.get_project_root(path)
-  git.reload_project(project_root, path)
-  return project_root, git.get_project(project_root) or {}
+---@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 and node.absolute_path ~= root do
-    common.update_git_status(node, false, project)
+  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
 
-function M.reload(node, git_status, unloaded_bufnr)
+---@param node Node
+---@param git_status table
+function M.reload(node, git_status)
   local cwd = node.link_to or node.absolute_path
   local handle = vim.loop.fs_scandir(cwd)
-  if type(handle) == "string" then
-    notify.error(handle)
+  if not handle then
     return
   end
 
-  local ps = log.profile_start("reload %s", node.absolute_path)
+  local profile = log.profile_start("reload %s", node.absolute_path)
 
-  local filter_status = filters.prepare(git_status, unloaded_bufnr)
+  local filter_status = filters.prepare(git_status)
 
   if node.group_next then
     node.nodes = { node.group_next }
     node.group_next = nil
   end
 
-  local child_names = {}
+  local remain_childs = {}
 
-  local node_ignored = node.git_status == "!!"
+  local node_ignored = explorer_node.is_git_ignored(node)
+  ---@type table<string, Node>
   local nodes_by_path = utils.key_by(node.nodes, "absolute_path")
   while true do
-    local ok, name, t = pcall(vim.loop.fs_scandir_next, handle)
-    if not ok or not name then
+    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
+    ---@type uv.fs_stat.result|nil
+    local stat = vim.loop.fs_stat(abs)
+
+    if not filters.should_filter(abs, stat, filter_status) then
+      remain_childs[abs] = true
 
       -- Recreate node if type changes.
       if nodes_by_path[abs] then
@@ -82,32 +109,32 @@ function M.reload(node, git_status, unloaded_bufnr)
 
         if n.type ~= t then
           utils.array_remove(node.nodes, n)
-          common.node_destroy(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") then
-          local folder = builders.folder(node, abs, name)
-          nodes_by_path[abs] = folder
-          table.insert(node.nodes, folder)
+        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
-          local file = builders.file(node, abs, name)
-          nodes_by_path[abs] = file
-          table.insert(node.nodes, file)
+          new_child = builders.file(node, abs, name, stat)
         elseif t == "link" then
-          local link = builders.link(node, abs, name)
+          local link = builders.link(node, abs, name, stat)
           if link.link_to ~= nil then
-            nodes_by_path[abs] = link
-            table.insert(node.nodes, link)
+            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(n.parent, abs, n.extension or "")
-          n.fs_stat = fs_stat_cached(abs)
+          n.executable = builders.is_executable(abs) or false
+          n.fs_stat = stat
         end
       end
     end
@@ -116,78 +143,86 @@ function M.reload(node, git_status, unloaded_bufnr)
   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]
+      if remain_childs[n.absolute_path] then
+        return remain_childs[n.absolute_path]
       else
-        common.node_destroy(n)
-        return nil
+        explorer_node.node_destroy(n)
+        return false
       end
     end, node.nodes)
   )
 
   local is_root = not node.parent
-  local child_folder_only = common.has_one_child_folder(node) and node.nodes[1]
+  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(ps, "reload %s", node.absolute_path)
+    log.profile_end(profile)
     return ns
   end
 
-  sorters.merge_sort(node.nodes, sorters.node_comparator)
+  sorters.sort(node.nodes)
   live_filter.apply_filter(node)
-  log.profile_end(ps, "reload %s", node.absolute_path)
+  log.profile_end(profile)
   return node.nodes
 end
 
 ---Refresh contents and git status for a single node
----@param node table
-function M.refresh_node(node)
+---@param node Node
+---@param callback function
+function M.refresh_node(node, callback)
   if type(node) ~= "table" then
-    return
+    callback()
   end
 
   local parent_node = utils.get_parent_of_group(node)
 
-  local project_root, project = reload_and_get_git_project(node.absolute_path)
+  reload_and_get_git_project(node.absolute_path, function(toplevel, project)
+    require("nvim-tree.explorer.reload").reload(parent_node, project)
 
-  require("nvim-tree.explorer.reload").reload(parent_node, project)
+    update_parent_statuses(parent_node, project, toplevel)
 
-  update_parent_statuses(parent_node, project, project_root)
+    callback()
+  end)
 end
 
----Refresh contents and git status for all nodes to a path: actual directory and links
+---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_nodes_for_path(path)
+function M.refresh_parent_nodes_for_path(path)
   local explorer = require("nvim-tree.core").get_explorer()
   if not explorer then
     return
   end
 
-  local pn = string.format("refresh_nodes_for_path %s", path)
-  local ps = log.profile_start(pn)
+  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 })
-    :hidden()
     :recursor(function(node)
-      if node.group_next then
-        return { node.group_next }
-      end
-      if node.nodes then
-        return node.nodes
-      end
+      return node.nodes
     end)
     :applier(function(node)
-      local abs_contains = node.absolute_path and path:match("^" .. node.absolute_path)
-      local link_contains = node.link_to and path:match("^" .. node.link_to)
+      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
-        M.refresh_node(node)
+        table.insert(parent_nodes, node)
       end
     end)
     :iterate()
 
-  log.profile_end(ps, pn)
+  -- 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)

lua/nvim-tree/explorer/sorters.lua

@@ -1,7 +1,13 @@
-local M = {
-  sort_by = nil,
-  node_comparator = nil,
-}
+local M = {}
+
+local C = {}
+
+--- Predefined comparator, defaulting to name
+---@param sorter string as per options
+---@return function
+local function get_comparator(sorter)
+  return C[sorter] or C.name
+end
 
 ---Create a shallow copy of a portion of a list.
 ---@param t table
@@ -17,6 +23,29 @@ local function tbl_slice(t, first, last)
   return slice
 end
 
+---Evaluate `sort.folders_first` and `sort.files_first`
+---@param a Node
+---@param b Node
+---@return boolean|nil
+local function folders_or_files_first(a, b)
+  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 M.config.sort.files_first
+  elseif a.nodes and not b.nodes then
+    -- folder <> file
+    return not M.config.sort.files_first
+  end
+end
+
+---@param t table
+---@param first number
+---@param mid number
+---@param last number
+---@param comparator fun(a: Node, b: Node): boolean
 local function merge(t, first, mid, last, comparator)
   local n1 = mid - first + 1
   local n2 = last - mid
@@ -50,6 +79,10 @@ local function merge(t, first, mid, last, comparator)
   end
 end
 
+---@param t table
+---@param first number
+---@param last number
+---@param comparator fun(a: Node, b: Node): boolean
 local function split_merge(t, first, last, comparator)
   if (last - first) < 1 then
     return
@@ -62,11 +95,10 @@ local function split_merge(t, first, last, comparator)
   merge(t, first, mid, last, comparator)
 end
 
----Perform a merge sort on a given list.
----@param t any[]
----@param comparator function|nil
-function M.merge_sort(t, comparator)
-  if type(M.sort_by) == "function" then
+---Perform a merge sort using sorter option.
+---@param t table nodes
+function M.sort(t)
+  if C.user then
     local t_user = {}
     local origin_index = {}
 
@@ -75,6 +107,7 @@ function M.merge_sort(t, comparator)
         absolute_path = n.absolute_path,
         executable = n.executable,
         extension = n.extension,
+        filetype = vim.filetype.match { filename = n.name },
         link_to = n.link_to,
         name = n.name,
         type = n.type,
@@ -82,7 +115,11 @@ function M.merge_sort(t, comparator)
       table.insert(origin_index, n)
     end
 
-    M.sort_by(t_user)
+    local predefined = C.user(t_user)
+    if predefined then
+      split_merge(t, 1, #t, get_comparator(predefined))
+      return
+    end
 
     -- do merge sort for prevent memory exceed
     local user_index = {}
@@ -105,23 +142,22 @@ function M.merge_sort(t, comparator)
 
     split_merge(t, 1, #t, mini_comparator) -- sort by user order
   else
-    if not comparator then
-      comparator = function(left, right)
-        return left < right
-      end
-    end
-    split_merge(t, 1, #t, comparator)
+    split_merge(t, 1, #t, get_comparator(M.config.sort.sorter))
   end
 end
 
+---@param a Node
+---@param b Node
+---@param ignorecase boolean|nil
+---@return boolean
 local function node_comparator_name_ignorecase_or_not(a, b, ignorecase)
   if not (a and b) then
     return true
   end
-  if a.nodes and not b.nodes then
-    return true
-  elseif not a.nodes and b.nodes then
-    return false
+
+  local early_return = folders_or_files_first(a, b)
+  if early_return ~= nil then
+    return early_return
   end
 
   if ignorecase then
@@ -131,22 +167,22 @@ local function node_comparator_name_ignorecase_or_not(a, b, ignorecase)
   end
 end
 
-function M.node_comparator_name_case_sensisive(a, b)
+function C.case_sensitive(a, b)
   return node_comparator_name_ignorecase_or_not(a, b, false)
 end
 
-function M.node_comparator_name_ignorecase(a, b)
+function C.name(a, b)
   return node_comparator_name_ignorecase_or_not(a, b, true)
 end
 
-function M.node_comparator_modification_time(a, b)
+function C.modification_time(a, b)
   if not (a and b) then
     return true
   end
-  if a.nodes and not b.nodes then
-    return true
-  elseif not a.nodes and b.nodes then
-    return false
+
+  local early_return = folders_or_files_first(a, b)
+  if early_return ~= nil then
+    return early_return
   end
 
   local last_modified_a = 0
@@ -163,19 +199,63 @@ function M.node_comparator_modification_time(a, b)
   return last_modified_b <= last_modified_a
 end
 
-function M.node_comparator_extension(a, b)
+function C.suffix(a, b)
   if not (a and b) then
     return true
   end
 
-  if a.nodes and not b.nodes then
-    return true
-  elseif not a.nodes and b.nodes then
-    return false
+  -- directories go first
+  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)
   end
 
-  if not (a.extension and b.extension) then
+  -- dotfiles go second
+  if a.name:sub(1, 1) == "." and b.name:sub(1, 1) ~= "." then
     return true
+  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)
+  end
+
+  -- unsuffixed go third
+  local a_suffix_ndx = a.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)
+  end
+
+  -- finally, compare by suffixes
+  local a_suffix = a.name:sub(a_suffix_ndx)
+  local b_suffix = b.name:sub(b_suffix_ndx)
+
+  if a_suffix and not b_suffix then
+    return true
+  elseif not a_suffix and b_suffix then
+    return false
+  elseif a_suffix:lower() == b_suffix:lower() then
+    return C.name(a, b)
+  end
+
+  return a_suffix:lower() < b_suffix:lower()
+end
+
+function C.extension(a, b)
+  if not (a and b) then
+    return true
+  end
+
+  local early_return = folders_or_files_first(a, b)
+  if early_return ~= nil then
+    return early_return
   end
 
   if a.extension and not b.extension then
@@ -184,21 +264,46 @@ function M.node_comparator_extension(a, b)
     return false
   end
 
-  return a.extension:lower() <= b.extension:lower()
+  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)
+  end
+
+  return a_ext < b_ext
+end
+
+function C.filetype(a, b)
+  local a_ft = vim.filetype.match { filename = a.name }
+  local b_ft = vim.filetype.match { filename = b.name }
+
+  -- directories first
+  local early_return = folders_or_files_first(a, b)
+  if early_return ~= nil then
+    return early_return
+  end
+
+  -- one is nil, the other wins
+  if a_ft and not b_ft then
+    return true
+  elseif not a_ft and b_ft then
+    return false
+  end
+
+  -- same filetype or both nil, sort by name
+  if a_ft == b_ft then
+    return C.name(a, b)
+  end
+
+  return a_ft < b_ft
 end
 
 function M.setup(opts)
-  M.sort_by = opts.sort_by
-  if M.sort_by and type(M.sort_by) == "function" then
-    M.node_comparator = M.sort_by
-  elseif M.sort_by == "modification_time" then
-    M.node_comparator = M.node_comparator_modification_time
-  elseif M.sort_by == "case_sensitive" then
-    M.node_comparator = M.node_comparator_name_case_sensisive
-  elseif M.sort_by == "extension" then
-    M.node_comparator = M.node_comparator_extension
-  else
-    M.node_comparator = M.node_comparator_name_ignorecase
+  M.config = {}
+  M.config.sort = opts.sort
+
+  if type(M.config.sort.sorter) == "function" then
+    C.user = M.config.sort.sorter
   end
 end
 

lua/nvim-tree/explorer/watch.lua

@@ -2,10 +2,25 @@ local log = require "nvim-tree.log"
 local utils = require "nvim-tree.utils"
 local Watcher = require("nvim-tree.watcher").Watcher
 
-local M = {}
+local M = {
+  config = {},
+  uid = 0,
+}
 
+---@param path string
+---@return boolean
 local function is_git(path)
-  return vim.fn.fnamemodify(path, ":t") == ".git"
+  -- If $GIT_DIR is set, consider its value to be equivalent to '.git'.
+  -- Expand $GIT_DIR (and `path`) to a full path (see :help filename-modifiers), since
+  -- it's possible to set it to a relative path. We want to make our best
+  -- effort to expand that to a valid absolute path.
+  if vim.fn.fnamemodify(path, ":p") == vim.fn.fnamemodify(vim.env.GIT_DIR, ":p") then
+    return true
+  elseif vim.fn.fnamemodify(path, ":t") == ".git" then
+    return true
+  else
+    return false
+  end
 end
 
 local IGNORED_PATHS = {
@@ -16,6 +31,8 @@ local IGNORED_PATHS = {
   "/dev",
 }
 
+---@param path string
+---@return boolean
 local function is_folder_ignored(path)
   for _, folder in ipairs(IGNORED_PATHS) do
     if vim.startswith(path, folder) then
@@ -23,7 +40,7 @@ local function is_folder_ignored(path)
     end
   end
 
-  for _, ignore_dir in ipairs(M.ignore_dirs) do
+  for _, ignore_dir in ipairs(M.config.filesystem_watchers.ignore_dirs) do
     if vim.fn.match(path, ignore_dir) ~= -1 then
       return true
     end
@@ -32,32 +49,32 @@ local function is_folder_ignored(path)
   return false
 end
 
+---@param node Node
+---@return Watcher|nil
 function M.create_watcher(node)
-  if not M.enabled or type(node) ~= "table" then
+  if not M.config.filesystem_watchers.enable or type(node) ~= "table" then
     return nil
   end
 
-  local path
-  if node.type == "link" then
-    path = node.link_to
-  else
-    path = node.absolute_path
-  end
-
+  local path = node.link_to or node.absolute_path
   if is_git(path) or is_folder_ignored(path) then
     return nil
   end
 
   local function callback(watcher)
     log.line("watcher", "node event scheduled refresh %s", watcher.context)
-    utils.debounce(watcher.context, M.debounce_delay, function()
+    utils.debounce(watcher.context, M.config.filesystem_watchers.debounce_delay, function()
+      if watcher.destroyed then
+        return
+      end
       if node.link_to then
         log.line("watcher", "node event executing refresh '%s' -> '%s'", node.link_to, node.absolute_path)
       else
         log.line("watcher", "node event executing refresh '%s'", node.absolute_path)
       end
-      require("nvim-tree.explorer.reload").refresh_node(node)
-      require("nvim-tree.renderer").draw()
+      require("nvim-tree.explorer.reload").refresh_node(node, function()
+        require("nvim-tree.renderer").draw()
+      end)
     end)
   end
 
@@ -68,9 +85,7 @@ function M.create_watcher(node)
 end
 
 function M.setup(opts)
-  M.enabled = opts.filesystem_watchers.enable
-  M.debounce_delay = opts.filesystem_watchers.debounce_delay
-  M.ignore_dirs = opts.filesystem_watchers.ignore_dirs
+  M.config.filesystem_watchers = opts.filesystem_watchers
   M.uid = 0
 end
 

lua/nvim-tree/git/init.lua

@@ -4,11 +4,19 @@ local git_utils = require "nvim-tree.git.utils"
 local Runner = require "nvim-tree.git.runner"
 local Watcher = require("nvim-tree.watcher").Watcher
 local Iterator = require "nvim-tree.iterators.node-iterator"
+local explorer_node = require "nvim-tree.explorer.node"
 
 local M = {
   config = {},
-  projects = {},
-  cwd_to_project_root = {},
+
+  -- all projects keyed by toplevel
+  _projects_by_toplevel = {},
+
+  -- index of paths inside toplevels, false when not inside a project
+  _toplevels_by_path = {},
+
+  -- git dirs by toplevel
+  _git_dirs_by_toplevel = {},
 }
 
 -- Files under .git that should result in a reload when changed.
@@ -21,36 +29,11 @@ local WATCHED_FILES = {
   "index", -- staging area
 }
 
-function M.reload()
-  if not M.config.git.enable then
-    return {}
-  end
-
-  for project_root in pairs(M.projects) do
-    M.reload_project(project_root)
-  end
-
-  return M.projects
-end
-
-function M.reload_project(project_root, path)
-  local project = M.projects[project_root]
-  if not project or not M.config.git.enable then
-    return
-  end
-
-  if path and path:find(project_root, 1, true) ~= 1 then
-    return
-  end
-
-  local git_status = Runner.run {
-    project_root = project_root,
-    path = path,
-    list_untracked = git_utils.should_show_untracked(project_root),
-    list_ignored = true,
-    timeout = M.config.git.timeout,
-  }
-
+---@param toplevel string|nil
+---@param path string|nil
+---@param project table
+---@param git_status table|nil
+local function reload_git_status(toplevel, path, project, git_status)
   if path then
     for p in pairs(project.files) do
       if p:find(path, 1, true) == 1 then
@@ -62,88 +45,198 @@ function M.reload_project(project_root, path)
     project.files = git_status
   end
 
-  project.dirs = git_utils.file_status_to_dir_status(project.files, project_root)
+  project.dirs = git_utils.file_status_to_dir_status(project.files, toplevel)
 end
 
-function M.get_project(project_root)
-  return M.projects[project_root]
+--- Is this path in a known ignored directory?
+---@param path string
+---@param project table git status
+---@return boolean
+local function path_ignored_in_project(path, project)
+  if not path or not project then
+    return false
+  end
+
+  if project and project.files then
+    for file, status in pairs(project.files) do
+      if status == "!!" and vim.startswith(path, file) then
+        return true
+      end
+    end
+  end
+  return false
 end
 
-function M.get_project_root(cwd)
+--- Reload all projects
+---@return table projects maybe empty
+function M.reload()
+  if not M.config.git.enable then
+    return {}
+  end
+
+  for toplevel in pairs(M._projects_by_toplevel) do
+    M.reload_project(toplevel)
+  end
+
+  return M._projects_by_toplevel
+end
+
+--- Reload one project. Does nothing when no project or path is ignored
+---@param toplevel string|nil
+---@param path string|nil optional path to update only
+---@param callback function|nil
+function M.reload_project(toplevel, path, callback)
+  local project = M._projects_by_toplevel[toplevel]
+  if not toplevel or not project or not M.config.git.enable then
+    if callback then
+      callback()
+    end
+    return
+  end
+
+  if path and (path:find(toplevel, 1, true) ~= 1 or path_ignored_in_project(path, project)) then
+    if callback then
+      callback()
+    end
+    return
+  end
+
+  local opts = {
+    toplevel = toplevel,
+    path = path,
+    list_untracked = git_utils.should_show_untracked(toplevel),
+    list_ignored = true,
+    timeout = M.config.git.timeout,
+  }
+
+  if callback then
+    Runner.run(opts, function(git_status)
+      reload_git_status(toplevel, path, project, git_status)
+      callback()
+    end)
+  else
+    -- TODO use callback once async/await is available
+    local git_status = Runner.run(opts)
+    reload_git_status(toplevel, path, project, git_status)
+  end
+end
+
+--- Retrieve a known project
+---@param toplevel string|nil
+---@return table|nil project
+function M.get_project(toplevel)
+  return M._projects_by_toplevel[toplevel]
+end
+
+--- Retrieve the toplevel for a path. nil on:
+---  git disabled
+---  not part of a project
+---  not a directory
+---  path in git.disable_for_dirs
+---@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
 
-  if M.cwd_to_project_root[cwd] then
-    return M.cwd_to_project_root[cwd]
+  if M._toplevels_by_path[path] then
+    return M._toplevels_by_path[path]
   end
 
-  if M.cwd_to_project_root[cwd] == false then
+  if M._toplevels_by_path[path] == false then
     return nil
   end
 
-  local stat, _ = vim.loop.fs_stat(cwd)
+  local stat, _ = vim.loop.fs_stat(path)
   if not stat or stat.type ~= "directory" then
     return nil
   end
 
-  M.cwd_to_project_root[cwd] = git_utils.get_toplevel(cwd)
-  return M.cwd_to_project_root[cwd]
-end
+  -- short-circuit any known ignored paths
+  for root, project in pairs(M._projects_by_toplevel) do
+    if project and path_ignored_in_project(path, project) then
+      M._toplevels_by_path[path] = root
+      return root
+    end
+  end
 
-local function reload_tree_at(project_root)
-  if not M.config.git.enable then
+  -- attempt to fetch toplevel
+  local toplevel, git_dir = git_utils.get_toplevel(path)
+  if not toplevel or not git_dir then
     return nil
   end
 
-  log.line("watcher", "git event executing '%s'", project_root)
-  local root_node = utils.get_node_from_path(project_root)
+  -- ignore disabled paths
+  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")
+    if toplevel_norm == disabled_norm then
+      return nil
+    end
+  end
+
+  M._toplevels_by_path[path] = toplevel
+  M._git_dirs_by_toplevel[toplevel] = git_dir
+  return M._toplevels_by_path[path]
+end
+
+local function reload_tree_at(toplevel)
+  if not M.config.git.enable or not toplevel then
+    return nil
+  end
+
+  log.line("watcher", "git event executing '%s'", toplevel)
+  local root_node = utils.get_node_from_path(toplevel)
   if not root_node then
     return
   end
 
-  M.reload_project(project_root)
-  local project = M.get_project(project_root)
+  M.reload_project(toplevel, nil, function()
+    local git_status = M.get_project(toplevel)
 
-  local project_files = project.files and project.files or {}
-  local project_dirs = project.dirs and project.dirs or {}
+    Iterator.builder(root_node.nodes)
+      :hidden()
+      :applier(function(node)
+        local parent_ignored = explorer_node.is_git_ignored(node.parent)
+        explorer_node.update_git_status(node, parent_ignored, git_status)
+      end)
+      :recursor(function(node)
+        return node.nodes and #node.nodes > 0 and node.nodes
+      end)
+      :iterate()
 
-  Iterator.builder(root_node.nodes)
-    :hidden()
-    :applier(function(node)
-      local parent_ignored = node.parent.git_status == "!!"
-      node.git_status = project_dirs[node.absolute_path] or project_files[node.absolute_path]
-      if not node.git_status and parent_ignored then
-        node.git_status = "!!"
-      end
-    end)
-    :recursor(function(node)
-      return node.nodes and #node.nodes > 0 and node.nodes
-    end)
-    :iterate()
-
-  require("nvim-tree.renderer").draw()
+    require("nvim-tree.renderer").draw()
+  end)
 end
 
-function M.load_project_status(cwd)
+--- Load the project status for a path. Does nothing when no toplevel for path.
+--- Only fetches project status when unknown, otherwise returns existing.
+---@param path string absolute
+---@return table project maybe empty
+function M.load_project_status(path)
   if not M.config.git.enable then
     return {}
   end
 
-  local project_root = M.get_project_root(cwd)
-  if not project_root then
-    M.cwd_to_project_root[cwd] = false
+  local toplevel = M.get_toplevel(path)
+  if not toplevel then
+    M._toplevels_by_path[path] = false
     return {}
   end
 
-  local status = M.projects[project_root]
+  local status = M._projects_by_toplevel[toplevel]
   if status then
     return status
   end
 
   local git_status = Runner.run {
-    project_root = project_root,
-    list_untracked = git_utils.should_show_untracked(project_root),
+    toplevel = toplevel,
+    list_untracked = git_utils.should_show_untracked(toplevel),
     list_ignored = true,
     timeout = M.config.git.timeout,
   }
@@ -153,29 +246,53 @@ function M.load_project_status(cwd)
     log.line("watcher", "git start")
 
     local callback = function(w)
-      log.line("watcher", "git event scheduled '%s'", w.project_root)
-      utils.debounce("git:watcher:" .. w.project_root, M.config.filesystem_watchers.debounce_delay, function()
-        reload_tree_at(w.project_root)
+      log.line("watcher", "git event scheduled '%s'", w.toplevel)
+      utils.debounce("git:watcher:" .. w.toplevel, M.config.filesystem_watchers.debounce_delay, function()
+        if w.destroyed then
+          return
+        end
+        reload_tree_at(w.toplevel)
       end)
     end
 
-    watcher = Watcher:new(utils.path_join { project_root, ".git" }, WATCHED_FILES, callback, {
-      project_root = project_root,
+    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,
     })
   end
 
-  M.projects[project_root] = {
-    files = git_status,
-    dirs = git_utils.file_status_to_dir_status(git_status, project_root),
-    watcher = watcher,
-  }
-  return M.projects[project_root]
+  if git_status then
+    M._projects_by_toplevel[toplevel] = {
+      files = git_status,
+      dirs = git_utils.file_status_to_dir_status(git_status, toplevel),
+      watcher = watcher,
+    }
+    return M._projects_by_toplevel[toplevel]
+  else
+    M._toplevels_by_path[path] = false
+    return {}
+  end
 end
 
 function M.purge_state()
   log.line("git", "purge_state")
-  M.projects = {}
-  M.cwd_to_project_root = {}
+
+  for _, project in pairs(M._projects_by_toplevel) do
+    if project.watcher then
+      project.watcher:destroy()
+    end
+  end
+
+  M._projects_by_toplevel = {}
+  M._toplevels_by_path = {}
+  M._git_dirs_by_toplevel = {}
+end
+
+--- Disable git integration permanently
+function M.disable_git_integration()
+  log.line("git", "disabling git integration")
+  M.purge_state()
+  M.config.git.enable = false
 end
 
 function M.setup(opts)

lua/nvim-tree/git/runner.lua

@@ -1,19 +1,35 @@
 local log = require "nvim-tree.log"
 local utils = require "nvim-tree.utils"
+local notify = require "nvim-tree.notify"
 
+---@class Runner
 local Runner = {}
 Runner.__index = Runner
 
+local timeouts = 0
+local MAX_TIMEOUTS = 5
+
+---@private
+---@param status string
+---@param path string|nil
 function Runner:_parse_status_output(status, path)
+  if not path then
+    return
+  end
+
   -- replacing slashes if on windows
   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.project_root, path })] = status
+    self.output[utils.path_remove_trailing(utils.path_join { self.toplevel, path })] = status
   end
 end
 
+---@private
+---@param prev_output string
+---@param incoming string
+---@return string
 function Runner:_handle_incoming_data(prev_output, incoming)
   if incoming and utils.str_find(incoming, "\n") then
     local prev = prev_output .. incoming
@@ -42,38 +58,50 @@ function Runner:_handle_incoming_data(prev_output, incoming)
   end
 
   for line in prev_output:gmatch "[^\n]*\n" do
-    self._parse_status_output(line)
+    self:_parse_status_output(line)
   end
 
-  return nil
+  return ""
 end
 
+---@param stdout_handle uv.uv_pipe_t
+---@param stderr_handle uv.uv_pipe_t
+---@return table
 function Runner:_getopts(stdout_handle, stderr_handle)
   local untracked = self.list_untracked and "-u" or nil
   local ignored = (self.list_untracked and self.list_ignored) and "--ignored=matching" or "--ignored=no"
   return {
     args = { "--no-optional-locks", "status", "--porcelain=v1", "-z", ignored, untracked, self.path },
-    cwd = self.project_root,
+    cwd = self.toplevel,
     stdio = { nil, stdout_handle, stderr_handle },
   }
 end
 
+---@param output string
 function Runner:_log_raw_output(output)
-  if output and type(output) == "string" then
+  if log.enabled "git" and output and type(output) == "string" then
     log.raw("git", "%s", output)
     log.line("git", "done")
   end
 end
 
-function Runner:_run_git_job()
+---@param callback function|nil
+function Runner:_run_git_job(callback)
   local handle, pid
   local stdout = vim.loop.new_pipe(false)
   local stderr = vim.loop.new_pipe(false)
   local timer = vim.loop.new_timer()
 
+  if stdout == nil or stderr == nil or timer == nil then
+    return
+  end
+
   local function on_finish(rc)
     self.rc = rc or 0
     if timer:is_closing() or stdout:is_closing() or stderr:is_closing() or (handle and handle:is_closing()) then
+      if callback then
+        callback()
+      end
       return
     end
     timer:stop()
@@ -82,11 +110,17 @@ function Runner:_run_git_job()
     stderr:read_stop()
     stdout:close()
     stderr:close()
-    if handle then
+
+    -- don't close the handle when killing as it will leave a zombie
+    if rc == -1 then
+      pcall(vim.loop.kill, pid, "sigkill")
+    elseif handle then
       handle:close()
     end
 
-    pcall(vim.loop.kill, pid)
+    if callback then
+      callback()
+    end
   end
 
   local opts = self:_getopts(stdout, stderr)
@@ -138,12 +172,29 @@ function Runner:_wait()
   end
 end
 
--- This module runs a git process, which will be killed if it takes more than timeout which defaults to 400ms
-function Runner.run(opts)
-  local ps = log.profile_start("git job %s %s", opts.project_root, opts.path)
+---@param opts table
+function Runner:_finalise(opts)
+  if self.rc == -1 then
+    log.line("git", "job timed out  %s %s", opts.toplevel, opts.path)
+    timeouts = timeouts + 1
+    if timeouts == MAX_TIMEOUTS then
+      notify.warn(string.format("%d git jobs have timed out after git.timeout %dms, disabling git integration.", timeouts, opts.timeout))
+      require("nvim-tree.git").disable_git_integration()
+    end
+  elseif self.rc ~= 0 then
+    log.line("git", "job fail rc %d %s %s", self.rc, opts.toplevel, opts.path)
+  else
+    log.line("git", "job success    %s %s", opts.toplevel, opts.path)
+  end
+end
 
+--- Runs a git process, which will be killed if it takes more than timeout which defaults to 400ms
+---@param opts table
+---@param callback function|nil executed passing return when complete
+---@return table|nil status by absolute path, nil if callback present
+function Runner.run(opts, callback)
   local self = setmetatable({
-    project_root = opts.project_root,
+    toplevel = opts.toplevel,
     path = opts.path,
     list_untracked = opts.list_untracked,
     list_ignored = opts.list_ignored,
@@ -152,20 +203,33 @@ function Runner.run(opts)
     rc = nil, -- -1 indicates timeout
   }, Runner)
 
-  self:_run_git_job()
-  self:_wait()
+  local async = callback ~= nil
+  local profile = log.profile_start("git %s job %s %s", async and "async" or "sync", opts.toplevel, opts.path)
 
-  log.profile_end(ps, "git job %s %s", opts.project_root, opts.path)
+  if async and callback then
+    -- async, always call back
+    self:_run_git_job(function()
+      log.profile_end(profile)
 
-  if self.rc == -1 then
-    log.line("git", "job timed out  %s %s", opts.project_root, opts.path)
-  elseif self.rc ~= 0 then
-    log.line("git", "job fail rc %d %s %s", self.rc, opts.project_root, opts.path)
+      self:_finalise(opts)
+
+      callback(self.output)
+    end)
   else
-    log.line("git", "job success    %s %s", opts.project_root, opts.path)
-  end
+    -- sync, maybe call back
+    self:_run_git_job()
+    self:_wait()
 
-  return self.output
+    log.profile_end(profile)
+
+    self:_finalise(opts)
+
+    if callback then
+      callback(self.output)
+    else
+      return self.output
+    end
+  end
 end
 
 return Runner

lua/nvim-tree/git/utils.lua

@@ -1,78 +1,135 @@
-local M = {}
 local log = require "nvim-tree.log"
+local utils = require "nvim-tree.utils"
 
-local has_cygpath = vim.fn.executable "cygpath" == 1
+local M = {
+  use_cygpath = false,
+}
 
+--- Retrieve the git toplevel directory
+---@param cwd string path
+---@return string|nil toplevel absolute path
+---@return string|nil git_dir absolute path
 function M.get_toplevel(cwd)
-  local ps = log.profile_start("git toplevel %s", cwd)
+  local profile = log.profile_start("git toplevel git_dir %s", cwd)
 
-  local cmd = { "git", "-C", cwd, "rev-parse", "--show-toplevel" }
-  log.line("git", "%s", vim.inspect(cmd))
+  -- both paths are absolute
+  local cmd = { "git", "-C", cwd, "rev-parse", "--show-toplevel", "--absolute-git-dir" }
+  log.line("git", "%s", table.concat(cmd, " "))
 
-  local toplevel = vim.fn.system(cmd)
+  local out = vim.fn.system(cmd)
 
-  log.raw("git", toplevel)
-  log.profile_end(ps, "git toplevel %s", cwd)
+  log.raw("git", out)
+  log.profile_end(profile)
 
-  if vim.v.shell_error ~= 0 or not toplevel or #toplevel == 0 or toplevel:match "fatal" then
-    return nil
+  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]+)"
+  if not toplevel then
+    return nil, nil
+  end
+  if not git_dir then
+    git_dir = utils.path_join { toplevel, ".git" }
   end
 
   -- git always returns path with forward slashes
   if vim.fn.has "win32" == 1 then
     -- msys2 git support
-    if has_cygpath then
-      toplevel = vim.fn.system("cygpath -w " .. vim.fn.shellescape(toplevel))
+    -- cygpath calls must in array format to avoid shell compatibility issues
+    if M.use_cygpath then
+      toplevel = vim.fn.system { "cygpath", "-w", toplevel }
       if vim.v.shell_error ~= 0 then
-        return nil
+        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 }
+      if vim.v.shell_error ~= 0 then
+        return nil, nil
+      end
+      -- remove trailing newline(\n) character added by vim.fn.system
+      git_dir = git_dir:gsub("\n", "")
     end
     toplevel = toplevel:gsub("/", "\\")
+    git_dir = git_dir:gsub("/", "\\")
   end
 
-  -- remove newline
-  return toplevel:sub(0, -2)
+  return toplevel, git_dir
 end
 
 local untracked = {}
 
+---@param cwd string
+---@return string|nil
 function M.should_show_untracked(cwd)
   if untracked[cwd] ~= nil then
     return untracked[cwd]
   end
 
-  local ps = log.profile_start("git untracked %s", cwd)
+  local profile = log.profile_start("git untracked %s", cwd)
 
   local cmd = { "git", "-C", cwd, "config", "status.showUntrackedFiles" }
-  log.line("git", vim.inspect(cmd))
+  log.line("git", table.concat(cmd, " "))
 
   local has_untracked = vim.fn.system(cmd)
 
   log.raw("git", has_untracked)
-  log.profile_end(ps, "git untracked %s", cwd)
+  log.profile_end(profile)
 
   untracked[cwd] = vim.trim(has_untracked) ~= "no"
   return untracked[cwd]
 end
 
+---@param t table|nil
+---@param k string
+---@return table
+local function nil_insert(t, k)
+  t = t or {}
+  t[k] = true
+  return t
+end
+
+---@param status table
+---@param cwd string|nil
+---@return table
 function M.file_status_to_dir_status(status, cwd)
-  local dirs = {}
+  local direct = {}
   for p, s in pairs(status) do
     if s ~= "!!" then
       local modified = vim.fn.fnamemodify(p, ":h")
-      dirs[modified] = s
+      direct[modified] = nil_insert(direct[modified], s)
     end
   end
 
-  for dirname, s in pairs(dirs) do
-    local modified = dirname
-    while modified ~= cwd and modified ~= "/" do
-      modified = vim.fn.fnamemodify(modified, ":h")
-      dirs[modified] = s
+  local indirect = {}
+  for dirname, statuses in pairs(direct) do
+    for s, _ in pairs(statuses) do
+      local modified = dirname
+      while modified ~= cwd and modified ~= "/" do
+        modified = vim.fn.fnamemodify(modified, ":h")
+        indirect[modified] = nil_insert(indirect[modified], s)
+      end
     end
   end
 
-  return dirs
+  local r = { indirect = indirect, direct = direct }
+  for _, d in pairs(r) do
+    for dirname, statuses in pairs(d) do
+      local new_statuses = {}
+      for s, _ in pairs(statuses) do
+        table.insert(new_statuses, s)
+      end
+      d[dirname] = new_statuses
+    end
+  end
+  return r
+end
+
+function M.setup(opts)
+  if opts.git.cygwin_support then
+    M.use_cygpath = vim.fn.executable "cygpath" == 1
+  end
 end
 
 return M

lua/nvim-tree/help.lua

@@ -0,0 +1,240 @@
+local keymap = require "nvim-tree.keymap"
+
+local PAT_MOUSE = "^<.*Mouse"
+local PAT_CTRL = "^<C%-"
+local PAT_SPECIAL = "^<.+"
+
+local WIN_HL = table.concat({
+  "NormalFloat:NvimTreeNormalFloat",
+  "WinSeparator:NvimTreeWinSeparator",
+  "CursorLine:NvimTreeCursorLine",
+}, ",")
+
+local M = {
+  config = {},
+
+  -- one and only buf/win
+  bufnr = nil,
+  winnr = nil,
+}
+
+--- Shorten and normalise a vim command lhs
+---@param lhs string
+---@return string
+local function tidy_lhs(lhs)
+  -- nvim_buf_get_keymap replaces leading "<" with "<lt>" e.g. "<lt>CTRL-v>"
+  lhs = lhs:gsub("^<lt>", "<")
+
+  -- shorten ctrls
+  if lhs:lower():match "^<ctrl%-" then
+    lhs = lhs:lower():gsub("^<ctrl%-", "<C%-")
+  end
+
+  -- uppercase ctrls
+  if lhs:lower():match "^<c%-" then
+    lhs = lhs:upper()
+  end
+
+  -- space is not escaped
+  lhs = lhs:gsub(" ", "<Space>")
+
+  return lhs
+end
+
+--- Remove prefix 'nvim-tree: '
+--- Hardcoded to keep default_on_attach simple
+---@param desc string
+---@return string
+local function tidy_desc(desc)
+  return desc and desc:gsub("^nvim%-tree: ", "") or ""
+end
+
+--- sort vim command lhs roughly as per :help index
+---@param a string
+---@param b string
+local function sort_lhs(a, b)
+  -- mouse first
+  if a:match(PAT_MOUSE) and not b:match(PAT_MOUSE) then
+    return true
+  elseif not a:match(PAT_MOUSE) and b:match(PAT_MOUSE) then
+    return false
+  end
+
+  -- ctrl next
+  if a:match(PAT_CTRL) and not b:match(PAT_CTRL) then
+    return true
+  elseif not a:match(PAT_CTRL) and b:match(PAT_CTRL) then
+    return false
+  end
+
+  -- special next
+  if a:match(PAT_SPECIAL) and not b:match(PAT_SPECIAL) then
+    return true
+  elseif not a:match(PAT_SPECIAL) and b:match(PAT_SPECIAL) then
+    return false
+  end
+
+  -- remainder alpha
+  return a:gsub("[^a-zA-Z]", "") < b:gsub("[^a-zA-Z]", "")
+end
+
+--- Compute all lines for the buffer
+---@return table strings of text
+---@return table arrays of arguments 3-6 for nvim_buf_add_highlight()
+---@return number maximum length of text
+local function compute()
+  local head_lhs = "nvim-tree mappings"
+  local head_rhs1 = "exit: q"
+  local head_rhs2 = string.format("sort by %s: s", M.config.sort_by == "key" and "description" or "keymap")
+
+  -- formatted lhs and desc from active keymap
+  local mappings = vim.tbl_map(function(map)
+    return { lhs = tidy_lhs(map.lhs), desc = tidy_desc(map.desc) }
+  end, keymap.get_keymap())
+
+  -- sorter function for mappings
+  local sort_fn
+
+  if M.config.sort_by == "desc" then
+    sort_fn = function(a, b)
+      return a.desc:lower() < b.desc:lower()
+    end
+  else
+    -- by default sort roughly by lhs
+    sort_fn = function(a, b)
+      return sort_lhs(a.lhs, b.lhs)
+    end
+  end
+
+  table.sort(mappings, sort_fn)
+
+  -- longest lhs and description
+  local max_lhs = 0
+  local max_desc = 0
+  for _, l in pairs(mappings) do
+    max_lhs = math.max(#l.lhs, max_lhs)
+    max_desc = math.max(#l.desc, max_desc)
+  end
+
+  -- 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
+  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
+    -- format in left aligned columns
+    local line = string.format(fmt, l.lhs, l.desc)
+    table.insert(lines, line)
+    width = math.max(#line, width)
+
+    -- highlight lhs
+    table.insert(hl, { "NvimTreeFolderName", i + 1, 1, #l.lhs + 1 })
+  end
+
+  return lines, hl, width
+end
+
+--- close the window and delete the buffer, if they exist
+local function close()
+  if M.winnr then
+    vim.api.nvim_win_close(M.winnr, true)
+    M.winnr = nil
+  end
+  if M.bufnr then
+    vim.api.nvim_buf_delete(M.bufnr, { force = true })
+    M.bufnr = nil
+  end
+end
+
+--- open a new window and buffer
+local function open()
+  -- close existing, shouldn't be necessary
+  close()
+
+  -- text and highlight
+  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)
+
+  -- highlight it
+  for _, h in ipairs(hl) do
+    vim.api.nvim_buf_add_highlight(M.bufnr, -1, h[1], h[2], h[3], h[4])
+  end
+
+  -- open a very restricted window
+  M.winnr = vim.api.nvim_open_win(M.bufnr, true, {
+    relative = "editor",
+    border = "single",
+    width = width,
+    height = #lines,
+    row = 1,
+    col = 0,
+    style = "minimal",
+    noautocmd = true,
+  })
+
+  -- style it a bit like the tree
+  vim.wo[M.winnr].winhl = WIN_HL
+  vim.wo[M.winnr].cursorline = M.config.cursorline
+
+  local function toggle_sort()
+    M.config.sort_by = (M.config.sort_by == "desc") and "key" or "desc"
+    open()
+  end
+
+  local keymaps = {
+    q = { fn = close, desc = "nvim-tree: exit help" },
+    s = { fn = toggle_sort, desc = "nvim-tree: toggle sorting method" },
+  }
+
+  for k, v in pairs(keymaps) do
+    vim.keymap.set("n", k, v.fn, {
+      desc = v.desc,
+      buffer = M.bufnr,
+      noremap = true,
+      silent = true,
+      nowait = true,
+    })
+  end
+
+  -- close window and delete buffer on leave
+  vim.api.nvim_create_autocmd({ "BufLeave", "WinLeave" }, {
+    buffer = M.bufnr,
+    once = true,
+    callback = close,
+  })
+end
+
+function M.toggle()
+  if M.winnr or M.bufnr then
+    close()
+  else
+    open()
+  end
+end
+
+function M.setup(opts)
+  M.config.cursorline = opts.view.cursorline
+  M.config.sort_by = opts.help.sort_by
+end
+
+return M

lua/nvim-tree/iterators/node-iterator.lua

@@ -1,6 +1,9 @@
+---@class NodeIterator
 local NodeIterator = {}
 NodeIterator.__index = NodeIterator
 
+---@param nodes Node[]
+---@return NodeIterator
 function NodeIterator.builder(nodes)
   return setmetatable({
     nodes = nodes,
@@ -15,6 +18,7 @@ function NodeIterator.builder(nodes)
   }, NodeIterator)
 end
 
+---@return NodeIterator
 function NodeIterator:hidden()
   self._filter_hidden = function(_)
     return true
@@ -22,27 +26,37 @@ function NodeIterator:hidden()
   return self
 end
 
+---@param f fun(node: Node): boolean
+---@return NodeIterator
 function NodeIterator:matcher(f)
   self._match = f
   return self
 end
 
+---@param f fun(node: Node, i: number)
+---@return NodeIterator
 function NodeIterator:applier(f)
   self._apply_fn_on_node = f
   return self
 end
 
+---@param f fun(node: Node): any
+---@return NodeIterator
 function NodeIterator:recursor(f)
   self._recurse_with = f
   return self
 end
 
+---@return Node|nil
+---@return number|nil
 function NodeIterator:iterate()
   local iteration_count = 0
   local function iter(nodes)
     for _, node in ipairs(nodes) do
       if self._filter_hidden(node) then
-        iteration_count = iteration_count + 1
+        if not node.group_next then
+          iteration_count = iteration_count + 1
+        end
         if self._match(node) then
           return node, iteration_count
         end

lua/nvim-tree/keymap.lua

@@ -1,290 +1,118 @@
-local Api = require "nvim-tree.api"
-
 local M = {}
 
-local DEFAULT_KEYMAPS = {
-  {
-    key = { "<CR>", "o", "<2-LeftMouse>" },
-    callback = Api.node.open.edit,
-    desc = "open a file or folder; root will cd to the above directory",
-  },
-  {
-    key = "<C-e>",
-    callback = Api.node.open.replace_tree_buffer,
-    desc = "edit the file in place, effectively replacing the tree explorer",
-  },
-  {
-    key = "O",
-    callback = Api.node.open.no_window_picker,
-    desc = "same as (edit) with no window picker",
-  },
-  {
-    key = { "<C-]>", "<2-RightMouse>" },
-    callback = Api.tree.change_root_to_node,
-    desc = "cd in the directory under the cursor",
-  },
-  {
-    key = "<C-v>",
-    callback = Api.node.open.vertical,
-    desc = "open the file in a vertical split",
-  },
-  {
-    key = "<C-x>",
-    callback = Api.node.open.horizontal,
-    desc = "open the file in a horizontal split",
-  },
-  {
-    key = "<C-t>",
-    callback = Api.node.open.tab,
-    desc = "open the file in a new tab",
-  },
-  {
-    key = "<",
-    callback = Api.node.navigate.sibling.prev,
-    desc = "navigate to the previous sibling of current file/directory",
-  },
-  {
-    key = ">",
-    callback = Api.node.navigate.sibling.next,
-    desc = "navigate to the next sibling of current file/directory",
-  },
-  {
-    key = "P",
-    callback = Api.node.navigate.parent,
-    desc = "move cursor to the parent directory",
-  },
-  {
-    key = "<BS>",
-    callback = Api.node.navigate.parent_close,
-    desc = "close current opened directory or parent",
-  },
-  {
-    key = "<Tab>",
-    callback = Api.node.open.preview,
-    desc = "open the file as a preview (keeps the cursor in the tree)",
-  },
-  {
-    key = "K",
-    callback = Api.node.navigate.sibling.first,
-    desc = "navigate to the first sibling of current file/directory",
-  },
-  {
-    key = "J",
-    callback = Api.node.navigate.sibling.last,
-    desc = "navigate to the last sibling of current file/directory",
-  },
-  {
-    key = "I",
-    callback = Api.tree.toggle_gitignore_filter,
-    desc = "toggle visibility of files/folders hidden via |git.ignore| option",
-  },
-  {
-    key = "H",
-    callback = Api.tree.toggle_hidden_filter,
-    desc = "toggle visibility of dotfiles via |filters.dotfiles| option",
-  },
-  {
-    key = "U",
-    callback = Api.tree.toggle_custom_filter,
-    desc = "toggle visibility of files/folders hidden via |filters.custom| option",
-  },
-  {
-    key = "R",
-    callback = Api.tree.reload,
-    desc = "refresh the tree",
-  },
-  {
-    key = "a",
-    callback = Api.fs.create,
-    desc = "add a file; leaving a trailing `/` will add a directory",
-  },
-  {
-    key = "d",
-    callback = Api.fs.remove,
-    desc = "delete a file (will prompt for confirmation)",
-  },
-  {
-    key = "D",
-    callback = Api.fs.trash,
-    desc = "trash a file via |trash| option",
-  },
-  {
-    key = "r",
-    callback = Api.fs.rename,
-    desc = "rename a file",
-  },
-  {
-    key = "<C-r>",
-    callback = Api.fs.rename_sub,
-    desc = "rename a file and omit the filename on input",
-  },
-  {
-    key = "x",
-    callback = Api.fs.cut,
-    desc = "add/remove file/directory to cut clipboard",
-  },
-  {
-    key = "c",
-    callback = Api.fs.copy.node,
-    desc = "add/remove file/directory to copy clipboard",
-  },
-  {
-    key = "p",
-    callback = Api.fs.paste,
-    desc = "paste from clipboard; cut clipboard has precedence over copy; will prompt for confirmation",
-  },
-  {
-    key = "y",
-    callback = Api.fs.copy.filename,
-    desc = "copy name to system clipboard",
-  },
-  {
-    key = "Y",
-    callback = Api.fs.copy.relative_path,
-    desc = "copy relative path to system clipboard",
-  },
-  {
-    key = "gy",
-    callback = Api.fs.copy.absolute_path,
-    desc = "copy absolute path to system clipboard",
-  },
-  {
-    key = "]e",
-    callback = Api.node.navigate.diagnostics.next,
-    desc = "go to next diagnostic item",
-  },
-  {
-    key = "]c",
-    callback = Api.node.navigate.git.next,
-    desc = "go to next git item",
-  },
-  {
-    key = "[e",
-    callback = Api.node.navigate.diagnostics.prev,
-    desc = "go to prev diagnostic item",
-  },
-  {
-    key = "[c",
-    callback = Api.node.navigate.git.prev,
-    desc = "go to prev git item",
-  },
-  {
-    key = "-",
-    callback = Api.tree.change_root_to_parent,
-    desc = "navigate up to the parent directory of the current file/directory",
-  },
-  {
-    key = "s",
-    callback = Api.node.run.system,
-    desc = "open a file with default system application or a folder with default file manager, using |system_open| option",
-  },
-  {
-    key = "f",
-    callback = Api.live_filter.start,
-    desc = "live filter nodes dynamically based on regex matching.",
-  },
-  {
-    key = "F",
-    callback = Api.live_filter.clear,
-    desc = "clear live filter",
-  },
-  {
-    key = "q",
-    callback = Api.tree.close,
-    desc = "close tree window",
-  },
-  {
-    key = "W",
-    callback = Api.tree.collapse_all,
-    desc = "collapse the whole tree",
-  },
-  {
-    key = "E",
-    callback = Api.tree.expand_all,
-    desc = "expand the whole tree, stopping after expanding |callbacks.expand_all.max_folder_discovery| folders; this might hang neovim for a while if running on a big folder",
-  },
-  {
-    key = "S",
-    callback = Api.tree.search_node,
-    desc = "prompt the user to enter a path and then expands the tree to match the path",
-  },
-  {
-    key = ".",
-    callback = Api.node.run.cmd,
-    desc = "enter vim command mode with the file the cursor is on",
-  },
-  {
-    key = "<C-k>",
-    callback = Api.node.show_info_popup,
-    desc = "toggle a popup with file infos about the file under the cursor",
-  },
-  {
-    key = "g?",
-    callback = Api.tree.toggle_help,
-    desc = "toggle help",
-  },
-  {
-    key = "m",
-    callback = Api.marks.toggle,
-    desc = "Toggle node in bookmarks",
-  },
-  {
-    key = "bmv",
-    callback = Api.marks.bulk.move,
-    desc = "Move all bookmarked nodes into specified location",
-  },
-}
+--- Apply mappings to a scratch buffer and return buffer local mappings
+---@param fn function(bufnr) on_attach or default_on_attach
+---@return table as per vim.api.nvim_buf_get_keymap
+local function generate_keymap(fn)
+  -- create an unlisted scratch buffer
+  local scratch_bufnr = vim.api.nvim_create_buf(false, true)
 
-function M.set_keymaps(bufnr)
-  local opts = { noremap = true, silent = true, nowait = true, buffer = bufnr }
-  for _, km in ipairs(M.keymaps) do
-    local keys = type(km.key) == "table" and km.key or { km.key }
-    for _, key in ipairs(keys) do
-      vim.keymap.set("n", key, km.callback, opts)
-    end
-  end
+  -- apply mappings
+  fn(scratch_bufnr)
+
+  -- retrieve all
+  local keymap = vim.api.nvim_buf_get_keymap(scratch_bufnr, "")
+
+  -- delete the scratch buffer
+  vim.api.nvim_buf_delete(scratch_bufnr, { force = true })
+
+  return keymap
 end
 
-local function filter_default_mappings(keys_to_disable)
-  local new_map = {}
-  for _, m in pairs(DEFAULT_KEYMAPS) do
-    local keys = type(m.key) == "table" and m.key or { m.key }
-    local reminding_keys = {}
-    for _, key in pairs(keys) do
-      local found = false
-      for _, key_to_disable in pairs(keys_to_disable) do
-        if key_to_disable == key then
-          found = true
-          break
-        end
-      end
-      if not found then
-        table.insert(reminding_keys, key)
-      end
-    end
-    if #reminding_keys > 0 then
-      local map = vim.deepcopy(m)
-      map.key = reminding_keys
-      table.insert(new_map, map)
-    end
+-- stylua: ignore start
+---@param bufnr integer
+function M.default_on_attach(bufnr)
+  local api = require('nvim-tree.api')
+
+  local function opts(desc)
+    return {
+      desc = 'nvim-tree: ' .. desc,
+      buffer = bufnr,
+      noremap = true,
+      silent = true,
+      nowait = true,
+  }
   end
-  return new_map
+
+  -- BEGIN_DEFAULT_ON_ATTACH
+  vim.keymap.set('n', '<C-]>',   api.tree.change_root_to_node,        opts('CD'))
+  vim.keymap.set('n', '<C-e>',   api.node.open.replace_tree_buffer,   opts('Open: In Place'))
+  vim.keymap.set('n', '<C-k>',   api.node.show_info_popup,            opts('Info'))
+  vim.keymap.set('n', '<C-r>',   api.fs.rename_sub,                   opts('Rename: Omit Filename'))
+  vim.keymap.set('n', '<C-t>',   api.node.open.tab,                   opts('Open: New Tab'))
+  vim.keymap.set('n', '<C-v>',   api.node.open.vertical,              opts('Open: Vertical Split'))
+  vim.keymap.set('n', '<C-x>',   api.node.open.horizontal,            opts('Open: Horizontal Split'))
+  vim.keymap.set('n', '<BS>',    api.node.navigate.parent_close,      opts('Close Directory'))
+  vim.keymap.set('n', '<CR>',    api.node.open.edit,                  opts('Open'))
+  vim.keymap.set('n', '<Tab>',   api.node.open.preview,               opts('Open Preview'))
+  vim.keymap.set('n', '>',       api.node.navigate.sibling.next,      opts('Next Sibling'))
+  vim.keymap.set('n', '<',       api.node.navigate.sibling.prev,      opts('Previous Sibling'))
+  vim.keymap.set('n', '.',       api.node.run.cmd,                    opts('Run Command'))
+  vim.keymap.set('n', '-',       api.tree.change_root_to_parent,      opts('Up'))
+  vim.keymap.set('n', 'a',       api.fs.create,                       opts('Create File Or Directory'))
+  vim.keymap.set('n', 'bd',      api.marks.bulk.delete,               opts('Delete Bookmarked'))
+  vim.keymap.set('n', 'bt',      api.marks.bulk.trash,                opts('Trash Bookmarked'))
+  vim.keymap.set('n', 'bmv',     api.marks.bulk.move,                 opts('Move Bookmarked'))
+  vim.keymap.set('n', 'B',       api.tree.toggle_no_buffer_filter,    opts('Toggle Filter: No Buffer'))
+  vim.keymap.set('n', 'c',       api.fs.copy.node,                    opts('Copy'))
+  vim.keymap.set('n', 'C',       api.tree.toggle_git_clean_filter,    opts('Toggle Filter: Git Clean'))
+  vim.keymap.set('n', '[c',      api.node.navigate.git.prev,          opts('Prev Git'))
+  vim.keymap.set('n', ']c',      api.node.navigate.git.next,          opts('Next Git'))
+  vim.keymap.set('n', 'd',       api.fs.remove,                       opts('Delete'))
+  vim.keymap.set('n', 'D',       api.fs.trash,                        opts('Trash'))
+  vim.keymap.set('n', 'E',       api.tree.expand_all,                 opts('Expand All'))
+  vim.keymap.set('n', 'e',       api.fs.rename_basename,              opts('Rename: Basename'))
+  vim.keymap.set('n', ']e',      api.node.navigate.diagnostics.next,  opts('Next Diagnostic'))
+  vim.keymap.set('n', '[e',      api.node.navigate.diagnostics.prev,  opts('Prev Diagnostic'))
+  vim.keymap.set('n', 'F',       api.live_filter.clear,               opts('Live Filter: Clear'))
+  vim.keymap.set('n', 'f',       api.live_filter.start,               opts('Live Filter: Start'))
+  vim.keymap.set('n', 'g?',      api.tree.toggle_help,                opts('Help'))
+  vim.keymap.set('n', 'gy',      api.fs.copy.absolute_path,           opts('Copy Absolute Path'))
+  vim.keymap.set('n', 'ge',      api.fs.copy.basename,                opts('Copy Basename'))
+  vim.keymap.set('n', 'H',       api.tree.toggle_hidden_filter,       opts('Toggle Filter: Dotfiles'))
+  vim.keymap.set('n', 'I',       api.tree.toggle_gitignore_filter,    opts('Toggle Filter: Git Ignore'))
+  vim.keymap.set('n', 'J',       api.node.navigate.sibling.last,      opts('Last Sibling'))
+  vim.keymap.set('n', 'K',       api.node.navigate.sibling.first,     opts('First Sibling'))
+  vim.keymap.set('n', 'L',       api.node.open.toggle_group_empty,    opts('Toggle Group Empty'))
+  vim.keymap.set('n', 'M',       api.tree.toggle_no_bookmark_filter,  opts('Toggle Filter: No Bookmark'))
+  vim.keymap.set('n', 'm',       api.marks.toggle,                    opts('Toggle Bookmark'))
+  vim.keymap.set('n', 'o',       api.node.open.edit,                  opts('Open'))
+  vim.keymap.set('n', 'O',       api.node.open.no_window_picker,      opts('Open: No Window Picker'))
+  vim.keymap.set('n', 'p',       api.fs.paste,                        opts('Paste'))
+  vim.keymap.set('n', 'P',       api.node.navigate.parent,            opts('Parent Directory'))
+  vim.keymap.set('n', 'q',       api.tree.close,                      opts('Close'))
+  vim.keymap.set('n', 'r',       api.fs.rename,                       opts('Rename'))
+  vim.keymap.set('n', 'R',       api.tree.reload,                     opts('Refresh'))
+  vim.keymap.set('n', 's',       api.node.run.system,                 opts('Run System'))
+  vim.keymap.set('n', 'S',       api.tree.search_node,                opts('Search'))
+  vim.keymap.set('n', 'u',       api.fs.rename_full,                  opts('Rename: Full Path'))
+  vim.keymap.set('n', 'U',       api.tree.toggle_custom_filter,       opts('Toggle Filter: Hidden'))
+  vim.keymap.set('n', 'W',       api.tree.collapse_all,               opts('Collapse'))
+  vim.keymap.set('n', 'x',       api.fs.cut,                          opts('Cut'))
+  vim.keymap.set('n', 'y',       api.fs.copy.filename,                opts('Copy Name'))
+  vim.keymap.set('n', 'Y',       api.fs.copy.relative_path,           opts('Copy Relative Path'))
+  vim.keymap.set('n', '<2-LeftMouse>',  api.node.open.edit,           opts('Open'))
+  vim.keymap.set('n', '<2-RightMouse>', api.tree.change_root_to_node, opts('CD'))
+  -- END_DEFAULT_ON_ATTACH
+end
+-- stylua: ignore end
+
+---@return table
+function M.get_keymap()
+  return generate_keymap(M.on_attach)
 end
 
-local function get_keymaps(keys_to_disable)
-  if keys_to_disable == true then
-    return {}
-  end
-
-  if type(keys_to_disable) == "table" and #keys_to_disable > 0 then
-    return filter_default_mappings(keys_to_disable)
-  end
-
-  return DEFAULT_KEYMAPS
+---@return table
+function M.get_keymap_default()
+  return generate_keymap(M.default_on_attach)
 end
 
 function M.setup(opts)
-  M.keymaps = get_keymaps(opts.remove_keymaps)
+  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

@@ -3,37 +3,79 @@ local notify = require "nvim-tree.notify"
 
 local M = {}
 
+-- silently move, please add to help nvim-tree-legacy-opts
 local function refactored(opts)
-  -- mapping actions
-  if opts.view and opts.view.mappings and opts.view.mappings.list then
-    for _, m in pairs(opts.view.mappings.list) do
-      if m.action == "toggle_ignored" then
-        m.action = "toggle_git_ignored"
-      end
-    end
-  end
-
   -- 2022/06/20
-  utils.move_missing_val(opts, "update_focused_file", "update_cwd", opts, "update_focused_file", "update_root")
-  utils.move_missing_val(opts, "", "update_cwd", opts, "", "sync_root_with_cwd")
+  utils.move_missing_val(opts, "update_focused_file", "update_cwd", opts, "update_focused_file", "update_root", true)
+  utils.move_missing_val(opts, "", "update_cwd", opts, "", "sync_root_with_cwd", true)
 
   -- 2022/11/07
   utils.move_missing_val(opts, "", "open_on_tab", opts, "tab.sync", "open", false)
-  utils.move_missing_val(opts, "", "open_on_tab", opts, "tab.sync", "close")
-  utils.move_missing_val(opts, "", "ignore_buf_on_tab_change", opts, "tab.sync", "ignore")
+  utils.move_missing_val(opts, "", "open_on_tab", opts, "tab.sync", "close", true)
+  utils.move_missing_val(opts, "", "ignore_buf_on_tab_change", opts, "tab.sync", "ignore", true)
 
   -- 2022/11/22
-  utils.move_missing_val(opts, "renderer", "root_folder_modifier", opts, "renderer", "root_folder_label")
+  utils.move_missing_val(opts, "renderer", "root_folder_modifier", opts, "renderer", "root_folder_label", true)
+
+  -- 2023/01/01
+  utils.move_missing_val(opts, "update_focused_file", "debounce_delay", opts, "view", "debounce_delay", true)
+
+  -- 2023/01/08
+  utils.move_missing_val(opts, "trash", "require_confirm", opts, "ui.confirm", "trash", true)
+
+  -- 2023/01/15
+  if type(opts.view) == "table" and opts.view.adaptive_size ~= nil then
+    if opts.view.adaptive_size and type(opts.view.width) ~= "table" then
+      local width = opts.view.width
+      opts.view.width = {
+        min = width,
+      }
+    end
+    opts.view.adaptive_size = nil
+  end
+
+  -- 2023/07/15
+  utils.move_missing_val(opts, "", "sort_by", opts, "sort", "sorter", true)
+
+  -- 2023/07/16
+  utils.move_missing_val(opts, "git", "ignore", opts, "filters", "git_ignored", true)
+
+  -- 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"
+  end
 end
 
 local function removed(opts)
   if opts.auto_close then
-    notify.warn "auto close feature has been removed, see note in the README (tips & reminder section)"
+    notify.warn "auto close feature has been removed: https://github.com/nvim-tree/nvim-tree.lua/wiki/Auto-Close"
     opts.auto_close = nil
   end
 
   if opts.focus_empty_on_setup then
-    notify.warn "focus_empty_on_setup has been removed and will be replaced by a new startup configuration. Please remove this option. See https://bit.ly/3yJch2T"
+    notify.warn "focus_empty_on_setup has been removed: https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup"
     opts.focus_empty_on_setup = nil
   end
 
@@ -47,6 +89,9 @@ function M.migrate_legacy_options(opts)
   -- silently move
   refactored(opts)
 
+  -- warn
+  deprecated(opts)
+
   -- warn and delete
   removed(opts)
 end

lua/nvim-tree/lib.lua

@@ -2,11 +2,19 @@ local renderer = require "nvim-tree.renderer"
 local view = require "nvim-tree.view"
 local core = require "nvim-tree.core"
 local utils = require "nvim-tree.utils"
+local events = require "nvim-tree.events"
+local explorer_node = require "nvim-tree.explorer.node"
+
+---@class LibOpenOpts
+---@field path string|nil path
+---@field current_window boolean|nil default false
+---@field winid number|nil
 
 local M = {
   target_winid = nil,
 }
 
+---@return Node|nil
 function M.get_node_at_cursor()
   if not core.get_explorer() then
     return
@@ -17,13 +25,8 @@ function M.get_node_at_cursor()
     return
   end
 
-  local cursor = vim.api.nvim_win_get_cursor(view.get_winnr())
+  local cursor = vim.api.nvim_win_get_cursor(winnr)
   local line = cursor[1]
-  if view.is_help_ui() then
-    local help_lines = require("nvim-tree.renderer.help").compute_lines()
-    local help_text = utils.get_nodes_by_line(help_lines, 1)[line]
-    return { name = help_text }
-  end
 
   if line == 1 and view.is_root_folder_visible(core.get_cwd()) then
     return { name = ".." }
@@ -33,8 +36,8 @@ function M.get_node_at_cursor()
 end
 
 ---Create a sanitized partial copy of a node, populating children recursively.
----@param node table
----@return table|nil cloned node
+---@param node Node|nil
+---@return Node|nil cloned node
 local function clone_node(node)
   if not node then
     node = core.get_explorer()
@@ -54,6 +57,7 @@ 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
@@ -67,21 +71,78 @@ local function clone_node(node)
 end
 
 ---Api.tree.get_nodes
+---@return Node[]|nil
 function M.get_nodes()
   return clone_node(core.get_explorer())
 end
 
 -- If node is grouped, return the last node in the group. Otherwise, return the given node.
+---@param node Node
+---@return Node
 function M.get_last_group_node(node)
-  local next = node
-  while next.group_next do
-    next = next.group_next
+  while node and node.group_next do
+    node = node.group_next
   end
-  return next
+
+  ---@diagnostic disable-next-line: return-type-mismatch -- it can't be nil
+  return node
 end
 
-function M.expand_or_collapse(node)
-  node.open = not node.open
+---Group empty folders
+-- Recursively group nodes
+---@param node Node
+---@return Node[]
+function M.group_empty_folders(node)
+  local is_root = not node.parent
+  local child_folder_only = explorer_node.has_one_child_folder(node) and node.nodes[1]
+  if M.group_empty and not is_root and child_folder_only then
+    node.group_next = child_folder_only
+    local ns = M.group_empty_folders(child_folder_only)
+    node.nodes = ns or {}
+    return ns
+  end
+  return node.nodes
+end
+
+---Ungroup empty folders
+-- If a node is grouped, ungroup it: put node.group_next to the node.nodes and set node.group_next to nil
+---@param node Node
+function M.ungroup_empty_folders(node)
+  local cur = node
+  while cur and cur.group_next do
+    cur.nodes = { cur.group_next }
+    cur.group_next = nil
+    cur = cur.nodes[1]
+  end
+end
+
+---@param node Node
+---@return Node[]
+function M.get_all_nodes_in_group(node)
+  local next_node = utils.get_parent_of_group(node)
+  local nodes = {}
+  while next_node do
+    table.insert(nodes, next_node)
+    next_node = next_node.group_next
+  end
+  return nodes
+end
+
+-- Toggle group empty folders
+---@param head_node Node
+local function toggle_group_folders(head_node)
+  local is_grouped = head_node.group_next ~= nil
+
+  if is_grouped then
+    M.ungroup_empty_folders(head_node)
+  else
+    M.group_empty_folders(head_node)
+  end
+end
+
+---@param node Node
+function M.expand_or_collapse(node, toggle_group)
+  toggle_group = toggle_group or false
   if node.has_children then
     node.has_children = false
   end
@@ -90,6 +151,22 @@ function M.expand_or_collapse(node)
     core.get_explorer():expand(node)
   end
 
+  local head_node = utils.get_parent_of_group(node)
+  if toggle_group then
+    toggle_group_folders(head_node)
+  end
+
+  local open = M.get_last_group_node(node).open
+  local next_open
+  if toggle_group then
+    next_open = open
+  else
+    next_open = not open
+  end
+  for _, n in ipairs(M.get_all_nodes_in_group(head_node)) do
+    n.open = next_open
+  end
+
   renderer.draw()
 end
 
@@ -104,6 +181,7 @@ function M.set_target_win()
   M.target_winid = id
 end
 
+---@param cwd string
 local function handle_buf_cwd(cwd)
   if M.respect_buf_cwd and cwd ~= core.get_cwd() then
     require("nvim-tree.actions.root.change-dir").fn(cwd)
@@ -129,7 +207,13 @@ local function should_hijack_current_buf()
   return should_hijack_dir or should_hijack_unnamed
 end
 
-function M.prompt(prompt_input, prompt_select, items_short, items_long, callback)
+---@param prompt_input string
+---@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)
   local function format_item(short)
     for i, s in ipairs(items_short) do
       if short == s then
@@ -140,49 +224,50 @@ function M.prompt(prompt_input, prompt_select, items_short, items_long, callback
   end
 
   if M.select_prompts then
-    vim.ui.select(items_short, { prompt = prompt_select, format_item = format_item }, function(item_short)
+    vim.ui.select(items_short, { prompt = prompt_select, kind = kind, format_item = format_item }, function(item_short)
       callback(item_short)
     end)
   else
-    vim.ui.input({ prompt = prompt_input }, function(item_short)
-      callback(item_short)
+    vim.ui.input({ prompt = prompt_input, default = items_short[1] or "" }, function(item_short)
+      if item_short then
+        callback(string.lower(item_short and item_short:sub(1, 1)) or nil)
+      end
     end)
   end
 end
 
-function M.open(cwd)
+---Open the tree, initialising as needed. Maybe hijack the current buffer.
+---@param opts LibOpenOpts|nil
+function M.open(opts)
+  opts = opts or {}
+
   M.set_target_win()
-  if not core.get_explorer() or cwd then
-    core.init(cwd or vim.loop.cwd())
+  if not core.get_explorer() or opts.path then
+    core.init(opts.path or vim.loop.cwd())
   end
   if should_hijack_current_buf() then
     view.close_this_tab_only()
-    view.open_in_current_win()
+    view.open_in_win()
+    renderer.draw()
+  elseif opts.winid then
+    view.open_in_win { hijack_current_buf = false, resize = false, winid = opts.winid }
+    renderer.draw()
+  elseif opts.current_window then
+    view.open_in_win { hijack_current_buf = false, resize = false }
     renderer.draw()
   else
     open_view_and_draw()
   end
   view.restore_tab_state()
+  events._dispatch_on_tree_open()
 end
 
--- @deprecated: use nvim-tree.actions.tree-modifiers.collapse-all.fn
-M.collapse_all = require("nvim-tree.actions.tree-modifiers.collapse-all").fn
--- @deprecated: use nvim-tree.actions.root.dir-up.fn
-M.dir_up = require("nvim-tree.actions.root.dir-up").fn
--- @deprecated: use nvim-tree.actions.root.change-dir.fn
-M.change_dir = require("nvim-tree.actions.root.change-dir").fn
--- @deprecated: use nvim-tree.actions.reloaders.reloaders.reload_explorer
-M.refresh_tree = require("nvim-tree.actions.reloaders.reloaders").reload_explorer
--- @deprecated: use nvim-tree.actions.reloaders.reloaders.reload_git
-M.reload_git = require("nvim-tree.actions.reloaders.reloaders").reload_git
--- @deprecated: use nvim-tree.actions.finders.find-file.fn
-M.set_index_and_redraw = require("nvim-tree.actions.finders.find-file").fn
-
 function M.setup(opts)
   M.hijack_unnamed_buffer_when_opening = opts.hijack_unnamed_buffer_when_opening
   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

@@ -1,6 +1,7 @@
 local view = require "nvim-tree.view"
 local utils = require "nvim-tree.utils"
 local Iterator = require "nvim-tree.iterators.node-iterator"
+local filters = require "nvim-tree.explorer.filters"
 
 local M = {
   filter = nil,
@@ -10,8 +11,14 @@ local function redraw()
   require("nvim-tree.renderer").draw()
 end
 
+---@param node_ Node|nil
 local function reset_filter(node_)
-  node_ = node_ or TreeExplorer
+  node_ = node_ or require("nvim-tree.core").get_explorer()
+
+  if node_ == nil then
+    return
+  end
+
   Iterator.builder(node_.nodes)
     :hidden()
     :applier(function(node)
@@ -37,7 +44,8 @@ local function remove_overlay()
     })
   end
 
-  vim.api.nvim_win_close(overlay_winnr, { force = true })
+  vim.api.nvim_win_close(overlay_winnr, true)
+  vim.api.nvim_buf_delete(overlay_bufnr, { force = true })
   overlay_bufnr = nil
   overlay_winnr = nil
 
@@ -46,12 +54,19 @@ local function remove_overlay()
   end
 end
 
+---@param node Node
+---@return boolean
 local function matches(node)
+  if not filters.config.enable then
+    return true
+  end
+
   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_)
@@ -78,7 +93,7 @@ function M.apply_filter(node_)
     node.hidden = not (has_nodes or (ok and is_match))
   end
 
-  iterate(node_ or TreeExplorer)
+  iterate(node_ or require("nvim-tree.core").get_explorer())
 end
 
 local function record_char()
@@ -104,8 +119,18 @@ local function configure_buffer_overlay()
   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()
-  local min_width = 20
   if view.View.float.enable then
     -- don't close nvim-tree float when focus is changed to filter window
     vim.api.nvim_clear_autocmds {
@@ -113,8 +138,6 @@ local function create_overlay()
       pattern = "NvimTree_*",
       group = vim.api.nvim_create_augroup("NvimTree", { clear = false }),
     }
-
-    min_width = min_width - 2
   end
 
   configure_buffer_overlay()
@@ -122,7 +145,7 @@ local function create_overlay()
     col = 1,
     row = 0,
     relative = "cursor",
-    width = math.max(min_width, vim.api.nvim_win_get_width(view.get_winnr()) - #M.prefix - 2),
+    width = calculate_overlay_win_width(),
     height = 1,
     border = "none",
     style = "minimal",
@@ -134,6 +157,7 @@ local function create_overlay()
 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()
@@ -145,9 +169,18 @@ function M.start_filtering()
 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)

lua/nvim-tree/log.lua

@@ -4,53 +4,94 @@ local M = {
 }
 
 --- Write to log file
---- @param typ string as per log.types config
---- @param fmt string for string.format
---- @vararg any arguments for string.format
+---@param typ string as per log.types config
+---@param fmt string for string.format
+---@param ... any arguments for string.format
 function M.raw(typ, fmt, ...)
-  if not M.path or not M.config.types[typ] and not M.config.types.all then
+  if not M.enabled(typ) then
     return
   end
 
   local line = string.format(fmt, ...)
   local file = io.open(M.path, "a")
-  io.output(file)
-  io.write(line)
-  io.close(file)
+  if file then
+    io.output(file)
+    io.write(line)
+    io.close(file)
+  end
 end
 
---- Write to log file via M.line
+---@class Profile
+---@field start number nanos
+---@field tag string
+
+--- Write profile start to log file
 --- START is prefixed
---- @return number nanos to pass to profile_end
+---@param fmt string for string.format
+---@param ... any arguments for string.format
+---@return Profile to pass to profile_end
 function M.profile_start(fmt, ...)
-  if not M.path or not M.config.types.profile and not M.config.types.all then
-    return
+  local profile = {}
+  if M.enabled "profile" then
+    profile.start = vim.loop.hrtime()
+    profile.tag = string.format((fmt or "???"), ...)
+    M.line("profile", "START %s", profile.tag)
   end
-  M.line("profile", "START " .. (fmt or "???"), ...)
-  return vim.loop.hrtime()
+  return profile
 end
 
---- Write to log file via M.line
+--- Write profile end to log file
 --- END is prefixed and duration in seconds is suffixed
---- @param start number nanos returned from profile_start
-function M.profile_end(start, fmt, ...)
-  if not M.path or not M.config.types.profile and not M.config.types.all then
-    return
+---@param profile Profile returned from profile_start
+function M.profile_end(profile)
+  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
-  local millis = start and math.modf((vim.loop.hrtime() - start) / 1000000) or -1
-  M.line("profile", "END   " .. (fmt or "???") .. "  " .. millis .. "ms", ...)
 end
 
--- Write to log file via M.raw
--- time and typ are prefixed and a trailing newline is added
+--- Write to log file
+--- time and typ are prefixed and a trailing newline is added
+---@param typ string as per log.types config
+---@param fmt string for string.format
+---@param ... any arguments for string.format
 function M.line(typ, fmt, ...)
-  M.raw(typ, string.format("[%s] [%s] %s\n", os.date "%Y-%m-%d %H:%M:%S", 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 "???")), ...)
+  end
+end
+
+local inspect_opts = {}
+
+---@param opts table
+function M.set_inspect_opts(opts)
+  inspect_opts = opts
+end
+
+--- Write to log file the inspection of a node
+--- defaults to the node under cursor if none is provided
+---@param typ string as per log.types config
+---@param node table|nil node to be inspected
+---@param fmt string for string.format
+---@vararg any arguments for string.format
+function M.node(typ, node, fmt, ...)
+  if M.enabled(typ) then
+    node = node or require("nvim-tree.lib").get_node_at_cursor()
+    M.raw(typ, string.format("[%s] [%s] %s\n%s\n", os.date "%Y-%m-%d %H:%M:%S", typ, (fmt or "???"), vim.inspect(node, inspect_opts)), ...)
+  end
+end
+
+--- Logging is enabled for typ or all
+---@param typ string as per log.types config
+---@return boolean
+function M.enabled(typ)
+  return M.path ~= nil and (M.config.types[typ] or M.config.types.all)
 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 "cache", 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").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" }, "nvimtree_bulk_delete", 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

@@ -1,18 +1,36 @@
-local Marks = require "nvim-tree.marks"
-local Core = require "nvim-tree.core"
+local marks = require "nvim-tree.marks"
+local core = require "nvim-tree.core"
 local utils = require "nvim-tree.utils"
-local FsRename = require "nvim-tree.actions.fs.rename-file"
+local rename_file = require "nvim-tree.actions.fs.rename-file"
 local notify = require "nvim-tree.notify"
+local lib = require "nvim-tree.lib"
 
-local M = {}
+local M = {
+  config = {},
+}
 
 function M.bulk_move()
-  if #Marks.get_marks() == 0 then
-    notify.warn "no bookmark to perform bulk move on, aborting."
+  if #marks.get_marks() == 0 then
+    notify.warn "No bookmarks to move."
     return
   end
 
-  vim.ui.input({ prompt = "Move to: ", default = Core.get_cwd(), completion = "dir" }, function(location)
+  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
@@ -22,21 +40,23 @@ function M.bulk_move()
       return
     end
 
-    local marks = Marks.get_marks()
-    for _, node in pairs(marks) do
+    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 }
-      FsRename.rename(node, to)
+      rename_file.rename(node, to)
     end
 
-    if M.enable_reload then
-      require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+    marks.clear_marks()
+
+    if not M.config.filesystem_watchers.enable then
+      require("nvim-tree.actions.reloaders").reload_explorer()
     end
   end)
 end
 
 function M.setup(opts)
-  M.enable_reload = not opts.filesystem_watchers.enable
+  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" }, "nvimtree_bulk_trash", 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,21 +1,27 @@
-local view = require "nvim-tree.view"
-local Iterator = require "nvim-tree.iterators.node-iterator"
-local core = require "nvim-tree.core"
+local renderer = {} -- circular dependency
 
 local NvimTreeMarks = {}
 
 local M = {}
 
+---@class MinimalNode
+---@field absolute_path string
+
+---@param node Node|MinimalNode
 local function add_mark(node)
   NvimTreeMarks[node.absolute_path] = node
-  M.draw()
+
+  renderer.draw()
 end
 
+---@param node Node|MinimalNode
 local function remove_mark(node)
   NvimTreeMarks[node.absolute_path] = nil
-  M.draw()
+
+  renderer.draw()
 end
 
+---@param node Node|MinimalNode
 function M.toggle_mark(node)
   if node.absolute_path == nil then
     return
@@ -26,17 +32,23 @@ function M.toggle_mark(node)
   else
     add_mark(node)
   end
+
+  renderer.draw()
 end
 
 function M.clear_marks()
   NvimTreeMarks = {}
-  M.draw()
+
+  renderer.draw()
 end
 
+---@param node Node|MinimalNode
+---@return table|nil
 function M.get_mark(node)
-  return NvimTreeMarks[node.absolute_path]
+  return node and NvimTreeMarks[node.absolute_path]
 end
 
+---@return table
 function M.get_marks()
   local list = {}
   for _, node in pairs(NvimTreeMarks) do
@@ -45,36 +57,11 @@ function M.get_marks()
   return list
 end
 
-local GROUP = "NvimTreeMarkSigns"
-local SIGN_NAME = "NvimTreeMark"
-
-function M.clear()
-  vim.fn.sign_unplace(GROUP)
-end
-
-function M.draw()
-  if not view.is_visible() then
-    return
-  end
-
-  M.clear()
-
-  local buf = view.get_bufnr()
-  local add = core.get_nodes_starting_line() - 1
-  Iterator.builder(core.get_explorer().nodes)
-    :recursor(function(node)
-      return node.open and node.nodes
-    end)
-    :applier(function(node, idx)
-      if M.get_mark(node) then
-        vim.fn.sign_place(0, GROUP, SIGN_NAME, buf, { lnum = idx + add, priority = 3 })
-      end
-    end)
-    :iterate()
-end
-
 function M.setup(opts)
-  vim.fn.sign_define(SIGN_NAME, { text = opts.renderer.icons.glyphs.bookmark, texthl = "NvimTreeBookmark" })
+  renderer = require "nvim-tree.renderer"
+
+  require("nvim-tree.marks.bulk-delete").setup(opts)
+  require("nvim-tree.marks.bulk-trash").setup(opts)
   require("nvim-tree.marks.bulk-move").setup(opts)
 end
 

lua/nvim-tree/marks/navigation.lua

@@ -5,6 +5,9 @@ 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
@@ -47,12 +50,16 @@ local function get_nearest(node, where)
   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)
@@ -61,6 +68,8 @@ local function open_or_focus(node)
   end
 end
 
+---@param where string
+---@return function
 local function navigate_to(where)
   return function()
     local node = lib.get_node_at_cursor()

lua/nvim-tree/node.lua

@@ -0,0 +1,34 @@
+---@meta
+
+---@class ParentNode
+---@field name string
+
+---@class BaseNode
+---@field absolute_path string
+---@field executable boolean
+---@field fs_stat uv.fs_stat.result|nil
+---@field git_status GitStatus|nil
+---@field hidden boolean
+---@field 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
+
+---@class FileNode: BaseNode
+---@field extension string
+
+---@class SymlinkDirNode: DirNode
+---@field link_to string
+
+---@class SymlinkFileNode: FileNode
+---@field link_to string
+
+---@alias SymlinkNode SymlinkDirNode|SymlinkFileNode
+---@alias Node ParentNode|DirNode|FileNode|SymlinkNode|Explorer

lua/nvim-tree/notify.lua

@@ -2,8 +2,22 @@ local M = {}
 
 local config = {
   threshold = vim.log.levels.INFO,
+  absolute_path = true,
 }
 
+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))
+      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 false
+  end
+
+  return title_support
+end
+
 local modes = {
   { name = "trace", level = vim.log.levels.TRACE },
   { name = "debug", level = vim.log.levels.DEBUG },
@@ -13,19 +27,18 @@ local modes = {
 }
 
 do
-  local has_notify, notify_plugin = pcall(require, "notify")
-
   local dispatch = function(level, msg)
-    if level < config.threshold then
+    if level < config.threshold or not msg then
       return
     end
 
     vim.schedule(function()
-      if has_notify and notify_plugin then
-        notify_plugin(msg, level, { title = "NvimTree" })
-      else
-        vim.notify("[NvimTree] " .. msg, level)
+      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)
       end
+
+      vim.notify(msg, level, { title = "NvimTree" })
     end)
   end
 
@@ -36,9 +49,20 @@ do
   end
 end
 
+---@param path string
+---@return string
+function M.render_path(path)
+  if config.absolute_path then
+    return path
+  else
+    return vim.fn.fnamemodify(path .. "/", ":h:t")
+  end
+end
+
 function M.setup(opts)
   opts = opts or {}
   config.threshold = opts.notify.threshold or vim.log.levels.INFO
+  config.absolute_path = opts.notify.absolute_path
 end
 
 return M

lua/nvim-tree/renderer/builder.lua

@@ -1,141 +1,148 @@
-local utils = require "nvim-tree.utils"
 local core = require "nvim-tree.core"
+local live_filter = require "nvim-tree.live-filter"
+local notify = require "nvim-tree.notify"
+local utils = require "nvim-tree.utils"
+local view = require "nvim-tree.view"
+
+local DecoratorBookmarks = require "nvim-tree.renderer.decorator.bookmarks"
+local DecoratorCopied = require "nvim-tree.renderer.decorator.copied"
+local DecoratorCut = require "nvim-tree.renderer.decorator.cut"
+local DecoratorDiagnostics = require "nvim-tree.renderer.decorator.diagnostics"
+local DecoratorGit = require "nvim-tree.renderer.decorator.git"
+local DecoratorModified = require "nvim-tree.renderer.decorator.modified"
+local DecoratorOpened = require "nvim-tree.renderer.decorator.opened"
 
-local git = require "nvim-tree.renderer.components.git"
 local pad = require "nvim-tree.renderer.components.padding"
 local icons = require "nvim-tree.renderer.components.icons"
 
+local M = {
+  opts = {},
+  decorators = {},
+  picture_map = {
+    jpg = true,
+    jpeg = true,
+    png = true,
+    gif = true,
+    webp = true,
+    jxl = true,
+  },
+}
+
+---@class HighlightedString
+---@field str string
+---@field hl string[]
+
+---@class AddHighlightArgs
+---@field group string[]
+---@field line number
+---@field col_start number
+---@field col_end number
+
+---@class Builder
+---@field lines string[] includes icons etc.
+---@field hl_args AddHighlightArgs[] line highlights
+---@field signs string[] line signs
+---@field private root_cwd string absolute path
+---@field private index number
+---@field private depth number
+---@field private combined_groups table<string, boolean> combined group names
+---@field private markers boolean[] indent markers
 local Builder = {}
-Builder.__index = Builder
 
-local DEFAULT_ROOT_FOLDER_LABEL = ":~:s?$?/..?"
-
-function Builder.new(root_cwd)
-  return setmetatable({
+---@return Builder
+function Builder:new()
+  local o = {
+    root_cwd = core.get_cwd(),
     index = 0,
     depth = 0,
-    highlights = {},
+    hl_args = {},
+    combined_groups = {},
     lines = {},
     markers = {},
     signs = {},
-    root_cwd = root_cwd,
-  }, Builder)
+  }
+  setmetatable(o, self)
+  self.__index = self
+
+  return o
 end
 
-function Builder:configure_root_label(root_folder_label)
-  self.root_folder_label = root_folder_label or DEFAULT_ROOT_FOLDER_LABEL
-  return self
+---Insert ranged highlight groups into self.highlights
+---@private
+---@param groups string[]
+---@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
 
-function Builder:configure_trailing_slash(with_trailing)
-  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_git_icons_padding(padding)
-  self.git_icon_padding = padding or " "
-  return self
-end
-
-function Builder:configure_git_icons_placement(where)
-  if where == "signcolumn" then
-    vim.fn.sign_unplace(git.SIGN_GROUP)
-    self.is_git_sign = true
-  end
-  self.is_git_after = where == "after" and not self.is_git_sign
-  return self
-end
-
-function Builder:configure_symlink_destination(show)
-  self.symlink_destination = show
-  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
-
-local function get_folder_name(node)
+---@private
+function Builder:get_folder_name(node)
   local name = node.name
   local next = node.group_next
   while next do
-    name = name .. "/" .. next.name
+    name = string.format("%s/%s", name, next.name)
     next = next.group_next
   end
-  return name
+
+  if node.group_next and type(M.opts.renderer.group_empty) == "function" then
+    local new_name = M.opts.renderer.group_empty(name)
+    if type(new_name) == "string" then
+      name = new_name
+    else
+      notify.warn(string.format("Invalid return type for field renderer.group_empty. Expected string, got %s", type(new_name)))
+    end
+  end
+
+  return string.format("%s%s", name, M.opts.renderer.add_trailing and "/" or "")
 end
 
-function Builder:_unwrap_git_data(git_icons_and_hl_groups, offset)
-  if not git_icons_and_hl_groups then
+---@private
+---@param highlighted_strings HighlightedString[]
+---@return string
+function Builder:unwrap_highlighted_strings(highlighted_strings)
+  if not highlighted_strings then
     return ""
   end
 
-  local icon = ""
-  for i, v in ipairs(git_icons_and_hl_groups) do
-    if #v.icon > 0 then
-      self:_insert_highlight(v.hl, offset + #icon, offset + #icon + #v.icon)
-      local remove_padding = self.is_git_after and i == #git_icons_and_hl_groups
-      icon = icon .. v.icon .. (remove_padding and "" or self.git_icon_padding)
+  local string = ""
+  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)
+      end
+      string = string.format("%s%s", string, v.str)
     end
   end
-  return icon
+  return string
 end
 
-function Builder:_build_folder(node, padding, git_hl, git_icons_tbl)
-  local offset = string.len(padding)
-
-  local name = get_folder_name(node)
+---@private
+---@param node table
+---@return HighlightedString icon
+---@return HighlightedString name
+function Builder:build_folder(node)
   local has_children = #node.nodes ~= 0 or node.has_children
-  local icon = icons.get_folder_icon(node.open, node.link_to ~= nil, has_children)
+  local icon, icon_hl = icons.get_folder_icon(node, has_children)
+  local foldername = self:get_folder_name(node)
 
-  local foldername = name .. self.trailing_slash
-  if node.link_to and self.symlink_destination then
-    local arrow = icons.i.symlink_arrow
-    local link_to = utils.path_relative(node.link_to, core.get_cwd())
-    foldername = foldername .. arrow .. link_to
-  end
-
-  local git_icons = self:_unwrap_git_data(git_icons_tbl, offset + #icon + (self.is_git_after and #foldername + 1 or 0))
-  local fname_starts_at = offset + #icon + (self.is_git_after and 0 or #git_icons)
-  local line = self:_format_line(padding .. icon, foldername, git_icons)
-  self:_insert_line(line)
-
-  if #icon > 0 then
+  if #icon > 0 and icon_hl == nil then
     if node.open then
-      self:_insert_highlight("NvimTreeOpenedFolderIcon", offset, offset + #icon)
+      icon_hl = "NvimTreeOpenedFolderIcon"
     else
-      self:_insert_highlight("NvimTreeClosedFolderIcon", offset, offset + #icon)
+      icon_hl = "NvimTreeClosedFolderIcon"
     end
   end
 
   local foldername_hl = "NvimTreeFolderName"
-  if vim.tbl_contains(self.special_files, node.absolute_path) or vim.tbl_contains(self.special_files, node.name) then
+  if node.link_to and M.opts.renderer.symlink_destination then
+    local arrow = icons.i.symlink_arrow
+    local link_to = utils.path_relative(node.link_to, self.root_cwd)
+    foldername = string.format("%s%s%s", foldername, arrow, link_to)
+    foldername_hl = "NvimTreeSymlinkFolderName"
+  elseif
+    vim.tbl_contains(M.opts.renderer.special_files, node.absolute_path) or vim.tbl_contains(M.opts.renderer.special_files, node.name)
+  then
     foldername_hl = "NvimTreeSpecialFolderName"
   elseif node.open then
     foldername_hl = "NvimTreeOpenedFolderName"
@@ -143,138 +150,216 @@ function Builder:_build_folder(node, padding, git_hl, git_icons_tbl)
     foldername_hl = "NvimTreeEmptyFolderName"
   end
 
-  self:_insert_highlight(foldername_hl, fname_starts_at, fname_starts_at + #foldername)
-
-  if git_hl then
-    self:_insert_highlight(git_hl, fname_starts_at, fname_starts_at + #foldername)
-  end
+  return { str = icon, hl = { icon_hl } }, { str = foldername, hl = { foldername_hl } }
 end
 
-function Builder:_format_line(before, after, git_icons)
-  git_icons = self.is_git_after and git_icons and " " .. git_icons or git_icons
-  return string.format(
-    "%s%s%s%s",
-    before,
-    self.is_git_after and "" or git_icons,
-    after,
-    self.is_git_after and git_icons or ""
-  )
-end
-
-function Builder:_build_symlink(node, padding, git_highlight, git_icons_tbl)
-  local offset = string.len(padding)
-
+---@private
+---@param node table
+---@return HighlightedString icon
+---@return HighlightedString name
+function Builder:build_symlink(node)
   local icon = icons.i.symlink
   local arrow = icons.i.symlink_arrow
   local symlink_formatted = node.name
-  if self.symlink_destination then
-    local link_to = utils.path_relative(node.link_to, core.get_cwd())
-    symlink_formatted = symlink_formatted .. arrow .. link_to
+  if M.opts.renderer.symlink_destination then
+    local link_to = utils.path_relative(node.link_to, self.root_cwd)
+    symlink_formatted = string.format("%s%s%s", symlink_formatted, arrow, link_to)
   end
 
-  local link_highlight = git_highlight or "NvimTreeSymlink"
-
-  local git_icons_starts_at = offset + #icon + (self.is_git_after and #symlink_formatted + 1 or 0)
-  local git_icons = self:_unwrap_git_data(git_icons_tbl, git_icons_starts_at)
-  local line = self:_format_line(padding .. icon, symlink_formatted, git_icons)
-
-  self:_insert_highlight(link_highlight, offset + (self.is_git_after and 0 or #git_icons), string.len(line))
-  self:_insert_line(line)
+  return { str = icon, hl = { "NvimTreeSymlinkIcon" } }, { str = symlink_formatted, hl = { "NvimTreeSymlink" } }
 end
 
-function Builder:_build_file_icon(node, offset)
-  local icon, hl_group = icons.get_file_icon(node.name, node.extension)
-  if hl_group then
-    self:_insert_highlight(hl_group, offset, offset + #icon)
-  end
-  return icon, false
-end
-
-function Builder:_highlight_opened_files(node, offset, icon_length, git_icons_length)
-  local from = offset
-  local to = offset
-
-  if self.highlight_opened_files == "icon" then
-    to = from + icon_length
-  elseif self.highlight_opened_files == "name" then
-    from = offset + icon_length + git_icons_length
-    to = from + #node.name
-  elseif self.highlight_opened_files == "all" then
-    to = from + icon_length + git_icons_length + #node.name
-  end
-
-  self:_insert_highlight("NvimTreeOpenedFile", from, to)
-end
-
-function Builder:_build_file(node, padding, git_highlight, git_icons_tbl)
-  local offset = string.len(padding)
-
-  local icon = self:_build_file_icon(node, offset)
-
-  local git_icons_starts_at = offset + #icon + (self.is_git_after and #node.name + 1 or 0)
-  local git_icons = self:_unwrap_git_data(git_icons_tbl, git_icons_starts_at)
-
-  self:_insert_line(self:_format_line(padding .. icon, node.name, git_icons))
-
-  local git_icons_length = self.is_git_after and 0 or #git_icons
-  local col_start = offset + #icon + git_icons_length
-  local col_end = col_start + #node.name
-
-  if vim.tbl_contains(self.special_files, node.absolute_path) or vim.tbl_contains(self.special_files, node.name) then
-    self:_insert_highlight("NvimTreeSpecialFile", col_start, col_end)
+---@private
+---@param node table
+---@return HighlightedString icon
+---@return HighlightedString name
+function Builder:build_file(node)
+  local hl
+  if vim.tbl_contains(M.opts.renderer.special_files, node.absolute_path) or vim.tbl_contains(M.opts.renderer.special_files, node.name) then
+    hl = "NvimTreeSpecialFile"
   elseif node.executable then
-    self:_insert_highlight("NvimTreeExecFile", col_start, col_end)
-  elseif self.picture_map[node.extension] then
-    self:_insert_highlight("NvimTreeImageFile", col_start, col_end)
+    hl = "NvimTreeExecFile"
+  elseif M.picture_map[node.extension] then
+    hl = "NvimTreeImageFile"
   end
 
-  local should_highlight_opened_files = self.highlight_opened_files and vim.fn.bufloaded(node.absolute_path) > 0
-  if should_highlight_opened_files then
-    self:_highlight_opened_files(node, offset, #icon, git_icons_length)
+  local icon, hl_group = icons.get_file_icon(node.name, node.extension)
+  return { str = icon, hl = { hl_group } }, { str = node.name, hl = { hl } }
+end
+
+---@private
+---@param indent_markers HighlightedString[]
+---@param arrows HighlightedString[]|nil
+---@param icon HighlightedString
+---@param name HighlightedString
+---@param node table
+---@return HighlightedString[]
+function Builder:format_line(indent_markers, arrows, icon, name, node)
+  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 = M.opts.renderer.icons.padding })
+      end
+      table.insert(t1, v)
+    end
+
+    -- first add_to_end don't need padding
+    -- hence added_len is calculated at the end to be used next time
+    added_len = 0
+    for _, v in ipairs(t2) do
+      added_len = added_len + #v.str
+    end
   end
 
-  if git_highlight then
-    self:_insert_highlight(git_highlight, col_start, col_end)
+  local line = { indent_markers, arrows }
+  add_to_end(line, { icon })
+
+  for i = #M.decorators, 1, -1 do
+    add_to_end(line, M.decorators[i]:icons_before(node))
+  end
+
+  add_to_end(line, { name })
+
+  for i = #M.decorators, 1, -1 do
+    add_to_end(line, M.decorators[i]:icons_after(node))
+  end
+
+  return line
+end
+
+---@private
+---@param node Node
+function Builder:build_signs(node)
+  -- first in priority order
+  local sign_name
+  for _, d in ipairs(M.decorators) do
+    sign_name = d:sign_name(node)
+    if sign_name then
+      self.signs[self.index] = sign_name
+      break
+    end
   end
 end
 
-function Builder:_build_line(node, idx, num_children)
-  local padding = pad.get_padding(self.depth, idx, num_children, node, self.markers)
+---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)))
 
-  if string.len(padding) > 0 then
-    self:_insert_highlight("NvimTreeIndentMarker", 0, string.len(padding))
+  -- 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
 
-  local git_highlight = git.get_highlight(node)
-  local git_icons_tbl = git.get_icons(node)
+  return combined_name
+end
 
-  if self.is_git_sign and git_icons_tbl and #git_icons_tbl > 0 then
-    local git_info = git_icons_tbl[1]
-    table.insert(self.signs, { sign = git_info.hl, lnum = self.index + 1 })
-    git_icons_tbl = {}
+---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 = #M.decorators, 1, -1 do
+    d = M.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; <= 0.8 always uses highest due to lack of a practical nvim_get_hl equivalent
+  if #icon_groups > 1 then
+    if vim.fn.has "nvim-0.9" == 1 then
+      icon_hl_group = self:create_combined_group(icon_groups)
+    else
+      icon_hl_group = icon_groups[#icon_groups]
+    end
+  else
+    icon_hl_group = icon_groups[1]
+  end
+
+  -- one or many name groups; <= 0.8 always uses highest due to lack of a practical nvim_get_hl equivalent
+  if #name_groups > 1 then
+    if vim.fn.has "nvim-0.9" == 1 then
+      name_hl_group = self:create_combined_group(name_groups)
+    else
+      name_hl_group = name_groups[#name_groups]
+    end
+  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)
+
+  -- main components
   local is_folder = node.nodes ~= nil
   local is_symlink = node.link_to ~= nil
-
+  local icon, name
   if is_folder then
-    self:_build_folder(node, padding, git_highlight, git_icons_tbl)
+    icon, name = self:build_folder(node)
   elseif is_symlink then
-    self:_build_symlink(node, padding, git_highlight, git_icons_tbl)
+    icon, name = self:build_symlink(node)
   else
-    self:_build_file(node, padding, git_highlight, git_icons_tbl)
+    icon, name = self:build_file(node)
   end
+
+  -- highighting
+  local icon_hl_group, name_hl_group = self:add_highlights(node)
+  table.insert(icon.hl, icon_hl_group)
+  table.insert(name.hl, name_hl_group)
+
+  local line = self:format_line(indent_markers, arrows, icon, name, node)
+  table.insert(self.lines, 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(node)
+    self:build_lines(node)
     self.depth = self.depth - 1
   end
 end
 
-function Builder:_get_nodes_number(nodes)
-  if not self.filter then
+---@private
+function Builder:get_nodes_number(nodes)
+  if not live_filter.filter then
     return #nodes
   end
 
@@ -287,53 +372,87 @@ function Builder:_get_nodes_number(nodes)
   return i
 end
 
-function Builder:build(tree)
-  local num_children = self:_get_nodes_number(tree.nodes)
+---@private
+function Builder:build_lines(node)
+  if not node then
+    node = core.get_explorer()
+  end
+  local num_children = self:get_nodes_number(node.nodes)
   local idx = 1
-  for _, node in ipairs(tree.nodes) do
-    if not node.hidden then
-      self:_build_line(node, idx, num_children)
+  for _, n in ipairs(node.nodes) do
+    if not n.hidden then
+      self:build_signs(n)
+      self:build_line(n, idx, num_children)
       idx = idx + 1
     end
   end
-
-  return self
 end
 
-local function format_root_name(root_cwd, root_label)
+---@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(root_cwd)
+    local label = root_label(self.root_cwd)
     if type(label) == "string" then
       return label
     else
-      root_label = DEFAULT_ROOT_FOLDER_LABEL
+      return "???"
     end
   end
-  return utils.path_remove_trailing(vim.fn.fnamemodify(root_cwd, root_label))
+  return utils.path_remove_trailing(vim.fn.fnamemodify(self.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))
+---@private
+function Builder:build_header()
+  if view.is_root_folder_visible(core.get_cwd()) then
+    local root_name = self:format_root_name(M.opts.renderer.root_folder_label)
+    table.insert(self.lines, root_name)
+    self:insert_highlight({ "NvimTreeRootFolder" }, 0, string.len(root_name))
     self.index = 1
   end
 
-  if 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))
+  if live_filter.filter then
+    local filter_line = string.format("%s/%s/", M.opts.live_filter.prefix, live_filter.filter)
+    table.insert(self.lines, filter_line)
+    local prefix_length = string.len(M.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
 
-function Builder:unwrap()
-  return self.lines, self.highlights, self.signs
+function Builder.setup(opts)
+  M.opts = opts
+
+  -- priority order
+  M.decorators = {
+    DecoratorCut:new(opts),
+    DecoratorCopied:new(opts),
+    DecoratorDiagnostics:new(opts),
+    DecoratorBookmarks:new(opts),
+    DecoratorModified:new(opts),
+    DecoratorOpened:new(opts),
+    DecoratorGit:new(opts),
+  }
 end
 
 return Builder

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

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

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

@@ -34,9 +34,6 @@ end
 
 local function show()
   local line_nr = vim.api.nvim_win_get_cursor(0)[1]
-  if line_nr == 1 and require("nvim-tree.view").is_root_folder_visible() then
-    return
-  end
   if vim.wo.wrap then
     return
   end
@@ -61,7 +58,8 @@ local function show()
 
   M.popup_win = vim.api.nvim_open_win(vim.api.nvim_create_buf(false, false), false, {
     relative = "win",
-    bufpos = { vim.fn.line "." - 2, 0 },
+    row = 0,
+    bufpos = { vim.api.nvim_win_get_cursor(0)[1] - 1, 0 },
     width = math.min(text_width, vim.o.columns - 2),
     height = 1,
     noautocmd = true,
@@ -71,7 +69,7 @@ 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 = 1 })
   vim.api.nvim_win_call(M.popup_win, function()
-    vim.fn.setbufline("%", 1, line)
+    vim.api.nvim_buf_set_lines(0, 0, -1, true, { line })
     for _, extmark in ipairs(extmarks) do
       local hl = extmark[4]
       vim.api.nvim_buf_add_highlight(0, ns_id, hl.hl_group, 0, extmark[3], hl.end_col)

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

@@ -1,170 +0,0 @@
-local notify = require "nvim-tree.notify"
-local explorer_common = require "nvim-tree.explorer.common"
-
-local M = {
-  SIGN_GROUP = "NvimTreeGitSigns",
-}
-
-local function build_icons_table(i)
-  return {
-    ["M "] = { { icon = i.staged, hl = "NvimTreeGitStaged" } },
-    [" M"] = { { icon = i.unstaged, hl = "NvimTreeGitDirty" } },
-    ["C "] = { { icon = i.staged, hl = "NvimTreeGitStaged" } },
-    [" C"] = { { icon = i.unstaged, hl = "NvimTreeGitDirty" } },
-    ["CM"] = { { icon = i.unstaged, hl = "NvimTreeGitDirty" } },
-    [" T"] = { { icon = i.unstaged, hl = "NvimTreeGitDirty" } },
-    ["T "] = { { icon = i.staged, hl = "NvimTreeGitStaged" } },
-    ["MM"] = {
-      { icon = i.staged, hl = "NvimTreeGitStaged" },
-      { icon = i.unstaged, hl = "NvimTreeGitDirty" },
-    },
-    ["MD"] = {
-      { icon = i.staged, hl = "NvimTreeGitStaged" },
-    },
-    ["A "] = {
-      { icon = i.staged, hl = "NvimTreeGitStaged" },
-    },
-    ["AD"] = {
-      { icon = i.staged, hl = "NvimTreeGitStaged" },
-    },
-    [" A"] = {
-      { icon = i.untracked, hl = "NvimTreeGitNew" },
-    },
-    -- not sure about this one
-    ["AA"] = {
-      { icon = i.unmerged, hl = "NvimTreeGitMerge" },
-      { icon = i.untracked, hl = "NvimTreeGitNew" },
-    },
-    ["AU"] = {
-      { icon = i.unmerged, hl = "NvimTreeGitMerge" },
-      { icon = i.untracked, hl = "NvimTreeGitNew" },
-    },
-    ["AM"] = {
-      { icon = i.staged, hl = "NvimTreeGitStaged" },
-      { icon = i.unstaged, hl = "NvimTreeGitDirty" },
-    },
-    ["??"] = { { icon = i.untracked, hl = "NvimTreeGitNew" } },
-    ["R "] = { { icon = i.renamed, hl = "NvimTreeGitRenamed" } },
-    [" R"] = { { icon = i.renamed, hl = "NvimTreeGitRenamed" } },
-    ["RM"] = {
-      { icon = i.unstaged, hl = "NvimTreeGitDirty" },
-      { icon = i.renamed, hl = "NvimTreeGitRenamed" },
-    },
-    ["UU"] = { { icon = i.unmerged, hl = "NvimTreeGitMerge" } },
-    ["UD"] = { { icon = i.unmerged, hl = "NvimTreeGitMerge" } },
-    ["UA"] = { { icon = i.unmerged, hl = "NvimTreeGitMerge" } },
-    [" D"] = { { icon = i.deleted, hl = "NvimTreeGitDeleted" } },
-    ["D "] = { { icon = i.deleted, hl = "NvimTreeGitDeleted" } },
-    ["RD"] = { { icon = i.deleted, hl = "NvimTreeGitDeleted" } },
-    ["DD"] = { { icon = i.deleted, hl = "NvimTreeGitDeleted" } },
-    ["DU"] = {
-      { icon = i.deleted, hl = "NvimTreeGitDeleted" },
-      { icon = i.unmerged, hl = "NvimTreeGitMerge" },
-    },
-    ["!!"] = { { icon = i.ignored, hl = "NvimTreeGitIgnored" } },
-    dirty = { { icon = i.unstaged, hl = "NvimTreeGitDirty" } },
-  }
-end
-
-local function nil_() end
-
-local function warn_status(git_status)
-  notify.warn(
-    'Unrecognized git state "'
-      .. git_status
-      .. '". Please open up an issue on https://github.com/nvim-tree/nvim-tree.lua/issues with this message.'
-  )
-end
-
-local function get_icons_(node)
-  if not explorer_common.shows_git_status(node) then
-    return nil
-  end
-
-  local git_status = node.git_status
-  local icons = M.git_icons[git_status]
-  if not icons then
-    if not M.config.highlight_git then
-      warn_status(git_status)
-    end
-    return nil
-  end
-
-  return icons
-end
-
-local git_hl = {
-  ["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 "] = "NvimTreeFileNew",
-  ["??"] = "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",
-}
-
-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 = node.git_status
-  if not explorer_common.shows_git_status(node) then
-    return
-  end
-
-  return git_hl[git_status]
-end
-
-function M.setup(opts)
-  M.config = opts.renderer
-
-  M.git_icons = build_icons_table(opts.renderer.icons.glyphs.git)
-
-  M.setup_signs(opts.renderer.icons.glyphs.git)
-
-  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

@@ -1,7 +1,7 @@
 local M = { i = {} }
 
 local function config_symlinks()
-  M.i.symlink = #M.config.glyphs.symlink > 0 and M.config.glyphs.symlink .. M.config.padding or ""
+  M.i.symlink = #M.config.glyphs.symlink > 0 and M.config.glyphs.symlink or ""
   M.i.symlink_arrow = M.config.symlink_arrow
 end
 
@@ -9,13 +9,14 @@ local function empty()
   return ""
 end
 
-local function get_folder_icon(open, is_symlink, has_children)
+local function get_folder_icon_default(node, has_children)
+  local is_symlink = node.links_to ~= nil
   local n
-  if is_symlink and open then
+  if is_symlink and node.open then
     n = M.config.glyphs.folder.symlink_open
   elseif is_symlink then
     n = M.config.glyphs.folder.symlink
-  elseif open then
+  elseif node.open then
     if has_children then
       n = M.config.glyphs.folder.open
     else
@@ -28,14 +29,26 @@ local function get_folder_icon(open, is_symlink, has_children)
       n = M.config.glyphs.folder.empty
     end
   end
-  return n .. M.config.padding
+  return n, nil
+end
+
+local function get_folder_icon_webdev(node, has_children)
+  local icon, hl_group = M.devicons.get_icon(node.name, node.extension)
+  if not M.config.web_devicons.folder.color then
+    hl_group = nil
+  end
+  if icon ~= nil then
+    return icon, hl_group
+  else
+    return get_folder_icon_default(node, has_children)
+  end
 end
 
 local function get_file_icon_default()
   local hl_group = "NvimTreeFileIcon"
   local icon = M.config.glyphs.default
   if #icon > 0 then
-    return icon .. M.config.padding, hl_group
+    return icon, hl_group
   else
     return ""
   end
@@ -43,22 +56,27 @@ end
 
 local function get_file_icon_webdev(fname, extension)
   local icon, hl_group = M.devicons.get_icon(fname, extension)
-  if not M.config.webdev_colors then
+  if not M.config.web_devicons.file.color then
     hl_group = "NvimTreeFileIcon"
   end
   if icon and hl_group ~= "DevIconDefault" then
-    return icon .. M.config.padding, hl_group
+    return icon, hl_group
   elseif string.match(extension, "%.(.*)") then
     -- If there are more extensions to the file, try to grab the icon for them recursively
     return get_file_icon_webdev(fname, string.match(extension, "%.(.*)"))
   else
-    return get_file_icon_default()
+    local devicons_default = M.devicons.get_default_icon()
+    if devicons_default and type(devicons_default.icon) == "string" and type(devicons_default.name) == "string" then
+      return devicons_default.icon, "DevIcon" .. devicons_default.name
+    else
+      return get_file_icon_default()
+    end
   end
 end
 
 local function config_file_icon()
   if M.config.show.file then
-    if M.devicons then
+    if M.devicons and M.config.web_devicons.file.enable then
       M.get_file_icon = get_file_icon_webdev
     else
       M.get_file_icon = get_file_icon_default
@@ -70,7 +88,11 @@ end
 
 local function config_folder_icon()
   if M.config.show.folder then
-    M.get_folder_icon = get_folder_icon
+    if M.devicons and M.config.web_devicons.folder.enable then
+      M.get_folder_icon = get_folder_icon_webdev
+    else
+      M.get_folder_icon = get_folder_icon_default
+    end
   else
     M.get_folder_icon = empty
   end

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

@@ -30,9 +30,7 @@ local function get_padding_indent_markers(depth, idx, nodes_number, markers, wit
     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)
+        local bottom_width = M.config.indent_width - 2 + (with_arrows and not inline_arrows and has_folder_sibling and 2 or 0)
         glyph = M.config.indent_markers.icons.corner
           .. string.rep(M.config.indent_markers.icons.bottom, bottom_width)
           .. (M.config.indent_width > 1 and " " or "")
@@ -58,18 +56,14 @@ local function get_padding_indent_markers(depth, idx, nodes_number, markers, wit
   return padding
 end
 
-local function get_padding_arrows(node, indent)
-  if node.nodes then
-    return M.config.icons.glyphs.folder[node.open and "arrow_open" or "arrow_closed"] .. " "
-  elseif indent then
-    return "  "
-  else
-    return ""
-  end
-end
-
-function M.get_padding(depth, idx, nodes_number, node, markers)
-  local padding = ""
+---@param depth integer
+---@param idx integer
+---@param nodes_number integer
+---@param node table
+---@param markers table
+---@return HighlightedString[]
+function M.get_indent_markers(depth, idx, nodes_number, node, markers)
+  local str = ""
 
   local show_arrows = M.config.icons.show.folder_arrow
   local show_markers = M.config.indent_markers.enable
@@ -77,16 +71,38 @@ function M.get_padding(depth, idx, nodes_number, node, markers)
   local indent_width = M.config.indent_width
 
   if show_markers then
-    padding = padding .. get_padding_indent_markers(depth, idx, nodes_number, markers, show_arrows, inline_arrows, node)
+    str = str .. get_padding_indent_markers(depth, idx, nodes_number, markers, show_arrows, inline_arrows, node)
   else
-    padding = padding .. string.rep(" ", depth * indent_width)
+    str = str .. string.rep(" ", depth * indent_width)
   end
 
-  if show_arrows then
-    padding = padding .. get_padding_arrows(node, not show_markers)
+  return { str = str, hl = { "NvimTreeIndentMarker" } }
+end
+
+---@param node table
+---@return HighlightedString[]|nil
+function M.get_arrows(node)
+  if not M.config.icons.show.folder_arrow then
+    return
   end
 
-  return padding
+  local str
+  local hl = "NvimTreeFolderArrowClosed"
+
+  if node.nodes then
+    if node.open then
+      str = M.config.icons.glyphs.folder["arrow_open"] .. " "
+      hl = "NvimTreeFolderArrowOpen"
+    else
+      str = M.config.icons.glyphs.folder["arrow_closed"] .. " "
+    end
+  elseif M.config.indent_markers.enable then
+    str = ""
+  else
+    str = "  "
+  end
+
+  return { str = str, hl = { hl } }
 end
 
 function M.setup(opts)

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

@@ -0,0 +1,51 @@
+local marks = require "nvim-tree.marks"
+
+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 DecoratorBookmarks: Decorator
+---@field icon HighlightedString
+local DecoratorBookmarks = Decorator:new()
+
+---@param opts table
+---@return DecoratorBookmarks
+function DecoratorBookmarks:new(opts)
+  local o = Decorator.new(self, {
+    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 marks.get_mark(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 marks.get_mark(node) then
+    return "NvimTreeBookmarkHL"
+  end
+end
+
+return DecoratorBookmarks

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

@@ -0,0 +1,38 @@
+local copy_paste
+
+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 DecoratorCopied: Decorator
+---@field enabled boolean
+---@field icon HighlightedString|nil
+local DecoratorCopied = Decorator:new()
+
+---@param opts table
+---@return DecoratorCopied
+function DecoratorCopied:new(opts)
+  local o = Decorator.new(self, {
+    enabled = true,
+    hl_pos = HL_POSITION[opts.renderer.highlight_clipboard] or HL_POSITION.none,
+    icon_placement = ICON_PLACEMENT.none,
+  })
+  ---@cast o DecoratorCopied
+
+  -- cyclic
+  copy_paste = copy_paste or require "nvim-tree.actions.fs.copy-paste"
+
+  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 copy_paste.is_copied(node) then
+    return "NvimTreeCopiedHL"
+  end
+end
+
+return DecoratorCopied

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

@@ -0,0 +1,38 @@
+local copy_paste
+
+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 DecoratorCut: Decorator
+---@field enabled boolean
+---@field icon HighlightedString|nil
+local DecoratorCut = Decorator:new()
+
+---@param opts table
+---@return DecoratorCut
+function DecoratorCut:new(opts)
+  local o = Decorator.new(self, {
+    enabled = true,
+    hl_pos = HL_POSITION[opts.renderer.highlight_clipboard] or HL_POSITION.none,
+    icon_placement = ICON_PLACEMENT.none,
+  })
+  ---@cast o DecoratorCut
+
+  -- cyclic
+  copy_paste = copy_paste or require "nvim-tree.actions.fs.copy-paste"
+
+  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 copy_paste.is_cut(node) then
+    return "NvimTreeCutHL"
+  end
+end
+
+return DecoratorCut

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

@@ -0,0 +1,110 @@
+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 DecoratorDiagnostics: Decorator
+---@field icons HighlightedString[]
+local DecoratorDiagnostics = Decorator:new()
+
+---@param opts table
+---@return DecoratorDiagnostics
+function DecoratorDiagnostics:new(opts)
+  local o = Decorator.new(self, {
+    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

@@ -0,0 +1,221 @@
+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 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
+---@return DecoratorGit
+function DecoratorGit:new(opts)
+  local o = Decorator.new(self, {
+    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