@ohos-ports/nx 17.3.2-beta.0

package/src/tasks-runner/tasks-schedule.d.ts

@@ -0,0 +1,36 @@
+import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { Task, TaskGraph } from '../config/task-graph';
+import { ProjectGraph } from '../config/project-graph';
+export interface Batch {
+    executorName: string;
+    taskGraph: TaskGraph;
+}
+export declare class TasksSchedule {
+    private readonly projectGraph;
+    private readonly taskGraph;
+    private readonly options;
+    private notScheduledTaskGraph;
+    private reverseTaskDeps;
+    private reverseProjectGraph;
+    private scheduledBatches;
+    private scheduledTasks;
+    private completedTasks;
+    private scheduleRequestsExecutionChain;
+    constructor(projectGraph: ProjectGraph, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions);
+    scheduleNextTasks(): Promise<void>;
+    hasTasks(): boolean;
+    complete(taskIds: string[]): void;
+    getAllScheduledTasks(): {
+        scheduledTasks: string[];
+        scheduledBatches: Batch[];
+    };
+    nextTask(): Task;
+    nextBatch(): Batch;
+    private scheduleTasks;
+    private scheduleTask;
+    private scheduleBatches;
+    private scheduleBatch;
+    private processTaskForBatches;
+    private canBatchTaskBeScheduled;
+    private canBeScheduled;
+}

package/src/tasks-runner/tasks-schedule.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TasksSchedule = void 0;
+const utils_1 = require("./utils");
+const project_graph_utils_1 = require("../utils/project-graph-utils");
+const operators_1 = require("../project-graph/operators");
+class TasksSchedule {
+    constructor(projectGraph, taskGraph, options) {
+        this.projectGraph = projectGraph;
+        this.taskGraph = taskGraph;
+        this.options = options;
+        this.notScheduledTaskGraph = this.taskGraph;
+        this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
+        this.reverseProjectGraph = (0, operators_1.reverse)(this.projectGraph);
+        this.scheduledBatches = [];
+        this.scheduledTasks = [];
+        this.completedTasks = new Set();
+        this.scheduleRequestsExecutionChain = Promise.resolve();
+    }
+    async scheduleNextTasks() {
+        this.scheduleRequestsExecutionChain =
+            this.scheduleRequestsExecutionChain.then(() => this.scheduleTasks());
+        await this.scheduleRequestsExecutionChain;
+    }
+    hasTasks() {
+        return (this.scheduledBatches.length +
+            this.scheduledTasks.length +
+            Object.keys(this.notScheduledTaskGraph.tasks).length !==
+            0);
+    }
+    complete(taskIds) {
+        for (const taskId of taskIds) {
+            this.completedTasks.add(taskId);
+        }
+        this.notScheduledTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(this.notScheduledTaskGraph, taskIds);
+    }
+    getAllScheduledTasks() {
+        return {
+            scheduledTasks: this.scheduledTasks,
+            scheduledBatches: this.scheduledBatches,
+        };
+    }
+    nextTask() {
+        if (this.scheduledTasks.length > 0) {
+            return this.taskGraph.tasks[this.scheduledTasks.shift()];
+        }
+        else {
+            return null;
+        }
+    }
+    nextBatch() {
+        return this.scheduledBatches.length > 0
+            ? this.scheduledBatches.shift()
+            : null;
+    }
+    async scheduleTasks() {
+        if (this.options.batch || process.env.NX_BATCH_MODE === 'true') {
+            await this.scheduleBatches();
+        }
+        for (let root of this.notScheduledTaskGraph.roots) {
+            if (this.canBeScheduled(root)) {
+                await this.scheduleTask(root);
+            }
+        }
+    }
+    async scheduleTask(taskId) {
+        this.notScheduledTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(this.notScheduledTaskGraph, [taskId]);
+        this.scheduledTasks = this.scheduledTasks
+            .concat(taskId)
+            // NOTE: sort task by most dependent on first
+            .sort((taskId1, taskId2) => {
+            // First compare the length of task dependencies.
+            const taskDifference = this.reverseTaskDeps[taskId2].length -
+                this.reverseTaskDeps[taskId1].length;
+            if (taskDifference !== 0) {
+                return taskDifference;
+            }
+            // Tie-breaker for tasks with equal number of task dependencies.
+            // Most likely tasks with no dependencies such as test
+            const project1 = this.taskGraph.tasks[taskId1].target.project;
+            const project2 = this.taskGraph.tasks[taskId2].target.project;
+            return ((0, project_graph_utils_1.findAllProjectNodeDependencies)(project2, this.reverseProjectGraph)
+                .length -
+                (0, project_graph_utils_1.findAllProjectNodeDependencies)(project1, this.reverseProjectGraph)
+                    .length);
+        });
+    }
+    async scheduleBatches() {
+        const batchMap = {};
+        for (const root of this.notScheduledTaskGraph.roots) {
+            const rootTask = this.notScheduledTaskGraph.tasks[root];
+            const executorName = await (0, utils_1.getExecutorNameForTask)(rootTask, this.projectGraph);
+            await this.processTaskForBatches(batchMap, rootTask, executorName, true);
+        }
+        for (const [executorName, taskGraph] of Object.entries(batchMap)) {
+            this.scheduleBatch({ executorName, taskGraph });
+        }
+    }
+    scheduleBatch({ executorName, taskGraph }) {
+        // Create a new task graph without the tasks that are being scheduled as part of this batch
+        this.notScheduledTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(this.notScheduledTaskGraph, Object.keys(taskGraph.tasks));
+        this.scheduledBatches.push({ executorName, taskGraph });
+    }
+    async processTaskForBatches(batches, task, rootExecutorName, isRoot) {
+        if (!this.canBatchTaskBeScheduled(task.id, batches[rootExecutorName])) {
+            return;
+        }
+        const { batchImplementationFactory } = await (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+        const executorName = await (0, utils_1.getExecutorNameForTask)(task, this.projectGraph);
+        if (rootExecutorName !== executorName) {
+            return;
+        }
+        if (!batchImplementationFactory) {
+            return;
+        }
+        const batch = (batches[rootExecutorName] =
+            batches[rootExecutorName] ??
+                {
+                    tasks: {},
+                    dependencies: {},
+                    roots: [],
+                });
+        batch.tasks[task.id] = task;
+        batch.dependencies[task.id] =
+            this.notScheduledTaskGraph.dependencies[task.id];
+        if (isRoot) {
+            batch.roots.push(task.id);
+        }
+        for (const dep of this.reverseTaskDeps[task.id]) {
+            const depTask = this.taskGraph.tasks[dep];
+            await this.processTaskForBatches(batches, depTask, rootExecutorName, false);
+        }
+    }
+    canBatchTaskBeScheduled(taskId, batchTaskGraph) {
+        // all deps have either completed or belong to the same batch
+        return this.taskGraph.dependencies[taskId].every((id) => this.completedTasks.has(id) || !!batchTaskGraph?.tasks[id]);
+    }
+    canBeScheduled(taskId) {
+        return this.taskGraph.dependencies[taskId].every((id) => this.completedTasks.has(id));
+    }
+}
+exports.TasksSchedule = TasksSchedule;

package/src/tasks-runner/utils.d.ts

@@ -0,0 +1,51 @@
+import { Task, TaskGraph } from '../config/task-graph';
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { TargetDependencyConfig } from '../config/workspace-json-project-json';
+import { CustomHasher } from '../config/misc-interfaces';
+export declare function getCommandAsString(execCommand: string, task: Task): string;
+export declare function getDependencyConfigs({ project, target }: {
+    project: string;
+    target: string;
+}, defaultDependencyConfigs: Record<string, (TargetDependencyConfig | string)[]>, projectGraph: ProjectGraph): TargetDependencyConfig[] | undefined;
+export declare function expandDependencyConfigSyntaxSugar(dependencyConfigString: string, graph: ProjectGraph): TargetDependencyConfig;
+export declare function getOutputs(p: Record<string, ProjectGraphProjectNode>, target: Task['target'], overrides: Task['overrides']): string[];
+declare class InvalidOutputsError extends Error {
+    outputs: string[];
+    invalidOutputs: Set<string>;
+    constructor(outputs: string[], invalidOutputs: Set<string>);
+    private static createMessage;
+}
+export declare function validateOutputs(outputs: string[]): void;
+export declare function transformLegacyOutputs(projectRoot: string, error: InvalidOutputsError): string[];
+/**
+ * @deprecated Pass the target and overrides instead. This will be removed in v19.
+ */
+export declare function getOutputsForTargetAndConfiguration(task: Task, node: ProjectGraphProjectNode): string[];
+export declare function getOutputsForTargetAndConfiguration(target: Task['target'] | Task, overrides: Task['overrides'] | ProjectGraphProjectNode, node: ProjectGraphProjectNode): string[];
+export declare function interpolate(template: string, data: any): string;
+export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): Promise<string>;
+export declare function getExecutorForTask(task: Task, projectGraph: ProjectGraph): Promise<import("../config/misc-interfaces").ExecutorConfig & {
+    isNgCompat: boolean;
+    isNxExecutor: boolean;
+}>;
+export declare function getCustomHasher(task: Task, projectGraph: ProjectGraph): Promise<CustomHasher> | null;
+export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
+export declare function removeIdsFromGraph<T>(graph: {
+    roots: string[];
+    dependencies: Record<string, string[]>;
+}, ids: string[], mapWithIds: Record<string, T>): {
+    mapWithIds: Record<string, T>;
+    roots: string[];
+    dependencies: Record<string, string[]>;
+};
+export declare function calculateReverseDeps(taskGraph: TaskGraph): Record<string, string[]>;
+export declare function getCliPath(): string;
+export declare function getPrintableCommandArgsForTask(task: Task): string[];
+export declare function getSerializedArgsForTask(task: Task, isVerbose: boolean): string[];
+export declare function shouldStreamOutput(task: Task, initiatingProject: string | null): boolean;
+export declare function isCacheableTask(task: Task, options: {
+    cacheableOperations?: string[] | null;
+    cacheableTargets?: string[] | null;
+}): boolean;
+export declare function unparse(options: Object): string[];
+export {};

package/src/tasks-runner/utils.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeIdsFromGraph = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.getOutputs = exports.expandDependencyConfigSyntaxSugar = exports.getDependencyConfigs = exports.getCommandAsString = void 0;
+const output_1 = require("../utils/output");
+const path_1 = require("path");
+const workspace_root_1 = require("../utils/workspace-root");
+const path_2 = require("../utils/path");
+const fileutils_1 = require("../utils/fileutils");
+const serialize_overrides_into_command_line_1 = require("../utils/serialize-overrides-into-command-line");
+const split_target_1 = require("../utils/split-target");
+const executor_utils_1 = require("../command-line/run/executor-utils");
+const project_graph_1 = require("../project-graph/project-graph");
+function getCommandAsString(execCommand, task) {
+    const args = getPrintableCommandArgsForTask(task);
+    return [execCommand, 'nx', ...args].join(' ').trim();
+}
+exports.getCommandAsString = getCommandAsString;
+function getDependencyConfigs({ project, target }, defaultDependencyConfigs, projectGraph) {
+    const dependencyConfigs = (projectGraph.nodes[project].data?.targets[target]?.dependsOn ??
+        defaultDependencyConfigs[target] ??
+        []).map((config) => typeof config === 'string'
+        ? expandDependencyConfigSyntaxSugar(config, projectGraph)
+        : config);
+    for (const dependencyConfig of dependencyConfigs) {
+        if (dependencyConfig.projects && dependencyConfig.dependencies) {
+            output_1.output.error({
+                title: `dependsOn is improperly configured for ${project}:${target}`,
+                bodyLines: [
+                    `dependsOn.projects and dependsOn.dependencies cannot be used together.`,
+                ],
+            });
+            process.exit(1);
+        }
+    }
+    return dependencyConfigs;
+}
+exports.getDependencyConfigs = getDependencyConfigs;
+function expandDependencyConfigSyntaxSugar(dependencyConfigString, graph) {
+    const [dependencies, targetString] = dependencyConfigString.startsWith('^')
+        ? [true, dependencyConfigString.substring(1)]
+        : [false, dependencyConfigString];
+    // Support for `project:target` syntax doesn't make sense for
+    // dependencies, so we only support `target` syntax for dependencies.
+    if (dependencies) {
+        return {
+            target: targetString,
+            dependencies: true,
+        };
+    }
+    // Support for both `project:target` and `target:with:colons` syntax
+    const [maybeProject, ...segments] = (0, split_target_1.splitByColons)(targetString);
+    // if no additional segments are provided, then the string references
+    // a target of the same project
+    if (!segments.length) {
+        return { target: maybeProject };
+    }
+    return {
+        // Only the first segment could be a project. If it is, the rest is a target.
+        // If its not, then the whole targetString was a target with colons in its name.
+        target: maybeProject in graph.nodes ? segments.join(':') : targetString,
+        // If the first segment is a project, then we have a specific project. Otherwise, we don't.
+        projects: maybeProject in graph.nodes ? [maybeProject] : undefined,
+    };
+}
+exports.expandDependencyConfigSyntaxSugar = expandDependencyConfigSyntaxSugar;
+function getOutputs(p, target, overrides) {
+    return getOutputsForTargetAndConfiguration(target, overrides, p[target.project]);
+}
+exports.getOutputs = getOutputs;
+class InvalidOutputsError extends Error {
+    constructor(outputs, invalidOutputs) {
+        super(InvalidOutputsError.createMessage(invalidOutputs));
+        this.outputs = outputs;
+        this.invalidOutputs = invalidOutputs;
+    }
+    static createMessage(invalidOutputs) {
+        const invalidOutputsList = '\n - ' + Array.from(invalidOutputs).join('\n - ');
+        return `The following outputs are invalid:${invalidOutputsList}\nPlease run "nx repair" to repair your configuration`;
+    }
+}
+function validateOutputs(outputs) {
+    const invalidOutputs = new Set();
+    for (const output of outputs) {
+        if (!/^!?{[\s\S]+}/.test(output)) {
+            invalidOutputs.add(output);
+        }
+    }
+    if (invalidOutputs.size > 0) {
+        throw new InvalidOutputsError(outputs, invalidOutputs);
+    }
+}
+exports.validateOutputs = validateOutputs;
+function transformLegacyOutputs(projectRoot, error) {
+    return error.outputs.map((output) => {
+        if (!error.invalidOutputs.has(output)) {
+            return output;
+        }
+        let [isNegated, outputPath] = output.startsWith('!')
+            ? [true, output.substring(1)]
+            : [false, output];
+        const relativePath = (0, fileutils_1.isRelativePath)(outputPath)
+            ? output
+            : (0, path_1.relative)(projectRoot, outputPath);
+        const isWithinProject = !relativePath.startsWith('..');
+        return ((isNegated ? '!' : '') +
+            (0, path_2.joinPathFragments)(isWithinProject ? '{projectRoot}' : '{workspaceRoot}', isWithinProject ? relativePath : outputPath));
+    });
+}
+exports.transformLegacyOutputs = transformLegacyOutputs;
+/**
+ * Returns the list of outputs that will be cached.
+ */
+function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode, node) {
+    const taskTarget = 'id' in taskTargetOrTask ? taskTargetOrTask.target : taskTargetOrTask;
+    const overrides = 'id' in taskTargetOrTask ? taskTargetOrTask.overrides : overridesOrNode;
+    node = 'id' in taskTargetOrTask ? overridesOrNode : node;
+    const { target, configuration } = taskTarget;
+    const targetConfiguration = node.data.targets[target];
+    const options = {
+        ...targetConfiguration.options,
+        ...targetConfiguration?.configurations?.[configuration],
+        ...overrides,
+    };
+    if (targetConfiguration?.outputs) {
+        validateOutputs(targetConfiguration.outputs);
+        return targetConfiguration.outputs
+            .map((output) => {
+            return interpolate(output, {
+                projectRoot: node.data.root,
+                projectName: node.name,
+                project: { ...node.data, name: node.name }, // this is legacy
+                options,
+            });
+        })
+            .filter((output) => !!output && !output.match(/{(projectRoot|workspaceRoot|(options.*))}/));
+    }
+    // Keep backwards compatibility in case `outputs` doesn't exist
+    if (options.outputPath) {
+        return Array.isArray(options.outputPath)
+            ? options.outputPath
+            : [options.outputPath];
+    }
+    else if (target === 'build' || target === 'prepare') {
+        return [
+            `dist/${node.data.root}`,
+            `${node.data.root}/dist`,
+            `${node.data.root}/build`,
+            `${node.data.root}/public`,
+        ];
+    }
+    else {
+        return [];
+    }
+}
+exports.getOutputsForTargetAndConfiguration = getOutputsForTargetAndConfiguration;
+function interpolate(template, data) {
+    if (template.includes('{workspaceRoot}', 1)) {
+        throw new Error(`Output '${template}' is invalid. {workspaceRoot} can only be used at the beginning of the expression.`);
+    }
+    if (data.projectRoot == '.' && template.includes('{projectRoot}', 1)) {
+        throw new Error(`Output '${template}' is invalid. When {projectRoot} is '.', it can only be used at the beginning of the expression.`);
+    }
+    let res = template.replace('{workspaceRoot}/', '');
+    if (data.projectRoot == '.') {
+        res = res.replace('{projectRoot}/', '');
+    }
+    return res.replace(/{([\s\S]+?)}/g, (match) => {
+        let value = data;
+        let path = match.slice(1, -1).trim().split('.');
+        for (let idx = 0; idx < path.length; idx++) {
+            if (!value[path[idx]]) {
+                return match;
+            }
+            value = value[path[idx]];
+        }
+        return value;
+    });
+}
+exports.interpolate = interpolate;
+async function getExecutorNameForTask(task, projectGraph) {
+    const project = projectGraph.nodes[task.target.project].data;
+    return project.targets[task.target.target].executor;
+}
+exports.getExecutorNameForTask = getExecutorNameForTask;
+async function getExecutorForTask(task, projectGraph) {
+    const executor = await getExecutorNameForTask(task, projectGraph);
+    const [nodeModule, executorName] = executor.split(':');
+    return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects);
+}
+exports.getExecutorForTask = getExecutorForTask;
+async function getCustomHasher(task, projectGraph) {
+    const factory = (await getExecutorForTask(task, projectGraph)).hasherFactory;
+    return factory ? factory() : null;
+}
+exports.getCustomHasher = getCustomHasher;
+function removeTasksFromTaskGraph(graph, ids) {
+    const newGraph = removeIdsFromGraph(graph, ids, graph.tasks);
+    return {
+        dependencies: newGraph.dependencies,
+        roots: newGraph.roots,
+        tasks: newGraph.mapWithIds,
+    };
+}
+exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
+function removeIdsFromGraph(graph, ids, mapWithIds) {
+    const filteredMapWithIds = {};
+    const dependencies = {};
+    const removedSet = new Set(ids);
+    for (let id of Object.keys(mapWithIds)) {
+        if (!removedSet.has(id)) {
+            filteredMapWithIds[id] = mapWithIds[id];
+            dependencies[id] = graph.dependencies[id].filter((depId) => !removedSet.has(depId));
+        }
+    }
+    return {
+        mapWithIds: filteredMapWithIds,
+        dependencies: dependencies,
+        roots: Object.keys(dependencies).filter((k) => dependencies[k].length === 0),
+    };
+}
+exports.removeIdsFromGraph = removeIdsFromGraph;
+function calculateReverseDeps(taskGraph) {
+    const reverseTaskDeps = {};
+    Object.keys(taskGraph.tasks).forEach((t) => {
+        reverseTaskDeps[t] = [];
+    });
+    Object.keys(taskGraph.dependencies).forEach((taskId) => {
+        taskGraph.dependencies[taskId].forEach((d) => {
+            reverseTaskDeps[d].push(taskId);
+        });
+    });
+    return reverseTaskDeps;
+}
+exports.calculateReverseDeps = calculateReverseDeps;
+function getCliPath() {
+    return require.resolve(`../../bin/run-executor.js`);
+}
+exports.getCliPath = getCliPath;
+function getPrintableCommandArgsForTask(task) {
+    const args = task.overrides['__overrides_unparsed__'];
+    const target = task.target.target.includes(':')
+        ? `"${task.target.target}"`
+        : task.target.target;
+    const config = task.target.configuration
+        ? `:${task.target.configuration}`
+        : '';
+    return ['run', `${task.target.project}:${target}${config}`, ...args];
+}
+exports.getPrintableCommandArgsForTask = getPrintableCommandArgsForTask;
+function getSerializedArgsForTask(task, isVerbose) {
+    return [
+        JSON.stringify({
+            targetDescription: task.target,
+            overrides: task.overrides,
+            isVerbose: isVerbose,
+        }),
+    ];
+}
+exports.getSerializedArgsForTask = getSerializedArgsForTask;
+function shouldStreamOutput(task, initiatingProject) {
+    if (process.env.NX_STREAM_OUTPUT === 'true')
+        return true;
+    if (longRunningTask(task))
+        return true;
+    if (task.target.project === initiatingProject)
+        return true;
+    return false;
+}
+exports.shouldStreamOutput = shouldStreamOutput;
+function isCacheableTask(task, options) {
+    if (task.cache !== undefined && !longRunningTask(task)) {
+        return task.cache;
+    }
+    const cacheable = options.cacheableOperations || options.cacheableTargets;
+    return (cacheable &&
+        cacheable.indexOf(task.target.target) > -1 &&
+        !longRunningTask(task));
+}
+exports.isCacheableTask = isCacheableTask;
+function longRunningTask(task) {
+    const t = task.target.target;
+    return ((!!task.overrides['watch'] && task.overrides['watch'] !== 'false') ||
+        t.endsWith(':watch') ||
+        t.endsWith('-watch') ||
+        t === 'serve' ||
+        t === 'dev' ||
+        t === 'start');
+}
+// TODO: vsavkin remove when nx-cloud doesn't depend on it
+function unparse(options) {
+    return (0, serialize_overrides_into_command_line_1.serializeOverridesIntoCommandLine)(options);
+}
+exports.unparse = unparse;

package/src/utils/ab-testing.d.ts

@@ -0,0 +1,51 @@
+export type MessageOptionKey = 'yes' | 'skip';
+declare const messageOptions: {
+    readonly setupNxCloud: readonly [{
+        readonly code: "enable-caching";
+        readonly message: "Would you like remote caching to make your build faster?";
+        readonly initial: 0;
+        readonly choices: readonly [{
+            readonly value: "yes";
+            readonly name: "Yes";
+        }, {
+            readonly value: "skip";
+            readonly name: "Skip for now";
+        }];
+        readonly footer: "\nRead more about remote cache at https://nx.dev/ci/features/remote-cache";
+        readonly hint: "\n(it's free and can be disabled any time)";
+    }];
+    readonly setupViewLogs: readonly [{
+        readonly code: "connect-to-view-logs";
+        readonly message: "To view the logs, Nx needs to connect your workspace to Nx Cloud and upload the most recent run details";
+        readonly initial: 0;
+        readonly choices: readonly [{
+            readonly value: "yes";
+            readonly name: "Yes";
+            readonly hint: "Connect to Nx Cloud and upload the run details";
+        }, {
+            readonly value: "skip";
+            readonly name: "No";
+        }];
+        readonly footer: "\nRead more about remote cache at https://nx.dev/ci/features/remote-cache";
+        readonly hint: "\n(it's free and can be disabled any time)";
+    }];
+};
+export type MessageKey = keyof typeof messageOptions;
+export type MessageData = typeof messageOptions[MessageKey][number];
+export declare class PromptMessages {
+    private selectedMessages;
+    getPrompt(key: MessageKey): MessageData;
+    codeOfSelectedPromptMessage(key: string): string;
+}
+export declare const messages: PromptMessages;
+/**
+ * We are incrementing a counter to track how often create-nx-workspace is used in CI
+ * vs dev environments. No personal information is collected.
+ */
+export declare function recordStat(opts: {
+    command: string;
+    nxVersion: string;
+    useCloud: boolean;
+    meta: string;
+}): Promise<void>;
+export {};

package/src/utils/ab-testing.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordStat = exports.messages = exports.PromptMessages = void 0;
+const is_ci_1 = require("./is-ci");
+const messageOptions = {
+    setupNxCloud: [
+        {
+            code: 'enable-caching',
+            message: `Would you like remote caching to make your build faster?`,
+            initial: 0,
+            choices: [
+                { value: 'yes', name: 'Yes' },
+                { value: 'skip', name: 'Skip for now' },
+            ],
+            footer: '\nRead more about remote cache at https://nx.dev/ci/features/remote-cache',
+            hint: `\n(it's free and can be disabled any time)`,
+        },
+    ],
+    setupViewLogs: [
+        {
+            code: 'connect-to-view-logs',
+            message: `To view the logs, Nx needs to connect your workspace to Nx Cloud and upload the most recent run details`,
+            initial: 0,
+            choices: [
+                {
+                    value: 'yes',
+                    name: 'Yes',
+                    hint: 'Connect to Nx Cloud and upload the run details',
+                },
+                { value: 'skip', name: 'No' },
+            ],
+            footer: '\nRead more about remote cache at https://nx.dev/ci/features/remote-cache',
+            hint: `\n(it's free and can be disabled any time)`,
+        },
+    ],
+};
+class PromptMessages {
+    constructor() {
+        this.selectedMessages = {};
+    }
+    getPrompt(key) {
+        if (this.selectedMessages[key] === undefined) {
+            if (process.env.NX_GENERATE_DOCS_PROCESS === 'true') {
+                this.selectedMessages[key] = 0;
+            }
+            else {
+                this.selectedMessages[key] = Math.floor(Math.random() * messageOptions[key].length);
+            }
+        }
+        return messageOptions[key][this.selectedMessages[key]];
+    }
+    codeOfSelectedPromptMessage(key) {
+        if (this.selectedMessages[key] === undefined)
+            return null;
+        return messageOptions[key][this.selectedMessages[key]].code;
+    }
+}
+exports.PromptMessages = PromptMessages;
+exports.messages = new PromptMessages();
+/**
+ * We are incrementing a counter to track how often create-nx-workspace is used in CI
+ * vs dev environments. No personal information is collected.
+ */
+async function recordStat(opts) {
+    try {
+        const major = Number(opts.nxVersion.split('.')[0]);
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.log(`Record stat. Major: ${major}`);
+        }
+        if (major < 10 || major > 16)
+            return; // test version, skip it
+        const axios = require('axios');
+        await (axios['default'] ?? axios)
+            .create({
+            baseURL: 'https://cloud.nx.app',
+            timeout: 400,
+        })
+            .post('/nx-cloud/stats', {
+            command: opts.command,
+            isCI: (0, is_ci_1.isCI)(),
+            useCloud: opts.useCloud,
+            meta: opts.meta,
+        });
+    }
+    catch (e) {
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.error(e);
+        }
+    }
+}
+exports.recordStat = recordStat;

package/src/utils/all-file-data.d.ts

@@ -0,0 +1,2 @@
+import { FileData } from '../config/project-graph';
+export declare function allFileData(): Promise<FileData[]>;