@nx/js 23.0.0-beta.2 → 23.0.0-beta.21

package/{src → dist/src}/utils/get-import-path.d.ts

@@ -3,4 +3,3 @@ import { Tree } from '@nx/devkit';
  * Prefixes project name with npm scope
  */
 export declare function getImportPath(tree: Tree, projectDirectory: string): string;
-//# sourceMappingURL=get-import-path.d.ts.map

package/{src → dist/src}/utils/get-main-file-dir.d.ts

@@ -1,2 +1 @@
 export declare function getRelativeDirectoryToProjectRoot(file: string, projectRoot: string): string;
-//# sourceMappingURL=get-main-file-dir.d.ts.map

package/{src → dist/src}/utils/is-locally-linked-package-version.d.ts

@@ -1,2 +1 @@
 export declare function isLocallyLinkedPackageVersion(version: string): boolean;
-//# sourceMappingURL=is-locally-linked-package-version.d.ts.map

package/{src → dist/src}/utils/is-valid-variable.d.ts

@@ -7,4 +7,3 @@ export declare function isValidVariable(name: string): {
     isValid: boolean;
     message: string;
 };
-//# sourceMappingURL=is-valid-variable.d.ts.map

package/dist/src/utils/module-format/is-esm-project.d.ts

@@ -0,0 +1,16 @@
+import { type Tree } from '@nx/devkit';
+/**
+ * Determine whether a project should be treated as ESM for the purpose of
+ * emitting `.ts` config and source files (e.g. choosing between
+ * `__filename`/`__dirname` and `import.meta.dirname`, or `require()` and
+ * `import` for sibling subpath imports).
+ *
+ * Mirrors Node's package.json `type` resolution: the **closest**
+ * package.json with a recognized `type` field wins.
+ *
+ * Resolution order:
+ * 1. The project's package.json `type`, if present and recognized.
+ * 2. The workspace-root package.json `type`, if present and recognized.
+ * 3. Default: `false` (CJS).
+ */
+export declare function isEsmProject(tree: Tree, projectRoot: string): boolean;

package/dist/src/utils/module-format/is-esm-project.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEsmProject = isEsmProject;
+const devkit_1 = require("@nx/devkit");
+const module_format_1 = require("./module-format");
+/**
+ * Determine whether a project should be treated as ESM for the purpose of
+ * emitting `.ts` config and source files (e.g. choosing between
+ * `__filename`/`__dirname` and `import.meta.dirname`, or `require()` and
+ * `import` for sibling subpath imports).
+ *
+ * Mirrors Node's package.json `type` resolution: the **closest**
+ * package.json with a recognized `type` field wins.
+ *
+ * Resolution order:
+ * 1. The project's package.json `type`, if present and recognized.
+ * 2. The workspace-root package.json `type`, if present and recognized.
+ * 3. Default: `false` (CJS).
+ */
+function isEsmProject(tree, projectRoot) {
+    const projectPackageJsonPath = (0, devkit_1.joinPathFragments)(projectRoot, 'package.json');
+    if (tree.exists(projectPackageJsonPath)) {
+        const projectFmt = (0, module_format_1.getPackageJsonModuleFormat)((0, devkit_1.readJson)(tree, projectPackageJsonPath));
+        // Only honor an explicit type field; fall through to workspace when
+        // unset so we match Node's "walk up to nearest type field" behavior.
+        if (projectFmt !== null) {
+            return projectFmt === 'esm';
+        }
+    }
+    const workspaceFmt = (0, module_format_1.getPackageJsonModuleFormat)((0, devkit_1.readJson)(tree, 'package.json'));
+    return workspaceFmt === 'esm';
+}

package/dist/src/utils/module-format/module-format.d.ts

@@ -0,0 +1,17 @@
+import type * as ts from 'typescript';
+export type ModuleFormat = 'cjs' | 'esm';
+/**
+ * Decide module format from a parsed package.json `type` field alone.
+ * Returns `null` when the field is unset or holds an unrecognized value -
+ * callers can then fall back to other signals (tsconfig, defaults).
+ */
+export declare function getPackageJsonModuleFormat(packageJson: {
+    type?: string;
+} | null | undefined): ModuleFormat | null;
+/**
+ * Decide module format from tsconfig compiler options' `module` setting.
+ * Returns `null` when the setting is unset OR when it is `NodeNext` /
+ * `Node16` (those defer to the package.json `type` field, so the caller
+ * should have already checked package.json).
+ */
+export declare function getTsConfigModuleFormat(compilerOptions: ts.CompilerOptions | null | undefined): ModuleFormat | null;

package/dist/src/utils/module-format/module-format.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageJsonModuleFormat = getPackageJsonModuleFormat;
+exports.getTsConfigModuleFormat = getTsConfigModuleFormat;
+/**
+ * Decide module format from a parsed package.json `type` field alone.
+ * Returns `null` when the field is unset or holds an unrecognized value -
+ * callers can then fall back to other signals (tsconfig, defaults).
+ */
+function getPackageJsonModuleFormat(packageJson) {
+    if (!packageJson)
+        return null;
+    if (packageJson.type === 'module')
+        return 'esm';
+    if (packageJson.type === 'commonjs')
+        return 'cjs';
+    return null;
+}
+/**
+ * Decide module format from tsconfig compiler options' `module` setting.
+ * Returns `null` when the setting is unset OR when it is `NodeNext` /
+ * `Node16` (those defer to the package.json `type` field, so the caller
+ * should have already checked package.json).
+ */
+function getTsConfigModuleFormat(compilerOptions) {
+    const m = compilerOptions?.module;
+    if (m === undefined)
+        return null;
+    // Lazy-require typescript so importing this module (e.g. via
+    // @nx/js/internal -> is-esm-project) doesn't fail in workspaces that
+    // haven't installed typescript yet (fresh CNW projects before a
+    // generator adds it).
+    const tsMod = require('typescript');
+    if (m === tsMod.ModuleKind.NodeNext || m === tsMod.ModuleKind.Node16)
+        return null;
+    if (m === tsMod.ModuleKind.ES2015 ||
+        m === tsMod.ModuleKind.ES2020 ||
+        m === tsMod.ModuleKind.ES2022 ||
+        m === tsMod.ModuleKind.ESNext) {
+        return 'esm';
+    }
+    return 'cjs';
+}

package/{src → dist/src}/utils/npm-config.d.ts

@@ -23,4 +23,3 @@ export declare function getNpmRegistry(cwd: string, scope?: string): Promise<str
  * @param cwd the directory where the npm config should be read from
  */
 export declare function getNpmTag(cwd: string): Promise<string>;
-//# sourceMappingURL=npm-config.d.ts.map

package/{src → dist/src}/utils/package-json/create-entry-points.d.ts

@@ -1,2 +1 @@
 export declare function createEntryPoints(additionalEntryPoints: undefined | string[], root: string): string[];
-//# sourceMappingURL=create-entry-points.d.ts.map

package/{src → dist/src}/utils/package-json/get-npm-scope.d.ts

@@ -3,4 +3,3 @@ import { Tree } from '@nx/devkit';
  * Read the npm scope that a workspace should use by default
  */
 export declare function getNpmScope(tree: Tree): string | undefined;
-//# sourceMappingURL=get-npm-scope.d.ts.map

package/{src → dist/src}/utils/package-json/index.d.ts

@@ -11,4 +11,3 @@ export interface CopyPackageJsonResult {
     stop?: () => void;
 }
 export declare function copyPackageJson(_options: CopyPackageJsonOptions, context: ExecutorContext): Promise<CopyPackageJsonResult>;
-//# sourceMappingURL=index.d.ts.map

package/{src → dist/src}/utils/package-json/sort-fields.d.ts

@@ -1,3 +1,2 @@
 import { type Tree } from '@nx/devkit';
 export declare function sortPackageJsonFields(tree: Tree, projectRoot: string): void;
-//# sourceMappingURL=sort-fields.d.ts.map

package/{src → dist/src}/utils/package-json/update-package-json.d.ts

@@ -32,4 +32,3 @@ export declare function getExports(options: Pick<UpdatePackageJsonOption, 'main'
 export declare function getUpdatedPackageJsonContent(packageJson: PackageJson, options: UpdatePackageJsonOption): PackageJson;
 export declare function getOutputDir(options: Pick<UpdatePackageJsonOption, 'main' | 'rootDir' | 'projectRoot' | 'outputFileName' | 'outputPath' | 'packageJsonPath'>): string;
 export {};
-//# sourceMappingURL=update-package-json.d.ts.map

package/{src → dist/src}/utils/package-manager-workspaces.d.ts

@@ -5,4 +5,3 @@ export declare function getPackageManagerWorkspacesPatterns(tree: Tree): string[
 export declare function isUsingPackageManagerWorkspaces(tree: Tree): boolean;
 export declare function isWorkspacesEnabled(tree: Tree): boolean;
 export declare function getProjectPackageManagerWorkspaceStateWarningTask(projectPackageManagerWorkspaceState: ProjectPackageManagerWorkspaceState, workspaceRoot: string): GeneratorCallback;
-//# sourceMappingURL=package-manager-workspaces.d.ts.map

package/{src → dist/src}/utils/prettier.d.ts

@@ -9,4 +9,3 @@ export declare function generatePrettierSetup(tree: Tree, options: {
     skipPackageJson?: boolean;
 }): GeneratorCallback;
 export declare function resolvePrettierConfigPath(tree: Tree): Promise<string | null>;
-//# sourceMappingURL=prettier.d.ts.map

package/{src → dist/src}/utils/prettier.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveUserExistingPrettierConfig = resolveUserExistingPrettierConfig;
 exports.generatePrettierSetup = generatePrettierSetup;
@@ -41,7 +8,7 @@ const versions_1 = require("./versions");
 async function resolveUserExistingPrettierConfig() {
     let prettier;
     try {
-        prettier = await Promise.resolve().then(() => __importStar(require('prettier')));
+        prettier = await import('prettier');
     }
     catch {
         return null;
@@ -111,7 +78,7 @@ function generatePrettierSetup(tree, options) {
 async function resolvePrettierConfigPath(tree) {
     let prettier;
     try {
-        prettier = await Promise.resolve().then(() => __importStar(require('prettier')));
+        prettier = await import('prettier');
     }
     catch {
         return null;
@@ -152,7 +119,7 @@ async function resolvePrettierConfigPath(tree) {
     }
     // check the package.yaml file
     if (tree.exists('package.yaml')) {
-        const { load } = await Promise.resolve().then(() => __importStar(require('@zkochan/js-yaml')));
+        const { load } = await import('@zkochan/js-yaml');
         const packageYaml = load(tree.read('package.yaml', 'utf-8'));
         if (packageYaml.prettier) {
             return 'package.yaml';

package/{src → dist/src}/utils/strip-glob-to-base-dir.d.ts

@@ -1,2 +1 @@
 export declare function stripGlobToBaseDir(pathWithGlob: string): string;
-//# sourceMappingURL=strip-glob-to-base-dir.d.ts.map

package/{src → dist/src}/utils/swc/add-swc-config.d.ts

@@ -2,4 +2,3 @@ import { type Tree } from '@nx/devkit';
 export declare const defaultExclude: string[];
 export declare function addSwcConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6', supportTsx?: boolean, swcName?: string, additionalExcludes?: string[]): void;
 export declare function addSwcTestConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6', supportTsx?: boolean): void;
-//# sourceMappingURL=add-swc-config.d.ts.map

package/{src → dist/src}/utils/swc/add-swc-dependencies.d.ts

@@ -5,4 +5,3 @@ export declare function getSwcDependencies(): {
 };
 export declare function addSwcDependencies(tree: Tree): import("@nx/devkit").GeneratorCallback;
 export declare function addSwcRegisterDependencies(tree: Tree): import("@nx/devkit").GeneratorCallback;
-//# sourceMappingURL=add-swc-dependencies.d.ts.map

package/{src → dist/src}/utils/swc/add-swc-dependencies.js

@@ -17,8 +17,8 @@ function getSwcDependencies() {
 }
 function addSwcDependencies(tree) {
     const { dependencies, devDependencies } = getSwcDependencies();
-    return (0, devkit_1.addDependenciesToPackageJson)(tree, dependencies, devDependencies);
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, dependencies, devDependencies, undefined, true);
 }
 function addSwcRegisterDependencies(tree) {
-    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@swc-node/register': versions_1.swcNodeVersion, '@swc/core': versions_1.swcCoreVersion });
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@swc-node/register': versions_1.swcNodeVersion, '@swc/core': versions_1.swcCoreVersion }, undefined, true);
 }

package/{src → dist/src}/utils/swc/compile-swc.d.ts

@@ -11,4 +11,3 @@ export declare function compileSwcWatch(context: ExecutorContext, normalizedOpti
     success: boolean;
     outfile: string;
 }, any, any>;
-//# sourceMappingURL=compile-swc.d.ts.map

package/{src → dist/src}/utils/swc/compile-swc.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileSwc = compileSwc;
 exports.compileSwcWatch = compileSwcWatch;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-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");
 const path_1 = require("path");
@@ -101,7 +101,7 @@ async function* compileSwcWatch(context, normalizedOptions, postCompilationCallb
     if (normalizedOptions.clean) {
         (0, node_fs_1.rmSync)(normalizedOptions.outputPath, { recursive: true, force: true });
     }
-    return yield* (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
+    return yield* (0, internal_1.createAsyncIterable)(async ({ next, done }) => {
         let processOnExit;
         let handleCallback;
         let stdoutOnData;

package/{src → dist/src}/utils/swc/get-swcrc-path.d.ts

@@ -3,4 +3,3 @@ export declare function getSwcrcPath(options: SwcExecutorOptions, contextRoot: s
     swcrcPath: string;
     tmpSwcrcPath: string;
 };
-//# sourceMappingURL=get-swcrc-path.d.ts.map

package/{src → dist/src}/utils/typescript/__mocks__/function-after-declarations-plugin.d.ts

@@ -1,2 +1 @@
 export declare const afterDeclarations: (options: any, program: any) => () => void;
-//# sourceMappingURL=function-after-declarations-plugin.d.ts.map

package/{src → dist/src}/utils/typescript/__mocks__/function-after-plugin.d.ts

@@ -1,2 +1 @@
 export declare const after: (options: any, program: any) => () => void;
-//# sourceMappingURL=function-after-plugin.d.ts.map

package/{src → dist/src}/utils/typescript/__mocks__/function-direct-export.d.ts

@@ -1,3 +1,2 @@
 declare const _default: (options: any, program: any) => () => void;
 export default _default;
-//# sourceMappingURL=function-direct-export.d.ts.map

package/{src → dist/src}/utils/typescript/__mocks__/function-multiple-hooks.d.ts

@@ -1,4 +1,3 @@
 export declare const before: (options: any, program: any) => () => void;
 export declare const after: (options: any, program: any) => () => void;
 export declare const afterDeclarations: (options: any, program: any) => () => void;
-//# sourceMappingURL=function-multiple-hooks.d.ts.map

package/{src → dist/src}/utils/typescript/__mocks__/plugin-a.d.ts

@@ -1,2 +1 @@
 export declare const before: (options: any, program: any) => () => void;
-//# sourceMappingURL=plugin-a.d.ts.map

package/{src → dist/src}/utils/typescript/__mocks__/plugin-b.d.ts

@@ -1,2 +1 @@
 export declare const after: (options: any, program: any) => () => void;
-//# sourceMappingURL=plugin-b.d.ts.map

package/{src → dist/src}/utils/typescript/add-tslib-dependencies.d.ts

@@ -1,3 +1,2 @@
 import { Tree } from '@nx/devkit';
 export declare function addTsLibDependencies(tree: Tree): import("@nx/devkit").GeneratorCallback;
-//# sourceMappingURL=add-tslib-dependencies.d.ts.map

package/{src → dist/src}/utils/typescript/ast-utils.d.ts

@@ -30,4 +30,3 @@ export declare function addMethod(tree: Tree, source: ts.SourceFile, modulePath:
 }): 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[];
-//# sourceMappingURL=ast-utils.d.ts.map

package/dist/src/utils/typescript/compilation.d.ts

@@ -0,0 +1,22 @@
+import type * as ts from 'typescript';
+import type { CustomTransformers, Diagnostic, Program } from 'typescript';
+export interface TypeScriptCompilationOptions {
+    outputPath: string;
+    projectName: string;
+    projectRoot: string;
+    tsConfig: string;
+    deleteOutputPath?: boolean;
+    rootDir?: string;
+    watch?: boolean;
+    getCustomTransformers?(program: Program): CustomTransformers;
+}
+export interface TypescriptWatchChangeEvent {
+    diagnostic: ts.Diagnostic;
+    newLine: string;
+    options: ts.CompilerOptions;
+    errorCount: number;
+}
+export declare function compileTypeScript(options: TypeScriptCompilationOptions): {
+    success: boolean;
+};
+export declare function compileTypeScriptWatcher(options: TypeScriptCompilationOptions, callback: (diagnostic: Diagnostic, newLine: string, options: ts.CompilerOptions, errorCount: number) => void | Promise<void>): ts.WatchOfFilesAndCompilerOptions<ts.BuilderProgram>;

package/dist/src/utils/typescript/compilation.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTypeScript = compileTypeScript;
+exports.compileTypeScriptWatcher = compileTypeScriptWatcher;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const ts_config_1 = require("./ts-config");
+const ensure_typescript_1 = require("./ensure-typescript");
+let tsModule;
+function compileTypeScript(options) {
+    const normalizedOptions = normalizeOptions(options);
+    const tsConfig = getNormalizedTsConfig(normalizedOptions);
+    if (normalizedOptions.deleteOutputPath) {
+        (0, fs_1.rmSync)(normalizedOptions.outputPath, { recursive: true, force: true });
+    }
+    return createProgram(tsConfig, normalizedOptions);
+}
+function compileTypeScriptWatcher(options, callback) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const normalizedOptions = normalizeOptions(options);
+    const tsConfig = getNormalizedTsConfig(normalizedOptions);
+    if (normalizedOptions.deleteOutputPath) {
+        (0, fs_1.rmSync)(normalizedOptions.outputPath, { recursive: true, force: true });
+    }
+    const host = tsModule.createWatchCompilerHost(tsConfig.fileNames, tsConfig.options, tsModule.sys);
+    const originalAfterProgramCreate = host.afterProgramCreate;
+    host.afterProgramCreate = (builderProgram) => {
+        const originalProgramEmit = builderProgram.emit;
+        builderProgram.emit = (targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
+            const consumerCustomTransformers = options.getCustomTransformers?.(builderProgram.getProgram());
+            const mergedCustomTransformers = mergeCustomTransformers(customTransformers, consumerCustomTransformers);
+            return originalProgramEmit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, mergedCustomTransformers);
+        };
+        if (originalAfterProgramCreate)
+            originalAfterProgramCreate(builderProgram);
+    };
+    const originalOnWatchStatusChange = host.onWatchStatusChange;
+    host.onWatchStatusChange = async (a, b, c, d) => {
+        originalOnWatchStatusChange?.(a, b, c, d);
+        await callback?.(a, b, c, d);
+    };
+    return tsModule.createWatchProgram(host);
+}
+function mergeCustomTransformers(originalCustomTransformers, consumerCustomTransformers) {
+    if (!consumerCustomTransformers)
+        return originalCustomTransformers;
+    const mergedCustomTransformers = {};
+    if (consumerCustomTransformers.before) {
+        mergedCustomTransformers.before = originalCustomTransformers?.before
+            ? [
+                ...originalCustomTransformers.before,
+                ...consumerCustomTransformers.before,
+            ]
+            : consumerCustomTransformers.before;
+    }
+    if (consumerCustomTransformers.after) {
+        mergedCustomTransformers.after = originalCustomTransformers?.after
+            ? [
+                ...originalCustomTransformers.after,
+                ...consumerCustomTransformers.after,
+            ]
+            : consumerCustomTransformers.after;
+    }
+    if (consumerCustomTransformers.afterDeclarations) {
+        mergedCustomTransformers.afterDeclarations =
+            originalCustomTransformers?.afterDeclarations
+                ? [
+                    ...originalCustomTransformers.afterDeclarations,
+                    ...consumerCustomTransformers.afterDeclarations,
+                ]
+                : consumerCustomTransformers.afterDeclarations;
+    }
+    return mergedCustomTransformers;
+}
+function getNormalizedTsConfig(options) {
+    const tsConfig = (0, ts_config_1.readTsConfig)(options.tsConfig);
+    tsConfig.options.outDir = options.outputPath;
+    tsConfig.options.noEmitOnError = true;
+    tsConfig.options.rootDir = options.rootDir;
+    if (tsConfig.options.incremental && !tsConfig.options.tsBuildInfoFile) {
+        tsConfig.options.tsBuildInfoFile = (0, devkit_1.joinPathFragments)(options.outputPath, 'tsconfig.tsbuildinfo');
+    }
+    return tsConfig;
+}
+function createProgram(tsconfig, { projectName, getCustomTransformers }) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const host = tsModule.createCompilerHost(tsconfig.options);
+    const program = tsModule.createProgram({
+        rootNames: tsconfig.fileNames,
+        options: tsconfig.options,
+        host,
+    });
+    devkit_1.logger.info(`Compiling TypeScript files for project "${projectName}"...`);
+    const results = program.emit(undefined, undefined, undefined, undefined, getCustomTransformers?.(program));
+    if (results.emitSkipped) {
+        const diagnostics = tsModule.formatDiagnosticsWithColorAndContext(results.diagnostics, {
+            getCurrentDirectory: () => tsModule.sys.getCurrentDirectory(),
+            getNewLine: () => tsModule.sys.newLine,
+            getCanonicalFileName: (name) => name,
+        });
+        devkit_1.logger.error(diagnostics);
+        return { success: false };
+    }
+    else {
+        devkit_1.logger.info(`Done compiling TypeScript files for project "${projectName}".`);
+        return { success: true };
+    }
+}
+function normalizeOptions(options) {
+    return {
+        ...options,
+        deleteOutputPath: options.deleteOutputPath ?? true,
+        rootDir: options.rootDir ?? options.projectRoot,
+    };
+}

package/{src → dist/src}/utils/typescript/compile-typescript-files.d.ts

@@ -1,4 +1,4 @@
-import { TypeScriptCompilationOptions } from '@nx/workspace/src/utilities/typescript/compilation';
+import { TypeScriptCompilationOptions } from './compilation';
 import { NormalizedExecutorOptions } from '../schema';
 export interface TypescriptCompilationResult {
     success: boolean;
@@ -8,4 +8,3 @@ export declare function compileTypeScriptFiles(normalizedOptions: NormalizedExec
     iterator: AsyncIterable<TypescriptCompilationResult>;
     close: () => void | Promise<void>;
 };
-//# sourceMappingURL=compile-typescript-files.d.ts.map

package/{src → dist/src}/utils/typescript/compile-typescript-files.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileTypeScriptFiles = compileTypeScriptFiles;
-const compilation_1 = require("@nx/workspace/src/utilities/typescript/compilation");
-const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const internal_1 = require("@nx/devkit/internal");
+const compilation_1 = require("./compilation");
 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
@@ -17,7 +17,7 @@ function compileTypeScriptFiles(normalizedOptions, tscOptions, postCompilationCa
     });
     let tearDown;
     return {
-        iterator: (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
+        iterator: (0, internal_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) {

package/{src → dist/src}/utils/typescript/configuration.d.ts

@@ -5,4 +5,3 @@ import type { CompilerOptions } from 'typescript';
  * different or not set in the provided tsconfig file.
  */
 export declare function getNeededCompilerOptionOverrides(tree: Tree, compilerOptions: Record<keyof CompilerOptions, any>, tsConfigPath: string): Record<keyof CompilerOptions, any>;
-//# sourceMappingURL=configuration.d.ts.map

package/{src → dist/src}/utils/typescript/create-ts-config.d.ts

@@ -15,4 +15,3 @@ export declare const tsConfigBaseOptions: {
     paths: {};
 };
 export declare function extractTsConfigBase(host: Tree): void;
-//# sourceMappingURL=create-ts-config.d.ts.map

package/{src → dist/src}/utils/typescript/ensure-typescript.d.ts

@@ -1,2 +1 @@
 export declare function ensureTypescript(): typeof import("typescript");
-//# sourceMappingURL=ensure-typescript.d.ts.map

package/{src → dist/src}/utils/typescript/get-source-nodes.d.ts

@@ -1,3 +1,2 @@
 import type * as ts from 'typescript';
 export declare function getSourceNodes(sourceFile: ts.SourceFile): ts.Node[];
-//# sourceMappingURL=get-source-nodes.d.ts.map

package/{src → dist/src}/utils/typescript/load-ts-transformers.d.ts

@@ -3,4 +3,3 @@ export declare function loadTsTransformers(plugins: TransformerEntry[], moduleRe
     compilerPluginHooks: CompilerPluginHooks;
     hasPlugin: boolean;
 };
-//# sourceMappingURL=load-ts-transformers.d.ts.map

package/{src → dist/src}/utils/typescript/plugin.d.ts

@@ -1,3 +1,2 @@
 import type { NxJsonConfiguration } from '@nx/devkit';
 export declare function ensureProjectIsIncludedInPluginRegistrations(nxJson: NxJsonConfiguration, projectRoot: string, buildTargetName: string | null): void;
-//# sourceMappingURL=plugin.d.ts.map

package/{src → dist/src}/utils/typescript/print-diagnostics.d.ts

@@ -1,2 +1 @@
 export declare function printDiagnostics(errors?: string[], warnings?: string[]): Promise<void>;
-//# sourceMappingURL=print-diagnostics.d.ts.map

package/{src → dist/src}/utils/typescript/raw-tsconfig.d.ts

@@ -33,4 +33,3 @@ export type RawTsconfigJsonCache = Map<string, unknown | null>;
 export declare function walkTsconfigExtendsChain(entryAbsolutePath: string, visit: (absolutePath: string, rawJson: unknown) => 'continue' | 'stop', options?: {
     jsonCache?: RawTsconfigJsonCache;
 }): void;
-//# sourceMappingURL=raw-tsconfig.d.ts.map

package/{src → dist/src}/utils/typescript/run-type-check.d.ts

@@ -32,4 +32,3 @@ export declare function runTypeCheckWatch(options: TypeCheckOptions, callback: (
 export declare function runTypeCheck(options: TypeCheckOptions): Promise<TypeCheckResult>;
 export declare function getFormattedDiagnostic(ts: typeof import('typescript'), workspaceRoot: string, diagnostic: Diagnostic): string;
 export {};
-//# sourceMappingURL=run-type-check.d.ts.map

package/{src → dist/src}/utils/typescript/run-type-check.js

@@ -57,7 +57,7 @@ async function runTypeCheck(options) {
     return getTypeCheckResult(ts, allDiagnostics, workspaceRoot, config.fileNames.length, program.getSourceFiles().length, incremental);
 }
 async function setupTypeScript(options) {
-    const ts = await Promise.resolve().then(() => tslib_1.__importStar(require('typescript')));
+    const ts = await import('typescript');
     const { workspaceRoot, tsConfigPath, cacheDir, incremental, projectRoot } = options;
     const config = (0, ts_config_1.readTsConfig)(tsConfigPath);
     if (config.errors.length) {

package/{src → dist/src}/utils/typescript/ts-config.d.ts

@@ -22,4 +22,3 @@ export declare function addTsConfigPath(tree: Tree, importPath: string, lookupPa
  */
 export declare function resolvePathsBaseUrl(tsconfigPath: string): string;
 export declare function readTsConfigPaths(tsConfig?: string | ts.ParsedCommandLine): ts.MapLike<string[]>;
-//# sourceMappingURL=ts-config.d.ts.map

package/{src → dist/src}/utils/typescript/ts-solution-setup.d.ts

@@ -22,4 +22,3 @@ export declare function getCustomConditionName(tree: Tree, options?: {
  * Get the already defined custom condition name or null if none is defined.
  */
 export declare function getDefinedCustomConditionName(tree: Tree): string | null;
-//# sourceMappingURL=ts-solution-setup.d.ts.map

package/{src → dist/src}/utils/typescript/types.d.ts

@@ -27,4 +27,3 @@ export interface CompilerPluginHooks {
     afterDeclarationsHooks: Array<(program?: Program) => TransformerFactory>;
 }
 export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/src/utils/typescript/types.js

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

package/{src → dist/src}/utils/versions.d.ts

@@ -6,7 +6,7 @@ export declare const swcCoreVersion = "~1.15.5";
 export declare const swcHelpersVersion = "~0.5.18";
 export declare const swcNodeVersion = "~1.11.1";
 export declare const tsLibVersion = "^2.3.0";
-export declare const typesNodeVersion = "20.19.9";
+export declare const typesNodeVersion = "^22.0.0";
 export declare const verdaccioVersion = "^6.3.2";
 export declare const typescriptVersion = "~5.9.2";
 /**
@@ -14,5 +14,4 @@ export declare const typescriptVersion = "~5.9.2";
  * that's supported by the lowest Angular supported version, e.g.
  * `npm view @angular/compiler-cli@18.0.0 peerDependencies.typescript`
  */
-export declare const supportedTypescriptVersions = ">=5.4.0";
-//# sourceMappingURL=versions.d.ts.map
+export declare const minSupportedTypescriptVersion = "5.4.0";