@nx/js 16.8.0-beta.3 → 16.8.0-beta.5

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileSwcWatch = exports.compileSwc = void 0;
-const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const child_process_1 = require("child_process");
 const fs_extra_1 = require("fs-extra");
@@ -31,117 +30,113 @@ function getTypeCheckOptions(normalizedOptions) {
     }
     return typeCheckOptions;
 }
-function compileSwc(context, normalizedOptions, postCompilationCallback) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        devkit_1.logger.log(`Compiling with SWC for ${context.projectName}...`);
-        if (normalizedOptions.clean) {
-            (0, fs_extra_1.removeSync)(normalizedOptions.outputPath);
-        }
-        const swcCmdLog = (0, child_process_1.execSync)(getSwcCmd(normalizedOptions.swcCliOptions), {
-            encoding: 'utf8',
-            cwd: normalizedOptions.swcCliOptions.swcCwd,
-        });
-        devkit_1.logger.log(swcCmdLog.replace(/\n/, ''));
-        const isCompileSuccess = swcCmdLog.includes('Successfully compiled');
-        if (normalizedOptions.skipTypeCheck) {
-            yield postCompilationCallback();
-            return { success: isCompileSuccess };
-        }
-        const { errors, warnings } = yield (0, run_type_check_1.runTypeCheck)(getTypeCheckOptions(normalizedOptions));
-        const hasErrors = errors.length > 0;
-        const hasWarnings = warnings.length > 0;
-        if (hasErrors || hasWarnings) {
-            yield (0, print_diagnostics_1.printDiagnostics)(errors, warnings);
-        }
-        yield postCompilationCallback();
-        return {
-            success: !hasErrors && isCompileSuccess,
-            outfile: normalizedOptions.mainOutputPath,
-        };
+async function compileSwc(context, normalizedOptions, postCompilationCallback) {
+    devkit_1.logger.log(`Compiling with SWC for ${context.projectName}...`);
+    if (normalizedOptions.clean) {
+        (0, fs_extra_1.removeSync)(normalizedOptions.outputPath);
+    }
+    const swcCmdLog = (0, child_process_1.execSync)(getSwcCmd(normalizedOptions.swcCliOptions), {
+        encoding: 'utf8',
+        cwd: normalizedOptions.swcCliOptions.swcCwd,
     });
+    devkit_1.logger.log(swcCmdLog.replace(/\n/, ''));
+    const isCompileSuccess = swcCmdLog.includes('Successfully compiled');
+    if (normalizedOptions.skipTypeCheck) {
+        await postCompilationCallback();
+        return { success: isCompileSuccess };
+    }
+    const { errors, warnings } = await (0, run_type_check_1.runTypeCheck)(getTypeCheckOptions(normalizedOptions));
+    const hasErrors = errors.length > 0;
+    const hasWarnings = warnings.length > 0;
+    if (hasErrors || hasWarnings) {
+        await (0, print_diagnostics_1.printDiagnostics)(errors, warnings);
+    }
+    await postCompilationCallback();
+    return {
+        success: !hasErrors && isCompileSuccess,
+        outfile: normalizedOptions.mainOutputPath,
+    };
 }
 exports.compileSwc = compileSwc;
-function compileSwcWatch(context, normalizedOptions, postCompilationCallback) {
-    return tslib_1.__asyncGenerator(this, arguments, function* compileSwcWatch_1() {
-        const getResult = (success) => ({
-            success,
-            outfile: normalizedOptions.mainOutputPath,
-        });
-        let typeCheckOptions;
-        let initialPostCompile = true;
-        if (normalizedOptions.clean) {
-            (0, fs_extra_1.removeSync)(normalizedOptions.outputPath);
-        }
-        return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues((0, async_iterable_1.createAsyncIterable)(({ next, done }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let processOnExit;
-            let stdoutOnData;
-            let stderrOnData;
-            let watcherOnExit;
-            const swcWatcher = (0, child_process_1.exec)(getSwcCmd(normalizedOptions.swcCliOptions, true), { cwd: normalizedOptions.swcCliOptions.swcCwd });
-            processOnExit = () => {
-                swcWatcher.kill();
-                done();
-                process.off('SIGINT', processOnExit);
-                process.off('SIGTERM', processOnExit);
-                process.off('exit', processOnExit);
-            };
-            stdoutOnData = (data) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                process.stdout.write(data);
-                if (!data.startsWith('Watching')) {
-                    const swcStatus = data.includes('Successfully');
-                    if (initialPostCompile) {
-                        yield postCompilationCallback();
-                        initialPostCompile = false;
-                    }
-                    if (normalizedOptions.skipTypeCheck) {
-                        next(getResult(swcStatus));
-                        return;
-                    }
-                    if (!typeCheckOptions) {
-                        typeCheckOptions = getTypeCheckOptions(normalizedOptions);
-                    }
-                    const delayed = delay(5000);
-                    next(getResult(yield Promise.race([
-                        delayed
-                            .start()
-                            .then(() => ({ tscStatus: false, type: 'timeout' })),
-                        (0, run_type_check_1.runTypeCheck)(typeCheckOptions).then(({ errors, warnings }) => {
-                            const hasErrors = errors.length > 0;
-                            if (hasErrors) {
-                                (0, print_diagnostics_1.printDiagnostics)(errors, warnings);
-                            }
-                            return {
-                                tscStatus: !hasErrors,
-                                type: 'tsc',
-                            };
-                        }),
-                    ]).then(({ type, tscStatus }) => {
-                        if (type === 'tsc') {
-                            delayed.cancel();
-                            return tscStatus && swcStatus;
-                        }
-                        return swcStatus;
-                    })));
+async function* compileSwcWatch(context, normalizedOptions, postCompilationCallback) {
+    const getResult = (success) => ({
+        success,
+        outfile: normalizedOptions.mainOutputPath,
+    });
+    let typeCheckOptions;
+    let initialPostCompile = true;
+    if (normalizedOptions.clean) {
+        (0, fs_extra_1.removeSync)(normalizedOptions.outputPath);
+    }
+    return yield* (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
+        let processOnExit;
+        let stdoutOnData;
+        let stderrOnData;
+        let watcherOnExit;
+        const swcWatcher = (0, child_process_1.exec)(getSwcCmd(normalizedOptions.swcCliOptions, true), { cwd: normalizedOptions.swcCliOptions.swcCwd });
+        processOnExit = () => {
+            swcWatcher.kill();
+            done();
+            process.off('SIGINT', processOnExit);
+            process.off('SIGTERM', processOnExit);
+            process.off('exit', processOnExit);
+        };
+        stdoutOnData = async (data) => {
+            process.stdout.write(data);
+            if (!data.startsWith('Watching')) {
+                const swcStatus = data.includes('Successfully');
+                if (initialPostCompile) {
+                    await postCompilationCallback();
+                    initialPostCompile = false;
                 }
-            });
-            stderrOnData = (err) => {
-                process.stderr.write(err);
-                if (err.includes('Debugger attached.')) {
+                if (normalizedOptions.skipTypeCheck) {
+                    next(getResult(swcStatus));
                     return;
                 }
-                next(getResult(false));
-            };
-            watcherOnExit = () => {
-                done();
-                swcWatcher.off('exit', watcherOnExit);
-            };
-            swcWatcher.stdout.on('data', stdoutOnData);
-            swcWatcher.stderr.on('data', stderrOnData);
-            process.on('SIGINT', processOnExit);
-            process.on('SIGTERM', processOnExit);
-            process.on('exit', processOnExit);
-            swcWatcher.on('exit', watcherOnExit);
-        }))))));
+                if (!typeCheckOptions) {
+                    typeCheckOptions = getTypeCheckOptions(normalizedOptions);
+                }
+                const delayed = delay(5000);
+                next(getResult(await Promise.race([
+                    delayed
+                        .start()
+                        .then(() => ({ tscStatus: false, type: 'timeout' })),
+                    (0, run_type_check_1.runTypeCheck)(typeCheckOptions).then(({ errors, warnings }) => {
+                        const hasErrors = errors.length > 0;
+                        if (hasErrors) {
+                            (0, print_diagnostics_1.printDiagnostics)(errors, warnings);
+                        }
+                        return {
+                            tscStatus: !hasErrors,
+                            type: 'tsc',
+                        };
+                    }),
+                ]).then(({ type, tscStatus }) => {
+                    if (type === 'tsc') {
+                        delayed.cancel();
+                        return tscStatus && swcStatus;
+                    }
+                    return swcStatus;
+                })));
+            }
+        };
+        stderrOnData = (err) => {
+            process.stderr.write(err);
+            if (err.includes('Debugger attached.')) {
+                return;
+            }
+            next(getResult(false));
+        };
+        watcherOnExit = () => {
+            done();
+            swcWatcher.off('exit', watcherOnExit);
+        };
+        swcWatcher.stdout.on('data', stdoutOnData);
+        swcWatcher.stderr.on('data', stderrOnData);
+        process.on('SIGINT', processOnExit);
+        process.on('SIGTERM', processOnExit);
+        process.on('exit', processOnExit);
+        swcWatcher.on('exit', watcherOnExit);
     });
 }
 exports.compileSwcWatch = compileSwcWatch;

package/src/utils/typescript/compile-typescript-files.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileTypeScriptFiles = void 0;
-const tslib_1 = require("tslib");
 const compilation_1 = require("@nx/workspace/src/utilities/typescript/compilation");
 const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
 const TYPESCRIPT_FOUND_N_ERRORS_WATCHING_FOR_FILE_CHANGES = 6194;
@@ -18,14 +17,14 @@ function compileTypeScriptFiles(normalizedOptions, tscOptions, postCompilationCa
     });
     let tearDown;
     return {
-        iterator: (0, async_iterable_1.createAsyncIterable)(({ next, done }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        iterator: (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
             if (normalizedOptions.watch) {
-                const host = (0, compilation_1.compileTypeScriptWatcher)(tscOptions, (d) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const host = (0, compilation_1.compileTypeScriptWatcher)(tscOptions, async (d) => {
                     if (d.code === TYPESCRIPT_FOUND_N_ERRORS_WATCHING_FOR_FILE_CHANGES) {
-                        yield postCompilationCallback();
+                        await postCompilationCallback();
                         next(getResult(getErrorCountFromMessage(d.messageText) === 0));
                     }
-                }));
+                });
                 tearDown = () => {
                     host.close();
                     done();
@@ -33,12 +32,12 @@ function compileTypeScriptFiles(normalizedOptions, tscOptions, postCompilationCa
             }
             else {
                 const { success } = (0, compilation_1.compileTypeScript)(tscOptions);
-                yield postCompilationCallback();
+                await postCompilationCallback();
                 next(getResult(success));
                 done();
             }
-        })),
-        close: () => tearDown === null || tearDown === void 0 ? void 0 : tearDown(),
+        }),
+        close: () => tearDown?.(),
     };
 }
 exports.compileTypeScriptFiles = compileTypeScriptFiles;

package/src/utils/typescript/print-diagnostics.js

@@ -1,21 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printDiagnostics = void 0;
-const tslib_1 = require("tslib");
-function printDiagnostics(errors = [], warnings = []) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (errors.length > 0) {
-            errors.forEach((err) => {
-                console.log(`${err}\n`);
-            });
-            console.log(`Found ${errors.length} error${errors.length > 1 ? 's' : ''}.`);
-        }
-        else if (warnings.length > 0) {
-            warnings.forEach((err) => {
-                console.log(`${err}\n`);
-            });
-            console.log(`Found ${warnings.length} warnings.`);
-        }
-    });
+async function printDiagnostics(errors = [], warnings = []) {
+    if (errors.length > 0) {
+        errors.forEach((err) => {
+            console.log(`${err}\n`);
+        });
+        console.log(`Found ${errors.length} error${errors.length > 1 ? 's' : ''}.`);
+    }
+    else if (warnings.length > 0) {
+        warnings.forEach((err) => {
+            console.log(`${err}\n`);
+        });
+        console.log(`Found ${warnings.length} warnings.`);
+    }
 }
 exports.printDiagnostics = printDiagnostics;

package/src/utils/typescript/run-type-check.js

@@ -1,74 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFormattedDiagnostic = exports.runTypeCheck = exports.runTypeCheckWatch = void 0;
-const tslib_1 = require("tslib");
 const chalk = require("chalk");
 const path = require("path");
 const code_frames_1 = require("nx/src/utils/code-frames");
 const highlight_1 = require("../code-frames/highlight");
 const ts_config_1 = require("../../utils/typescript/ts-config");
-function runTypeCheckWatch(options, callback) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const { ts, workspaceRoot, config, compilerOptions } = yield setupTypeScript(options);
-        const host = ts.createWatchCompilerHost(config.fileNames, compilerOptions, ts.sys, ts.createEmitAndSemanticDiagnosticsBuilderProgram);
-        const originalOnWatchStatusChange = host.onWatchStatusChange;
-        host.onWatchStatusChange = (diagnostic, newLine, opts, errorCount) => {
-            originalOnWatchStatusChange === null || originalOnWatchStatusChange === void 0 ? void 0 : originalOnWatchStatusChange(diagnostic, newLine, opts, errorCount);
-            callback(diagnostic, getFormattedDiagnostic(ts, workspaceRoot, diagnostic), errorCount);
-        };
-        const watchProgram = ts.createWatchProgram(host);
-        const program = watchProgram.getProgram().getProgram();
-        const diagnostics = ts.getPreEmitDiagnostics(program);
-        return {
-            close: watchProgram.close.bind(watchProgram),
-            preEmitErrors: diagnostics
-                .filter((d) => d.category === ts.DiagnosticCategory.Error)
-                .map((d) => getFormattedDiagnostic(ts, workspaceRoot, d)),
-            preEmitWarnings: diagnostics
-                .filter((d) => d.category === ts.DiagnosticCategory.Warning)
-                .map((d) => getFormattedDiagnostic(ts, workspaceRoot, d)),
-        };
-    });
+async function runTypeCheckWatch(options, callback) {
+    const { ts, workspaceRoot, config, compilerOptions } = await setupTypeScript(options);
+    const host = ts.createWatchCompilerHost(config.fileNames, compilerOptions, ts.sys, ts.createEmitAndSemanticDiagnosticsBuilderProgram);
+    const originalOnWatchStatusChange = host.onWatchStatusChange;
+    host.onWatchStatusChange = (diagnostic, newLine, opts, errorCount) => {
+        originalOnWatchStatusChange?.(diagnostic, newLine, opts, errorCount);
+        callback(diagnostic, getFormattedDiagnostic(ts, workspaceRoot, diagnostic), errorCount);
+    };
+    const watchProgram = ts.createWatchProgram(host);
+    const program = watchProgram.getProgram().getProgram();
+    const diagnostics = ts.getPreEmitDiagnostics(program);
+    return {
+        close: watchProgram.close.bind(watchProgram),
+        preEmitErrors: diagnostics
+            .filter((d) => d.category === ts.DiagnosticCategory.Error)
+            .map((d) => getFormattedDiagnostic(ts, workspaceRoot, d)),
+        preEmitWarnings: diagnostics
+            .filter((d) => d.category === ts.DiagnosticCategory.Warning)
+            .map((d) => getFormattedDiagnostic(ts, workspaceRoot, d)),
+    };
 }
 exports.runTypeCheckWatch = runTypeCheckWatch;
-function runTypeCheck(options) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const { ts, workspaceRoot, cacheDir, config, compilerOptions } = yield setupTypeScript(options);
-        let program;
-        let incremental = false;
-        if (compilerOptions.incremental && cacheDir) {
-            incremental = true;
-            program = ts.createIncrementalProgram({
-                rootNames: config.fileNames,
-                options: Object.assign(Object.assign({}, compilerOptions), { incremental: true, tsBuildInfoFile: path.join(cacheDir, '.tsbuildinfo') }),
-            });
-        }
-        else {
-            program = ts.createProgram(config.fileNames, compilerOptions);
-        }
-        const result = program.emit();
-        const allDiagnostics = ts
-            .getPreEmitDiagnostics(program)
-            .concat(result.diagnostics);
-        return getTypeCheckResult(ts, allDiagnostics, workspaceRoot, config.fileNames.length, program.getSourceFiles().length, incremental);
-    });
+async function runTypeCheck(options) {
+    const { ts, workspaceRoot, cacheDir, config, compilerOptions } = await setupTypeScript(options);
+    let program;
+    let incremental = false;
+    if (compilerOptions.incremental && cacheDir) {
+        incremental = true;
+        program = ts.createIncrementalProgram({
+            rootNames: config.fileNames,
+            options: {
+                ...compilerOptions,
+                incremental: true,
+                tsBuildInfoFile: path.join(cacheDir, '.tsbuildinfo'),
+            },
+        });
+    }
+    else {
+        program = ts.createProgram(config.fileNames, compilerOptions);
+    }
+    const result = program.emit();
+    const allDiagnostics = ts
+        .getPreEmitDiagnostics(program)
+        .concat(result.diagnostics);
+    return getTypeCheckResult(ts, allDiagnostics, workspaceRoot, config.fileNames.length, program.getSourceFiles().length, incremental);
 }
 exports.runTypeCheck = runTypeCheck;
-function setupTypeScript(options) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const ts = yield Promise.resolve().then(() => require('typescript'));
-        const { workspaceRoot, tsConfigPath, cacheDir, incremental, rootDir } = options;
-        const config = (0, ts_config_1.readTsConfig)(tsConfigPath);
-        if (config.errors.length) {
-            const errorMessages = config.errors.map((e) => e.messageText).join('\n');
-            throw new Error(`Invalid config file due to following: ${errorMessages}`);
-        }
-        const emitOptions = options.mode === 'emitDeclarationOnly'
-            ? { emitDeclarationOnly: true, declaration: true, outDir: options.outDir }
-            : { noEmit: true };
-        const compilerOptions = Object.assign(Object.assign(Object.assign(Object.assign({}, config.options), { skipLibCheck: true }), emitOptions), { incremental, rootDir: rootDir || config.options.rootDir });
-        return { ts, workspaceRoot, cacheDir, config, compilerOptions };
-    });
+async function setupTypeScript(options) {
+    const ts = await Promise.resolve().then(() => require('typescript'));
+    const { workspaceRoot, tsConfigPath, cacheDir, incremental, rootDir } = options;
+    const config = (0, ts_config_1.readTsConfig)(tsConfigPath);
+    if (config.errors.length) {
+        const errorMessages = config.errors.map((e) => e.messageText).join('\n');
+        throw new Error(`Invalid config file due to following: ${errorMessages}`);
+    }
+    const emitOptions = options.mode === 'emitDeclarationOnly'
+        ? { emitDeclarationOnly: true, declaration: true, outDir: options.outDir }
+        : { noEmit: true };
+    const compilerOptions = {
+        ...config.options,
+        skipLibCheck: true,
+        ...emitOptions,
+        incremental,
+        rootDir: rootDir || config.options.rootDir,
+    };
+    return { ts, workspaceRoot, cacheDir, config, compilerOptions };
 }
 function getTypeCheckResult(ts, allDiagnostics, workspaceRoot, inputFilesCount, totalFilesCount, incremental = false) {
     const errors = allDiagnostics

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

@@ -46,9 +46,8 @@ function getRootTsConfigFileName(tree) {
 exports.getRootTsConfigFileName = getRootTsConfigFileName;
 function addTsConfigPath(tree, importPath, lookupPaths) {
     (0, devkit_1.updateJson)(tree, getRootTsConfigPathInTree(tree), (json) => {
-        var _a;
         const c = json.compilerOptions;
-        (_a = c.paths) !== null && _a !== void 0 ? _a : (c.paths = {});
+        c.paths ??= {};
         if (c.paths[importPath]) {
             throw new Error(`You already have a library using the import path "${importPath}". Make sure to specify a unique one.`);
         }
@@ -58,8 +57,7 @@ function addTsConfigPath(tree, importPath, lookupPaths) {
 }
 exports.addTsConfigPath = addTsConfigPath;
 function readTsConfigPaths(tsConfig) {
-    var _a;
-    tsConfig !== null && tsConfig !== void 0 ? tsConfig : (tsConfig = getRootTsConfigPath());
+    tsConfig ??= getRootTsConfigPath();
     try {
         if (!tsModule) {
             tsModule = (0, ensure_typescript_1.ensureTypescript)();
@@ -72,7 +70,7 @@ function readTsConfigPaths(tsConfig) {
         else {
             config = tsConfig;
         }
-        if ((_a = config.options) === null || _a === void 0 ? void 0 : _a.paths) {
+        if (config.options?.paths) {
             return config.options.paths;
         }
         else {

package/src/utils/typescript/tsnode-register.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsNodeRegister = void 0;
 function tsNodeRegister(file, tsConfig) {
-    if (!(file === null || file === void 0 ? void 0 : file.endsWith('.ts')))
+    if (!file?.endsWith('.ts'))
         return;
     // Register TS compiler lazily
     require('ts-node').register({

package/src/utils/watch-for-single-file-changes.js

@@ -1,26 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.watchForSingleFileChanges = void 0;
-const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const client_1 = require("nx/src/daemon/client/client");
 const path_1 = require("path");
-function watchForSingleFileChanges(projectName, projectRoot, relativeFilePath, callback) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const unregisterFileWatcher = yield client_1.daemonClient.registerFileWatcher({ watchProjects: [projectName] }, (err, data) => {
-            var _a;
-            if (err === 'closed') {
-                devkit_1.logger.error(`Watch error: Daemon closed the connection`);
-                process.exit(1);
-            }
-            else if (err) {
-                devkit_1.logger.error(`Watch error: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : 'Unknown'}`);
-            }
-            else if (data.changedFiles.some((file) => file.path == (0, path_1.join)(projectRoot, relativeFilePath))) {
-                callback();
-            }
-        });
-        return () => unregisterFileWatcher();
+async function watchForSingleFileChanges(projectName, projectRoot, relativeFilePath, callback) {
+    const unregisterFileWatcher = await client_1.daemonClient.registerFileWatcher({ watchProjects: [projectName] }, (err, data) => {
+        if (err === 'closed') {
+            devkit_1.logger.error(`Watch error: Daemon closed the connection`);
+            process.exit(1);
+        }
+        else if (err) {
+            devkit_1.logger.error(`Watch error: ${err?.message ?? 'Unknown'}`);
+        }
+        else if (data.changedFiles.some((file) => file.path == (0, path_1.join)(projectRoot, relativeFilePath))) {
+            callback();
+        }
     });
+    return () => unregisterFileWatcher();
 }
 exports.watchForSingleFileChanges = watchForSingleFileChanges;