1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
local path = require "nvim-lsp-installer.path"
local fs = require "nvim-lsp-installer.fs"
local Data = require "nvim-lsp-installer.data"
local installers = require "nvim-lsp-installer.installers"
local std = require "nvim-lsp-installer.installers.std"
local platform = require "nvim-lsp-installer.platform"
local process = require "nvim-lsp-installer.process"
local M = {}
local npm = platform.is_win and "npm.cmd" or "npm"
---@param installer ServerInstallerFunction
local function ensure_npm(installer)
return installers.pipe {
std.ensure_executables {
{ "node", "node was not found in path. Refer to https://nodejs.org/en/." },
{
"npm",
"npm was not found in path. Refer to https://docs.npmjs.com/downloading-and-installing-node-js-and-npm.",
},
},
installer,
}
end
local function create_installer(read_version_from_context)
---@param packages string[]
return function(packages)
return ensure_npm(
---@type ServerInstallerFunction
function(_, callback, context)
local pkgs = Data.list_copy(packages or {})
local c = process.chain {
cwd = context.install_dir,
stdio_sink = context.stdio_sink,
}
-- Use global-style. The reasons for this are:
-- a) To avoid polluting the executables (aka bin-links) that npm creates.
-- b) The installation is, after all, more similar to a "global" installation. We don't really gain
-- any of the benefits of not using global style (e.g., deduping the dependency tree).
--
-- We write to .npmrc manually instead of going through npm because managing a local .npmrc file
-- is a bit unreliable across npm versions (especially <7), so we take extra measures to avoid
-- inadvertently polluting global npm config.
fs.append_file(path.concat { context.install_dir, ".npmrc" }, "global-style=true")
-- stylua: ignore start
if not (fs.dir_exists(path.concat { context.install_dir, "node_modules" }) or
fs.file_exists(path.concat { context.install_dir, "package.json" }))
then
-- Create a package.json to set a boundary for where npm installs packages.
c.run(npm, { "init", "--yes", "--scope=lsp-installer" })
end
if read_version_from_context and context.requested_server_version and #pkgs > 0 then
-- The "head" package is the recipient for the requested version. It's.. by design... don't ask.
pkgs[1] = ("%s@%s"):format(pkgs[1], context.requested_server_version)
end
-- stylua: ignore end
c.run(npm, vim.list_extend({ "install" }, pkgs))
c.spawn(callback)
end
)
end
end
---Creates an installer that installs the provided packages. Will respect user's requested version.
M.packages = create_installer(true)
---Creates an installer that installs the provided packages. Will NOT respect user's requested version.
---This is useful in situation where there's a need to install an auxiliary npm package.
M.install = create_installer(false)
---Creates a server installer that executes the given executable.
---@param executable string
---@param args string[]
function M.exec(executable, args)
---@type ServerInstallerFunction
return function(_, callback, context)
process.spawn(M.executable(context.install_dir, executable), {
args = args,
cwd = context.install_dir,
stdio_sink = context.stdio_sink,
}, callback)
end
end
---Creates a server installer that runs the given script.
---@param script string @The npm script to run (npm run).
function M.run(script)
return ensure_npm(
---@type ServerInstallerFunction
function(_, callback, context)
process.spawn(npm, {
args = { "run", script },
cwd = context.install_dir,
stdio_sink = context.stdio_sink,
}, callback)
end
)
end
---@param root_dir string @The directory to resolve the executable from.
---@param executable string
function M.executable(root_dir, executable)
return path.concat {
root_dir,
"node_modules",
".bin",
platform.is_win and ("%s.cmd"):format(executable) or executable,
}
end
return M
|
