@nestjs/cli 11.0.16 → 12.0.0-alpha.1

package/lib/compiler/hooks/tsconfig-paths.hook.js

@@ -1,12 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsconfigPathsBeforeHookFactory = tsconfigPathsBeforeHookFactory;
-const os = require("os");
-const path_1 = require("path");
-const typescript_loader_1 = require("../typescript-loader");
-const tsPaths = require("tsconfig-paths");
-function tsconfigPathsBeforeHookFactory(compilerOptions) {
-    const tsBinary = new typescript_loader_1.TypeScriptBinaryLoader().load();
+import { createRequire } from 'module';
+import { dirname, posix } from 'path';
+import * as tsPaths from 'tsconfig-paths';
+import { TypeScriptBinaryLoader } from '../typescript-loader.js';
+const require = createRequire(import.meta.url);
+export function tsconfigPathsBeforeHookFactory(compilerOptions) {
+    const tsBinary = new TypeScriptBinaryLoader().load();
     const { paths = {}, baseUrl = './' } = compilerOptions;
     const matcher = tsPaths.createMatchPath(baseUrl, paths, ['main']);
     return (ctx) => {
@@ -57,20 +55,22 @@ function getNotAliasedPath(sf, matcher, text) {
     if (!result) {
         return;
     }
-    if (os.platform() === 'win32') {
+    if (process.platform === 'win32') {
         result = result.replace(/\\/g, '/');
     }
     try {
         // Installed packages (node modules) should take precedence over root files with the same name.
         // Ref: https://github.com/nestjs/nest-cli/issues/838
         const packagePath = require.resolve(text, {
-            paths: [process.cwd(), ...module.paths],
+            paths: [process.cwd(), ...(require.resolve.paths(text) ?? [])],
         });
         if (packagePath) {
             return text;
         }
     }
-    catch { }
-    const resolvedPath = path_1.posix.relative((0, path_1.dirname)(sf.fileName), result) || './';
+    catch {
+        // package resolution failed, fall through to relative path
+    }
+    const resolvedPath = posix.relative(dirname(sf.fileName), result) || './';
     return resolvedPath[0] === '.' ? resolvedPath : './' + resolvedPath;
 }

package/lib/compiler/interfaces/readonly-visitor.interface.js

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

package/lib/compiler/plugins/plugin-metadata-generator.d.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { ReadonlyVisitor } from '../interfaces/readonly-visitor.interface';
+import { ReadonlyVisitor } from '../interfaces/readonly-visitor.interface.js';
 export interface PluginMetadataGenerateOptions {
     /**
      * The visitors to use to generate the metadata.

package/lib/compiler/plugins/plugin-metadata-generator.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginMetadataGenerator = void 0;
-const constants_1 = require("../swc/constants");
-const type_checker_host_1 = require("../swc/type-checker-host");
-const typescript_loader_1 = require("../typescript-loader");
-const plugin_metadata_printer_1 = require("./plugin-metadata-printer");
+import { FOUND_NO_ISSUES_GENERATING_METADATA } from '../swc/constants.js';
+import { TypeCheckerHost } from '../swc/type-checker-host.js';
+import { TypeScriptBinaryLoader } from '../typescript-loader.js';
+import { PluginMetadataPrinter } from './plugin-metadata-printer.js';
 /**
  * Generates plugins metadata by traversing the AST of the project.
  * @example
@@ -20,11 +17,12 @@ const plugin_metadata_printer_1 = require("./plugin-metadata-printer");
  * });
  * ```
  */
-class PluginMetadataGenerator {
+export class PluginMetadataGenerator {
+    pluginMetadataPrinter = new PluginMetadataPrinter();
+    typeCheckerHost = new TypeCheckerHost();
+    typescriptLoader = new TypeScriptBinaryLoader();
+    tsBinary;
     constructor() {
-        this.pluginMetadataPrinter = new plugin_metadata_printer_1.PluginMetadataPrinter();
-        this.typeCheckerHost = new type_checker_host_1.TypeCheckerHost();
-        this.typescriptLoader = new typescript_loader_1.TypeScriptBinaryLoader();
         this.tsBinary = this.typescriptLoader.load();
     }
     generate(options) {
@@ -50,7 +48,7 @@ class PluginMetadataGenerator {
                     console.log(tsBinary.formatDiagnosticsWithColorAndContext(diagnostics, formatDiagnosticsHost));
                 }
                 else {
-                    console.log(constants_1.FOUND_NO_ISSUES_GENERATING_METADATA);
+                    console.log(FOUND_NO_ISSUES_GENERATING_METADATA);
                 }
             }
         };
@@ -81,4 +79,3 @@ class PluginMetadataGenerator {
         }, this.tsBinary);
     }
 }
-exports.PluginMetadataGenerator = PluginMetadataGenerator;

package/lib/compiler/plugins/plugin-metadata-printer.d.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { DeepPluginMeta } from '../interfaces/readonly-visitor.interface';
+import { DeepPluginMeta } from '../interfaces/readonly-visitor.interface.js';
 export interface PluginMetadataPrintOptions {
     outputDir: string;
     filename?: string;

package/lib/compiler/plugins/plugin-metadata-printer.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginMetadataPrinter = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
+import { writeFileSync } from 'fs';
+import { join } from 'path';
 const SERIALIZED_METADATA_FILENAME = 'metadata.ts';
 const TYPE_IMPORT_VARIABLE_NAME = 't';
 /**
  * Prints the metadata to a file.
  */
-class PluginMetadataPrinter {
+export class PluginMetadataPrinter {
     print(metadata, typeImports, options, tsBinary) {
         const objectLiteralExpr = tsBinary.factory.createObjectLiteralExpression(Object.keys(metadata).map((key) => this.recursivelyCreatePropertyAssignment(key, metadata[key], tsBinary)));
         const exportAssignment = tsBinary.factory.createExportAssignment(undefined, undefined, tsBinary.factory.createArrowFunction([tsBinary.factory.createToken(tsBinary.SyntaxKind.AsyncKeyword)], undefined, [], undefined, tsBinary.factory.createToken(tsBinary.SyntaxKind.EqualsGreaterThanToken), tsBinary.factory.createBlock([
@@ -20,9 +17,9 @@ class PluginMetadataPrinter {
         });
         const resultFile = tsBinary.createSourceFile('file.ts', '', tsBinary.ScriptTarget.Latest, 
         /*setParentNodes*/ false, tsBinary.ScriptKind.TS);
-        const filename = (0, path_1.join)(options.outputDir, options.filename ?? SERIALIZED_METADATA_FILENAME);
+        const filename = join(options.outputDir, options.filename ?? SERIALIZED_METADATA_FILENAME);
         const eslintPrefix = `/* eslint-disable */\n`;
-        (0, fs_1.writeFileSync)(filename, eslintPrefix +
+        writeFileSync(filename, eslintPrefix +
             printer.printNode(tsBinary.EmitHint.Unspecified, exportAssignment, resultFile));
     }
     recursivelyCreatePropertyAssignment(identifier, meta, tsBinary) {
@@ -48,4 +45,3 @@ class PluginMetadataPrinter {
         return tsBinary.factory.createPropertyAssignment(tsBinary.factory.createComputedPropertyName(tsBinary.factory.createStringLiteral(identifier)), tsBinary.factory.createIdentifier(target));
     }
 }
-exports.PluginMetadataPrinter = PluginMetadataPrinter;

package/lib/compiler/plugins/plugins-loader.d.ts

@@ -1,10 +1,10 @@
 import * as ts from 'typescript';
-import { ReadonlyVisitor } from '../interfaces/readonly-visitor.interface';
+import { ReadonlyVisitor } from '../interfaces/readonly-visitor.interface.js';
 type Transformer = ts.TransformerFactory<any> | ts.CustomTransformerFactory;
 type PluginEntry = string | PluginAndOptions;
 type PluginOptions = Record<string, any>;
 interface PluginAndOptions {
-    name: 'string';
+    name: string;
     options: PluginOptions;
 }
 export interface NestCompilerPlugin {

package/lib/compiler/plugins/plugins-loader.js

@@ -1,10 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginsLoader = void 0;
-const path_1 = require("path");
-const ui_1 = require("../../ui");
+import { createRequire } from 'module';
+import { join } from 'path';
+import { CLI_ERRORS } from '../../ui/index.js';
+const require = createRequire(import.meta.url);
 const PLUGIN_ENTRY_FILENAME = 'plugin';
-class PluginsLoader {
+export class PluginsLoader {
     load(plugins = [], extras = {}) {
         const pluginNames = plugins.map((entry) => typeof entry === 'object'
             ? entry.name
@@ -18,7 +17,7 @@ class PluginsLoader {
         };
         pluginRefs.forEach((plugin, index) => {
             if (!plugin.before && !plugin.after && !plugin.afterDeclarations) {
-                throw new Error(ui_1.CLI_ERRORS.WRONG_PLUGIN(pluginNames[index]));
+                throw new Error(CLI_ERRORS.WRONG_PLUGIN(pluginNames[index]));
             }
             const options = typeof plugins[index] === 'object'
                 ? plugins[index].options || {}
@@ -46,25 +45,26 @@ class PluginsLoader {
     }
     resolvePluginReferences(pluginNames) {
         const nodeModulePaths = [
-            (0, path_1.join)(process.cwd(), 'node_modules'),
-            ...module.paths,
+            join(process.cwd(), 'node_modules'),
+            ...(require.resolve.paths('typescript') ?? []),
         ];
         return pluginNames.map((item) => {
             try {
                 try {
-                    const binaryPath = require.resolve((0, path_1.join)(item, PLUGIN_ENTRY_FILENAME), {
+                    const binaryPath = require.resolve(join(item, PLUGIN_ENTRY_FILENAME), {
                         paths: nodeModulePaths,
                     });
                     return require(binaryPath);
                 }
-                catch { }
+                catch {
+                    // entry-point resolution failed, try bare module resolve
+                }
                 const binaryPath = require.resolve(item, { paths: nodeModulePaths });
                 return require(binaryPath);
             }
             catch (e) {
-                throw new Error(`"${item}" plugin is not installed.`);
+                throw new Error(`"${item}" plugin is not installed.`, { cause: e });
             }
         });
     }
 }
-exports.PluginsLoader = PluginsLoader;

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

@@ -0,0 +1,19 @@
+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';
+type RspackConfigFactory = (config: Record<string, any>, rspackRef: any) => Record<string, any>;
+type RspackConfigFactoryOrConfig = RspackConfigFactory | Record<string, any>;
+type RspackCompilerExtras = {
+    options: Record<string, any>;
+    assetsManager: AssetsManager;
+    rspackConfigFactoryOrConfig: RspackConfigFactoryOrConfig | RspackConfigFactoryOrConfig[];
+    debug?: boolean;
+    watchMode?: boolean;
+};
+export declare class RspackCompiler extends BaseCompiler<RspackCompilerExtras> {
+    constructor(pluginsLoader: PluginsLoader);
+    run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, extras: RspackCompilerExtras, onSuccess?: () => void): void;
+    private createAfterCallback;
+}
+export {};

package/lib/compiler/rspack-compiler.js

@@ -0,0 +1,105 @@
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import { join } from 'path';
+import { INFO_PREFIX } from '../ui/index.js';
+import { isEsmProject } from '../utils/is-esm-project.js';
+import { BaseCompiler } from './base-compiler.js';
+import { rspackDefaultsFactory } from './defaults/rspack-defaults.js';
+import { getValueOrDefault } from './helpers/get-value-or-default.js';
+const require = createRequire(import.meta.url);
+export class RspackCompiler extends BaseCompiler {
+    constructor(pluginsLoader) {
+        super(pluginsLoader);
+    }
+    run(configuration, tsConfigPath, appName, extras, onSuccess) {
+        const cwd = process.cwd();
+        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 = getValueOrDefault(configuration, 'entryFile', appName, 'entryFile', extras.options);
+        const entryFileRoot = getValueOrDefault(configuration, 'root', appName) || '';
+        const defaultOptions = rspackDefaultsFactory(pathToSource, entryFileRoot, entryFile, extras.debug ?? false, tsConfigPath, plugins, isEsmProject());
+        let rspack;
+        try {
+            rspack = require('@rspack/core');
+        }
+        catch {
+            throw new Error('@rspack/core is not installed. To use the rspack compiler, install the required packages:\n\n' +
+                '  npm install --save-dev @rspack/core webpack-node-externals tsconfig-paths-webpack-plugin\n');
+        }
+        let compiler;
+        let watchOptions;
+        let watch;
+        if (Array.isArray(extras.rspackConfigFactoryOrConfig)) {
+            const rspackConfigurations = extras.rspackConfigFactoryOrConfig.map((configOrFactory) => {
+                const unwrappedConfig = typeof configOrFactory !== 'function'
+                    ? configOrFactory
+                    : configOrFactory(defaultOptions, rspack);
+                return {
+                    ...defaultOptions,
+                    mode: extras.watchMode ? 'development' : defaultOptions.mode,
+                    ...unwrappedConfig,
+                };
+            });
+            compiler = rspack.rspack(rspackConfigurations);
+            watchOptions = rspackConfigurations.map((config) => config.watchOptions || {});
+            watch = rspackConfigurations.some((config) => config.watch);
+        }
+        else {
+            const projectRspackOptions = typeof extras.rspackConfigFactoryOrConfig !== 'function'
+                ? extras.rspackConfigFactoryOrConfig
+                : extras.rspackConfigFactoryOrConfig(defaultOptions, rspack);
+            const rspackConfiguration = {
+                ...defaultOptions,
+                mode: extras.watchMode ? 'development' : defaultOptions.mode,
+                ...projectRspackOptions,
+            };
+            compiler = rspack.rspack(rspackConfiguration);
+            watchOptions = rspackConfiguration.watchOptions;
+            watch = rspackConfiguration.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${INFO_PREFIX} Rspack is building your sources...\n`);
+                callback();
+            });
+            compiler.watch(watchOptions || {}, afterCallback);
+        }
+        else {
+            compiler.run(afterCallback);
+        }
+    }
+    createAfterCallback(onSuccess, assetsManager, watchMode, watch) {
+        return (err, stats) => {
+            if (err && stats === undefined) {
+                // Could not complete the compilation
+                // The error caught is most likely thrown by underlying tasks
+                console.log(err);
+                return process.exit(1);
+            }
+            const statsOutput = stats.toString({
+                chunks: false,
+                colors: true,
+                modules: false,
+                assets: false,
+            });
+            if (!err && !stats.hasErrors()) {
+                if (!onSuccess) {
+                    assetsManager.closeWatchers();
+                }
+                else {
+                    onSuccess();
+                }
+            }
+            else if (!watchMode && !watch) {
+                console.log(statsOutput);
+                return process.exit(1);
+            }
+            console.log(statsOutput);
+        };
+    }
+}

package/lib/compiler/swc/constants.d.ts

@@ -1,5 +1,4 @@
 export declare const TSC_NO_ERRORS_MESSAGE = "Found 0 errors. Watching for file changes.";
-export declare const TSC_COMPILATION_STARTED_MESSAGE = "Starting compilation in watch mode...";
 export declare const SWC_LOG_PREFIX: string;
 export declare const TSC_LOG_PREFIX: string;
 export declare const TSC_LOG_ERROR_PREFIX: string;

package/lib/compiler/swc/constants.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FOUND_NO_ISSUES_GENERATING_METADATA = exports.FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED = exports.INITIALIZING_TYPE_CHECKER = exports.TSC_LOG_SUCCESS_PREFIX = exports.TSC_LOG_ERROR_PREFIX = exports.TSC_LOG_PREFIX = exports.SWC_LOG_PREFIX = exports.TSC_COMPILATION_STARTED_MESSAGE = exports.TSC_NO_ERRORS_MESSAGE = void 0;
-const ansis_1 = require("ansis");
-exports.TSC_NO_ERRORS_MESSAGE = 'Found 0 errors. Watching for file changes.';
-exports.TSC_COMPILATION_STARTED_MESSAGE = 'Starting compilation in watch mode...';
-exports.SWC_LOG_PREFIX = (0, ansis_1.cyan)('> ') + ansis_1.bgCyan.bold(' SWC ');
-exports.TSC_LOG_PREFIX = (0, ansis_1.cyan)('> ') + ansis_1.bgCyan.bold(' TSC ');
-exports.TSC_LOG_ERROR_PREFIX = (0, ansis_1.red)('> ') + ansis_1.bgRed.bold(' TSC ');
-exports.TSC_LOG_SUCCESS_PREFIX = (0, ansis_1.green)('> ') + ansis_1.bgGreen.bold(' TSC ');
-exports.INITIALIZING_TYPE_CHECKER = ansis_1.bgCyan.bold(' TSC ') + (0, ansis_1.cyan)(' Initializing type checker...');
-exports.FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED = exports.TSC_LOG_SUCCESS_PREFIX + (0, ansis_1.green)(' Found 0 issues.');
-exports.FOUND_NO_ISSUES_GENERATING_METADATA = exports.TSC_LOG_SUCCESS_PREFIX + (0, ansis_1.green)(' Found 0 issues. Generating metadata...');
+import { bgCyan, bgGreen, bgRed, cyan, green, red } from 'ansis';
+export const TSC_NO_ERRORS_MESSAGE = 'Found 0 errors. Watching for file changes.';
+export const SWC_LOG_PREFIX = cyan('> ') + bgCyan.bold(' SWC ');
+export const TSC_LOG_PREFIX = cyan('> ') + bgCyan.bold(' TSC ');
+export const TSC_LOG_ERROR_PREFIX = red('> ') + bgRed.bold(' TSC ');
+export const TSC_LOG_SUCCESS_PREFIX = green('> ') + bgGreen.bold(' TSC ');
+export const INITIALIZING_TYPE_CHECKER = bgCyan.bold(' TSC ') + cyan(' Initializing type checker...');
+export const FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED = TSC_LOG_SUCCESS_PREFIX + green(' Found 0 issues.');
+export const FOUND_NO_ISSUES_GENERATING_METADATA = TSC_LOG_SUCCESS_PREFIX + green(' Found 0 issues. Generating metadata...');

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

@@ -1,25 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ui_1 = require("../../ui");
-const base_compiler_1 = require("../base-compiler");
-const plugin_metadata_generator_1 = require("../plugins/plugin-metadata-generator");
-const plugins_loader_1 = require("../plugins/plugins-loader");
-const constants_1 = require("./constants");
-const type_checker_host_1 = require("./type-checker-host");
+import { ERROR_PREFIX } from '../../ui/index.js';
+import { BaseCompiler } from '../base-compiler.js';
+import { PluginMetadataGenerator } from '../plugins/plugin-metadata-generator.js';
+import { PluginsLoader } from '../plugins/plugins-loader.js';
+import { FOUND_NO_ISSUES_GENERATING_METADATA, FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED, } from './constants.js';
+import { TypeCheckerHost } from './type-checker-host.js';
 const [tsConfigPath, appName, sourceRoot, plugins] = process.argv.slice(2);
-class ForkedTypeChecker extends base_compiler_1.BaseCompiler {
-    constructor() {
-        super(...arguments);
-        this.pluginMetadataGenerator = new plugin_metadata_generator_1.PluginMetadataGenerator();
-        this.typeCheckerHost = new type_checker_host_1.TypeCheckerHost();
-    }
+class ForkedTypeChecker extends BaseCompiler {
+    pluginMetadataGenerator = new PluginMetadataGenerator();
+    typeCheckerHost = new TypeCheckerHost();
     async run(configuration, tsConfigPath, appName, extras) {
         const { readonlyVisitors } = this.loadPlugins(configuration, tsConfigPath, appName);
         const outputDir = this.getPathToSource(configuration, tsConfigPath, appName);
         try {
             const onTypeCheckOrProgramInit = (program) => {
                 if (readonlyVisitors.length > 0) {
-                    console.log(constants_1.FOUND_NO_ISSUES_GENERATING_METADATA);
+                    console.log(FOUND_NO_ISSUES_GENERATING_METADATA);
                     this.pluginMetadataGenerator.generate({
                         outputDir,
                         visitors: readonlyVisitors,
@@ -27,7 +22,7 @@ class ForkedTypeChecker extends base_compiler_1.BaseCompiler {
                     });
                 }
                 else {
-                    console.log(constants_1.FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED);
+                    console.log(FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED);
                 }
             };
             this.typeCheckerHost.run(tsConfigPath, {
@@ -37,11 +32,11 @@ class ForkedTypeChecker extends base_compiler_1.BaseCompiler {
             });
         }
         catch (err) {
-            console.log(ui_1.ERROR_PREFIX, err.message);
+            console.error(ERROR_PREFIX, err.message);
         }
     }
 }
-const pluginsLoader = new plugins_loader_1.PluginsLoader();
+const pluginsLoader = new PluginsLoader();
 const forkedTypeChecker = new ForkedTypeChecker(pluginsLoader);
 const applicationName = appName === 'undefined' ? '' : appName;
 const options = {

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

@@ -1,8 +1,8 @@
 import * as ts from 'typescript';
-import { Configuration } from '../../configuration';
-import { AssetsManager } from '../assets-manager';
-import { BaseCompiler } from '../base-compiler';
-import { PluginsLoader } from '../plugins/plugins-loader';
+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';
 export type SwcCompilerExtras = {
     watch: boolean;
     typeCheck: boolean;

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

@@ -1,30 +1,33 @@
-"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 } from 'child_process';
+import * as chokidar from 'chokidar';
+import { readFileSync } from 'fs';
+import { stat } from 'fs/promises';
+import { createRequire } from 'module';
+import * as path from 'path';
+import { isAbsolute, join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+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 { 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);
+        const swcrcFilePath = getValueOrDefault(configuration, 'compilerOptions.builder.options.swcrcPath', appName);
         if (extras.watch) {
             if (extras.typeCheck) {
                 this.runTypeChecker(configuration, tsConfigPath, appName, extras);
@@ -56,10 +59,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 +78,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 +86,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 +101,11 @@ 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...')));
+        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();
@@ -136,19 +139,19 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
         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 +173,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 +193,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) {
@@ -211,9 +214,9 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
         watcher.on('add', async (file) => onFileAdded(file));
     }
     watchFilesInOutDir(options, onChange) {
-        const dir = (0, path_1.isAbsolute)(options.cliOptions.outDir)
+        const dir = isAbsolute(options.cliOptions.outDir)
             ? options.cliOptions.outDir
-            : (0, path_1.join)(process.cwd(), options.cliOptions.outDir);
+            : join(process.cwd(), options.cliOptions.outDir);
         const watcher = chokidar.watch(dir, {
             ignored: (file, stats) => (stats?.isFile() &&
                 !(file.endsWith('.js') || file.endsWith('.mjs'))),
@@ -228,4 +231,3 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
         }
     }
 }
-exports.SwcCompiler = SwcCompiler;