@nx/js 16.4.0-beta.1 → 16.4.0-beta.10

package/src/executors/tsc/lib/batch/typescript-diagnostic-reporters.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatWatchStatusReport = exports.formatSolutionBuilderStatusReport = exports.formatDiagnosticReport = void 0;
+const ts = require("typescript");
+// adapted from TS default diagnostic reporter
+function formatDiagnosticReport(diagnostic, host) {
+    const diagnostics = new Array(1);
+    diagnostics[0] = diagnostic;
+    const formattedDiagnostic = '\n' +
+        ts.formatDiagnosticsWithColorAndContext(diagnostics, host) +
+        host.getNewLine();
+    diagnostics[0] = undefined;
+    return formattedDiagnostic;
+}
+exports.formatDiagnosticReport = formatDiagnosticReport;
+// adapted from TS default solution builder status reporter
+function formatSolutionBuilderStatusReport(diagnostic) {
+    let formattedDiagnostic = `[${formatColorAndReset(getLocaleTimeString(), ForegroundColorEscapeSequences.Grey)}] `;
+    formattedDiagnostic += `${ts.flattenDiagnosticMessageText(diagnostic.messageText, ts.sys.newLine)}${ts.sys.newLine + ts.sys.newLine}`;
+    return formattedDiagnostic;
+}
+exports.formatSolutionBuilderStatusReport = formatSolutionBuilderStatusReport;
+// adapted from TS default watch status reporter
+function formatWatchStatusReport(diagnostic, newLine) {
+    let output = `[${formatColorAndReset(getLocaleTimeString(), ForegroundColorEscapeSequences.Grey)}] `;
+    output += `${ts.flattenDiagnosticMessageText(diagnostic.messageText, ts.sys.newLine)}${newLine + newLine}`;
+    return output;
+}
+exports.formatWatchStatusReport = formatWatchStatusReport;
+function formatColorAndReset(text, formatStyle) {
+    const resetEscapeSequence = '\u001b[0m';
+    return formatStyle + text + resetEscapeSequence;
+}
+function getLocaleTimeString() {
+    return new Date().toLocaleTimeString();
+}
+var ForegroundColorEscapeSequences;
+(function (ForegroundColorEscapeSequences) {
+    ForegroundColorEscapeSequences["Grey"] = "\u001B[90m";
+    ForegroundColorEscapeSequences["Red"] = "\u001B[91m";
+    ForegroundColorEscapeSequences["Yellow"] = "\u001B[93m";
+    ForegroundColorEscapeSequences["Blue"] = "\u001B[94m";
+    ForegroundColorEscapeSequences["Cyan"] = "\u001B[96m";
+})(ForegroundColorEscapeSequences || (ForegroundColorEscapeSequences = {}));

package/src/executors/tsc/lib/batch/watch.d.ts

@@ -0,0 +1,3 @@
+import type { TaskInfo } from './types';
+export declare function watchTaskProjectsPackageJsonFileChanges(taskInfos: TaskInfo[], callback: (changedTaskInfos: TaskInfo[]) => void): Promise<() => void>;
+export declare function watchTaskProjectsFileChangesForAssets(taskInfos: TaskInfo[]): Promise<() => void>;

package/src/executors/tsc/lib/batch/watch.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchTaskProjectsFileChangesForAssets = exports.watchTaskProjectsPackageJsonFileChanges = void 0;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const client_1 = require("nx/src/daemon/client/client");
+const path_1 = require("path");
+function watchTaskProjectsPackageJsonFileChanges(taskInfos, callback) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const projects = [];
+        const packageJsonTaskInfoMap = new Map();
+        taskInfos.forEach((t) => {
+            projects.push(t.context.projectName);
+            packageJsonTaskInfoMap.set((0, path_1.join)(t.options.projectRoot, 'package.json'), t);
+        });
+        const unregisterFileWatcher = yield client_1.daemonClient.registerFileWatcher({ watchProjects: projects }, (err, data) => {
+            var _a;
+            if (err === 'closed') {
+                devkit_1.logger.error(`Watch error: Daemon closed the connection`);
+                process.exit(1);
+            }
+            else if (err) {
+                devkit_1.logger.error(`Watch error: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : 'Unknown'}`);
+            }
+            else {
+                const changedTasks = [];
+                data.changedFiles.forEach((file) => {
+                    if (packageJsonTaskInfoMap.has(file.path)) {
+                        changedTasks.push(packageJsonTaskInfoMap.get(file.path));
+                    }
+                });
+                if (changedTasks.length) {
+                    callback(changedTasks);
+                }
+            }
+        });
+        return () => unregisterFileWatcher();
+    });
+}
+exports.watchTaskProjectsPackageJsonFileChanges = watchTaskProjectsPackageJsonFileChanges;
+function watchTaskProjectsFileChangesForAssets(taskInfos) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const unregisterFileWatcher = yield client_1.daemonClient.registerFileWatcher({
+            watchProjects: taskInfos.map((t) => t.context.projectName),
+            includeDependentProjects: true,
+            includeGlobalWorkspaceFiles: true,
+        }, (err, data) => {
+            var _a;
+            if (err === 'closed') {
+                devkit_1.logger.error(`Watch error: Daemon closed the connection`);
+                process.exit(1);
+            }
+            else if (err) {
+                devkit_1.logger.error(`Watch error: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : 'Unknown'}`);
+            }
+            else {
+                taskInfos.forEach((t) => t.assetsHandler.processWatchEvents(data.changedFiles));
+            }
+        });
+        return () => unregisterFileWatcher();
+    });
+}
+exports.watchTaskProjectsFileChangesForAssets = watchTaskProjectsFileChangesForAssets;

package/src/executors/tsc/lib/get-custom-transformers-factory.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import type { TransformerEntry } from '../../../utils/typescript/types';
+export declare function getCustomTrasformersFactory(transformers: TransformerEntry[]): (program: ts.Program) => ts.CustomTransformers;

package/src/executors/tsc/lib/get-custom-transformers-factory.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCustomTrasformersFactory = void 0;
+const load_ts_transformers_1 = require("../../../utils/typescript/load-ts-transformers");
+function getCustomTrasformersFactory(transformers) {
+    const { compilerPluginHooks } = (0, load_ts_transformers_1.loadTsTransformers)(transformers);
+    return (program) => ({
+        before: compilerPluginHooks.beforeHooks.map((hook) => hook(program)),
+        after: compilerPluginHooks.afterHooks.map((hook) => hook(program)),
+        afterDeclarations: compilerPluginHooks.afterDeclarationsHooks.map((hook) => hook(program)),
+    });
+}
+exports.getCustomTrasformersFactory = getCustomTrasformersFactory;

package/src/executors/tsc/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get-custom-transformers-factory';
+export * from './normalize-options';

package/src/executors/tsc/lib/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./get-custom-transformers-factory"), exports);
+tslib_1.__exportStar(require("./normalize-options"), exports);

package/src/executors/tsc/lib/normalize-options.d.ts

@@ -0,0 +1,2 @@
+import type { ExecutorOptions, NormalizedExecutorOptions } from '../../../utils/schema';
+export declare function normalizeOptions(options: ExecutorOptions, contextRoot: string, sourceRoot: string, projectRoot: string): NormalizedExecutorOptions;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const path_1 = require("path");
+const assets_1 = require("../../../utils/assets/assets");
+function normalizeOptions(options, contextRoot, sourceRoot, projectRoot) {
+    const outputPath = (0, path_1.join)(contextRoot, options.outputPath);
+    const rootDir = options.rootDir
+        ? (0, path_1.join)(contextRoot, options.rootDir)
+        : (0, path_1.join)(contextRoot, projectRoot);
+    if (options.watch == null) {
+        options.watch = false;
+    }
+    // TODO: put back when inlining story is more stable
+    // if (options.external == null) {
+    //   options.external = 'all';
+    // } else if (Array.isArray(options.external) && options.external.length === 0) {
+    //   options.external = 'none';
+    // }
+    if (Array.isArray(options.external) && options.external.length > 0) {
+        const firstItem = options.external[0];
+        if (firstItem === 'all' || firstItem === 'none') {
+            options.external = firstItem;
+        }
+    }
+    const files = (0, assets_1.assetGlobsToFiles)(options.assets, contextRoot, outputPath);
+    return Object.assign(Object.assign({}, options), { root: contextRoot, sourceRoot,
+        projectRoot,
+        files,
+        outputPath, tsConfig: (0, path_1.join)(contextRoot, options.tsConfig), rootDir, mainOutputPath: (0, path_1.resolve)(outputPath, options.main.replace(`${projectRoot}/`, '').replace('.ts', '.js')) });
+}
+exports.normalizeOptions = normalizeOptions;

package/src/executors/tsc/tsc.batch-impl.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutorContext, TaskGraph } from '@nx/devkit';
+import type { ExecutorOptions } from '../../utils/schema';
+export declare function tscBatchExecutor(taskGraph: TaskGraph, inputs: Record<string, ExecutorOptions>, overrides: ExecutorOptions, context: ExecutorContext): AsyncGenerator<import("../../../../../build/packages/nx/src/tasks-runner/batch/batch-messages").BatchResults, any, undefined>;
+export default tscBatchExecutor;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tscBatchExecutor = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const update_package_json_1 = require("../../utils/package-json/update-package-json");
+const batch_1 = require("./lib/batch");
+function tscBatchExecutor(taskGraph, inputs, overrides, context) {
+    return tslib_1.__asyncGenerator(this, arguments, function* tscBatchExecutor_1() {
+        const tasksOptions = (0, batch_1.normalizeTasksOptions)(inputs, context);
+        let shouldWatch = false;
+        Object.values(tasksOptions).forEach((taskOptions) => {
+            if (taskOptions.clean) {
+                (0, fs_1.rmSync)(taskOptions.outputPath, { force: true, recursive: true });
+            }
+            if (taskOptions.watch) {
+                shouldWatch = true;
+            }
+        });
+        const tsConfigTaskInfoMap = {};
+        (0, batch_1.buildTaskInfoPerTsConfigMap)(tsConfigTaskInfoMap, tasksOptions, context, Object.keys(taskGraph.tasks), shouldWatch);
+        const typescriptCompilation = (0, batch_1.compileBatchTypescript)(tsConfigTaskInfoMap, taskGraph, shouldWatch, (taskInfo) => {
+            taskInfo.assetsHandler.processAllAssetsOnceSync();
+            (0, update_package_json_1.updatePackageJson)(taskInfo.options, taskInfo.context, taskInfo.projectGraphNode, taskInfo.buildableProjectNodeDependencies);
+        });
+        if (shouldWatch) {
+            const taskInfos = Object.values(tsConfigTaskInfoMap);
+            const watchAssetsChangesDisposer = yield tslib_1.__await((0, batch_1.watchTaskProjectsFileChangesForAssets)(taskInfos));
+            const watchProjectsChangesDisposer = yield tslib_1.__await((0, batch_1.watchTaskProjectsPackageJsonFileChanges)(taskInfos, (changedTaskInfos) => {
+                for (const t of changedTaskInfos) {
+                    (0, update_package_json_1.updatePackageJson)(t.options, t.context, t.projectGraphNode, t.buildableProjectNodeDependencies);
+                }
+            }));
+            const handleTermination = (exitCode) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                yield typescriptCompilation.close();
+                watchAssetsChangesDisposer();
+                watchProjectsChangesDisposer();
+                process.exit(exitCode);
+            });
+            process.on('SIGINT', () => handleTermination(128 + 2));
+            process.on('SIGTERM', () => handleTermination(128 + 15));
+        }
+        return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues(typescriptCompilation.iterator))));
+    });
+}
+exports.tscBatchExecutor = tscBatchExecutor;
+exports.default = tscBatchExecutor;

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

@@ -1,7 +1,6 @@
 import { ExecutorContext } from '@nx/devkit';
 import type { TypeScriptCompilationOptions } from '@nx/workspace/src/utilities/typescript/compilation';
 import { ExecutorOptions, NormalizedExecutorOptions } from '../../utils/schema';
-export declare function normalizeOptions(options: ExecutorOptions, contextRoot: string, sourceRoot: string, projectRoot: string): NormalizedExecutorOptions;
 export declare function createTypeScriptCompilationOptions(normalizedOptions: NormalizedExecutorOptions, context: ExecutorContext): TypeScriptCompilationOptions;
 export declare function tscExecutor(_options: ExecutorOptions, context: ExecutorContext): AsyncGenerator<import("../../utils/typescript/compile-typescript-files").TypescriptCompilationResult, any, undefined>;
 export default tscExecutor;

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

@@ -1,51 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tscExecutor = exports.createTypeScriptCompilationOptions = exports.normalizeOptions = void 0;
+exports.tscExecutor = exports.createTypeScriptCompilationOptions = void 0;
 const tslib_1 = require("tslib");
-const assets_1 = require("../../utils/assets/assets");
-const path_1 = require("path");
 const copy_assets_handler_1 = require("../../utils/assets/copy-assets-handler");
 const check_dependencies_1 = require("../../utils/check-dependencies");
 const compiler_helper_dependency_1 = require("../../utils/compiler-helper-dependency");
 const inline_1 = require("../../utils/inline");
 const update_package_json_1 = require("../../utils/package-json/update-package-json");
 const compile_typescript_files_1 = require("../../utils/typescript/compile-typescript-files");
-const load_ts_transformers_1 = require("../../utils/typescript/load-ts-transformers");
 const watch_for_single_file_changes_1 = require("../../utils/watch-for-single-file-changes");
-function normalizeOptions(options, contextRoot, sourceRoot, projectRoot) {
-    const outputPath = (0, path_1.join)(contextRoot, options.outputPath);
-    const rootDir = options.rootDir
-        ? (0, path_1.join)(contextRoot, options.rootDir)
-        : projectRoot;
-    if (options.watch == null) {
-        options.watch = false;
-    }
-    // TODO: put back when inlining story is more stable
-    // if (options.external == null) {
-    //   options.external = 'all';
-    // } else if (Array.isArray(options.external) && options.external.length === 0) {
-    //   options.external = 'none';
-    // }
-    if (Array.isArray(options.external) && options.external.length > 0) {
-        const firstItem = options.external[0];
-        if (firstItem === 'all' || firstItem === 'none') {
-            options.external = firstItem;
-        }
-    }
-    const files = (0, assets_1.assetGlobsToFiles)(options.assets, contextRoot, outputPath);
-    return Object.assign(Object.assign({}, options), { root: contextRoot, sourceRoot,
-        projectRoot,
-        files,
-        outputPath, tsConfig: (0, path_1.join)(contextRoot, options.tsConfig), rootDir, mainOutputPath: (0, path_1.resolve)(outputPath, options.main.replace(`${projectRoot}/`, '').replace('.ts', '.js')) });
-}
-exports.normalizeOptions = normalizeOptions;
+const lib_1 = require("./lib");
 function createTypeScriptCompilationOptions(normalizedOptions, context) {
-    const { compilerPluginHooks } = (0, load_ts_transformers_1.loadTsTransformers)(normalizedOptions.transformers);
-    const getCustomTransformers = (program) => ({
-        before: compilerPluginHooks.beforeHooks.map((hook) => hook(program)),
-        after: compilerPluginHooks.afterHooks.map((hook) => hook(program)),
-        afterDeclarations: compilerPluginHooks.afterDeclarationsHooks.map((hook) => hook(program)),
-    });
     return {
         outputPath: normalizedOptions.outputPath,
         projectName: context.projectName,
@@ -54,14 +19,14 @@ function createTypeScriptCompilationOptions(normalizedOptions, context) {
         tsConfig: normalizedOptions.tsConfig,
         watch: normalizedOptions.watch,
         deleteOutputPath: normalizedOptions.clean,
-        getCustomTransformers,
+        getCustomTransformers: (0, lib_1.getCustomTrasformersFactory)(normalizedOptions.transformers),
     };
 }
 exports.createTypeScriptCompilationOptions = createTypeScriptCompilationOptions;
 function tscExecutor(_options, context) {
     return tslib_1.__asyncGenerator(this, arguments, function* tscExecutor_1() {
         const { sourceRoot, root } = context.projectsConfigurations.projects[context.projectName];
-        const options = normalizeOptions(_options, context.root, sourceRoot, root);
+        const options = (0, lib_1.normalizeOptions)(_options, context.root, sourceRoot, root);
         const { projectRoot, tmpTsConfig, target, dependencies } = (0, check_dependencies_1.checkDependencies)(context, _options.tsConfig);
         if (tmpTsConfig) {
             options.tsConfig = tmpTsConfig;

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

@@ -7,5 +7,6 @@ import { VerdaccioExecutorSchema } from './schema';
  */
 export declare function verdaccioExecutor(options: VerdaccioExecutorSchema, context: ExecutorContext): Promise<{
     success: boolean;
+    port: number;
 }>;
 export default verdaccioExecutor;

package/src/executors/verdaccio/verdaccio.impl.js

@@ -5,6 +5,8 @@ const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const fs_extra_1 = require("fs-extra");
 const child_process_1 = require("child_process");
+const detectPort = require("detect-port");
+const path_1 = require("path");
 let childProcess;
 /**
  * - set npm and yarn to use local registry
@@ -19,8 +21,12 @@ function verdaccioExecutor(options, context) {
         catch (e) {
             throw new Error('Verdaccio is not installed. Please run `npm install verdaccio` or `yarn add verdaccio`');
         }
-        if (options.clear && options.storage && (0, fs_extra_1.existsSync)(options.storage)) {
-            (0, fs_extra_1.removeSync)(options.storage);
+        if (options.storage) {
+            options.storage = (0, path_1.resolve)(context.root, options.storage);
+            if (options.clear && (0, fs_extra_1.existsSync)(options.storage)) {
+                (0, fs_extra_1.rmSync)(options.storage, { recursive: true, force: true });
+                console.log(`Cleared local registry storage folder ${options.storage}`);
+            }
         }
         const cleanupFunctions = options.location === 'none' ? [] : [setupNpm(options), setupYarn(options)];
         const processExitListener = (signal) => {
@@ -36,16 +42,23 @@ function verdaccioExecutor(options, context) {
         process.on('SIGINT', processExitListener);
         process.on('SIGHUP', processExitListener);
         try {
-            yield startVerdaccio(options);
+            const port = yield detectPort(options.port);
+            if (port !== options.port) {
+                devkit_1.logger.info(`Port ${options.port} was occupied. Using port ${port}.`);
+                options.port = port;
+            }
+            yield startVerdaccio(options, context.root);
         }
         catch (e) {
-            devkit_1.logger.error('Failed to start verdaccio: ' + e.toString());
+            devkit_1.logger.error('Failed to start verdaccio: ' + (e === null || e === void 0 ? void 0 : e.toString()));
             return {
                 success: false,
+                port: options.port,
             };
         }
         return {
             success: true,
+            port: options.port,
         };
     });
 }
@@ -53,23 +66,13 @@ exports.verdaccioExecutor = verdaccioExecutor;
 /**
  * Fork the verdaccio process: https://verdaccio.org/docs/verdaccio-programmatically/#using-fork-from-child_process-module
  */
-function startVerdaccio(options) {
+function startVerdaccio(options, workspaceRoot) {
     return new Promise((resolve, reject) => {
-        childProcess = (0, child_process_1.fork)(require.resolve('verdaccio/bin/verdaccio'), createVerdaccioOptions(options), {
-            env: Object.assign(Object.assign({}, process.env), { VERDACCIO_HANDLE_KILL_SIGNALS: 'true' }),
-            stdio: ['inherit', 'pipe', 'pipe', 'ipc'],
-        });
-        childProcess.stdout.on('data', (data) => {
-            process.stdout.write(data);
-        });
-        childProcess.stderr.on('data', (data) => {
-            if (data.includes('VerdaccioWarning') ||
-                data.includes('DeprecationWarning')) {
-                process.stdout.write(data);
-            }
-            else {
-                reject(data);
-            }
+        childProcess = (0, child_process_1.fork)(require.resolve('verdaccio/bin/verdaccio'), createVerdaccioOptions(options, workspaceRoot), {
+            env: Object.assign(Object.assign(Object.assign({}, process.env), { VERDACCIO_HANDLE_KILL_SIGNALS: 'true' }), (options.storage
+                ? { VERDACCIO_STORAGE_PATH: options.storage }
+                : {})),
+            stdio: 'inherit',
         });
         childProcess.on('error', (err) => {
             reject(err);
@@ -87,13 +90,13 @@ function startVerdaccio(options) {
         });
     });
 }
-function createVerdaccioOptions(options) {
+function createVerdaccioOptions(options, workspaceRoot) {
     const verdaccioArgs = [];
     if (options.port) {
         verdaccioArgs.push('--listen', options.port.toString());
     }
     if (options.config) {
-        verdaccioArgs.push('--config', options.config);
+        verdaccioArgs.push('--config', (0, path_1.join)(workspaceRoot, options.config));
     }
     return verdaccioArgs;
 }

package/src/generators/library/library.js

@@ -44,12 +44,10 @@ function projectGenerator(tree, schema, destinationDir, filesDir) {
                 includeVitest: options.unitTestRunner === 'vitest',
                 includeLib: true,
                 skipFormat: true,
+                testEnvironment: options.testEnvironment,
             });
             tasks.push(viteTask);
         }
-        if (options.bundler === 'rollup') {
-            ensureBabelRootConfigExists(tree);
-        }
         if (options.linter !== 'none') {
             const lintCallback = yield addLint(tree, options);
             tasks.push(lintCallback);
@@ -70,6 +68,7 @@ function projectGenerator(tree, schema, destinationDir, filesDir) {
                 uiFramework: 'none',
                 coverageProvider: 'c8',
                 skipFormat: true,
+                testEnvironment: options.testEnvironment,
             });
             tasks.push(vitestTask);
         }
@@ -384,13 +383,6 @@ function getBuildExecutor(bundler) {
             return undefined;
     }
 }
-function ensureBabelRootConfigExists(tree) {
-    if (tree.exists('babel.config.json'))
-        return;
-    (0, devkit_1.writeJson)(tree, 'babel.config.json', {
-        babelrcRoots: ['*'],
-    });
-}
 function getOutputPath(options, destinationDir) {
     const parts = ['dist'];
     if (destinationDir) {

package/src/generators/library/schema.json

@@ -56,12 +56,8 @@
     "testEnvironment": {
       "type": "string",
       "enum": ["jsdom", "node"],
-      "description": "The test environment to use if unitTestRunner is set to jest.",
-      "default": "jsdom"
-    },
-    "importPath": {
-      "type": "string",
-      "description": "The library name used to import it, like @myorg/my-awesome-lib."
+      "description": "The test environment to use if unitTestRunner is set to jest or vitest.",
+      "default": "node"
     },
     "pascalCaseFiles": {
       "type": "boolean",
@@ -85,6 +81,11 @@
       "description": "Generate a publishable library.",
       "x-priority": "important"
     },
+    "importPath": {
+      "type": "string",
+      "description": "The library name used to import it, like @myorg/my-awesome-lib. Required for publishable library.",
+      "x-priority": "important"
+    },
     "buildable": {
       "type": "boolean",
       "default": true,

package/src/generators/setup-build/generator.d.ts

@@ -0,0 +1,5 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import { SetupBuildGeneratorSchema } from './schema';
+export declare function setupBuildGenerator(tree: Tree, options: SetupBuildGeneratorSchema): Promise<GeneratorCallback>;
+export default setupBuildGenerator;
+export declare const setupBuildSchematic: (generatorOptions: SetupBuildGeneratorSchema) => (tree: any, context: any) => Promise<any>;

package/src/generators/setup-build/generator.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupBuildSchematic = exports.setupBuildGenerator = void 0;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const add_swc_config_1 = require("../../utils/swc/add-swc-config");
+const add_swc_dependencies_1 = require("../../utils/swc/add-swc-dependencies");
+const versions_1 = require("../../utils/versions");
+function setupBuildGenerator(tree, options) {
+    var _a, _b, _c;
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const tasks = [];
+        const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+        const buildTarget = (_a = options.buildTarget) !== null && _a !== void 0 ? _a : 'build';
+        (_b = project.targets) !== null && _b !== void 0 ? _b : (project.targets = {});
+        let mainFile;
+        if (options.main) {
+            mainFile = options.main;
+        }
+        else {
+            const root = (_c = project.sourceRoot) !== null && _c !== void 0 ? _c : project.root;
+            for (const f of [
+                (0, devkit_1.joinPathFragments)(root, 'main.ts'),
+                (0, devkit_1.joinPathFragments)(root, 'main.js'),
+                (0, devkit_1.joinPathFragments)(root, 'index.ts'),
+                (0, devkit_1.joinPathFragments)(root, 'index.js'),
+            ]) {
+                if (tree.exists(f)) {
+                    mainFile = f;
+                    break;
+                }
+            }
+        }
+        if (!mainFile || !tree.exists(mainFile)) {
+            throw new Error(`Cannot locate a main file for ${options.project}. Please specify one using --main=<file-path>.`);
+        }
+        let tsConfigFile;
+        if (options.tsConfig) {
+            tsConfigFile = options.tsConfig;
+        }
+        else {
+            for (const f of [
+                'tsconfig.lib.json',
+                'tsconfig.app.json',
+                'tsconfig.json',
+            ]) {
+                const candidate = (0, devkit_1.joinPathFragments)(project.root, f);
+                if (tree.exists(candidate)) {
+                    tsConfigFile = candidate;
+                    break;
+                }
+            }
+        }
+        if (!tsConfigFile || !tree.exists(tsConfigFile)) {
+            throw new Error(`Cannot locate a tsConfig file for ${options.project}. Please specify one using --tsConfig=<file-path>.`);
+        }
+        switch (options.bundler) {
+            case 'vite': {
+                const { viteConfigurationGenerator } = (0, devkit_1.ensurePackage)('@nx/vite', versions_1.nxVersion);
+                const task = yield viteConfigurationGenerator(tree, {
+                    buildTarget: options.buildTarget,
+                    project: options.project,
+                    newProject: true,
+                    uiFramework: 'none',
+                    includeVitest: false,
+                    includeLib: true,
+                    skipFormat: true,
+                });
+                tasks.push(task);
+                break;
+            }
+            case 'esbuild': {
+                const { esbuildProjectGenerator } = (0, devkit_1.ensurePackage)('@nx/esbuild', versions_1.nxVersion);
+                const task = yield esbuildProjectGenerator(tree, {
+                    main: mainFile,
+                    buildTarget: options.buildTarget,
+                    project: options.project,
+                    skipFormat: true,
+                });
+                tasks.push(task);
+                break;
+            }
+            case 'rollup': {
+                const { rollupProjectGenerator } = (0, devkit_1.ensurePackage)('@nx/rollup', versions_1.nxVersion);
+                const task = yield rollupProjectGenerator(tree, {
+                    buildTarget: options.buildTarget,
+                    main: mainFile,
+                    project: options.project,
+                    skipFormat: true,
+                    compiler: 'tsc',
+                });
+                tasks.push(task);
+                break;
+            }
+            case 'tsc': {
+                const outputPath = (0, devkit_1.joinPathFragments)('dist', project.root);
+                project.targets[buildTarget] = {
+                    executor: `@nx/js:tsc`,
+                    outputs: ['{options.outputPath}'],
+                    options: {
+                        outputPath,
+                        main: mainFile,
+                        tsConfig: tsConfigFile,
+                        assets: [],
+                    },
+                };
+                (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
+                break;
+            }
+            case 'swc': {
+                const outputPath = (0, devkit_1.joinPathFragments)('dist', project.root);
+                project.targets[buildTarget] = {
+                    executor: `@nx/js:swc`,
+                    outputs: ['{options.outputPath}'],
+                    options: {
+                        outputPath,
+                        main: mainFile,
+                        tsConfig: tsConfigFile,
+                        assets: [],
+                    },
+                };
+                (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
+                (0, add_swc_dependencies_1.addSwcDependencies)(tree);
+                (0, add_swc_config_1.addSwcConfig)(tree, project.root, 'es6');
+            }
+        }
+        yield (0, devkit_1.formatFiles)(tree);
+        return (0, devkit_1.runTasksInSerial)(...tasks);
+    });
+}
+exports.setupBuildGenerator = setupBuildGenerator;
+exports.default = setupBuildGenerator;
+exports.setupBuildSchematic = (0, devkit_1.convertNxGenerator)(setupBuildGenerator);

package/src/generators/setup-build/schema.d.ts

@@ -0,0 +1,7 @@
+export interface SetupBuildGeneratorSchema {
+  project: string;
+  bundler: 'tsc' | 'swc' | 'vite' | 'rollup' | 'esbuild';
+  main?: string;
+  tsConfig?: string;
+  buildTarget?: string;
+}