daohualiuxiang
/
monaco-editor
mirror of https://github.com/microsoft/monaco-editor.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Export apis

pull/2748/head
Alex Dima 2016-06-16 11:54:41 +02:00
parent 83339b4d97
commit 73295879a4
8 changed files with 256 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gulpfile.js
View File

@ -47,6 +47,7 @@ gulp.task('release', ['clean-release','compile'], function() {
}
return merge(
merge(
bundleOne('src/monaco.contribution'),
bundleOne('lib/typescriptServices'),
bundleOne('src/mode', ['vs/language/typescript/lib/typescriptServices']),
@ -62,7 +63,10 @@ gulp.task('release', ['clean-release','compile'], function() {
);
this.emit('data', data);
}))
.pipe(gulp.dest('./release/'));
.pipe(gulp.dest('./release/')),
gulp.src('src/monaco.d.ts').pipe(gulp.dest('./release/'))
);
});

4
src/languageFeatures.ts
View File

@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
import {LanguageServiceDefaults} from './typescript';
import {LanguageServiceDefaultsImpl} from './monaco.contribution';
import * as ts from '../lib/typescriptServices';
import {TypeScriptWorker} from './worker';
@ -47,7 +47,7 @@ export class DiagnostcsAdapter extends Adapter {
private _disposables: IDisposable[] = [];
private _listener: { [uri: string]: IDisposable } = Object.create(null);
constructor(private _defaults: LanguageServiceDefaults, private _selector: string,
constructor(private _defaults: LanguageServiceDefaultsImpl, private _selector: string,
worker: (first: Uri, ...more: Uri[]) => Promise<TypeScriptWorker>
) {
super(worker);

12
src/mode.ts
View File

@ -5,32 +5,32 @@
'use strict';
import {Language, createTokenizationSupport} from './tokenization';
import {LanguageServiceDefaults, typeScriptDefaults, javaScriptDefaults, LanguageServiceMode} from './typescript';
import {WorkerManager} from './workerManager';
import {TypeScriptWorker} from './worker';
import {LanguageServiceDefaultsImpl} from './monaco.contribution';
import * as languageFeatures from './languageFeatures';
import Promise = monaco.Promise;
import Uri = monaco.Uri;
import IDisposable = monaco.IDisposable;
export function setupTypeScript(): void {
export function setupTypeScript(defaults:LanguageServiceDefaultsImpl): void {
setupMode(
typeScriptDefaults,
defaults,
'typescript',
Language.TypeScript
);
}
export function setupJavaScript(): void {
export function setupJavaScript(defaults:LanguageServiceDefaultsImpl): void {
setupMode(
javaScriptDefaults,
defaults,
'javascript',
Language.EcmaScript5
);
}
function setupMode(defaults:LanguageServiceDefaults, modeId:string, language:Language): void {
function setupMode(defaults:LanguageServiceDefaultsImpl, modeId:string, language:Language): void {
let disposables: IDisposable[] = [];

132
src/monaco.contribution.ts
View File

@ -6,8 +6,136 @@
import * as mode from './mode';
import Emitter = monaco.Emitter;
import IEvent = monaco.IEvent;
import IDisposable = monaco.IDisposable;
declare var require:<T>(moduleId:[string], callback:(module:T)=>void)=>void;
// --- TypeScript configuration and defaults ---------
export class LanguageServiceDefaultsImpl implements monaco.languages.typescript.LanguageServiceDefaults {
private _onDidChange = new Emitter<monaco.languages.typescript.LanguageServiceDefaults>();
private _extraLibs: { [path: string]: string };
private _compilerOptions: monaco.languages.typescript.CompilerOptions;
private _diagnosticsOptions: monaco.languages.typescript.DiagnosticsOptions;
constructor(compilerOptions: monaco.languages.typescript.CompilerOptions, diagnosticsOptions: monaco.languages.typescript.DiagnosticsOptions) {
this._extraLibs = Object.create(null);
this.setCompilerOptions(compilerOptions);
this.setDiagnosticsOptions(diagnosticsOptions);
}
get onDidChange(): IEvent<monaco.languages.typescript.LanguageServiceDefaults>{
return this._onDidChange.event;
}
get extraLibs(): { [path: string]: string; } {
return Object.freeze(this._extraLibs);
}
addExtraLib(content: string, filePath?: string): IDisposable {
if (typeof filePath === 'undefined') {
filePath = `ts:extralib-${Date.now()}`;
}
if (this._extraLibs[filePath]) {
throw new Error(`${filePath} already a extra lib`);
}
this._extraLibs[filePath] = content;
this._onDidChange.fire(this);
return {
dispose: () => {
if (delete this._extraLibs[filePath]) {
this._onDidChange.fire(this);
}
}
};
}
get compilerOptions(): monaco.languages.typescript.CompilerOptions {
return this._compilerOptions;
}
setCompilerOptions(options: monaco.languages.typescript.CompilerOptions): void {
this._compilerOptions = options || Object.create(null);
this._onDidChange.fire(this);
}
get diagnosticsOptions(): monaco.languages.typescript.DiagnosticsOptions {
return this._diagnosticsOptions;
}
setDiagnosticsOptions(options: monaco.languages.typescript.DiagnosticsOptions): void {
this._diagnosticsOptions = options || Object.create(null);
this._onDidChange.fire(this);
}
}
// --- BEGIN enums copied from typescript to prevent loading the entire typescriptServices ---
enum ModuleKind {
None = 0,
CommonJS = 1,
AMD = 2,
UMD = 3,
System = 4,
ES6 = 5,
ES2015 = 5,
}
enum JsxEmit {
None = 0,
Preserve = 1,
React = 2,
}
enum NewLineKind {
CarriageReturnLineFeed = 0,
LineFeed = 1,
}
enum ScriptTarget {
ES3 = 0,
ES5 = 1,
ES6 = 2,
ES2015 = 2,
Latest = 2,
}
enum ModuleResolutionKind {
Classic = 1,
NodeJs = 2,
}
// --- END enums copied from typescript to prevent loading the entire typescriptServices ---
const typescriptDefaults = new LanguageServiceDefaultsImpl(
{ allowNonTsExtensions: true, target: ScriptTarget.Latest },
{ noSemanticValidation: false, noSyntaxValidation: false });
const javascriptDefaults = new LanguageServiceDefaultsImpl(
{ allowNonTsExtensions: true, allowJs: true, target: ScriptTarget.Latest },
{ noSemanticValidation: true, noSyntaxValidation: false });
function createAPI(): typeof monaco.languages.typescript {
return {
ModuleKind: ModuleKind,
JsxEmit: JsxEmit,
NewLineKind: NewLineKind,
ScriptTarget: ScriptTarget,
ModuleResolutionKind: ModuleResolutionKind,
typescriptDefaults: typescriptDefaults,
javascriptDefaults: javascriptDefaults
}
}
// --- Registration to monaco editor ---
function withMode(callback:(module:typeof mode)=>void): void {
require<typeof mode>(['vs/language/typescript/src/mode'], callback);
}
@ -19,7 +147,7 @@ monaco.languages.register({
mimetypes: ['text/typescript']
});
monaco.languages.onLanguage('typescript', () => {
withMode((mode) => mode.setupTypeScript());
withMode((mode) => mode.setupTypeScript(typescriptDefaults));
});
monaco.languages.register({
@ -31,5 +159,5 @@ monaco.languages.register({
mimetypes: ['text/javascript'],
});
monaco.languages.onLanguage('javascript', () => {
withMode((mode) => mode.setupJavaScript());
withMode((mode) => mode.setupJavaScript(javascriptDefaults));
});

109
src/monaco.d.ts vendored 100644
View File

@ -0,0 +1,109 @@
declare module monaco.languages.typescript {
export enum ModuleKind {
None = 0,
CommonJS = 1,
AMD = 2,
UMD = 3,
System = 4,
ES6 = 5,
ES2015 = 5,
}
export enum JsxEmit {
None = 0,
Preserve = 1,
React = 2,
}
export enum NewLineKind {
CarriageReturnLineFeed = 0,
LineFeed = 1,
}
export enum ScriptTarget {
ES3 = 0,
ES5 = 1,
ES6 = 2,
ES2015 = 2,
Latest = 2,
}
export enum ModuleResolutionKind {
Classic = 1,
NodeJs = 2,
}
interface CompilerOptions {
allowNonTsExtensions?: boolean;
charset?: string;
declaration?: boolean;
diagnostics?: boolean;
emitBOM?: boolean;
help?: boolean;
init?: boolean;
inlineSourceMap?: boolean;
inlineSources?: boolean;
jsx?: JsxEmit;
reactNamespace?: string;
listFiles?: boolean;
locale?: string;
mapRoot?: string;
module?: ModuleKind;
newLine?: NewLineKind;
noEmit?: boolean;
noEmitHelpers?: boolean;
noEmitOnError?: boolean;
noErrorTruncation?: boolean;
noImplicitAny?: boolean;
noLib?: boolean;
noResolve?: boolean;
out?: string;
outFile?: string;
outDir?: string;
preserveConstEnums?: boolean;
project?: string;
removeComments?: boolean;
rootDir?: string;
sourceMap?: boolean;
sourceRoot?: string;
suppressExcessPropertyErrors?: boolean;
suppressImplicitAnyIndexErrors?: boolean;
target?: ScriptTarget;
version?: boolean;
watch?: boolean;
isolatedModules?: boolean;
experimentalDecorators?: boolean;
emitDecoratorMetadata?: boolean;
moduleResolution?: ModuleResolutionKind;
allowUnusedLabels?: boolean;
allowUnreachableCode?: boolean;
noImplicitReturns?: boolean;
noFallthroughCasesInSwitch?: boolean;
forceConsistentCasingInFileNames?: boolean;
allowSyntheticDefaultImports?: boolean;
allowJs?: boolean;
noImplicitUseStrict?: boolean;
disableSizeLimit?: boolean;
[option: string]: string | number | boolean;
}
export interface DiagnosticsOptions {
noSemanticValidation?: boolean;
noSyntaxValidation?: boolean;
}
export interface LanguageServiceDefaults {
onDidChange: IEvent<LanguageServiceDefaults>;
extraLibs: { [path:string]: string; };
addExtraLib(content: string, filePath?: string): IDisposable;
compilerOptions: CompilerOptions;
setCompilerOptions(options: CompilerOptions): void;
diagnosticsOptions: DiagnosticsOptions;
setDiagnosticsOptions(options: DiagnosticsOptions): void;
}
export var typescriptDefaults: LanguageServiceDefaults;
export var javascriptDefaults: LanguageServiceDefaults;
}

96
src/typescript.ts
View File

@ -1,96 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as ts from '../lib/typescriptServices';
import {TypeScriptWorker} from './worker';
import Emitter = monaco.Emitter;
import Promise = monaco.Promise;
import Uri = monaco.Uri;
import IDisposable = monaco.IDisposable;
// --- TypeScript configuration and defaults ---------
export interface DiagnosticsOptions {
noSemanticValidation?: boolean;
noSyntaxValidation?: boolean;
}
export class LanguageServiceDefaults {
private _onDidChange = new Emitter<LanguageServiceDefaults>();
private _extraLibs: { [path: string]: string };
private _compilerOptions: ts.CompilerOptions;
private _diagnosticsOptions: DiagnosticsOptions;
constructor(compilerOptions: ts.CompilerOptions, diagnosticsOptions: DiagnosticsOptions) {
this._extraLibs = Object.create(null);
this.setCompilerOptions(compilerOptions);
this.setDiagnosticsOptions(diagnosticsOptions);
}
get onDidChange(): monaco.IEvent<LanguageServiceDefaults>{
return this._onDidChange.event;
}
get extraLibs(): { [path: string]: string } {
return Object.freeze(this._extraLibs);
}
addExtraLib(content: string, filePath?: string): IDisposable {
if (typeof filePath === 'undefined') {
filePath = `ts:extralib-${Date.now()}`;
}
if (this._extraLibs[filePath]) {
throw new Error(`${filePath} already a extra lib`);
}
this._extraLibs[filePath] = content;
this._onDidChange.fire(this);
return {
dispose: () => {
if (delete this._extraLibs[filePath]) {
this._onDidChange.fire(this);
}
}
};
}
get compilerOptions(): ts.CompilerOptions {
return this._compilerOptions;
}
setCompilerOptions(options: ts.CompilerOptions): void {
this._compilerOptions = options || Object.create(null);
this._onDidChange.fire(this);
}
get diagnosticsOptions(): DiagnosticsOptions {
return this._diagnosticsOptions;
}
setDiagnosticsOptions(options: DiagnosticsOptions): void {
this._diagnosticsOptions = options || Object.create(null);
this._onDidChange.fire(this);
}
}
export const typeScriptDefaults = new LanguageServiceDefaults(
{ allowNonTsExtensions: true, target: ts.ScriptTarget.Latest },
{ noSemanticValidation: false, noSyntaxValidation: false });
export const javaScriptDefaults = new LanguageServiceDefaults(
{ allowNonTsExtensions: true, allowJs: true, target: ts.ScriptTarget.Latest },
{ noSemanticValidation: true, noSyntaxValidation: false });
// --- TypeScript worker protocol ---------
export interface LanguageServiceMode {
getLanguageServiceWorker(...resources: Uri[]): Promise<TypeScriptWorker>;
}

6
src/workerManager.ts
View File

@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
import {LanguageServiceMode, LanguageServiceDefaults} from './typescript';
import {LanguageServiceDefaultsImpl} from './monaco.contribution';
import {TypeScriptWorker} from './worker';
import Promise = monaco.Promise;
@ -15,7 +15,7 @@ const STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min
export class WorkerManager {
private _defaults: LanguageServiceDefaults;
private _defaults: LanguageServiceDefaultsImpl;
private _idleCheckInterval: number;
private _lastUsedTime: number;
private _configChangeListener: IDisposable;
@ -23,7 +23,7 @@ export class WorkerManager {
private _worker: monaco.editor.MonacoWebWorker<TypeScriptWorker>;
private _client: Promise<TypeScriptWorker>;
constructor(defaults: LanguageServiceDefaults) {
constructor(defaults: LanguageServiceDefaultsImpl) {
this._defaults = defaults;
this._worker = null;
this._idleCheckInterval = setInterval(() => this._checkIfIdle(), 30 * 1000);

1
tsconfig.json
View File

@ -14,6 +14,7 @@
"src/languageFeatures.ts",
"src/mode.ts",
"src/monaco.contribution.ts",
"src/monaco.d.ts",
"src/tokenization.ts",
"src/typescript.ts",
"src/worker.ts",