@harmoniclabs/monaco-editor 0.52.0

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

@@ -0,0 +1,372 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 './jsonMode';
+import { Emitter, IEvent, languages, Uri } from '../../fillers/monaco-editor-core';
+
+// ---- JSON service types ----
+export interface BaseASTNode {
+	readonly type: 'object' | 'array' | 'property' | 'string' | 'number' | 'boolean' | 'null';
+	readonly parent?: ASTNode;
+	readonly offset: number;
+	readonly length: number;
+	readonly children?: ASTNode[];
+	readonly value?: string | boolean | number | null;
+}
+export interface ObjectASTNode extends BaseASTNode {
+	readonly type: 'object';
+	readonly properties: PropertyASTNode[];
+	readonly children: ASTNode[];
+}
+export interface PropertyASTNode extends BaseASTNode {
+	readonly type: 'property';
+	readonly keyNode: StringASTNode;
+	readonly valueNode?: ASTNode;
+	readonly colonOffset?: number;
+	readonly children: ASTNode[];
+}
+export interface ArrayASTNode extends BaseASTNode {
+	readonly type: 'array';
+	readonly items: ASTNode[];
+	readonly children: ASTNode[];
+}
+export interface StringASTNode extends BaseASTNode {
+	readonly type: 'string';
+	readonly value: string;
+}
+export interface NumberASTNode extends BaseASTNode {
+	readonly type: 'number';
+	readonly value: number;
+	readonly isInteger: boolean;
+}
+export interface BooleanASTNode extends BaseASTNode {
+	readonly type: 'boolean';
+	readonly value: boolean;
+}
+export interface NullASTNode extends BaseASTNode {
+	readonly type: 'null';
+	readonly value: null;
+}
+
+export type ASTNode =
+	| ObjectASTNode
+	| PropertyASTNode
+	| ArrayASTNode
+	| StringASTNode
+	| NumberASTNode
+	| BooleanASTNode
+	| NullASTNode;
+
+export type JSONDocument = {
+	root: ASTNode | undefined;
+	getNodeFromOffset(offset: number, includeRightBound?: boolean): ASTNode | undefined;
+};
+
+export type JSONSchemaRef = JSONSchema | boolean;
+
+export interface JSONSchemaMap {
+	[name: string]: JSONSchemaRef;
+}
+
+export interface JSONSchema {
+	id?: string;
+	$id?: string;
+	$schema?: string;
+	type?: string | string[];
+	title?: string;
+	default?: any;
+	definitions?: {
+		[name: string]: JSONSchema;
+	};
+	description?: string;
+	properties?: JSONSchemaMap;
+	patternProperties?: JSONSchemaMap;
+	additionalProperties?: boolean | JSONSchemaRef;
+	minProperties?: number;
+	maxProperties?: number;
+	dependencies?:
+		| JSONSchemaMap
+		| {
+				[prop: string]: string[];
+		  };
+	items?: JSONSchemaRef | JSONSchemaRef[];
+	minItems?: number;
+	maxItems?: number;
+	uniqueItems?: boolean;
+	additionalItems?: boolean | JSONSchemaRef;
+	pattern?: string;
+	minLength?: number;
+	maxLength?: number;
+	minimum?: number;
+	maximum?: number;
+	exclusiveMinimum?: boolean | number;
+	exclusiveMaximum?: boolean | number;
+	multipleOf?: number;
+	required?: string[];
+	$ref?: string;
+	anyOf?: JSONSchemaRef[];
+	allOf?: JSONSchemaRef[];
+	oneOf?: JSONSchemaRef[];
+	not?: JSONSchemaRef;
+	enum?: any[];
+	format?: string;
+	const?: any;
+	contains?: JSONSchemaRef;
+	propertyNames?: JSONSchemaRef;
+	examples?: any[];
+	$comment?: string;
+	if?: JSONSchemaRef;
+	then?: JSONSchemaRef;
+	else?: JSONSchemaRef;
+	defaultSnippets?: {
+		label?: string;
+		description?: string;
+		markdownDescription?: string;
+		body?: any;
+		bodyText?: string;
+	}[];
+	errorMessage?: string;
+	patternErrorMessage?: string;
+	deprecationMessage?: string;
+	enumDescriptions?: string[];
+	markdownEnumDescriptions?: string[];
+	markdownDescription?: string;
+	doNotSuggest?: boolean;
+	suggestSortText?: string;
+	allowComments?: boolean;
+	allowTrailingCommas?: boolean;
+}
+
+export interface MatchingSchema {
+	node: ASTNode;
+	schema: JSONSchema;
+}
+
+// --- JSON configuration and defaults ---------
+export interface DiagnosticsOptions {
+	/**
+	 * If set, the validator will be enabled and perform syntax and schema based validation,
+	 * unless `DiagnosticsOptions.schemaValidation` is set to `ignore`.
+	 */
+	readonly validate?: boolean;
+	/**
+	 * If set, comments are tolerated. If set to false, syntax errors will be emitted for comments.
+	 * `DiagnosticsOptions.allowComments` will override this setting.
+	 */
+	readonly allowComments?: boolean;
+	/**
+	 * A list of known schemas and/or associations of schemas to file names.
+	 */
+	readonly schemas?: {
+		/**
+		 * The URI of the schema, which is also the identifier of the schema.
+		 */
+		readonly uri: string;
+		/**
+		 * A list of glob patterns that describe for which file URIs the JSON schema will be used.
+		 * '*' and '**' wildcards are supported. Exclusion patterns start with '!'.
+		 * For example '*.schema.json', 'package.json', '!foo*.schema.json', 'foo/**\/BADRESP.json'.
+		 * A match succeeds when there is at least one pattern matching and last matching pattern does not start with '!'.
+		 */
+		readonly fileMatch?: string[];
+		/**
+		 * The schema for the given URI.
+		 */
+		readonly schema?: any;
+	}[];
+	/**
+	 *  If set, the schema service would load schema content on-demand with 'fetch' if available
+	 */
+	readonly enableSchemaRequest?: boolean;
+	/**
+	 * The severity of problems from schema validation. If set to 'ignore', schema validation will be skipped. If not set, 'warning' is used.
+	 */
+	readonly schemaValidation?: SeverityLevel;
+	/**
+	 * The severity of problems that occurred when resolving and loading schemas. If set to 'ignore', schema resolving problems are not reported. If not set, 'warning' is used.
+	 */
+	readonly schemaRequest?: SeverityLevel;
+	/**
+	 * The severity of reported trailing commas. If not set, trailing commas will be reported as errors.
+	 */
+	readonly trailingCommas?: SeverityLevel;
+	/**
+	 * The severity of reported comments. If not set, 'DiagnosticsOptions.allowComments' defines whether comments are ignored or reported as errors.
+	 */
+	readonly comments?: SeverityLevel;
+}
+
+export declare type SeverityLevel = 'error' | 'warning' | 'ignore';
+
+export interface ModeConfiguration {
+	/**
+	 * Defines whether the built-in documentFormattingEdit provider is enabled.
+	 */
+	readonly documentFormattingEdits?: boolean;
+
+	/**
+	 * Defines whether the built-in documentRangeFormattingEdit provider is enabled.
+	 */
+	readonly documentRangeFormattingEdits?: boolean;
+
+	/**
+	 * 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 tokens provider is enabled.
+	 */
+	readonly tokens?: 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;
+}
+
+export interface LanguageServiceDefaults {
+	readonly languageId: string;
+	readonly onDidChange: IEvent<LanguageServiceDefaults>;
+	readonly diagnosticsOptions: DiagnosticsOptions;
+	readonly modeConfiguration: ModeConfiguration;
+	setDiagnosticsOptions(options: DiagnosticsOptions): void;
+	setModeConfiguration(modeConfiguration: ModeConfiguration): void;
+}
+
+class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
+	private _onDidChange = new Emitter<LanguageServiceDefaults>();
+	private _diagnosticsOptions!: DiagnosticsOptions;
+	private _modeConfiguration!: ModeConfiguration;
+	private _languageId: string;
+
+	constructor(
+		languageId: string,
+		diagnosticsOptions: DiagnosticsOptions,
+		modeConfiguration: ModeConfiguration
+	) {
+		this._languageId = languageId;
+		this.setDiagnosticsOptions(diagnosticsOptions);
+		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(): DiagnosticsOptions {
+		return this._diagnosticsOptions;
+	}
+
+	setDiagnosticsOptions(options: DiagnosticsOptions): void {
+		this._diagnosticsOptions = options || Object.create(null);
+		this._onDidChange.fire(this);
+	}
+
+	setModeConfiguration(modeConfiguration: ModeConfiguration): void {
+		this._modeConfiguration = modeConfiguration || Object.create(null);
+		this._onDidChange.fire(this);
+	}
+}
+
+const diagnosticDefault: Required<DiagnosticsOptions> = {
+	validate: true,
+	allowComments: true,
+	schemas: [],
+	enableSchemaRequest: false,
+	schemaRequest: 'warning',
+	schemaValidation: 'warning',
+	comments: 'error',
+	trailingCommas: 'error'
+};
+
+const modeConfigurationDefault: Required<ModeConfiguration> = {
+	documentFormattingEdits: true,
+	documentRangeFormattingEdits: true,
+	completionItems: true,
+	hovers: true,
+	documentSymbols: true,
+	tokens: true,
+	colors: true,
+	foldingRanges: true,
+	diagnostics: true,
+	selectionRanges: true
+};
+
+export const jsonDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl(
+	'json',
+	diagnosticDefault,
+	modeConfigurationDefault
+);
+
+export interface IJSONWorker {
+	parseJSONDocument(uri: string): Promise<JSONDocument | null>;
+	getMatchingSchemas(uri: string): Promise<MatchingSchema[]>;
+}
+
+export const getWorker = (): Promise<(...uris: Uri[]) => Promise<IJSONWorker>> =>
+	getMode().then((mode) => mode.getWorker());
+
+// export to the global based API
+(<any>languages).json = { jsonDefaults, getWorker };
+
+// --- 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/json/jsonMode'], resolve, reject);
+		});
+	} else {
+		return import('./jsonMode');
+	}
+}
+
+languages.register({
+	id: 'json',
+	extensions: ['.json', '.bowerrc', '.jshintrc', '.jscsrc', '.eslintrc', '.babelrc', '.har'],
+	aliases: ['JSON', 'json'],
+	mimetypes: ['application/json']
+});
+
+languages.onLanguage('json', () => {
+	getMode().then((mode) => mode.setupMode(jsonDefaults));
+});

package/src/language/json/tokenization.ts

@@ -0,0 +1,273 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as json from 'jsonc-parser';
+import { languages } from '../../fillers/monaco-editor-core';
+
+export function createTokenizationSupport(supportComments: boolean): languages.TokensProvider {
+	return {
+		getInitialState: () => new JSONState(null, null, false, null),
+		tokenize: (line, state?) => tokenize(supportComments, line, <JSONState>state)
+	};
+}
+
+export const TOKEN_DELIM_OBJECT = 'delimiter.bracket.json';
+export const TOKEN_DELIM_ARRAY = 'delimiter.array.json';
+export const TOKEN_DELIM_COLON = 'delimiter.colon.json';
+export const TOKEN_DELIM_COMMA = 'delimiter.comma.json';
+export const TOKEN_VALUE_BOOLEAN = 'keyword.json';
+export const TOKEN_VALUE_NULL = 'keyword.json';
+export const TOKEN_VALUE_STRING = 'string.value.json';
+export const TOKEN_VALUE_NUMBER = 'number.json';
+export const TOKEN_PROPERTY_NAME = 'string.key.json';
+export const TOKEN_COMMENT_BLOCK = 'comment.block.json';
+export const TOKEN_COMMENT_LINE = 'comment.line.json';
+
+const enum JSONParent {
+	Object = 0,
+	Array = 1
+}
+
+class ParentsStack {
+	constructor(public readonly parent: ParentsStack | null, public readonly type: JSONParent) {}
+
+	public static pop(parents: ParentsStack | null): ParentsStack | null {
+		if (parents) {
+			return parents.parent;
+		}
+		return null;
+	}
+
+	public static push(parents: ParentsStack | null, type: JSONParent): ParentsStack {
+		return new ParentsStack(parents, type);
+	}
+
+	public static equals(a: ParentsStack | null, b: ParentsStack | null): boolean {
+		if (!a && !b) {
+			return true;
+		}
+		if (!a || !b) {
+			return false;
+		}
+		while (a && b) {
+			if (a === b) {
+				return true;
+			}
+			if (a.type !== b.type) {
+				return false;
+			}
+			a = a.parent;
+			b = b.parent;
+		}
+		return true;
+	}
+}
+
+class JSONState implements languages.IState {
+	private _state: languages.IState | null;
+
+	public scanError: ScanError | null;
+	public lastWasColon: boolean;
+	public parents: ParentsStack | null;
+
+	constructor(
+		state: languages.IState | null,
+		scanError: ScanError | null,
+		lastWasColon: boolean,
+		parents: ParentsStack | null
+	) {
+		this._state = state;
+		this.scanError = scanError;
+		this.lastWasColon = lastWasColon;
+		this.parents = parents;
+	}
+
+	public clone(): JSONState {
+		return new JSONState(this._state, this.scanError, this.lastWasColon, this.parents);
+	}
+
+	public equals(other: languages.IState): boolean {
+		if (other === this) {
+			return true;
+		}
+		if (!other || !(other instanceof JSONState)) {
+			return false;
+		}
+		return (
+			this.scanError === other.scanError &&
+			this.lastWasColon === other.lastWasColon &&
+			ParentsStack.equals(this.parents, other.parents)
+		);
+	}
+
+	public getStateData(): languages.IState | null {
+		return this._state;
+	}
+
+	public setStateData(state: languages.IState): void {
+		this._state = state;
+	}
+}
+
+const enum ScanError {
+	None = 0,
+	UnexpectedEndOfComment = 1,
+	UnexpectedEndOfString = 2,
+	UnexpectedEndOfNumber = 3,
+	InvalidUnicode = 4,
+	InvalidEscapeCharacter = 5,
+	InvalidCharacter = 6
+}
+
+const enum SyntaxKind {
+	OpenBraceToken = 1,
+	CloseBraceToken = 2,
+	OpenBracketToken = 3,
+	CloseBracketToken = 4,
+	CommaToken = 5,
+	ColonToken = 6,
+	NullKeyword = 7,
+	TrueKeyword = 8,
+	FalseKeyword = 9,
+	StringLiteral = 10,
+	NumericLiteral = 11,
+	LineCommentTrivia = 12,
+	BlockCommentTrivia = 13,
+	LineBreakTrivia = 14,
+	Trivia = 15,
+	Unknown = 16,
+	EOF = 17
+}
+
+function tokenize(
+	comments: boolean,
+	line: string,
+	state: JSONState,
+	offsetDelta: number = 0
+): languages.ILineTokens {
+	// handle multiline strings and block comments
+	let numberOfInsertedCharacters = 0;
+	let adjustOffset = false;
+
+	switch (state.scanError) {
+		case ScanError.UnexpectedEndOfString:
+			line = '"' + line;
+			numberOfInsertedCharacters = 1;
+			break;
+		case ScanError.UnexpectedEndOfComment:
+			line = '/*' + line;
+			numberOfInsertedCharacters = 2;
+			break;
+	}
+
+	const scanner = json.createScanner(line);
+	let lastWasColon = state.lastWasColon;
+	let parents = state.parents;
+
+	const ret: languages.ILineTokens = {
+		tokens: <languages.IToken[]>[],
+		endState: state.clone()
+	};
+
+	while (true) {
+		let offset = offsetDelta + scanner.getPosition();
+		let type = '';
+
+		const kind = <SyntaxKind>(<any>scanner.scan());
+		if (kind === SyntaxKind.EOF) {
+			break;
+		}
+
+		// Check that the scanner has advanced
+		if (offset === offsetDelta + scanner.getPosition()) {
+			throw new Error(
+				'Scanner did not advance, next 3 characters are: ' + line.substr(scanner.getPosition(), 3)
+			);
+		}
+
+		// In case we inserted /* or " character, we need to
+		// adjust the offset of all tokens (except the first)
+		if (adjustOffset) {
+			offset -= numberOfInsertedCharacters;
+		}
+		adjustOffset = numberOfInsertedCharacters > 0;
+
+		// brackets and type
+		switch (kind) {
+			case SyntaxKind.OpenBraceToken:
+				parents = ParentsStack.push(parents, JSONParent.Object);
+				type = TOKEN_DELIM_OBJECT;
+				lastWasColon = false;
+				break;
+			case SyntaxKind.CloseBraceToken:
+				parents = ParentsStack.pop(parents);
+				type = TOKEN_DELIM_OBJECT;
+				lastWasColon = false;
+				break;
+			case SyntaxKind.OpenBracketToken:
+				parents = ParentsStack.push(parents, JSONParent.Array);
+				type = TOKEN_DELIM_ARRAY;
+				lastWasColon = false;
+				break;
+			case SyntaxKind.CloseBracketToken:
+				parents = ParentsStack.pop(parents);
+				type = TOKEN_DELIM_ARRAY;
+				lastWasColon = false;
+				break;
+			case SyntaxKind.ColonToken:
+				type = TOKEN_DELIM_COLON;
+				lastWasColon = true;
+				break;
+			case SyntaxKind.CommaToken:
+				type = TOKEN_DELIM_COMMA;
+				lastWasColon = false;
+				break;
+			case SyntaxKind.TrueKeyword:
+			case SyntaxKind.FalseKeyword:
+				type = TOKEN_VALUE_BOOLEAN;
+				lastWasColon = false;
+				break;
+			case SyntaxKind.NullKeyword:
+				type = TOKEN_VALUE_NULL;
+				lastWasColon = false;
+				break;
+			case SyntaxKind.StringLiteral:
+				const currentParent = parents ? parents.type : JSONParent.Object;
+				const inArray = currentParent === JSONParent.Array;
+				type = lastWasColon || inArray ? TOKEN_VALUE_STRING : TOKEN_PROPERTY_NAME;
+				lastWasColon = false;
+				break;
+			case SyntaxKind.NumericLiteral:
+				type = TOKEN_VALUE_NUMBER;
+				lastWasColon = false;
+				break;
+		}
+
+		// comments, iff enabled
+		if (comments) {
+			switch (kind) {
+				case SyntaxKind.LineCommentTrivia:
+					type = TOKEN_COMMENT_LINE;
+					break;
+				case SyntaxKind.BlockCommentTrivia:
+					type = TOKEN_COMMENT_BLOCK;
+					break;
+			}
+		}
+
+		ret.endState = new JSONState(
+			state.getStateData(),
+			<ScanError>(<any>scanner.getTokenError()),
+			lastWasColon,
+			parents
+		);
+		ret.tokens.push({
+			startIndex: offset,
+			scopes: type
+		});
+	}
+
+	return ret;
+}