vscode-languageserver
Version:
Language server implementation for node
296 lines (295 loc) • 10.4 kB
JavaScript
;
/* --------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
* ------------------------------------------------------------------------------------------ */
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.FileSystem = void 0;
exports.uriToFilePath = uriToFilePath;
exports.resolve = resolve;
exports.resolveGlobalNodePath = resolveGlobalNodePath;
exports.resolveGlobalYarnPath = resolveGlobalYarnPath;
exports.resolveModulePath = resolveModulePath;
const url = __importStar(require("url"));
const path = __importStar(require("path"));
const fs = __importStar(require("fs"));
const child_process_1 = require("child_process");
/**
* @deprecated Use the `vscode-uri` npm module which provides a more
* complete implementation of handling VS Code URIs.
*/
function uriToFilePath(uri) {
const parsed = url.parse(uri);
if (parsed.protocol !== 'file:' || !parsed.path) {
return undefined;
}
const segments = parsed.path.split('/');
for (let i = 0, len = segments.length; i < len; i++) {
segments[i] = decodeURIComponent(segments[i]);
}
if (process.platform === 'win32' && segments.length > 1) {
const first = segments[0];
const second = segments[1];
// Do we have a drive letter and we started with a / which is the
// case if the first segement is empty (see split above)
if (first.length === 0 && second.length > 1 && second[1] === ':') {
// Remove first slash
segments.shift();
}
}
return path.normalize(segments.join('/'));
}
function isWindows() {
return process.platform === 'win32';
}
function resolve(moduleName, nodePath, cwd, tracer) {
const nodePathKey = 'NODE_PATH';
const app = [
'var p = process;',
'p.on(\'message\',function(m){',
'if(m.c===\'e\'){',
'p.exit(0);',
'}',
'else if(m.c===\'rs\'){',
'try{',
'var r=require.resolve(m.a);',
'p.send({c:\'r\',s:true,r:r});',
'}',
'catch(err){',
'p.send({c:\'r\',s:false});',
'}',
'}',
'});'
].join('');
return new Promise((resolve, reject) => {
const env = process.env;
const newEnv = Object.create(null);
Object.keys(env).forEach(key => newEnv[key] = env[key]);
if (nodePath && fs.existsSync(nodePath) /* see issue 545 */) {
if (newEnv[nodePathKey]) {
newEnv[nodePathKey] = nodePath + path.delimiter + newEnv[nodePathKey];
}
else {
newEnv[nodePathKey] = nodePath;
}
if (tracer) {
tracer(`NODE_PATH value is: ${newEnv[nodePathKey]}`);
}
}
newEnv['ELECTRON_RUN_AS_NODE'] = '1';
try {
const cp = (0, child_process_1.fork)('', [], {
cwd: cwd,
env: newEnv,
execArgv: ['-e', app]
});
if (cp.pid === void 0) {
reject(new Error(`Starting process to resolve node module ${moduleName} failed`));
return;
}
cp.on('error', (error) => {
reject(error);
});
cp.on('message', (message) => {
if (message.c === 'r') {
cp.send({ c: 'e' });
if (message.s) {
resolve(message.r);
}
else {
reject(new Error(`Failed to resolve module: ${moduleName}`));
}
}
});
const message = {
c: 'rs',
a: moduleName
};
cp.send(message);
}
catch (error) {
reject(error);
}
});
}
/**
* Resolve the global npm package path.
* @deprecated Since this depends on the used package manager and their version the best is that servers
* implement this themselves since they know best what kind of package managers to support.
* @param tracer the tracer to use
*/
function resolveGlobalNodePath(tracer) {
let npmCommand = 'npm';
const env = Object.create(null);
Object.keys(process.env).forEach(key => env[key] = process.env[key]);
env['NO_UPDATE_NOTIFIER'] = 'true';
const options = {
encoding: 'utf8',
env
};
if (isWindows()) {
npmCommand = 'npm.cmd';
options.shell = true;
}
const handler = () => { };
try {
process.on('SIGPIPE', handler);
const stdout = (0, child_process_1.spawnSync)(npmCommand, ['config', 'get', 'prefix'], options).stdout;
if (!stdout) {
if (tracer) {
tracer(`'npm config get prefix' didn't return a value.`);
}
return undefined;
}
const prefix = stdout.trim();
if (tracer) {
tracer(`'npm config get prefix' value is: ${prefix}`);
}
if (prefix.length > 0) {
if (isWindows()) {
return path.join(prefix, 'node_modules');
}
else {
return path.join(prefix, 'lib', 'node_modules');
}
}
return undefined;
}
catch (err) {
return undefined;
}
finally {
process.removeListener('SIGPIPE', handler);
}
}
/*
* Resolve the global yarn pakage path.
* @deprecated Since this depends on the used package manager and their version the best is that servers
* implement this themselves since they know best what kind of package managers to support.
* @param tracer the tracer to use
*/
function resolveGlobalYarnPath(tracer) {
let yarnCommand = 'yarn';
const options = {
encoding: 'utf8'
};
if (isWindows()) {
yarnCommand = 'yarn.cmd';
options.shell = true;
}
const handler = () => { };
try {
process.on('SIGPIPE', handler);
const results = (0, child_process_1.spawnSync)(yarnCommand, ['global', 'dir', '--json'], options);
const stdout = results.stdout;
if (!stdout) {
if (tracer) {
tracer(`'yarn global dir' didn't return a value.`);
if (results.stderr) {
tracer(results.stderr);
}
}
return undefined;
}
const lines = stdout.trim().split(/\r?\n/);
for (const line of lines) {
try {
const yarn = JSON.parse(line);
if (yarn.type === 'log') {
return path.join(yarn.data, 'node_modules');
}
}
catch (e) {
// Do nothing. Ignore the line
}
}
return undefined;
}
catch (err) {
return undefined;
}
finally {
process.removeListener('SIGPIPE', handler);
}
}
var FileSystem;
(function (FileSystem) {
let _isCaseSensitive = undefined;
function isCaseSensitive() {
if (_isCaseSensitive !== void 0) {
return _isCaseSensitive;
}
if (process.platform === 'win32') {
_isCaseSensitive = false;
}
else {
// convert current file name to upper case / lower case and check if file exists
// (guards against cases when name is already all uppercase or lowercase)
_isCaseSensitive = !fs.existsSync(__filename.toUpperCase()) || !fs.existsSync(__filename.toLowerCase());
}
return _isCaseSensitive;
}
FileSystem.isCaseSensitive = isCaseSensitive;
function isParent(parent, child) {
if (isCaseSensitive()) {
return path.normalize(child).indexOf(path.normalize(parent)) === 0;
}
else {
return path.normalize(child).toLowerCase().indexOf(path.normalize(parent).toLowerCase()) === 0;
}
}
FileSystem.isParent = isParent;
})(FileSystem || (exports.FileSystem = FileSystem = {}));
function resolveModulePath(workspaceRoot, moduleName, nodePath, tracer) {
if (nodePath) {
if (!path.isAbsolute(nodePath)) {
nodePath = path.join(workspaceRoot, nodePath);
}
return resolve(moduleName, nodePath, nodePath, tracer).then((value) => {
if (FileSystem.isParent(nodePath, value)) {
return value;
}
else {
return Promise.reject(new Error(`Failed to load ${moduleName} from node path location.`));
}
}).then(undefined, (_error) => {
return resolve(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
});
}
else {
return resolve(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
}
}