Merge pull request #278893 from microsoft/dev/mjbvz/gulp-ts

Convert gulp files to ts

Author: mjbvz

build/gulpfile.cli.mjs renamed to build/gulpfile.cli.ts

@@ -12,15 +12,11 @@ import * as cp from 'child_process';
 import { tmpdir } from 'os';
 import { existsSync, mkdirSync, rmSync } from 'fs';
 import * as task from './lib/task.ts';
-import * as watcher from './lib/watch/index.ts';
-import * as utilModule from './lib/util.ts';
-import * as reporterModule from './lib/reporter.ts';
+import watcher from './lib/watch/index.ts';
+import { debounce } from './lib/util.ts';
+import { createReporter } from './lib/reporter.ts';
 import untar from 'gulp-untar';
 import gunzip from 'gulp-gunzip';
-import { fileURLToPath } from 'url';
-
-const { debounce } = utilModule;
-const { createReporter } = reporterModule;
 
 const root = 'cli';
 const rootAbs = path.resolve(import.meta.dirname, '..', root);
@@ -43,8 +39,7 @@ const platformOpensslDirName =
 const platformOpensslDir = path.join(rootAbs, 'openssl', 'package', 'out', platformOpensslDirName);
 
 const hasLocalRust = (() => {
-	/** @type boolean | undefined */
-	let result = undefined;
+	let result: boolean | undefined = undefined;
 	return () => {
 		if (result !== undefined) {
 			return result;
@@ -61,15 +56,14 @@ const hasLocalRust = (() => {
 	};
 })();
 
-const compileFromSources = (callback) => {
+const compileFromSources = (callback: (err?: string) => void) => {
 	const proc = cp.spawn('cargo', ['--color', 'always', 'build'], {
 		cwd: root,
 		stdio: ['ignore', 'pipe', 'pipe'],
 		env: existsSync(platformOpensslDir) ? { OPENSSL_DIR: platformOpensslDir, ...process.env } : process.env
 	});
 
-	/** @type Buffer[] */
-	const stdoutErr = [];
+	const stdoutErr: Buffer[] = [];
 	proc.stdout.on('data', d => stdoutErr.push(d));
 	proc.stderr.on('data', d => stdoutErr.push(d));
 	proc.on('error', callback);
@@ -82,7 +76,7 @@ const compileFromSources = (callback) => {
 	});
 };
 
-const acquireBuiltOpenSSL = (callback) => {
+const acquireBuiltOpenSSL = (callback: (err?: unknown) => void) => {
 	const dir = path.join(tmpdir(), 'vscode-openssl-download');
 	mkdirSync(dir, { recursive: true });
 
@@ -103,29 +97,28 @@ const acquireBuiltOpenSSL = (callback) => {
 		});
 };
 
-const compileWithOpenSSLCheck = (/** @type import('./lib/reporter').IReporter */ reporter) => es.map((_, callback) => {
+const compileWithOpenSSLCheck = (reporter: import('./lib/reporter.ts').IReporter) => es.map((_, callback) => {
 	compileFromSources(err => {
 		if (!err) {
 			// no-op
 		} else if (err.toString().includes('Could not find directory of OpenSSL installation') && !existsSync(platformOpensslDir)) {
 			fancyLog(ansiColors.yellow(`[cli]`), 'OpenSSL libraries not found, acquiring prebuilt bits...');
 			acquireBuiltOpenSSL(err => {
 				if (err) {
-					callback(err);
+					callback(err as Error);
 				} else {
 					compileFromSources(err => {
 						if (err) {
 							reporter(err.toString());
 						}
-						callback(null, '');
+						callback(undefined, '');
 					});
 				}
 			});
 		} else {
 			reporter(err.toString());
 		}
-
-		callback(null, '');
+		callback(undefined, '');
 	});
 });
 
@@ -148,7 +141,7 @@ const compileCliTask = task.define('compile-cli', () => {
 const watchCliTask = task.define('watch-cli', () => {
 	warnIfRustNotInstalled();
 	return watcher(`${src}/**`, { read: false })
-		.pipe(debounce(compileCliTask));
+		.pipe(debounce(compileCliTask as task.StreamTask));
 });
 
 gulp.task(compileCliTask);

build/gulpfile.compile.mjs renamed to build/gulpfile.compile.ts

@@ -2,17 +2,14 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-//@ts-check
+
 import gulp from 'gulp';
 import * as util from './lib/util.ts';
 import * as date from './lib/date.ts';
 import * as task from './lib/task.ts';
 import * as compilation from './lib/compilation.ts';
 
-/**
- * @param {boolean} disableMangle
- */
-function makeCompileBuildTask(disableMangle) {
+function makeCompileBuildTask(disableMangle: boolean) {
 	return task.series(
 		util.rimraf('out-build'),
 		date.writeISODate('out-build'),

build/gulpfile.editor.mjs renamed to build/gulpfile.editor.ts

@@ -2,7 +2,7 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-//@ts-check
+
 import gulp from 'gulp';
 import path from 'path';
 import * as util from './lib/util.ts';
@@ -84,10 +84,7 @@ const compileEditorESMTask = task.define('compile-editor-esm', () => {
 	);
 });
 
-/**
- * @param {string} contents
- */
-function toExternalDTS(contents) {
+function toExternalDTS(contents: string) {
 	const lines = contents.split(/\r\n|\r|\n/);
 	let killNextCloseCurlyBrace = false;
 	for (let i = 0; i < lines.length; i++) {
@@ -230,10 +227,7 @@ gulp.task('monacodts', task.define('monacodts', () => {
 
 //#region monaco type checking
 
-/**
- * @param {boolean} watch
- */
-function createTscCompileTask(watch) {
+function createTscCompileTask(watch: boolean) {
 	return () => {
 		return new Promise((resolve, reject) => {
 			const args = ['./node_modules/.bin/tsc', '-p', './src/tsconfig.monaco.json', '--noEmit'];
@@ -244,11 +238,10 @@ function createTscCompileTask(watch) {
 				cwd: path.join(import.meta.dirname, '..'),
 				// stdio: [null, 'pipe', 'inherit']
 			});
-			const errors = [];
+			const errors: string[] = [];
 			const reporter = createReporter('monaco');
 
-			/** @type {NodeJS.ReadWriteStream | undefined} */
-			let report;
+			let report: NodeJS.ReadWriteStream | undefined;
 			const magic = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g; // https://stackoverflow.com/questions/25245716/remove-all-ansi-colors-styles-from-strings
 
 			child.stdout.on('data', data => {
@@ -286,14 +279,13 @@ export const monacoTypecheckWatchTask = task.define('monaco-typecheck-watch', cr
 export const monacoTypecheckTask = task.define('monaco-typecheck', createTscCompileTask(false));
 
 //#endregion
-
 /**
  * Sets a field on an object only if it's not already set, otherwise throws an error
- * @param {any} obj - The object to modify
- * @param {string} field - The field name to set
- * @param {any} value - The value to set
+ * @param obj The object to modify
+ * @param field The field name to set
+ * @param value The value to set
  */
-function setUnsetField(obj, field, value) {
+function setUnsetField(obj: Record<string, unknown>, field: string, value: unknown) {
 	if (obj[field] !== undefined) {
 		throw new Error(`Field "${field}" is already set (but was expected to not be).`);
 	}

build/gulpfile.extensions.mjs renamed to build/gulpfile.extensions.ts

@@ -22,7 +22,6 @@ import plumber from 'gulp-plumber';
 import * as ext from './lib/extensions.ts';
 import * as tsb from './lib/tsb/index.ts';
 import sourcemaps from 'gulp-sourcemaps';
-import { fileURLToPath } from 'url';
 
 const { getVersion } = getVersionModule;
 const { createReporter } = reporterModule;
@@ -79,13 +78,13 @@ const compilations = [
 	'.vscode/extensions/vscode-selfhost-import-aid/tsconfig.json',
 ];
 
-const getBaseUrl = out => `https://main.vscode-cdn.net/sourcemaps/${commit}/${out}`;
+const getBaseUrl = (out: string) => `https://main.vscode-cdn.net/sourcemaps/${commit}/${out}`;
 
 const tasks = compilations.map(function (tsconfigFile) {
 	const absolutePath = path.join(root, tsconfigFile);
 	const relativeDirname = path.dirname(tsconfigFile.replace(/^(.*\/)?extensions\//i, ''));
 
-	const overrideOptions = {};
+	const overrideOptions: { sourceMap?: boolean; inlineSources?: boolean; base?: string } = {};
 	overrideOptions.sourceMap = true;
 
 	const name = relativeDirname.replace(/\//g, '-');
@@ -98,7 +97,7 @@ const tasks = compilations.map(function (tsconfigFile) {
 	const out = path.join(srcRoot, 'out');
 	const baseUrl = getBaseUrl(out);
 
-	function createPipeline(build, emitError, transpileOnly) {
+	function createPipeline(build: boolean, emitError?: boolean, transpileOnly?: boolean) {
 		const reporter = createReporter('extensions');
 
 		overrideOptions.inlineSources = Boolean(build);
@@ -122,14 +121,14 @@ const tasks = compilations.map(function (tsconfigFile) {
 				.pipe(compilation())
 				.pipe(build ? util.stripSourceMappingURL() : es.through())
 				.pipe(sourcemaps.write('.', {
-					sourceMappingURL: !build ? null : f => `${baseUrl}/${f.relative}.map`,
+					sourceMappingURL: !build ? undefined : f => `${baseUrl}/${f.relative}.map`,
 					addComment: !!build,
 					includeContent: !!build,
 					// note: trailing slash is important, else the source URLs in V8's file coverage are incorrect
 					sourceRoot: '../src/',
 				}))
 				.pipe(tsFilter.restore)
-				.pipe(reporter.end(emitError));
+				.pipe(reporter.end(!!emitError));
 
 			return es.duplex(input, output);
 		};
@@ -266,10 +265,7 @@ gulp.task(compileWebExtensionsTask);
 export const watchWebExtensionsTask = task.define('watch-web', () => buildWebExtensions(true));
 gulp.task(watchWebExtensionsTask);
 
-/**
- * @param {boolean} isWatch
- */
-async function buildWebExtensions(isWatch) {
+async function buildWebExtensions(isWatch: boolean) {
 	const extensionsPath = path.join(root, 'extensions');
 	const webpackConfigLocations = await nodeUtil.promisify(glob)(
 		path.join(extensionsPath, '**', 'extension-browser.webpack.config.js'),

build/gulpfile.hygiene.mjs renamed to build/gulpfile.hygiene.ts

@@ -11,13 +11,10 @@ import { hygiene } from './hygiene.ts';
 
 const dirName = path.dirname(new URL(import.meta.url).pathname);
 
-/**
- * @param {string} actualPath
- */
-function checkPackageJSON(actualPath) {
+function checkPackageJSON(this: NodeJS.ReadWriteStream, actualPath: string) {
 	const actual = JSON.parse(fs.readFileSync(path.join(dirName, '..', actualPath), 'utf8'));
 	const rootPackageJSON = JSON.parse(fs.readFileSync(path.join(dirName, '..', 'package.json'), 'utf8'));
-	const checkIncluded = (set1, set2) => {
+	const checkIncluded = (set1: Record<string, string>, set2: Record<string, string>) => {
 		for (const depName in set1) {
 			const depVersion = set1[depName];
 			const rootDepVersion = set2[depName];