@depup/nestjs__cli 11.0.16-depup.1

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsconfigPathsBeforeHookFactory = tsconfigPathsBeforeHookFactory;
+const os = require("os");
+const path_1 = require("path");
+const typescript_loader_1 = require("../typescript-loader");
+const tsPaths = require("tsconfig-paths");
+function tsconfigPathsBeforeHookFactory(compilerOptions) {
+    const tsBinary = new typescript_loader_1.TypeScriptBinaryLoader().load();
+    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 importPathWithQuotes = node.moduleSpecifier && node.moduleSpecifier.getText();
+                        if (!importPathWithQuotes) {
+                            return node;
+                        }
+                        const text = importPathWithQuotes.substring(1, importPathWithQuotes.length - 1);
+                        const result = getNotAliasedPath(sf, matcher, text);
+                        if (!result) {
+                            return node;
+                        }
+                        const moduleSpecifier = tsBinary.factory.createStringLiteral(result);
+                        moduleSpecifier.parent = node.moduleSpecifier.parent;
+                        if (tsBinary.isImportDeclaration(node)) {
+                            const updatedNode = tsBinary.factory.updateImportDeclaration(node, node.modifiers, node.importClause, moduleSpecifier, node.assertClause);
+                            updatedNode.flags = node.flags;
+                            return updatedNode;
+                        }
+                        else {
+                            const updatedNode = tsBinary.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
+                            updatedNode.flags = node.flags;
+                            return updatedNode;
+                        }
+                    }
+                    catch {
+                        return node;
+                    }
+                }
+                return tsBinary.visitEachChild(node, visitNode, ctx);
+            };
+            return tsBinary.visitNode(sf, visitNode);
+        };
+    };
+}
+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 { }
+    const resolvedPath = path_1.posix.relative((0, path_1.dirname)(sf.fileName), result) || './';
+    return resolvedPath[0] === '.' ? resolvedPath : './' + resolvedPath;
+}

package/lib/compiler/interfaces/readonly-visitor.interface.d.ts

@@ -0,0 +1,10 @@
+import * as ts from 'typescript';
+export type DeepPluginMeta = ts.ObjectLiteralExpression | {
+    [key: string]: DeepPluginMeta;
+};
+export interface ReadonlyVisitor {
+    key: string;
+    typeImports: Record<string, string>;
+    visit(program: unknown, sf: unknown): unknown;
+    collect(): Record<string, Array<unknown>>;
+}

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

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

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

@@ -0,0 +1,58 @@
+import * as ts from 'typescript';
+import { ReadonlyVisitor } from '../interfaces/readonly-visitor.interface';
+export interface PluginMetadataGenerateOptions {
+    /**
+     * The visitors to use to generate the metadata.
+     */
+    visitors: ReadonlyVisitor[];
+    /**
+     * The output directory to write the metadata to.
+     */
+    outputDir: string;
+    /**
+     * Whether to watch the project for changes.
+     */
+    watch?: boolean;
+    /**
+     * The path to the tsconfig file.
+     * Relative to the current working directory (process.cwd()).
+     */
+    tsconfigPath?: string;
+    /**
+     * The filename to write the metadata to.
+     */
+    filename?: string;
+    /**
+     * A reference to an existing ts.Program instance.
+     */
+    tsProgramRef?: ts.Program;
+    /**
+     * Whether to print diagnostics to the console.
+     * @default true
+     */
+    printDiagnostics?: boolean;
+}
+/**
+ * Generates plugins metadata by traversing the AST of the project.
+ * @example
+ * ```ts
+ * const generator = new PluginMetadataGenerator();
+ * generator.generate({
+ *  visitors: [
+ *    new ReadonlyVisitor({ introspectComments: true, pathToSource: __dirname }),
+ *  ],
+ *  outputDir: __dirname,
+ *  watch: true,
+ *  tsconfigPath: 'tsconfig.build.json',
+ * });
+ * ```
+ */
+export declare class PluginMetadataGenerator {
+    private readonly pluginMetadataPrinter;
+    private readonly typeCheckerHost;
+    private readonly typescriptLoader;
+    private readonly tsBinary;
+    constructor();
+    generate(options: PluginMetadataGenerateOptions): void;
+    private traverseAndPrintMetadata;
+}

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginMetadataGenerator = void 0;
+const constants_1 = require("../swc/constants");
+const type_checker_host_1 = require("../swc/type-checker-host");
+const typescript_loader_1 = require("../typescript-loader");
+const plugin_metadata_printer_1 = require("./plugin-metadata-printer");
+/**
+ * Generates plugins metadata by traversing the AST of the project.
+ * @example
+ * ```ts
+ * const generator = new PluginMetadataGenerator();
+ * generator.generate({
+ *  visitors: [
+ *    new ReadonlyVisitor({ introspectComments: true, pathToSource: __dirname }),
+ *  ],
+ *  outputDir: __dirname,
+ *  watch: true,
+ *  tsconfigPath: 'tsconfig.build.json',
+ * });
+ * ```
+ */
+class PluginMetadataGenerator {
+    constructor() {
+        this.pluginMetadataPrinter = new plugin_metadata_printer_1.PluginMetadataPrinter();
+        this.typeCheckerHost = new type_checker_host_1.TypeCheckerHost();
+        this.typescriptLoader = new typescript_loader_1.TypeScriptBinaryLoader();
+        this.tsBinary = this.typescriptLoader.load();
+    }
+    generate(options) {
+        const { tsconfigPath, visitors, tsProgramRef, outputDir, watch, filename, printDiagnostics = true, } = options;
+        if (visitors.length === 0) {
+            return;
+        }
+        if (tsProgramRef) {
+            return this.traverseAndPrintMetadata(tsProgramRef, visitors, outputDir, filename);
+        }
+        const onTypeCheckOrProgramInit = (program) => {
+            this.traverseAndPrintMetadata(program, visitors, outputDir, filename);
+            if (printDiagnostics) {
+                const tsBinary = this.typescriptLoader.load();
+                const diagnostics = tsBinary.getPreEmitDiagnostics(program);
+                if (diagnostics.length > 0) {
+                    const formatDiagnosticsHost = {
+                        getCanonicalFileName: (path) => path,
+                        getCurrentDirectory: tsBinary.sys.getCurrentDirectory,
+                        getNewLine: () => tsBinary.sys.newLine,
+                    };
+                    console.log();
+                    console.log(tsBinary.formatDiagnosticsWithColorAndContext(diagnostics, formatDiagnosticsHost));
+                }
+                else {
+                    console.log(constants_1.FOUND_NO_ISSUES_GENERATING_METADATA);
+                }
+            }
+        };
+        this.typeCheckerHost.run(tsconfigPath, {
+            watch,
+            onTypeCheck: onTypeCheckOrProgramInit,
+            onProgramInit: onTypeCheckOrProgramInit,
+        });
+    }
+    traverseAndPrintMetadata(programRef, visitors, outputDir, filename) {
+        for (const sourceFile of programRef.getSourceFiles()) {
+            if (!sourceFile.isDeclarationFile) {
+                visitors.forEach((visitor) => visitor.visit(programRef, sourceFile));
+            }
+        }
+        let typeImports = {};
+        const collectedMetadata = {};
+        visitors.forEach((visitor) => {
+            collectedMetadata[visitor.key] = visitor.collect();
+            typeImports = {
+                ...typeImports,
+                ...visitor.typeImports,
+            };
+        });
+        this.pluginMetadataPrinter.print(collectedMetadata, typeImports, {
+            outputDir,
+            filename,
+        }, this.tsBinary);
+    }
+}
+exports.PluginMetadataGenerator = PluginMetadataGenerator;

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

@@ -0,0 +1,17 @@
+import * as ts from 'typescript';
+import { DeepPluginMeta } from '../interfaces/readonly-visitor.interface';
+export interface PluginMetadataPrintOptions {
+    outputDir: string;
+    filename?: string;
+}
+type ComposedPluginMeta = Record<string, Record<string, Array<[ts.CallExpression, DeepPluginMeta]>>>;
+/**
+ * Prints the metadata to a file.
+ */
+export declare class PluginMetadataPrinter {
+    print(metadata: ComposedPluginMeta, typeImports: Record<string, string>, options: PluginMetadataPrintOptions, tsBinary: typeof ts): void;
+    private recursivelyCreatePropertyAssignment;
+    private createTypeImportVariableStatement;
+    private createPropertyAssignment;
+}
+export {};

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginMetadataPrinter = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const SERIALIZED_METADATA_FILENAME = 'metadata.ts';
+const TYPE_IMPORT_VARIABLE_NAME = 't';
+/**
+ * Prints the metadata to a file.
+ */
+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([
+            this.createTypeImportVariableStatement(typeImports, tsBinary),
+            tsBinary.factory.createReturnStatement(objectLiteralExpr),
+        ], true)));
+        const printer = tsBinary.createPrinter({
+            newLine: tsBinary.NewLineKind.LineFeed,
+        });
+        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 eslintPrefix = `/* eslint-disable */\n`;
+        (0, fs_1.writeFileSync)(filename, eslintPrefix +
+            printer.printNode(tsBinary.EmitHint.Unspecified, exportAssignment, resultFile));
+    }
+    recursivelyCreatePropertyAssignment(identifier, meta, tsBinary) {
+        if (Array.isArray(meta)) {
+            return tsBinary.factory.createPropertyAssignment(tsBinary.factory.createStringLiteral(identifier), tsBinary.factory.createArrayLiteralExpression(meta.map(([importExpr, meta]) => tsBinary.factory.createArrayLiteralExpression([
+                importExpr,
+                tsBinary.factory.createObjectLiteralExpression(Object.keys(meta).map((key) => this.recursivelyCreatePropertyAssignment(key, meta[key], tsBinary))),
+            ]))));
+        }
+        return tsBinary.factory.createPropertyAssignment(tsBinary.factory.createStringLiteral(identifier), tsBinary.isObjectLiteralExpression(meta)
+            ? meta
+            : tsBinary.factory.createObjectLiteralExpression(Object.keys(meta).map((key) => this.recursivelyCreatePropertyAssignment(key, meta[key], tsBinary))));
+    }
+    createTypeImportVariableStatement(typeImports, tsBinary) {
+        return tsBinary.factory.createVariableStatement(undefined, tsBinary.factory.createVariableDeclarationList([
+            tsBinary.factory.createVariableDeclaration(tsBinary.factory.createIdentifier(TYPE_IMPORT_VARIABLE_NAME), undefined, undefined, tsBinary.factory.createObjectLiteralExpression(Object.keys(typeImports).map((ti) => this.createPropertyAssignment(ti, typeImports[ti], tsBinary)), true)),
+        ], tsBinary.NodeFlags.Const |
+            tsBinary.NodeFlags.AwaitContext |
+            tsBinary.NodeFlags.ContextFlags |
+            tsBinary.NodeFlags.TypeExcludesFlags));
+    }
+    createPropertyAssignment(identifier, target, tsBinary) {
+        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

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

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginsLoader = void 0;
+const path_1 = require("path");
+const ui_1 = require("../../ui");
+const PLUGIN_ENTRY_FILENAME = 'plugin';
+class PluginsLoader {
+    load(plugins = [], extras = {}) {
+        const pluginNames = plugins.map((entry) => typeof entry === 'object'
+            ? entry.name
+            : entry);
+        const pluginRefs = this.resolvePluginReferences(pluginNames);
+        const multiCompilerPlugins = {
+            afterHooks: [],
+            afterDeclarationsHooks: [],
+            beforeHooks: [],
+            readonlyVisitors: [],
+        };
+        pluginRefs.forEach((plugin, index) => {
+            if (!plugin.before && !plugin.after && !plugin.afterDeclarations) {
+                throw new Error(ui_1.CLI_ERRORS.WRONG_PLUGIN(pluginNames[index]));
+            }
+            const options = typeof plugins[index] === 'object'
+                ? plugins[index].options || {}
+                : {};
+            if (plugin.before) {
+                multiCompilerPlugins.beforeHooks.push(plugin.before.bind(plugin.before, options));
+            }
+            if (plugin.after) {
+                multiCompilerPlugins.afterHooks.push(plugin.after.bind(plugin.after, options));
+            }
+            if (plugin.afterDeclarations) {
+                multiCompilerPlugins.afterDeclarationsHooks.push(plugin.afterDeclarations.bind(plugin.afterDeclarations, options));
+            }
+            if (plugin.ReadonlyVisitor) {
+                const instance = new plugin.ReadonlyVisitor({
+                    ...options,
+                    ...extras,
+                    readonly: true,
+                });
+                instance.key = pluginNames[index];
+                multiCompilerPlugins.readonlyVisitors.push(instance);
+            }
+        });
+        return multiCompilerPlugins;
+    }
+    resolvePluginReferences(pluginNames) {
+        const nodeModulePaths = [
+            (0, path_1.join)(process.cwd(), 'node_modules'),
+            ...module.paths,
+        ];
+        return pluginNames.map((item) => {
+            try {
+                try {
+                    const binaryPath = require.resolve((0, path_1.join)(item, PLUGIN_ENTRY_FILENAME), {
+                        paths: nodeModulePaths,
+                    });
+                    return require(binaryPath);
+                }
+                catch { }
+                const binaryPath = require.resolve(item, { paths: nodeModulePaths });
+                return require(binaryPath);
+            }
+            catch (e) {
+                throw new Error(`"${item}" plugin is not installed.`);
+            }
+        });
+    }
+}
+exports.PluginsLoader = PluginsLoader;

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

@@ -0,0 +1,9 @@
+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;
+export declare const TSC_LOG_SUCCESS_PREFIX: string;
+export declare const INITIALIZING_TYPE_CHECKER: string;
+export declare const FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED: string;
+export declare const FOUND_NO_ISSUES_GENERATING_METADATA: string;

package/lib/compiler/swc/constants.js

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

package/lib/compiler/swc/forked-type-checker.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,63 @@
+"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");
+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();
+    }
+    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);
+                    this.pluginMetadataGenerator.generate({
+                        outputDir,
+                        visitors: readonlyVisitors,
+                        tsProgramRef: program,
+                    });
+                }
+                else {
+                    console.log(constants_1.FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED);
+                }
+            };
+            this.typeCheckerHost.run(tsConfigPath, {
+                watch: extras.watch,
+                onTypeCheck: onTypeCheckOrProgramInit,
+                onProgramInit: onTypeCheckOrProgramInit,
+            });
+        }
+        catch (err) {
+            console.log(ui_1.ERROR_PREFIX, err.message);
+        }
+    }
+}
+const pluginsLoader = new plugins_loader_1.PluginsLoader();
+const forkedTypeChecker = new ForkedTypeChecker(pluginsLoader);
+const applicationName = appName === 'undefined' ? '' : appName;
+const options = {
+    sourceRoot,
+};
+if (applicationName) {
+    options.projects = {};
+    options.projects[applicationName] = {
+        compilerOptions: {
+            plugins: JSON.parse(plugins),
+        },
+    };
+}
+else {
+    options.compilerOptions = {
+        plugins: JSON.parse(plugins),
+    };
+}
+forkedTypeChecker.run(options, tsConfigPath, applicationName, { watch: true, typeCheck: true });

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

@@ -0,0 +1,25 @@
+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';
+export type SwcCompilerExtras = {
+    watch: boolean;
+    typeCheck: boolean;
+    assetsManager: AssetsManager;
+    tsOptions: ts.CompilerOptions;
+};
+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 runTypeChecker;
+    private runSwc;
+    private loadSwcCliBinary;
+    private getSwcRcFileContentIfExists;
+    private deepMerge;
+    private debounce;
+    private watchFilesInSrcDir;
+    private watchFilesInOutDir;
+}