@ohos-ports/nx 17.3.2-beta.0

package/src/tasks-runner/life-cycles/invoke-runner-terminal-output-life-cycle.d.ts

@@ -0,0 +1,17 @@
+import { TaskStatus } from '../tasks-runner';
+import type { LifeCycle } from '../life-cycle';
+import { Task } from '../../config/task-graph';
+export declare class InvokeRunnerTerminalOutputLifeCycle implements LifeCycle {
+    private readonly tasks;
+    failedTasks: Task[];
+    cachedTasks: Task[];
+    constructor(tasks: Task[]);
+    startCommand(): void;
+    endCommand(): void;
+    endTasks(taskResults: {
+        task: Task;
+        status: TaskStatus;
+        code: number;
+    }[]): void;
+    printTaskTerminalOutput(task: Task, cacheStatus: TaskStatus, terminalOutput: string): void;
+}

package/src/tasks-runner/life-cycles/invoke-runner-terminal-output-life-cycle.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvokeRunnerTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const utils_1 = require("../utils");
+class InvokeRunnerTerminalOutputLifeCycle {
+    constructor(tasks) {
+        this.tasks = tasks;
+        this.failedTasks = [];
+        this.cachedTasks = [];
+    }
+    startCommand() {
+        output_1.output.log({
+            color: 'cyan',
+            title: `Running ${this.tasks.length} tasks:`,
+            bodyLines: this.tasks.map((task) => `- Task ${task.id} ${task.overrides.__overrides_unparsed__.length > 0
+                ? `Overrides: ${task.overrides.__overrides_unparsed__.join(' ')}`
+                : ''}`),
+        });
+        output_1.output.addVerticalSeparatorWithoutNewLines('cyan');
+    }
+    endCommand() {
+        output_1.output.addNewline();
+        const taskIds = this.tasks.map((task) => {
+            const cached = this.cachedTasks.indexOf(task) !== -1;
+            const failed = this.failedTasks.indexOf(task) !== -1;
+            return `- Task ${task.id} ${task.overrides.__overrides_unparsed__.length > 0
+                ? `Overrides: ${task.overrides.__overrides_unparsed__.join(' ')}`
+                : ''} ${cached ? 'CACHED' : ''} ${failed ? 'FAILED' : ''}`;
+        });
+        if (this.failedTasks.length === 0) {
+            output_1.output.addVerticalSeparatorWithoutNewLines('green');
+            output_1.output.success({
+                title: `Successfully ran ${this.tasks.length} tasks:`,
+                bodyLines: taskIds,
+            });
+        }
+        else {
+            output_1.output.addVerticalSeparatorWithoutNewLines('red');
+            output_1.output.error({
+                title: `Ran ${this.tasks.length} tasks:`,
+                bodyLines: taskIds,
+            });
+        }
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            if (t.status === 'failure') {
+                this.failedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache-kept-existing') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'remote-cache') {
+                this.cachedTasks.push(t.task);
+            }
+        }
+    }
+    printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
+        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+        output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
+    }
+}
+exports.InvokeRunnerTerminalOutputLifeCycle = InvokeRunnerTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/pretty-time.d.ts

@@ -0,0 +1,4 @@
+/**
+ * All credit to https://github.com/jonschlinkert/pretty-time
+ */
+export declare function prettyTime(time: any, smallest?: any, digits?: any): string;

package/src/tasks-runner/life-cycles/pretty-time.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * All credit to https://github.com/jonschlinkert/pretty-time
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyTime = void 0;
+const nano = (time) => +time[0] * 1e9 + +time[1];
+const scale = {
+    w: 6048e11,
+    d: 864e11,
+    h: 36e11,
+    m: 6e10,
+    s: 1e9,
+    ms: 1e6,
+    μs: 1e3,
+    ns: 1,
+};
+const regex = {
+    w: /^(w((ee)?k)?s?)$/,
+    d: /^(d(ay)?s?)$/,
+    h: /^(h((ou)?r)?s?)$/,
+    m: /^(min(ute)?s?|m)$/,
+    s: /^((sec(ond)?)s?|s)$/,
+    ms: /^(milli(second)?s?|ms)$/,
+    μs: /^(micro(second)?s?|μs)$/,
+    ns: /^(nano(second)?s?|ns?)$/,
+};
+const isSmallest = function (uom, unit) {
+    return regex[uom].test(unit);
+};
+const round = function (num, digits) {
+    const n = Math.abs(num);
+    return /[0-9]/.test(digits) ? Number(n.toFixed(digits)) : Math.round(n);
+};
+function prettyTime(time, smallest, digits) {
+    const isNumber = /^[0-9]+$/.test(time);
+    if (!isNumber && !Array.isArray(time)) {
+        throw new TypeError('expected an array or number in nanoseconds');
+    }
+    if (Array.isArray(time) && time.length !== 2) {
+        throw new TypeError('expected an array from process.hrtime()');
+    }
+    if (/^[0-9]+$/.test(smallest)) {
+        digits = smallest;
+        smallest = null;
+    }
+    let num = isNumber ? time : nano(time);
+    let res = '';
+    let prev;
+    for (const uom of Object.keys(scale)) {
+        const step = scale[uom];
+        let inc = num / step;
+        if (smallest && isSmallest(uom, smallest)) {
+            inc = round(inc, digits);
+            if (prev && inc === prev / step)
+                --inc;
+            res += inc + uom;
+            return res.trim();
+        }
+        if (inc < 1)
+            continue;
+        if (!smallest) {
+            inc = round(inc, digits);
+            res += inc + uom;
+            return res;
+        }
+        prev = step;
+        inc = Math.floor(inc);
+        num -= inc * step;
+        res += inc + uom + ' ';
+    }
+    return res.trim();
+}
+exports.prettyTime = prettyTime;

package/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.d.ts

@@ -0,0 +1,33 @@
+import { TaskStatus } from '../tasks-runner';
+import type { LifeCycle } from '../life-cycle';
+import { Task } from '../../config/task-graph';
+/**
+ * The following life cycle's outputs are static, meaning no previous content
+ * is rewritten or modified as new outputs are added. It is therefore intended
+ * for use in CI environments.
+ *
+ * For the common case of a user executing a command on their local machine,
+ * the dynamic equivalent of this life cycle is usually preferable.
+ */
+export declare class StaticRunManyTerminalOutputLifeCycle implements LifeCycle {
+    private readonly projectNames;
+    private readonly tasks;
+    private readonly args;
+    private readonly taskOverrides;
+    failedTasks: Task[];
+    cachedTasks: Task[];
+    allCompletedTasks: Map<string, Task>;
+    constructor(projectNames: string[], tasks: Task[], args: {
+        targets?: string[];
+        configuration?: string;
+    }, taskOverrides: any);
+    startCommand(): void;
+    endCommand(): void;
+    private skippedTasks;
+    endTasks(taskResults: {
+        task: Task;
+        status: TaskStatus;
+        code: number;
+    }[]): void;
+    printTaskTerminalOutput(task: Task, cacheStatus: TaskStatus, terminalOutput: string): void;
+}

package/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticRunManyTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const utils_1 = require("../utils");
+const formatting_utils_1 = require("./formatting-utils");
+/**
+ * The following life cycle's outputs are static, meaning no previous content
+ * is rewritten or modified as new outputs are added. It is therefore intended
+ * for use in CI environments.
+ *
+ * For the common case of a user executing a command on their local machine,
+ * the dynamic equivalent of this life cycle is usually preferable.
+ */
+class StaticRunManyTerminalOutputLifeCycle {
+    constructor(projectNames, tasks, args, taskOverrides) {
+        this.projectNames = projectNames;
+        this.tasks = tasks;
+        this.args = args;
+        this.taskOverrides = taskOverrides;
+        this.failedTasks = [];
+        this.cachedTasks = [];
+        this.allCompletedTasks = new Map();
+    }
+    startCommand() {
+        if (this.projectNames.length <= 0) {
+            output_1.output.logSingleLine(`No projects with ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} were run`);
+            return;
+        }
+        const bodyLines = this.projectNames.map((affectedProject) => ` ${output_1.output.dim('-')} ${affectedProject}`);
+        if (Object.keys(this.taskOverrides).length > 0) {
+            bodyLines.push('');
+            bodyLines.push(`${output_1.output.dim('With additional flags:')}`);
+            Object.entries(this.taskOverrides)
+                .map(([flag, value]) => (0, formatting_utils_1.formatFlags)('', flag, value))
+                .forEach((arg) => bodyLines.push(arg));
+        }
+        const title = `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}:`;
+        output_1.output.log({
+            color: 'cyan',
+            title,
+            bodyLines,
+        });
+        output_1.output.addVerticalSeparatorWithoutNewLines('cyan');
+    }
+    endCommand() {
+        output_1.output.addNewline();
+        if (this.failedTasks.length === 0) {
+            output_1.output.addVerticalSeparatorWithoutNewLines('green');
+            const bodyLines = this.cachedTasks.length > 0
+                ? [
+                    output_1.output.dim(`Nx read the output from the cache instead of running the command for ${this.cachedTasks.length} out of ${this.tasks.length} tasks.`),
+                ]
+                : [];
+            output_1.output.success({
+                title: `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}`,
+                bodyLines,
+            });
+        }
+        else {
+            output_1.output.addVerticalSeparatorWithoutNewLines('red');
+            const bodyLines = [];
+            const skippedTasks = this.skippedTasks();
+            if (skippedTasks.length > 0) {
+                bodyLines.push(output_1.output.dim('Tasks not run because their dependencies failed or --nx-bail=true:'), '', ...skippedTasks.map((task) => `${output_1.output.dim('-')} ${task.id}`), '');
+            }
+            bodyLines.push(output_1.output.dim('Failed tasks:'), '', ...[...this.failedTasks.values()].map((task) => `${output_1.output.dim('-')} ${task.id}`));
+            output_1.output.error({
+                title: `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} failed`,
+                bodyLines,
+            });
+        }
+    }
+    skippedTasks() {
+        return this.tasks.filter((t) => !this.allCompletedTasks.has(t.id));
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            this.allCompletedTasks.set(t.task.id, t.task);
+            if (t.status === 'failure') {
+                this.failedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache-kept-existing') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'remote-cache') {
+                this.cachedTasks.push(t.task);
+            }
+        }
+    }
+    printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
+        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+        output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
+    }
+}
+exports.StaticRunManyTerminalOutputLifeCycle = StaticRunManyTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.d.ts

@@ -0,0 +1,31 @@
+import { TaskStatus } from '../tasks-runner';
+import type { LifeCycle } from '../life-cycle';
+import { Task } from '../../config/task-graph';
+/**
+ * The following life cycle's outputs are static, meaning no previous content
+ * is rewritten or modified as new outputs are added. It is therefore intended
+ * for use in CI environments.
+ *
+ * For the common case of a user executing a command on their local machine,
+ * the dynamic equivalent of this life cycle is usually preferable.
+ */
+export declare class StaticRunOneTerminalOutputLifeCycle implements LifeCycle {
+    private readonly initiatingProject;
+    private readonly projectNames;
+    private readonly tasks;
+    private readonly args;
+    failedTasks: Task[];
+    cachedTasks: Task[];
+    constructor(initiatingProject: string, projectNames: string[], tasks: Task[], args: {
+        targets?: string[];
+        configuration?: string;
+    });
+    startCommand(): void;
+    endCommand(): void;
+    endTasks(taskResults: {
+        task: Task;
+        status: TaskStatus;
+        code: number;
+    }[]): void;
+    printTaskTerminalOutput(task: Task, status: TaskStatus, terminalOutput: string): void;
+}

package/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticRunOneTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const utils_1 = require("../utils");
+const formatting_utils_1 = require("./formatting-utils");
+/**
+ * The following life cycle's outputs are static, meaning no previous content
+ * is rewritten or modified as new outputs are added. It is therefore intended
+ * for use in CI environments.
+ *
+ * For the common case of a user executing a command on their local machine,
+ * the dynamic equivalent of this life cycle is usually preferable.
+ */
+class StaticRunOneTerminalOutputLifeCycle {
+    constructor(initiatingProject, projectNames, tasks, args) {
+        this.initiatingProject = initiatingProject;
+        this.projectNames = projectNames;
+        this.tasks = tasks;
+        this.args = args;
+        this.failedTasks = [];
+        this.cachedTasks = [];
+    }
+    startCommand() {
+        const numberOfDeps = this.tasks.length - 1;
+        const title = `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}:`;
+        if (numberOfDeps > 0) {
+            output_1.output.log({
+                color: 'cyan',
+                title,
+            });
+            output_1.output.addVerticalSeparatorWithoutNewLines('cyan');
+        }
+    }
+    endCommand() {
+        output_1.output.addNewline();
+        if (this.failedTasks.length === 0) {
+            output_1.output.addVerticalSeparatorWithoutNewLines('green');
+            const bodyLines = this.cachedTasks.length > 0
+                ? [
+                    output_1.output.dim(`Nx read the output from the cache instead of running the command for ${this.cachedTasks.length} out of ${this.tasks.length} tasks.`),
+                ]
+                : [];
+            output_1.output.success({
+                title: `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}`,
+                bodyLines,
+            });
+        }
+        else {
+            output_1.output.addVerticalSeparatorWithoutNewLines('red');
+            const bodyLines = [
+                output_1.output.dim('Failed tasks:'),
+                '',
+                ...this.failedTasks.map((task) => `${output_1.output.dim('-')} ${task.id}`),
+                '',
+                `${output_1.output.dim('Hint: run the command with')} --verbose ${output_1.output.dim('for more details.')}`,
+            ];
+            output_1.output.error({
+                title: `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} failed`,
+                bodyLines,
+            });
+        }
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            if (t.status === 'failure') {
+                this.failedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache-kept-existing') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'remote-cache') {
+                this.cachedTasks.push(t.task);
+            }
+        }
+    }
+    printTaskTerminalOutput(task, status, terminalOutput) {
+        if (status === 'success' ||
+            status === 'failure' ||
+            task.target.project === this.initiatingProject) {
+            const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+            output_1.output.logCommandOutput(args.join(' '), status, terminalOutput);
+        }
+    }
+}
+exports.StaticRunOneTerminalOutputLifeCycle = StaticRunOneTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/store-run-information-life-cycle.d.ts

@@ -0,0 +1,22 @@
+import { LifeCycle } from '../../tasks-runner/life-cycle';
+import { Task } from '../../config/task-graph';
+import { TaskStatus } from '../../tasks-runner/tasks-runner';
+export declare class StoreRunInformationLifeCycle implements LifeCycle {
+    private readonly command;
+    private readonly storeFile;
+    private readonly now;
+    private startTime;
+    private timings;
+    private taskResults;
+    constructor(command?: string, storeFile?: typeof storeFileFunction, now?: () => string);
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: Array<{
+        task: Task;
+        status: TaskStatus;
+        code: number;
+    }>): void;
+    startCommand(): void;
+    endCommand(): any;
+}
+declare function storeFileFunction(runDetails: any): void;
+export {};

package/src/tasks-runner/life-cycles/store-run-information-life-cycle.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreRunInformationLifeCycle = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const cache_directory_1 = require("../../utils/cache-directory");
+class StoreRunInformationLifeCycle {
+    constructor(command = parseCommand(), storeFile = storeFileFunction, now = () => new Date().toISOString()) {
+        this.command = command;
+        this.storeFile = storeFile;
+        this.now = now;
+        this.timings = {};
+        this.taskResults = [];
+    }
+    startTasks(tasks) {
+        for (let t of tasks) {
+            this.timings[t.id] = {
+                start: this.now(),
+                end: undefined,
+            };
+        }
+    }
+    endTasks(taskResults) {
+        for (let tr of taskResults) {
+            if (tr.task.startTime) {
+                this.timings[tr.task.id].start = new Date(tr.task.startTime).toISOString();
+            }
+            if (tr.task.endTime) {
+                this.timings[tr.task.id].end = new Date(tr.task.endTime).toISOString();
+            }
+            else {
+                this.timings[tr.task.id].end = this.now();
+            }
+        }
+        this.taskResults.push(...taskResults);
+    }
+    startCommand() {
+        this.startTime = this.now();
+    }
+    endCommand() {
+        try {
+            const endTime = this.now();
+            const runDetails = {
+                run: {
+                    command: this.command,
+                    startTime: this.startTime,
+                    endTime: endTime,
+                    inner: false,
+                },
+                tasks: this.taskResults.map((tr) => {
+                    const cacheStatus = tr.status === 'remote-cache'
+                        ? 'remote-cache-hit'
+                        : tr.status === 'local-cache' ||
+                            tr.status === 'local-cache-kept-existing'
+                            ? 'local-cache-hit'
+                            : 'cache-miss';
+                    return {
+                        taskId: tr.task.id,
+                        target: tr.task.target.target,
+                        projectName: tr.task.target.project,
+                        hash: tr.task.hash,
+                        startTime: this.timings[tr.task.id].start,
+                        endTime: this.timings[tr.task.id].end,
+                        params: '',
+                        cacheStatus,
+                        status: tr.code,
+                    };
+                }),
+            };
+            this.storeFile(runDetails);
+        }
+        catch (e) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.error(e);
+            }
+        }
+    }
+}
+exports.StoreRunInformationLifeCycle = StoreRunInformationLifeCycle;
+function parseCommand() {
+    const cmdBase = (0, path_1.parse)(process.argv[1]).name;
+    const args = `${process.argv.slice(2).join(' ')}`;
+    return `${cmdBase} ${args}`;
+}
+function storeFileFunction(runDetails) {
+    (0, fs_1.writeFileSync)((0, path_1.join)(cache_directory_1.cacheDir, 'run.json'), JSON.stringify(runDetails, null, 2));
+}

package/src/tasks-runner/life-cycles/task-profiling-life-cycle.d.ts

@@ -0,0 +1,19 @@
+import { LifeCycle, TaskMetadata } from '../life-cycle';
+import { TaskStatus } from '../tasks-runner';
+import { Task } from '../../config/task-graph';
+export declare class TaskProfilingLifeCycle implements LifeCycle {
+    private timings;
+    private profile;
+    private readonly profileFile;
+    private registeredGroups;
+    constructor(_profileFile: string);
+    startTasks(tasks: Task[], { groupId }: TaskMetadata): void;
+    endTasks(taskResults: Array<{
+        task: Task;
+        status: TaskStatus;
+        code: number;
+    }>, metadata: TaskMetadata): void;
+    endCommand(): void;
+    private recordTaskCompletions;
+    private registerGroup;
+}

package/src/tasks-runner/life-cycles/task-profiling-life-cycle.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskProfilingLifeCycle = void 0;
+const path_1 = require("path");
+const fileutils_1 = require("../../utils/fileutils");
+class TaskProfilingLifeCycle {
+    constructor(_profileFile) {
+        this.timings = {};
+        this.profile = [];
+        this.registeredGroups = new Set();
+        this.profileFile = (0, path_1.join)(process.cwd(), _profileFile);
+    }
+    startTasks(tasks, { groupId }) {
+        if (this.profileFile && !this.registeredGroups.has(groupId)) {
+            this.registerGroup(groupId);
+        }
+        for (let t of tasks) {
+            this.timings[t.id] = {
+                perfStart: Date.now(),
+            };
+        }
+    }
+    endTasks(taskResults, metadata) {
+        for (let tr of taskResults) {
+            if (tr.task.startTime) {
+                this.timings[tr.task.id].perfStart = tr.task.startTime;
+            }
+            if (tr.task.endTime) {
+                this.timings[tr.task.id].perfEnd = tr.task.endTime;
+            }
+            else {
+                this.timings[tr.task.id].perfEnd = Date.now();
+            }
+        }
+        this.recordTaskCompletions(taskResults, metadata);
+    }
+    endCommand() {
+        (0, fileutils_1.writeJsonFile)(this.profileFile, this.profile);
+        console.log(`Performance Profile: ${this.profileFile}`);
+    }
+    recordTaskCompletions(tasks, { groupId }) {
+        for (const { task, status } of tasks) {
+            const { perfStart, perfEnd } = this.timings[task.id];
+            this.profile.push({
+                name: task.id,
+                cat: Object.values(task.target).join(','),
+                ph: 'X',
+                ts: perfStart * 1000,
+                dur: (perfEnd - perfStart) * 1000,
+                pid: process.pid,
+                tid: groupId,
+                args: {
+                    target: task.target,
+                    status,
+                },
+            });
+        }
+    }
+    registerGroup(groupId) {
+        this.profile.push({
+            name: 'thread_name',
+            ph: 'M',
+            pid: process.pid,
+            tid: groupId,
+            ts: 0,
+            args: {
+                name: 'Group #' + (groupId + 1),
+            },
+        });
+        this.registeredGroups.add(groupId);
+    }
+}
+exports.TaskProfilingLifeCycle = TaskProfilingLifeCycle;

package/src/tasks-runner/life-cycles/task-timings-life-cycle.d.ts

@@ -0,0 +1,13 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle } from '../life-cycle';
+import { TaskStatus } from '../tasks-runner';
+export declare class TaskTimingsLifeCycle implements LifeCycle {
+    private timings;
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: Array<{
+        task: Task;
+        status: TaskStatus;
+        code: number;
+    }>): void;
+    endCommand(): void;
+}

package/src/tasks-runner/life-cycles/task-timings-life-cycle.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskTimingsLifeCycle = void 0;
+class TaskTimingsLifeCycle {
+    constructor() {
+        this.timings = {};
+    }
+    startTasks(tasks) {
+        for (let t of tasks) {
+            this.timings[t.id] = {
+                start: new Date().getTime(),
+                end: undefined,
+            };
+        }
+    }
+    endTasks(taskResults) {
+        for (let tr of taskResults) {
+            if (tr.task.startTime) {
+                this.timings[tr.task.id].start = tr.task.startTime;
+            }
+            if (tr.task.endTime) {
+                this.timings[tr.task.id].end = tr.task.endTime;
+            }
+            else {
+                this.timings[tr.task.id].end = new Date().getTime();
+            }
+        }
+    }
+    endCommand() {
+        console.log('Task Execution Timings:');
+        const timings = {};
+        Object.keys(this.timings).forEach((p) => {
+            const t = this.timings[p];
+            timings[p] = t.end ? t.end - t.start : null;
+        });
+        console.log(JSON.stringify(timings, null, 2));
+    }
+}
+exports.TaskTimingsLifeCycle = TaskTimingsLifeCycle;