neex 0.6.45 → 0.6.46

package/dist/src/build-manager.js

@@ -1,345 +1,368 @@
 "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.BuildManager = void 0;
-// src/build-manager.ts - Build manager with file watching and compilation
-const watcher_1 = require("./watcher");
-const runner_1 = require("./runner");
+// src/build-manager.ts - Build manager for TypeScript projects using tsx
+const child_process_1 = require("child_process");
+const chokidar_1 = require("chokidar");
+const logger_manager_js_1 = require("./logger-manager.js");
 const chalk_1 = __importDefault(require("chalk"));
 const figures_1 = __importDefault(require("figures"));
-const logger_process_1 = require("./logger-process");
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = require("fs");
 class BuildManager {
     constructor(options) {
+        this.watcher = null;
+        this.buildProcess = null;
         this.isBuilding = false;
         this.buildCount = 0;
-        this.startTime = new Date();
-        const defaultOptions = {
-            parallel: false,
-            printOutput: false,
-            color: true,
-            showTiming: false,
-            prefix: false,
-            stopOnError: true,
-            minimalOutput: true,
-            groupOutput: false,
-            isServerMode: false,
-            watch: false,
-            ignore: [
-                'node_modules/**',
-                '.git/**',
-                '*.log',
-                'dist/**',
-                'build/**',
-                'coverage/**',
-                '.nyc_output/**',
-                '*.tmp',
-                '*.temp'
-            ],
-            delay: 1000,
-            verbose: false,
-            showInfo: false,
-            runnerName: 'neex build',
-            clean: false,
-            sourceMap: false,
-            target: 'es2020',
-            module: 'commonjs'
-        };
-        this.options = {
-            ...defaultOptions,
-            ...options
-        };
+        this.debouncedBuild = this.debounce(this.runBuild.bind(this), 500);
+        this.options = options;
     }
-    setupFileWatcher() {
-        if (!this.options.watch) {
-            return;
-        }
-        const inputDir = path.dirname(this.options.inputFile);
-        const watchOptions = {
-            watch: [inputDir],
-            ignore: this.options.ignore,
-            ext: this.options.buildType === 'typescript' ? ['ts', 'tsx'] : ['js', 'jsx', 'mjs', 'cjs'],
-            delay: this.options.delay,
-            verbose: this.options.verbose && this.options.showInfo
-        };
-        this.fileWatcher = new watcher_1.FileWatcher(watchOptions);
-        this.fileWatcher.on('change', (event) => {
-            if (this.options.watch && !this.isBuilding) {
-                this.handleFileChange(event);
+    async cleanOutputDirectory() {
+        if (this.options.clean && (0, fs_1.existsSync)(this.options.output)) {
+            try {
+                await promises_1.default.rm(this.options.output, { recursive: true, force: true });
+                if (this.options.verbose) {
+                    logger_manager_js_1.loggerManager.printLine(`Cleaned output directory: ${this.options.output}`, 'info');
+                }
+            }
+            catch (error) {
+                logger_manager_js_1.loggerManager.printLine(`Failed to clean output directory: ${error.message}`, 'warn');
             }
-        });
-    }
-    async handleFileChange(event) {
-        if (this.options.showInfo) {
-            const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
-            logger_process_1.logger.printLine(`${prefix} File changed: ${chalk_1.default.yellow(event.relativePath)}`, 'info');
         }
-        await this.rebuild();
     }
     async ensureOutputDirectory() {
         try {
-            await fs.mkdir(this.options.outputDir, { recursive: true });
+            await promises_1.default.mkdir(this.options.output, { recursive: true });
         }
         catch (error) {
-            if (this.options.showInfo) {
-                logger_process_1.logger.printLine(`Failed to create output directory: ${error.message}`, 'error');
-            }
-            throw error;
+            throw new Error(`Failed to create output directory: ${error.message}`);
         }
     }
-    async cleanOutputDirectory() {
-        if (!this.options.clean) {
-            return;
+    async validateTsConfig() {
+        if (!(0, fs_1.existsSync)(this.options.tsconfig)) {
+            throw new Error(`TypeScript config file not found: ${this.options.tsconfig}`);
         }
-        try {
-            await fs.rm(this.options.outputDir, { recursive: true, force: true });
-            if (this.options.showInfo) {
-                const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
-                logger_process_1.logger.printLine(`${prefix} Cleaned output directory: ${chalk_1.default.yellow(this.options.outputDir)}`, 'info');
+    }
+    async copyPackageJson() {
+        var _a;
+        const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+        const outputPackageJsonPath = path_1.default.join(this.options.output, 'package.json');
+        if ((0, fs_1.existsSync)(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(await promises_1.default.readFile(packageJsonPath, 'utf8'));
+                // Create production package.json
+                const prodPackageJson = {
+                    name: packageJson.name,
+                    version: packageJson.version,
+                    description: packageJson.description,
+                    main: ((_a = packageJson.main) === null || _a === void 0 ? void 0 : _a.replace(/^src\//, '')) || 'index.js',
+                    type: this.options.format === 'esm' ? 'module' : 'commonjs',
+                    scripts: {
+                        start: 'node index.js'
+                    },
+                    dependencies: packageJson.dependencies || {},
+                    engines: packageJson.engines
+                };
+                await promises_1.default.writeFile(outputPackageJsonPath, JSON.stringify(prodPackageJson, null, 2));
+                if (this.options.verbose) {
+                    logger_manager_js_1.loggerManager.printLine('Generated production package.json', 'info');
+                }
             }
-        }
-        catch (error) {
-            if (this.options.showInfo) {
-                logger_process_1.logger.printLine(`Failed to clean output directory: ${error.message}`, 'error');
+            catch (error) {
+                logger_manager_js_1.loggerManager.printLine(`Failed to copy package.json: ${error.message}`, 'warn');
             }
-            throw error;
         }
     }
-    generateBuildCommand() {
-        const { inputFile, outputDir, buildType, sourceMap, target, module } = this.options;
-        switch (buildType) {
-            case 'typescript':
-                let tsCommand = `npx tsc ${inputFile} --outDir ${outputDir} --target ${target} --module ${module} --moduleResolution node --esModuleInterop --allowSyntheticDefaultImports --strict --skipLibCheck`;
-                if (sourceMap) {
-                    tsCommand += ' --sourceMap';
-                }
-                return tsCommand;
-            case 'javascript':
-            case 'copy':
-                return `cp ${inputFile} ${path.join(outputDir, path.basename(inputFile))}`;
-            default:
-                return `cp ${inputFile} ${path.join(outputDir, path.basename(inputFile))}`;
+    getBuildCommand() {
+        if (this.options.bundle) {
+            // Use tsx for bundling
+            const args = [
+                'build',
+                this.options.source,
+                '--out-dir',
+                this.options.output,
+                '--target',
+                this.options.target
+            ];
+            if (this.options.minify) {
+                args.push('--minify');
+            }
+            if (this.options.sourcemap) {
+                args.push('--sourcemap');
+            }
+            if (this.options.format === 'esm') {
+                args.push('--format', 'esm');
+            }
+            if (this.options.external.length > 0) {
+                args.push('--external', this.options.external.join(','));
+            }
+            return { command: 'tsx', args };
+        }
+        else {
+            // Use TypeScript compiler directly
+            const args = [
+                '--project',
+                this.options.tsconfig,
+                '--outDir',
+                this.options.output,
+                '--target',
+                this.options.target
+            ];
+            if (this.options.sourcemap) {
+                args.push('--sourceMap');
+            }
+            if (this.options.format === 'esm') {
+                args.push('--module', 'es2020');
+            }
+            return { command: 'tsc', args };
         }
     }
     async runBuild() {
-        var _a, _b, _c;
-        const buildCommand = this.generateBuildCommand();
-        // Create a runner with clean output settings
-        const runnerOptions = {
-            ...this.options,
-            printOutput: (_a = this.options.showInfo) !== null && _a !== void 0 ? _a : false,
-            showTiming: (_b = this.options.showInfo) !== null && _b !== void 0 ? _b : false,
-            prefix: (_c = this.options.showInfo) !== null && _c !== void 0 ? _c : false,
-            customPrefix: this.options.showInfo ? () => `build` : undefined
-        };
-        this.runner = new runner_1.Runner(runnerOptions);
+        if (this.isBuilding) {
+            return;
+        }
+        this.isBuilding = true;
+        this.buildCount++;
+        const startTime = Date.now();
+        if (!this.options.quiet) {
+            const buildNumber = this.options.watch ? ` #${this.buildCount}` : '';
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Building${buildNumber}...`, 'info');
+        }
         try {
-            this.isBuilding = true;
-            this.buildCount++;
-            this.lastBuildTime = new Date();
-            // Ensure output directory exists
             await this.ensureOutputDirectory();
-            // Clean if requested
-            if (this.options.clean && this.buildCount === 1) {
-                await this.cleanOutputDirectory();
-                await this.ensureOutputDirectory();
+            const { command, args } = this.getBuildCommand();
+            if (this.options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`Executing: ${command} ${args.join(' ')}`, 'info');
             }
-            const results = await this.runner.run([buildCommand]);
-            // Handle build results
-            const success = results.every(result => result.success);
-            if (!success) {
-                // Only show errors, let the caller handle success message
-                const failedResults = results.filter(result => !result.success);
-                for (const result of failedResults) {
-                    if (result.stderr) {
-                        console.error(chalk_1.default.red(result.stderr));
-                    }
-                    if (result.error) {
-                        console.error(chalk_1.default.red(result.error));
+            return new Promise((resolve, reject) => {
+                var _a, _b;
+                this.buildProcess = (0, child_process_1.spawn)(command, args, {
+                    stdio: this.options.verbose ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'ignore', 'pipe'],
+                    shell: false,
+                    env: {
+                        ...process.env,
+                        FORCE_COLOR: this.options.color ? '1' : '0'
                     }
+                });
+                let stderr = '';
+                if (this.options.verbose) {
+                    (_a = this.buildProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+                        process.stdout.write(data);
+                    });
                 }
-                throw new Error('Build failed');
-            }
-            return results;
+                (_b = this.buildProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+                    stderr += data.toString();
+                    if (this.options.verbose) {
+                        process.stderr.write(data);
+                    }
+                });
+                this.buildProcess.on('error', (error) => {
+                    this.buildProcess = null;
+                    this.isBuilding = false;
+                    reject(new Error(`Build process error: ${error.message}`));
+                });
+                this.buildProcess.on('exit', async (code) => {
+                    this.buildProcess = null;
+                    this.isBuilding = false;
+                    const duration = Date.now() - startTime;
+                    if (code === 0) {
+                        // Copy package.json after successful build
+                        await this.copyPackageJson();
+                        if (!this.options.quiet) {
+                            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Build completed in ${duration}ms`, 'info');
+                        }
+                        if (this.options.analyze) {
+                            await this.analyzeBuild();
+                        }
+                        resolve();
+                    }
+                    else {
+                        const error = new Error(`Build failed with code ${code}`);
+                        if (stderr) {
+                            logger_manager_js_1.loggerManager.printLine(`Build errors:\n${stderr}`, 'error');
+                        }
+                        reject(error);
+                    }
+                });
+            });
         }
         catch (error) {
-            throw error;
-        }
-        finally {
             this.isBuilding = false;
+            throw error;
         }
     }
-    printBuildBanner() {
-        var _a;
-        if (!this.options.showInfo) {
-            return;
-        }
-        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
-        const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
-        const uptimeStr = this.formatUptime(uptime);
-        console.log('\n' + chalk_1.default.bgBlue.black(`    ${(_a = this.options.runnerName) === null || _a === void 0 ? void 0 : _a.toUpperCase()} MODE    `) + '\n');
-        if (this.buildCount > 0) {
-            console.log(`${prefix} ${chalk_1.default.green(`${figures_1.default.tick} Build #${this.buildCount}`)}`);
+    async analyzeBuild() {
+        try {
+            const stats = await promises_1.default.stat(this.options.output);
+            const files = await promises_1.default.readdir(this.options.output, { withFileTypes: true });
+            let totalSize = 0;
+            const fileStats = [];
+            for (const file of files) {
+                if (file.isFile()) {
+                    const filePath = path_1.default.join(this.options.output, file.name);
+                    const stat = await promises_1.default.stat(filePath);
+                    totalSize += stat.size;
+                    fileStats.push({ name: file.name, size: stat.size });
+                }
+            }
+            fileStats.sort((a, b) => b.size - a.size);
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Bundle Analysis:`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`Total size: ${chalk_1.default.cyan(this.formatBytes(totalSize))}`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`Files: ${files.length}`, 'info');
+            if (this.options.verbose) {
+                fileStats.slice(0, 10).forEach(file => {
+                    logger_manager_js_1.loggerManager.printLine(`  ${file.name}: ${this.formatBytes(file.size)}`, 'info');
+                });
+            }
         }
-        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Uptime: ${uptimeStr}`)}`);
-        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Input: ${this.options.inputFile}`)}`);
-        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Output: ${this.options.outputDir}`)}`);
-        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Build type: ${this.options.buildType}`)}`);
-        if (this.options.watch) {
-            console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Watching for changes...`)}`);
+        catch (error) {
+            logger_manager_js_1.loggerManager.printLine(`Failed to analyze build: ${error.message}`, 'warn');
         }
-        console.log('');
     }
-    formatUptime(seconds) {
-        if (seconds < 60) {
-            return `${seconds}s`;
-        }
-        else if (seconds < 3600) {
-            const minutes = Math.floor(seconds / 60);
-            const remainingSeconds = seconds % 60;
-            return `${minutes}m ${remainingSeconds}s`;
-        }
-        else {
-            const hours = Math.floor(seconds / 3600);
-            const minutes = Math.floor((seconds % 3600) / 60);
-            return `${hours}h ${minutes}m`;
+    async stopProcess() {
+        if (!this.buildProcess) {
+            return;
         }
+        return new Promise((resolve) => {
+            if (!this.buildProcess) {
+                resolve();
+                return;
+            }
+            const proc = this.buildProcess;
+            this.buildProcess = null;
+            const cleanup = () => {
+                if (!this.options.quiet) {
+                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.square)} Stopped build process`, 'info');
+                }
+                resolve();
+            };
+            proc.on('exit', cleanup);
+            proc.on('error', cleanup);
+            try {
+                if (proc.pid) {
+                    // Kill process group
+                    process.kill(-proc.pid, 'SIGTERM');
+                    // Fallback after timeout
+                    setTimeout(() => {
+                        if (proc.pid && !proc.killed) {
+                            try {
+                                process.kill(-proc.pid, 'SIGKILL');
+                            }
+                            catch (e) {
+                                // Ignore
+                            }
+                        }
+                    }, 5000);
+                }
+            }
+            catch (error) {
+                // Process might already be dead
+                cleanup();
+            }
+        });
     }
-    async start() {
-        this.startTime = new Date();
-        // Setup file watcher if watch mode is enabled
-        if (this.options.watch) {
-            this.setupFileWatcher();
-        }
-        // Print build banner only if showInfo is true
-        if (this.options.showInfo) {
-            this.printBuildBanner();
-        }
-        // Start file watcher if enabled
-        if (this.fileWatcher) {
-            await this.fileWatcher.start();
-        }
-        // Run initial build
-        await this.runBuild();
-        // Set up graceful shutdown
-        this.setupGracefulShutdown();
-        if (this.options.watch) {
-            if (this.options.showInfo) {
-                const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
-                logger_process_1.logger.printLine(`${prefix} Build completed. Watching for changes...`, 'info');
-                logger_process_1.logger.printLine(`${prefix} Press ${chalk_1.default.cyan('Ctrl+C')} to stop`, 'info');
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 Bytes';
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+    setupWatcher() {
+        const watchPatterns = [
+            `${this.options.source}/**/*.ts`,
+            `${this.options.source}/**/*.tsx`,
+            `${this.options.source}/**/*.js`,
+            `${this.options.source}/**/*.jsx`,
+            this.options.tsconfig
+        ];
+        this.watcher = (0, chokidar_1.watch)(watchPatterns, {
+            ignoreInitial: true,
+            followSymlinks: false,
+            usePolling: false,
+            atomic: 300,
+            ignored: [
+                '**/node_modules/**',
+                '**/.git/**',
+                `**/${this.options.output}/**`,
+                '**/*.log'
+            ]
+        });
+        this.watcher.on('change', (filePath) => {
+            if (this.options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`File changed: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
             }
+            this.debouncedBuild();
+        });
+        this.watcher.on('add', (filePath) => {
+            if (this.options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`File added: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+            }
+            this.debouncedBuild();
+        });
+        this.watcher.on('unlink', (filePath) => {
+            if (this.options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`File removed: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+            }
+            this.debouncedBuild();
+        });
+        this.watcher.on('error', (error) => {
+            logger_manager_js_1.loggerManager.printLine(`Watcher error: ${error.message}`, 'error');
+        });
+        if (this.options.verbose) {
+            logger_manager_js_1.loggerManager.printLine(`Watching: ${watchPatterns.join(', ')}`, 'info');
         }
     }
-    async rebuild() {
-        if (this.isBuilding) {
-            return;
-        }
-        if (this.options.showInfo) {
-            const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
-            logger_process_1.logger.printLine(`${prefix} Rebuilding due to file changes...`, 'info');
-        }
-        // Stop current processes
-        if (this.runner) {
-            this.runner.cleanup('SIGTERM');
-        }
-        // Wait a moment before rebuilding
-        await new Promise(resolve => setTimeout(resolve, 500));
-        // Print rebuild banner only if showInfo is true
-        if (this.options.showInfo) {
-            this.printBuildBanner();
+    debounce(func, wait) {
+        let timeout;
+        return function executedFunction(...args) {
+            const later = () => {
+                clearTimeout(timeout);
+                func(...args);
+            };
+            clearTimeout(timeout);
+            timeout = setTimeout(later, wait);
+        };
+    }
+    async build() {
+        // Check if source directory exists
+        if (!(0, fs_1.existsSync)(this.options.source)) {
+            throw new Error(`Source directory not found: ${this.options.source}`);
         }
-        // Run build again
-        await this.runBuild();
-        if (this.options.showInfo) {
-            const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
-            logger_process_1.logger.printLine(`${prefix} Rebuild completed. Watching for changes...`, 'info');
+        try {
+            await this.validateTsConfig();
+            await this.cleanOutputDirectory();
+            await this.runBuild();
+            if (this.options.watch) {
+                this.setupWatcher();
+                if (!this.options.quiet) {
+                    logger_manager_js_1.loggerManager.printLine('Watching for file changes...', 'info');
+                }
+            }
         }
-        else {
-            // Show rebuild completion even without showInfo for watch mode
-            console.log(chalk_1.default.green(`${figures_1.default.tick} Rebuild completed`));
+        catch (error) {
+            logger_manager_js_1.loggerManager.printLine(error.message, 'error');
+            if (!this.options.watch) {
+                process.exit(1);
+            }
         }
     }
     async stop() {
-        if (!this.isBuilding && !this.options.watch) {
-            return;
-        }
-        if (this.options.showInfo) {
-            const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
-            logger_process_1.logger.printLine(`${prefix} Stopping build process...`, 'info');
-        }
-        // Stop file watcher
-        if (this.fileWatcher) {
-            this.fileWatcher.stop();
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Stopping build process...`, 'info');
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
         }
-        // Stop current processes
-        if (this.runner) {
-            this.runner.cleanup('SIGTERM');
-        }
-        if (this.options.showInfo) {
-            const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
-            const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
-            const uptimeStr = this.formatUptime(uptime);
-            logger_process_1.logger.printLine(`${prefix} Build process stopped after ${uptimeStr}`, 'info');
-            if (this.buildCount > 0) {
-                logger_process_1.logger.printLine(`${prefix} Total builds: ${this.buildCount}`, 'info');
-            }
+        await this.stopProcess();
+        if (this.buildCount > 0) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Build process stopped after ${this.buildCount} build(s)`, 'info');
         }
     }
-    setupGracefulShutdown() {
-        const handleSignal = (signal) => {
-            if (this.options.showInfo) {
-                console.log(`\n${chalk_1.default.yellow(`${figures_1.default.warning} Received ${signal}. Shutting down build process...`)}`);
-            }
-            this.stop().then(() => {
-                process.exit(0);
-            });
-        };
-        process.on('SIGINT', () => handleSignal('SIGINT'));
-        process.on('SIGTERM', () => handleSignal('SIGTERM'));
-        process.on('SIGQUIT', () => handleSignal('SIGQUIT'));
-    }
-    isActive() {
-        return this.isBuilding || (this.options.watch || false);
-    }
-    getUptime() {
-        return Math.floor((Date.now() - this.startTime.getTime()) / 1000);
-    }
-    getBuildCount() {
-        return this.buildCount;
-    }
-    getLastBuildTime() {
-        return this.lastBuildTime;
-    }
-    getWatchedFiles() {
-        var _a;
-        return ((_a = this.fileWatcher) === null || _a === void 0 ? void 0 : _a.getWatchedFiles()) || [];
-    }
 }
 exports.BuildManager = BuildManager;