@nx/js 16.4.0-beta.9 → 16.4.0

package/src/executors/tsc/lib/typescript-compilation.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTypescriptSolution = void 0;
+const tslib_1 = require("tslib");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const ts = require("typescript");
+const get_custom_transformers_factory_1 = require("./get-custom-transformers-factory");
+const typescript_diagnostic_reporters_1 = require("./typescript-diagnostic-reporters");
+// https://github.com/microsoft/TypeScript/blob/d45012c5e2ab122919ee4777a7887307c5f4a1e0/src/compiler/diagnosticMessages.json#L4050-L4053
+// Typescript diagnostic message for 5083: Cannot read file '{0}'.
+const TYPESCRIPT_CANNOT_READ_FILE = 5083;
+// https://github.com/microsoft/TypeScript/blob/d45012c5e2ab122919ee4777a7887307c5f4a1e0/src/compiler/diagnosticMessages.json#L4211-4214
+// Typescript diagnostic message for 6032: File change detected. Starting incremental compilation...
+const TYPESCRIPT_FILE_CHANGE_DETECTED_STARTING_INCREMENTAL_COMPILATION = 6032;
+function compileTypescriptSolution(context, watch, logger, hooks, reporters) {
+    if (watch) {
+        // create an AsyncIterable that doesn't complete, watch mode is only
+        // stopped by killing the process
+        return (0, async_iterable_1.createAsyncIterable)(({ next }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            hooks !== null && hooks !== void 0 ? hooks : (hooks = {});
+            const callerAfterProjectCompilationCallback = hooks.afterProjectCompilationCallback;
+            hooks.afterProjectCompilationCallback = (tsConfig, success) => {
+                callerAfterProjectCompilationCallback === null || callerAfterProjectCompilationCallback === void 0 ? void 0 : callerAfterProjectCompilationCallback(tsConfig, success);
+                next({ tsConfig, success });
+            };
+            compileTSWithWatch(context, logger, hooks, reporters);
+        }));
+    }
+    // turn it into an AsyncIterable
+    const compilationGenerator = compileTS(context, logger, hooks, reporters);
+    return {
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    return Promise.resolve(compilationGenerator.next());
+                },
+            };
+        },
+    };
+}
+exports.compileTypescriptSolution = compileTypescriptSolution;
+function* compileTS(context, logger, hooks, reporters) {
+    var _a, _b, _c;
+    let project;
+    const formatDiagnosticsHost = {
+        getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+        getNewLine: () => ts.sys.newLine,
+        getCanonicalFileName: (filename) => ts.sys.useCaseSensitiveFileNames ? filename : filename.toLowerCase(),
+    };
+    const solutionBuilderHost = ts.createSolutionBuilderHost(getSystem(context), 
+    /*createProgram*/ undefined, (diagnostic) => {
+        var _a;
+        const formattedDiagnostic = (0, typescript_diagnostic_reporters_1.formatDiagnosticReport)(diagnostic, formatDiagnosticsHost);
+        // handles edge case where a wrong a project reference path can't be read
+        if (diagnostic.code === TYPESCRIPT_CANNOT_READ_FILE) {
+            throw new Error(formattedDiagnostic);
+        }
+        logger.info(formattedDiagnostic, project.project);
+        (_a = reporters === null || reporters === void 0 ? void 0 : reporters.diagnosticReporter) === null || _a === void 0 ? void 0 : _a.call(reporters, project.project, diagnostic);
+    }, (diagnostic) => {
+        var _a;
+        const formattedDiagnostic = (0, typescript_diagnostic_reporters_1.formatSolutionBuilderStatusReport)(diagnostic);
+        logger.info(formattedDiagnostic, project.project);
+        (_a = reporters === null || reporters === void 0 ? void 0 : reporters.solutionBuilderStatusReporter) === null || _a === void 0 ? void 0 : _a.call(reporters, project.project, diagnostic);
+    });
+    const rootNames = Object.keys(context);
+    const solutionBuilder = ts.createSolutionBuilder(solutionBuilderHost, rootNames, {});
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        project = solutionBuilder.getNextInvalidatedProject();
+        if (!project) {
+            break;
+        }
+        const projectContext = context[project.project];
+        const projectName = projectContext === null || projectContext === void 0 ? void 0 : projectContext.project;
+        /**
+         * This only applies when the deprecated `prepend` option is set to `true`.
+         * Skip support.
+         */
+        if (project.kind === ts.InvalidatedProjectKind.UpdateBundle) {
+            logger.warn(`The project ${projectName} ` +
+                `is using the deprecated "prepend" Typescript compiler option. ` +
+                `This option is not supported by the batch executor and it's ignored.\n`, project.project);
+            continue;
+        }
+        (_a = hooks === null || hooks === void 0 ? void 0 : hooks.beforeProjectCompilationCallback) === null || _a === void 0 ? void 0 : _a.call(hooks, project.project);
+        if (project.kind === ts.InvalidatedProjectKind.UpdateOutputFileStamps) {
+            logger.info(`Updating output timestamps of project "${projectName}"...\n`, project.project);
+            // update output timestamps and mark project as complete
+            const status = project.done();
+            const success = status === ts.ExitStatus.Success;
+            if (success) {
+                logger.info(`Done updating output timestamps of project "${projectName}"...\n`, project.project);
+            }
+            (_b = hooks === null || hooks === void 0 ? void 0 : hooks.afterProjectCompilationCallback) === null || _b === void 0 ? void 0 : _b.call(hooks, project.project, success);
+            yield { success, tsConfig: project.project };
+            continue;
+        }
+        logger.info(`Compiling TypeScript files for project "${projectName}"...\n`, project.project);
+        // build and mark project as complete
+        const status = project.done(undefined, undefined, (0, get_custom_transformers_factory_1.getCustomTrasformersFactory)(projectContext.transformers)(project.getProgram()));
+        const success = status === ts.ExitStatus.Success;
+        if (success) {
+            logger.info(`Done compiling TypeScript files for project "${projectName}".\n`, project.project);
+        }
+        (_c = hooks === null || hooks === void 0 ? void 0 : hooks.afterProjectCompilationCallback) === null || _c === void 0 ? void 0 : _c.call(hooks, project.project, success);
+        yield {
+            success: status === ts.ExitStatus.Success,
+            tsConfig: project.project,
+        };
+    }
+}
+function compileTSWithWatch(context, logger, hooks, reporters) {
+    let project;
+    const solutionHost = ts.createSolutionBuilderWithWatchHost(getSystem(context), 
+    /*createProgram*/ undefined);
+    if (reporters === null || reporters === void 0 ? void 0 : reporters.diagnosticReporter) {
+        const originalDiagnosticReporter = solutionHost.reportDiagnostic;
+        solutionHost.reportDiagnostic = (diagnostic) => {
+            originalDiagnosticReporter(diagnostic);
+            reporters.diagnosticReporter(project.project, diagnostic);
+        };
+    }
+    if (reporters === null || reporters === void 0 ? void 0 : reporters.solutionBuilderStatusReporter) {
+        const originalSolutionBuilderStatusReporter = solutionHost.reportSolutionBuilderStatus;
+        solutionHost.reportDiagnostic = (diagnostic) => {
+            originalSolutionBuilderStatusReporter(diagnostic);
+            reporters.solutionBuilderStatusReporter(project.project, diagnostic);
+        };
+    }
+    const originalWatchStatusReporter = solutionHost.onWatchStatusChange;
+    solutionHost.onWatchStatusChange = (diagnostic, newLine, options, errorCount) => {
+        var _a;
+        originalWatchStatusReporter(diagnostic, newLine, options, errorCount);
+        if (diagnostic.code ===
+            TYPESCRIPT_FILE_CHANGE_DETECTED_STARTING_INCREMENTAL_COMPILATION) {
+            // there's a change, build invalidated projects
+            build();
+        }
+        (_a = reporters === null || reporters === void 0 ? void 0 : reporters.watchStatusReporter) === null || _a === void 0 ? void 0 : _a.call(reporters, project === null || project === void 0 ? void 0 : project.project, diagnostic, newLine, options, errorCount);
+    };
+    const rootNames = Object.keys(context);
+    const solutionBuilder = ts.createSolutionBuilderWithWatch(solutionHost, rootNames, {});
+    const build = () => {
+        var _a, _b;
+        while (true) {
+            project = solutionBuilder.getNextInvalidatedProject();
+            if (!project) {
+                break;
+            }
+            const projectContext = context[project.project];
+            const projectName = projectContext.project;
+            /**
+             * This only applies when the deprecated `prepend` option is set to `true`.
+             * Skip support.
+             */
+            if (project.kind === ts.InvalidatedProjectKind.UpdateBundle) {
+                logger.warn(`The project ${projectName} ` +
+                    `is using the deprecated "prepend" Typescript compiler option. ` +
+                    `This option is not supported by the batch executor and it's ignored.`);
+                continue;
+            }
+            hooks === null || hooks === void 0 ? void 0 : hooks.beforeProjectCompilationCallback(project.project);
+            if (project.kind === ts.InvalidatedProjectKind.UpdateOutputFileStamps) {
+                if (projectName) {
+                    logger.info(`Updating output timestamps of project "${projectName}"...\n`, project.project);
+                }
+                // update output timestamps and mark project as complete
+                const status = project.done();
+                const success = status === ts.ExitStatus.Success;
+                if (projectName && success) {
+                    logger.info(`Done updating output timestamps of project "${projectName}"...\n`, project.project);
+                }
+                (_a = hooks === null || hooks === void 0 ? void 0 : hooks.afterProjectCompilationCallback) === null || _a === void 0 ? void 0 : _a.call(hooks, project.project, success);
+                continue;
+            }
+            logger.info(`Compiling TypeScript files for project "${projectName}"...\n`, project.project);
+            // build and mark project as complete
+            const status = project.done(undefined, undefined, (0, get_custom_transformers_factory_1.getCustomTrasformersFactory)(projectContext.transformers)(project.getProgram()));
+            const success = status === ts.ExitStatus.Success;
+            if (success) {
+                logger.info(`Done compiling TypeScript files for project "${projectName}".\n`, project.project);
+            }
+            (_b = hooks === null || hooks === void 0 ? void 0 : hooks.afterProjectCompilationCallback) === null || _b === void 0 ? void 0 : _b.call(hooks, project.project, success);
+        }
+    };
+    // initial build
+    build();
+    /**
+     * This is a workaround to get the TS file watching to kick off. It won't
+     * build twice since the `build` call above will mark invalidated projects
+     * as completed and then, the implementation of the `solutionBuilder.build`
+     * skips them.
+     * We can't rely solely in `solutionBuilder.build()` because it doesn't
+     * accept custom transformers.
+     */
+    solutionBuilder.build();
+}
+function getSystem(context) {
+    return Object.assign(Object.assign({}, ts.sys), { readFile(path, encoding) {
+            if (context[path]) {
+                return context[path].tsConfig.content;
+            }
+            return ts.sys.readFile(path, encoding);
+        } });
+}

package/src/executors/tsc/lib/{batch/typescript-diagnostic-reporters.d.ts → typescript-diagnostic-reporters.d.ts}

@@ -1,4 +1,3 @@
 import * as ts from 'typescript';
 export declare function formatDiagnosticReport(diagnostic: ts.Diagnostic, host: ts.FormatDiagnosticsHost): string;
 export declare function formatSolutionBuilderStatusReport(diagnostic: ts.Diagnostic): string;
-export declare function formatWatchStatusReport(diagnostic: ts.Diagnostic, newLine: string): string;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatWatchStatusReport = exports.formatSolutionBuilderStatusReport = exports.formatDiagnosticReport = void 0;
+exports.formatSolutionBuilderStatusReport = exports.formatDiagnosticReport = void 0;
 const ts = require("typescript");
 // adapted from TS default diagnostic reporter
 function formatDiagnosticReport(diagnostic, host) {
@@ -20,13 +20,6 @@ function formatSolutionBuilderStatusReport(diagnostic) {
     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;

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

@@ -1,4 +1,5 @@
-import type { ExecutorContext, TaskGraph } from '@nx/devkit';
+import { ExecutorContext, TaskGraph } from '@nx/devkit';
+import type { BatchExecutorTaskResult } from 'nx/src/config/misc-interfaces';
 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 declare function tscBatchExecutor(taskGraph: TaskGraph, inputs: Record<string, ExecutorOptions>, overrides: ExecutorOptions, context: ExecutorContext): AsyncGenerator<BatchExecutorTaskResult, any, unknown>;
 export default tscBatchExecutor;

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

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tscBatchExecutor = void 0;
 const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
 const fs_1 = require("fs");
+const async_iterator_1 = require("nx/src/utils/async-iterator");
 const update_package_json_1 = require("../../utils/package-json/update-package-json");
+const lib_1 = require("./lib");
 const batch_1 = require("./lib/batch");
 function tscBatchExecutor(taskGraph, inputs, overrides, context) {
     return tslib_1.__asyncGenerator(this, arguments, function* tscBatchExecutor_1() {
@@ -17,11 +20,43 @@ function tscBatchExecutor(taskGraph, inputs, overrides, context) {
                 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);
+        const taskInMemoryTsConfigMap = (0, lib_1.getProcessedTaskTsConfigs)(Object.keys(taskGraph.tasks), tasksOptions, context);
+        const tsConfigTaskInfoMap = (0, batch_1.createTaskInfoPerTsConfigMap)(tasksOptions, context, Object.keys(taskGraph.tasks), taskInMemoryTsConfigMap);
+        const tsCompilationContext = createTypescriptCompilationContext(tsConfigTaskInfoMap, taskInMemoryTsConfigMap, context);
+        const logger = {
+            error: (message, tsConfig) => {
+                process.stderr.write(message);
+                if (tsConfig) {
+                    tsConfigTaskInfoMap[tsConfig].terminalOutput += message;
+                }
+            },
+            info: (message, tsConfig) => {
+                process.stdout.write(message);
+                if (tsConfig) {
+                    tsConfigTaskInfoMap[tsConfig].terminalOutput += message;
+                }
+            },
+            warn: (message, tsConfig) => {
+                process.stdout.write(message);
+                if (tsConfig) {
+                    tsConfigTaskInfoMap[tsConfig].terminalOutput += message;
+                }
+            },
+        };
+        const typescriptCompilation = (0, lib_1.compileTypescriptSolution)(tsCompilationContext, shouldWatch, logger, {
+            beforeProjectCompilationCallback: (tsConfig) => {
+                if (tsConfigTaskInfoMap[tsConfig]) {
+                    tsConfigTaskInfoMap[tsConfig].startTime = Date.now();
+                }
+            },
+            afterProjectCompilationCallback: (tsConfig) => {
+                if (tsConfigTaskInfoMap[tsConfig]) {
+                    const taskInfo = tsConfigTaskInfoMap[tsConfig];
+                    taskInfo.assetsHandler.processAllAssetsOnceSync();
+                    (0, update_package_json_1.updatePackageJson)(taskInfo.options, taskInfo.context, taskInfo.projectGraphNode, taskInfo.buildableProjectNodeDependencies);
+                    taskInfo.endTime = Date.now();
+                }
+            },
         });
         if (shouldWatch) {
             const taskInfos = Object.values(tsConfigTaskInfoMap);
@@ -32,16 +67,71 @@ function tscBatchExecutor(taskGraph, inputs, overrides, context) {
                 }
             }));
             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(mapAsyncIterable(typescriptCompilation, (iterator) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                // drain the iterator, we don't use the results
+                yield (0, async_iterator_1.getLastValueFromAsyncIterableIterator)(iterator);
+                return { value: undefined, done: true };
+            }))))));
         }
-        return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues(typescriptCompilation.iterator))));
+        return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues(mapAsyncIterable(typescriptCompilation, (iterator) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { value, done } = yield iterator.next();
+            if (done) {
+                return { value, done: true };
+            }
+            const taskResult = {
+                task: tsConfigTaskInfoMap[value.tsConfig].task,
+                result: {
+                    success: value.success,
+                    terminalOutput: tsConfigTaskInfoMap[value.tsConfig].terminalOutput,
+                    startTime: tsConfigTaskInfoMap[value.tsConfig].startTime,
+                    endTime: tsConfigTaskInfoMap[value.tsConfig].endTime,
+                },
+            };
+            return { value: taskResult, done: false };
+        }))))));
     });
 }
 exports.tscBatchExecutor = tscBatchExecutor;
 exports.default = tscBatchExecutor;
+function mapAsyncIterable(iterable, nextFn) {
+    return tslib_1.__asyncGenerator(this, arguments, function* mapAsyncIterable_1() {
+        return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues({
+            [Symbol.asyncIterator]() {
+                const iterator = iterable[Symbol.asyncIterator].call(iterable);
+                return {
+                    next() {
+                        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                            return yield nextFn(iterator);
+                        });
+                    },
+                };
+            },
+        }))));
+    });
+}
+function createTypescriptCompilationContext(tsConfigTaskInfoMap, taskInMemoryTsConfigMap, context) {
+    const tsCompilationContext = Object.entries(tsConfigTaskInfoMap).reduce((acc, [tsConfig, taskInfo]) => {
+        acc[tsConfig] = {
+            project: taskInfo.context.projectName,
+            tsConfig: taskInfo.tsConfig,
+            transformers: taskInfo.options.transformers,
+        };
+        return acc;
+    }, {});
+    Object.entries(taskInMemoryTsConfigMap).forEach(([task, tsConfig]) => {
+        if (!tsCompilationContext[tsConfig.path]) {
+            tsCompilationContext[tsConfig.path] = {
+                project: (0, devkit_1.parseTargetString)(task, context.projectGraph).project,
+                transformers: [],
+                tsConfig: tsConfig,
+            };
+        }
+    });
+    return tsCompilationContext;
+}

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

@@ -7,6 +7,7 @@ const fs_extra_1 = require("fs-extra");
 const child_process_1 = require("child_process");
 const detectPort = require("detect-port");
 const path_1 = require("path");
+const semver_1 = require("semver");
 let childProcess;
 /**
  * - set npm and yarn to use local registry
@@ -28,6 +29,11 @@ function verdaccioExecutor(options, context) {
                 console.log(`Cleared local registry storage folder ${options.storage}`);
             }
         }
+        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;
+        }
         const cleanupFunctions = options.location === 'none' ? [] : [setupNpm(options), setupYarn(options)];
         const processExitListener = (signal) => {
             if (childProcess) {
@@ -42,11 +48,6 @@ function verdaccioExecutor(options, context) {
         process.on('SIGINT', processExitListener);
         process.on('SIGHUP', processExitListener);
         try {
-            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) {
@@ -134,36 +135,71 @@ function setupNpm(options) {
         }
     };
 }
+function getYarnUnsafeHttpWhitelist(isYarnV1) {
+    return !isYarnV1
+        ? new Set(JSON.parse((0, child_process_1.execSync)(`yarn config get unsafeHttpWhitelist --json`).toString()))
+        : null;
+}
+function setYarnUnsafeHttpWhitelist(currentWhitelist, options) {
+    if (currentWhitelist.size > 1) {
+        (0, child_process_1.execSync)(`yarn config set unsafeHttpWhitelist --json '${JSON.stringify(Array.from(currentWhitelist))}'` + (options.location === 'user' ? ' --home' : ''));
+    }
+    else {
+        (0, child_process_1.execSync)(`yarn config unset unsafeHttpWhitelist` +
+            (options.location === 'user' ? ' --home' : ''));
+    }
+}
 function setupYarn(options) {
     var _a, _b, _c;
+    let isYarnV1;
     try {
-        (0, child_process_1.execSync)('yarn --version');
+        isYarnV1 = (0, semver_1.major)((0, child_process_1.execSync)('yarn --version').toString().trim()) === 1;
     }
-    catch (e) {
+    catch (_d) {
+        // This would fail if yarn is not installed which is okay
         return () => { };
     }
-    let yarnRegistryPath;
     try {
-        yarnRegistryPath = (_c = (_b = (_a = (0, child_process_1.execSync)(`yarn config get registry`)) === null || _a === void 0 ? void 0 : _a.toString()) === null || _b === void 0 ? void 0 : _b.trim()) === null || _c === void 0 ? void 0 : _c.replace('\u001b[2K\u001b[1G', ''); // strip out ansi codes
-        (0, child_process_1.execSync)(`yarn config set registry http://localhost:${options.port}/`);
+        const registryConfigName = isYarnV1 ? 'registry' : 'npmRegistryServer';
+        const yarnRegistryPath = (_c = (_b = (_a = (0, child_process_1.execSync)(`yarn config get ${registryConfigName}`)) === null || _a === void 0 ? void 0 : _a.toString()) === null || _b === void 0 ? void 0 : _b.trim()) === null || _c === void 0 ? void 0 : _c.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' : ''));
         devkit_1.logger.info(`Set yarn registry to http://localhost:${options.port}/`);
+        const currentWhitelist = getYarnUnsafeHttpWhitelist(isYarnV1);
+        let whitelistedLocalhost = false;
+        if (!isYarnV1 && !currentWhitelist.has('localhost')) {
+            whitelistedLocalhost = true;
+            currentWhitelist.add('localhost');
+            setYarnUnsafeHttpWhitelist(currentWhitelist, options);
+            devkit_1.logger.info(`Whitelisted http://localhost:${options.port}/ as an unsafe http server`);
+        }
+        return () => {
+            try {
+                if (yarnRegistryPath) {
+                    (0, child_process_1.execSync)(`yarn config set ${registryConfigName} ${yarnRegistryPath}` +
+                        (options.location === 'user' ? ' --home' : ''));
+                    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' : ''));
+                }
+                if (whitelistedLocalhost) {
+                    const currentWhitelist = getYarnUnsafeHttpWhitelist(isYarnV1);
+                    if (currentWhitelist.has('localhost')) {
+                        currentWhitelist.delete('localhost');
+                        setYarnUnsafeHttpWhitelist(currentWhitelist, options);
+                        devkit_1.logger.info(`Removed http://localhost:${options.port}/ as an unsafe http server`);
+                    }
+                }
+            }
+            catch (e) {
+                throw new Error(`Failed to reset yarn registry: ${e.message}`);
+            }
+        };
     }
     catch (e) {
         throw new Error(`Failed to set yarn registry to http://localhost:${options.port}/: ${e.message}`);
     }
-    return () => {
-        try {
-            if (yarnRegistryPath) {
-                (0, child_process_1.execSync)(`yarn config set registry ${yarnRegistryPath}`);
-                devkit_1.logger.info(`Reset yarn registry to ${yarnRegistryPath}`);
-            }
-            else {
-                (0, child_process_1.execSync)(`yarn config delete registry`);
-            }
-        }
-        catch (e) {
-            throw new Error(`Failed to reset yarn registry: ${e.message}`);
-        }
-    };
 }
 exports.default = verdaccioExecutor;

package/src/generators/setup-verdaccio/files/config.yml

@@ -1,10 +1,6 @@
 # path to a directory with all packages
 storage: ../tmp/local-registry/storage
 
-auth:
-  htpasswd:
-    file: ./htpasswd
-
 # a list of other known repositories we can talk to
 uplinks:
   npmjs:
@@ -26,4 +22,7 @@ packages:
 logs:
   type: stdout
   format: pretty
-  level: http
+  level: warn
+
+publish:
+  allow_offline: true # set offline to true to allow publish offline

package/src/internal.d.ts

@@ -1,3 +1,4 @@
 export { resolveModuleByImport } from './utils/typescript/ast-utils';
 export { registerTsProject, registerTsConfigPaths, } from 'nx/src/plugins/js/utils/register';
 export { TargetProjectLocator } from 'nx/src/plugins/js/project-graph/build-dependencies/target-project-locator';
+export { findProjectsNpmDependencies } from 'nx/src/plugins/js/package-json/create-package-json';

package/src/internal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TargetProjectLocator = exports.registerTsConfigPaths = exports.registerTsProject = exports.resolveModuleByImport = void 0;
+exports.findProjectsNpmDependencies = exports.TargetProjectLocator = exports.registerTsConfigPaths = exports.registerTsProject = exports.resolveModuleByImport = void 0;
 var ast_utils_1 = require("./utils/typescript/ast-utils");
 Object.defineProperty(exports, "resolveModuleByImport", { enumerable: true, get: function () { return ast_utils_1.resolveModuleByImport; } });
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
@@ -10,3 +10,6 @@ Object.defineProperty(exports, "registerTsConfigPaths", { enumerable: true, get:
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 var target_project_locator_1 = require("nx/src/plugins/js/project-graph/build-dependencies/target-project-locator");
 Object.defineProperty(exports, "TargetProjectLocator", { enumerable: true, get: function () { return target_project_locator_1.TargetProjectLocator; } });
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+var create_package_json_1 = require("nx/src/plugins/js/package-json/create-package-json");
+Object.defineProperty(exports, "findProjectsNpmDependencies", { enumerable: true, get: function () { return create_package_json_1.findProjectsNpmDependencies; } });

package/src/plugins/jest/start-local-registry.js

@@ -28,8 +28,12 @@ function startLocalRegistry({ localRegistryTarget, storage, verbose, }) {
                 console.log('Local registry started on port ' + port);
                 const registry = `http://localhost:${port}`;
                 process.env.npm_config_registry = registry;
-                process.env.YARN_REGISTRY = registry;
                 (0, child_process_1.execSync)(`npm config set //localhost:${port}/:_authToken "secretVerdaccioToken"`);
+                // yarnv1
+                process.env.YARN_REGISTRY = registry;
+                // yarnv2
+                process.env.YARN_NPM_REGISTRY_SERVER = registry;
+                process.env.YARN_UNSAFE_HTTP_WHITELIST = 'localhost';
                 console.log('Set npm and yarn config registry to ' + registry);
                 resolve(() => {
                     childProcess.kill();

package/src/utils/compiler-helper-dependency.d.ts

@@ -1,4 +1,4 @@
-import { ProjectGraph, ProjectGraphDependency } from '@nx/devkit';
+import { type ProjectGraph, type ProjectGraphDependency } from '@nx/devkit';
 import { DependentBuildableProjectNode } from './buildable-libs-utils';
 export declare enum HelperDependency {
     tsc = "npm:tslib",
@@ -11,6 +11,7 @@ export declare enum HelperDependency {
  * @param {HelperDependency} helperDependency
  * @param {string} configPath
  * @param {DependentBuildableProjectNode[]} dependencies
+ * @param {ProjectGraph} projectGraph
  * @param {boolean=false} returnDependencyIfFound
  */
 export declare function getHelperDependency(helperDependency: HelperDependency, configPath: string, dependencies: DependentBuildableProjectNode[], projectGraph: ProjectGraph, returnDependencyIfFound?: boolean): DependentBuildableProjectNode | null;

package/src/utils/compiler-helper-dependency.js

@@ -9,7 +9,7 @@ var HelperDependency;
 (function (HelperDependency) {
     HelperDependency["tsc"] = "npm:tslib";
     HelperDependency["swc"] = "npm:@swc/helpers";
-})(HelperDependency = exports.HelperDependency || (exports.HelperDependency = {}));
+})(HelperDependency || (exports.HelperDependency = HelperDependency = {}));
 const jsExecutors = {
     '@nx/js:tsc': {
         helperDependency: HelperDependency.tsc,
@@ -27,6 +27,7 @@ const jsExecutors = {
  * @param {HelperDependency} helperDependency
  * @param {string} configPath
  * @param {DependentBuildableProjectNode[]} dependencies
+ * @param {ProjectGraph} projectGraph
  * @param {boolean=false} returnDependencyIfFound
  */
 function getHelperDependency(helperDependency, configPath, dependencies, projectGraph, returnDependencyIfFound = false) {
@@ -50,7 +51,17 @@ function getHelperDependency(helperDependency, configPath, dependencies, project
     }
     if (!isHelperNeeded)
         return null;
-    const libNode = projectGraph.externalNodes[helperDependency];
+    let libNode = projectGraph[helperDependency];
+    // If libNode is not found due to the version suffix from pnpm lockfile, try to match it by package name.
+    if (!libNode) {
+        for (const nodeName of Object.keys(projectGraph.externalNodes)) {
+            const node = projectGraph.externalNodes[nodeName];
+            if (`npm:${node.data.packageName}` === helperDependency) {
+                libNode = node;
+                break;
+            }
+        }
+    }
     if (!libNode) {
         devkit_1.logger.warn(`Your library compilation option specifies that the compiler external helper (${helperDependency.split(':')[1]}) is needed but it is not installed.`);
         return null;
@@ -74,8 +85,7 @@ function getHelperDependenciesFromProjectGraph(contextRoot, sourceProject, proje
     const internalDependencies = sourceDependencies.reduce((result, dependency) => {
         // we check if a dependency is part of the workspace and if it's a library
         // because we wouldn't want to include external dependencies (npm packages)
-        if (!dependency.target.startsWith('npm:') &&
-            !!projectGraph.nodes[dependency.target] &&
+        if (projectGraph.nodes[dependency.target] &&
             projectGraph.nodes[dependency.target].type === 'lib') {
             const targetData = projectGraph.nodes[dependency.target].data;
             // check if the dependency has a buildable target with one of the jsExecutors

package/src/utils/versions.d.ts

@@ -8,7 +8,7 @@ export declare const swcNodeVersion = "~1.4.2";
 export declare const tsLibVersion = "^2.3.0";
 export declare const typesNodeVersion = "18.7.1";
 export declare const verdaccioVersion = "^5.0.4";
-export declare const typescriptVersion = "~5.0.2";
+export declare const typescriptVersion = "~5.1.3";
 /**
  * The minimum version is currently determined from the lowest version
  * that's supported by the lowest Angular supported version, e.g.

package/src/utils/versions.js

@@ -12,7 +12,7 @@ exports.tsLibVersion = '^2.3.0';
 exports.typesNodeVersion = '18.7.1';
 exports.verdaccioVersion = '^5.0.4';
 // Typescript
-exports.typescriptVersion = '~5.0.2';
+exports.typescriptVersion = '~5.1.3';
 /**
  * The minimum version is currently determined from the lowest version
  * that's supported by the lowest Angular supported version, e.g.

package/src/executors/tsc/lib/batch/generate-temp-tsconfig.d.ts

@@ -1,3 +0,0 @@
-import type { ExecutorContext } from '@nx/devkit';
-import type { NormalizedExecutorOptions } from '../../../../utils/schema';
-export declare function generateTempTsConfig(taskOptionsMap: Record<string, NormalizedExecutorOptions>, taskName: string, taskOptions: NormalizedExecutorOptions, context: ExecutorContext): string;