@vscode/vsce 2.30.0 → 2.30.1-0

package/out/main.js

@@ -77,6 +77,7 @@ module.exports = function (argv) {
     commander_1.default
         .command('ls')
         .description('Lists all the files that will be published/packaged')
+        .option('--tree', 'Prints the files in a tree format', false)
         .option('--yarn', 'Use yarn instead of npm (default inferred from presence of yarn.lock or .yarnrc)')
         .option('--no-yarn', 'Use npm instead of yarn (default inferred from absence of yarn.lock or .yarnrc)')
         .option('--packagedDependencies <path>', 'Select packages that should be published only (includes dependencies)', (val, all) => (all ? all.concat(val) : [val]), undefined)
@@ -84,7 +85,7 @@ module.exports = function (argv) {
         // default must remain undefined for dependencies or we will fail to load defaults from package.json
         .option('--dependencies', 'Enable dependency detection via npm or yarn', undefined)
         .option('--no-dependencies', 'Disable dependency detection via npm or yarn', undefined)
-        .action(({ yarn, packagedDependencies, ignoreFile, dependencies }) => main((0, package_1.ls)({ useYarn: yarn, packagedDependencies, ignoreFile, dependencies })));
+        .action(({ tree, yarn, packagedDependencies, ignoreFile, dependencies }) => main((0, package_1.ls)({ tree, useYarn: yarn, packagedDependencies, ignoreFile, dependencies })));
     commander_1.default
         .command('package [version]')
         .alias('pack')

package/out/package.js

@@ -1346,7 +1346,7 @@ async function pack(options = {}) {
     const cwd = options.cwd || process.cwd();
     const manifest = await readManifest(cwd);
     const files = await collect(manifest, options);
-    printPackagedFiles(files, cwd, manifest, options);
+    await printPackagedFiles(files, cwd, manifest, options);
     if (options.version && !(options.updatePackageJson ?? true)) {
         manifest.version = options.version;
     }
@@ -1393,17 +1393,8 @@ async function packageCommand(options = {}) {
         await signPackage(packagePath, options.signTool);
     }
     const stats = await fs.promises.stat(packagePath);
-    let size = 0;
-    let unit = '';
-    if (stats.size > 1048576) {
-        size = Math.round(stats.size / 10485.76) / 100;
-        unit = 'MB';
-    }
-    else {
-        size = Math.round(stats.size / 10.24) / 100;
-        unit = 'KB';
-    }
-    util.log.done(`Packaged: ${packagePath} (${files.length} files, ${size}${unit})`);
+    const packageSize = util.bytesToString(stats.size);
+    util.log.done(`Packaged: ${packagePath} ` + chalk_1.default.bold(`(${files.length} files, ${packageSize})`));
 }
 exports.packageCommand = packageCommand;
 /**
@@ -1411,7 +1402,7 @@ exports.packageCommand = packageCommand;
  */
 async function listFiles(options = {}) {
     const cwd = options.cwd ?? process.cwd();
-    const manifest = await readManifest(cwd);
+    const manifest = options.manifest ?? await readManifest(cwd);
     if (options.prepublish) {
         await prepublish(cwd, manifest, options.useYarn);
     }
@@ -1419,27 +1410,33 @@ async function listFiles(options = {}) {
 }
 exports.listFiles = listFiles;
 /**
- * Lists the files included in the extension's package. Runs prepublish.
+ * Lists the files included in the extension's package.
  */
 async function ls(options = {}) {
-    const files = await listFiles({ ...options, prepublish: true });
-    for (const file of files) {
-        console.log(`${file}`);
+    const cwd = process.cwd();
+    const manifest = await readManifest(cwd);
+    const files = await listFiles({ ...options, cwd, manifest });
+    if (options.tree) {
+        const printableFileStructure = await util.generateFileStructureTree(getDefaultPackageName(manifest, options), files.map(f => ({ origin: f, tree: f })));
+        console.log(printableFileStructure.join('\n'));
+    }
+    else {
+        console.log(files.join('\n'));
     }
 }
 exports.ls = ls;
 /**
  * Prints the packaged files of an extension.
  */
-function printPackagedFiles(files, cwd, manifest, options) {
+async function printPackagedFiles(files, cwd, manifest, options) {
     // Warn if the extension contains a lot of files
     const jsFiles = files.filter(f => /\.js$/i.test(f.path));
     if (files.length > 5000 || jsFiles.length > 100) {
-        let message = '\n';
+        let message = '';
         message += `This extension consists of ${chalk_1.default.bold(String(files.length))} files, out of which ${chalk_1.default.bold(String(jsFiles.length))} are JavaScript files. `;
         message += `For performance reasons, you should bundle your extension: ${chalk_1.default.underline('https://aka.ms/vscode-bundle-extension')}. `;
         message += `You should also exclude unnecessary files by adding them to your .vscodeignore: ${chalk_1.default.underline('https://aka.ms/vscode-vscodeignore')}.\n`;
-        console.log(message);
+        util.log.warn(message);
     }
     // Warn if the extension does not have a .vscodeignore file or a files property in package.json
     if (!options.ignoreFile && !manifest.files) {
@@ -1447,20 +1444,27 @@ function printPackagedFiles(files, cwd, manifest, options) {
         if (!hasDeaultIgnore) {
             let message = '';
             message += `Neither a ${chalk_1.default.bold('.vscodeignore')} file nor a ${chalk_1.default.bold('"files"')} property in package.json was found. `;
-            message += `To ensure only necessary files are included in your extension package, `;
-            message += `add a .vscodeignore file or specify the "files" property in package.json. More info: ${chalk_1.default.underline('https://aka.ms/vscode-vscodeignore')}`;
+            message += `To ensure only necessary files are included in your extension, `;
+            message += `add a .vscodeignore file or specify the "files" property in package.json. More info: ${chalk_1.default.underline('https://aka.ms/vscode-vscodeignore')}\n`;
             util.log.warn(message);
         }
     }
     // Print the files included in the package
-    const printableFileStructure = util.generateFileStructureTree(getDefaultPackageName(manifest, options), files.map(f => f.path), 35);
+    const printableFileStructure = await util.generateFileStructureTree(getDefaultPackageName(manifest, options), files.map(f => ({
+        // File path relative to the extension root
+        origin: f.path.startsWith('extension/') ? f.path.substring(10) : f.path,
+        // File path in the VSIX
+        tree: f.path
+    })), 35 // Print up to 35 files/folders
+    );
     let message = '';
     message += chalk_1.default.bold.blue(`Files included in the VSIX:\n`);
     message += printableFileStructure.join('\n');
+    // If not all files have been printed, mention how all files can be printed
     if (files.length + 1 > printableFileStructure.length) {
-        // If not all files have been printed, mention how all files can be printed
-        message += `\n\n=> Run ${chalk_1.default.bold('vsce ls')} to see a list of all included files.\n`;
+        message += `\n\n=> Run ${chalk_1.default.bold('vsce ls --tree')} to see all included files.`;
     }
+    message += '\n';
     util.log.info(message);
 }
 exports.printPackagedFiles = printPackagedFiles;

package/out/util.js

@@ -1,10 +1,34 @@
 "use strict";
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateFileStructureTree = exports.patchOptionsWithManifest = exports.log = exports.sequence = exports.CancellationToken = exports.isCancelledError = exports.nonnull = exports.flatten = exports.chain = exports.normalize = exports.getPublicGalleryAPI = exports.getSecurityRolesAPI = exports.getGalleryAPI = exports.getHubUrl = exports.getMarketplaceUrl = exports.getPublishedUrl = exports.read = void 0;
+exports.generateFileStructureTree = exports.bytesToString = exports.patchOptionsWithManifest = exports.log = exports.sequence = exports.CancellationToken = exports.isCancelledError = exports.nonnull = exports.flatten = exports.chain = exports.normalize = exports.getPublicGalleryAPI = exports.getSecurityRolesAPI = exports.getGalleryAPI = exports.getHubUrl = exports.getMarketplaceUrl = exports.getPublishedUrl = exports.read = void 0;
 const util_1 = require("util");
+const fs = __importStar(require("fs"));
 const read_1 = __importDefault(require("read"));
 const WebApi_1 = require("azure-devops-node-api/WebApi");
 const GalleryApi_1 = require("azure-devops-node-api/GalleryApi");
@@ -166,82 +190,169 @@ function patchOptionsWithManifest(options, manifest) {
     }
 }
 exports.patchOptionsWithManifest = patchOptionsWithManifest;
-function generateFileStructureTree(rootFolder, filePaths, maxPrint = Number.MAX_VALUE) {
+function bytesToString(bytes) {
+    let size = 0;
+    let unit = '';
+    if (bytes > 1048576) {
+        size = Math.round(bytes / 10485.76) / 100;
+        unit = 'MB';
+    }
+    else {
+        size = Math.round(bytes / 10.24) / 100;
+        unit = 'KB';
+    }
+    return `${size} ${unit}`;
+}
+exports.bytesToString = bytesToString;
+const FOLDER_SIZE_KEY = "/__FOlDER_SIZE__\\";
+const FOLDER_FILES_TOTAL_KEY = "/__FOLDER_CHILDREN__\\";
+const FILE_SIZE_WARNING_THRESHOLD = 0.85;
+const FILE_SIZE_LARGE_THRESHOLD = 0.2;
+async function generateFileStructureTree(rootFolder, filePaths, printLinesLimit = Number.MAX_VALUE) {
     const folderTree = {};
     const depthCounts = [];
     // Build a tree structure from the file paths
-    filePaths.forEach(filePath => {
-        const parts = filePath.split('/');
+    // Store the file size in the leaf node and the folder size in the folder node
+    // Store the number of children in the folder node
+    for (const filePath of filePaths) {
+        const parts = filePath.tree.split('/');
         let currentLevel = folderTree;
         parts.forEach((part, depth) => {
+            const isFile = depth === parts.length - 1;
+            // Create the node if it doesn't exist
             if (!currentLevel[part]) {
-                currentLevel[part] = depth === parts.length - 1 ? null : {};
+                if (isFile) {
+                    // The file size is stored in the leaf node, 
+                    currentLevel[part] = 0;
+                }
+                else {
+                    // The folder size is stored in the folder node
+                    currentLevel[part] = {};
+                    currentLevel[part][FOLDER_SIZE_KEY] = 0;
+                    currentLevel[part][FOLDER_FILES_TOTAL_KEY] = 0;
+                }
+                // Count the number of items at each depth
                 if (depthCounts.length <= depth) {
                     depthCounts.push(0);
                 }
                 depthCounts[depth]++;
             }
             currentLevel = currentLevel[part];
+            // Count the total number of children in the nested folders
+            if (!isFile) {
+                currentLevel[FOLDER_FILES_TOTAL_KEY]++;
+            }
         });
-    });
-    // Get max depth
+    }
+    ;
+    // Get max depth depending on the maximum number of lines allowed to print
     let currentDepth = 0;
-    let countUpToCurrentDepth = depthCounts[0];
+    let countUpToCurrentDepth = depthCounts[0] + 1 /* root folder */;
     for (let i = 1; i < depthCounts.length; i++) {
-        if (countUpToCurrentDepth + depthCounts[i] > maxPrint) {
+        if (countUpToCurrentDepth + depthCounts[i] > printLinesLimit) {
             break;
         }
         currentDepth++;
         countUpToCurrentDepth += depthCounts[i];
     }
     const maxDepth = currentDepth;
-    let message = [];
-    // Helper function to print the tree
-    const printTree = (tree, depth, prefix) => {
+    // Get all file sizes
+    const fileSizes = await Promise.all(filePaths.map(async (filePath) => {
+        try {
+            const stats = await fs.promises.stat(filePath.origin);
+            return [stats.size, filePath.tree];
+        }
+        catch (error) {
+            return [0, filePath.origin];
+        }
+    }));
+    // Store all file sizes in the tree
+    let totalFileSizes = 0;
+    fileSizes.forEach(([size, filePath]) => {
+        totalFileSizes += size;
+        const parts = filePath.split('/');
+        let currentLevel = folderTree;
+        parts.forEach(part => {
+            if (typeof currentLevel[part] === 'number') {
+                currentLevel[part] = size;
+            }
+            else if (currentLevel[part]) {
+                currentLevel[part][FOLDER_SIZE_KEY] += size;
+            }
+            currentLevel = currentLevel[part];
+        });
+    });
+    let output = [];
+    output.push(chalk_1.default.bold(rootFolder));
+    output.push(...createTreeOutput(folderTree, maxDepth, totalFileSizes));
+    for (const [size, filePath] of fileSizes) {
+        if (size > FILE_SIZE_WARNING_THRESHOLD * totalFileSizes) {
+            output.push(`\nThe file ${filePath} is ${chalk_1.default.red('large')} (${bytesToString(size)})`);
+            break;
+        }
+    }
+    return output;
+}
+exports.generateFileStructureTree = generateFileStructureTree;
+function createTreeOutput(fileSystem, maxDepth, totalFileSizes) {
+    const getColorFromSize = (size) => {
+        if (size > FILE_SIZE_WARNING_THRESHOLD * totalFileSizes) {
+            return chalk_1.default.red;
+        }
+        else if (size > FILE_SIZE_LARGE_THRESHOLD * totalFileSizes) {
+            return chalk_1.default.yellow;
+        }
+        else {
+            return chalk_1.default.grey;
+        }
+    };
+    const createFileOutput = (prefix, fileName, fileSize) => {
+        let fileSizeColored = '';
+        if (fileSize > 0) {
+            const fileSizeString = `[${bytesToString(fileSize)}]`;
+            fileSizeColored = getColorFromSize(fileSize)(fileSizeString);
+        }
+        return `${prefix}${fileName} ${fileSizeColored}`;
+    };
+    const createFolderOutput = (prefix, filesCount, folderSize, folderName, depth) => {
+        if (depth < maxDepth) {
+            // Max depth is not reached, print only the folder
+            // as children will be printed
+            return prefix + chalk_1.default.bold(`${folderName}/`);
+        }
+        // Max depth is reached, print the folder name and additional metadata
+        // as children will not be printed
+        const folderSizeString = bytesToString(folderSize);
+        const folder = chalk_1.default.bold(`${folderName}/`);
+        const numFilesString = chalk_1.default.green(`(${filesCount} ${filesCount === 1 ? 'file' : 'files'})`);
+        const folderSizeColored = getColorFromSize(folderSize)(`[${folderSizeString}]`);
+        return `${prefix}${folder} ${numFilesString} ${folderSizeColored}`;
+    };
+    const createTreeLayerOutput = (tree, depth, prefix, path) => {
         // Print all files before folders
-        const sortedFolderKeys = Object.keys(tree).filter(key => tree[key] !== null).sort();
-        const sortedFileKeys = Object.keys(tree).filter(key => tree[key] === null).sort();
-        const sortedKeys = [...sortedFileKeys, ...sortedFolderKeys];
+        const sortedFolderKeys = Object.keys(tree).filter(key => typeof tree[key] !== 'number').sort();
+        const sortedFileKeys = Object.keys(tree).filter(key => typeof tree[key] === 'number').sort();
+        const sortedKeys = [...sortedFileKeys, ...sortedFolderKeys].filter(key => key !== FOLDER_SIZE_KEY && key !== FOLDER_FILES_TOTAL_KEY);
+        const output = [];
         for (let i = 0; i < sortedKeys.length; i++) {
             const key = sortedKeys[i];
             const isLast = i === sortedKeys.length - 1;
             const localPrefix = prefix + (isLast ? '└─ ' : '├─ ');
             const childPrefix = prefix + (isLast ? '   ' : '│  ');
-            if (tree[key] === null) {
+            if (typeof tree[key] === 'number') {
                 // It's a file
-                message.push(localPrefix + key);
+                output.push(createFileOutput(localPrefix, key, tree[key]));
             }
             else {
                 // It's a folder
+                output.push(createFolderOutput(localPrefix, tree[key][FOLDER_FILES_TOTAL_KEY], tree[key][FOLDER_SIZE_KEY], key, depth));
                 if (depth < maxDepth) {
-                    // maxdepth is not reached, print the folder and its children
-                    message.push(localPrefix + chalk_1.default.bold(`${key}/`));
-                    printTree(tree[key], depth + 1, childPrefix);
+                    output.push(...createTreeLayerOutput(tree[key], depth + 1, childPrefix, path + key + '/'));
                 }
-                else {
-                    // max depth is reached, print the folder but not its children
-                    const filesCount = countFiles(tree[key]);
-                    message.push(localPrefix + chalk_1.default.bold(`${key}/`) + chalk_1.default.green(` (${filesCount} ${filesCount === 1 ? 'file' : 'files'})`));
-                }
-            }
-        }
-    };
-    // Helper function to count the number of files in a tree
-    const countFiles = (tree) => {
-        let filesCount = 0;
-        for (const key in tree) {
-            if (tree[key] === null) {
-                filesCount++;
-            }
-            else {
-                filesCount += countFiles(tree[key]);
             }
         }
-        return filesCount;
+        return output;
     };
-    message.push(chalk_1.default.bold(rootFolder));
-    printTree(folderTree, 0, '');
-    return message;
+    return createTreeLayerOutput(fileSystem, 0, '', '');
 }
-exports.generateFileStructureTree = generateFileStructureTree;
 //# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vscode/vsce",
-	"version": "2.30.0",
+	"version": "2.30.1-0",
 	"description": "VS Code Extensions Manager",
 	"repository": {
 		"type": "git",