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

package/src/utils/typescript/create-ts-config.d.ts

@@ -0,0 +1,18 @@
+import { Tree } from 'nx/src/generators/tree';
+export declare const tsConfigBaseOptions: {
+    rootDir: string;
+    sourceMap: boolean;
+    declaration: boolean;
+    moduleResolution: string;
+    emitDecoratorMetadata: boolean;
+    experimentalDecorators: boolean;
+    importHelpers: boolean;
+    target: string;
+    module: string;
+    lib: string[];
+    skipLibCheck: boolean;
+    skipDefaultLibCheck: boolean;
+    baseUrl: string;
+    paths: {};
+};
+export declare function extractTsConfigBase(host: Tree): void;

package/src/utils/typescript/create-ts-config.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTsConfigBase = exports.tsConfigBaseOptions = void 0;
+const json_1 = require("nx/src/generators/utils/json");
+exports.tsConfigBaseOptions = {
+    rootDir: '.',
+    sourceMap: true,
+    declaration: false,
+    moduleResolution: 'node',
+    emitDecoratorMetadata: true,
+    experimentalDecorators: true,
+    importHelpers: true,
+    target: 'es2015',
+    module: 'esnext',
+    lib: ['es2020', 'dom'],
+    skipLibCheck: true,
+    skipDefaultLibCheck: true,
+    baseUrl: '.',
+    paths: {},
+};
+function extractTsConfigBase(host) {
+    if (host.exists('tsconfig.base.json'))
+        return;
+    const tsconfig = (0, json_1.readJson)(host, 'tsconfig.json');
+    const baseCompilerOptions = {};
+    for (let compilerOption of Object.keys(exports.tsConfigBaseOptions)) {
+        baseCompilerOptions[compilerOption] =
+            tsconfig.compilerOptions[compilerOption];
+        delete tsconfig.compilerOptions[compilerOption];
+    }
+    (0, json_1.writeJson)(host, 'tsconfig.base.json', {
+        compileOnSave: false,
+        compilerOptions: baseCompilerOptions,
+        exclude: tsconfig.exclude,
+    });
+    tsconfig.extends = './tsconfig.base.json';
+    delete tsconfig.compileOnSave;
+    delete tsconfig.exclude;
+    (0, json_1.writeJson)(host, 'tsconfig.json', tsconfig);
+    // special case for updating e2e tests.
+    if (host.exists('e2e/tsconfig.json')) {
+        (0, json_1.updateJson)(host, 'e2e/tsconfig.json', (json) => {
+            json.extends = '../tsconfig.base.json';
+            return json;
+        });
+    }
+}
+exports.extractTsConfigBase = extractTsConfigBase;

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

@@ -0,0 +1 @@
+export declare function ensureTypescript(): typeof import("typescript");

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureTypescript = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../versions");
+function ensureTypescript() {
+    return (0, devkit_1.ensurePackage)('typescript', versions_1.typescriptVersion);
+}
+exports.ensureTypescript = ensureTypescript;

package/src/utils/typescript/get-source-nodes.d.ts

@@ -0,0 +1,2 @@
+import type * as ts from 'typescript';
+export declare function getSourceNodes(sourceFile: ts.SourceFile): ts.Node[];

package/src/utils/typescript/get-source-nodes.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceNodes = void 0;
+function getSourceNodes(sourceFile) {
+    const nodes = [sourceFile];
+    const result = [];
+    while (nodes.length > 0) {
+        const node = nodes.shift();
+        if (node) {
+            result.push(node);
+            if (node.getChildCount(sourceFile) >= 0) {
+                nodes.unshift(...node.getChildren());
+            }
+        }
+    }
+    return result;
+}
+exports.getSourceNodes = getSourceNodes;

package/src/utils/typescript/load-ts-transformers.d.ts

@@ -0,0 +1,5 @@
+import { CompilerPluginHooks, TransformerEntry } from './types';
+export declare function loadTsTransformers(plugins: TransformerEntry[], moduleResolver?: typeof require.resolve): {
+    compilerPluginHooks: CompilerPluginHooks;
+    hasPlugin: boolean;
+};

package/src/utils/typescript/load-ts-transformers.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTsTransformers = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+function loadTsTransformers(plugins, moduleResolver = require.resolve) {
+    const beforeHooks = [];
+    const afterHooks = [];
+    const afterDeclarationsHooks = [];
+    if (!plugins || !plugins.length)
+        return {
+            compilerPluginHooks: {
+                beforeHooks,
+                afterHooks,
+                afterDeclarationsHooks,
+            },
+            hasPlugin: false,
+        };
+    const normalizedPlugins = plugins.map((plugin) => typeof plugin === 'string' ? { name: plugin, options: {} } : plugin);
+    const nodeModulePaths = [
+        (0, path_1.join)(process.cwd(), 'node_modules'),
+        ...module.paths,
+    ];
+    const pluginRefs = normalizedPlugins.map(({ name }) => {
+        try {
+            const binaryPath = moduleResolver(name, {
+                paths: nodeModulePaths,
+            });
+            return require(binaryPath);
+        }
+        catch (e) {
+            devkit_1.logger.warn(`"${name}" plugin could not be found!`);
+            return {};
+        }
+    });
+    for (let i = 0; i < pluginRefs.length; i++) {
+        const { name: pluginName, options: pluginOptions } = normalizedPlugins[i];
+        const { before, after, afterDeclarations } = pluginRefs[i];
+        if (!before && !after && !afterDeclarations) {
+            devkit_1.logger.warn(`${pluginName} is not a Transformer Plugin. It does not provide neither before(), after(), nor afterDeclarations()`);
+            continue;
+        }
+        if (before) {
+            beforeHooks.push(before.bind(before, pluginOptions));
+        }
+        if (after) {
+            afterHooks.push(after.bind(after, pluginOptions));
+        }
+        if (afterDeclarations) {
+            afterDeclarationsHooks.push(afterDeclarations.bind(afterDeclarations, pluginOptions));
+        }
+    }
+    return {
+        compilerPluginHooks: {
+            beforeHooks,
+            afterHooks,
+            afterDeclarationsHooks,
+        },
+        hasPlugin: true,
+    };
+}
+exports.loadTsTransformers = loadTsTransformers;

package/src/utils/typescript/print-diagnostics.d.ts

@@ -0,0 +1 @@
+export declare function printDiagnostics(errors?: string[], warnings?: string[]): Promise<void>;

package/src/utils/typescript/print-diagnostics.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printDiagnostics = void 0;
+async function printDiagnostics(errors = [], warnings = []) {
+    if (errors.length > 0) {
+        errors.forEach((err) => {
+            console.log(`${err}\n`);
+        });
+        console.log(`Found ${errors.length} error${errors.length > 1 ? 's' : ''}.`);
+    }
+    else if (warnings.length > 0) {
+        warnings.forEach((err) => {
+            console.log(`${err}\n`);
+        });
+        console.log(`Found ${warnings.length} warnings.`);
+    }
+}
+exports.printDiagnostics = printDiagnostics;

package/src/utils/typescript/run-type-check.d.ts

@@ -0,0 +1,32 @@
+import type { Diagnostic } from 'typescript';
+export interface TypeCheckResult {
+    warnings?: string[];
+    errors?: string[];
+    inputFilesCount: number;
+    totalFilesCount: number;
+    incremental: boolean;
+}
+export type TypeCheckOptions = BaseTypeCheckOptions & Mode;
+interface BaseTypeCheckOptions {
+    workspaceRoot: string;
+    tsConfigPath: string;
+    cacheDir?: string;
+    incremental?: boolean;
+    rootDir?: string;
+}
+type Mode = NoEmitMode | EmitDeclarationOnlyMode;
+interface NoEmitMode {
+    mode: 'noEmit';
+}
+interface EmitDeclarationOnlyMode {
+    mode: 'emitDeclarationOnly';
+    outDir: string;
+}
+export declare function runTypeCheckWatch(options: TypeCheckOptions, callback: (diagnostic: Diagnostic, formattedDiagnostic: string, errorCount?: number) => void | Promise<void>): Promise<{
+    close: any;
+    preEmitErrors: string[];
+    preEmitWarnings: string[];
+}>;
+export declare function runTypeCheck(options: TypeCheckOptions): Promise<TypeCheckResult>;
+export declare function getFormattedDiagnostic(ts: typeof import('typescript'), workspaceRoot: string, diagnostic: Diagnostic): string;
+export {};

package/src/utils/typescript/run-type-check.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFormattedDiagnostic = exports.runTypeCheck = exports.runTypeCheckWatch = void 0;
+const chalk = require("chalk");
+const path = require("path");
+const code_frames_1 = require("nx/src/utils/code-frames");
+const highlight_1 = require("../code-frames/highlight");
+const ts_config_1 = require("../../utils/typescript/ts-config");
+async function runTypeCheckWatch(options, callback) {
+    const { ts, workspaceRoot, config, compilerOptions } = await setupTypeScript(options);
+    const host = ts.createWatchCompilerHost(config.fileNames, compilerOptions, ts.sys, ts.createEmitAndSemanticDiagnosticsBuilderProgram);
+    const originalOnWatchStatusChange = host.onWatchStatusChange;
+    host.onWatchStatusChange = (diagnostic, newLine, opts, errorCount) => {
+        originalOnWatchStatusChange?.(diagnostic, newLine, opts, errorCount);
+        callback(diagnostic, getFormattedDiagnostic(ts, workspaceRoot, diagnostic), errorCount);
+    };
+    const watchProgram = ts.createWatchProgram(host);
+    const program = watchProgram.getProgram().getProgram();
+    const diagnostics = ts.getPreEmitDiagnostics(program);
+    return {
+        close: watchProgram.close.bind(watchProgram),
+        preEmitErrors: diagnostics
+            .filter((d) => d.category === ts.DiagnosticCategory.Error)
+            .map((d) => getFormattedDiagnostic(ts, workspaceRoot, d)),
+        preEmitWarnings: diagnostics
+            .filter((d) => d.category === ts.DiagnosticCategory.Warning)
+            .map((d) => getFormattedDiagnostic(ts, workspaceRoot, d)),
+    };
+}
+exports.runTypeCheckWatch = runTypeCheckWatch;
+async function runTypeCheck(options) {
+    const { ts, workspaceRoot, cacheDir, config, compilerOptions } = await setupTypeScript(options);
+    let program;
+    let incremental = false;
+    if (compilerOptions.incremental && cacheDir) {
+        incremental = true;
+        program = ts.createIncrementalProgram({
+            rootNames: config.fileNames,
+            options: {
+                ...compilerOptions,
+                incremental: true,
+                tsBuildInfoFile: path.join(cacheDir, '.tsbuildinfo'),
+            },
+        });
+    }
+    else {
+        program = ts.createProgram(config.fileNames, compilerOptions);
+    }
+    const result = program.emit();
+    const allDiagnostics = ts
+        .getPreEmitDiagnostics(program)
+        .concat(result.diagnostics);
+    return getTypeCheckResult(ts, allDiagnostics, workspaceRoot, config.fileNames.length, program.getSourceFiles().length, incremental);
+}
+exports.runTypeCheck = runTypeCheck;
+async function setupTypeScript(options) {
+    const ts = await Promise.resolve().then(() => require('typescript'));
+    const { workspaceRoot, tsConfigPath, cacheDir, incremental, rootDir } = options;
+    const config = (0, ts_config_1.readTsConfig)(tsConfigPath);
+    if (config.errors.length) {
+        const errorMessages = config.errors.map((e) => e.messageText).join('\n');
+        throw new Error(`Invalid config file due to following: ${errorMessages}`);
+    }
+    const emitOptions = options.mode === 'emitDeclarationOnly'
+        ? { emitDeclarationOnly: true, declaration: true, outDir: options.outDir }
+        : { noEmit: true };
+    const compilerOptions = {
+        ...config.options,
+        skipLibCheck: true,
+        ...emitOptions,
+        incremental,
+        rootDir: rootDir || config.options.rootDir,
+    };
+    return { ts, workspaceRoot, cacheDir, config, compilerOptions };
+}
+function getTypeCheckResult(ts, allDiagnostics, workspaceRoot, inputFilesCount, totalFilesCount, incremental = false) {
+    const errors = allDiagnostics
+        .filter((d) => d.category === ts.DiagnosticCategory.Error)
+        .map((d) => getFormattedDiagnostic(ts, workspaceRoot, d));
+    const warnings = allDiagnostics
+        .filter((d) => d.category === ts.DiagnosticCategory.Warning)
+        .map((d) => getFormattedDiagnostic(ts, workspaceRoot, d));
+    return {
+        warnings,
+        errors,
+        inputFilesCount,
+        totalFilesCount,
+        incremental,
+    };
+}
+function getFormattedDiagnostic(ts, workspaceRoot, diagnostic) {
+    let message = '';
+    const reason = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    const category = diagnostic.category;
+    switch (category) {
+        case ts.DiagnosticCategory.Warning: {
+            message += `${chalk.yellow.bold('warning')} ${chalk.gray(`TS${diagnostic.code}`)}: `;
+            break;
+        }
+        case ts.DiagnosticCategory.Error: {
+            message += `${chalk.red.bold('error')} ${chalk.gray(`TS${diagnostic.code}`)}: `;
+            break;
+        }
+        case ts.DiagnosticCategory.Suggestion:
+        case ts.DiagnosticCategory.Message:
+        default: {
+            message += `${chalk.cyan.bold(category === 2 ? 'suggestion' : 'info')}: `;
+            break;
+        }
+    }
+    message += reason + '\n';
+    if (diagnostic.file) {
+        const pos = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+        const line = pos.line + 1;
+        const column = pos.character + 1;
+        const fileName = path.relative(workspaceRoot, diagnostic.file.fileName);
+        message =
+            `${chalk.underline.blue(`${fileName}:${line}:${column}`)} - ` + message;
+        const code = diagnostic.file.getFullText(diagnostic.file.getSourceFile());
+        message +=
+            '\n' +
+                (0, code_frames_1.codeFrameColumns)(code, {
+                    start: { line: line, column },
+                }, { highlight: highlight_1.highlight });
+    }
+    return message;
+}
+exports.getFormattedDiagnostic = getFormattedDiagnostic;

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

@@ -0,0 +1,9 @@
+import { Tree } from '@nx/devkit';
+import * as ts from 'typescript';
+export declare function readTsConfig(tsConfigPath: string): ts.ParsedCommandLine;
+export declare function getRootTsConfigPathInTree(tree: Tree): string | null;
+export declare function getRelativePathToRootTsConfig(tree: Tree, targetPath: string): string;
+export declare function getRootTsConfigPath(): string | null;
+export declare function getRootTsConfigFileName(tree?: Tree): string | null;
+export declare function addTsConfigPath(tree: Tree, importPath: string, lookupPaths: string[]): void;
+export declare function readTsConfigPaths(tsConfig?: string | ts.ParsedCommandLine): ts.MapLike<string[]>;

package/src/utils/typescript/ts-config.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTsConfigPaths = exports.addTsConfigPath = exports.getRootTsConfigFileName = exports.getRootTsConfigPath = exports.getRelativePathToRootTsConfig = exports.getRootTsConfigPathInTree = exports.readTsConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ensure_typescript_1 = require("./ensure-typescript");
+let tsModule;
+function readTsConfig(tsConfigPath) {
+    if (!tsModule) {
+        tsModule = require('typescript');
+    }
+    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
+    return tsModule.parseJsonConfigFileContent(readResult.config, tsModule.sys, (0, path_1.dirname)(tsConfigPath));
+}
+exports.readTsConfig = readTsConfig;
+function getRootTsConfigPathInTree(tree) {
+    for (const path of ['tsconfig.base.json', 'tsconfig.json']) {
+        if (tree.exists(path)) {
+            return path;
+        }
+    }
+    return 'tsconfig.base.json';
+}
+exports.getRootTsConfigPathInTree = getRootTsConfigPathInTree;
+function getRelativePathToRootTsConfig(tree, targetPath) {
+    return (0, devkit_1.offsetFromRoot)(targetPath) + getRootTsConfigPathInTree(tree);
+}
+exports.getRelativePathToRootTsConfig = getRelativePathToRootTsConfig;
+function getRootTsConfigPath() {
+    const tsConfigFileName = getRootTsConfigFileName();
+    return tsConfigFileName ? (0, path_1.join)(devkit_1.workspaceRoot, tsConfigFileName) : null;
+}
+exports.getRootTsConfigPath = getRootTsConfigPath;
+function getRootTsConfigFileName(tree) {
+    for (const tsConfigName of ['tsconfig.base.json', 'tsconfig.json']) {
+        const pathExists = tree
+            ? tree.exists(tsConfigName)
+            : (0, fs_1.existsSync)((0, path_1.join)(devkit_1.workspaceRoot, tsConfigName));
+        if (pathExists) {
+            return tsConfigName;
+        }
+    }
+    return null;
+}
+exports.getRootTsConfigFileName = getRootTsConfigFileName;
+function addTsConfigPath(tree, importPath, lookupPaths) {
+    (0, devkit_1.updateJson)(tree, getRootTsConfigPathInTree(tree), (json) => {
+        json.compilerOptions ??= {};
+        const c = json.compilerOptions;
+        c.paths ??= {};
+        if (c.paths[importPath]) {
+            throw new Error(`You already have a library using the import path "${importPath}". Make sure to specify a unique one.`);
+        }
+        c.paths[importPath] = lookupPaths;
+        return json;
+    });
+}
+exports.addTsConfigPath = addTsConfigPath;
+function readTsConfigPaths(tsConfig) {
+    tsConfig ??= getRootTsConfigPath();
+    try {
+        if (!tsModule) {
+            tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        }
+        let config;
+        if (typeof tsConfig === 'string') {
+            const configFile = tsModule.readConfigFile(tsConfig, tsModule.sys.readFile);
+            config = tsModule.parseJsonConfigFileContent(configFile.config, tsModule.sys, (0, path_1.dirname)(tsConfig));
+        }
+        else {
+            config = tsConfig;
+        }
+        if (config.options?.paths) {
+            return config.options.paths;
+        }
+        else {
+            return null;
+        }
+    }
+    catch (e) {
+        return null;
+    }
+}
+exports.readTsConfigPaths = readTsConfigPaths;

package/src/utils/typescript/tsnode-register.d.ts

@@ -0,0 +1 @@
+export declare function tsNodeRegister(file: string, tsConfig?: string): void;

package/src/utils/typescript/tsnode-register.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsNodeRegister = void 0;
+function tsNodeRegister(file, tsConfig) {
+    if (!file?.endsWith('.ts'))
+        return;
+    // Register TS compiler lazily
+    require('ts-node').register({
+        project: tsConfig,
+        compilerOptions: {
+            module: 'CommonJS',
+            types: ['node'],
+        },
+    });
+    if (!tsConfig)
+        return;
+    // Register paths in tsConfig
+    const tsconfigPaths = require('tsconfig-paths');
+    const { absoluteBaseUrl: baseUrl, paths } = tsconfigPaths.loadConfig(tsConfig);
+    if (baseUrl && paths) {
+        tsconfigPaths.register({ baseUrl, paths });
+    }
+}
+exports.tsNodeRegister = tsNodeRegister;

package/src/utils/typescript/types.d.ts

@@ -0,0 +1,18 @@
+import type { CustomTransformerFactory, Node, Program, TransformerFactory as TypescriptTransformerFactory } from 'typescript';
+type TransformerFactory = TypescriptTransformerFactory<Node> | CustomTransformerFactory;
+export interface TransformerPlugin {
+    name: string;
+    options: Record<string, unknown>;
+}
+export type TransformerEntry = string | TransformerPlugin;
+export interface CompilerPlugin {
+    before?: (options?: Record<string, unknown>, program?: Program) => TransformerFactory;
+    after?: (options?: Record<string, unknown>, program?: Program) => TransformerFactory;
+    afterDeclarations?: (options?: Record<string, unknown>, program?: Program) => TransformerFactory;
+}
+export interface CompilerPluginHooks {
+    beforeHooks: Array<(program?: Program) => TransformerFactory>;
+    afterHooks: Array<(program?: Program) => TransformerFactory>;
+    afterDeclarationsHooks: Array<(program?: Program) => TransformerFactory>;
+}
+export {};

package/src/utils/typescript/types.js

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

package/src/utils/versions.d.ts

@@ -0,0 +1,17 @@
+export declare const nxVersion: any;
+export declare const esbuildVersion = "^0.19.2";
+export declare const prettierVersion = "^2.6.2";
+export declare const swcCliVersion = "~0.1.62";
+export declare const swcCoreVersion = "~1.3.85";
+export declare const swcHelpersVersion = "~0.5.2";
+export declare const swcNodeVersion = "~1.8.0";
+export declare const tsLibVersion = "^2.3.0";
+export declare const typesNodeVersion = "18.16.9";
+export declare const verdaccioVersion = "^5.0.4";
+export declare const typescriptVersion = "~5.3.2";
+/**
+ * The minimum version is currently determined from the lowest version
+ * that's supported by the lowest Angular supported version, e.g.
+ * `npm view @angular/compiler-cli@14.0.0 peerDependencies.typescript`
+ */
+export declare const supportedTypescriptVersions = ">=4.8.2";

package/src/utils/versions.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedTypescriptVersions = exports.typescriptVersion = exports.verdaccioVersion = exports.typesNodeVersion = exports.tsLibVersion = exports.swcNodeVersion = exports.swcHelpersVersion = exports.swcCoreVersion = exports.swcCliVersion = exports.prettierVersion = exports.esbuildVersion = exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;
+exports.esbuildVersion = '^0.19.2';
+exports.prettierVersion = '^2.6.2';
+exports.swcCliVersion = '~0.1.62';
+exports.swcCoreVersion = '~1.3.85';
+exports.swcHelpersVersion = '~0.5.2';
+exports.swcNodeVersion = '~1.8.0';
+exports.tsLibVersion = '^2.3.0';
+exports.typesNodeVersion = '18.16.9';
+exports.verdaccioVersion = '^5.0.4';
+// Typescript
+exports.typescriptVersion = '~5.3.2';
+/**
+ * The minimum version is currently determined from the lowest version
+ * that's supported by the lowest Angular supported version, e.g.
+ * `npm view @angular/compiler-cli@14.0.0 peerDependencies.typescript`
+ */
+exports.supportedTypescriptVersions = '>=4.8.2';

package/src/utils/watch-for-single-file-changes.d.ts

@@ -0,0 +1 @@
+export declare function watchForSingleFileChanges(projectName: string, projectRoot: string, relativeFilePath: string, callback: () => void): Promise<() => void>;

package/src/utils/watch-for-single-file-changes.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchForSingleFileChanges = void 0;
+const devkit_1 = require("@nx/devkit");
+const client_1 = require("nx/src/daemon/client/client");
+const path_1 = require("path");
+async function watchForSingleFileChanges(projectName, projectRoot, relativeFilePath, callback) {
+    const unregisterFileWatcher = await client_1.daemonClient.registerFileWatcher({ watchProjects: [projectName] }, (err, data) => {
+        if (err === 'closed') {
+            devkit_1.logger.error(`Watch error: Daemon closed the connection`);
+            process.exit(1);
+        }
+        else if (err) {
+            devkit_1.logger.error(`Watch error: ${err?.message ?? 'Unknown'}`);
+        }
+        else if (data.changedFiles.some((file) => file.path == (0, path_1.join)(projectRoot, relativeFilePath))) {
+            callback();
+        }
+    });
+    return () => unregisterFileWatcher();
+}
+exports.watchForSingleFileChanges = watchForSingleFileChanges;