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

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,8 +45,8 @@ 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 {
@@ -57,14 +56,15 @@ class PluginsLoader {
                     });
                     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,21 @@
+import type * as ts from 'typescript';
+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;
+    tsOptions?: ts.CompilerOptions;
+};
+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,111 @@
+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 { 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(), extras.tsOptions);
+        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) {
+                    // rspack 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();
+                }
+            }
+            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.error(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,25 +1,32 @@
-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 type { TsConfigProviderOutput } from '../helpers/tsconfig-provider.js';
+import { PluginsLoader } from '../plugins/plugins-loader.js';
 export type SwcCompilerExtras = {
     watch: boolean;
     typeCheck: boolean;
+    emitDeclarations: boolean;
     assetsManager: AssetsManager;
-    tsOptions: ts.CompilerOptions;
+    tsOptions: TsConfigProviderOutput['options'];
+    tsConfigExclude: string[];
+    silent?: boolean;
 };
 export declare class SwcCompiler extends BaseCompiler {
     private readonly pluginMetadataGenerator;
     private readonly typeCheckerHost;
     constructor(pluginsLoader: PluginsLoader);
     run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, extras: SwcCompilerExtras, onSuccess?: () => void): Promise<void>;
+    private emitDeclarations;
     private runTypeChecker;
     private runSwc;
+    private shouldLogSwcStatus;
     private loadSwcCliBinary;
     private getSwcRcFileContentIfExists;
     private deepMerge;
     private debounce;
     private watchFilesInSrcDir;
+    private isIgnoredBySwc;
+    private normalizeSwcIgnorePath;
     private watchFilesInOutDir;
 }