analyze-codebase 1.2.2 → 1.3.1

package/dist/analyze/index.js

@@ -1,15 +1,96 @@
 "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.analyzeCodebase = void 0;
 const chalk_1 = __importDefault(require("chalk"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const path = __importStar(require("path"));
 const file_1 = require("../analyze/file");
-const file_2 = require("../utils/file");
 const output_1 = require("../utils/output");
+const progress_1 = require("../utils/progress");
+const spinner_1 = require("../utils/spinner");
+const cancellation_1 = require("../utils/cancellation");
+const collectFiles = async (directory, extensions, exclude) => {
+    const patterns = [];
+    const ignorePatterns = [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/coverage/**",
+        "**/.git/**",
+        "**/.next/**",
+        "**/public/**",
+        "**/test/**",
+        "**/tests/**",
+        "**/mocks/**",
+    ];
+    if (exclude) {
+        ignorePatterns.push(...exclude.map((ex) => `**/${ex}/**`));
+    }
+    if (extensions && extensions.length > 0) {
+        patterns.push(...extensions.map((ext) => `**/*${ext}`), "**/*" // Also include files without extensions
+        );
+    }
+    else {
+        patterns.push("**/*");
+    }
+    const files = await (0, fast_glob_1.default)(patterns, {
+        cwd: directory,
+        ignore: ignorePatterns,
+        absolute: true,
+        onlyFiles: true,
+        dot: false,
+    });
+    // Filter by extension if specified
+    if (extensions && extensions.length > 0) {
+        return files.filter((file) => {
+            const ext = path.extname(file);
+            return extensions.includes(ext);
+        });
+    }
+    return files;
+};
+const processFile = (filePath, output, fileNameCases) => {
+    const { fileNameCase } = (0, file_1.analyzeFile)(filePath, output);
+    if (fileNameCases[fileNameCase] !== undefined)
+        fileNameCases[fileNameCase] += 1;
+    else
+        fileNameCases[fileNameCase] = 1;
+};
 const analyzeCodebase = async (options) => {
     const start = Date.now();
+    const cancellationToken = new cancellation_1.CancellationToken();
+    const spinner = (0, spinner_1.createSpinner)("🔍 Discovering files...");
+    // Cleanup on cancellation
+    cancellationToken.onCancel(() => {
+        spinner.stop();
+        console.log(chalk_1.default.yellow("\n\n⚠️  Cancellation requested. Cleaning up...\n"));
+    });
     const fileNameCases = {};
     const output = {
         Physical: 0,
@@ -22,29 +103,110 @@ const analyzeCodebase = async (options) => {
         Empty: 0,
         ToDo: 0,
     };
-    console.log(chalk_1.default.bold(`\n\nAnalyzing codebase in ${chalk_1.default.cyan(options.directory)} ${(options === null || options === void 0 ? void 0 : options.framework) ? `framework: ${chalk_1.default.cyan(options.framework)}` : ""}\n`));
-    let fileCount = 0;
-    await (0, file_2.traverseDirectory)({
-        extensions: options.extensions,
-        directory: options.directory,
-        exclude: options.exclude,
-        checkFileNames: options.checkFileNames,
-        onFile: (filePath) => {
-            fileCount++;
-            const { fileNameCase } = (0, file_1.analyzeFile)(filePath, output);
-            if (fileNameCases[fileNameCase] !== undefined)
-                fileNameCases[fileNameCase] += 1;
-            else
-                fileNameCases[fileNameCase] = 0;
-        },
-    });
-    await (0, output_1.logOutput)({
-        fileCount,
-        fileNameCases,
-        options,
-        output,
-    });
-    const totalSecond = ((Date.now() - start) / 1000).toFixed(2);
-    console.log(chalk_1.default.bold(`Time taken: ${chalk_1.default.yellow(totalSecond)}s\n`));
+    let progressBar = null;
+    try {
+        // Collect all files first
+        spinner.update("🔍 Scanning directory structure...");
+        const files = await collectFiles(options.directory, options.extensions, options.exclude);
+        spinner.succeed(`✅ Found ${files.length} files to analyze`);
+        if (files.length === 0) {
+            await (0, output_1.logOutput)({
+                fileCount: 0,
+                fileNameCases: {},
+                options,
+                output,
+                duration: (Date.now() - start) / 1000,
+            });
+            return;
+        }
+        // Create progress bar
+        const showProgress = options.showProgress !== false;
+        progressBar = showProgress
+            ? new progress_1.ProgressBar({ total: files.length })
+            : null;
+        // Cleanup progress bar on cancellation
+        cancellationToken.onCancel(() => {
+            progressBar === null || progressBar === void 0 ? void 0 : progressBar.stop();
+        });
+        // Process files with optimized concurrency
+        // For file I/O operations, optimal concurrency is 20-30 to avoid I/O contention
+        // Too high concurrency can actually slow things down due to disk I/O bottlenecks
+        const fileCount = files.length;
+        // Optimal concurrency for file I/O: 20-30 is usually the sweet spot
+        const defaultConcurrency = fileCount > 500 ? 30 : fileCount > 100 ? 25 : 20;
+        const maxConcurrency = options.maxConcurrency || defaultConcurrency;
+        if (maxConcurrency > 1) {
+            // Parallel processing
+            const chunks = [];
+            for (let i = 0; i < files.length; i += maxConcurrency) {
+                chunks.push(files.slice(i, i + maxConcurrency));
+            }
+            for (const chunk of chunks) {
+                // Check for cancellation before processing each chunk
+                if (cancellationToken.isCancelled()) {
+                    progressBar === null || progressBar === void 0 ? void 0 : progressBar.stop();
+                    throw new Error("Operation cancelled by user");
+                }
+                // Use Promise.allSettled to handle cancellation better
+                const results = await Promise.allSettled(chunk.map(async (filePath) => {
+                    if (cancellationToken.isCancelled()) {
+                        throw new Error("Operation cancelled by user");
+                    }
+                    if (options.checkFileNames || options.checkFileContent) {
+                        processFile(filePath, output, fileNameCases);
+                    }
+                    progressBar === null || progressBar === void 0 ? void 0 : progressBar.update(1);
+                }));
+                // Check if any promise was cancelled
+                const cancelled = results.some((result) => {
+                    var _a;
+                    return result.status === "rejected" &&
+                        ((_a = result.reason) === null || _a === void 0 ? void 0 : _a.message) === "Operation cancelled by user";
+                });
+                if (cancelled || cancellationToken.isCancelled()) {
+                    progressBar === null || progressBar === void 0 ? void 0 : progressBar.stop();
+                    throw new Error("Operation cancelled by user");
+                }
+            }
+        }
+        else {
+            // Sequential processing
+            for (const filePath of files) {
+                if (cancellationToken.isCancelled()) {
+                    progressBar === null || progressBar === void 0 ? void 0 : progressBar.stop();
+                    throw new Error("Operation cancelled by user");
+                }
+                if (options.checkFileNames || options.checkFileContent) {
+                    processFile(filePath, output, fileNameCases);
+                }
+                progressBar === null || progressBar === void 0 ? void 0 : progressBar.update(1);
+            }
+        }
+        if (cancellationToken.isCancelled()) {
+            progressBar === null || progressBar === void 0 ? void 0 : progressBar.stop();
+            throw new Error("Operation cancelled by user");
+        }
+        progressBar === null || progressBar === void 0 ? void 0 : progressBar.complete();
+        const duration = (Date.now() - start) / 1000;
+        await (0, output_1.logOutput)({
+            fileCount,
+            fileNameCases,
+            options,
+            output,
+            duration,
+            exportFormat: options.exportFormat,
+            exportPath: options.exportPath,
+        });
+    }
+    catch (error) {
+        spinner.stop();
+        progressBar === null || progressBar === void 0 ? void 0 : progressBar.stop();
+        if ((error === null || error === void 0 ? void 0 : error.message) === "Operation cancelled by user" || cancellationToken.isCancelled()) {
+            console.log(chalk_1.default.yellow("\n\n✅ Analysis cancelled by user\n"));
+            process.exit(130); // Standard exit code for SIGINT
+        }
+        spinner.fail(`❌ Error during analysis: ${error}`);
+        throw error;
+    }
 };
 exports.analyzeCodebase = analyzeCodebase;

package/dist/index.js

@@ -1,37 +1,224 @@
 #!/usr/bin/env node
 "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.mergeOptions = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const commander_1 = require("commander");
 const runner_1 = __importDefault(require("./runner"));
+const i18n_1 = require("./analyze/i18n");
+const config_1 = require("./utils/config");
+const boxen_1 = __importDefault(require("boxen"));
 chalk_1.default.level = 3;
+/**
+ * Calculates optimal concurrency based on system resources and project size
+ * For large projects, uses higher concurrency for better performance
+ */
+const calculateOptimalConcurrency = () => {
+    // Get CPU count (default to 4 if unavailable)
+    const cpuCount = require("os").cpus().length || 4;
+    // For large projects, use more aggressive concurrency
+    // Base: 2x CPU cores, but cap at reasonable limits
+    // This allows 50-100+ concurrent operations on modern machines
+    const baseConcurrency = Math.max(cpuCount * 2, 20);
+    // Cap at 200 to prevent overwhelming the system
+    return Math.min(baseConcurrency, 200);
+};
+// Merge config with CLI options (CLI options take precedence)
+const mergeOptions = (config, cliOptions) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return {
+        directory: cliOptions.directory || "",
+        framework: cliOptions.framework || (config === null || config === void 0 ? void 0 : config.framework),
+        extensions: ((_a = cliOptions.extensions) === null || _a === void 0 ? void 0 : _a.length)
+            ? cliOptions.extensions
+            : config === null || config === void 0 ? void 0 : config.extensions,
+        exclude: ((_b = cliOptions.exclude) === null || _b === void 0 ? void 0 : _b.length) ? cliOptions.exclude : config === null || config === void 0 ? void 0 : config.exclude,
+        checkFileNames: cliOptions.checkFileNames !== undefined
+            ? cliOptions.checkFileNames
+            : (_c = config === null || config === void 0 ? void 0 : config.checkFileNames) !== null && _c !== void 0 ? _c : true,
+        checkFileContent: cliOptions.checkFileContent !== undefined
+            ? cliOptions.checkFileContent
+            : (_d = config === null || config === void 0 ? void 0 : config.checkFileContent) !== null && _d !== void 0 ? _d : true,
+        writeJsonOutput: cliOptions.writeJsonOutput !== undefined
+            ? cliOptions.writeJsonOutput
+            : (_e = config === null || config === void 0 ? void 0 : config.writeJsonOutput) !== null && _e !== void 0 ? _e : false,
+        showProgress: (_f = config === null || config === void 0 ? void 0 : config.showProgress) !== null && _f !== void 0 ? _f : true,
+        parallel: (_g = config === null || config === void 0 ? void 0 : config.parallel) !== null && _g !== void 0 ? _g : true,
+        maxConcurrency: (_h = config === null || config === void 0 ? void 0 : config.maxConcurrency) !== null && _h !== void 0 ? _h : calculateOptimalConcurrency(),
+    };
+};
+exports.mergeOptions = mergeOptions;
 commander_1.program
-    .arguments("<directory>")
-    .description("Analyze the specified directory")
+    .name("analyze-codebase")
+    .description("📊 A powerful CLI tool for analyzing codebase structure, naming conventions, and code quality")
+    .version("1.3.1")
+    .arguments("[directory]")
     .option("-f, --framework <framework>", "Specify the framework")
     .option("-e, --extensions <extensions...>", "Specify the extensions", (value, previous) => previous.concat(value), [])
     .option("-exc, --exclude <exclude...>", "Specify the exclude", (value, previous) => previous.concat(value), [])
     .option("--checkFileNames [checkFileNames]", "Check file names", parseBoolean)
-    .option("--checkFileContent [checkFileContent]", "Check directories", parseBoolean)
+    .option("--checkFileContent [checkFileContent]", "Check file content", parseBoolean)
     .option("-w, --writeJsonOutput [writeJsonOutput]", "Write json output", parseBoolean)
-    .action((directory, options) => {
-    var _a, _b, _c;
-    if (options.checkFileNames === false &&
-        options.checkFileContent === false) {
-        return console.error(chalk_1.default.red(`\nError: You must specify ${chalk_1.default.yellow("true")} at least one of the following options: ${chalk_1.default.yellow("--checkFileNames")}, ${chalk_1.default.yellow("--checkFileContent")}\n`));
+    .option("--i18n-file <i18nFile>", "Check for unused translation keys in the specified i18n JSON file (e.g., messages/en.json)")
+    .option("--watch", "Watch mode: automatically re-analyze on file changes")
+    .option("--no-progress", "Disable progress bar")
+    .option("--max-concurrency <number>", "Max concurrent file processing (default: auto, up to 200 for large projects)", parseInt)
+    .option("--export <format>", "Export format: json, csv, or html", "json")
+    .option("--output <path>", "Output path for export")
+    .action(async (directory = ".", options) => {
+    try {
+        // Load config file
+        const config = await (0, config_1.loadConfig)(directory);
+        if (config) {
+            const configPath = await Promise.resolve().then(() => __importStar(require("./utils/config"))).then((m) => m.findConfigFile(directory));
+            if (configPath) {
+                (0, config_1.displayConfigInfo)(configPath);
+            }
+        }
+        // If i18n-file is specified, run i18n analysis instead
+        if (options.i18nFile) {
+            try {
+                await (0, i18n_1.analyzeAndRemoveUnusedKeys)({
+                    directory,
+                    i18nFile: options.i18nFile,
+                    extensions: options.extensions,
+                    exclude: options.exclude,
+                    maxConcurrency: options.maxConcurrency,
+                });
+                return;
+            }
+            catch (error) {
+                console.error(chalk_1.default.red(`\nError during i18n analysis: ${error}\n`));
+                process.exit(1);
+            }
+        }
+        // Watch mode
+        if (options.watch) {
+            const { startWatchMode } = await Promise.resolve().then(() => __importStar(require("./utils/watch")));
+            await startWatchMode(directory, options, config);
+            return;
+        }
+        const mergedOptions = (0, exports.mergeOptions)(config, {
+            ...options,
+            directory,
+        });
+        if (mergedOptions.checkFileNames === false &&
+            mergedOptions.checkFileContent === false) {
+            return console.error(chalk_1.default.red(`\nError: You must specify ${chalk_1.default.yellow("true")} at least one of the following options: ${chalk_1.default.yellow("--checkFileNames")}, ${chalk_1.default.yellow("--checkFileContent")}\n`));
+        }
+        // Auto-fix extensions without dot prefix (e.g., "ts" -> ".ts")
+        if (mergedOptions.extensions) {
+            mergedOptions.extensions = mergedOptions.extensions.map((ext) => ext.startsWith(".") ? ext : `.${ext}`);
+        }
+        // Override maxConcurrency if explicitly provided via CLI
+        const finalOptions = {
+            ...mergedOptions,
+            exportFormat: options.export,
+            exportPath: options.output,
+        };
+        if (options.maxConcurrency !== undefined) {
+            finalOptions.maxConcurrency = options.maxConcurrency;
+        }
+        (0, runner_1.default)(finalOptions);
     }
-    if ((_a = options === null || options === void 0 ? void 0 : options.extensions) === null || _a === void 0 ? void 0 : _a.find((d) => !d.includes("."))) {
-        return console.error(chalk_1.default.red("\nError: Extensions must include a dot (.)\n"));
+    catch (error) {
+        console.error(chalk_1.default.red(`\n❌ Error: ${error}\n`));
+        process.exit(1);
     }
-    (0, runner_1.default)({
-        ...options,
-        directory,
-        checkFileContent: (_b = options.checkFileContent) !== null && _b !== void 0 ? _b : true,
-        checkFileNames: (_c = options.checkFileNames) !== null && _c !== void 0 ? _c : true,
-    });
+});
+// Add init command for creating config file
+commander_1.program
+    .command("init")
+    .description("Initialize a config file (.analyze-codebase.json)")
+    .action(async () => {
+    const inquirer = (await Promise.resolve().then(() => __importStar(require("inquirer")))).default;
+    const { createConfigFile } = await Promise.resolve().then(() => __importStar(require("./utils/config")));
+    const answers = await inquirer.prompt([
+        {
+            type: "input",
+            name: "framework",
+            message: "Framework (optional):",
+        },
+        {
+            type: "input",
+            name: "extensions",
+            message: "File extensions (comma-separated, e.g., .ts,.tsx):",
+            default: ".ts,.tsx,.js,.jsx",
+        },
+        {
+            type: "input",
+            name: "exclude",
+            message: "Exclude directories (comma-separated):",
+            default: "node_modules,dist,build",
+        },
+        {
+            type: "confirm",
+            name: "checkFileNames",
+            message: "Check file names?",
+            default: true,
+        },
+        {
+            type: "confirm",
+            name: "checkFileContent",
+            message: "Check file content?",
+            default: true,
+        },
+        {
+            type: "confirm",
+            name: "writeJsonOutput",
+            message: "Write JSON output by default?",
+            default: false,
+        },
+    ]);
+    const config = {
+        framework: answers.framework || undefined,
+        extensions: answers.extensions
+            .split(",")
+            .map((ext) => ext.trim())
+            .filter((ext) => ext),
+        exclude: answers.exclude
+            .split(",")
+            .map((ex) => ex.trim())
+            .filter((ex) => ex),
+        checkFileNames: answers.checkFileNames,
+        checkFileContent: answers.checkFileContent,
+        writeJsonOutput: answers.writeJsonOutput,
+        showProgress: true,
+        parallel: true,
+        // maxConcurrency will be auto-calculated based on project size
+    };
+    const configPath = await createConfigFile(".", config);
+    console.log((0, boxen_1.default)(chalk_1.default.green(`✅ Config file created: ${chalk_1.default.cyan(configPath)}`), {
+        padding: 1,
+        borderColor: "green",
+        borderStyle: "round",
+    }));
 });
 commander_1.program.parse(process.argv);
 function parseBoolean(value) {

package/dist/utils/__tests__/config.test.js

@@ -0,0 +1,94 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+(0, vitest_1.describe)("Config", () => {
+    const testDir = path.join(__dirname, "../../../test-temp");
+    const configPath = path.join(testDir, ".analyze-codebase.json");
+    (0, vitest_1.beforeEach)(async () => {
+        // Create test directory
+        try {
+            await fs.mkdir(testDir, { recursive: true });
+        }
+        catch (_a) {
+            // Directory might already exist
+        }
+    });
+    (0, vitest_1.afterEach)(async () => {
+        // Clean up test files
+        try {
+            await fs.unlink(configPath);
+        }
+        catch (_a) {
+            // File might not exist
+        }
+        try {
+            await fs.rmdir(testDir);
+        }
+        catch (_b) {
+            // Directory might not be empty
+        }
+    });
+    (0, vitest_1.it)("should create a config file", async () => {
+        const config = {
+            extensions: [".ts", ".tsx"],
+            exclude: ["node_modules"],
+            checkFileNames: true,
+            checkFileContent: true,
+        };
+        const createdPath = await (0, config_1.createConfigFile)(testDir, config);
+        (0, vitest_1.expect)(createdPath).toBe(configPath);
+        const exists = await fs.access(configPath).then(() => true).catch(() => false);
+        (0, vitest_1.expect)(exists).toBe(true);
+    });
+    (0, vitest_1.it)("should load a config file", async () => {
+        const config = {
+            extensions: [".ts", ".tsx"],
+            exclude: ["node_modules"],
+            checkFileNames: true,
+            checkFileContent: true,
+        };
+        await (0, config_1.createConfigFile)(testDir, config);
+        const loaded = await (0, config_1.loadConfig)(testDir);
+        (0, vitest_1.expect)(loaded).toBeTruthy();
+        (0, vitest_1.expect)(loaded === null || loaded === void 0 ? void 0 : loaded.extensions).toEqual(config.extensions);
+        (0, vitest_1.expect)(loaded === null || loaded === void 0 ? void 0 : loaded.exclude).toEqual(config.exclude);
+    });
+    (0, vitest_1.it)("should find config file in directory", async () => {
+        const config = {
+            extensions: [".ts"],
+        };
+        await (0, config_1.createConfigFile)(testDir, config);
+        const found = await (0, config_1.findConfigFile)(testDir);
+        (0, vitest_1.expect)(found).toBe(configPath);
+    });
+    (0, vitest_1.it)("should return null if config file doesn't exist", async () => {
+        const found = await (0, config_1.findConfigFile)(testDir);
+        (0, vitest_1.expect)(found).toBeNull();
+    });
+});

package/dist/utils/__tests__/progress.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const progress_1 = require("../progress");
+(0, vitest_1.describe)("ProgressBar", () => {
+    let progressBar;
+    (0, vitest_1.beforeEach)(() => {
+        // Suppress console output during tests
+        vitest_1.vi.spyOn(console, "log").mockImplementation(() => { });
+    });
+    (0, vitest_1.afterEach)(() => {
+        if (progressBar) {
+            progressBar.stop();
+        }
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)("should create a progress bar with total", () => {
+        progressBar = new progress_1.ProgressBar({ total: 100 });
+        (0, vitest_1.expect)(progressBar).toBeInstanceOf(progress_1.ProgressBar);
+        progressBar.stop();
+    });
+    (0, vitest_1.it)("should update progress", () => {
+        progressBar = new progress_1.ProgressBar({ total: 100 });
+        progressBar.update(10);
+        progressBar.update(20);
+        progressBar.stop();
+    });
+    (0, vitest_1.it)("should set total", () => {
+        progressBar = new progress_1.ProgressBar({ total: 50 });
+        progressBar.setTotal(100);
+        progressBar.stop();
+    });
+    (0, vitest_1.it)("should complete progress bar", () => {
+        progressBar = new progress_1.ProgressBar({ total: 100 });
+        progressBar.complete();
+    });
+});