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

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

@@ -20,7 +20,7 @@ export type TasksRunner<T = unknown> = (tasks: Task[], options: T, context?: {
     hasher?: TaskHasher;
     daemon?: DaemonClient;
     /** Tasks hashed only once the tasks they read outputs from have run. */
-    deferredTaskIds?: ReadonlySet<string>;
+    hashingDeferredTaskIds?: ReadonlySet<string>;
 }) => any | Promise<{
     [id: string]: TaskStatus;
 }>;

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

@@ -2,16 +2,23 @@ import { DefaultTasksRunnerOptions } from './default-tasks-runner';
 import { Task, TaskGraph } from '../config/task-graph';
 import { ProjectGraph } from '../config/project-graph';
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { TaskReadiness } from '../native';
 export interface Batch {
     id: string;
     executorName: string;
     taskGraph: TaskGraph;
 }
+export interface TasksScheduleHooks {
+    readinessElsewhere?: (producerId: string) => TaskReadiness | null;
+    onReadinessHold?: (producerId: string) => void;
+}
 export declare class TasksSchedule {
     private readonly projectGraph;
     private readonly projects;
     private readonly taskGraph;
     private readonly options;
+    private readonly fullTaskGraph;
+    private readonly hooks;
     private notScheduledTaskGraph;
     private reverseTaskDeps;
     private reverseProjectGraph;
@@ -19,14 +26,21 @@ export declare class TasksSchedule {
     private scheduledBatches;
     private scheduledTasks;
     private runningTasks;
+    private pendingStart;
     private completedTasks;
+    private readiness;
+    private probedProducers;
     private scheduleRequestsExecutionChain;
     private estimatedTaskTimings;
     private projectDependencies;
     private batchCounters;
-    constructor(projectGraph: ProjectGraph, projects: Record<string, ProjectConfiguration>, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions);
+    constructor(projectGraph: ProjectGraph, projects: Record<string, ProjectConfiguration>, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions, fullTaskGraph?: TaskGraph, hooks?: TasksScheduleHooks);
     init(): Promise<void>;
     scheduleNextTasks(): Promise<void>;
+    markContinuousTaskStarted(taskId: string): void;
+    markReady(taskId: string): void;
+    markReadinessFailed(taskId: string): void;
+    markReadinessPending(taskId: string): void;
     hasTasks(): boolean;
     complete(taskIds: string[]): void;
     getAllScheduledTasks(): {
@@ -42,7 +56,10 @@ export declare class TasksSchedule {
     private scheduleBatches;
     private scheduleBatch;
     private processTaskForBatches;
+    private probedProducersOf;
+    private isProducerReady;
     private canBatchTaskBeScheduled;
+    private areContinuousDependenciesReady;
     private canBeScheduled;
     getEstimatedTaskTimings(): Record<string, number>;
 }

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

@@ -5,12 +5,15 @@ const utils_1 = require("./utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
 const operators_1 = require("../project-graph/operators");
 const task_history_1 = require("../utils/task-history");
+const ready_when_1 = require("./readiness/ready-when");
 class TasksSchedule {
-    constructor(projectGraph, projects, taskGraph, options) {
+    constructor(projectGraph, projects, taskGraph, options, fullTaskGraph = taskGraph, hooks = {}) {
         this.projectGraph = projectGraph;
         this.projects = projects;
         this.taskGraph = taskGraph;
         this.options = options;
+        this.fullTaskGraph = fullTaskGraph;
+        this.hooks = hooks;
         this.notScheduledTaskGraph = this.taskGraph;
         this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
         this.reverseProjectGraph = (0, operators_1.reverse)(this.projectGraph);
@@ -18,7 +21,13 @@ class TasksSchedule {
         this.scheduledBatches = [];
         this.scheduledTasks = [];
         this.runningTasks = new Set();
+        // Continuous tasks with ready edges, queued but not spawned; their
+        // dependents stay unreleased
+        this.pendingStart = new Set();
         this.completedTasks = new Set();
+        this.readiness = new Map();
+        // Read from the full graph: an agent worker's own graph has no edges
+        this.probedProducers = (0, ready_when_1.getReadyDependencies)(this.fullTaskGraph, this.projectGraph);
         this.scheduleRequestsExecutionChain = Promise.resolve();
         this.estimatedTaskTimings = {};
         this.projectDependencies = {};
@@ -38,6 +47,18 @@ class TasksSchedule {
             this.scheduleRequestsExecutionChain.then(() => this.scheduleTasks());
         await this.scheduleRequestsExecutionChain;
     }
+    markContinuousTaskStarted(taskId) {
+        this.pendingStart.delete(taskId);
+    }
+    markReady(taskId) {
+        this.readiness.set(taskId, 'ready');
+    }
+    markReadinessFailed(taskId) {
+        this.readiness.set(taskId, 'failed');
+    }
+    markReadinessPending(taskId) {
+        this.readiness.delete(taskId);
+    }
     hasTasks() {
         return (this.scheduledBatches.length +
             this.scheduledTasks.length +
@@ -116,6 +137,10 @@ class TasksSchedule {
         for (const taskId of taskIds) {
             this.scheduledTasks.push(taskId);
             this.runningTasks.add(taskId);
+            const task = this.taskGraph.tasks[taskId];
+            if (task.continuous && this.probedProducersOf(task).length > 0) {
+                this.pendingStart.add(taskId);
+            }
         }
         this.sortScheduledTasks();
     }
@@ -182,6 +207,15 @@ class TasksSchedule {
         if (!this.canBatchTaskBeScheduled(task, batches[rootExecutorName])) {
             return;
         }
+        // A batch never waits, so a task joins one once its probed producers are
+        // ready. A continuous task that something waits on, or that declares a
+        // probe, runs alone: only that path records its start and readiness
+        if ((task.continuous &&
+            (this.reverseTaskDeps[task.id].length > 0 ||
+                (0, ready_when_1.getReadyWhenConfig)(task, this.projectGraph) != null)) ||
+            this.probedProducersOf(task).some((id) => !this.isProducerReady(id))) {
+            return;
+        }
         const { batchImplementationFactory, preferBatch } = (0, utils_1.getExecutorForTask)(task, this.projects);
         const executorName = (0, utils_1.getExecutorNameForTask)(task, this.projectGraph);
         if (rootExecutorName !== executorName) {
@@ -222,17 +256,40 @@ class TasksSchedule {
             await this.processTaskForBatches(batches, depTask, rootExecutorName, false, visitedInBatch);
         }
     }
+    probedProducersOf(task) {
+        return this.probedProducers[task.id] ?? [];
+    }
+    isProducerReady(producerId) {
+        if (this.taskGraph.tasks[producerId]) {
+            return this.readiness.get(producerId) === 'ready';
+        }
+        return this.hooks.readinessElsewhere?.(producerId) === 1 /* TaskReadiness.Ready */;
+    }
     canBatchTaskBeScheduled(task, batchTaskGraph) {
         // task self needs to support parallelism (undefined defaults to parallel)
-        // all deps have either completed or belong to the same batch
+        // all deps have either completed or belong to the same batch, and every
+        // continuous dep has started, and is ready where the edge asks for it
         return (task.parallelism !== false &&
-            this.taskGraph.dependencies[task.id].every((id) => this.completedTasks.has(id) || !!batchTaskGraph?.tasks[id]));
+            this.taskGraph.dependencies[task.id].every(({ id }) => this.completedTasks.has(id) || !!batchTaskGraph?.tasks[id]) &&
+            this.areContinuousDependenciesReady(task.id));
+    }
+    // A producer outside this task graph is polled by the task itself
+    areContinuousDependenciesReady(taskId) {
+        const started = this.taskGraph.continuousDependencies[taskId].every(({ id }) => this.runningTasks.has(id) && !this.pendingStart.has(id));
+        if (!started) {
+            return false;
+        }
+        const pendingProducers = this.probedProducersOf(this.taskGraph.tasks[taskId]).filter((id) => this.taskGraph.tasks[id] && !this.readiness.has(id));
+        for (const producerId of pendingProducers) {
+            this.hooks.onReadinessHold?.(producerId);
+        }
+        return pendingProducers.length === 0;
     }
     canBeScheduled(taskId) {
-        const hasDependenciesCompleted = this.taskGraph.dependencies[taskId].every((id) => this.completedTasks.has(id));
-        const hasContinuousDependenciesStarted = this.taskGraph.continuousDependencies[taskId].every((id) => this.runningTasks.has(id));
+        const hasDependenciesCompleted = this.taskGraph.dependencies[taskId].every(({ id }) => this.completedTasks.has(id));
+        const continuousDependenciesReady = this.areContinuousDependenciesReady(taskId);
         // if dependencies have not completed, cannot schedule
-        if (!hasDependenciesCompleted || !hasContinuousDependenciesStarted) {
+        if (!hasDependenciesCompleted || !continuousDependenciesReady) {
             return false;
         }
         // if there are no running tasks, can schedule anything

package/dist/src/tasks-runner/tokens.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Nx tokens are `{name}` or `{name.path}`, optionally followed by `??`
+ * fallbacks that resolve left to right: `{options.port ?? env.PORT ?? 4200}`.
+ * Only the last part can be a literal, and the literal can contain tokens.
+ * Braces that don't start with a token are text, so `${VAR}` or
+ * `{{.State.Health.Status}}` stay as written.
+ */
+export type TokenNode = {
+    kind: 'text';
+    text: string;
+} | Token;
+export interface Token {
+    kind: 'token';
+    raw: string;
+    parts: TokenPart[];
+}
+export type TokenPart = Reference | {
+    kind: 'literal';
+    nodes: TokenNode[];
+};
+interface Reference {
+    kind: 'reference';
+    name: string;
+    path: string | undefined;
+}
+export interface TokenScope {
+    /** Whether `{name}` or `{name.path}` is a token. An `env.` fallback skips this check */
+    isToken(name: string, path: string | undefined): boolean;
+    /** The value of `{name}` or `{name.path}` */
+    read(name: string, path: string | undefined): unknown;
+    /**
+     * Where `env.` references read from. When absent, `env.` is not a token, so
+     * `{env.X}` stays text and a fallback `env.X` is a literal.
+     */
+    env?: {
+        read: () => NodeJS.ProcessEnv;
+    } | {
+        reject: () => Error;
+    };
+    /** The text of a token with no value and no literal fallback */
+    noValue(token: string): string;
+    /** Whether a value counts as unset, as `undefined`, `null` and `''` always do */
+    isUnset?(value: unknown): boolean;
+    /** The text of a value; defaults to `String(value)` */
+    toText?(value: unknown, token: string): string;
+}
+export declare function parseTokens(template: string, scope: TokenScope): TokenNode[];
+export declare function resolveTokens(template: string, scope: TokenScope): string;
+export declare function renderTokens(nodes: TokenNode[], scope: TokenScope): string;
+export declare function resolveToken(token: Token, scope: TokenScope, renderLiteral: (nodes: TokenNode[]) => string): string;
+/** Walks a dotted path; a missing step yields `undefined` */
+export declare function readPath(value: unknown, path: string | undefined): unknown;
+export declare function readEnv(env: NodeJS.ProcessEnv, name: string): string | undefined;
+export {};

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

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokens = parseTokens;
+exports.resolveTokens = resolveTokens;
+exports.renderTokens = renderTokens;
+exports.resolveToken = resolveToken;
+exports.readPath = readPath;
+exports.readEnv = readEnv;
+function parseTokens(template, scope) {
+    const nodes = [];
+    let text = '';
+    let index = 0;
+    let open;
+    while ((open = template.indexOf('{', index)) !== -1) {
+        const close = findClosingBrace(template, open);
+        const node = close === -1 ? null : parseToken(template.slice(open, close + 1), scope);
+        if (!node) {
+            // Not a token, but a token can still sit inside it: `{a,{projectRoot}}`
+            text += template.slice(index, open + 1);
+            index = open + 1;
+            continue;
+        }
+        text += template.slice(index, open);
+        if (text) {
+            nodes.push({ kind: 'text', text });
+        }
+        text = '';
+        nodes.push(node);
+        index = close + 1;
+    }
+    text += template.slice(index);
+    if (text) {
+        nodes.push({ kind: 'text', text });
+    }
+    return nodes;
+}
+function resolveTokens(template, scope) {
+    return renderTokens(parseTokens(template, scope), scope);
+}
+function renderTokens(nodes, scope) {
+    return nodes
+        .map((node) => node.kind === 'text'
+        ? node.text
+        : resolveToken(node, scope, (literal) => renderTokens(literal, scope)))
+        .join('');
+}
+function resolveToken(token, scope, renderLiteral) {
+    for (const part of token.parts) {
+        if (part.kind === 'literal') {
+            return renderLiteral(part.nodes);
+        }
+        const value = part.name === 'env' && scope.env && 'read' in scope.env
+            ? readEnv(scope.env.read(), part.path)
+            : scope.read(part.name, part.path);
+        if (value !== undefined &&
+            value !== null &&
+            value !== '' &&
+            !scope.isUnset?.(value)) {
+            return scope.toText ? scope.toText(value, token.raw) : String(value);
+        }
+    }
+    return scope.noValue(token.raw);
+}
+/** Walks a dotted path; a missing step yields `undefined` */
+function readPath(value, path) {
+    if (path === undefined) {
+        return value;
+    }
+    for (const key of path.split('.')) {
+        if (value === undefined ||
+            value === null ||
+            !Object.hasOwn(value, key)) {
+            return undefined;
+        }
+        value = value[key];
+    }
+    return value;
+}
+function parseToken(raw, scope) {
+    const sources = splitFallbacks(raw.slice(1, -1));
+    if (!parseReference(sources[0], scope, true)) {
+        return null;
+    }
+    const parts = sources.map((source, i) => {
+        const reference = parseReference(source, scope, i === 0);
+        if (reference) {
+            return reference;
+        }
+        if (i < sources.length - 1) {
+            throw new Error(`"${raw}" has a fallback after the literal "${source}" that can never be used`);
+        }
+        return { kind: 'literal', nodes: parseTokens(source, scope) };
+    });
+    if (scope.env && 'reject' in scope.env && readsEnv(parts)) {
+        throw scope.env.reject();
+    }
+    return { kind: 'token', raw, parts };
+}
+function readsEnv(parts) {
+    return parts.some((p) => p.kind === 'reference' && p.name === 'env');
+}
+// The names an env file can define, plus parentheses for Windows names such as
+// `ProgramFiles(x86)`. A glob such as `{env.ts,env.d.ts}` stays text
+const ENV_NAME = /^[\w.()-]+$/;
+function parseReference(source, scope, first) {
+    const dot = source.indexOf('.');
+    const name = dot === -1 ? source : source.slice(0, dot);
+    const path = dot === -1 ? undefined : source.slice(dot + 1);
+    const isReference = name === 'env'
+        ? scope.env !== undefined &&
+            path !== undefined &&
+            ENV_NAME.test(path) &&
+            (!first || scope.isToken(name, path))
+        : scope.isToken(name, path);
+    return isReference ? { kind: 'reference', name, path } : null;
+}
+function findClosingBrace(template, open) {
+    let depth = 0;
+    for (let i = open; i < template.length; i++) {
+        if (template[i] === '{') {
+            depth++;
+        }
+        else if (template[i] === '}' && --depth === 0) {
+            return i;
+        }
+    }
+    return -1;
+}
+function splitFallbacks(expression) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < expression.length; i++) {
+        if (expression[i] === '{') {
+            depth++;
+        }
+        else if (expression[i] === '}') {
+            depth--;
+        }
+        else if (depth === 0 && expression.startsWith('??', i)) {
+            parts.push(expression.slice(start, i));
+            start = i + 2;
+            i++;
+        }
+    }
+    parts.push(expression.slice(start));
+    return parts.map((part) => part.trim());
+}
+// Windows env names are case-insensitive, but a copied env object keeps the
+// spelling Windows reported (`Path`, not `PATH`)
+function readEnv(env, name) {
+    if (Object.hasOwn(env, name)) {
+        return env[name];
+    }
+    if (process.platform !== 'win32') {
+        return undefined;
+    }
+    const upperName = name.toUpperCase();
+    const key = Object.keys(env).find((k) => k.toUpperCase() === upperName);
+    return key === undefined ? undefined : env[key];
+}

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

@@ -2,7 +2,6 @@ import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { ProjectConfiguration, TargetConfiguration, TargetDependencyConfig } from '../config/workspace-json-project-json';
-import { LegacyDependsOnLocation } from './legacy-depends-on-warning';
 export type NormalizedTargetDependencyConfig = TargetDependencyConfig & {
     projects: string[];
 };
@@ -10,9 +9,8 @@ export declare function getDependencyConfigs({ project, target }: {
     project: string;
     target: string;
 }, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, projectGraph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[] | undefined;
-export type DependsOnEntryLocation = LegacyDependsOnLocation;
-export declare function normalizeDependencyConfigDefinition(definition: string | TargetDependencyConfig, currentProject: string, graph: ProjectGraph, allTargetNames: string[], location?: DependsOnEntryLocation): NormalizedTargetDependencyConfig[];
-export declare function normalizeDependencyConfigProjects(dependencyConfig: TargetDependencyConfig, currentProject: string, graph: ProjectGraph, location?: DependsOnEntryLocation): NormalizedTargetDependencyConfig;
+export declare function normalizeDependencyConfigDefinition(definition: string | TargetDependencyConfig, currentProject: string, graph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
+export declare function normalizeDependencyConfigProjects(dependencyConfig: TargetDependencyConfig, currentProject: string, graph: ProjectGraph): NormalizedTargetDependencyConfig;
 export declare function expandDependencyConfigSyntaxSugar(dependencyConfigString: string | TargetDependencyConfig, graph: ProjectGraph, currentProject?: string): TargetDependencyConfig;
 export declare function expandWildcardTargetConfiguration(dependencyConfig: NormalizedTargetDependencyConfig, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
 export declare function readProjectAndTargetFromTargetString(targetString: string, projects: Record<string, ProjectGraphProjectNode>, currentProject?: string): {
@@ -20,7 +18,7 @@ export declare function readProjectAndTargetFromTargetString(targetString: strin
     target: string;
 };
 export declare function getOutputs(p: Record<string, ProjectGraphProjectNode>, target: Task['target'], overrides: Task['overrides']): string[];
-export declare function normalizeTargetDependencyWithStringProjects(dependencyConfig: TargetDependencyConfig, currentProject?: string, location?: DependsOnEntryLocation): Omit<TargetDependencyConfig, 'projects'> & {
+export declare function normalizeTargetDependencyWithStringProjects(dependencyConfig: TargetDependencyConfig): Omit<TargetDependencyConfig, 'projects'> & {
     projects?: string[];
 };
 export declare function validateOutputs(outputs: string[]): void;
@@ -30,7 +28,21 @@ export declare function transformLegacyOutputs(projectRoot: string, outputs: str
  */
 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;
+/**
+ * Resolves the tokens in a configured output, without its leading `!`. A token
+ * with no value stays as written.
+ */
+export declare function interpolateOutput(output: string, node: ProjectGraphProjectNode, options: Record<string, unknown>): string;
+/**
+ * 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.
+ */
+export declare function interpolate(template: string, data: any, options?: {
+    envNotAllowed?: (template: string) => string;
+}): string;
 export declare function getTargetConfigurationForTask(task: Task, projectGraph: ProjectGraph): TargetConfiguration | undefined;
 export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): string;
 /**
@@ -49,6 +61,8 @@ export declare function getExecutorForTask(task: Task, projects: Record<string,
     isNxExecutor: boolean;
 };
 export declare function getCustomHasher(task: Task, projects: Record<string, ProjectConfiguration>): CustomHasher | null;
+/** Test-only: forget which executors have been warned about. */
+export declare function resetCustomHasherDeprecationWarnings(): void;
 /**
  * `taskGraph` pruned to `required`, which must already hold its dependencies.
  * Unknown ids are ignored: a sync generator can remove a task after selection.
@@ -64,3 +78,18 @@ export declare function shouldStreamOutput(task: Task, initiatingProject: string
 export declare function isCacheableTask(task: Task): boolean;
 export declare function unparse(options: Object): string[];
 export declare function createTaskId(project: string, target: string, configuration: string | undefined): string;
+/**
+ * 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.
+ */
+export declare function hashTaskOverrides(task: Task): string;