@gadmin2n/cli 0.0.73

package/lib/compiler/assets-manager.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetsManager = void 0;
+const chokidar = require("chokidar");
+const path_1 = require("path");
+const shell = require("shelljs");
+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) => {
+                if (typeof item === 'string') {
+                    return {
+                        glob: (0, path_1.join)(sourceRoot, item),
+                        outDir,
+                    };
+                }
+                return {
+                    outDir: item.outDir || outDir,
+                    glob: (0, path_1.join)(sourceRoot, item.include),
+                    exclude: item.exclude ? (0, path_1.join)(sourceRoot, item.exclude) : undefined,
+                    flat: item.flat,
+                    watchAssets: item.watchAssets,
+                };
+            });
+            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,
+                };
+                // prettier-ignore
+                const watcher = chokidar
+                    .watch(item.glob, { ignored: item.exclude })
+                    .on('add', (path) => this.actionOnFile(Object.assign(Object.assign({}, option), { path, action: 'change' })))
+                    .on('change', (path) => this.actionOnFile(Object.assign(Object.assign({}, option), { path, action: 'change' })))
+                    .on('unlink', (path) => this.actionOnFile(Object.assign(Object.assign({}, option), { path, action: 'unlink' })));
+                this.watchers.push(watcher);
+            }
+        }
+        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;
+        // Allow to do action for the first time before check watchMode
+        if (!isWatchEnabled && this.watchAssetsKeyValue[path]) {
+            return;
+        }
+        // Set path value to true for watching the first time
+        this.watchAssetsKeyValue[path] = 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') {
+            shell.mkdir('-p', (0, path_1.dirname)(dest));
+            shell.cp(path, dest);
+        }
+        else if (action === 'unlink') {
+            // Remove from output dir if file is deleted
+            shell.rm(dest);
+        }
+    }
+}
+exports.AssetsManager = AssetsManager;

package/lib/compiler/compiler.d.ts

@@ -0,0 +1,12 @@
+import { Configuration } from '../configuration';
+import { TsConfigProvider } from './helpers/tsconfig-provider';
+import { PluginsLoader } from './plugins-loader';
+import { TypeScriptBinaryLoader } from './typescript-loader';
+export declare class Compiler {
+    private readonly pluginsLoader;
+    private readonly tsConfigProvider;
+    private readonly typescriptLoader;
+    constructor(pluginsLoader: PluginsLoader, tsConfigProvider: TsConfigProvider, typescriptLoader: TypeScriptBinaryLoader);
+    run(configuration: Required<Configuration>, configFilename: string, appName: string, onSuccess?: () => void): void;
+    private reportAfterCompilationDiagnostic;
+}

package/lib/compiler/compiler.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compiler = void 0;
+const ts = require("typescript");
+const get_value_or_default_1 = require("./helpers/get-value-or-default");
+const tsconfig_paths_hook_1 = require("./hooks/tsconfig-paths.hook");
+class Compiler {
+    constructor(pluginsLoader, tsConfigProvider, typescriptLoader) {
+        this.pluginsLoader = pluginsLoader;
+        this.tsConfigProvider = tsConfigProvider;
+        this.typescriptLoader = typescriptLoader;
+    }
+    run(configuration, configFilename, appName, 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(configFilename);
+        const createProgram = tsBinary.createIncrementalProgram || tsBinary.createProgram;
+        const program = createProgram.call(ts, {
+            rootNames: fileNames,
+            projectReferences,
+            options,
+        });
+        const pluginsConfig = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.plugins', appName);
+        const plugins = this.pluginsLoader.load(pluginsConfig);
+        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: before.concat(tsconfigPathsPlugin),
+            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/webpack-defaults.d.ts

@@ -0,0 +1,3 @@
+import { MultiNestCompilerPlugins } from '../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,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webpackDefaultsFactory = void 0;
+const ForkTsCheckerWebpackPlugin = require("fork-ts-checker-webpack-plugin");
+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.defaultConfiguration.compilerOptions.tsConfigPath, plugins) => ({
+    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: !isAnyPluginRegistered(plugins),
+                            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',
+                    'cache-manager',
+                    'class-validator',
+                    'class-transformer',
+                ];
+                if (!lazyImports.includes(resource)) {
+                    return false;
+                }
+                try {
+                    require.resolve(resource, {
+                        paths: [process.cwd()],
+                    });
+                }
+                catch (err) {
+                    return true;
+                }
+                return false;
+            },
+        }),
+        new ForkTsCheckerWebpackPlugin({
+            typescript: {
+                configFile: tsConfigFile,
+            },
+        }),
+    ],
+});
+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,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendTsExtension = void 0;
+const path_1 = require("path");
+function appendTsExtension(path) {
+    return (0, path_1.extname)(path) === '.ts' ? path : path + '.ts';
+}
+exports.appendTsExtension = appendTsExtension;

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,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyPathResolve = void 0;
+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));
+}
+exports.copyPathResolve = copyPathResolve;
+function dealWith(inPath, up) {
+    if (!up) {
+        return inPath;
+    }
+    if (depth(inPath) < up) {
+        throw new Error('cant go up that far');
+    }
+    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/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, key?: 'path' | 'webpack' | 'webpackPath', 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,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValueOfPath = exports.getValueOrDefault = void 0;
+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;
+}
+exports.getValueOrDefault = getValueOrDefault;
+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;
+}
+exports.getValueOfPath = getValueOfPath;
+function stripDoubleQuotes(text) {
+    return text.replace(/"/g, '');
+}

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>;

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsconfigPathsBeforeHookFactory = void 0;
+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();
+    const { paths = {}, baseUrl = './' } = compilerOptions;
+    const matcher = tsPaths.createMatchPath(baseUrl, paths, ['main']);
+    return (ctx) => {
+        return (sf) => {
+            const visitNode = (node) => {
+                if (tsBinary.isImportDeclaration(node) ||
+                    (tsBinary.isExportDeclaration(node) && node.moduleSpecifier)) {
+                    try {
+                        const newNode = tsBinary.getMutableClone(node);
+                        const importPathWithQuotes = node.moduleSpecifier && node.moduleSpecifier.getText();
+                        if (!importPathWithQuotes) {
+                            return node;
+                        }
+                        const text = importPathWithQuotes.substr(1, importPathWithQuotes.length - 2);
+                        const result = getNotAliasedPath(sf, matcher, text);
+                        if (!result) {
+                            return node;
+                        }
+                        newNode.moduleSpecifier = tsBinary.createLiteral(result);
+                        newNode.moduleSpecifier.parent = node.moduleSpecifier.parent;
+                        newNode.flags = node.flags;
+                        return newNode;
+                    }
+                    catch (_a) {
+                        return node;
+                    }
+                }
+                return tsBinary.visitEachChild(node, visitNode, ctx);
+            };
+            return tsBinary.visitNode(sf, visitNode);
+        };
+    };
+}
+exports.tsconfigPathsBeforeHookFactory = tsconfigPathsBeforeHookFactory;
+function getNotAliasedPath(sf, matcher, text) {
+    let result = matcher(text, undefined, undefined, [
+        '.ts',
+        '.tsx',
+        '.js',
+        '.jsx',
+    ]);
+    if (!result) {
+        return;
+    }
+    if (os.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],
+        });
+        if (packagePath) {
+            return text;
+        }
+    }
+    catch (_a) { }
+    const resolvedPath = path_1.posix.relative((0, path_1.dirname)(sf.fileName), result) || './';
+    return resolvedPath[0] === '.' ? resolvedPath : './' + resolvedPath;
+}

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

@@ -0,0 +1,21 @@
+import * as ts from 'typescript';
+declare type Transformer = ts.TransformerFactory<any> | ts.CustomTransformerFactory;
+declare type PluginEntry = string | PluginAndOptions;
+interface PluginAndOptions {
+    name: 'string';
+    options: Record<string, any>;
+}
+export interface NestCompilerPlugin {
+    before?: (options?: Record<string, any>, program?: ts.Program) => Transformer;
+    after?: (options?: Record<string, any>, program?: ts.Program) => Transformer;
+    afterDeclarations?: (options?: Record<string, any>, program?: ts.Program) => Transformer;
+}
+export interface MultiNestCompilerPlugins {
+    beforeHooks: Array<(program?: ts.Program) => Transformer>;
+    afterHooks: Array<(program?: ts.Program) => Transformer>;
+    afterDeclarationsHooks: Array<(program?: ts.Program) => Transformer>;
+}
+export declare class PluginsLoader {
+    load(plugins?: PluginEntry[]): MultiNestCompilerPlugins;
+}
+export {};

package/lib/compiler/plugins-loader.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginsLoader = void 0;
+const path_1 = require("path");
+const util_1 = require("util");
+const ui_1 = require("../ui");
+const PLUGIN_ENTRY_FILENAME = 'plugin';
+class PluginsLoader {
+    load(plugins = []) {
+        const pluginNames = plugins.map((entry) => (0, util_1.isObject)(entry) ? entry.name : entry);
+        const nodeModulePaths = [
+            (0, path_1.join)(process.cwd(), 'node_modules'),
+            ...module.paths,
+        ];
+        const pluginRefs = pluginNames.map((item) => {
+            try {
+                try {
+                    const binaryPath = require.resolve((0, path_1.join)(item, PLUGIN_ENTRY_FILENAME), {
+                        paths: nodeModulePaths,
+                    });
+                    return require(binaryPath);
+                }
+                catch (_a) { }
+                const binaryPath = require.resolve(item, { paths: nodeModulePaths });
+                return require(binaryPath);
+            }
+            catch (e) {
+                throw new Error(`"${item}" plugin could not be found!`);
+            }
+        });
+        const beforeHooks = [];
+        const afterHooks = [];
+        const afterDeclarationsHooks = [];
+        pluginRefs.forEach((plugin, index) => {
+            if (!plugin.before && !plugin.after && !plugin.afterDeclarations) {
+                throw new Error(ui_1.CLI_ERRORS.WRONG_PLUGIN(pluginNames[index]));
+            }
+            const options = (0, util_1.isObject)(plugins[index])
+                ? plugins[index].options || {}
+                : {};
+            plugin.before &&
+                beforeHooks.push(plugin.before.bind(plugin.before, options));
+            plugin.after && afterHooks.push(plugin.after.bind(plugin.after, options));
+            plugin.afterDeclarations &&
+                afterDeclarationsHooks.push(plugin.afterDeclarations.bind(plugin.afterDeclarations, options));
+        });
+        return {
+            beforeHooks,
+            afterHooks,
+            afterDeclarationsHooks,
+        };
+    }
+}
+exports.PluginsLoader = PluginsLoader;

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

@@ -0,0 +1,6 @@
+import * as ts from 'typescript';
+export declare class TypeScriptBinaryLoader {
+    private tsBinary?;
+    load(): typeof ts;
+    getModulePaths(): string[];
+}

package/lib/compiler/typescript-loader.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptBinaryLoader = void 0;
+class TypeScriptBinaryLoader {
+    load() {
+        if (this.tsBinary) {
+            return this.tsBinary;
+        }
+        try {
+            const tsBinaryPath = require.resolve('typescript', {
+                paths: [process.cwd(), ...this.getModulePaths()],
+            });
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const tsBinary = require(tsBinaryPath);
+            this.tsBinary = tsBinary;
+            return tsBinary;
+        }
+        catch (_a) {
+            throw new Error('TypeScript could not be found! Please, install "typescript" package.');
+        }
+    }
+    getModulePaths() {
+        const modulePaths = module.paths.slice(2, module.paths.length);
+        const packageDeps = modulePaths.slice(0, 3);
+        return [
+            ...packageDeps.reverse(),
+            ...modulePaths.slice(3, modulePaths.length).reverse(),
+        ];
+    }
+}
+exports.TypeScriptBinaryLoader = TypeScriptBinaryLoader;

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

@@ -0,0 +1,14 @@
+import * as ts from 'typescript';
+import { Configuration } from '../configuration';
+import { TsConfigProvider } from './helpers/tsconfig-provider';
+import { PluginsLoader } from './plugins-loader';
+import { TypeScriptBinaryLoader } from './typescript-loader';
+export declare class WatchCompiler {
+    private readonly pluginsLoader;
+    private readonly tsConfigProvider;
+    private readonly typescriptLoader;
+    constructor(pluginsLoader: PluginsLoader, tsConfigProvider: TsConfigProvider, typescriptLoader: TypeScriptBinaryLoader);
+    run(configuration: Required<Configuration>, configFilename: string, appName: string, tsCompilerOptions: ts.CompilerOptions, onSuccess?: () => void): void;
+    private createDiagnosticReporter;
+    private createWatchStatusChanged;
+}