@nx/js 19.6.1 → 19.6.2

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.1",
+  "version": "19.6.2",
   "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.6.2",
+    "@nx/workspace": "19.6.2",
     "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.1",
-    "@nx/workspace": "19.6.1",
-    "@nrwl/js": "19.6.1"
+    "@nrwl/js": "19.6.2"
   },
   "peerDependencies": {
     "verdaccio": "^5.0.4"

package/src/executors/tsc/lib/normalize-options.js

@@ -23,6 +23,7 @@ function normalizeOptions(options, contextRoot, sourceRoot, projectRoot) {
             options.external = firstItem;
         }
     }
+    options.assets ??= [];
     const files = (0, assets_1.assetGlobsToFiles)(options.assets, contextRoot, outputPath);
     return {
         ...options,

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/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 };
 }