@nx/js 16.6.0-beta.6 → 16.6.0-beta.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "16.6.0-beta.6",
+  "version": "16.6.0-beta.8",
   "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,9 +39,9 @@
     "@babel/preset-env": "^7.22.9",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@nrwl/js": "16.6.0-beta.6",
-    "@nx/devkit": "16.6.0-beta.6",
-    "@nx/workspace": "16.6.0-beta.6",
+    "@nrwl/js": "16.6.0-beta.8",
+    "@nx/devkit": "16.6.0-beta.8",
+    "@nx/workspace": "16.6.0-beta.8",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",
@@ -71,5 +71,5 @@
     "access": "public"
   },
   "types": "./src/index.d.ts",
-  "gitHead": "9aad21dbfb2b659e488b6626f59df58ab23c0032"
+  "gitHead": "d1d06349e703d903ac47fb7adc7d250ce140d77e"
 }

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

@@ -274,21 +274,14 @@ function getFileToRun(context, project, buildOptions, buildTargetExecutor) {
     return (0, path_1.join)(context.root, buildOptions.outputPath, outputFileName);
 }
 function fileToRunCorrectPath(fileToRun) {
-    if (!(0, fileutils_1.fileExists)(fileToRun)) {
-        const cjsFile = fileToRun.replace(/\.js$/, '.cjs');
-        if ((0, fileutils_1.fileExists)(cjsFile)) {
-            fileToRun = cjsFile;
-        }
-        else {
-            const mjsFile = fileToRun.replace(/\.js$/, '.mjs');
-            if ((0, fileutils_1.fileExists)(mjsFile)) {
-                fileToRun = mjsFile;
-            }
-            else {
-                throw new Error(`Could not find ${fileToRun}. Make sure your build succeeded.`);
-            }
-        }
+    if ((0, fileutils_1.fileExists)(fileToRun))
+        return fileToRun;
+    const extensionsToTry = ['.cjs', '.mjs', 'cjs.js', '.esm.js'];
+    for (const ext of extensionsToTry) {
+        const file = fileToRun.replace(/\.js$/, ext);
+        if ((0, fileutils_1.fileExists)(file))
+            return file;
     }
-    return fileToRun;
+    throw new Error(`Could not find ${fileToRun}. Make sure your build succeeded.`);
 }
 exports.default = nodeExecutor;

package/src/executors/swc/swc.impl.d.ts

@@ -1,6 +1,5 @@
 import { ExecutorContext } from '@nx/devkit';
-import { NormalizedSwcExecutorOptions, SwcExecutorOptions } from '../../utils/schema';
-export declare function normalizeOptions(options: SwcExecutorOptions, contextRoot: string, sourceRoot?: string, projectRoot?: string): NormalizedSwcExecutorOptions;
+import { SwcExecutorOptions } from '../../utils/schema';
 export declare function swcExecutor(_options: SwcExecutorOptions, context: ExecutorContext): AsyncGenerator<{
     success: boolean;
     outfile?: undefined;

package/src/executors/swc/swc.impl.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.swcExecutor = exports.normalizeOptions = void 0;
+exports.swcExecutor = void 0;
 const tslib_1 = require("tslib");
 const assets_1 = require("../../utils/assets/assets");
 const fs_extra_1 = require("fs-extra");
@@ -13,8 +13,8 @@ const package_json_1 = require("../../utils/package-json");
 const compile_swc_1 = require("../../utils/swc/compile-swc");
 const get_swcrc_path_1 = require("../../utils/swc/get-swcrc-path");
 const inline_2 = require("../../utils/swc/inline");
-function normalizeOptions(options, contextRoot, sourceRoot, projectRoot) {
-    const outputPath = (0, path_1.join)(contextRoot, options.outputPath);
+function normalizeOptions(options, root, sourceRoot, projectRoot) {
+    const outputPath = (0, path_1.join)(root, options.outputPath);
     if (options.skipTypeCheck == null) {
         options.skipTypeCheck = false;
     }
@@ -33,25 +33,20 @@ function normalizeOptions(options, contextRoot, sourceRoot, projectRoot) {
             options.external = firstItem;
         }
     }
-    const files = (0, assets_1.assetGlobsToFiles)(options.assets, contextRoot, outputPath);
-    const projectRootParts = projectRoot.split('/');
-    // We pop the last part of the `projectRoot` to pass
-    // the last part (projectDir) and the remainder (projectRootParts) to swc
-    const projectDir = projectRootParts.pop();
-    // default to current directory if projectRootParts is [].
-    // Eg: when a project is at the root level, outside of layout dir
-    const swcCwd = projectRootParts.join('/') || '.';
-    const swcrcPath = (0, get_swcrc_path_1.getSwcrcPath)(options, contextRoot, projectRoot);
+    const files = (0, assets_1.assetGlobsToFiles)(options.assets, root, outputPath);
+    const swcrcPath = (0, get_swcrc_path_1.getSwcrcPath)(options, root, projectRoot);
+    // TODO(meeroslav): Check why this is needed in order for swc to properly nest folders
+    const distParent = outputPath.split('/').slice(0, -1).join('/');
     const swcCliOptions = {
-        srcPath: projectDir,
-        destPath: (0, path_1.relative)((0, path_1.join)(contextRoot, swcCwd), outputPath),
-        swcCwd,
+        srcPath: projectRoot,
+        destPath: (0, path_1.relative)(root, distParent),
         swcrcPath,
     };
-    return Object.assign(Object.assign({}, options), { mainOutputPath: (0, path_1.resolve)(outputPath, options.main.replace(`${projectRoot}/`, '').replace('.ts', '.js')), files, root: contextRoot, sourceRoot,
-        projectRoot, originalProjectRoot: projectRoot, outputPath, tsConfig: (0, path_1.join)(contextRoot, options.tsConfig), swcCliOptions });
+    return Object.assign(Object.assign({}, options), { mainOutputPath: (0, path_1.resolve)(outputPath, options.main.replace(`${projectRoot}/`, '').replace('.ts', '.js')), files,
+        root,
+        sourceRoot,
+        projectRoot, originalProjectRoot: projectRoot, outputPath, tsConfig: (0, path_1.join)(root, options.tsConfig), swcCliOptions });
 }
-exports.normalizeOptions = normalizeOptions;
 function swcExecutor(_options, context) {
     return tslib_1.__asyncGenerator(this, arguments, function* swcExecutor_1() {
         const { sourceRoot, root } = context.projectsConfigurations.projects[context.projectName];
@@ -67,13 +62,8 @@ function swcExecutor(_options, context) {
         const inlineProjectGraph = (0, inline_1.handleInliningBuild)(context, options, options.tsConfig);
         if (!(0, inline_1.isInlineGraphEmpty)(inlineProjectGraph)) {
             options.projectRoot = '.'; // set to root of workspace to include other libs for type check
-            // remap paths for SWC compilation
-            options.swcCliOptions.srcPath = options.swcCliOptions.swcCwd;
-            options.swcCliOptions.swcCwd = '.';
-            options.swcCliOptions.destPath = options.swcCliOptions.destPath
-                .split('../')
-                .at(-1)
-                .concat('/', options.swcCliOptions.srcPath);
+            options.swcCliOptions.srcPath = root.split('/').slice(0, -1).join('/'); // set to root of libraries to include other libs
+            options.swcCliOptions.destPath = (0, path_1.join)(_options.outputPath, options.swcCliOptions.srcPath); // new destPath is dist/{libs}/{parentLib}/{libs}
             // tmp swcrc with dependencies to exclude
             // - buildable libraries
             // - other libraries that are not dependent on the current project

package/src/executors/tsc/lib/batch/build-task-info-per-tsconfig-map.js

@@ -23,7 +23,7 @@ function processTasksAndPopulateTsConfigTaskInfoMap(tsConfigTaskInfoMap, tasksOp
         if (!tsConfig) {
             continue;
         }
-        let taskOptions = (_a = tasksOptions[taskName]) !== null && _a !== void 0 ? _a : (0, get_task_options_1.getTaskWithTscExecutorOptions)(taskName, context);
+        let taskOptions = (_a = tasksOptions[taskName]) !== null && _a !== void 0 ? _a : (0, get_task_options_1.getTaskOptions)(taskName, context);
         if (taskOptions) {
             const taskInfo = createTaskInfo(taskName, taskOptions, context, tsConfig);
             const tsConfigPath = (0, path_1.join)(context.root, (0, path_1.relative)(context.root, taskOptions.tsConfig)).replace(/\\/g, '/');

package/src/executors/tsc/lib/get-task-options.d.ts

@@ -1,8 +1,3 @@
 import type { ExecutorContext } from '@nx/devkit';
 import type { NormalizedExecutorOptions } from '../../../utils/schema';
-export declare function getTaskOptions(taskName: string, context: ExecutorContext): NormalizedExecutorOptions | {
-    tsConfig: string | null;
-    rootDir: string;
-    outputPath: string;
-};
-export declare function getTaskWithTscExecutorOptions(taskName: string, context: ExecutorContext): NormalizedExecutorOptions | null;
+export declare function getTaskOptions(taskName: string, context: ExecutorContext): NormalizedExecutorOptions | null;

package/src/executors/tsc/lib/get-task-options.js

@@ -1,28 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTaskWithTscExecutorOptions = exports.getTaskOptions = void 0;
-const devkit_1 = require("@nx/devkit");
-const path_1 = require("path");
+exports.getTaskOptions = void 0;
 const normalize_options_1 = require("./normalize-options");
-function getTaskOptions(taskName, context) {
-    const result = getTaskWithTscExecutorOptions(taskName, context);
-    if (result) {
-        return result;
-    }
-    const { taskOptions, root, projectNode, target } = parseTaskInfo(taskName, context);
-    const outputs = (0, devkit_1.getOutputsForTargetAndConfiguration)({ overrides: context.taskGraph.tasks[taskName].overrides, target }, projectNode);
-    const outputPath = outputs.length
-        ? (0, path_1.join)(context.root, outputs[0])
-        : (0, path_1.join)(context.root, 'dist', root);
-    const rootDir = (0, path_1.join)(context.root, root);
-    const tsConfig = taskOptions.tsConfig
-        ? (0, path_1.join)(context.root, taskOptions.tsConfig)
-        : null;
-    return { tsConfig, rootDir, outputPath };
-}
-exports.getTaskOptions = getTaskOptions;
 const tasksOptionsCache = new Map();
-function getTaskWithTscExecutorOptions(taskName, context) {
+function getTaskOptions(taskName, context) {
     if (tasksOptionsCache.has(taskName)) {
         return tasksOptionsCache.get(taskName);
     }
@@ -37,7 +18,7 @@ function getTaskWithTscExecutorOptions(taskName, context) {
         return null;
     }
 }
-exports.getTaskWithTscExecutorOptions = getTaskWithTscExecutorOptions;
+exports.getTaskOptions = getTaskOptions;
 function parseTaskInfo(taskName, context) {
     var _a, _b;
     const target = context.taskGraph.tasks[taskName].target;

package/src/executors/tsc/lib/get-tsconfig.d.ts

@@ -1,4 +1,4 @@
-import { ExecutorContext } from '@nx/devkit';
+import { type ExecutorContext } from '@nx/devkit';
 import type { NormalizedExecutorOptions } from '../../../utils/schema';
 import type { TypescriptInMemoryTsConfig } from './typescript-compilation';
 export declare function getProcessedTaskTsConfigs(tasks: string[], tasksOptions: Record<string, NormalizedExecutorOptions>, context: ExecutorContext): Record<string, TypescriptInMemoryTsConfig>;

package/src/executors/tsc/lib/get-tsconfig.js

@@ -2,112 +2,62 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProcessedTaskTsConfigs = void 0;
 const devkit_1 = require("@nx/devkit");
-const fileutils_1 = require("nx/src/utils/fileutils");
 const path_1 = require("path");
-const buildable_libs_utils_1 = require("../../../utils/buildable-libs-utils");
 const get_task_options_1 = require("./get-task-options");
 function getProcessedTaskTsConfigs(tasks, tasksOptions, context) {
     const taskInMemoryTsConfigMap = {};
     for (const task of tasks) {
-        generateTaskTsConfigOrGetDependentBuildableProjectNode(task, tasksOptions, context, taskInMemoryTsConfigMap);
+        generateTaskProjectTsConfig(task, tasksOptions, context, taskInMemoryTsConfigMap);
     }
     return taskInMemoryTsConfigMap;
 }
 exports.getProcessedTaskTsConfigs = getProcessedTaskTsConfigs;
-const taskTsConfigGenerationCache = new Map();
-function generateTaskTsConfigOrGetDependentBuildableProjectNode(task, tasksOptions, context, taskInMemoryTsConfigMap) {
-    var _a, _b, _c;
-    if (taskTsConfigGenerationCache.has(task)) {
-        return taskTsConfigGenerationCache.get(task);
-    }
-    let tsConfig = (_b = (_a = tasksOptions[task]) === null || _a === void 0 ? void 0 : _a.tsConfig) !== null && _b !== void 0 ? _b : (0, get_task_options_1.getTaskOptions)(task, context).tsConfig;
-    let taskWithTsConfig = task;
-    if (!tsConfig) {
-        // check if other tasks in the task graph from the same project has a tsConfig
-        const otherTasksInProject = getDependencyTasksInSameProject(task, context);
-        const taskTsConfig = findTaskWithTsConfig(otherTasksInProject, context);
-        if (taskTsConfig) {
-            if (taskTsConfigGenerationCache.has(taskTsConfig.tsConfig)) {
-                return taskTsConfigGenerationCache.get(taskTsConfig.tsConfig);
-            }
-            tsConfig = taskTsConfig.tsConfig;
-            taskWithTsConfig = taskTsConfig.task;
-        }
-    }
-    if (tsConfig) {
-        const { projectReferences, dependentBuildableProjectNodes } = collectDependenciesFromTask(task, tasksOptions, context, taskInMemoryTsConfigMap);
-        taskInMemoryTsConfigMap[taskWithTsConfig] = getInMemoryTsConfig(tsConfig, (_c = tasksOptions[taskWithTsConfig]) !== null && _c !== void 0 ? _c : (0, get_task_options_1.getTaskOptions)(taskWithTsConfig, context), projectReferences, dependentBuildableProjectNodes);
-        const result = { tsConfig };
-        taskTsConfigGenerationCache.set(task, result);
-        return result;
-    }
-    // there's no tsConfig, return a buildable project node so the path mapping
-    // is remapped to the output
-    const result = taskToDependentBuildableProjectNode(task, context);
-    taskTsConfigGenerationCache.set(task, result);
-    return result;
-}
-const projectDependenciesCache = new Map();
-function collectDependenciesFromTask(task, tasksOptions, context, taskInMemoryTsConfigMap) {
+const projectTsConfigCache = new Map();
+function generateTaskProjectTsConfig(task, tasksOptions, context, taskInMemoryTsConfigMap) {
     var _a;
-    const { project: taskProject } = (0, devkit_1.parseTargetString)(task, context.projectGraph);
-    if (projectDependenciesCache.has(taskProject)) {
-        return projectDependenciesCache.get(taskProject);
+    const { project } = (0, devkit_1.parseTargetString)(task, context.projectGraph);
+    if (projectTsConfigCache.has(project)) {
+        const { tsConfig, tsConfigPath } = projectTsConfigCache.get(project);
+        taskInMemoryTsConfigMap[task] = tsConfig;
+        return tsConfigPath;
     }
-    const dependentBuildableProjectNodes = [];
-    const projectReferences = new Set();
-    const allProjectTasks = [
+    const tasksInProject = [
         task,
         ...getDependencyTasksInSameProject(task, context),
     ];
-    for (const projectTask of allProjectTasks) {
-        for (const depTask of (_a = context.taskGraph.dependencies[projectTask]) !== null && _a !== void 0 ? _a : []) {
-            if (task === depTask) {
-                continue;
-            }
-            const { project: depTaskProject } = (0, devkit_1.parseTargetString)(depTask, context.projectGraph);
-            if (depTaskProject === taskProject) {
-                // recursively collect dependencies for tasks in the same project
-                const result = collectDependenciesFromTask(depTask, tasksOptions, context, taskInMemoryTsConfigMap);
-                result.projectReferences.forEach((pr) => {
-                    projectReferences.add(pr);
-                });
-                result.dependentBuildableProjectNodes.forEach((node) => {
-                    dependentBuildableProjectNodes.push(node);
-                });
-            }
-            else {
-                // task is from a different project, get its project reference or buildable node
-                const result = generateTaskTsConfigOrGetDependentBuildableProjectNode(depTask, tasksOptions, context, taskInMemoryTsConfigMap);
-                if ('tsConfig' in result) {
-                    projectReferences.add(result.tsConfig);
-                }
-                else {
-                    dependentBuildableProjectNodes.push(result);
-                }
-            }
+    const taskWithTscExecutor = tasksInProject.find((t) => hasTscExecutor(t, context));
+    if (!taskWithTscExecutor) {
+        throw new Error((0, devkit_1.stripIndents) `The "@nx/js:tsc" batch executor requires all dependencies to use the "@nx/js:tsc" executor.
+        None of the following tasks in the "${project}" project use the "@nx/js:tsc" executor:
+        ${tasksInProject.map((t) => `- ${t}`).join('\n')}`);
+    }
+    const projectReferences = [];
+    for (const task of tasksInProject) {
+        for (const depTask of getDependencyTasksInOtherProjects(task, project, context)) {
+            const tsConfigPath = generateTaskProjectTsConfig(depTask, tasksOptions, context, taskInMemoryTsConfigMap);
+            projectReferences.push(tsConfigPath);
         }
     }
-    projectDependenciesCache.set(taskProject, {
-        projectReferences: Array.from(projectReferences),
-        dependentBuildableProjectNodes,
+    const taskOptions = (_a = tasksOptions[taskWithTscExecutor]) !== null && _a !== void 0 ? _a : (0, get_task_options_1.getTaskOptions)(taskWithTscExecutor, context);
+    const tsConfigPath = taskOptions.tsConfig;
+    taskInMemoryTsConfigMap[taskWithTscExecutor] = getInMemoryTsConfig(tsConfigPath, taskOptions, projectReferences);
+    projectTsConfigCache.set(project, {
+        tsConfigPath: tsConfigPath,
+        tsConfig: taskInMemoryTsConfigMap[taskWithTscExecutor],
     });
-    return projectDependenciesCache.get(taskProject);
+    return tsConfigPath;
 }
-function taskToDependentBuildableProjectNode(task, context) {
-    const target = context.taskGraph.tasks[task].target;
-    const projectGraphNode = context.projectGraph.nodes[target.project];
-    const libPackageJsonPath = (0, path_1.join)(context.root, projectGraphNode.data.root, 'package.json');
-    return {
-        name: (0, fileutils_1.fileExists)(libPackageJsonPath)
-            ? (0, devkit_1.readJsonFile)(libPackageJsonPath).name
-            : target.project,
-        outputs: (0, devkit_1.getOutputsForTargetAndConfiguration)({ overrides: {}, target }, projectGraphNode),
-        node: projectGraphNode,
-    };
+function getDependencyTasksInOtherProjects(task, project, context) {
+    return context.taskGraph.dependencies[task].filter((t) => t !== task &&
+        (0, devkit_1.parseTargetString)(t, context.projectGraph).project !== project);
 }
-function getInMemoryTsConfig(tsConfig, taskOptions, projectReferences, dependentBuildableProjectNodes) {
-    var _a, _b;
+function getDependencyTasksInSameProject(task, context) {
+    const { project: taskProject } = (0, devkit_1.parseTargetString)(task, context.projectGraph);
+    return Object.keys(context.taskGraph.tasks).filter((t) => t !== task &&
+        (0, devkit_1.parseTargetString)(t, context.projectGraph).project === taskProject);
+}
+function getInMemoryTsConfig(tsConfig, taskOptions, projectReferences) {
+    var _a;
     const originalTsConfig = (0, devkit_1.readJsonFile)(tsConfig, {
         allowTrailingComma: true,
         disallowComments: false,
@@ -116,23 +66,12 @@ function getInMemoryTsConfig(tsConfig, taskOptions, projectReferences, dependent
         .map((r) => r.path)
         .concat(projectReferences)));
     return {
-        content: JSON.stringify(Object.assign(Object.assign({}, originalTsConfig), { compilerOptions: Object.assign(Object.assign({}, originalTsConfig.compilerOptions), { rootDir: taskOptions.rootDir, outDir: taskOptions.outputPath, composite: true, declaration: true, declarationMap: true, tsBuildInfoFile: (0, path_1.join)(taskOptions.outputPath, 'tsconfig.tsbuildinfo'), paths: dependentBuildableProjectNodes.length
-                    ? (0, buildable_libs_utils_1.computeCompilerOptionsPaths)(tsConfig, dependentBuildableProjectNodes)
-                    : (_b = originalTsConfig.compilerOptions) === null || _b === void 0 ? void 0 : _b.paths }), references: allProjectReferences.map((pr) => ({ path: pr })) })),
+        content: JSON.stringify(Object.assign(Object.assign({}, originalTsConfig), { compilerOptions: Object.assign(Object.assign({}, originalTsConfig.compilerOptions), { rootDir: taskOptions.rootDir, outDir: taskOptions.outputPath, composite: true, declaration: true, declarationMap: true, tsBuildInfoFile: (0, path_1.join)(taskOptions.outputPath, 'tsconfig.tsbuildinfo') }), references: allProjectReferences.map((pr) => ({ path: pr })) })),
         path: tsConfig.replace(/\\/g, '/'),
     };
 }
-function findTaskWithTsConfig(tasks, context) {
-    for (const task of tasks) {
-        const depTaskOptions = (0, get_task_options_1.getTaskOptions)(task, context);
-        if (depTaskOptions === null || depTaskOptions === void 0 ? void 0 : depTaskOptions.tsConfig) {
-            return { task: task, tsConfig: depTaskOptions.tsConfig };
-        }
-    }
-    return null;
-}
-function getDependencyTasksInSameProject(task, context) {
-    const { project: taskProject } = (0, devkit_1.parseTargetString)(task, context.projectGraph);
-    return Object.keys(context.taskGraph.tasks).filter((t) => t !== task &&
-        (0, devkit_1.parseTargetString)(t, context.projectGraph).project === taskProject);
+function hasTscExecutor(task, context) {
+    const { project, target } = (0, devkit_1.parseTargetString)(task, context.projectGraph);
+    return (context.projectGraph.nodes[project].data.targets[target].executor ===
+        '@nx/js:tsc');
 }

package/src/generators/library/library.js

@@ -151,7 +151,7 @@ function addProject(tree, options, destinationDir) {
 function addLint(tree, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         const { lintProjectGenerator } = (0, devkit_1.ensurePackage)('@nx/linter', versions_1.nxVersion);
-        return lintProjectGenerator(tree, {
+        const task = lintProjectGenerator(tree, {
             project: options.name,
             linter: options.linter,
             skipFormat: true,
@@ -165,6 +165,23 @@ function addLint(tree, options) {
             setParserOptionsProject: options.setParserOptionsProject,
             rootProject: options.rootProject,
         });
+        // Also update the root .eslintrc.json lintProjectGenerator will not generate it for root projects.
+        // But we need to set the package.json checks.
+        if (options.rootProject) {
+            (0, devkit_1.updateJson)(tree, '.eslintrc.json', (json) => {
+                var _a;
+                (_a = json.overrides) !== null && _a !== void 0 ? _a : (json.overrides = []);
+                json.overrides.push({
+                    files: ['*.json'],
+                    parser: 'jsonc-eslint-parser',
+                    rules: {
+                        '@nx/dependency-checks': 'error',
+                    },
+                });
+                return json;
+            });
+        }
+        return task;
     });
 }
 exports.addLint = addLint;
@@ -219,8 +236,8 @@ function createFiles(tree, options, filesDir) {
         (0, devkit_1.updateJson)(tree, packageJsonPath, (json) => {
             json.name = options.importPath;
             json.version = '0.0.1';
-            // If the package is publishable, we should remove the private field.
-            if (json.private && options.publishable) {
+            // If the package is publishable or root/standalone, we should remove the private field.
+            if (json.private && (options.publishable || options.rootProject)) {
                 delete json.private;
             }
             return Object.assign(Object.assign(Object.assign({}, json), { dependencies: Object.assign(Object.assign({}, json.dependencies), determineDependencies(options)) }), determineEntryFields(options));

package/src/plugins/rollup/type-definitions.d.ts

@@ -0,0 +1,8 @@
+import type { OutputBundle } from 'rollup';
+export declare function typeDefinitions(options: {
+    projectRoot: string;
+    main: string;
+}): {
+    name: string;
+    generateBundle(_opts: unknown, bundle: OutputBundle): Promise<void>;
+};

package/src/plugins/rollup/type-definitions.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeDefinitions = void 0;
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const devkit_1 = require("@nx/devkit");
+//NOTE: This is here so we can share between `@nx/rollup` and `@nx/vite`.
+/*
+ * This plugin takes all entry-points from the generated bundle and creates a
+ * bundled version of corresponding d.ts files.
+ *
+ * For example, `src/index.ts` generates two corresponding files:
+ * - `dist/xyz/index.js`
+ * - `dist/xyz/src/index.d.ts`
+ *
+ * We want a third file: `dist/index.d.ts` that re-exports from `src/index.d.ts`.
+ * That way, when TSC or IDEs look for types, it will find them in the right place.
+ */
+function typeDefinitions(options) {
+    return {
+        name: 'dts-bundle',
+        generateBundle(_opts, bundle) {
+            return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                for (const [name, file] of Object.entries(bundle)) {
+                    if (file.type === 'asset' ||
+                        !file.isEntry ||
+                        file.facadeModuleId == null) {
+                        continue;
+                    }
+                    const hasDefaultExport = file.exports.includes('default');
+                    const entrySourceFileName = (0, path_1.relative)(options.projectRoot, file.facadeModuleId);
+                    const entrySourceDtsName = entrySourceFileName.replace(/\.[cm]?[jt]sx?$/, '');
+                    const dtsFileName = file.fileName.replace(/\.[cm]?js$/, '.d.ts');
+                    const relativeSourceDtsName = JSON.stringify('./' + entrySourceDtsName);
+                    const dtsFileSource = hasDefaultExport
+                        ? (0, devkit_1.stripIndents) `
+              export * from ${relativeSourceDtsName};
+              export { default } from ${relativeSourceDtsName};
+            `
+                        : `export * from ${relativeSourceDtsName};\n`;
+                    this.emitFile({
+                        type: 'asset',
+                        fileName: dtsFileName,
+                        source: dtsFileSource,
+                    });
+                }
+            });
+        },
+    };
+}
+exports.typeDefinitions = typeDefinitions;

package/src/utils/swc/compile-swc.js

@@ -9,7 +9,8 @@ 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");
 function getSwcCmd({ swcrcPath, srcPath, destPath }, watch = false) {
-    let swcCmd = `npx swc ${
+    const packageManager = (0, devkit_1.getPackageManagerCommand)();
+    let swcCmd = `${packageManager.exec} swc ${
     // TODO(jack): clean this up when we remove inline module support
     // Handle root project
     srcPath === '.' ? 'src' : srcPath} -d ${destPath} --config-file=${swcrcPath}`;
@@ -32,14 +33,13 @@ function getTypeCheckOptions(normalizedOptions) {
 }
 function compileSwc(context, normalizedOptions, postCompilationCallback) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const isRootProject = context.projectGraph.nodes[context.projectName].data.root === '.';
         devkit_1.logger.log(`Compiling with SWC for ${context.projectName}...`);
         if (normalizedOptions.clean) {
             (0, fs_extra_1.removeSync)(normalizedOptions.outputPath);
         }
         const swcCmdLog = (0, child_process_1.execSync)(getSwcCmd(normalizedOptions.swcCliOptions), {
-            cwd: normalizedOptions.swcCliOptions.swcCwd,
-        }).toString();
+            encoding: 'utf8',
+        });
         devkit_1.logger.log(swcCmdLog.replace(/\n/, ''));
         const isCompileSuccess = swcCmdLog.includes('Successfully compiled');
         if (normalizedOptions.skipTypeCheck) {