@ohos-ports/nx 23.3.0-beta.3 → 24.0.2-beta.0

package/dist/src/tasks-runner/utils.js

@@ -11,12 +11,14 @@ exports.normalizeTargetDependencyWithStringProjects = normalizeTargetDependencyW
 exports.validateOutputs = validateOutputs;
 exports.transformLegacyOutputs = transformLegacyOutputs;
 exports.getOutputsForTargetAndConfiguration = getOutputsForTargetAndConfiguration;
+exports.interpolateOutput = interpolateOutput;
 exports.interpolate = interpolate;
 exports.getTargetConfigurationForTask = getTargetConfigurationForTask;
 exports.getExecutorNameForTask = getExecutorNameForTask;
 exports.expandInitiatingTasksThroughNoop = expandInitiatingTasksThroughNoop;
 exports.getExecutorForTask = getExecutorForTask;
 exports.getCustomHasher = getCustomHasher;
+exports.resetCustomHasherDeprecationWarnings = resetCustomHasherDeprecationWarnings;
 exports.pruneToSelectedTasks = pruneToSelectedTasks;
 exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
 exports.calculateReverseDeps = calculateReverseDeps;
@@ -28,37 +30,36 @@ exports.shouldStreamOutput = shouldStreamOutput;
 exports.isCacheableTask = isCacheableTask;
 exports.unparse = unparse;
 exports.createTaskId = createTaskId;
+exports.hashTaskOverrides = hashTaskOverrides;
 const minimatch_1 = require("minimatch");
 const node_path_1 = require("node:path");
 const posix_1 = require("node:path/posix");
 const executor_utils_1 = require("../command-line/run/executor-utils");
+const file_hasher_1 = require("../hasher/file-hasher");
 const native_1 = require("../native");
 const fileutils_1 = require("../utils/fileutils");
 const find_matching_projects_1 = require("../utils/find-matching-projects");
-const legacy_depends_on_warning_1 = require("./legacy-depends-on-warning");
 const globs_1 = require("../utils/globs");
 const long_running_target_1 = require("../utils/long-running-target");
+const output_1 = require("../utils/output");
 const path_1 = require("../utils/path");
 const serialize_overrides_into_command_line_1 = require("../utils/serialize-overrides-into-command-line");
 const split_target_1 = require("../utils/split-target");
 const workspace_root_1 = require("../utils/workspace-root");
 const is_tui_enabled_1 = require("./is-tui-enabled");
+const tokens_1 = require("./tokens");
 function getDependencyConfigs({ project, target }, extraTargetDependencies, projectGraph, allTargetNames) {
-    const legacyViolations = [];
-    const dependencyConfigs = (projectGraph.nodes[project].data?.targets[target]?.dependsOn ??
+    return (projectGraph.nodes[project].data?.targets[target]?.dependsOn ??
         // This is passed into `run-command` from programmatic invocations
         extraTargetDependencies[target] ??
-        []).flatMap((config, index) => normalizeDependencyConfigDefinition(config, project, projectGraph, allTargetNames, { ownerTarget: target, index, legacyViolations }));
-    if (legacyViolations.length) {
-        (0, legacy_depends_on_warning_1.flushLegacyDependsOnViolations)(project, target, legacyViolations, projectGraph.nodes[project]?.data?.root);
-    }
-    return dependencyConfigs;
+        []).flatMap((config) => normalizeDependencyConfigDefinition(config, project, projectGraph, allTargetNames));
 }
-function normalizeDependencyConfigDefinition(definition, currentProject, graph, allTargetNames, location) {
-    return expandWildcardTargetConfiguration(normalizeDependencyConfigProjects(expandDependencyConfigSyntaxSugar(definition, graph, currentProject), currentProject, graph, location), allTargetNames);
+function normalizeDependencyConfigDefinition(definition, currentProject, graph, allTargetNames) {
+    return expandWildcardTargetConfiguration(normalizeDependencyConfigProjects(expandDependencyConfigSyntaxSugar(definition, graph, currentProject), currentProject, graph), allTargetNames);
 }
-function normalizeDependencyConfigProjects(dependencyConfig, currentProject, graph, location) {
-    const noStringConfig = normalizeTargetDependencyWithStringProjects(dependencyConfig, currentProject, location);
+function normalizeDependencyConfigProjects(dependencyConfig, currentProject, graph) {
+    assertNotLegacyProjectsString(dependencyConfig, currentProject, graph);
+    const noStringConfig = normalizeTargetDependencyWithStringProjects(dependencyConfig);
     if (noStringConfig.projects) {
         dependencyConfig.projects = (0, find_matching_projects_1.findMatchingProjects)(noStringConfig.projects, graph.nodes);
     }
@@ -67,6 +68,13 @@ function normalizeDependencyConfigProjects(dependencyConfig, currentProject, gra
     }
     return dependencyConfig;
 }
+function assertNotLegacyProjectsString(dependencyConfig, currentProject, graph) {
+    const projects = dependencyConfig.projects;
+    if ((projects === 'self' || projects === 'dependencies') &&
+        !graph.nodes[projects]) {
+        throw new Error(`${currentProject} has a dependsOn entry using projects: '${projects}', which is no longer supported: ${JSON.stringify(dependencyConfig)}\nPlease run "nx repair" to repair your configuration`);
+    }
+}
 function expandDependencyConfigSyntaxSugar(dependencyConfigString, graph, currentProject) {
     if (typeof dependencyConfigString !== 'string') {
         return dependencyConfigString;
@@ -133,23 +141,9 @@ function readProjectAndTargetFromTargetString(targetString, projects, currentPro
 function getOutputs(p, target, overrides) {
     return getOutputsForTargetAndConfiguration(target, overrides, p[target.project]);
 }
-function normalizeTargetDependencyWithStringProjects(dependencyConfig, currentProject, location) {
+function normalizeTargetDependencyWithStringProjects(dependencyConfig) {
     if (typeof dependencyConfig.projects === 'string') {
-        // TODO(v24): Remove the `self` / `dependencies` magic-string shim.
-        // The v16 `update-depends-on-to-tokens` migration already rewrites
-        // these to the modern shape, and `nx repair` will re-run it on demand.
-        if (dependencyConfig.projects === 'self') {
-            (0, legacy_depends_on_warning_1.warnLegacyDependsOnMagicString)(currentProject, dependencyConfig, location);
-            delete dependencyConfig.projects;
-        }
-        else if (dependencyConfig.projects === 'dependencies') {
-            (0, legacy_depends_on_warning_1.warnLegacyDependsOnMagicString)(currentProject, dependencyConfig, location);
-            dependencyConfig.dependencies = true;
-            delete dependencyConfig.projects;
-        }
-        else {
-            dependencyConfig.projects = [dependencyConfig.projects];
-        }
+        dependencyConfig.projects = [dependencyConfig.projects];
     }
     return dependencyConfig;
 }
@@ -222,18 +216,10 @@ function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode,
         validateOutputs(targetConfiguration.outputs);
         const result = new Set();
         for (const output of targetConfiguration.outputs) {
-            // A leading `!` is negation, not part of the path: strip it so
-            // `{workspaceRoot}` still sits where interpolate requires it.
-            const isNegated = output.startsWith('!');
-            const interpolatedOutput = interpolate(isNegated ? output.substring(1) : output, {
-                projectRoot: node.data.root,
-                projectName: node.name,
-                project: { ...node.data, name: node.name }, // this is legacy
-                options,
-            });
+            const interpolatedOutput = interpolateOutput(output, node, options);
             if (!!interpolatedOutput &&
                 !interpolatedOutput.match(/{(projectRoot|workspaceRoot|(options.*))}/)) {
-                result.add(isNegated ? `!${interpolatedOutput}` : interpolatedOutput);
+                result.add(output.startsWith('!') ? `!${interpolatedOutput}` : interpolatedOutput);
             }
         }
         return Array.from(result);
@@ -257,37 +243,89 @@ function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode,
     }
 }
 /**
- * Matches portions of a string which need to be interpolated.
- * Matches anything within curly braces, excluding the braces.
+ * Resolves the tokens in a configured output, without its leading `!`. A token
+ * with no value stays as written.
+ */
+function interpolateOutput(output, node, options) {
+    // A leading `!` is negation, not part of the path: strip it so
+    // `{workspaceRoot}` still sits where interpolate requires it.
+    return interpolate(output.startsWith('!') ? output.substring(1) : output, {
+        projectRoot: node.data.root,
+        projectName: node.name,
+        project: { ...node.data, name: node.name }, // this is legacy
+        options,
+    });
+}
+/**
+ * Resolves Nx tokens in a path, where each token names a key of `data`
+ * (`{projectRoot}/dist`, `{options.outputPath ?? dist/{projectRoot}}`).
+ * Paths starting with `/` are returned as written. A token with no value
+ * stays as written. `env.` is text, unless `envNotAllowed` is given: then it
+ * throws with that message.
  */
-const replacementRegex = /{([\s\S]+?)}/g;
-function interpolate(template, data) {
-    // Path is absolute or doesn't need interpolation
-    if (template.startsWith('/') || !replacementRegex.test(template)) {
+function interpolate(template, data, options) {
+    if (!/{[\s\S]+?}/.test(template)) {
+        return template;
+    }
+    const scope = {
+        isToken: (name) => name === 'env' || Object.hasOwn(data, name),
+        read: (name, path) => (0, tokens_1.readPath)(data[name], path),
+        env: options?.envNotAllowed
+            ? { reject: () => new Error(options.envNotAllowed(template)) }
+            : undefined,
+        noValue: (token) => token,
+    };
+    if (template.startsWith('/')) {
+        if (options?.envNotAllowed) {
+            (0, tokens_1.parseTokens)(template, scope);
+        }
         return template;
     }
-    if (template.includes('{workspaceRoot}', 1)) {
+    const nodes = (0, tokens_1.parseTokens)(template, scope);
+    if (!isWorkspaceRootOnlyAtStart(nodes, true)) {
         throw new Error(`Output '${template}' is invalid. {workspaceRoot} can only be used at the beginning of the expression.`);
     }
-    const parts = template.split('/').map((s) => _interpolate(s, data));
-    return (0, posix_1.join)(...parts).replace('{workspaceRoot}/', '');
+    return joinSegments(nodes, data, scope).replace('{workspaceRoot}/', '');
+}
+// A fallback's literal only ever replaces its whole token, so a token at the
+// start can fall back to `{workspaceRoot}/...`
+function isWorkspaceRootOnlyAtStart(nodes, atStart) {
+    return nodes.every((node, i) => {
+        const nodeAtStart = atStart && i === 0;
+        if (node.kind === 'text') {
+            return !node.text.includes('{workspaceRoot}', nodeAtStart ? 1 : 0);
+        }
+        return node.parts.every((part) => part.kind === 'literal'
+            ? isWorkspaceRootOnlyAtStart(part.nodes, nodeAtStart)
+            : part.name !== 'workspaceRoot' || nodeAtStart);
+    });
 }
-function _interpolate(template, data) {
-    let res = template;
-    if (data.projectRoot == '.') {
-        res = res.replace('{projectRoot}', '');
-    }
-    return res.replace(replacementRegex, (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;
+// Joining the `/`-separated segments normalizes a root project's
+// `{projectRoot}` away, wherever it sits
+function joinSegments(nodes, data, scope) {
+    const segments = [''];
+    const append = (nodes, isLiteral) => {
+        for (const [i, node] of nodes.entries()) {
+            if (node.kind === 'text') {
+                // A literal keeps its leading `/` on the segment, as an option value
+                // does, so an absolute fallback stays absolute
+                const root = isLiteral && i === 0 && node.text.startsWith('/') ? '/' : '';
+                const [first, ...rest] = node.text.substring(root.length).split('/');
+                segments[segments.length - 1] += root + first;
+                segments.push(...rest);
+            }
+            else {
+                // Resolved before indexing `segments`: a fallback literal appends to it
+                const value = data.projectRoot == '.' && node.raw === '{projectRoot}'
+                    ? ''
+                    : (0, tokens_1.resolveToken)(node, scope, (literal) => append(literal, true));
+                segments[segments.length - 1] += value;
             }
-            value = value[path[idx]];
         }
-        return value;
-    });
+        return '';
+    };
+    append(nodes, false);
+    return (0, posix_1.join)(...segments);
 }
 function getTargetConfigurationForTask(task, projectGraph) {
     const node = projectGraph.nodes[task.target.project];
@@ -324,10 +362,10 @@ function expandInitiatingTasksThroughNoop(initiatingTasks, taskGraph, projectGra
             continue;
         if (getExecutorNameForTask(task, projectGraph) === 'nx:noop') {
             for (const dep of taskGraph.dependencies[taskId] ?? []) {
-                queue.push(dep);
+                queue.push(dep.id);
             }
             for (const dep of taskGraph.continuousDependencies[taskId] ?? []) {
-                queue.push(dep);
+                queue.push(dep.id);
             }
         }
         else {
@@ -341,9 +379,33 @@ function getExecutorForTask(task, projects) {
     const [nodeModule, executorName] = (0, executor_utils_1.parseExecutor)(executor);
     return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot, projects);
 }
+// TODO(v25): remove custom hasher support.
 function getCustomHasher(task, projects) {
     const factory = getExecutorForTask(task, projects).hasherFactory;
-    return factory ? factory() : null;
+    if (!factory) {
+        return null;
+    }
+    warnCustomHasherDeprecation(projects[task.target.project].targets[task.target.target].executor);
+    return factory();
+}
+const customHasherDeprecationWarned = new Set();
+function warnCustomHasherDeprecation(executor) {
+    if (customHasherDeprecationWarned.has(executor)) {
+        return;
+    }
+    customHasherDeprecationWarned.add(executor);
+    output_1.output.warn({
+        title: `The "${executor}" executor uses a custom hasher, which is deprecated and will be removed in Nx 25.`,
+        bodyLines: [
+            'Replace the custom hasher with target inputs, following the migration guide:',
+            'https://nx.dev/docs/kb/local-executors#replace-a-custom-hasher-with-inputs',
+            'If the executor comes from a third-party plugin, report this to its maintainers.',
+        ],
+    });
+}
+/** Test-only: forget which executors have been warned about. */
+function resetCustomHasherDeprecationWarnings() {
+    customHasherDeprecationWarned.clear();
 }
 /**
  * `taskGraph` pruned to `required`, which must already hold its dependencies.
@@ -370,8 +432,8 @@ function removeIdsFromTaskGraph(graph, ids, mapWithIds) {
     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));
-            continuousDependencies[id] = graph.continuousDependencies[id].filter((depId) => !removedSet.has(depId));
+            dependencies[id] = graph.dependencies[id].filter((dep) => !removedSet.has(dep.id));
+            continuousDependencies[id] = graph.continuousDependencies[id].filter((dep) => !removedSet.has(dep.id));
         }
     }
     return {
@@ -388,12 +450,12 @@ function calculateReverseDeps(taskGraph) {
     });
     Object.keys(taskGraph.dependencies).forEach((taskId) => {
         taskGraph.dependencies[taskId].forEach((d) => {
-            reverseTaskDeps[d].push(taskId);
+            reverseTaskDeps[d.id].push(taskId);
         });
     });
     Object.keys(taskGraph.continuousDependencies).forEach((taskId) => {
         taskGraph.continuousDependencies[taskId].forEach((d) => {
-            reverseTaskDeps[d].push(taskId);
+            reverseTaskDeps[d.id].push(taskId);
         });
     });
     return reverseTaskDeps;
@@ -457,3 +519,22 @@ function createTaskId(project, target, configuration) {
     }
     return id;
 }
+/**
+ * Distinguishes two invocations of the same task for the recursive invocation
+ * detector. The task id alone would report `nx run app:build --flag` invoked
+ * from within `app:build` as a loop, so the detector pairs the id with this
+ * hash and only treats an exact repeat as an immediate loop.
+ *
+ * The hash cannot decide recursion on its own. Arguments that accumulate
+ * through forwarding (`app:build` -> `app:build hello` -> `app:build hello
+ * hello`) hash differently on every hop, so the tracker also bounds how many
+ * ancestors may be running one task id.
+ *
+ * `__overrides_unparsed__` is dropped, matching how the task hasher treats it:
+ * it restates the other keys as raw argv, down to flag order and spelling.
+ */
+function hashTaskOverrides(task) {
+    const overrides = { ...task.overrides };
+    delete overrides['__overrides_unparsed__'];
+    return (0, file_hasher_1.hashObject)(overrides);
+}

package/dist/src/ultracache/ci-status.d.ts

@@ -0,0 +1,24 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+import type { InputDefinition, TargetConfiguration } from '../config/workspace-json-project-json';
+export declare const ULTRACACHE_DOCS_URL = "https://nx.dev/docs/reference/project-configuration#ultracache";
+/**
+ * "Learn more" as an OSC 8 link where the terminal supports one, styled like
+ * the TUI's links (underline + cyan, see `tui/components/link.rs`); else the dimmed URL.
+ */
+export declare function ultracacheDocsLink(): string;
+/**
+ * Whether Nx Cloud's workspace setting has CI hash tasks from their Ultracache
+ * configs. `false` whenever Nx Cloud cannot say. Asked once per process.
+ */
+export declare function isUltracacheOnInCI(nxJson: NxJsonConfiguration): Promise<boolean>;
+/** For specs. */
+export declare function resetUltracacheStatus(): void;
+export type UltracacheModeInCI = 'on' | 'warn' | 'error' | 'off';
+/**
+ * How CI treats this target's tasks when the workspace is On; `undefined` when
+ * Ultracache doesn't apply. Mirrors the eligibility walk in `ultracache_eligibility.rs`.
+ */
+export declare function ultracacheModeInCI(target: TargetConfiguration, customHasher: boolean): UltracacheModeInCI | undefined;
+export declare function hasAlwaysInput(inputs: readonly (InputDefinition | string)[] | undefined): boolean;
+/** The notice `nx show` prints after `Ultracache:` for a target in `mode`. */
+export declare function ultracacheInCINotice(mode: UltracacheModeInCI, alwaysInputs: boolean): string;

package/dist/src/ultracache/ci-status.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ULTRACACHE_DOCS_URL = void 0;
+exports.ultracacheDocsLink = ultracacheDocsLink;
+exports.isUltracacheOnInCI = isUltracacheOnInCI;
+exports.resetUltracacheStatus = resetUltracacheStatus;
+exports.ultracacheModeInCI = ultracacheModeInCI;
+exports.hasAlwaysInput = hasAlwaysInput;
+exports.ultracacheInCINotice = ultracacheInCINotice;
+const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
+const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+const terminal_link_1 = require("../utils/terminal-link");
+const fetch_1 = require("./fetch");
+const STATUS_TIMEOUT_MS = 2_000;
+exports.ULTRACACHE_DOCS_URL = 'https://nx.dev/docs/reference/project-configuration#ultracache';
+/**
+ * "Learn more" as an OSC 8 link where the terminal supports one, styled like
+ * the TUI's links (underline + cyan, see `tui/components/link.rs`); else the dimmed URL.
+ */
+function ultracacheDocsLink() {
+    const pc = require('picocolors');
+    return (0, terminal_link_1.supportsHyperlinks)()
+        ? (0, terminal_link_1.terminalLink)(pc.cyan(pc.underline('Learn more')), exports.ULTRACACHE_DOCS_URL)
+        : pc.dim(exports.ULTRACACHE_DOCS_URL);
+}
+let status;
+/**
+ * Whether Nx Cloud's workspace setting has CI hash tasks from their Ultracache
+ * configs. `false` whenever Nx Cloud cannot say. Asked once per process.
+ */
+function isUltracacheOnInCI(nxJson) {
+    status ??= readUltracacheStatus(nxJson);
+    return status;
+}
+/** For specs. */
+function resetUltracacheStatus() {
+    status = undefined;
+}
+async function readUltracacheStatus(nxJson) {
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)(nxJson)) {
+        return false;
+    }
+    try {
+        const nxCloudOptions = (0, get_cloud_options_1.getCloudOptions)();
+        const client = await (0, fetch_1.loadCloudClient)(nxCloudOptions);
+        if (typeof client?.readUltracacheStatus !== 'function') {
+            return false;
+        }
+        const { enabled } = await client.readUltracacheStatus({
+            nxCloudOptions,
+            timeoutMs: STATUS_TIMEOUT_MS,
+        });
+        return enabled === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * How CI treats this target's tasks when the workspace is On; `undefined` when
+ * Ultracache doesn't apply. Mirrors the eligibility walk in `ultracache_eligibility.rs`.
+ */
+function ultracacheModeInCI(target, customHasher) {
+    if (target.cache !== true || target.continuous || customHasher) {
+        return undefined;
+    }
+    return target.ultracache?.mode ?? 'on';
+}
+function hasAlwaysInput(inputs) {
+    return !!inputs?.some((i) => typeof i === 'object' && 'always' in i && i.always);
+}
+/** The notice `nx show` prints after `Ultracache:` for a target in `mode`. */
+function ultracacheInCINotice(mode, alwaysInputs) {
+    switch (mode) {
+        case 'on':
+            return [
+                'In CI, file inputs are replaced by the files this task read during previous runs.',
+                ...(alwaysInputs ? ['`always` inputs still count.'] : []),
+            ].join(' ');
+        case 'warn':
+            return 'In CI, Nx Cloud warns if this task reads files outside its hash or writes files outside its outputs.';
+        case 'error':
+            return 'In CI, Nx Cloud fails the run if this task reads files outside its hash or writes files outside its outputs.';
+        case 'off':
+            return 'In CI, this task is not recorded.';
+    }
+}

package/dist/src/ultracache/config.d.ts

@@ -12,9 +12,9 @@ export interface UltracacheEnv {
     hasNxCloudToken?: boolean;
 }
 /**
- * Off unless a CI run opts in with `NX_CLOUD_USE_ULTRACACHE=true` in a
- * workspace that uses Nx Cloud, since there is nothing to fetch from otherwise.
- * `env` defaults to this process's.
+ * On for CI runs in a workspace that uses Nx Cloud, since there is nothing to
+ * fetch from otherwise. Nx Cloud's workspace setting decides whether the fetch
+ * returns any; `NX_CLOUD_USE_ULTRACACHE=false` skips it. `env` defaults to this process's.
  */
 export declare function isUltracacheConfigurationFetchEnabled(nxJson: NxJsonConfiguration, runnerOptions?: UltracacheCloudOptions, env?: UltracacheEnv): boolean;
 /** The subset of this run's environment the decision reads. */

package/dist/src/ultracache/config.js

@@ -5,15 +5,15 @@ exports.ultracacheEnv = ultracacheEnv;
 const is_ci_1 = require("../utils/is-ci");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 /**
- * Off unless a CI run opts in with `NX_CLOUD_USE_ULTRACACHE=true` in a
- * workspace that uses Nx Cloud, since there is nothing to fetch from otherwise.
- * `env` defaults to this process's.
+ * On for CI runs in a workspace that uses Nx Cloud, since there is nothing to
+ * fetch from otherwise. Nx Cloud's workspace setting decides whether the fetch
+ * returns any; `NX_CLOUD_USE_ULTRACACHE=false` skips it. `env` defaults to this process's.
  */
 function isUltracacheConfigurationFetchEnabled(nxJson, runnerOptions = {}, env = ultracacheEnv()) {
     if (env.NX_NO_CLOUD === 'true' ||
         nxJson.neverConnectToCloud ||
         runnerOptions.cloud === false ||
-        env.NX_CLOUD_USE_ULTRACACHE !== 'true' ||
+        env.NX_CLOUD_USE_ULTRACACHE === 'false' ||
         !(0, is_ci_1.isCI)()) {
         return false;
     }

package/dist/src/ultracache/fetch.d.ts

@@ -1,3 +1,4 @@
+import { type NxCloudClient } from '../nx-cloud/update-manager';
 import type { UltracacheCloudOptions } from './config';
 /** The Nx Cloud client's `readUltracacheConfigurations` contract, as far as nx uses it. */
 export interface ReadUltracacheConfigurationsOptions {
@@ -19,3 +20,4 @@ export interface ReadUltracacheConfigurationsResult {
  * `NO_CONFIGURATIONS`.
  */
 export declare function fetchUltracacheConfigurations(runnerOptions: UltracacheCloudOptions): Promise<ReadUltracacheConfigurationsResult>;
+export declare function loadCloudClient(runnerOptions: UltracacheCloudOptions): Promise<NxCloudClient | undefined>;

package/dist/src/ultracache/fetch.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchUltracacheConfigurations = fetchUltracacheConfigurations;
+exports.loadCloudClient = loadCloudClient;
 const resolution_helpers_1 = require("../nx-cloud/resolution-helpers");
 const update_manager_1 = require("../nx-cloud/update-manager");
 const workspace_root_1 = require("../utils/workspace-root");

package/dist/src/ultracache/overrides.js

@@ -19,6 +19,7 @@ function customHasherTaskIds(projectGraph, taskGraph) {
         return memoized;
     }
     const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
+    // TODO(v25): remove custom hasher support.
     const ids = Object.values(taskGraph.tasks)
         .filter((task) => {
         try {
@@ -48,6 +49,9 @@ function getUltracacheSettings(taskGraph) {
 function ultracacheEligibilityOptions(projectGraph, taskGraph) {
     return {
         customHasherTaskIds: customHasherTaskIds(projectGraph, taskGraph),
+        continuousTaskIds: Object.values(taskGraph.tasks)
+            .filter((task) => task.continuous)
+            .map((task) => task.id),
     };
 }
 /**

package/dist/src/utils/acknowledge-build-scripts.d.ts

@@ -9,5 +9,38 @@ import type { PackageManager } from './package-manager';
  * that introduces such a dependency records the decision up front. Other
  * package managers run build scripts unconditionally, so this is a no-op for
  * them.
+ *
+ * @param treeOrRoot The workspace tree, or its root on disk.
+ * @param packageManager The workspace package manager.
+ * @param entries Package name to decision: `true` runs the package's build
+ * scripts, `false` skips them. Entries the user already decided are kept.
+ * @param directory Workspace root relative to the tree root, for generators
+ * that scaffold a workspace into a subdirectory.
+ *
+ * @example
+ * ```typescript
+ * acknowledgeBuildScripts(tree, detectPackageManager(tree.root), {
+ *   esbuild: false,
+ *   cypress: true,
+ * });
+ * ```
+ */
+export declare function acknowledgeBuildScripts(treeOrRoot: Tree | string, packageManager: PackageManager, entries: Record<string, boolean>, directory?: string): void;
+/**
+ * Records the build-script decisions a package declares for its own
+ * dependency tree, so the install that first pulls the package in can stay
+ * strict. A package declares them in the `pnpm.allowBuilds` field of its
+ * package.json, the same shape pnpm reads from a workspace root; pnpm ignores
+ * the field on dependencies, so it is read from the registry here.
+ *
+ * A declared `false` is recorded as is: it only skips a script. A declared
+ * `true` would let a publisher authorize code execution in the workspace, so
+ * it is a request: in a terminal the owner picks which to allow, elsewhere
+ * every request is recorded as `false`. Decisions the owner already recorded
+ * are kept either way, and everything recorded is printed.
+ *
+ * Resolves to whether the package declared any decision. Nothing is recorded
+ * for package managers other than pnpm, pnpm < 11, packages that declare
+ * nothing, and specs the registry cannot answer, such as a tarball path.
  */
-export declare function acknowledgeBuildScripts(treeOrRoot: Tree | string, packageManager: PackageManager, entries: Record<string, boolean>): void;
+export declare function acknowledgeDeclaredBuildScripts(treeOrRoot: Tree | string, packageManager: PackageManager, packageName: string, version: string, directory?: string): Promise<boolean>;