write our own little gulp-eslint which takes the eslint from our work…

…space root (#230115)

build/eslint.js

@@ -8,17 +8,11 @@ const vfs = require('vinyl-fs');
 const { eslintFilter } = require('./filters');
 
 function eslint() {
-	const gulpeslint = require('gulp-eslint');
+	const eslint = require('./gulp-eslint');
 	return vfs
 		.src(eslintFilter, { base: '.', follow: true, allowEmpty: true })
 		.pipe(
-			gulpeslint({
-				configFile: '.eslintrc.json'
-			})
-		)
-		.pipe(gulpeslint.formatEach('compact'))
-		.pipe(
-			gulpeslint.results((results) => {
+			eslint((results) => {
 				if (results.warningCount > 0 || results.errorCount > 0) {
 					throw new Error('eslint failed with warnings and/or errors');
 				}

build/gulp-eslint.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';
+
+const { ESLint } = require('eslint');
+const { Transform } = require('stream');
+const { relative } = require('path');
+const fancyLog = require('fancy-log');
+
+/**
+ * @param {Function} action - A function to handle all ESLint results
+ * @returns {stream} gulp file stream
+ */
+function eslint(action) {
+	const linter = new ESLint();
+	const formatter = linter.loadFormatter('compact');
+
+	const results = [];
+	results.errorCount = 0;
+	results.warningCount = 0;
+
+	return transform(
+		async (file, enc, cb) => {
+			const filePath = relative(process.cwd(), file.path);
+
+			if (file.isNull()) {
+				cb(null, file);
+				return;
+			}
+
+			if (file.isStream()) {
+				cb(new Error('vinyl files with Stream contents are not supported'));
+				return;
+			}
+
+			try {
+				// TODO: Should this be checked?
+				if (await linter.isPathIgnored(filePath)) {
+					cb(null, file);
+					return;
+				}
+
+				const result = (await linter.lintText(file.contents.toString(), { filePath }))[0];
+				results.push(result);
+				results.errorCount += result.errorCount;
+				results.warningCount += result.warningCount;
+
+				const message = (await formatter).format([result]);
+				if (message) {
+					fancyLog(message);
+				}
+				cb(null, file);
+			} catch (error) {
+				cb(error);
+			}
+		},
+		(done) => {
+			try {
+				action(results);
+				done();
+			} catch (error) {
+				done(error);
+			}
+		});
+}
+
+function transform(transform, flush) {
+	return new Transform({
+		objectMode: true,
+		transform,
+		flush
+	});
+}
+
+module.exports = eslint;

build/hygiene.js

@@ -21,7 +21,7 @@ const copyrightHeaderLines = [
 ];
 
 function hygiene(some, linting = true) {
-	const gulpeslint = require('gulp-eslint');
+	const eslint = require('./gulp-eslint');
 	const gulpstylelint = require('./stylelint');
 	const formatter = require('./lib/formatter');
 
@@ -172,13 +172,7 @@ function hygiene(some, linting = true) {
 			result
 				.pipe(filter(eslintFilter))
 				.pipe(
-					gulpeslint({
-						configFile: '.eslintrc.json'
-					})
-				)
-				.pipe(gulpeslint.formatEach('compact'))
-				.pipe(
-					gulpeslint.results((results) => {
+					eslint((results) => {
 						errorCount += results.warningCount;
 						errorCount += results.errorCount;
 					})

extensions/markdown-language-features/preview-src/activeLineMarker.ts

@@ -12,20 +12,20 @@ export class ActiveLineMarker {
 		this._update(previous && (previous.codeElement || previous.element));
 	}
 
-	_update(before: HTMLElement | undefined) {
+	private _update(before: HTMLElement | undefined) {
 		this._unmarkActiveElement(this._current);
 		this._markActiveElement(before);
 		this._current = before;
 	}
 
-	_unmarkActiveElement(element: HTMLElement | undefined) {
+	private _unmarkActiveElement(element: HTMLElement | undefined) {
 		if (!element) {
 			return;
 		}
 		element.classList.toggle('code-active-line', false);
 	}
 
-	_markActiveElement(element: HTMLElement | undefined) {
+	private _markActiveElement(element: HTMLElement | undefined) {
 		if (!element) {
 			return;
 		}

extensions/markdown-language-features/preview-src/csp.ts

@@ -11,45 +11,45 @@ import { getStrings } from './strings';
  * Shows an alert when there is a content security policy violation.
  */
 export class CspAlerter {
-	private didShow = false;
-	private didHaveCspWarning = false;
+	private _didShow = false;
+	private _didHaveCspWarning = false;
 
-	private messaging?: MessagePoster;
+	private _messaging?: MessagePoster;
 
 	constructor(
-		private readonly settingsManager: SettingsManager,
+		private readonly _settingsManager: SettingsManager,
 	) {
 		document.addEventListener('securitypolicyviolation', () => {
-			this.onCspWarning();
+			this._onCspWarning();
 		});
 
 		window.addEventListener('message', (event) => {
 			if (event && event.data && event.data.name === 'vscode-did-block-svg') {
-				this.onCspWarning();
+				this._onCspWarning();
 			}
 		});
 	}
 
 	public setPoster(poster: MessagePoster) {
-		this.messaging = poster;
-		if (this.didHaveCspWarning) {
-			this.showCspWarning();
+		this._messaging = poster;
+		if (this._didHaveCspWarning) {
+			this._showCspWarning();
 		}
 	}
 
-	private onCspWarning() {
-		this.didHaveCspWarning = true;
-		this.showCspWarning();
+	private _onCspWarning() {
+		this._didHaveCspWarning = true;
+		this._showCspWarning();
 	}
 
-	private showCspWarning() {
+	private _showCspWarning() {
 		const strings = getStrings();
-		const settings = this.settingsManager.settings;
+		const settings = this._settingsManager.settings;
 
-		if (this.didShow || settings.disableSecurityWarnings || !this.messaging) {
+		if (this._didShow || settings.disableSecurityWarnings || !this._messaging) {
 			return;
 		}
-		this.didShow = true;
+		this._didShow = true;
 
 		const notification = document.createElement('a');
 		notification.innerText = strings.cspAlertMessageText;
@@ -59,7 +59,7 @@ export class CspAlerter {
 		notification.setAttribute('role', 'button');
 		notification.setAttribute('aria-label', strings.cspAlertMessageLabel);
 		notification.onclick = () => {
-			this.messaging!.postMessage('showPreviewSecuritySelector', { source: settings.source });
+			this._messaging!.postMessage('showPreviewSecuritySelector', { source: settings.source });
 		};
 		document.body.appendChild(notification);
 	}

extensions/markdown-language-features/preview-src/loading.ts

@@ -5,15 +5,15 @@
 import { MessagePoster } from './messaging';
 
 export class StyleLoadingMonitor {
-	private unloadedStyles: string[] = [];
-	private finishedLoading: boolean = false;
+	private _unloadedStyles: string[] = [];
+	private _finishedLoading: boolean = false;
 
-	private poster?: MessagePoster;
+	private _poster?: MessagePoster;
 
 	constructor() {
 		const onStyleLoadError = (event: any) => {
 			const source = event.target.dataset.source;
-			this.unloadedStyles.push(source);
+			this._unloadedStyles.push(source);
 		};
 
 		window.addEventListener('DOMContentLoaded', () => {
@@ -25,18 +25,18 @@ export class StyleLoadingMonitor {
 		});
 
 		window.addEventListener('load', () => {
-			if (!this.unloadedStyles.length) {
+			if (!this._unloadedStyles.length) {
 				return;
 			}
-			this.finishedLoading = true;
-			this.poster?.postMessage('previewStyleLoadError', { unloadedStyles: this.unloadedStyles });
+			this._finishedLoading = true;
+			this._poster?.postMessage('previewStyleLoadError', { unloadedStyles: this._unloadedStyles });
 		});
 	}
 
 	public setPoster(poster: MessagePoster): void {
-		this.poster = poster;
-		if (this.finishedLoading) {
-			poster.postMessage('previewStyleLoadError', { unloadedStyles: this.unloadedStyles });
+		this._poster = poster;
+		if (this._finishedLoading) {
+			poster.postMessage('previewStyleLoadError', { unloadedStyles: this._unloadedStyles });
 		}
 	}
 }