Extract task code to its own file

build/gulpfile.compile.js

@@ -6,15 +6,16 @@
 'use strict';
 
 const util = require('./lib/util');
+const task = require('./lib/task');
 const compilation = require('./lib/compilation');
 const { compileExtensionsBuildTask } = require('./gulpfile.extensions');
 
 // Full compile, including nls and inline sources in sourcemaps, for build
-const compileClientBuildTask = util.task.series(util.rimraf('out-build'), compilation.compileTask('src', 'out-build', true));
+const compileClientBuildTask = task.series(util.rimraf('out-build'), compilation.compileTask('src', 'out-build', true));
 compileClientBuildTask.displayName = 'compile-client-build';
 
 // All Build
-const compileBuildTask = util.task.parallel(compileClientBuildTask, compileExtensionsBuildTask);
+const compileBuildTask = task.parallel(compileClientBuildTask, compileExtensionsBuildTask);
 compileBuildTask.displayName = 'compile-build';
 
 exports.compileBuildTask = compileBuildTask;

build/gulpfile.editor.js

@@ -6,6 +6,7 @@
 const gulp = require('gulp');
 const path = require('path');
 const util = require('./lib/util');
+const task = require('./lib/task');
 const common = require('./lib/optimize');
 const es = require('event-stream');
 const File = require('vinyl');
@@ -290,8 +291,8 @@ const finalEditorResourcesTask = function () {
 finalEditorResourcesTask.displayName = 'final-editor-resources';
 
 gulp.task('editor-distro',
-	util.task.series(
+	task.series(
-		util.task.parallel(
+		task.parallel(
 			util.rimraf('out-editor-src'),
 			util.rimraf('out-editor-build'),
 			util.rimraf('out-editor-esm'),
@@ -300,13 +301,13 @@ gulp.task('editor-distro',
 			util.rimraf('out-editor-min')
 		),
 		extractEditorSrcTask,
-		util.task.parallel(
+		task.parallel(
-			util.task.series(
+			task.series(
 				compileEditorAMDTask,
 				optimizeEditorAMDTask,
 				minifyEditorAMDTask
 			),
-			util.task.series(
+			task.series(
 				createESMSourcesAndResourcesTask,
 				compileEditorESMTask
 			)

build/gulpfile.extensions.js

@@ -12,6 +12,7 @@ const tsb = require('gulp-tsb');
 const es = require('event-stream');
 const filter = require('gulp-filter');
 const util = require('./lib/util');
+const task = require('./lib/task');
 const watcher = require('./lib/watch');
 const createReporter = require('./lib/reporter').createReporter;
 const glob = require('glob');
@@ -112,7 +113,7 @@ const tasks = compilations.map(function (tsconfigFile) {
 			.pipe(gulp.dest(out));
 	};
 	compileTask_.displayName = `compile-extension-${name}`;
-	const compileTask = util.task.series(cleanTask, compileTask_);
+	const compileTask = task.series(cleanTask, compileTask_);
 
 	const watchTask_ = () => {
 		const pipeline = createPipeline(false);
@@ -124,7 +125,7 @@ const tasks = compilations.map(function (tsconfigFile) {
 			.pipe(gulp.dest(out));
 	};
 	watchTask_.displayName = `watch-extension-${name}`;
-	const watchTask = util.task.series(cleanTask, watchTask_);
+	const watchTask = task.series(cleanTask, watchTask_);
 
 	const compileBuildTask_ = () => {
 		const pipeline = createPipeline(true, true);
@@ -135,7 +136,7 @@ const tasks = compilations.map(function (tsconfigFile) {
 			.pipe(gulp.dest(out));
 	};
 	compileBuildTask_.displayName = `compile-build-extension-${name}`;
-	const compileBuildTask = util.task.series(cleanTask, compileBuildTask_);
+	const compileBuildTask = task.series(cleanTask, compileBuildTask_);
 
 	// Tasks
 	gulp.task('compile-extension:' + name, compileTask);
@@ -148,16 +149,16 @@ const tasks = compilations.map(function (tsconfigFile) {
 	};
 });
 
-const compileExtensionsTask = util.task.parallel(...tasks.map(t => t.compileTask));
+const compileExtensionsTask = task.parallel(...tasks.map(t => t.compileTask));
 compileExtensionsTask.displayName = 'compile-extensions';
 gulp.task(compileExtensionsTask.displayName, compileExtensionsTask);
 exports.compileExtensionsTask = compileExtensionsTask;
 
-const watchExtensionsTask = util.task.parallel(...tasks.map(t => t.watchTask));
+const watchExtensionsTask = task.parallel(...tasks.map(t => t.watchTask));
 watchExtensionsTask.displayName = 'watch-extensions';
 gulp.task(watchExtensionsTask.displayName, watchExtensionsTask);
 exports.watchExtensionsTask = watchExtensionsTask;
 
-const compileExtensionsBuildTask = util.task.parallel(...tasks.map(t => t.compileBuildTask));
+const compileExtensionsBuildTask = task.parallel(...tasks.map(t => t.compileBuildTask));
 compileExtensionsBuildTask.displayName = 'compile-extensions-build';
 exports.compileExtensionsBuildTask = compileExtensionsBuildTask;

build/gulpfile.vscode.js

@@ -20,6 +20,7 @@ const filter = require('gulp-filter');
 const json = require('gulp-json-editor');
 const _ = require('underscore');
 const util = require('./lib/util');
+const task = require('./lib/task');
 const ext = require('./lib/extensions');
 const buildfile = require('../src/buildfile');
 const common = require('./lib/optimize');
@@ -87,8 +88,8 @@ const BUNDLED_FILE_HEADER = [
 	' *--------------------------------------------------------*/'
 ].join('\n');
 
-const optimizeVSCodeTask = util.task.series(
+const optimizeVSCodeTask = task.series(
-	util.task.parallel(
+	task.parallel(
 		util.rimraf('out-vscode'),
 		compileBuildTask
 	),
@@ -105,7 +106,7 @@ const optimizeVSCodeTask = util.task.series(
 optimizeVSCodeTask.displayName = 'optimize-vscode';
 
 
-const optimizeIndexJSTask = util.task.series(
+const optimizeIndexJSTask = task.series(
 	optimizeVSCodeTask,
 	() => {
 		const fullpath = path.join(process.cwd(), 'out-vscode/bootstrap-window.js');
@@ -117,8 +118,8 @@ const optimizeIndexJSTask = util.task.series(
 optimizeIndexJSTask.displayName = 'optimize-index-js';
 
 const sourceMappingURLBase = `https://ticino.blob.core.windows.net/sourcemaps/${commit}`;
-const minifyVSCodeTask = util.task.series(
+const minifyVSCodeTask = task.series(
-	util.task.parallel(
+	task.parallel(
 		util.rimraf('out-vscode-min'),
 		optimizeIndexJSTask
 	),
@@ -213,11 +214,11 @@ function getElectron(arch) {
 	};
 }
 
-gulp.task('electron', util.task.series(util.rimraf('.build/electron'), getElectron(process.arch)));
+gulp.task('electron', task.series(util.rimraf('.build/electron'), getElectron(process.arch)));
-gulp.task('electron-ia32', util.task.series(util.rimraf('.build/electron'), getElectron('ia32')));
+gulp.task('electron-ia32', task.series(util.rimraf('.build/electron'), getElectron('ia32')));
-gulp.task('electron-x64', util.task.series(util.rimraf('.build/electron'), getElectron('x64')));
+gulp.task('electron-x64', task.series(util.rimraf('.build/electron'), getElectron('x64')));
-gulp.task('electron-arm', util.task.series(util.rimraf('.build/electron'), getElectron('arm')));
+gulp.task('electron-arm', task.series(util.rimraf('.build/electron'), getElectron('arm')));
-gulp.task('electron-arm64', util.task.series(util.rimraf('.build/electron'), getElectron('arm64')));
+gulp.task('electron-arm64', task.series(util.rimraf('.build/electron'), getElectron('arm64')));
 
 
 /**
@@ -457,8 +458,8 @@ BUILD_TARGETS.forEach(buildTarget => {
 		const sourceFolderName = `out-vscode${dashed(minified)}`;
 		const destinationFolderName = `VSCode${dashed(platform)}${dashed(arch)}`;
 
-		const vscodeTask = util.task.series(
+		const vscodeTask = task.series(
-			util.task.parallel(
+			task.parallel(
 				minified ? minifyVSCodeTask : optimizeVSCodeTask,
 				util.rimraf(path.join(buildRoot, destinationFolderName))
 			),
@@ -491,7 +492,7 @@ const apiName = process.env.TRANSIFEX_API_NAME;
 const apiToken = process.env.TRANSIFEX_API_TOKEN;
 
 gulp.task('vscode-translations-push',
-	util.task.series(
+	task.series(
 		optimizeVSCodeTask,
 		function () {
 			const pathToMetadata = './out-vscode/nls.metadata.json';
@@ -509,7 +510,7 @@ gulp.task('vscode-translations-push',
 );
 
 gulp.task('vscode-translations-export',
-	util.task.series(
+	task.series(
 		optimizeVSCodeTask,
 		function () {
 			const pathToMetadata = './out-vscode/nls.metadata.json';
@@ -614,7 +615,7 @@ generateVSCodeConfigurationTask.displayName = 'generate-vscode-configuration';
 
 const allConfigDetailsPath = path.join(os.tmpdir(), 'configuration.json');
 gulp.task('upload-vscode-configuration',
-	util.task.series(
+	task.series(
 		generateVSCodeConfigurationTask,
 		() => {
 			if (!shouldSetupSettingsSearch()) {

build/gulpfile.vscode.linux.js

@@ -12,6 +12,7 @@ const shell = require('gulp-shell');
 const es = require('event-stream');
 const vfs = require('vinyl-fs');
 const util = require('./lib/util');
+const task = require('./lib/task');
 const packageJson = require('../package.json');
 const product = require('../product.json');
 const rpmDependencies = require('../resources/linux/rpm/dependencies.json');
@@ -241,29 +242,29 @@ BUILD_TARGETS.forEach((buildTarget) => {
 
 	{
 		const debArch = getDebPackageArch(arch);
-		const prepareDebTask = util.task.series(util.rimraf(`.build/linux/deb/${debArch}`), prepareDebPackage(arch));
+		const prepareDebTask = task.series(util.rimraf(`.build/linux/deb/${debArch}`), prepareDebPackage(arch));
 		prepareDebTask.displayName = `vscode-linux-${arch}-prepare-deb`;
 		// gulp.task(prepareDebTask.displayName, prepareDebTask);
-		const buildDebTask = util.task.series(prepareDebTask, buildDebPackage(arch));
+		const buildDebTask = task.series(prepareDebTask, buildDebPackage(arch));
 		buildDebTask.displayName = `vscode-linux-${arch}-build-deb`;
 		gulp.task(buildDebTask.displayName, buildDebTask);
 	}
 
 	{
 		const rpmArch = getRpmPackageArch(arch);
-		const prepareRpmTask = util.task.series(util.rimraf(`.build/linux/rpm/${rpmArch}`), prepareRpmPackage(arch));
+		const prepareRpmTask = task.series(util.rimraf(`.build/linux/rpm/${rpmArch}`), prepareRpmPackage(arch));
 		prepareRpmTask.displayName = `vscode-linux-${arch}-prepare-rpm`;
 		// gulp.task(prepareRpmTask.displayName, prepareRpmTask);
-		const buildRpmTask = util.task.series(prepareRpmTask, buildRpmPackage(arch));
+		const buildRpmTask = task.series(prepareRpmTask, buildRpmPackage(arch));
 		buildRpmTask.displayName = `vscode-linux-${arch}-build-rpm`;
 		gulp.task(buildRpmTask.displayName, buildRpmTask);
 	}
 
 	{
-		const prepareSnapTask = util.task.series(util.rimraf(`.build/linux/snap/${arch}`), prepareSnapPackage(arch));
+		const prepareSnapTask = task.series(util.rimraf(`.build/linux/snap/${arch}`), prepareSnapPackage(arch));
 		prepareSnapTask.displayName = `vscode-linux-${arch}-prepare-snap`;
 		gulp.task(prepareSnapTask.displayName, prepareSnapTask);
-		const buildSnapTask = util.task.series(prepareSnapTask, buildSnapPackage(arch));
+		const buildSnapTask = task.series(prepareSnapTask, buildSnapPackage(arch));
 		buildSnapTask.displayName = `vscode-linux-${arch}-build-snap`;
 		gulp.task(buildSnapTask.displayName, buildSnapTask);
 	}

build/gulpfile.vscode.win32.js

@@ -12,6 +12,7 @@ const assert = require('assert');
 const cp = require('child_process');
 const _7z = require('7zip')['7z'];
 const util = require('./lib/util');
+const task = require('./lib/task');
 const pkg = require('../package.json');
 const product = require('../product.json');
 const vfs = require('vinyl-fs');
@@ -106,7 +107,7 @@ function buildWin32Setup(arch, target) {
 
 function defineWin32SetupTasks(arch, target) {
 	const cleanTask = util.rimraf(setupDir(arch, target));
-	gulp.task(`vscode-win32-${arch}-${target}-setup`, util.task.series(cleanTask, buildWin32Setup(arch, target)));
+	gulp.task(`vscode-win32-${arch}-${target}-setup`, task.series(cleanTask, buildWin32Setup(arch, target)));
 }
 
 defineWin32SetupTasks('ia32', 'system');
@@ -124,8 +125,8 @@ function archiveWin32Setup(arch) {
 	};
 }
 
-gulp.task('vscode-win32-ia32-archive', util.task.series(util.rimraf(zipDir('ia32')), archiveWin32Setup('ia32')));
+gulp.task('vscode-win32-ia32-archive', task.series(util.rimraf(zipDir('ia32')), archiveWin32Setup('ia32')));
-gulp.task('vscode-win32-x64-archive', util.task.series(util.rimraf(zipDir('x64')), archiveWin32Setup('x64')));
+gulp.task('vscode-win32-x64-archive', task.series(util.rimraf(zipDir('x64')), archiveWin32Setup('x64')));
 
 function copyInnoUpdater(arch) {
 	return () => {
@@ -141,5 +142,5 @@ function patchInnoUpdater(arch) {
 	};
 }
 
-gulp.task('vscode-win32-ia32-inno-updater', util.task.series(copyInnoUpdater('ia32'), patchInnoUpdater('ia32')));
+gulp.task('vscode-win32-ia32-inno-updater', task.series(copyInnoUpdater('ia32'), patchInnoUpdater('ia32')));
-gulp.task('vscode-win32-x64-inno-updater', util.task.series(copyInnoUpdater('x64'), patchInnoUpdater('x64')));
+gulp.task('vscode-win32-x64-inno-updater', task.series(copyInnoUpdater('x64'), patchInnoUpdater('x64')));

build/lib/task.js

@@ -0,0 +1,78 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const fancyLog = require("fancy-log");
+const ansiColors = require("ansi-colors");
+function _isPromise(p) {
+    if (typeof p.then === 'function') {
+        return true;
+    }
+    return false;
+}
+function _renderTime(time) {
+    if (time < 1000) {
+        return `${time.toFixed(2)} ms`;
+    }
+    let seconds = time / 1000;
+    if (seconds < 60) {
+        return `${seconds.toFixed(1)} s`;
+    }
+    let minutes = Math.floor(seconds / 60);
+    seconds -= minutes * 60;
+    return `${minutes} m and ${seconds} s`;
+}
+async function _execute(task) {
+    const name = task.displayName || task.name || `<anonymous>`;
+    fancyLog('Starting', ansiColors.cyan(name), '...');
+    const startTime = process.hrtime();
+    await _doExecute(task);
+    const elapsedArr = process.hrtime(startTime);
+    const elapsedNanoseconds = (elapsedArr[0] * 1e9 + elapsedArr[1]);
+    fancyLog(`Finished`, ansiColors.cyan(name), 'after', ansiColors.green(_renderTime(elapsedNanoseconds / 1e6)));
+}
+async function _doExecute(task) {
+    // Always invoke as if it were a callback task
+    return new Promise((resolve, reject) => {
+        if (task.length === 1) {
+            // this is a calback task
+            task((err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+            return;
+        }
+        const taskResult = task();
+        if (typeof taskResult === 'undefined') {
+            // this is a sync task
+            resolve();
+            return;
+        }
+        if (_isPromise(taskResult)) {
+            // this is a promise returning task
+            taskResult.then(resolve, reject);
+            return;
+        }
+        // this is a stream returning task
+        taskResult.on('end', _ => resolve());
+        taskResult.on('error', err => reject(err));
+    });
+}
+function series(...tasks) {
+    return async () => {
+        for (let i = 0; i < tasks.length; i++) {
+            await _execute(tasks[i]);
+        }
+    };
+}
+exports.series = series;
+function parallel(...tasks) {
+    return async () => {
+        await Promise.all(tasks.map(t => _execute(t)));
+    };
+}
+exports.parallel = parallel;

build/lib/task.ts

@@ -0,0 +1,92 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as fancyLog from 'fancy-log';
+import * as ansiColors from 'ansi-colors';
+
+export type PromiseTask = () => Promise<void>;
+export type StreamTask = () => NodeJS.ReadWriteStream;
+export type CallbackTask = (cb?: (err?: any) => void) => void;
+export type Task = PromiseTask | StreamTask | CallbackTask;
+
+function _isPromise(p: Promise<void> | NodeJS.ReadWriteStream): p is Promise<void> {
+	if (typeof (<any>p).then === 'function') {
+		return true;
+	}
+	return false;
+}
+
+function _renderTime(time: number): string {
+	if (time < 1000) {
+		return `${time.toFixed(2)} ms`;
+	}
+	let seconds = time / 1000;
+	if (seconds < 60) {
+		return `${seconds.toFixed(1)} s`;
+	}
+	let minutes = Math.floor(seconds / 60);
+	seconds -= minutes * 60;
+	return `${minutes} m and ${seconds} s`;
+}
+
+async function _execute(task: Task): Promise<void> {
+	const name = (<any>task).displayName || task.name || `<anonymous>`;
+	fancyLog('Starting', ansiColors.cyan(name), '...');
+	const startTime = process.hrtime();
+	await _doExecute(task);
+	const elapsedArr = process.hrtime(startTime);
+	const elapsedNanoseconds = (elapsedArr[0] * 1e9 + elapsedArr[1]);
+	fancyLog(`Finished`, ansiColors.cyan(name), 'after', ansiColors.green(_renderTime(elapsedNanoseconds / 1e6)));
+}
+
+async function _doExecute(task: Task): Promise<void> {
+	// Always invoke as if it were a callback task
+	return new Promise((resolve, reject) => {
+		if (task.length === 1) {
+			// this is a calback task
+			task((err) => {
+				if (err) {
+					return reject(err);
+				}
+				resolve();
+			});
+			return;
+		}
+
+		const taskResult = task();
+
+		if (typeof taskResult === 'undefined') {
+			// this is a sync task
+			resolve();
+			return;
+		}
+
+		if (_isPromise(taskResult)) {
+			// this is a promise returning task
+			taskResult.then(resolve, reject);
+			return;
+		}
+
+		// this is a stream returning task
+		taskResult.on('end', _ => resolve());
+		taskResult.on('error', err => reject(err));
+	});
+}
+
+export function series(...tasks: Task[]): PromiseTask {
+	return async () => {
+		for (let i = 0; i < tasks.length; i++) {
+			await _execute(tasks[i]);
+		}
+	};
+}
+
+export function parallel(...tasks: Task[]): PromiseTask {
+	return async () => {
+		await Promise.all(tasks.map(t => _execute(t)));
+	};
+}

build/lib/util.js

@@ -14,8 +14,6 @@ const fs = require("fs");
 const _rimraf = require("rimraf");
 const git = require("./git");
 const VinylFile = require("vinyl");
-const fancyLog = require("fancy-log");
-const ansiColors = require("ansi-colors");
 const NoCancellationToken = { isCancellationRequested: () => false };
 function incremental(streamProvider, initial, supportsCancellation) {
     const input = es.through();
@@ -186,79 +184,6 @@ function rimraf(dir) {
     return retry;
 }
 exports.rimraf = rimraf;
-var task;
-(function (task_1) {
-    function _isPromise(p) {
-        if (typeof p.then === 'function') {
-            return true;
-        }
-        return false;
-    }
-    function _renderTime(time) {
-        if (time < 1000) {
-            return `${time.toFixed(2)} ms`;
-        }
-        let seconds = time / 1000;
-        if (seconds < 60) {
-            return `${seconds.toFixed(1)} s`;
-        }
-        let minutes = Math.floor(seconds / 60);
-        seconds -= minutes * 60;
-        return `${minutes} m and ${seconds} s`;
-    }
-    async function _execute(task) {
-        const name = task.displayName || task.name || `<anonymous>`;
-        fancyLog('Starting', ansiColors.cyan(name), '...');
-        const startTime = process.hrtime();
-        await _doExecute(task);
-        const elapsedArr = process.hrtime(startTime);
-        const elapsedNanoseconds = (elapsedArr[0] * 1e9 + elapsedArr[1]);
-        fancyLog(`Finished`, ansiColors.cyan(name), 'after', ansiColors.green(_renderTime(elapsedNanoseconds / 1e6)));
-    }
-    async function _doExecute(task) {
-        // Always invoke as if it were a callback task
-        return new Promise((resolve, reject) => {
-            if (task.length === 1) {
-                // this is a calback task
-                task((err) => {
-                    if (err) {
-                        return reject(err);
-                    }
-                    resolve();
-                });
-                return;
-            }
-            const taskResult = task();
-            if (typeof taskResult === 'undefined') {
-                // this is a sync task
-                resolve();
-                return;
-            }
-            if (_isPromise(taskResult)) {
-                // this is a promise returning task
-                taskResult.then(resolve, reject);
-                return;
-            }
-            // this is a stream returning task
-            taskResult.on('end', _ => resolve());
-            taskResult.on('error', err => reject(err));
-        });
-    }
-    function series(...tasks) {
-        return async () => {
-            for (let i = 0; i < tasks.length; i++) {
-                await _execute(tasks[i]);
-            }
-        };
-    }
-    task_1.series = series;
-    function parallel(...tasks) {
-        return async () => {
-            await Promise.all(tasks.map(t => _execute(t)));
-        };
-    }
-    task_1.parallel = parallel;
-})(task = exports.task || (exports.task = {}));
 function getVersion(root) {
     let version = process.env['BUILD_SOURCEVERSION'];
     if (!version || !/^[0-9a-f]{40}$/i.test(version)) {

build/lib/util.ts

@@ -17,8 +17,6 @@ import * as git from './git';
 import * as VinylFile from 'vinyl';
 import { ThroughStream } from 'through';
 import * as sm from 'source-map';
-import * as fancyLog from 'fancy-log';
-import * as ansiColors from 'ansi-colors';
 
 export interface ICancellationToken {
 	isCancellationRequested(): boolean;
@@ -239,92 +237,6 @@ export function rimraf(dir: string): (cb: any) => void {
 	return retry;
 }
 
-export type PromiseTask = () => Promise<void>;
-export type StreamTask = () => NodeJS.ReadWriteStream;
-export type CallbackTask = (cb?: (err?: any) => void) => void;
-export type Task = PromiseTask | StreamTask | CallbackTask;
-
-export namespace task {
-
-	function _isPromise(p: Promise<void> | NodeJS.ReadWriteStream): p is Promise<void> {
-		if (typeof (<any>p).then === 'function') {
-			return true;
-		}
-		return false;
-	}
-
-	function _renderTime(time: number): string {
-		if (time < 1000) {
-			return `${time.toFixed(2)} ms`;
-		}
-		let seconds = time / 1000;
-		if (seconds < 60) {
-			return `${seconds.toFixed(1)} s`;
-		}
-		let minutes = Math.floor(seconds / 60);
-		seconds -= minutes * 60;
-		return `${minutes} m and ${seconds} s`;
-	}
-
-	async function _execute(task: Task): Promise<void> {
-		const name = (<any>task).displayName || task.name || `<anonymous>`;
-		fancyLog('Starting', ansiColors.cyan(name), '...');
-		const startTime = process.hrtime();
-		await _doExecute(task);
-		const elapsedArr = process.hrtime(startTime);
-		const elapsedNanoseconds = (elapsedArr[0] * 1e9 + elapsedArr[1]);
-		fancyLog(`Finished`, ansiColors.cyan(name), 'after', ansiColors.green(_renderTime(elapsedNanoseconds / 1e6)));
-	}
-
-	async function _doExecute(task: Task): Promise<void> {
-		// Always invoke as if it were a callback task
-		return new Promise((resolve, reject) => {
-			if (task.length === 1) {
-				// this is a calback task
-				task((err) => {
-					if (err) {
-						return reject(err);
-					}
-					resolve();
-				});
-				return;
-			}
-
-			const taskResult = task();
-
-			if (typeof taskResult === 'undefined') {
-				// this is a sync task
-				resolve();
-				return;
-			}
-
-			if (_isPromise(taskResult)) {
-				// this is a promise returning task
-				taskResult.then(resolve, reject);
-				return;
-			}
-
-			// this is a stream returning task
-			taskResult.on('end', _ => resolve());
-			taskResult.on('error', err => reject(err));
-		});
-	}
-
-	export function series(...tasks: Task[]): PromiseTask {
-		return async () => {
-			for (let i = 0; i < tasks.length; i++) {
-				await _execute(tasks[i]);
-			}
-		};
-	}
-
-	export function parallel(...tasks: Task[]): PromiseTask {
-		return async () => {
-			await Promise.all(tasks.map(t => _execute(t)));
-		};
-	}
-}
-
 export function getVersion(root: string): string | undefined {
 	let version = process.env['BUILD_SOURCEVERSION'];
 

gulpfile.js

@@ -10,26 +10,27 @@ require('events').EventEmitter.defaultMaxListeners = 100;
 
 const gulp = require('gulp');
 const util = require('./build/lib/util');
+const task = require('./build/lib/task');
 const path = require('path');
 const compilation = require('./build/lib/compilation');
 const { monacoTypecheckTask/* , monacoTypecheckWatchTask */ } = require('./build/gulpfile.editor');
 const { compileExtensionsTask, watchExtensionsTask } = require('./build/gulpfile.extensions');
 
 // Fast compile for development time
-const compileClientTask = util.task.series(util.rimraf('out'), compilation.compileTask('src', 'out', false));
+const compileClientTask = task.series(util.rimraf('out'), compilation.compileTask('src', 'out', false));
 compileClientTask.displayName = 'compile-client';
 gulp.task(compileClientTask.displayName, compileClientTask);
 
-const watchClientTask = util.task.series(util.rimraf('out'), compilation.watchTask('out', false));
+const watchClientTask = task.series(util.rimraf('out'), compilation.watchTask('out', false));
 watchClientTask.displayName = 'watch-client';
 gulp.task(watchClientTask.displayName, watchClientTask);
 
 // All
-const compileTask = util.task.parallel(monacoTypecheckTask, compileClientTask, compileExtensionsTask);
+const compileTask = task.parallel(monacoTypecheckTask, compileClientTask, compileExtensionsTask);
 compileTask.displayName = 'compile';
 gulp.task(compileTask.displayName, compileTask);
 
-gulp.task('watch', util.task.parallel(/* monacoTypecheckWatchTask, */ watchClientTask, watchExtensionsTask));
+gulp.task('watch', task.parallel(/* monacoTypecheckWatchTask, */ watchClientTask, watchExtensionsTask));
 
 // Default
 gulp.task('default', compileTask);