@nx/js 19.0.0-beta.0 → 19.0.0-beta.10

package/babel.js

@@ -13,7 +13,7 @@ module.exports = function (api, options = {}) {
     const emitDecoratorMetadata = api.caller((caller) => caller?.emitDecoratorMetadata ?? true);
     // Determine settings  for `@babel//babel-plugin-transform-class-properties`,
     // so that we can sync the `loose` option with `@babel/preset-env`.
-    // TODO(v19): Remove classProperties since it's no longer needed, now that the class props transform is in preset-env.
+    // TODO(v20): Remove classProperties since it's no longer needed, now that the class props transform is in preset-env.
     const loose = options.classProperties?.loose ?? options.loose ?? true;
     if (options.classProperties) {
         devkit_1.logger.warn(`Use =\`loose\` option instead of \`classProperties.loose\`. The \`classProperties\` option will be removed in Nx 19`);

package/generators.json

@@ -41,6 +41,12 @@
       "schema": "./src/generators/setup-build/schema.json",
       "alias": ["build"],
       "description": "setup-build generator"
+    },
+    "sync": {
+      "factory": "./src/generators/sync/sync#syncGenerator",
+      "schema": "./src/generators/sync/schema.json",
+      "description": "Synchronize TypeScript project references based on the project graph",
+      "hidden": true
     }
   }
 }

package/migrations.json

@@ -1,11 +1,5 @@
 {
   "generators": {
-    "rename-swcrc-config": {
-      "cli": "nx",
-      "version": "15.8.0-beta.0",
-      "description": "Rename .lib.swcrc to .swcrc for better SWC support throughout the workspace",
-      "factory": "./src/migrations/update-15-8-0/rename-swcrc-config"
-    },
     "update-16-0-0-add-nx-packages": {
       "cli": "nx",
       "version": "16.0.0-beta.1",
@@ -32,18 +26,6 @@
     }
   },
   "packageJsonUpdates": {
-    "15.8.0": {
-      "version": "15.8.0-beta.2",
-      "x-prompt": "Do you want to update to TypeScript v4.9?",
-      "requires": {
-        "typescript": ">=4.8.2 <4.9.0"
-      },
-      "packages": {
-        "typescript": {
-          "version": "~4.9.5"
-        }
-      }
-    },
     "16.0.0": {
       "version": "16.0.0-beta.3",
       "packages": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "19.0.0-beta.0",
+  "version": "19.0.0-beta.10",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -37,7 +37,6 @@
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@phenomnomnominal/tsquery": "~5.0.1",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",
     "babel-plugin-transform-typescript-metadata": "^0.3.1",
@@ -57,9 +56,9 @@
     "semver": "^7.5.3",
     "source-map-support": "0.5.19",
     "tslib": "^2.3.0",
-    "@nx/devkit": "19.0.0-beta.0",
-    "@nx/workspace": "19.0.0-beta.0",
-    "@nrwl/js": "19.0.0-beta.0"
+    "@nx/devkit": "19.0.0-beta.10",
+    "@nx/workspace": "19.0.0-beta.10",
+    "@nrwl/js": "19.0.0-beta.10"
   },
   "peerDependencies": {
     "verdaccio": "^5.0.4"

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

@@ -297,7 +297,7 @@ function getFileToRun(context, project, buildOptions, buildTargetExecutor) {
 function fileToRunCorrectPath(fileToRun) {
     if ((0, fileutils_1.fileExists)(fileToRun))
         return fileToRun;
-    const extensionsToTry = ['.cjs', '.mjs', 'cjs.js', '.esm.js'];
+    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))

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

@@ -8,6 +8,10 @@ const detectPort = require("detect-port");
 const path_1 = require("path");
 const semver_1 = require("semver");
 let childProcess;
+let env = {
+    SKIP_YARN_COREPACK_CHECK: 'true',
+    ...process.env,
+};
 /**
  * - set npm and yarn to use local registry
  * - start verdaccio
@@ -104,19 +108,19 @@ function createVerdaccioOptions(options, workspaceRoot) {
 }
 function setupNpm(options) {
     try {
-        (0, child_process_1.execSync)('npm --version');
+        (0, child_process_1.execSync)('npm --version', { env });
     }
     catch (e) {
         return () => { };
     }
     let npmRegistryPath;
     try {
-        npmRegistryPath = (0, child_process_1.execSync)(`npm config get registry --location ${options.location}`)
+        npmRegistryPath = (0, child_process_1.execSync)(`npm config get registry --location ${options.location}`, { env })
             ?.toString()
             ?.trim()
             ?.replace('\u001b[2K\u001b[1G', ''); // strip out ansi codes
-        (0, child_process_1.execSync)(`npm config set registry http://localhost:${options.port}/ --location ${options.location}`);
-        (0, child_process_1.execSync)(`npm config set //localhost:${options.port}/:_authToken="secretVerdaccioToken" --location ${options.location}`);
+        (0, child_process_1.execSync)(`npm config set registry http://localhost:${options.port}/ --location ${options.location}`, { env });
+        (0, child_process_1.execSync)(`npm config set //localhost:${options.port}/:_authToken="secretVerdaccioToken" --location ${options.location}`, { env });
         devkit_1.logger.info(`Set npm registry to http://localhost:${options.port}/`);
     }
     catch (e) {
@@ -124,19 +128,21 @@ function setupNpm(options) {
     }
     return () => {
         try {
-            const currentNpmRegistryPath = (0, child_process_1.execSync)(`npm config get registry --location ${options.location}`)
+            const currentNpmRegistryPath = (0, child_process_1.execSync)(`npm config get registry --location ${options.location}`, { env })
                 ?.toString()
                 ?.trim()
                 ?.replace('\u001b[2K\u001b[1G', ''); // strip out ansi codes
             if (npmRegistryPath && currentNpmRegistryPath.includes('localhost')) {
-                (0, child_process_1.execSync)(`npm config set registry ${npmRegistryPath} --location ${options.location}`);
+                (0, child_process_1.execSync)(`npm config set registry ${npmRegistryPath} --location ${options.location}`, { env });
                 devkit_1.logger.info(`Reset npm registry to ${npmRegistryPath}`);
             }
             else {
-                (0, child_process_1.execSync)(`npm config delete registry --location ${options.location}`);
+                (0, child_process_1.execSync)(`npm config delete registry --location ${options.location}`, {
+                    env,
+                });
                 devkit_1.logger.info('Cleared custom npm registry');
             }
-            (0, child_process_1.execSync)(`npm config delete //localhost:${options.port}/:_authToken  --location ${options.location}`);
+            (0, child_process_1.execSync)(`npm config delete //localhost:${options.port}/:_authToken  --location ${options.location}`, { env });
         }
         catch (e) {
             throw new Error(`Failed to reset npm registry: ${e.message}`);
@@ -145,22 +151,25 @@ function setupNpm(options) {
 }
 function getYarnUnsafeHttpWhitelist(isYarnV1) {
     return !isYarnV1
-        ? new Set(JSON.parse((0, child_process_1.execSync)(`yarn config get unsafeHttpWhitelist --json`).toString()))
+        ? new Set(JSON.parse((0, child_process_1.execSync)(`yarn config get unsafeHttpWhitelist --json`, {
+            env,
+        }).toString()))
         : null;
 }
 function setYarnUnsafeHttpWhitelist(currentWhitelist, options) {
     if (currentWhitelist.size > 0) {
-        (0, child_process_1.execSync)(`yarn config set unsafeHttpWhitelist --json '${JSON.stringify(Array.from(currentWhitelist))}'` + (options.location === 'user' ? ' --home' : ''));
+        (0, child_process_1.execSync)(`yarn config set unsafeHttpWhitelist --json '${JSON.stringify(Array.from(currentWhitelist))}'` + (options.location === 'user' ? ' --home' : ''), { env });
     }
     else {
         (0, child_process_1.execSync)(`yarn config unset unsafeHttpWhitelist` +
-            (options.location === 'user' ? ' --home' : ''));
+            (options.location === 'user' ? ' --home' : ''), { env });
     }
 }
 function setupYarn(options) {
     let isYarnV1;
     try {
-        isYarnV1 = (0, semver_1.major)((0, child_process_1.execSync)('yarn --version').toString().trim()) === 1;
+        isYarnV1 =
+            (0, semver_1.major)((0, child_process_1.execSync)('yarn --version', { env }).toString().trim()) === 1;
     }
     catch {
         // This would fail if yarn is not installed which is okay
@@ -168,12 +177,14 @@ function setupYarn(options) {
     }
     try {
         const registryConfigName = isYarnV1 ? 'registry' : 'npmRegistryServer';
-        const yarnRegistryPath = (0, child_process_1.execSync)(`yarn config get ${registryConfigName}`)
+        const yarnRegistryPath = (0, child_process_1.execSync)(`yarn config get ${registryConfigName}`, {
+            env,
+        })
             ?.toString()
             ?.trim()
             ?.replace('\u001b[2K\u001b[1G', ''); // strip out ansi codes
         (0, child_process_1.execSync)(`yarn config set ${registryConfigName} http://localhost:${options.port}/` +
-            (options.location === 'user' ? ' --home' : ''));
+            (options.location === 'user' ? ' --home' : ''), { env });
         devkit_1.logger.info(`Set yarn registry to http://localhost:${options.port}/`);
         const currentWhitelist = getYarnUnsafeHttpWhitelist(isYarnV1);
         let whitelistedLocalhost = false;
@@ -185,18 +196,18 @@ function setupYarn(options) {
         }
         return () => {
             try {
-                const currentYarnRegistryPath = (0, child_process_1.execSync)(`yarn config get ${registryConfigName}`)
+                const currentYarnRegistryPath = (0, child_process_1.execSync)(`yarn config get ${registryConfigName}`, { env })
                     ?.toString()
                     ?.trim()
                     ?.replace('\u001b[2K\u001b[1G', ''); // strip out ansi codes
                 if (yarnRegistryPath && currentYarnRegistryPath.includes('localhost')) {
                     (0, child_process_1.execSync)(`yarn config set ${registryConfigName} ${yarnRegistryPath}` +
-                        (options.location === 'user' ? ' --home' : ''));
+                        (options.location === 'user' ? ' --home' : ''), { env });
                     devkit_1.logger.info(`Reset yarn ${registryConfigName} to ${yarnRegistryPath}`);
                 }
                 else {
                     (0, child_process_1.execSync)(`yarn config ${isYarnV1 ? 'delete' : 'unset'} ${registryConfigName}` +
-                        (options.location === 'user' ? ' --home' : ''));
+                        (options.location === 'user' ? ' --home' : ''), { env });
                     devkit_1.logger.info(`Cleared custom yarn ${registryConfigName}`);
                 }
                 if (whitelistedLocalhost) {

package/src/generators/sync/schema.d.ts

@@ -0,0 +1 @@
+export interface SyncSchema {}

package/src/generators/sync/schema.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "action",
+  "type": "object",
+  "description": "Synchronize TypeScript project references based on the project graph.",
+  "properties": {},
+  "required": []
+}

package/src/generators/sync/sync.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import { SyncSchema } from './schema';
+export declare function syncGenerator(tree: Tree, options: SyncSchema): Promise<void>;

package/src/generators/sync/sync.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const node_path_1 = require("node:path");
+const plugin_1 = require("../../plugins/typescript/plugin");
+async function syncGenerator(tree, options) {
+    // Ensure that the plugin has been wired up in nx.json
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    let tscPluginConfig = nxJson.plugins.find((p) => {
+        if (typeof p === 'string') {
+            return p === plugin_1.PLUGIN_NAME;
+        }
+        return p.plugin === plugin_1.PLUGIN_NAME;
+    });
+    if (!tscPluginConfig) {
+        throw new Error(`The ${plugin_1.PLUGIN_NAME} plugin must be added to the "plugins" array in nx.json before syncing tsconfigs`);
+    }
+    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
+    const firstPartyDeps = Object.entries(projectGraph.dependencies).filter(([name, data]) => !name.startsWith('npm:') && data.length > 0);
+    // Root tsconfig containing project references for the whole workspace
+    const rootTsconfigPath = 'tsconfig.json';
+    const rootTsconfig = (0, devkit_1.readJson)(tree, rootTsconfigPath);
+    const tsconfigProjectNodeValues = Object.values(projectGraph.nodes).filter((node) => {
+        const projectTsconfigPath = (0, devkit_1.joinPathFragments)(node.data.root, 'tsconfig.json');
+        return tree.exists(projectTsconfigPath);
+    });
+    if (tsconfigProjectNodeValues.length > 0) {
+        // Sync the root tsconfig references from the project graph (do not destroy existing references)
+        rootTsconfig.references = rootTsconfig.references || [];
+        const referencesSet = new Set(rootTsconfig.references.map((ref) => normalizeReferencePath(ref.path)));
+        for (const node of tsconfigProjectNodeValues) {
+            const normalizedPath = normalizeReferencePath(node.data.root);
+            // Skip the root tsconfig itself
+            if (node.data.root !== '.' && !referencesSet.has(normalizedPath)) {
+                rootTsconfig.references.push({ path: `./${normalizedPath}` });
+            }
+        }
+        (0, devkit_1.writeJson)(tree, rootTsconfigPath, rootTsconfig);
+    }
+    for (const [name, data] of firstPartyDeps) {
+        // Get the source project nodes for the source and target
+        const sourceProjectNode = projectGraph.nodes[name];
+        // Find the relevant tsconfig files for the source project
+        const sourceProjectTsconfigPath = (0, devkit_1.joinPathFragments)(sourceProjectNode.data.root, 'tsconfig.json');
+        if (!tree.exists(sourceProjectTsconfigPath)) {
+            console.warn(`Skipping project "${name}" as there is no tsconfig.json file found in the project root "${sourceProjectNode.data.root}"`);
+            continue;
+        }
+        const sourceTsconfig = (0, devkit_1.readJson)(tree, sourceProjectTsconfigPath);
+        for (const dep of data) {
+            // Get the target project node
+            const targetProjectNode = projectGraph.nodes[dep.target];
+            if (!targetProjectNode) {
+                // It's an external dependency
+                continue;
+            }
+            // Set defaults only in the case where we have at least one dependency so that we don't patch files when not necessary
+            sourceTsconfig.references = sourceTsconfig.references || [];
+            // Ensure the project reference for the target is set
+            const relativePathToTargetRoot = (0, node_path_1.relative)(sourceProjectNode.data.root, targetProjectNode.data.root);
+            if (!sourceTsconfig.references.some((ref) => ref.path === relativePathToTargetRoot)) {
+                // Make sure we unshift rather than push so that dependencies are built in the right order by TypeScript when it is run directly from the root of the workspace
+                sourceTsconfig.references.unshift({ path: relativePathToTargetRoot });
+            }
+        }
+        // Update the source tsconfig files
+        (0, devkit_1.writeJson)(tree, sourceProjectTsconfigPath, sourceTsconfig);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.syncGenerator = syncGenerator;
+// Normalize the paths to strip leading `./` and trailing `/tsconfig.json`
+function normalizeReferencePath(path) {
+    return path.replace(/\/tsconfig.json$/, '').replace(/^\.\//, '');
+}

package/src/plugins/typescript/plugin.d.ts

@@ -0,0 +1,13 @@
+import { type CreateDependencies, type CreateNodes } from '@nx/devkit';
+export interface TscPluginOptions {
+    typecheck?: boolean | {
+        targetName?: string;
+    };
+    build?: boolean | {
+        targetName?: string;
+        configName?: string;
+    };
+}
+export declare const createDependencies: CreateDependencies;
+export declare const PLUGIN_NAME = "@nx/js/typescript";
+export declare const createNodes: CreateNodes<TscPluginOptions>;

package/src/plugins/typescript/plugin.js

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.PLUGIN_NAME = exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const minimatch_1 = require("minimatch");
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const ts_config_1 = require("../../utils/typescript/ts-config");
+const cachePath = (0, node_path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'tsc.hash');
+const targetsCache = (0, node_fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+const calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+const createDependencies = () => {
+    writeTargetsToCache(calculatedTargets);
+    return [];
+};
+exports.createDependencies = createDependencies;
+exports.PLUGIN_NAME = '@nx/js/typescript';
+exports.createNodes = [
+    '**/tsconfig*.json',
+    (configFilePath, options, context) => {
+        const pluginOptions = normalizePluginOptions(options);
+        const projectRoot = (0, node_path_1.dirname)(configFilePath);
+        const fullConfigPath = (0, devkit_1.joinPathFragments)(context.workspaceRoot, configFilePath);
+        // Do not create a project if package.json and project.json isn't there.
+        const siblingFiles = (0, node_fs_1.readdirSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot));
+        if (!siblingFiles.includes('package.json') &&
+            !siblingFiles.includes('project.json')) {
+            return {};
+        }
+        // Do not create a project if it's not a tsconfig.json and there is no tsconfig.json in the same directory
+        if ((0, node_path_1.basename)(configFilePath) !== 'tsconfig.json' &&
+            !siblingFiles.includes('tsconfig.json')) {
+            return {};
+        }
+        const nodeHash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, pluginOptions, context, [(0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot))]);
+        // The hash is calculated at the node/project level, so we add the config file path to avoid conflicts when caching
+        const cacheKey = `${nodeHash}_${configFilePath}`;
+        const targets = targetsCache[cacheKey]
+            ? targetsCache[cacheKey]
+            : buildTscTargets(fullConfigPath, projectRoot, pluginOptions, context);
+        calculatedTargets[cacheKey] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    projectType: 'library',
+                    targets,
+                },
+            },
+        };
+    },
+];
+function buildTscTargets(configFilePath, projectRoot, options, context) {
+    const targets = {};
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const tsConfig = readCachedTsConfig(configFilePath);
+    // TODO: check whether we want to always run with --pretty --verbose, it makes replacing scripts harder
+    // `--verbose` conflicts with `tsc -b --clean`, might be another reason for not using it, it would
+    // prevent users from running the task with `--clean` flag.
+    // Should we consider creating a different optional target for `--clean`?
+    // Should we consider having a plugin option to disable `--pretty` and `--verbose`?
+    let internalProjectReferences;
+    // Typecheck target
+    if ((0, node_path_1.basename)(configFilePath) === 'tsconfig.json' && options.typecheck) {
+        internalProjectReferences = resolveInternalProjectReferences(configFilePath, tsConfig);
+        const targetName = options.typecheck.targetName;
+        if (!targets[targetName]) {
+            let command = `tsc --build --emitDeclarationOnly --pretty --verbose`;
+            if (tsConfig.options.noEmit ||
+                Object.values(internalProjectReferences).some((ref) => ref.options.noEmit)) {
+                // `--emitDeclarationOnly` and `--noEmit` are mutually exclusive, so
+                // we remove `--emitDeclarationOnly` if `--noEmit` is set.
+                command = `tsc --build --pretty --verbose`;
+            }
+            targets[targetName] = {
+                dependsOn: [`^${targetName}`],
+                command,
+                options: { cwd: projectRoot },
+                cache: true,
+                inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
+                outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
+            };
+        }
+    }
+    // Build target
+    if (options.build && (0, node_path_1.basename)(configFilePath) === options.build.configName) {
+        internalProjectReferences ??= resolveInternalProjectReferences(configFilePath, tsConfig);
+        const targetName = options.build.targetName;
+        targets[targetName] = {
+            dependsOn: [`^${targetName}`],
+            command: `tsc --build ${options.build.configName} --pretty --verbose`,
+            options: { cwd: projectRoot },
+            cache: true,
+            inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
+            outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
+        };
+    }
+    return targets;
+}
+function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot) {
+    const configFiles = new Set();
+    const includePaths = new Set();
+    const excludePaths = new Set();
+    const extendedConfigFiles = getExtendedConfigFiles(configFilePath, tsConfig);
+    extendedConfigFiles.forEach((configPath) => {
+        configFiles.add(configPath);
+    });
+    const projectTsConfigFiles = [
+        [configFilePath, tsConfig],
+        ...Object.entries(internalProjectReferences),
+    ];
+    projectTsConfigFiles.forEach(([configPath, config]) => {
+        configFiles.add(configPath);
+        (config.raw?.include ?? []).forEach((p) => includePaths.add(p));
+        if (config.raw?.exclude) {
+            /**
+             * We need to filter out the exclude paths that are already included in
+             * other tsconfig files. If they are not included in other tsconfig files,
+             * they still correctly apply to the current file and we should keep them.
+             */
+            const otherFilesInclude = [];
+            projectTsConfigFiles.forEach(([path, c]) => {
+                if (path !== configPath) {
+                    otherFilesInclude.push(...(c.raw?.include ?? []));
+                }
+            });
+            const normalize = (p) => (p.startsWith('./') ? p.slice(2) : p);
+            config.raw.exclude.forEach((excludePath) => {
+                if (!otherFilesInclude.some((includePath) => (0, minimatch_1.minimatch)(normalize(includePath), normalize(excludePath)) ||
+                    (0, minimatch_1.minimatch)(normalize(excludePath), normalize(includePath)))) {
+                    excludePaths.add(excludePath);
+                }
+            });
+        }
+    });
+    const inputs = [];
+    if (includePaths.size) {
+        inputs.push(...Array.from(configFiles).map((p) => pathToInputOrOutput(p, workspaceRoot, projectRoot)), ...Array.from(includePaths).map((p) => (0, devkit_1.joinPathFragments)('{projectRoot}', p)));
+    }
+    else {
+        // If we couldn't identify any include paths, we default to the default
+        // named inputs.
+        inputs.push('production' in namedInputs ? 'production' : 'default');
+    }
+    if (excludePaths.size) {
+        inputs.push(...Array.from(excludePaths).map((p) => `!${(0, devkit_1.joinPathFragments)('{projectRoot}', p)}`));
+    }
+    if (hasExternalProjectReferences(configFilePath, tsConfig)) {
+        // Importing modules from a referenced project will load its output declaration files (d.ts)
+        // https://www.typescriptlang.org/docs/handbook/project-references.html#what-is-a-project-reference
+        inputs.push({ dependentTasksOutputFiles: '**/*.d.ts' });
+    }
+    else {
+        inputs.push('production' in namedInputs ? '^production' : '^default');
+    }
+    inputs.push({ externalDependencies: ['typescript'] });
+    return inputs;
+}
+function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot) {
+    const outputs = new Set();
+    // We could have more surgical outputs based on the tsconfig options, but the
+    // user could override them through the command line and that wouldn't be
+    // reflected in the outputs. So, we just include everything that could be
+    // produced by the tsc command.
+    [tsConfig, ...Object.values(internalProjectReferences)].forEach((config) => {
+        if (config.options.outFile) {
+            const outFileName = (0, node_path_1.basename)(config.options.outFile, '.js');
+            const outFileDir = (0, node_path_1.dirname)(config.options.outFile);
+            outputs.add((0, devkit_1.joinPathFragments)('{workspaceRoot}', (0, node_path_1.relative)(workspaceRoot, config.options.outFile)));
+            // outFile is not be used with .cjs, .mjs, .jsx, so the list is simpler
+            const outDir = (0, node_path_1.relative)(workspaceRoot, outFileDir);
+            outputs.add((0, devkit_1.joinPathFragments)('{workspaceRoot}', outDir, `${outFileName}.js.map`));
+            outputs.add((0, devkit_1.joinPathFragments)('{workspaceRoot}', outDir, `${outFileName}.d.ts`));
+            outputs.add((0, devkit_1.joinPathFragments)('{workspaceRoot}', outDir, `${outFileName}.d.ts.map`));
+            // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
+            outputs.add(tsConfig.options.tsBuildInfoFile
+                ? pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, projectRoot)
+                : (0, devkit_1.joinPathFragments)('{workspaceRoot}', outDir, `${outFileName}.tsbuildinfo`));
+        }
+        else if (config.options.outDir) {
+            outputs.add((0, devkit_1.joinPathFragments)('{workspaceRoot}', (0, node_path_1.relative)(workspaceRoot, config.options.outDir)));
+        }
+        else if (config.fileNames.length) {
+            // tsc produce files in place when no outDir or outFile is set
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.js'));
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.cjs'));
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.mjs'));
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.jsx'));
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.js.map')); // should also include .cjs and .mjs data
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.jsx.map'));
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.d.ts'));
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.d.cts'));
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.d.mts'));
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.d.ts.map'));
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.d.cts.map'));
+            outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.d.mts.map'));
+            // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
+            const name = (0, node_path_1.basename)(configFilePath, '.json');
+            outputs.add(tsConfig.options.tsBuildInfoFile
+                ? pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, projectRoot)
+                : (0, devkit_1.joinPathFragments)('{projectRoot}', `${name}.tsbuildinfo`));
+        }
+    });
+    return Array.from(outputs);
+}
+function pathToInputOrOutput(path, workspaceRoot, projectRoot) {
+    const pathRelativeToProjectRoot = (0, devkit_1.normalizePath)((0, node_path_1.relative)(projectRoot, path));
+    if (pathRelativeToProjectRoot.startsWith('..')) {
+        return (0, devkit_1.joinPathFragments)('{workspaceRoot}', (0, node_path_1.relative)(workspaceRoot, path));
+    }
+    return (0, devkit_1.joinPathFragments)('{projectRoot}', pathRelativeToProjectRoot);
+}
+function getExtendedConfigFiles(tsConfigPath, tsConfig) {
+    const extendedConfigFiles = new Set();
+    let currentConfigPath = tsConfigPath;
+    let currentConfig = tsConfig;
+    while (currentConfig.raw?.extends) {
+        const extendedConfigPath = (0, node_path_1.join)((0, node_path_1.dirname)(currentConfigPath), currentConfig.raw.extends);
+        extendedConfigFiles.add(extendedConfigPath);
+        const extendedConfig = readCachedTsConfig(extendedConfigPath);
+        currentConfigPath = extendedConfigPath;
+        currentConfig = extendedConfig;
+    }
+    return Array.from(extendedConfigFiles);
+}
+function resolveInternalProjectReferences(configFilePath, tsConfig, projectReferences = {}) {
+    if (!tsConfig.projectReferences?.length) {
+        return projectReferences;
+    }
+    const basePath = getTsConfigBasePath(configFilePath);
+    for (const ref of tsConfig.projectReferences) {
+        let refConfigPath = ref.path;
+        if (projectReferences[refConfigPath]) {
+            // Already resolved
+            continue;
+        }
+        if (isExternalProjectReference(refConfigPath, basePath)) {
+            continue;
+        }
+        if (!refConfigPath.endsWith('.json')) {
+            refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
+        }
+        const refTsConfig = readCachedTsConfig(refConfigPath);
+        projectReferences[refConfigPath] = refTsConfig;
+        resolveInternalProjectReferences(refConfigPath, refTsConfig, projectReferences);
+    }
+    return projectReferences;
+}
+function hasExternalProjectReferences(tsConfigPath, tsConfig, seen = new Set()) {
+    if (!tsConfig.projectReferences?.length) {
+        return false;
+    }
+    seen.add(tsConfigPath);
+    const basePath = getTsConfigBasePath(tsConfigPath);
+    for (const ref of tsConfig.projectReferences) {
+        let refConfigPath = ref.path;
+        if (seen.has(refConfigPath)) {
+            // Already seen
+            continue;
+        }
+        if (isExternalProjectReference(refConfigPath, basePath)) {
+            return true;
+        }
+        if (!refConfigPath.endsWith('.json')) {
+            refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
+        }
+        const refTsConfig = readCachedTsConfig(refConfigPath);
+        const result = hasExternalProjectReferences(refConfigPath, refTsConfig);
+        if (result) {
+            return true;
+        }
+    }
+    return false;
+}
+function isExternalProjectReference(refTsConfigPath, basePath) {
+    const refBasePath = getTsConfigBasePath(refTsConfigPath);
+    // TODO: there could be internal project references in nested dirs (e.g.
+    // our storybook generator generates a nested `.storybook/tsconfig.json`),
+    // which would be considered an external project reference but it's not.
+    // We could instead check if the referenced tsconfig is outside the project
+    // root, but that would cause issues with standalone workspaces with nested
+    // projects.
+    return refBasePath !== basePath;
+}
+function getTsConfigBasePath(tsConfigPath) {
+    return (0, node_fs_1.statSync)(tsConfigPath).isFile() ? (0, node_path_1.dirname)(tsConfigPath) : tsConfigPath;
+}
+// TODO: we could probably persist this to disk to avoid reading the same
+// tsconfig files over multiple runs
+const tsConfigCache = new Map();
+function readCachedTsConfig(tsConfigPath) {
+    const cacheKey = getTsConfigCacheKey(tsConfigPath);
+    if (tsConfigCache.has(cacheKey)) {
+        return tsConfigCache.get(cacheKey);
+    }
+    const tsConfig = (0, ts_config_1.readTsConfig)(tsConfigPath);
+    tsConfigCache.set(cacheKey, tsConfig);
+    return tsConfig;
+}
+function getTsConfigCacheKey(tsConfigPath) {
+    const timestamp = (0, node_fs_1.statSync)(tsConfigPath).mtimeMs;
+    return `${tsConfigPath}-${timestamp}`;
+}
+function normalizePluginOptions(pluginOptions = {}) {
+    const defaultTypecheckTargetName = 'typecheck';
+    let typecheck = {
+        targetName: defaultTypecheckTargetName,
+    };
+    if (pluginOptions.typecheck === false) {
+        typecheck = false;
+    }
+    else if (pluginOptions.typecheck &&
+        typeof pluginOptions.typecheck !== 'boolean') {
+        typecheck = {
+            targetName: pluginOptions.typecheck.targetName ?? defaultTypecheckTargetName,
+        };
+    }
+    const defaultBuildTargetName = 'build';
+    const defaultBuildConfigName = 'tsconfig.lib.json';
+    let build = {
+        targetName: defaultBuildTargetName,
+        configName: defaultBuildConfigName,
+    };
+    // Build target is not enabled by default
+    if (!pluginOptions.build) {
+        build = false;
+    }
+    else if (pluginOptions.build && typeof pluginOptions.build !== 'boolean') {
+        build = {
+            targetName: pluginOptions.build.targetName ?? defaultBuildTargetName,
+            configName: pluginOptions.build.configName ?? defaultBuildConfigName,
+        };
+    }
+    return {
+        typecheck,
+        build,
+    };
+}

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CopyAssetsHandler = exports.defaultFileEventHandler = void 0;
 const minimatch_1 = require("minimatch");
-const path = require("path");
+const path = require("node:path/posix");
 const fse = require("fs-extra");
 const ignore_1 = require("ignore");
 const fg = require("fast-glob");

package/typescript.d.ts

@@ -0,0 +1 @@
+export { createDependencies, createNodes, } from './src/plugins/typescript/plugin';

package/typescript.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+var plugin_1 = require("./src/plugins/typescript/plugin");
+Object.defineProperty(exports, "createDependencies", { enumerable: true, get: function () { return plugin_1.createDependencies; } });
+Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return plugin_1.createNodes; } });

package/src/migrations/update-15-8-0/rename-swcrc-config.d.ts

@@ -1,2 +0,0 @@
-import { Tree } from '@nx/devkit';
-export default function (tree: Tree): Promise<void>;

package/src/migrations/update-15-8-0/rename-swcrc-config.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const devkit_1 = require("@nx/devkit");
-const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
-const tsquery_1 = require("@phenomnomnominal/tsquery");
-async function default_1(tree) {
-    let changesMade = false;
-    const projects = (0, devkit_1.getProjects)(tree);
-    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/js:swc', (_, projectName, target, configurationName) => {
-        const projectConfiguration = projects.get(projectName);
-        const executorOptions = configurationName
-            ? projectConfiguration.targets[target].configurations[configurationName]
-            : projectConfiguration.targets[target].options;
-        // if the project uses a custom path to swcrc file
-        // and only if it's the default name
-        if (executorOptions.swcrc &&
-            executorOptions.swcrc.includes('.lib.swcrc')) {
-            const newSwcrc = executorOptions.swcrc.replace('.lib.swcrc', '.swcrc');
-            // rename the swcrc file first
-            tree.rename(executorOptions.swcrc, newSwcrc);
-            // then update the executor options
-            executorOptions.swcrc = newSwcrc;
-            changesMade = true;
-        }
-        const libSwcrcPath = (0, devkit_1.joinPathFragments)(projectConfiguration.root, '.lib.swcrc') ||
-            (0, devkit_1.joinPathFragments)(projectConfiguration.sourceRoot, '.lib.swcrc');
-        const isLibSwcrcExist = tree.exists(libSwcrcPath);
-        if (isLibSwcrcExist) {
-            tree.rename(libSwcrcPath, libSwcrcPath.replace('.lib.swcrc', '.swcrc'));
-            changesMade = true;
-        }
-        (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
-    });
-    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/jest:jest', (_, projectName, target, configurationName) => {
-        const projectConfiguration = projects.get(projectName);
-        const executorOptions = configurationName
-            ? projectConfiguration.targets[target].configurations[configurationName]
-            : projectConfiguration.targets[target].options;
-        const isJestConfigExist = executorOptions.jestConfig && tree.exists(executorOptions.jestConfig);
-        if (isJestConfigExist) {
-            const jestConfig = tree.read(executorOptions.jestConfig, 'utf-8');
-            const jsonParseNodes = tsquery_1.tsquery.query(jestConfig, ':matches(CallExpression:has(Identifier[name="JSON"]):has(Identifier[name="parse"]))');
-            if (jsonParseNodes.length) {
-                // if we already assign false to swcrc, skip
-                if (jestConfig.includes('.swcrc = false')) {
-                    return;
-                }
-                let updatedJestConfig = tsquery_1.tsquery.replace(jestConfig, 'CallExpression:has(Identifier[name="JSON"]):has(Identifier[name="parse"]) TemplateSpan', (templateSpan) => {
-                    if (templateSpan.literal.text === '/.lib.swcrc') {
-                        return templateSpan
-                            .getFullText()
-                            .replace('.lib.swcrc', '.swcrc');
-                    }
-                    return '';
-                });
-                updatedJestConfig = tsquery_1.tsquery.replace(updatedJestConfig, ':matches(ExportAssignment, BinaryExpression:has(Identifier[name="module"]):has(Identifier[name="exports"]))', (node) => {
-                    return `
-
-// disable .swcrc look-up by SWC core because we're passing in swcJestConfig ourselves.
-// If we do not disable this, SWC Core will read .swcrc and won't transform our test files due to "exclude"
-if (swcJestConfig.swcrc === undefined) {
-  swcJestConfig.swcrc = false;
-}
-
-${node.getFullText()}
-`;
-                });
-                tree.write(executorOptions.jestConfig, updatedJestConfig);
-                changesMade = true;
-            }
-        }
-    });
-    if (changesMade) {
-        await (0, devkit_1.formatFiles)(tree);
-    }
-}
-exports.default = default_1;