vscode-eslint 0.0.3 → 0.0.5

package/server/src/is.ts

@@ -1,18 +0,0 @@
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-
-const toString = Object.prototype.toString;
-
-export function boolean(value: any): value is boolean {
-	return value === true || value === false;
-}
-
-export function nullOrUndefined(value: any): value is null | undefined {
-	return value === null || value === undefined;
-}
-
-export function string(value: any): value is string {
-	return toString.call(value) === '[object String]';
-}

package/server/src/languageDefaults.ts

@@ -1,40 +0,0 @@
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-
-// This should either come from LSP or VS Code. That we repeat this is bogus.
-
-type LanguageConfig = {
-	ext: string;
-	lineComment: string;
-	blockComment: [string, string];
-};
-
-const languageId2Config: Map<string, LanguageConfig> = new Map([
-	['javascript', { ext: 'js', lineComment: '//', blockComment: ['/*', '*/'] }],
-	['javascriptreact', { ext: 'jsx', lineComment: '//', blockComment: ['/*', '*/'] }],
-	['typescript', { ext: 'ts', lineComment: '//', blockComment: ['/*', '*/'] } ],
-	['typescriptreact', { ext: 'tsx', lineComment: '//', blockComment: ['/*', '*/'] } ],
-	['html', { ext: 'html', lineComment: '//', blockComment: ['<!--', '-->'] }],
-	['vue', { ext: 'vue', lineComment: '//', blockComment: ['<!--', '-->'] }],
-	['coffeescript', { ext: 'coffee', lineComment: '#', blockComment: ['###', '###'] }],
-	['yaml', { ext: 'yaml', lineComment: '#', blockComment: ['#', ''] }],
-	['graphql', { ext: 'graphql', lineComment: '#', blockComment: ['#', ''] }]
-]);
-
-namespace LanguageDefaults {
-	export function getLineComment(languageId: string): string {
-		return languageId2Config.get(languageId)?.lineComment ?? '//';
-	}
-
-	export function getBlockComment(languageId: string): [string, string] {
-		return languageId2Config.get(languageId)?.blockComment ?? ['/*', '*/'];
-	}
-
-	export function getExtension(languageId: string): string | undefined {
-		return languageId2Config.get(languageId)?.ext;
-	}
-}
-
-export default LanguageDefaults;

package/server/src/linkedMap.ts

@@ -1,448 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-interface Item<K, V> {
-	previous: Item<K, V> | undefined;
-	next: Item<K, V> | undefined;
-	key: K;
-	value: V;
-}
-
-export namespace Touch {
-	export const None: 0 = 0;
-	export const First: 1 = 1;
-	export const AsOld: 1 = Touch.First;
-	export const Last: 2 = 2;
-	export const AsNew: 2 = Touch.Last;
-}
-
-export type Touch = 0 | 1 | 2;
-
-export class LinkedMap<K, V> implements Map<K, V> {
-
-	readonly [Symbol.toStringTag] = 'LinkedMap';
-
-	private _map: Map<K, Item<K, V>>;
-	private _head: Item<K, V> | undefined;
-	private _tail: Item<K, V> | undefined;
-	private _size: number;
-
-	private _state: number;
-
-	public constructor() {
-		this._map = new Map<K, Item<K, V>>();
-		this._head = undefined;
-		this._tail = undefined;
-		this._size = 0;
-		this._state = 0;
-	}
-
-	public clear(): void {
-		this._map.clear();
-		this._head = undefined;
-		this._tail = undefined;
-		this._size = 0;
-		this._state++;
-	}
-
-	public isEmpty(): boolean {
-		return !this._head && !this._tail;
-	}
-
-	public get size(): number {
-		return this._size;
-	}
-
-	public get first(): V | undefined {
-		return this._head?.value;
-	}
-
-	public get last(): V | undefined {
-		return this._tail?.value;
-	}
-
-	public has(key: K): boolean {
-		return this._map.has(key);
-	}
-
-	public get(key: K, touch: Touch = Touch.None): V | undefined {
-		const item = this._map.get(key);
-		if (!item) {
-			return undefined;
-		}
-		if (touch !== Touch.None) {
-			this.touch(item, touch);
-		}
-		return item.value;
-	}
-
-	public set(key: K, value: V, touch: Touch = Touch.None): this {
-		let item = this._map.get(key);
-		if (item) {
-			item.value = value;
-			if (touch !== Touch.None) {
-				this.touch(item, touch);
-			}
-		} else {
-			item = { key, value, next: undefined, previous: undefined };
-			switch (touch) {
-				case Touch.None:
-					this.addItemLast(item);
-					break;
-				case Touch.First:
-					this.addItemFirst(item);
-					break;
-				case Touch.Last:
-					this.addItemLast(item);
-					break;
-				default:
-					this.addItemLast(item);
-					break;
-			}
-			this._map.set(key, item);
-			this._size++;
-		}
-		return this;
-	}
-
-	public delete(key: K): boolean {
-		return !!this.remove(key);
-	}
-
-	public remove(key: K): V | undefined {
-		const item = this._map.get(key);
-		if (!item) {
-			return undefined;
-		}
-		this._map.delete(key);
-		this.removeItem(item);
-		this._size--;
-		return item.value;
-	}
-
-	public shift(): V | undefined {
-		if (!this._head && !this._tail) {
-			return undefined;
-		}
-		if (!this._head || !this._tail) {
-			throw new Error('Invalid list');
-		}
-		const item = this._head;
-		this._map.delete(item.key);
-		this.removeItem(item);
-		this._size--;
-		return item.value;
-	}
-
-	public forEach(callbackfn: (value: V, key: K, map: LinkedMap<K, V>) => void, thisArg?: any): void {
-		const state = this._state;
-		let current = this._head;
-		while (current) {
-			if (thisArg) {
-				callbackfn.bind(thisArg)(current.value, current.key, this);
-			} else {
-				callbackfn(current.value, current.key, this);
-			}
-			if (this._state !== state) {
-				throw new Error(`LinkedMap got modified during iteration.`);
-			}
-			current = current.next;
-		}
-	}
-
-	public keys(): IterableIterator<K> {
-		const map = this;
-		const state = this._state;
-		let current = this._head;
-		const iterator: IterableIterator<K> = {
-			[Symbol.iterator]() {
-				return iterator;
-			},
-			next(): IteratorResult<K> {
-				if (map._state !== state) {
-					throw new Error(`LinkedMap got modified during iteration.`);
-				}
-				if (current) {
-					const result = { value: current.key, done: false };
-					current = current.next;
-					return result;
-				} else {
-					return { value: undefined, done: true };
-				}
-			}
-		};
-		return iterator;
-	}
-
-	public values(): IterableIterator<V> {
-		const map = this;
-		const state = this._state;
-		let current = this._head;
-		const iterator: IterableIterator<V> = {
-			[Symbol.iterator]() {
-				return iterator;
-			},
-			next(): IteratorResult<V> {
-				if (map._state !== state) {
-					throw new Error(`LinkedMap got modified during iteration.`);
-				}
-				if (current) {
-					const result = { value: current.value, done: false };
-					current = current.next;
-					return result;
-				} else {
-					return { value: undefined, done: true };
-				}
-			}
-		};
-		return iterator;
-	}
-
-	public entries(): IterableIterator<[K, V]> {
-		const map = this;
-		const state = this._state;
-		let current = this._head;
-		const iterator: IterableIterator<[K, V]> = {
-			[Symbol.iterator]() {
-				return iterator;
-			},
-			next(): IteratorResult<[K, V]> {
-				if (map._state !== state) {
-					throw new Error(`LinkedMap got modified during iteration.`);
-				}
-				if (current) {
-					const result: IteratorResult<[K, V]> = { value: [current.key, current.value], done: false };
-					current = current.next;
-					return result;
-				} else {
-					return { value: undefined, done: true };
-				}
-			}
-		};
-		return iterator;
-	}
-
-	public [Symbol.iterator](): IterableIterator<[K, V]> {
-		return this.entries();
-	}
-
-	protected trimOld(newSize: number) {
-		if (newSize >= this.size) {
-			return;
-		}
-		if (newSize === 0) {
-			this.clear();
-			return;
-		}
-		let current = this._head;
-		let currentSize = this.size;
-		while (current && currentSize > newSize) {
-			this._map.delete(current.key);
-			current = current.next;
-			currentSize--;
-		}
-		this._head = current;
-		this._size = currentSize;
-		if (current) {
-			current.previous = undefined;
-		}
-		this._state++;
-	}
-
-	private addItemFirst(item: Item<K, V>): void {
-		// First time Insert
-		if (!this._head && !this._tail) {
-			this._tail = item;
-		} else if (!this._head) {
-			throw new Error('Invalid list');
-		} else {
-			item.next = this._head;
-			this._head.previous = item;
-		}
-		this._head = item;
-		this._state++;
-	}
-
-	private addItemLast(item: Item<K, V>): void {
-		// First time Insert
-		if (!this._head && !this._tail) {
-			this._head = item;
-		} else if (!this._tail) {
-			throw new Error('Invalid list');
-		} else {
-			item.previous = this._tail;
-			this._tail.next = item;
-		}
-		this._tail = item;
-		this._state++;
-	}
-
-	private removeItem(item: Item<K, V>): void {
-		if (item === this._head && item === this._tail) {
-			this._head = undefined;
-			this._tail = undefined;
-		}
-		else if (item === this._head) {
-			// This can only happen if size === 1 which is handled
-			// by the case above.
-			if (!item.next) {
-				throw new Error('Invalid list');
-			}
-			item.next.previous = undefined;
-			this._head = item.next;
-		}
-		else if (item === this._tail) {
-			// This can only happen if size === 1 which is handled
-			// by the case above.
-			if (!item.previous) {
-				throw new Error('Invalid list');
-			}
-			item.previous.next = undefined;
-			this._tail = item.previous;
-		}
-		else {
-			const next = item.next;
-			const previous = item.previous;
-			if (!next || !previous) {
-				throw new Error('Invalid list');
-			}
-			next.previous = previous;
-			previous.next = next;
-		}
-		item.next = undefined;
-		item.previous = undefined;
-		this._state++;
-	}
-
-	private touch(item: Item<K, V>, touch: Touch): void {
-		if (!this._head || !this._tail) {
-			throw new Error('Invalid list');
-		}
-		if ((touch !== Touch.First && touch !== Touch.Last)) {
-			return;
-		}
-
-		if (touch === Touch.First) {
-			if (item === this._head) {
-				return;
-			}
-
-			const next = item.next;
-			const previous = item.previous;
-
-			// Unlink the item
-			if (item === this._tail) {
-				// previous must be defined since item was not head but is tail
-				// So there are more than on item in the map
-				previous!.next = undefined;
-				this._tail = previous;
-			}
-			else {
-				// Both next and previous are not undefined since item was neither head nor tail.
-				next!.previous = previous;
-				previous!.next = next;
-			}
-
-			// Insert the node at head
-			item.previous = undefined;
-			item.next = this._head;
-			this._head.previous = item;
-			this._head = item;
-			this._state++;
-		} else if (touch === Touch.Last) {
-			if (item === this._tail) {
-				return;
-			}
-
-			const next = item.next;
-			const previous = item.previous;
-
-			// Unlink the item.
-			if (item === this._head) {
-				// next must be defined since item was not tail but is head
-				// So there are more than on item in the map
-				next!.previous = undefined;
-				this._head = next;
-			} else {
-				// Both next and previous are not undefined since item was neither head nor tail.
-				next!.previous = previous;
-				previous!.next = next;
-			}
-			item.next = undefined;
-			item.previous = this._tail;
-			this._tail.next = item;
-			this._tail = item;
-			this._state++;
-		}
-	}
-
-	public toJSON(): [K, V][] {
-		const data: [K, V][] = [];
-
-		this.forEach((value, key) => {
-			data.push([key, value]);
-		});
-
-		return data;
-	}
-
-	public fromJSON(data: [K, V][]): void {
-		this.clear();
-
-		for (const [key, value] of data) {
-			this.set(key, value);
-		}
-	}
-}
-
-export class LRUCache<K, V> extends LinkedMap<K, V> {
-
-	private _limit: number;
-	private _ratio: number;
-
-	public constructor(limit: number, ratio: number = 1) {
-		super();
-		this._limit = limit;
-		this._ratio = Math.min(Math.max(0, ratio), 1);
-	}
-
-	public get limit(): number {
-		return this._limit;
-	}
-
-	public set limit(limit: number) {
-		this._limit = limit;
-		this.checkTrim();
-	}
-
-	public get ratio(): number {
-		return this._ratio;
-	}
-
-	public set ratio(ratio: number) {
-		this._ratio = Math.min(Math.max(0, ratio), 1);
-		this.checkTrim();
-	}
-
-	public get(key: K, touch: Touch = Touch.AsNew): V | undefined {
-		return super.get(key, touch);
-	}
-
-	public peek(key: K): V | undefined {
-		return super.get(key, Touch.None);
-	}
-
-	public set(key: K, value: V): this {
-		super.set(key, value, Touch.Last);
-		this.checkTrim();
-		return this;
-	}
-
-	private checkTrim() {
-		if (this.size > this._limit) {
-			this.trimOld(Math.round(this._limit * this._ratio));
-		}
-	}
-}

package/server/src/paths.ts

@@ -1,128 +0,0 @@
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-
-import * as fs from 'fs';
-
-import { URI } from 'vscode-uri';
-import { TextDocument } from 'vscode-languageserver-textdocument';
-
-import * as Is from './is';
-
-/**
- * Special functions to deal with path conversions in the context of ESLint
- */
-
-/**
- * Normalizes the drive letter to upper case which is the default in Node but not in
- * VS Code.
- */
-export function normalizeDriveLetter(path: string): string {
-	if (process.platform !== 'win32' || path.length < 2 || path[1] !== ':') {
-		return path;
-	}
-	return path[0].toUpperCase() + path.substring(1);
-}
-
-const enum CharCode {
-	/**
-	 * The `\` character.
-	 */
-	Backslash = 92,
-}
-
-/**
- * Check if the path follows this pattern: `\\hostname\sharename`.
- *
- * @see https://msdn.microsoft.com/en-us/library/gg465305.aspx
- * @return A boolean indication if the path is a UNC path, on none-windows
- * always false.
- */
-export function isUNC(path: string): boolean {
-	if (process.platform !== 'win32') {
-		// UNC is a windows concept
-		return false;
-	}
-
-	if (!path || path.length < 5) {
-		// at least \\a\b
-		return false;
-	}
-
-	let code = path.charCodeAt(0);
-	if (code !== CharCode.Backslash) {
-		return false;
-	}
-	code = path.charCodeAt(1);
-	if (code !== CharCode.Backslash) {
-		return false;
-	}
-	let pos = 2;
-	const start = pos;
-	for (; pos < path.length; pos++) {
-		code = path.charCodeAt(pos);
-		if (code === CharCode.Backslash) {
-			break;
-		}
-	}
-	if (start === pos) {
-		return false;
-	}
-	code = path.charCodeAt(pos + 1);
-	if (isNaN(code) || code === CharCode.Backslash) {
-		return false;
-	}
-	return true;
-}
-
-export function getFileSystemPath(uri: URI, useRealpaths: boolean): string {
-	let result = uri.fsPath;
-	if (process.platform === 'win32' && result.length >= 2 && result[1] === ':') {
-		// Node by default uses an upper case drive letter and ESLint uses
-		// === to compare paths which results in the equal check failing
-		// if the drive letter is lower case in th URI. Ensure upper case.
-		result = result[0].toUpperCase() + result.substr(1);
-	}
-	if (useRealpaths) {
-		result = tryRealpath(result);
-	} else if (process.platform === 'win32' || process.platform === 'darwin') {
-		const realpath = tryRealpath(result);
-		// Only use the real path if only the casing has changed.
-		if (realpath.toLowerCase() === result.toLowerCase()) {
-			result = realpath;
-		}
-	}
-	return result;
-}
-
-function tryRealpath(path: string): string {
-	try {
-		return fs.realpathSync.native(path);
-	} catch (error) {
-		// Silently ignore errors from `fs.realpathSync` to handle scenarios where
-		// the file being linted is not yet written to disk. This occurs in editors
-		// such as Neovim for non-written buffers.
-		return path;
-	}
-}
-
-export function normalizePath(path: string): string;
-export function normalizePath(path: undefined): undefined;
-export function normalizePath(path: string | undefined): string | undefined {
-	if (path === undefined) {
-		return undefined;
-	}
-	if (process.platform === 'win32') {
-		return path.replace(/\\/g, '/');
-	}
-	return path;
-}
-
-export function getUri(documentOrUri: string | TextDocument | URI): URI {
-	return Is.string(documentOrUri)
-		? URI.parse(documentOrUri)
-		: documentOrUri instanceof URI
-			? documentOrUri
-			: URI.parse(documentOrUri.uri);
-}

package/server/src/thenable.d.ts

@@ -1,5 +0,0 @@
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-interface Thenable<T> extends PromiseLike<T> {}

package/server/tsconfig.json

@@ -1,21 +0,0 @@
-{
-	"extends": "../tsconfig.base.json",
-	"compilerOptions": {
-		"module": "Node16",
-		"moduleResolution": "Node16",
-		"target": "ES2022",
-		"sourceMap": true,
-		"outDir": "out",
-		"rootDir": "src",
-		"lib": [ "ES2023" ],
-		"tsBuildInfoFile": "out/compile.tsbuildinfo",
-        "incremental": true,
-        "composite": true
-	},
-	"include": [
-		"src"
-	],
-	"exclude": [
-		"node_modules"
-	]
-}

package/server/webpack.config.js

@@ -1,25 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-//@ts-check
-
-'use strict';
-
-const withDefaults = require('../shared.webpack.config');
-const path = require('path');
-
-module.exports = withDefaults({
-	context: path.join(__dirname),
-	entry: {
-		extension: './src/eslintServer.ts',
-	},
-	resolve: {
-		symlinks: false
-	},
-	output: {
-		filename: 'eslintServer.js',
-		path: path.join(__dirname, 'out')
-	}
-});