function format(text) { // Parse the source text var sourceFile = ts.createSourceFile('file.ts', text, ts.ScriptTarget.Latest, /*setParentPointers*/ true); // Get the formatting edits on the input sources var edits = ts.formatting.formatDocument(sourceFile, getRuleProvider(tsfmt), tsfmt); // Apply the edits on the input code return applyEdits(text, edits); function getRuleProvider(options) { // Share this between multiple formatters using the same options. // This represents the bulk of the space the formatter uses. var ruleProvider = new ts.formatting.RulesProvider(); ruleProvider.ensureUpToDate(options); return ruleProvider; } function applyEdits(text, edits) { // Apply edits in reverse on the existing text var result = text; for (var i = edits.length - 1; i >= 0; i--) { var change = edits[i]; var head = result.slice(0, change.span.start); var tail = result.slice(change.span.start + change.span.length); result = head + change.newText + tail; } return result; } }
function format(fileName, text, options) { "use strict"; if (options === void 0) { options = utils_1.createDefaultFormatCodeOptions(); } var sourceFile = ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, "0"); fixupParentReferences(sourceFile); var edits = ts.formatting.formatDocument(sourceFile, getRuleProvider(options), options); return applyEdits(text, edits); function getRuleProvider(options) { var ruleProvider = new ts.formatting.RulesProvider(); ruleProvider.ensureUpToDate(options); return ruleProvider; } function applyEdits(text, edits) { var result = text; for (var i = edits.length - 1; i >= 0; i--) { var change = edits[i]; var head = void 0; if (typeof change.span.start === "number") { head = result.slice(0, change.span.start); } else { head = result.slice(0, change.span.start()); } var tail = void 0; if (typeof change.span.start === "number") { tail = result.slice(change.span.start + change.span.length); } else { tail = result.slice(change.span.start() + change.span.length()); } result = head + change.newText + tail; } return result; } }
// Note: this uses ts.formatting which is part of the typescript 1.4 package but is not currently // exposed in the public typescript.d.ts. The typings should be exposed in the next release. function format(text) { var options = getDefaultOptions(); // Parse the source text var sourceFile = ts.createSourceFile("file.ts", text, ts.ScriptTarget.Latest, true); fixupParentReferences(sourceFile); // Get the formatting edits on the input sources var edits = ts.formatting.formatDocument(sourceFile, getRuleProvider(options), options); // Apply the edits on the input code return applyEdits(text, edits); function getRuleProvider(options) { // Share this between multiple formatters using the same options. // This represents the bulk of the space the formatter uses. var ruleProvider = new ts.formatting.RulesProvider(); ruleProvider.ensureUpToDate(options); return ruleProvider; } function applyEdits(text, edits) { // Apply edits in reverse on the existing text var result = text; for (var i = edits.length - 1; i >= 0; i--) { var change = edits[i]; var head = result.slice(0, change.span.start); var tail = result.slice(change.span.start + change.span.length); result = head + change.newText + tail; } return result; } function getDefaultOptions() { return { IndentSize: 4, TabSize: 4, NewLineCharacter: '\n', ConvertTabsToSpaces: true, InsertSpaceAfterCommaDelimiter: true, InsertSpaceAfterSemicolonInForStatements: true, InsertSpaceBeforeAndAfterBinaryOperators: true, InsertSpaceAfterKeywordsInControlFlowStatements: true, InsertSpaceAfterFunctionKeywordForAnonymousFunctions: false, InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false, PlaceOpenBraceOnNewLineForFunctions: false, PlaceOpenBraceOnNewLineForControlBlocks: false }; } function fixupParentReferences(sourceFile) { var parent = sourceFile; function walk(n) { n.parent = parent; var saveParent = parent; parent = n; ts.forEachChild(n, walk); parent = saveParent; } ts.forEachChild(sourceFile, walk); } }
function format(text) { let options = getDefaultOptions(); // Parse the source text let sourceFile = ts.createSourceFile("file.ts", text, ts.ScriptTarget.Latest, /*setParentPointers*/ true); // Get the formatting edits on the input sources let edits = ts.formatting.formatDocument(sourceFile, getRuleProvider(options), options); // Apply the edits on the input code return applyEdits(text, edits); function getRuleProvider(options) { // Share this between multiple formatters using the same options. // This represents the bulk of the space the formatter uses. let ruleProvider = new ts.formatting.RulesProvider(); ruleProvider.ensureUpToDate(options); return ruleProvider; } function applyEdits(text, edits) { // Apply edits in reverse on the existing text let result = text; for (let i = edits.length - 1; i >= 0; i--) { let change = edits[i]; let head = result.slice(0, change.span.start); let tail = result.slice(change.span.start + change.span.length); result = head + change.newText + tail; } return result; } function getDefaultOptions() { return { IndentSize: 2, TabSize: 2, NewLineCharacter: '\n', ConvertTabsToSpaces: true, IndentStyle: ts.IndentStyle.Smart, InsertSpaceAfterCommaDelimiter: true, InsertSpaceAfterSemicolonInForStatements: true, InsertSpaceBeforeAndAfterBinaryOperators: true, InsertSpaceAfterKeywordsInControlFlowStatements: true, InsertSpaceAfterFunctionKeywordForAnonymousFunctions: false, InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false, InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false, InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false, PlaceOpenBraceOnNewLineForFunctions: false, PlaceOpenBraceOnNewLineForControlBlocks: false }; } }
function getRuleProvider(options) { // Share this between multiple formatters using the same options. // This represents the bulk of the space the formatter uses. return ts.formatting.getFormatContext(options); }
function format(text, endl) { const REALLY_FORMAT = false; text = preformat(text, endl); if (!REALLY_FORMAT) { return text; } // Parse the source text let sourceFile = ts.createSourceFile('file.ts', text, ts.ScriptTarget.Latest, /*setParentPointers*/ true); // Get the formatting edits on the input sources let edits = ts.formatting.formatDocument(sourceFile, getRuleProvider(tsfmt), tsfmt); // Apply the edits on the input code return applyEdits(text, edits); function countParensCurly(text) { let cnt = 0; for (let i = 0; i < text.length; i++) { if (text.charAt(i) === '(' || text.charAt(i) === '{') { cnt++; } if (text.charAt(i) === ')' || text.charAt(i) === '}') { cnt--; } } return cnt; } function repeatStr(s, cnt) { let r = ''; for (let i = 0; i < cnt; i++) { r += s; } return r; } function preformat(text, endl) { let lines = text.split(endl); let inComment = false; let inCommentDeltaIndent = 0; let indent = 0; for (let i = 0; i < lines.length; i++) { let line = lines[i].replace(/\s$/, ''); let repeat = false; let lineIndent = 0; do { repeat = false; if (line.substring(0, 4) === ' ') { line = line.substring(4); lineIndent++; repeat = true; } if (line.charAt(0) === '\t') { line = line.substring(1); lineIndent++; repeat = true; } } while (repeat); if (line.length === 0) { continue; } if (inComment) { if (/\*\//.test(line)) { inComment = false; } lines[i] = repeatStr('\t', lineIndent + inCommentDeltaIndent) + line; continue; } if (/\/\*/.test(line)) { inComment = true; inCommentDeltaIndent = indent - lineIndent; lines[i] = repeatStr('\t', indent) + line; continue; } const cnt = countParensCurly(line); let shouldUnindentAfter = false; let shouldUnindentBefore = false; if (cnt < 0) { if (/[({]/.test(line)) { shouldUnindentAfter = true; } else { shouldUnindentBefore = true; } } else if (cnt === 0) { shouldUnindentBefore = /^\}/.test(line); } let shouldIndentAfter = false; if (cnt > 0) { shouldIndentAfter = true; } else if (cnt === 0) { shouldIndentAfter = /{$/.test(line); } if (shouldUnindentBefore) { indent--; } lines[i] = repeatStr('\t', indent) + line; if (shouldUnindentAfter) { indent--; } if (shouldIndentAfter) { indent++; } } return lines.join(endl); } function getRuleProvider(options) { // Share this between multiple formatters using the same options. // This represents the bulk of the space the formatter uses. return ts.formatting.getFormatContext(options); } function applyEdits(text, edits) { // Apply edits in reverse on the existing text let result = text; for (let i = edits.length - 1; i >= 0; i--) { let change = edits[i]; let head = result.slice(0, change.span.start); let tail = result.slice(change.span.start + change.span.length); result = head + change.newText + tail; } return result; } }