@nx/workspace 0.0.0-pr-22179-271588f

package/src/utilities/typescript/compilation.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTypeScriptWatcher = exports.compileTypeScript = void 0;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const ts_config_1 = require("../ts-config");
+const typescript_1 = require("../typescript");
+let tsModule;
+function compileTypeScript(options) {
+    const normalizedOptions = normalizeOptions(options);
+    const tsConfig = getNormalizedTsConfig(normalizedOptions);
+    if (normalizedOptions.deleteOutputPath) {
+        (0, fs_1.rmSync)(normalizedOptions.outputPath, { recursive: true, force: true });
+    }
+    return createProgram(tsConfig, normalizedOptions);
+}
+exports.compileTypeScript = compileTypeScript;
+function compileTypeScriptWatcher(options, callback) {
+    if (!tsModule) {
+        tsModule = (0, typescript_1.ensureTypescript)();
+    }
+    const normalizedOptions = normalizeOptions(options);
+    const tsConfig = getNormalizedTsConfig(normalizedOptions);
+    if (normalizedOptions.deleteOutputPath) {
+        (0, fs_1.rmSync)(normalizedOptions.outputPath, { recursive: true, force: true });
+    }
+    const host = tsModule.createWatchCompilerHost(tsConfig.fileNames, tsConfig.options, tsModule.sys);
+    const originalAfterProgramCreate = host.afterProgramCreate;
+    host.afterProgramCreate = (builderProgram) => {
+        const originalProgramEmit = builderProgram.emit;
+        builderProgram.emit = (targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
+            const consumerCustomTransformers = options.getCustomTransformers?.(builderProgram.getProgram());
+            const mergedCustomTransformers = mergeCustomTransformers(customTransformers, consumerCustomTransformers);
+            return originalProgramEmit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, mergedCustomTransformers);
+        };
+        if (originalAfterProgramCreate)
+            originalAfterProgramCreate(builderProgram);
+    };
+    const originalOnWatchStatusChange = host.onWatchStatusChange;
+    host.onWatchStatusChange = async (a, b, c, d) => {
+        originalOnWatchStatusChange?.(a, b, c, d);
+        await callback?.(a, b, c, d);
+    };
+    return tsModule.createWatchProgram(host);
+}
+exports.compileTypeScriptWatcher = compileTypeScriptWatcher;
+function mergeCustomTransformers(originalCustomTransformers, consumerCustomTransformers) {
+    if (!consumerCustomTransformers)
+        return originalCustomTransformers;
+    const mergedCustomTransformers = {};
+    if (consumerCustomTransformers.before) {
+        mergedCustomTransformers.before = originalCustomTransformers?.before
+            ? [
+                ...originalCustomTransformers.before,
+                ...consumerCustomTransformers.before,
+            ]
+            : consumerCustomTransformers.before;
+    }
+    if (consumerCustomTransformers.after) {
+        mergedCustomTransformers.after = originalCustomTransformers?.after
+            ? [
+                ...originalCustomTransformers.after,
+                ...consumerCustomTransformers.after,
+            ]
+            : consumerCustomTransformers.after;
+    }
+    if (consumerCustomTransformers.afterDeclarations) {
+        mergedCustomTransformers.afterDeclarations =
+            originalCustomTransformers?.afterDeclarations
+                ? [
+                    ...originalCustomTransformers.afterDeclarations,
+                    ...consumerCustomTransformers.afterDeclarations,
+                ]
+                : consumerCustomTransformers.afterDeclarations;
+    }
+    return mergedCustomTransformers;
+}
+function getNormalizedTsConfig(options) {
+    const tsConfig = (0, ts_config_1.readTsConfig)(options.tsConfig);
+    tsConfig.options.outDir = options.outputPath;
+    tsConfig.options.noEmitOnError = true;
+    tsConfig.options.rootDir = options.rootDir;
+    if (tsConfig.options.incremental && !tsConfig.options.tsBuildInfoFile) {
+        tsConfig.options.tsBuildInfoFile = (0, devkit_1.joinPathFragments)(options.outputPath, 'tsconfig.tsbuildinfo');
+    }
+    return tsConfig;
+}
+function createProgram(tsconfig, { projectName, getCustomTransformers }) {
+    if (!tsModule) {
+        tsModule = (0, typescript_1.ensureTypescript)();
+    }
+    const host = tsModule.createCompilerHost(tsconfig.options);
+    const program = tsModule.createProgram({
+        rootNames: tsconfig.fileNames,
+        options: tsconfig.options,
+        host,
+    });
+    devkit_1.logger.info(`Compiling TypeScript files for project "${projectName}"...`);
+    const results = program.emit(undefined, undefined, undefined, undefined, getCustomTransformers?.(program));
+    if (results.emitSkipped) {
+        const diagnostics = tsModule.formatDiagnosticsWithColorAndContext(results.diagnostics, {
+            getCurrentDirectory: () => tsModule.sys.getCurrentDirectory(),
+            getNewLine: () => tsModule.sys.newLine,
+            getCanonicalFileName: (name) => name,
+        });
+        devkit_1.logger.error(diagnostics);
+        return { success: false };
+    }
+    else {
+        devkit_1.logger.info(`Done compiling TypeScript files for project "${projectName}".`);
+        return { success: true };
+    }
+}
+function normalizeOptions(options) {
+    return {
+        ...options,
+        deleteOutputPath: options.deleteOutputPath ?? true,
+        rootDir: options.rootDir ?? options.projectRoot,
+    };
+}

package/src/utilities/typescript/get-source-nodes.d.ts

@@ -0,0 +1,5 @@
+import type * as ts from 'typescript';
+/**
+ * @deprecated This function will be removed from @nx/workspace in version 17. Prefer importing from @nx/js.
+ */
+export declare function getSourceNodes(sourceFile: ts.SourceFile): ts.Node[];

package/src/utilities/typescript/get-source-nodes.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceNodes = void 0;
+/**
+ * @deprecated This function will be removed from @nx/workspace in version 17. Prefer importing from @nx/js.
+ */
+function getSourceNodes(sourceFile) {
+    const nodes = [sourceFile];
+    const result = [];
+    while (nodes.length > 0) {
+        const node = nodes.shift();
+        if (node) {
+            result.push(node);
+            if (node.getChildCount(sourceFile) >= 0) {
+                nodes.unshift(...node.getChildren());
+            }
+        }
+    }
+    return result;
+}
+exports.getSourceNodes = getSourceNodes;

package/src/utilities/typescript.d.ts

@@ -0,0 +1,13 @@
+import type * as ts from 'typescript';
+export { compileTypeScript } from './typescript/compilation';
+export type { TypeScriptCompilationOptions } from './typescript/compilation';
+export { getSourceNodes } from './typescript/get-source-nodes';
+/**
+ * Find a module based on it's import
+ *
+ * @param importExpr Import used to resolve to a module
+ * @param filePath
+ * @param tsConfigPath
+ */
+export declare function resolveModuleByImport(importExpr: string, filePath: string, tsConfigPath: string): string;
+export declare function ensureTypescript(): typeof ts;

package/src/utilities/typescript.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureTypescript = exports.resolveModuleByImport = exports.getSourceNodes = exports.compileTypeScript = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const versions_1 = require("../utils/versions");
+var compilation_1 = require("./typescript/compilation");
+Object.defineProperty(exports, "compileTypeScript", { enumerable: true, get: function () { return compilation_1.compileTypeScript; } });
+var get_source_nodes_1 = require("./typescript/get-source-nodes");
+Object.defineProperty(exports, "getSourceNodes", { enumerable: true, get: function () { return get_source_nodes_1.getSourceNodes; } });
+const normalizedAppRoot = devkit_1.workspaceRoot.replace(/\\/g, '/');
+let tsModule;
+function readTsConfigOptions(tsConfigPath) {
+    if (!tsModule) {
+        tsModule = ensureTypescript();
+    }
+    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
+    // we don't need to scan the files, we only care about options
+    const host = {
+        readDirectory: () => [],
+        readFile: () => '',
+        fileExists: tsModule.sys.fileExists,
+    };
+    return tsModule.parseJsonConfigFileContent(readResult.config, host, (0, path_1.dirname)(tsConfigPath)).options;
+}
+let compilerHost;
+/**
+ * Find a module based on it's import
+ *
+ * @param importExpr Import used to resolve to a module
+ * @param filePath
+ * @param tsConfigPath
+ */
+function resolveModuleByImport(importExpr, filePath, tsConfigPath) {
+    compilerHost = compilerHost || getCompilerHost(tsConfigPath);
+    const { options, host, moduleResolutionCache } = compilerHost;
+    const { resolvedModule } = tsModule.resolveModuleName(importExpr, filePath, options, host, moduleResolutionCache);
+    if (!resolvedModule) {
+        return;
+    }
+    else {
+        return resolvedModule.resolvedFileName.replace(`${normalizedAppRoot}/`, '');
+    }
+}
+exports.resolveModuleByImport = resolveModuleByImport;
+function getCompilerHost(tsConfigPath) {
+    const options = readTsConfigOptions(tsConfigPath);
+    const host = tsModule.createCompilerHost(options, true);
+    const moduleResolutionCache = tsModule.createModuleResolutionCache(devkit_1.workspaceRoot, host.getCanonicalFileName);
+    return { options, host, moduleResolutionCache };
+}
+function ensureTypescript() {
+    return (0, devkit_1.ensurePackage)('typescript', versions_1.typescriptVersion);
+}
+exports.ensureTypescript = ensureTypescript;

package/src/utils/ast-utils.d.ts

@@ -0,0 +1 @@
+export { getSourceNodes } from '../utilities/typescript/get-source-nodes';

package/src/utils/ast-utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceNodes = void 0;
+var get_source_nodes_1 = require("../utilities/typescript/get-source-nodes");
+Object.defineProperty(exports, "getSourceNodes", { enumerable: true, get: function () { return get_source_nodes_1.getSourceNodes; } });

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

@@ -0,0 +1,16 @@
+import type { Tree } from '@angular-devkit/schematics';
+/**
+ * @deprecated Nx no longer supports workspace.json
+ */
+export declare function getWorkspacePath(host: Tree): string;
+export declare function parseTarget(targetString: string): {
+    project: string;
+    target: string;
+    config: string;
+};
+export declare function editTarget(targetString: string, callback: any): string;
+export declare function serializeTarget({ project, target, config }: {
+    project: any;
+    target: any;
+    config: any;
+}): string;

package/src/utils/cli-config-utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeTarget = exports.editTarget = exports.parseTarget = exports.getWorkspacePath = void 0;
+/**
+ * @deprecated Nx no longer supports workspace.json
+ */
+function getWorkspacePath(host) {
+    const possibleFiles = ['/angular.json', '/workspace.json'];
+    return possibleFiles.filter((path) => host.exists(path))[0];
+}
+exports.getWorkspacePath = getWorkspacePath;
+function parseTarget(targetString) {
+    const [project, target, config] = targetString.split(':');
+    return {
+        project,
+        target,
+        config,
+    };
+}
+exports.parseTarget = parseTarget;
+function editTarget(targetString, callback) {
+    const parsedTarget = parseTarget(targetString);
+    return serializeTarget(callback(parsedTarget));
+}
+exports.editTarget = editTarget;
+function serializeTarget({ project, target, config }) {
+    return [project, target, config].filter((part) => !!part).join(':');
+}
+exports.serializeTarget = serializeTarget;

package/src/utils/lint.d.ts

@@ -0,0 +1,4 @@
+export declare const enum Linter {
+    EsLint = "eslint",
+    None = "none"
+}

package/src/utils/lint.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/utils/output.d.ts

@@ -0,0 +1,52 @@
+import * as chalk from 'chalk';
+export interface CLIErrorMessageConfig {
+    title: string;
+    bodyLines?: string[];
+    slug?: string;
+}
+export interface CLIWarnMessageConfig {
+    title: string;
+    bodyLines?: string[];
+    slug?: string;
+}
+export interface CLINoteMessageConfig {
+    title: string;
+    bodyLines?: string[];
+}
+export interface CLISuccessMessageConfig {
+    title: string;
+    bodyLines?: string[];
+}
+declare class CLIOutput {
+    private readonly NX_PREFIX;
+    /**
+     * Longer dash character which forms more of a continuous line when place side to side
+     * with itself, unlike the standard dash character
+     */
+    private readonly VERTICAL_SEPARATOR;
+    /**
+     * Expose some color and other utility functions so that other parts of the codebase that need
+     * more fine-grained control of message bodies are still using a centralized
+     * implementation.
+     */
+    colors: {
+        gray: chalk.Chalk;
+    };
+    bold: chalk.Chalk;
+    underline: chalk.Chalk;
+    private writeToStdOut;
+    private writeOutputTitle;
+    private writeOptionalOutputBody;
+    addNewline(): void;
+    addVerticalSeparator(): void;
+    addVerticalSeparatorWithoutNewLines(): void;
+    error({ title, slug, bodyLines }: CLIErrorMessageConfig): void;
+    warn({ title, slug, bodyLines }: CLIWarnMessageConfig): void;
+    note({ title, bodyLines }: CLINoteMessageConfig): void;
+    success({ title, bodyLines }: CLISuccessMessageConfig): void;
+    logSingleLine(message: string): void;
+    logCommand(message: string, isCached?: boolean): void;
+    log({ title, bodyLines }: CLIWarnMessageConfig): void;
+}
+export declare const output: CLIOutput;
+export {};

package/src/utils/output.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.output = void 0;
+const chalk = require("chalk");
+/**
+ * Automatically disable styling applied by chalk if CI=true
+ */
+if (process.env.CI === 'true') {
+    chalk.level = 0;
+}
+class CLIOutput {
+    constructor() {
+        this.NX_PREFIX = chalk.reset.inverse.bold.cyan(' NX ');
+        /**
+         * Longer dash character which forms more of a continuous line when place side to side
+         * with itself, unlike the standard dash character
+         */
+        this.VERTICAL_SEPARATOR = '———————————————————————————————————————————————';
+        /**
+         * Expose some color and other utility functions so that other parts of the codebase that need
+         * more fine-grained control of message bodies are still using a centralized
+         * implementation.
+         */
+        this.colors = {
+            gray: chalk.gray,
+        };
+        this.bold = chalk.bold;
+        this.underline = chalk.underline;
+    }
+    writeToStdOut(str) {
+        process.stdout.write(str);
+    }
+    writeOutputTitle({ label, title, }) {
+        let outputTitle;
+        if (label) {
+            outputTitle = `${this.NX_PREFIX} ${label} ${title}\n`;
+        }
+        else {
+            outputTitle = `${this.NX_PREFIX} ${title}\n`;
+        }
+        this.writeToStdOut(outputTitle);
+    }
+    writeOptionalOutputBody(bodyLines) {
+        if (!bodyLines) {
+            return;
+        }
+        this.addNewline();
+        bodyLines.forEach((bodyLine) => this.writeToStdOut(`  ${bodyLine}\n`));
+    }
+    addNewline() {
+        this.writeToStdOut('\n');
+    }
+    addVerticalSeparator() {
+        this.writeToStdOut(`\n${chalk.gray(this.VERTICAL_SEPARATOR)}\n\n`);
+    }
+    addVerticalSeparatorWithoutNewLines() {
+        this.writeToStdOut(`${chalk.gray(this.VERTICAL_SEPARATOR)}\n`);
+    }
+    error({ title, slug, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            label: chalk.reset.inverse.bold.red(' ERROR '),
+            title: chalk.bold.red(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        /**
+         * Optional slug to be used in an Nx error message redirect URL
+         */
+        if (slug && typeof slug === 'string') {
+            this.addNewline();
+            this.writeToStdOut(`${chalk.grey('  Learn more about this error: ')}https://errors.nx.dev/${slug}\n`);
+        }
+        this.addNewline();
+    }
+    warn({ title, slug, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            label: chalk.reset.inverse.bold.yellow(' WARNING '),
+            title: chalk.bold.yellow(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        /**
+         * Optional slug to be used in an Nx warning message redirect URL
+         */
+        if (slug && typeof slug === 'string') {
+            this.addNewline();
+            this.writeToStdOut(`${chalk.grey('  Learn more about this warning: ')}https://errors.nx.dev/${slug}\n`);
+        }
+        this.addNewline();
+    }
+    note({ title, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            label: chalk.reset.inverse.bold.keyword('orange')(' NOTE '),
+            title: chalk.bold.keyword('orange')(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+    }
+    success({ title, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            label: chalk.reset.inverse.bold.green(' SUCCESS '),
+            title: chalk.bold.green(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+    }
+    logSingleLine(message) {
+        this.addNewline();
+        this.writeOutputTitle({
+            title: message,
+        });
+        this.addNewline();
+    }
+    logCommand(message, isCached = false) {
+        this.addNewline();
+        this.writeToStdOut(chalk.bold(`> ${message} `));
+        if (isCached) {
+            this.writeToStdOut(chalk.bold.grey(`[retrieved from cache]`));
+        }
+        this.addNewline();
+    }
+    log({ title, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            title: chalk.white(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+    }
+}
+exports.output = new CLIOutput();

package/src/utils/perf-logging.d.ts

@@ -0,0 +1 @@
+export {};

package/src/utils/perf-logging.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const perf_hooks_1 = require("perf_hooks");
+if (process.env.NX_PERF_LOGGING === 'true') {
+    const obs = new perf_hooks_1.PerformanceObserver((list) => {
+        const entry = list.getEntries()[0];
+        console.log(`Time for '${entry.name}'`, entry.duration);
+    });
+    obs.observe({ entryTypes: ['measure'] });
+}

package/src/utils/project-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum ProjectType {
+    Application = "application",
+    Library = "library"
+}
+export declare function projectRootDir(projectType: ProjectType): "apps" | "libs";

package/src/utils/project-type.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectRootDir = exports.ProjectType = void 0;
+var ProjectType;
+(function (ProjectType) {
+    ProjectType["Application"] = "application";
+    ProjectType["Library"] = "library";
+})(ProjectType || (exports.ProjectType = ProjectType = {}));
+function projectRootDir(projectType) {
+    if (projectType == ProjectType.Application) {
+        return 'apps';
+    }
+    else if (projectType == ProjectType.Library) {
+        return 'libs';
+    }
+}
+exports.projectRootDir = projectRootDir;

package/src/utils/versions.d.ts

@@ -0,0 +1,3 @@
+export declare const nxVersion: any;
+export declare const typescriptVersion = "~5.3.2";
+export declare const angularCliVersion = "~17.2.0";

package/src/utils/versions.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.angularCliVersion = exports.typescriptVersion = exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;
+exports.typescriptVersion = '~5.3.2';
+// TODO: remove when preset generation is reworked and
+// deps are not installed from workspace
+exports.angularCliVersion = '~17.2.0';

package/tasks-runners/default.d.ts

@@ -0,0 +1 @@
+export { defaultTasksRunner as default } from 'nx/src/tasks-runner/default-tasks-runner';

package/tasks-runners/default.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var default_tasks_runner_1 = require("nx/src/tasks-runner/default-tasks-runner");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return default_tasks_runner_1.defaultTasksRunner; } });