@nx/js 0.0.0-pr-22179-271588f

package/src/utils/swc/add-swc-config.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSwcConfig = exports.defaultExclude = void 0;
+const path_1 = require("path");
+exports.defaultExclude = [
+    'jest.config.ts',
+    '.*\\.spec.tsx?$',
+    '.*\\.test.tsx?$',
+    './src/jest-setup.ts$',
+    './**/jest-setup.ts$',
+    '.*.js$',
+];
+const swcOptionsString = (type = 'commonjs') => `{
+  "jsc": {
+    "target": "es2017",
+    "parser": {
+      "syntax": "typescript",
+      "decorators": true,
+      "dynamicImport": true
+    },
+    "transform": {
+      "decoratorMetadata": true,
+      "legacyDecorator": true
+    },
+    "keepClassNames": true,
+    "externalHelpers": true,
+    "loose": true
+  },
+  "module": {
+    "type": "${type}"
+  },
+  "sourceMaps": true,
+  "exclude": ${JSON.stringify(exports.defaultExclude)}
+}`;
+function addSwcConfig(tree, projectDir, type = 'commonjs') {
+    const swcrcPath = (0, path_1.join)(projectDir, '.swcrc');
+    if (tree.exists(swcrcPath))
+        return;
+    tree.write(swcrcPath, swcOptionsString(type));
+}
+exports.addSwcConfig = addSwcConfig;

package/src/utils/swc/add-swc-dependencies.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export declare function addSwcDependencies(tree: Tree): import("@nx/devkit").GeneratorCallback;
+export declare function addSwcRegisterDependencies(tree: Tree): import("@nx/devkit").GeneratorCallback;

package/src/utils/swc/add-swc-dependencies.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSwcRegisterDependencies = exports.addSwcDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../versions");
+function addSwcDependencies(tree) {
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {
+        '@swc/helpers': versions_1.swcHelpersVersion,
+    }, {
+        '@swc/core': versions_1.swcCoreVersion,
+        '@swc/cli': versions_1.swcCliVersion,
+    });
+}
+exports.addSwcDependencies = addSwcDependencies;
+function addSwcRegisterDependencies(tree) {
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@swc-node/register': versions_1.swcNodeVersion, '@swc/core': versions_1.swcCoreVersion });
+}
+exports.addSwcRegisterDependencies = addSwcRegisterDependencies;

package/src/utils/swc/compile-swc.d.ts

@@ -0,0 +1,13 @@
+import { ExecutorContext } from '@nx/devkit';
+import { NormalizedSwcExecutorOptions } from '../schema';
+export declare function compileSwc(context: ExecutorContext, normalizedOptions: NormalizedSwcExecutorOptions, postCompilationCallback: () => Promise<void>): Promise<{
+    success: boolean;
+    outfile?: undefined;
+} | {
+    success: boolean;
+    outfile: string;
+}>;
+export declare function compileSwcWatch(context: ExecutorContext, normalizedOptions: NormalizedSwcExecutorOptions, postCompilationCallback: () => Promise<void>): AsyncGenerator<{
+    success: boolean;
+    outfile: string;
+}, any, undefined>;

package/src/utils/swc/compile-swc.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileSwcWatch = exports.compileSwc = void 0;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const fs_extra_1 = require("fs-extra");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const print_diagnostics_1 = require("../typescript/print-diagnostics");
+const run_type_check_1 = require("../typescript/run-type-check");
+function getSwcCmd({ swcrcPath, srcPath, destPath }, watch = false) {
+    const swcCLI = require.resolve('@swc/cli/bin/swc.js');
+    let swcCmd = `node ${swcCLI} ${
+    // TODO(jack): clean this up when we remove inline module support
+    // Handle root project
+    srcPath === '.' ? 'src' : srcPath} -d ${srcPath === '.' ? `${destPath}/src` : destPath} --config-file=${swcrcPath}`;
+    return watch ? swcCmd.concat(' --watch') : swcCmd;
+}
+function getTypeCheckOptions(normalizedOptions) {
+    const { projectRoot, watch, tsConfig, root, outputPath } = normalizedOptions;
+    const typeCheckOptions = {
+        mode: 'emitDeclarationOnly',
+        tsConfigPath: tsConfig,
+        outDir: outputPath,
+        workspaceRoot: root,
+        rootDir: projectRoot,
+    };
+    if (watch) {
+        typeCheckOptions.incremental = true;
+        typeCheckOptions.cacheDir = devkit_1.cacheDir;
+    }
+    return typeCheckOptions;
+}
+async function compileSwc(context, normalizedOptions, postCompilationCallback) {
+    devkit_1.logger.log(`Compiling with SWC for ${context.projectName}...`);
+    if (normalizedOptions.clean) {
+        (0, fs_extra_1.removeSync)(normalizedOptions.outputPath);
+    }
+    const swcCmdLog = (0, child_process_1.execSync)(getSwcCmd(normalizedOptions.swcCliOptions), {
+        encoding: 'utf8',
+        cwd: normalizedOptions.swcCliOptions.swcCwd,
+    });
+    devkit_1.logger.log(swcCmdLog.replace(/\n/, ''));
+    const isCompileSuccess = swcCmdLog.includes('Successfully compiled');
+    if (normalizedOptions.skipTypeCheck) {
+        await postCompilationCallback();
+        return { success: isCompileSuccess };
+    }
+    const { errors, warnings } = await (0, run_type_check_1.runTypeCheck)(getTypeCheckOptions(normalizedOptions));
+    const hasErrors = errors.length > 0;
+    const hasWarnings = warnings.length > 0;
+    if (hasErrors || hasWarnings) {
+        await (0, print_diagnostics_1.printDiagnostics)(errors, warnings);
+    }
+    await postCompilationCallback();
+    return {
+        success: !hasErrors && isCompileSuccess,
+        outfile: normalizedOptions.mainOutputPath,
+    };
+}
+exports.compileSwc = compileSwc;
+async function* compileSwcWatch(context, normalizedOptions, postCompilationCallback) {
+    const getResult = (success) => ({
+        success,
+        outfile: normalizedOptions.mainOutputPath,
+    });
+    let typeCheckOptions;
+    let initialPostCompile = true;
+    if (normalizedOptions.clean) {
+        (0, fs_extra_1.removeSync)(normalizedOptions.outputPath);
+    }
+    return yield* (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
+        let processOnExit;
+        let stdoutOnData;
+        let stderrOnData;
+        let watcherOnExit;
+        const swcWatcher = (0, child_process_1.exec)(getSwcCmd(normalizedOptions.swcCliOptions, true), { cwd: normalizedOptions.swcCliOptions.swcCwd });
+        processOnExit = () => {
+            swcWatcher.kill();
+            done();
+            process.off('SIGINT', processOnExit);
+            process.off('SIGTERM', processOnExit);
+            process.off('exit', processOnExit);
+        };
+        stdoutOnData = async (data) => {
+            process.stdout.write(data);
+            if (!data.startsWith('Watching')) {
+                const swcStatus = data.includes('Successfully');
+                if (initialPostCompile) {
+                    await postCompilationCallback();
+                    initialPostCompile = false;
+                }
+                if (normalizedOptions.skipTypeCheck) {
+                    next(getResult(swcStatus));
+                    return;
+                }
+                if (!typeCheckOptions) {
+                    typeCheckOptions = getTypeCheckOptions(normalizedOptions);
+                }
+                const delayed = delay(5000);
+                next(getResult(await Promise.race([
+                    delayed
+                        .start()
+                        .then(() => ({ tscStatus: false, type: 'timeout' })),
+                    (0, run_type_check_1.runTypeCheck)(typeCheckOptions).then(({ errors, warnings }) => {
+                        const hasErrors = errors.length > 0;
+                        if (hasErrors) {
+                            (0, print_diagnostics_1.printDiagnostics)(errors, warnings);
+                        }
+                        return {
+                            tscStatus: !hasErrors,
+                            type: 'tsc',
+                        };
+                    }),
+                ]).then(({ type, tscStatus }) => {
+                    if (type === 'tsc') {
+                        delayed.cancel();
+                        return tscStatus && swcStatus;
+                    }
+                    return swcStatus;
+                })));
+            }
+        };
+        stderrOnData = (err) => {
+            process.stderr.write(err);
+            if (err.includes('Debugger attached.')) {
+                return;
+            }
+            next(getResult(false));
+        };
+        watcherOnExit = () => {
+            done();
+            swcWatcher.off('exit', watcherOnExit);
+        };
+        swcWatcher.stdout.on('data', stdoutOnData);
+        swcWatcher.stderr.on('data', stderrOnData);
+        process.on('SIGINT', processOnExit);
+        process.on('SIGTERM', processOnExit);
+        process.on('exit', processOnExit);
+        swcWatcher.on('exit', watcherOnExit);
+    });
+}
+exports.compileSwcWatch = compileSwcWatch;
+function delay(ms) {
+    let timerId = undefined;
+    return {
+        start() {
+            return new Promise((resolve) => {
+                timerId = setTimeout(() => {
+                    resolve();
+                }, ms);
+            });
+        },
+        cancel() {
+            if (timerId) {
+                clearTimeout(timerId);
+                timerId = undefined;
+            }
+        },
+    };
+}

package/src/utils/swc/get-swcrc-path.d.ts

@@ -0,0 +1,5 @@
+import { SwcExecutorOptions } from '../schema';
+export declare function getSwcrcPath(options: SwcExecutorOptions, contextRoot: string, projectRoot: string): {
+    swcrcPath: string;
+    tmpSwcrcPath: string;
+};

package/src/utils/swc/get-swcrc-path.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSwcrcPath = void 0;
+const path_1 = require("path");
+function getSwcrcPath(options, contextRoot, projectRoot) {
+    const swcrcPath = options.swcrc
+        ? (0, path_1.join)(contextRoot, options.swcrc)
+        : (0, path_1.join)(contextRoot, projectRoot, '.swcrc');
+    const tmpSwcrcPath = (0, path_1.join)(contextRoot, projectRoot, 'tmp', '.generated.swcrc');
+    return {
+        swcrcPath,
+        tmpSwcrcPath,
+    };
+}
+exports.getSwcrcPath = getSwcrcPath;

package/src/utils/swc/inline.d.ts

@@ -0,0 +1,2 @@
+import type { InlineProjectGraph } from '../inline';
+export declare function generateTmpSwcrc(inlineProjectGraph: InlineProjectGraph, swcrcPath: string, tmpSwcrcPath: string): string;

package/src/utils/swc/inline.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTmpSwcrc = void 0;
+const devkit_1 = require("@nx/devkit");
+function generateTmpSwcrc(inlineProjectGraph, swcrcPath, tmpSwcrcPath) {
+    const swcrc = (0, devkit_1.readJsonFile)(swcrcPath);
+    swcrc['exclude'] = swcrc['exclude'].concat(Object.values(inlineProjectGraph.externals).map((external) => `${external.root}/**/.*.ts$`), 'node_modules/**/*.ts$');
+    (0, devkit_1.writeJsonFile)(tmpSwcrcPath, swcrc);
+    return tmpSwcrcPath;
+}
+exports.generateTmpSwcrc = generateTmpSwcrc;

package/src/utils/typescript/__mocks__/plugin-a.d.ts

@@ -0,0 +1 @@
+export declare const before: () => void;

package/src/utils/typescript/__mocks__/plugin-a.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.before = void 0;
+const before = () => { };
+exports.before = before;

package/src/utils/typescript/__mocks__/plugin-b.d.ts

@@ -0,0 +1 @@
+export declare const after: () => void;

package/src/utils/typescript/__mocks__/plugin-b.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.after = void 0;
+const after = () => { };
+exports.after = after;

package/src/utils/typescript/add-tslib-dependencies.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function addTsLibDependencies(tree: Tree): import("@nx/devkit").GeneratorCallback;

package/src/utils/typescript/add-tslib-dependencies.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTsLibDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../versions");
+function addTsLibDependencies(tree) {
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {
+        tslib: versions_1.tsLibVersion,
+    }, {});
+}
+exports.addTsLibDependencies = addTsLibDependencies;

package/src/utils/typescript/ast-utils.d.ts

@@ -0,0 +1,32 @@
+import type { Tree } from '@nx/devkit';
+import type * as ts from 'typescript';
+import { Node, SyntaxKind } from 'typescript';
+/**
+ * Find a module based on its import
+ *
+ * @param importExpr Import used to resolve to a module
+ * @param filePath
+ * @param tsConfigPath
+ */
+export declare function resolveModuleByImport(importExpr: string, filePath: string, tsConfigPath: string): string;
+export declare function insertChange(host: Tree, sourceFile: ts.SourceFile, filePath: string, insertPosition: number, contentToInsert: string): ts.SourceFile;
+export declare function replaceChange(host: Tree, sourceFile: ts.SourceFile, filePath: string, insertPosition: number, contentToInsert: string, oldContent: string): ts.SourceFile;
+export declare function removeChange(host: Tree, sourceFile: ts.SourceFile, filePath: string, removePosition: number, contentToRemove: string): ts.SourceFile;
+export declare function insertImport(host: Tree, source: ts.SourceFile, fileToEdit: string, symbolName: string, fileName: string, isDefault?: boolean): ts.SourceFile;
+export declare function addGlobal(host: Tree, source: ts.SourceFile, modulePath: string, statement: string): ts.SourceFile;
+export declare function getImport(source: ts.SourceFile, predicate: (a: any) => boolean): {
+    moduleSpec: string;
+    bindings: string[];
+}[];
+export declare function replaceNodeValue(host: Tree, sourceFile: ts.SourceFile, modulePath: string, node: ts.Node, content: string): ts.SourceFile;
+export declare function addParameterToConstructor(tree: Tree, source: ts.SourceFile, modulePath: string, opts: {
+    className: string;
+    param: string;
+}): ts.SourceFile;
+export declare function addMethod(tree: Tree, source: ts.SourceFile, modulePath: string, opts: {
+    className: string;
+    methodHeader: string;
+    body?: string;
+}): ts.SourceFile;
+export declare function findClass(source: ts.SourceFile, className: string, silent?: boolean): ts.ClassDeclaration;
+export declare function findNodes(node: Node, kind: SyntaxKind | SyntaxKind[], max?: number): Node[];

package/src/utils/typescript/ast-utils.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNodes = exports.findClass = exports.addMethod = exports.addParameterToConstructor = exports.replaceNodeValue = exports.getImport = exports.addGlobal = exports.insertImport = exports.removeChange = exports.replaceChange = exports.insertChange = exports.resolveModuleByImport = void 0;
+const ensure_typescript_1 = require("./ensure-typescript");
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const get_source_nodes_1 = require("./get-source-nodes");
+const normalizedAppRoot = devkit_1.workspaceRoot.replace(/\\/g, '/');
+let tsModule;
+let compilerHost;
+/**
+ * Find a module based on its import
+ *
+ * @param importExpr Import used to resolve to a module
+ * @param filePath
+ * @param tsConfigPath
+ */
+function resolveModuleByImport(importExpr, filePath, tsConfigPath) {
+    compilerHost = compilerHost || getCompilerHost(tsConfigPath);
+    const { options, host, moduleResolutionCache } = compilerHost;
+    const { resolvedModule } = tsModule.resolveModuleName(importExpr, filePath, options, host, moduleResolutionCache);
+    if (!resolvedModule) {
+        return;
+    }
+    else {
+        return resolvedModule.resolvedFileName.replace(`${normalizedAppRoot}/`, '');
+    }
+}
+exports.resolveModuleByImport = resolveModuleByImport;
+function getCompilerHost(tsConfigPath) {
+    const options = readTsConfigOptions(tsConfigPath);
+    const host = tsModule.createCompilerHost(options, true);
+    const moduleResolutionCache = tsModule.createModuleResolutionCache(devkit_1.workspaceRoot, host.getCanonicalFileName);
+    return { options, host, moduleResolutionCache };
+}
+function readTsConfigOptions(tsConfigPath) {
+    if (!tsModule) {
+        tsModule = require('typescript');
+    }
+    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
+    // we don't need to scan the files, we only care about options
+    const host = {
+        readDirectory: () => [],
+        readFile: () => '',
+        fileExists: tsModule.sys.fileExists,
+    };
+    return tsModule.parseJsonConfigFileContent(readResult.config, host, (0, path_1.dirname)(tsConfigPath)).options;
+}
+function nodesByPosition(first, second) {
+    return first.getStart() - second.getStart();
+}
+function updateTsSourceFile(host, sourceFile, filePath) {
+    const newFileContents = host.read(filePath).toString('utf-8');
+    return sourceFile.update(newFileContents, {
+        newLength: newFileContents.length,
+        span: {
+            length: sourceFile.text.length,
+            start: 0,
+        },
+    });
+}
+function insertChange(host, sourceFile, filePath, insertPosition, contentToInsert) {
+    const content = host.read(filePath).toString();
+    const prefix = content.substring(0, insertPosition);
+    const suffix = content.substring(insertPosition);
+    host.write(filePath, `${prefix}${contentToInsert}${suffix}`);
+    return updateTsSourceFile(host, sourceFile, filePath);
+}
+exports.insertChange = insertChange;
+function replaceChange(host, sourceFile, filePath, insertPosition, contentToInsert, oldContent) {
+    const content = host.read(filePath, 'utf-8');
+    const prefix = content.substring(0, insertPosition);
+    const suffix = content.substring(insertPosition + oldContent.length);
+    const text = content.substring(insertPosition, insertPosition + oldContent.length);
+    if (text !== oldContent) {
+        throw new Error(`Invalid replace: "${text}" != "${oldContent}".`);
+    }
+    host.write(filePath, `${prefix}${contentToInsert}${suffix}`);
+    return updateTsSourceFile(host, sourceFile, filePath);
+}
+exports.replaceChange = replaceChange;
+function removeChange(host, sourceFile, filePath, removePosition, contentToRemove) {
+    const content = host.read(filePath).toString();
+    const prefix = content.substring(0, removePosition);
+    const suffix = content.substring(removePosition + contentToRemove.length);
+    host.write(filePath, `${prefix}${suffix}`);
+    return updateTsSourceFile(host, sourceFile, filePath);
+}
+exports.removeChange = removeChange;
+function insertImport(host, source, fileToEdit, symbolName, fileName, isDefault = false) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const rootNode = source;
+    const allImports = findNodes(rootNode, tsModule.SyntaxKind.ImportDeclaration);
+    // get nodes that map to import statements from the file fileName
+    const relevantImports = allImports.filter((node) => {
+        // StringLiteral of the ImportDeclaration is the import file (fileName in this case).
+        const importFiles = node
+            .getChildren()
+            .filter((child) => child.kind === tsModule.SyntaxKind.StringLiteral)
+            .map((n) => n.text);
+        return importFiles.filter((file) => file === fileName).length === 1;
+    });
+    if (relevantImports.length > 0) {
+        let importsAsterisk = false;
+        // imports from import file
+        const imports = [];
+        relevantImports.forEach((n) => {
+            Array.prototype.push.apply(imports, findNodes(n, tsModule.SyntaxKind.Identifier));
+            if (findNodes(n, tsModule.SyntaxKind.AsteriskToken).length > 0) {
+                importsAsterisk = true;
+            }
+        });
+        // if imports * from fileName, don't add symbolName
+        if (importsAsterisk) {
+            return source;
+        }
+        const importTextNodes = imports.filter((n) => n.text === symbolName);
+        // insert import if it's not there
+        if (importTextNodes.length === 0) {
+            const fallbackPos = findNodes(relevantImports[0], tsModule.SyntaxKind.CloseBraceToken)[0].getStart() ||
+                findNodes(relevantImports[0], tsModule.SyntaxKind.FromKeyword)[0].getStart();
+            return insertAfterLastOccurrence(host, source, imports, `, ${symbolName}`, fileToEdit, fallbackPos);
+        }
+        return source;
+    }
+    // no such import declaration exists
+    const useStrict = findNodes(rootNode, tsModule.SyntaxKind.StringLiteral).filter((n) => n.text === 'use strict');
+    let fallbackPos = 0;
+    if (useStrict.length > 0) {
+        fallbackPos = useStrict[0].end;
+    }
+    const open = isDefault ? '' : '{ ';
+    const close = isDefault ? '' : ' }';
+    // if there are no imports or 'use strict' statement, insert import at beginning of file
+    const insertAtBeginning = allImports.length === 0 && useStrict.length === 0;
+    const separator = insertAtBeginning ? '' : ';\n';
+    const toInsert = `${separator}import ${open}${symbolName}${close}` +
+        ` from '${fileName}'${insertAtBeginning ? ';\n' : ''}`;
+    return insertAfterLastOccurrence(host, source, allImports, toInsert, fileToEdit, fallbackPos, tsModule.SyntaxKind.StringLiteral);
+}
+exports.insertImport = insertImport;
+function insertAfterLastOccurrence(host, sourceFile, nodes, toInsert, pathToFile, fallbackPos, syntaxKind) {
+    // sort() has a side effect, so make a copy so that we won't overwrite the parent's object.
+    let lastItem = [...nodes].sort(nodesByPosition).pop();
+    if (!lastItem) {
+        throw new Error();
+    }
+    if (syntaxKind) {
+        lastItem = findNodes(lastItem, syntaxKind).sort(nodesByPosition).pop();
+    }
+    if (!lastItem && fallbackPos == undefined) {
+        throw new Error(`tried to insert ${toInsert} as first occurrence with no fallback position`);
+    }
+    const lastItemPosition = lastItem ? lastItem.getEnd() : fallbackPos;
+    return insertChange(host, sourceFile, pathToFile, lastItemPosition, toInsert);
+}
+function addGlobal(host, source, modulePath, statement) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const allImports = findNodes(source, tsModule.SyntaxKind.ImportDeclaration);
+    if (allImports.length > 0) {
+        const lastImport = allImports[allImports.length - 1];
+        return insertChange(host, source, modulePath, lastImport.end + 1, `\n${statement}\n`);
+    }
+    else {
+        return insertChange(host, source, modulePath, 0, `${statement}\n`);
+    }
+}
+exports.addGlobal = addGlobal;
+function getImport(source, predicate) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const allImports = findNodes(source, tsModule.SyntaxKind.ImportDeclaration);
+    const matching = allImports.filter((i) => predicate(i.moduleSpecifier.getText()));
+    return matching.map((i) => {
+        const moduleSpec = i.moduleSpecifier
+            .getText()
+            .substring(1, i.moduleSpecifier.getText().length - 1);
+        const t = i.importClause.namedBindings.getText();
+        const bindings = t
+            .replace('{', '')
+            .replace('}', '')
+            .split(',')
+            .map((q) => q.trim());
+        return { moduleSpec, bindings };
+    });
+}
+exports.getImport = getImport;
+function replaceNodeValue(host, sourceFile, modulePath, node, content) {
+    return replaceChange(host, sourceFile, modulePath, node.getStart(node.getSourceFile()), content, node.getText());
+}
+exports.replaceNodeValue = replaceNodeValue;
+function addParameterToConstructor(tree, source, modulePath, opts) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const clazz = findClass(source, opts.className);
+    const constructor = clazz.members.filter((m) => m.kind === tsModule.SyntaxKind.Constructor)[0];
+    if (constructor) {
+        throw new Error('Should be tested'); // TODO: check this
+    }
+    return addMethod(tree, source, modulePath, {
+        className: opts.className,
+        methodHeader: `constructor(${opts.param})`,
+    });
+}
+exports.addParameterToConstructor = addParameterToConstructor;
+function addMethod(tree, source, modulePath, opts) {
+    const clazz = findClass(source, opts.className);
+    const body = opts.body
+        ? `
+${opts.methodHeader} {
+${opts.body}
+}
+`
+        : `
+${opts.methodHeader} {}
+`;
+    return insertChange(tree, source, modulePath, clazz.end - 1, body);
+}
+exports.addMethod = addMethod;
+function findClass(source, className, silent = false) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const nodes = (0, get_source_nodes_1.getSourceNodes)(source);
+    const clazz = nodes.filter((n) => n.kind === tsModule.SyntaxKind.ClassDeclaration &&
+        n.name.text === className)[0];
+    if (!clazz && !silent) {
+        throw new Error(`Cannot find class '${className}'.`);
+    }
+    return clazz;
+}
+exports.findClass = findClass;
+function findNodes(node, kind, max = Infinity) {
+    if (!node || max == 0) {
+        return [];
+    }
+    const arr = [];
+    const hasMatch = Array.isArray(kind)
+        ? kind.includes(node.kind)
+        : node.kind === kind;
+    if (hasMatch) {
+        arr.push(node);
+        max--;
+    }
+    if (max > 0) {
+        for (const child of node.getChildren()) {
+            findNodes(child, kind, max).forEach((node) => {
+                if (max > 0) {
+                    arr.push(node);
+                }
+                max--;
+            });
+            if (max <= 0) {
+                break;
+            }
+        }
+    }
+    return arr;
+}
+exports.findNodes = findNodes;

package/src/utils/typescript/compile-typescript-files.d.ts

@@ -0,0 +1,10 @@
+import { TypeScriptCompilationOptions } from '@nx/workspace/src/utilities/typescript/compilation';
+import { NormalizedExecutorOptions } from '../schema';
+export interface TypescriptCompilationResult {
+    success: boolean;
+    outfile: string;
+}
+export declare function compileTypeScriptFiles(normalizedOptions: NormalizedExecutorOptions, tscOptions: TypeScriptCompilationOptions, postCompilationCallback: () => void | Promise<void>): {
+    iterator: AsyncIterable<TypescriptCompilationResult>;
+    close: () => void | Promise<void>;
+};

package/src/utils/typescript/compile-typescript-files.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTypeScriptFiles = void 0;
+const compilation_1 = require("@nx/workspace/src/utilities/typescript/compilation");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const TYPESCRIPT_FOUND_N_ERRORS_WATCHING_FOR_FILE_CHANGES = 6194;
+// Typescript diagnostic message for 6194: Found {0} errors. Watching for file changes.
+// https://github.com/microsoft/TypeScript/blob/d45012c5e2ab122919ee4777a7887307c5f4a1e0/src/compiler/diagnosticMessages.json#L4763-L4766
+const ERROR_COUNT_REGEX = /Found (\d+) errors/;
+function getErrorCountFromMessage(messageText) {
+    return Number.parseInt(ERROR_COUNT_REGEX.exec(messageText)[1]);
+}
+function compileTypeScriptFiles(normalizedOptions, tscOptions, postCompilationCallback) {
+    const getResult = (success) => ({
+        success,
+        outfile: normalizedOptions.mainOutputPath,
+    });
+    let tearDown;
+    return {
+        iterator: (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
+            if (normalizedOptions.watch) {
+                const host = (0, compilation_1.compileTypeScriptWatcher)(tscOptions, async (d) => {
+                    if (d.code === TYPESCRIPT_FOUND_N_ERRORS_WATCHING_FOR_FILE_CHANGES) {
+                        await postCompilationCallback();
+                        next(getResult(getErrorCountFromMessage(d.messageText) === 0));
+                    }
+                });
+                tearDown = () => {
+                    host.close();
+                    done();
+                };
+            }
+            else {
+                const { success } = (0, compilation_1.compileTypeScript)(tscOptions);
+                await postCompilationCallback();
+                next(getResult(success));
+                done();
+            }
+        }),
+        close: () => tearDown?.(),
+    };
+}
+exports.compileTypeScriptFiles = compileTypeScriptFiles;