@nestjs/cli 11.0.16 → 12.0.0-alpha.1

package/commands/generate.command.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenerateCommand = void 0;
-const ansis_1 = require("ansis");
-const Table = require("cli-table3");
-const schematics_1 = require("../lib/schematics");
-const load_configuration_1 = require("../lib/utils/load-configuration");
-const abstract_command_1 = require("./abstract.command");
-class GenerateCommand extends abstract_command_1.AbstractCommand {
+import { bold, cyan, green } from 'ansis';
+import Table from 'cli-table3';
+import { CollectionFactory } from '../lib/schematics/index.js';
+import { loadConfiguration } from '../lib/utils/load-configuration.js';
+import { AbstractCommand } from './abstract.command.js';
+export class GenerateCommand extends AbstractCommand {
     async load(program) {
         program
             .command('generate <schematic> [name] [path]')
@@ -18,57 +15,33 @@ class GenerateCommand extends abstract_command_1.AbstractCommand {
             .option('--no-flat', 'Enforce that directories are generated.', () => false)
             .option('--spec', 'Enforce spec files generation.', () => {
             return { value: true, passedAsInput: true };
-        }, true)
+        }, { value: true, passedAsInput: false })
             .option('--spec-file-suffix [suffix]', 'Use a custom suffix for spec files.')
             .option('--skip-import', 'Skip importing', () => true, false)
             .option('--no-spec', 'Disable spec files generation.', () => {
             return { value: false, passedAsInput: true };
         })
             .option('-c, --collection [collectionName]', 'Schematics collection to use.')
-            .action(async (schematic, name, path, command) => {
-            const options = [];
-            options.push({ name: 'dry-run', value: !!command.dryRun });
-            if (command.flat !== undefined) {
-                options.push({ name: 'flat', value: command.flat });
-            }
-            options.push({
-                name: 'spec',
-                value: typeof command.spec === 'boolean'
-                    ? command.spec
-                    : command.spec.value,
-                options: {
-                    passedAsInput: typeof command.spec === 'boolean'
-                        ? false
-                        : command.spec.passedAsInput,
-                },
-            });
-            options.push({
-                name: 'specFileSuffix',
-                value: command.specFileSuffix,
-            });
-            options.push({
-                name: 'collection',
-                value: command.collection,
-            });
-            options.push({
-                name: 'project',
-                value: command.project,
-            });
-            options.push({
-                name: 'skipImport',
-                value: command.skipImport,
-            });
-            const inputs = [];
-            inputs.push({ name: 'schematic', value: schematic });
-            inputs.push({ name: 'name', value: name });
-            inputs.push({ name: 'path', value: path });
-            await this.action.handle(inputs, options);
+            .action(async (schematic, name, path, options) => {
+            const context = {
+                schematic,
+                name,
+                path,
+                dryRun: !!options.dryRun,
+                flat: options.flat,
+                spec: options.spec,
+                specFileSuffix: options.specFileSuffix,
+                collection: options.collection,
+                project: options.project,
+                skipImport: options.skipImport,
+            };
+            await this.action.handle(context);
         });
     }
     async buildDescription() {
         const collection = await this.getCollection();
         return ('Generate a Nest element.\n' +
-            `  Schematics available on ${(0, ansis_1.bold)(collection)} collection:\n` +
+            `  Schematics available on ${bold(collection)} collection:\n` +
             this.buildSchematicsListAsTable(await this.getSchematics(collection)));
     }
     buildSchematicsListAsTable(schematics) {
@@ -88,20 +61,19 @@ class GenerateCommand extends abstract_command_1.AbstractCommand {
         const table = new Table(tableConfig);
         for (const schematic of schematics) {
             table.push([
-                (0, ansis_1.green)(schematic.name),
-                (0, ansis_1.cyan)(schematic.alias),
+                green(schematic.name),
+                cyan(schematic.alias),
                 schematic.description,
             ]);
         }
         return table.toString();
     }
     async getCollection() {
-        const configuration = await (0, load_configuration_1.loadConfiguration)();
+        const configuration = await loadConfiguration();
         return configuration.collection;
     }
     async getSchematics(collection) {
-        const abstractCollection = schematics_1.CollectionFactory.create(collection);
+        const abstractCollection = CollectionFactory.create(collection);
         return abstractCollection.getSchematics();
     }
 }
-exports.GenerateCommand = GenerateCommand;

package/commands/index.d.ts

@@ -1,2 +1,3 @@
-export * from './command.loader';
-export * from './command.input';
+export * from './command.input.js';
+export * from './command.loader.js';
+export * from './context/index.js';

package/commands/index.js

@@ -1,18 +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("./command.loader"), exports);
-__exportStar(require("./command.input"), exports);
+export * from './command.input.js';
+export * from './command.loader.js';
+export * from './context/index.js';

package/commands/info.command.d.ts

@@ -1,5 +1,5 @@
-import { CommanderStatic } from 'commander';
-import { AbstractCommand } from './abstract.command';
+import { Command } from 'commander';
+import { AbstractCommand } from './abstract.command.js';
 export declare class InfoCommand extends AbstractCommand {
-    load(program: CommanderStatic): void;
+    load(program: Command): void;
 }

package/commands/info.command.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InfoCommand = void 0;
-const abstract_command_1 = require("./abstract.command");
-class InfoCommand extends abstract_command_1.AbstractCommand {
+import { AbstractCommand } from './abstract.command.js';
+export class InfoCommand extends AbstractCommand {
     load(program) {
         program
             .command('info')
@@ -13,4 +10,3 @@ class InfoCommand extends abstract_command_1.AbstractCommand {
         });
     }
 }
-exports.InfoCommand = InfoCommand;

package/commands/new.command.d.ts

@@ -1,5 +1,5 @@
-import { CommanderStatic } from 'commander';
-import { AbstractCommand } from './abstract.command';
+import { Command } from 'commander';
+import { AbstractCommand } from './abstract.command.js';
 export declare class NewCommand extends AbstractCommand {
-    load(program: CommanderStatic): void;
+    load(program: Command): void;
 }

package/commands/new.command.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NewCommand = void 0;
-const schematics_1 = require("../lib/schematics");
-const abstract_command_1 = require("./abstract.command");
-class NewCommand extends abstract_command_1.AbstractCommand {
+import { Collection } from '../lib/schematics/index.js';
+import { AbstractCommand } from './abstract.command.js';
+export class NewCommand extends AbstractCommand {
     load(program) {
         program
             .command('new [name]')
@@ -15,47 +12,41 @@ class NewCommand extends abstract_command_1.AbstractCommand {
             .option('-s, --skip-install', 'Skip package installation.', false)
             .option('-p, --package-manager [packageManager]', 'Specify package manager.')
             .option('-l, --language [language]', 'Programming language to be used (TypeScript or JavaScript)', 'TypeScript')
-            .option('-c, --collection [collectionName]', 'Schematics collection to use', schematics_1.Collection.NESTJS)
+            .option('-c, --collection [collectionName]', 'Schematics collection to use', Collection.NESTJS)
             .option('--strict', 'Enables strict mode in TypeScript.', false)
-            .action(async (name, command) => {
-            const options = [];
+            .action(async (name, options) => {
             const availableLanguages = ['js', 'ts', 'javascript', 'typescript'];
-            options.push({ name: 'directory', value: command.directory });
-            options.push({ name: 'dry-run', value: command.dryRun });
-            options.push({ name: 'skip-git', value: command.skipGit });
-            options.push({ name: 'skip-install', value: command.skipInstall });
-            options.push({ name: 'strict', value: command.strict });
-            options.push({
-                name: 'packageManager',
-                value: command.packageManager,
-            });
-            options.push({ name: 'collection', value: command.collection });
-            if (!!command.language) {
-                const lowercasedLanguage = command.language.toLowerCase();
+            let language = options.language;
+            if (language) {
+                const lowercasedLanguage = language.toLowerCase();
                 const langMatch = availableLanguages.includes(lowercasedLanguage);
                 if (!langMatch) {
-                    throw new Error(`Invalid language "${command.language}" selected. Available languages are "typescript" or "javascript"`);
+                    throw new Error(`Invalid language "${language}" selected. Available languages are "typescript" or "javascript"`);
                 }
                 switch (lowercasedLanguage) {
                     case 'javascript':
-                        command.language = 'js';
+                        language = 'js';
                         break;
                     case 'typescript':
-                        command.language = 'ts';
+                        language = 'ts';
                         break;
                     default:
-                        command.language = lowercasedLanguage;
+                        language = lowercasedLanguage;
                         break;
                 }
             }
-            options.push({
-                name: 'language',
-                value: command.language,
-            });
-            const inputs = [];
-            inputs.push({ name: 'name', value: name });
-            await this.action.handle(inputs, options);
+            const context = {
+                name,
+                directory: options.directory,
+                dryRun: options.dryRun,
+                skipGit: options.skipGit,
+                skipInstall: options.skipInstall,
+                packageManager: options.packageManager,
+                language,
+                collection: options.collection,
+                strict: options.strict,
+            };
+            await this.action.handle(context);
         });
     }
 }
-exports.NewCommand = NewCommand;

package/commands/start.command.d.ts

@@ -1,5 +1,5 @@
-import { CommanderStatic } from 'commander';
-import { AbstractCommand } from './abstract.command';
+import { Command } from 'commander';
+import { AbstractCommand } from './abstract.command.js';
 export declare class StartCommand extends AbstractCommand {
-    load(program: CommanderStatic): void;
+    load(program: Command): void;
 }

package/commands/start.command.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StartCommand = void 0;
-const ui_1 = require("../lib/ui");
-const remaining_flags_1 = require("../lib/utils/remaining-flags");
-const abstract_command_1 = require("./abstract.command");
-class StartCommand extends abstract_command_1.AbstractCommand {
+import { ERROR_PREFIX } from '../lib/ui/index.js';
+import { getRemainingFlags } from '../lib/utils/remaining-flags.js';
+import { AbstractCommand } from './abstract.command.js';
+export class StartCommand extends AbstractCommand {
     load(program) {
         const collect = (value, previous) => {
             return previous.concat([value]);
@@ -15,7 +12,7 @@ class StartCommand extends abstract_command_1.AbstractCommand {
             .option('-c, --config [path]', 'Path to nest-cli configuration file.')
             .option('-p, --path [path]', 'Path to tsconfig file.')
             .option('-w, --watch', 'Run in watch mode (live-reload).')
-            .option('-b, --builder [name]', 'Builder to be used (tsc, webpack, swc).')
+            .option('-b, --builder [name]', 'Builder to be used (tsc, webpack, swc, rspack).')
             .option('--watchAssets', 'Watch non-ts (e.g., .graphql) files mode.')
             .option('-d, --debug [hostport] ', 'Run in debug mode (with --inspect flag).')
             .option('--webpack', 'Use webpack for compilation (deprecated option, use --builder instead).')
@@ -30,75 +27,41 @@ class StartCommand extends abstract_command_1.AbstractCommand {
             .option('--no-shell', 'Do not spawn child processes within a shell.')
             .option('--env-file [path]', 'Path to an env file (.env) to be loaded into the environment.', collect, [])
             .description('Run Nest application.')
-            .action(async (app, command) => {
-            const options = [];
-            options.push({
-                name: 'config',
-                value: command.config,
-            });
-            const isWebpackEnabled = command.tsc ? false : command.webpack;
-            options.push({ name: 'webpack', value: isWebpackEnabled });
-            options.push({ name: 'debug', value: command.debug });
-            options.push({ name: 'watch', value: !!command.watch });
-            options.push({ name: 'watchAssets', value: !!command.watchAssets });
-            options.push({
-                name: 'path',
-                value: command.path,
-            });
-            options.push({
-                name: 'webpackPath',
-                value: command.webpackPath,
-            });
-            options.push({
-                name: 'exec',
-                value: command.exec,
-            });
-            options.push({
-                name: 'sourceRoot',
-                value: command.sourceRoot,
-            });
-            options.push({
-                name: 'entryFile',
-                value: command.entryFile,
-            });
-            options.push({
-                name: 'preserveWatchOutput',
-                value: !!command.preserveWatchOutput &&
-                    !!command.watch &&
-                    !isWebpackEnabled,
-            });
-            options.push({
-                name: 'shell',
-                value: !!command.shell,
-            });
-            options.push({
-                name: 'envFile',
-                value: command.envFile,
-            });
-            const availableBuilders = ['tsc', 'webpack', 'swc'];
-            if (command.builder && !availableBuilders.includes(command.builder)) {
-                console.error(ui_1.ERROR_PREFIX +
-                    ` Invalid builder option: ${command.builder}. Available builders: ${availableBuilders.join(', ')}`);
+            .action(async (app, options) => {
+            const isWebpackEnabled = options.tsc ? false : options.webpack;
+            const availableBuilders = ['tsc', 'webpack', 'swc', 'rspack'];
+            if (options.builder && !availableBuilders.includes(options.builder)) {
+                console.error(ERROR_PREFIX +
+                    ` Invalid builder option: ${options.builder}. Available builders: ${availableBuilders.join(', ')}`);
                 return;
             }
-            options.push({
-                name: 'builder',
-                value: command.builder,
-            });
-            options.push({
-                name: 'typeCheck',
-                value: command.typeCheck,
-            });
-            const inputs = [];
-            inputs.push({ name: 'app', value: app });
-            const flags = (0, remaining_flags_1.getRemainingFlags)(program);
+            const context = {
+                app,
+                config: options.config,
+                webpack: isWebpackEnabled,
+                watch: !!options.watch,
+                watchAssets: !!options.watchAssets,
+                path: options.path,
+                webpackPath: options.webpackPath,
+                builder: options.builder,
+                typeCheck: options.typeCheck,
+                preserveWatchOutput: !!options.preserveWatchOutput &&
+                    !!options.watch &&
+                    !isWebpackEnabled,
+                debug: options.debug,
+                exec: options.exec,
+                sourceRoot: options.sourceRoot,
+                entryFile: options.entryFile,
+                shell: !!options.shell,
+                envFile: options.envFile ?? [],
+                extraFlags: getRemainingFlags(program),
+            };
             try {
-                await this.action.handle(inputs, options, flags);
+                await this.action.handle(context);
             }
-            catch (err) {
+            catch {
                 process.exit(1);
             }
         });
     }
 }
-exports.StartCommand = StartCommand;

package/lib/compiler/assets-manager.d.ts

@@ -1,4 +1,4 @@
-import { Configuration } from '../configuration';
+import { Configuration } from '../configuration/index.js';
 export declare class AssetsManager {
     private watchAssetsKeyValue;
     private watchers;

package/lib/compiler/assets-manager.js

@@ -1,18 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssetsManager = void 0;
-const chokidar = require("chokidar");
-const fs_1 = require("fs");
-const glob_1 = require("glob");
-const path_1 = require("path");
-const copy_path_resolve_1 = require("./helpers/copy-path-resolve");
-const get_value_or_default_1 = require("./helpers/get-value-or-default");
-class AssetsManager {
-    constructor() {
-        this.watchAssetsKeyValue = {};
-        this.watchers = [];
-        this.actionInProgress = false;
-    }
+import * as chokidar from 'chokidar';
+import { copyFileSync, mkdirSync, rmSync, statSync } from 'fs';
+import { sync } from 'glob';
+import { dirname, join, sep } from 'path';
+import { copyPathResolve } from './helpers/copy-path-resolve.js';
+import { getValueOrDefault } from './helpers/get-value-or-default.js';
+export class AssetsManager {
+    watchAssetsKeyValue = {};
+    watchers = [];
+    actionInProgress = false;
     /**
      * Using on `nest build` to close file watch or the build process will not end
      * Interval like process
@@ -34,19 +29,19 @@ class AssetsManager {
         setTimeout(closeFn, timeoutMs);
     }
     copyAssets(configuration, appName, outDir, watchAssetsMode) {
-        const assets = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.assets', appName) || [];
+        const assets = getValueOrDefault(configuration, 'compilerOptions.assets', appName) || [];
         if (assets.length <= 0) {
             return;
         }
         try {
-            let sourceRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName);
-            sourceRoot = (0, path_1.join)(process.cwd(), sourceRoot);
+            let sourceRoot = getValueOrDefault(configuration, 'sourceRoot', appName);
+            sourceRoot = join(process.cwd(), sourceRoot);
             const filesToCopy = assets.map((item) => {
                 let includePath = typeof item === 'string' ? item : item.include;
                 let excludePath = typeof item !== 'string' && item.exclude ? item.exclude : undefined;
-                includePath = (0, path_1.join)(sourceRoot, includePath).replace(/\\/g, '/');
+                includePath = join(sourceRoot, includePath).replace(/\\/g, '/');
                 excludePath = excludePath
-                    ? (0, path_1.join)(sourceRoot, excludePath).replace(/\\/g, '/')
+                    ? join(sourceRoot, excludePath).replace(/\\/g, '/')
                     : undefined;
                 return {
                     outDir: typeof item !== 'string' ? item.outDir || outDir : outDir,
@@ -56,7 +51,7 @@ class AssetsManager {
                     watchAssets: typeof item !== 'string' ? item.watchAssets : undefined,
                 };
             });
-            const isWatchEnabled = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.watchAssets', appName) || watchAssetsMode;
+            const isWatchEnabled = getValueOrDefault(configuration, 'compilerOptions.watchAssets', appName) || watchAssetsMode;
             for (const item of filesToCopy) {
                 const option = {
                     action: 'change',
@@ -68,7 +63,7 @@ class AssetsManager {
                 if (isWatchEnabled || item.watchAssets) {
                     // prettier-ignore
                     const watcher = chokidar
-                        .watch((0, glob_1.sync)(item.glob, {
+                        .watch(sync(item.glob, {
                         ignore: item.exclude,
                         dot: true,
                     }))
@@ -78,17 +73,17 @@ class AssetsManager {
                     this.watchers.push(watcher);
                 }
                 else {
-                    const matchedPaths = (0, glob_1.sync)(item.glob, {
+                    const matchedPaths = sync(item.glob, {
                         ignore: item.exclude,
                         dot: true,
                     });
                     const files = item.glob.endsWith('*')
-                        ? matchedPaths.filter((matched) => (0, fs_1.statSync)(matched).isFile())
+                        ? matchedPaths.filter((matched) => statSync(matched).isFile())
                         : matchedPaths.flatMap((matched) => {
-                            if ((0, fs_1.statSync)(matched).isDirectory()) {
-                                return (0, glob_1.sync)(`${matched}/**/*`, {
+                            if (statSync(matched).isDirectory()) {
+                                return sync(`${matched}/**/*`, {
                                     ignore: item.exclude,
-                                }).filter((file) => (0, fs_1.statSync)(file).isFile());
+                                }).filter((file) => statSync(file).isFile());
                             }
                             return matched;
                         });
@@ -99,7 +94,7 @@ class AssetsManager {
             }
         }
         catch (err) {
-            throw new Error(`An error occurred during the assets copying process. ${err.message}`);
+            throw new Error(`An error occurred during the assets copying process. ${err.message}`, { cause: err });
         }
     }
     actionOnFile(option) {
@@ -114,16 +109,15 @@ class AssetsManager {
         this.watchAssetsKeyValue[assetCheckKey] = true;
         // Set action to true to avoid watches getting cutoff
         this.actionInProgress = true;
-        const dest = (0, copy_path_resolve_1.copyPathResolve)(path, item.outDir, sourceRoot.split(path_1.sep).length);
+        const dest = copyPathResolve(path, item.outDir, sourceRoot.split(sep).length);
         // Copy to output dir if file is changed or added
         if (action === 'change') {
-            (0, fs_1.mkdirSync)((0, path_1.dirname)(dest), { recursive: true });
-            (0, fs_1.copyFileSync)(path, dest);
+            mkdirSync(dirname(dest), { recursive: true });
+            copyFileSync(path, dest);
         }
         else if (action === 'unlink') {
             // Remove from output dir if file is deleted
-            (0, fs_1.rmSync)(dest, { force: true });
+            rmSync(dest, { force: true });
         }
     }
 }
-exports.AssetsManager = AssetsManager;

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

@@ -1,9 +1,9 @@
-import { Configuration } from '../configuration';
-import { PluginsLoader } from './plugins/plugins-loader';
+import { Configuration } from '../configuration/index.js';
+import { PluginsLoader } from './plugins/plugins-loader.js';
 export declare abstract class BaseCompiler<T = Record<string, any>> {
     private readonly pluginsLoader;
     constructor(pluginsLoader: PluginsLoader);
-    abstract run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, extras?: T, onSuccess?: () => void): any;
-    loadPlugins(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined): import("./plugins/plugins-loader").MultiNestCompilerPlugins;
-    getPathToSource(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined): string;
+    abstract run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, extras?: T, onSuccess?: () => void): void | Promise<void>;
+    protected loadPlugins(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined): import("./plugins/plugins-loader.js").MultiNestCompilerPlugins;
+    protected getPathToSource(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined): string;
 }

package/lib/compiler/base-compiler.js

@@ -1,26 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseCompiler = void 0;
-const path_1 = require("path");
-const get_value_or_default_1 = require("./helpers/get-value-or-default");
-class BaseCompiler {
+import { dirname, join, normalize, relative } from 'path';
+import { getValueOrDefault } from './helpers/get-value-or-default.js';
+export class BaseCompiler {
+    pluginsLoader;
     constructor(pluginsLoader) {
         this.pluginsLoader = pluginsLoader;
     }
     loadPlugins(configuration, tsConfigPath, appName) {
-        const pluginsConfig = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.plugins', appName);
+        const pluginsConfig = getValueOrDefault(configuration, 'compilerOptions.plugins', appName);
         const pathToSource = this.getPathToSource(configuration, tsConfigPath, appName);
         const plugins = this.pluginsLoader.load(pluginsConfig, { pathToSource });
         return plugins;
     }
     getPathToSource(configuration, tsConfigPath, appName) {
-        const sourceRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName, 'sourceRoot');
+        const sourceRoot = getValueOrDefault(configuration, 'sourceRoot', appName, 'sourceRoot');
         const cwd = process.cwd();
-        const relativeRootPath = (0, path_1.dirname)((0, path_1.relative)(cwd, tsConfigPath));
-        const pathToSource = (0, path_1.normalize)(sourceRoot).indexOf((0, path_1.normalize)(relativeRootPath)) >= 0
-            ? (0, path_1.join)(cwd, sourceRoot)
-            : (0, path_1.join)(cwd, relativeRootPath, sourceRoot);
+        const relativeRootPath = dirname(relative(cwd, tsConfigPath));
+        const pathToSource = normalize(sourceRoot).indexOf(normalize(relativeRootPath)) >= 0
+            ? join(cwd, sourceRoot)
+            : join(cwd, relativeRootPath, sourceRoot);
         return pathToSource;
     }
 }
-exports.BaseCompiler = BaseCompiler;

package/lib/compiler/compiler.d.ts

@@ -1,12 +1,12 @@
-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';
 export declare class Compiler extends BaseCompiler {
     private readonly tsConfigProvider;
     private readonly typescriptLoader;
     constructor(pluginsLoader: PluginsLoader, tsConfigProvider: TsConfigProvider, typescriptLoader: TypeScriptBinaryLoader);
-    run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, _extras: any, onSuccess?: () => void): void;
+    run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, _extras: unknown, onSuccess?: () => void): void;
     private reportAfterCompilationDiagnostic;
 }