microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-15 11:35:42 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Update LKG

Browse Source
This commit is contained in:
Mohamed Hegazy 2016-11-03 14:51:12 -07:00
parent 17735cd2e5
commit dbf69b7873
7 changed files with 246 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/tsc.js
View File

@ -37138,7 +37138,7 @@ var ts;
})(ts || (ts = {}));
var ts;
(function (ts) {
ts.version = "2.0.6";
ts.version = "2.0.7";
var emptyArray = [];
function findConfigFile(searchPath, fileExists, configName) {
if (configName === void 0) { configName = "tsconfig.json"; }

47
lib/tsserver.js
View File

@ -38527,7 +38527,7 @@ var ts;
})(ts || (ts = {}));
var ts;
(function (ts) {
ts.version = "2.0.6";
ts.version = "2.0.7";
var emptyArray = [];
function findConfigFile(searchPath, fileExists, configName) {
if (configName === void 0) { configName = "tsconfig.json"; }
@ -43823,6 +43823,9 @@ var ts;
return this.rulesMap;
};
RulesProvider.prototype.ensureUpToDate = function (options) {
this.ensureUpToDateWorker(ts.toEditorSettings(options));
};
RulesProvider.prototype.ensureUpToDateWorker = function (options) {
if (!this.options || !ts.compareDataObjects(this.options, options)) {
var activeRules = this.createActiveRules(options);
var rulesMap = formatting.RulesMap.create(activeRules);
@ -43921,6 +43924,10 @@ var ts;
var formatting;
(function (formatting) {
function formatOnEnter(position, sourceFile, rulesProvider, options) {
return formatOnEnterWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnEnter = formatOnEnter;
function formatOnEnterWorker(position, sourceFile, rulesProvider, options) {
var line = sourceFile.getLineAndCharacterOfPosition(position).line;
if (line === 0) {
return [];
@ -43938,31 +43945,47 @@ var ts;
};
return formatSpan(span, sourceFile, options, rulesProvider, 2);
}
formatting.formatOnEnter = formatOnEnter;
formatting.formatOnEnterWorker = formatOnEnterWorker;
function formatOnSemicolon(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 23, sourceFile, options, rulesProvider, 3);
return formatOnSemicolonWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnSemicolon = formatOnSemicolon;
function formatOnSemicolonWorker(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 23, sourceFile, options, rulesProvider, 3);
}
formatting.formatOnSemicolonWorker = formatOnSemicolonWorker;
function formatOnClosingCurly(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 16, sourceFile, options, rulesProvider, 4);
return formatOnClosingCurlyWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnClosingCurly = formatOnClosingCurly;
function formatOnClosingCurlyWorker(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 16, sourceFile, options, rulesProvider, 4);
}
formatting.formatOnClosingCurlyWorker = formatOnClosingCurlyWorker;
function formatDocument(sourceFile, rulesProvider, options) {
return formatDocumentWorker(sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatDocument = formatDocument;
function formatDocumentWorker(sourceFile, rulesProvider, options) {
var span = {
pos: 0,
end: sourceFile.text.length
};
return formatSpan(span, sourceFile, options, rulesProvider, 0);
}
formatting.formatDocument = formatDocument;
formatting.formatDocumentWorker = formatDocumentWorker;
function formatSelection(start, end, sourceFile, rulesProvider, options) {
return formatSelectionWorker(start, end, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatSelection = formatSelection;
function formatSelectionWorker(start, end, sourceFile, rulesProvider, options) {
var span = {
pos: ts.getLineStartPositionForPosition(start, sourceFile),
end: end
};
return formatSpan(span, sourceFile, options, rulesProvider, 1);
}
formatting.formatSelection = formatSelection;
formatting.formatSelectionWorker = formatSelectionWorker;
function formatOutermostParent(position, expectedLastToken, sourceFile, options, rulesProvider, requestKind) {
var parent = findOutermostParent(position, expectedLastToken, sourceFile);
if (!parent) {
@ -46888,7 +46911,7 @@ var ts;
if (!ruleProvider) {
ruleProvider = new ts.formatting.RulesProvider();
}
ruleProvider.ensureUpToDate(options);
ruleProvider.ensureUpToDateWorker(options);
return ruleProvider;
}
function synchronizeHostData() {
@ -50857,24 +50880,24 @@ var ts;
function getFormattingEditsForRange(fileName, start, end, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
return ts.formatting.formatSelection(start, end, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatSelectionWorker(start, end, sourceFile, getRuleProvider(settings), settings);
}
function getFormattingEditsForDocument(fileName, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
return ts.formatting.formatDocument(sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatDocumentWorker(sourceFile, getRuleProvider(settings), settings);
}
function getFormattingEditsAfterKeystroke(fileName, position, key, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
if (key === "}") {
return ts.formatting.formatOnClosingCurly(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnClosingCurlyWorker(position, sourceFile, getRuleProvider(settings), settings);
}
else if (key === ";") {
return ts.formatting.formatOnSemicolon(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnSemicolonWorker(position, sourceFile, getRuleProvider(settings), settings);
}
else if (key === "\n") {
return ts.formatting.formatOnEnter(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnEnterWorker(position, sourceFile, getRuleProvider(settings), settings);
}
return [];
}

18
lib/tsserverlibrary.d.ts vendored
View File

@ -8739,7 +8739,8 @@ declare namespace ts.formatting {
getRuleName(rule: Rule): string;
getRuleByName(name: string): Rule;
getRulesMap(): RulesMap;
ensureUpToDate(options: ts.FormatCodeSettings): void;
ensureUpToDate(options: ts.FormatCodeSettings | ts.FormatCodeOptions): void;
ensureUpToDateWorker(options: ts.FormatCodeSettings): void;
private createActiveRules(options);
}
}
@ -8752,11 +8753,16 @@ declare namespace ts.formatting {
token: TextRangeWithKind;
trailingTrivia: TextRangeWithKind[];
}
function formatOnEnter(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[];
function formatOnSemicolon(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[];
function formatOnClosingCurly(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[];
function formatDocument(sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[];
function formatSelection(start: number, end: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[];
function formatOnEnter(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings | FormatCodeOptions): TextChange[];
function formatOnEnterWorker(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[];
function formatOnSemicolon(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings | FormatCodeOptions): TextChange[];
function formatOnSemicolonWorker(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[];
function formatOnClosingCurly(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings | FormatCodeOptions): TextChange[];
function formatOnClosingCurlyWorker(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[];
function formatDocument(sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings | FormatCodeOptions): TextChange[];
function formatDocumentWorker(sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[];
function formatSelection(start: number, end: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings | FormatCodeOptions): TextChange[];
function formatSelectionWorker(start: number, end: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[];
function getIndentationString(indentation: number, options: EditorSettings): string;
}
declare namespace ts.formatting {

47
lib/tsserverlibrary.js
View File

@ -38527,7 +38527,7 @@ var ts;
})(ts || (ts = {}));
var ts;
(function (ts) {
ts.version = "2.0.6";
ts.version = "2.0.7";
var emptyArray = [];
function findConfigFile(searchPath, fileExists, configName) {
if (configName === void 0) { configName = "tsconfig.json"; }
@ -43823,6 +43823,9 @@ var ts;
return this.rulesMap;
};
RulesProvider.prototype.ensureUpToDate = function (options) {
this.ensureUpToDateWorker(ts.toEditorSettings(options));
};
RulesProvider.prototype.ensureUpToDateWorker = function (options) {
if (!this.options || !ts.compareDataObjects(this.options, options)) {
var activeRules = this.createActiveRules(options);
var rulesMap = formatting.RulesMap.create(activeRules);
@ -43921,6 +43924,10 @@ var ts;
var formatting;
(function (formatting) {
function formatOnEnter(position, sourceFile, rulesProvider, options) {
return formatOnEnterWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnEnter = formatOnEnter;
function formatOnEnterWorker(position, sourceFile, rulesProvider, options) {
var line = sourceFile.getLineAndCharacterOfPosition(position).line;
if (line === 0) {
return [];
@ -43938,31 +43945,47 @@ var ts;
};
return formatSpan(span, sourceFile, options, rulesProvider, 2);
}
formatting.formatOnEnter = formatOnEnter;
formatting.formatOnEnterWorker = formatOnEnterWorker;
function formatOnSemicolon(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 23, sourceFile, options, rulesProvider, 3);
return formatOnSemicolonWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnSemicolon = formatOnSemicolon;
function formatOnSemicolonWorker(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 23, sourceFile, options, rulesProvider, 3);
}
formatting.formatOnSemicolonWorker = formatOnSemicolonWorker;
function formatOnClosingCurly(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 16, sourceFile, options, rulesProvider, 4);
return formatOnClosingCurlyWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnClosingCurly = formatOnClosingCurly;
function formatOnClosingCurlyWorker(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 16, sourceFile, options, rulesProvider, 4);
}
formatting.formatOnClosingCurlyWorker = formatOnClosingCurlyWorker;
function formatDocument(sourceFile, rulesProvider, options) {
return formatDocumentWorker(sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatDocument = formatDocument;
function formatDocumentWorker(sourceFile, rulesProvider, options) {
var span = {
pos: 0,
end: sourceFile.text.length
};
return formatSpan(span, sourceFile, options, rulesProvider, 0);
}
formatting.formatDocument = formatDocument;
formatting.formatDocumentWorker = formatDocumentWorker;
function formatSelection(start, end, sourceFile, rulesProvider, options) {
return formatSelectionWorker(start, end, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatSelection = formatSelection;
function formatSelectionWorker(start, end, sourceFile, rulesProvider, options) {
var span = {
pos: ts.getLineStartPositionForPosition(start, sourceFile),
end: end
};
return formatSpan(span, sourceFile, options, rulesProvider, 1);
}
formatting.formatSelection = formatSelection;
formatting.formatSelectionWorker = formatSelectionWorker;
function formatOutermostParent(position, expectedLastToken, sourceFile, options, rulesProvider, requestKind) {
var parent = findOutermostParent(position, expectedLastToken, sourceFile);
if (!parent) {
@ -46888,7 +46911,7 @@ var ts;
if (!ruleProvider) {
ruleProvider = new ts.formatting.RulesProvider();
}
ruleProvider.ensureUpToDate(options);
ruleProvider.ensureUpToDateWorker(options);
return ruleProvider;
}
function synchronizeHostData() {
@ -50857,24 +50880,24 @@ var ts;
function getFormattingEditsForRange(fileName, start, end, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
return ts.formatting.formatSelection(start, end, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatSelectionWorker(start, end, sourceFile, getRuleProvider(settings), settings);
}
function getFormattingEditsForDocument(fileName, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
return ts.formatting.formatDocument(sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatDocumentWorker(sourceFile, getRuleProvider(settings), settings);
}
function getFormattingEditsAfterKeystroke(fileName, position, key, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
if (key === "}") {
return ts.formatting.formatOnClosingCurly(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnClosingCurlyWorker(position, sourceFile, getRuleProvider(settings), settings);
}
else if (key === ";") {
return ts.formatting.formatOnSemicolon(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnSemicolonWorker(position, sourceFile, getRuleProvider(settings), settings);
}
else if (key === "\n") {
return ts.formatting.formatOnEnter(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnEnterWorker(position, sourceFile, getRuleProvider(settings), settings);
}
return [];
}

47
lib/typescript.js
View File

@ -44687,7 +44687,7 @@ var ts;
var ts;
(function (ts) {
/** The version of the TypeScript compiler release */
ts.version = "2.0.6";
ts.version = "2.0.7";
var emptyArray = [];
function findConfigFile(searchPath, fileExists, configName) {
if (configName === void 0) { configName = "tsconfig.json"; }
@ -51874,6 +51874,9 @@ var ts;
return this.rulesMap;
};
RulesProvider.prototype.ensureUpToDate = function (options) {
this.ensureUpToDateWorker(ts.toEditorSettings(options));
};
RulesProvider.prototype.ensureUpToDateWorker = function (options) {
if (!this.options || !ts.compareDataObjects(this.options, options)) {
var activeRules = this.createActiveRules(options);
var rulesMap = formatting.RulesMap.create(activeRules);
@ -51981,6 +51984,10 @@ var ts;
Constants[Constants["Unknown"] = -1] = "Unknown";
})(Constants || (Constants = {}));
function formatOnEnter(position, sourceFile, rulesProvider, options) {
return formatOnEnterWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnEnter = formatOnEnter;
function formatOnEnterWorker(position, sourceFile, rulesProvider, options) {
var line = sourceFile.getLineAndCharacterOfPosition(position).line;
if (line === 0) {
return [];
@ -52008,24 +52015,40 @@ var ts;
};
return formatSpan(span, sourceFile, options, rulesProvider, 2 /* FormatOnEnter */);
}
formatting.formatOnEnter = formatOnEnter;
formatting.formatOnEnterWorker = formatOnEnterWorker;
function formatOnSemicolon(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 23 /* SemicolonToken */, sourceFile, options, rulesProvider, 3 /* FormatOnSemicolon */);
return formatOnSemicolonWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnSemicolon = formatOnSemicolon;
function formatOnSemicolonWorker(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 23 /* SemicolonToken */, sourceFile, options, rulesProvider, 3 /* FormatOnSemicolon */);
}
formatting.formatOnSemicolonWorker = formatOnSemicolonWorker;
function formatOnClosingCurly(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 16 /* CloseBraceToken */, sourceFile, options, rulesProvider, 4 /* FormatOnClosingCurlyBrace */);
return formatOnClosingCurlyWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnClosingCurly = formatOnClosingCurly;
function formatOnClosingCurlyWorker(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 16 /* CloseBraceToken */, sourceFile, options, rulesProvider, 4 /* FormatOnClosingCurlyBrace */);
}
formatting.formatOnClosingCurlyWorker = formatOnClosingCurlyWorker;
function formatDocument(sourceFile, rulesProvider, options) {
return formatDocumentWorker(sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatDocument = formatDocument;
function formatDocumentWorker(sourceFile, rulesProvider, options) {
var span = {
pos: 0,
end: sourceFile.text.length
};
return formatSpan(span, sourceFile, options, rulesProvider, 0 /* FormatDocument */);
}
formatting.formatDocument = formatDocument;
formatting.formatDocumentWorker = formatDocumentWorker;
function formatSelection(start, end, sourceFile, rulesProvider, options) {
return formatSelectionWorker(start, end, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatSelection = formatSelection;
function formatSelectionWorker(start, end, sourceFile, rulesProvider, options) {
// format from the beginning of the line
var span = {
pos: ts.getLineStartPositionForPosition(start, sourceFile),
@ -52033,7 +52056,7 @@ var ts;
};
return formatSpan(span, sourceFile, options, rulesProvider, 1 /* FormatSelection */);
}
formatting.formatSelection = formatSelection;
formatting.formatSelectionWorker = formatSelectionWorker;
function formatOutermostParent(position, expectedLastToken, sourceFile, options, rulesProvider, requestKind) {
var parent = findOutermostParent(position, expectedLastToken, sourceFile);
if (!parent) {
@ -55451,7 +55474,7 @@ var ts;
if (!ruleProvider) {
ruleProvider = new ts.formatting.RulesProvider();
}
ruleProvider.ensureUpToDate(options);
ruleProvider.ensureUpToDateWorker(options);
return ruleProvider;
}
function synchronizeHostData() {
@ -60083,24 +60106,24 @@ var ts;
function getFormattingEditsForRange(fileName, start, end, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
return ts.formatting.formatSelection(start, end, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatSelectionWorker(start, end, sourceFile, getRuleProvider(settings), settings);
}
function getFormattingEditsForDocument(fileName, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
return ts.formatting.formatDocument(sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatDocumentWorker(sourceFile, getRuleProvider(settings), settings);
}
function getFormattingEditsAfterKeystroke(fileName, position, key, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
if (key === "}") {
return ts.formatting.formatOnClosingCurly(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnClosingCurlyWorker(position, sourceFile, getRuleProvider(settings), settings);
}
else if (key === ";") {
return ts.formatting.formatOnSemicolon(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnSemicolonWorker(position, sourceFile, getRuleProvider(settings), settings);
}
else if (key === "\n") {
return ts.formatting.formatOnEnter(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnEnterWorker(position, sourceFile, getRuleProvider(settings), settings);
}
return [];
}

47
lib/typescriptServices.js
View File

@ -44687,7 +44687,7 @@ var ts;
var ts;
(function (ts) {
/** The version of the TypeScript compiler release */
ts.version = "2.0.6";
ts.version = "2.0.7";
var emptyArray = [];
function findConfigFile(searchPath, fileExists, configName) {
if (configName === void 0) { configName = "tsconfig.json"; }
@ -51874,6 +51874,9 @@ var ts;
return this.rulesMap;
};
RulesProvider.prototype.ensureUpToDate = function (options) {
this.ensureUpToDateWorker(ts.toEditorSettings(options));
};
RulesProvider.prototype.ensureUpToDateWorker = function (options) {
if (!this.options || !ts.compareDataObjects(this.options, options)) {
var activeRules = this.createActiveRules(options);
var rulesMap = formatting.RulesMap.create(activeRules);
@ -51981,6 +51984,10 @@ var ts;
Constants[Constants["Unknown"] = -1] = "Unknown";
})(Constants || (Constants = {}));
function formatOnEnter(position, sourceFile, rulesProvider, options) {
return formatOnEnterWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnEnter = formatOnEnter;
function formatOnEnterWorker(position, sourceFile, rulesProvider, options) {
var line = sourceFile.getLineAndCharacterOfPosition(position).line;
if (line === 0) {
return [];
@ -52008,24 +52015,40 @@ var ts;
};
return formatSpan(span, sourceFile, options, rulesProvider, 2 /* FormatOnEnter */);
}
formatting.formatOnEnter = formatOnEnter;
formatting.formatOnEnterWorker = formatOnEnterWorker;
function formatOnSemicolon(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 23 /* SemicolonToken */, sourceFile, options, rulesProvider, 3 /* FormatOnSemicolon */);
return formatOnSemicolonWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnSemicolon = formatOnSemicolon;
function formatOnSemicolonWorker(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 23 /* SemicolonToken */, sourceFile, options, rulesProvider, 3 /* FormatOnSemicolon */);
}
formatting.formatOnSemicolonWorker = formatOnSemicolonWorker;
function formatOnClosingCurly(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 16 /* CloseBraceToken */, sourceFile, options, rulesProvider, 4 /* FormatOnClosingCurlyBrace */);
return formatOnClosingCurlyWorker(position, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatOnClosingCurly = formatOnClosingCurly;
function formatOnClosingCurlyWorker(position, sourceFile, rulesProvider, options) {
return formatOutermostParent(position, 16 /* CloseBraceToken */, sourceFile, options, rulesProvider, 4 /* FormatOnClosingCurlyBrace */);
}
formatting.formatOnClosingCurlyWorker = formatOnClosingCurlyWorker;
function formatDocument(sourceFile, rulesProvider, options) {
return formatDocumentWorker(sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatDocument = formatDocument;
function formatDocumentWorker(sourceFile, rulesProvider, options) {
var span = {
pos: 0,
end: sourceFile.text.length
};
return formatSpan(span, sourceFile, options, rulesProvider, 0 /* FormatDocument */);
}
formatting.formatDocument = formatDocument;
formatting.formatDocumentWorker = formatDocumentWorker;
function formatSelection(start, end, sourceFile, rulesProvider, options) {
return formatSelectionWorker(start, end, sourceFile, rulesProvider, ts.toEditorSettings(options));
}
formatting.formatSelection = formatSelection;
function formatSelectionWorker(start, end, sourceFile, rulesProvider, options) {
// format from the beginning of the line
var span = {
pos: ts.getLineStartPositionForPosition(start, sourceFile),
@ -52033,7 +52056,7 @@ var ts;
};
return formatSpan(span, sourceFile, options, rulesProvider, 1 /* FormatSelection */);
}
formatting.formatSelection = formatSelection;
formatting.formatSelectionWorker = formatSelectionWorker;
function formatOutermostParent(position, expectedLastToken, sourceFile, options, rulesProvider, requestKind) {
var parent = findOutermostParent(position, expectedLastToken, sourceFile);
if (!parent) {
@ -55451,7 +55474,7 @@ var ts;
if (!ruleProvider) {
ruleProvider = new ts.formatting.RulesProvider();
}
ruleProvider.ensureUpToDate(options);
ruleProvider.ensureUpToDateWorker(options);
return ruleProvider;
}
function synchronizeHostData() {
@ -60083,24 +60106,24 @@ var ts;
function getFormattingEditsForRange(fileName, start, end, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
return ts.formatting.formatSelection(start, end, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatSelectionWorker(start, end, sourceFile, getRuleProvider(settings), settings);
}
function getFormattingEditsForDocument(fileName, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
return ts.formatting.formatDocument(sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatDocumentWorker(sourceFile, getRuleProvider(settings), settings);
}
function getFormattingEditsAfterKeystroke(fileName, position, key, optionsOrSettings) {
var settings = toEditorSettings(optionsOrSettings);
var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
if (key === "}") {
return ts.formatting.formatOnClosingCurly(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnClosingCurlyWorker(position, sourceFile, getRuleProvider(settings), settings);
}
else if (key === ";") {
return ts.formatting.formatOnSemicolon(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnSemicolonWorker(position, sourceFile, getRuleProvider(settings), settings);
}
else if (key === "\n") {
return ts.formatting.formatOnEnter(position, sourceFile, getRuleProvider(settings), settings);
return ts.formatting.formatOnEnterWorker(position, sourceFile, getRuleProvider(settings), settings);
}
return [];
}

217
lib/typingsInstaller.js
View File

@ -5733,11 +5733,10 @@ var ts;
return PackageNameValidationResult.Ok;
}
typingsInstaller.validatePackageName = validatePackageName;
typingsInstaller.NpmViewRequest = "npm view";
typingsInstaller.NpmInstallRequest = "npm install";
var TypingsInstaller = (function () {
function TypingsInstaller(globalCachePath, safeListPath, throttleLimit, log) {
function TypingsInstaller(installTypingHost, globalCachePath, safeListPath, throttleLimit, log) {
if (log === void 0) { log = nullLog; }
this.installTypingHost = installTypingHost;
this.globalCachePath = globalCachePath;
this.safeListPath = safeListPath;
this.throttleLimit = throttleLimit;
@ -5752,10 +5751,8 @@ var ts;
if (this.log.isEnabled()) {
this.log.writeLine("Global cache location '" + globalCachePath + "', safe file path '" + safeListPath + "'");
}
}
TypingsInstaller.prototype.init = function () {
this.processCacheLocation(this.globalCachePath);
};
}
TypingsInstaller.prototype.closeProject = function (req) {
this.closeWatchers(req.projectName);
};
@ -5854,7 +5851,7 @@ var ts;
}
this.knownCachesSet[cacheLocation] = true;
};
TypingsInstaller.prototype.filterTypings = function (typingsToInstall) {
TypingsInstaller.prototype.filterAndMapToScopedName = function (typingsToInstall) {
if (typingsToInstall.length === 0) {
return typingsToInstall;
}
@ -5866,7 +5863,14 @@ var ts;
}
var validationResult = validatePackageName(typing);
if (validationResult === PackageNameValidationResult.Ok) {
result.push(typing);
if (typing in this.typesRegistry) {
result.push("@types/" + typing);
}
else {
if (this.log.isEnabled()) {
this.log.writeLine("Entry for package '" + typing + "' does not exist in local types registry - skipping...");
}
}
}
else {
this.missingTypingsSet[typing] = true;
@ -5893,19 +5897,8 @@ var ts;
}
return result;
};
TypingsInstaller.prototype.installTypings = function (req, cachePath, currentlyCachedTypings, typingsToInstall) {
var _this = this;
if (this.log.isEnabled()) {
this.log.writeLine("Installing typings " + JSON.stringify(typingsToInstall));
}
typingsToInstall = this.filterTypings(typingsToInstall);
if (typingsToInstall.length === 0) {
if (this.log.isEnabled()) {
this.log.writeLine("All typings are known to be missing or invalid - no need to go any further");
}
return;
}
var npmConfigPath = ts.combinePaths(cachePath, "package.json");
TypingsInstaller.prototype.ensurePackageDirectoryExists = function (directory) {
var npmConfigPath = ts.combinePaths(directory, "package.json");
if (this.log.isEnabled()) {
this.log.writeLine("Npm config file: " + npmConfigPath);
}
@ -5913,22 +5906,39 @@ var ts;
if (this.log.isEnabled()) {
this.log.writeLine("Npm config file: '" + npmConfigPath + "' is missing, creating new one...");
}
this.ensureDirectoryExists(cachePath, this.installTypingHost);
this.ensureDirectoryExists(directory, this.installTypingHost);
this.installTypingHost.writeFile(npmConfigPath, "{}");
}
this.runInstall(cachePath, typingsToInstall, function (installedTypings) {
if (_this.log.isEnabled()) {
_this.log.writeLine("Requested to install typings " + JSON.stringify(typingsToInstall) + ", installed typings " + JSON.stringify(installedTypings));
};
TypingsInstaller.prototype.installTypings = function (req, cachePath, currentlyCachedTypings, typingsToInstall) {
var _this = this;
if (this.log.isEnabled()) {
this.log.writeLine("Installing typings " + JSON.stringify(typingsToInstall));
}
var scopedTypings = this.filterAndMapToScopedName(typingsToInstall);
if (scopedTypings.length === 0) {
if (this.log.isEnabled()) {
this.log.writeLine("All typings are known to be missing or invalid - no need to go any further");
}
return;
}
this.ensurePackageDirectoryExists(cachePath);
var requestId = this.installRunCount;
this.installRunCount++;
this.installTypingsAsync(requestId, scopedTypings, cachePath, function (ok) {
if (!ok) {
return;
}
if (_this.log.isEnabled()) {
_this.log.writeLine("Requested to install typings " + JSON.stringify(scopedTypings) + ", installed typings " + JSON.stringify(scopedTypings));
}
var installedPackages = ts.createMap();
var installedTypingFiles = [];
for (var _i = 0, installedTypings_1 = installedTypings; _i < installedTypings_1.length; _i++) {
var t = installedTypings_1[_i];
for (var _i = 0, scopedTypings_1 = scopedTypings; _i < scopedTypings_1.length; _i++) {
var t = scopedTypings_1[_i];
var packageName = ts.getBaseFileName(t);
if (!packageName) {
continue;
}
installedPackages[packageName] = true;
var typingFile = typingToFileName(cachePath, packageName, _this.installTypingHost);
if (!typingFile) {
continue;
@ -5941,49 +5951,9 @@ var ts;
if (_this.log.isEnabled()) {
_this.log.writeLine("Installed typing files " + JSON.stringify(installedTypingFiles));
}
for (var _a = 0, typingsToInstall_2 = typingsToInstall; _a < typingsToInstall_2.length; _a++) {
var toInstall = typingsToInstall_2[_a];
if (!installedPackages[toInstall]) {
if (_this.log.isEnabled()) {
_this.log.writeLine("New missing typing package '" + toInstall + "'");
}
_this.missingTypingsSet[toInstall] = true;
}
}
_this.sendResponse(_this.createSetTypings(req, currentlyCachedTypings.concat(installedTypingFiles)));
});
};
TypingsInstaller.prototype.runInstall = function (cachePath, typingsToInstall, postInstallAction) {
var requestId = this.installRunCount;
this.installRunCount++;
var execInstallCmdCount = 0;
var filteredTypings = [];
for (var _i = 0, typingsToInstall_3 = typingsToInstall; _i < typingsToInstall_3.length; _i++) {
var typing = typingsToInstall_3[_i];
filterExistingTypings(this, typing);
}
function filterExistingTypings(self, typing) {
self.execAsync(typingsInstaller.NpmViewRequest, requestId, [typing], cachePath, function (ok) {
if (ok) {
filteredTypings.push(typing);
}
execInstallCmdCount++;
if (execInstallCmdCount === typingsToInstall.length) {
installFilteredTypings(self, filteredTypings);
}
});
}
function installFilteredTypings(self, filteredTypings) {
if (filteredTypings.length === 0) {
postInstallAction([]);
return;
}
var scopedTypings = filteredTypings.map(function (t) { return "@types/" + t; });
self.execAsync(typingsInstaller.NpmInstallRequest, requestId, scopedTypings, cachePath, function (ok) {
postInstallAction(ok ? scopedTypings : []);
});
}
};
TypingsInstaller.prototype.ensureDirectoryExists = function (directory, host) {
var directoryName = ts.getDirectoryPath(directory);
if (!host.directoryExists(directoryName)) {
@ -6025,8 +5995,8 @@ var ts;
kind: "set"
};
};
TypingsInstaller.prototype.execAsync = function (requestKind, requestId, args, cwd, onRequestCompleted) {
this.pendingRunRequests.unshift({ requestKind: requestKind, requestId: requestId, args: args, cwd: cwd, onRequestCompleted: onRequestCompleted });
TypingsInstaller.prototype.installTypingsAsync = function (requestId, args, cwd, onRequestCompleted) {
this.pendingRunRequests.unshift({ requestId: requestId, args: args, cwd: cwd, onRequestCompleted: onRequestCompleted });
this.executeWithThrottling();
};
TypingsInstaller.prototype.executeWithThrottling = function () {
@ -6034,7 +6004,7 @@ var ts;
var _loop_1 = function() {
this_1.inFlightRequestCount++;
var request = this_1.pendingRunRequests.pop();
this_1.executeRequest(request.requestKind, request.requestId, request.args, request.cwd, function (ok) {
this_1.installWorker(request.requestId, request.args, request.cwd, function (ok) {
_this.inFlightRequestCount--;
request.onRequestCompleted(ok);
_this.executeWithThrottling();
@ -6079,21 +6049,55 @@ var ts;
return "npm";
}
}
function loadTypesRegistryFile(typesRegistryFilePath, host, log) {
if (!host.fileExists(typesRegistryFilePath)) {
if (log.isEnabled()) {
log.writeLine("Types registry file '" + typesRegistryFilePath + "' does not exist");
}
return ts.createMap();
}
try {
var content = JSON.parse(host.readFile(typesRegistryFilePath));
return ts.createMap(content.entries);
}
catch (e) {
if (log.isEnabled()) {
log.writeLine("Error when loading types registry file '" + typesRegistryFilePath + "': " + e.message + ", " + e.stack);
}
return ts.createMap();
}
}
var TypesRegistryPackageName = "types-registry";
function getTypesRegistryFileLocation(globalTypingsCacheLocation) {
return ts.combinePaths(ts.normalizeSlashes(globalTypingsCacheLocation), "node_modules/" + TypesRegistryPackageName + "/index.json");
}
var NodeTypingsInstaller = (function (_super) {
__extends(NodeTypingsInstaller, _super);
function NodeTypingsInstaller(globalTypingsCacheLocation, throttleLimit, log) {
_super.call(this, globalTypingsCacheLocation, ts.toPath("typingSafeList.json", __dirname, ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames)), throttleLimit, log);
this.installTypingHost = ts.sys;
_super.call(this, ts.sys, globalTypingsCacheLocation, ts.toPath("typingSafeList.json", __dirname, ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames)), throttleLimit, log);
if (this.log.isEnabled()) {
this.log.writeLine("Process id: " + process.pid);
}
this.npmPath = getNPMLocation(process.argv[0]);
this.exec = require("child_process").exec;
this.httpGet = require("http").get;
var execSync;
(_a = require("child_process"), this.exec = _a.exec, execSync = _a.execSync, _a);
this.ensurePackageDirectoryExists(globalTypingsCacheLocation);
try {
if (this.log.isEnabled()) {
this.log.writeLine("Updating " + TypesRegistryPackageName + " npm package...");
}
execSync(this.npmPath + " install " + TypesRegistryPackageName, { cwd: globalTypingsCacheLocation, stdio: "ignore" });
}
catch (e) {
if (this.log.isEnabled()) {
this.log.writeLine("Error updating " + TypesRegistryPackageName + " package: " + e.message);
}
}
this.typesRegistry = loadTypesRegistryFile(getTypesRegistryFileLocation(globalTypingsCacheLocation), this.installTypingHost, this.log);
var _a;
}
NodeTypingsInstaller.prototype.init = function () {
NodeTypingsInstaller.prototype.listen = function () {
var _this = this;
_super.prototype.init.call(this);
process.on("message", function (req) {
switch (req.kind) {
case "discover":
@ -6113,54 +6117,19 @@ var ts;
this.log.writeLine("Response has been sent.");
}
};
NodeTypingsInstaller.prototype.executeRequest = function (requestKind, requestId, args, cwd, onRequestCompleted) {
NodeTypingsInstaller.prototype.installWorker = function (requestId, args, cwd, onRequestCompleted) {
var _this = this;
if (this.log.isEnabled()) {
this.log.writeLine("#" + requestId + " executing " + requestKind + ", arguments'" + JSON.stringify(args) + "'.");
}
switch (requestKind) {
case typingsInstaller.NpmViewRequest:
{
ts.Debug.assert(args.length === 1);
var url_1 = "http://registry.npmjs.org/@types%2f" + args[0];
var start_2 = Date.now();
this.httpGet(url_1, function (response) {
var ok = false;
if (_this.log.isEnabled()) {
_this.log.writeLine(requestKind + " #" + requestId + " request to " + url_1 + ":: status code " + response.statusCode + ", status message '" + response.statusMessage + "', took " + (Date.now() - start_2) + " ms");
}
switch (response.statusCode) {
case 200:
case 301:
case 302:
ok = true;
break;
}
response.destroy();
onRequestCompleted(ok);
}).on("error", function (err) {
if (_this.log.isEnabled()) {
_this.log.writeLine(requestKind + " #" + requestId + " query to npm registry failed with error " + err.message + ", stack " + err.stack);
}
onRequestCompleted(false);
});
}
break;
case typingsInstaller.NpmInstallRequest:
{
var command = this.npmPath + " install " + args.join(" ") + " --save-dev";
var start_3 = Date.now();
this.exec(command, { cwd: cwd }, function (err, stdout, stderr) {
if (_this.log.isEnabled()) {
_this.log.writeLine(requestKind + " #" + requestId + " took: " + (Date.now() - start_3) + " ms" + ts.sys.newLine + "stdout: " + stdout + ts.sys.newLine + "stderr: " + stderr);
}
onRequestCompleted(!!stdout);
});
}
break;
default:
ts.Debug.assert(false, "Unknown request kind " + requestKind);
this.log.writeLine("#" + requestId + " with arguments'" + JSON.stringify(args) + "'.");
}
var command = this.npmPath + " install " + args.join(" ") + " --save-dev";
var start = Date.now();
this.exec(command, { cwd: cwd }, function (err, stdout, stderr) {
if (_this.log.isEnabled()) {
_this.log.writeLine("npm install #" + requestId + " took: " + (Date.now() - start) + " ms" + ts.sys.newLine + "stdout: " + stdout + ts.sys.newLine + "stderr: " + stderr);
}
onRequestCompleted(!!stdout);
});
};
return NodeTypingsInstaller;
}(typingsInstaller.TypingsInstaller));
@ -6186,7 +6155,7 @@ var ts;
process.exit(0);
});
var installer = new NodeTypingsInstaller(globalTypingsCacheLocation, 5, log);
installer.init();
installer.listen();
})(typingsInstaller = server.typingsInstaller || (server.typingsInstaller = {}));
})(server = ts.server || (ts.server = {}));
})(ts || (ts = {}));