@depup/nestjs__cli 11.0.16-depup.1

package/commands/build.command.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildCommand = void 0;
+const ui_1 = require("../lib/ui");
+const abstract_command_1 = require("./abstract.command");
+class BuildCommand extends abstract_command_1.AbstractCommand {
+    load(program) {
+        program
+            .command('build [apps...]')
+            .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('--watchAssets', 'Watch non-ts (e.g., .graphql) files mode.')
+            .option('--webpack', 'Use webpack for compilation (deprecated option, use --builder instead).')
+            .option('--type-check', 'Enable type checking (when SWC is used).')
+            .option('--webpackPath [path]', 'Path to webpack configuration.')
+            .option('--tsc', 'Use typescript compiler for compilation.')
+            .option('--preserveWatchOutput', 'Use "preserveWatchOutput" option when using tsc watch mode.')
+            .option('--all', 'Build all projects in a monorepo.')
+            .description('Build Nest application.')
+            .action(async (apps, 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: '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,
+            });
+            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(', ')}`);
+                return;
+            }
+            options.push({
+                name: 'builder',
+                value: command.builder,
+            });
+            options.push({
+                name: 'typeCheck',
+                value: command.typeCheck,
+            });
+            options.push({
+                name: 'preserveWatchOutput',
+                value: !!command.preserveWatchOutput &&
+                    !!command.watch &&
+                    !isWebpackEnabled,
+            });
+            options.push({ name: 'all', value: !!command.all });
+            const inputs = apps.map((app) => ({
+                name: 'app',
+                value: app,
+            }));
+            // Handle the default project for `nest build` with no args
+            // The action instance will pick up the default project when value is `undefined`
+            if (inputs.length === 0) {
+                inputs.push({ name: 'app', value: undefined });
+            }
+            await this.action.handle(inputs, options);
+        });
+    }
+}
+exports.BuildCommand = BuildCommand;

package/commands/command.input.d.ts

@@ -0,0 +1,5 @@
+export interface Input {
+    name: string;
+    value: boolean | string | string[];
+    options?: any;
+}

package/commands/command.input.js

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

package/commands/command.loader.d.ts

@@ -0,0 +1,5 @@
+import { CommanderStatic } from 'commander';
+export declare class CommandLoader {
+    static load(program: CommanderStatic): Promise<void>;
+    private static handleInvalidCommand;
+}

package/commands/command.loader.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandLoader = void 0;
+const ansis_1 = require("ansis");
+const actions_1 = require("../actions");
+const ui_1 = require("../lib/ui");
+const add_command_1 = require("./add.command");
+const build_command_1 = require("./build.command");
+const generate_command_1 = require("./generate.command");
+const info_command_1 = require("./info.command");
+const new_command_1 = require("./new.command");
+const start_command_1 = require("./start.command");
+class CommandLoader {
+    static async load(program) {
+        new new_command_1.NewCommand(new actions_1.NewAction()).load(program);
+        new build_command_1.BuildCommand(new actions_1.BuildAction()).load(program);
+        new start_command_1.StartCommand(new actions_1.StartAction()).load(program);
+        new info_command_1.InfoCommand(new actions_1.InfoAction()).load(program);
+        new add_command_1.AddCommand(new actions_1.AddAction()).load(program);
+        await new generate_command_1.GenerateCommand(new actions_1.GenerateAction()).load(program);
+        this.handleInvalidCommand(program);
+    }
+    static handleInvalidCommand(program) {
+        program.on('command:*', () => {
+            console.error(`\n${ui_1.ERROR_PREFIX} Invalid command: ${(0, ansis_1.red) `%s`}`, program.args.join(' '));
+            console.log(`See ${(0, ansis_1.red) `--help`} for a list of available commands.\n`);
+            process.exit(1);
+        });
+    }
+}
+exports.CommandLoader = CommandLoader;

package/commands/generate.command.d.ts

@@ -0,0 +1,9 @@
+import { CommanderStatic } from 'commander';
+import { AbstractCommand } from './abstract.command';
+export declare class GenerateCommand extends AbstractCommand {
+    load(program: CommanderStatic): Promise<void>;
+    private buildDescription;
+    private buildSchematicsListAsTable;
+    private getCollection;
+    private getSchematics;
+}

package/commands/generate.command.js

@@ -0,0 +1,107 @@
+"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 {
+    async load(program) {
+        program
+            .command('generate <schematic> [name] [path]')
+            .alias('g')
+            .description(await this.buildDescription())
+            .option('-d, --dry-run', 'Report actions that would be taken without writing out results.')
+            .option('-p, --project [project]', 'Project in which to generate files.')
+            .option('--flat', 'Enforce flat structure of generated element.', () => true)
+            .option('--no-flat', 'Enforce that directories are generated.', () => false)
+            .option('--spec', 'Enforce spec files generation.', () => {
+            return { value: true, passedAsInput: true };
+        }, true)
+            .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);
+        });
+    }
+    async buildDescription() {
+        const collection = await this.getCollection();
+        return ('Generate a Nest element.\n' +
+            `  Schematics available on ${(0, ansis_1.bold)(collection)} collection:\n` +
+            this.buildSchematicsListAsTable(await this.getSchematics(collection)));
+    }
+    buildSchematicsListAsTable(schematics) {
+        const leftMargin = '    ';
+        const tableConfig = {
+            head: ['name', 'alias', 'description'],
+            chars: {
+                'left': leftMargin.concat('│'),
+                'top-left': leftMargin.concat('┌'),
+                'bottom-left': leftMargin.concat('└'),
+                'mid': '',
+                'left-mid': '',
+                'mid-mid': '',
+                'right-mid': '',
+            },
+        };
+        const table = new Table(tableConfig);
+        for (const schematic of schematics) {
+            table.push([
+                (0, ansis_1.green)(schematic.name),
+                (0, ansis_1.cyan)(schematic.alias),
+                schematic.description,
+            ]);
+        }
+        return table.toString();
+    }
+    async getCollection() {
+        const configuration = await (0, load_configuration_1.loadConfiguration)();
+        return configuration.collection;
+    }
+    async getSchematics(collection) {
+        const abstractCollection = schematics_1.CollectionFactory.create(collection);
+        return abstractCollection.getSchematics();
+    }
+}
+exports.GenerateCommand = GenerateCommand;

package/commands/index.d.ts

@@ -0,0 +1,2 @@
+export * from './command.loader';
+export * from './command.input';

package/commands/index.js

@@ -0,0 +1,18 @@
+"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);

package/commands/info.command.d.ts

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

package/commands/info.command.js

@@ -0,0 +1,16 @@
+"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 {
+    load(program) {
+        program
+            .command('info')
+            .alias('i')
+            .description('Display Nest project details.')
+            .action(async () => {
+            await this.action.handle();
+        });
+    }
+}
+exports.InfoCommand = InfoCommand;

package/commands/new.command.d.ts

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

package/commands/new.command.js

@@ -0,0 +1,61 @@
+"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 {
+    load(program) {
+        program
+            .command('new [name]')
+            .alias('n')
+            .description('Generate Nest application.')
+            .option('--directory [directory]', 'Specify the destination directory')
+            .option('-d, --dry-run', 'Report actions that would be performed without writing out results.', false)
+            .option('-g, --skip-git', 'Skip git repository initialization.', false)
+            .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('--strict', 'Enables strict mode in TypeScript.', false)
+            .action(async (name, command) => {
+            const 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();
+                const langMatch = availableLanguages.includes(lowercasedLanguage);
+                if (!langMatch) {
+                    throw new Error(`Invalid language "${command.language}" selected. Available languages are "typescript" or "javascript"`);
+                }
+                switch (lowercasedLanguage) {
+                    case 'javascript':
+                        command.language = 'js';
+                        break;
+                    case 'typescript':
+                        command.language = 'ts';
+                        break;
+                    default:
+                        command.language = lowercasedLanguage;
+                        break;
+                }
+            }
+            options.push({
+                name: 'language',
+                value: command.language,
+            });
+            const inputs = [];
+            inputs.push({ name: 'name', value: name });
+            await this.action.handle(inputs, options);
+        });
+    }
+}
+exports.NewCommand = NewCommand;

package/commands/start.command.d.ts

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

package/commands/start.command.js

@@ -0,0 +1,104 @@
+"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 {
+    load(program) {
+        const collect = (value, previous) => {
+            return previous.concat([value]);
+        };
+        program
+            .command('start [app]')
+            .allowUnknownOption()
+            .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('--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).')
+            .option('--webpackPath [path]', 'Path to webpack configuration.')
+            .option('--type-check', 'Enable type checking (when SWC is used).')
+            .option('--tsc', 'Use typescript compiler for compilation.')
+            .option('--sourceRoot [sourceRoot]', 'Points at the root of the source code for the single project in standard mode structures, or the default project in monorepo mode structures.')
+            .option('--entryFile [entryFile]', "Path to the entry file where this command will work with. Defaults to the one defined at your Nest's CLI config file.")
+            .option('-e, --exec [binary]', 'Binary to run (default: "node").')
+            .option('--preserveWatchOutput', 'Use "preserveWatchOutput" option when using tsc watch mode.')
+            .option('--shell', "Spawn child processes within a shell (see node's child_process.spawn() method docs). Default: true.", true)
+            .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(', ')}`);
+                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);
+            try {
+                await this.action.handle(inputs, options, flags);
+            }
+            catch (err) {
+                process.exit(1);
+            }
+        });
+    }
+}
+exports.StartCommand = StartCommand;

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

@@ -0,0 +1,15 @@
+import { Configuration } from '../configuration';
+export declare class AssetsManager {
+    private watchAssetsKeyValue;
+    private watchers;
+    private actionInProgress;
+    /**
+     * Using on `nest build` to close file watch or the build process will not end
+     * Interval like process
+     * If no action has been taken recently close watchers
+     * If action has been taken recently flag and try again
+     */
+    closeWatchers(): void;
+    copyAssets(configuration: Required<Configuration>, appName: string | undefined, outDir: string, watchAssetsMode: boolean): void;
+    private actionOnFile;
+}

package/lib/compiler/assets-manager.js

@@ -0,0 +1,129 @@
+"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;
+    }
+    /**
+     * Using on `nest build` to close file watch or the build process will not end
+     * Interval like process
+     * If no action has been taken recently close watchers
+     * If action has been taken recently flag and try again
+     */
+    closeWatchers() {
+        // Consider adjusting this for larger files
+        const timeoutMs = 500;
+        const closeFn = () => {
+            if (this.actionInProgress) {
+                this.actionInProgress = false;
+                setTimeout(closeFn, timeoutMs);
+            }
+            else {
+                this.watchers.forEach((watcher) => watcher.close());
+            }
+        };
+        setTimeout(closeFn, timeoutMs);
+    }
+    copyAssets(configuration, appName, outDir, watchAssetsMode) {
+        const assets = (0, get_value_or_default_1.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);
+            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, '/');
+                excludePath = excludePath
+                    ? (0, path_1.join)(sourceRoot, excludePath).replace(/\\/g, '/')
+                    : undefined;
+                return {
+                    outDir: typeof item !== 'string' ? item.outDir || outDir : outDir,
+                    glob: includePath,
+                    exclude: excludePath,
+                    flat: typeof item !== 'string' ? item.flat : undefined, // deprecated field
+                    watchAssets: typeof item !== 'string' ? item.watchAssets : undefined,
+                };
+            });
+            const isWatchEnabled = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.watchAssets', appName) || watchAssetsMode;
+            for (const item of filesToCopy) {
+                const option = {
+                    action: 'change',
+                    item,
+                    path: '',
+                    sourceRoot,
+                    watchAssetsMode: isWatchEnabled,
+                };
+                if (isWatchEnabled || item.watchAssets) {
+                    // prettier-ignore
+                    const watcher = chokidar
+                        .watch((0, glob_1.sync)(item.glob, {
+                        ignore: item.exclude,
+                        dot: true,
+                    }))
+                        .on('add', (path) => this.actionOnFile({ ...option, path, action: 'change' }))
+                        .on('change', (path) => this.actionOnFile({ ...option, path, action: 'change' }))
+                        .on('unlink', (path) => this.actionOnFile({ ...option, path, action: 'unlink' }));
+                    this.watchers.push(watcher);
+                }
+                else {
+                    const matchedPaths = (0, glob_1.sync)(item.glob, {
+                        ignore: item.exclude,
+                        dot: true,
+                    });
+                    const files = item.glob.endsWith('*')
+                        ? matchedPaths.filter((matched) => (0, fs_1.statSync)(matched).isFile())
+                        : matchedPaths.flatMap((matched) => {
+                            if ((0, fs_1.statSync)(matched).isDirectory()) {
+                                return (0, glob_1.sync)(`${matched}/**/*`, {
+                                    ignore: item.exclude,
+                                }).filter((file) => (0, fs_1.statSync)(file).isFile());
+                            }
+                            return matched;
+                        });
+                    for (const path of files) {
+                        this.actionOnFile({ ...option, path, action: 'change' });
+                    }
+                }
+            }
+        }
+        catch (err) {
+            throw new Error(`An error occurred during the assets copying process. ${err.message}`);
+        }
+    }
+    actionOnFile(option) {
+        const { action, item, path, sourceRoot, watchAssetsMode } = option;
+        const isWatchEnabled = watchAssetsMode || item.watchAssets;
+        const assetCheckKey = path + (item.outDir ?? '');
+        // Allow to do action for the first time before check watchMode
+        if (!isWatchEnabled && this.watchAssetsKeyValue[assetCheckKey]) {
+            return;
+        }
+        // Set path value to true for watching the first time
+        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);
+        // 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);
+        }
+        else if (action === 'unlink') {
+            // Remove from output dir if file is deleted
+            (0, fs_1.rmSync)(dest, { force: true });
+        }
+    }
+}
+exports.AssetsManager = AssetsManager;

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

@@ -0,0 +1,9 @@
+import { Configuration } from '../configuration';
+import { PluginsLoader } from './plugins/plugins-loader';
+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;
+}

package/lib/compiler/base-compiler.js

@@ -0,0 +1,26 @@
+"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 {
+    constructor(pluginsLoader) {
+        this.pluginsLoader = pluginsLoader;
+    }
+    loadPlugins(configuration, tsConfigPath, appName) {
+        const pluginsConfig = (0, get_value_or_default_1.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 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);
+        return pathToSource;
+    }
+}
+exports.BaseCompiler = BaseCompiler;