@depup/nestjs__cli 11.0.24-depup.8 → 12.0.0-depup.0

package/lib/compiler/swc/swc-compiler.js

@@ -1,40 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwcCompiler = void 0;
-const ansis_1 = require("ansis");
-const child_process_1 = require("child_process");
-const chokidar = require("chokidar");
-const fs_1 = require("fs");
-const promises_1 = require("fs/promises");
-const path = require("path");
-const path_1 = require("path");
-const ui_1 = require("../../ui");
-const tree_kill_1 = require("../../utils/tree-kill");
-const base_compiler_1 = require("../base-compiler");
-const swc_defaults_1 = require("../defaults/swc-defaults");
-const get_value_or_default_1 = require("../helpers/get-value-or-default");
-const plugin_metadata_generator_1 = require("../plugins/plugin-metadata-generator");
-const constants_1 = require("./constants");
-const type_checker_host_1 = require("./type-checker-host");
-class SwcCompiler extends base_compiler_1.BaseCompiler {
+import { cyan } from 'ansis';
+import { fork, spawnSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { stat } from 'fs/promises';
+import { minimatch } from 'minimatch';
+import { createRequire } from 'module';
+import * as path from 'path';
+import { dirname, isAbsolute, join, posix, relative } from 'path';
+import { fileURLToPath } from 'url';
+import { ERROR_PREFIX } from '../../ui/index.js';
+import { treeKillSync } from '../../utils/tree-kill.js';
+import { BaseCompiler } from '../base-compiler.js';
+import { swcDefaultsFactory } from '../defaults/swc-defaults.js';
+import { getValueOrDefault } from '../helpers/get-value-or-default.js';
+import { PluginMetadataGenerator } from '../plugins/plugin-metadata-generator.js';
+import { watchDirectoryRecursively } from '../watchers/recursive-directory-watcher.js';
+import { FOUND_NO_ISSUES_GENERATING_METADATA, FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED, SWC_LOG_PREFIX, } from './constants.js';
+import { TypeCheckerHost } from './type-checker-host.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+export class SwcCompiler extends BaseCompiler {
+    pluginMetadataGenerator = new PluginMetadataGenerator();
+    typeCheckerHost = new TypeCheckerHost();
     constructor(pluginsLoader) {
         super(pluginsLoader);
-        this.pluginMetadataGenerator = new plugin_metadata_generator_1.PluginMetadataGenerator();
-        this.typeCheckerHost = new type_checker_host_1.TypeCheckerHost();
     }
     async run(configuration, tsConfigPath, appName, extras, onSuccess) {
-        const swcOptions = (0, swc_defaults_1.swcDefaultsFactory)(extras.tsOptions, configuration);
-        const swcrcFilePath = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.builder.options.swcrcPath', appName);
+        const swcOptions = swcDefaultsFactory(extras.tsOptions, configuration, extras.tsConfigExclude);
+        const swcrcFilePath = getValueOrDefault(configuration, 'compilerOptions.builder.options.swcrcPath', appName);
         if (extras.watch) {
             if (extras.typeCheck) {
                 this.runTypeChecker(configuration, tsConfigPath, appName, extras);
             }
             await this.runSwc(swcOptions, extras, swcrcFilePath);
+            if (extras.emitDeclarations) {
+                this.emitDeclarations(tsConfigPath);
+            }
             if (onSuccess) {
                 onSuccess();
                 const debounceTime = 150;
                 const callback = this.debounce(onSuccess, debounceTime);
-                this.watchFilesInOutDir(swcOptions, callback);
+                void this.watchFilesInOutDir(swcOptions, callback);
             }
         }
         else {
@@ -42,12 +48,28 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
                 await this.runTypeChecker(configuration, tsConfigPath, appName, extras);
             }
             await this.runSwc(swcOptions, extras, swcrcFilePath);
+            if (extras.emitDeclarations) {
+                this.emitDeclarations(tsConfigPath);
+            }
             if (onSuccess) {
                 onSuccess();
             }
             await extras.assetsManager?.closeWatchers();
         }
     }
+    emitDeclarations(tsConfigPath) {
+        process.nextTick(() => console.log(SWC_LOG_PREFIX, cyan('Emitting declaration files...')));
+        const tscPath = join(process.cwd(), 'node_modules', '.bin', 'tsc');
+        const result = spawnSync(tscPath, ['--emitDeclarationOnly', '-p', tsConfigPath], {
+            cwd: process.cwd(),
+            stdio: 'inherit',
+            shell: true,
+        });
+        if (result.status !== 0) {
+            console.error(ERROR_PREFIX +
+                ' Failed to emit declaration files. Please ensure "declaration" is enabled in your tsconfig.');
+        }
+    }
     runTypeChecker(configuration, tsConfigPath, appName, extras) {
         if (extras.watch) {
             const args = [
@@ -56,10 +78,10 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
                 configuration.sourceRoot ?? 'src',
                 JSON.stringify(configuration.compilerOptions.plugins ?? []),
             ];
-            const childProcessRef = (0, child_process_1.fork)((0, path_1.join)(__dirname, 'forked-type-checker.js'), args, {
+            const childProcessRef = fork(join(__dirname, 'forked-type-checker.js'), args, {
                 cwd: process.cwd(),
             });
-            process.on('exit', () => childProcessRef && (0, tree_kill_1.treeKillSync)(childProcessRef.pid));
+            process.on('exit', () => childProcessRef && treeKillSync(childProcessRef.pid));
         }
         else {
             const { readonlyVisitors } = this.loadPlugins(configuration, tsConfigPath, appName);
@@ -75,7 +97,7 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
                                 resolve();
                             }
                             if (readonlyVisitors.length > 0) {
-                                process.nextTick(() => console.log(constants_1.FOUND_NO_ISSUES_GENERATING_METADATA));
+                                process.nextTick(() => console.log(FOUND_NO_ISSUES_GENERATING_METADATA));
                                 this.pluginMetadataGenerator.generate({
                                     outputDir,
                                     visitors: readonlyVisitors,
@@ -83,7 +105,7 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
                                 });
                             }
                             else {
-                                process.nextTick(() => console.log(constants_1.FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED));
+                                process.nextTick(() => console.log(FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED));
                             }
                         },
                     });
@@ -98,11 +120,13 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
         }
     }
     async runSwc(options, extras, swcrcFilePath) {
-        process.nextTick(() => console.log(constants_1.SWC_LOG_PREFIX, (0, ansis_1.cyan)('Running...')));
+        if (this.shouldLogSwcStatus(extras)) {
+            process.nextTick(() => console.log(SWC_LOG_PREFIX, cyan('Running...')));
+        }
         const swcCli = this.loadSwcCliBinary();
         const swcRcFile = await this.getSwcRcFileContentIfExists(swcrcFilePath);
         const swcOptions = this.deepMerge(options.swcOptions, swcRcFile);
-        if (swcOptions?.jsc?.baseUrl && !(0, path_1.isAbsolute)(swcOptions?.jsc?.baseUrl)) {
+        if (swcOptions?.jsc?.baseUrl && !isAbsolute(swcOptions?.jsc?.baseUrl)) {
             // jsc.baseUrl should be resolved by the caller, if it's passed as an object.
             // https://github.com/swc-project/swc/pull/7827
             const rootDir = process.cwd();
@@ -120,35 +144,54 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
             // This is required since SWC no longer supports auto-compiling of newly added files in watch mode.
             // We need to watch the source directory and trigger SWC compilation manually.
             await this.watchFilesInSrcDir(options, async (file) => {
-                // Transpile newly added file
-                await swcCli.default({
-                    ...swcCliOpts,
-                    cliOptions: {
-                        ...swcCliOpts.cliOptions,
-                        filenames: [file],
-                    },
-                });
+                // Transpile newly added file (one-shot: inheriting "watch" here would
+                // register one more permanent @swc/cli watcher per added file, and each
+                // async invocation constructs a Piscina pool that is never destroyed)
+                try {
+                    await swcCli.default({
+                        ...swcCliOpts,
+                        cliOptions: {
+                            ...swcCliOpts.cliOptions,
+                            filenames: [file],
+                            watch: false,
+                            sync: true,
+                        },
+                    });
+                }
+                catch {
+                    // Outside of watch mode "@swc/cli" rejects when a file fails to
+                    // compile, after having reported the failure itself. Swallow it so
+                    // that adding a file that does not compile yet does not tear down
+                    // the watch process.
+                }
             });
         }
         await swcCli.default(swcCliOpts);
     }
+    shouldLogSwcStatus(extras) {
+        if (extras.silent) {
+            return false;
+        }
+        const npmLogLevel = process.env.npm_config_loglevel?.toLowerCase();
+        return npmLogLevel !== 'silent';
+    }
     loadSwcCliBinary() {
         try {
             return require('@swc/cli/lib/swc/dir');
         }
-        catch (err) {
-            console.error(ui_1.ERROR_PREFIX +
+        catch {
+            console.error(ERROR_PREFIX +
                 ' Failed to load "@swc/cli" and/or "@swc/core" required packages. Please, make sure to install them as development dependencies.');
             process.exit(1);
         }
     }
     getSwcRcFileContentIfExists(swcrcFilePath) {
         try {
-            return JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(process.cwd(), swcrcFilePath ?? '.swcrc'), 'utf8'));
+            return JSON.parse(readFileSync(join(process.cwd(), swcrcFilePath ?? '.swcrc'), 'utf8'));
         }
-        catch (err) {
+        catch {
             if (swcrcFilePath !== undefined) {
-                console.error(ui_1.ERROR_PREFIX +
+                console.error(ERROR_PREFIX +
                     ` Failed to load "${swcrcFilePath}". Please, check if the file exists and is valid JSON.`);
                 process.exit(1);
             }
@@ -170,7 +213,7 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
         }
         const merged = { ...target };
         for (const key in source) {
-            if (source.hasOwnProperty(key)) {
+            if (Object.hasOwn(source, key)) {
                 if (key in target) {
                     merged[key] = this.deepMerge(target[key], source[key]);
                 }
@@ -190,7 +233,7 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
     }
     async watchFilesInSrcDir(options, onFileAdded) {
         const srcDir = options.cliOptions?.filenames?.[0];
-        const isDirectory = await (0, promises_1.stat)(srcDir)
+        const isDirectory = await stat(srcDir)
             .then((stats) => stats.isDirectory())
             .catch(() => false);
         if (!srcDir || !isDirectory) {
@@ -199,35 +242,38 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
             return;
         }
         const extensions = options.cliOptions?.extensions ?? ['.ts'];
-        const watcher = chokidar.watch(srcDir, {
-            ignored: (file, stats) => (stats?.isFile() &&
-                !extensions.some((ext) => file.endsWith(ext))),
-            ignoreInitial: true,
-            awaitWriteFinish: {
-                stabilityThreshold: 50,
-                pollInterval: 10,
+        await watchDirectoryRecursively(srcDir, {
+            extensions,
+            onAdd: async (file) => {
+                if (this.isIgnoredBySwc(file, options.cliOptions?.ignore)) {
+                    return;
+                }
+                await onFileAdded(file);
             },
         });
-        watcher.on('add', async (file) => onFileAdded(file));
     }
-    watchFilesInOutDir(options, onChange) {
-        const dir = (0, path_1.isAbsolute)(options.cliOptions.outDir)
-            ? options.cliOptions.outDir
-            : (0, path_1.join)(process.cwd(), options.cliOptions.outDir);
-        const watcher = chokidar.watch(dir, {
-            ignored: (file, stats) => (stats?.isFile() &&
-                !(file.endsWith('.js') || file.endsWith('.mjs'))),
-            ignoreInitial: true,
-            awaitWriteFinish: {
-                stabilityThreshold: 50,
-                pollInterval: 10,
-            },
+    isIgnoredBySwc(file, ignore = [], cwd = process.cwd()) {
+        if (!ignore.length) {
+            return false;
+        }
+        const relativeFile = isAbsolute(file) ? relative(cwd, file) : file;
+        const normalizedFile = this.normalizeSwcIgnorePath(relativeFile);
+        return ignore.some((pattern) => {
+            const normalizedPattern = this.normalizeSwcIgnorePath(pattern);
+            return [normalizedPattern, posix.join(normalizedPattern, '**')].some((pattern) => minimatch(normalizedFile, pattern));
         });
-        watcher.on('ready', () => {
-            for (const type of ['add', 'change']) {
-                watcher.on(type, async () => onChange());
-            }
+    }
+    normalizeSwcIgnorePath(value) {
+        return posix.normalize(value.replace(/\\/g, '/'));
+    }
+    async watchFilesInOutDir(options, onChange) {
+        const dir = isAbsolute(options.cliOptions.outDir)
+            ? options.cliOptions.outDir
+            : join(process.cwd(), options.cliOptions.outDir);
+        await watchDirectoryRecursively(dir, {
+            extensions: ['.js', '.mjs'],
+            onAdd: onChange,
+            onChange: onChange,
         });
     }
 }
-exports.SwcCompiler = SwcCompiler;

package/lib/compiler/swc/type-checker-host.js

@@ -1,43 +1,50 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCheckerHost = void 0;
-const ansis_1 = require("ansis");
-const ora = require("ora");
-const ts = require("typescript");
-const tsconfig_provider_1 = require("../helpers/tsconfig-provider");
-const typescript_loader_1 = require("../typescript-loader");
-const constants_1 = require("./constants");
-class TypeCheckerHost {
-    constructor() {
-        this.typescriptLoader = new typescript_loader_1.TypeScriptBinaryLoader();
-        this.tsConfigProvider = new tsconfig_provider_1.TsConfigProvider(this.typescriptLoader);
-    }
+import { red } from 'ansis';
+import ora from 'ora';
+import * as ts from 'typescript';
+import { TsConfigProvider } from '../helpers/tsconfig-provider.js';
+import { TypeScriptBinaryLoader } from '../typescript-loader.js';
+import { INITIALIZING_TYPE_CHECKER, TSC_LOG_ERROR_PREFIX, TSC_NO_ERRORS_MESSAGE, } from './constants.js';
+export class TypeCheckerHost {
+    typescriptLoader = new TypeScriptBinaryLoader();
+    tsConfigProvider = new TsConfigProvider(this.typescriptLoader);
     run(tsconfigPath, options) {
         if (!tsconfigPath) {
             throw new Error('"tsconfigPath" is required when "tsProgramRef" is not provided.');
         }
         const tsBinary = this.typescriptLoader.load();
         const spinner = ora({
-            text: constants_1.INITIALIZING_TYPE_CHECKER,
+            text: INITIALIZING_TYPE_CHECKER,
         });
         if (options.watch) {
             console.log();
             spinner.start();
-            this.runInWatchMode(tsconfigPath, tsBinary, options);
-            spinner.succeed();
+            try {
+                this.runInWatchMode(tsconfigPath, tsBinary, options);
+                spinner.succeed();
+            }
+            catch (err) {
+                spinner.fail();
+                throw err;
+            }
             return;
         }
         spinner.start();
-        this.runOnce(tsconfigPath, tsBinary, options);
-        spinner.succeed();
+        try {
+            this.runOnce(tsconfigPath, tsBinary, options);
+            spinner.succeed();
+        }
+        catch (err) {
+            spinner.fail();
+            throw err;
+        }
     }
     runInWatchMode(tsconfigPath, tsBinary, options) {
         const { options: tsOptions } = this.tsConfigProvider.getByConfigFilename(tsconfigPath);
         let builderProgram = undefined;
         const reportWatchStatusCallback = (diagnostic) => {
-            if (diagnostic.messageText !== constants_1.TSC_NO_ERRORS_MESSAGE) {
+            if (diagnostic.messageText !== TSC_NO_ERRORS_MESSAGE) {
                 if (diagnostic.messageText?.includes('Found')) {
-                    console.log(constants_1.TSC_LOG_ERROR_PREFIX, (0, ansis_1.red)(diagnostic.messageText.toString()));
+                    console.error(TSC_LOG_ERROR_PREFIX, red(diagnostic.messageText.toString()));
                 }
                 return;
             }
@@ -71,9 +78,10 @@ class TypeCheckerHost {
                 getCurrentDirectory: tsBinary.sys.getCurrentDirectory,
                 getNewLine: () => tsBinary.sys.newLine,
             };
+            const formattedDiagnostics = tsBinary.formatDiagnosticsWithColorAndContext(diagnostics, formatDiagnosticsHost);
             console.log();
-            console.log(tsBinary.formatDiagnosticsWithColorAndContext(diagnostics, formatDiagnosticsHost));
-            process.exit(1);
+            console.log(formattedDiagnostics);
+            throw new Error(`Found ${diagnostics.length} type error(s) during compilation.`);
         }
         options.onTypeCheck?.(programRef);
     }
@@ -87,4 +95,3 @@ class TypeCheckerHost {
         return tsBinary.createWatchCompilerHost(tsConfigPath, tsOptions, tsBinary.sys, undefined, origDiagnosticReporter, reportWatchStatusCallback);
     }
 }
-exports.TypeCheckerHost = TypeCheckerHost;

package/lib/compiler/typescript-loader.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeScriptBinaryLoader = void 0;
-const ui_1 = require("../ui");
-class TypeScriptBinaryLoader {
+import { createRequire } from 'module';
+import { CLI_ERRORS } from '../ui/index.js';
+const require = createRequire(import.meta.url);
+export class TypeScriptBinaryLoader {
+    tsBinary;
     load() {
         if (this.tsBinary) {
             return this.tsBinary;
@@ -12,7 +12,6 @@ class TypeScriptBinaryLoader {
             const tsBinaryPath = require.resolve('typescript', {
                 paths: [process.cwd(), ...this.getModulePaths()],
             });
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
             tsBinary = require(tsBinaryPath);
         }
         catch {
@@ -24,11 +23,11 @@ class TypeScriptBinaryLoader {
     }
     assertProgrammaticApiIsSupported(tsBinary) {
         if (typeof tsBinary.getParsedCommandLineOfConfigFile !== 'function') {
-            throw new Error(ui_1.CLI_ERRORS.UNSUPPORTED_TYPESCRIPT_VERSION(tsBinary.version));
+            throw new Error(CLI_ERRORS.UNSUPPORTED_TYPESCRIPT_VERSION(tsBinary.version));
         }
     }
     getModulePaths() {
-        const modulePaths = module.paths.slice(2, module.paths.length);
+        const modulePaths = require.resolve.paths('typescript') ?? [];
         const packageDeps = modulePaths.slice(0, 3);
         return [
             ...packageDeps.reverse(),
@@ -36,4 +35,3 @@ class TypeScriptBinaryLoader {
         ];
     }
 }
-exports.TypeScriptBinaryLoader = TypeScriptBinaryLoader;

package/lib/compiler/watch-compiler.d.ts

@@ -1,8 +1,8 @@
-import { Configuration } from '../configuration';
-import { BaseCompiler } from './base-compiler';
-import { TsConfigProvider } from './helpers/tsconfig-provider';
-import { PluginsLoader } from './plugins/plugins-loader';
-import { TypeScriptBinaryLoader } from './typescript-loader';
+import { Configuration } from '../configuration/index.js';
+import { BaseCompiler } from './base-compiler.js';
+import { TsConfigProvider } from './helpers/tsconfig-provider.js';
+import { PluginsLoader } from './plugins/plugins-loader.js';
+import { TypeScriptBinaryLoader } from './typescript-loader.js';
 type TypescriptWatchCompilerExtras = {
     /**
      * If `undefined`, the value of 'preserveWatchOutput' option from tsconfig

package/lib/compiler/watch-compiler.js

@@ -1,12 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WatchCompiler = void 0;
-const errors_1 = require("../ui/errors");
-const base_compiler_1 = require("./base-compiler");
-const get_value_or_default_1 = require("./helpers/get-value-or-default");
-const manual_restart_1 = require("./helpers/manual-restart");
-const tsconfig_paths_hook_1 = require("./hooks/tsconfig-paths.hook");
-class WatchCompiler extends base_compiler_1.BaseCompiler {
+import { CLI_ERRORS } from '../ui/errors.js';
+import { BaseCompiler } from './base-compiler.js';
+import { getValueOrDefault } from './helpers/get-value-or-default.js';
+import { displayManualRestartTip, listenForManualRestart, } from './helpers/manual-restart.js';
+import { tsconfigPathsBeforeHookFactory } from './hooks/tsconfig-paths.hook.js';
+export class WatchCompiler extends BaseCompiler {
+    tsConfigProvider;
+    typescriptLoader;
     constructor(pluginsLoader, tsConfigProvider, typescriptLoader) {
         super(pluginsLoader);
         this.tsConfigProvider = tsConfigProvider;
@@ -16,7 +15,7 @@ class WatchCompiler extends base_compiler_1.BaseCompiler {
         const tsBin = this.typescriptLoader.load();
         const configPath = tsBin.findConfigFile(process.cwd(), tsBin.sys.fileExists, tsConfigPath);
         if (!configPath) {
-            throw new Error(errors_1.CLI_ERRORS.MISSING_TYPESCRIPT(tsConfigPath));
+            throw new Error(CLI_ERRORS.MISSING_TYPESCRIPT(tsConfigPath));
         }
         const { options, projectReferences } = this.tsConfigProvider.getByConfigFilename(tsConfigPath);
         const createProgram = tsBin.createEmitAndSemanticDiagnosticsBuilderProgram;
@@ -26,12 +25,12 @@ class WatchCompiler extends base_compiler_1.BaseCompiler {
             ...options,
             preserveWatchOutput: extras.preserveWatchOutput ?? options.preserveWatchOutput,
         }, tsBin.sys, createProgram, this.createDiagnosticReporter(origDiagnosticReporter), this.createWatchStatusChanged(origWatchStatusReporter, onSuccess));
-        const manualRestart = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.manualRestart', appName);
+        const manualRestart = getValueOrDefault(configuration, 'compilerOptions.manualRestart', appName);
         const plugins = this.loadPlugins(configuration, tsConfigPath, appName);
         this.overrideCreateProgramFn(host, manualRestart, projectReferences, plugins);
         const watchProgram = tsBin.createWatchProgram(host);
         if (manualRestart) {
-            (0, manual_restart_1.listenForManualRestart)(() => {
+            listenForManualRestart(() => {
                 watchProgram.close();
                 this.run(configuration, tsConfigPath, appName, extras, onSuccess);
             });
@@ -41,10 +40,10 @@ class WatchCompiler extends base_compiler_1.BaseCompiler {
         const origCreateProgram = host.createProgram;
         host.createProgram = (rootNames, options, host, oldProgram) => {
             if (manualRestart) {
-                (0, manual_restart_1.displayManualRestartTip)();
+                displayManualRestartTip();
             }
             const tsconfigPathsPlugin = options
-                ? (0, tsconfig_paths_hook_1.tsconfigPathsBeforeHookFactory)(options)
+                ? tsconfigPathsBeforeHookFactory(options)
                 : null;
             const program = origCreateProgram(rootNames, options, host, oldProgram, undefined, projectReferences);
             const origProgramEmit = program.emit;
@@ -85,4 +84,3 @@ class WatchCompiler extends base_compiler_1.BaseCompiler {
         };
     }
 }
-exports.WatchCompiler = WatchCompiler;

package/lib/compiler/watchers/recursive-directory-watcher.d.ts

@@ -0,0 +1,37 @@
+export interface RecursiveDirectoryWatcherOptions {
+    /**
+     * File suffixes to report events for, e.g. `['.ts']`. Matched with
+     * `String#endsWith`, so both `ts` and `.ts` are accepted.
+     */
+    extensions: string[];
+    /**
+     * Called with the path of a file that appeared after the initial scan.
+     */
+    onAdd?: (file: string) => unknown;
+    /**
+     * Called with the path of a file that was modified after the initial scan.
+     */
+    onChange?: (file: string) => unknown;
+    /**
+     * Equivalent of chokidar's "awaitWriteFinish": an event is only reported
+     * once the file size stopped changing for that many milliseconds.
+     */
+    stabilityThreshold?: number;
+    pollInterval?: number;
+}
+export interface RecursiveDirectoryWatcher {
+    close(): Promise<void>;
+}
+export declare function supportsNativeRecursiveWatch(platform?: string): boolean;
+/**
+ * Watches a directory tree for added and changed files.
+ *
+ * On macOS chokidar (since v4, which dropped the bundled `fsevents` backend)
+ * falls back to `fs.watch` per file, and libuv only uses FSEvents for
+ * directories - so every watched file permanently costs a file descriptor and
+ * a medium-sized project quickly hits `EMFILE`. A single recursive `fs.watch`
+ * over the directory costs one handle for the whole tree instead.
+ *
+ * See https://github.com/nestjs/nest-cli/issues/3512
+ */
+export declare function watchDirectoryRecursively(dir: string, options: RecursiveDirectoryWatcherOptions): Promise<RecursiveDirectoryWatcher>;