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

package/lib/compiler/watchers/recursive-directory-watcher.js

@@ -0,0 +1,334 @@
+import * as chokidar from 'chokidar';
+import { watch as watchFs } from 'fs';
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+const DEFAULT_STABILITY_THRESHOLD = 50;
+const DEFAULT_POLL_INTERVAL = 10;
+const RESCAN_DEBOUNCE = 100;
+/**
+ * A recursive "fs.watch" only starts delivering once its underlying stream is
+ * running, which happens some time after "fs.watch" returns - measurably later
+ * on a loaded machine. Anything written in that window produces no event at
+ * all, so the tree is diffed a few times while the stream warms up; without
+ * this a file added moments after the watch started is never compiled.
+ */
+const CATCH_UP_SCAN_DELAYS = [100, 500, 1_500];
+const REARM_INTERVAL = 500;
+const DIRECTORY_EXISTENCE_CHECK_INTERVAL = 1_000;
+/**
+ * Platforms on which libuv implements `fs.watch(dir, { recursive: true })`
+ * natively (FSEvents on macOS, ReadDirectoryChangesW on Windows), so that a
+ * whole tree costs a single handle. Everywhere else Node either emulates it in
+ * JavaScript (Linux, only since v20.13) or does not support it at all, so
+ * chokidar - which is already O(directories) there - stays in charge.
+ */
+const NATIVE_RECURSIVE_WATCH_PLATFORMS = new Set([
+    'darwin',
+    'win32',
+]);
+export function supportsNativeRecursiveWatch(platform = process.platform) {
+    return NATIVE_RECURSIVE_WATCH_PLATFORMS.has(platform);
+}
+/**
+ * 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 async function watchDirectoryRecursively(dir, options) {
+    if (supportsNativeRecursiveWatch()) {
+        return new NativeRecursiveDirectoryWatcher(dir, options).start();
+    }
+    return createChokidarWatcher(dir, options);
+}
+async function createChokidarWatcher(dir, options) {
+    const watcher = chokidar.watch(dir, {
+        ignored: (file, stats) => (stats?.isFile() &&
+            !matchesExtension(file, options.extensions)),
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: options.stabilityThreshold ?? DEFAULT_STABILITY_THRESHOLD,
+            pollInterval: options.pollInterval ?? DEFAULT_POLL_INTERVAL,
+        },
+    });
+    // Chokidar swallows everything it encounters during its initial scan (that
+    // is what "ignoreInitial" means), so the watch is only truly active once
+    // "ready" has fired. Resolving before that would silently drop every file
+    // written in between - the caller has no other signal to wait on.
+    await new Promise((resolve) => {
+        // Chokidar rethrows an "error" that has no listener; scanning a tree that
+        // is being rewritten underneath is not fatal, so it must not take the
+        // process down either.
+        watcher.on('error', () => resolve());
+        watcher.once('ready', () => resolve());
+    });
+    if (options.onAdd) {
+        watcher.on('add', (file) => void options.onAdd(file));
+    }
+    if (options.onChange) {
+        watcher.on('change', (file) => void options.onChange(file));
+    }
+    return {
+        close: () => watcher.close(),
+    };
+}
+function matchesExtension(file, extensions) {
+    return extensions.some((extension) => file.endsWith(extension));
+}
+class NativeRecursiveDirectoryWatcher {
+    dir;
+    options;
+    /** Known files mapped to the modification time we last reported. */
+    known = new Map();
+    pending = new Map();
+    stabilityThreshold;
+    pollInterval;
+    watcher;
+    existenceTimer;
+    rearmTimer;
+    rescanTimer;
+    catchUpTimers = new Set();
+    closed = false;
+    constructor(dir, options) {
+        this.dir = dir;
+        this.options = options;
+        this.stabilityThreshold =
+            options.stabilityThreshold ?? DEFAULT_STABILITY_THRESHOLD;
+        this.pollInterval = options.pollInterval ?? DEFAULT_POLL_INTERVAL;
+    }
+    async start() {
+        // Snapshot before arming the watcher so that the files that already exist
+        // are not reported, mirroring chokidar's "ignoreInitial".
+        await this.scan(false);
+        this.arm();
+        return this;
+    }
+    async close() {
+        this.closed = true;
+        clearTimeout(this.rearmTimer);
+        clearTimeout(this.rescanTimer);
+        this.clearCatchUpScans();
+        for (const { timer } of this.pending.values()) {
+            clearTimeout(timer);
+        }
+        this.pending.clear();
+        this.disposeWatcher();
+    }
+    arm() {
+        if (this.closed) {
+            return;
+        }
+        try {
+            this.watcher = watchFs(this.dir, { recursive: true }, (_, filename) => this.handleEvent(filename));
+        }
+        catch {
+            // The directory does not exist (yet) - "outDir" is only created by the
+            // first successful build - or the platform refused the recursive watch.
+            this.scheduleRearm();
+            return;
+        }
+        // A watcher whose directory is removed stops emitting instead of failing,
+        // so its liveness is checked separately.
+        this.watcher.on('error', () => this.rearm());
+        this.existenceTimer = setInterval(() => {
+            void stat(this.dir)
+                .then((stats) => {
+                if (!stats.isDirectory()) {
+                    this.rearm();
+                }
+            })
+                .catch(() => this.rearm());
+        }, DIRECTORY_EXISTENCE_CHECK_INTERVAL);
+        this.existenceTimer.unref?.();
+        this.scheduleCatchUpScans();
+    }
+    scheduleCatchUpScans() {
+        for (const delay of CATCH_UP_SCAN_DELAYS) {
+            const timer = setTimeout(() => {
+                this.catchUpTimers.delete(timer);
+                void this.scan(true);
+            }, delay);
+            timer.unref?.();
+            this.catchUpTimers.add(timer);
+        }
+    }
+    clearCatchUpScans() {
+        for (const timer of this.catchUpTimers) {
+            clearTimeout(timer);
+        }
+        this.catchUpTimers.clear();
+    }
+    handleEvent(filename) {
+        if (this.closed) {
+            return;
+        }
+        if (!filename) {
+            // macOS coalesces some events and reports no filename at all; fall back
+            // to diffing the tree.
+            this.scheduleRescan();
+            return;
+        }
+        const file = join(this.dir, filename.toString());
+        if (!matchesExtension(file, this.options.extensions)) {
+            return;
+        }
+        this.settle(file);
+    }
+    scheduleRescan() {
+        if (this.closed || this.rescanTimer) {
+            return;
+        }
+        this.rescanTimer = setTimeout(() => {
+            this.rescanTimer = undefined;
+            void this.scan(true);
+        }, RESCAN_DEBOUNCE);
+        this.rescanTimer.unref?.();
+    }
+    /**
+     * Walks the tree and, when `emit` is set, reports the files that were added
+     * or modified since the last walk. Reading the tree does not hold any handle.
+     */
+    async scan(emit) {
+        let entries;
+        try {
+            entries = await readdir(this.dir, {
+                recursive: true,
+                withFileTypes: true,
+            });
+        }
+        catch {
+            // Directory is gone; everything it held counts as removed.
+            this.known.clear();
+            return;
+        }
+        if (this.closed) {
+            return;
+        }
+        const seen = new Set();
+        for (const entry of entries) {
+            if (!entry.isFile()) {
+                continue;
+            }
+            const file = join(entry.parentPath ?? entry.path, entry.name);
+            if (!matchesExtension(file, this.options.extensions)) {
+                continue;
+            }
+            seen.add(file);
+            const mtimeMs = await stat(file)
+                .then((stats) => stats.mtimeMs)
+                .catch(() => undefined);
+            if (mtimeMs === undefined) {
+                continue;
+            }
+            if (!emit) {
+                this.known.set(file, mtimeMs);
+                continue;
+            }
+            if (this.known.get(file) !== mtimeMs) {
+                this.settle(file);
+            }
+        }
+        for (const file of this.known.keys()) {
+            if (!seen.has(file)) {
+                this.known.delete(file);
+            }
+        }
+    }
+    /**
+     * Delays reporting until the file stopped growing, so that a half-written
+     * file is never handed over to the compiler.
+     */
+    settle(file) {
+        const pending = this.pending.get(file);
+        if (pending) {
+            clearTimeout(pending.timer);
+        }
+        const state = {
+            size: -1,
+            stableSince: Date.now(),
+            timer: undefined,
+        };
+        state.timer = setTimeout(() => void this.poll(file), this.pollInterval);
+        this.pending.set(file, state);
+    }
+    async poll(file) {
+        const state = this.pending.get(file);
+        if (this.closed || !state) {
+            return;
+        }
+        const stats = await stat(file).catch(() => undefined);
+        if (this.closed) {
+            return;
+        }
+        if (!stats) {
+            // Removed (or renamed away) before it settled.
+            this.pending.delete(file);
+            this.known.delete(file);
+            return;
+        }
+        const now = Date.now();
+        if (stats.size !== state.size) {
+            state.size = stats.size;
+            state.stableSince = now;
+        }
+        if (now - state.stableSince >= this.stabilityThreshold) {
+            this.pending.delete(file);
+            this.emit(file, stats.mtimeMs);
+            return;
+        }
+        state.timer = setTimeout(() => void this.poll(file), this.pollInterval);
+    }
+    emit(file, mtimeMs) {
+        const isKnown = this.known.has(file);
+        this.known.set(file, mtimeMs);
+        if (isKnown) {
+            void this.options.onChange?.(file);
+        }
+        else {
+            void this.options.onAdd?.(file);
+        }
+    }
+    rearm() {
+        if (this.closed) {
+            return;
+        }
+        this.disposeWatcher();
+        this.known.clear();
+        this.scheduleRearm();
+    }
+    scheduleRearm() {
+        if (this.closed || this.rearmTimer) {
+            return;
+        }
+        this.rearmTimer = setTimeout(() => {
+            this.rearmTimer = undefined;
+            if (this.closed) {
+                return;
+            }
+            void stat(this.dir)
+                .then(async (stats) => {
+                if (!stats.isDirectory()) {
+                    this.scheduleRearm();
+                    return;
+                }
+                this.arm();
+                // The tree may have been (re)populated while unwatched.
+                await this.scan(true);
+            })
+                .catch(() => this.scheduleRearm());
+        }, REARM_INTERVAL);
+        this.rearmTimer.unref?.();
+    }
+    disposeWatcher() {
+        this.clearCatchUpScans();
+        clearInterval(this.existenceTimer);
+        this.existenceTimer = undefined;
+        this.watcher?.close();
+        this.watcher = undefined;
+    }
+}

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

@@ -1,13 +1,12 @@
-import { Input } from '../../commands';
-import { Configuration } from '../configuration';
-import { AssetsManager } from './assets-manager';
-import { BaseCompiler } from './base-compiler';
-import { PluginsLoader } from './plugins/plugins-loader';
-import webpack = require('webpack');
+import { Configuration } from '../configuration/index.js';
+import { AssetsManager } from './assets-manager.js';
+import { BaseCompiler } from './base-compiler.js';
+import { PluginsLoader } from './plugins/plugins-loader.js';
+import type webpack from 'webpack';
 type WebpackConfigFactory = (config: webpack.Configuration, webpackRef: typeof webpack) => webpack.Configuration;
 type WebpackConfigFactoryOrConfig = WebpackConfigFactory | webpack.Configuration;
 type WebpackCompilerExtras = {
-    inputs: Input[];
+    options: Record<string, any>;
     assetsManager: AssetsManager;
     webpackConfigFactoryOrConfig: WebpackConfigFactoryOrConfig | WebpackConfigFactoryOrConfig[];
     debug?: boolean;

package/lib/compiler/webpack-compiler.js

@@ -1,28 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebpackCompiler = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const ui_1 = require("../ui");
-const base_compiler_1 = require("./base-compiler");
-const webpack_defaults_1 = require("./defaults/webpack-defaults");
-const get_value_or_default_1 = require("./helpers/get-value-or-default");
-const webpack = require("webpack");
-class WebpackCompiler extends base_compiler_1.BaseCompiler {
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import { join } from 'path';
+import { ERROR_PREFIX, INFO_PREFIX } from '../ui/index.js';
+import { isEsmProject } from '../utils/is-esm-project.js';
+import { BaseCompiler } from './base-compiler.js';
+import { webpackDefaultsFactory } from './defaults/webpack-defaults.js';
+import { getValueOrDefault } from './helpers/get-value-or-default.js';
+const WEBPACK_DEPRECATION_MSG = 'The webpack compiler is deprecated and will be removed in a future major version. ' +
+    'Please migrate to rspack (--builder rspack). ' +
+    'See https://docs.nestjs.com/cli/usages#build for details.';
+const require = createRequire(import.meta.url);
+function loadWebpack() {
+    try {
+        return require('webpack');
+    }
+    catch {
+        throw new Error('webpack is not installed. To use the webpack compiler, install the required packages:\n\n' +
+            '  npm install --save-dev webpack webpack-node-externals tsconfig-paths-webpack-plugin ts-loader\n');
+    }
+}
+export class WebpackCompiler extends BaseCompiler {
     constructor(pluginsLoader) {
         super(pluginsLoader);
     }
     run(configuration, tsConfigPath, appName, extras, onSuccess) {
         const cwd = process.cwd();
-        const configPath = (0, path_1.join)(cwd, tsConfigPath);
-        if (!(0, fs_1.existsSync)(configPath)) {
+        const configPath = join(cwd, tsConfigPath);
+        if (!existsSync(configPath)) {
             throw new Error(`Could not find TypeScript configuration file "${tsConfigPath}".`);
         }
         const plugins = this.loadPlugins(configuration, tsConfigPath, appName);
         const pathToSource = this.getPathToSource(configuration, tsConfigPath, appName);
-        const entryFile = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'entryFile', appName, 'entryFile', extras.inputs);
-        const entryFileRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'root', appName) || '';
-        const defaultOptions = (0, webpack_defaults_1.webpackDefaultsFactory)(pathToSource, entryFileRoot, entryFile, extras.debug ?? false, tsConfigPath, plugins);
+        const entryFile = getValueOrDefault(configuration, 'entryFile', appName, 'entryFile', extras.options);
+        const entryFileRoot = getValueOrDefault(configuration, 'root', appName) || '';
+        if (isEsmProject()) {
+            throw new Error('The webpack compiler does not support ESM projects ("type": "module" in package.json). ' +
+                'Please use rspack instead by setting "builder": "rspack" in your nest-cli.json compilerOptions, ' +
+                'or use --builder rspack on the command line.');
+        }
+        console.warn(`\n${INFO_PREFIX} ${WEBPACK_DEPRECATION_MSG}\n`);
+        const defaultOptions = webpackDefaultsFactory(pathToSource, entryFileRoot, entryFile, extras.debug ?? false, tsConfigPath, plugins);
+        const wp = loadWebpack();
         let compiler;
         let watchOptions;
         let watch;
@@ -30,34 +48,34 @@ class WebpackCompiler extends base_compiler_1.BaseCompiler {
             const webpackConfigurations = extras.webpackConfigFactoryOrConfig.map((configOrFactory) => {
                 const unwrappedConfig = typeof configOrFactory !== 'function'
                     ? configOrFactory
-                    : configOrFactory(defaultOptions, webpack);
+                    : configOrFactory(defaultOptions, wp);
                 return {
                     ...defaultOptions,
                     mode: extras.watchMode ? 'development' : defaultOptions.mode,
                     ...unwrappedConfig,
                 };
             });
-            compiler = webpack(webpackConfigurations);
+            compiler = wp(webpackConfigurations);
             watchOptions = webpackConfigurations.map((config) => config.watchOptions || {});
             watch = webpackConfigurations.some((config) => config.watch);
         }
         else {
             const projectWebpackOptions = typeof extras.webpackConfigFactoryOrConfig !== 'function'
                 ? extras.webpackConfigFactoryOrConfig
-                : extras.webpackConfigFactoryOrConfig(defaultOptions, webpack);
+                : extras.webpackConfigFactoryOrConfig(defaultOptions, wp);
             const webpackConfiguration = {
                 ...defaultOptions,
                 mode: extras.watchMode ? 'development' : defaultOptions.mode,
                 ...projectWebpackOptions,
             };
-            compiler = webpack(webpackConfiguration);
+            compiler = wp(webpackConfiguration);
             watchOptions = webpackConfiguration.watchOptions;
             watch = webpackConfiguration.watch;
         }
         const afterCallback = this.createAfterCallback(onSuccess, extras.assetsManager, extras.watchMode ?? false, watch);
         if (extras.watchMode || watch) {
             compiler.hooks.watchRun.tapAsync('Rebuild info', (params, callback) => {
-                console.log(`\n${ui_1.INFO_PREFIX} Webpack is building your sources...\n`);
+                console.log(`\n${INFO_PREFIX} Webpack is building your sources...\n`);
                 callback();
             });
             compiler.watch(watchOptions || {}, afterCallback);
@@ -82,7 +100,13 @@ class WebpackCompiler extends base_compiler_1.BaseCompiler {
             });
             if (!err && !stats.hasErrors()) {
                 if (!onSuccess) {
-                    assetsManager.closeWatchers();
+                    // webpack ignores whatever this callback returns, so the close is
+                    // handled here rather than awaited — but its rejection still has to
+                    // be caught or it terminates the CLI after a successful compile.
+                    assetsManager.closeWatchers().catch((error) => {
+                        console.error(`${ERROR_PREFIX} Failed to close asset watchers. ` +
+                            `${error instanceof Error ? error.message : String(error)}`);
+                    });
                 }
                 else {
                     onSuccess();
@@ -96,4 +120,3 @@ class WebpackCompiler extends base_compiler_1.BaseCompiler {
         };
     }
 }
-exports.WebpackCompiler = WebpackCompiler;

package/lib/configuration/configuration.d.ts

@@ -13,6 +13,7 @@ export interface ActionOnFile {
     path: string;
     sourceRoot: string;
     watchAssetsMode: boolean;
+    confinePathsToProject: boolean;
 }
 export interface SwcBuilderOptions {
     swcrcPath?: string;
@@ -27,13 +28,19 @@ export interface SwcBuilderOptions {
 export interface WebpackBuilderOptions {
     configPath?: string;
 }
+export interface RspackBuilderOptions {
+    configPath?: string;
+}
 export interface TscBuilderOptions {
     configPath?: string;
 }
-export type BuilderVariant = 'tsc' | 'swc' | 'webpack';
+export type BuilderVariant = 'tsc' | 'swc' | 'webpack' | 'rspack';
 export type Builder = BuilderVariant | {
     type: 'webpack';
     options?: WebpackBuilderOptions;
+} | {
+    type: 'rspack';
+    options?: RspackBuilderOptions;
 } | {
     type: 'swc';
     options?: SwcBuilderOptions;
@@ -54,12 +61,19 @@ export interface CompilerOptions {
     plugins?: string[] | PluginOptions[];
     assets?: Asset[];
     deleteOutDir?: boolean;
+    allowOutsidePaths?: boolean;
     manualRestart?: boolean;
     builder?: Builder;
+    emitDeclarations?: boolean;
+    /**
+     * List of library project names whose assets should also be copied
+     * when building this application.
+     */
+    includeLibraryAssets?: string[];
 }
 export interface PluginOptions {
     name: string;
-    options: Record<string, any>[];
+    options: Record<string, any>;
 }
 export interface GenerateOptions {
     spec?: boolean | Record<string, boolean>;
@@ -76,7 +90,6 @@ export interface ProjectConfiguration {
     compilerOptions?: CompilerOptions;
 }
 export interface Configuration {
-    [key: string]: any;
     language?: string;
     collection?: string;
     sourceRoot?: string;

package/lib/configuration/configuration.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/lib/configuration/configuration.loader.d.ts

@@ -1,4 +1,4 @@
-import { Configuration } from './configuration';
+import { Configuration } from './configuration.js';
 export interface ConfigurationLoader {
     load(name?: string): Required<Configuration> | Promise<Required<Configuration>>;
 }

package/lib/configuration/configuration.loader.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/lib/configuration/defaults.d.ts

@@ -1,6 +1,7 @@
-import { Configuration } from './configuration';
+import { Configuration } from './configuration.js';
 export declare const defaultConfiguration: Required<Configuration>;
 export declare const defaultTsconfigFilename: string;
 export declare const defaultWebpackConfigFilename = "webpack.config.js";
+export declare const defaultRspackConfigFilename = "rspack.config.js";
 export declare const defaultOutDir = "dist";
 export declare const defaultGitIgnore = "# compiled output\n/dist\n/node_modules\n/build\n\n# Logs\nlogs\n*.log\nnpm-debug.log*\npnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\nlerna-debug.log*\n\n# OS\n.DS_Store\n\n# Tests\n/coverage\n/.nyc_output\n\n# IDEs and editors\n/.idea\n.project\n.classpath\n.c9/\n*.launch\n.settings/\n*.sublime-workspace\n\n# IDE - VSCode\n.vscode/*\n!.vscode/settings.json\n!.vscode/tasks.json\n!.vscode/launch.json\n!.vscode/extensions.json\n\n# dotenv environment variable files\n.env\n.env.development.local\n.env.test.local\n.env.production.local\n.env.local\n\n# temp directory\n.temp\n.tmp\n\n# Runtime data\npids\n*.pid\n*.seed\n*.pid.lock\n\n# Diagnostic reports (https://nodejs.org/api/report.html)\nreport.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json\n";

package/lib/configuration/defaults.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultGitIgnore = exports.defaultOutDir = exports.defaultWebpackConfigFilename = exports.defaultTsconfigFilename = exports.defaultConfiguration = void 0;
-const get_default_tsconfig_path_1 = require("../utils/get-default-tsconfig-path");
-exports.defaultConfiguration = {
+import { getDefaultTsconfigPath } from '../utils/get-default-tsconfig-path.js';
+export const defaultConfiguration = {
     language: 'ts',
     sourceRoot: 'src',
     collection: '@nestjs/schematics',
@@ -14,7 +11,7 @@ exports.defaultConfiguration = {
         builder: {
             type: 'tsc',
             options: {
-                configPath: (0, get_default_tsconfig_path_1.getDefaultTsconfigPath)(),
+                configPath: getDefaultTsconfigPath(),
             },
         },
         webpack: false,
@@ -24,10 +21,11 @@ exports.defaultConfiguration = {
     },
     generateOptions: {},
 };
-exports.defaultTsconfigFilename = (0, get_default_tsconfig_path_1.getDefaultTsconfigPath)();
-exports.defaultWebpackConfigFilename = 'webpack.config.js';
-exports.defaultOutDir = 'dist';
-exports.defaultGitIgnore = `# compiled output
+export const defaultTsconfigFilename = getDefaultTsconfigPath();
+export const defaultWebpackConfigFilename = 'webpack.config.js';
+export const defaultRspackConfigFilename = 'rspack.config.js';
+export const defaultOutDir = 'dist';
+export const defaultGitIgnore = `# compiled output
 /dist
 /node_modules
 /build

package/lib/configuration/index.d.ts

@@ -1,3 +1,3 @@
-export * from './configuration.loader';
-export * from './nest-configuration.loader';
-export * from './configuration';
+export * from './configuration.loader.js';
+export * from './nest-configuration.loader.js';
+export * from './configuration.js';

package/lib/configuration/index.js

@@ -1,19 +1,3 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./configuration.loader"), exports);
-__exportStar(require("./nest-configuration.loader"), exports);
-__exportStar(require("./configuration"), exports);
+export * from './configuration.loader.js';
+export * from './nest-configuration.loader.js';
+export * from './configuration.js';

package/lib/configuration/nest-configuration.loader.d.ts

@@ -1,6 +1,6 @@
-import { Reader } from '../readers';
-import { Configuration } from './configuration';
-import { ConfigurationLoader } from './configuration.loader';
+import { Reader } from '../readers/index.js';
+import { Configuration } from './configuration.js';
+import { ConfigurationLoader } from './configuration.loader.js';
 export declare class NestConfigurationLoader implements ConfigurationLoader {
     private readonly reader;
     constructor(reader: Reader);