@nx/js 16.8.0-beta.4 → 16.8.0-beta.6

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;