@depup/nestjs__cli 11.0.16-depup.1

package/lib/compiler/compiler.d.ts

@@ -0,0 +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';
+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;
+    private reportAfterCompilationDiagnostic;
+}

package/lib/compiler/compiler.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compiler = void 0;
+const ts = require("typescript");
+const base_compiler_1 = require("./base-compiler");
+const tsconfig_paths_hook_1 = require("./hooks/tsconfig-paths.hook");
+class Compiler extends base_compiler_1.BaseCompiler {
+    constructor(pluginsLoader, tsConfigProvider, typescriptLoader) {
+        super(pluginsLoader);
+        this.tsConfigProvider = tsConfigProvider;
+        this.typescriptLoader = typescriptLoader;
+    }
+    run(configuration, tsConfigPath, appName, _extras, onSuccess) {
+        const tsBinary = this.typescriptLoader.load();
+        const formatHost = {
+            getCanonicalFileName: (path) => path,
+            getCurrentDirectory: tsBinary.sys.getCurrentDirectory,
+            getNewLine: () => tsBinary.sys.newLine,
+        };
+        const { options, fileNames, projectReferences } = this.tsConfigProvider.getByConfigFilename(tsConfigPath);
+        const createProgram = tsBinary.createIncrementalProgram || tsBinary.createProgram;
+        const program = createProgram.call(ts, {
+            rootNames: fileNames,
+            projectReferences,
+            options,
+        });
+        const plugins = this.loadPlugins(configuration, tsConfigPath, appName);
+        const tsconfigPathsPlugin = (0, tsconfig_paths_hook_1.tsconfigPathsBeforeHookFactory)(options);
+        const programRef = program.getProgram
+            ? program.getProgram()
+            : program;
+        const before = plugins.beforeHooks.map((hook) => hook(programRef));
+        const after = plugins.afterHooks.map((hook) => hook(programRef));
+        const afterDeclarations = plugins.afterDeclarationsHooks.map((hook) => hook(programRef));
+        const emitResult = program.emit(undefined, undefined, undefined, undefined, {
+            before: tsconfigPathsPlugin
+                ? before.concat(tsconfigPathsPlugin)
+                : before,
+            after,
+            afterDeclarations,
+        });
+        const errorsCount = this.reportAfterCompilationDiagnostic(program, emitResult, tsBinary, formatHost);
+        if (errorsCount) {
+            process.exit(1);
+        }
+        else if (!errorsCount && onSuccess) {
+            onSuccess();
+        }
+    }
+    reportAfterCompilationDiagnostic(program, emitResult, tsBinary, formatHost) {
+        const diagnostics = tsBinary
+            .getPreEmitDiagnostics(program)
+            .concat(emitResult.diagnostics);
+        if (diagnostics.length > 0) {
+            console.error(tsBinary.formatDiagnosticsWithColorAndContext(diagnostics, formatHost));
+            console.info(`Found ${diagnostics.length} error(s).` + tsBinary.sys.newLine);
+        }
+        return diagnostics.length;
+    }
+}
+exports.Compiler = Compiler;

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

@@ -0,0 +1,61 @@
+import * as ts from 'typescript';
+import { Configuration } from '../../configuration';
+export declare const swcDefaultsFactory: (tsOptions?: ts.CompilerOptions, configuration?: Configuration) => {
+    swcOptions: {
+        sourceMaps: string | boolean | undefined;
+        module: {
+            type: string;
+        };
+        jsc: {
+            target: string;
+            parser: {
+                syntax: string;
+                decorators: boolean;
+                dynamicImport: boolean;
+            };
+            transform: {
+                legacyDecorator: boolean;
+                decoratorMetadata: boolean;
+                useDefineForClassFields: boolean;
+            };
+            keepClassNames: boolean;
+            baseUrl: string | undefined;
+            paths: ts.MapLike<string[]> | undefined;
+        };
+        minify: boolean;
+        swcrc: boolean;
+    };
+    cliOptions: {
+        outDir: string;
+        filenames: string[];
+        sync: boolean;
+        extensions: string[];
+        copyFiles: boolean;
+        includeDotfiles: boolean;
+        quiet: boolean;
+        watch: boolean;
+        stripLeadingPaths: boolean;
+    } | {
+        swcrcPath?: string;
+        outDir: string;
+        filenames: string[];
+        sync: boolean;
+        extensions: string[];
+        copyFiles: boolean;
+        includeDotfiles: boolean;
+        quiet: boolean;
+        watch: boolean;
+        stripLeadingPaths: boolean;
+    } | {
+        configPath?: string;
+        outDir: string;
+        filenames: string[];
+        sync: boolean;
+        extensions: string[];
+        copyFiles: boolean;
+        includeDotfiles: boolean;
+        quiet: boolean;
+        watch: boolean;
+        stripLeadingPaths: boolean;
+    };
+};

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swcDefaultsFactory = void 0;
+const swcDefaultsFactory = (tsOptions, configuration) => {
+    const builderOptions = typeof configuration?.compilerOptions?.builder !== 'string'
+        ? configuration?.compilerOptions?.builder?.options
+        : {};
+    return {
+        swcOptions: {
+            sourceMaps: tsOptions?.sourceMap || (tsOptions?.inlineSourceMap && 'inline'),
+            module: {
+                type: 'commonjs',
+            },
+            jsc: {
+                target: 'es2021',
+                parser: {
+                    syntax: 'typescript',
+                    decorators: true,
+                    dynamicImport: true,
+                },
+                transform: {
+                    legacyDecorator: true,
+                    decoratorMetadata: true,
+                    useDefineForClassFields: false,
+                },
+                keepClassNames: true,
+                baseUrl: tsOptions?.baseUrl,
+                paths: tsOptions?.paths,
+            },
+            minify: false,
+            swcrc: true,
+        },
+        cliOptions: {
+            outDir: tsOptions?.outDir ? convertPath(tsOptions.outDir) : 'dist',
+            filenames: [configuration?.sourceRoot ?? 'src'],
+            sync: false,
+            extensions: ['.js', '.ts'],
+            copyFiles: false,
+            includeDotfiles: false,
+            quiet: false,
+            watch: false,
+            stripLeadingPaths: true,
+            ...builderOptions,
+        },
+    };
+};
+exports.swcDefaultsFactory = swcDefaultsFactory;
+/**
+ * Converts Windows specific file paths to posix
+ * @param windowsPath
+ */
+function convertPath(windowsPath) {
+    return windowsPath
+        .replace(/^\\\\\?\\/, '')
+        .replace(/\\/g, '/')
+        .replace(/\/\/+/g, '/');
+}

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

@@ -0,0 +1,3 @@
+import { MultiNestCompilerPlugins } from '../plugins/plugins-loader';
+import webpack = require('webpack');
+export declare const webpackDefaultsFactory: (sourceRoot: string, relativeSourceRoot: string, entryFilename: string, isDebugEnabled: boolean | undefined, tsConfigFile: string | undefined, plugins: MultiNestCompilerPlugins) => webpack.Configuration;

package/lib/compiler/defaults/webpack-defaults.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webpackDefaultsFactory = void 0;
+const path_1 = require("path");
+const tsconfig_paths_webpack_plugin_1 = require("tsconfig-paths-webpack-plugin");
+const defaults_1 = require("../../configuration/defaults");
+const append_extension_1 = require("../helpers/append-extension");
+const webpack = require("webpack");
+const nodeExternals = require("webpack-node-externals");
+const webpackDefaultsFactory = (sourceRoot, relativeSourceRoot, entryFilename, isDebugEnabled = false, tsConfigFile = defaults_1.defaultTsconfigFilename, plugins) => {
+    const isPluginRegistered = isAnyPluginRegistered(plugins);
+    const webpackConfiguration = {
+        entry: (0, append_extension_1.appendTsExtension)((0, path_1.join)(sourceRoot, entryFilename)),
+        devtool: isDebugEnabled ? 'inline-source-map' : false,
+        target: 'node',
+        output: {
+            filename: (0, path_1.join)(relativeSourceRoot, `${entryFilename}.js`),
+        },
+        ignoreWarnings: [/^(?!CriticalDependenciesWarning$)/],
+        externals: [nodeExternals()],
+        externalsPresets: { node: true },
+        module: {
+            rules: [
+                {
+                    test: /.tsx?$/,
+                    use: [
+                        {
+                            loader: 'ts-loader',
+                            options: {
+                                transpileOnly: !isPluginRegistered,
+                                configFile: tsConfigFile,
+                                getCustomTransformers: (program) => ({
+                                    before: plugins.beforeHooks.map((hook) => hook(program)),
+                                    after: plugins.afterHooks.map((hook) => hook(program)),
+                                    afterDeclarations: plugins.afterDeclarationsHooks.map((hook) => hook(program)),
+                                }),
+                            },
+                        },
+                    ],
+                    exclude: /node_modules/,
+                },
+            ],
+        },
+        resolve: {
+            extensions: ['.tsx', '.ts', '.js'],
+            plugins: [
+                new tsconfig_paths_webpack_plugin_1.TsconfigPathsPlugin({
+                    configFile: tsConfigFile,
+                }),
+            ],
+        },
+        mode: 'none',
+        optimization: {
+            nodeEnv: false,
+        },
+        node: {
+            __filename: false,
+            __dirname: false,
+        },
+        plugins: [
+            new webpack.IgnorePlugin({
+                checkResource(resource) {
+                    const lazyImports = [
+                        '@nestjs/microservices',
+                        '@nestjs/microservices/microservices-module',
+                        '@nestjs/websockets/socket-module',
+                        'class-validator',
+                        'class-transformer',
+                        'class-transformer/storage',
+                    ];
+                    if (!lazyImports.includes(resource)) {
+                        return false;
+                    }
+                    try {
+                        require.resolve(resource, {
+                            paths: [process.cwd()],
+                        });
+                    }
+                    catch (err) {
+                        return true;
+                    }
+                    return false;
+                },
+            }),
+        ],
+    };
+    if (!isPluginRegistered) {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
+        webpackConfiguration.plugins.push(new ForkTsCheckerWebpackPlugin({
+            typescript: {
+                configFile: tsConfigFile,
+            },
+        }));
+    }
+    return webpackConfiguration;
+};
+exports.webpackDefaultsFactory = webpackDefaultsFactory;
+function isAnyPluginRegistered(plugins) {
+    return ((plugins.afterHooks && plugins.afterHooks.length > 0) ||
+        (plugins.beforeHooks && plugins.beforeHooks.length > 0) ||
+        (plugins.afterDeclarationsHooks &&
+            plugins.afterDeclarationsHooks.length > 0));
+}

package/lib/compiler/helpers/append-extension.d.ts

@@ -0,0 +1 @@
+export declare function appendTsExtension(path: string): string;

package/lib/compiler/helpers/append-extension.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendTsExtension = appendTsExtension;
+const path_1 = require("path");
+function appendTsExtension(path) {
+    return (0, path_1.extname)(path) === '.ts' ? path : path + '.ts';
+}

package/lib/compiler/helpers/copy-path-resolve.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Helper function for returning a copy destination filename
+ *
+ * @description used in `assets-manager.ts` (copy from `copyfiles`)
+ * @see https://github.com/calvinmetcalf/copyfiles/blob/master/index.js#L22
+ */
+export declare function copyPathResolve(filePath: string, outDir: string, up: number): string;

package/lib/compiler/helpers/copy-path-resolve.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyPathResolve = copyPathResolve;
+const path = require("path");
+/**
+ * Helper function for returning a copy destination filename
+ *
+ * @description used in `assets-manager.ts` (copy from `copyfiles`)
+ * @see https://github.com/calvinmetcalf/copyfiles/blob/master/index.js#L22
+ */
+function copyPathResolve(filePath, outDir, up) {
+    return path.join(outDir, dealWith(filePath, up));
+}
+function dealWith(inPath, up) {
+    if (!up) {
+        return inPath;
+    }
+    if (depth(inPath) < up - 1) {
+        throw new Error('Path outside of project folder is not allowed');
+    }
+    return path.join(...path.normalize(inPath).split(path.sep).slice(up));
+}
+function depth(string) {
+    return path.normalize(string).split(path.sep).length - 1;
+}

package/lib/compiler/helpers/delete-out-dir.d.ts

@@ -0,0 +1,2 @@
+import { Configuration } from '../../configuration';
+export declare function deleteOutDirIfEnabled(configuration: Required<Configuration>, appName: string | undefined, dirPath: string): Promise<void>;

package/lib/compiler/helpers/delete-out-dir.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteOutDirIfEnabled = deleteOutDirIfEnabled;
+const promises_1 = require("fs/promises");
+const get_value_or_default_1 = require("./get-value-or-default");
+async function deleteOutDirIfEnabled(configuration, appName, dirPath) {
+    const isDeleteEnabled = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.deleteOutDir', appName);
+    if (!isDeleteEnabled) {
+        return;
+    }
+    await (0, promises_1.rm)(dirPath, { recursive: true, force: true });
+}

package/lib/compiler/helpers/get-builder.d.ts

@@ -0,0 +1,21 @@
+import { Input } from '../../../commands';
+import { Configuration } from '../../configuration';
+/**
+ * Returns the builder to use for the given application.
+ * @param configuration Configuration object.
+ * @param cmdOptions Command line options.
+ * @param appName Application name.
+ * @returns The builder to use.
+ */
+export declare function getBuilder(configuration: Required<Configuration>, cmdOptions: Input[], appName: string | undefined): {
+    type: "webpack";
+    options?: import("../../configuration").WebpackBuilderOptions;
+} | {
+    type: "swc";
+    options?: import("../../configuration").SwcBuilderOptions;
+} | {
+    type: "tsc";
+    options?: import("../../configuration").TscBuilderOptions;
+} | {
+    type: import("../../configuration").BuilderVariant;
+};

package/lib/compiler/helpers/get-builder.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBuilder = getBuilder;
+const get_value_or_default_1 = require("./get-value-or-default");
+/**
+ * Returns the builder to use for the given application.
+ * @param configuration Configuration object.
+ * @param cmdOptions Command line options.
+ * @param appName Application name.
+ * @returns The builder to use.
+ */
+function getBuilder(configuration, cmdOptions, appName) {
+    const builderValue = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.builder', appName, 'builder', cmdOptions, 'tsc');
+    return typeof builderValue === 'string'
+        ? {
+            type: builderValue,
+        }
+        : builderValue;
+}

package/lib/compiler/helpers/get-tsc-config.path.d.ts

@@ -0,0 +1,10 @@
+import { Input } from '../../../commands';
+import { Configuration } from '../../configuration';
+/**
+ * Returns the path to the tsc configuration file to use for the given application.
+ * @param configuration Configuration object.
+ * @param cmdOptions Command line options.
+ * @param appName Application name.
+ * @returns The path to the tsc configuration file to use.
+ */
+export declare function getTscConfigPath(configuration: Required<Configuration>, cmdOptions: Input[], appName: string | undefined): string;

package/lib/compiler/helpers/get-tsc-config.path.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTscConfigPath = getTscConfigPath;
+const get_default_tsconfig_path_1 = require("../../utils/get-default-tsconfig-path");
+const get_value_or_default_1 = require("./get-value-or-default");
+/**
+ * Returns the path to the tsc configuration file to use for the given application.
+ * @param configuration Configuration object.
+ * @param cmdOptions Command line options.
+ * @param appName Application name.
+ * @returns The path to the tsc configuration file to use.
+ */
+function getTscConfigPath(configuration, cmdOptions, appName) {
+    let tsconfigPath = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.tsConfigPath', appName, 'path', cmdOptions);
+    if (tsconfigPath) {
+        return tsconfigPath;
+    }
+    const builder = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.builder', appName);
+    tsconfigPath =
+        typeof builder === 'object' && builder?.type === 'tsc'
+            ? builder.options?.configPath
+            : undefined;
+    return tsconfigPath ?? (0, get_default_tsconfig_path_1.getDefaultTsconfigPath)();
+}

package/lib/compiler/helpers/get-value-or-default.d.ts

@@ -0,0 +1,4 @@
+import { Input } from '../../../commands';
+import { Configuration } from '../../configuration';
+export declare function getValueOrDefault<T = any>(configuration: Required<Configuration>, propertyPath: string, appName: string | undefined, key?: 'path' | 'webpack' | 'webpackPath' | 'entryFile' | 'sourceRoot' | 'exec' | 'builder' | 'typeCheck', options?: Input[], defaultValue?: T): T;
+export declare function getValueOfPath<T = any>(object: Record<string, any>, propertyPath: string): T;

package/lib/compiler/helpers/get-value-or-default.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValueOrDefault = getValueOrDefault;
+exports.getValueOfPath = getValueOfPath;
+function getValueOrDefault(configuration, propertyPath, appName, key, options = [], defaultValue) {
+    const item = options.find((option) => option.name === key);
+    const origValue = item && item.value;
+    if (origValue !== undefined && origValue !== null) {
+        return origValue;
+    }
+    if (configuration.projects && configuration.projects[appName]) {
+        // Wrap the application name in double-quotes to prevent splitting it
+        // into separate chunks
+        appName = appName && !appName.includes('"') ? `"${appName}"` : appName;
+        const perAppValue = getValueOfPath(configuration, `projects.${appName}.`.concat(propertyPath));
+        if (perAppValue !== undefined) {
+            return perAppValue;
+        }
+    }
+    let value = getValueOfPath(configuration, propertyPath);
+    if (value === undefined) {
+        value = defaultValue;
+    }
+    return value;
+}
+function getValueOfPath(object, propertyPath) {
+    const fragments = propertyPath.split('.');
+    let propertyValue = object;
+    let isConcatInProgress = false;
+    let path = '';
+    for (const fragment of fragments) {
+        if (!propertyValue) {
+            break;
+        }
+        /**
+         * When path is escaped with "" double quotes,
+         * concatenate the property path.
+         * Reference: https://github.com/nestjs/nest-cli/issues/947
+         */
+        if (fragment.startsWith('"') && fragment.endsWith('"')) {
+            path = stripDoubleQuotes(fragment);
+        }
+        else if (fragment.startsWith('"')) {
+            path += stripDoubleQuotes(fragment) + '.';
+            isConcatInProgress = true;
+            continue;
+        }
+        else if (isConcatInProgress && !fragment.endsWith('"')) {
+            path += fragment + '.';
+            continue;
+        }
+        else if (fragment.endsWith('"')) {
+            path += stripDoubleQuotes(fragment);
+            isConcatInProgress = false;
+        }
+        else {
+            path = fragment;
+        }
+        propertyValue = propertyValue[path];
+        path = '';
+    }
+    return propertyValue;
+}
+function stripDoubleQuotes(text) {
+    return text.replace(/"/g, '');
+}

package/lib/compiler/helpers/get-webpack-config-path.d.ts

@@ -0,0 +1,10 @@
+import { Input } from '../../../commands';
+import { Configuration } from '../../configuration';
+/**
+ * Returns the path to the webpack configuration file to use for the given application.
+ * @param configuration Configuration object.
+ * @param cmdOptions Command line options.
+ * @param appName Application name.
+ * @returns The path to the webpack configuration file to use.
+ */
+export declare function getWebpackConfigPath(configuration: Required<Configuration>, cmdOptions: Input[], appName: string | undefined): string | undefined;

package/lib/compiler/helpers/get-webpack-config-path.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWebpackConfigPath = getWebpackConfigPath;
+const get_value_or_default_1 = require("./get-value-or-default");
+/**
+ * Returns the path to the webpack configuration file to use for the given application.
+ * @param configuration Configuration object.
+ * @param cmdOptions Command line options.
+ * @param appName Application name.
+ * @returns The path to the webpack configuration file to use.
+ */
+function getWebpackConfigPath(configuration, cmdOptions, appName) {
+    let webpackPath = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.webpackConfigPath', appName, 'webpackPath', cmdOptions);
+    if (webpackPath) {
+        return webpackPath;
+    }
+    const builder = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.builder', appName);
+    webpackPath =
+        typeof builder === 'object' && builder?.type === 'webpack'
+            ? builder.options?.configPath
+            : undefined;
+    return webpackPath;
+}

package/lib/compiler/helpers/manual-restart.d.ts

@@ -0,0 +1,2 @@
+export declare function listenForManualRestart(callback: () => void): void;
+export declare function displayManualRestartTip(): void;

package/lib/compiler/helpers/manual-restart.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listenForManualRestart = listenForManualRestart;
+exports.displayManualRestartTip = displayManualRestartTip;
+const ansis_1 = require("ansis");
+function listenForManualRestart(callback) {
+    const stdinListener = (data) => {
+        if (data.toString().trim() === 'rs') {
+            process.stdin.removeListener('data', stdinListener);
+            callback();
+        }
+    };
+    process.stdin.on('data', stdinListener);
+}
+function displayManualRestartTip() {
+    console.log(`To restart at any time, enter ${(0, ansis_1.gray) `rs`}.\n`);
+}

package/lib/compiler/helpers/tsconfig-provider.d.ts

@@ -0,0 +1,11 @@
+import * as ts from 'typescript';
+import { TypeScriptBinaryLoader } from '../typescript-loader';
+export declare class TsConfigProvider {
+    private readonly typescriptLoader;
+    constructor(typescriptLoader: TypeScriptBinaryLoader);
+    getByConfigFilename(configFilename: string): {
+        options: ts.CompilerOptions;
+        fileNames: string[];
+        projectReferences: readonly ts.ProjectReference[] | undefined;
+    };
+}

package/lib/compiler/helpers/tsconfig-provider.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsConfigProvider = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ui_1 = require("../../ui");
+class TsConfigProvider {
+    constructor(typescriptLoader) {
+        this.typescriptLoader = typescriptLoader;
+    }
+    getByConfigFilename(configFilename) {
+        const configPath = (0, path_1.join)(process.cwd(), configFilename);
+        if (!(0, fs_1.existsSync)(configPath)) {
+            throw new Error(ui_1.CLI_ERRORS.MISSING_TYPESCRIPT(configFilename));
+        }
+        const tsBinary = this.typescriptLoader.load();
+        const parsedCmd = tsBinary.getParsedCommandLineOfConfigFile(configPath, undefined, tsBinary.sys);
+        const { options, fileNames, projectReferences } = parsedCmd;
+        return { options, fileNames, projectReferences };
+    }
+}
+exports.TsConfigProvider = TsConfigProvider;

package/lib/compiler/hooks/tsconfig-paths.hook.d.ts

@@ -0,0 +1,2 @@
+import * as ts from 'typescript';
+export declare function tsconfigPathsBeforeHookFactory(compilerOptions: ts.CompilerOptions): (ctx: ts.TransformationContext) => ts.Transformer<any>;