@nx/js 17.0.2 → 17.0.4

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateLockFile = void 0;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const client_1 = require("nx/src/daemon/client/client");
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
+const semver_1 = require("semver");
+async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
+    if (generatorOptions?.skipLockFileUpdate) {
+        if (verbose) {
+            console.log('\nSkipped lock file update because skipLockFileUpdate was set.');
+        }
+        return [];
+    }
+    const packageManager = (0, devkit_1.detectPackageManager)(cwd);
+    if (packageManager === 'yarn' &&
+        !(0, semver_1.gte)((0, devkit_1.getPackageManagerVersion)(packageManager), '2.0.0')) {
+        // yarn classic does not store workspace data in the lock file, so we don't need to update it
+        if (verbose) {
+            console.log('\nSkipped lock file update because it is not necessary for Yarn Classic.');
+        }
+        return [];
+    }
+    const workspacesEnabled = (0, devkit_1.isWorkspacesEnabled)(packageManager, cwd);
+    if (!workspacesEnabled) {
+        if (verbose) {
+            console.log(`\nSkipped lock file update because ${packageManager} workspaces are not enabled.`);
+        }
+        return [];
+    }
+    const isDaemonEnabled = client_1.daemonClient.enabled();
+    if (!dryRun && isDaemonEnabled) {
+        // if not in dry-run temporarily stop the daemon, as it will error if the lock file is updated
+        await client_1.daemonClient.stop();
+    }
+    const packageManagerCommands = (0, devkit_1.getPackageManagerCommand)(packageManager);
+    let installArgs = generatorOptions?.installArgs || '';
+    devkit_1.output.logSingleLine(`Updating ${packageManager} lock file`);
+    let env = {};
+    if (generatorOptions?.installIgnoreScripts) {
+        if (packageManager === 'yarn') {
+            env = { YARN_ENABLE_SCRIPTS: 'false' };
+        }
+        else {
+            // npm and pnpm use the same --ignore-scripts option
+            installArgs = `${installArgs} --ignore-scripts`.trim();
+        }
+    }
+    const lockFile = (0, lock_file_1.getLockFileName)(packageManager);
+    const command = `${packageManagerCommands.updateLockFile} ${installArgs}`.trim();
+    if (verbose) {
+        if (dryRun) {
+            console.log(`Would update ${lockFile} with the following command, but --dry-run was set:`);
+        }
+        else {
+            console.log(`Updating ${lockFile} with the following command:`);
+        }
+        console.log(command);
+    }
+    if (dryRun) {
+        return [];
+    }
+    execLockFileUpdate(command, cwd, env);
+    if (isDaemonEnabled) {
+        try {
+            await client_1.daemonClient.startInBackground();
+        }
+        catch (e) {
+            // If the daemon fails to start, we don't want to prevent the user from continuing, so we just log the error and move on
+            if (verbose) {
+                devkit_1.output.warn({
+                    title: 'Unable to restart the Nx Daemon. It will be disabled until you run "nx reset"',
+                    bodyLines: [e.message],
+                });
+            }
+        }
+    }
+    return [lockFile];
+}
+exports.updateLockFile = updateLockFile;
+function execLockFileUpdate(command, cwd, env = {}) {
+    try {
+        (0, child_process_1.execSync)(command, {
+            cwd,
+            env: {
+                ...process.env,
+                ...env,
+            },
+        });
+    }
+    catch (e) {
+        devkit_1.output.error({
+            title: `Error updating lock file with command '${command}'`,
+            bodyLines: [
+                `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.`,
+            ],
+        });
+        throw e;
+    }
+}

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

@@ -5,6 +5,7 @@ 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");
+const add_build_target_defaults_1 = require("@nx/devkit/src/generators/add-build-target-defaults");
 async function setupBuildGenerator(tree, options) {
     const tasks = [];
     const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
@@ -101,6 +102,7 @@ async function setupBuildGenerator(tree, options) {
             break;
         }
         case 'tsc': {
+            (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, '@nx/js:tsc');
             const outputPath = (0, devkit_1.joinPathFragments)('dist', project.root);
             project.targets[buildTarget] = {
                 executor: `@nx/js:tsc`,
@@ -116,6 +118,7 @@ async function setupBuildGenerator(tree, options) {
             break;
         }
         case 'swc': {
+            (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, '@nx/js:swc');
             const outputPath = (0, devkit_1.joinPathFragments)('dist', project.root);
             project.targets[buildTarget] = {
                 executor: `@nx/js:swc`,

package/src/generators/setup-build/schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$schema": "https://json-schema.org/schema",
   "$id": "SetupBuild",
   "title": "Setup Build",
   "description": "Sets up build target for a project.",

package/src/generators/setup-verdaccio/schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$schema": "https://json-schema.org/schema",
   "$id": "SetupVerdaccio",
   "title": "Setup Verdaccio",
   "description": "Setup Verdaccio local-registry.",

package/src/migrations/update-17-0-0/remove-deprecated-build-options.js

@@ -12,7 +12,8 @@ async function default_1(tree) {
         if (!projectConfig.targets)
             continue;
         for (const target of Object.values(projectConfig.targets)) {
-            if (target.executor.startsWith('@nx/') &&
+            if (target.executor?.startsWith('@nx/') &&
+                target.options &&
                 ('buildableProjectDepsInPackageJsonType' in target.options ||
                     'updateBuildableProjectDepsInPackageJson' in target.options)) {
                 delete target.options['buildableProjectDepsInPackageJsonType'];

package/src/utils/add-local-registry-scripts.js

@@ -9,6 +9,7 @@ const startLocalRegistryScript = (localRegistryTarget) => `
  */
 import { startLocalRegistry } from '@nx/js/plugins/jest/local-registry';
 import { execFileSync } from 'child_process';
+import { releasePublish, releaseVersion } from 'nx/release';
 
 export default async () => {
   // local registry target to run
@@ -21,12 +22,21 @@ export default async () => {
     storage,
     verbose: false,
   });
-  const nx = require.resolve('nx');
-  execFileSync(
-    nx,
-    ['run-many', '--targets', 'publish', '--ver', '1.0.0', '--tag', 'e2e'],
-    { env: process.env, stdio: 'inherit' }
-  );
+
+  await releaseVersion({
+    specifier: '0.0.0-e2e',
+    stageChanges: false,
+    gitCommit: false,
+    gitTag: false,
+    firstRelease: true,
+    generatorOptionsOverrides: {
+      skipLockFileUpdate: true
+    }
+  });
+  await releasePublish({
+    tag: 'e2e',
+    firstRelease: true
+  });
 };
 `;
 const stopLocalRegistryScript = `
@@ -49,6 +59,16 @@ function addLocalRegistryScripts(tree) {
     if (!tree.exists(startLocalRegistryPath)) {
         tree.write(startLocalRegistryPath, startLocalRegistryScript(localRegistryTarget));
     }
+    else {
+        const existingStartLocalRegistryScript = tree
+            .read(startLocalRegistryPath)
+            .toString();
+        if (!existingStartLocalRegistryScript.includes('nx/release')) {
+            devkit_1.output.warn({
+                title: 'Your `start-local-registry.ts` script may be outdated. To ensure that newly generated packages are published appropriately when running end to end tests, update this script to use Nx Release. See https://nx.dev/recipes/nx-release/update-local-registry-setup for details.',
+            });
+        }
+    }
     if (!tree.exists(stopLocalRegistryPath)) {
         tree.write(stopLocalRegistryPath, stopLocalRegistryScript);
     }

package/src/utils/assets/copy-assets-handler.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CopyAssetsHandler = exports.defaultFileEventHandler = void 0;
-const minimatch = require("minimatch");
+const minimatch_1 = require("minimatch");
 const path = require("path");
 const fse = require("fs-extra");
 const ignore_1 = require("ignore");
@@ -114,8 +114,8 @@ class CopyAssetsHandler {
         for (const event of events) {
             const pathFromRoot = path.relative(this.rootDir, event.path);
             for (const ag of this.assetGlobs) {
-                if (minimatch(pathFromRoot, ag.pattern) &&
-                    !ag.ignore?.some((ig) => minimatch(pathFromRoot, ig)) &&
+                if ((0, minimatch_1.minimatch)(pathFromRoot, ag.pattern) &&
+                    !ag.ignore?.some((ig) => (0, minimatch_1.minimatch)(pathFromRoot, ig)) &&
                     !this.ignore.ignores(pathFromRoot)) {
                     const relPath = path.relative(ag.input, pathFromRoot);
                     const destPath = relPath.startsWith('..') ? pathFromRoot : relPath;
@@ -134,7 +134,7 @@ class CopyAssetsHandler {
     }
     filesToEvent(files, assetGlob) {
         return files.reduce((acc, src) => {
-            if (!assetGlob.ignore?.some((ig) => minimatch(src, ig)) &&
+            if (!assetGlob.ignore?.some((ig) => (0, minimatch_1.minimatch)(src, ig)) &&
                 !this.ignore.ignores(src)) {
                 const relPath = path.relative(assetGlob.input, src);
                 const dest = relPath.startsWith('..') ? src : relPath;

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

@@ -84,7 +84,8 @@ function calculateProjectDependencies(projGraph, root, projectName, targetName,
 exports.calculateProjectDependencies = calculateProjectDependencies;
 function collectDependencies(project, projGraph, acc, shallow, areTopLevelDeps = true) {
     (projGraph.dependencies[project] || []).forEach((dependency) => {
-        if (!acc.some((dep) => dep.name === dependency.target)) {
+        const existingEntry = acc.find((dep) => dep.name === dependency.target);
+        if (!existingEntry) {
             // Temporary skip this. Currently the set of external nodes is built from package.json, not lock file.
             // As a result, some nodes might be missing. This should not cause any issues, we can just skip them.
             if (dependency.target.startsWith('npm:') &&
@@ -96,6 +97,9 @@ function collectDependencies(project, projGraph, acc, shallow, areTopLevelDeps =
                 collectDependencies(dependency.target, projGraph, acc, shallow, false);
             }
         }
+        else if (areTopLevelDeps && !existingEntry.isTopLevel) {
+            existingEntry.isTopLevel = true;
+        }
     });
     return acc;
 }
@@ -123,7 +127,7 @@ function calculateDependenciesFromTaskGraph(taskGraph, projectGraph, root, proje
         const depTask = taskGraph.tasks[taskName];
         const depProjectNode = projectGraph.nodes?.[depTask.target.project];
         if (depProjectNode?.type !== 'lib') {
-            return null;
+            continue;
         }
         let outputs = (0, devkit_1.getOutputsForTargetAndConfiguration)(depTask.target, depTask.overrides, depProjectNode);
         if (outputs.length === 0) {

package/src/utils/find-npm-dependencies.d.ts

@@ -1,8 +1,9 @@
-import { type ProjectGraph, type ProjectGraphProjectNode, type ProjectFileMap } from '@nx/devkit';
+import { type ProjectFileMap, type ProjectGraph, type ProjectGraphProjectNode } from '@nx/devkit';
 /**
  * Finds all npm dependencies and their expected versions for a given project.
  */
 export declare function findNpmDependencies(workspaceRoot: string, sourceProject: ProjectGraphProjectNode, projectGraph: ProjectGraph, projectFileMap: ProjectFileMap, buildTarget: string, options?: {
     includeTransitiveDependencies?: boolean;
     ignoredFiles?: string[];
+    useLocalPathsForWorkspaceDependencies?: boolean;
 }): Record<string, string>;

package/src/utils/find-npm-dependencies.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findNpmDependencies = void 0;
 const path_1 = require("path");
 const configuration_1 = require("nx/src/config/configuration");
-const task_hasher_1 = require("nx/src/hasher/task-hasher");
 const devkit_1 = require("@nx/devkit");
 const fileutils_1 = require("nx/src/utils/fileutils");
 const project_graph_1 = require("nx/src/config/project-graph");
 const ts_config_1 = require("./typescript/ts-config");
+const task_hasher_1 = require("nx/src/hasher/task-hasher");
 /**
  * Finds all npm dependencies and their expected versions for a given project.
  */
@@ -21,7 +21,7 @@ function findNpmDependencies(workspaceRoot, sourceProject, projectGraph, project
         if (seen?.has(currentProject.name))
             return;
         seen?.add(currentProject.name);
-        collectDependenciesFromFileMap(workspaceRoot, currentProject, projectGraph, projectFileMap, buildTarget, options.ignoredFiles, collectedDeps);
+        collectDependenciesFromFileMap(workspaceRoot, currentProject, projectGraph, projectFileMap, buildTarget, options.ignoredFiles, options.useLocalPathsForWorkspaceDependencies, collectedDeps);
         collectHelperDependencies(workspaceRoot, currentProject, projectGraph, buildTarget, collectedDeps);
         if (options.includeTransitiveDependencies) {
             const projectDeps = projectGraph.dependencies[currentProject.name];
@@ -38,7 +38,7 @@ function findNpmDependencies(workspaceRoot, sourceProject, projectGraph, project
 exports.findNpmDependencies = findNpmDependencies;
 // Keep track of workspace libs we already read package.json for so we don't read from disk again.
 const seenWorkspaceDeps = {};
-function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGraph, projectFileMap, buildTarget, ignoredFiles, npmDeps) {
+function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGraph, projectFileMap, buildTarget, ignoredFiles, useLocalPathsForWorkspaceDependencies, npmDeps) {
     const rawFiles = projectFileMap[sourceProject.name];
     if (!rawFiles)
         return;
@@ -82,12 +82,27 @@ function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGra
                 workspaceDep.data.targets[buildTarget] &&
                     // Make sure package.json exists and has a valid name.
                     packageJson?.name) {
-                    // This is a workspace lib so we can't reliably read in a specific version since it depends on how the workspace is set up.
-                    // ASSUMPTION: Most users will use '*' for workspace lib versions. Otherwise, they can manually update it.
-                    npmDeps[packageJson.name] = '*';
+                    let version;
+                    if (useLocalPathsForWorkspaceDependencies) {
+                        // Find the relative `file:...` path and use that as the version value.
+                        // This is useful for monorepos like Nx where the release will handle setting the correct version in dist.
+                        const depRoot = (0, path_1.join)(workspaceRoot, workspaceDep.data.root);
+                        const ownRoot = (0, path_1.join)(workspaceRoot, sourceProject.data.root);
+                        const relativePath = (0, path_1.relative)(ownRoot, depRoot);
+                        const filePath = (0, devkit_1.normalizePath)(relativePath); // normalize slashes for windows
+                        version = `file:${filePath}`;
+                    }
+                    else {
+                        // Otherwise, read the version from the dependencies `package.json` file.
+                        // This is useful for monorepos that commit release versions.
+                        // Users can also set version as "*" in source `package.json` files, which will be the value set here.
+                        // This is useful if they use custom scripts to update them in dist.
+                        version = packageJson.version ?? '*'; // fallback in case version is missing
+                    }
+                    npmDeps[packageJson.name] = version;
                     seenWorkspaceDeps[workspaceDep.name] = {
                         name: packageJson.name,
-                        version: '*',
+                        version,
                     };
                 }
             }
@@ -106,8 +121,9 @@ function collectHelperDependencies(workspaceRoot, sourceProject, projectGraph, b
         return;
     if (target.executor === '@nx/js:tsc' && target.options?.tsConfig) {
         const tsConfig = (0, ts_config_1.readTsConfig)((0, path_1.join)(workspaceRoot, target.options.tsConfig));
-        if (tsConfig?.options['importHelpers']) {
-            npmDeps['tslib'] = projectGraph.externalNodes['npm:tslib']?.data.version;
+        if (tsConfig?.options['importHelpers'] &&
+            projectGraph.externalNodes['npm:tslib']?.type === 'npm') {
+            npmDeps['tslib'] = projectGraph.externalNodes['npm:tslib'].data.version;
         }
     }
     if (target.executor === '@nx/js:swc') {
@@ -117,9 +133,10 @@ function collectHelperDependencies(workspaceRoot, sourceProject, projectGraph, b
         const swcConfig = (0, fileutils_1.fileExists)(swcConfigPath)
             ? (0, devkit_1.readJsonFile)(swcConfigPath)
             : {};
-        if (swcConfig?.jsc?.externalHelpers) {
+        if (swcConfig?.jsc?.externalHelpers &&
+            projectGraph.externalNodes['npm:@swc/helpers']?.type === 'npm') {
             npmDeps['@swc/helpers'] =
-                projectGraph.externalNodes['npm:@swc/helpers']?.data.version;
+                projectGraph.externalNodes['npm:@swc/helpers'].data.version;
         }
     }
 }

package/src/utils/inline.js

@@ -161,9 +161,11 @@ function movePackage(from, to) {
     (0, fs_extra_1.copySync)(from, to, { overwrite: true });
 }
 function updateImports(destOutputPath, inlinedDepsDestOutputRecord) {
-    const importRegex = new RegExp(Object.keys(inlinedDepsDestOutputRecord)
-        .map((pathAlias) => `["'](${pathAlias})["']`)
-        .join('|'), 'g');
+    const pathAliases = Object.keys(inlinedDepsDestOutputRecord);
+    if (pathAliases.length == 0) {
+        return;
+    }
+    const importRegex = new RegExp(pathAliases.map((pathAlias) => `["'](${pathAlias})["']`).join('|'), 'g');
     recursiveUpdateImport(destOutputPath, importRegex, inlinedDepsDestOutputRecord);
 }
 function recursiveUpdateImport(dirPath, importRegex, inlinedDepsDestOutputRecord, rootParentDir) {
@@ -177,7 +179,7 @@ function recursiveUpdateImport(dirPath, importRegex, inlinedDepsDestOutputRecord
             const updatedContent = fileContent.replace(importRegex, (matched) => {
                 const result = matched.replace(/['"]/g, '');
                 // If a match is the same as the rootParentDir, we're checking its own files so we return the matched as in no changes.
-                if (result === rootParentDir)
+                if (result === rootParentDir || !inlinedDepsDestOutputRecord[result])
                     return matched;
                 const importPath = `"${(0, path_1.relative)(dirPath, inlinedDepsDestOutputRecord[result])}"`;
                 return (0, devkit_1.normalizePath)(importPath);

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

@@ -0,0 +1,25 @@
+import { PackageJson } from 'nx/src/utils/package-json';
+export declare function parseRegistryOptions(cwd: string, pkg: {
+    packageRoot: string;
+    packageJson: PackageJson;
+}, options: {
+    registry?: string;
+    tag?: string;
+}, logWarnFn?: (message: string) => void): Promise<{
+    registry: string;
+    tag: string;
+    registryConfigKey: string;
+}>;
+/**
+ * Returns the npm registry that is used for publishing.
+ *
+ * @param scope the scope of the package for which to determine the registry
+ * @param cwd the directory where the npm config should be read from
+ */
+export declare function getNpmRegistry(cwd: string, scope?: string): Promise<string>;
+/**
+ * Returns the npm tag that is used for publishing.
+ *
+ * @param cwd the directory where the npm config should be read from
+ */
+export declare function getNpmTag(cwd: string): Promise<string>;

package/src/utils/npm-config.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNpmTag = exports.getNpmRegistry = exports.parseRegistryOptions = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+async function parseRegistryOptions(cwd, pkg, options, logWarnFn = console.warn) {
+    const npmRcPath = (0, path_1.join)(pkg.packageRoot, '.npmrc');
+    if ((0, fs_1.existsSync)(npmRcPath)) {
+        const relativeNpmRcPath = (0, path_1.relative)(cwd, npmRcPath);
+        logWarnFn(`\nIgnoring .npmrc file detected in the package root: ${relativeNpmRcPath}. Nested .npmrc files are not supported by npm. Only the .npmrc file at the root of the workspace will be used. To customize the registry or tag for specific packages, see https://nx.dev/recipes/nx-release/configure-custom-registries\n`);
+    }
+    const scope = pkg.packageJson.name.startsWith('@')
+        ? pkg.packageJson.name.split('/')[0]
+        : '';
+    // If the package is scoped, then the registry argument that will
+    // correctly override the registry in the .npmrc file must be scoped.
+    const registryConfigKey = scope ? `${scope}:registry` : 'registry';
+    const publishConfigRegistry = pkg.packageJson.publishConfig?.[registryConfigKey];
+    // Even though it won't override the actual registry that's actually used,
+    // the user might think otherwise, so we should still warn if the user has
+    // set a 'registry' in 'publishConfig' for a scoped package.
+    if (publishConfigRegistry || pkg.packageJson.publishConfig?.registry) {
+        const relativePackageJsonPath = (0, path_1.relative)(cwd, (0, path_1.join)(pkg.packageRoot, 'package.json'));
+        if (options.registry) {
+            logWarnFn(`\nRegistry detected in the 'publishConfig' of the package manifest: ${relativePackageJsonPath}. This will override your registry option set in the project configuration or passed via the --registry argument, which is why configuring the registry with 'publishConfig' is not recommended. For details, see https://nx.dev/recipes/nx-release/configure-custom-registries\n`);
+        }
+        else {
+            logWarnFn(`\nRegistry detected in the 'publishConfig' of the package manifest: ${relativePackageJsonPath}. Configuring the registry in this way is not recommended because it prevents the registry from being overridden in project configuration or via the --registry argument. To customize the registry for specific packages, see https://nx.dev/recipes/nx-release/configure-custom-registries\n`);
+        }
+    }
+    const registry = 
+    // `npm publish` will always use the publishConfig registry if it exists, even over the --registry arg
+    publishConfigRegistry ||
+        options.registry ||
+        (await getNpmRegistry(cwd, scope));
+    const tag = options.tag || (await getNpmTag(cwd));
+    return { registry, tag, registryConfigKey };
+}
+exports.parseRegistryOptions = parseRegistryOptions;
+/**
+ * Returns the npm registry that is used for publishing.
+ *
+ * @param scope the scope of the package for which to determine the registry
+ * @param cwd the directory where the npm config should be read from
+ */
+async function getNpmRegistry(cwd, scope) {
+    let registry;
+    if (scope) {
+        registry = await getNpmConfigValue(`${scope}:registry`, cwd);
+    }
+    if (!registry) {
+        registry = await getNpmConfigValue('registry', cwd);
+    }
+    return registry;
+}
+exports.getNpmRegistry = getNpmRegistry;
+/**
+ * Returns the npm tag that is used for publishing.
+ *
+ * @param cwd the directory where the npm config should be read from
+ */
+async function getNpmTag(cwd) {
+    // npm does not support '@scope:tag' in the npm config, so we only need to check for 'tag'.
+    return getNpmConfigValue('tag', cwd);
+}
+exports.getNpmTag = getNpmTag;
+async function getNpmConfigValue(key, cwd) {
+    try {
+        const result = await execAsync(`npm config get ${key}`, cwd);
+        return result === 'undefined' ? undefined : result;
+    }
+    catch (e) {
+        return Promise.resolve(undefined);
+    }
+}
+async function execAsync(command, cwd) {
+    // Must be non-blocking async to allow spinner to render
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(command, { cwd }, (error, stdout, stderr) => {
+            if (error) {
+                return reject(error);
+            }
+            if (stderr) {
+                return reject(stderr);
+            }
+            return resolve(stdout.trim());
+        });
+    });
+}

package/src/utils/schema.d.ts

@@ -14,6 +14,7 @@ export interface LibraryGeneratorSchema {
   skipFormat?: boolean;
   tags?: string;
   skipTsConfig?: boolean;
+  skipPackageJson?: boolean;
   includeBabelRc?: boolean;
   unitTestRunner?: 'jest' | 'vitest' | 'none';
   linter?: Linter;
@@ -32,6 +33,7 @@ export interface LibraryGeneratorSchema {
   minimal?: boolean;
   rootProject?: boolean;
   simpleName?: boolean;
+  addPlugin?: boolean;
 }
 
 export interface ExecutorOptions {
@@ -81,4 +83,5 @@ export interface NormalizedSwcExecutorOptions
   swcExclude: string[];
   skipTypeCheck: boolean;
   swcCliOptions: SwcCliOptions;
+  tmpSwcrcPath: string;
 }

package/src/utils/swc/get-swcrc-path.d.ts

@@ -1,2 +1,5 @@
 import { SwcExecutorOptions } from '../schema';
-export declare function getSwcrcPath(options: SwcExecutorOptions, contextRoot: string, projectRoot: string): string;
+export declare function getSwcrcPath(options: SwcExecutorOptions, contextRoot: string, projectRoot: string): {
+    swcrcPath: string;
+    tmpSwcrcPath: string;
+};

package/src/utils/swc/get-swcrc-path.js

@@ -3,8 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSwcrcPath = void 0;
 const path_1 = require("path");
 function getSwcrcPath(options, contextRoot, projectRoot) {
-    return options.swcrc
+    const swcrcPath = options.swcrc
         ? (0, path_1.join)(contextRoot, options.swcrc)
         : (0, path_1.join)(contextRoot, projectRoot, '.swcrc');
+    const tmpSwcrcPath = (0, path_1.join)(contextRoot, projectRoot, 'tmp', '.generated.swcrc');
+    return {
+        swcrcPath,
+        tmpSwcrcPath,
+    };
 }
 exports.getSwcrcPath = getSwcrcPath;

package/src/utils/swc/inline.d.ts

@@ -1,2 +1,2 @@
 import type { InlineProjectGraph } from '../inline';
-export declare function generateTmpSwcrc(inlineProjectGraph: InlineProjectGraph, swcrcPath: string): string;
+export declare function generateTmpSwcrc(inlineProjectGraph: InlineProjectGraph, swcrcPath: string, tmpSwcrcPath: string): string;

package/src/utils/swc/inline.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTmpSwcrc = void 0;
 const devkit_1 = require("@nx/devkit");
-function generateTmpSwcrc(inlineProjectGraph, swcrcPath) {
+function generateTmpSwcrc(inlineProjectGraph, swcrcPath, tmpSwcrcPath) {
     const swcrc = (0, devkit_1.readJsonFile)(swcrcPath);
     swcrc['exclude'] = swcrc['exclude'].concat(Object.values(inlineProjectGraph.externals).map((external) => `${external.root}/**/.*.ts$`), 'node_modules/**/*.ts$');
-    const tmpSwcrcPath = `tmp${swcrcPath}`;
     (0, devkit_1.writeJsonFile)(tmpSwcrcPath, swcrc);
     return tmpSwcrcPath;
 }

package/src/utils/typescript/ast-utils.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findNodes = exports.findClass = exports.addMethod = exports.addParameterToConstructor = exports.replaceNodeValue = exports.getImport = exports.addGlobal = exports.insertImport = exports.removeChange = exports.replaceChange = exports.insertChange = exports.resolveModuleByImport = void 0;
-// TODO(colum): replace when https://github.com/nrwl/nx/pull/15497 is merged
-const typescript_1 = require("@nx/workspace/src/utilities/typescript");
 const ensure_typescript_1 = require("./ensure-typescript");
 const devkit_1 = require("@nx/devkit");
 const path_1 = require("path");
+const get_source_nodes_1 = require("./get-source-nodes");
 const normalizedAppRoot = devkit_1.workspaceRoot.replace(/\\/g, '/');
 let tsModule;
 let compilerHost;
@@ -228,7 +227,7 @@ function findClass(source, className, silent = false) {
     if (!tsModule) {
         tsModule = (0, ensure_typescript_1.ensureTypescript)();
     }
-    const nodes = (0, typescript_1.getSourceNodes)(source);
+    const nodes = (0, get_source_nodes_1.getSourceNodes)(source);
     const clazz = nodes.filter((n) => n.kind === tsModule.SyntaxKind.ClassDeclaration &&
         n.name.text === className)[0];
     if (!clazz && !silent) {

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

@@ -46,6 +46,7 @@ function getRootTsConfigFileName(tree) {
 exports.getRootTsConfigFileName = getRootTsConfigFileName;
 function addTsConfigPath(tree, importPath, lookupPaths) {
     (0, devkit_1.updateJson)(tree, getRootTsConfigPathInTree(tree), (json) => {
+        json.compilerOptions ??= {};
         const c = json.compilerOptions;
         c.paths ??= {};
         if (c.paths[importPath]) {

package/src/utils/versions.d.ts

@@ -4,14 +4,14 @@ export declare const prettierVersion = "^2.6.2";
 export declare const swcCliVersion = "~0.1.62";
 export declare const swcCoreVersion = "~1.3.85";
 export declare const swcHelpersVersion = "~0.5.2";
-export declare const swcNodeVersion = "~1.6.7";
+export declare const swcNodeVersion = "~1.8.0";
 export declare const tsLibVersion = "^2.3.0";
-export declare const typesNodeVersion = "18.7.1";
+export declare const typesNodeVersion = "18.16.9";
 export declare const verdaccioVersion = "^5.0.4";
-export declare const typescriptVersion = "~5.1.3";
+export declare const typescriptVersion = "~5.4.2";
 /**
  * The minimum version is currently determined from the lowest version
  * that's supported by the lowest Angular supported version, e.g.
  * `npm view @angular/compiler-cli@14.0.0 peerDependencies.typescript`
  */
-export declare const supportedTypescriptVersions = ">=4.6.2";
+export declare const supportedTypescriptVersions = ">=4.8.2";

package/src/utils/versions.js

@@ -7,15 +7,15 @@ exports.prettierVersion = '^2.6.2';
 exports.swcCliVersion = '~0.1.62';
 exports.swcCoreVersion = '~1.3.85';
 exports.swcHelpersVersion = '~0.5.2';
-exports.swcNodeVersion = '~1.6.7';
+exports.swcNodeVersion = '~1.8.0';
 exports.tsLibVersion = '^2.3.0';
-exports.typesNodeVersion = '18.7.1';
+exports.typesNodeVersion = '18.16.9';
 exports.verdaccioVersion = '^5.0.4';
 // Typescript
-exports.typescriptVersion = '~5.1.3';
+exports.typescriptVersion = '~5.4.2';
 /**
  * The minimum version is currently determined from the lowest version
  * that's supported by the lowest Angular supported version, e.g.
  * `npm view @angular/compiler-cli@14.0.0 peerDependencies.typescript`
  */
-exports.supportedTypescriptVersions = '>=4.6.2';
+exports.supportedTypescriptVersions = '>=4.8.2';