@harmoniclabs/monaco-editor 0.52.0

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

@@ -0,0 +1,362 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 './cssMode';
+import { languages, Emitter, IEvent } from '../../fillers/monaco-editor-core';
+
+export interface CSSFormatConfiguration {
+	/** separate selectors with newline (e.g. "a,\nbr" or "a, br"): Default: true */
+	newlineBetweenSelectors?: boolean;
+	/** add a new line after every css rule: Default: true */
+	newlineBetweenRules?: boolean;
+	/** ensure space around selector separators:  '>', '+', '~' (e.g. "a>b" -> "a > b"): Default: false */
+	spaceAroundSelectorSeparator?: boolean;
+	/** put braces on the same line as rules (`collapse`), or put braces on own line, Allman / ANSI style (`expand`). Default `collapse` */
+	braceStyle?: 'collapse' | 'expand';
+	/** whether existing line breaks before elements should be preserved. Default: true */
+	preserveNewLines?: boolean;
+	/** maximum number of line breaks to be preserved in one chunk. Default: unlimited */
+	maxPreserveNewLines?: number;
+}
+
+export interface Options {
+	readonly validate?: boolean;
+	readonly lint?: {
+		readonly compatibleVendorPrefixes?: 'ignore' | 'warning' | 'error';
+		readonly vendorPrefix?: 'ignore' | 'warning' | 'error';
+		readonly duplicateProperties?: 'ignore' | 'warning' | 'error';
+		readonly emptyRules?: 'ignore' | 'warning' | 'error';
+		readonly importStatement?: 'ignore' | 'warning' | 'error';
+		readonly boxModel?: 'ignore' | 'warning' | 'error';
+		readonly universalSelector?: 'ignore' | 'warning' | 'error';
+		readonly zeroUnits?: 'ignore' | 'warning' | 'error';
+		readonly fontFaceProperties?: 'ignore' | 'warning' | 'error';
+		readonly hexColorLength?: 'ignore' | 'warning' | 'error';
+		readonly argumentsInColorFunction?: 'ignore' | 'warning' | 'error';
+		readonly unknownProperties?: 'ignore' | 'warning' | 'error';
+		readonly ieHack?: 'ignore' | 'warning' | 'error';
+		readonly unknownVendorSpecificProperties?: 'ignore' | 'warning' | 'error';
+		readonly propertyIgnoredDueToDisplay?: 'ignore' | 'warning' | 'error';
+		readonly important?: 'ignore' | 'warning' | 'error';
+		readonly float?: 'ignore' | 'warning' | 'error';
+		readonly idSelector?: 'ignore' | 'warning' | 'error';
+	};
+	/**
+	 * Configures the CSS data types known by the langauge service.
+	 */
+	readonly data?: CSSDataConfiguration;
+
+	/**
+	 * Settings for the CSS formatter.
+	 */
+	readonly format?: CSSFormatConfiguration;
+}
+
+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 definitions?: boolean;
+
+	/**
+	 * Defines whether the built-in references provider is enabled.
+	 */
+	readonly references?: 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 document formatting edit provider is enabled.
+	 */
+	readonly documentFormattingEdits?: boolean;
+
+	/**
+	 * Defines whether the built-in document formatting range edit provider is enabled.
+	 */
+	readonly documentRangeFormattingEdits?: boolean;
+}
+
+export interface LanguageServiceDefaults {
+	readonly languageId: string;
+	readonly onDidChange: IEvent<LanguageServiceDefaults>;
+
+	readonly modeConfiguration: ModeConfiguration;
+	readonly options: Options;
+	setOptions(options: Options): void;
+	setModeConfiguration(modeConfiguration: ModeConfiguration): void;
+
+	/** @deprecated Use options instead */
+	readonly diagnosticsOptions: DiagnosticsOptions;
+	/** @deprecated Use setOptions instead */
+	setDiagnosticsOptions(options: DiagnosticsOptions): void;
+}
+
+/** @deprecated Use Options instead */
+export type DiagnosticsOptions = Options;
+
+// --- CSS 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 modeConfiguration(): ModeConfiguration {
+		return this._modeConfiguration;
+	}
+
+	get diagnosticsOptions(): Options {
+		return this.options;
+	}
+
+	get options(): Options {
+		return this._options;
+	}
+
+	setOptions(options: Options): void {
+		this._options = options || Object.create(null);
+		this._onDidChange.fire(this);
+	}
+
+	setDiagnosticsOptions(options: Options): void {
+		this.setOptions(options);
+	}
+
+	setModeConfiguration(modeConfiguration: ModeConfiguration): void {
+		this._modeConfiguration = modeConfiguration || Object.create(null);
+		this._onDidChange.fire(this);
+	}
+}
+
+const optionsDefault: Required<Options> = {
+	validate: true,
+	lint: {
+		compatibleVendorPrefixes: 'ignore',
+		vendorPrefix: 'warning',
+		duplicateProperties: 'warning',
+		emptyRules: 'warning',
+		importStatement: 'ignore',
+		boxModel: 'ignore',
+		universalSelector: 'ignore',
+		zeroUnits: 'ignore',
+		fontFaceProperties: 'warning',
+		hexColorLength: 'error',
+		argumentsInColorFunction: 'error',
+		unknownProperties: 'warning',
+		ieHack: 'ignore',
+		unknownVendorSpecificProperties: 'ignore',
+		propertyIgnoredDueToDisplay: 'warning',
+		important: 'ignore',
+		float: 'ignore',
+		idSelector: 'ignore'
+	},
+	data: { useDefaultDataProvider: true },
+	format: {
+		newlineBetweenSelectors: true,
+		newlineBetweenRules: true,
+		spaceAroundSelectorSeparator: false,
+		braceStyle: 'collapse',
+		maxPreserveNewLines: undefined,
+		preserveNewLines: true
+	}
+};
+
+const modeConfigurationDefault: Required<ModeConfiguration> = {
+	completionItems: true,
+	hovers: true,
+	documentSymbols: true,
+	definitions: true,
+	references: true,
+	documentHighlights: true,
+	rename: true,
+	colors: true,
+	foldingRanges: true,
+	diagnostics: true,
+	selectionRanges: true,
+	documentFormattingEdits: true,
+	documentRangeFormattingEdits: true
+};
+
+export const cssDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl(
+	'css',
+	optionsDefault,
+	modeConfigurationDefault
+);
+export const scssDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl(
+	'scss',
+	optionsDefault,
+	modeConfigurationDefault
+);
+export const lessDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl(
+	'less',
+	optionsDefault,
+	modeConfigurationDefault
+);
+
+// export to the global based API
+(<any>languages).css = { cssDefaults, lessDefaults, scssDefaults };
+
+// --- 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/css/cssMode'], resolve, reject);
+		});
+	} else {
+		return import('./cssMode');
+	}
+}
+
+languages.onLanguage('less', () => {
+	getMode().then((mode) => mode.setupMode(lessDefaults));
+});
+
+languages.onLanguage('scss', () => {
+	getMode().then((mode) => mode.setupMode(scssDefaults));
+});
+
+languages.onLanguage('css', () => {
+	getMode().then((mode) => mode.setupMode(cssDefaults));
+});
+
+// CSS Data
+
+export interface CSSDataConfiguration {
+	/**
+	 * Defines whether the standard CSS properties, at-directives, pseudoClasses and pseudoElements are shown.
+	 */
+	useDefaultDataProvider?: boolean;
+	/**
+	 * Provides a set of custom data providers.
+	 */
+	dataProviders?: { [providerId: string]: CSSDataV1 };
+}
+
+/**
+ * Custom CSS properties, at-directives, pseudoClasses and pseudoElements
+ * https://github.com/microsoft/vscode-css-languageservice/blob/main/docs/customData.md
+ */
+export interface CSSDataV1 {
+	version: 1 | 1.1;
+	properties?: IPropertyData[];
+	atDirectives?: IAtDirectiveData[];
+	pseudoClasses?: IPseudoClassData[];
+	pseudoElements?: IPseudoElementData[];
+}
+
+export type EntryStatus = 'standard' | 'experimental' | 'nonstandard' | 'obsolete';
+
+export interface IReference {
+	name: string;
+	url: string;
+}
+
+export interface IPropertyData {
+	name: string;
+	description?: string | MarkupContent;
+	browsers?: string[];
+	restrictions?: string[];
+	status?: EntryStatus;
+	syntax?: string;
+	values?: IValueData[];
+	references?: IReference[];
+	relevance?: number;
+}
+export interface IAtDirectiveData {
+	name: string;
+	description?: string | MarkupContent;
+	browsers?: string[];
+	status?: EntryStatus;
+	references?: IReference[];
+}
+export interface IPseudoClassData {
+	name: string;
+	description?: string | MarkupContent;
+	browsers?: string[];
+	status?: EntryStatus;
+	references?: IReference[];
+}
+export interface IPseudoElementData {
+	name: string;
+	description?: string | MarkupContent;
+	browsers?: string[];
+	status?: EntryStatus;
+	references?: IReference[];
+}
+
+export interface IValueData {
+	name: string;
+	description?: string | MarkupContent;
+	browsers?: string[];
+	status?: EntryStatus;
+	references?: IReference[];
+}
+export interface MarkupContent {
+	kind: MarkupKind;
+	value: string;
+}
+export declare type MarkupKind = 'plaintext' | 'markdown';

package/src/language/css/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 { CSSWorker } from './cssWorker';
+import { editor, IDisposable, Uri } 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<CSSWorker> | null;
+	private _client: Promise<CSSWorker> | 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<CSSWorker> {
+		this._lastUsedTime = Date.now();
+
+		if (!this._client) {
+			this._worker = editor.createWebWorker<CSSWorker>({
+				// module that exports the create() method and returns a `CSSWorker` instance
+				moduleId: 'vs/language/css/cssWorker',
+
+				label: this._defaults.languageId,
+
+				// passed in to the create() method
+				createData: {
+					options: this._defaults.options,
+					languageId: this._defaults.languageId
+				}
+			});
+
+			this._client = <Promise<CSSWorker>>(<any>this._worker.getProxy());
+		}
+
+		return this._client;
+	}
+
+	getLanguageServiceWorker(...resources: Uri[]): Promise<CSSWorker> {
+		let _client: CSSWorker;
+		return this._getClient()
+			.then((client) => {
+				_client = client;
+			})
+			.then((_) => {
+				if (this._worker) {
+					return this._worker.withSyncedResources(resources);
+				}
+			})
+			.then((_) => _client);
+	}
+}

package/src/language/html/html.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 { HTMLWorker } from './htmlWorker';
+
+self.onmessage = () => {
+	// ignore the first message
+	worker.initialize((ctx, createData) => {
+		return new HTMLWorker(ctx, createData);
+	});
+};

package/src/language/html/htmlMode.ts

@@ -0,0 +1,171 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { WorkerManager } from './workerManager';
+import type { HTMLWorker } from './htmlWorker';
+import { LanguageServiceDefaults } from './monaco.contribution';
+import * as languageFeatures from '../common/lspLanguageFeatures';
+import { Uri, IDisposable, languages } from '../../fillers/monaco-editor-core';
+
+class HTMLCompletionAdapter extends languageFeatures.CompletionAdapter<HTMLWorker> {
+	constructor(worker: languageFeatures.WorkerAccessor<HTMLWorker>) {
+		super(worker, ['.', ':', '<', '"', '=', '/']);
+	}
+}
+
+export function setupMode1(defaults: LanguageServiceDefaults): void {
+	const client = new WorkerManager(defaults);
+
+	const worker: languageFeatures.WorkerAccessor<HTMLWorker> = (
+		...uris: Uri[]
+	): Promise<HTMLWorker> => {
+		return client.getLanguageServiceWorker(...uris);
+	};
+
+	let languageId = defaults.languageId;
+
+	// all modes
+	languages.registerCompletionItemProvider(languageId, new HTMLCompletionAdapter(worker));
+	languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker));
+
+	languages.registerDocumentHighlightProvider(
+		languageId,
+		new languageFeatures.DocumentHighlightAdapter(worker)
+	);
+	languages.registerLinkProvider(languageId, new languageFeatures.DocumentLinkAdapter(worker));
+	languages.registerFoldingRangeProvider(
+		languageId,
+		new languageFeatures.FoldingRangeAdapter(worker)
+	);
+	languages.registerDocumentSymbolProvider(
+		languageId,
+		new languageFeatures.DocumentSymbolAdapter(worker)
+	);
+	languages.registerSelectionRangeProvider(
+		languageId,
+		new languageFeatures.SelectionRangeAdapter(worker)
+	);
+	languages.registerRenameProvider(languageId, new languageFeatures.RenameAdapter(worker));
+
+	// only html
+	if (languageId === 'html') {
+		languages.registerDocumentFormattingEditProvider(
+			languageId,
+			new languageFeatures.DocumentFormattingEditProvider(worker)
+		);
+		languages.registerDocumentRangeFormattingEditProvider(
+			languageId,
+			new languageFeatures.DocumentRangeFormattingEditProvider(worker)
+		);
+	}
+}
+
+export function setupMode(defaults: LanguageServiceDefaults): IDisposable {
+	const disposables: IDisposable[] = [];
+	const providers: IDisposable[] = [];
+
+	const client = new WorkerManager(defaults);
+	disposables.push(client);
+
+	const worker: languageFeatures.WorkerAccessor<HTMLWorker> = (
+		...uris: Uri[]
+	): Promise<HTMLWorker> => {
+		return client.getLanguageServiceWorker(...uris);
+	};
+
+	function registerProviders(): void {
+		const { languageId, modeConfiguration } = defaults;
+
+		disposeAll(providers);
+
+		if (modeConfiguration.completionItems) {
+			providers.push(
+				languages.registerCompletionItemProvider(languageId, new HTMLCompletionAdapter(worker))
+			);
+		}
+		if (modeConfiguration.hovers) {
+			providers.push(
+				languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker))
+			);
+		}
+		if (modeConfiguration.documentHighlights) {
+			providers.push(
+				languages.registerDocumentHighlightProvider(
+					languageId,
+					new languageFeatures.DocumentHighlightAdapter(worker)
+				)
+			);
+		}
+		if (modeConfiguration.links) {
+			providers.push(
+				languages.registerLinkProvider(languageId, new languageFeatures.DocumentLinkAdapter(worker))
+			);
+		}
+		if (modeConfiguration.documentSymbols) {
+			providers.push(
+				languages.registerDocumentSymbolProvider(
+					languageId,
+					new languageFeatures.DocumentSymbolAdapter(worker)
+				)
+			);
+		}
+		if (modeConfiguration.rename) {
+			providers.push(
+				languages.registerRenameProvider(languageId, new languageFeatures.RenameAdapter(worker))
+			);
+		}
+		if (modeConfiguration.foldingRanges) {
+			providers.push(
+				languages.registerFoldingRangeProvider(
+					languageId,
+					new languageFeatures.FoldingRangeAdapter(worker)
+				)
+			);
+		}
+		if (modeConfiguration.selectionRanges) {
+			providers.push(
+				languages.registerSelectionRangeProvider(
+					languageId,
+					new languageFeatures.SelectionRangeAdapter(worker)
+				)
+			);
+		}
+		if (modeConfiguration.documentFormattingEdits) {
+			providers.push(
+				languages.registerDocumentFormattingEditProvider(
+					languageId,
+					new languageFeatures.DocumentFormattingEditProvider(worker)
+				)
+			);
+		}
+		if (modeConfiguration.documentRangeFormattingEdits) {
+			providers.push(
+				languages.registerDocumentRangeFormattingEditProvider(
+					languageId,
+					new languageFeatures.DocumentRangeFormattingEditProvider(worker)
+				)
+			);
+		}
+	}
+
+	registerProviders();
+
+	disposables.push(asDisposable(providers));
+
+	return asDisposable(disposables);
+}
+
+function asDisposable(disposables: IDisposable[]): IDisposable {
+	return { dispose: () => disposeAll(disposables) };
+}
+
+function disposeAll(disposables: IDisposable[]) {
+	while (disposables.length) {
+		disposables.pop()!.dispose();
+	}
+}
+
+export { WorkerManager } from './workerManager';
+export * from '../common/lspLanguageFeatures';