213
const home = '~';
214
export function shorten(paths: string[], defaultPathSeparator: string = sep): string[] {
216
>
217
>
// for every path
218
>
let match = false;
219
>
for (let pathIndex = 0; pathIndex < paths.length; pathIndex++) {
220
>
let pathSeparator = defaultPathSeparator;
221
>
const originalPath = paths[pathIndex];
222
>
223
>
if (originalPath === '') {
224
>
shortenedPaths[pathIndex] = `.${pathSeparator}`;
225
>
continue;
226
>
}
227
>
228
>
if (!originalPath) {
229
>
shortenedPaths[pathIndex] = originalPath;
230
>
continue;
231
>
}
232
>
233
>
match = true;
234
>
235
>
// trim for now and concatenate unc path (e.g. \\network) or root path (/etc, ~/etc) later
236
>
let prefix = '';
237
>
let trimmedPath = originalPath;
238
>
if (urlSchemaRegexp.test(trimmedPath)) {
239
>
prefix = trimmedPath.substr(0, trimmedPath.indexOf('//') + 2);
240
>
trimmedPath = trimmedPath.substr(trimmedPath.indexOf('//') + 2);
241
>
pathSeparator = '/';
242
>
} else if (trimmedPath.indexOf(unc) === 0) {
243
prefix = trimmedPath.substr(0, trimmedPath.indexOf(unc) + unc.length);
244
trimmedPath = trimmedPath.substr(trimmedPath.indexOf(unc) + unc.length);
246
>
prefix = trimmedPath.substr(0, trimmedPath.indexOf(pathSeparator) + pathSeparator.length);
247
>
trimmedPath = trimmedPath.substr(trimmedPath.indexOf(pathSeparator) + pathSeparator.length);
248
>
} else if (trimmedPath.indexOf(home) === 0) {
249
>
prefix = trimmedPath.substr(0, trimmedPath.indexOf(home) + home.length);
250
>
trimmedPath = trimmedPath.substr(trimmedPath.indexOf(home) + home.length);
251
>
}
252
>
253
>
// pick the first shortest subpath found
254
>
const segments: string[] = trimmedPath.split(pathSeparator);
255
>
for (let subpathLength = 1; match && subpathLength <= segments.length; subpathLength++) {
256
>
for (let start = segments.length - subpathLength; match && start >= 0; start--) {
257
>
match = false;
258
>
let subpath = segments.slice(start, start + subpathLength).join(pathSeparator);
259
>
260
>
// that is unique to any other path
261
>
for (let otherPathIndex = 0; !match && otherPathIndex < paths.length; otherPathIndex++) {
262
>
263
>
// suffix subpath treated specially as we consider no match 'x' and 'x/...'
264
>
if (otherPathIndex !== pathIndex && paths[otherPathIndex] && paths[otherPathIndex].indexOf(subpath) > -1) {
265
>
const isSubpathEnding: boolean = (start + subpathLength === segments.length);
266
>
267
>
// Adding separator as prefix for subpath, such that 'endsWith(src, trgt)' considers subpath as directory name instead of plain string.
268
>
// prefix is not added when either subpath is root directory or path[otherPathIndex] does not have multiple directories.
269
>
const subpathWithSep: string = (start > 0 && paths[otherPathIndex].indexOf(pathSeparator) > -1) ? pathSeparator + subpath : subpath;
270
>
const isOtherPathEnding: boolean = paths[otherPathIndex].endsWith(subpathWithSep);
271
>
272
>
match = !isSubpathEnding || isOtherPathEnding;
273
>
}
274
>
}
275
>
276
>
// found unique subpath
277
>
if (!match) {
278
>
let result = '';
279
>
280
>
// preserve disk drive or root prefix
281
>
if (segments[0].endsWith(':') || prefix !== '') {
282
>
if (start === 1) {
283
>
// extend subpath to include disk drive prefix
284
>
start = 0;
285
>
subpathLength++;
286
>
subpath = segments[0] + pathSeparator + subpath;
287
>
}
288
>
289
>
if (start > 0) {
290
>
result = segments[0] + pathSeparator;
291
>
}
292
>
293
>
result = prefix + result;
294
>
}
295
>
296
>
// add ellipsis at the beginning if needed
297
>
if (start > 0) {
298
>
result = result + ellipsis + pathSeparator;
299
>
}
300
>
301
>
result = result + subpath;
302
>
303
>
// add ellipsis at the end if needed
304
>
if (start + subpathLength < segments.length) {
305
>
// If the last segment is empty, preserve the trailing slash.
306
>
if (start + subpathLength === segments.length - 1 && segments[segments.length - 1] === '') {
307
>
result = result + pathSeparator;
308
>
} else {
309
>
result = result + pathSeparator + ellipsis;
310
>
}
311
>
}
312
>
313
>
shortenedPaths[pathIndex] = result;
314
>
}
315
>
}
316
>
}
317
>
318
>
if (match) {
319
>
shortenedPaths[pathIndex] = originalPath; // use original path if no unique subpaths found
320
>
}
321
>
}
322
>
323
>
return shortenedPaths;
324
>
}
325
326
export interface ISeparator {