vscode-extension-samples/tree-view-sample/src/nodeDependencies.ts at main · microsoft/vscode-extension-samples · GitHub

Name: vscode-extension-samples/tree-view-sample/src/nodeDependencies.ts at main · microsoft/vscode-extension-samples · GitHub
Rating: 4.8 (123 reviews)
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
import*asvscodefrom'vscode';
import*asfsfrom'fs';
import*aspathfrom'path';

exportclassDepNodeProviderimplementsvscode.TreeDataProvider<Dependency>{

private_onDidChangeTreeData: vscode.EventEmitter<Dependency|undefined|void>=newvscode.EventEmitter<Dependency|undefined|void>();
readonlyonDidChangeTreeData: vscode.Event<Dependency|undefined|void>=this._onDidChangeTreeData.event;

constructor(privateworkspaceRoot: string|undefined){
}

refresh(): void{
this._onDidChangeTreeData.fire();
}

getTreeItem(element: Dependency): vscode.TreeItem{
returnelement;
}

getChildren(element?: Dependency): Thenable<Dependency[]>{
if(!this.workspaceRoot){
vscode.window.showInformationMessage('No dependency in empty workspace');
returnPromise.resolve([]);
}

if(element){
returnPromise.resolve(this.getDepsInPackageJson(path.join(this.workspaceRoot,'node_modules',element.label,'package.json')));
}else{
constpackageJsonPath=path.join(this.workspaceRoot,'package.json');
if(this.pathExists(packageJsonPath)){
returnPromise.resolve(this.getDepsInPackageJson(packageJsonPath));
}else{
vscode.window.showInformationMessage('Workspace has no package.json');
returnPromise.resolve([]);
}
}

}

/**
 * Given the path to package.json, read all its dependencies and devDependencies.
 */
privategetDepsInPackageJson(packageJsonPath: string): Dependency[]{
constworkspaceRoot=this.workspaceRoot;
if(this.pathExists(packageJsonPath)&&workspaceRoot){
constpackageJson=JSON.parse(fs.readFileSync(packageJsonPath,'utf-8'));

consttoDep=(moduleName: string,version: string): Dependency=>{
if(this.pathExists(path.join(workspaceRoot,'node_modules',moduleName))){
returnnewDependency(moduleName,version,vscode.TreeItemCollapsibleState.Collapsed);
}else{
returnnewDependency(moduleName,version,vscode.TreeItemCollapsibleState.None,{
command: 'extension.openPackageOnNpm',
title: '',
arguments: [moduleName]
});
}
};

constdeps=packageJson.dependencies
 ? Object.keys(packageJson.dependencies).map(dep=>toDep(dep,packageJson.dependencies[dep]))
 : [];
constdevDeps=packageJson.devDependencies
 ? Object.keys(packageJson.devDependencies).map(dep=>toDep(dep,packageJson.devDependencies[dep]))
 : [];
returndeps.concat(devDeps);
}else{
return[];
}
}

privatepathExists(p: string): boolean{
try{
fs.accessSync(p);
}catch{
returnfalse;
}

returntrue;
}
}

exportclassDependencyextendsvscode.TreeItem{

constructor(
publicreadonlylabel: string,
privatereadonlyversion: string,
publicreadonlycollapsibleState: vscode.TreeItemCollapsibleState,
publicreadonlycommand?: vscode.Command
){
super(label,collapsibleState);

this.tooltip=`${this.label}-${this.version}`;
this.description=this.version;
}

iconPath={
light: path.join(__filename,'..','..','resources','light','dependency.svg'),
dark: path.join(__filename,'..','..','resources','dark','dependency.svg')
};

contextValue='dependency';
}