@nx/js 0.0.0-pr-29314-e664f92 → 0.0.0-pr-29286-735af1e

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2024 Narwhal Technologies Inc.
+Copyright (c) 2017-2025 Narwhal Technologies Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "0.0.0-pr-29314-e664f92",
+  "version": "0.0.0-pr-29286-735af1e",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -39,8 +39,8 @@
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@nx/devkit": "0.0.0-pr-29314-e664f92",
-    "@nx/workspace": "0.0.0-pr-29314-e664f92",
+    "@nx/devkit": "0.0.0-pr-29286-735af1e",
+    "@nx/workspace": "0.0.0-pr-29286-735af1e",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",

package/src/generators/library/files/lib/src/index.ts__tmpl__

@@ -1 +1 @@
-export * from './lib/<%= fileName %>';
+export * from './lib/<%= fileNameImport %>';

package/src/generators/library/library.js

@@ -22,6 +22,7 @@ const ts_solution_setup_1 = require("../../utils/typescript/ts-solution-setup");
 const versions_1 = require("../../utils/versions");
 const init_1 = require("../init/init");
 const generator_1 = require("../setup-verdaccio/generator");
+const ensure_typescript_1 = require("../../utils/typescript/ensure-typescript");
 const defaultOutputDirectory = 'dist';
 async function libraryGenerator(tree, schema) {
     return await libraryGeneratorInternal(tree, {
@@ -147,12 +148,7 @@ async function libraryGeneratorInternal(tree, schema) {
 async function configureProject(tree, options) {
     if (options.hasPlugin) {
         const nxJson = (0, devkit_1.readNxJson)(tree);
-        if (options.bundler === 'none') {
-            (0, plugin_1.ensureProjectIsExcludedFromPluginRegistrations)(nxJson, options.projectRoot);
-        }
-        else {
-            (0, plugin_1.ensureProjectIsIncludedInPluginRegistrations)(nxJson, options.projectRoot);
-        }
+        (0, plugin_1.ensureProjectIsIncludedInPluginRegistrations)(nxJson, options.projectRoot);
         (0, devkit_1.updateNxJson)(tree, nxJson);
     }
     const projectConfiguration = {
@@ -335,6 +331,19 @@ function addBabelRc(tree, options) {
 function createFiles(tree, options) {
     const { className, name, propertyName } = (0, devkit_1.names)(options.projectNames.projectFileName);
     createProjectTsConfigs(tree, options);
+    let fileNameImport = options.fileName;
+    if (options.bundler === 'vite') {
+        const tsConfig = (0, ts_config_1.readTsConfigFromTree)(tree, (0, path_1.join)(options.projectRoot, 'tsconfig.lib.json'));
+        const ts = (0, ensure_typescript_1.ensureTypescript)();
+        if (tsConfig.options.moduleResolution === ts.ModuleResolutionKind.Node16 ||
+            tsConfig.options.moduleResolution === ts.ModuleResolutionKind.NodeNext) {
+            // Node16 and NodeNext require explicit file extensions for relative
+            // import paths. Since we generate the file with the `.ts` extension,
+            // we import it from the same file with the `.js` extension.
+            // https://www.typescriptlang.org/docs/handbook/modules/reference.html#file-extension-substitution
+            fileNameImport = `${options.fileName}.js`;
+        }
+    }
     (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, './files/lib'), options.projectRoot, {
         ...options,
         dot: '.',
@@ -348,6 +357,7 @@ function createFiles(tree, options) {
         offsetFromRoot: (0, devkit_1.offsetFromRoot)(options.projectRoot),
         buildable: options.bundler && options.bundler !== 'none',
         hasUnitTestRunner: options.unitTestRunner !== 'none',
+        fileNameImport,
     });
     if (!options.rootProject) {
         (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, './files/readme'), options.projectRoot, {
@@ -686,6 +696,9 @@ function createProjectTsConfigs(tree, options) {
             .map(([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`)
             .join(',\n    '),
         tmpl: '',
+        outDir: options.bundler === 'tsc'
+            ? 'dist'
+            : `out-tsc/${options.projectRoot.split('/').pop()}`,
     });
     // tsconfig.json
     if (options.isUsingTsSolutionConfig) {
@@ -793,14 +806,10 @@ function determineEntryFields(options) {
             };
         case 'vite':
             return {
-                // Since we're publishing both formats, skip the type field.
-                // Bundlers or Node will determine the entry point to use.
+                type: 'module',
                 main: options.isUsingTsSolutionConfig
                     ? './dist/index.js'
                     : './index.js',
-                module: options.isUsingTsSolutionConfig
-                    ? './dist/index.mjs'
-                    : './index.mjs',
                 typings: options.isUsingTsSolutionConfig
                     ? './dist/index.d.ts'
                     : './index.d.ts',

package/src/generators/release-version/utils/update-lock-file.js

@@ -99,7 +99,7 @@ function execLockFileUpdate(command, cwd, env = {}) {
                 `Verify that '${command}' succeeds when run from the workspace root.`,
                 `To configure a string of arguments to be passed to this command, set the 'release.version.generatorOptions.installArgs' property in nx.json.`,
                 `To ignore install lifecycle scripts, set 'release.version.generatorOptions.installIgnoreScripts' to true in nx.json.`,
-                `To disable this step entirely, set 'release.version.skipLockFileUpdate' to true in nx.json.`,
+                `To disable this step entirely, set 'release.version.generatorOptions.skipLockFileUpdate' to true in nx.json.`,
             ],
         });
         throw e;

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

@@ -55,10 +55,20 @@ async function syncGenerator(tree) {
     const tsSysFromTree = {
         ...ts.sys,
         fileExists(path) {
-            return tsconfigExists(tree, tsconfigInfoCaches, path);
+            // Given ts.System.resolve resolve full path for tsconfig within node_modules
+            // We need to remove the workspace root to ensure we don't have double workspace root within the Tree
+            const correctPath = path.startsWith(tree.root)
+                ? (0, posix_1.relative)(tree.root, path)
+                : path;
+            return tsconfigExists(tree, tsconfigInfoCaches, correctPath);
         },
         readFile(path) {
-            return readRawTsconfigContents(tree, tsconfigInfoCaches, path);
+            // Given ts.System.resolve resolve full path for tsconfig within node_modules
+            // We need to remove the workspace root to ensure we don't have double workspace root within the Tree
+            const correctPath = path.startsWith(tree.root)
+                ? (0, posix_1.relative)(tree.root, path)
+                : path;
+            return readRawTsconfigContents(tree, tsconfigInfoCaches, correctPath);
         },
     };
     // Track if any changes were made to the tsconfig files. We check the changes
@@ -250,8 +260,8 @@ function collectProjectDependencies(tree, projectName, projectGraph, collectedDe
     collectedDependencies.set(projectName, []);
     for (const dep of projectGraph.dependencies[projectName]) {
         const targetProjectNode = projectGraph.nodes[dep.target];
-        if (!targetProjectNode) {
-            // It's an npm dependency
+        if (!targetProjectNode || dep.type === 'implicit') {
+            // It's an npm or an implicit dependency
             continue;
         }
         // Add the target project node to the list of dependencies for the current project
@@ -325,7 +335,7 @@ function getTsConfigPathFromReferencePath(tree, ownerTsConfigPath, referencePath
  */
 function patchTsconfigJsonReferences(tree, tsconfigInfoCaches, tsconfigPath, updatedReferences) {
     const stringifiedJsonContents = readRawTsconfigContents(tree, tsconfigInfoCaches, tsconfigPath);
-    const edits = (0, jsonc_parser_1.modify)(stringifiedJsonContents, ['references'], updatedReferences, { formattingOptions: { keepLines: false } });
+    const edits = (0, jsonc_parser_1.modify)(stringifiedJsonContents, ['references'], updatedReferences, { formattingOptions: { keepLines: true, insertSpaces: true, tabSize: 2 } });
     const updatedJsonContents = (0, jsonc_parser_1.applyEdits)(stringifiedJsonContents, edits);
     // The final contents will be formatted by formatFiles() later
     tree.write(tsconfigPath, updatedJsonContents);

package/src/plugins/typescript/plugin.js

@@ -161,7 +161,9 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
         }
     }
     // Build target
-    if (options.build && (0, node_path_1.basename)(configFilePath) === options.build.configName) {
+    if (options.build &&
+        (0, node_path_1.basename)(configFilePath) === options.build.configName &&
+        isValidPackageJsonBuildConfig(tsConfig, context.workspaceRoot, projectRoot, configFilePath)) {
         internalProjectReferences ??= resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
         const targetName = options.build.targetName;
         targets[targetName] = {
@@ -272,10 +274,16 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
         }
         else if (config.options.outDir) {
             outputs.add(pathToInputOrOutput(config.options.outDir, workspaceRoot, projectRoot));
-            if (config.options.tsBuildInfoFile &&
-                !(0, node_path_1.normalize)(config.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(config.options.outDir)}${node_path_1.sep}`)) {
-                // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
-                outputs.add(pathToInputOrOutput(config.options.tsBuildInfoFile, workspaceRoot, projectRoot));
+            if (config.options.tsBuildInfoFile) {
+                if (!(0, node_path_1.normalize)(config.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(config.options.outDir)}${node_path_1.sep}`)) {
+                    // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
+                    outputs.add(pathToInputOrOutput(config.options.tsBuildInfoFile, workspaceRoot, projectRoot));
+                }
+            }
+            else if (config.options.rootDir && config.options.rootDir !== '.') {
+                // If rootDir is set, then the tsbuildinfo file will be outside the outDir so we need to add it.
+                const relativeRootDir = (0, node_path_1.relative)(config.options.rootDir, (0, node_path_1.join)(workspaceRoot, projectRoot));
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, relativeRootDir, `*.tsbuildinfo`), workspaceRoot, projectRoot));
             }
         }
         else if (config.fileNames.length) {
@@ -301,6 +309,78 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
     });
     return Array.from(outputs);
 }
+/**
+ * Checks whether a `package.json` file has a valid build configuration by ensuring
+ * that the `main`, `module`, or `exports` do not include paths from the `rootDir`.
+ * Or if `outFile` is defined, it should not be within the `rootDir`.
+ *
+ * @param tsConfig The TypeScript configuration object.
+ * @param workspaceRoot The workspace root path.
+ * @param projectRoot The project root path.
+ * @param tsConfigPath The path to the TypeScript configuration file.
+ * @returns `true` if the package has a valid build configuration; otherwise, `false`.
+ */
+function isValidPackageJsonBuildConfig(tsConfig, workspaceRoot, projectRoot, tsConfigPath) {
+    if (!(0, node_fs_1.existsSync)((0, devkit_1.joinPathFragments)(projectRoot, 'package.json'))) {
+        // If the package.json file does not exist.
+        // Assume it's valid because it would be using `project.json` instead.
+        return true;
+    }
+    const packageJson = (0, devkit_1.readJsonFile)((0, devkit_1.joinPathFragments)(projectRoot, 'package.json'));
+    const rootDir = tsConfig.options.rootDir ?? 'src/';
+    if (!tsConfig.options.rootDir) {
+        console.warn(`The 'rootDir' option is not set in the tsconfig file at ${tsConfigPath}. Assuming 'src/' as the root directory.`);
+    }
+    const isPathWithinSrc = (path) => {
+        const resolvedRootDir = (0, node_path_1.resolve)(workspaceRoot, projectRoot, rootDir);
+        const pathToCheck = (0, node_path_1.resolve)(workspaceRoot, projectRoot, path);
+        return pathToCheck.startsWith(resolvedRootDir);
+    };
+    // If `outFile` is defined, check the validity of the path.
+    if (tsConfig.options.outFile) {
+        if (isPathWithinSrc(tsConfig.options.outFile)) {
+            return false;
+        }
+    }
+    const buildPaths = ['main', 'module'];
+    for (const field of buildPaths) {
+        if (packageJson[field] && isPathWithinSrc(packageJson[field])) {
+            return false;
+        }
+    }
+    const exports = packageJson?.exports;
+    // Checks if the value is a path within the `src` directory.
+    const containsInvalidPath = (value) => {
+        if (typeof value === 'string') {
+            return isPathWithinSrc(value);
+        }
+        else if (typeof value === 'object') {
+            return Object.entries(value).some(([currentKey, subValue]) => {
+                // Skip types field
+                if (currentKey === 'types') {
+                    return false;
+                }
+                if (typeof subValue === 'string') {
+                    return isPathWithinSrc(subValue);
+                }
+                return false;
+            });
+        }
+        return false;
+    };
+    if (typeof exports === 'string' && isPathWithinSrc(exports)) {
+        return false;
+    }
+    // Check nested exports if `exports` is an object.
+    if (typeof exports === 'object') {
+        for (const key in exports) {
+            if (containsInvalidPath(exports[key])) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
 function pathToInputOrOutput(path, workspaceRoot, projectRoot) {
     const pathRelativeToProjectRoot = (0, devkit_1.normalizePath)((0, node_path_1.relative)(projectRoot, path));
     if (pathRelativeToProjectRoot.startsWith('..')) {

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

@@ -230,6 +230,9 @@ function computeCompilerOptionsPaths(tsConfig, dependencies) {
 }
 function createTmpTsConfig(tsconfigPath, workspaceRoot, projectRoot, dependencies, useWorkspaceAsBaseUrl = false) {
     const tmpTsConfigPath = (0, path_1.join)(workspaceRoot, 'tmp', projectRoot, process.env.NX_TASK_TARGET_TARGET ?? 'build', 'tsconfig.generated.json');
+    if (tsconfigPath === tmpTsConfigPath) {
+        return tsconfigPath;
+    }
     const parsedTSConfig = readTsConfigWithRemappedPaths(tsconfigPath, tmpTsConfigPath, dependencies, workspaceRoot);
     process.on('exit', () => cleanupTmpTsConfigFile(tmpTsConfigPath));
     if (useWorkspaceAsBaseUrl) {

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

@@ -1,6 +1,7 @@
 import { Tree } from '@nx/devkit';
 import type * as ts from 'typescript';
 export declare function readTsConfig(tsConfigPath: string, sys?: ts.System): ts.ParsedCommandLine;
+export declare function readTsConfigFromTree(tree: Tree, 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;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readTsConfig = readTsConfig;
+exports.readTsConfigFromTree = readTsConfigFromTree;
 exports.getRootTsConfigPathInTree = getRootTsConfigPathInTree;
 exports.getRelativePathToRootTsConfig = getRelativePathToRootTsConfig;
 exports.getRootTsConfigPath = getRootTsConfigPath;
@@ -20,6 +21,16 @@ function readTsConfig(tsConfigPath, sys) {
     const readResult = tsModule.readConfigFile(tsConfigPath, sys.readFile);
     return tsModule.parseJsonConfigFileContent(readResult.config, sys, (0, path_1.dirname)(tsConfigPath));
 }
+function readTsConfigFromTree(tree, tsConfigPath) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const tsSysFromTree = {
+        ...tsModule.sys,
+        readFile: (path) => tree.read(path, 'utf-8'),
+    };
+    return readTsConfig(tsConfigPath, tsSysFromTree);
+}
 function getRootTsConfigPathInTree(tree) {
     for (const path of ['tsconfig.base.json', 'tsconfig.json']) {
         if (tree.exists(path)) {

package/src/utils/typescript/ts-solution-setup.d.ts

@@ -4,3 +4,4 @@ export declare function isUsingTsSolutionSetup(tree?: Tree): boolean;
 export declare function assertNotUsingTsSolutionSetup(tree: Tree, pluginName: string, generatorName: string): void;
 export declare function findRuntimeTsConfigName(tree: Tree, projectRoot: string): string | null;
 export declare function updateTsconfigFiles(tree: Tree, projectRoot: string, runtimeTsconfigFileName: string, compilerOptions: Record<string, string | boolean | string[]>, exclude?: string[], rootDir?: string): void;
+export declare function addProjectToTsSolutionWorkspace(tree: Tree, projectDir: string): void;

package/src/utils/typescript/ts-solution-setup.js

@@ -5,6 +5,7 @@ exports.isUsingTsSolutionSetup = isUsingTsSolutionSetup;
 exports.assertNotUsingTsSolutionSetup = assertNotUsingTsSolutionSetup;
 exports.findRuntimeTsConfigName = findRuntimeTsConfigName;
 exports.updateTsconfigFiles = updateTsconfigFiles;
+exports.addProjectToTsSolutionWorkspace = addProjectToTsSolutionWorkspace;
 const devkit_1 = require("@nx/devkit");
 const tree_1 = require("nx/src/generators/tree");
 const package_manager_workspaces_1 = require("../package-manager-workspaces");
@@ -66,7 +67,7 @@ function assertNotUsingTsSolutionSetup(tree, pluginName, generatorName) {
             `We're working hard to support the existing TypeScript setup with the ${artifactString}. We'll soon release a new version of Nx with support for it.`,
         ],
     });
-    process.exit(1);
+    throw new Error(`The ${artifactString} doesn't yet support the existing TypeScript setup. See the error above.`);
 }
 function findRuntimeTsConfigName(tree, projectRoot) {
     if (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.app.json')))
@@ -94,8 +95,20 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
                 rootDir,
                 ...compilerOptions,
             };
+            if (rootDir && rootDir !== '.') {
+                // when rootDir is different from '.', the tsbuildinfo file is output
+                // at `<outDir>/<relative path to config from rootDir>/`, so we need
+                // to set it explicitly to ensure it's output to the outDir
+                // https://www.typescriptlang.org/tsconfig/#tsBuildInfoFile
+                json.compilerOptions.tsBuildInfoFile = (0, posix_1.join)('out-tsc', projectRoot.split('/').at(-1), (0, posix_1.basename)(runtimeTsconfigFileName, '.json') + '.tsbuildinfo');
+            }
+            else if (json.compilerOptions.tsBuildInfoFile) {
+                // when rootDir is '.' or not set, it would be output to the outDir, so
+                // we don't need to set it explicitly
+                delete json.compilerOptions.tsBuildInfoFile;
+            }
             const excludeSet = json.exclude
-                ? new Set(['dist', ...json.exclude, ...exclude])
+                ? new Set(['out-tsc', 'dist', ...json.exclude, ...exclude])
                 : new Set(exclude);
             json.exclude = Array.from(excludeSet);
             return json;
@@ -115,16 +128,6 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
             return json;
         });
     }
-    if (tree.exists(tsconfigE2E)) {
-        // tsconfig.json for e2e projects need to have references array
-        (0, devkit_1.updateJson)(tree, tsconfigE2E, (json) => {
-            json.references ??= [];
-            const projectPath = (0, posix_1.relative)(e2eRoot, projectRoot);
-            if (!json.references.some((x) => x.path === projectPath))
-                json.references.push({ path: projectPath });
-            return json;
-        });
-    }
     if (tree.exists('tsconfig.json')) {
         (0, devkit_1.updateJson)(tree, 'tsconfig.json', (json) => {
             const projectPath = './' + projectRoot;
@@ -135,3 +138,32 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
         });
     }
 }
+function addProjectToTsSolutionWorkspace(tree, projectDir) {
+    // If dir is "libs/foo" then use "libs/**" so we don't need so many entries in the workspace file.
+    // If the dir is just "foo" then we have to add it as is.
+    const baseDir = (0, posix_1.dirname)(projectDir);
+    const pattern = baseDir === '.' ? projectDir : `${baseDir}/**`;
+    if (tree.exists('pnpm-workspace.yaml')) {
+        const { load, dump } = require('@zkochan/js-yaml');
+        const workspaceFile = tree.read('pnpm-workspace.yaml', 'utf-8');
+        const yamlData = load(workspaceFile);
+        if (!yamlData?.packages) {
+            yamlData.packages = [];
+        }
+        if (!yamlData.packages.includes(pattern)) {
+            yamlData.packages.push(pattern);
+            tree.write('pnpm-workspace.yaml', dump(yamlData, { indent: 2, quotingType: '"', forceQuotes: true }));
+        }
+    }
+    else {
+        // Update package.json
+        const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
+        if (!packageJson.workspaces) {
+            packageJson.workspaces = [];
+        }
+        if (!packageJson.workspaces.includes(pattern)) {
+            packageJson.workspaces.push(pattern);
+            tree.write('package.json', JSON.stringify(packageJson, null, 2));
+        }
+    }
+}