@nx/js 19.6.0 → 19.7.0-beta.0

package/README.md

@@ -22,7 +22,7 @@
 
 # Nx: Smart Monorepos · Fast CI
 
-Nx is a build system with built-in tooling and advanced CI capabilities. It helps you maintain and scale monorepos, both locally and on CI.
+Nx is a build system, optimized for monorepos, with plugins for popular frameworks and tools and advanced CI capabilities including caching and distribution.
 
 This package is a [JavaScript/TypeScript plugin for Nx](https://nx.dev/js/overview).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "19.6.0",
+  "version": "19.7.0-beta.0",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -34,11 +34,13 @@
   "dependencies": {
     "@babel/core": "^7.23.2",
     "@babel/plugin-proposal-decorators": "^7.22.7",
-    "@babel/plugin-transform-runtime": "^7.23.2",
     "@babel/plugin-transform-class-properties": "^7.22.5",
+    "@babel/plugin-transform-runtime": "^7.23.2",
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
+    "@nx/devkit": "19.7.0-beta.0",
+    "@nx/workspace": "19.7.0-beta.0",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",
     "babel-plugin-transform-typescript-metadata": "^0.3.1",
@@ -47,20 +49,19 @@
     "detect-port": "^1.5.1",
     "fast-glob": "3.2.7",
     "fs-extra": "^11.1.0",
-    "npm-package-arg": "11.0.1",
-    "npm-run-path": "^4.0.1",
-    "ts-node": "10.9.1",
-    "tsconfig-paths": "^4.1.2",
     "ignore": "^5.0.4",
     "js-tokens": "^4.0.0",
+    "jsonc-parser": "3.2.0",
     "minimatch": "9.0.3",
+    "npm-package-arg": "11.0.1",
+    "npm-run-path": "^4.0.1",
     "ora": "5.3.0",
     "semver": "^7.5.3",
     "source-map-support": "0.5.19",
+    "ts-node": "10.9.1",
+    "tsconfig-paths": "^4.1.2",
     "tslib": "^2.3.0",
-    "@nx/devkit": "19.6.0",
-    "@nx/workspace": "19.6.0",
-    "@nrwl/js": "19.6.0"
+    "@nrwl/js": "19.7.0-beta.0"
   },
   "peerDependencies": {
     "verdaccio": "^5.0.4"

package/src/executors/node/node-with-require-overrides.d.ts

@@ -1,7 +1,4 @@
-declare const Module: any;
 declare const url: any;
-declare const originalLoader: any;
+declare const patchSigint: any;
+declare const patchRequire: any;
 declare const dynamicImport: Function;
-declare const mappings: any;
-declare const keys: string[];
-declare const fileToRun: any;

package/src/executors/node/node-with-require-overrides.js

@@ -1,21 +1,7 @@
-const Module = require('module');
 const url = require('node:url');
-const originalLoader = Module._load;
+const { patchSigint } = require('./patch-sigint');
+const { patchRequire } = require('./patch-require');
+patchSigint();
+patchRequire();
 const dynamicImport = new Function('specifier', 'return import(specifier)');
-const mappings = JSON.parse(process.env.NX_MAPPINGS);
-const keys = Object.keys(mappings);
-const fileToRun = url.pathToFileURL(process.env.NX_FILE_TO_RUN);
-Module._load = function (request, parent) {
-    if (!parent)
-        return originalLoader.apply(this, arguments);
-    const match = keys.find((k) => request === k);
-    if (match) {
-        const newArguments = [...arguments];
-        newArguments[0] = mappings[match];
-        return originalLoader.apply(this, newArguments);
-    }
-    else {
-        return originalLoader.apply(this, arguments);
-    }
-};
-dynamicImport(fileToRun);
+dynamicImport(url.pathToFileURL(process.env.NX_FILE_TO_RUN));

package/src/executors/node/node.impl.js

@@ -111,11 +111,14 @@ async function* nodeExecutor(options, context) {
                         task.childProcess.stderr.on('data', handleStdErr);
                         task.childProcess.once('exit', (code) => {
                             task.childProcess.off('data', handleStdErr);
-                            if (options.watch && !task.killed) {
+                            if (options.watch &&
+                                !task.killed &&
+                                // SIGINT should exist the process rather than watch for changes.
+                                code !== 130) {
                                 devkit_1.logger.info(`NX Process exited with code ${code}, waiting for changes to restart...`);
                             }
-                            if (!options.watch) {
-                                if (code !== 0) {
+                            if (!options.watch || code === 130) {
+                                if (code !== 0 && code !== 130) {
                                     error(new Error(`Process exited with code ${code}`));
                                 }
                                 else {

package/src/executors/node/patch-require.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Overrides require calls to map buildable workspace libs to their output location.
+ * This is useful for running programs compiled via TSC/SWC that aren't bundled.
+ */
+export declare function patchRequire(): void;

package/src/executors/node/patch-require.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchRequire = patchRequire;
+const Module = require('node:module');
+const originalLoader = Module._load;
+/**
+ * Overrides require calls to map buildable workspace libs to their output location.
+ * This is useful for running programs compiled via TSC/SWC that aren't bundled.
+ */
+function patchRequire() {
+    const mappings = JSON.parse(process.env.NX_MAPPINGS);
+    const keys = Object.keys(mappings);
+    Module._load = function (request, parent) {
+        if (!parent)
+            return originalLoader.apply(this, arguments);
+        const match = keys.find((k) => request === k);
+        if (match) {
+            const newArguments = [...arguments];
+            newArguments[0] = mappings[match];
+            return originalLoader.apply(this, newArguments);
+        }
+        else {
+            return originalLoader.apply(this, arguments);
+        }
+    };
+}

package/src/executors/node/patch-sigint.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Patches the current process so that Ctrl+C is properly handled.
+ * Without this patch, SIGINT or Ctrl+C does not wait for graceful shutdown and exits immediately.
+ */
+export declare function patchSigint(): void;

package/src/executors/node/patch-sigint.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchSigint = patchSigint;
+const readline = require('node:readline');
+/**
+ * Patches the current process so that Ctrl+C is properly handled.
+ * Without this patch, SIGINT or Ctrl+C does not wait for graceful shutdown and exits immediately.
+ */
+function patchSigint() {
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(true);
+    process.stdin.on('keypress', async (chunk, key) => {
+        if (key && key.ctrl && key.name === 'c') {
+            process.stdin.setRawMode(false); // To ensure nx terminal is not stuck in raw mode
+            const listeners = process.listeners('SIGINT');
+            for (const listener of listeners) {
+                await listener('SIGINT');
+            }
+            process.exit(130);
+        }
+    });
+    console.log('To exit the process, press Ctrl+C');
+}

package/src/executors/tsc/tsc.impl.js

@@ -29,11 +29,11 @@ function determineModuleFormatFromTsConfig(absolutePathToTsConfig) {
 }
 function createTypeScriptCompilationOptions(normalizedOptions, context) {
     return {
-        outputPath: normalizedOptions.outputPath,
+        outputPath: (0, devkit_1.joinPathFragments)(normalizedOptions.outputPath),
         projectName: context.projectName,
         projectRoot: normalizedOptions.projectRoot,
-        rootDir: normalizedOptions.rootDir,
-        tsConfig: normalizedOptions.tsConfig,
+        rootDir: (0, devkit_1.joinPathFragments)(normalizedOptions.rootDir),
+        tsConfig: (0, devkit_1.joinPathFragments)(normalizedOptions.tsConfig),
         watch: normalizedOptions.watch,
         deleteOutputPath: normalizedOptions.clean,
         getCustomTransformers: (0, lib_1.getCustomTrasformersFactory)(normalizedOptions.transformers),

package/src/generators/library/library.js

@@ -159,7 +159,7 @@ async function addProject(tree, options) {
             }
         }
         if (options.publishable) {
-            const packageRoot = (0, path_1.join)(defaultOutputDirectory, '{projectRoot}');
+            const packageRoot = (0, devkit_1.joinPathFragments)(defaultOutputDirectory, '{projectRoot}');
             projectConfiguration.targets ??= {};
             projectConfiguration.targets['nx-release-publish'] = {
                 options: {

package/src/generators/release-version/release-version.js

@@ -76,7 +76,7 @@ Valid values are: ${version_1.validReleaseVersionPrefixes
             if (!packageRoot) {
                 throw new Error(`The project "${projectName}" does not have a packageRoot available. Please report this issue on https://github.com/nrwl/nx`);
             }
-            const packageJsonPath = (0, node_path_1.join)(packageRoot, 'package.json');
+            const packageJsonPath = (0, devkit_1.joinPathFragments)(packageRoot, 'package.json');
             if (!tree.exists(packageJsonPath)) {
                 throw new Error(`The project "${projectName}" does not have a package.json available at ${packageJsonPath}.
 
@@ -544,7 +544,7 @@ To fix this you will either need to add a package.json file at that location, or
                 if (!dependencyPackageRoot) {
                     throw new Error(`The project "${dependencyProjectName}" does not have a packageRoot available. Please report this issue on https://github.com/nrwl/nx`);
                 }
-                const dependencyPackageJsonPath = (0, node_path_1.join)(dependencyPackageRoot, 'package.json');
+                const dependencyPackageJsonPath = (0, devkit_1.joinPathFragments)(dependencyPackageRoot, 'package.json');
                 const dependencyPackageJson = (0, devkit_1.readJson)(tree, dependencyPackageJsonPath);
                 updateDependentProjectAndAddToVersionData({
                     dependentProject: transitiveDependentProject,

package/src/generators/typescript-sync/typescript-sync.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.syncGenerator = syncGenerator;
 const devkit_1 = require("@nx/devkit");
+const jsonc_parser_1 = require("jsonc-parser");
 const posix_1 = require("node:path/posix");
+const ts = require("typescript");
 const plugin_1 = require("../../plugins/typescript/plugin");
 const COMMON_RUNTIME_TS_CONFIG_FILE_NAMES = [
     'tsconfig.app.json',
@@ -27,16 +29,25 @@ async function syncGenerator(tree) {
     // Root tsconfig containing project references for the whole workspace
     const rootTsconfigPath = 'tsconfig.json';
     if (!tree.exists(rootTsconfigPath)) {
-        throw new Error(`A "tsconfig.json" file must exist in the workspace root.`);
+        throw new Error(`A "tsconfig.json" file must exist in the workspace root in order to use this sync generator.`);
     }
-    const rootTsconfig = (0, devkit_1.readJson)(tree, rootTsconfigPath);
+    const rawTsconfigContentsCache = new Map();
+    const stringifiedRootJsonContents = readRawTsconfigContents(tree, rawTsconfigContentsCache, rootTsconfigPath);
+    const rootTsconfig = (0, devkit_1.parseJson)(stringifiedRootJsonContents);
     const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
     const projectRoots = new Set();
+    const tsconfigHasCompositeEnabledCache = new Map();
     const tsconfigProjectNodeValues = Object.values(projectGraph.nodes).filter((node) => {
         projectRoots.add(node.data.root);
         const projectTsconfigPath = (0, devkit_1.joinPathFragments)(node.data.root, 'tsconfig.json');
-        return tree.exists(projectTsconfigPath);
+        return tsconfigExists(tree, rawTsconfigContentsCache, projectTsconfigPath);
     });
+    const tsSysFromTree = {
+        ...ts.sys,
+        readFile(path) {
+            return readRawTsconfigContents(tree, rawTsconfigContentsCache, path);
+        },
+    };
     // Track if any changes were made to the tsconfig files. We check the changes
     // made by this generator to know if the TS config is out of sync with the
     // project graph. Therefore, we don't format the files if there were no changes
@@ -47,7 +58,7 @@ async function syncGenerator(tree) {
         for (const ref of rootTsconfig.references ?? []) {
             // reference path is relative to the tsconfig file
             const resolvedRefPath = getTsConfigPathFromReferencePath(tree, rootTsconfigPath, ref.path);
-            if (tree.exists(resolvedRefPath)) {
+            if (tsconfigExists(tree, rawTsconfigContentsCache, resolvedRefPath)) {
                 // we only keep the references that still exist
                 referencesSet.add(normalizeReferencePath(ref.path));
             }
@@ -64,10 +75,13 @@ async function syncGenerator(tree) {
             }
         }
         if (hasChanges) {
-            rootTsconfig.references = Array.from(referencesSet).map((ref) => ({
+            const updatedReferences = Array.from(referencesSet)
+                // Check composite is true in the internal reference before proceeding
+                .filter((ref) => hasCompositeEnabled(tsSysFromTree, tsconfigHasCompositeEnabledCache, (0, devkit_1.joinPathFragments)(ref, 'tsconfig.json')))
+                .map((ref) => ({
                 path: `./${ref}`,
             }));
-            (0, devkit_1.writeJson)(tree, rootTsconfigPath, rootTsconfig);
+            patchTsconfigJsonReferences(tree, rawTsconfigContentsCache, rootTsconfigPath, updatedReferences);
         }
     }
     const runtimeTsConfigFileNames = nxJson.sync?.generatorOptions?.['@nx/js:typescript-sync']
@@ -84,7 +98,7 @@ async function syncGenerator(tree) {
         const sourceProjectNode = projectGraph.nodes[name];
         // Find the relevant tsconfig file for the source project
         const sourceProjectTsconfigPath = (0, devkit_1.joinPathFragments)(sourceProjectNode.data.root, 'tsconfig.json');
-        if (!tree.exists(sourceProjectTsconfigPath)) {
+        if (!tsconfigExists(tree, rawTsconfigContentsCache, sourceProjectTsconfigPath)) {
             if (process.env.NX_VERBOSE_LOGGING === 'true') {
                 devkit_1.logger.warn(`Skipping project "${name}" as there is no tsconfig.json file found in the project root "${sourceProjectNode.data.root}".`);
             }
@@ -97,16 +111,16 @@ async function syncGenerator(tree) {
         }
         for (const runtimeTsConfigFileName of runtimeTsConfigFileNames) {
             const runtimeTsConfigPath = (0, devkit_1.joinPathFragments)(sourceProjectNode.data.root, runtimeTsConfigFileName);
-            if (!tree.exists(runtimeTsConfigPath)) {
+            if (!tsconfigExists(tree, rawTsconfigContentsCache, runtimeTsConfigPath)) {
                 continue;
             }
             // Update project references for the runtime tsconfig
             hasChanges =
-                updateTsConfigReferences(tree, runtimeTsConfigPath, dependencies, sourceProjectNode.data.root, projectRoots, runtimeTsConfigFileName, runtimeTsConfigFileNames) || hasChanges;
+                updateTsConfigReferences(tree, tsSysFromTree, rawTsconfigContentsCache, tsconfigHasCompositeEnabledCache, runtimeTsConfigPath, dependencies, sourceProjectNode.data.root, projectRoots, runtimeTsConfigFileName, runtimeTsConfigFileNames) || hasChanges;
         }
         // Update project references for the tsconfig.json file
         hasChanges =
-            updateTsConfigReferences(tree, sourceProjectTsconfigPath, dependencies, sourceProjectNode.data.root, projectRoots) || hasChanges;
+            updateTsConfigReferences(tree, tsSysFromTree, rawTsconfigContentsCache, tsconfigHasCompositeEnabledCache, sourceProjectTsconfigPath, dependencies, sourceProjectNode.data.root, projectRoots) || hasChanges;
     }
     if (hasChanges) {
         await (0, devkit_1.formatFiles)(tree);
@@ -116,8 +130,28 @@ async function syncGenerator(tree) {
     }
 }
 exports.default = syncGenerator;
-function updateTsConfigReferences(tree, tsConfigPath, dependencies, projectRoot, projectRoots, runtimeTsConfigFileName, possibleRuntimeTsConfigFileNames) {
-    const tsConfig = (0, devkit_1.readJson)(tree, tsConfigPath);
+/**
+ * Within the context of a sync generator, performance is a key concern,
+ * so avoid FS interactions whenever possible.
+ */
+function readRawTsconfigContents(tree, rawTsconfigContentsCache, tsconfigPath) {
+    if (!rawTsconfigContentsCache.has(tsconfigPath)) {
+        rawTsconfigContentsCache.set(tsconfigPath, tree.read(tsconfigPath, 'utf-8'));
+    }
+    return rawTsconfigContentsCache.get(tsconfigPath);
+}
+/**
+ * Within the context of a sync generator, performance is a key concern,
+ * so avoid FS interactions whenever possible.
+ */
+function tsconfigExists(tree, rawTsconfigContentsCache, tsconfigPath) {
+    return rawTsconfigContentsCache.has(tsconfigPath)
+        ? true
+        : tree.exists(tsconfigPath);
+}
+function updateTsConfigReferences(tree, tsSysFromTree, rawTsconfigContentsCache, tsconfigHasCompositeEnabledCache, tsConfigPath, dependencies, projectRoot, projectRoots, runtimeTsConfigFileName, possibleRuntimeTsConfigFileNames) {
+    const stringifiedJsonContents = readRawTsconfigContents(tree, rawTsconfigContentsCache, tsConfigPath);
+    const tsConfig = (0, devkit_1.parseJson)(stringifiedJsonContents);
     // We have at least one dependency so we can safely set it to an empty array if not already set
     const references = [];
     const originalReferencesSet = new Set();
@@ -127,8 +161,8 @@ function updateTsConfigReferences(tree, tsConfigPath, dependencies, projectRoot,
         originalReferencesSet.add(normalizedPath);
         // reference path is relative to the tsconfig file
         const resolvedRefPath = getTsConfigPathFromReferencePath(tree, tsConfigPath, ref.path);
-        if (isInternalProjectReference(tree, resolvedRefPath, projectRoot, projectRoots)) {
-            // we keep all internal references
+        if (isProjectReferenceWithinNxProject(tree, rawTsconfigContentsCache, resolvedRefPath, projectRoot, projectRoots)) {
+            // we keep all references within the current Nx project
             references.push(ref);
             newReferencesSet.add(normalizedPath);
         }
@@ -139,7 +173,11 @@ function updateTsConfigReferences(tree, tsConfigPath, dependencies, projectRoot,
         let referencePath = dep.data.root;
         if (runtimeTsConfigFileName) {
             const runtimeTsConfigPath = (0, devkit_1.joinPathFragments)(dep.data.root, runtimeTsConfigFileName);
-            if (tree.exists(runtimeTsConfigPath)) {
+            if (tsconfigExists(tree, rawTsconfigContentsCache, runtimeTsConfigPath)) {
+                // Check composite is true in the dependency runtime tsconfig file before proceeding
+                if (!hasCompositeEnabled(tsSysFromTree, tsconfigHasCompositeEnabledCache, runtimeTsConfigPath)) {
+                    continue;
+                }
                 referencePath = runtimeTsConfigPath;
             }
             else {
@@ -148,13 +186,23 @@ function updateTsConfigReferences(tree, tsConfigPath, dependencies, projectRoot,
                 for (const possibleRuntimeTsConfigFileName of possibleRuntimeTsConfigFileNames ??
                     []) {
                     const possibleRuntimeTsConfigPath = (0, devkit_1.joinPathFragments)(dep.data.root, possibleRuntimeTsConfigFileName);
-                    if (tree.exists(possibleRuntimeTsConfigPath)) {
+                    if (tsconfigExists(tree, rawTsconfigContentsCache, possibleRuntimeTsConfigPath)) {
+                        // Check composite is true in the dependency runtime tsconfig file before proceeding
+                        if (!hasCompositeEnabled(tsSysFromTree, tsconfigHasCompositeEnabledCache, possibleRuntimeTsConfigPath)) {
+                            continue;
+                        }
                         referencePath = possibleRuntimeTsConfigPath;
                         break;
                     }
                 }
             }
         }
+        else {
+            // Check composite is true in the dependency tsconfig.json file before proceeding
+            if (!hasCompositeEnabled(tsSysFromTree, tsconfigHasCompositeEnabledCache, (0, devkit_1.joinPathFragments)(dep.data.root, 'tsconfig.json'))) {
+                continue;
+            }
+        }
         const relativePathToTargetRoot = (0, posix_1.relative)(projectRoot, referencePath);
         if (!newReferencesSet.has(relativePathToTargetRoot)) {
             newReferencesSet.add(relativePathToTargetRoot);
@@ -167,8 +215,7 @@ function updateTsConfigReferences(tree, tsConfigPath, dependencies, projectRoot,
     }
     hasChanges ||= newReferencesSet.size !== originalReferencesSet.size;
     if (hasChanges) {
-        tsConfig.references = references;
-        (0, devkit_1.writeJson)(tree, tsConfigPath, tsConfig);
+        patchTsconfigJsonReferences(tree, rawTsconfigContentsCache, tsConfigPath, references);
     }
     return hasChanges;
 }
@@ -214,8 +261,8 @@ function normalizeReferencePath(path) {
         .replace(/\/tsconfig.json$/, '')
         .replace(/^\.\//, '');
 }
-function isInternalProjectReference(tree, refTsConfigPath, projectRoot, projectRoots) {
-    let currentPath = getTsConfigDirName(tree, refTsConfigPath);
+function isProjectReferenceWithinNxProject(tree, rawTsconfigContentsCache, refTsConfigPath, projectRoot, projectRoots) {
+    let currentPath = getTsConfigDirName(tree, rawTsconfigContentsCache, refTsConfigPath);
     if ((0, posix_1.relative)(projectRoot, currentPath).startsWith('..')) {
         // it's outside of the project root, so it's an external project reference
         return false;
@@ -230,8 +277,10 @@ function isInternalProjectReference(tree, refTsConfigPath, projectRoot, projectR
     // it's inside the project root, so it's an internal project reference
     return true;
 }
-function getTsConfigDirName(tree, tsConfigPath) {
-    return tree.isFile(tsConfigPath)
+function getTsConfigDirName(tree, rawTsconfigContentsCache, tsConfigPath) {
+    return (rawTsconfigContentsCache.has(tsConfigPath)
+        ? true
+        : tree.isFile(tsConfigPath))
         ? (0, posix_1.dirname)(tsConfigPath)
         : (0, posix_1.normalize)(tsConfigPath);
 }
@@ -241,3 +290,22 @@ function getTsConfigPathFromReferencePath(tree, ownerTsConfigPath, referencePath
         ? resolvedRefPath
         : (0, devkit_1.joinPathFragments)(resolvedRefPath, 'tsconfig.json');
 }
+/**
+ * Minimally patch just the "references" property within the tsconfig file at a given path.
+ * This allows comments in other sections of the file to remain intact when syncing is run.
+ */
+function patchTsconfigJsonReferences(tree, rawTsconfigContentsCache, tsconfigPath, updatedReferences) {
+    const stringifiedJsonContents = readRawTsconfigContents(tree, rawTsconfigContentsCache, tsconfigPath);
+    const edits = (0, jsonc_parser_1.modify)(stringifiedJsonContents, ['references'], updatedReferences, {});
+    const updatedJsonContents = (0, jsonc_parser_1.applyEdits)(stringifiedJsonContents, edits);
+    // The final contents will be formatted by formatFiles() later
+    tree.write(tsconfigPath, updatedJsonContents);
+}
+function hasCompositeEnabled(tsSysFromTree, tsconfigHasCompositeEnabledCache, tsconfigPath) {
+    if (!tsconfigHasCompositeEnabledCache.has(tsconfigPath)) {
+        const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(tsconfigPath, tsSysFromTree.readFile).config, tsSysFromTree, (0, posix_1.dirname)(tsconfigPath));
+        const enabledVal = parsed.options.composite === true;
+        tsconfigHasCompositeEnabledCache.set(tsconfigPath, enabledVal);
+    }
+    return tsconfigHasCompositeEnabledCache.get(tsconfigPath);
+}

package/src/utils/buildable-libs-utils.js

@@ -283,6 +283,9 @@ function updatePaths(dependencies, paths) {
     const pathsKeys = Object.keys(paths);
     // For each registered dependency
     dependencies.forEach((dep) => {
+        if (dep.node.type === 'npm') {
+            return;
+        }
         // If there are outputs
         if (dep.outputs && dep.outputs.length > 0) {
             // Directly map the dependency name to the output paths (dist/packages/..., etc.)
@@ -294,14 +297,19 @@ function updatePaths(dependencies, paths) {
                 // If the path points to the current dependency and is nested (/)
                 if (path.startsWith(nestedName)) {
                     const nestedPart = path.slice(nestedName.length);
-                    // Bind secondary endpoints for ng-packagr projects
+                    // Bind potential secondary endpoints for ng-packagr projects
                     let mappedPaths = dep.outputs.map((output) => `${output}/${nestedPart}`);
-                    // Get the dependency's package name
-                    const { root } = (dep.node?.data || {});
-                    if (root) {
-                        // Update nested mappings to point to the dependency's output paths
-                        mappedPaths = mappedPaths.concat(paths[path].flatMap((path) => dep.outputs.map((output) => path.replace(root, output))));
-                    }
+                    const { root } = dep.node.data;
+                    // Update nested mappings to point to the dependency's output paths
+                    mappedPaths = mappedPaths.concat(paths[path].flatMap((p) => dep.outputs.flatMap((output) => {
+                        const basePath = p.replace(root, output);
+                        return [
+                            // extension-less path to support compiled output
+                            basePath.replace(new RegExp(`${(0, path_1.extname)(basePath)}$`, 'gi'), ''),
+                            // original path with the root re-mapped to the output path
+                            basePath,
+                        ];
+                    })));
                     paths[path] = mappedPaths;
                 }
             }

package/src/utils/schema.d.ts

@@ -2,7 +2,7 @@ import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project
 import type { AssetGlob, FileInputOutput } from './assets/assets';
 import { TransformerEntry } from './typescript/types';
 // nx-ignore-next-line
-const { Linter } = require('@nx/eslint'); // use require to import to avoid circular dependency
+const { Linter, LinterType } = require('@nx/eslint'); // use require to import to avoid circular dependency
 
 export type Compiler = 'tsc' | 'swc';
 export type Bundler = 'swc' | 'tsc' | 'rollup' | 'vite' | 'esbuild' | 'none';
@@ -17,7 +17,7 @@ export interface LibraryGeneratorSchema {
   skipPackageJson?: boolean;
   includeBabelRc?: boolean;
   unitTestRunner?: 'jest' | 'vitest' | 'none';
-  linter?: Linter;
+  linter?: Linter | LinterType;
   testEnvironment?: 'jsdom' | 'node';
   importPath?: string;
   js?: boolean;

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

@@ -13,6 +13,7 @@ interface BaseTypeCheckOptions {
     cacheDir?: string;
     incremental?: boolean;
     rootDir?: string;
+    projectRoot?: string;
 }
 type Mode = NoEmitMode | EmitDeclarationOnlyMode;
 interface NoEmitMode {

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

@@ -55,21 +55,28 @@ async function runTypeCheck(options) {
 }
 async function setupTypeScript(options) {
     const ts = await Promise.resolve().then(() => require('typescript'));
-    const { workspaceRoot, tsConfigPath, cacheDir, incremental, rootDir } = options;
+    const { workspaceRoot, tsConfigPath, cacheDir, incremental, projectRoot } = 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 }
+        ? {
+            emitDeclarationOnly: true,
+            declaration: true,
+            outDir: options.outDir,
+            declarationDir: options.projectRoot && options.outDir.indexOf(projectRoot)
+                ? options.outDir.replace(projectRoot, '')
+                : undefined,
+        }
         : { noEmit: true };
     const compilerOptions = {
         ...config.options,
         skipLibCheck: true,
         ...emitOptions,
         incremental,
-        rootDir: rootDir || config.options.rootDir,
+        rootDir: options.rootDir || config.options.rootDir,
     };
     return { ts, workspaceRoot, cacheDir, config, compilerOptions };
 }