coc-sonarlint 0.0.1 → 0.0.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +1 -1
- package/README.md +1 -1
- package/lib/index.js +339 -313
- package/package.json +2 -2
package/lib/index.js
CHANGED
|
@@ -1,4 +1,3 @@
|
|
|
1
|
-
"use strict";
|
|
2
1
|
var __create = Object.create;
|
|
3
2
|
var __defProp = Object.defineProperty;
|
|
4
3
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
@@ -50,10 +49,10 @@ var require_which = __commonJS({
|
|
|
50
49
|
module2.exports = which;
|
|
51
50
|
which.sync = whichSync;
|
|
52
51
|
var path3 = require("path");
|
|
53
|
-
var
|
|
52
|
+
var fs4;
|
|
54
53
|
var COLON = process.platform === "win32" ? ";" : ":";
|
|
55
54
|
var isExe;
|
|
56
|
-
var
|
|
55
|
+
var fs4 = require("fs");
|
|
57
56
|
if (process.platform == "win32") {
|
|
58
57
|
isExe = function isExe2() {
|
|
59
58
|
return true;
|
|
@@ -83,7 +82,7 @@ var require_which = __commonJS({
|
|
|
83
82
|
if (ii === ll)
|
|
84
83
|
return F(i + 1, l);
|
|
85
84
|
var ext = pathExt[ii];
|
|
86
|
-
|
|
85
|
+
fs4.stat(p + ext, function(er, stat) {
|
|
87
86
|
if (!er && stat && stat.isFile() && isExe(stat.mode, stat.uid, stat.gid)) {
|
|
88
87
|
return cb(null, p + ext);
|
|
89
88
|
}
|
|
@@ -108,7 +107,7 @@ var require_which = __commonJS({
|
|
|
108
107
|
var cur = p + pathExt[j];
|
|
109
108
|
var stat;
|
|
110
109
|
try {
|
|
111
|
-
stat =
|
|
110
|
+
stat = fs4.statSync(cur);
|
|
112
111
|
} catch (ex) {
|
|
113
112
|
}
|
|
114
113
|
if (stat && stat.isFile() && isExe(stat.mode, stat.uid, stat.gid))
|
|
@@ -762,7 +761,7 @@ var require_dist = __commonJS({
|
|
|
762
761
|
var __importDefault = exports && exports.__importDefault || function(mod) {
|
|
763
762
|
return mod && mod.__esModule ? mod : { "default": mod };
|
|
764
763
|
};
|
|
765
|
-
var
|
|
764
|
+
var fs4 = __importStar(require("fs"));
|
|
766
765
|
var path3 = __importStar(require("path"));
|
|
767
766
|
var cp2 = __importStar(require("child_process"));
|
|
768
767
|
var child_process_1 = require("child_process");
|
|
@@ -853,10 +852,10 @@ var require_dist = __commonJS({
|
|
|
853
852
|
console.error(ex);
|
|
854
853
|
}
|
|
855
854
|
}
|
|
856
|
-
proposed =
|
|
855
|
+
proposed = fs4.realpathSync(proposed);
|
|
857
856
|
proposed = path3.dirname(proposed);
|
|
858
857
|
var macUtility = path3.resolve(proposed, "java_home");
|
|
859
|
-
if (
|
|
858
|
+
if (fs4.existsSync(macUtility)) {
|
|
860
859
|
var buffer = void 0;
|
|
861
860
|
try {
|
|
862
861
|
buffer = cp2.execSync(macUtility, { cwd: proposed });
|
|
@@ -945,7 +944,7 @@ var require_dist = __commonJS({
|
|
|
945
944
|
});
|
|
946
945
|
}
|
|
947
946
|
function dirIsJavaHome(dir, javaFilename) {
|
|
948
|
-
return
|
|
947
|
+
return fs4.existsSync("" + dir) && fs4.statSync(dir).isDirectory() && fs4.existsSync(path3.resolve(dir, "bin", javaFilename));
|
|
949
948
|
}
|
|
950
949
|
module2.exports = findJavaHome2;
|
|
951
950
|
}
|
|
@@ -1011,56 +1010,56 @@ var require_polyfills = __commonJS({
|
|
|
1011
1010
|
}
|
|
1012
1011
|
var chdir;
|
|
1013
1012
|
module2.exports = patch;
|
|
1014
|
-
function patch(
|
|
1013
|
+
function patch(fs4) {
|
|
1015
1014
|
if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
|
|
1016
|
-
patchLchmod(
|
|
1017
|
-
}
|
|
1018
|
-
if (!
|
|
1019
|
-
patchLutimes(
|
|
1020
|
-
}
|
|
1021
|
-
|
|
1022
|
-
|
|
1023
|
-
|
|
1024
|
-
|
|
1025
|
-
|
|
1026
|
-
|
|
1027
|
-
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
|
|
1032
|
-
|
|
1033
|
-
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
1039
|
-
if (
|
|
1040
|
-
|
|
1015
|
+
patchLchmod(fs4);
|
|
1016
|
+
}
|
|
1017
|
+
if (!fs4.lutimes) {
|
|
1018
|
+
patchLutimes(fs4);
|
|
1019
|
+
}
|
|
1020
|
+
fs4.chown = chownFix(fs4.chown);
|
|
1021
|
+
fs4.fchown = chownFix(fs4.fchown);
|
|
1022
|
+
fs4.lchown = chownFix(fs4.lchown);
|
|
1023
|
+
fs4.chmod = chmodFix(fs4.chmod);
|
|
1024
|
+
fs4.fchmod = chmodFix(fs4.fchmod);
|
|
1025
|
+
fs4.lchmod = chmodFix(fs4.lchmod);
|
|
1026
|
+
fs4.chownSync = chownFixSync(fs4.chownSync);
|
|
1027
|
+
fs4.fchownSync = chownFixSync(fs4.fchownSync);
|
|
1028
|
+
fs4.lchownSync = chownFixSync(fs4.lchownSync);
|
|
1029
|
+
fs4.chmodSync = chmodFixSync(fs4.chmodSync);
|
|
1030
|
+
fs4.fchmodSync = chmodFixSync(fs4.fchmodSync);
|
|
1031
|
+
fs4.lchmodSync = chmodFixSync(fs4.lchmodSync);
|
|
1032
|
+
fs4.stat = statFix(fs4.stat);
|
|
1033
|
+
fs4.fstat = statFix(fs4.fstat);
|
|
1034
|
+
fs4.lstat = statFix(fs4.lstat);
|
|
1035
|
+
fs4.statSync = statFixSync(fs4.statSync);
|
|
1036
|
+
fs4.fstatSync = statFixSync(fs4.fstatSync);
|
|
1037
|
+
fs4.lstatSync = statFixSync(fs4.lstatSync);
|
|
1038
|
+
if (fs4.chmod && !fs4.lchmod) {
|
|
1039
|
+
fs4.lchmod = function(path3, mode, cb) {
|
|
1041
1040
|
if (cb)
|
|
1042
1041
|
process.nextTick(cb);
|
|
1043
1042
|
};
|
|
1044
|
-
|
|
1043
|
+
fs4.lchmodSync = function() {
|
|
1045
1044
|
};
|
|
1046
1045
|
}
|
|
1047
|
-
if (
|
|
1048
|
-
|
|
1046
|
+
if (fs4.chown && !fs4.lchown) {
|
|
1047
|
+
fs4.lchown = function(path3, uid, gid, cb) {
|
|
1049
1048
|
if (cb)
|
|
1050
1049
|
process.nextTick(cb);
|
|
1051
1050
|
};
|
|
1052
|
-
|
|
1051
|
+
fs4.lchownSync = function() {
|
|
1053
1052
|
};
|
|
1054
1053
|
}
|
|
1055
1054
|
if (platform === "win32") {
|
|
1056
|
-
|
|
1055
|
+
fs4.rename = typeof fs4.rename !== "function" ? fs4.rename : function(fs$rename) {
|
|
1057
1056
|
function rename(from, to, cb) {
|
|
1058
1057
|
var start = Date.now();
|
|
1059
1058
|
var backoff = 0;
|
|
1060
1059
|
fs$rename(from, to, function CB(er) {
|
|
1061
1060
|
if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
|
|
1062
1061
|
setTimeout(function() {
|
|
1063
|
-
|
|
1062
|
+
fs4.stat(to, function(stater, st) {
|
|
1064
1063
|
if (stater && stater.code === "ENOENT")
|
|
1065
1064
|
fs$rename(from, to, CB);
|
|
1066
1065
|
else
|
|
@@ -1078,9 +1077,9 @@ var require_polyfills = __commonJS({
|
|
|
1078
1077
|
if (Object.setPrototypeOf)
|
|
1079
1078
|
Object.setPrototypeOf(rename, fs$rename);
|
|
1080
1079
|
return rename;
|
|
1081
|
-
}(
|
|
1080
|
+
}(fs4.rename);
|
|
1082
1081
|
}
|
|
1083
|
-
|
|
1082
|
+
fs4.read = typeof fs4.read !== "function" ? fs4.read : function(fs$read) {
|
|
1084
1083
|
function read(fd, buffer, offset, length, position, callback_) {
|
|
1085
1084
|
var callback;
|
|
1086
1085
|
if (callback_ && typeof callback_ === "function") {
|
|
@@ -1088,23 +1087,23 @@ var require_polyfills = __commonJS({
|
|
|
1088
1087
|
callback = function(er, _, __) {
|
|
1089
1088
|
if (er && er.code === "EAGAIN" && eagCounter < 10) {
|
|
1090
1089
|
eagCounter++;
|
|
1091
|
-
return fs$read.call(
|
|
1090
|
+
return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
|
|
1092
1091
|
}
|
|
1093
1092
|
callback_.apply(this, arguments);
|
|
1094
1093
|
};
|
|
1095
1094
|
}
|
|
1096
|
-
return fs$read.call(
|
|
1095
|
+
return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
|
|
1097
1096
|
}
|
|
1098
1097
|
if (Object.setPrototypeOf)
|
|
1099
1098
|
Object.setPrototypeOf(read, fs$read);
|
|
1100
1099
|
return read;
|
|
1101
|
-
}(
|
|
1102
|
-
|
|
1100
|
+
}(fs4.read);
|
|
1101
|
+
fs4.readSync = typeof fs4.readSync !== "function" ? fs4.readSync : function(fs$readSync) {
|
|
1103
1102
|
return function(fd, buffer, offset, length, position) {
|
|
1104
1103
|
var eagCounter = 0;
|
|
1105
1104
|
while (true) {
|
|
1106
1105
|
try {
|
|
1107
|
-
return fs$readSync.call(
|
|
1106
|
+
return fs$readSync.call(fs4, fd, buffer, offset, length, position);
|
|
1108
1107
|
} catch (er) {
|
|
1109
1108
|
if (er.code === "EAGAIN" && eagCounter < 10) {
|
|
1110
1109
|
eagCounter++;
|
|
@@ -1114,10 +1113,10 @@ var require_polyfills = __commonJS({
|
|
|
1114
1113
|
}
|
|
1115
1114
|
}
|
|
1116
1115
|
};
|
|
1117
|
-
}(
|
|
1118
|
-
function patchLchmod(
|
|
1119
|
-
|
|
1120
|
-
|
|
1116
|
+
}(fs4.readSync);
|
|
1117
|
+
function patchLchmod(fs5) {
|
|
1118
|
+
fs5.lchmod = function(path3, mode, callback) {
|
|
1119
|
+
fs5.open(
|
|
1121
1120
|
path3,
|
|
1122
1121
|
constants.O_WRONLY | constants.O_SYMLINK,
|
|
1123
1122
|
mode,
|
|
@@ -1127,8 +1126,8 @@ var require_polyfills = __commonJS({
|
|
|
1127
1126
|
callback(err);
|
|
1128
1127
|
return;
|
|
1129
1128
|
}
|
|
1130
|
-
|
|
1131
|
-
|
|
1129
|
+
fs5.fchmod(fd, mode, function(err2) {
|
|
1130
|
+
fs5.close(fd, function(err22) {
|
|
1132
1131
|
if (callback)
|
|
1133
1132
|
callback(err2 || err22);
|
|
1134
1133
|
});
|
|
@@ -1136,68 +1135,68 @@ var require_polyfills = __commonJS({
|
|
|
1136
1135
|
}
|
|
1137
1136
|
);
|
|
1138
1137
|
};
|
|
1139
|
-
|
|
1140
|
-
var fd =
|
|
1138
|
+
fs5.lchmodSync = function(path3, mode) {
|
|
1139
|
+
var fd = fs5.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
|
|
1141
1140
|
var threw = true;
|
|
1142
1141
|
var ret;
|
|
1143
1142
|
try {
|
|
1144
|
-
ret =
|
|
1143
|
+
ret = fs5.fchmodSync(fd, mode);
|
|
1145
1144
|
threw = false;
|
|
1146
1145
|
} finally {
|
|
1147
1146
|
if (threw) {
|
|
1148
1147
|
try {
|
|
1149
|
-
|
|
1148
|
+
fs5.closeSync(fd);
|
|
1150
1149
|
} catch (er) {
|
|
1151
1150
|
}
|
|
1152
1151
|
} else {
|
|
1153
|
-
|
|
1152
|
+
fs5.closeSync(fd);
|
|
1154
1153
|
}
|
|
1155
1154
|
}
|
|
1156
1155
|
return ret;
|
|
1157
1156
|
};
|
|
1158
1157
|
}
|
|
1159
|
-
function patchLutimes(
|
|
1160
|
-
if (constants.hasOwnProperty("O_SYMLINK") &&
|
|
1161
|
-
|
|
1162
|
-
|
|
1158
|
+
function patchLutimes(fs5) {
|
|
1159
|
+
if (constants.hasOwnProperty("O_SYMLINK") && fs5.futimes) {
|
|
1160
|
+
fs5.lutimes = function(path3, at, mt, cb) {
|
|
1161
|
+
fs5.open(path3, constants.O_SYMLINK, function(er, fd) {
|
|
1163
1162
|
if (er) {
|
|
1164
1163
|
if (cb)
|
|
1165
1164
|
cb(er);
|
|
1166
1165
|
return;
|
|
1167
1166
|
}
|
|
1168
|
-
|
|
1169
|
-
|
|
1167
|
+
fs5.futimes(fd, at, mt, function(er2) {
|
|
1168
|
+
fs5.close(fd, function(er22) {
|
|
1170
1169
|
if (cb)
|
|
1171
1170
|
cb(er2 || er22);
|
|
1172
1171
|
});
|
|
1173
1172
|
});
|
|
1174
1173
|
});
|
|
1175
1174
|
};
|
|
1176
|
-
|
|
1177
|
-
var fd =
|
|
1175
|
+
fs5.lutimesSync = function(path3, at, mt) {
|
|
1176
|
+
var fd = fs5.openSync(path3, constants.O_SYMLINK);
|
|
1178
1177
|
var ret;
|
|
1179
1178
|
var threw = true;
|
|
1180
1179
|
try {
|
|
1181
|
-
ret =
|
|
1180
|
+
ret = fs5.futimesSync(fd, at, mt);
|
|
1182
1181
|
threw = false;
|
|
1183
1182
|
} finally {
|
|
1184
1183
|
if (threw) {
|
|
1185
1184
|
try {
|
|
1186
|
-
|
|
1185
|
+
fs5.closeSync(fd);
|
|
1187
1186
|
} catch (er) {
|
|
1188
1187
|
}
|
|
1189
1188
|
} else {
|
|
1190
|
-
|
|
1189
|
+
fs5.closeSync(fd);
|
|
1191
1190
|
}
|
|
1192
1191
|
}
|
|
1193
1192
|
return ret;
|
|
1194
1193
|
};
|
|
1195
|
-
} else if (
|
|
1196
|
-
|
|
1194
|
+
} else if (fs5.futimes) {
|
|
1195
|
+
fs5.lutimes = function(_a, _b, _c, cb) {
|
|
1197
1196
|
if (cb)
|
|
1198
1197
|
process.nextTick(cb);
|
|
1199
1198
|
};
|
|
1200
|
-
|
|
1199
|
+
fs5.lutimesSync = function() {
|
|
1201
1200
|
};
|
|
1202
1201
|
}
|
|
1203
1202
|
}
|
|
@@ -1205,7 +1204,7 @@ var require_polyfills = __commonJS({
|
|
|
1205
1204
|
if (!orig)
|
|
1206
1205
|
return orig;
|
|
1207
1206
|
return function(target, mode, cb) {
|
|
1208
|
-
return orig.call(
|
|
1207
|
+
return orig.call(fs4, target, mode, function(er) {
|
|
1209
1208
|
if (chownErOk(er))
|
|
1210
1209
|
er = null;
|
|
1211
1210
|
if (cb)
|
|
@@ -1218,7 +1217,7 @@ var require_polyfills = __commonJS({
|
|
|
1218
1217
|
return orig;
|
|
1219
1218
|
return function(target, mode) {
|
|
1220
1219
|
try {
|
|
1221
|
-
return orig.call(
|
|
1220
|
+
return orig.call(fs4, target, mode);
|
|
1222
1221
|
} catch (er) {
|
|
1223
1222
|
if (!chownErOk(er))
|
|
1224
1223
|
throw er;
|
|
@@ -1229,7 +1228,7 @@ var require_polyfills = __commonJS({
|
|
|
1229
1228
|
if (!orig)
|
|
1230
1229
|
return orig;
|
|
1231
1230
|
return function(target, uid, gid, cb) {
|
|
1232
|
-
return orig.call(
|
|
1231
|
+
return orig.call(fs4, target, uid, gid, function(er) {
|
|
1233
1232
|
if (chownErOk(er))
|
|
1234
1233
|
er = null;
|
|
1235
1234
|
if (cb)
|
|
@@ -1242,7 +1241,7 @@ var require_polyfills = __commonJS({
|
|
|
1242
1241
|
return orig;
|
|
1243
1242
|
return function(target, uid, gid) {
|
|
1244
1243
|
try {
|
|
1245
|
-
return orig.call(
|
|
1244
|
+
return orig.call(fs4, target, uid, gid);
|
|
1246
1245
|
} catch (er) {
|
|
1247
1246
|
if (!chownErOk(er))
|
|
1248
1247
|
throw er;
|
|
@@ -1267,14 +1266,14 @@ var require_polyfills = __commonJS({
|
|
|
1267
1266
|
if (cb)
|
|
1268
1267
|
cb.apply(this, arguments);
|
|
1269
1268
|
}
|
|
1270
|
-
return options ? orig.call(
|
|
1269
|
+
return options ? orig.call(fs4, target, options, callback) : orig.call(fs4, target, callback);
|
|
1271
1270
|
};
|
|
1272
1271
|
}
|
|
1273
1272
|
function statFixSync(orig) {
|
|
1274
1273
|
if (!orig)
|
|
1275
1274
|
return orig;
|
|
1276
1275
|
return function(target, options) {
|
|
1277
|
-
var stats = options ? orig.call(
|
|
1276
|
+
var stats = options ? orig.call(fs4, target, options) : orig.call(fs4, target);
|
|
1278
1277
|
if (stats) {
|
|
1279
1278
|
if (stats.uid < 0)
|
|
1280
1279
|
stats.uid += 4294967296;
|
|
@@ -1305,7 +1304,7 @@ var require_legacy_streams = __commonJS({
|
|
|
1305
1304
|
"node_modules/graceful-fs/legacy-streams.js"(exports, module2) {
|
|
1306
1305
|
var Stream = require("stream").Stream;
|
|
1307
1306
|
module2.exports = legacy;
|
|
1308
|
-
function legacy(
|
|
1307
|
+
function legacy(fs4) {
|
|
1309
1308
|
return {
|
|
1310
1309
|
ReadStream,
|
|
1311
1310
|
WriteStream
|
|
@@ -1350,7 +1349,7 @@ var require_legacy_streams = __commonJS({
|
|
|
1350
1349
|
});
|
|
1351
1350
|
return;
|
|
1352
1351
|
}
|
|
1353
|
-
|
|
1352
|
+
fs4.open(this.path, this.flags, this.mode, function(err, fd) {
|
|
1354
1353
|
if (err) {
|
|
1355
1354
|
self.emit("error", err);
|
|
1356
1355
|
self.readable = false;
|
|
@@ -1390,7 +1389,7 @@ var require_legacy_streams = __commonJS({
|
|
|
1390
1389
|
this.busy = false;
|
|
1391
1390
|
this._queue = [];
|
|
1392
1391
|
if (this.fd === null) {
|
|
1393
|
-
this._open =
|
|
1392
|
+
this._open = fs4.open;
|
|
1394
1393
|
this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
|
|
1395
1394
|
this.flush();
|
|
1396
1395
|
}
|
|
@@ -1425,7 +1424,7 @@ var require_clone = __commonJS({
|
|
|
1425
1424
|
// node_modules/graceful-fs/graceful-fs.js
|
|
1426
1425
|
var require_graceful_fs = __commonJS({
|
|
1427
1426
|
"node_modules/graceful-fs/graceful-fs.js"(exports, module2) {
|
|
1428
|
-
var
|
|
1427
|
+
var fs4 = require("fs");
|
|
1429
1428
|
var polyfills = require_polyfills();
|
|
1430
1429
|
var legacy = require_legacy_streams();
|
|
1431
1430
|
var clone = require_clone();
|
|
@@ -1457,12 +1456,12 @@ var require_graceful_fs = __commonJS({
|
|
|
1457
1456
|
m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
|
|
1458
1457
|
console.error(m);
|
|
1459
1458
|
};
|
|
1460
|
-
if (!
|
|
1459
|
+
if (!fs4[gracefulQueue]) {
|
|
1461
1460
|
queue = global[gracefulQueue] || [];
|
|
1462
|
-
publishQueue(
|
|
1463
|
-
|
|
1461
|
+
publishQueue(fs4, queue);
|
|
1462
|
+
fs4.close = function(fs$close) {
|
|
1464
1463
|
function close(fd, cb) {
|
|
1465
|
-
return fs$close.call(
|
|
1464
|
+
return fs$close.call(fs4, fd, function(err) {
|
|
1466
1465
|
if (!err) {
|
|
1467
1466
|
resetQueue();
|
|
1468
1467
|
}
|
|
@@ -1474,40 +1473,40 @@ var require_graceful_fs = __commonJS({
|
|
|
1474
1473
|
value: fs$close
|
|
1475
1474
|
});
|
|
1476
1475
|
return close;
|
|
1477
|
-
}(
|
|
1478
|
-
|
|
1476
|
+
}(fs4.close);
|
|
1477
|
+
fs4.closeSync = function(fs$closeSync) {
|
|
1479
1478
|
function closeSync(fd) {
|
|
1480
|
-
fs$closeSync.apply(
|
|
1479
|
+
fs$closeSync.apply(fs4, arguments);
|
|
1481
1480
|
resetQueue();
|
|
1482
1481
|
}
|
|
1483
1482
|
Object.defineProperty(closeSync, previousSymbol, {
|
|
1484
1483
|
value: fs$closeSync
|
|
1485
1484
|
});
|
|
1486
1485
|
return closeSync;
|
|
1487
|
-
}(
|
|
1486
|
+
}(fs4.closeSync);
|
|
1488
1487
|
if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
|
|
1489
1488
|
process.on("exit", function() {
|
|
1490
|
-
debug(
|
|
1491
|
-
require("assert").equal(
|
|
1489
|
+
debug(fs4[gracefulQueue]);
|
|
1490
|
+
require("assert").equal(fs4[gracefulQueue].length, 0);
|
|
1492
1491
|
});
|
|
1493
1492
|
}
|
|
1494
1493
|
}
|
|
1495
1494
|
var queue;
|
|
1496
1495
|
if (!global[gracefulQueue]) {
|
|
1497
|
-
publishQueue(global,
|
|
1498
|
-
}
|
|
1499
|
-
module2.exports = patch(clone(
|
|
1500
|
-
if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !
|
|
1501
|
-
module2.exports = patch(
|
|
1502
|
-
|
|
1503
|
-
}
|
|
1504
|
-
function patch(
|
|
1505
|
-
polyfills(
|
|
1506
|
-
|
|
1507
|
-
|
|
1508
|
-
|
|
1509
|
-
var fs$readFile =
|
|
1510
|
-
|
|
1496
|
+
publishQueue(global, fs4[gracefulQueue]);
|
|
1497
|
+
}
|
|
1498
|
+
module2.exports = patch(clone(fs4));
|
|
1499
|
+
if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs4.__patched) {
|
|
1500
|
+
module2.exports = patch(fs4);
|
|
1501
|
+
fs4.__patched = true;
|
|
1502
|
+
}
|
|
1503
|
+
function patch(fs5) {
|
|
1504
|
+
polyfills(fs5);
|
|
1505
|
+
fs5.gracefulify = patch;
|
|
1506
|
+
fs5.createReadStream = createReadStream;
|
|
1507
|
+
fs5.createWriteStream = createWriteStream;
|
|
1508
|
+
var fs$readFile = fs5.readFile;
|
|
1509
|
+
fs5.readFile = readFile;
|
|
1511
1510
|
function readFile(path3, options, cb) {
|
|
1512
1511
|
if (typeof options === "function")
|
|
1513
1512
|
cb = options, options = null;
|
|
@@ -1523,8 +1522,8 @@ var require_graceful_fs = __commonJS({
|
|
|
1523
1522
|
});
|
|
1524
1523
|
}
|
|
1525
1524
|
}
|
|
1526
|
-
var fs$writeFile =
|
|
1527
|
-
|
|
1525
|
+
var fs$writeFile = fs5.writeFile;
|
|
1526
|
+
fs5.writeFile = writeFile;
|
|
1528
1527
|
function writeFile(path3, data, options, cb) {
|
|
1529
1528
|
if (typeof options === "function")
|
|
1530
1529
|
cb = options, options = null;
|
|
@@ -1540,9 +1539,9 @@ var require_graceful_fs = __commonJS({
|
|
|
1540
1539
|
});
|
|
1541
1540
|
}
|
|
1542
1541
|
}
|
|
1543
|
-
var fs$appendFile =
|
|
1542
|
+
var fs$appendFile = fs5.appendFile;
|
|
1544
1543
|
if (fs$appendFile)
|
|
1545
|
-
|
|
1544
|
+
fs5.appendFile = appendFile;
|
|
1546
1545
|
function appendFile(path3, data, options, cb) {
|
|
1547
1546
|
if (typeof options === "function")
|
|
1548
1547
|
cb = options, options = null;
|
|
@@ -1558,9 +1557,9 @@ var require_graceful_fs = __commonJS({
|
|
|
1558
1557
|
});
|
|
1559
1558
|
}
|
|
1560
1559
|
}
|
|
1561
|
-
var fs$copyFile =
|
|
1560
|
+
var fs$copyFile = fs5.copyFile;
|
|
1562
1561
|
if (fs$copyFile)
|
|
1563
|
-
|
|
1562
|
+
fs5.copyFile = copyFile;
|
|
1564
1563
|
function copyFile(src, dest, flags, cb) {
|
|
1565
1564
|
if (typeof flags === "function") {
|
|
1566
1565
|
cb = flags;
|
|
@@ -1578,8 +1577,8 @@ var require_graceful_fs = __commonJS({
|
|
|
1578
1577
|
});
|
|
1579
1578
|
}
|
|
1580
1579
|
}
|
|
1581
|
-
var fs$readdir =
|
|
1582
|
-
|
|
1580
|
+
var fs$readdir = fs5.readdir;
|
|
1581
|
+
fs5.readdir = readdir;
|
|
1583
1582
|
var noReaddirOptionVersions = /^v[0-5]\./;
|
|
1584
1583
|
function readdir(path3, options, cb) {
|
|
1585
1584
|
if (typeof options === "function")
|
|
@@ -1620,21 +1619,21 @@ var require_graceful_fs = __commonJS({
|
|
|
1620
1619
|
}
|
|
1621
1620
|
}
|
|
1622
1621
|
if (process.version.substr(0, 4) === "v0.8") {
|
|
1623
|
-
var legStreams = legacy(
|
|
1622
|
+
var legStreams = legacy(fs5);
|
|
1624
1623
|
ReadStream = legStreams.ReadStream;
|
|
1625
1624
|
WriteStream = legStreams.WriteStream;
|
|
1626
1625
|
}
|
|
1627
|
-
var fs$ReadStream =
|
|
1626
|
+
var fs$ReadStream = fs5.ReadStream;
|
|
1628
1627
|
if (fs$ReadStream) {
|
|
1629
1628
|
ReadStream.prototype = Object.create(fs$ReadStream.prototype);
|
|
1630
1629
|
ReadStream.prototype.open = ReadStream$open;
|
|
1631
1630
|
}
|
|
1632
|
-
var fs$WriteStream =
|
|
1631
|
+
var fs$WriteStream = fs5.WriteStream;
|
|
1633
1632
|
if (fs$WriteStream) {
|
|
1634
1633
|
WriteStream.prototype = Object.create(fs$WriteStream.prototype);
|
|
1635
1634
|
WriteStream.prototype.open = WriteStream$open;
|
|
1636
1635
|
}
|
|
1637
|
-
Object.defineProperty(
|
|
1636
|
+
Object.defineProperty(fs5, "ReadStream", {
|
|
1638
1637
|
get: function() {
|
|
1639
1638
|
return ReadStream;
|
|
1640
1639
|
},
|
|
@@ -1644,7 +1643,7 @@ var require_graceful_fs = __commonJS({
|
|
|
1644
1643
|
enumerable: true,
|
|
1645
1644
|
configurable: true
|
|
1646
1645
|
});
|
|
1647
|
-
Object.defineProperty(
|
|
1646
|
+
Object.defineProperty(fs5, "WriteStream", {
|
|
1648
1647
|
get: function() {
|
|
1649
1648
|
return WriteStream;
|
|
1650
1649
|
},
|
|
@@ -1655,7 +1654,7 @@ var require_graceful_fs = __commonJS({
|
|
|
1655
1654
|
configurable: true
|
|
1656
1655
|
});
|
|
1657
1656
|
var FileReadStream = ReadStream;
|
|
1658
|
-
Object.defineProperty(
|
|
1657
|
+
Object.defineProperty(fs5, "FileReadStream", {
|
|
1659
1658
|
get: function() {
|
|
1660
1659
|
return FileReadStream;
|
|
1661
1660
|
},
|
|
@@ -1666,7 +1665,7 @@ var require_graceful_fs = __commonJS({
|
|
|
1666
1665
|
configurable: true
|
|
1667
1666
|
});
|
|
1668
1667
|
var FileWriteStream = WriteStream;
|
|
1669
|
-
Object.defineProperty(
|
|
1668
|
+
Object.defineProperty(fs5, "FileWriteStream", {
|
|
1670
1669
|
get: function() {
|
|
1671
1670
|
return FileWriteStream;
|
|
1672
1671
|
},
|
|
@@ -1715,13 +1714,13 @@ var require_graceful_fs = __commonJS({
|
|
|
1715
1714
|
});
|
|
1716
1715
|
}
|
|
1717
1716
|
function createReadStream(path3, options) {
|
|
1718
|
-
return new
|
|
1717
|
+
return new fs5.ReadStream(path3, options);
|
|
1719
1718
|
}
|
|
1720
1719
|
function createWriteStream(path3, options) {
|
|
1721
|
-
return new
|
|
1720
|
+
return new fs5.WriteStream(path3, options);
|
|
1722
1721
|
}
|
|
1723
|
-
var fs$open =
|
|
1724
|
-
|
|
1722
|
+
var fs$open = fs5.open;
|
|
1723
|
+
fs5.open = open;
|
|
1725
1724
|
function open(path3, flags, mode, cb) {
|
|
1726
1725
|
if (typeof mode === "function")
|
|
1727
1726
|
cb = mode, mode = null;
|
|
@@ -1737,20 +1736,20 @@ var require_graceful_fs = __commonJS({
|
|
|
1737
1736
|
});
|
|
1738
1737
|
}
|
|
1739
1738
|
}
|
|
1740
|
-
return
|
|
1739
|
+
return fs5;
|
|
1741
1740
|
}
|
|
1742
1741
|
function enqueue(elem) {
|
|
1743
1742
|
debug("ENQUEUE", elem[0].name, elem[1]);
|
|
1744
|
-
|
|
1743
|
+
fs4[gracefulQueue].push(elem);
|
|
1745
1744
|
retry();
|
|
1746
1745
|
}
|
|
1747
1746
|
var retryTimer;
|
|
1748
1747
|
function resetQueue() {
|
|
1749
1748
|
var now = Date.now();
|
|
1750
|
-
for (var i = 0; i <
|
|
1751
|
-
if (
|
|
1752
|
-
|
|
1753
|
-
|
|
1749
|
+
for (var i = 0; i < fs4[gracefulQueue].length; ++i) {
|
|
1750
|
+
if (fs4[gracefulQueue][i].length > 2) {
|
|
1751
|
+
fs4[gracefulQueue][i][3] = now;
|
|
1752
|
+
fs4[gracefulQueue][i][4] = now;
|
|
1754
1753
|
}
|
|
1755
1754
|
}
|
|
1756
1755
|
retry();
|
|
@@ -1758,9 +1757,9 @@ var require_graceful_fs = __commonJS({
|
|
|
1758
1757
|
function retry() {
|
|
1759
1758
|
clearTimeout(retryTimer);
|
|
1760
1759
|
retryTimer = void 0;
|
|
1761
|
-
if (
|
|
1760
|
+
if (fs4[gracefulQueue].length === 0)
|
|
1762
1761
|
return;
|
|
1763
|
-
var elem =
|
|
1762
|
+
var elem = fs4[gracefulQueue].shift();
|
|
1764
1763
|
var fn = elem[0];
|
|
1765
1764
|
var args = elem[1];
|
|
1766
1765
|
var err = elem[2];
|
|
@@ -1782,7 +1781,7 @@ var require_graceful_fs = __commonJS({
|
|
|
1782
1781
|
debug("RETRY", fn.name, args);
|
|
1783
1782
|
fn.apply(null, args.concat([startTime]));
|
|
1784
1783
|
} else {
|
|
1785
|
-
|
|
1784
|
+
fs4[gracefulQueue].push(elem);
|
|
1786
1785
|
}
|
|
1787
1786
|
}
|
|
1788
1787
|
if (retryTimer === void 0) {
|
|
@@ -1797,7 +1796,7 @@ var require_fs = __commonJS({
|
|
|
1797
1796
|
"node_modules/fs-extra/lib/fs/index.js"(exports) {
|
|
1798
1797
|
"use strict";
|
|
1799
1798
|
var u = require_universalify().fromCallback;
|
|
1800
|
-
var
|
|
1799
|
+
var fs4 = require_graceful_fs();
|
|
1801
1800
|
var api = [
|
|
1802
1801
|
"access",
|
|
1803
1802
|
"appendFile",
|
|
@@ -1832,31 +1831,31 @@ var require_fs = __commonJS({
|
|
|
1832
1831
|
"utimes",
|
|
1833
1832
|
"writeFile"
|
|
1834
1833
|
].filter((key) => {
|
|
1835
|
-
return typeof
|
|
1834
|
+
return typeof fs4[key] === "function";
|
|
1836
1835
|
});
|
|
1837
|
-
Object.keys(
|
|
1836
|
+
Object.keys(fs4).forEach((key) => {
|
|
1838
1837
|
if (key === "promises") {
|
|
1839
1838
|
return;
|
|
1840
1839
|
}
|
|
1841
|
-
exports[key] =
|
|
1840
|
+
exports[key] = fs4[key];
|
|
1842
1841
|
});
|
|
1843
1842
|
api.forEach((method) => {
|
|
1844
|
-
exports[method] = u(
|
|
1843
|
+
exports[method] = u(fs4[method]);
|
|
1845
1844
|
});
|
|
1846
1845
|
exports.exists = function(filename, callback) {
|
|
1847
1846
|
if (typeof callback === "function") {
|
|
1848
|
-
return
|
|
1847
|
+
return fs4.exists(filename, callback);
|
|
1849
1848
|
}
|
|
1850
1849
|
return new Promise((resolve3) => {
|
|
1851
|
-
return
|
|
1850
|
+
return fs4.exists(filename, resolve3);
|
|
1852
1851
|
});
|
|
1853
1852
|
};
|
|
1854
1853
|
exports.read = function(fd, buffer, offset, length, position, callback) {
|
|
1855
1854
|
if (typeof callback === "function") {
|
|
1856
|
-
return
|
|
1855
|
+
return fs4.read(fd, buffer, offset, length, position, callback);
|
|
1857
1856
|
}
|
|
1858
1857
|
return new Promise((resolve3, reject) => {
|
|
1859
|
-
|
|
1858
|
+
fs4.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
|
|
1860
1859
|
if (err)
|
|
1861
1860
|
return reject(err);
|
|
1862
1861
|
resolve3({ bytesRead, buffer: buffer2 });
|
|
@@ -1865,18 +1864,18 @@ var require_fs = __commonJS({
|
|
|
1865
1864
|
};
|
|
1866
1865
|
exports.write = function(fd, buffer, ...args) {
|
|
1867
1866
|
if (typeof args[args.length - 1] === "function") {
|
|
1868
|
-
return
|
|
1867
|
+
return fs4.write(fd, buffer, ...args);
|
|
1869
1868
|
}
|
|
1870
1869
|
return new Promise((resolve3, reject) => {
|
|
1871
|
-
|
|
1870
|
+
fs4.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
|
|
1872
1871
|
if (err)
|
|
1873
1872
|
return reject(err);
|
|
1874
1873
|
resolve3({ bytesWritten, buffer: buffer2 });
|
|
1875
1874
|
});
|
|
1876
1875
|
});
|
|
1877
1876
|
};
|
|
1878
|
-
if (typeof
|
|
1879
|
-
exports.realpath.native = u(
|
|
1877
|
+
if (typeof fs4.realpath.native === "function") {
|
|
1878
|
+
exports.realpath.native = u(fs4.realpath.native);
|
|
1880
1879
|
}
|
|
1881
1880
|
}
|
|
1882
1881
|
});
|
|
@@ -1909,7 +1908,7 @@ var require_win32 = __commonJS({
|
|
|
1909
1908
|
var require_mkdirs = __commonJS({
|
|
1910
1909
|
"node_modules/fs-extra/lib/mkdirs/mkdirs.js"(exports, module2) {
|
|
1911
1910
|
"use strict";
|
|
1912
|
-
var
|
|
1911
|
+
var fs4 = require_graceful_fs();
|
|
1913
1912
|
var path3 = require("path");
|
|
1914
1913
|
var invalidWin32Path = require_win32().invalidWin32Path;
|
|
1915
1914
|
var o777 = parseInt("0777", 8);
|
|
@@ -1926,7 +1925,7 @@ var require_mkdirs = __commonJS({
|
|
|
1926
1925
|
return callback(errInval);
|
|
1927
1926
|
}
|
|
1928
1927
|
let mode = opts.mode;
|
|
1929
|
-
const xfs = opts.fs ||
|
|
1928
|
+
const xfs = opts.fs || fs4;
|
|
1930
1929
|
if (mode === void 0) {
|
|
1931
1930
|
mode = o777 & ~process.umask();
|
|
1932
1931
|
}
|
|
@@ -1970,7 +1969,7 @@ var require_mkdirs = __commonJS({
|
|
|
1970
1969
|
var require_mkdirs_sync = __commonJS({
|
|
1971
1970
|
"node_modules/fs-extra/lib/mkdirs/mkdirs-sync.js"(exports, module2) {
|
|
1972
1971
|
"use strict";
|
|
1973
|
-
var
|
|
1972
|
+
var fs4 = require_graceful_fs();
|
|
1974
1973
|
var path3 = require("path");
|
|
1975
1974
|
var invalidWin32Path = require_win32().invalidWin32Path;
|
|
1976
1975
|
var o777 = parseInt("0777", 8);
|
|
@@ -1979,7 +1978,7 @@ var require_mkdirs_sync = __commonJS({
|
|
|
1979
1978
|
opts = { mode: opts };
|
|
1980
1979
|
}
|
|
1981
1980
|
let mode = opts.mode;
|
|
1982
|
-
const xfs = opts.fs ||
|
|
1981
|
+
const xfs = opts.fs || fs4;
|
|
1983
1982
|
if (process.platform === "win32" && invalidWin32Path(p)) {
|
|
1984
1983
|
const errInval = new Error(p + " contains invalid WIN32 path characters.");
|
|
1985
1984
|
errInval.code = "EINVAL";
|
|
@@ -2039,36 +2038,36 @@ var require_mkdirs2 = __commonJS({
|
|
|
2039
2038
|
var require_utimes = __commonJS({
|
|
2040
2039
|
"node_modules/fs-extra/lib/util/utimes.js"(exports, module2) {
|
|
2041
2040
|
"use strict";
|
|
2042
|
-
var
|
|
2041
|
+
var fs4 = require_graceful_fs();
|
|
2043
2042
|
var os = require("os");
|
|
2044
2043
|
var path3 = require("path");
|
|
2045
2044
|
function hasMillisResSync() {
|
|
2046
2045
|
let tmpfile = path3.join("millis-test-sync" + Date.now().toString() + Math.random().toString().slice(2));
|
|
2047
2046
|
tmpfile = path3.join(os.tmpdir(), tmpfile);
|
|
2048
2047
|
const d = new Date(1435410243862);
|
|
2049
|
-
|
|
2050
|
-
const fd =
|
|
2051
|
-
|
|
2052
|
-
|
|
2053
|
-
return
|
|
2048
|
+
fs4.writeFileSync(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141");
|
|
2049
|
+
const fd = fs4.openSync(tmpfile, "r+");
|
|
2050
|
+
fs4.futimesSync(fd, d, d);
|
|
2051
|
+
fs4.closeSync(fd);
|
|
2052
|
+
return fs4.statSync(tmpfile).mtime > 1435410243e3;
|
|
2054
2053
|
}
|
|
2055
2054
|
function hasMillisRes(callback) {
|
|
2056
2055
|
let tmpfile = path3.join("millis-test" + Date.now().toString() + Math.random().toString().slice(2));
|
|
2057
2056
|
tmpfile = path3.join(os.tmpdir(), tmpfile);
|
|
2058
2057
|
const d = new Date(1435410243862);
|
|
2059
|
-
|
|
2058
|
+
fs4.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
|
|
2060
2059
|
if (err)
|
|
2061
2060
|
return callback(err);
|
|
2062
|
-
|
|
2061
|
+
fs4.open(tmpfile, "r+", (err2, fd) => {
|
|
2063
2062
|
if (err2)
|
|
2064
2063
|
return callback(err2);
|
|
2065
|
-
|
|
2064
|
+
fs4.futimes(fd, d, d, (err3) => {
|
|
2066
2065
|
if (err3)
|
|
2067
2066
|
return callback(err3);
|
|
2068
|
-
|
|
2067
|
+
fs4.close(fd, (err4) => {
|
|
2069
2068
|
if (err4)
|
|
2070
2069
|
return callback(err4);
|
|
2071
|
-
|
|
2070
|
+
fs4.stat(tmpfile, (err5, stats) => {
|
|
2072
2071
|
if (err5)
|
|
2073
2072
|
return callback(err5);
|
|
2074
2073
|
callback(null, stats.mtime > 1435410243e3);
|
|
@@ -2088,11 +2087,11 @@ var require_utimes = __commonJS({
|
|
|
2088
2087
|
}
|
|
2089
2088
|
}
|
|
2090
2089
|
function utimesMillis(path4, atime, mtime, callback) {
|
|
2091
|
-
|
|
2090
|
+
fs4.open(path4, "r+", (err, fd) => {
|
|
2092
2091
|
if (err)
|
|
2093
2092
|
return callback(err);
|
|
2094
|
-
|
|
2095
|
-
|
|
2093
|
+
fs4.futimes(fd, atime, mtime, (futimesErr) => {
|
|
2094
|
+
fs4.close(fd, (closeErr) => {
|
|
2096
2095
|
if (callback)
|
|
2097
2096
|
callback(futimesErr || closeErr);
|
|
2098
2097
|
});
|
|
@@ -2100,9 +2099,9 @@ var require_utimes = __commonJS({
|
|
|
2100
2099
|
});
|
|
2101
2100
|
}
|
|
2102
2101
|
function utimesMillisSync(path4, atime, mtime) {
|
|
2103
|
-
const fd =
|
|
2104
|
-
|
|
2105
|
-
return
|
|
2102
|
+
const fd = fs4.openSync(path4, "r+");
|
|
2103
|
+
fs4.futimesSync(fd, atime, mtime);
|
|
2104
|
+
return fs4.closeSync(fd);
|
|
2106
2105
|
}
|
|
2107
2106
|
module2.exports = {
|
|
2108
2107
|
hasMillisRes,
|
|
@@ -2118,7 +2117,7 @@ var require_utimes = __commonJS({
|
|
|
2118
2117
|
var require_stat = __commonJS({
|
|
2119
2118
|
"node_modules/fs-extra/lib/util/stat.js"(exports, module2) {
|
|
2120
2119
|
"use strict";
|
|
2121
|
-
var
|
|
2120
|
+
var fs4 = require_graceful_fs();
|
|
2122
2121
|
var path3 = require("path");
|
|
2123
2122
|
var NODE_VERSION_MAJOR_WITH_BIGINT = 10;
|
|
2124
2123
|
var NODE_VERSION_MINOR_WITH_BIGINT = 5;
|
|
@@ -2143,10 +2142,10 @@ var require_stat = __commonJS({
|
|
|
2143
2142
|
}
|
|
2144
2143
|
function getStats(src, dest, cb) {
|
|
2145
2144
|
if (nodeSupportsBigInt()) {
|
|
2146
|
-
|
|
2145
|
+
fs4.stat(src, { bigint: true }, (err, srcStat) => {
|
|
2147
2146
|
if (err)
|
|
2148
2147
|
return cb(err);
|
|
2149
|
-
|
|
2148
|
+
fs4.stat(dest, { bigint: true }, (err2, destStat) => {
|
|
2150
2149
|
if (err2) {
|
|
2151
2150
|
if (err2.code === "ENOENT")
|
|
2152
2151
|
return cb(null, { srcStat, destStat: null });
|
|
@@ -2156,10 +2155,10 @@ var require_stat = __commonJS({
|
|
|
2156
2155
|
});
|
|
2157
2156
|
});
|
|
2158
2157
|
} else {
|
|
2159
|
-
|
|
2158
|
+
fs4.stat(src, (err, srcStat) => {
|
|
2160
2159
|
if (err)
|
|
2161
2160
|
return cb(err);
|
|
2162
|
-
|
|
2161
|
+
fs4.stat(dest, (err2, destStat) => {
|
|
2163
2162
|
if (err2) {
|
|
2164
2163
|
if (err2.code === "ENOENT")
|
|
2165
2164
|
return cb(null, { srcStat, destStat: null });
|
|
@@ -2173,15 +2172,15 @@ var require_stat = __commonJS({
|
|
|
2173
2172
|
function getStatsSync(src, dest) {
|
|
2174
2173
|
let srcStat, destStat;
|
|
2175
2174
|
if (nodeSupportsBigInt()) {
|
|
2176
|
-
srcStat =
|
|
2175
|
+
srcStat = fs4.statSync(src, { bigint: true });
|
|
2177
2176
|
} else {
|
|
2178
|
-
srcStat =
|
|
2177
|
+
srcStat = fs4.statSync(src);
|
|
2179
2178
|
}
|
|
2180
2179
|
try {
|
|
2181
2180
|
if (nodeSupportsBigInt()) {
|
|
2182
|
-
destStat =
|
|
2181
|
+
destStat = fs4.statSync(dest, { bigint: true });
|
|
2183
2182
|
} else {
|
|
2184
|
-
destStat =
|
|
2183
|
+
destStat = fs4.statSync(dest);
|
|
2185
2184
|
}
|
|
2186
2185
|
} catch (err) {
|
|
2187
2186
|
if (err.code === "ENOENT")
|
|
@@ -2220,7 +2219,7 @@ var require_stat = __commonJS({
|
|
|
2220
2219
|
if (destParent === srcParent || destParent === path3.parse(destParent).root)
|
|
2221
2220
|
return cb();
|
|
2222
2221
|
if (nodeSupportsBigInt()) {
|
|
2223
|
-
|
|
2222
|
+
fs4.stat(destParent, { bigint: true }, (err, destStat) => {
|
|
2224
2223
|
if (err) {
|
|
2225
2224
|
if (err.code === "ENOENT")
|
|
2226
2225
|
return cb();
|
|
@@ -2232,7 +2231,7 @@ var require_stat = __commonJS({
|
|
|
2232
2231
|
return checkParentPaths(src, srcStat, destParent, funcName, cb);
|
|
2233
2232
|
});
|
|
2234
2233
|
} else {
|
|
2235
|
-
|
|
2234
|
+
fs4.stat(destParent, (err, destStat) => {
|
|
2236
2235
|
if (err) {
|
|
2237
2236
|
if (err.code === "ENOENT")
|
|
2238
2237
|
return cb();
|
|
@@ -2253,9 +2252,9 @@ var require_stat = __commonJS({
|
|
|
2253
2252
|
let destStat;
|
|
2254
2253
|
try {
|
|
2255
2254
|
if (nodeSupportsBigInt()) {
|
|
2256
|
-
destStat =
|
|
2255
|
+
destStat = fs4.statSync(destParent, { bigint: true });
|
|
2257
2256
|
} else {
|
|
2258
|
-
destStat =
|
|
2257
|
+
destStat = fs4.statSync(destParent);
|
|
2259
2258
|
}
|
|
2260
2259
|
} catch (err) {
|
|
2261
2260
|
if (err.code === "ENOENT")
|
|
@@ -2306,7 +2305,7 @@ var require_buffer = __commonJS({
|
|
|
2306
2305
|
var require_copy_sync = __commonJS({
|
|
2307
2306
|
"node_modules/fs-extra/lib/copy-sync/copy-sync.js"(exports, module2) {
|
|
2308
2307
|
"use strict";
|
|
2309
|
-
var
|
|
2308
|
+
var fs4 = require_graceful_fs();
|
|
2310
2309
|
var path3 = require("path");
|
|
2311
2310
|
var mkdirpSync = require_mkdirs2().mkdirsSync;
|
|
2312
2311
|
var utimesSync = require_utimes().utimesMillisSync;
|
|
@@ -2331,7 +2330,7 @@ var require_copy_sync = __commonJS({
|
|
|
2331
2330
|
if (opts.filter && !opts.filter(src, dest))
|
|
2332
2331
|
return;
|
|
2333
2332
|
const destParent = path3.dirname(dest);
|
|
2334
|
-
if (!
|
|
2333
|
+
if (!fs4.existsSync(destParent))
|
|
2335
2334
|
mkdirpSync(destParent);
|
|
2336
2335
|
return startCopy(destStat, src, dest, opts);
|
|
2337
2336
|
}
|
|
@@ -2341,7 +2340,7 @@ var require_copy_sync = __commonJS({
|
|
|
2341
2340
|
return getStats(destStat, src, dest, opts);
|
|
2342
2341
|
}
|
|
2343
2342
|
function getStats(destStat, src, dest, opts) {
|
|
2344
|
-
const statSync2 = opts.dereference ?
|
|
2343
|
+
const statSync2 = opts.dereference ? fs4.statSync : fs4.lstatSync;
|
|
2345
2344
|
const srcStat = statSync2(src);
|
|
2346
2345
|
if (srcStat.isDirectory())
|
|
2347
2346
|
return onDir(srcStat, destStat, src, dest, opts);
|
|
@@ -2357,16 +2356,16 @@ var require_copy_sync = __commonJS({
|
|
|
2357
2356
|
}
|
|
2358
2357
|
function mayCopyFile(srcStat, src, dest, opts) {
|
|
2359
2358
|
if (opts.overwrite) {
|
|
2360
|
-
|
|
2359
|
+
fs4.unlinkSync(dest);
|
|
2361
2360
|
return copyFile(srcStat, src, dest, opts);
|
|
2362
2361
|
} else if (opts.errorOnExist) {
|
|
2363
2362
|
throw new Error(`'${dest}' already exists`);
|
|
2364
2363
|
}
|
|
2365
2364
|
}
|
|
2366
2365
|
function copyFile(srcStat, src, dest, opts) {
|
|
2367
|
-
if (typeof
|
|
2368
|
-
|
|
2369
|
-
|
|
2366
|
+
if (typeof fs4.copyFileSync === "function") {
|
|
2367
|
+
fs4.copyFileSync(src, dest);
|
|
2368
|
+
fs4.chmodSync(dest, srcStat.mode);
|
|
2370
2369
|
if (opts.preserveTimestamps) {
|
|
2371
2370
|
return utimesSync(dest, srcStat.atime, srcStat.mtime);
|
|
2372
2371
|
}
|
|
@@ -2377,18 +2376,18 @@ var require_copy_sync = __commonJS({
|
|
|
2377
2376
|
function copyFileFallback(srcStat, src, dest, opts) {
|
|
2378
2377
|
const BUF_LENGTH = 64 * 1024;
|
|
2379
2378
|
const _buff = require_buffer()(BUF_LENGTH);
|
|
2380
|
-
const fdr =
|
|
2381
|
-
const fdw =
|
|
2379
|
+
const fdr = fs4.openSync(src, "r");
|
|
2380
|
+
const fdw = fs4.openSync(dest, "w", srcStat.mode);
|
|
2382
2381
|
let pos = 0;
|
|
2383
2382
|
while (pos < srcStat.size) {
|
|
2384
|
-
const bytesRead =
|
|
2385
|
-
|
|
2383
|
+
const bytesRead = fs4.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
|
|
2384
|
+
fs4.writeSync(fdw, _buff, 0, bytesRead);
|
|
2386
2385
|
pos += bytesRead;
|
|
2387
2386
|
}
|
|
2388
2387
|
if (opts.preserveTimestamps)
|
|
2389
|
-
|
|
2390
|
-
|
|
2391
|
-
|
|
2388
|
+
fs4.futimesSync(fdw, srcStat.atime, srcStat.mtime);
|
|
2389
|
+
fs4.closeSync(fdr);
|
|
2390
|
+
fs4.closeSync(fdw);
|
|
2392
2391
|
}
|
|
2393
2392
|
function onDir(srcStat, destStat, src, dest, opts) {
|
|
2394
2393
|
if (!destStat)
|
|
@@ -2399,12 +2398,12 @@ var require_copy_sync = __commonJS({
|
|
|
2399
2398
|
return copyDir(src, dest, opts);
|
|
2400
2399
|
}
|
|
2401
2400
|
function mkDirAndCopy(srcStat, src, dest, opts) {
|
|
2402
|
-
|
|
2401
|
+
fs4.mkdirSync(dest);
|
|
2403
2402
|
copyDir(src, dest, opts);
|
|
2404
|
-
return
|
|
2403
|
+
return fs4.chmodSync(dest, srcStat.mode);
|
|
2405
2404
|
}
|
|
2406
2405
|
function copyDir(src, dest, opts) {
|
|
2407
|
-
|
|
2406
|
+
fs4.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
|
|
2408
2407
|
}
|
|
2409
2408
|
function copyDirItem(item, src, dest, opts) {
|
|
2410
2409
|
const srcItem = path3.join(src, item);
|
|
@@ -2413,19 +2412,19 @@ var require_copy_sync = __commonJS({
|
|
|
2413
2412
|
return startCopy(destStat, srcItem, destItem, opts);
|
|
2414
2413
|
}
|
|
2415
2414
|
function onLink(destStat, src, dest, opts) {
|
|
2416
|
-
let resolvedSrc =
|
|
2415
|
+
let resolvedSrc = fs4.readlinkSync(src);
|
|
2417
2416
|
if (opts.dereference) {
|
|
2418
2417
|
resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
|
|
2419
2418
|
}
|
|
2420
2419
|
if (!destStat) {
|
|
2421
|
-
return
|
|
2420
|
+
return fs4.symlinkSync(resolvedSrc, dest);
|
|
2422
2421
|
} else {
|
|
2423
2422
|
let resolvedDest;
|
|
2424
2423
|
try {
|
|
2425
|
-
resolvedDest =
|
|
2424
|
+
resolvedDest = fs4.readlinkSync(dest);
|
|
2426
2425
|
} catch (err) {
|
|
2427
2426
|
if (err.code === "EINVAL" || err.code === "UNKNOWN")
|
|
2428
|
-
return
|
|
2427
|
+
return fs4.symlinkSync(resolvedSrc, dest);
|
|
2429
2428
|
throw err;
|
|
2430
2429
|
}
|
|
2431
2430
|
if (opts.dereference) {
|
|
@@ -2434,15 +2433,15 @@ var require_copy_sync = __commonJS({
|
|
|
2434
2433
|
if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
|
|
2435
2434
|
throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
|
|
2436
2435
|
}
|
|
2437
|
-
if (
|
|
2436
|
+
if (fs4.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
|
|
2438
2437
|
throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
|
|
2439
2438
|
}
|
|
2440
2439
|
return copyLink(resolvedSrc, dest);
|
|
2441
2440
|
}
|
|
2442
2441
|
}
|
|
2443
2442
|
function copyLink(resolvedSrc, dest) {
|
|
2444
|
-
|
|
2445
|
-
return
|
|
2443
|
+
fs4.unlinkSync(dest);
|
|
2444
|
+
return fs4.symlinkSync(resolvedSrc, dest);
|
|
2446
2445
|
}
|
|
2447
2446
|
module2.exports = copySync;
|
|
2448
2447
|
}
|
|
@@ -2463,13 +2462,13 @@ var require_path_exists = __commonJS({
|
|
|
2463
2462
|
"node_modules/fs-extra/lib/path-exists/index.js"(exports, module2) {
|
|
2464
2463
|
"use strict";
|
|
2465
2464
|
var u = require_universalify().fromPromise;
|
|
2466
|
-
var
|
|
2465
|
+
var fs4 = require_fs();
|
|
2467
2466
|
function pathExists2(path3) {
|
|
2468
|
-
return
|
|
2467
|
+
return fs4.access(path3).then(() => true).catch(() => false);
|
|
2469
2468
|
}
|
|
2470
2469
|
module2.exports = {
|
|
2471
2470
|
pathExists: u(pathExists2),
|
|
2472
|
-
pathExistsSync:
|
|
2471
|
+
pathExistsSync: fs4.existsSync
|
|
2473
2472
|
};
|
|
2474
2473
|
}
|
|
2475
2474
|
});
|
|
@@ -2478,7 +2477,7 @@ var require_path_exists = __commonJS({
|
|
|
2478
2477
|
var require_copy = __commonJS({
|
|
2479
2478
|
"node_modules/fs-extra/lib/copy/copy.js"(exports, module2) {
|
|
2480
2479
|
"use strict";
|
|
2481
|
-
var
|
|
2480
|
+
var fs4 = require_graceful_fs();
|
|
2482
2481
|
var path3 = require("path");
|
|
2483
2482
|
var mkdirp = require_mkdirs2().mkdirs;
|
|
2484
2483
|
var pathExists2 = require_path_exists().pathExists;
|
|
@@ -2541,7 +2540,7 @@ var require_copy = __commonJS({
|
|
|
2541
2540
|
return getStats(destStat, src, dest, opts, cb);
|
|
2542
2541
|
}
|
|
2543
2542
|
function getStats(destStat, src, dest, opts, cb) {
|
|
2544
|
-
const stat2 = opts.dereference ?
|
|
2543
|
+
const stat2 = opts.dereference ? fs4.stat : fs4.lstat;
|
|
2545
2544
|
stat2(src, (err, srcStat) => {
|
|
2546
2545
|
if (err)
|
|
2547
2546
|
return cb(err);
|
|
@@ -2560,7 +2559,7 @@ var require_copy = __commonJS({
|
|
|
2560
2559
|
}
|
|
2561
2560
|
function mayCopyFile(srcStat, src, dest, opts, cb) {
|
|
2562
2561
|
if (opts.overwrite) {
|
|
2563
|
-
|
|
2562
|
+
fs4.unlink(dest, (err) => {
|
|
2564
2563
|
if (err)
|
|
2565
2564
|
return cb(err);
|
|
2566
2565
|
return copyFile(srcStat, src, dest, opts, cb);
|
|
@@ -2571,8 +2570,8 @@ var require_copy = __commonJS({
|
|
|
2571
2570
|
return cb();
|
|
2572
2571
|
}
|
|
2573
2572
|
function copyFile(srcStat, src, dest, opts, cb) {
|
|
2574
|
-
if (typeof
|
|
2575
|
-
return
|
|
2573
|
+
if (typeof fs4.copyFile === "function") {
|
|
2574
|
+
return fs4.copyFile(src, dest, (err) => {
|
|
2576
2575
|
if (err)
|
|
2577
2576
|
return cb(err);
|
|
2578
2577
|
return setDestModeAndTimestamps(srcStat, dest, opts, cb);
|
|
@@ -2581,14 +2580,14 @@ var require_copy = __commonJS({
|
|
|
2581
2580
|
return copyFileFallback(srcStat, src, dest, opts, cb);
|
|
2582
2581
|
}
|
|
2583
2582
|
function copyFileFallback(srcStat, src, dest, opts, cb) {
|
|
2584
|
-
const rs =
|
|
2583
|
+
const rs = fs4.createReadStream(src);
|
|
2585
2584
|
rs.on("error", (err) => cb(err)).once("open", () => {
|
|
2586
|
-
const ws =
|
|
2585
|
+
const ws = fs4.createWriteStream(dest, { mode: srcStat.mode });
|
|
2587
2586
|
ws.on("error", (err) => cb(err)).on("open", () => rs.pipe(ws)).once("close", () => setDestModeAndTimestamps(srcStat, dest, opts, cb));
|
|
2588
2587
|
});
|
|
2589
2588
|
}
|
|
2590
2589
|
function setDestModeAndTimestamps(srcStat, dest, opts, cb) {
|
|
2591
|
-
|
|
2590
|
+
fs4.chmod(dest, srcStat.mode, (err) => {
|
|
2592
2591
|
if (err)
|
|
2593
2592
|
return cb(err);
|
|
2594
2593
|
if (opts.preserveTimestamps) {
|
|
@@ -2606,18 +2605,18 @@ var require_copy = __commonJS({
|
|
|
2606
2605
|
return copyDir(src, dest, opts, cb);
|
|
2607
2606
|
}
|
|
2608
2607
|
function mkDirAndCopy(srcStat, src, dest, opts, cb) {
|
|
2609
|
-
|
|
2608
|
+
fs4.mkdir(dest, (err) => {
|
|
2610
2609
|
if (err)
|
|
2611
2610
|
return cb(err);
|
|
2612
2611
|
copyDir(src, dest, opts, (err2) => {
|
|
2613
2612
|
if (err2)
|
|
2614
2613
|
return cb(err2);
|
|
2615
|
-
return
|
|
2614
|
+
return fs4.chmod(dest, srcStat.mode, cb);
|
|
2616
2615
|
});
|
|
2617
2616
|
});
|
|
2618
2617
|
}
|
|
2619
2618
|
function copyDir(src, dest, opts, cb) {
|
|
2620
|
-
|
|
2619
|
+
fs4.readdir(src, (err, items) => {
|
|
2621
2620
|
if (err)
|
|
2622
2621
|
return cb(err);
|
|
2623
2622
|
return copyDirItems(items, src, dest, opts, cb);
|
|
@@ -2644,19 +2643,19 @@ var require_copy = __commonJS({
|
|
|
2644
2643
|
});
|
|
2645
2644
|
}
|
|
2646
2645
|
function onLink(destStat, src, dest, opts, cb) {
|
|
2647
|
-
|
|
2646
|
+
fs4.readlink(src, (err, resolvedSrc) => {
|
|
2648
2647
|
if (err)
|
|
2649
2648
|
return cb(err);
|
|
2650
2649
|
if (opts.dereference) {
|
|
2651
2650
|
resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
|
|
2652
2651
|
}
|
|
2653
2652
|
if (!destStat) {
|
|
2654
|
-
return
|
|
2653
|
+
return fs4.symlink(resolvedSrc, dest, cb);
|
|
2655
2654
|
} else {
|
|
2656
|
-
|
|
2655
|
+
fs4.readlink(dest, (err2, resolvedDest) => {
|
|
2657
2656
|
if (err2) {
|
|
2658
2657
|
if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
|
|
2659
|
-
return
|
|
2658
|
+
return fs4.symlink(resolvedSrc, dest, cb);
|
|
2660
2659
|
return cb(err2);
|
|
2661
2660
|
}
|
|
2662
2661
|
if (opts.dereference) {
|
|
@@ -2674,10 +2673,10 @@ var require_copy = __commonJS({
|
|
|
2674
2673
|
});
|
|
2675
2674
|
}
|
|
2676
2675
|
function copyLink(resolvedSrc, dest, cb) {
|
|
2677
|
-
|
|
2676
|
+
fs4.unlink(dest, (err) => {
|
|
2678
2677
|
if (err)
|
|
2679
2678
|
return cb(err);
|
|
2680
|
-
return
|
|
2679
|
+
return fs4.symlink(resolvedSrc, dest, cb);
|
|
2681
2680
|
});
|
|
2682
2681
|
}
|
|
2683
2682
|
module2.exports = copy;
|
|
@@ -2699,7 +2698,7 @@ var require_copy2 = __commonJS({
|
|
|
2699
2698
|
var require_rimraf = __commonJS({
|
|
2700
2699
|
"node_modules/fs-extra/lib/remove/rimraf.js"(exports, module2) {
|
|
2701
2700
|
"use strict";
|
|
2702
|
-
var
|
|
2701
|
+
var fs4 = require_graceful_fs();
|
|
2703
2702
|
var path3 = require("path");
|
|
2704
2703
|
var assert = require("assert");
|
|
2705
2704
|
var isWindows2 = process.platform === "win32";
|
|
@@ -2713,9 +2712,9 @@ var require_rimraf = __commonJS({
|
|
|
2713
2712
|
"readdir"
|
|
2714
2713
|
];
|
|
2715
2714
|
methods.forEach((m) => {
|
|
2716
|
-
options[m] = options[m] ||
|
|
2715
|
+
options[m] = options[m] || fs4[m];
|
|
2717
2716
|
m = m + "Sync";
|
|
2718
|
-
options[m] = options[m] ||
|
|
2717
|
+
options[m] = options[m] || fs4[m];
|
|
2719
2718
|
});
|
|
2720
2719
|
options.maxBusyTries = options.maxBusyTries || 3;
|
|
2721
2720
|
}
|
|
@@ -2964,14 +2963,14 @@ var require_empty = __commonJS({
|
|
|
2964
2963
|
"node_modules/fs-extra/lib/empty/index.js"(exports, module2) {
|
|
2965
2964
|
"use strict";
|
|
2966
2965
|
var u = require_universalify().fromCallback;
|
|
2967
|
-
var
|
|
2966
|
+
var fs4 = require_graceful_fs();
|
|
2968
2967
|
var path3 = require("path");
|
|
2969
2968
|
var mkdir = require_mkdirs2();
|
|
2970
2969
|
var remove = require_remove();
|
|
2971
2970
|
var emptyDir = u(function emptyDir2(dir, callback) {
|
|
2972
2971
|
callback = callback || function() {
|
|
2973
2972
|
};
|
|
2974
|
-
|
|
2973
|
+
fs4.readdir(dir, (err, items) => {
|
|
2975
2974
|
if (err)
|
|
2976
2975
|
return mkdir.mkdirs(dir, callback);
|
|
2977
2976
|
items = items.map((item) => path3.join(dir, item));
|
|
@@ -2991,7 +2990,7 @@ var require_empty = __commonJS({
|
|
|
2991
2990
|
function emptyDirSync(dir) {
|
|
2992
2991
|
let items;
|
|
2993
2992
|
try {
|
|
2994
|
-
items =
|
|
2993
|
+
items = fs4.readdirSync(dir);
|
|
2995
2994
|
} catch (err) {
|
|
2996
2995
|
return mkdir.mkdirsSync(dir);
|
|
2997
2996
|
}
|
|
@@ -3015,18 +3014,18 @@ var require_file = __commonJS({
|
|
|
3015
3014
|
"use strict";
|
|
3016
3015
|
var u = require_universalify().fromCallback;
|
|
3017
3016
|
var path3 = require("path");
|
|
3018
|
-
var
|
|
3017
|
+
var fs4 = require_graceful_fs();
|
|
3019
3018
|
var mkdir = require_mkdirs2();
|
|
3020
3019
|
var pathExists2 = require_path_exists().pathExists;
|
|
3021
3020
|
function createFile(file, callback) {
|
|
3022
3021
|
function makeFile() {
|
|
3023
|
-
|
|
3022
|
+
fs4.writeFile(file, "", (err) => {
|
|
3024
3023
|
if (err)
|
|
3025
3024
|
return callback(err);
|
|
3026
3025
|
callback();
|
|
3027
3026
|
});
|
|
3028
3027
|
}
|
|
3029
|
-
|
|
3028
|
+
fs4.stat(file, (err, stats) => {
|
|
3030
3029
|
if (!err && stats.isFile())
|
|
3031
3030
|
return callback();
|
|
3032
3031
|
const dir = path3.dirname(file);
|
|
@@ -3046,16 +3045,16 @@ var require_file = __commonJS({
|
|
|
3046
3045
|
function createFileSync(file) {
|
|
3047
3046
|
let stats;
|
|
3048
3047
|
try {
|
|
3049
|
-
stats =
|
|
3048
|
+
stats = fs4.statSync(file);
|
|
3050
3049
|
} catch (e) {
|
|
3051
3050
|
}
|
|
3052
3051
|
if (stats && stats.isFile())
|
|
3053
3052
|
return;
|
|
3054
3053
|
const dir = path3.dirname(file);
|
|
3055
|
-
if (!
|
|
3054
|
+
if (!fs4.existsSync(dir)) {
|
|
3056
3055
|
mkdir.mkdirsSync(dir);
|
|
3057
3056
|
}
|
|
3058
|
-
|
|
3057
|
+
fs4.writeFileSync(file, "");
|
|
3059
3058
|
}
|
|
3060
3059
|
module2.exports = {
|
|
3061
3060
|
createFile: u(createFile),
|
|
@@ -3070,12 +3069,12 @@ var require_link = __commonJS({
|
|
|
3070
3069
|
"use strict";
|
|
3071
3070
|
var u = require_universalify().fromCallback;
|
|
3072
3071
|
var path3 = require("path");
|
|
3073
|
-
var
|
|
3072
|
+
var fs4 = require_graceful_fs();
|
|
3074
3073
|
var mkdir = require_mkdirs2();
|
|
3075
3074
|
var pathExists2 = require_path_exists().pathExists;
|
|
3076
3075
|
function createLink(srcpath, dstpath, callback) {
|
|
3077
3076
|
function makeLink(srcpath2, dstpath2) {
|
|
3078
|
-
|
|
3077
|
+
fs4.link(srcpath2, dstpath2, (err) => {
|
|
3079
3078
|
if (err)
|
|
3080
3079
|
return callback(err);
|
|
3081
3080
|
callback(null);
|
|
@@ -3086,7 +3085,7 @@ var require_link = __commonJS({
|
|
|
3086
3085
|
return callback(err);
|
|
3087
3086
|
if (destinationExists)
|
|
3088
3087
|
return callback(null);
|
|
3089
|
-
|
|
3088
|
+
fs4.lstat(srcpath, (err2) => {
|
|
3090
3089
|
if (err2) {
|
|
3091
3090
|
err2.message = err2.message.replace("lstat", "ensureLink");
|
|
3092
3091
|
return callback(err2);
|
|
@@ -3107,21 +3106,21 @@ var require_link = __commonJS({
|
|
|
3107
3106
|
});
|
|
3108
3107
|
}
|
|
3109
3108
|
function createLinkSync(srcpath, dstpath) {
|
|
3110
|
-
const destinationExists =
|
|
3109
|
+
const destinationExists = fs4.existsSync(dstpath);
|
|
3111
3110
|
if (destinationExists)
|
|
3112
3111
|
return void 0;
|
|
3113
3112
|
try {
|
|
3114
|
-
|
|
3113
|
+
fs4.lstatSync(srcpath);
|
|
3115
3114
|
} catch (err) {
|
|
3116
3115
|
err.message = err.message.replace("lstat", "ensureLink");
|
|
3117
3116
|
throw err;
|
|
3118
3117
|
}
|
|
3119
3118
|
const dir = path3.dirname(dstpath);
|
|
3120
|
-
const dirExists =
|
|
3119
|
+
const dirExists = fs4.existsSync(dir);
|
|
3121
3120
|
if (dirExists)
|
|
3122
|
-
return
|
|
3121
|
+
return fs4.linkSync(srcpath, dstpath);
|
|
3123
3122
|
mkdir.mkdirsSync(dir);
|
|
3124
|
-
return
|
|
3123
|
+
return fs4.linkSync(srcpath, dstpath);
|
|
3125
3124
|
}
|
|
3126
3125
|
module2.exports = {
|
|
3127
3126
|
createLink: u(createLink),
|
|
@@ -3135,11 +3134,11 @@ var require_symlink_paths = __commonJS({
|
|
|
3135
3134
|
"node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module2) {
|
|
3136
3135
|
"use strict";
|
|
3137
3136
|
var path3 = require("path");
|
|
3138
|
-
var
|
|
3137
|
+
var fs4 = require_graceful_fs();
|
|
3139
3138
|
var pathExists2 = require_path_exists().pathExists;
|
|
3140
3139
|
function symlinkPaths(srcpath, dstpath, callback) {
|
|
3141
3140
|
if (path3.isAbsolute(srcpath)) {
|
|
3142
|
-
return
|
|
3141
|
+
return fs4.lstat(srcpath, (err) => {
|
|
3143
3142
|
if (err) {
|
|
3144
3143
|
err.message = err.message.replace("lstat", "ensureSymlink");
|
|
3145
3144
|
return callback(err);
|
|
@@ -3161,7 +3160,7 @@ var require_symlink_paths = __commonJS({
|
|
|
3161
3160
|
"toDst": srcpath
|
|
3162
3161
|
});
|
|
3163
3162
|
} else {
|
|
3164
|
-
return
|
|
3163
|
+
return fs4.lstat(srcpath, (err2) => {
|
|
3165
3164
|
if (err2) {
|
|
3166
3165
|
err2.message = err2.message.replace("lstat", "ensureSymlink");
|
|
3167
3166
|
return callback(err2);
|
|
@@ -3178,7 +3177,7 @@ var require_symlink_paths = __commonJS({
|
|
|
3178
3177
|
function symlinkPathsSync(srcpath, dstpath) {
|
|
3179
3178
|
let exists;
|
|
3180
3179
|
if (path3.isAbsolute(srcpath)) {
|
|
3181
|
-
exists =
|
|
3180
|
+
exists = fs4.existsSync(srcpath);
|
|
3182
3181
|
if (!exists)
|
|
3183
3182
|
throw new Error("absolute srcpath does not exist");
|
|
3184
3183
|
return {
|
|
@@ -3188,14 +3187,14 @@ var require_symlink_paths = __commonJS({
|
|
|
3188
3187
|
} else {
|
|
3189
3188
|
const dstdir = path3.dirname(dstpath);
|
|
3190
3189
|
const relativeToDst = path3.join(dstdir, srcpath);
|
|
3191
|
-
exists =
|
|
3190
|
+
exists = fs4.existsSync(relativeToDst);
|
|
3192
3191
|
if (exists) {
|
|
3193
3192
|
return {
|
|
3194
3193
|
"toCwd": relativeToDst,
|
|
3195
3194
|
"toDst": srcpath
|
|
3196
3195
|
};
|
|
3197
3196
|
} else {
|
|
3198
|
-
exists =
|
|
3197
|
+
exists = fs4.existsSync(srcpath);
|
|
3199
3198
|
if (!exists)
|
|
3200
3199
|
throw new Error("relative srcpath does not exist");
|
|
3201
3200
|
return {
|
|
@@ -3216,13 +3215,13 @@ var require_symlink_paths = __commonJS({
|
|
|
3216
3215
|
var require_symlink_type = __commonJS({
|
|
3217
3216
|
"node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module2) {
|
|
3218
3217
|
"use strict";
|
|
3219
|
-
var
|
|
3218
|
+
var fs4 = require_graceful_fs();
|
|
3220
3219
|
function symlinkType(srcpath, type, callback) {
|
|
3221
3220
|
callback = typeof type === "function" ? type : callback;
|
|
3222
3221
|
type = typeof type === "function" ? false : type;
|
|
3223
3222
|
if (type)
|
|
3224
3223
|
return callback(null, type);
|
|
3225
|
-
|
|
3224
|
+
fs4.lstat(srcpath, (err, stats) => {
|
|
3226
3225
|
if (err)
|
|
3227
3226
|
return callback(null, "file");
|
|
3228
3227
|
type = stats && stats.isDirectory() ? "dir" : "file";
|
|
@@ -3234,7 +3233,7 @@ var require_symlink_type = __commonJS({
|
|
|
3234
3233
|
if (type)
|
|
3235
3234
|
return type;
|
|
3236
3235
|
try {
|
|
3237
|
-
stats =
|
|
3236
|
+
stats = fs4.lstatSync(srcpath);
|
|
3238
3237
|
} catch (e) {
|
|
3239
3238
|
return "file";
|
|
3240
3239
|
}
|
|
@@ -3253,7 +3252,7 @@ var require_symlink = __commonJS({
|
|
|
3253
3252
|
"use strict";
|
|
3254
3253
|
var u = require_universalify().fromCallback;
|
|
3255
3254
|
var path3 = require("path");
|
|
3256
|
-
var
|
|
3255
|
+
var fs4 = require_graceful_fs();
|
|
3257
3256
|
var _mkdirs = require_mkdirs2();
|
|
3258
3257
|
var mkdirs = _mkdirs.mkdirs;
|
|
3259
3258
|
var mkdirsSync = _mkdirs.mkdirsSync;
|
|
@@ -3284,11 +3283,11 @@ var require_symlink = __commonJS({
|
|
|
3284
3283
|
if (err4)
|
|
3285
3284
|
return callback(err4);
|
|
3286
3285
|
if (dirExists)
|
|
3287
|
-
return
|
|
3286
|
+
return fs4.symlink(srcpath, dstpath, type2, callback);
|
|
3288
3287
|
mkdirs(dir, (err5) => {
|
|
3289
3288
|
if (err5)
|
|
3290
3289
|
return callback(err5);
|
|
3291
|
-
|
|
3290
|
+
fs4.symlink(srcpath, dstpath, type2, callback);
|
|
3292
3291
|
});
|
|
3293
3292
|
});
|
|
3294
3293
|
});
|
|
@@ -3296,18 +3295,18 @@ var require_symlink = __commonJS({
|
|
|
3296
3295
|
});
|
|
3297
3296
|
}
|
|
3298
3297
|
function createSymlinkSync(srcpath, dstpath, type) {
|
|
3299
|
-
const destinationExists =
|
|
3298
|
+
const destinationExists = fs4.existsSync(dstpath);
|
|
3300
3299
|
if (destinationExists)
|
|
3301
3300
|
return void 0;
|
|
3302
3301
|
const relative = symlinkPathsSync(srcpath, dstpath);
|
|
3303
3302
|
srcpath = relative.toDst;
|
|
3304
3303
|
type = symlinkTypeSync(relative.toCwd, type);
|
|
3305
3304
|
const dir = path3.dirname(dstpath);
|
|
3306
|
-
const exists =
|
|
3305
|
+
const exists = fs4.existsSync(dir);
|
|
3307
3306
|
if (exists)
|
|
3308
|
-
return
|
|
3307
|
+
return fs4.symlinkSync(srcpath, dstpath, type);
|
|
3309
3308
|
mkdirsSync(dir);
|
|
3310
|
-
return
|
|
3309
|
+
return fs4.symlinkSync(srcpath, dstpath, type);
|
|
3311
3310
|
}
|
|
3312
3311
|
module2.exports = {
|
|
3313
3312
|
createSymlink: u(createSymlink),
|
|
@@ -3358,12 +3357,12 @@ var require_jsonfile = __commonJS({
|
|
|
3358
3357
|
options = { encoding: options };
|
|
3359
3358
|
}
|
|
3360
3359
|
options = options || {};
|
|
3361
|
-
var
|
|
3360
|
+
var fs4 = options.fs || _fs;
|
|
3362
3361
|
var shouldThrow = true;
|
|
3363
3362
|
if ("throws" in options) {
|
|
3364
3363
|
shouldThrow = options.throws;
|
|
3365
3364
|
}
|
|
3366
|
-
|
|
3365
|
+
fs4.readFile(file, options, function(err, data) {
|
|
3367
3366
|
if (err)
|
|
3368
3367
|
return callback(err);
|
|
3369
3368
|
data = stripBom(data);
|
|
@@ -3386,13 +3385,13 @@ var require_jsonfile = __commonJS({
|
|
|
3386
3385
|
if (typeof options === "string") {
|
|
3387
3386
|
options = { encoding: options };
|
|
3388
3387
|
}
|
|
3389
|
-
var
|
|
3388
|
+
var fs4 = options.fs || _fs;
|
|
3390
3389
|
var shouldThrow = true;
|
|
3391
3390
|
if ("throws" in options) {
|
|
3392
3391
|
shouldThrow = options.throws;
|
|
3393
3392
|
}
|
|
3394
3393
|
try {
|
|
3395
|
-
var content =
|
|
3394
|
+
var content = fs4.readFileSync(file, options);
|
|
3396
3395
|
content = stripBom(content);
|
|
3397
3396
|
return JSON.parse(content, options.reviver);
|
|
3398
3397
|
} catch (err) {
|
|
@@ -3424,7 +3423,7 @@ var require_jsonfile = __commonJS({
|
|
|
3424
3423
|
options = {};
|
|
3425
3424
|
}
|
|
3426
3425
|
options = options || {};
|
|
3427
|
-
var
|
|
3426
|
+
var fs4 = options.fs || _fs;
|
|
3428
3427
|
var str = "";
|
|
3429
3428
|
try {
|
|
3430
3429
|
str = stringify(obj, options);
|
|
@@ -3433,13 +3432,13 @@ var require_jsonfile = __commonJS({
|
|
|
3433
3432
|
callback(err, null);
|
|
3434
3433
|
return;
|
|
3435
3434
|
}
|
|
3436
|
-
|
|
3435
|
+
fs4.writeFile(file, str, options, callback);
|
|
3437
3436
|
}
|
|
3438
3437
|
function writeFileSync(file, obj, options) {
|
|
3439
3438
|
options = options || {};
|
|
3440
|
-
var
|
|
3439
|
+
var fs4 = options.fs || _fs;
|
|
3441
3440
|
var str = stringify(obj, options);
|
|
3442
|
-
return
|
|
3441
|
+
return fs4.writeFileSync(file, str, options);
|
|
3443
3442
|
}
|
|
3444
3443
|
function stripBom(content) {
|
|
3445
3444
|
if (Buffer.isBuffer(content))
|
|
@@ -3506,13 +3505,13 @@ var require_output_json = __commonJS({
|
|
|
3506
3505
|
var require_output_json_sync = __commonJS({
|
|
3507
3506
|
"node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module2) {
|
|
3508
3507
|
"use strict";
|
|
3509
|
-
var
|
|
3508
|
+
var fs4 = require_graceful_fs();
|
|
3510
3509
|
var path3 = require("path");
|
|
3511
3510
|
var mkdir = require_mkdirs2();
|
|
3512
3511
|
var jsonFile = require_jsonfile2();
|
|
3513
3512
|
function outputJsonSync(file, data, options) {
|
|
3514
3513
|
const dir = path3.dirname(file);
|
|
3515
|
-
if (!
|
|
3514
|
+
if (!fs4.existsSync(dir)) {
|
|
3516
3515
|
mkdir.mkdirsSync(dir);
|
|
3517
3516
|
}
|
|
3518
3517
|
jsonFile.writeJsonSync(file, data, options);
|
|
@@ -3543,7 +3542,7 @@ var require_json = __commonJS({
|
|
|
3543
3542
|
var require_move_sync = __commonJS({
|
|
3544
3543
|
"node_modules/fs-extra/lib/move-sync/move-sync.js"(exports, module2) {
|
|
3545
3544
|
"use strict";
|
|
3546
|
-
var
|
|
3545
|
+
var fs4 = require_graceful_fs();
|
|
3547
3546
|
var path3 = require("path");
|
|
3548
3547
|
var copySync = require_copy_sync2().copySync;
|
|
3549
3548
|
var removeSync = require_remove().removeSync;
|
|
@@ -3562,13 +3561,13 @@ var require_move_sync = __commonJS({
|
|
|
3562
3561
|
removeSync(dest);
|
|
3563
3562
|
return rename(src, dest, overwrite);
|
|
3564
3563
|
}
|
|
3565
|
-
if (
|
|
3564
|
+
if (fs4.existsSync(dest))
|
|
3566
3565
|
throw new Error("dest already exists.");
|
|
3567
3566
|
return rename(src, dest, overwrite);
|
|
3568
3567
|
}
|
|
3569
3568
|
function rename(src, dest, overwrite) {
|
|
3570
3569
|
try {
|
|
3571
|
-
|
|
3570
|
+
fs4.renameSync(src, dest);
|
|
3572
3571
|
} catch (err) {
|
|
3573
3572
|
if (err.code !== "EXDEV")
|
|
3574
3573
|
throw err;
|
|
@@ -3601,7 +3600,7 @@ var require_move_sync2 = __commonJS({
|
|
|
3601
3600
|
var require_move = __commonJS({
|
|
3602
3601
|
"node_modules/fs-extra/lib/move/move.js"(exports, module2) {
|
|
3603
3602
|
"use strict";
|
|
3604
|
-
var
|
|
3603
|
+
var fs4 = require_graceful_fs();
|
|
3605
3604
|
var path3 = require("path");
|
|
3606
3605
|
var copy = require_copy2().copy;
|
|
3607
3606
|
var remove = require_remove().remove;
|
|
@@ -3646,7 +3645,7 @@ var require_move = __commonJS({
|
|
|
3646
3645
|
});
|
|
3647
3646
|
}
|
|
3648
3647
|
function rename(src, dest, overwrite, cb) {
|
|
3649
|
-
|
|
3648
|
+
fs4.rename(src, dest, (err) => {
|
|
3650
3649
|
if (!err)
|
|
3651
3650
|
return cb();
|
|
3652
3651
|
if (err.code !== "EXDEV")
|
|
@@ -3685,7 +3684,7 @@ var require_output = __commonJS({
|
|
|
3685
3684
|
"node_modules/fs-extra/lib/output/index.js"(exports, module2) {
|
|
3686
3685
|
"use strict";
|
|
3687
3686
|
var u = require_universalify().fromCallback;
|
|
3688
|
-
var
|
|
3687
|
+
var fs4 = require_graceful_fs();
|
|
3689
3688
|
var path3 = require("path");
|
|
3690
3689
|
var mkdir = require_mkdirs2();
|
|
3691
3690
|
var pathExists2 = require_path_exists().pathExists;
|
|
@@ -3699,21 +3698,21 @@ var require_output = __commonJS({
|
|
|
3699
3698
|
if (err)
|
|
3700
3699
|
return callback(err);
|
|
3701
3700
|
if (itDoes)
|
|
3702
|
-
return
|
|
3701
|
+
return fs4.writeFile(file, data, encoding, callback);
|
|
3703
3702
|
mkdir.mkdirs(dir, (err2) => {
|
|
3704
3703
|
if (err2)
|
|
3705
3704
|
return callback(err2);
|
|
3706
|
-
|
|
3705
|
+
fs4.writeFile(file, data, encoding, callback);
|
|
3707
3706
|
});
|
|
3708
3707
|
});
|
|
3709
3708
|
}
|
|
3710
3709
|
function outputFileSync(file, ...args) {
|
|
3711
3710
|
const dir = path3.dirname(file);
|
|
3712
|
-
if (
|
|
3713
|
-
return
|
|
3711
|
+
if (fs4.existsSync(dir)) {
|
|
3712
|
+
return fs4.writeFileSync(file, ...args);
|
|
3714
3713
|
}
|
|
3715
3714
|
mkdir.mkdirsSync(dir);
|
|
3716
|
-
|
|
3715
|
+
fs4.writeFileSync(file, ...args);
|
|
3717
3716
|
}
|
|
3718
3717
|
module2.exports = {
|
|
3719
3718
|
outputFile: u(outputFile),
|
|
@@ -3741,11 +3740,11 @@ var require_lib = __commonJS({
|
|
|
3741
3740
|
require_path_exists(),
|
|
3742
3741
|
require_remove()
|
|
3743
3742
|
);
|
|
3744
|
-
var
|
|
3745
|
-
if (Object.getOwnPropertyDescriptor(
|
|
3743
|
+
var fs4 = require("fs");
|
|
3744
|
+
if (Object.getOwnPropertyDescriptor(fs4, "promises")) {
|
|
3746
3745
|
Object.defineProperty(module2.exports, "promises", {
|
|
3747
3746
|
get() {
|
|
3748
|
-
return
|
|
3747
|
+
return fs4.promises;
|
|
3749
3748
|
}
|
|
3750
3749
|
});
|
|
3751
3750
|
}
|
|
@@ -3756,9 +3755,9 @@ var require_lib = __commonJS({
|
|
|
3756
3755
|
var require_path_exists2 = __commonJS({
|
|
3757
3756
|
"node_modules/path-exists/index.js"(exports, module2) {
|
|
3758
3757
|
"use strict";
|
|
3759
|
-
var
|
|
3758
|
+
var fs4 = require("fs");
|
|
3760
3759
|
var { promisify } = require("util");
|
|
3761
|
-
var pAccess = promisify(
|
|
3760
|
+
var pAccess = promisify(fs4.access);
|
|
3762
3761
|
module2.exports = async (path3) => {
|
|
3763
3762
|
try {
|
|
3764
3763
|
await pAccess(path3);
|
|
@@ -3769,7 +3768,7 @@ var require_path_exists2 = __commonJS({
|
|
|
3769
3768
|
};
|
|
3770
3769
|
module2.exports.sync = (path3) => {
|
|
3771
3770
|
try {
|
|
3772
|
-
|
|
3771
|
+
fs4.accessSync(path3);
|
|
3773
3772
|
return true;
|
|
3774
3773
|
} catch (_) {
|
|
3775
3774
|
return false;
|
|
@@ -4241,11 +4240,26 @@ function showLogOutput() {
|
|
|
4241
4240
|
}
|
|
4242
4241
|
|
|
4243
4242
|
// src/lsp/server.ts
|
|
4243
|
+
var fs = __toESM(require("fs"));
|
|
4244
4244
|
var Path = __toESM(require("path"));
|
|
4245
4245
|
var coc3 = __toESM(require("coc.nvim"));
|
|
4246
4246
|
var DEBUG = typeof v8debug === "object" || startedInDebugMode(process);
|
|
4247
4247
|
function languageServerCommand(context, requirements) {
|
|
4248
|
-
|
|
4248
|
+
let location = getSonarLintConfiguration().get("ls.directory");
|
|
4249
|
+
location = !location ? Path.resolve(__dirname, "../") : location;
|
|
4250
|
+
if (location) {
|
|
4251
|
+
location = coc3.workspace.expand(location);
|
|
4252
|
+
if (!fs.existsSync(location)) {
|
|
4253
|
+
logToSonarLintOutput(
|
|
4254
|
+
`Sonar can not start, invalid or non existent path was detected ${location}`
|
|
4255
|
+
);
|
|
4256
|
+
coc3.window.showWarningMessage(`Sonar binaries were not found, check SonarLint output`);
|
|
4257
|
+
return void 0;
|
|
4258
|
+
}
|
|
4259
|
+
} else {
|
|
4260
|
+
coc3.window.showWarningMessage(`Sonar binaries directory could not be resolved at all`);
|
|
4261
|
+
return void 0;
|
|
4262
|
+
}
|
|
4249
4263
|
const serverJar = Path.resolve(
|
|
4250
4264
|
location,
|
|
4251
4265
|
"server",
|
|
@@ -4704,7 +4718,7 @@ var SonarLintExtendedLanguageClient = class extends coc6.LanguageClient {
|
|
|
4704
4718
|
};
|
|
4705
4719
|
|
|
4706
4720
|
// src/util/platform.ts
|
|
4707
|
-
var
|
|
4721
|
+
var fs2 = __toESM(require("fs"));
|
|
4708
4722
|
function getPlatform() {
|
|
4709
4723
|
const platform = process.platform;
|
|
4710
4724
|
if (platform === "linux" && isAlpineLinux()) {
|
|
@@ -4715,10 +4729,10 @@ function getPlatform() {
|
|
|
4715
4729
|
function isAlpineLinux() {
|
|
4716
4730
|
let fileContent;
|
|
4717
4731
|
try {
|
|
4718
|
-
fileContent =
|
|
4732
|
+
fileContent = fs2.readFileSync("/etc/os-release", "utf-8");
|
|
4719
4733
|
} catch (error1) {
|
|
4720
4734
|
try {
|
|
4721
|
-
fileContent =
|
|
4735
|
+
fileContent = fs2.readFileSync("/usr/lib/os-release", "utf-8");
|
|
4722
4736
|
} catch (error2) {
|
|
4723
4737
|
return false;
|
|
4724
4738
|
}
|
|
@@ -4978,6 +4992,10 @@ var javaApiTooLowAlreadyLogged = false;
|
|
|
4978
4992
|
var javaServerInLightWeightModeAlreadyLogged = false;
|
|
4979
4993
|
function installClasspathListener(languageClient2) {
|
|
4980
4994
|
const extension2 = getJavaExtension();
|
|
4995
|
+
if (!extension2) {
|
|
4996
|
+
coc8.window.showWarningMessage(`Unable to find any compliant java extension installed in the coc runtime`);
|
|
4997
|
+
return;
|
|
4998
|
+
}
|
|
4981
4999
|
if (extension2?.isActive) {
|
|
4982
5000
|
if (!classpathChangeListener) {
|
|
4983
5001
|
const extensionApi = extension2.exports;
|
|
@@ -4990,11 +5008,9 @@ function installClasspathListener(languageClient2) {
|
|
|
4990
5008
|
logToSonarLintOutput(`Installed classpath listener for java`);
|
|
4991
5009
|
}
|
|
4992
5010
|
}
|
|
4993
|
-
} else {
|
|
4994
|
-
|
|
4995
|
-
|
|
4996
|
-
classpathChangeListener = void 0;
|
|
4997
|
-
}
|
|
5011
|
+
} else if (classpathChangeListener) {
|
|
5012
|
+
classpathChangeListener.dispose();
|
|
5013
|
+
classpathChangeListener = void 0;
|
|
4998
5014
|
}
|
|
4999
5015
|
}
|
|
5000
5016
|
function newServerModeChangeListener(languageClient2) {
|
|
@@ -5019,11 +5035,9 @@ function installServerModeChangeListener(languageClient2) {
|
|
|
5019
5035
|
}
|
|
5020
5036
|
logToSonarLintOutput(`Installed server mode listener for java`);
|
|
5021
5037
|
}
|
|
5022
|
-
} else {
|
|
5023
|
-
|
|
5024
|
-
|
|
5025
|
-
serverModeListener = void 0;
|
|
5026
|
-
}
|
|
5038
|
+
} else if (serverModeListener) {
|
|
5039
|
+
serverModeListener.dispose();
|
|
5040
|
+
serverModeListener = void 0;
|
|
5027
5041
|
}
|
|
5028
5042
|
}
|
|
5029
5043
|
function isJavaApiRecentEnough(apiVersion) {
|
|
@@ -5041,6 +5055,10 @@ function isJavaApiRecentEnough(apiVersion) {
|
|
|
5041
5055
|
async function getJavaConfig(languageClient2, fileUri) {
|
|
5042
5056
|
const extension2 = getJavaExtension();
|
|
5043
5057
|
try {
|
|
5058
|
+
if (!extension2) {
|
|
5059
|
+
coc8.window.showWarningMessage(`Unable to find any compliant java extension installed in the coc runtime`);
|
|
5060
|
+
return;
|
|
5061
|
+
}
|
|
5044
5062
|
const extensionApi = await extension2?.activate();
|
|
5045
5063
|
if (extensionApi && isJavaApiRecentEnough(extensionApi.apiVersion)) {
|
|
5046
5064
|
installClasspathListener(languageClient2);
|
|
@@ -5069,7 +5087,7 @@ async function getJavaConfig(languageClient2, fileUri) {
|
|
|
5069
5087
|
};
|
|
5070
5088
|
}
|
|
5071
5089
|
} catch (error) {
|
|
5072
|
-
|
|
5090
|
+
coc8.window.showErrorMessage(JSON.stringify(error));
|
|
5073
5091
|
}
|
|
5074
5092
|
}
|
|
5075
5093
|
function javaConfigDisabledInLightWeightMode() {
|
|
@@ -5082,7 +5100,11 @@ function javaConfigDisabledInLightWeightMode() {
|
|
|
5082
5100
|
return void 0;
|
|
5083
5101
|
}
|
|
5084
5102
|
function getJavaExtension() {
|
|
5085
|
-
|
|
5103
|
+
const java = coc8.extensions.getExtensionById("coc-java");
|
|
5104
|
+
if (!java || java == null || java === void 0) {
|
|
5105
|
+
return coc8.extensions.getExtensionById("coc-java-dev");
|
|
5106
|
+
}
|
|
5107
|
+
return java;
|
|
5086
5108
|
}
|
|
5087
5109
|
|
|
5088
5110
|
// src/rules/rulepanel.ts
|
|
@@ -5165,7 +5187,7 @@ function renderRuleParam(param, config) {
|
|
|
5165
5187
|
|
|
5166
5188
|
// src/cfamily/cfamily.ts
|
|
5167
5189
|
var coc10 = __toESM(require("coc.nvim"));
|
|
5168
|
-
var
|
|
5190
|
+
var fs3 = __toESM(require("fs"));
|
|
5169
5191
|
var path2 = __toESM(require("path"));
|
|
5170
5192
|
|
|
5171
5193
|
// src/commons.ts
|
|
@@ -5219,7 +5241,7 @@ function tryRelativizeToWorkspaceFolder(filePath) {
|
|
|
5219
5241
|
return [filePath, void 0];
|
|
5220
5242
|
}
|
|
5221
5243
|
async function configureCompilationDatabase() {
|
|
5222
|
-
const paths = (await coc10.workspace.findFiles(`**/compile_commands.json`)).filter((path3) =>
|
|
5244
|
+
const paths = (await coc10.workspace.findFiles(`**/compile_commands.json`)).filter((path3) => fs3.existsSync(path3.fsPath));
|
|
5223
5245
|
if (paths.length === 0) {
|
|
5224
5246
|
coc10.window.showWarningMessage(`No compilation databases were found in the workspace
|
|
5225
5247
|
|
|
@@ -5307,10 +5329,14 @@ async function runJavaServer(context) {
|
|
|
5307
5329
|
});
|
|
5308
5330
|
throw error;
|
|
5309
5331
|
}).then((requirements) => {
|
|
5310
|
-
return new Promise((resolve3,
|
|
5332
|
+
return new Promise((resolve3, reject) => {
|
|
5311
5333
|
const { command, args } = languageServerCommand(context, requirements);
|
|
5334
|
+
if (!command) {
|
|
5335
|
+
reject(void 0);
|
|
5336
|
+
return;
|
|
5337
|
+
}
|
|
5312
5338
|
logToSonarLintOutput(`Executing ${command} ${args.join(" ")}`);
|
|
5313
|
-
import_coc2.window.showInformationMessage("Sonarlint is starting...");
|
|
5339
|
+
import_coc2.window.showInformationMessage("Sonarlint server is starting...");
|
|
5314
5340
|
const process2 = ChildProcess.spawn(command, args);
|
|
5315
5341
|
process2.stderr.on("data", function(data) {
|
|
5316
5342
|
logWithPrefix(data, "[stderr]");
|
|
@@ -5496,22 +5522,22 @@ function installCustomRequestHandlers(context) {
|
|
|
5496
5522
|
);
|
|
5497
5523
|
languageClient.onNotification(
|
|
5498
5524
|
ShowSonarLintOutputNotification.type,
|
|
5499
|
-
() => coc11.commands.executeCommand(Commands.SHOW_SONARLINT_OUTPUT)
|
|
5525
|
+
() => void coc11.commands.executeCommand(Commands.SHOW_SONARLINT_OUTPUT)
|
|
5500
5526
|
);
|
|
5501
5527
|
languageClient.onNotification(
|
|
5502
5528
|
OpenJavaHomeSettingsNotification.type,
|
|
5503
|
-
() => coc11.commands.executeCommand(Commands.OPEN_SETTINGS, JAVA_HOME_CONFIG)
|
|
5529
|
+
() => void coc11.commands.executeCommand(Commands.OPEN_SETTINGS, JAVA_HOME_CONFIG)
|
|
5504
5530
|
);
|
|
5505
5531
|
languageClient.onNotification(
|
|
5506
5532
|
OpenPathToNodeSettingsNotification.type,
|
|
5507
|
-
() => coc11.commands.executeCommand(
|
|
5533
|
+
() => void coc11.commands.executeCommand(
|
|
5508
5534
|
Commands.OPEN_SETTINGS,
|
|
5509
5535
|
"sonarlint.pathToNodeExecutable"
|
|
5510
5536
|
)
|
|
5511
5537
|
);
|
|
5512
5538
|
languageClient.onNotification(
|
|
5513
5539
|
BrowseToNotification.type,
|
|
5514
|
-
(browseTo) => coc11.commands.executeCommand(
|
|
5540
|
+
(browseTo) => void coc11.commands.executeCommand(
|
|
5515
5541
|
Commands.OPEN_BROWSER,
|
|
5516
5542
|
coc11.Uri.parse(browseTo)
|
|
5517
5543
|
)
|