SystemSh0cker/monaco-editor
1
0
Fork 0
mirror of https://github.com/microsoft/monaco-editor.git synced 2025-12-22 11:35:40 +01:00
Code Issues Projects Releases Packages Activity

Changes for PR #30

Browse source
This commit is contained in:
Alex Dima 2019-03-04 15:09:02 +01:00
parent 6c73d7f708
commit 6b2271c1c1
9 changed files with 128 additions and 181 deletions
Download patch file Download diff file Expand all files Collapse all files

12
scripts/bundle.js
View file

@ -29,8 +29,6 @@ bundleOne('monaco.contribution');
bundleOne('tsMode');
bundleOne('tsWorker');
updateImports('monaco.contribution');
function bundleOne(moduleId, exclude) {
requirejs.optimize({
baseUrl: 'release/dev/',
@ -38,8 +36,7 @@ function bundleOne(moduleId, exclude) {
out: 'release/min/' + moduleId + '.js',
exclude: exclude,
paths: {
'vs/language/typescript': REPO_ROOT + '/release/dev',
'vs/basic-languages': REPO_ROOT + '/node_modules/monaco-languages/release/dev'
'vs/language/typescript': REPO_ROOT + '/release/dev'
},
optimize: 'none'
}, function(buildResponse) {
@ -56,10 +53,3 @@ function bundleOne(moduleId, exclude) {
fs.writeFileSync(filePath, BUNDLED_FILE_HEADER + result.code);
})
}
function updateImports(moduleId) {
const filePath = path.join(REPO_ROOT, 'release/esm/' + moduleId + '.js');
let fileContents = fs.readFileSync(filePath).toString();
fileContents = fileContents.replace(/vs\/basic-languages\//g, "../../basic-languages/");
fs.writeFileSync(filePath, fileContents);
}

7
src/languageFeatures.ts
View file

@ -134,15 +134,16 @@ export class DiagnostcsAdapter extends Adapter {
}
}
});
const redoDiagosticsCallback = () => {
const recomputeDiagostics = () => {
// redo diagnostics when options change
for (const model of monaco.editor.getModels()) {
onModelRemoved(model);
onModelAdd(model);
}
};
this._disposables.push(this._defaults.onDidChange(redoDiagosticsCallback));
this._disposables.push(this._defaults.onDidExtraLibsChange(redoDiagosticsCallback));
this._disposables.push(this._defaults.onDidChange(recomputeDiagostics));
this._disposables.push(this._defaults.onDidExtraLibsChange(recomputeDiagostics));
monaco.editor.getModels().forEach(onModelAdd);
}

193
src/monaco.contribution.ts
View file

@ -5,8 +5,6 @@
'use strict';
import * as mode from './tsMode';
import * as tsDefinitions from 'vs/basic-languages/typescript/typescript';
import * as jsDefinitions from 'vs/basic-languages/javascript/javascript';
import Emitter = monaco.Emitter;
import IEvent = monaco.IEvent;
@ -14,41 +12,45 @@ import IDisposable = monaco.IDisposable;
// --- TypeScript configuration and defaults ---------
export interface IExtraLib {
content: string;
version: number;
}
export interface IExtraLibs {
[path: string]: IExtraLib;
}
export class LanguageServiceDefaultsImpl implements monaco.languages.typescript.LanguageServiceDefaults {
private _onDidChange = new Emitter<monaco.languages.typescript.LanguageServiceDefaults>();
private _onDidExtraLibsChange = new Emitter<monaco.languages.typescript.LanguageServiceDefaults>();
private _onDidChange = new Emitter<void>();
private _onDidExtraLibsChange = new Emitter<void>();
private _extraLibs: { [path: string]: { content: string, version: number } };
private _extraLibs: IExtraLibs;
private _workerMaxIdleTime: number;
private _eagerModelSync: boolean;
private _compilerOptions: monaco.languages.typescript.CompilerOptions;
private _diagnosticsOptions: monaco.languages.typescript.DiagnosticsOptions;
private _languageId: string;
private _eagerExtraLibSync: boolean = true;
private _onDidExtraLibsChangeTimeout: number;
constructor(languageId: string, compilerOptions: monaco.languages.typescript.CompilerOptions, diagnosticsOptions: monaco.languages.typescript.DiagnosticsOptions) {
constructor(compilerOptions: monaco.languages.typescript.CompilerOptions, diagnosticsOptions: monaco.languages.typescript.DiagnosticsOptions) {
this._extraLibs = Object.create(null);
this._workerMaxIdleTime = 2 * 60 * 1000;
this.setCompilerOptions(compilerOptions);
this.setDiagnosticsOptions(diagnosticsOptions);
this._languageId = languageId;
this._onDidExtraLibsChangeTimeout = -1;
}
get onDidChange(): IEvent<monaco.languages.typescript.LanguageServiceDefaults> {
get onDidChange(): IEvent<void> {
return this._onDidChange.event;
}
get onDidExtraLibsChange(): IEvent<monaco.languages.typescript.LanguageServiceDefaults> {
get onDidExtraLibsChange(): IEvent<void> {
return this._onDidExtraLibsChange.event;
}
getExtraLibs(): { [path: string]: string; } {
const result = Object.create(null);
for (var key in this._extraLibs) {
result[key] = this._extraLibs[key];
}
return Object.freeze(result);
getExtraLibs(): IExtraLibs {
return this._extraLibs;
}
addExtraLib(content: string, filePath?: string): IDisposable {
@ -56,49 +58,49 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.typescript.
filePath = `ts:extralib-${Date.now()}`;
}
if (this._extraLibs[filePath]) {
if(this._extraLibs[filePath].content !== content) {
this._extraLibs[filePath].version++;
this._extraLibs[filePath].content = content;
}
} else {
this._extraLibs[filePath] = {
content: content,
version: 1,
if (this._extraLibs[filePath] && this._extraLibs[filePath].content === content) {
// no-op, there already exists an extra lib with this content
return {
dispose: () => { }
};
}
if (this._eagerExtraLibSync) {
this.syncExtraLibs();
let myVersion = 1;
if (this._extraLibs[filePath]) {
myVersion = this._extraLibs[filePath].version + 1;
}
this._extraLibs[filePath] = {
content: content,
version: myVersion,
};
this._fireOnDidExtraLibsChangeSoon();
return {
dispose: () => {
if (delete this._extraLibs[filePath] && this._eagerExtraLibSync) {
this.syncExtraLibs();
let extraLib = this._extraLibs[filePath];
if (!extraLib) {
return;
}
if (extraLib.version !== myVersion) {
return;
}
delete this._extraLibs[filePath];
this._fireOnDidExtraLibsChangeSoon();
}
};
}
async syncExtraLibs(): Promise<void> {
try {
let worker;
try {
// we don't care if the get language worker fails.
// This happens if addExtraLib is called before the worker has initialized.
// however, when the worker has finished downloading and initializes,
// it does so with the latest extraLibs so no sync issue can appear
worker = await getLanguageWorker(this._languageId);
} catch (ignored) {
return;
}
const client = await worker("");
client.syncExtraLibs(this._extraLibs);
// let all listeners know that the extra libs have changed
this._onDidExtraLibsChange.fire(this);
} catch (error) {
console.error(error);
private _fireOnDidExtraLibsChangeSoon(): void {
if (this._onDidExtraLibsChangeTimeout !== -1) {
// already scheduled
return;
}
this._onDidExtraLibsChangeTimeout = setTimeout(() => {
this._onDidExtraLibsChangeTimeout = -1;
this._onDidExtraLibsChange.fire(undefined);
}, 0);
}
getCompilerOptions(): monaco.languages.typescript.CompilerOptions {
@ -107,7 +109,7 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.typescript.
setCompilerOptions(options: monaco.languages.typescript.CompilerOptions): void {
this._compilerOptions = options || Object.create(null);
this._onDidChange.fire(this);
this._onDidChange.fire(undefined);
}
getDiagnosticsOptions(): monaco.languages.typescript.DiagnosticsOptions {
@ -116,7 +118,7 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.typescript.
setDiagnosticsOptions(options: monaco.languages.typescript.DiagnosticsOptions): void {
this._diagnosticsOptions = options || Object.create(null);
this._onDidChange.fire(this);
this._onDidChange.fire(undefined);
}
setMaximumWorkerIdleTime(value: number): void {
@ -138,10 +140,6 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.typescript.
getEagerModelSync() {
return this._eagerModelSync;
}
setEagerExtraLibSync(value: boolean) {
this._eagerExtraLibSync = value;
}
}
//#region enums copied from typescript to prevent loading the entire typescriptServices ---
@ -182,75 +180,20 @@ enum ModuleResolutionKind {
}
//#endregion
const languageDefaultOptions = {
javascript: {
compilerOptions: { allowNonTsExtensions: true, allowJs: true, target: ScriptTarget.Latest },
diagnosticsOptions: { noSemanticValidation: true, noSyntaxValidation: false },
},
typescript: {
compilerOptions: { allowNonTsExtensions: true, target: ScriptTarget.Latest },
diagnosticsOptions: { noSemanticValidation: false, noSyntaxValidation: false }
}
}
const typescriptDefaults = new LanguageServiceDefaultsImpl(
{ allowNonTsExtensions: true, target: ScriptTarget.Latest },
{ noSemanticValidation: false, noSyntaxValidation: false });
const languageDefaults: { [name: string]: LanguageServiceDefaultsImpl } = {};
/**
* Generate the LanguageServiceDefaults for a new langauage with the given name
* @param languageId Name of the language
* @param isTypescriptBased Whether the language inherits from a typescript base or a javascript one
*/
function setupLanguageServiceDefaults(languageId: string, isTypescriptBased: boolean) {
const languageOptions = isTypescriptBased ? languageDefaultOptions.typescript : languageDefaultOptions.javascript;
languageDefaults[languageId] = new LanguageServiceDefaultsImpl(languageId, languageOptions.compilerOptions, languageOptions.diagnosticsOptions);
}
setupNamedLanguage({
id: 'typescript',
extensions: ['.ts', '.tsx'],
aliases: ['TypeScript', 'ts', 'typescript'],
mimetypes: ['text/typescript']
}, true, true);
setupNamedLanguage({
id: 'javascript',
extensions: ['.js', '.es6', '.jsx'],
firstLine: '^#!.*\\bnode',
filenames: ['jakefile'],
aliases: ['JavaScript', 'javascript', 'js'],
mimetypes: ['text/javascript'],
}, false, true);
const javascriptDefaults = new LanguageServiceDefaultsImpl(
{ allowNonTsExtensions: true, allowJs: true, target: ScriptTarget.Latest },
{ noSemanticValidation: true, noSyntaxValidation: false });
function getTypeScriptWorker(): Promise<any> {
return getLanguageWorker("typescript");
return getMode().then(mode => mode.getTypeScriptWorker());
}
function getJavaScriptWorker(): Promise<any> {
return getLanguageWorker("javascript");
}
function getLanguageWorker(languageName: string): Promise<any> {
return getMode().then(mode => mode.getNamedLanguageWorker(languageName));
}
function getLanguageDefaults(languageName: string): LanguageServiceDefaultsImpl {
return languageDefaults[languageName];
}
function setupNamedLanguage(languageDefinition: monaco.languages.ILanguageExtensionPoint, isTypescript: boolean, registerLanguage?: boolean): void {
if (registerLanguage) {
monaco.languages.register(languageDefinition);
const langageConfig = isTypescript ? tsDefinitions : jsDefinitions;
monaco.languages.setMonarchTokensProvider(languageDefinition.id, langageConfig.language);
monaco.languages.setLanguageConfiguration(languageDefinition.id, langageConfig.conf);
}
setupLanguageServiceDefaults(languageDefinition.id, isTypescript);
monaco.languages.onLanguage(languageDefinition.id, () => {
return getMode().then(mode => mode.setupNamedLanguage(languageDefinition.id, isTypescript, languageDefaults[languageDefinition.id]));
});
return getMode().then(mode => mode.getJavaScriptWorker());
}
// Export API
@ -261,13 +204,10 @@ function createAPI(): typeof monaco.languages.typescript {
NewLineKind: NewLineKind,
ScriptTarget: ScriptTarget,
ModuleResolutionKind: ModuleResolutionKind,
typescriptDefaults: getLanguageDefaults("typescript"),
javascriptDefaults: getLanguageDefaults("javascript"),
getLanguageDefaults: getLanguageDefaults,
typescriptDefaults: typescriptDefaults,
javascriptDefaults: javascriptDefaults,
getTypeScriptWorker: getTypeScriptWorker,
getJavaScriptWorker: getJavaScriptWorker,
getLanguageWorker: getLanguageWorker,
setupNamedLanguage: setupNamedLanguage
getJavaScriptWorker: getJavaScriptWorker
}
}
monaco.languages.typescript = createAPI();
@ -277,3 +217,10 @@ monaco.languages.typescript = createAPI();
function getMode(): Promise<typeof mode> {
return import('./tsMode');
}
monaco.languages.onLanguage('typescript', () => {
return getMode().then(mode => mode.setupTypeScript(typescriptDefaults));
});
monaco.languages.onLanguage('javascript', () => {
return getMode().then(mode => mode.setupJavaScript(javascriptDefaults));
});

15
src/monaco.d.ts vendored
View file

@ -164,17 +164,6 @@ declare module monaco.languages.typescript {
* to the worker on start or restart.
*/
setEagerModelSync(value: boolean): void;
/**
* Configure if the extra libs should be eagerly synced after each addExtraLibCall.
* This is true by default
*/
setEagerExtraLibSync(value: boolean): void;
/**
* If EagerExtraLibSync is disabled, call this to trigger the changes.
*/
syncExtraLibs(): Promise<void>;
}
export var typescriptDefaults: LanguageServiceDefaults;
@ -182,8 +171,4 @@ declare module monaco.languages.typescript {
export var getTypeScriptWorker: () => Promise<any>;
export var getJavaScriptWorker: () => Promise<any>;
export var getLanguageWorker: (langaugeName: string) => Promise<any>;
export var setupNamedLanguage: (languageDefinition: languages.ILanguageExtensionPoint, isTypescript: boolean, registerLanguage?: boolean) => void;
export var getLanguageDefaults: (languageName: string) => LanguageServiceDefaults;
}

35
src/tsMode.ts
View file

@ -11,23 +11,40 @@ import * as languageFeatures from './languageFeatures';
import Uri = monaco.Uri;
let scriptWorkerMap: { [name: string]: (first: Uri, ...more: Uri[]) => Promise<TypeScriptWorker> } = {};
let javaScriptWorker: (first: Uri, ...more: Uri[]) => Promise<TypeScriptWorker>;
let typeScriptWorker: (first: Uri, ...more: Uri[]) => Promise<TypeScriptWorker>;
export function setupNamedLanguage(languageName: string, isTypescript: boolean, defaults: LanguageServiceDefaultsImpl): void {
scriptWorkerMap[languageName + "Worker"] = setupMode(
export function setupTypeScript(defaults: LanguageServiceDefaultsImpl): void {
typeScriptWorker = setupMode(
defaults,
languageName
'typescript'
);
}
export function getNamedLanguageWorker(languageName: string): Promise<(first: Uri, ...more: Uri[]) => Promise<TypeScriptWorker>> {
let workerName = languageName + "Worker";
export function setupJavaScript(defaults: LanguageServiceDefaultsImpl): void {
javaScriptWorker = setupMode(
defaults,
'javascript'
);
}
export function getJavaScriptWorker(): Promise<(first: Uri, ...more: Uri[]) => Promise<TypeScriptWorker>> {
return new Promise((resolve, reject) => {
if (!scriptWorkerMap[workerName]) {
return reject(languageName + " not registered!");
if (!javaScriptWorker) {
return reject("JavaScript not registered!");
}
resolve(scriptWorkerMap[workerName]);
resolve(javaScriptWorker);
});
}
export function getTypeScriptWorker(): Promise<(first: Uri, ...more: Uri[]) => Promise<TypeScriptWorker>> {
return new Promise((resolve, reject) => {
if (!typeScriptWorker) {
return reject("TypeScript not registered!");
}
resolve(typeScriptWorker);
});
}

13
src/tsWorker.ts
View file

@ -6,6 +6,7 @@
import * as ts from './lib/typescriptServices';
import { lib_dts, lib_es6_dts } from './lib/lib';
import { IExtraLibs } from './monaco.contribution';
import IWorkerContext = monaco.worker.IWorkerContext;
@ -24,7 +25,7 @@ export class TypeScriptWorker implements ts.LanguageServiceHost {
// --- model sync -----------------------
private _ctx: IWorkerContext;
private _extraLibs: { [path: string]: { content: string, version: number } } = Object.create(null);
private _extraLibs: IExtraLibs = Object.create(null);
private _languageService = ts.createLanguageService(this);
private _compilerOptions: ts.CompilerOptions;
@ -62,8 +63,8 @@ export class TypeScriptWorker implements ts.LanguageServiceHost {
} else if (this.isDefaultLibFileName(fileName)) {
// default lib is static
return '1';
} else if(fileName in this._extraLibs) {
return this._extraLibs[fileName].version.toString();
} else if (fileName in this._extraLibs) {
return String(this._extraLibs[fileName].version);
}
}
@ -75,7 +76,7 @@ export class TypeScriptWorker implements ts.LanguageServiceHost {
text = model.getValue();
} else if (fileName in this._extraLibs) {
// static extra lib
// extra lib
text = this._extraLibs[fileName].content;
} else if (fileName === DEFAULT_LIB.NAME) {
@ -199,14 +200,14 @@ export class TypeScriptWorker implements ts.LanguageServiceHost {
return Promise.resolve(this._languageService.getEmitOutput(fileName));
}
syncExtraLibs(extraLibs: { [path: string]: { content: string, version: number } }) {
updateExtraLibs(extraLibs: IExtraLibs) {
this._extraLibs = extraLibs;
}
}
export interface ICreateData {
compilerOptions: ts.CompilerOptions;
extraLibs: { [path: string]: { content: string, version: number } };
extraLibs: IExtraLibs;
}
export function create(ctx: IWorkerContext, createData: ICreateData): TypeScriptWorker {

8
src/tsconfig.esm.json
View file

@ -9,13 +9,7 @@
"es5",
"es2015.collection",
"es2015.promise"
],
"baseUrl": "",
"paths": {
"vs/basic-languages/*": [
"../node_modules/monaco-languages/release/esm/*"
]
},
]
},
"include": [
"**/*.ts"

8
src/tsconfig.json
View file

@ -9,13 +9,7 @@
"es5",
"es2015.collection",
"es2015.promise"
],
"baseUrl": "",
"paths": {
"vs/basic-languages/*": [
"../node_modules/monaco-languages/release/dev/*"
]
},
]
},
"include": [
"**/*.ts"

18
src/workerManager.ts
View file

@ -17,6 +17,8 @@ export class WorkerManager {
private _idleCheckInterval: number;
private _lastUsedTime: number;
private _configChangeListener: IDisposable;
private _updateExtraLibsToken: number;
private _extraLibsChangeListener: IDisposable;
private _worker: monaco.editor.MonacoWebWorker<TypeScriptWorker>;
private _client: Promise<TypeScriptWorker>;
@ -28,6 +30,8 @@ export class WorkerManager {
this._idleCheckInterval = setInterval(() => this._checkIfIdle(), 30 * 1000);
this._lastUsedTime = 0;
this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker());
this._updateExtraLibsToken = 0;
this._extraLibsChangeListener = this._defaults.onDidExtraLibsChange(() => this._updateExtraLibs());
}
private _stopWorker(): void {
@ -41,9 +45,23 @@ export class WorkerManager {
dispose(): void {
clearInterval(this._idleCheckInterval);
this._configChangeListener.dispose();
this._extraLibsChangeListener.dispose();
this._stopWorker();
}
private async _updateExtraLibs(): Promise<void> {
if (!this._worker) {
return;
}
const myToken = ++this._updateExtraLibsToken;
const proxy = await this._worker.getProxy();
if (this._updateExtraLibsToken !== myToken) {
// avoid multiple calls
return;
}
proxy.updateExtraLibs(this._defaults.getExtraLibs());
}
private _checkIfIdle(): void {
if (!this._worker) {
return;