feat: improve ts and export (#112)

* feat: improve declaration files

* feat: improve tsconfig.json and fix ts check errors

* feat: improve languageFeatures

* feat: improve debounce types

* feat: improve ts type

* feat: enhance languageFeatures

* feat: languages are loaded on demand

* feat: remove useless exports

* docs: update website

src/baseSQLWorker.ts

@@ -17,14 +17,6 @@ export abstract class BaseSQLWorker {
 		return Promise.resolve([]);
 	}
 
-	async valid(code: string): Promise<ParseError[]> {
-		if (code) {
-			const result = this.parser.validate(code);
-			return Promise.resolve(result);
-		}
-		return Promise.resolve([]);
-	}
-
 	async parserTreeToString(code: string): Promise<string> {
 		if (code) {
 			const parser = this.parser.createParser(code);
@@ -60,7 +52,7 @@ export abstract class BaseSQLWorker {
 		return Promise.resolve([null, null]);
 	}
 
-	async getAllEntities(code: string, position: Position): Promise<EntityContext[] | null> {
+	async getAllEntities(code: string, position?: Position): Promise<EntityContext[] | null> {
 		code = code || this.getTextDocument();
 		if (code) {
 			const allEntities = this.parser.getAllEntities(code, position);

src/common/utils.ts

@@ -1,15 +1,19 @@
-export function debounce(func: Function, timeout: number, immediate?: boolean) {
-	let timer: any = null;
-	return (...args: any) => {
+export function debounce<T extends (...args: unknown[]) => unknown>(
+	func: T,
+	timeout: number,
+	immediate?: boolean
+): (...args: Parameters<T>) => unknown {
+	let timer: NodeJS.Timeout | null = null;
+	return (...args) => {
 		if (timer) {
 			clearTimeout(timer);
 		}
 		if (immediate && !timer) {
-			func?.(...args);
+			return func?.(...args);
 		}
 
 		timer = setTimeout(() => {
-			clearTimeout(timer);
+			timer && clearTimeout(timer);
 			timer = null;
 			func?.(...args);
 		}, timeout);

src/editor.worker.d.ts

@@ -0,0 +1,3 @@
+declare module 'monaco-editor/esm/vs/editor/editor.worker.js' {
+	export function initialize(callback: (ctx: any, createData: any) => any): void;
+}

src/flinksql/flinkSQLWorker.ts

@@ -6,7 +6,8 @@ import { ICreateData } from '../_.contribution';
 export class FLinkSQLWorker extends BaseSQLWorker {
 	protected _ctx: worker.IWorkerContext;
 	protected parser: FlinkSQL;
-	constructor(ctx: worker.IWorkerContext, createData: ICreateData) {
+	constructor(ctx: worker.IWorkerContext, _createData: ICreateData) {
+		// CreatedData is not required now.
 		super();
 		this._ctx = ctx;
 		this.parser = new FlinkSQL();

src/flinksql/flinksql.contribution.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { loadLanguage, registerLanguage } from '../_.contribution';
+import { registerLanguage } from '../_.contribution';
 import { setupLanguageFeatures } from '../setupLanguageFeatures';
 import { LanguageIdEnum } from '../common/constants';
 
@@ -14,8 +14,6 @@ registerLanguage({
 	loader: () => import('./flinksql')
 });
 
-loadLanguage(LanguageIdEnum.FLINK);
-
 setupLanguageFeatures({
 	languageId: LanguageIdEnum.FLINK,
 	completionItems: true,

src/flinksql/flinksql.worker.ts

@@ -3,7 +3,8 @@ import * as EditorWorker from 'monaco-editor/esm/vs/editor/editor.worker.js';
 import { FLinkSQLWorker } from './flinkSQLWorker';
 import { ICreateData } from '../_.contribution';
 
-self.onmessage = (e: any) => {
+self.onmessage = () => {
+	// ignore the first message
 	EditorWorker.initialize((ctx: worker.IWorkerContext, createData: ICreateData) => {
 		return new FLinkSQLWorker(ctx, createData);
 	});

src/hivesql/hiveSQLWorker.ts

@@ -6,7 +6,8 @@ import { BaseSQLWorker } from '../baseSQLWorker';
 export class HiveSQLWorker extends BaseSQLWorker {
 	protected _ctx: worker.IWorkerContext;
 	protected parser: HiveSQL;
-	constructor(ctx: worker.IWorkerContext, createData: ICreateData) {
+	constructor(ctx: worker.IWorkerContext, _createData: ICreateData) {
+		// CreatedData is not required now.
 		super();
 		this._ctx = ctx;
 		this.parser = new HiveSQL();

src/hivesql/hivesql.contribution.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { loadLanguage, registerLanguage } from '../_.contribution';
+import { registerLanguage } from '../_.contribution';
 import { setupLanguageFeatures } from '../setupLanguageFeatures';
 import { LanguageIdEnum } from '../common/constants';
 
@@ -14,8 +14,6 @@ registerLanguage({
 	loader: () => import('./hivesql')
 });
 
-loadLanguage(LanguageIdEnum.HIVE);
-
 setupLanguageFeatures({
 	languageId: LanguageIdEnum.HIVE,
 	completionItems: true,

src/hivesql/hivesql.worker.ts

@@ -3,7 +3,8 @@ import * as EditorWorker from 'monaco-editor/esm/vs/editor/editor.worker.js';
 import { ICreateData } from '../_.contribution';
 import { HiveSQLWorker } from './hiveSQLWorker';
 
-self.onmessage = (e: any) => {
+self.onmessage = () => {
+	// ignore the first message
 	EditorWorker.initialize((ctx: worker.IWorkerContext, createData: ICreateData) => {
 		return new HiveSQLWorker(ctx, createData);
 	});

src/impalasql/impalaSQLWorker.ts

@@ -6,7 +6,8 @@ import { ICreateData } from '../_.contribution';
 export class ImpalaSQLWorker extends BaseSQLWorker {
 	protected _ctx: worker.IWorkerContext;
 	protected parser: ImpalaSQL;
-	constructor(ctx: worker.IWorkerContext, createData: ICreateData) {
+	constructor(ctx: worker.IWorkerContext, _createData: ICreateData) {
+		// CreatedData is not required now.
 		super();
 		this._ctx = ctx;
 		this.parser = new ImpalaSQL();

src/impalasql/impalasql.contribution.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { loadLanguage, registerLanguage } from '../_.contribution';
+import { registerLanguage } from '../_.contribution';
 import { setupLanguageFeatures } from '../setupLanguageFeatures';
 import { LanguageIdEnum } from '../common/constants';
 
@@ -14,8 +14,6 @@ registerLanguage({
 	loader: () => import('./impalasql')
 });
 
-loadLanguage(LanguageIdEnum.IMPALA);
-
 setupLanguageFeatures({
 	languageId: LanguageIdEnum.IMPALA,
 	completionItems: true,

src/impalasql/impalasql.worker.ts

@@ -3,7 +3,8 @@ import * as EditorWorker from 'monaco-editor/esm/vs/editor/editor.worker.js';
 import { ImpalaSQLWorker } from './impalaSQLWorker';
 import { ICreateData } from '../_.contribution';
 
-self.onmessage = (e: any) => {
+self.onmessage = () => {
+	// ignore the first message
 	EditorWorker.initialize((ctx: worker.IWorkerContext, createData: ICreateData) => {
 		return new ImpalaSQLWorker(ctx, createData);
 	});

src/languageFeatures.ts

@@ -14,7 +14,7 @@ import type { ParseError } from 'dt-sql-parser';
 import type { LanguageServiceDefaults, CompletionService, ICompletionItem } from './_.contribution';
 
 export interface WorkerAccessor<T extends BaseSQLWorker> {
-	(first: Uri, ...more: Uri[]): Promise<T>;
+	(...uris: Uri[]): Promise<T>;
 }
 
 export class DiagnosticsAdapter<T extends BaseSQLWorker> {
@@ -24,7 +24,7 @@ export class DiagnosticsAdapter<T extends BaseSQLWorker> {
 	constructor(
 		private _languageId: string,
 		private _worker: WorkerAccessor<T>,
-		private _defaults: LanguageServiceDefaults
+		private readonly _defaults: LanguageServiceDefaults
 	) {
 		const onModelAdd = (model: editor.IModel): void => {
 			let modeId = model.getLanguageId();
@@ -35,7 +35,7 @@ export class DiagnosticsAdapter<T extends BaseSQLWorker> {
 			this._listener[model.uri.toString()] = model.onDidChangeContent(
 				debounce(() => {
 					this._doValidate(model.uri, modeId);
-				}, 600)
+				}, 500)
 			);
 
 			this._doValidate(model.uri, modeId);
@@ -61,14 +61,16 @@ export class DiagnosticsAdapter<T extends BaseSQLWorker> {
 			})
 		);
 
-		this._defaults.onDidChange((_) => {
-			editor.getModels().forEach((model) => {
-				if (model.getLanguageId() === this._languageId) {
-					onModelRemoved(model);
-					onModelAdd(model);
-				}
-			});
-		});
+		this._disposables.push(
+			this._defaults.onDidChange((_) => {
+				editor.getModels().forEach((model) => {
+					if (model.getLanguageId() === this._languageId) {
+						onModelRemoved(model);
+						onModelAdd(model);
+					}
+				});
+			})
+		);
 
 		this._disposables.push({
 			dispose: () => {
@@ -115,7 +117,7 @@ function toSeverity(lsSeverity?: number): MarkerSeverity {
 	}
 }
 
-function toDiagnostics(resource: Uri, diag: ParseError): editor.IMarkerData {
+function toDiagnostics(_resource: Uri, diag: ParseError): editor.IMarkerData {
 	return {
 		severity: toSeverity(),
 		startLineNumber: diag.startLine,
@@ -131,11 +133,10 @@ function toDiagnostics(resource: Uri, diag: ParseError): editor.IMarkerData {
 export class CompletionAdapter<T extends BaseSQLWorker>
 	implements languages.CompletionItemProvider
 {
-	constructor(private readonly _worker: WorkerAccessor<T>, defaults: LanguageServiceDefaults) {
-		this._defaults = defaults;
-	}
-
-	private _defaults: LanguageServiceDefaults;
+	constructor(
+		private readonly _worker: WorkerAccessor<T>,
+		private readonly _defaults: LanguageServiceDefaults
+	) {}
 
 	public get triggerCharacters(): string[] {
 		return ['.', ' '];
@@ -145,7 +146,7 @@ export class CompletionAdapter<T extends BaseSQLWorker>
 		model: editor.IReadOnlyModel,
 		position: Position,
 		context: languages.CompletionContext,
-		token: CancellationToken
+		_token: CancellationToken
 	): Promise<languages.CompletionList> {
 		const resource = model.uri;
 		return this._worker(resource)

src/languageService.ts

@@ -4,40 +4,73 @@ import {
 	diagnosticDefault,
 	modeConfigurationDefault
 } from './_.contribution';
-import { WorkerAccessor } from './languageFeatures';
 import { WorkerManager } from './workerManager';
 import { BaseSQLWorker } from './baseSQLWorker';
+import { Position, Uri, editor } from './fillers/monaco-editor-core';
 
-type ClientWorker = (...uris: any) => Promise<BaseSQLWorker>;
+export class LanguageService<T extends BaseSQLWorker = BaseSQLWorker> {
+	private workerClients: Map<string, WorkerManager<T>> = new Map();
 
-export class LanguageService {
-	private worker: Map<string, WorkerAccessor<any>> = new Map();
+	public valid(language: string, model: editor.IReadOnlyModel | string) {
+		const text = typeof model === 'string' ? model : model.getValue();
+		const uri = typeof model === 'string' ? void 0 : model.uri;
 
-	public valid(language: string, sqlContent: string): Promise<any> {
-		const clientWorker = this.getClientWorker(language);
-		return clientWorker(sqlContent).then((worker) => {
-			return worker.valid(sqlContent);
+		const clientWorker = this.getClientWorker(language, uri as Uri);
+		return clientWorker.then((worker) => {
+			return worker.doValidation(text);
 		});
 	}
 
-	public parserTreeToString(language: string, sqlContent: string): Promise<any> {
-		const clientWorker = this.getClientWorker(language);
-		return clientWorker(sqlContent).then((worker) => {
-			return worker.parserTreeToString(sqlContent);
+	public parserTreeToString(language: string, model: editor.IReadOnlyModel | string) {
+		const text = typeof model === 'string' ? model : model.getValue();
+		const uri = typeof model === 'string' ? void 0 : model.uri;
+
+		const clientWorker = this.getClientWorker(language, uri as Uri);
+		return clientWorker.then((worker) => {
+			return worker.parserTreeToString(text);
+		});
+	}
+
+	public getAllEntities(
+		language: string,
+		model: editor.IReadOnlyModel | string,
+		position?: Position
+	) {
+		const text = typeof model === 'string' ? model : model.getValue();
+		const uri = typeof model === 'string' ? void 0 : model.uri;
+
+		const clientWorker = this.getClientWorker(language, uri as Uri);
+		return clientWorker.then((worker) => {
+			return worker.getAllEntities(text, position);
 		});
 	}
 
-	private getClientWorker(language: string): ClientWorker {
-		let existWorker = this.worker.get(language);
-		if (!existWorker) {
-			const client = new WorkerManager(this.getLanguageServiceDefault(language));
-			const worker: WorkerAccessor<any> = (...uris): Promise<any> => {
-				return client.getLanguageServiceWorker(...uris);
-			};
-			this.worker.set(language, worker);
-			return worker;
+	/**
+	 * Dispose a language service.
+	 * If the language is null, dispose all language services.
+	 */
+	public dispose(language?: string): void {
+		if (language) {
+			if (this.workerClients.has(language)) {
+				this.workerClients.get(language)?.dispose();
+				this.workerClients.delete(language);
+			}
+		} else {
+			this.workerClients.forEach((client) => {
+				client.dispose();
+			});
+			this.workerClients.clear();
+		}
+	}
+
+	private getClientWorker(language: string, ...uri: Uri[]): Promise<T> {
+		let existClient = this.workerClients.get(language);
+		if (!existClient) {
+			const client = new WorkerManager<T>(this.getLanguageServiceDefault(language));
+			this.workerClients.set(language, client);
+			return client.getLanguageServiceWorker(...uri);
 		}
-		return existWorker;
+		return existClient.getLanguageServiceWorker(...uri);
 	}
 
 	private getLanguageServiceDefault(languageId: string): LanguageServiceDefaults {

src/main.ts

@@ -1,13 +1,21 @@
 export * from './_.contribution';
 export * from './languageService';
-export * from './languageFeatures';
-export * from './setupLanguageMode';
 export * from './setupLanguageFeatures';
-export * from './workerManager';
-export * from './common/utils';
 export * from './common/constants';
 export * from './theme';
 
-export { SyntaxContextType } from 'dt-sql-parser';
+export {
+	EntityContextType,
+	StmtContextType,
+	/** @deprecated use {@link EntityContextType} to instead. */
+	SyntaxContextType
+} from 'dt-sql-parser';
 
-export type { WordRange, SyntaxSuggestion, Suggestions, TextSlice } from 'dt-sql-parser';
+export type {
+	WordRange,
+	SyntaxSuggestion,
+	Suggestions,
+	TextSlice,
+	ParseError,
+	EntityContext
+} from 'dt-sql-parser';