@harmoniclabs/monaco-editor 0.52.0

package/src/language/html/htmlWorker.ts

@@ -0,0 +1,164 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { worker } from '../../fillers/monaco-editor-core';
+import * as htmlService from 'vscode-html-languageservice';
+import type { Options } from './monaco.contribution';
+import { IHTMLDataProvider } from 'vscode-html-languageservice';
+
+export class HTMLWorker {
+	private _ctx: worker.IWorkerContext;
+	private _languageService: htmlService.LanguageService;
+	private _languageSettings: Options;
+	private _languageId: string;
+
+	constructor(ctx: worker.IWorkerContext, createData: ICreateData) {
+		this._ctx = ctx;
+		this._languageSettings = createData.languageSettings;
+		this._languageId = createData.languageId;
+
+		const data = this._languageSettings.data;
+
+		const useDefaultDataProvider = data?.useDefaultDataProvider;
+		const customDataProviders: IHTMLDataProvider[] = [];
+		if (data?.dataProviders) {
+			for (const id in data.dataProviders) {
+				customDataProviders.push(htmlService.newHTMLDataProvider(id, data.dataProviders[id]));
+			}
+		}
+		this._languageService = htmlService.getLanguageService({
+			useDefaultDataProvider,
+			customDataProviders
+		});
+	}
+
+	async doComplete(
+		uri: string,
+		position: htmlService.Position
+	): Promise<htmlService.CompletionList | null> {
+		let document = this._getTextDocument(uri);
+		if (!document) {
+			return null;
+		}
+		let htmlDocument = this._languageService.parseHTMLDocument(document);
+		return Promise.resolve(
+			this._languageService.doComplete(
+				document,
+				position,
+				htmlDocument,
+				this._languageSettings && this._languageSettings.suggest
+			)
+		);
+	}
+	async format(
+		uri: string,
+		range: htmlService.Range,
+		options: htmlService.FormattingOptions
+	): Promise<htmlService.TextEdit[]> {
+		let document = this._getTextDocument(uri);
+		if (!document) {
+			return [];
+		}
+		let formattingOptions = { ...this._languageSettings.format, ...options };
+		let textEdits = this._languageService.format(document, range, formattingOptions);
+		return Promise.resolve(textEdits);
+	}
+	async doHover(uri: string, position: htmlService.Position): Promise<htmlService.Hover | null> {
+		let document = this._getTextDocument(uri);
+		if (!document) {
+			return null;
+		}
+		let htmlDocument = this._languageService.parseHTMLDocument(document);
+		let hover = this._languageService.doHover(document, position, htmlDocument);
+		return Promise.resolve(hover);
+	}
+	async findDocumentHighlights(
+		uri: string,
+		position: htmlService.Position
+	): Promise<htmlService.DocumentHighlight[]> {
+		let document = this._getTextDocument(uri);
+		if (!document) {
+			return [];
+		}
+		let htmlDocument = this._languageService.parseHTMLDocument(document);
+		let highlights = this._languageService.findDocumentHighlights(document, position, htmlDocument);
+		return Promise.resolve(highlights);
+	}
+	async findDocumentLinks(uri: string): Promise<htmlService.DocumentLink[]> {
+		let document = this._getTextDocument(uri);
+		if (!document) {
+			return [];
+		}
+		let links = this._languageService.findDocumentLinks(document, null! /*TODO@aeschli*/);
+		return Promise.resolve(links);
+	}
+	async findDocumentSymbols(uri: string): Promise<htmlService.SymbolInformation[]> {
+		let document = this._getTextDocument(uri);
+		if (!document) {
+			return [];
+		}
+		let htmlDocument = this._languageService.parseHTMLDocument(document);
+		let symbols = this._languageService.findDocumentSymbols(document, htmlDocument);
+		return Promise.resolve(symbols);
+	}
+	async getFoldingRanges(
+		uri: string,
+		context?: { rangeLimit?: number }
+	): Promise<htmlService.FoldingRange[]> {
+		let document = this._getTextDocument(uri);
+		if (!document) {
+			return [];
+		}
+		let ranges = this._languageService.getFoldingRanges(document, context);
+		return Promise.resolve(ranges);
+	}
+	async getSelectionRanges(
+		uri: string,
+		positions: htmlService.Position[]
+	): Promise<htmlService.SelectionRange[]> {
+		let document = this._getTextDocument(uri);
+		if (!document) {
+			return [];
+		}
+		let ranges = this._languageService.getSelectionRanges(document, positions);
+		return Promise.resolve(ranges);
+	}
+	async doRename(
+		uri: string,
+		position: htmlService.Position,
+		newName: string
+	): Promise<htmlService.WorkspaceEdit | null> {
+		let document = this._getTextDocument(uri);
+		if (!document) {
+			return null;
+		}
+		let htmlDocument = this._languageService.parseHTMLDocument(document);
+		let renames = this._languageService.doRename(document, position, newName, htmlDocument);
+		return Promise.resolve(renames);
+	}
+	private _getTextDocument(uri: string): htmlService.TextDocument | null {
+		let models = this._ctx.getMirrorModels();
+		for (let model of models) {
+			if (model.uri.toString() === uri) {
+				return htmlService.TextDocument.create(
+					uri,
+					this._languageId,
+					model.version,
+					model.getValue()
+				);
+			}
+		}
+		return null;
+	}
+}
+
+export interface ICreateData {
+	languageId: string;
+	languageSettings: Options;
+}
+
+export function create(ctx: worker.IWorkerContext, createData: ICreateData): HTMLWorker {
+	return new HTMLWorker(ctx, createData);
+}

package/src/language/html/monaco.contribution.ts

@@ -0,0 +1,329 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as mode from './htmlMode';
+import { languages, Emitter, IEvent, IDisposable } from '../../fillers/monaco-editor-core';
+
+export interface HTMLFormatConfiguration {
+	readonly tabSize: number;
+	readonly insertSpaces: boolean;
+	readonly wrapLineLength: number;
+	readonly unformatted: string;
+	readonly contentUnformatted: string;
+	readonly indentInnerHtml: boolean;
+	readonly preserveNewLines: boolean;
+	readonly maxPreserveNewLines: number | undefined;
+	readonly indentHandlebars: boolean;
+	readonly endWithNewline: boolean;
+	readonly extraLiners: string;
+	readonly wrapAttributes: 'auto' | 'force' | 'force-aligned' | 'force-expand-multiline';
+}
+
+export interface CompletionConfiguration {
+	readonly [providerId: string]: boolean;
+}
+
+export interface Options {
+	/**
+	 * Settings for the HTML formatter.
+	 */
+	readonly format?: HTMLFormatConfiguration;
+	/**
+	 * Code completion settings.
+	 */
+	readonly suggest?: CompletionConfiguration;
+	/**
+	 * Configures the HTML data types known by the HTML langauge service.
+	 */
+	readonly data?: HTMLDataConfiguration;
+}
+
+export interface ModeConfiguration {
+	/**
+	 * Defines whether the built-in completionItemProvider is enabled.
+	 */
+	readonly completionItems?: boolean;
+
+	/**
+	 * Defines whether the built-in hoverProvider is enabled.
+	 */
+	readonly hovers?: boolean;
+
+	/**
+	 * Defines whether the built-in documentSymbolProvider is enabled.
+	 */
+	readonly documentSymbols?: boolean;
+
+	/**
+	 * Defines whether the built-in definitions provider is enabled.
+	 */
+	readonly links?: boolean;
+
+	/**
+	 * Defines whether the built-in references provider is enabled.
+	 */
+	readonly documentHighlights?: boolean;
+
+	/**
+	 * Defines whether the built-in rename provider is enabled.
+	 */
+	readonly rename?: boolean;
+
+	/**
+	 * Defines whether the built-in color provider is enabled.
+	 */
+	readonly colors?: boolean;
+
+	/**
+	 * Defines whether the built-in foldingRange provider is enabled.
+	 */
+	readonly foldingRanges?: boolean;
+
+	/**
+	 * Defines whether the built-in diagnostic provider is enabled.
+	 */
+	readonly diagnostics?: boolean;
+
+	/**
+	 * Defines whether the built-in selection range provider is enabled.
+	 */
+	readonly selectionRanges?: boolean;
+
+	/**
+	 * Defines whether the built-in documentFormattingEdit provider is enabled.
+	 */
+	readonly documentFormattingEdits?: boolean;
+
+	/**
+	 * Defines whether the built-in documentRangeFormattingEdit provider is enabled.
+	 */
+	readonly documentRangeFormattingEdits?: boolean;
+}
+
+export interface LanguageServiceDefaults {
+	readonly languageId: string;
+	readonly modeConfiguration: ModeConfiguration;
+	readonly onDidChange: IEvent<LanguageServiceDefaults>;
+	readonly options: Options;
+	setOptions(options: Options): void;
+	setModeConfiguration(modeConfiguration: ModeConfiguration): void;
+}
+// --- HTML configuration and defaults ---------
+
+class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
+	private _onDidChange = new Emitter<LanguageServiceDefaults>();
+	private _options!: Options;
+	private _modeConfiguration!: ModeConfiguration;
+	private _languageId: string;
+
+	constructor(languageId: string, options: Options, modeConfiguration: ModeConfiguration) {
+		this._languageId = languageId;
+		this.setOptions(options);
+		this.setModeConfiguration(modeConfiguration);
+	}
+
+	get onDidChange(): IEvent<LanguageServiceDefaults> {
+		return this._onDidChange.event;
+	}
+
+	get languageId(): string {
+		return this._languageId;
+	}
+
+	get options(): Options {
+		return this._options;
+	}
+
+	get modeConfiguration(): ModeConfiguration {
+		return this._modeConfiguration;
+	}
+
+	setOptions(options: Options): void {
+		this._options = options || Object.create(null);
+		this._onDidChange.fire(this);
+	}
+
+	setModeConfiguration(modeConfiguration: ModeConfiguration): void {
+		this._modeConfiguration = modeConfiguration || Object.create(null);
+		this._onDidChange.fire(this);
+	}
+}
+
+const formatDefaults: Required<HTMLFormatConfiguration> = {
+	tabSize: 4,
+	insertSpaces: false,
+	wrapLineLength: 120,
+	unformatted:
+		'default": "a, abbr, acronym, b, bdo, big, br, button, cite, code, dfn, em, i, img, input, kbd, label, map, object, q, samp, select, small, span, strong, sub, sup, textarea, tt, var',
+	contentUnformatted: 'pre',
+	indentInnerHtml: false,
+	preserveNewLines: true,
+	maxPreserveNewLines: undefined,
+	indentHandlebars: false,
+	endWithNewline: false,
+	extraLiners: 'head, body, /html',
+	wrapAttributes: 'auto'
+};
+
+const optionsDefault: Required<Options> = {
+	format: formatDefaults,
+	suggest: {},
+	data: { useDefaultDataProvider: true }
+};
+
+function getConfigurationDefault(languageId: string): Required<ModeConfiguration> {
+	return {
+		completionItems: true,
+		hovers: true,
+		documentSymbols: true,
+		links: true,
+		documentHighlights: true,
+		rename: true,
+		colors: true,
+		foldingRanges: true,
+		selectionRanges: true,
+		diagnostics: languageId === htmlLanguageId, // turned off for Razor and Handlebar
+		documentFormattingEdits: languageId === htmlLanguageId, // turned off for Razor and Handlebar
+		documentRangeFormattingEdits: languageId === htmlLanguageId // turned off for Razor and Handlebar
+	};
+}
+
+const htmlLanguageId = 'html';
+const handlebarsLanguageId = 'handlebars';
+const razorLanguageId = 'razor';
+
+export const htmlLanguageService = registerHTMLLanguageService(
+	htmlLanguageId,
+	optionsDefault,
+	getConfigurationDefault(htmlLanguageId)
+);
+export const htmlDefaults = htmlLanguageService.defaults;
+
+export const handlebarLanguageService = registerHTMLLanguageService(
+	handlebarsLanguageId,
+	optionsDefault,
+	getConfigurationDefault(handlebarsLanguageId)
+);
+export const handlebarDefaults = handlebarLanguageService.defaults;
+
+export const razorLanguageService = registerHTMLLanguageService(
+	razorLanguageId,
+	optionsDefault,
+	getConfigurationDefault(razorLanguageId)
+);
+export const razorDefaults = razorLanguageService.defaults;
+
+// export to the global based API
+(<any>languages).html = {
+	htmlDefaults,
+	razorDefaults,
+	handlebarDefaults,
+	htmlLanguageService,
+	handlebarLanguageService,
+	razorLanguageService,
+	registerHTMLLanguageService
+};
+
+// --- Registration to monaco editor ---
+
+declare var AMD: any;
+declare var require: any;
+
+function getMode(): Promise<typeof mode> {
+	if (AMD) {
+		return new Promise((resolve, reject) => {
+			require(['vs/language/html/htmlMode'], resolve, reject);
+		});
+	} else {
+		return import('./htmlMode');
+	}
+}
+
+export interface LanguageServiceRegistration extends IDisposable {
+	readonly defaults: LanguageServiceDefaults;
+}
+
+/**
+ * Registers a new HTML language service for the languageId.
+ * Note: 'html', 'handlebar' and 'razor' are registered by default.
+ *
+ * Use this method to register additional language ids with a HTML service.
+ * The language server has to be registered before an editor model is opened.
+ */
+export function registerHTMLLanguageService(
+	languageId: string,
+	options: Options = optionsDefault,
+	modeConfiguration: ModeConfiguration = getConfigurationDefault(languageId)
+): LanguageServiceRegistration {
+	const defaults = new LanguageServiceDefaultsImpl(languageId, options, modeConfiguration);
+	let mode: IDisposable | undefined;
+
+	// delay the initalization of the mode until the language is accessed the first time
+	const onLanguageListener = languages.onLanguage(languageId, async () => {
+		mode = (await getMode()).setupMode(defaults);
+	});
+	return {
+		defaults,
+		dispose() {
+			onLanguageListener.dispose();
+			mode?.dispose();
+			mode = undefined;
+		}
+	};
+}
+
+export interface HTMLDataConfiguration {
+	/**
+	 * Defines whether the standard HTML tags and attributes are shown
+	 */
+	readonly useDefaultDataProvider?: boolean;
+	/**
+	 * Provides a set of custom data providers.
+	 */
+	readonly dataProviders?: { [providerId: string]: HTMLDataV1 };
+}
+
+/**
+ * Custom HTML tags attributes and attribute values
+ * https://github.com/microsoft/vscode-html-languageservice/blob/main/docs/customData.md
+ */
+export interface HTMLDataV1 {
+	readonly version: 1 | 1.1;
+	readonly tags?: ITagData[];
+	readonly globalAttributes?: IAttributeData[];
+	readonly valueSets?: IValueSet[];
+}
+
+export interface IReference {
+	readonly name: string;
+	readonly url: string;
+}
+export interface ITagData {
+	readonly name: string;
+	readonly description?: string | MarkupContent;
+	readonly attributes: IAttributeData[];
+	readonly references?: IReference[];
+}
+export interface IAttributeData {
+	readonly name: string;
+	readonly description?: string | MarkupContent;
+	readonly valueSet?: string;
+	readonly values?: IValueData[];
+	readonly references?: IReference[];
+}
+export interface IValueData {
+	readonly name: string;
+	readonly description?: string | MarkupContent;
+	readonly references?: IReference[];
+}
+export interface IValueSet {
+	readonly name: string;
+	readonly values: IValueData[];
+}
+export interface MarkupContent {
+	readonly kind: MarkupKind;
+	readonly value: string;
+}
+export declare type MarkupKind = 'plaintext' | 'markdown';

package/src/language/html/workerManager.ts

@@ -0,0 +1,90 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { LanguageServiceDefaults } from './monaco.contribution';
+import type { HTMLWorker } from './htmlWorker';
+import { Uri, IDisposable, editor } from '../../fillers/monaco-editor-core';
+
+const STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min
+
+export class WorkerManager {
+	private _defaults: LanguageServiceDefaults;
+	private _idleCheckInterval: number;
+	private _lastUsedTime: number;
+	private _configChangeListener: IDisposable;
+
+	private _worker: editor.MonacoWebWorker<HTMLWorker> | null;
+	private _client: Promise<HTMLWorker> | null;
+
+	constructor(defaults: LanguageServiceDefaults) {
+		this._defaults = defaults;
+		this._worker = null;
+		this._client = null;
+		this._idleCheckInterval = window.setInterval(() => this._checkIfIdle(), 30 * 1000);
+		this._lastUsedTime = 0;
+		this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker());
+	}
+
+	private _stopWorker(): void {
+		if (this._worker) {
+			this._worker.dispose();
+			this._worker = null;
+		}
+		this._client = null;
+	}
+
+	dispose(): void {
+		clearInterval(this._idleCheckInterval);
+		this._configChangeListener.dispose();
+		this._stopWorker();
+	}
+
+	private _checkIfIdle(): void {
+		if (!this._worker) {
+			return;
+		}
+		let timePassedSinceLastUsed = Date.now() - this._lastUsedTime;
+		if (timePassedSinceLastUsed > STOP_WHEN_IDLE_FOR) {
+			this._stopWorker();
+		}
+	}
+
+	private _getClient(): Promise<HTMLWorker> {
+		this._lastUsedTime = Date.now();
+
+		if (!this._client) {
+			this._worker = editor.createWebWorker<HTMLWorker>({
+				// module that exports the create() method and returns a `HTMLWorker` instance
+				moduleId: 'vs/language/html/htmlWorker',
+
+				// passed in to the create() method
+				createData: {
+					languageSettings: this._defaults.options,
+					languageId: this._defaults.languageId
+				},
+
+				label: this._defaults.languageId
+			});
+
+			this._client = <Promise<HTMLWorker>>this._worker.getProxy();
+		}
+
+		return this._client;
+	}
+
+	getLanguageServiceWorker(...resources: Uri[]): Promise<HTMLWorker> {
+		let _client: HTMLWorker;
+		return this._getClient()
+			.then((client) => {
+				_client = client;
+			})
+			.then((_) => {
+				if (this._worker) {
+					return this._worker.withSyncedResources(resources);
+				}
+			})
+			.then((_) => _client);
+	}
+}

package/src/language/json/json.worker.ts

@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker';
+import { JSONWorker } from './jsonWorker';
+
+self.onmessage = () => {
+	// ignore the first message
+	worker.initialize((ctx, createData) => {
+		return new JSONWorker(ctx, createData);
+	});
+};